Fixed tests still using old integer to_str

Fixed integer tests

2 files changed, 33 insertions, 11 deletions

diff --git a/src/libcore/num/int-template.rs b/src/libcore/num/int-template.rs
index 6263a9d887b..06d11e23967 100644
--- a/src/libcore/num/int-template.rs
+++ b/src/libcore/num/int-template.rs
@@ -26,6 +26,9 @@ use prelude::*;
 use str;
 use uint;
 use vec;
+use i8;
+use i16;
+use i32;
 
 pub const bits : uint = inst::bits;
 pub const bytes : uint = (inst::bits / 8);
@@ -301,13 +304,13 @@ fn test_from_str() {
     assert from_str(~"0") == Some(0 as T);
     assert from_str(~"3") == Some(3 as T);
     assert from_str(~"10") == Some(10 as T);
-    assert from_str(~"123456789") == Some(123456789 as T);
+    assert i32::from_str(~"123456789") == Some(123456789 as i32);
     assert from_str(~"00100") == Some(100 as T);
 
     assert from_str(~"-1") == Some(-1 as T);
     assert from_str(~"-3") == Some(-3 as T);
     assert from_str(~"-10") == Some(-10 as T);
-    assert from_str(~"-123456789") == Some(-123456789 as T);
+    assert i32::from_str(~"-123456789") == Some(-123456789 as i32);
     assert from_str(~"-00100") == Some(-100 as T);
 
     assert from_str(~" ").is_none();
@@ -320,18 +323,18 @@ fn test_parse_bytes() {
     assert parse_bytes(to_bytes(~"123"), 10u) == Some(123 as T);
     assert parse_bytes(to_bytes(~"1001"), 2u) == Some(9 as T);
     assert parse_bytes(to_bytes(~"123"), 8u) == Some(83 as T);
-    assert parse_bytes(to_bytes(~"123"), 16u) == Some(291 as T);
-    assert parse_bytes(to_bytes(~"ffff"), 16u) == Some(65535 as T);
-    assert parse_bytes(to_bytes(~"FFFF"), 16u) == Some(65535 as T);
+    assert i32::parse_bytes(to_bytes(~"123"), 16u) == Some(291 as i32);
+    assert i32::parse_bytes(to_bytes(~"ffff"), 16u) == Some(65535 as i32);
+    assert i32::parse_bytes(to_bytes(~"FFFF"), 16u) == Some(65535 as i32);
     assert parse_bytes(to_bytes(~"z"), 36u) == Some(35 as T);
     assert parse_bytes(to_bytes(~"Z"), 36u) == Some(35 as T);
 
     assert parse_bytes(to_bytes(~"-123"), 10u) == Some(-123 as T);
     assert parse_bytes(to_bytes(~"-1001"), 2u) == Some(-9 as T);
     assert parse_bytes(to_bytes(~"-123"), 8u) == Some(-83 as T);
-    assert parse_bytes(to_bytes(~"-123"), 16u) == Some(-291 as T);
-    assert parse_bytes(to_bytes(~"-ffff"), 16u) == Some(-65535 as T);
-    assert parse_bytes(to_bytes(~"-FFFF"), 16u) == Some(-65535 as T);
+    assert i32::parse_bytes(to_bytes(~"-123"), 16u) == Some(-291 as i32);
+    assert i32::parse_bytes(to_bytes(~"-ffff"), 16u) == Some(-65535 as i32);
+    assert i32::parse_bytes(to_bytes(~"-FFFF"), 16u) == Some(-65535 as i32);
     assert parse_bytes(to_bytes(~"-z"), 36u) == Some(-35 as T);
     assert parse_bytes(to_bytes(~"-Z"), 36u) == Some(-35 as T);
 
@@ -380,27 +383,35 @@ fn test_int_to_str_overflow() {
 fn test_int_from_str_overflow() {
     let mut i8_val: i8 = 127_i8;
     assert (i8::from_str(~"127") == Some(i8_val));
+    assert (i8::from_str(~"128").is_none());
 
     i8_val += 1 as i8;
     assert (i8::from_str(~"-128") == Some(i8_val));
+    assert (i8::from_str(~"-129").is_none());
 
     let mut i16_val: i16 = 32_767_i16;
     assert (i16::from_str(~"32767") == Some(i16_val));
+    assert (i16::from_str(~"32768").is_none());
 
     i16_val += 1 as i16;
     assert (i16::from_str(~"-32768") == Some(i16_val));
+    assert (i16::from_str(~"-32769").is_none());
 
     let mut i32_val: i32 = 2_147_483_647_i32;
     assert (i32::from_str(~"2147483647") == Some(i32_val));
+    assert (i32::from_str(~"2147483648").is_none());
 
     i32_val += 1 as i32;
     assert (i32::from_str(~"-2147483648") == Some(i32_val));
+    assert (i32::from_str(~"-2147483649").is_none());
 
     let mut i64_val: i64 = 9_223_372_036_854_775_807_i64;
     assert (i64::from_str(~"9223372036854775807") == Some(i64_val));
+    assert (i64::from_str(~"9223372036854775808").is_none());
 
     i64_val += 1 as i64;
     assert (i64::from_str(~"-9223372036854775808") == Some(i64_val));
+    assert (i64::from_str(~"-9223372036854775809").is_none());
 }
 
 #[test]
diff --git a/src/libcore/num/uint-template.rs b/src/libcore/num/uint-template.rs
index 0c39186824a..44ed9816cf9 100644
--- a/src/libcore/num/uint-template.rs
+++ b/src/libcore/num/uint-template.rs
@@ -27,6 +27,9 @@ use prelude::*;
 use str;
 use uint;
 use vec;
+use u8;
+use u16;
+use u32;
 
 pub const bits : uint = inst::bits;
 pub const bytes : uint = (inst::bits / 8);
@@ -274,7 +277,7 @@ pub fn test_from_str() {
     assert from_str(~"0") == Some(0u as T);
     assert from_str(~"3") == Some(3u as T);
     assert from_str(~"10") == Some(10u as T);
-    assert from_str(~"123456789") == Some(123456789u as T);
+    assert u32::from_str(~"123456789") == Some(123456789 as u32);
     assert from_str(~"00100") == Some(100u as T);
 
     assert from_str(~"").is_none();
@@ -288,8 +291,8 @@ pub fn test_parse_bytes() {
     assert parse_bytes(to_bytes(~"123"), 10u) == Some(123u as T);
     assert parse_bytes(to_bytes(~"1001"), 2u) == Some(9u as T);
     assert parse_bytes(to_bytes(~"123"), 8u) == Some(83u as T);
-    assert parse_bytes(to_bytes(~"123"), 16u) == Some(291u as T);
-    assert parse_bytes(to_bytes(~"ffff"), 16u) == Some(65535u as T);
+    assert u16::parse_bytes(to_bytes(~"123"), 16u) == Some(291u as u16);
+    assert u16::parse_bytes(to_bytes(~"ffff"), 16u) == Some(65535u as u16);
     assert parse_bytes(to_bytes(~"z"), 36u) == Some(35u as T);
 
     assert parse_bytes(to_bytes(~"Z"), 10u).is_none();
@@ -327,27 +330,35 @@ fn test_uint_to_str_overflow() {
 fn test_uint_from_str_overflow() {
     let mut u8_val: u8 = 255_u8;
     assert (u8::from_str(~"255") == Some(u8_val));
+    assert (u8::from_str(~"256").is_none());
 
     u8_val += 1 as u8;
     assert (u8::from_str(~"0") == Some(u8_val));
+    assert (u8::from_str(~"-1").is_none());
 
     let mut u16_val: u16 = 65_535_u16;
     assert (u16::from_str(~"65535") == Some(u16_val));
+    assert (u16::from_str(~"65536").is_none());
 
     u16_val += 1 as u16;
     assert (u16::from_str(~"0") == Some(u16_val));
+    assert (u16::from_str(~"-1").is_none());
 
     let mut u32_val: u32 = 4_294_967_295_u32;
     assert (u32::from_str(~"4294967295") == Some(u32_val));
+    assert (u32::from_str(~"4294967296").is_none());
 
     u32_val += 1 as u32;
     assert (u32::from_str(~"0") == Some(u32_val));
+    assert (u32::from_str(~"-1").is_none());
 
     let mut u64_val: u64 = 18_446_744_073_709_551_615_u64;
     assert (u64::from_str(~"18446744073709551615") == Some(u64_val));
+    assert (u64::from_str(~"18446744073709551616").is_none());
 
     u64_val += 1 as u64;
     assert (u64::from_str(~"0") == Some(u64_val));
+    assert (u64::from_str(~"-1").is_none());
 }
 
 #[test]