1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

macro_rules! doit_signed {
    ($($Algo:ident),*) => ($(
        impl $Algo for i8 {
            #[inline]
            fn swap_bits(self) -> i8 {
                $Algo::swap_bits(self as u8) as i8
            }
        }

        impl $Algo for i16 {
            #[inline]
            fn swap_bits(self) -> i16 {
                $Algo::swap_bits(self as u16) as i16
            }
        }

        impl $Algo for i32 {
            #[inline]
            fn swap_bits(self) -> i32 {
                $Algo::swap_bits(self as u32) as i32
            }
        }

        impl $Algo for i64 {
            #[inline]
            fn swap_bits(self) -> i64 {
                $Algo::swap_bits(self as u64) as i64
            }
        }

        impl $Algo for isize {
            #[inline]
            fn swap_bits(self) -> isize {
                $Algo::swap_bits(self as usize) as isize
            }
        }
    )*)
}

macro_rules! test_suite {
    () => {
        #[test]
        fn reverse_u8() {
            assert_eq!(0xABu8.swap_bits(), 0xD5u8);
        }

        #[test]
        fn reverse_u16() {
            assert_eq!(0xABCDu16.swap_bits(), 0xB3D5u16);
        }

        #[test]
        fn reverse_u32() {
            assert_eq!(0xABCD2345u32.swap_bits(), 0xA2C4B3D5u32);
        }

        #[test]
        fn reverse_u64() {
            assert_eq!(0x0123456789ABCDEFu64.swap_bits(), 0xF7B3D591E6A2C480u64);
        }

        #[test]
        fn reverse_usize() {
            assert_eq!(0xFFusize.swap_bits(), 0xFFusize.swap_bytes());
        }

        #[test]
        fn reverse_i8() {
            assert_eq!(0xABi8.swap_bits(), 0xD5i8);
        }

        #[test]
        fn reverse_i16() {
            assert_eq!(0xABCDi16.swap_bits(), 0xB3D5i16);
        }

        #[test]
        fn reverse_i32() {
            assert_eq!(0xABCD2345i32.swap_bits(), 0xA2C4B3D5i32);
        }

        #[test]
        fn reverse_i64() {
            assert_eq!(0x0123456789ABCDEFi64.swap_bits(), 0xF7B3D591E6A2C480i64);
        }

        #[test]
        fn reverse_isize() {
            assert_eq!(0xFFisize.swap_bits(), 0xFFisize.swap_bytes());
        }
    };
}