cleanup int suffixes in libcoretest

srinivasreddy · srinivasreddy · commit e1cc62854902 · 2016-03-11T08:42:56.000+05:30
diff --git a/src/libcoretest/fmt/builders.rs b/src/libcoretest/fmt/builders.rs
@@ -53,7 +53,7 @@ mod debug_struct {
             fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
                 fmt.debug_struct("Foo")
                     .field("bar", &true)
-                    .field("baz", &format_args!("{}/{}", 10i32, 20i32))
+                    .field("baz", &format_args!("{}/{}", 10, 20))
                     .finish()
             }
         }
@@ -75,7 +75,7 @@ mod debug_struct {
             fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
                 fmt.debug_struct("Foo")
                     .field("bar", &true)
-                    .field("baz", &format_args!("{}/{}", 10i32, 20i32))
+                    .field("baz", &format_args!("{}/{}", 10, 20))
                     .finish()
             }
         }
@@ -150,7 +150,7 @@ mod debug_tuple {
             fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
                 fmt.debug_tuple("Foo")
                     .field(&true)
-                    .field(&format_args!("{}/{}", 10i32, 20i32))
+                    .field(&format_args!("{}/{}", 10, 20))
                     .finish()
             }
         }
@@ -172,7 +172,7 @@ mod debug_tuple {
             fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
                 fmt.debug_tuple("Foo")
                     .field(&true)
-                    .field(&format_args!("{}/{}", 10i32, 20i32))
+                    .field(&format_args!("{}/{}", 10, 20))
                     .finish()
             }
         }
@@ -247,7 +247,7 @@ mod debug_map {
             fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
                 fmt.debug_map()
                     .entry(&"bar", &true)
-                    .entry(&10i32, &format_args!("{}/{}", 10i32, 20i32))
+                    .entry(&10, &format_args!("{}/{}", 10, 20))
                     .finish()
             }
         }
@@ -269,7 +269,7 @@ mod debug_map {
             fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
                 fmt.debug_map()
                     .entry(&"bar", &true)
-                    .entry(&10i32, &format_args!("{}/{}", 10i32, 20i32))
+                    .entry(&10, &format_args!("{}/{}", 10, 20))
                     .finish()
             }
         }
@@ -348,7 +348,7 @@ mod debug_set {
             fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
                 fmt.debug_set()
                     .entry(&true)
-                    .entry(&format_args!("{}/{}", 10i32, 20i32))
+                    .entry(&format_args!("{}/{}", 10, 20))
                     .finish()
             }
         }
@@ -370,7 +370,7 @@ mod debug_set {
             fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
                 fmt.debug_set()
                     .entry(&true)
-                    .entry(&format_args!("{}/{}", 10i32, 20i32))
+                    .entry(&format_args!("{}/{}", 10, 20))
                     .finish()
             }
         }
@@ -445,7 +445,7 @@ mod debug_list {
             fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
                 fmt.debug_list()
                     .entry(&true)
-                    .entry(&format_args!("{}/{}", 10i32, 20i32))
+                    .entry(&format_args!("{}/{}", 10, 20))
                     .finish()
             }
         }
@@ -467,7 +467,7 @@ mod debug_list {
             fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
                 fmt.debug_list()
                     .entry(&true)
-                    .entry(&format_args!("{}/{}", 10i32, 20i32))
+                    .entry(&format_args!("{}/{}", 10, 20))
                     .finish()
             }
         }
diff --git a/src/libcoretest/iter.rs b/src/libcoretest/iter.rs
@@ -677,7 +677,7 @@ fn test_rev() {
 
 #[test]
 fn test_cloned() {
-    let xs = [2u8, 4, 6, 8];
+    let xs = [2, 4, 6, 8];
 
     let mut it = xs.iter().cloned();
     assert_eq!(it.len(), 4);
@@ -861,8 +861,8 @@ fn test_range() {
     assert_eq!((-10..-1).size_hint(), (9, Some(9)));
     assert_eq!((-1..-10).size_hint(), (0, Some(0)));
 
-    assert_eq!((-70..58i8).size_hint(), (128, Some(128)));
-    assert_eq!((-128..127i8).size_hint(), (255, Some(255)));
+    assert_eq!((-70..58).size_hint(), (128, Some(128)));
+    assert_eq!((-128..127).size_hint(), (255, Some(255)));
     assert_eq!((-2..isize::MAX).size_hint(),
                (isize::MAX as usize + 2, Some(isize::MAX as usize + 2)));
 }
@@ -1013,7 +1013,7 @@ fn bench_max_by_key2(b: &mut Bencher) {
         array.iter().enumerate().max_by_key(|&(_, item)| item).unwrap().0
     }
 
-    let mut data = vec![0i32; 1638];
+    let mut data = vec![0; 1638];
     data[514] = 9999;
 
     b.iter(|| max_index_iter(&data));
diff --git a/src/libcoretest/num/int_macros.rs b/src/libcoretest/num/int_macros.rs
@@ -208,11 +208,11 @@ mod tests {
     fn test_pow() {
         let mut r = 2 as $T;
 
-        assert_eq!(r.pow(2u32), 4 as $T);
-        assert_eq!(r.pow(0u32), 1 as $T);
+        assert_eq!(r.pow(2), 4 as $T);
+        assert_eq!(r.pow(0), 1 as $T);
         r = -2 as $T;
-        assert_eq!(r.pow(2u32), 4 as $T);
-        assert_eq!(r.pow(3u32), -8 as $T);
+        assert_eq!(r.pow(2), 4 as $T);
+        assert_eq!(r.pow(3), -8 as $T);
     }
 }
 
diff --git a/src/libcoretest/num/mod.rs b/src/libcoretest/num/mod.rs
@@ -99,8 +99,8 @@ mod tests {
 
     #[test]
     fn test_leading_plus() {
-        assert_eq!("+127".parse::<u8>().ok(), Some(127u8));
-        assert_eq!("+9223372036854775807".parse::<i64>().ok(), Some(9223372036854775807i64));
+        assert_eq!("+127".parse::<u8>().ok(), Some(127));
+        assert_eq!("+9223372036854775807".parse::<i64>().ok(), Some(9223372036854775807));
     }
 
     #[test]
diff --git a/src/libcoretest/option.rs b/src/libcoretest/option.rs
@@ -251,7 +251,7 @@ fn test_collect() {
 
 #[test]
 fn test_cloned() {
-    let val = 1u32;
+    let val = 1;
     let val_ref = &val;
     let opt_none: Option<&'static u32> = None;
     let opt_ref = Some(&val);
@@ -263,10 +263,10 @@ fn test_cloned() {
 
     // Immutable ref works
     assert_eq!(opt_ref.clone(), Some(&val));
-    assert_eq!(opt_ref.cloned(), Some(1u32));
+    assert_eq!(opt_ref.cloned(), Some(1));
 
     // Double Immutable ref works
     assert_eq!(opt_ref_ref.clone(), Some(&val_ref));
     assert_eq!(opt_ref_ref.clone().cloned(), Some(&val));
-    assert_eq!(opt_ref_ref.cloned().cloned(), Some(1u32));
+    assert_eq!(opt_ref_ref.cloned().cloned(), Some(1));
 }

Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ mod debug_struct {`
`53`	`53`	`fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {`
`54`	`54`	`fmt.debug_struct("Foo")`
`55`	`55`	`.field("bar", &true)`
`56`		`- .field("baz", &format_args!("{}/{}", 10i32, 20i32))`
	`56`	`+ .field("baz", &format_args!("{}/{}", 10, 20))`
`57`	`57`	`.finish()`
`58`	`58`	`}`
`59`	`59`	`}`
`@@ -75,7 +75,7 @@ mod debug_struct {`
`75`	`75`	`fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {`
`76`	`76`	`fmt.debug_struct("Foo")`
`77`	`77`	`.field("bar", &true)`
`78`		`- .field("baz", &format_args!("{}/{}", 10i32, 20i32))`
	`78`	`+ .field("baz", &format_args!("{}/{}", 10, 20))`
`79`	`79`	`.finish()`
`80`	`80`	`}`
`81`	`81`	`}`
`@@ -150,7 +150,7 @@ mod debug_tuple {`
`150`	`150`	`fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {`
`151`	`151`	`fmt.debug_tuple("Foo")`
`152`	`152`	`.field(&true)`
`153`		`- .field(&format_args!("{}/{}", 10i32, 20i32))`
	`153`	`+ .field(&format_args!("{}/{}", 10, 20))`
`154`	`154`	`.finish()`
`155`	`155`	`}`
`156`	`156`	`}`
`@@ -172,7 +172,7 @@ mod debug_tuple {`
`172`	`172`	`fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {`
`173`	`173`	`fmt.debug_tuple("Foo")`
`174`	`174`	`.field(&true)`
`175`		`- .field(&format_args!("{}/{}", 10i32, 20i32))`
	`175`	`+ .field(&format_args!("{}/{}", 10, 20))`
`176`	`176`	`.finish()`
`177`	`177`	`}`
`178`	`178`	`}`
`@@ -247,7 +247,7 @@ mod debug_map {`
`247`	`247`	`fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {`
`248`	`248`	`fmt.debug_map()`
`249`	`249`	`.entry(&"bar", &true)`
`250`		`- .entry(&10i32, &format_args!("{}/{}", 10i32, 20i32))`
	`250`	`+ .entry(&10, &format_args!("{}/{}", 10, 20))`
`251`	`251`	`.finish()`
`252`	`252`	`}`
`253`	`253`	`}`
`@@ -269,7 +269,7 @@ mod debug_map {`
`269`	`269`	`fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {`
`270`	`270`	`fmt.debug_map()`
`271`	`271`	`.entry(&"bar", &true)`
`272`		`- .entry(&10i32, &format_args!("{}/{}", 10i32, 20i32))`
	`272`	`+ .entry(&10, &format_args!("{}/{}", 10, 20))`
`273`	`273`	`.finish()`
`274`	`274`	`}`
`275`	`275`	`}`
`@@ -348,7 +348,7 @@ mod debug_set {`
`348`	`348`	`fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {`
`349`	`349`	`fmt.debug_set()`
`350`	`350`	`.entry(&true)`
`351`		`- .entry(&format_args!("{}/{}", 10i32, 20i32))`
	`351`	`+ .entry(&format_args!("{}/{}", 10, 20))`
`352`	`352`	`.finish()`
`353`	`353`	`}`
`354`	`354`	`}`
`@@ -370,7 +370,7 @@ mod debug_set {`
`370`	`370`	`fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {`
`371`	`371`	`fmt.debug_set()`
`372`	`372`	`.entry(&true)`
`373`		`- .entry(&format_args!("{}/{}", 10i32, 20i32))`
	`373`	`+ .entry(&format_args!("{}/{}", 10, 20))`
`374`	`374`	`.finish()`
`375`	`375`	`}`
`376`	`376`	`}`
`@@ -445,7 +445,7 @@ mod debug_list {`
`445`	`445`	`fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {`
`446`	`446`	`fmt.debug_list()`
`447`	`447`	`.entry(&true)`
`448`		`- .entry(&format_args!("{}/{}", 10i32, 20i32))`
	`448`	`+ .entry(&format_args!("{}/{}", 10, 20))`
`449`	`449`	`.finish()`
`450`	`450`	`}`
`451`	`451`	`}`
`@@ -467,7 +467,7 @@ mod debug_list {`
`467`	`467`	`fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {`
`468`	`468`	`fmt.debug_list()`
`469`	`469`	`.entry(&true)`
`470`		`- .entry(&format_args!("{}/{}", 10i32, 20i32))`
	`470`	`+ .entry(&format_args!("{}/{}", 10, 20))`
`471`	`471`	`.finish()`
`472`	`472`	`}`
`473`	`473`	`}`
Original file line number	Diff line number	Diff line change
`@@ -208,11 +208,11 @@ mod tests {`
`208`	`208`	`fn test_pow() {`
`209`	`209`	`let mut r = 2 as $T;`
`210`	`210`
`211`		`- assert_eq!(r.pow(2u32), 4 as $T);`
`212`		`- assert_eq!(r.pow(0u32), 1 as $T);`
	`211`	`+ assert_eq!(r.pow(2), 4 as $T);`
	`212`	`+ assert_eq!(r.pow(0), 1 as $T);`
`213`	`213`	`r = -2 as $T;`
`214`		`- assert_eq!(r.pow(2u32), 4 as $T);`
`215`		`- assert_eq!(r.pow(3u32), -8 as $T);`
	`214`	`+ assert_eq!(r.pow(2), 4 as $T);`
	`215`	`+ assert_eq!(r.pow(3), -8 as $T);`
`216`	`216`	`}`
`217`	`217`	`}`
`218`	`218`
Original file line number	Diff line number	Diff line change
`@@ -99,8 +99,8 @@ mod tests {`
`99`	`99`
`100`	`100`	`#[test]`
`101`	`101`	`fn test_leading_plus() {`
`102`		`- assert_eq!("+127".parse::<u8>().ok(), Some(127u8));`
`103`		`- assert_eq!("+9223372036854775807".parse::<i64>().ok(), Some(9223372036854775807i64));`
	`102`	`+ assert_eq!("+127".parse::<u8>().ok(), Some(127));`
	`103`	`+ assert_eq!("+9223372036854775807".parse::<i64>().ok(), Some(9223372036854775807));`
`104`	`104`	`}`
`105`	`105`
`106`	`106`	`#[test]`