cleanup warnings from libstd
This commit is contained in:
Erick Tryzelaar
parent
1965d72957
commit
dc970c13f4
@ -11,7 +11,6 @@
|
||||
//! Unsafe casting functions
|
||||
|
||||
use sys;
|
||||
use unstable;
|
||||
use unstable::intrinsics;
|
||||
|
||||
/// Casts the value at `src` to U. The two types must have the same length.
|
||||
|
||||
@ -488,7 +488,7 @@ mod tests {
|
||||
assert!(f == i && f == v);
|
||||
|
||||
buf += ~[t as u8];
|
||||
stream_inc.input(~[t as u8]);
|
||||
stream_inc.input([t as u8]);
|
||||
|
||||
t += 1;
|
||||
}
|
||||
|
||||
@ -1839,7 +1839,7 @@ mod tests {
|
||||
{
|
||||
let out: @io::Writer =
|
||||
result::get(
|
||||
&io::file_writer(tmpfile, ~[io::Create, io::Truncate]));
|
||||
&io::file_writer(tmpfile, [io::Create, io::Truncate]));
|
||||
out.write_str(frood);
|
||||
}
|
||||
let inp: @io::Reader = result::get(&io::file_reader(tmpfile));
|
||||
@ -1850,7 +1850,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_readchars_empty() {
|
||||
do io::with_str_reader(~"") |inp| {
|
||||
do io::with_str_reader("") |inp| {
|
||||
let res : ~[char] = inp.read_chars(128);
|
||||
assert_eq!(res.len(), 0);
|
||||
}
|
||||
@ -1858,7 +1858,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_read_line_utf8() {
|
||||
do io::with_str_reader(~"生锈的汤匙切肉汤hello生锈的汤匙切肉汤") |inp| {
|
||||
do io::with_str_reader("生锈的汤匙切肉汤hello生锈的汤匙切肉汤") |inp| {
|
||||
let line = inp.read_line();
|
||||
assert_eq!(line, ~"生锈的汤匙切肉汤hello生锈的汤匙切肉汤");
|
||||
}
|
||||
@ -1866,15 +1866,15 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_read_lines() {
|
||||
do io::with_str_reader(~"a\nb\nc\n") |inp| {
|
||||
do io::with_str_reader("a\nb\nc\n") |inp| {
|
||||
assert_eq!(inp.read_lines(), ~[~"a", ~"b", ~"c"]);
|
||||
}
|
||||
|
||||
do io::with_str_reader(~"a\nb\nc") |inp| {
|
||||
do io::with_str_reader("a\nb\nc") |inp| {
|
||||
assert_eq!(inp.read_lines(), ~[~"a", ~"b", ~"c"]);
|
||||
}
|
||||
|
||||
do io::with_str_reader(~"") |inp| {
|
||||
do io::with_str_reader("") |inp| {
|
||||
assert!(inp.read_lines().is_empty());
|
||||
}
|
||||
}
|
||||
@ -1909,7 +1909,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_readchar() {
|
||||
do io::with_str_reader(~"生") |inp| {
|
||||
do io::with_str_reader("生") |inp| {
|
||||
let res : char = inp.read_char();
|
||||
assert_eq!(res as int, 29983);
|
||||
}
|
||||
@ -1917,7 +1917,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_readchar_empty() {
|
||||
do io::with_str_reader(~"") |inp| {
|
||||
do io::with_str_reader("") |inp| {
|
||||
let res : char = inp.read_char();
|
||||
assert_eq!(res as int, -1);
|
||||
}
|
||||
@ -1966,7 +1966,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn file_writer_bad_name() {
|
||||
match io::file_writer(&Path("?/?"), ~[]) {
|
||||
match io::file_writer(&Path("?/?"), []) {
|
||||
result::Err(copy e) => {
|
||||
assert!(str::starts_with(e, "error opening"));
|
||||
}
|
||||
@ -1987,15 +1987,15 @@ mod tests {
|
||||
#[test]
|
||||
fn bytes_buffer_overwrite() {
|
||||
let wr = BytesWriter();
|
||||
wr.write(~[0u8, 1u8, 2u8, 3u8]);
|
||||
wr.write([0u8, 1u8, 2u8, 3u8]);
|
||||
assert!(*wr.bytes == ~[0u8, 1u8, 2u8, 3u8]);
|
||||
wr.seek(-2, SeekCur);
|
||||
wr.write(~[4u8, 5u8, 6u8, 7u8]);
|
||||
wr.write([4u8, 5u8, 6u8, 7u8]);
|
||||
assert!(*wr.bytes == ~[0u8, 1u8, 4u8, 5u8, 6u8, 7u8]);
|
||||
wr.seek(-2, SeekEnd);
|
||||
wr.write(~[8u8]);
|
||||
wr.write([8u8]);
|
||||
wr.seek(1, SeekSet);
|
||||
wr.write(~[9u8]);
|
||||
wr.write([9u8]);
|
||||
assert!(*wr.bytes == ~[0u8, 9u8, 4u8, 5u8, 8u8, 7u8]);
|
||||
}
|
||||
|
||||
@ -2085,7 +2085,7 @@ mod tests {
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[test]
|
||||
fn test_read_write_f32() {
|
||||
let path = Path("tmp/lib-io-test-read-write-f32.tmp");
|
||||
let f:f32 = 8.1250;
|
||||
|
||||
@ -951,7 +951,6 @@ impl num::FromStrRadix for f32 {
|
||||
mod tests {
|
||||
use f32::*;
|
||||
use num::*;
|
||||
use super::*;
|
||||
use prelude::*;
|
||||
|
||||
#[test]
|
||||
|
||||
@ -993,7 +993,6 @@ impl num::FromStrRadix for f64 {
|
||||
mod tests {
|
||||
use f64::*;
|
||||
use num::*;
|
||||
use super::*;
|
||||
use prelude::*;
|
||||
|
||||
#[test]
|
||||
|
||||
@ -1251,101 +1251,101 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
pub fn test_from_str() {
|
||||
assert_eq!(from_str(~"3"), Some(3.));
|
||||
assert_eq!(from_str(~"3.14"), Some(3.14));
|
||||
assert_eq!(from_str(~"+3.14"), Some(3.14));
|
||||
assert_eq!(from_str(~"-3.14"), Some(-3.14));
|
||||
assert_eq!(from_str(~"2.5E10"), Some(25000000000.));
|
||||
assert_eq!(from_str(~"2.5e10"), Some(25000000000.));
|
||||
assert_eq!(from_str(~"25000000000.E-10"), Some(2.5));
|
||||
assert_eq!(from_str(~"."), Some(0.));
|
||||
assert_eq!(from_str(~".e1"), Some(0.));
|
||||
assert_eq!(from_str(~".e-1"), Some(0.));
|
||||
assert_eq!(from_str(~"5."), Some(5.));
|
||||
assert_eq!(from_str(~".5"), Some(0.5));
|
||||
assert_eq!(from_str(~"0.5"), Some(0.5));
|
||||
assert_eq!(from_str(~"-.5"), Some(-0.5));
|
||||
assert_eq!(from_str(~"-5"), Some(-5.));
|
||||
assert_eq!(from_str(~"inf"), Some(infinity));
|
||||
assert_eq!(from_str(~"+inf"), Some(infinity));
|
||||
assert_eq!(from_str(~"-inf"), Some(neg_infinity));
|
||||
assert_eq!(from_str("3"), Some(3.));
|
||||
assert_eq!(from_str("3.14"), Some(3.14));
|
||||
assert_eq!(from_str("+3.14"), Some(3.14));
|
||||
assert_eq!(from_str("-3.14"), Some(-3.14));
|
||||
assert_eq!(from_str("2.5E10"), Some(25000000000.));
|
||||
assert_eq!(from_str("2.5e10"), Some(25000000000.));
|
||||
assert_eq!(from_str("25000000000.E-10"), Some(2.5));
|
||||
assert_eq!(from_str("."), Some(0.));
|
||||
assert_eq!(from_str(".e1"), Some(0.));
|
||||
assert_eq!(from_str(".e-1"), Some(0.));
|
||||
assert_eq!(from_str("5."), Some(5.));
|
||||
assert_eq!(from_str(".5"), Some(0.5));
|
||||
assert_eq!(from_str("0.5"), Some(0.5));
|
||||
assert_eq!(from_str("-.5"), Some(-0.5));
|
||||
assert_eq!(from_str("-5"), Some(-5.));
|
||||
assert_eq!(from_str("inf"), Some(infinity));
|
||||
assert_eq!(from_str("+inf"), Some(infinity));
|
||||
assert_eq!(from_str("-inf"), Some(neg_infinity));
|
||||
// note: NaN != NaN, hence this slightly complex test
|
||||
match from_str(~"NaN") {
|
||||
match from_str("NaN") {
|
||||
Some(f) => assert!(f.is_NaN()),
|
||||
None => fail!()
|
||||
}
|
||||
// note: -0 == 0, hence these slightly more complex tests
|
||||
match from_str(~"-0") {
|
||||
match from_str("-0") {
|
||||
Some(v) if v.is_zero() => assert!(v.is_negative()),
|
||||
_ => fail!()
|
||||
}
|
||||
match from_str(~"0") {
|
||||
match from_str("0") {
|
||||
Some(v) if v.is_zero() => assert!(v.is_positive()),
|
||||
_ => fail!()
|
||||
}
|
||||
|
||||
assert!(from_str(~"").is_none());
|
||||
assert!(from_str(~"x").is_none());
|
||||
assert!(from_str(~" ").is_none());
|
||||
assert!(from_str(~" ").is_none());
|
||||
assert!(from_str(~"e").is_none());
|
||||
assert!(from_str(~"E").is_none());
|
||||
assert!(from_str(~"E1").is_none());
|
||||
assert!(from_str(~"1e1e1").is_none());
|
||||
assert!(from_str(~"1e1.1").is_none());
|
||||
assert!(from_str(~"1e1-1").is_none());
|
||||
assert!(from_str("").is_none());
|
||||
assert!(from_str("x").is_none());
|
||||
assert!(from_str(" ").is_none());
|
||||
assert!(from_str(" ").is_none());
|
||||
assert!(from_str("e").is_none());
|
||||
assert!(from_str("E").is_none());
|
||||
assert!(from_str("E1").is_none());
|
||||
assert!(from_str("1e1e1").is_none());
|
||||
assert!(from_str("1e1.1").is_none());
|
||||
assert!(from_str("1e1-1").is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
pub fn test_from_str_hex() {
|
||||
assert_eq!(from_str_hex(~"a4"), Some(164.));
|
||||
assert_eq!(from_str_hex(~"a4.fe"), Some(164.9921875));
|
||||
assert_eq!(from_str_hex(~"-a4.fe"), Some(-164.9921875));
|
||||
assert_eq!(from_str_hex(~"+a4.fe"), Some(164.9921875));
|
||||
assert_eq!(from_str_hex(~"ff0P4"), Some(0xff00 as float));
|
||||
assert_eq!(from_str_hex(~"ff0p4"), Some(0xff00 as float));
|
||||
assert_eq!(from_str_hex(~"ff0p-4"), Some(0xff as float));
|
||||
assert_eq!(from_str_hex(~"."), Some(0.));
|
||||
assert_eq!(from_str_hex(~".p1"), Some(0.));
|
||||
assert_eq!(from_str_hex(~".p-1"), Some(0.));
|
||||
assert_eq!(from_str_hex(~"f."), Some(15.));
|
||||
assert_eq!(from_str_hex(~".f"), Some(0.9375));
|
||||
assert_eq!(from_str_hex(~"0.f"), Some(0.9375));
|
||||
assert_eq!(from_str_hex(~"-.f"), Some(-0.9375));
|
||||
assert_eq!(from_str_hex(~"-f"), Some(-15.));
|
||||
assert_eq!(from_str_hex(~"inf"), Some(infinity));
|
||||
assert_eq!(from_str_hex(~"+inf"), Some(infinity));
|
||||
assert_eq!(from_str_hex(~"-inf"), Some(neg_infinity));
|
||||
assert_eq!(from_str_hex("a4"), Some(164.));
|
||||
assert_eq!(from_str_hex("a4.fe"), Some(164.9921875));
|
||||
assert_eq!(from_str_hex("-a4.fe"), Some(-164.9921875));
|
||||
assert_eq!(from_str_hex("+a4.fe"), Some(164.9921875));
|
||||
assert_eq!(from_str_hex("ff0P4"), Some(0xff00 as float));
|
||||
assert_eq!(from_str_hex("ff0p4"), Some(0xff00 as float));
|
||||
assert_eq!(from_str_hex("ff0p-4"), Some(0xff as float));
|
||||
assert_eq!(from_str_hex("."), Some(0.));
|
||||
assert_eq!(from_str_hex(".p1"), Some(0.));
|
||||
assert_eq!(from_str_hex(".p-1"), Some(0.));
|
||||
assert_eq!(from_str_hex("f."), Some(15.));
|
||||
assert_eq!(from_str_hex(".f"), Some(0.9375));
|
||||
assert_eq!(from_str_hex("0.f"), Some(0.9375));
|
||||
assert_eq!(from_str_hex("-.f"), Some(-0.9375));
|
||||
assert_eq!(from_str_hex("-f"), Some(-15.));
|
||||
assert_eq!(from_str_hex("inf"), Some(infinity));
|
||||
assert_eq!(from_str_hex("+inf"), Some(infinity));
|
||||
assert_eq!(from_str_hex("-inf"), Some(neg_infinity));
|
||||
// note: NaN != NaN, hence this slightly complex test
|
||||
match from_str_hex(~"NaN") {
|
||||
match from_str_hex("NaN") {
|
||||
Some(f) => assert!(f.is_NaN()),
|
||||
None => fail!()
|
||||
}
|
||||
// note: -0 == 0, hence these slightly more complex tests
|
||||
match from_str_hex(~"-0") {
|
||||
match from_str_hex("-0") {
|
||||
Some(v) if v.is_zero() => assert!(v.is_negative()),
|
||||
_ => fail!()
|
||||
}
|
||||
match from_str_hex(~"0") {
|
||||
match from_str_hex("0") {
|
||||
Some(v) if v.is_zero() => assert!(v.is_positive()),
|
||||
_ => fail!()
|
||||
}
|
||||
assert_eq!(from_str_hex(~"e"), Some(14.));
|
||||
assert_eq!(from_str_hex(~"E"), Some(14.));
|
||||
assert_eq!(from_str_hex(~"E1"), Some(225.));
|
||||
assert_eq!(from_str_hex(~"1e1e1"), Some(123361.));
|
||||
assert_eq!(from_str_hex(~"1e1.1"), Some(481.0625));
|
||||
assert_eq!(from_str_hex("e"), Some(14.));
|
||||
assert_eq!(from_str_hex("E"), Some(14.));
|
||||
assert_eq!(from_str_hex("E1"), Some(225.));
|
||||
assert_eq!(from_str_hex("1e1e1"), Some(123361.));
|
||||
assert_eq!(from_str_hex("1e1.1"), Some(481.0625));
|
||||
|
||||
assert!(from_str_hex(~"").is_none());
|
||||
assert!(from_str_hex(~"x").is_none());
|
||||
assert!(from_str_hex(~" ").is_none());
|
||||
assert!(from_str_hex(~" ").is_none());
|
||||
assert!(from_str_hex(~"p").is_none());
|
||||
assert!(from_str_hex(~"P").is_none());
|
||||
assert!(from_str_hex(~"P1").is_none());
|
||||
assert!(from_str_hex(~"1p1p1").is_none());
|
||||
assert!(from_str_hex(~"1p1.1").is_none());
|
||||
assert!(from_str_hex(~"1p1-1").is_none());
|
||||
assert!(from_str_hex("").is_none());
|
||||
assert!(from_str_hex("x").is_none());
|
||||
assert!(from_str_hex(" ").is_none());
|
||||
assert!(from_str_hex(" ").is_none());
|
||||
assert!(from_str_hex("p").is_none());
|
||||
assert!(from_str_hex("P").is_none());
|
||||
assert!(from_str_hex("P1").is_none());
|
||||
assert!(from_str_hex("1p1p1").is_none());
|
||||
assert!(from_str_hex("1p1.1").is_none());
|
||||
assert!(from_str_hex("1p1-1").is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -1375,8 +1375,8 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
pub fn test_from_str_radix() {
|
||||
assert_eq!(from_str_radix(~"10", 36u), Some(36.));
|
||||
assert_eq!(from_str_radix(~"1000.001", 2u), Some(8.125));
|
||||
assert_eq!(from_str_radix("10", 36u), Some(36.));
|
||||
assert_eq!(from_str_radix("1000.001", 2u), Some(8.125));
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@ -755,45 +755,45 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_from_str() {
|
||||
assert_eq!(from_str(~"0"), Some(0 as T));
|
||||
assert_eq!(from_str(~"3"), Some(3 as T));
|
||||
assert_eq!(from_str(~"10"), Some(10 as T));
|
||||
assert_eq!(i32::from_str(~"123456789"), Some(123456789 as i32));
|
||||
assert_eq!(from_str(~"00100"), Some(100 as T));
|
||||
assert_eq!(from_str("0"), Some(0 as T));
|
||||
assert_eq!(from_str("3"), Some(3 as T));
|
||||
assert_eq!(from_str("10"), Some(10 as T));
|
||||
assert_eq!(i32::from_str("123456789"), Some(123456789 as i32));
|
||||
assert_eq!(from_str("00100"), Some(100 as T));
|
||||
|
||||
assert_eq!(from_str(~"-1"), Some(-1 as T));
|
||||
assert_eq!(from_str(~"-3"), Some(-3 as T));
|
||||
assert_eq!(from_str(~"-10"), Some(-10 as T));
|
||||
assert_eq!(i32::from_str(~"-123456789"), Some(-123456789 as i32));
|
||||
assert_eq!(from_str(~"-00100"), Some(-100 as T));
|
||||
assert_eq!(from_str("-1"), Some(-1 as T));
|
||||
assert_eq!(from_str("-3"), Some(-3 as T));
|
||||
assert_eq!(from_str("-10"), Some(-10 as T));
|
||||
assert_eq!(i32::from_str("-123456789"), Some(-123456789 as i32));
|
||||
assert_eq!(from_str("-00100"), Some(-100 as T));
|
||||
|
||||
assert!(from_str(~" ").is_none());
|
||||
assert!(from_str(~"x").is_none());
|
||||
assert!(from_str(" ").is_none());
|
||||
assert!(from_str("x").is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_parse_bytes() {
|
||||
use str::to_bytes;
|
||||
assert_eq!(parse_bytes(to_bytes(~"123"), 10u), Some(123 as T));
|
||||
assert_eq!(parse_bytes(to_bytes(~"1001"), 2u), Some(9 as T));
|
||||
assert_eq!(parse_bytes(to_bytes(~"123"), 8u), Some(83 as T));
|
||||
assert_eq!(i32::parse_bytes(to_bytes(~"123"), 16u), Some(291 as i32));
|
||||
assert_eq!(i32::parse_bytes(to_bytes(~"ffff"), 16u), Some(65535 as i32));
|
||||
assert_eq!(i32::parse_bytes(to_bytes(~"FFFF"), 16u), Some(65535 as i32));
|
||||
assert_eq!(parse_bytes(to_bytes(~"z"), 36u), Some(35 as T));
|
||||
assert_eq!(parse_bytes(to_bytes(~"Z"), 36u), Some(35 as T));
|
||||
assert_eq!(parse_bytes(to_bytes("123"), 10u), Some(123 as T));
|
||||
assert_eq!(parse_bytes(to_bytes("1001"), 2u), Some(9 as T));
|
||||
assert_eq!(parse_bytes(to_bytes("123"), 8u), Some(83 as T));
|
||||
assert_eq!(i32::parse_bytes(to_bytes("123"), 16u), Some(291 as i32));
|
||||
assert_eq!(i32::parse_bytes(to_bytes("ffff"), 16u), Some(65535 as i32));
|
||||
assert_eq!(i32::parse_bytes(to_bytes("FFFF"), 16u), Some(65535 as i32));
|
||||
assert_eq!(parse_bytes(to_bytes("z"), 36u), Some(35 as T));
|
||||
assert_eq!(parse_bytes(to_bytes("Z"), 36u), Some(35 as T));
|
||||
|
||||
assert_eq!(parse_bytes(to_bytes(~"-123"), 10u), Some(-123 as T));
|
||||
assert_eq!(parse_bytes(to_bytes(~"-1001"), 2u), Some(-9 as T));
|
||||
assert_eq!(parse_bytes(to_bytes(~"-123"), 8u), Some(-83 as T));
|
||||
assert_eq!(i32::parse_bytes(to_bytes(~"-123"), 16u), Some(-291 as i32));
|
||||
assert_eq!(i32::parse_bytes(to_bytes(~"-ffff"), 16u), Some(-65535 as i32));
|
||||
assert_eq!(i32::parse_bytes(to_bytes(~"-FFFF"), 16u), Some(-65535 as i32));
|
||||
assert_eq!(parse_bytes(to_bytes(~"-z"), 36u), Some(-35 as T));
|
||||
assert_eq!(parse_bytes(to_bytes(~"-Z"), 36u), Some(-35 as T));
|
||||
assert_eq!(parse_bytes(to_bytes("-123"), 10u), Some(-123 as T));
|
||||
assert_eq!(parse_bytes(to_bytes("-1001"), 2u), Some(-9 as T));
|
||||
assert_eq!(parse_bytes(to_bytes("-123"), 8u), Some(-83 as T));
|
||||
assert_eq!(i32::parse_bytes(to_bytes("-123"), 16u), Some(-291 as i32));
|
||||
assert_eq!(i32::parse_bytes(to_bytes("-ffff"), 16u), Some(-65535 as i32));
|
||||
assert_eq!(i32::parse_bytes(to_bytes("-FFFF"), 16u), Some(-65535 as i32));
|
||||
assert_eq!(parse_bytes(to_bytes("-z"), 36u), Some(-35 as T));
|
||||
assert_eq!(parse_bytes(to_bytes("-Z"), 36u), Some(-35 as T));
|
||||
|
||||
assert!(parse_bytes(to_bytes(~"Z"), 35u).is_none());
|
||||
assert!(parse_bytes(to_bytes(~"-9"), 2u).is_none());
|
||||
assert!(parse_bytes(to_bytes("Z"), 35u).is_none());
|
||||
assert!(parse_bytes(to_bytes("-9"), 2u).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -836,36 +836,36 @@ mod tests {
|
||||
#[test]
|
||||
fn test_int_from_str_overflow() {
|
||||
let mut i8_val: i8 = 127_i8;
|
||||
assert_eq!(i8::from_str(~"127"), Some(i8_val));
|
||||
assert!(i8::from_str(~"128").is_none());
|
||||
assert_eq!(i8::from_str("127"), Some(i8_val));
|
||||
assert!(i8::from_str("128").is_none());
|
||||
|
||||
i8_val += 1 as i8;
|
||||
assert_eq!(i8::from_str(~"-128"), Some(i8_val));
|
||||
assert!(i8::from_str(~"-129").is_none());
|
||||
assert_eq!(i8::from_str("-128"), Some(i8_val));
|
||||
assert!(i8::from_str("-129").is_none());
|
||||
|
||||
let mut i16_val: i16 = 32_767_i16;
|
||||
assert_eq!(i16::from_str(~"32767"), Some(i16_val));
|
||||
assert!(i16::from_str(~"32768").is_none());
|
||||
assert_eq!(i16::from_str("32767"), Some(i16_val));
|
||||
assert!(i16::from_str("32768").is_none());
|
||||
|
||||
i16_val += 1 as i16;
|
||||
assert_eq!(i16::from_str(~"-32768"), Some(i16_val));
|
||||
assert!(i16::from_str(~"-32769").is_none());
|
||||
assert_eq!(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_eq!(i32::from_str(~"2147483647"), Some(i32_val));
|
||||
assert!(i32::from_str(~"2147483648").is_none());
|
||||
assert_eq!(i32::from_str("2147483647"), Some(i32_val));
|
||||
assert!(i32::from_str("2147483648").is_none());
|
||||
|
||||
i32_val += 1 as i32;
|
||||
assert_eq!(i32::from_str(~"-2147483648"), Some(i32_val));
|
||||
assert!(i32::from_str(~"-2147483649").is_none());
|
||||
assert_eq!(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_eq!(i64::from_str(~"9223372036854775807"), Some(i64_val));
|
||||
assert!(i64::from_str(~"9223372036854775808").is_none());
|
||||
assert_eq!(i64::from_str("9223372036854775807"), Some(i64_val));
|
||||
assert!(i64::from_str("9223372036854775808").is_none());
|
||||
|
||||
i64_val += 1 as i64;
|
||||
assert_eq!(i64::from_str(~"-9223372036854775808"), Some(i64_val));
|
||||
assert!(i64::from_str(~"-9223372036854775809").is_none());
|
||||
assert_eq!(i64::from_str("-9223372036854775808"), Some(i64_val));
|
||||
assert!(i64::from_str("-9223372036854775809").is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@ -472,29 +472,29 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
pub fn test_from_str() {
|
||||
assert_eq!(from_str(~"0"), Some(0u as T));
|
||||
assert_eq!(from_str(~"3"), Some(3u as T));
|
||||
assert_eq!(from_str(~"10"), Some(10u as T));
|
||||
assert_eq!(u32::from_str(~"123456789"), Some(123456789 as u32));
|
||||
assert_eq!(from_str(~"00100"), Some(100u as T));
|
||||
assert_eq!(from_str("0"), Some(0u as T));
|
||||
assert_eq!(from_str("3"), Some(3u as T));
|
||||
assert_eq!(from_str("10"), Some(10u as T));
|
||||
assert_eq!(u32::from_str("123456789"), Some(123456789 as u32));
|
||||
assert_eq!(from_str("00100"), Some(100u as T));
|
||||
|
||||
assert!(from_str(~"").is_none());
|
||||
assert!(from_str(~" ").is_none());
|
||||
assert!(from_str(~"x").is_none());
|
||||
assert!(from_str("").is_none());
|
||||
assert!(from_str(" ").is_none());
|
||||
assert!(from_str("x").is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
pub fn test_parse_bytes() {
|
||||
use str::to_bytes;
|
||||
assert_eq!(parse_bytes(to_bytes(~"123"), 10u), Some(123u as T));
|
||||
assert_eq!(parse_bytes(to_bytes(~"1001"), 2u), Some(9u as T));
|
||||
assert_eq!(parse_bytes(to_bytes(~"123"), 8u), Some(83u as T));
|
||||
assert_eq!(u16::parse_bytes(to_bytes(~"123"), 16u), Some(291u as u16));
|
||||
assert_eq!(u16::parse_bytes(to_bytes(~"ffff"), 16u), Some(65535u as u16));
|
||||
assert_eq!(parse_bytes(to_bytes(~"z"), 36u), Some(35u as T));
|
||||
assert_eq!(parse_bytes(to_bytes("123"), 10u), Some(123u as T));
|
||||
assert_eq!(parse_bytes(to_bytes("1001"), 2u), Some(9u as T));
|
||||
assert_eq!(parse_bytes(to_bytes("123"), 8u), Some(83u as T));
|
||||
assert_eq!(u16::parse_bytes(to_bytes("123"), 16u), Some(291u as u16));
|
||||
assert_eq!(u16::parse_bytes(to_bytes("ffff"), 16u), Some(65535u as u16));
|
||||
assert_eq!(parse_bytes(to_bytes("z"), 36u), Some(35u as T));
|
||||
|
||||
assert!(parse_bytes(to_bytes(~"Z"), 10u).is_none());
|
||||
assert!(parse_bytes(to_bytes(~"_"), 2u).is_none());
|
||||
assert!(parse_bytes(to_bytes("Z"), 10u).is_none());
|
||||
assert!(parse_bytes(to_bytes("_"), 2u).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -527,36 +527,36 @@ mod tests {
|
||||
#[test]
|
||||
fn test_uint_from_str_overflow() {
|
||||
let mut u8_val: u8 = 255_u8;
|
||||
assert_eq!(u8::from_str(~"255"), Some(u8_val));
|
||||
assert!(u8::from_str(~"256").is_none());
|
||||
assert_eq!(u8::from_str("255"), Some(u8_val));
|
||||
assert!(u8::from_str("256").is_none());
|
||||
|
||||
u8_val += 1 as u8;
|
||||
assert_eq!(u8::from_str(~"0"), Some(u8_val));
|
||||
assert!(u8::from_str(~"-1").is_none());
|
||||
assert_eq!(u8::from_str("0"), Some(u8_val));
|
||||
assert!(u8::from_str("-1").is_none());
|
||||
|
||||
let mut u16_val: u16 = 65_535_u16;
|
||||
assert_eq!(u16::from_str(~"65535"), Some(u16_val));
|
||||
assert!(u16::from_str(~"65536").is_none());
|
||||
assert_eq!(u16::from_str("65535"), Some(u16_val));
|
||||
assert!(u16::from_str("65536").is_none());
|
||||
|
||||
u16_val += 1 as u16;
|
||||
assert_eq!(u16::from_str(~"0"), Some(u16_val));
|
||||
assert!(u16::from_str(~"-1").is_none());
|
||||
assert_eq!(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_eq!(u32::from_str(~"4294967295"), Some(u32_val));
|
||||
assert!(u32::from_str(~"4294967296").is_none());
|
||||
assert_eq!(u32::from_str("4294967295"), Some(u32_val));
|
||||
assert!(u32::from_str("4294967296").is_none());
|
||||
|
||||
u32_val += 1 as u32;
|
||||
assert_eq!(u32::from_str(~"0"), Some(u32_val));
|
||||
assert!(u32::from_str(~"-1").is_none());
|
||||
assert_eq!(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_eq!(u64::from_str(~"18446744073709551615"), Some(u64_val));
|
||||
assert!(u64::from_str(~"18446744073709551616").is_none());
|
||||
assert_eq!(u64::from_str("18446744073709551615"), Some(u64_val));
|
||||
assert!(u64::from_str("18446744073709551616").is_none());
|
||||
|
||||
u64_val += 1 as u64;
|
||||
assert_eq!(u64::from_str(~"0"), Some(u64_val));
|
||||
assert!(u64::from_str(~"-1").is_none());
|
||||
assert_eq!(u64::from_str("0"), Some(u64_val));
|
||||
assert!(u64::from_str("-1").is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@ -1444,14 +1444,14 @@ mod tests {
|
||||
#[test]
|
||||
fn test_setenv() {
|
||||
let n = make_rand_name();
|
||||
setenv(n, ~"VALUE");
|
||||
setenv(n, "VALUE");
|
||||
assert_eq!(getenv(n), option::Some(~"VALUE"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_unsetenv() {
|
||||
let n = make_rand_name();
|
||||
setenv(n, ~"VALUE");
|
||||
setenv(n, "VALUE");
|
||||
unsetenv(n);
|
||||
assert_eq!(getenv(n), option::None);
|
||||
}
|
||||
@ -1461,10 +1461,10 @@ mod tests {
|
||||
#[ignore]
|
||||
fn test_setenv_overwrite() {
|
||||
let n = make_rand_name();
|
||||
setenv(n, ~"1");
|
||||
setenv(n, ~"2");
|
||||
setenv(n, "1");
|
||||
setenv(n, "2");
|
||||
assert_eq!(getenv(n), option::Some(~"2"));
|
||||
setenv(n, ~"");
|
||||
setenv(n, "");
|
||||
assert_eq!(getenv(n), option::Some(~""));
|
||||
}
|
||||
|
||||
@ -1515,7 +1515,7 @@ mod tests {
|
||||
let n = make_rand_name();
|
||||
|
||||
let mut e = env();
|
||||
setenv(n, ~"VALUE");
|
||||
setenv(n, "VALUE");
|
||||
assert!(!vec::contains(e, &(copy n, ~"VALUE")));
|
||||
|
||||
e = env();
|
||||
@ -1526,7 +1526,7 @@ mod tests {
|
||||
fn test() {
|
||||
assert!((!Path("test-path").is_absolute));
|
||||
|
||||
debug!(~"Current working directory: " + getcwd().to_str());
|
||||
debug!("Current working directory: %s", getcwd().to_str());
|
||||
|
||||
debug!(make_absolute(&Path("test-path")));
|
||||
debug!(make_absolute(&Path("/usr/bin")));
|
||||
@ -1535,43 +1535,43 @@ mod tests {
|
||||
#[test]
|
||||
#[cfg(unix)]
|
||||
fn homedir() {
|
||||
let oldhome = getenv(~"HOME");
|
||||
let oldhome = getenv("HOME");
|
||||
|
||||
setenv(~"HOME", ~"/home/MountainView");
|
||||
setenv("HOME", "/home/MountainView");
|
||||
assert_eq!(os::homedir(), Some(Path("/home/MountainView")));
|
||||
|
||||
setenv(~"HOME", ~"");
|
||||
setenv("HOME", "");
|
||||
assert!(os::homedir().is_none());
|
||||
|
||||
for oldhome.each |s| { setenv(~"HOME", *s) }
|
||||
for oldhome.each |s| { setenv("HOME", *s) }
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(windows)]
|
||||
fn homedir() {
|
||||
|
||||
let oldhome = getenv(~"HOME");
|
||||
let olduserprofile = getenv(~"USERPROFILE");
|
||||
let oldhome = getenv("HOME");
|
||||
let olduserprofile = getenv("USERPROFILE");
|
||||
|
||||
setenv(~"HOME", ~"");
|
||||
setenv(~"USERPROFILE", ~"");
|
||||
setenv("HOME", "");
|
||||
setenv("USERPROFILE", "");
|
||||
|
||||
assert!(os::homedir().is_none());
|
||||
|
||||
setenv(~"HOME", ~"/home/MountainView");
|
||||
setenv("HOME", "/home/MountainView");
|
||||
assert_eq!(os::homedir(), Some(Path("/home/MountainView")));
|
||||
|
||||
setenv(~"HOME", ~"");
|
||||
setenv("HOME", "");
|
||||
|
||||
setenv(~"USERPROFILE", ~"/home/MountainView");
|
||||
setenv("USERPROFILE", "/home/MountainView");
|
||||
assert_eq!(os::homedir(), Some(Path("/home/MountainView")));
|
||||
|
||||
setenv(~"HOME", ~"/home/MountainView");
|
||||
setenv(~"USERPROFILE", ~"/home/PaloAlto");
|
||||
setenv("HOME", "/home/MountainView");
|
||||
setenv("USERPROFILE", "/home/PaloAlto");
|
||||
assert_eq!(os::homedir(), Some(Path("/home/MountainView")));
|
||||
|
||||
oldhome.each(|s| {setenv(~"HOME", *s);true});
|
||||
olduserprofile.each(|s| {setenv(~"USERPROFILE", *s);true});
|
||||
oldhome.each(|s| { setenv("HOME", *s); true });
|
||||
olduserprofile.each(|s| { setenv("USERPROFILE", *s); true });
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -1646,7 +1646,7 @@ mod tests {
|
||||
fail!("%s doesn't exist", in.to_str());
|
||||
}
|
||||
assert!((rs));
|
||||
let rslt = run::run_program(~"diff", ~[in.to_str(), out.to_str()]);
|
||||
let rslt = run::run_program("diff", [in.to_str(), out.to_str()]);
|
||||
assert_eq!(rslt, 0);
|
||||
assert_eq!(out.get_mode(), in_mode);
|
||||
assert!((remove_file(&in)));
|
||||
|
||||
@ -988,10 +988,10 @@ mod tests {
|
||||
#[test]
|
||||
fn test_choose_weighted() {
|
||||
let mut r = rng();
|
||||
assert!(r.choose_weighted(~[
|
||||
assert!(r.choose_weighted([
|
||||
Weighted { weight: 1u, item: 42 },
|
||||
]) == 42);
|
||||
assert!(r.choose_weighted(~[
|
||||
assert!(r.choose_weighted([
|
||||
Weighted { weight: 0u, item: 42 },
|
||||
Weighted { weight: 1u, item: 43 },
|
||||
]) == 43);
|
||||
@ -1000,10 +1000,10 @@ mod tests {
|
||||
#[test]
|
||||
fn test_choose_weighted_option() {
|
||||
let mut r = rng();
|
||||
assert!(r.choose_weighted_option(~[
|
||||
assert!(r.choose_weighted_option([
|
||||
Weighted { weight: 1u, item: 42 },
|
||||
]) == Some(42));
|
||||
assert!(r.choose_weighted_option(~[
|
||||
assert!(r.choose_weighted_option([
|
||||
Weighted { weight: 0u, item: 42 },
|
||||
Weighted { weight: 1u, item: 43 },
|
||||
]) == Some(43));
|
||||
@ -1015,8 +1015,8 @@ mod tests {
|
||||
fn test_weighted_vec() {
|
||||
let mut r = rng();
|
||||
let empty: ~[int] = ~[];
|
||||
assert_eq!(r.weighted_vec(~[]), empty);
|
||||
assert!(r.weighted_vec(~[
|
||||
assert_eq!(r.weighted_vec([]), empty);
|
||||
assert!(r.weighted_vec([
|
||||
Weighted { weight: 0u, item: 3u },
|
||||
Weighted { weight: 1u, item: 2u },
|
||||
Weighted { weight: 2u, item: 1u },
|
||||
@ -1027,15 +1027,15 @@ mod tests {
|
||||
fn test_shuffle() {
|
||||
let mut r = rng();
|
||||
let empty: ~[int] = ~[];
|
||||
assert_eq!(r.shuffle(~[]), empty);
|
||||
assert_eq!(r.shuffle(~[1, 1, 1]), ~[1, 1, 1]);
|
||||
assert_eq!(r.shuffle([]), empty);
|
||||
assert_eq!(r.shuffle([1, 1, 1]), ~[1, 1, 1]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_task_rng() {
|
||||
let mut r = task_rng();
|
||||
r.gen::<int>();
|
||||
assert_eq!(r.shuffle(~[1, 1, 1]), ~[1, 1, 1]);
|
||||
assert_eq!(r.shuffle([1, 1, 1]), ~[1, 1, 1]);
|
||||
assert_eq!(r.gen_uint_range(0u, 1u), 0u);
|
||||
}
|
||||
|
||||
|
||||
@ -474,7 +474,7 @@ mod test {
|
||||
#[test]
|
||||
fn oneshot_single_thread_peek_open() {
|
||||
do run_in_newsched_task {
|
||||
let (port, chan) = oneshot::<int>();
|
||||
let (port, _) = oneshot::<int>();
|
||||
assert!(!port.peek());
|
||||
}
|
||||
}
|
||||
|
||||
@ -587,12 +587,10 @@ fn extend_sign(val: u64, nbytes: uint) -> i64 {
|
||||
|
||||
#[cfg(test)]
|
||||
mod test {
|
||||
use super::{ReaderUtil, ReaderByteConversions, WriterByteConversions};
|
||||
use u64;
|
||||
use i32;
|
||||
use super::ReaderUtil;
|
||||
use option::{Some, None};
|
||||
use cell::Cell;
|
||||
use rt::io::mem::{MemReader, MemWriter};
|
||||
use rt::io::mem::MemReader;
|
||||
use rt::io::mock::MockReader;
|
||||
use rt::io::{read_error, placeholder_error};
|
||||
|
||||
|
||||
@ -33,7 +33,7 @@ impl Local for Scheduler {
|
||||
}
|
||||
|
||||
impl Local for Task {
|
||||
fn put(value: ~Task) { abort!("unimpl") }
|
||||
fn put(_value: ~Task) { abort!("unimpl") }
|
||||
fn take() -> ~Task { abort!("unimpl") }
|
||||
fn exists() -> bool { abort!("unimpl") }
|
||||
fn borrow(f: &fn(&mut Task)) {
|
||||
@ -71,10 +71,10 @@ impl Local for Task {
|
||||
|
||||
// XXX: This formulation won't work once ~IoFactoryObject is a real trait pointer
|
||||
impl Local for IoFactoryObject {
|
||||
fn put(value: ~IoFactoryObject) { abort!("unimpl") }
|
||||
fn put(_value: ~IoFactoryObject) { abort!("unimpl") }
|
||||
fn take() -> ~IoFactoryObject { abort!("unimpl") }
|
||||
fn exists() -> bool { abort!("unimpl") }
|
||||
fn borrow(f: &fn(&mut IoFactoryObject)) { abort!("unimpl") }
|
||||
fn borrow(_f: &fn(&mut IoFactoryObject)) { abort!("unimpl") }
|
||||
unsafe fn unsafe_borrow() -> *mut IoFactoryObject {
|
||||
let sched = Local::unsafe_borrow::<Scheduler>();
|
||||
let io: *mut IoFactoryObject = (*sched).event_loop.io().unwrap();
|
||||
@ -115,4 +115,4 @@ mod test {
|
||||
}
|
||||
let _scheduler: ~Scheduler = Local::take();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -20,7 +20,6 @@ use super::context::Context;
|
||||
use super::task::Task;
|
||||
use rt::local_ptr;
|
||||
use rt::local::Local;
|
||||
use rt::rtio::IoFactoryObject;
|
||||
|
||||
/// The Scheduler is responsible for coordinating execution of Coroutines
|
||||
/// on a single thread. When the scheduler is running it is owned by
|
||||
|
||||
@ -16,7 +16,6 @@
|
||||
use prelude::*;
|
||||
use libc::{c_void, uintptr_t};
|
||||
use cast::transmute;
|
||||
use super::sched::Scheduler;
|
||||
use rt::local::Local;
|
||||
use super::local_heap::LocalHeap;
|
||||
use rt::logging::StdErrLogger;
|
||||
|
||||
@ -2794,31 +2794,31 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_len() {
|
||||
assert_eq!(len(~""), 0u);
|
||||
assert_eq!(len(~"hello world"), 11u);
|
||||
assert_eq!(len(~"\x63"), 1u);
|
||||
assert_eq!(len(~"\xa2"), 2u);
|
||||
assert_eq!(len(~"\u03c0"), 2u);
|
||||
assert_eq!(len(~"\u2620"), 3u);
|
||||
assert_eq!(len(~"\U0001d11e"), 4u);
|
||||
assert_eq!(len(""), 0u);
|
||||
assert_eq!(len("hello world"), 11u);
|
||||
assert_eq!(len("\x63"), 1u);
|
||||
assert_eq!(len("\xa2"), 2u);
|
||||
assert_eq!(len("\u03c0"), 2u);
|
||||
assert_eq!(len("\u2620"), 3u);
|
||||
assert_eq!(len("\U0001d11e"), 4u);
|
||||
|
||||
assert_eq!(char_len(~""), 0u);
|
||||
assert_eq!(char_len(~"hello world"), 11u);
|
||||
assert_eq!(char_len(~"\x63"), 1u);
|
||||
assert_eq!(char_len(~"\xa2"), 1u);
|
||||
assert_eq!(char_len(~"\u03c0"), 1u);
|
||||
assert_eq!(char_len(~"\u2620"), 1u);
|
||||
assert_eq!(char_len(~"\U0001d11e"), 1u);
|
||||
assert_eq!(char_len(~"ประเทศไทย中华Việt Nam"), 19u);
|
||||
assert_eq!(char_len(""), 0u);
|
||||
assert_eq!(char_len("hello world"), 11u);
|
||||
assert_eq!(char_len("\x63"), 1u);
|
||||
assert_eq!(char_len("\xa2"), 1u);
|
||||
assert_eq!(char_len("\u03c0"), 1u);
|
||||
assert_eq!(char_len("\u2620"), 1u);
|
||||
assert_eq!(char_len("\U0001d11e"), 1u);
|
||||
assert_eq!(char_len("ประเทศไทย中华Việt Nam"), 19u);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_rfind_char() {
|
||||
assert_eq!(rfind_char(~"hello", 'l'), Some(3u));
|
||||
assert_eq!(rfind_char(~"hello", 'o'), Some(4u));
|
||||
assert_eq!(rfind_char(~"hello", 'h'), Some(0u));
|
||||
assert!(rfind_char(~"hello", 'z').is_none());
|
||||
assert_eq!(rfind_char(~"ประเทศไทย中华Việt Nam", '华'), Some(30u));
|
||||
assert_eq!(rfind_char("hello", 'l'), Some(3u));
|
||||
assert_eq!(rfind_char("hello", 'o'), Some(4u));
|
||||
assert_eq!(rfind_char("hello", 'h'), Some(0u));
|
||||
assert!(rfind_char("hello", 'z').is_none());
|
||||
assert_eq!(rfind_char("ประเทศไทย中华Việt Nam", '华'), Some(30u));
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -2848,66 +2848,66 @@ mod tests {
|
||||
#[test]
|
||||
fn test_split_char() {
|
||||
fn t(s: &str, c: char, u: &[~str]) {
|
||||
debug!(~"split_byte: " + s);
|
||||
debug!("split_byte: %?", s);
|
||||
let mut v = ~[];
|
||||
for each_split_char(s, c) |s| { v.push(s.to_owned()) }
|
||||
debug!("split_byte to: %?", v);
|
||||
assert!(vec::all2(v, u, |a,b| a == b));
|
||||
}
|
||||
t(~"abc.hello.there", '.', ~[~"abc", ~"hello", ~"there"]);
|
||||
t(~".hello.there", '.', ~[~"", ~"hello", ~"there"]);
|
||||
t(~"...hello.there.", '.', ~[~"", ~"", ~"", ~"hello", ~"there", ~""]);
|
||||
t("abc.hello.there", '.', [~"abc", ~"hello", ~"there"]);
|
||||
t(".hello.there", '.', [~"", ~"hello", ~"there"]);
|
||||
t("...hello.there.", '.', [~"", ~"", ~"", ~"hello", ~"there", ~""]);
|
||||
|
||||
t(~"", 'z', ~[~""]);
|
||||
t(~"z", 'z', ~[~"",~""]);
|
||||
t(~"ok", 'z', ~[~"ok"]);
|
||||
t("", 'z', [~""]);
|
||||
t("z", 'z', [~"",~""]);
|
||||
t("ok", 'z', [~"ok"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_split_char_2() {
|
||||
fn t(s: &str, c: char, u: &[~str]) {
|
||||
debug!(~"split_byte: " + s);
|
||||
debug!("split_byte: %?", s);
|
||||
let mut v = ~[];
|
||||
for each_split_char(s, c) |s| { v.push(s.to_owned()) }
|
||||
debug!("split_byte to: %?", v);
|
||||
assert!(vec::all2(v, u, |a,b| a == b));
|
||||
}
|
||||
let data = ~"ประเทศไทย中华Việt Nam";
|
||||
t(data, 'V', ~[~"ประเทศไทย中华", ~"iệt Nam"]);
|
||||
t(data, 'ท', ~[~"ประเ", ~"ศไ", ~"ย中华Việt Nam"]);
|
||||
let data = "ประเทศไทย中华Việt Nam";
|
||||
t(data, 'V', [~"ประเทศไทย中华", ~"iệt Nam"]);
|
||||
t(data, 'ท', [~"ประเ", ~"ศไ", ~"ย中华Việt Nam"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_splitn_char() {
|
||||
fn t(s: &str, c: char, n: uint, u: &[~str]) {
|
||||
debug!(~"splitn_byte: " + s);
|
||||
debug!("splitn_byte: %?", s);
|
||||
let mut v = ~[];
|
||||
for each_splitn_char(s, c, n) |s| { v.push(s.to_owned()) }
|
||||
debug!("split_byte to: %?", v);
|
||||
debug!("comparing vs. %?", u);
|
||||
assert!(vec::all2(v, u, |a,b| a == b));
|
||||
}
|
||||
t(~"abc.hello.there", '.', 0u, ~[~"abc.hello.there"]);
|
||||
t(~"abc.hello.there", '.', 1u, ~[~"abc", ~"hello.there"]);
|
||||
t(~"abc.hello.there", '.', 2u, ~[~"abc", ~"hello", ~"there"]);
|
||||
t(~"abc.hello.there", '.', 3u, ~[~"abc", ~"hello", ~"there"]);
|
||||
t(~".hello.there", '.', 0u, ~[~".hello.there"]);
|
||||
t(~".hello.there", '.', 1u, ~[~"", ~"hello.there"]);
|
||||
t(~"...hello.there.", '.', 3u, ~[~"", ~"", ~"", ~"hello.there."]);
|
||||
t(~"...hello.there.", '.', 5u, ~[~"", ~"", ~"", ~"hello", ~"there", ~""]);
|
||||
t("abc.hello.there", '.', 0u, [~"abc.hello.there"]);
|
||||
t("abc.hello.there", '.', 1u, [~"abc", ~"hello.there"]);
|
||||
t("abc.hello.there", '.', 2u, [~"abc", ~"hello", ~"there"]);
|
||||
t("abc.hello.there", '.', 3u, [~"abc", ~"hello", ~"there"]);
|
||||
t(".hello.there", '.', 0u, [~".hello.there"]);
|
||||
t(".hello.there", '.', 1u, [~"", ~"hello.there"]);
|
||||
t("...hello.there.", '.', 3u, [~"", ~"", ~"", ~"hello.there."]);
|
||||
t("...hello.there.", '.', 5u, [~"", ~"", ~"", ~"hello", ~"there", ~""]);
|
||||
|
||||
t(~"", 'z', 5u, ~[~""]);
|
||||
t(~"z", 'z', 5u, ~[~"",~""]);
|
||||
t(~"ok", 'z', 5u, ~[~"ok"]);
|
||||
t(~"z", 'z', 0u, ~[~"z"]);
|
||||
t(~"w.x.y", '.', 0u, ~[~"w.x.y"]);
|
||||
t(~"w.x.y", '.', 1u, ~[~"w",~"x.y"]);
|
||||
t("", 'z', 5u, [~""]);
|
||||
t("z", 'z', 5u, [~"",~""]);
|
||||
t("ok", 'z', 5u, [~"ok"]);
|
||||
t("z", 'z', 0u, [~"z"]);
|
||||
t("w.x.y", '.', 0u, [~"w.x.y"]);
|
||||
t("w.x.y", '.', 1u, [~"w",~"x.y"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_splitn_char_2 () {
|
||||
fn test_splitn_char_2() {
|
||||
fn t(s: &str, c: char, n: uint, u: &[~str]) {
|
||||
debug!(~"splitn_byte: " + s);
|
||||
debug!("splitn_byte: %?", s);
|
||||
let mut v = ~[];
|
||||
for each_splitn_char(s, c, n) |s| { v.push(s.to_owned()) }
|
||||
debug!("split_byte to: %?", v);
|
||||
@ -2915,60 +2915,59 @@ mod tests {
|
||||
assert!(vec::all2(v, u, |a,b| a == b));
|
||||
}
|
||||
|
||||
t(~"ประเทศไทย中华Việt Nam", '华', 1u, ~[~"ประเทศไทย中", ~"Việt Nam"]);
|
||||
t(~"zzXXXzYYYzWWWz", 'z', 3u, ~[~"", ~"", ~"XXX", ~"YYYzWWWz"]);
|
||||
t(~"z", 'z', 5u, ~[~"",~""]);
|
||||
t(~"", 'z', 5u, ~[~""]);
|
||||
t(~"ok", 'z', 5u, ~[~"ok"]);
|
||||
t("ประเทศไทย中华Việt Nam", '华', 1u, [~"ประเทศไทย中", ~"Việt Nam"]);
|
||||
t("zzXXXzYYYzWWWz", 'z', 3u, [~"", ~"", ~"XXX", ~"YYYzWWWz"]);
|
||||
t("z", 'z', 5u, [~"",~""]);
|
||||
t("", 'z', 5u, [~""]);
|
||||
t("ok", 'z', 5u, [~"ok"]);
|
||||
}
|
||||
|
||||
|
||||
#[test]
|
||||
fn test_splitn_char_3() {
|
||||
fn t(s: &str, c: char, n: uint, u: &[~str]) {
|
||||
debug!(~"splitn_byte: " + s);
|
||||
debug!("splitn_byte: %?", s);
|
||||
let mut v = ~[];
|
||||
for each_splitn_char(s, c, n) |s| { v.push(s.to_owned()) }
|
||||
debug!("split_byte to: %?", v);
|
||||
debug!("comparing vs. %?", u);
|
||||
assert!(vec::all2(v, u, |a,b| a == b));
|
||||
}
|
||||
let data = ~"ประเทศไทย中华Việt Nam";
|
||||
t(data, 'V', 1u, ~[~"ประเทศไทย中华", ~"iệt Nam"]);
|
||||
t(data, 'ท', 1u, ~[~"ประเ", ~"ศไทย中华Việt Nam"]);
|
||||
let data = "ประเทศไทย中华Việt Nam";
|
||||
t(data, 'V', 1u, [~"ประเทศไทย中华", ~"iệt Nam"]);
|
||||
t(data, 'ท', 1u, [~"ประเ", ~"ศไทย中华Việt Nam"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_split_char_no_trailing() {
|
||||
fn t(s: &str, c: char, u: &[~str]) {
|
||||
debug!(~"split_byte: " + s);
|
||||
debug!("split_byte: %?", s);
|
||||
let mut v = ~[];
|
||||
for each_split_char_no_trailing(s, c) |s| { v.push(s.to_owned()) }
|
||||
debug!("split_byte to: %?", v);
|
||||
assert!(vec::all2(v, u, |a,b| a == b));
|
||||
}
|
||||
t(~"abc.hello.there", '.', ~[~"abc", ~"hello", ~"there"]);
|
||||
t(~".hello.there", '.', ~[~"", ~"hello", ~"there"]);
|
||||
t(~"...hello.there.", '.', ~[~"", ~"", ~"", ~"hello", ~"there"]);
|
||||
t("abc.hello.there", '.', [~"abc", ~"hello", ~"there"]);
|
||||
t(".hello.there", '.', [~"", ~"hello", ~"there"]);
|
||||
t("...hello.there.", '.', [~"", ~"", ~"", ~"hello", ~"there"]);
|
||||
|
||||
t(~"...hello.there.", '.', ~[~"", ~"", ~"", ~"hello", ~"there"]);
|
||||
t(~"", 'z', ~[]);
|
||||
t(~"z", 'z', ~[~""]);
|
||||
t(~"ok", 'z', ~[~"ok"]);
|
||||
t("...hello.there.", '.', [~"", ~"", ~"", ~"hello", ~"there"]);
|
||||
t("", 'z', []);
|
||||
t("z", 'z', [~""]);
|
||||
t("ok", 'z', [~"ok"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_split_char_no_trailing_2() {
|
||||
fn t(s: &str, c: char, u: &[~str]) {
|
||||
debug!(~"split_byte: " + s);
|
||||
debug!("split_byte: %?", s);
|
||||
let mut v = ~[];
|
||||
for each_split_char_no_trailing(s, c) |s| { v.push(s.to_owned()) }
|
||||
debug!("split_byte to: %?", v);
|
||||
assert!(vec::all2(v, u, |a,b| a == b));
|
||||
}
|
||||
let data = ~"ประเทศไทย中华Việt Nam";
|
||||
t(data, 'V', ~[~"ประเทศไทย中华", ~"iệt Nam"]);
|
||||
t(data, 'ท', ~[~"ประเ", ~"ศไ", ~"ย中华Việt Nam"]);
|
||||
let data = "ประเทศไทย中华Việt Nam";
|
||||
t(data, 'V', [~"ประเทศไทย中华", ~"iệt Nam"]);
|
||||
t(data, 'ท', [~"ประเ", ~"ศไ", ~"ย中华Việt Nam"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -2978,20 +2977,20 @@ mod tests {
|
||||
for each_split_str(s, sep) |s| { v.push(s.to_owned()) }
|
||||
assert!(vec::all2(v, u, |a,b| a == b));
|
||||
}
|
||||
t(~"--1233345--", ~"12345", ~[~"--1233345--"]);
|
||||
t(~"abc::hello::there", ~"::", ~[~"abc", ~"hello", ~"there"]);
|
||||
t(~"::hello::there", ~"::", ~[~"", ~"hello", ~"there"]);
|
||||
t(~"hello::there::", ~"::", ~[~"hello", ~"there", ~""]);
|
||||
t(~"::hello::there::", ~"::", ~[~"", ~"hello", ~"there", ~""]);
|
||||
t(~"ประเทศไทย中华Việt Nam", ~"中华", ~[~"ประเทศไทย", ~"Việt Nam"]);
|
||||
t(~"zzXXXzzYYYzz", ~"zz", ~[~"", ~"XXX", ~"YYY", ~""]);
|
||||
t(~"zzXXXzYYYz", ~"XXX", ~[~"zz", ~"zYYYz"]);
|
||||
t(~".XXX.YYY.", ~".", ~[~"", ~"XXX", ~"YYY", ~""]);
|
||||
t(~"", ~".", ~[~""]);
|
||||
t(~"zz", ~"zz", ~[~"",~""]);
|
||||
t(~"ok", ~"z", ~[~"ok"]);
|
||||
t(~"zzz", ~"zz", ~[~"",~"z"]);
|
||||
t(~"zzzzz", ~"zz", ~[~"",~"",~"z"]);
|
||||
t("--1233345--", "12345", [~"--1233345--"]);
|
||||
t("abc::hello::there", "::", [~"abc", ~"hello", ~"there"]);
|
||||
t("::hello::there", "::", [~"", ~"hello", ~"there"]);
|
||||
t("hello::there::", "::", [~"hello", ~"there", ~""]);
|
||||
t("::hello::there::", "::", [~"", ~"hello", ~"there", ~""]);
|
||||
t("ประเทศไทย中华Việt Nam", "中华", [~"ประเทศไทย", ~"Việt Nam"]);
|
||||
t("zzXXXzzYYYzz", "zz", [~"", ~"XXX", ~"YYY", ~""]);
|
||||
t("zzXXXzYYYz", "XXX", [~"zz", ~"zYYYz"]);
|
||||
t(".XXX.YYY.", ".", [~"", ~"XXX", ~"YYY", ~""]);
|
||||
t("", ".", [~""]);
|
||||
t("zz", "zz", [~"",~""]);
|
||||
t("ok", "z", [~"ok"]);
|
||||
t("zzz", "zz", [~"",~"z"]);
|
||||
t("zzzzz", "zz", [~"",~"",~"z"]);
|
||||
}
|
||||
|
||||
|
||||
@ -3003,12 +3002,12 @@ mod tests {
|
||||
assert!(vec::all2(v, u, |a,b| a == b));
|
||||
}
|
||||
|
||||
t(~"ประเทศไทย中华Việt Nam", |cc| cc == '华', ~[~"ประเทศไทย中", ~"Việt Nam"]);
|
||||
t(~"zzXXXzYYYz", char::is_lowercase, ~[~"", ~"", ~"XXX", ~"YYY", ~""]);
|
||||
t(~"zzXXXzYYYz", char::is_uppercase, ~[~"zz", ~"", ~"", ~"z", ~"", ~"", ~"z"]);
|
||||
t(~"z", |cc| cc == 'z', ~[~"",~""]);
|
||||
t(~"", |cc| cc == 'z', ~[~""]);
|
||||
t(~"ok", |cc| cc == 'z', ~[~"ok"]);
|
||||
t("ประเทศไทย中华Việt Nam", |cc| cc == '华', [~"ประเทศไทย中", ~"Việt Nam"]);
|
||||
t("zzXXXzYYYz", char::is_lowercase, [~"", ~"", ~"XXX", ~"YYY", ~""]);
|
||||
t("zzXXXzYYYz", char::is_uppercase, [~"zz", ~"", ~"", ~"z", ~"", ~"", ~"z"]);
|
||||
t("z", |cc| cc == 'z', [~"",~""]);
|
||||
t("", |cc| cc == 'z', [~""]);
|
||||
t("ok", |cc| cc == 'z', [~"ok"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -3019,18 +3018,18 @@ mod tests {
|
||||
assert!(vec::all2(v, u, |a,b| a == b));
|
||||
}
|
||||
|
||||
t(~"ประเทศไทย中华Việt Nam", |cc| cc == '华', ~[~"ประเทศไทย中", ~"Việt Nam"]);
|
||||
t(~"zzXXXzYYYz", char::is_lowercase, ~[~"", ~"", ~"XXX", ~"YYY"]);
|
||||
t(~"zzXXXzYYYz", char::is_uppercase, ~[~"zz", ~"", ~"", ~"z", ~"", ~"", ~"z"]);
|
||||
t(~"z", |cc| cc == 'z', ~[~""]);
|
||||
t(~"", |cc| cc == 'z', ~[]);
|
||||
t(~"ok", |cc| cc == 'z', ~[~"ok"]);
|
||||
t("ประเทศไทย中华Việt Nam", |cc| cc == '华', [~"ประเทศไทย中", ~"Việt Nam"]);
|
||||
t("zzXXXzYYYz", char::is_lowercase, [~"", ~"", ~"XXX", ~"YYY"]);
|
||||
t("zzXXXzYYYz", char::is_uppercase, [~"zz", ~"", ~"", ~"z", ~"", ~"", ~"z"]);
|
||||
t("z", |cc| cc == 'z', [~""]);
|
||||
t("", |cc| cc == 'z', []);
|
||||
t("ok", |cc| cc == 'z', [~"ok"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_lines() {
|
||||
let lf = ~"\nMary had a little lamb\nLittle lamb\n";
|
||||
let crlf = ~"\r\nMary had a little lamb\r\nLittle lamb\r\n";
|
||||
let lf = "\nMary had a little lamb\nLittle lamb\n";
|
||||
let crlf = "\r\nMary had a little lamb\r\nLittle lamb\r\n";
|
||||
|
||||
fn t(s: &str, f: &fn(&str, &fn(&str) -> bool) -> bool, u: &[~str]) {
|
||||
let mut v = ~[];
|
||||
@ -3038,30 +3037,30 @@ mod tests {
|
||||
assert!(vec::all2(v, u, |a,b| a == b));
|
||||
}
|
||||
|
||||
t(lf, each_line ,~[~"", ~"Mary had a little lamb", ~"Little lamb"]);
|
||||
t(lf, each_line_any, ~[~"", ~"Mary had a little lamb", ~"Little lamb"]);
|
||||
t(crlf, each_line, ~[~"\r", ~"Mary had a little lamb\r", ~"Little lamb\r"]);
|
||||
t(crlf, each_line_any, ~[~"", ~"Mary had a little lamb", ~"Little lamb"]);
|
||||
t(~"", each_line, ~[]);
|
||||
t(~"", each_line_any, ~[]);
|
||||
t(~"\n", each_line, ~[~""]);
|
||||
t(~"\n", each_line_any, ~[~""]);
|
||||
t(~"banana", each_line, ~[~"banana"]);
|
||||
t(~"banana", each_line_any, ~[~"banana"]);
|
||||
t(lf, each_line, [~"", ~"Mary had a little lamb", ~"Little lamb"]);
|
||||
t(lf, each_line_any, [~"", ~"Mary had a little lamb", ~"Little lamb"]);
|
||||
t(crlf, each_line, [~"\r", ~"Mary had a little lamb\r", ~"Little lamb\r"]);
|
||||
t(crlf, each_line_any, [~"", ~"Mary had a little lamb", ~"Little lamb"]);
|
||||
t("", each_line, []);
|
||||
t("", each_line_any, []);
|
||||
t("\n", each_line, [~""]);
|
||||
t("\n", each_line_any, [~""]);
|
||||
t("banana", each_line, [~"banana"]);
|
||||
t("banana", each_line_any, [~"banana"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_words () {
|
||||
fn test_words() {
|
||||
fn t(s: &str, f: &fn(&str, &fn(&str) -> bool) -> bool, u: &[~str]) {
|
||||
let mut v = ~[];
|
||||
for f(s) |s| { v.push(s.to_owned()) }
|
||||
assert!(vec::all2(v, u, |a,b| a == b));
|
||||
}
|
||||
let data = ~"\nMary had a little lamb\nLittle lamb\n";
|
||||
let data = "\nMary had a little lamb\nLittle lamb\n";
|
||||
|
||||
t(data, each_word, ~[~"Mary",~"had",~"a",~"little",~"lamb",~"Little",~"lamb"]);
|
||||
t(~"ok", each_word, ~[~"ok"]);
|
||||
t(~"", each_word, ~[]);
|
||||
t(data, each_word, [~"Mary",~"had",~"a",~"little",~"lamb",~"Little",~"lamb"]);
|
||||
t("ok", each_word, [~"ok"]);
|
||||
t("", each_word, []);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -3071,53 +3070,53 @@ mod tests {
|
||||
for each_split_within(s, i) |s| { v.push(s.to_owned()) }
|
||||
assert!(vec::all2(v, u, |a,b| a == b));
|
||||
}
|
||||
t(~"", 0, ~[]);
|
||||
t(~"", 15, ~[]);
|
||||
t(~"hello", 15, ~[~"hello"]);
|
||||
t(~"\nMary had a little lamb\nLittle lamb\n", 15,
|
||||
~[~"Mary had a", ~"little lamb", ~"Little lamb"]);
|
||||
t("", 0, []);
|
||||
t("", 15, []);
|
||||
t("hello", 15, [~"hello"]);
|
||||
t("\nMary had a little lamb\nLittle lamb\n", 15,
|
||||
[~"Mary had a", ~"little lamb", ~"Little lamb"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_find_str() {
|
||||
// byte positions
|
||||
assert!(find_str(~"banana", ~"apple pie").is_none());
|
||||
assert_eq!(find_str(~"", ~""), Some(0u));
|
||||
assert!(find_str("banana", "apple pie").is_none());
|
||||
assert_eq!(find_str("", ""), Some(0u));
|
||||
|
||||
let data = ~"ประเทศไทย中华Việt Nam";
|
||||
assert_eq!(find_str(data, ~""), Some(0u));
|
||||
assert_eq!(find_str(data, ~"ประเ"), Some( 0u));
|
||||
assert_eq!(find_str(data, ~"ะเ"), Some( 6u));
|
||||
assert_eq!(find_str(data, ~"中华"), Some(27u));
|
||||
assert!(find_str(data, ~"ไท华").is_none());
|
||||
let data = "ประเทศไทย中华Việt Nam";
|
||||
assert_eq!(find_str(data, ""), Some(0u));
|
||||
assert_eq!(find_str(data, "ประเ"), Some( 0u));
|
||||
assert_eq!(find_str(data, "ะเ"), Some( 6u));
|
||||
assert_eq!(find_str(data, "中华"), Some(27u));
|
||||
assert!(find_str(data, "ไท华").is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_find_str_between() {
|
||||
// byte positions
|
||||
assert_eq!(find_str_between(~"", ~"", 0u, 0u), Some(0u));
|
||||
assert_eq!(find_str_between("", "", 0u, 0u), Some(0u));
|
||||
|
||||
let data = ~"abcabc";
|
||||
assert_eq!(find_str_between(data, ~"ab", 0u, 6u), Some(0u));
|
||||
assert_eq!(find_str_between(data, ~"ab", 2u, 6u), Some(3u));
|
||||
assert!(find_str_between(data, ~"ab", 2u, 4u).is_none());
|
||||
let data = "abcabc";
|
||||
assert_eq!(find_str_between(data, "ab", 0u, 6u), Some(0u));
|
||||
assert_eq!(find_str_between(data, "ab", 2u, 6u), Some(3u));
|
||||
assert!(find_str_between(data, "ab", 2u, 4u).is_none());
|
||||
|
||||
let mut data = ~"ประเทศไทย中华Việt Nam";
|
||||
data = data + data;
|
||||
assert_eq!(find_str_between(data, ~"", 0u, 43u), Some(0u));
|
||||
assert_eq!(find_str_between(data, ~"", 6u, 43u), Some(6u));
|
||||
assert_eq!(find_str_between(data, "", 0u, 43u), Some(0u));
|
||||
assert_eq!(find_str_between(data, "", 6u, 43u), Some(6u));
|
||||
|
||||
assert_eq!(find_str_between(data, ~"ประ", 0u, 43u), Some( 0u));
|
||||
assert_eq!(find_str_between(data, ~"ทศไ", 0u, 43u), Some(12u));
|
||||
assert_eq!(find_str_between(data, ~"ย中", 0u, 43u), Some(24u));
|
||||
assert_eq!(find_str_between(data, ~"iệt", 0u, 43u), Some(34u));
|
||||
assert_eq!(find_str_between(data, ~"Nam", 0u, 43u), Some(40u));
|
||||
assert_eq!(find_str_between(data, "ประ", 0u, 43u), Some( 0u));
|
||||
assert_eq!(find_str_between(data, "ทศไ", 0u, 43u), Some(12u));
|
||||
assert_eq!(find_str_between(data, "ย中", 0u, 43u), Some(24u));
|
||||
assert_eq!(find_str_between(data, "iệt", 0u, 43u), Some(34u));
|
||||
assert_eq!(find_str_between(data, "Nam", 0u, 43u), Some(40u));
|
||||
|
||||
assert_eq!(find_str_between(data, ~"ประ", 43u, 86u), Some(43u));
|
||||
assert_eq!(find_str_between(data, ~"ทศไ", 43u, 86u), Some(55u));
|
||||
assert_eq!(find_str_between(data, ~"ย中", 43u, 86u), Some(67u));
|
||||
assert_eq!(find_str_between(data, ~"iệt", 43u, 86u), Some(77u));
|
||||
assert_eq!(find_str_between(data, ~"Nam", 43u, 86u), Some(83u));
|
||||
assert_eq!(find_str_between(data, "ประ", 43u, 86u), Some(43u));
|
||||
assert_eq!(find_str_between(data, "ทศไ", 43u, 86u), Some(55u));
|
||||
assert_eq!(find_str_between(data, "ย中", 43u, 86u), Some(67u));
|
||||
assert_eq!(find_str_between(data, "iệt", 43u, 86u), Some(77u));
|
||||
assert_eq!(find_str_between(data, "Nam", 43u, 86u), Some(83u));
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -3135,10 +3134,10 @@ mod tests {
|
||||
fn t(v: &[~str], s: &str) {
|
||||
assert_eq!(concat(v), s.to_str());
|
||||
}
|
||||
t(~[~"you", ~"know", ~"I'm", ~"no", ~"good"], ~"youknowI'mnogood");
|
||||
let v: ~[~str] = ~[];
|
||||
t(v, ~"");
|
||||
t(~[~"hi"], ~"hi");
|
||||
t([~"you", ~"know", ~"I'm", ~"no", ~"good"], "youknowI'mnogood");
|
||||
let v: &[~str] = [];
|
||||
t(v, "");
|
||||
t([~"hi"], "hi");
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -3146,11 +3145,11 @@ mod tests {
|
||||
fn t(v: &[~str], sep: &str, s: &str) {
|
||||
assert_eq!(connect(v, sep), s.to_str());
|
||||
}
|
||||
t(~[~"you", ~"know", ~"I'm", ~"no", ~"good"],
|
||||
~" ", ~"you know I'm no good");
|
||||
let v: ~[~str] = ~[];
|
||||
t(v, ~" ", ~"");
|
||||
t(~[~"hi"], ~" ", ~"hi");
|
||||
t([~"you", ~"know", ~"I'm", ~"no", ~"good"],
|
||||
" ", "you know I'm no good");
|
||||
let v: &[~str] = ~[];
|
||||
t(v, " ", "");
|
||||
t([~"hi"], " ", "hi");
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -3166,11 +3165,11 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_repeat() {
|
||||
assert_eq!(repeat(~"x", 4), ~"xxxx");
|
||||
assert_eq!(repeat(~"hi", 4), ~"hihihihi");
|
||||
assert_eq!(repeat(~"ไท华", 3), ~"ไท华ไท华ไท华");
|
||||
assert_eq!(repeat(~"", 4), ~"");
|
||||
assert_eq!(repeat(~"hi", 0), ~"");
|
||||
assert_eq!(repeat("x", 4), ~"xxxx");
|
||||
assert_eq!(repeat("hi", 4), ~"hihihihi");
|
||||
assert_eq!(repeat("ไท华", 3), ~"ไท华ไท华ไท华");
|
||||
assert_eq!(repeat("", 4), ~"");
|
||||
assert_eq!(repeat("hi", 0), ~"");
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -3197,38 +3196,38 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_starts_with() {
|
||||
assert!((starts_with(~"", ~"")));
|
||||
assert!((starts_with(~"abc", ~"")));
|
||||
assert!((starts_with(~"abc", ~"a")));
|
||||
assert!((!starts_with(~"a", ~"abc")));
|
||||
assert!((!starts_with(~"", ~"abc")));
|
||||
assert!((starts_with("", "")));
|
||||
assert!((starts_with("abc", "")));
|
||||
assert!((starts_with("abc", "a")));
|
||||
assert!((!starts_with("a", "abc")));
|
||||
assert!((!starts_with("", "abc")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ends_with() {
|
||||
assert!((ends_with(~"", ~"")));
|
||||
assert!((ends_with(~"abc", ~"")));
|
||||
assert!((ends_with(~"abc", ~"c")));
|
||||
assert!((!ends_with(~"a", ~"abc")));
|
||||
assert!((!ends_with(~"", ~"abc")));
|
||||
assert!((ends_with("", "")));
|
||||
assert!((ends_with("abc", "")));
|
||||
assert!((ends_with("abc", "c")));
|
||||
assert!((!ends_with("a", "abc")));
|
||||
assert!((!ends_with("", "abc")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_is_empty() {
|
||||
assert!((is_empty(~"")));
|
||||
assert!((!is_empty(~"a")));
|
||||
assert!((is_empty("")));
|
||||
assert!((!is_empty("a")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_replace() {
|
||||
let a = ~"a";
|
||||
assert_eq!(replace(~"", a, ~"b"), ~"");
|
||||
assert_eq!(replace(~"a", a, ~"b"), ~"b");
|
||||
assert_eq!(replace(~"ab", a, ~"b"), ~"bb");
|
||||
let test = ~"test";
|
||||
assert!(replace(~" test test ", test, ~"toast") ==
|
||||
let a = "a";
|
||||
assert_eq!(replace("", a, "b"), ~"");
|
||||
assert_eq!(replace("a", a, "b"), ~"b");
|
||||
assert_eq!(replace("ab", a, "b"), ~"bb");
|
||||
let test = "test";
|
||||
assert!(replace(" test test ", test, "toast") ==
|
||||
~" toast toast ");
|
||||
assert_eq!(replace(~" test test ", test, ~""), ~" ");
|
||||
assert_eq!(replace(" test test ", test, ""), ~" ");
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -3338,32 +3337,26 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_trim_left_chars() {
|
||||
assert!(trim_left_chars(" *** foo *** ", ~[]) ==
|
||||
" *** foo *** ");
|
||||
assert!(trim_left_chars(" *** foo *** ", ~['*', ' ']) ==
|
||||
"foo *** ");
|
||||
assert_eq!(trim_left_chars(" *** *** ", ~['*', ' ']), "");
|
||||
assert!(trim_left_chars("foo *** ", ~['*', ' ']) ==
|
||||
"foo *** ");
|
||||
assert!(trim_left_chars(" *** foo *** ", []) == " *** foo *** ");
|
||||
assert!(trim_left_chars(" *** foo *** ", ['*', ' ']) == "foo *** ");
|
||||
assert_eq!(trim_left_chars(" *** *** ", ['*', ' ']), "");
|
||||
assert!(trim_left_chars("foo *** ", ['*', ' ']) == "foo *** ");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_trim_right_chars() {
|
||||
assert!(trim_right_chars(" *** foo *** ", ~[]) ==
|
||||
" *** foo *** ");
|
||||
assert!(trim_right_chars(" *** foo *** ", ~['*', ' ']) ==
|
||||
" *** foo");
|
||||
assert_eq!(trim_right_chars(" *** *** ", ~['*', ' ']), "");
|
||||
assert!(trim_right_chars(" *** foo", ~['*', ' ']) ==
|
||||
" *** foo");
|
||||
assert!(trim_right_chars(" *** foo *** ", []) == " *** foo *** ");
|
||||
assert!(trim_right_chars(" *** foo *** ", ['*', ' ']) == " *** foo");
|
||||
assert_eq!(trim_right_chars(" *** *** ", ['*', ' ']), "");
|
||||
assert!(trim_right_chars(" *** foo", ['*', ' ']) == " *** foo");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_trim_chars() {
|
||||
assert_eq!(trim_chars(" *** foo *** ", ~[]), " *** foo *** ");
|
||||
assert_eq!(trim_chars(" *** foo *** ", ~['*', ' ']), "foo");
|
||||
assert_eq!(trim_chars(" *** *** ", ~['*', ' ']), "");
|
||||
assert_eq!(trim_chars("foo", ~['*', ' ']), "foo");
|
||||
assert_eq!(trim_chars(" *** foo *** ", []), " *** foo *** ");
|
||||
assert_eq!(trim_chars(" *** foo *** ", ['*', ' ']), "foo");
|
||||
assert_eq!(trim_chars(" *** *** ", ['*', ' ']), "");
|
||||
assert_eq!(trim_chars("foo", ['*', ' ']), "foo");
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -3398,11 +3391,11 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_is_whitespace() {
|
||||
assert!((is_whitespace(~"")));
|
||||
assert!((is_whitespace(~" ")));
|
||||
assert!((is_whitespace(~"\u2009"))); // Thin space
|
||||
assert!((is_whitespace(~" \n\t ")));
|
||||
assert!((!is_whitespace(~" _ ")));
|
||||
assert!(is_whitespace(""));
|
||||
assert!(is_whitespace(" "));
|
||||
assert!(is_whitespace("\u2009")); // Thin space
|
||||
assert!(is_whitespace(" \n\t "));
|
||||
assert!(!is_whitespace(" _ "));
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -3543,7 +3536,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_as_buf() {
|
||||
let a = ~"Abcdefg";
|
||||
let a = "Abcdefg";
|
||||
let b = as_buf(a, |buf, _l| {
|
||||
assert_eq!(unsafe { *buf }, 65u8);
|
||||
100
|
||||
@ -3553,7 +3546,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_as_buf_small() {
|
||||
let a = ~"A";
|
||||
let a = "A";
|
||||
let b = as_buf(a, |buf, _l| {
|
||||
assert_eq!(unsafe { *buf }, 65u8);
|
||||
100
|
||||
@ -3631,32 +3624,32 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_contains() {
|
||||
assert!(contains(~"abcde", ~"bcd"));
|
||||
assert!(contains(~"abcde", ~"abcd"));
|
||||
assert!(contains(~"abcde", ~"bcde"));
|
||||
assert!(contains(~"abcde", ~""));
|
||||
assert!(contains(~"", ~""));
|
||||
assert!(!contains(~"abcde", ~"def"));
|
||||
assert!(!contains(~"", ~"a"));
|
||||
assert!(contains("abcde", "bcd"));
|
||||
assert!(contains("abcde", "abcd"));
|
||||
assert!(contains("abcde", "bcde"));
|
||||
assert!(contains("abcde", ""));
|
||||
assert!(contains("", ""));
|
||||
assert!(!contains("abcde", "def"));
|
||||
assert!(!contains("", "a"));
|
||||
|
||||
let data = ~"ประเทศไทย中华Việt Nam";
|
||||
assert!(contains(data, ~"ประเ"));
|
||||
assert!(contains(data, ~"ะเ"));
|
||||
assert!(contains(data, ~"中华"));
|
||||
assert!(!contains(data, ~"ไท华"));
|
||||
assert!(contains(data, "ประเ"));
|
||||
assert!(contains(data, "ะเ"));
|
||||
assert!(contains(data, "中华"));
|
||||
assert!(!contains(data, "ไท华"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_contains_char() {
|
||||
assert!(contains_char(~"abc", 'b'));
|
||||
assert!(contains_char(~"a", 'a'));
|
||||
assert!(!contains_char(~"abc", 'd'));
|
||||
assert!(!contains_char(~"", 'a'));
|
||||
assert!(contains_char("abc", 'b'));
|
||||
assert!(contains_char("a", 'a'));
|
||||
assert!(!contains_char("abc", 'd'));
|
||||
assert!(!contains_char("", 'a'));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_split_char_each() {
|
||||
let data = ~"\nMary had a little lamb\nLittle lamb\n";
|
||||
let data = "\nMary had a little lamb\nLittle lamb\n";
|
||||
|
||||
let mut ii = 0;
|
||||
|
||||
@ -3674,7 +3667,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_splitn_char_each() {
|
||||
let data = ~"\nMary had a little lamb\nLittle lamb\n";
|
||||
let data = "\nMary had a little lamb\nLittle lamb\n";
|
||||
|
||||
let mut ii = 0;
|
||||
|
||||
@ -3691,7 +3684,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_words_each() {
|
||||
let data = ~"\nMary had a little lamb\nLittle lamb\n";
|
||||
let data = "\nMary had a little lamb\nLittle lamb\n";
|
||||
|
||||
let mut ii = 0;
|
||||
|
||||
@ -3706,12 +3699,12 @@ mod tests {
|
||||
ii += 1;
|
||||
}
|
||||
|
||||
each_word(~"", |_x| fail!()); // should not fail
|
||||
each_word("", |_x| fail!()); // should not fail
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_lines_each () {
|
||||
let lf = ~"\nMary had a little lamb\nLittle lamb\n";
|
||||
let lf = "\nMary had a little lamb\nLittle lamb\n";
|
||||
|
||||
let mut ii = 0;
|
||||
|
||||
@ -3728,26 +3721,26 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_map() {
|
||||
assert_eq!(~"", map(~"", |c| unsafe {libc::toupper(c as c_char)} as char));
|
||||
assert_eq!(~"YMCA", map(~"ymca", |c| unsafe {libc::toupper(c as c_char)} as char));
|
||||
assert_eq!(~"", map("", |c| unsafe {libc::toupper(c as c_char)} as char));
|
||||
assert_eq!(~"YMCA", map("ymca", |c| unsafe {libc::toupper(c as c_char)} as char));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_all() {
|
||||
assert_eq!(true, all(~"", char::is_uppercase));
|
||||
assert_eq!(false, all(~"ymca", char::is_uppercase));
|
||||
assert_eq!(true, all(~"YMCA", char::is_uppercase));
|
||||
assert_eq!(false, all(~"yMCA", char::is_uppercase));
|
||||
assert_eq!(false, all(~"YMCy", char::is_uppercase));
|
||||
assert_eq!(true, all("", char::is_uppercase));
|
||||
assert_eq!(false, all("ymca", char::is_uppercase));
|
||||
assert_eq!(true, all("YMCA", char::is_uppercase));
|
||||
assert_eq!(false, all("yMCA", char::is_uppercase));
|
||||
assert_eq!(false, all("YMCy", char::is_uppercase));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_any() {
|
||||
assert_eq!(false, any(~"", char::is_uppercase));
|
||||
assert_eq!(false, any(~"ymca", char::is_uppercase));
|
||||
assert_eq!(true, any(~"YMCA", char::is_uppercase));
|
||||
assert_eq!(true, any(~"yMCA", char::is_uppercase));
|
||||
assert_eq!(true, any(~"Ymcy", char::is_uppercase));
|
||||
assert_eq!(false, any("", char::is_uppercase));
|
||||
assert_eq!(false, any("ymca", char::is_uppercase));
|
||||
assert_eq!(true, any("YMCA", char::is_uppercase));
|
||||
assert_eq!(true, any("yMCA", char::is_uppercase));
|
||||
assert_eq!(true, any("Ymcy", char::is_uppercase));
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -3761,41 +3754,41 @@ mod tests {
|
||||
#[test]
|
||||
fn test_utf16() {
|
||||
let pairs =
|
||||
~[(~"𐍅𐌿𐌻𐍆𐌹𐌻𐌰\n",
|
||||
[(~"𐍅𐌿𐌻𐍆𐌹𐌻𐌰\n",
|
||||
~[0xd800_u16, 0xdf45_u16, 0xd800_u16, 0xdf3f_u16,
|
||||
0xd800_u16, 0xdf3b_u16, 0xd800_u16, 0xdf46_u16,
|
||||
0xd800_u16, 0xdf39_u16, 0xd800_u16, 0xdf3b_u16,
|
||||
0xd800_u16, 0xdf30_u16, 0x000a_u16]),
|
||||
0xd800_u16, 0xdf3b_u16, 0xd800_u16, 0xdf46_u16,
|
||||
0xd800_u16, 0xdf39_u16, 0xd800_u16, 0xdf3b_u16,
|
||||
0xd800_u16, 0xdf30_u16, 0x000a_u16]),
|
||||
|
||||
(~"𐐒𐑉𐐮𐑀𐐲𐑋 𐐏𐐲𐑍\n",
|
||||
~[0xd801_u16, 0xdc12_u16, 0xd801_u16,
|
||||
0xdc49_u16, 0xd801_u16, 0xdc2e_u16, 0xd801_u16,
|
||||
0xdc40_u16, 0xd801_u16, 0xdc32_u16, 0xd801_u16,
|
||||
0xdc4b_u16, 0x0020_u16, 0xd801_u16, 0xdc0f_u16,
|
||||
0xd801_u16, 0xdc32_u16, 0xd801_u16, 0xdc4d_u16,
|
||||
0x000a_u16]),
|
||||
0xdc49_u16, 0xd801_u16, 0xdc2e_u16, 0xd801_u16,
|
||||
0xdc40_u16, 0xd801_u16, 0xdc32_u16, 0xd801_u16,
|
||||
0xdc4b_u16, 0x0020_u16, 0xd801_u16, 0xdc0f_u16,
|
||||
0xd801_u16, 0xdc32_u16, 0xd801_u16, 0xdc4d_u16,
|
||||
0x000a_u16]),
|
||||
|
||||
(~"𐌀𐌖𐌋𐌄𐌑𐌉·𐌌𐌄𐌕𐌄𐌋𐌉𐌑\n",
|
||||
~[0xd800_u16, 0xdf00_u16, 0xd800_u16, 0xdf16_u16,
|
||||
0xd800_u16, 0xdf0b_u16, 0xd800_u16, 0xdf04_u16,
|
||||
0xd800_u16, 0xdf11_u16, 0xd800_u16, 0xdf09_u16,
|
||||
0x00b7_u16, 0xd800_u16, 0xdf0c_u16, 0xd800_u16,
|
||||
0xdf04_u16, 0xd800_u16, 0xdf15_u16, 0xd800_u16,
|
||||
0xdf04_u16, 0xd800_u16, 0xdf0b_u16, 0xd800_u16,
|
||||
0xdf09_u16, 0xd800_u16, 0xdf11_u16, 0x000a_u16 ]),
|
||||
0xd800_u16, 0xdf0b_u16, 0xd800_u16, 0xdf04_u16,
|
||||
0xd800_u16, 0xdf11_u16, 0xd800_u16, 0xdf09_u16,
|
||||
0x00b7_u16, 0xd800_u16, 0xdf0c_u16, 0xd800_u16,
|
||||
0xdf04_u16, 0xd800_u16, 0xdf15_u16, 0xd800_u16,
|
||||
0xdf04_u16, 0xd800_u16, 0xdf0b_u16, 0xd800_u16,
|
||||
0xdf09_u16, 0xd800_u16, 0xdf11_u16, 0x000a_u16 ]),
|
||||
|
||||
(~"𐒋𐒘𐒈𐒑𐒛𐒒 𐒕𐒓 𐒈𐒚𐒍 𐒏𐒜𐒒𐒖𐒆 𐒕𐒆\n",
|
||||
~[0xd801_u16, 0xdc8b_u16, 0xd801_u16, 0xdc98_u16,
|
||||
0xd801_u16, 0xdc88_u16, 0xd801_u16, 0xdc91_u16,
|
||||
0xd801_u16, 0xdc9b_u16, 0xd801_u16, 0xdc92_u16,
|
||||
0x0020_u16, 0xd801_u16, 0xdc95_u16, 0xd801_u16,
|
||||
0xdc93_u16, 0x0020_u16, 0xd801_u16, 0xdc88_u16,
|
||||
0xd801_u16, 0xdc9a_u16, 0xd801_u16, 0xdc8d_u16,
|
||||
0x0020_u16, 0xd801_u16, 0xdc8f_u16, 0xd801_u16,
|
||||
0xdc9c_u16, 0xd801_u16, 0xdc92_u16, 0xd801_u16,
|
||||
0xdc96_u16, 0xd801_u16, 0xdc86_u16, 0x0020_u16,
|
||||
0xd801_u16, 0xdc95_u16, 0xd801_u16, 0xdc86_u16,
|
||||
0x000a_u16 ]) ];
|
||||
0xd801_u16, 0xdc88_u16, 0xd801_u16, 0xdc91_u16,
|
||||
0xd801_u16, 0xdc9b_u16, 0xd801_u16, 0xdc92_u16,
|
||||
0x0020_u16, 0xd801_u16, 0xdc95_u16, 0xd801_u16,
|
||||
0xdc93_u16, 0x0020_u16, 0xd801_u16, 0xdc88_u16,
|
||||
0xd801_u16, 0xdc9a_u16, 0xd801_u16, 0xdc8d_u16,
|
||||
0x0020_u16, 0xd801_u16, 0xdc8f_u16, 0xd801_u16,
|
||||
0xdc9c_u16, 0xd801_u16, 0xdc92_u16, 0xd801_u16,
|
||||
0xdc96_u16, 0xd801_u16, 0xdc86_u16, 0x0020_u16,
|
||||
0xd801_u16, 0xdc95_u16, 0xd801_u16, 0xdc86_u16,
|
||||
0x000a_u16 ]) ];
|
||||
|
||||
for pairs.each |p| {
|
||||
let (s, u) = copy *p;
|
||||
@ -3972,35 +3965,35 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_escape_unicode() {
|
||||
assert_eq!(escape_unicode(~"abc"), ~"\\x61\\x62\\x63");
|
||||
assert_eq!(escape_unicode(~"a c"), ~"\\x61\\x20\\x63");
|
||||
assert_eq!(escape_unicode(~"\r\n\t"), ~"\\x0d\\x0a\\x09");
|
||||
assert_eq!(escape_unicode(~"'\"\\"), ~"\\x27\\x22\\x5c");
|
||||
assert!(escape_unicode(~"\x00\x01\xfe\xff") ==
|
||||
assert_eq!(escape_unicode("abc"), ~"\\x61\\x62\\x63");
|
||||
assert_eq!(escape_unicode("a c"), ~"\\x61\\x20\\x63");
|
||||
assert_eq!(escape_unicode("\r\n\t"), ~"\\x0d\\x0a\\x09");
|
||||
assert_eq!(escape_unicode("'\"\\"), ~"\\x27\\x22\\x5c");
|
||||
assert!(escape_unicode("\x00\x01\xfe\xff") ==
|
||||
~"\\x00\\x01\\xfe\\xff");
|
||||
assert_eq!(escape_unicode(~"\u0100\uffff"), ~"\\u0100\\uffff");
|
||||
assert!(escape_unicode(~"\U00010000\U0010ffff") ==
|
||||
assert_eq!(escape_unicode("\u0100\uffff"), ~"\\u0100\\uffff");
|
||||
assert!(escape_unicode("\U00010000\U0010ffff") ==
|
||||
~"\\U00010000\\U0010ffff");
|
||||
assert_eq!(escape_unicode(~"ab\ufb00"), ~"\\x61\\x62\\ufb00");
|
||||
assert_eq!(escape_unicode(~"\U0001d4ea\r"), ~"\\U0001d4ea\\x0d");
|
||||
assert_eq!(escape_unicode("ab\ufb00"), ~"\\x61\\x62\\ufb00");
|
||||
assert_eq!(escape_unicode("\U0001d4ea\r"), ~"\\U0001d4ea\\x0d");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_escape_default() {
|
||||
assert_eq!(escape_default(~"abc"), ~"abc");
|
||||
assert_eq!(escape_default(~"a c"), ~"a c");
|
||||
assert_eq!(escape_default(~"\r\n\t"), ~"\\r\\n\\t");
|
||||
assert_eq!(escape_default(~"'\"\\"), ~"\\'\\\"\\\\");
|
||||
assert_eq!(escape_default(~"\u0100\uffff"), ~"\\u0100\\uffff");
|
||||
assert!(escape_default(~"\U00010000\U0010ffff") ==
|
||||
assert_eq!(escape_default("abc"), ~"abc");
|
||||
assert_eq!(escape_default("a c"), ~"a c");
|
||||
assert_eq!(escape_default("\r\n\t"), ~"\\r\\n\\t");
|
||||
assert_eq!(escape_default("'\"\\"), ~"\\'\\\"\\\\");
|
||||
assert_eq!(escape_default("\u0100\uffff"), ~"\\u0100\\uffff");
|
||||
assert!(escape_default("\U00010000\U0010ffff") ==
|
||||
~"\\U00010000\\U0010ffff");
|
||||
assert_eq!(escape_default(~"ab\ufb00"), ~"ab\\ufb00");
|
||||
assert_eq!(escape_default(~"\U0001d4ea\r"), ~"\\U0001d4ea\\r");
|
||||
assert_eq!(escape_default("ab\ufb00"), ~"ab\\ufb00");
|
||||
assert_eq!(escape_default("\U0001d4ea\r"), ~"\\U0001d4ea\\r");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_to_managed() {
|
||||
assert_eq!((~"abc").to_managed(), @"abc");
|
||||
assert_eq!("abc".to_managed(), @"abc");
|
||||
assert_eq!(slice("abcdef", 1, 5).to_managed(), @"bcde");
|
||||
}
|
||||
|
||||
|
||||
@ -228,8 +228,8 @@ mod tests {
|
||||
assert_eq!('`'.to_ascii().to_upper().to_char(), '`');
|
||||
assert_eq!('{'.to_ascii().to_upper().to_char(), '{');
|
||||
|
||||
assert!(str::all(~"banana", |c| c.is_ascii()));
|
||||
assert!(! str::all(~"ประเทศไทย中华Việt Nam", |c| c.is_ascii()));
|
||||
assert!(str::all("banana", |c| c.is_ascii()));
|
||||
assert!(! str::all("ประเทศไทย中华Việt Nam", |c| c.is_ascii()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@ -2962,8 +2962,8 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_is_empty() {
|
||||
assert!(is_empty::<int>(~[]));
|
||||
assert!(!is_empty(~[0]));
|
||||
assert!(is_empty::<int>([]));
|
||||
assert!(!is_empty([0]));
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -3445,7 +3445,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_each_empty() {
|
||||
for each::<int>(~[]) |_v| {
|
||||
for each::<int>([]) |_v| {
|
||||
fail!(); // should never be executed
|
||||
}
|
||||
}
|
||||
@ -3453,7 +3453,7 @@ mod tests {
|
||||
#[test]
|
||||
fn test_each_nonempty() {
|
||||
let mut i = 0;
|
||||
for each(~[1, 2, 3]) |v| {
|
||||
for each([1, 2, 3]) |v| {
|
||||
i += *v;
|
||||
}
|
||||
assert_eq!(i, 6);
|
||||
@ -3462,7 +3462,7 @@ mod tests {
|
||||
#[test]
|
||||
fn test_eachi() {
|
||||
let mut i = 0;
|
||||
for eachi(~[1, 2, 3]) |j, v| {
|
||||
for eachi([1, 2, 3]) |j, v| {
|
||||
if i == 0 { assert!(*v == 1); }
|
||||
assert_eq!(j + 1u, *v as uint);
|
||||
i += *v;
|
||||
@ -3481,7 +3481,7 @@ mod tests {
|
||||
#[test]
|
||||
fn test_each_reverse_nonempty() {
|
||||
let mut i = 0;
|
||||
for each_reverse(~[1, 2, 3]) |v| {
|
||||
for each_reverse([1, 2, 3]) |v| {
|
||||
if i == 0 { assert!(*v == 3); }
|
||||
i += *v
|
||||
}
|
||||
@ -3491,7 +3491,7 @@ mod tests {
|
||||
#[test]
|
||||
fn test_eachi_reverse() {
|
||||
let mut i = 0;
|
||||
for eachi_reverse(~[0, 1, 2]) |j, v| {
|
||||
for eachi_reverse([0, 1, 2]) |j, v| {
|
||||
if i == 0 { assert!(*v == 2); }
|
||||
assert_eq!(j, *v as uint);
|
||||
i += *v;
|
||||
@ -3512,48 +3512,48 @@ mod tests {
|
||||
let mut results: ~[~[int]];
|
||||
|
||||
results = ~[];
|
||||
for each_permutation(~[]) |v| { results.push(to_owned(v)); }
|
||||
for each_permutation([]) |v| { results.push(to_owned(v)); }
|
||||
assert_eq!(results, ~[~[]]);
|
||||
|
||||
results = ~[];
|
||||
for each_permutation(~[7]) |v| { results.push(to_owned(v)); }
|
||||
for each_permutation([7]) |v| { results.push(to_owned(v)); }
|
||||
assert_eq!(results, ~[~[7]]);
|
||||
|
||||
results = ~[];
|
||||
for each_permutation(~[1,1]) |v| { results.push(to_owned(v)); }
|
||||
for each_permutation([1,1]) |v| { results.push(to_owned(v)); }
|
||||
assert_eq!(results, ~[~[1,1],~[1,1]]);
|
||||
|
||||
results = ~[];
|
||||
for each_permutation(~[5,2,0]) |v| { results.push(to_owned(v)); }
|
||||
for each_permutation([5,2,0]) |v| { results.push(to_owned(v)); }
|
||||
assert!(results ==
|
||||
~[~[5,2,0],~[5,0,2],~[2,5,0],~[2,0,5],~[0,5,2],~[0,2,5]]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_any_and_all() {
|
||||
assert!(any(~[1u, 2u, 3u], is_three));
|
||||
assert!(!any(~[0u, 1u, 2u], is_three));
|
||||
assert!(any(~[1u, 2u, 3u, 4u, 5u], is_three));
|
||||
assert!(!any(~[1u, 2u, 4u, 5u, 6u], is_three));
|
||||
assert!(any([1u, 2u, 3u], is_three));
|
||||
assert!(!any([0u, 1u, 2u], is_three));
|
||||
assert!(any([1u, 2u, 3u, 4u, 5u], is_three));
|
||||
assert!(!any([1u, 2u, 4u, 5u, 6u], is_three));
|
||||
|
||||
assert!(all(~[3u, 3u, 3u], is_three));
|
||||
assert!(!all(~[3u, 3u, 2u], is_three));
|
||||
assert!(all(~[3u, 3u, 3u, 3u, 3u], is_three));
|
||||
assert!(!all(~[3u, 3u, 0u, 1u, 2u], is_three));
|
||||
assert!(all([3u, 3u, 3u], is_three));
|
||||
assert!(!all([3u, 3u, 2u], is_three));
|
||||
assert!(all([3u, 3u, 3u, 3u, 3u], is_three));
|
||||
assert!(!all([3u, 3u, 0u, 1u, 2u], is_three));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_any2_and_all2() {
|
||||
|
||||
assert!(any2(~[2u, 4u, 6u], ~[2u, 4u, 6u], is_equal));
|
||||
assert!(any2(~[1u, 2u, 3u], ~[4u, 5u, 3u], is_equal));
|
||||
assert!(!any2(~[1u, 2u, 3u], ~[4u, 5u, 6u], is_equal));
|
||||
assert!(any2(~[2u, 4u, 6u], ~[2u, 4u], is_equal));
|
||||
assert!(any2([2u, 4u, 6u], [2u, 4u, 6u], is_equal));
|
||||
assert!(any2([1u, 2u, 3u], [4u, 5u, 3u], is_equal));
|
||||
assert!(!any2([1u, 2u, 3u], [4u, 5u, 6u], is_equal));
|
||||
assert!(any2([2u, 4u, 6u], [2u, 4u], is_equal));
|
||||
|
||||
assert!(all2(~[2u, 4u, 6u], ~[2u, 4u, 6u], is_equal));
|
||||
assert!(!all2(~[1u, 2u, 3u], ~[4u, 5u, 3u], is_equal));
|
||||
assert!(!all2(~[1u, 2u, 3u], ~[4u, 5u, 6u], is_equal));
|
||||
assert!(!all2(~[2u, 4u, 6u], ~[2u, 4u], is_equal));
|
||||
assert!(all2([2u, 4u, 6u], [2u, 4u, 6u], is_equal));
|
||||
assert!(!all2([1u, 2u, 3u], [4u, 5u, 3u], is_equal));
|
||||
assert!(!all2([1u, 2u, 3u], [4u, 5u, 6u], is_equal));
|
||||
assert!(!all2([2u, 4u, 6u], [2u, 4u], is_equal));
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -3576,7 +3576,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_position_elem() {
|
||||
assert!(position_elem(~[], &1).is_none());
|
||||
assert!(position_elem([], &1).is_none());
|
||||
|
||||
let v1 = ~[1, 2, 3, 3, 2, 5];
|
||||
assert_eq!(position_elem(v1, &1), Some(0u));
|
||||
@ -3590,7 +3590,7 @@ mod tests {
|
||||
fn less_than_three(i: &int) -> bool { *i < 3 }
|
||||
fn is_eighteen(i: &int) -> bool { *i == 18 }
|
||||
|
||||
assert!(position(~[], less_than_three).is_none());
|
||||
assert!(position([], less_than_three).is_none());
|
||||
|
||||
let v1 = ~[5, 4, 3, 2, 1];
|
||||
assert_eq!(position(v1, less_than_three), Some(3u));
|
||||
@ -3599,7 +3599,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_position_between() {
|
||||
assert!(position_between(~[], 0u, 0u, f).is_none());
|
||||
assert!(position_between([], 0u, 0u, f).is_none());
|
||||
|
||||
fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' }
|
||||
let v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
|
||||
@ -3627,7 +3627,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_find() {
|
||||
assert!(find(~[], f).is_none());
|
||||
assert!(find([], f).is_none());
|
||||
|
||||
fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' }
|
||||
fn g(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'd' }
|
||||
@ -3639,7 +3639,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_find_between() {
|
||||
assert!(find_between(~[], 0u, 0u, f).is_none());
|
||||
assert!(find_between([], 0u, 0u, f).is_none());
|
||||
|
||||
fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' }
|
||||
let v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
|
||||
@ -3667,7 +3667,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_rposition() {
|
||||
assert!(find(~[], f).is_none());
|
||||
assert!(find([], f).is_none());
|
||||
|
||||
fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' }
|
||||
fn g(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'd' }
|
||||
@ -3679,7 +3679,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_rposition_between() {
|
||||
assert!(rposition_between(~[], 0u, 0u, f).is_none());
|
||||
assert!(rposition_between([], 0u, 0u, f).is_none());
|
||||
|
||||
fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' }
|
||||
let v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
|
||||
@ -3707,7 +3707,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_rfind() {
|
||||
assert!(rfind(~[], f).is_none());
|
||||
assert!(rfind([], f).is_none());
|
||||
|
||||
fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' }
|
||||
fn g(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'd' }
|
||||
@ -3719,7 +3719,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_rfind_between() {
|
||||
assert!(rfind_between(~[], 0u, 0u, f).is_none());
|
||||
assert!(rfind_between([], 0u, 0u, f).is_none());
|
||||
|
||||
fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' }
|
||||
let v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
|
||||
@ -3798,14 +3798,14 @@ mod tests {
|
||||
reverse(v);
|
||||
assert_eq!(v[0], 20);
|
||||
assert_eq!(v[1], 10);
|
||||
let v2 = reversed::<int>(~[10, 20]);
|
||||
let v2 = reversed::<int>([10, 20]);
|
||||
assert_eq!(v2[0], 20);
|
||||
assert_eq!(v2[1], 10);
|
||||
v[0] = 30;
|
||||
assert_eq!(v2[0], 20);
|
||||
// Make sure they work with 0-length vectors too.
|
||||
|
||||
let v4 = reversed::<int>(~[]);
|
||||
let v4 = reversed::<int>([]);
|
||||
assert_eq!(v4, ~[]);
|
||||
let mut v3: ~[int] = ~[];
|
||||
reverse::<int>(v3);
|
||||
@ -3813,7 +3813,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn reversed_mut() {
|
||||
let v2 = reversed::<int>(~[10, 20]);
|
||||
let v2 = reversed::<int>([10, 20]);
|
||||
assert_eq!(v2[0], 20);
|
||||
assert_eq!(v2[1], 10);
|
||||
}
|
||||
@ -3822,22 +3822,22 @@ mod tests {
|
||||
fn test_split() {
|
||||
fn f(x: &int) -> bool { *x == 3 }
|
||||
|
||||
assert_eq!(split(~[], f), ~[]);
|
||||
assert_eq!(split(~[1, 2], f), ~[~[1, 2]]);
|
||||
assert_eq!(split(~[3, 1, 2], f), ~[~[], ~[1, 2]]);
|
||||
assert_eq!(split(~[1, 2, 3], f), ~[~[1, 2], ~[]]);
|
||||
assert_eq!(split(~[1, 2, 3, 4, 3, 5], f), ~[~[1, 2], ~[4], ~[5]]);
|
||||
assert_eq!(split([], f), ~[]);
|
||||
assert_eq!(split([1, 2], f), ~[~[1, 2]]);
|
||||
assert_eq!(split([3, 1, 2], f), ~[~[], ~[1, 2]]);
|
||||
assert_eq!(split([1, 2, 3], f), ~[~[1, 2], ~[]]);
|
||||
assert_eq!(split([1, 2, 3, 4, 3, 5], f), ~[~[1, 2], ~[4], ~[5]]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_splitn() {
|
||||
fn f(x: &int) -> bool { *x == 3 }
|
||||
|
||||
assert_eq!(splitn(~[], 1u, f), ~[]);
|
||||
assert_eq!(splitn(~[1, 2], 1u, f), ~[~[1, 2]]);
|
||||
assert_eq!(splitn(~[3, 1, 2], 1u, f), ~[~[], ~[1, 2]]);
|
||||
assert_eq!(splitn(~[1, 2, 3], 1u, f), ~[~[1, 2], ~[]]);
|
||||
assert!(splitn(~[1, 2, 3, 4, 3, 5], 1u, f) ==
|
||||
assert_eq!(splitn([], 1u, f), ~[]);
|
||||
assert_eq!(splitn([1, 2], 1u, f), ~[~[1, 2]]);
|
||||
assert_eq!(splitn([3, 1, 2], 1u, f), ~[~[], ~[1, 2]]);
|
||||
assert_eq!(splitn([1, 2, 3], 1u, f), ~[~[1, 2], ~[]]);
|
||||
assert!(splitn([1, 2, 3, 4, 3, 5], 1u, f) ==
|
||||
~[~[1, 2], ~[4, 3, 5]]);
|
||||
}
|
||||
|
||||
@ -3845,10 +3845,10 @@ mod tests {
|
||||
fn test_rsplit() {
|
||||
fn f(x: &int) -> bool { *x == 3 }
|
||||
|
||||
assert_eq!(rsplit(~[], f), ~[]);
|
||||
assert_eq!(rsplit(~[1, 2], f), ~[~[1, 2]]);
|
||||
assert_eq!(rsplit(~[1, 2, 3], f), ~[~[1, 2], ~[]]);
|
||||
assert!(rsplit(~[1, 2, 3, 4, 3, 5], f) ==
|
||||
assert_eq!(rsplit([], f), ~[]);
|
||||
assert_eq!(rsplit([1, 2], f), ~[~[1, 2]]);
|
||||
assert_eq!(rsplit([1, 2, 3], f), ~[~[1, 2], ~[]]);
|
||||
assert!(rsplit([1, 2, 3, 4, 3, 5], f) ==
|
||||
~[~[1, 2], ~[4], ~[5]]);
|
||||
}
|
||||
|
||||
@ -3856,53 +3856,46 @@ mod tests {
|
||||
fn test_rsplitn() {
|
||||
fn f(x: &int) -> bool { *x == 3 }
|
||||
|
||||
assert_eq!(rsplitn(~[], 1u, f), ~[]);
|
||||
assert_eq!(rsplitn(~[1, 2], 1u, f), ~[~[1, 2]]);
|
||||
assert_eq!(rsplitn(~[1, 2, 3], 1u, f), ~[~[1, 2], ~[]]);
|
||||
assert!(rsplitn(~[1, 2, 3, 4, 3, 5], 1u, f) ==
|
||||
~[~[1, 2, 3, 4], ~[5]]);
|
||||
assert_eq!(rsplitn([], 1u, f), ~[]);
|
||||
assert_eq!(rsplitn([1, 2], 1u, f), ~[~[1, 2]]);
|
||||
assert_eq!(rsplitn([1, 2, 3], 1u, f), ~[~[1, 2], ~[]]);
|
||||
assert_eq!(rsplitn([1, 2, 3, 4, 3, 5], 1u, f), ~[~[1, 2, 3, 4], ~[5]]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_partition() {
|
||||
// FIXME (#4355 maybe): using v.partition here crashes
|
||||
assert_eq!(partition(~[], |x: &int| *x < 3), (~[], ~[]));
|
||||
assert!(partition(~[1, 2, 3], |x: &int| *x < 4) ==
|
||||
(~[1, 2, 3], ~[]));
|
||||
assert!(partition(~[1, 2, 3], |x: &int| *x < 2) ==
|
||||
(~[1], ~[2, 3]));
|
||||
assert!(partition(~[1, 2, 3], |x: &int| *x < 0) ==
|
||||
(~[], ~[1, 2, 3]));
|
||||
assert_eq!(partition(~[1, 2, 3], |x: &int| *x < 4), (~[1, 2, 3], ~[]));
|
||||
assert_eq!(partition(~[1, 2, 3], |x: &int| *x < 2), (~[1], ~[2, 3]));
|
||||
assert_eq!(partition(~[1, 2, 3], |x: &int| *x < 0), (~[], ~[1, 2, 3]));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_partitioned() {
|
||||
assert_eq!((~[]).partitioned(|x: &int| *x < 3), (~[], ~[]))
|
||||
assert!((~[1, 2, 3]).partitioned(|x: &int| *x < 4) ==
|
||||
(~[1, 2, 3], ~[]));
|
||||
assert!((~[1, 2, 3]).partitioned(|x: &int| *x < 2) ==
|
||||
(~[1], ~[2, 3]));
|
||||
assert!((~[1, 2, 3]).partitioned(|x: &int| *x < 0) ==
|
||||
(~[], ~[1, 2, 3]));
|
||||
assert_eq!(([]).partitioned(|x: &int| *x < 3), (~[], ~[]))
|
||||
assert_eq!(([1, 2, 3]).partitioned(|x: &int| *x < 4), (~[1, 2, 3], ~[]));
|
||||
assert_eq!(([1, 2, 3]).partitioned(|x: &int| *x < 2), (~[1], ~[2, 3]));
|
||||
assert_eq!(([1, 2, 3]).partitioned(|x: &int| *x < 0), (~[], ~[1, 2, 3]));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_concat() {
|
||||
assert_eq!(concat(~[~[1], ~[2,3]]), ~[1, 2, 3]);
|
||||
assert_eq!(concat([~[1], ~[2,3]]), ~[1, 2, 3]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_connect() {
|
||||
assert_eq!(connect(~[], &0), ~[]);
|
||||
assert_eq!(connect(~[~[1], ~[2, 3]], &0), ~[1, 0, 2, 3]);
|
||||
assert_eq!(connect(~[~[1], ~[2], ~[3]], &0), ~[1, 0, 2, 0, 3]);
|
||||
assert_eq!(connect([], &0), ~[]);
|
||||
assert_eq!(connect([~[1], ~[2, 3]], &0), ~[1, 0, 2, 3]);
|
||||
assert_eq!(connect([~[1], ~[2], ~[3]], &0), ~[1, 0, 2, 0, 3]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_windowed () {
|
||||
fn t(n: uint, expected: &[&[int]]) {
|
||||
let mut i = 0;
|
||||
for windowed(n, ~[1,2,3,4,5,6]) |v| {
|
||||
for windowed(n, [1,2,3,4,5,6]) |v| {
|
||||
assert_eq!(v, expected[i]);
|
||||
i += 1;
|
||||
}
|
||||
@ -3920,7 +3913,7 @@ mod tests {
|
||||
#[should_fail]
|
||||
#[ignore(cfg(windows))]
|
||||
fn test_windowed_() {
|
||||
for windowed (0u, ~[1u,2u,3u,4u,5u,6u]) |_v| {}
|
||||
for windowed (0u, [1u,2u,3u,4u,5u,6u]) |_v| {}
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user