Merge the Bitwise and ByteOrder traits into the Int trait

This reduces the complexity of the trait hierarchy.

1 files changed, 54 insertions, 15 deletions

diff --git a/src/libcore/num/int_macros.rs b/src/libcore/num/int_macros.rs
index 8a1bd66aa1a..84744b3f5d7 100644
--- a/src/libcore/num/int_macros.rs
+++ b/src/libcore/num/int_macros.rs
@@ -35,7 +35,6 @@ mod tests {
 
     use int;
     use num;
-    use num::Bitwise;
     use num::CheckedDiv;
 
     #[test]
@@ -90,7 +89,7 @@ mod tests {
     }
 
     #[test]
-    fn test_bitwise() {
+    fn test_bitwise_operators() {
         assert!(0b1110 as $T == (0b1100 as $T).bitor(&(0b1010 as $T)));
         assert!(0b1000 as $T == (0b1100 as $T).bitand(&(0b1010 as $T)));
         assert!(0b0110 as $T == (0b1100 as $T).bitxor(&(0b1010 as $T)));
@@ -99,34 +98,74 @@ mod tests {
         assert!(-(0b11 as $T) - (1 as $T) == (0b11 as $T).not());
     }
 
+    static A: $T = 0b0101100;
+    static B: $T = 0b0100001;
+    static C: $T = 0b1111001;
+
+    static _0: $T = 0;
+    static _1: $T = !0;
+
     #[test]
     fn test_count_ones() {
-        assert!((0b0101100 as $T).count_ones() == 3);
-        assert!((0b0100001 as $T).count_ones() == 2);
-        assert!((0b1111001 as $T).count_ones() == 5);
+        assert!(A.count_ones() == 3);
+        assert!(B.count_ones() == 2);
+        assert!(C.count_ones() == 5);
     }
 
     #[test]
     fn test_count_zeros() {
-        assert!((0b0101100 as $T).count_zeros() == BITS as $T - 3);
-        assert!((0b0100001 as $T).count_zeros() == BITS as $T - 2);
-        assert!((0b1111001 as $T).count_zeros() == BITS as $T - 5);
+        assert!(A.count_zeros() == BITS as $T - 3);
+        assert!(B.count_zeros() == BITS as $T - 2);
+        assert!(C.count_zeros() == BITS as $T - 5);
     }
 
     #[test]
     fn test_rotate() {
-        let n: $T = 0b0101100; assert_eq!(n.rotate_left(6).rotate_right(2).rotate_right(4), n);
-        let n: $T = 0b0100001; assert_eq!(n.rotate_left(3).rotate_left(2).rotate_right(5),  n);
-        let n: $T = 0b1111001; assert_eq!(n.rotate_left(6).rotate_right(2).rotate_right(4), n);
+        assert_eq!(A.rotate_left(6).rotate_right(2).rotate_right(4), A);
+        assert_eq!(B.rotate_left(3).rotate_left(2).rotate_right(5), B);
+        assert_eq!(C.rotate_left(6).rotate_right(2).rotate_right(4), C);
 
         // Rotating these should make no difference
         //
         // We test using 124 bits because to ensure that overlong bit shifts do
         // not cause undefined behaviour. See #10183.
-        let n: $T = 0;   assert_eq!(n.rotate_left(124), n);
-        let n: $T = -1;  assert_eq!(n.rotate_left(124), n);
-        let n: $T = 0;   assert_eq!(n.rotate_right(124), n);
-        let n: $T = -1;  assert_eq!(n.rotate_right(124), n);
+        assert_eq!(_0.rotate_left(124), _0);
+        assert_eq!(_1.rotate_left(124), _1);
+        assert_eq!(_0.rotate_right(124), _0);
+        assert_eq!(_1.rotate_right(124), _1);
+    }
+
+    #[test]
+    fn test_swap_bytes() {
+        assert_eq!(A.swap_bytes().swap_bytes(), A);
+        assert_eq!(B.swap_bytes().swap_bytes(), B);
+        assert_eq!(C.swap_bytes().swap_bytes(), C);
+
+        // Swapping these should make no difference
+        assert_eq!(_0.swap_bytes(), _0);
+        assert_eq!(_1.swap_bytes(), _1);
+    }
+
+    #[test]
+    fn test_little_endian() {
+        assert_eq!(Int::from_little_endian(A.to_little_endian()), A);
+        assert_eq!(Int::from_little_endian(B.to_little_endian()), B);
+        assert_eq!(Int::from_little_endian(C.to_little_endian()), C);
+        assert_eq!(Int::from_little_endian(_0), _0);
+        assert_eq!(Int::from_little_endian(_1), _1);
+        assert_eq!(_0.to_little_endian(), _0);
+        assert_eq!(_1.to_little_endian(), _1);
+    }
+
+    #[test]
+    fn test_big_endian() {
+        assert_eq!(Int::from_big_endian(A.to_big_endian()), A);
+        assert_eq!(Int::from_big_endian(B.to_big_endian()), B);
+        assert_eq!(Int::from_big_endian(C.to_big_endian()), C);
+        assert_eq!(Int::from_big_endian(_0), _0);
+        assert_eq!(Int::from_big_endian(_1), _1);
+        assert_eq!(_0.to_big_endian(), _0);
+        assert_eq!(_1.to_big_endian(), _1);
     }
 
     #[test]