---

yaml
---
r: 42270
b: refs/heads/master
c: 7113fd1
h: refs/heads/master
v: v3

Author: Kimundi

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: eb194621044253fae32649511d76515a64009a53
+refs/heads/master: 7113fd150ad169dcc0348f84bcd6042da0f9fd5c
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2f46b763da2c098913884f101b6d71d69af41b49
 refs/heads/try: 3d5418789064fdb463e872a4e651af1c628a3650

trunk/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]

trunk/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]

trunk/src/libstd/map.rs

@@ -619,32 +619,35 @@ mod tests {
             map::HashMap::<~str, ~str>();
         i = 0u;
         while i < num_to_insert {
-            assert hm_ss.insert(uint::to_str(i, 2u), uint::to_str(i * i, 2u));
+            assert hm_ss.insert(uint::to_str_radix(i, 2u),
+                                uint::to_str_radix(i * i, 2u));
             debug!("inserting \"%s\" -> \"%s\"",
-                   uint::to_str(i, 2u),
-                   uint::to_str(i*i, 2u));
+                   uint::to_str_radix(i, 2u),
+                   uint::to_str_radix(i*i, 2u));
             i += 1u;
         }
         debug!("-----");
         i = 0u;
         while i < num_to_insert {
             debug!("get(\"%s\") = \"%s\"",
-                   uint::to_str(i, 2u),
-                   hm_ss.get(uint::to_str(i, 2u)));
-            assert hm_ss.get(uint::to_str(i, 2u)) == uint::to_str(i * i, 2u);
+                   uint::to_str_radix(i, 2u),
+                   hm_ss.get(uint::to_str_radix(i, 2u)));
+            assert hm_ss.get(uint::to_str_radix(i, 2u)) ==
+                             uint::to_str_radix(i * i, 2u);
             i += 1u;
         }
-        assert (hm_ss.insert(uint::to_str(num_to_insert, 2u),
-                             uint::to_str(17u, 2u)));
-        assert hm_ss.get(uint::to_str(num_to_insert, 2u)) ==
-            uint::to_str(17u, 2u);
+        assert (hm_ss.insert(uint::to_str_radix(num_to_insert, 2u),
+                             uint::to_str_radix(17u, 2u)));
+        assert hm_ss.get(uint::to_str_radix(num_to_insert, 2u)) ==
+            uint::to_str_radix(17u, 2u);
         debug!("-----");
         i = 0u;
         while i < num_to_insert {
             debug!("get(\"%s\") = \"%s\"",
-                   uint::to_str(i, 2u),
-                   hm_ss.get(uint::to_str(i, 2u)));
-            assert hm_ss.get(uint::to_str(i, 2u)) == uint::to_str(i * i, 2u);
+                   uint::to_str_radix(i, 2u),
+                   hm_ss.get(uint::to_str_radix(i, 2u)));
+            assert hm_ss.get(uint::to_str_radix(i, 2u)) ==
+                             uint::to_str_radix(i * i, 2u);
             i += 1u;
         }
         debug!("*** finished test_growth");