bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

auto merge of #6690 : erickt/rust/cleanup-warnings, r=brson

Browse source 
Simple patch series to fix up all the warnings a rustc compile is giving at the moment. It also fixes a NOTE in `to_bytes.rs` to remove the `to_bytes::iter_bytes_<N>` functions.
This commit is contained in:
bors 2013-05-23 18:10:36 -07:00
commit a776d65b4d
66 changed files with 1300 additions and 1342 deletions
Download patch file Download diff file Expand all files Collapse all files

11
doc/tutorial.md
View file

@ -1480,7 +1480,6 @@ This code creates a closure that adds a given string to its argument,
returns it from a function, and then calls it: returns it from a function, and then calls it:
~~~~ ~~~~
# extern mod std;
fn mk_appender(suffix: ~str) -> @fn(~str) -> ~str { fn mk_appender(suffix: ~str) -> @fn(~str) -> ~str {
// The compiler knows that we intend this closure to be of type @fn // The compiler knows that we intend this closure to be of type @fn
return |s| s + suffix; return |s| s + suffix;
@ -2292,7 +2291,7 @@ let nonsense = mycircle.radius() * mycircle.area();
## Deriving implementations for traits ## Deriving implementations for traits
A small number of traits in `std` and `std` can have implementations A small number of traits in `std` and `extra` can have implementations
that can be automatically derived. These instances are specified by that can be automatically derived. These instances are specified by
placing the `deriving` attribute on a data type declaration. For placing the `deriving` attribute on a data type declaration. For
example, the following will mean that `Circle` has an implementation example, the following will mean that `Circle` has an implementation
@ -2541,9 +2540,9 @@ as well as an inscrutable string of alphanumerics. These are both
part of Rust's library versioning scheme. The alphanumerics are part of Rust's library versioning scheme. The alphanumerics are
a hash representing the crate metadata. a hash representing the crate metadata.
## The std library ## The standard library
The Rust std library provides runtime features required by the language, The Rust standard library provides runtime features required by the language,
including the task scheduler and memory allocators, as well as library including the task scheduler and memory allocators, as well as library
support for Rust built-in types, platform abstractions, and other commonly support for Rust built-in types, platform abstractions, and other commonly
used features. used features.
@ -2559,7 +2558,7 @@ I/O abstractions ([`io`]), [containers] like [`hashmap`],
common traits ([`kinds`], [`ops`], [`cmp`], [`num`], common traits ([`kinds`], [`ops`], [`cmp`], [`num`],
[`to_str`], [`clone`]), and complete bindings to the C standard library ([`libc`]). [`to_str`], [`clone`]), and complete bindings to the C standard library ([`libc`]).
### Core injection and the Rust prelude ### Standard Library injection and the Rust prelude
`std` is imported at the topmost level of every crate by default, as `std` is imported at the topmost level of every crate by default, as
if the first line of each crate was if the first line of each crate was
@ -2571,7 +2570,7 @@ with the `std::` path prefix, as in `use std::vec`, `use std::task::spawn`,
etc. etc.
Additionally, `std` contains a `prelude` module that reexports many of the Additionally, `std` contains a `prelude` module that reexports many of the
most common std modules, types and traits. The contents of the prelude are most common standard modules, types and traits. The contents of the prelude are
imported into every *module* by default. Implicitly, all modules behave as if imported into every *module* by default. Implicitly, all modules behave as if
they contained the following prologue: they contained the following prologue:

72
src/compiletest/compiletest.rc
View file

@ -50,20 +50,20 @@ pub fn main() {
pub fn parse_config(args: ~[~str]) -> config { pub fn parse_config(args: ~[~str]) -> config {
let opts = let opts =
~[getopts::reqopt(~"compile-lib-path"), ~[getopts::reqopt("compile-lib-path"),
getopts::reqopt(~"run-lib-path"), getopts::reqopt("run-lib-path"),
getopts::reqopt(~"rustc-path"), getopts::reqopt(~"src-base"), getopts::reqopt("rustc-path"), getopts::reqopt("src-base"),
getopts::reqopt(~"build-base"), getopts::reqopt(~"aux-base"), getopts::reqopt("build-base"), getopts::reqopt("aux-base"),
getopts::reqopt(~"stage-id"), getopts::reqopt("stage-id"),
getopts::reqopt(~"mode"), getopts::optflag(~"ignored"), getopts::reqopt("mode"), getopts::optflag("ignored"),
getopts::optopt(~"runtool"), getopts::optopt(~"rustcflags"), getopts::optopt("runtool"), getopts::optopt("rustcflags"),
getopts::optflag(~"verbose"), getopts::optflag("verbose"),
getopts::optopt(~"logfile"), getopts::optopt("logfile"),
getopts::optflag(~"jit"), getopts::optflag("jit"),
getopts::optflag(~"newrt"), getopts::optflag("newrt"),
getopts::optopt(~"target"), getopts::optopt("target"),
getopts::optopt(~"adb-path"), getopts::optopt("adb-path"),
getopts::optopt(~"adb-test-dir") getopts::optopt("adb-test-dir")
]; ];
assert!(!args.is_empty()); assert!(!args.is_empty());
@ -74,43 +74,43 @@ pub fn parse_config(args: ~[~str]) -> config {
Err(f) => fail!(getopts::fail_str(f)) Err(f) => fail!(getopts::fail_str(f))
}; };
fn opt_path(m: &getopts::Matches, nm: ~str) -> Path { fn opt_path(m: &getopts::Matches, nm: &str) -> Path {
Path(getopts::opt_str(m, nm)) Path(getopts::opt_str(m, nm))
} }
config { config {
compile_lib_path: getopts::opt_str(matches, ~"compile-lib-path"), compile_lib_path: getopts::opt_str(matches, "compile-lib-path"),
run_lib_path: getopts::opt_str(matches, ~"run-lib-path"), run_lib_path: getopts::opt_str(matches, "run-lib-path"),
rustc_path: opt_path(matches, ~"rustc-path"), rustc_path: opt_path(matches, "rustc-path"),
src_base: opt_path(matches, ~"src-base"), src_base: opt_path(matches, "src-base"),
build_base: opt_path(matches, ~"build-base"), build_base: opt_path(matches, "build-base"),
aux_base: opt_path(matches, ~"aux-base"), aux_base: opt_path(matches, "aux-base"),
stage_id: getopts::opt_str(matches, ~"stage-id"), stage_id: getopts::opt_str(matches, "stage-id"),
mode: str_mode(getopts::opt_str(matches, ~"mode")), mode: str_mode(getopts::opt_str(matches, "mode")),
run_ignored: getopts::opt_present(matches, ~"ignored"), run_ignored: getopts::opt_present(matches, "ignored"),
filter: filter:
if vec::len(matches.free) > 0u { if vec::len(matches.free) > 0u {
option::Some(copy matches.free[0]) option::Some(copy matches.free[0])
} else { option::None }, } else { option::None },
logfile: getopts::opt_maybe_str(matches, ~"logfile").map(|s| Path(*s)), logfile: getopts::opt_maybe_str(matches, "logfile").map(|s| Path(*s)),
runtool: getopts::opt_maybe_str(matches, ~"runtool"), runtool: getopts::opt_maybe_str(matches, "runtool"),
rustcflags: getopts::opt_maybe_str(matches, ~"rustcflags"), rustcflags: getopts::opt_maybe_str(matches, "rustcflags"),
jit: getopts::opt_present(matches, ~"jit"), jit: getopts::opt_present(matches, "jit"),
newrt: getopts::opt_present(matches, ~"newrt"), newrt: getopts::opt_present(matches, "newrt"),
target: opt_str2(getopts::opt_maybe_str(matches, ~"target")).to_str(), target: opt_str2(getopts::opt_maybe_str(matches, "target")).to_str(),
adb_path: opt_str2(getopts::opt_maybe_str(matches, ~"adb-path")).to_str(), adb_path: opt_str2(getopts::opt_maybe_str(matches, "adb-path")).to_str(),
adb_test_dir: adb_test_dir:
opt_str2(getopts::opt_maybe_str(matches, ~"adb-test-dir")).to_str(), opt_str2(getopts::opt_maybe_str(matches, "adb-test-dir")).to_str(),
adb_device_status: adb_device_status:
if (opt_str2(getopts::opt_maybe_str(matches, ~"target")) == if (opt_str2(getopts::opt_maybe_str(matches, "target")) ==
~"arm-linux-androideabi") { ~"arm-linux-androideabi") {
if (opt_str2(getopts::opt_maybe_str(matches, ~"adb-test-dir")) != if (opt_str2(getopts::opt_maybe_str(matches, "adb-test-dir")) !=
~"(none)" && ~"(none)" &&
opt_str2(getopts::opt_maybe_str(matches, ~"adb-test-dir")) != opt_str2(getopts::opt_maybe_str(matches, "adb-test-dir")) !=
~"") { true } ~"") { true }
else { false } else { false }
} else { false }, } else { false },
verbose: getopts::opt_present(matches, ~"verbose") verbose: getopts::opt_present(matches, "verbose")
} }
} }

7
src/compiletest/header.rs
View file

@ -87,10 +87,10 @@ pub fn load_props(testfile: &Path) -> TestProps {
pub fn is_test_ignored(config: &config, testfile: &Path) -> bool { pub fn is_test_ignored(config: &config, testfile: &Path) -> bool {
for iter_header(testfile) |ln| { for iter_header(testfile) |ln| {
if parse_name_directive(ln, ~"xfail-test") { return true; } if parse_name_directive(ln, "xfail-test") { return true; }
if parse_name_directive(ln, xfail_target()) { return true; } if parse_name_directive(ln, xfail_target()) { return true; }
if config.mode == common::mode_pretty && if config.mode == common::mode_pretty &&
parse_name_directive(ln, ~"xfail-pretty") { return true; } parse_name_directive(ln, "xfail-pretty") { return true; }
}; };
return false; return false;
@ -107,8 +107,7 @@ fn iter_header(testfile: &Path, it: &fn(~str) -> bool) -> bool {
// Assume that any directives will be found before the first // Assume that any directives will be found before the first
// module or function. This doesn't seem to be an optimization // module or function. This doesn't seem to be an optimization
// with a warm page cache. Maybe with a cold one. // with a warm page cache. Maybe with a cold one.
if str::starts_with(ln, ~"fn") if str::starts_with(ln, "fn") || str::starts_with(ln, "mod") {
|| str::starts_with(ln, ~"mod") {
return false; return false;
} else { if !(it(ln)) { return false; } } } else { if !(it(ln)) { return false; } }
} }

28
src/compiletest/runtest.rs
View file

@ -25,7 +25,7 @@ use util::logv;
pub fn run(config: config, testfile: ~str) { pub fn run(config: config, testfile: ~str) {
if config.verbose { if config.verbose {
// We're going to be dumping a lot of info. Start on a new line. // We're going to be dumping a lot of info. Start on a new line.
io::stdout().write_str(~"\n\n"); io::stdout().write_str("\n\n");
} }
let testfile = Path(testfile); let testfile = Path(testfile);
debug!("running %s", testfile.to_str()); debug!("running %s", testfile.to_str());
@ -231,7 +231,7 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
// do not optimize debuginfo tests // do not optimize debuginfo tests
let mut config = match config.rustcflags { let mut config = match config.rustcflags {
Some(ref flags) => config { Some(ref flags) => config {
rustcflags: Some(str::replace(*flags, ~"-O", ~"")), rustcflags: Some(str::replace(*flags, "-O", "")),
.. copy *config .. copy *config
}, },
None => copy *config None => copy *config
@ -249,19 +249,19 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
// write debugger script // write debugger script
let script_str = str::append(cmds, "\nquit\n"); let script_str = str::append(cmds, "\nquit\n");
debug!("script_str = %s", script_str); debug!("script_str = %s", script_str);
dump_output_file(config, testfile, script_str, ~"debugger.script"); dump_output_file(config, testfile, script_str, "debugger.script");
// run debugger script with gdb // run debugger script with gdb
#[cfg(windows)] #[cfg(windows)]
fn debugger() -> ~str { ~"gdb.exe" } fn debugger() -> ~str { ~"gdb.exe" }
#[cfg(unix)] #[cfg(unix)]
fn debugger() -> ~str { ~"gdb" } fn debugger() -> ~str { ~"gdb" }
let debugger_script = make_out_name(config, testfile, ~"debugger.script"); let debugger_script = make_out_name(config, testfile, "debugger.script");
let debugger_opts = ~[~"-quiet", ~"-batch", ~"-nx", let debugger_opts = ~[~"-quiet", ~"-batch", ~"-nx",
~"-command=" + debugger_script.to_str(), ~"-command=" + debugger_script.to_str(),
make_exe_name(config, testfile).to_str()]; make_exe_name(config, testfile).to_str()];
let ProcArgs = ProcArgs {prog: debugger(), args: debugger_opts}; let ProcArgs = ProcArgs {prog: debugger(), args: debugger_opts};
ProcRes = compose_and_run(config, testfile, ProcArgs, ~[], ~"", None); ProcRes = compose_and_run(config, testfile, ProcArgs, ~[], "", None);
if ProcRes.status != 0 { if ProcRes.status != 0 {
fatal(~"gdb failed to execute"); fatal(~"gdb failed to execute");
} }
@ -368,7 +368,7 @@ fn check_expected_errors(expected_errors: ~[errors::ExpectedError],
} }
// ignore this msg which gets printed at the end // ignore this msg which gets printed at the end
if str::contains(line, ~"aborting due to") { if str::contains(line, "aborting due to") {
was_expected = true; was_expected = true;
} }
@ -643,7 +643,7 @@ fn program_output(config: &config, testfile: &Path, lib_path: &str, prog: ~str,
#[cfg(target_os = "macos")] #[cfg(target_os = "macos")]
#[cfg(target_os = "freebsd")] #[cfg(target_os = "freebsd")]
fn make_cmdline(_libpath: &str, prog: &str, args: &[~str]) -> ~str { fn make_cmdline(_libpath: &str, prog: &str, args: &[~str]) -> ~str {
fmt!("%s %s", prog, str::connect(args, ~" ")) fmt!("%s %s", prog, str::connect(args, " "))
} }
#[cfg(target_os = "win32")] #[cfg(target_os = "win32")]
@ -668,7 +668,7 @@ fn dump_output_file(config: &config, testfile: &Path,
out: &str, extension: &str) { out: &str, extension: &str) {
let outfile = make_out_name(config, testfile, extension); let outfile = make_out_name(config, testfile, extension);
let writer = let writer =
io::file_writer(&outfile, ~[io::Create, io::Truncate]).get(); io::file_writer(&outfile, [io::Create, io::Truncate]).get();
writer.write_str(out); writer.write_str(out);
} }
@ -692,8 +692,8 @@ fn output_base_name(config: &config, testfile: &Path) -> Path {
fn maybe_dump_to_stdout(config: &config, out: &str, err: &str) { fn maybe_dump_to_stdout(config: &config, out: &str, err: &str) {
if config.verbose { if config.verbose {
let sep1 = fmt!("------%s------------------------------", ~"stdout"); let sep1 = fmt!("------%s------------------------------", "stdout");
let sep2 = fmt!("------%s------------------------------", ~"stderr"); let sep2 = fmt!("------%s------------------------------", "stderr");
let sep3 = ~"------------------------------------------"; let sep3 = ~"------------------------------------------";
io::stdout().write_line(sep1); io::stdout().write_line(sep1);
io::stdout().write_line(out); io::stdout().write_line(out);
@ -781,10 +781,10 @@ fn _arm_exec_compiled_test(config: &config, props: &TestProps,
newargs_err.push(newcmd_err); newargs_err.push(newcmd_err);
let procsrv::Result{ out: out_out, err: _out_err, status: out_status } = let procsrv::Result{ out: out_out, err: _out_err, status: out_status } =
procsrv::run(~"", config.adb_path, newargs_out, ~[(~"",~"")], procsrv::run("", config.adb_path, newargs_out, ~[(~"",~"")],
Some(~"")); Some(~""));
let procsrv::Result{ out: err_out, err: _err_err, status: _err_status } = let procsrv::Result{ out: err_out, err: _err_err, status: _err_status } =
procsrv::run(~"", config.adb_path, newargs_err, ~[(~"",~"")], procsrv::run("", config.adb_path, newargs_err, ~[(~"",~"")],
Some(~"")); Some(~""));
dump_output(config, testfile, out_out, err_out); dump_output(config, testfile, out_out, err_out);
@ -818,8 +818,8 @@ fn _arm_push_aux_shared_library(config: &config, testfile: &Path) {
if (file.filetype() == Some(~".so")) { if (file.filetype() == Some(~".so")) {
let copy_result = procsrv::run(~"", config.adb_path, let copy_result = procsrv::run("", config.adb_path,
~[~"push", file.to_str(), copy config.adb_test_dir], [~"push", file.to_str(), copy config.adb_test_dir],
~[(~"",~"")], Some(~"")); ~[(~"",~"")], Some(~""));
if config.verbose { if config.verbose {

18
src/libextra/base64.rs
View file

@ -12,10 +12,6 @@
use core::prelude::*; use core::prelude::*;
use core::old_iter;
use core::str;
use core::vec;
pub trait ToBase64 { pub trait ToBase64 {
fn to_base64(&self) -> ~str; fn to_base64(&self) -> ~str;
} }
@ -242,12 +238,12 @@ mod tests {
#[test] #[test]
fn test_from_base64() { fn test_from_base64() {
assert_eq!((~"").from_base64(), str::to_bytes(~"")); assert_eq!((~"").from_base64(), str::to_bytes(""));
assert!((~"Zg==").from_base64() == str::to_bytes(~"f")); assert!((~"Zg==").from_base64() == str::to_bytes("f"));
assert_eq!((~"Zm8=").from_base64(), str::to_bytes(~"fo")); assert_eq!((~"Zm8=").from_base64(), str::to_bytes("fo"));
assert_eq!((~"Zm9v").from_base64(), str::to_bytes(~"foo")); assert_eq!((~"Zm9v").from_base64(), str::to_bytes("foo"));
assert!((~"Zm9vYg==").from_base64() == str::to_bytes(~"foob")); assert!((~"Zm9vYg==").from_base64() == str::to_bytes("foob"));
assert_eq!((~"Zm9vYmE=").from_base64(), str::to_bytes(~"fooba")) assert_eq!((~"Zm9vYmE=").from_base64(), str::to_bytes("fooba"))
assert_eq!((~"Zm9vYmFy").from_base64(), str::to_bytes(~"foobar")); assert_eq!((~"Zm9vYmFy").from_base64(), str::to_bytes("foobar"));
} }
} }

17
src/libextra/bitv.rs
View file

@ -10,8 +10,6 @@
use core::prelude::*; use core::prelude::*;
use core::vec::from_elem;
struct SmallBitv { struct SmallBitv {
/// only the lowest nbits of this value are used. the rest is undefined. /// only the lowest nbits of this value are used. the rest is undefined.
bits: uint bits: uint
@ -257,7 +255,7 @@ pub impl Bitv {
let nelems = nbits/uint::bits + let nelems = nbits/uint::bits +
if nbits % uint::bits == 0 {0} else {1}; if nbits % uint::bits == 0 {0} else {1};
let elem = if init {!0} else {0}; let elem = if init {!0} else {0};
let s = from_elem(nelems, elem); let s = vec::from_elem(nelems, elem);
Big(~BigBitv::new(s)) Big(~BigBitv::new(s))
}; };
Bitv {rep: rep, nbits: nbits} Bitv {rep: rep, nbits: nbits}
@ -502,7 +500,7 @@ impl Clone for Bitv {
Bitv{nbits: self.nbits, rep: Small(~SmallBitv{bits: b.bits})} Bitv{nbits: self.nbits, rep: Small(~SmallBitv{bits: b.bits})}
} }
Big(ref b) => { Big(ref b) => {
let mut st = from_elem(self.nbits / uint::bits + 1, 0); let mut st = vec::from_elem(self.nbits / uint::bits + 1, 0);
let len = st.len(); let len = st.len();
for uint::range(0, len) |i| { st[i] = b.storage[i]; }; for uint::range(0, len) |i| { st[i] = b.storage[i]; };
Bitv{nbits: self.nbits, rep: Big(~BigBitv{storage: st})} Bitv{nbits: self.nbits, rep: Big(~BigBitv{storage: st})}
@ -872,17 +870,14 @@ mod tests {
#[test] #[test]
fn test_0_elements() { fn test_0_elements() {
let mut act; let act = Bitv::new(0u, false);
let exp; let exp = vec::from_elem::<uint>(0u, 0u);
act = Bitv::new(0u, false);
exp = vec::from_elem::<uint>(0u, 0u);
assert!(act.eq_vec(exp)); assert!(act.eq_vec(exp));
} }
#[test] #[test]
fn test_1_element() { fn test_1_element() {
let mut act; let mut act = Bitv::new(1u, false);
act = Bitv::new(1u, false);
assert!(act.eq_vec(~[0u])); assert!(act.eq_vec(~[0u]));
act = Bitv::new(1u, true); act = Bitv::new(1u, true);
assert!(act.eq_vec(~[1u])); assert!(act.eq_vec(~[1u]));
@ -1488,7 +1483,7 @@ mod tests {
#[bench] #[bench]
fn bench_bitv_big_union(b: &mut BenchHarness) { fn bench_bitv_big_union(b: &mut BenchHarness) {
let mut b1 = Bitv::new(bench_bits, false); let mut b1 = Bitv::new(bench_bits, false);
let mut b2 = Bitv::new(bench_bits, false); let b2 = Bitv::new(bench_bits, false);
do b.iter { do b.iter {
b1.union(&b2); b1.union(&b2);
} }

42
src/libextra/dlist.rs
View file

@ -540,13 +540,13 @@ mod tests {
#[test] #[test]
fn test_dlist_concat() { fn test_dlist_concat() {
let a = from_vec(~[1,2]); let a = from_vec([1,2]);
let b = from_vec(~[3,4]); let b = from_vec([3,4]);
let c = from_vec(~[5,6]); let c = from_vec([5,6]);
let d = from_vec(~[7,8]); let d = from_vec([7,8]);
let ab = from_vec(~[a,b]); let ab = from_vec([a,b]);
let cd = from_vec(~[c,d]); let cd = from_vec([c,d]);
let abcd = concat(concat(from_vec(~[ab,cd]))); let abcd = concat(concat(from_vec([ab,cd])));
abcd.assert_consistent(); assert_eq!(abcd.len(), 8); abcd.assert_consistent(); assert_eq!(abcd.len(), 8);
abcd.assert_consistent(); assert_eq!(abcd.pop().get(), 1); abcd.assert_consistent(); assert_eq!(abcd.pop().get(), 1);
abcd.assert_consistent(); assert_eq!(abcd.pop().get(), 2); abcd.assert_consistent(); assert_eq!(abcd.pop().get(), 2);
@ -560,8 +560,8 @@ mod tests {
} }
#[test] #[test]
fn test_dlist_append() { fn test_dlist_append() {
let a = from_vec(~[1,2,3]); let a = from_vec([1,2,3]);
let b = from_vec(~[4,5,6]); let b = from_vec([4,5,6]);
a.append(b); a.append(b);
assert_eq!(a.len(), 6); assert_eq!(a.len(), 6);
assert_eq!(b.len(), 0); assert_eq!(b.len(), 0);
@ -576,7 +576,7 @@ mod tests {
} }
#[test] #[test]
fn test_dlist_append_empty() { fn test_dlist_append_empty() {
let a = from_vec(~[1,2,3]); let a = from_vec([1,2,3]);
let b = DList::<int>(); let b = DList::<int>();
a.append(b); a.append(b);
assert_eq!(a.len(), 3); assert_eq!(a.len(), 3);
@ -590,7 +590,7 @@ mod tests {
#[test] #[test]
fn test_dlist_append_to_empty() { fn test_dlist_append_to_empty() {
let a = DList::<int>(); let a = DList::<int>();
let b = from_vec(~[4,5,6]); let b = from_vec([4,5,6]);
a.append(b); a.append(b);
assert_eq!(a.len(), 3); assert_eq!(a.len(), 3);
assert_eq!(b.len(), 0); assert_eq!(b.len(), 0);
@ -626,8 +626,8 @@ mod tests {
} }
#[test] #[test]
fn test_dlist_prepend() { fn test_dlist_prepend() {
let a = from_vec(~[1,2,3]); let a = from_vec([1,2,3]);
let b = from_vec(~[4,5,6]); let b = from_vec([4,5,6]);
b.prepend(a); b.prepend(a);
assert_eq!(a.len(), 0); assert_eq!(a.len(), 0);
assert_eq!(b.len(), 6); assert_eq!(b.len(), 6);
@ -642,7 +642,7 @@ mod tests {
} }
#[test] #[test]
fn test_dlist_reverse() { fn test_dlist_reverse() {
let a = from_vec(~[5,4,3,2,1]); let a = from_vec([5,4,3,2,1]);
a.reverse(); a.reverse();
assert_eq!(a.len(), 5); assert_eq!(a.len(), 5);
a.assert_consistent(); assert_eq!(a.pop().get(), 1); a.assert_consistent(); assert_eq!(a.pop().get(), 1);
@ -661,7 +661,7 @@ mod tests {
} }
#[test] #[test]
fn test_dlist_each_node() { fn test_dlist_each_node() {
let a = from_vec(~[1,2,4,5]); let a = from_vec([1,2,4,5]);
for a.each_node |nobe| { for a.each_node |nobe| {
if nobe.data > 3 { if nobe.data > 3 {
a.insert_before(3, nobe); a.insert_before(3, nobe);
@ -678,7 +678,7 @@ mod tests {
} }
#[test] #[test]
fn test_dlist_clear() { fn test_dlist_clear() {
let a = from_vec(~[5,4,3,2,1]); let a = from_vec([5,4,3,2,1]);
a.clear(); a.clear();
assert_eq!(a.len(), 0); assert_eq!(a.len(), 0);
a.assert_consistent(); a.assert_consistent();
@ -686,20 +686,20 @@ mod tests {
#[test] #[test]
fn test_dlist_is_empty() { fn test_dlist_is_empty() {
let empty = DList::<int>(); let empty = DList::<int>();
let full1 = from_vec(~[1,2,3]); let full1 = from_vec([1,2,3]);
assert!(empty.is_empty()); assert!(empty.is_empty());
assert!(!full1.is_empty()); assert!(!full1.is_empty());
} }
#[test] #[test]
fn test_dlist_head_tail() { fn test_dlist_head_tail() {
let l = from_vec(~[1,2,3]); let l = from_vec([1,2,3]);
assert_eq!(l.head(), 1); assert_eq!(l.head(), 1);
assert_eq!(l.tail(), 3); assert_eq!(l.tail(), 3);
assert_eq!(l.len(), 3); assert_eq!(l.len(), 3);
} }
#[test] #[test]
fn test_dlist_pop() { fn test_dlist_pop() {
let l = from_vec(~[1,2,3]); let l = from_vec([1,2,3]);
assert_eq!(l.pop().get(), 1); assert_eq!(l.pop().get(), 1);
assert_eq!(l.tail(), 3); assert_eq!(l.tail(), 3);
assert_eq!(l.head(), 2); assert_eq!(l.head(), 2);
@ -712,7 +712,7 @@ mod tests {
} }
#[test] #[test]
fn test_dlist_pop_tail() { fn test_dlist_pop_tail() {
let l = from_vec(~[1,2,3]); let l = from_vec([1,2,3]);
assert_eq!(l.pop_tail().get(), 3); assert_eq!(l.pop_tail().get(), 3);
assert_eq!(l.tail(), 2); assert_eq!(l.tail(), 2);
assert_eq!(l.head(), 1); assert_eq!(l.head(), 1);
@ -758,7 +758,7 @@ mod tests {
} }
#[test] #[test]
fn test_dlist_break_early() { fn test_dlist_break_early() {
let l = from_vec(~[1,2,3,4,5]); let l = from_vec([1,2,3,4,5]);
let mut x = 0; let mut x = 0;
for l.each |i| { for l.each |i| {
x += 1; x += 1;

15
src/libextra/fileinput.rs
View file

@ -96,8 +96,6 @@ total line count).
use core::prelude::*; use core::prelude::*;
use core::io::ReaderUtil;
/** /**
A summary of the internal state of a `FileInput` object. `line_num` A summary of the internal state of a `FileInput` object. `line_num`
and `line_num_file` represent the number of lines read in total and in and `line_num_file` represent the number of lines read in total and in
@ -407,7 +405,6 @@ pub fn input_vec_state(files: ~[Option<Path>],
mod test { mod test {
use core::prelude::*; use core::prelude::*;
use core::io::WriterUtil;
use super::{FileInput, pathify, input_vec, input_vec_state}; use super::{FileInput, pathify, input_vec, input_vec_state};
fn make_file(path : &Path, contents: &[~str]) { fn make_file(path : &Path, contents: &[~str]) {
@ -441,7 +438,7 @@ mod test {
// 3 files containing 0\n, 1\n, and 2\n respectively // 3 files containing 0\n, 1\n, and 2\n respectively
for filenames.eachi |i, &filename| { for filenames.eachi |i, &filename| {
make_file(filename.get_ref(), ~[fmt!("%u", i)]); make_file(filename.get_ref(), [fmt!("%u", i)]);
} }
let fi = FileInput::from_vec(copy filenames); let fi = FileInput::from_vec(copy filenames);
@ -471,7 +468,7 @@ mod test {
// 3 files containing 1\n, 2\n, and 3\n respectively // 3 files containing 1\n, 2\n, and 3\n respectively
for filenames.eachi |i, &filename| { for filenames.eachi |i, &filename| {
make_file(filename.get_ref(), ~[fmt!("%u", i)]); make_file(filename.get_ref(), [fmt!("%u", i)]);
} }
let fi = FileInput::from_vec(filenames); let fi = FileInput::from_vec(filenames);
@ -533,9 +530,9 @@ mod test {
3, 3,
|i| fmt!("tmp/lib-fileinput-test-empty-files-%u.tmp", i)),true); |i| fmt!("tmp/lib-fileinput-test-empty-files-%u.tmp", i)),true);
make_file(filenames[0].get_ref(), ~[~"1", ~"2"]); make_file(filenames[0].get_ref(), [~"1", ~"2"]);
make_file(filenames[1].get_ref(), ~[]); make_file(filenames[1].get_ref(), []);
make_file(filenames[2].get_ref(), ~[~"3", ~"4"]); make_file(filenames[2].get_ref(), [~"3", ~"4"]);
let mut count = 0; let mut count = 0;
for input_vec_state(copy filenames) |line, state| { for input_vec_state(copy filenames) |line, state| {
@ -580,7 +577,7 @@ mod test {
make_file(&filename.get(), contents); make_file(&filename.get(), contents);
} }
let mut in = FileInput::from_vec(filenames); let in = FileInput::from_vec(filenames);
// read once from 0 // read once from 0
assert_eq!(in.read_line(), ~"0 1"); assert_eq!(in.read_line(), ~"0 1");

55
src/libextra/flate.rs
View file

@ -16,12 +16,8 @@ Simple compression
use core::prelude::*; use core::prelude::*;
use core::libc::{c_void, size_t, c_int};
use core::libc; use core::libc;
use core::vec; use core::libc::{c_void, size_t, c_int};
#[cfg(test)] use core::rand;
#[cfg(test)] use core::rand::RngUtil;
pub mod rustrt { pub mod rustrt {
use core::libc::{c_int, c_void, size_t}; use core::libc::{c_int, c_void, size_t};
@ -83,27 +79,34 @@ pub fn inflate_bytes(bytes: &const [u8]) -> ~[u8] {
} }
} }
#[test] #[cfg(test)]
#[allow(non_implicitly_copyable_typarams)] mod tests {
fn test_flate_round_trip() { use super::*;
let mut r = rand::rng(); use core::rand;
let mut words = ~[]; use core::rand::RngUtil;
for 20.times {
let range = r.gen_uint_range(1, 10); #[test]
words.push(r.gen_bytes(range)); #[allow(non_implicitly_copyable_typarams)]
} fn test_flate_round_trip() {
for 20.times { let mut r = rand::rng();
let mut in = ~[]; let mut words = ~[];
for 2000.times { for 20.times {
in.push_all(r.choose(words)); let range = r.gen_uint_range(1, 10);
words.push(r.gen_bytes(range));
}
for 20.times {
let mut in = ~[];
for 2000.times {
in.push_all(r.choose(words));
}
debug!("de/inflate of %u bytes of random word-sequences",
in.len());
let cmp = deflate_bytes(in);
let out = inflate_bytes(cmp);
debug!("%u bytes deflated to %u (%.1f%% size)",
in.len(), cmp.len(),
100.0 * ((cmp.len() as float) / (in.len() as float)));
assert_eq!(in, out);
} }
debug!("de/inflate of %u bytes of random word-sequences",
in.len());
let cmp = deflate_bytes(in);
let out = inflate_bytes(cmp);
debug!("%u bytes deflated to %u (%.1f%% size)",
in.len(), cmp.len(),
100.0 * ((cmp.len() as float) / (in.len() as float)));
assert_eq!(in, out);
} }
} }

255
src/libextra/getopts.rs
View file

@ -681,12 +681,12 @@ mod tests {
#[test] #[test]
fn test_reqopt_long() { fn test_reqopt_long() {
let args = ~[~"--test=20"]; let args = ~[~"--test=20"];
let opts = ~[reqopt(~"test")]; let opts = ~[reqopt("test")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Ok(ref m) => { Ok(ref m) => {
assert!((opt_present(m, ~"test"))); assert!((opt_present(m, "test")));
assert_eq!(opt_str(m, ~"test"), ~"20"); assert_eq!(opt_str(m, "test"), ~"20");
} }
_ => { fail!("test_reqopt_long failed"); } _ => { fail!("test_reqopt_long failed"); }
} }
@ -695,7 +695,7 @@ mod tests {
#[test] #[test]
fn test_reqopt_long_missing() { fn test_reqopt_long_missing() {
let args = ~[~"blah"]; let args = ~[~"blah"];
let opts = ~[reqopt(~"test")]; let opts = ~[reqopt("test")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Err(copy f) => check_fail_type(f, OptionMissing_), Err(copy f) => check_fail_type(f, OptionMissing_),
@ -706,7 +706,7 @@ mod tests {
#[test] #[test]
fn test_reqopt_long_no_arg() { fn test_reqopt_long_no_arg() {
let args = ~[~"--test"]; let args = ~[~"--test"];
let opts = ~[reqopt(~"test")]; let opts = ~[reqopt("test")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Err(copy f) => check_fail_type(f, ArgumentMissing_), Err(copy f) => check_fail_type(f, ArgumentMissing_),
@ -717,7 +717,7 @@ mod tests {
#[test] #[test]
fn test_reqopt_long_multi() { fn test_reqopt_long_multi() {
let args = ~[~"--test=20", ~"--test=30"]; let args = ~[~"--test=20", ~"--test=30"];
let opts = ~[reqopt(~"test")]; let opts = ~[reqopt("test")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Err(copy f) => check_fail_type(f, OptionDuplicated_), Err(copy f) => check_fail_type(f, OptionDuplicated_),
@ -728,12 +728,12 @@ mod tests {
#[test] #[test]
fn test_reqopt_short() { fn test_reqopt_short() {
let args = ~[~"-t", ~"20"]; let args = ~[~"-t", ~"20"];
let opts = ~[reqopt(~"t")]; let opts = ~[reqopt("t")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Ok(ref m) => { Ok(ref m) => {
assert!((opt_present(m, ~"t"))); assert!((opt_present(m, "t")));
assert_eq!(opt_str(m, ~"t"), ~"20"); assert_eq!(opt_str(m, "t"), ~"20");
} }
_ => fail!() _ => fail!()
} }
@ -742,7 +742,7 @@ mod tests {
#[test] #[test]
fn test_reqopt_short_missing() { fn test_reqopt_short_missing() {
let args = ~[~"blah"]; let args = ~[~"blah"];
let opts = ~[reqopt(~"t")]; let opts = ~[reqopt("t")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Err(copy f) => check_fail_type(f, OptionMissing_), Err(copy f) => check_fail_type(f, OptionMissing_),
@ -753,7 +753,7 @@ mod tests {
#[test] #[test]
fn test_reqopt_short_no_arg() { fn test_reqopt_short_no_arg() {
let args = ~[~"-t"]; let args = ~[~"-t"];
let opts = ~[reqopt(~"t")]; let opts = ~[reqopt("t")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Err(copy f) => check_fail_type(f, ArgumentMissing_), Err(copy f) => check_fail_type(f, ArgumentMissing_),
@ -764,7 +764,7 @@ mod tests {
#[test] #[test]
fn test_reqopt_short_multi() { fn test_reqopt_short_multi() {
let args = ~[~"-t", ~"20", ~"-t", ~"30"]; let args = ~[~"-t", ~"20", ~"-t", ~"30"];
let opts = ~[reqopt(~"t")]; let opts = ~[reqopt("t")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Err(copy f) => check_fail_type(f, OptionDuplicated_), Err(copy f) => check_fail_type(f, OptionDuplicated_),
@ -777,12 +777,12 @@ mod tests {
#[test] #[test]
fn test_optopt_long() { fn test_optopt_long() {
let args = ~[~"--test=20"]; let args = ~[~"--test=20"];
let opts = ~[optopt(~"test")]; let opts = ~[optopt("test")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Ok(ref m) => { Ok(ref m) => {
assert!((opt_present(m, ~"test"))); assert!((opt_present(m, "test")));
assert_eq!(opt_str(m, ~"test"), ~"20"); assert_eq!(opt_str(m, "test"), ~"20");
} }
_ => fail!() _ => fail!()
} }
@ -791,10 +791,10 @@ mod tests {
#[test] #[test]
fn test_optopt_long_missing() { fn test_optopt_long_missing() {
let args = ~[~"blah"]; let args = ~[~"blah"];
let opts = ~[optopt(~"test")]; let opts = ~[optopt("test")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Ok(ref m) => assert!(!opt_present(m, ~"test")), Ok(ref m) => assert!(!opt_present(m, "test")),
_ => fail!() _ => fail!()
} }
} }
@ -802,7 +802,7 @@ mod tests {
#[test] #[test]
fn test_optopt_long_no_arg() { fn test_optopt_long_no_arg() {
let args = ~[~"--test"]; let args = ~[~"--test"];
let opts = ~[optopt(~"test")]; let opts = ~[optopt("test")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Err(copy f) => check_fail_type(f, ArgumentMissing_), Err(copy f) => check_fail_type(f, ArgumentMissing_),
@ -813,7 +813,7 @@ mod tests {
#[test] #[test]
fn test_optopt_long_multi() { fn test_optopt_long_multi() {
let args = ~[~"--test=20", ~"--test=30"]; let args = ~[~"--test=20", ~"--test=30"];
let opts = ~[optopt(~"test")]; let opts = ~[optopt("test")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Err(copy f) => check_fail_type(f, OptionDuplicated_), Err(copy f) => check_fail_type(f, OptionDuplicated_),
@ -824,12 +824,12 @@ mod tests {
#[test] #[test]
fn test_optopt_short() { fn test_optopt_short() {
let args = ~[~"-t", ~"20"]; let args = ~[~"-t", ~"20"];
let opts = ~[optopt(~"t")]; let opts = ~[optopt("t")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Ok(ref m) => { Ok(ref m) => {
assert!((opt_present(m, ~"t"))); assert!((opt_present(m, "t")));
assert_eq!(opt_str(m, ~"t"), ~"20"); assert_eq!(opt_str(m, "t"), ~"20");
} }
_ => fail!() _ => fail!()
} }
@ -838,10 +838,10 @@ mod tests {
#[test] #[test]
fn test_optopt_short_missing() { fn test_optopt_short_missing() {
let args = ~[~"blah"]; let args = ~[~"blah"];
let opts = ~[optopt(~"t")]; let opts = ~[optopt("t")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Ok(ref m) => assert!(!opt_present(m, ~"t")), Ok(ref m) => assert!(!opt_present(m, "t")),
_ => fail!() _ => fail!()
} }
} }
@ -849,7 +849,7 @@ mod tests {
#[test] #[test]
fn test_optopt_short_no_arg() { fn test_optopt_short_no_arg() {
let args = ~[~"-t"]; let args = ~[~"-t"];
let opts = ~[optopt(~"t")]; let opts = ~[optopt("t")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Err(copy f) => check_fail_type(f, ArgumentMissing_), Err(copy f) => check_fail_type(f, ArgumentMissing_),
@ -860,7 +860,7 @@ mod tests {
#[test] #[test]
fn test_optopt_short_multi() { fn test_optopt_short_multi() {
let args = ~[~"-t", ~"20", ~"-t", ~"30"]; let args = ~[~"-t", ~"20", ~"-t", ~"30"];
let opts = ~[optopt(~"t")]; let opts = ~[optopt("t")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Err(copy f) => check_fail_type(f, OptionDuplicated_), Err(copy f) => check_fail_type(f, OptionDuplicated_),
@ -873,10 +873,10 @@ mod tests {
#[test] #[test]
fn test_optflag_long() { fn test_optflag_long() {
let args = ~[~"--test"]; let args = ~[~"--test"];
let opts = ~[optflag(~"test")]; let opts = ~[optflag("test")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Ok(ref m) => assert!(opt_present(m, ~"test")), Ok(ref m) => assert!(opt_present(m, "test")),
_ => fail!() _ => fail!()
} }
} }
@ -884,10 +884,10 @@ mod tests {
#[test] #[test]
fn test_optflag_long_missing() { fn test_optflag_long_missing() {
let args = ~[~"blah"]; let args = ~[~"blah"];
let opts = ~[optflag(~"test")]; let opts = ~[optflag("test")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Ok(ref m) => assert!(!opt_present(m, ~"test")), Ok(ref m) => assert!(!opt_present(m, "test")),
_ => fail!() _ => fail!()
} }
} }
@ -895,7 +895,7 @@ mod tests {
#[test] #[test]
fn test_optflag_long_arg() { fn test_optflag_long_arg() {
let args = ~[~"--test=20"]; let args = ~[~"--test=20"];
let opts = ~[optflag(~"test")]; let opts = ~[optflag("test")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Err(copy f) => { Err(copy f) => {
@ -909,7 +909,7 @@ mod tests {
#[test] #[test]
fn test_optflag_long_multi() { fn test_optflag_long_multi() {
let args = ~[~"--test", ~"--test"]; let args = ~[~"--test", ~"--test"];
let opts = ~[optflag(~"test")]; let opts = ~[optflag("test")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Err(copy f) => check_fail_type(f, OptionDuplicated_), Err(copy f) => check_fail_type(f, OptionDuplicated_),
@ -920,10 +920,10 @@ mod tests {
#[test] #[test]
fn test_optflag_short() { fn test_optflag_short() {
let args = ~[~"-t"]; let args = ~[~"-t"];
let opts = ~[optflag(~"t")]; let opts = ~[optflag("t")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Ok(ref m) => assert!(opt_present(m, ~"t")), Ok(ref m) => assert!(opt_present(m, "t")),
_ => fail!() _ => fail!()
} }
} }
@ -931,10 +931,10 @@ mod tests {
#[test] #[test]
fn test_optflag_short_missing() { fn test_optflag_short_missing() {
let args = ~[~"blah"]; let args = ~[~"blah"];
let opts = ~[optflag(~"t")]; let opts = ~[optflag("t")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Ok(ref m) => assert!(!opt_present(m, ~"t")), Ok(ref m) => assert!(!opt_present(m, "t")),
_ => fail!() _ => fail!()
} }
} }
@ -942,7 +942,7 @@ mod tests {
#[test] #[test]
fn test_optflag_short_arg() { fn test_optflag_short_arg() {
let args = ~[~"-t", ~"20"]; let args = ~[~"-t", ~"20"];
let opts = ~[optflag(~"t")]; let opts = ~[optflag("t")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Ok(ref m) => { Ok(ref m) => {
@ -957,7 +957,7 @@ mod tests {
#[test] #[test]
fn test_optflag_short_multi() { fn test_optflag_short_multi() {
let args = ~[~"-t", ~"-t"]; let args = ~[~"-t", ~"-t"];
let opts = ~[optflag(~"t")]; let opts = ~[optflag("t")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Err(copy f) => check_fail_type(f, OptionDuplicated_), Err(copy f) => check_fail_type(f, OptionDuplicated_),
@ -969,11 +969,11 @@ mod tests {
#[test] #[test]
fn test_optflagmulti_short1() { fn test_optflagmulti_short1() {
let args = ~[~"-v"]; let args = ~[~"-v"];
let opts = ~[optflagmulti(~"v")]; let opts = ~[optflagmulti("v")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Ok(ref m) => { Ok(ref m) => {
assert_eq!(opt_count(m, ~"v"), 1); assert_eq!(opt_count(m, "v"), 1);
} }
_ => fail!() _ => fail!()
} }
@ -982,11 +982,11 @@ mod tests {
#[test] #[test]
fn test_optflagmulti_short2a() { fn test_optflagmulti_short2a() {
let args = ~[~"-v", ~"-v"]; let args = ~[~"-v", ~"-v"];
let opts = ~[optflagmulti(~"v")]; let opts = ~[optflagmulti("v")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Ok(ref m) => { Ok(ref m) => {
assert_eq!(opt_count(m, ~"v"), 2); assert_eq!(opt_count(m, "v"), 2);
} }
_ => fail!() _ => fail!()
} }
@ -995,11 +995,11 @@ mod tests {
#[test] #[test]
fn test_optflagmulti_short2b() { fn test_optflagmulti_short2b() {
let args = ~[~"-vv"]; let args = ~[~"-vv"];
let opts = ~[optflagmulti(~"v")]; let opts = ~[optflagmulti("v")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Ok(ref m) => { Ok(ref m) => {
assert_eq!(opt_count(m, ~"v"), 2); assert_eq!(opt_count(m, "v"), 2);
} }
_ => fail!() _ => fail!()
} }
@ -1008,11 +1008,11 @@ mod tests {
#[test] #[test]
fn test_optflagmulti_long1() { fn test_optflagmulti_long1() {
let args = ~[~"--verbose"]; let args = ~[~"--verbose"];
let opts = ~[optflagmulti(~"verbose")]; let opts = ~[optflagmulti("verbose")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Ok(ref m) => { Ok(ref m) => {
assert_eq!(opt_count(m, ~"verbose"), 1); assert_eq!(opt_count(m, "verbose"), 1);
} }
_ => fail!() _ => fail!()
} }
@ -1021,11 +1021,11 @@ mod tests {
#[test] #[test]
fn test_optflagmulti_long2() { fn test_optflagmulti_long2() {
let args = ~[~"--verbose", ~"--verbose"]; let args = ~[~"--verbose", ~"--verbose"];
let opts = ~[optflagmulti(~"verbose")]; let opts = ~[optflagmulti("verbose")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Ok(ref m) => { Ok(ref m) => {
assert_eq!(opt_count(m, ~"verbose"), 2); assert_eq!(opt_count(m, "verbose"), 2);
} }
_ => fail!() _ => fail!()
} }
@ -1035,12 +1035,12 @@ mod tests {
#[test] #[test]
fn test_optmulti_long() { fn test_optmulti_long() {
let args = ~[~"--test=20"]; let args = ~[~"--test=20"];
let opts = ~[optmulti(~"test")]; let opts = ~[optmulti("test")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Ok(ref m) => { Ok(ref m) => {
assert!((opt_present(m, ~"test"))); assert!((opt_present(m, "test")));
assert_eq!(opt_str(m, ~"test"), ~"20"); assert_eq!(opt_str(m, "test"), ~"20");
} }
_ => fail!() _ => fail!()
} }
@ -1049,10 +1049,10 @@ mod tests {
#[test] #[test]
fn test_optmulti_long_missing() { fn test_optmulti_long_missing() {
let args = ~[~"blah"]; let args = ~[~"blah"];
let opts = ~[optmulti(~"test")]; let opts = ~[optmulti("test")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Ok(ref m) => assert!(!opt_present(m, ~"test")), Ok(ref m) => assert!(!opt_present(m, "test")),
_ => fail!() _ => fail!()
} }
} }
@ -1060,7 +1060,7 @@ mod tests {
#[test] #[test]
fn test_optmulti_long_no_arg() { fn test_optmulti_long_no_arg() {
let args = ~[~"--test"]; let args = ~[~"--test"];
let opts = ~[optmulti(~"test")]; let opts = ~[optmulti("test")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Err(copy f) => check_fail_type(f, ArgumentMissing_), Err(copy f) => check_fail_type(f, ArgumentMissing_),
@ -1071,13 +1071,13 @@ mod tests {
#[test] #[test]
fn test_optmulti_long_multi() { fn test_optmulti_long_multi() {
let args = ~[~"--test=20", ~"--test=30"]; let args = ~[~"--test=20", ~"--test=30"];
let opts = ~[optmulti(~"test")]; let opts = ~[optmulti("test")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Ok(ref m) => { Ok(ref m) => {
assert!(opt_present(m, ~"test")); assert!(opt_present(m, "test"));
assert_eq!(opt_str(m, ~"test"), ~"20"); assert_eq!(opt_str(m, "test"), ~"20");
let pair = opt_strs(m, ~"test"); let pair = opt_strs(m, "test");
assert!(pair[0] == ~"20"); assert!(pair[0] == ~"20");
assert!(pair[1] == ~"30"); assert!(pair[1] == ~"30");
} }
@ -1088,12 +1088,12 @@ mod tests {
#[test] #[test]
fn test_optmulti_short() { fn test_optmulti_short() {
let args = ~[~"-t", ~"20"]; let args = ~[~"-t", ~"20"];
let opts = ~[optmulti(~"t")]; let opts = ~[optmulti("t")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Ok(ref m) => { Ok(ref m) => {
assert!((opt_present(m, ~"t"))); assert!((opt_present(m, "t")));
assert_eq!(opt_str(m, ~"t"), ~"20"); assert_eq!(opt_str(m, "t"), ~"20");
} }
_ => fail!() _ => fail!()
} }
@ -1102,10 +1102,10 @@ mod tests {
#[test] #[test]
fn test_optmulti_short_missing() { fn test_optmulti_short_missing() {
let args = ~[~"blah"]; let args = ~[~"blah"];
let opts = ~[optmulti(~"t")]; let opts = ~[optmulti("t")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Ok(ref m) => assert!(!opt_present(m, ~"t")), Ok(ref m) => assert!(!opt_present(m, "t")),
_ => fail!() _ => fail!()
} }
} }
@ -1113,7 +1113,7 @@ mod tests {
#[test] #[test]
fn test_optmulti_short_no_arg() { fn test_optmulti_short_no_arg() {
let args = ~[~"-t"]; let args = ~[~"-t"];
let opts = ~[optmulti(~"t")]; let opts = ~[optmulti("t")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Err(copy f) => check_fail_type(f, ArgumentMissing_), Err(copy f) => check_fail_type(f, ArgumentMissing_),
@ -1124,13 +1124,13 @@ mod tests {
#[test] #[test]
fn test_optmulti_short_multi() { fn test_optmulti_short_multi() {
let args = ~[~"-t", ~"20", ~"-t", ~"30"]; let args = ~[~"-t", ~"20", ~"-t", ~"30"];
let opts = ~[optmulti(~"t")]; let opts = ~[optmulti("t")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Ok(ref m) => { Ok(ref m) => {
assert!((opt_present(m, ~"t"))); assert!((opt_present(m, "t")));
assert_eq!(opt_str(m, ~"t"), ~"20"); assert_eq!(opt_str(m, "t"), ~"20");
let pair = opt_strs(m, ~"t"); let pair = opt_strs(m, "t");
assert!(pair[0] == ~"20"); assert!(pair[0] == ~"20");
assert!(pair[1] == ~"30"); assert!(pair[1] == ~"30");
} }
@ -1141,7 +1141,7 @@ mod tests {
#[test] #[test]
fn test_unrecognized_option_long() { fn test_unrecognized_option_long() {
let args = ~[~"--untest"]; let args = ~[~"--untest"];
let opts = ~[optmulti(~"t")]; let opts = ~[optmulti("t")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Err(copy f) => check_fail_type(f, UnrecognizedOption_), Err(copy f) => check_fail_type(f, UnrecognizedOption_),
@ -1152,7 +1152,7 @@ mod tests {
#[test] #[test]
fn test_unrecognized_option_short() { fn test_unrecognized_option_short() {
let args = ~[~"-t"]; let args = ~[~"-t"];
let opts = ~[optmulti(~"test")]; let opts = ~[optmulti("test")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Err(copy f) => check_fail_type(f, UnrecognizedOption_), Err(copy f) => check_fail_type(f, UnrecognizedOption_),
@ -1167,26 +1167,26 @@ mod tests {
~"--flag", ~"--long=30", ~"-f", ~"-m", ~"40", ~"--flag", ~"--long=30", ~"-f", ~"-m", ~"40",
~"-m", ~"50", ~"-n", ~"-A B", ~"-n", ~"-60 70"]; ~"-m", ~"50", ~"-n", ~"-A B", ~"-n", ~"-60 70"];
let opts = let opts =
~[optopt(~"s"), optflag(~"flag"), reqopt(~"long"), ~[optopt("s"), optflag("flag"), reqopt("long"),
optflag(~"f"), optmulti(~"m"), optmulti(~"n"), optflag("f"), optmulti("m"), optmulti("n"),
optopt(~"notpresent")]; optopt("notpresent")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Ok(ref m) => { Ok(ref m) => {
assert!(m.free[0] == ~"prog"); assert!(m.free[0] == ~"prog");
assert!(m.free[1] == ~"free1"); assert!(m.free[1] == ~"free1");
assert_eq!(opt_str(m, ~"s"), ~"20"); assert_eq!(opt_str(m, "s"), ~"20");
assert!(m.free[2] == ~"free2"); assert!(m.free[2] == ~"free2");
assert!((opt_present(m, ~"flag"))); assert!((opt_present(m, "flag")));
assert_eq!(opt_str(m, ~"long"), ~"30"); assert_eq!(opt_str(m, "long"), ~"30");
assert!((opt_present(m, ~"f"))); assert!((opt_present(m, "f")));
let pair = opt_strs(m, ~"m"); let pair = opt_strs(m, "m");
assert!(pair[0] == ~"40"); assert!(pair[0] == ~"40");
assert!(pair[1] == ~"50"); assert!(pair[1] == ~"50");
let pair = opt_strs(m, ~"n"); let pair = opt_strs(m, "n");
assert!(pair[0] == ~"-A B"); assert!(pair[0] == ~"-A B");
assert!(pair[1] == ~"-60 70"); assert!(pair[1] == ~"-60 70");
assert!((!opt_present(m, ~"notpresent"))); assert!((!opt_present(m, "notpresent")));
} }
_ => fail!() _ => fail!()
} }
@ -1195,43 +1195,43 @@ mod tests {
#[test] #[test]
fn test_multi() { fn test_multi() {
let args = ~[~"-e", ~"foo", ~"--encrypt", ~"foo"]; let args = ~[~"-e", ~"foo", ~"--encrypt", ~"foo"];
let opts = ~[optopt(~"e"), optopt(~"encrypt"), optopt(~"f")]; let opts = ~[optopt("e"), optopt("encrypt"), optopt("f")];
let matches = &match getopts(args, opts) { let matches = &match getopts(args, opts) {
result::Ok(m) => m, result::Ok(m) => m,
result::Err(_) => fail!() result::Err(_) => fail!()
}; };
assert!(opts_present(matches, ~[~"e"])); assert!(opts_present(matches, [~"e"]));
assert!(opts_present(matches, ~[~"encrypt"])); assert!(opts_present(matches, [~"encrypt"]));
assert!(opts_present(matches, ~[~"encrypt", ~"e"])); assert!(opts_present(matches, [~"encrypt", ~"e"]));
assert!(opts_present(matches, ~[~"e", ~"encrypt"])); assert!(opts_present(matches, [~"e", ~"encrypt"]));
assert!(!opts_present(matches, ~[~"f"])); assert!(!opts_present(matches, [~"f"]));
assert!(!opts_present(matches, ~[~"thing"])); assert!(!opts_present(matches, [~"thing"]));
assert!(!opts_present(matches, ~[])); assert!(!opts_present(matches, []));
assert_eq!(opts_str(matches, ~[~"e"]), ~"foo"); assert_eq!(opts_str(matches, [~"e"]), ~"foo");
assert_eq!(opts_str(matches, ~[~"encrypt"]), ~"foo"); assert_eq!(opts_str(matches, [~"encrypt"]), ~"foo");
assert_eq!(opts_str(matches, ~[~"e", ~"encrypt"]), ~"foo"); assert_eq!(opts_str(matches, [~"e", ~"encrypt"]), ~"foo");
assert_eq!(opts_str(matches, ~[~"encrypt", ~"e"]), ~"foo"); assert_eq!(opts_str(matches, [~"encrypt", ~"e"]), ~"foo");
} }
#[test] #[test]
fn test_nospace() { fn test_nospace() {
let args = ~[~"-Lfoo", ~"-M."]; let args = ~[~"-Lfoo", ~"-M."];
let opts = ~[optmulti(~"L"), optmulti(~"M")]; let opts = ~[optmulti("L"), optmulti("M")];
let matches = &match getopts(args, opts) { let matches = &match getopts(args, opts) {
result::Ok(m) => m, result::Ok(m) => m,
result::Err(_) => fail!() result::Err(_) => fail!()
}; };
assert!(opts_present(matches, ~[~"L"])); assert!(opts_present(matches, [~"L"]));
assert_eq!(opts_str(matches, ~[~"L"]), ~"foo"); assert_eq!(opts_str(matches, [~"L"]), ~"foo");
assert!(opts_present(matches, ~[~"M"])); assert!(opts_present(matches, [~"M"]));
assert_eq!(opts_str(matches, ~[~"M"]), ~"."); assert_eq!(opts_str(matches, [~"M"]), ~".");
} }
#[test] #[test]
fn test_groups_reqopt() { fn test_groups_reqopt() {
let opt = groups::reqopt(~"b", ~"banana", ~"some bananas", ~"VAL"); let opt = groups::reqopt("b", "banana", "some bananas", "VAL");
assert!(opt == OptGroup { short_name: ~"b", assert!(opt == OptGroup { short_name: ~"b",
long_name: ~"banana", long_name: ~"banana",
hint: ~"VAL", hint: ~"VAL",
@ -1242,7 +1242,7 @@ mod tests {
#[test] #[test]
fn test_groups_optopt() { fn test_groups_optopt() {
let opt = groups::optopt(~"a", ~"apple", ~"some apples", ~"VAL"); let opt = groups::optopt("a", "apple", "some apples", "VAL");
assert!(opt == OptGroup { short_name: ~"a", assert!(opt == OptGroup { short_name: ~"a",
long_name: ~"apple", long_name: ~"apple",
hint: ~"VAL", hint: ~"VAL",
@ -1253,7 +1253,7 @@ mod tests {
#[test] #[test]
fn test_groups_optflag() { fn test_groups_optflag() {
let opt = groups::optflag(~"k", ~"kiwi", ~"some kiwis"); let opt = groups::optflag("k", "kiwi", "some kiwis");
assert!(opt == OptGroup { short_name: ~"k", assert!(opt == OptGroup { short_name: ~"k",
long_name: ~"kiwi", long_name: ~"kiwi",
hint: ~"", hint: ~"",
@ -1264,8 +1264,7 @@ mod tests {
#[test] #[test]
fn test_groups_optflagopt() { fn test_groups_optflagopt() {
let opt = groups::optflagopt(~"p", ~"pineapple", let opt = groups::optflagopt("p", "pineapple", "some pineapples", "VAL");
~"some pineapples", ~"VAL");
assert!(opt == OptGroup { short_name: ~"p", assert!(opt == OptGroup { short_name: ~"p",
long_name: ~"pineapple", long_name: ~"pineapple",
hint: ~"VAL", hint: ~"VAL",
@ -1276,8 +1275,7 @@ mod tests {
#[test] #[test]
fn test_groups_optmulti() { fn test_groups_optmulti() {
let opt = groups::optmulti(~"l", ~"lime", let opt = groups::optmulti("l", "lime", "some limes", "VAL");
~"some limes", ~"VAL");
assert!(opt == OptGroup { short_name: ~"l", assert!(opt == OptGroup { short_name: ~"l",
long_name: ~"lime", long_name: ~"lime",
hint: ~"VAL", hint: ~"VAL",
@ -1288,9 +1286,8 @@ mod tests {
#[test] #[test]
fn test_groups_long_to_short() { fn test_groups_long_to_short() {
let short = ~[reqopt(~"b"), reqopt(~"banana")]; let short = ~[reqopt("b"), reqopt("banana")];
let verbose = groups::reqopt(~"b", ~"banana", let verbose = groups::reqopt("b", "banana", "some bananas", "VAL");
~"some bananas", ~"VAL");
assert_eq!(groups::long_to_short(&verbose), short); assert_eq!(groups::long_to_short(&verbose), short);
} }
@ -1298,19 +1295,19 @@ mod tests {
#[test] #[test]
fn test_groups_getopts() { fn test_groups_getopts() {
let short = ~[ let short = ~[
reqopt(~"b"), reqopt(~"banana"), reqopt("b"), reqopt("banana"),
optopt(~"a"), optopt(~"apple"), optopt("a"), optopt("apple"),
optflag(~"k"), optflagopt(~"kiwi"), optflag("k"), optflagopt("kiwi"),
optflagopt(~"p"), optflagopt("p"),
optmulti(~"l") optmulti("l")
]; ];
let verbose = ~[ let verbose = ~[
groups::reqopt(~"b", ~"banana", ~"Desc", ~"VAL"), groups::reqopt("b", "banana", "Desc", "VAL"),
groups::optopt(~"a", ~"apple", ~"Desc", ~"VAL"), groups::optopt("a", "apple", "Desc", "VAL"),
groups::optflag(~"k", ~"kiwi", ~"Desc"), groups::optflag("k", "kiwi", "Desc"),
groups::optflagopt(~"p", ~"", ~"Desc", ~"VAL"), groups::optflagopt("p", "", "Desc", "VAL"),
groups::optmulti(~"l", ~"", ~"Desc", ~"VAL"), groups::optmulti("l", "", "Desc", "VAL"),
]; ];
let sample_args = ~[~"-k", ~"15", ~"--apple", ~"1", ~"k", let sample_args = ~[~"-k", ~"15", ~"--apple", ~"1", ~"k",
@ -1324,12 +1321,12 @@ mod tests {
#[test] #[test]
fn test_groups_usage() { fn test_groups_usage() {
let optgroups = ~[ let optgroups = ~[
groups::reqopt(~"b", ~"banana", ~"Desc", ~"VAL"), groups::reqopt("b", "banana", "Desc", "VAL"),
groups::optopt(~"a", ~"012345678901234567890123456789", groups::optopt("a", "012345678901234567890123456789",
~"Desc", ~"VAL"), "Desc", "VAL"),
groups::optflag(~"k", ~"kiwi", ~"Desc"), groups::optflag("k", "kiwi", "Desc"),
groups::optflagopt(~"p", ~"", ~"Desc", ~"VAL"), groups::optflagopt("p", "", "Desc", "VAL"),
groups::optmulti(~"l", ~"", ~"Desc", ~"VAL"), groups::optmulti("l", "", "Desc", "VAL"),
]; ];
let expected = let expected =
@ -1345,7 +1342,7 @@ Options:
"; ";
let generated_usage = groups::usage(~"Usage: fruits", optgroups); let generated_usage = groups::usage("Usage: fruits", optgroups);
debug!("expected: <<%s>>", expected); debug!("expected: <<%s>>", expected);
debug!("generated: <<%s>>", generated_usage); debug!("generated: <<%s>>", generated_usage);
@ -1358,10 +1355,10 @@ Options:
// lines wrap after 78: or rather descriptions wrap after 54 // lines wrap after 78: or rather descriptions wrap after 54
let optgroups = ~[ let optgroups = ~[
groups::optflag(~"k", ~"kiwi", groups::optflag("k", "kiwi",
~"This is a long description which won't be wrapped..+.."), // 54 "This is a long description which won't be wrapped..+.."), // 54
groups::optflag(~"a", ~"apple", groups::optflag("a", "apple",
~"This is a long description which _will_ be wrapped..+.."), // 55 "This is a long description which _will_ be wrapped..+.."), // 55
]; ];
let expected = let expected =
@ -1374,7 +1371,7 @@ Options:
"; ";
let usage = groups::usage(~"Usage: fruits", optgroups); let usage = groups::usage("Usage: fruits", optgroups);
debug!("expected: <<%s>>", expected); debug!("expected: <<%s>>", expected);
debug!("generated: <<%s>>", usage); debug!("generated: <<%s>>", usage);

248
src/libextra/json.rs
View file

@ -1444,15 +1444,15 @@ mod tests {
#[test] #[test]
fn test_write_object() { fn test_write_object() {
assert_eq!(to_str(&mk_object(~[])), ~"{}"); assert_eq!(to_str(&mk_object([])), ~"{}");
assert_eq!(to_pretty_str(&mk_object(~[])), ~"{}"); assert_eq!(to_pretty_str(&mk_object([])), ~"{}");
assert_eq!( assert_eq!(
to_str(&mk_object(~[(~"a", Boolean(true))])), to_str(&mk_object([(~"a", Boolean(true))])),
~"{\"a\":true}" ~"{\"a\":true}"
); );
assert_eq!( assert_eq!(
to_pretty_str(&mk_object(~[(~"a", Boolean(true))])), to_pretty_str(&mk_object([(~"a", Boolean(true))])),
~"\ ~"\
{\n \ {\n \
\"a\": true\n\ \"a\": true\n\
@ -1460,10 +1460,10 @@ mod tests {
); );
assert_eq!( assert_eq!(
to_str(&mk_object(~[ to_str(&mk_object([
(~"b", List(~[ (~"b", List(~[
mk_object(~[(~"c", String(~"\x0c\r"))]), mk_object([(~"c", String(~"\x0c\r"))]),
mk_object(~[(~"d", String(~""))]) mk_object([(~"d", String(~""))])
])) ]))
])), ])),
~"{\ ~"{\
@ -1474,10 +1474,10 @@ mod tests {
}" }"
); );
assert_eq!( assert_eq!(
to_pretty_str(&mk_object(~[ to_pretty_str(&mk_object([
(~"b", List(~[ (~"b", List(~[
mk_object(~[(~"c", String(~"\x0c\r"))]), mk_object([(~"c", String(~"\x0c\r"))]),
mk_object(~[(~"d", String(~""))]) mk_object([(~"d", String(~""))])
])) ]))
])), ])),
~"\ ~"\
@ -1493,11 +1493,11 @@ mod tests {
}" }"
); );
let a = mk_object(~[ let a = mk_object([
(~"a", Boolean(true)), (~"a", Boolean(true)),
(~"b", List(~[ (~"b", List(~[
mk_object(~[(~"c", String(~"\x0c\r"))]), mk_object([(~"c", String(~"\x0c\r"))]),
mk_object(~[(~"d", String(~""))]) mk_object([(~"d", String(~""))])
])) ]))
]); ]);
@ -1582,299 +1582,299 @@ mod tests {
#[test] #[test]
fn test_trailing_characters() { fn test_trailing_characters() {
assert_eq!(from_str(~"nulla"), assert_eq!(from_str("nulla"),
Err(Error {line: 1u, col: 5u, msg: @~"trailing characters"})); Err(Error {line: 1u, col: 5u, msg: @~"trailing characters"}));
assert_eq!(from_str(~"truea"), assert_eq!(from_str("truea"),
Err(Error {line: 1u, col: 5u, msg: @~"trailing characters"})); Err(Error {line: 1u, col: 5u, msg: @~"trailing characters"}));
assert_eq!(from_str(~"falsea"), assert_eq!(from_str("falsea"),
Err(Error {line: 1u, col: 6u, msg: @~"trailing characters"})); Err(Error {line: 1u, col: 6u, msg: @~"trailing characters"}));
assert_eq!(from_str(~"1a"), assert_eq!(from_str("1a"),
Err(Error {line: 1u, col: 2u, msg: @~"trailing characters"})); Err(Error {line: 1u, col: 2u, msg: @~"trailing characters"}));
assert_eq!(from_str(~"[]a"), assert_eq!(from_str("[]a"),
Err(Error {line: 1u, col: 3u, msg: @~"trailing characters"})); Err(Error {line: 1u, col: 3u, msg: @~"trailing characters"}));
assert_eq!(from_str(~"{}a"), assert_eq!(from_str("{}a"),
Err(Error {line: 1u, col: 3u, msg: @~"trailing characters"})); Err(Error {line: 1u, col: 3u, msg: @~"trailing characters"}));
} }
#[test] #[test]
fn test_read_identifiers() { fn test_read_identifiers() {
assert_eq!(from_str(~"n"), assert_eq!(from_str("n"),
Err(Error {line: 1u, col: 2u, msg: @~"invalid syntax"})); Err(Error {line: 1u, col: 2u, msg: @~"invalid syntax"}));
assert_eq!(from_str(~"nul"), assert_eq!(from_str("nul"),
Err(Error {line: 1u, col: 4u, msg: @~"invalid syntax"})); Err(Error {line: 1u, col: 4u, msg: @~"invalid syntax"}));
assert_eq!(from_str(~"t"), assert_eq!(from_str("t"),
Err(Error {line: 1u, col: 2u, msg: @~"invalid syntax"})); Err(Error {line: 1u, col: 2u, msg: @~"invalid syntax"}));
assert_eq!(from_str(~"truz"), assert_eq!(from_str("truz"),
Err(Error {line: 1u, col: 4u, msg: @~"invalid syntax"})); Err(Error {line: 1u, col: 4u, msg: @~"invalid syntax"}));
assert_eq!(from_str(~"f"), assert_eq!(from_str("f"),
Err(Error {line: 1u, col: 2u, msg: @~"invalid syntax"})); Err(Error {line: 1u, col: 2u, msg: @~"invalid syntax"}));
assert_eq!(from_str(~"faz"), assert_eq!(from_str("faz"),
Err(Error {line: 1u, col: 3u, msg: @~"invalid syntax"})); Err(Error {line: 1u, col: 3u, msg: @~"invalid syntax"}));
assert_eq!(from_str(~"null"), Ok(Null)); assert_eq!(from_str("null"), Ok(Null));
assert_eq!(from_str(~"true"), Ok(Boolean(true))); assert_eq!(from_str("true"), Ok(Boolean(true)));
assert_eq!(from_str(~"false"), Ok(Boolean(false))); assert_eq!(from_str("false"), Ok(Boolean(false)));
assert_eq!(from_str(~" null "), Ok(Null)); assert_eq!(from_str(" null "), Ok(Null));
assert_eq!(from_str(~" true "), Ok(Boolean(true))); assert_eq!(from_str(" true "), Ok(Boolean(true)));
assert_eq!(from_str(~" false "), Ok(Boolean(false))); assert_eq!(from_str(" false "), Ok(Boolean(false)));
} }
#[test] #[test]
fn test_decode_identifiers() { fn test_decode_identifiers() {
let mut decoder = Decoder(from_str(~"null").unwrap()); let mut decoder = Decoder(from_str("null").unwrap());
let v: () = Decodable::decode(&mut decoder); let v: () = Decodable::decode(&mut decoder);
assert_eq!(v, ()); assert_eq!(v, ());
let mut decoder = Decoder(from_str(~"true").unwrap()); let mut decoder = Decoder(from_str("true").unwrap());
let v: bool = Decodable::decode(&mut decoder); let v: bool = Decodable::decode(&mut decoder);
assert_eq!(v, true); assert_eq!(v, true);
let mut decoder = Decoder(from_str(~"false").unwrap()); let mut decoder = Decoder(from_str("false").unwrap());
let v: bool = Decodable::decode(&mut decoder); let v: bool = Decodable::decode(&mut decoder);
assert_eq!(v, false); assert_eq!(v, false);
} }
#[test] #[test]
fn test_read_number() { fn test_read_number() {
assert_eq!(from_str(~"+"), assert_eq!(from_str("+"),
Err(Error {line: 1u, col: 1u, msg: @~"invalid syntax"})); Err(Error {line: 1u, col: 1u, msg: @~"invalid syntax"}));
assert_eq!(from_str(~"."), assert_eq!(from_str("."),
Err(Error {line: 1u, col: 1u, msg: @~"invalid syntax"})); Err(Error {line: 1u, col: 1u, msg: @~"invalid syntax"}));
assert_eq!(from_str(~"-"), assert_eq!(from_str("-"),
Err(Error {line: 1u, col: 2u, msg: @~"invalid number"})); Err(Error {line: 1u, col: 2u, msg: @~"invalid number"}));
assert_eq!(from_str(~"00"), assert_eq!(from_str("00"),
Err(Error {line: 1u, col: 2u, msg: @~"invalid number"})); Err(Error {line: 1u, col: 2u, msg: @~"invalid number"}));
assert_eq!(from_str(~"1."), assert_eq!(from_str("1."),
Err(Error {line: 1u, col: 3u, msg: @~"invalid number"})); Err(Error {line: 1u, col: 3u, msg: @~"invalid number"}));
assert_eq!(from_str(~"1e"), assert_eq!(from_str("1e"),
Err(Error {line: 1u, col: 3u, msg: @~"invalid number"})); Err(Error {line: 1u, col: 3u, msg: @~"invalid number"}));
assert_eq!(from_str(~"1e+"), assert_eq!(from_str("1e+"),
Err(Error {line: 1u, col: 4u, msg: @~"invalid number"})); Err(Error {line: 1u, col: 4u, msg: @~"invalid number"}));
assert_eq!(from_str(~"3"), Ok(Number(3f))); assert_eq!(from_str("3"), Ok(Number(3f)));
assert_eq!(from_str(~"3.1"), Ok(Number(3.1f))); assert_eq!(from_str("3.1"), Ok(Number(3.1f)));
assert_eq!(from_str(~"-1.2"), Ok(Number(-1.2f))); assert_eq!(from_str("-1.2"), Ok(Number(-1.2f)));
assert_eq!(from_str(~"0.4"), Ok(Number(0.4f))); assert_eq!(from_str("0.4"), Ok(Number(0.4f)));
assert_eq!(from_str(~"0.4e5"), Ok(Number(0.4e5f))); assert_eq!(from_str("0.4e5"), Ok(Number(0.4e5f)));
assert_eq!(from_str(~"0.4e+15"), Ok(Number(0.4e15f))); assert_eq!(from_str("0.4e+15"), Ok(Number(0.4e15f)));
assert_eq!(from_str(~"0.4e-01"), Ok(Number(0.4e-01f))); assert_eq!(from_str("0.4e-01"), Ok(Number(0.4e-01f)));
assert_eq!(from_str(~" 3 "), Ok(Number(3f))); assert_eq!(from_str(" 3 "), Ok(Number(3f)));
} }
#[test] #[test]
fn test_decode_numbers() { fn test_decode_numbers() {
let mut decoder = Decoder(from_str(~"3").unwrap()); let mut decoder = Decoder(from_str("3").unwrap());
let v: float = Decodable::decode(&mut decoder); let v: float = Decodable::decode(&mut decoder);
assert_eq!(v, 3f); assert_eq!(v, 3f);
let mut decoder = Decoder(from_str(~"3.1").unwrap()); let mut decoder = Decoder(from_str("3.1").unwrap());
let v: float = Decodable::decode(&mut decoder); let v: float = Decodable::decode(&mut decoder);
assert_eq!(v, 3.1f); assert_eq!(v, 3.1f);
let mut decoder = Decoder(from_str(~"-1.2").unwrap()); let mut decoder = Decoder(from_str("-1.2").unwrap());
let v: float = Decodable::decode(&mut decoder); let v: float = Decodable::decode(&mut decoder);
assert_eq!(v, -1.2f); assert_eq!(v, -1.2f);
let mut decoder = Decoder(from_str(~"0.4").unwrap()); let mut decoder = Decoder(from_str("0.4").unwrap());
let v: float = Decodable::decode(&mut decoder); let v: float = Decodable::decode(&mut decoder);
assert_eq!(v, 0.4f); assert_eq!(v, 0.4f);
let mut decoder = Decoder(from_str(~"0.4e5").unwrap()); let mut decoder = Decoder(from_str("0.4e5").unwrap());
let v: float = Decodable::decode(&mut decoder); let v: float = Decodable::decode(&mut decoder);
assert_eq!(v, 0.4e5f); assert_eq!(v, 0.4e5f);
let mut decoder = Decoder(from_str(~"0.4e15").unwrap()); let mut decoder = Decoder(from_str("0.4e15").unwrap());
let v: float = Decodable::decode(&mut decoder); let v: float = Decodable::decode(&mut decoder);
assert_eq!(v, 0.4e15f); assert_eq!(v, 0.4e15f);
let mut decoder = Decoder(from_str(~"0.4e-01").unwrap()); let mut decoder = Decoder(from_str("0.4e-01").unwrap());
let v: float = Decodable::decode(&mut decoder); let v: float = Decodable::decode(&mut decoder);
assert_eq!(v, 0.4e-01f); assert_eq!(v, 0.4e-01f);
} }
#[test] #[test]
fn test_read_str() { fn test_read_str() {
assert_eq!(from_str(~"\""), assert_eq!(from_str("\""),
Err(Error {line: 1u, col: 2u, msg: @~"EOF while parsing string" Err(Error {line: 1u, col: 2u, msg: @~"EOF while parsing string"
})); }));
assert_eq!(from_str(~"\"lol"), assert_eq!(from_str("\"lol"),
Err(Error {line: 1u, col: 5u, msg: @~"EOF while parsing string" Err(Error {line: 1u, col: 5u, msg: @~"EOF while parsing string"
})); }));
assert_eq!(from_str(~"\"\""), Ok(String(~""))); assert_eq!(from_str("\"\""), Ok(String(~"")));
assert_eq!(from_str(~"\"foo\""), Ok(String(~"foo"))); assert_eq!(from_str("\"foo\""), Ok(String(~"foo")));
assert_eq!(from_str(~"\"\\\"\""), Ok(String(~"\""))); assert_eq!(from_str("\"\\\"\""), Ok(String(~"\"")));
assert_eq!(from_str(~"\"\\b\""), Ok(String(~"\x08"))); assert_eq!(from_str("\"\\b\""), Ok(String(~"\x08")));
assert_eq!(from_str(~"\"\\n\""), Ok(String(~"\n"))); assert_eq!(from_str("\"\\n\""), Ok(String(~"\n")));
assert_eq!(from_str(~"\"\\r\""), Ok(String(~"\r"))); assert_eq!(from_str("\"\\r\""), Ok(String(~"\r")));
assert_eq!(from_str(~"\"\\t\""), Ok(String(~"\t"))); assert_eq!(from_str("\"\\t\""), Ok(String(~"\t")));
assert_eq!(from_str(~" \"foo\" "), Ok(String(~"foo"))); assert_eq!(from_str(" \"foo\" "), Ok(String(~"foo")));
assert_eq!(from_str(~"\"\\u12ab\""), Ok(String(~"\u12ab"))); assert_eq!(from_str("\"\\u12ab\""), Ok(String(~"\u12ab")));
assert_eq!(from_str(~"\"\\uAB12\""), Ok(String(~"\uAB12"))); assert_eq!(from_str("\"\\uAB12\""), Ok(String(~"\uAB12")));
} }
#[test] #[test]
fn test_decode_str() { fn test_decode_str() {
let mut decoder = Decoder(from_str(~"\"\"").unwrap()); let mut decoder = Decoder(from_str("\"\"").unwrap());
let v: ~str = Decodable::decode(&mut decoder); let v: ~str = Decodable::decode(&mut decoder);
assert_eq!(v, ~""); assert_eq!(v, ~"");
let mut decoder = Decoder(from_str(~"\"foo\"").unwrap()); let mut decoder = Decoder(from_str("\"foo\"").unwrap());
let v: ~str = Decodable::decode(&mut decoder); let v: ~str = Decodable::decode(&mut decoder);
assert_eq!(v, ~"foo"); assert_eq!(v, ~"foo");
let mut decoder = Decoder(from_str(~"\"\\\"\"").unwrap()); let mut decoder = Decoder(from_str("\"\\\"\"").unwrap());
let v: ~str = Decodable::decode(&mut decoder); let v: ~str = Decodable::decode(&mut decoder);
assert_eq!(v, ~"\""); assert_eq!(v, ~"\"");
let mut decoder = Decoder(from_str(~"\"\\b\"").unwrap()); let mut decoder = Decoder(from_str("\"\\b\"").unwrap());
let v: ~str = Decodable::decode(&mut decoder); let v: ~str = Decodable::decode(&mut decoder);
assert_eq!(v, ~"\x08"); assert_eq!(v, ~"\x08");
let mut decoder = Decoder(from_str(~"\"\\n\"").unwrap()); let mut decoder = Decoder(from_str("\"\\n\"").unwrap());
let v: ~str = Decodable::decode(&mut decoder); let v: ~str = Decodable::decode(&mut decoder);
assert_eq!(v, ~"\n"); assert_eq!(v, ~"\n");
let mut decoder = Decoder(from_str(~"\"\\r\"").unwrap()); let mut decoder = Decoder(from_str("\"\\r\"").unwrap());
let v: ~str = Decodable::decode(&mut decoder); let v: ~str = Decodable::decode(&mut decoder);
assert_eq!(v, ~"\r"); assert_eq!(v, ~"\r");
let mut decoder = Decoder(from_str(~"\"\\t\"").unwrap()); let mut decoder = Decoder(from_str("\"\\t\"").unwrap());
let v: ~str = Decodable::decode(&mut decoder); let v: ~str = Decodable::decode(&mut decoder);
assert_eq!(v, ~"\t"); assert_eq!(v, ~"\t");
let mut decoder = Decoder(from_str(~"\"\\u12ab\"").unwrap()); let mut decoder = Decoder(from_str("\"\\u12ab\"").unwrap());
let v: ~str = Decodable::decode(&mut decoder); let v: ~str = Decodable::decode(&mut decoder);
assert_eq!(v, ~"\u12ab"); assert_eq!(v, ~"\u12ab");
let mut decoder = Decoder(from_str(~"\"\\uAB12\"").unwrap()); let mut decoder = Decoder(from_str("\"\\uAB12\"").unwrap());
let v: ~str = Decodable::decode(&mut decoder); let v: ~str = Decodable::decode(&mut decoder);
assert_eq!(v, ~"\uAB12"); assert_eq!(v, ~"\uAB12");
} }
#[test] #[test]
fn test_read_list() { fn test_read_list() {
assert_eq!(from_str(~"["), assert_eq!(from_str("["),
Err(Error {line: 1u, col: 2u, msg: @~"EOF while parsing value"})); Err(Error {line: 1u, col: 2u, msg: @~"EOF while parsing value"}));
assert_eq!(from_str(~"[1"), assert_eq!(from_str("[1"),
Err(Error {line: 1u, col: 3u, msg: @~"EOF while parsing list"})); Err(Error {line: 1u, col: 3u, msg: @~"EOF while parsing list"}));
assert_eq!(from_str(~"[1,"), assert_eq!(from_str("[1,"),
Err(Error {line: 1u, col: 4u, msg: @~"EOF while parsing value"})); Err(Error {line: 1u, col: 4u, msg: @~"EOF while parsing value"}));
assert_eq!(from_str(~"[1,]"), assert_eq!(from_str("[1,]"),
Err(Error {line: 1u, col: 4u, msg: @~"invalid syntax"})); Err(Error {line: 1u, col: 4u, msg: @~"invalid syntax"}));
assert_eq!(from_str(~"[6 7]"), assert_eq!(from_str("[6 7]"),
Err(Error {line: 1u, col: 4u, msg: @~"expected `,` or `]`"})); Err(Error {line: 1u, col: 4u, msg: @~"expected `,` or `]`"}));
assert_eq!(from_str(~"[]"), Ok(List(~[]))); assert_eq!(from_str("[]"), Ok(List(~[])));
assert_eq!(from_str(~"[ ]"), Ok(List(~[]))); assert_eq!(from_str("[ ]"), Ok(List(~[])));
assert_eq!(from_str(~"[true]"), Ok(List(~[Boolean(true)]))); assert_eq!(from_str("[true]"), Ok(List(~[Boolean(true)])));
assert_eq!(from_str(~"[ false ]"), Ok(List(~[Boolean(false)]))); assert_eq!(from_str("[ false ]"), Ok(List(~[Boolean(false)])));
assert_eq!(from_str(~"[null]"), Ok(List(~[Null]))); assert_eq!(from_str("[null]"), Ok(List(~[Null])));
assert_eq!(from_str(~"[3, 1]"), assert_eq!(from_str("[3, 1]"),
Ok(List(~[Number(3f), Number(1f)]))); Ok(List(~[Number(3f), Number(1f)])));
assert_eq!(from_str(~"\n[3, 2]\n"), assert_eq!(from_str("\n[3, 2]\n"),
Ok(List(~[Number(3f), Number(2f)]))); Ok(List(~[Number(3f), Number(2f)])));
assert_eq!(from_str(~"[2, [4, 1]]"), assert_eq!(from_str("[2, [4, 1]]"),
Ok(List(~[Number(2f), List(~[Number(4f), Number(1f)])]))); Ok(List(~[Number(2f), List(~[Number(4f), Number(1f)])])));
} }
#[test] #[test]
fn test_decode_list() { fn test_decode_list() {
let mut decoder = Decoder(from_str(~"[]").unwrap()); let mut decoder = Decoder(from_str("[]").unwrap());
let v: ~[()] = Decodable::decode(&mut decoder); let v: ~[()] = Decodable::decode(&mut decoder);
assert_eq!(v, ~[]); assert_eq!(v, ~[]);
let mut decoder = Decoder(from_str(~"[null]").unwrap()); let mut decoder = Decoder(from_str("[null]").unwrap());
let v: ~[()] = Decodable::decode(&mut decoder); let v: ~[()] = Decodable::decode(&mut decoder);
assert_eq!(v, ~[()]); assert_eq!(v, ~[()]);
let mut decoder = Decoder(from_str(~"[true]").unwrap()); let mut decoder = Decoder(from_str("[true]").unwrap());
let v: ~[bool] = Decodable::decode(&mut decoder); let v: ~[bool] = Decodable::decode(&mut decoder);
assert_eq!(v, ~[true]); assert_eq!(v, ~[true]);
let mut decoder = Decoder(from_str(~"[true]").unwrap()); let mut decoder = Decoder(from_str("[true]").unwrap());
let v: ~[bool] = Decodable::decode(&mut decoder); let v: ~[bool] = Decodable::decode(&mut decoder);
assert_eq!(v, ~[true]); assert_eq!(v, ~[true]);
let mut decoder = Decoder(from_str(~"[3, 1]").unwrap()); let mut decoder = Decoder(from_str("[3, 1]").unwrap());
let v: ~[int] = Decodable::decode(&mut decoder); let v: ~[int] = Decodable::decode(&mut decoder);
assert_eq!(v, ~[3, 1]); assert_eq!(v, ~[3, 1]);
let mut decoder = Decoder(from_str(~"[[3], [1, 2]]").unwrap()); let mut decoder = Decoder(from_str("[[3], [1, 2]]").unwrap());
let v: ~[~[uint]] = Decodable::decode(&mut decoder); let v: ~[~[uint]] = Decodable::decode(&mut decoder);
assert_eq!(v, ~[~[3], ~[1, 2]]); assert_eq!(v, ~[~[3], ~[1, 2]]);
} }
#[test] #[test]
fn test_read_object() { fn test_read_object() {
assert_eq!(from_str(~"{"), assert_eq!(from_str("{"),
Err(Error { Err(Error {
line: 1u, line: 1u,
col: 2u, col: 2u,
msg: @~"EOF while parsing object"})); msg: @~"EOF while parsing object"}));
assert_eq!(from_str(~"{ "), assert_eq!(from_str("{ "),
Err(Error { Err(Error {
line: 1u, line: 1u,
col: 3u, col: 3u,
msg: @~"EOF while parsing object"})); msg: @~"EOF while parsing object"}));
assert_eq!(from_str(~"{1"), assert_eq!(from_str("{1"),
Err(Error { Err(Error {
line: 1u, line: 1u,
col: 2u, col: 2u,
msg: @~"key must be a string"})); msg: @~"key must be a string"}));
assert_eq!(from_str(~"{ \"a\""), assert_eq!(from_str("{ \"a\""),
Err(Error { Err(Error {
line: 1u, line: 1u,
col: 6u, col: 6u,
msg: @~"EOF while parsing object"})); msg: @~"EOF while parsing object"}));
assert_eq!(from_str(~"{\"a\""), assert_eq!(from_str("{\"a\""),
Err(Error { Err(Error {
line: 1u, line: 1u,
col: 5u, col: 5u,
msg: @~"EOF while parsing object"})); msg: @~"EOF while parsing object"}));
assert_eq!(from_str(~"{\"a\" "), assert_eq!(from_str("{\"a\" "),
Err(Error { Err(Error {
line: 1u, line: 1u,
col: 6u, col: 6u,
msg: @~"EOF while parsing object"})); msg: @~"EOF while parsing object"}));
assert_eq!(from_str(~"{\"a\" 1"), assert_eq!(from_str("{\"a\" 1"),
Err(Error {line: 1u, col: 6u, msg: @~"expected `:`"})); Err(Error {line: 1u, col: 6u, msg: @~"expected `:`"}));
assert_eq!(from_str(~"{\"a\":"), assert_eq!(from_str("{\"a\":"),
Err(Error {line: 1u, col: 6u, msg: @~"EOF while parsing value"})); Err(Error {line: 1u, col: 6u, msg: @~"EOF while parsing value"}));
assert_eq!(from_str(~"{\"a\":1"), assert_eq!(from_str("{\"a\":1"),
Err(Error { Err(Error {
line: 1u, line: 1u,
col: 7u, col: 7u,
msg: @~"EOF while parsing object"})); msg: @~"EOF while parsing object"}));
assert_eq!(from_str(~"{\"a\":1 1"), assert_eq!(from_str("{\"a\":1 1"),
Err(Error {line: 1u, col: 8u, msg: @~"expected `,` or `}`"})); Err(Error {line: 1u, col: 8u, msg: @~"expected `,` or `}`"}));
assert_eq!(from_str(~"{\"a\":1,"), assert_eq!(from_str("{\"a\":1,"),
Err(Error { Err(Error {
line: 1u, line: 1u,
col: 8u, col: 8u,
msg: @~"EOF while parsing object"})); msg: @~"EOF while parsing object"}));
assert_eq!(result::unwrap(from_str(~"{}")), mk_object(~[])); assert_eq!(result::unwrap(from_str("{}")), mk_object([]));
assert_eq!(result::unwrap(from_str(~"{\"a\": 3}")), assert_eq!(result::unwrap(from_str("{\"a\": 3}")),
mk_object(~[(~"a", Number(3.0f))])); mk_object([(~"a", Number(3.0f))]));
assert_eq!(result::unwrap(from_str( assert_eq!(result::unwrap(from_str(
~"{ \"a\": null, \"b\" : true }")), "{ \"a\": null, \"b\" : true }")),
mk_object(~[ mk_object([
(~"a", Null), (~"a", Null),
(~"b", Boolean(true))])); (~"b", Boolean(true))]));
assert_eq!(result::unwrap( assert_eq!(result::unwrap(
from_str(~"\n{ \"a\": null, \"b\" : true }\n")), from_str("\n{ \"a\": null, \"b\" : true }\n")),
mk_object(~[ mk_object([
(~"a", Null), (~"a", Null),
(~"b", Boolean(true))])); (~"b", Boolean(true))]));
assert_eq!(result::unwrap(from_str( assert_eq!(result::unwrap(from_str(
~"{\"a\" : 1.0 ,\"b\": [ true ]}")), "{\"a\" : 1.0 ,\"b\": [ true ]}")),
mk_object(~[ mk_object([
(~"a", Number(1.0)), (~"a", Number(1.0)),
(~"b", List(~[Boolean(true)])) (~"b", List(~[Boolean(true)]))
])); ]));
@ -1887,13 +1887,13 @@ mod tests {
~"{ \"c\": {\"d\": null} } " + ~"{ \"c\": {\"d\": null} } " +
~"]" + ~"]" +
~"}")), ~"}")),
mk_object(~[ mk_object([
(~"a", Number(1.0f)), (~"a", Number(1.0f)),
(~"b", List(~[ (~"b", List(~[
Boolean(true), Boolean(true),
String(~"foo\nbar"), String(~"foo\nbar"),
mk_object(~[ mk_object([
(~"c", mk_object(~[(~"d", Null)])) (~"c", mk_object([(~"d", Null)]))
]) ])
])) ]))
])); ]));
@ -1920,23 +1920,23 @@ mod tests {
#[test] #[test]
fn test_decode_option() { fn test_decode_option() {
let mut decoder = Decoder(from_str(~"null").unwrap()); let mut decoder = Decoder(from_str("null").unwrap());
let value: Option<~str> = Decodable::decode(&mut decoder); let value: Option<~str> = Decodable::decode(&mut decoder);
assert_eq!(value, None); assert_eq!(value, None);
let mut decoder = Decoder(from_str(~"\"jodhpurs\"").unwrap()); let mut decoder = Decoder(from_str("\"jodhpurs\"").unwrap());
let value: Option<~str> = Decodable::decode(&mut decoder); let value: Option<~str> = Decodable::decode(&mut decoder);
assert_eq!(value, Some(~"jodhpurs")); assert_eq!(value, Some(~"jodhpurs"));
} }
#[test] #[test]
fn test_decode_enum() { fn test_decode_enum() {
let mut decoder = Decoder(from_str(~"\"Dog\"").unwrap()); let mut decoder = Decoder(from_str("\"Dog\"").unwrap());
let value: Animal = Decodable::decode(&mut decoder); let value: Animal = Decodable::decode(&mut decoder);
assert_eq!(value, Dog); assert_eq!(value, Dog);
let mut decoder = let mut decoder =
Decoder(from_str(~"[\"Frog\",\"Henry\",349]").unwrap()); Decoder(from_str("[\"Frog\",\"Henry\",349]").unwrap());
let value: Animal = Decodable::decode(&mut decoder); let value: Animal = Decodable::decode(&mut decoder);
assert_eq!(value, Frog(~"Henry", 349)); assert_eq!(value, Frog(~"Henry", 349));
} }
@ -1953,7 +1953,7 @@ mod tests {
#[test] #[test]
fn test_multiline_errors() { fn test_multiline_errors() {
assert_eq!(from_str(~"{\n \"foo\":\n \"bar\""), assert_eq!(from_str("{\n \"foo\":\n \"bar\""),
Err(Error { Err(Error {
line: 3u, line: 3u,
col: 8u, col: 8u,

26
src/libextra/list.rs
View file

@ -184,9 +184,9 @@ mod tests {
#[test] #[test]
fn test_is_empty() { fn test_is_empty() {
let empty : @list::List<int> = from_vec(~[]); let empty : @list::List<int> = from_vec([]);
let full1 = from_vec(~[1]); let full1 = from_vec([1]);
let full2 = from_vec(~['r', 'u']); let full2 = from_vec(['r', 'u']);
assert!(is_empty(empty)); assert!(is_empty(empty));
assert!(!is_empty(full1)); assert!(!is_empty(full1));
@ -195,7 +195,7 @@ mod tests {
#[test] #[test]
fn test_from_vec() { fn test_from_vec() {
let l = from_vec(~[0, 1, 2]); let l = from_vec([0, 1, 2]);
assert_eq!(head(l), 0); assert_eq!(head(l), 0);
@ -208,14 +208,14 @@ mod tests {
#[test] #[test]
fn test_from_vec_empty() { fn test_from_vec_empty() {
let empty : @list::List<int> = from_vec(~[]); let empty : @list::List<int> = from_vec([]);
assert_eq!(empty, @list::Nil::<int>); assert_eq!(empty, @list::Nil::<int>);
} }
#[test] #[test]
fn test_foldl() { fn test_foldl() {
fn add(a: &uint, b: &int) -> uint { return *a + (*b as uint); } fn add(a: &uint, b: &int) -> uint { return *a + (*b as uint); }
let l = from_vec(~[0, 1, 2, 3, 4]); let l = from_vec([0, 1, 2, 3, 4]);
let empty = @list::Nil::<int>; let empty = @list::Nil::<int>;
assert_eq!(list::foldl(0u, l, add), 10u); assert_eq!(list::foldl(0u, l, add), 10u);
assert_eq!(list::foldl(0u, empty, add), 0u); assert_eq!(list::foldl(0u, empty, add), 0u);
@ -226,21 +226,21 @@ mod tests {
fn sub(a: &int, b: &int) -> int { fn sub(a: &int, b: &int) -> int {
*a - *b *a - *b
} }
let l = from_vec(~[1, 2, 3, 4]); let l = from_vec([1, 2, 3, 4]);
assert_eq!(list::foldl(0, l, sub), -10); assert_eq!(list::foldl(0, l, sub), -10);
} }
#[test] #[test]
fn test_find_success() { fn test_find_success() {
fn match_(i: &int) -> bool { return *i == 2; } fn match_(i: &int) -> bool { return *i == 2; }
let l = from_vec(~[0, 1, 2]); let l = from_vec([0, 1, 2]);
assert_eq!(list::find(l, match_), option::Some(2)); assert_eq!(list::find(l, match_), option::Some(2));
} }
#[test] #[test]
fn test_find_fail() { fn test_find_fail() {
fn match_(_i: &int) -> bool { return false; } fn match_(_i: &int) -> bool { return false; }
let l = from_vec(~[0, 1, 2]); let l = from_vec([0, 1, 2]);
let empty = @list::Nil::<int>; let empty = @list::Nil::<int>;
assert_eq!(list::find(l, match_), option::None::<int>); assert_eq!(list::find(l, match_), option::None::<int>);
assert_eq!(list::find(empty, match_), option::None::<int>); assert_eq!(list::find(empty, match_), option::None::<int>);
@ -248,7 +248,7 @@ mod tests {
#[test] #[test]
fn test_has() { fn test_has() {
let l = from_vec(~[5, 8, 6]); let l = from_vec([5, 8, 6]);
let empty = @list::Nil::<int>; let empty = @list::Nil::<int>;
assert!((list::has(l, 5))); assert!((list::has(l, 5)));
assert!((!list::has(l, 7))); assert!((!list::has(l, 7)));
@ -258,7 +258,7 @@ mod tests {
#[test] #[test]
fn test_len() { fn test_len() {
let l = from_vec(~[0, 1, 2]); let l = from_vec([0, 1, 2]);
let empty = @list::Nil::<int>; let empty = @list::Nil::<int>;
assert_eq!(list::len(l), 3u); assert_eq!(list::len(l), 3u);
assert_eq!(list::len(empty), 0u); assert_eq!(list::len(empty), 0u);
@ -266,7 +266,7 @@ mod tests {
#[test] #[test]
fn test_append() { fn test_append() {
assert!(from_vec(~[1,2,3,4]) assert!(from_vec([1,2,3,4])
== list::append(list::from_vec(~[1,2]), list::from_vec(~[3,4]))); == list::append(list::from_vec([1,2]), list::from_vec([3,4])));
} }
} }

14
src/libextra/md4.rs
View file

@ -127,17 +127,17 @@ pub fn md4_text(msg: &str) -> ~str { md4_str(str::to_bytes(msg)) }
#[test] #[test]
fn test_md4() { fn test_md4() {
assert_eq!(md4_text(~""), ~"31d6cfe0d16ae931b73c59d7e0c089c0"); assert_eq!(md4_text(""), ~"31d6cfe0d16ae931b73c59d7e0c089c0");
assert_eq!(md4_text(~"a"), ~"bde52cb31de33e46245e05fbdbd6fb24"); assert_eq!(md4_text("a"), ~"bde52cb31de33e46245e05fbdbd6fb24");
assert_eq!(md4_text(~"abc"), ~"a448017aaf21d8525fc10ae87aa6729d"); assert_eq!(md4_text("abc"), ~"a448017aaf21d8525fc10ae87aa6729d");
assert!(md4_text(~"message digest") == assert!(md4_text("message digest") ==
~"d9130a8164549fe818874806e1c7014b"); ~"d9130a8164549fe818874806e1c7014b");
assert!(md4_text(~"abcdefghijklmnopqrstuvwxyz") == assert!(md4_text("abcdefghijklmnopqrstuvwxyz") ==
~"d79e1c308aa5bbcdeea8ed63df412da9"); ~"d79e1c308aa5bbcdeea8ed63df412da9");
assert!(md4_text( assert!(md4_text(
~"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\
0123456789") == ~"043f8582f241db351ce627e153e7f0e4"); 0123456789") == ~"043f8582f241db351ce627e153e7f0e4");
assert!(md4_text(~"1234567890123456789012345678901234567890123456789\ assert!(md4_text("1234567890123456789012345678901234567890123456789\
0123456789012345678901234567890") == 0123456789012345678901234567890") ==
~"e33b4ddc9c38f2199c3e7b164fcc0536"); ~"e33b4ddc9c38f2199c3e7b164fcc0536");
} }

4
src/libextra/net_ip.rs
View file

@ -393,7 +393,7 @@ mod test {
} }
#[test] #[test]
fn test_ip_ipv4_bad_parse() { fn test_ip_ipv4_bad_parse() {
match v4::try_parse_addr(~"b4df00d") { match v4::try_parse_addr("b4df00d") {
result::Err(ref err_info) => { result::Err(ref err_info) => {
debug!("got error as expected %?", err_info); debug!("got error as expected %?", err_info);
assert!(true); assert!(true);
@ -406,7 +406,7 @@ mod test {
#[test] #[test]
#[ignore(target_os="win32")] #[ignore(target_os="win32")]
fn test_ip_ipv6_bad_parse() { fn test_ip_ipv6_bad_parse() {
match v6::try_parse_addr(~"::,~2234k;") { match v6::try_parse_addr("::,~2234k;") {
result::Err(ref err_info) => { result::Err(ref err_info) => {
debug!("got error as expected %?", err_info); debug!("got error as expected %?", err_info);
assert!(true); assert!(true);

2
src/libextra/net_tcp.rs
View file

@ -1630,7 +1630,7 @@ mod test {
assert_eq!(net::ip::get_port(&sock.get_peer_addr()), 8887); assert_eq!(net::ip::get_port(&sock.get_peer_addr()), 8887);
// Fulfill the protocol the test server expects // Fulfill the protocol the test server expects
let resp_bytes = str::to_bytes(~"ping"); let resp_bytes = str::to_bytes("ping");
tcp_write_single(&sock, resp_bytes); tcp_write_single(&sock, resp_bytes);
debug!("message sent"); debug!("message sent");
sock.read(0u); sock.read(0u);

14
src/libextra/net_url.rs
View file

@ -716,11 +716,11 @@ impl IterBytes for Url {
#[test] #[test]
fn test_split_char_first() { fn test_split_char_first() {
let (u,v) = split_char_first(~"hello, sweet world", ','); let (u,v) = split_char_first("hello, sweet world", ',');
assert_eq!(u, ~"hello"); assert_eq!(u, ~"hello");
assert_eq!(v, ~" sweet world"); assert_eq!(v, ~" sweet world");
let (u,v) = split_char_first(~"hello sweet world", ','); let (u,v) = split_char_first("hello sweet world", ',');
assert_eq!(u, ~"hello sweet world"); assert_eq!(u, ~"hello sweet world");
assert_eq!(v, ~""); assert_eq!(v, ~"");
} }
@ -774,9 +774,9 @@ fn test_get_authority() {
"//2001:0db8:85a3:0042:0000:8a2e:0370:7334:8000:00").is_err()); "//2001:0db8:85a3:0042:0000:8a2e:0370:7334:8000:00").is_err());
// these parse as empty, because they don't start with '//' // these parse as empty, because they don't start with '//'
let (_, h, _, _) = get_authority(~"user:pass@rust-lang").unwrap(); let (_, h, _, _) = get_authority("user:pass@rust-lang").unwrap();
assert_eq!(h, ~""); assert_eq!(h, ~"");
let (_, h, _, _) = get_authority(~"rust-lang.org").unwrap(); let (_, h, _, _) = get_authority("rust-lang.org").unwrap();
assert_eq!(h, ~""); assert_eq!(h, ~"");
} }
@ -788,12 +788,12 @@ fn test_get_path() {
let (p, r) = get_path("test@email.com#fragment", false).unwrap(); let (p, r) = get_path("test@email.com#fragment", false).unwrap();
assert_eq!(p, ~"test@email.com"); assert_eq!(p, ~"test@email.com");
assert_eq!(r, ~"#fragment"); assert_eq!(r, ~"#fragment");
let (p, r) = get_path(~"/gen/:addr=?q=v", false).unwrap(); let (p, r) = get_path("/gen/:addr=?q=v", false).unwrap();
assert_eq!(p, ~"/gen/:addr="); assert_eq!(p, ~"/gen/:addr=");
assert_eq!(r, ~"?q=v"); assert_eq!(r, ~"?q=v");
//failure cases //failure cases
assert!(get_path(~"something?q", true).is_err()); assert!(get_path("something?q", true).is_err());
} }
#[cfg(test)] #[cfg(test)]
@ -1058,7 +1058,7 @@ mod tests {
// FIXME #4449: Commented out because this causes an ICE, but only // FIXME #4449: Commented out because this causes an ICE, but only
// on FreeBSD // on FreeBSD
/* /*
assert_eq!(decode_form_urlencoded(~[]).len(), 0); assert_eq!(decode_form_urlencoded([]).len(), 0);
let s = str::to_bytes("a=1&foo+bar=abc&foo+bar=12+%3D+34"); let s = str::to_bytes("a=1&foo+bar=abc&foo+bar=12+%3D+34");
let form = decode_form_urlencoded(s); let form = decode_form_urlencoded(s);

18
src/libextra/num/bigint.rs
View file

@ -1156,12 +1156,12 @@ mod biguint_tests {
fn check(slice: &[BigDigit], data: &[BigDigit]) { fn check(slice: &[BigDigit], data: &[BigDigit]) {
assert!(data == BigUint::from_slice(slice).data); assert!(data == BigUint::from_slice(slice).data);
} }
check(~[1], ~[1]); check([1], [1]);
check(~[0, 0, 0], ~[]); check([0, 0, 0], []);
check(~[1, 2, 0, 0], ~[1, 2]); check([1, 2, 0, 0], [1, 2]);
check(~[0, 0, 1, 2], ~[0, 0, 1, 2]); check([0, 0, 1, 2], [0, 0, 1, 2]);
check(~[0, 0, 1, 2, 0, 0], ~[0, 0, 1, 2]); check([0, 0, 1, 2, 0, 0], [0, 0, 1, 2]);
check(~[-1], ~[-1]); check([-1], [-1]);
} }
#[test] #[test]
@ -1579,9 +1579,9 @@ mod biguint_tests {
} }
} }
assert_eq!(FromStrRadix::from_str_radix::<BigUint>(~"Z", 10), None); assert_eq!(FromStrRadix::from_str_radix::<BigUint>("Z", 10), None);
assert_eq!(FromStrRadix::from_str_radix::<BigUint>(~"_", 2), None); assert_eq!(FromStrRadix::from_str_radix::<BigUint>("_", 2), None);
assert_eq!(FromStrRadix::from_str_radix::<BigUint>(~"-1", 10), None); assert_eq!(FromStrRadix::from_str_radix::<BigUint>("-1", 10), None);
} }
#[test] #[test]

1
src/libextra/priority_queue.rs
View file

@ -14,7 +14,6 @@ use core::prelude::*;
use core::old_iter::BaseIter; use core::old_iter::BaseIter;
use core::unstable::intrinsics::{move_val_init, init}; use core::unstable::intrinsics::{move_val_init, init};
use core::unstable::intrinsics::uninit;
use core::util::{replace, swap}; use core::util::{replace, swap};
pub struct PriorityQueue<T> { pub struct PriorityQueue<T> {

2
src/libextra/sha1.rs
View file

@ -295,7 +295,7 @@ mod tests {
let mut i = 0; let mut i = 0;
let mut rs = ~""; let mut rs = ~"";
while i < 100000 { while i < 100000 {
str::push_str(&mut rs, ~"aaaaaaaaaa"); rs.push_str("aaaaaaaaaa");
i += 1; i += 1;
} }
return rs; return rs;

2
src/libextra/sort.rs
View file

@ -895,7 +895,7 @@ mod tests {
#[test] #[test]
fn test_merge_sort_mutable() { fn test_merge_sort_mutable() {
pub fn le(a: &int, b: &int) -> bool { *a <= *b } pub fn le(a: &int, b: &int) -> bool { *a <= *b }
let mut v1 = ~[3, 2, 1]; let v1 = ~[3, 2, 1];
let v2 = merge_sort(v1, le); let v2 = merge_sort(v1, le);
assert_eq!(v2, ~[1, 2, 3]); assert_eq!(v2, ~[1, 2, 3]);
} }

1
src/libextra/std.rc
View file

@ -27,7 +27,6 @@ not required in or otherwise suitable for the core library.
#[crate_type = "lib"]; #[crate_type = "lib"];
#[deny(non_camel_case_types)]; #[deny(non_camel_case_types)];
#[allow(unnecessary_allocation)];
#[no_core]; #[no_core];
#[no_std]; #[no_std];

4
src/libextra/test.rs
View file

@ -394,8 +394,8 @@ fn should_sort_failures_before_printing_them() {
print_failures(st); print_failures(st);
}; };
let apos = str::find_str(s, ~"a").get(); let apos = str::find_str(s, "a").get();
let bpos = str::find_str(s, ~"b").get(); let bpos = str::find_str(s, "b").get();
assert!(apos < bpos); assert!(apos < bpos);
} }

188
src/libextra/time.rs
View file

@ -899,7 +899,7 @@ mod tests {
} }
fn test_at_utc() { fn test_at_utc() {
os::setenv(~"TZ", ~"America/Los_Angeles"); os::setenv("TZ", "America/Los_Angeles");
tzset(); tzset();
let time = ::time::Timespec::new(1234567890, 54321); let time = ::time::Timespec::new(1234567890, 54321);
@ -920,7 +920,7 @@ mod tests {
} }
fn test_at() { fn test_at() {
os::setenv(~"TZ", ~"America/Los_Angeles"); os::setenv("TZ", "America/Los_Angeles");
tzset(); tzset();
let time = ::time::Timespec::new(1234567890, 54321); let time = ::time::Timespec::new(1234567890, 54321);
@ -948,7 +948,7 @@ mod tests {
} }
fn test_to_timespec() { fn test_to_timespec() {
os::setenv(~"TZ", ~"America/Los_Angeles"); os::setenv("TZ", "America/Los_Angeles");
tzset(); tzset();
let time = ::time::Timespec::new(1234567890, 54321); let time = ::time::Timespec::new(1234567890, 54321);
@ -959,7 +959,7 @@ mod tests {
} }
fn test_conversions() { fn test_conversions() {
os::setenv(~"TZ", ~"America/Los_Angeles"); os::setenv("TZ", "America/Los_Angeles");
tzset(); tzset();
let time = ::time::Timespec::new(1234567890, 54321); let time = ::time::Timespec::new(1234567890, 54321);
@ -975,10 +975,10 @@ mod tests {
} }
fn test_strptime() { fn test_strptime() {
os::setenv(~"TZ", ~"America/Los_Angeles"); os::setenv("TZ", "America/Los_Angeles");
tzset(); tzset();
match strptime(~"", ~"") { match strptime("", "") {
Ok(ref tm) => { Ok(ref tm) => {
assert!(tm.tm_sec == 0_i32); assert!(tm.tm_sec == 0_i32);
assert!(tm.tm_min == 0_i32); assert!(tm.tm_min == 0_i32);
@ -995,12 +995,12 @@ mod tests {
Err(_) => () Err(_) => ()
} }
let format = ~"%a %b %e %T %Y"; let format = "%a %b %e %T %Y";
assert_eq!(strptime(~"", format), Err(~"Invalid time")); assert_eq!(strptime("", format), Err(~"Invalid time"));
assert!(strptime(~"Fri Feb 13 15:31:30", format) assert!(strptime("Fri Feb 13 15:31:30", format)
== Err(~"Invalid time")); == Err(~"Invalid time"));
match strptime(~"Fri Feb 13 15:31:30 2009", format) { match strptime("Fri Feb 13 15:31:30 2009", format) {
Err(copy e) => fail!(e), Err(copy e) => fail!(e),
Ok(ref tm) => { Ok(ref tm) => {
assert!(tm.tm_sec == 30_i32); assert!(tm.tm_sec == 30_i32);
@ -1034,7 +1034,7 @@ mod tests {
~"Friday", ~"Friday",
~"Saturday" ~"Saturday"
].each |day| { ].each |day| {
assert!(test(*day, ~"%A")); assert!(test(*day, "%A"));
} }
for [ for [
@ -1046,7 +1046,7 @@ mod tests {
~"Fri", ~"Fri",
~"Sat" ~"Sat"
].each |day| { ].each |day| {
assert!(test(*day, ~"%a")); assert!(test(*day, "%a"));
} }
for [ for [
@ -1063,7 +1063,7 @@ mod tests {
~"November", ~"November",
~"December" ~"December"
].each |day| { ].each |day| {
assert!(test(*day, ~"%B")); assert!(test(*day, "%B"));
} }
for [ for [
@ -1080,60 +1080,60 @@ mod tests {
~"Nov", ~"Nov",
~"Dec" ~"Dec"
].each |day| { ].each |day| {
assert!(test(*day, ~"%b")); assert!(test(*day, "%b"));
} }
assert!(test(~"19", ~"%C")); assert!(test("19", "%C"));
assert!(test(~"Fri Feb 13 23:31:30 2009", ~"%c")); assert!(test("Fri Feb 13 23:31:30 2009", "%c"));
assert!(test(~"02/13/09", ~"%D")); assert!(test("02/13/09", "%D"));
assert!(test(~"03", ~"%d")); assert!(test("03", "%d"));
assert!(test(~"13", ~"%d")); assert!(test("13", "%d"));
assert!(test(~" 3", ~"%e")); assert!(test(" 3", "%e"));
assert!(test(~"13", ~"%e")); assert!(test("13", "%e"));
assert!(test(~"2009-02-13", ~"%F")); assert!(test("2009-02-13", "%F"));
assert!(test(~"03", ~"%H")); assert!(test("03", "%H"));
assert!(test(~"13", ~"%H")); assert!(test("13", "%H"));
assert!(test(~"03", ~"%I")); // FIXME (#2350): flesh out assert!(test("03", "%I")); // FIXME (#2350): flesh out
assert!(test(~"11", ~"%I")); // FIXME (#2350): flesh out assert!(test("11", "%I")); // FIXME (#2350): flesh out
assert!(test(~"044", ~"%j")); assert!(test("044", "%j"));
assert!(test(~" 3", ~"%k")); assert!(test(" 3", "%k"));
assert!(test(~"13", ~"%k")); assert!(test("13", "%k"));
assert!(test(~" 1", ~"%l")); assert!(test(" 1", "%l"));
assert!(test(~"11", ~"%l")); assert!(test("11", "%l"));
assert!(test(~"03", ~"%M")); assert!(test("03", "%M"));
assert!(test(~"13", ~"%M")); assert!(test("13", "%M"));
assert!(test(~"\n", ~"%n")); assert!(test("\n", "%n"));
assert!(test(~"am", ~"%P")); assert!(test("am", "%P"));
assert!(test(~"pm", ~"%P")); assert!(test("pm", "%P"));
assert!(test(~"AM", ~"%p")); assert!(test("AM", "%p"));
assert!(test(~"PM", ~"%p")); assert!(test("PM", "%p"));
assert!(test(~"23:31", ~"%R")); assert!(test("23:31", "%R"));
assert!(test(~"11:31:30 AM", ~"%r")); assert!(test("11:31:30 AM", "%r"));
assert!(test(~"11:31:30 PM", ~"%r")); assert!(test("11:31:30 PM", "%r"));
assert!(test(~"03", ~"%S")); assert!(test("03", "%S"));
assert!(test(~"13", ~"%S")); assert!(test("13", "%S"));
assert!(test(~"15:31:30", ~"%T")); assert!(test("15:31:30", "%T"));
assert!(test(~"\t", ~"%t")); assert!(test("\t", "%t"));
assert!(test(~"1", ~"%u")); assert!(test("1", "%u"));
assert!(test(~"7", ~"%u")); assert!(test("7", "%u"));
assert!(test(~"13-Feb-2009", ~"%v")); assert!(test("13-Feb-2009", "%v"));
assert!(test(~"0", ~"%w")); assert!(test("0", "%w"));
assert!(test(~"6", ~"%w")); assert!(test("6", "%w"));
assert!(test(~"2009", ~"%Y")); assert!(test("2009", "%Y"));
assert!(test(~"09", ~"%y")); assert!(test("09", "%y"));
assert!(result::unwrap(strptime(~"UTC", ~"%Z")).tm_zone == assert!(result::unwrap(strptime("UTC", "%Z")).tm_zone ==
~"UTC"); ~"UTC");
assert!(result::unwrap(strptime(~"PST", ~"%Z")).tm_zone == assert!(result::unwrap(strptime("PST", "%Z")).tm_zone ==
~""); ~"");
assert!(result::unwrap(strptime(~"-0000", ~"%z")).tm_gmtoff == assert!(result::unwrap(strptime("-0000", "%z")).tm_gmtoff ==
0); 0);
assert!(result::unwrap(strptime(~"-0800", ~"%z")).tm_gmtoff == assert!(result::unwrap(strptime("-0800", "%z")).tm_gmtoff ==
0); 0);
assert!(test(~"%", ~"%%")); assert!(test("%", "%%"));
} }
fn test_ctime() { fn test_ctime() {
os::setenv(~"TZ", ~"America/Los_Angeles"); os::setenv("TZ", "America/Los_Angeles");
tzset(); tzset();
let time = ::time::Timespec::new(1234567890, 54321); let time = ::time::Timespec::new(1234567890, 54321);
@ -1147,60 +1147,60 @@ mod tests {
} }
fn test_strftime() { fn test_strftime() {
os::setenv(~"TZ", ~"America/Los_Angeles"); os::setenv("TZ", "America/Los_Angeles");
tzset(); tzset();
let time = ::time::Timespec::new(1234567890, 54321); let time = ::time::Timespec::new(1234567890, 54321);
let utc = at_utc(time); let utc = at_utc(time);
let local = at(time); let local = at(time);
assert_eq!(local.strftime(~""), ~""); assert_eq!(local.strftime(""), ~"");
assert_eq!(local.strftime(~"%A"), ~"Friday"); assert_eq!(local.strftime("%A"), ~"Friday");
assert_eq!(local.strftime(~"%a"), ~"Fri"); assert_eq!(local.strftime("%a"), ~"Fri");
assert_eq!(local.strftime(~"%B"), ~"February"); assert_eq!(local.strftime("%B"), ~"February");
assert_eq!(local.strftime(~"%b"), ~"Feb"); assert_eq!(local.strftime("%b"), ~"Feb");
assert_eq!(local.strftime(~"%C"), ~"20"); assert_eq!(local.strftime("%C"), ~"20");
assert_eq!(local.strftime(~"%c"), ~"Fri Feb 13 15:31:30 2009"); assert_eq!(local.strftime("%c"), ~"Fri Feb 13 15:31:30 2009");
assert_eq!(local.strftime(~"%D"), ~"02/13/09"); assert_eq!(local.strftime("%D"), ~"02/13/09");
assert_eq!(local.strftime(~"%d"), ~"13"); assert_eq!(local.strftime("%d"), ~"13");
assert_eq!(local.strftime(~"%e"), ~"13"); assert_eq!(local.strftime("%e"), ~"13");
assert_eq!(local.strftime(~"%F"), ~"2009-02-13"); assert_eq!(local.strftime("%F"), ~"2009-02-13");
// assert!(local.strftime("%G") == "2009"); // assert!(local.strftime("%G") == "2009");
// assert!(local.strftime("%g") == "09"); // assert!(local.strftime("%g") == "09");
assert_eq!(local.strftime(~"%H"), ~"15"); assert_eq!(local.strftime("%H"), ~"15");
assert_eq!(local.strftime(~"%I"), ~"03"); assert_eq!(local.strftime("%I"), ~"03");
assert_eq!(local.strftime(~"%j"), ~"044"); assert_eq!(local.strftime("%j"), ~"044");
assert_eq!(local.strftime(~"%k"), ~"15"); assert_eq!(local.strftime("%k"), ~"15");
assert_eq!(local.strftime(~"%l"), ~" 3"); assert_eq!(local.strftime("%l"), ~" 3");
assert_eq!(local.strftime(~"%M"), ~"31"); assert_eq!(local.strftime("%M"), ~"31");
assert_eq!(local.strftime(~"%m"), ~"02"); assert_eq!(local.strftime("%m"), ~"02");
assert_eq!(local.strftime(~"%n"), ~"\n"); assert_eq!(local.strftime("%n"), ~"\n");
assert_eq!(local.strftime(~"%P"), ~"pm"); assert_eq!(local.strftime("%P"), ~"pm");
assert_eq!(local.strftime(~"%p"), ~"PM"); assert_eq!(local.strftime("%p"), ~"PM");
assert_eq!(local.strftime(~"%R"), ~"15:31"); assert_eq!(local.strftime("%R"), ~"15:31");
assert_eq!(local.strftime(~"%r"), ~"03:31:30 PM"); assert_eq!(local.strftime("%r"), ~"03:31:30 PM");
assert_eq!(local.strftime(~"%S"), ~"30"); assert_eq!(local.strftime("%S"), ~"30");
assert_eq!(local.strftime(~"%s"), ~"1234567890"); assert_eq!(local.strftime("%s"), ~"1234567890");
assert_eq!(local.strftime(~"%T"), ~"15:31:30"); assert_eq!(local.strftime("%T"), ~"15:31:30");
assert_eq!(local.strftime(~"%t"), ~"\t"); assert_eq!(local.strftime("%t"), ~"\t");
// assert!(local.strftime("%U") == "06"); // assert!(local.strftime("%U") == "06");
assert_eq!(local.strftime(~"%u"), ~"5"); assert_eq!(local.strftime("%u"), ~"5");
// assert!(local.strftime("%V") == "07"); // assert!(local.strftime("%V") == "07");
assert_eq!(local.strftime(~"%v"), ~"13-Feb-2009"); assert_eq!(local.strftime("%v"), ~"13-Feb-2009");
// assert!(local.strftime("%W") == "06"); // assert!(local.strftime("%W") == "06");
assert_eq!(local.strftime(~"%w"), ~"5"); assert_eq!(local.strftime("%w"), ~"5");
// handle "%X" // handle "%X"
// handle "%x" // handle "%x"
assert_eq!(local.strftime(~"%Y"), ~"2009"); assert_eq!(local.strftime("%Y"), ~"2009");
assert_eq!(local.strftime(~"%y"), ~"09"); assert_eq!(local.strftime("%y"), ~"09");
// FIXME (#2350): We should probably standardize on the timezone // FIXME (#2350): We should probably standardize on the timezone
// abbreviation. // abbreviation.
let zone = local.strftime(~"%Z"); let zone = local.strftime("%Z");
assert!(zone == ~"PST" || zone == ~"Pacific Standard Time"); assert!(zone == ~"PST" || zone == ~"Pacific Standard Time");
assert_eq!(local.strftime(~"%z"), ~"-0800"); assert_eq!(local.strftime("%z"), ~"-0800");
assert_eq!(local.strftime(~"%%"), ~"%"); assert_eq!(local.strftime("%%"), ~"%");
// FIXME (#2350): We should probably standardize on the timezone // FIXME (#2350): We should probably standardize on the timezone
// abbreviation. // abbreviation.

8
src/libextra/treemap.rs
View file

@ -759,10 +759,10 @@ mod test_treemap {
fn u8_map() { fn u8_map() {
let mut m = TreeMap::new(); let mut m = TreeMap::new();
let k1 = str::to_bytes(~"foo"); let k1 = str::to_bytes("foo");
let k2 = str::to_bytes(~"bar"); let k2 = str::to_bytes("bar");
let v1 = str::to_bytes(~"baz"); let v1 = str::to_bytes("baz");
let v2 = str::to_bytes(~"foobar"); let v2 = str::to_bytes("foobar");
m.insert(copy k1, copy v1); m.insert(copy k1, copy v1);
m.insert(copy k2, copy v2); m.insert(copy k2, copy v2);

12
src/librustc/back/rpath.rs
View file

@ -211,8 +211,8 @@ mod test {
#[test] #[test]
fn test_rpaths_to_flags() { fn test_rpaths_to_flags() {
let flags = rpaths_to_flags(~[Path("path1"), let flags = rpaths_to_flags([Path("path1"),
Path("path2")]); Path("path2")]);
assert_eq!(flags, ~[~"-Wl,-rpath,path1", ~"-Wl,-rpath,path2"]); assert_eq!(flags, ~[~"-Wl,-rpath,path1", ~"-Wl,-rpath,path2"]);
} }
@ -243,10 +243,10 @@ mod test {
#[test] #[test]
fn test_minimize2() { fn test_minimize2() {
let res = minimize_rpaths(~[Path("1a"), Path("2"), Path("2"), let res = minimize_rpaths([Path("1a"), Path("2"), Path("2"),
Path("1a"), Path("4a"),Path("1a"), Path("1a"), Path("4a"),Path("1a"),
Path("2"), Path("3"), Path("4a"), Path("2"), Path("3"), Path("4a"),
Path("3")]); Path("3")]);
assert_eq!(res, ~[Path("1a"), Path("2"), Path("4a"), Path("3")]); assert_eq!(res, ~[Path("1a"), Path("2"), Path("4a"), Path("3")]);
} }

8
src/librustc/driver/driver.rs
View file

@ -30,7 +30,7 @@ use core::io;
use core::os; use core::os;
use core::str; use core::str;
use core::vec; use core::vec;
use extra::getopts::groups::{optopt, optmulti, optflag, optflagopt, getopts}; use extra::getopts::groups::{optopt, optmulti, optflag, optflagopt};
use extra::getopts::{opt_present}; use extra::getopts::{opt_present};
use extra::getopts; use extra::getopts;
use syntax::ast; use syntax::ast;
@ -942,7 +942,7 @@ mod test {
@~"rustc", matches, diagnostic::emit); @~"rustc", matches, diagnostic::emit);
let sess = build_session(sessopts, diagnostic::emit); let sess = build_session(sessopts, diagnostic::emit);
let cfg = build_configuration(sess, @~"whatever", &str_input(~"")); let cfg = build_configuration(sess, @~"whatever", &str_input(~""));
assert!((attr::contains_name(cfg, ~"test"))); assert!((attr::contains_name(cfg, "test")));
} }
// When the user supplies --test and --cfg test, don't implicitly add // When the user supplies --test and --cfg test, don't implicitly add
@ -950,7 +950,7 @@ mod test {
#[test] #[test]
fn test_switch_implies_cfg_test_unless_cfg_test() { fn test_switch_implies_cfg_test_unless_cfg_test() {
let matches = let matches =
&match getopts(~[~"--test", ~"--cfg=test"], optgroups()) { &match getopts([~"--test", ~"--cfg=test"], optgroups()) {
Ok(copy m) => m, Ok(copy m) => m,
Err(copy f) => { Err(copy f) => {
fail!("test_switch_implies_cfg_test_unless_cfg_test: %s", getopts::fail_str(f)); fail!("test_switch_implies_cfg_test_unless_cfg_test: %s", getopts::fail_str(f));
@ -960,7 +960,7 @@ mod test {
@~"rustc", matches, diagnostic::emit); @~"rustc", matches, diagnostic::emit);
let sess = build_session(sessopts, diagnostic::emit); let sess = build_session(sessopts, diagnostic::emit);
let cfg = build_configuration(sess, @~"whatever", &str_input(~"")); let cfg = build_configuration(sess, @~"whatever", &str_input(~""));
let test_items = attr::find_meta_items_by_name(cfg, ~"test"); let test_items = attr::find_meta_items_by_name(cfg, "test");
assert_eq!(test_items.len(), 1u); assert_eq!(test_items.len(), 1u);
} }
} }

1
src/librustc/middle/lint.rs
View file

@ -10,7 +10,6 @@
use core::prelude::*; use core::prelude::*;
use driver::session::Session;
use driver::session; use driver::session;
use middle::ty; use middle::ty;
use middle::pat_util; use middle::pat_util;

6
src/librustc/middle/resolve.rs
View file

@ -535,7 +535,7 @@ pub impl NameBindings {
parent_link: ParentLink, parent_link: ParentLink,
def_id: Option<def_id>, def_id: Option<def_id>,
kind: ModuleKind, kind: ModuleKind,
sp: span) { _sp: span) {
match self.type_def { match self.type_def {
None => { None => {
let module = @mut Module(parent_link, def_id, kind); let module = @mut Module(parent_link, def_id, kind);
@ -2586,8 +2586,8 @@ pub impl Resolver {
(ImportSearch, ImplModuleKind) => { (ImportSearch, ImplModuleKind) => {
self.session.span_err( self.session.span_err(
span, span,
~"cannot import from a trait \ "cannot import from a trait \
or type implementation"); or type implementation");
return Failed; return Failed;
} }
(_, _) => search_module = module_def, (_, _) => search_module = module_def,

18
src/librustc/middle/trans/common.rs
View file

@ -1367,13 +1367,21 @@ pub type mono_id = @mono_id_;
impl to_bytes::IterBytes for mono_param_id { impl to_bytes::IterBytes for mono_param_id {
fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
match *self { match *self {
mono_precise(t, ref mids) => mono_precise(t, ref mids) => {
to_bytes::iter_bytes_3(&0u8, &ty::type_id(t), mids, lsb0, f), 0u8.iter_bytes(lsb0, f) &&
ty::type_id(t).iter_bytes(lsb0, f) &&
mids.iter_bytes(lsb0, f)
}
mono_any => 1u8.iter_bytes(lsb0, f), mono_any => 1u8.iter_bytes(lsb0, f),
mono_repr(ref a, ref b, ref c, ref d) => mono_repr(ref a, ref b, ref c, ref d) => {
to_bytes::iter_bytes_5(&2u8, a, b, c, d, lsb0, f) 2u8.iter_bytes(lsb0, f) &&
a.iter_bytes(lsb0, f) &&
b.iter_bytes(lsb0, f) &&
c.iter_bytes(lsb0, f) &&
d.iter_bytes(lsb0, f)
}
} }
} }
} }
@ -1386,7 +1394,7 @@ impl to_bytes::IterBytes for MonoDataClass {
impl to_bytes::IterBytes for mono_id_ { impl to_bytes::IterBytes for mono_id_ {
fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
to_bytes::iter_bytes_2(&self.def, &self.params, lsb0, f) self.def.iter_bytes(lsb0, f) && self.params.iter_bytes(lsb0, f)
} }
} }

2
src/librustc/middle/trans/meth.rs
View file

@ -873,7 +873,7 @@ pub fn trans_trait_cast(bcx: block,
val: @ast::expr, val: @ast::expr,
id: ast::node_id, id: ast::node_id,
dest: expr::Dest, dest: expr::Dest,
store: ty::TraitStore) _store: ty::TraitStore)
-> block { -> block {
let mut bcx = bcx; let mut bcx = bcx;
let _icx = bcx.insn_ctxt("impl::trans_cast"); let _icx = bcx.insn_ctxt("impl::trans_cast");

2
src/librustc/middle/trans/reflect.rs
View file

@ -145,7 +145,7 @@ pub impl Reflector {
} }
fn leaf(&mut self, name: ~str) { fn leaf(&mut self, name: ~str) {
self.visit(name, ~[]); self.visit(name, []);
} }
// Entrypoint // Entrypoint

155
src/librustc/middle/ty.rs
View file

@ -137,7 +137,9 @@ type creader_cache = @mut HashMap<creader_cache_key, t>;
impl to_bytes::IterBytes for creader_cache_key { impl to_bytes::IterBytes for creader_cache_key {
fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
to_bytes::iter_bytes_3(&self.cnum, &self.pos, &self.len, lsb0, f) self.cnum.iter_bytes(lsb0, f) &&
self.pos.iter_bytes(lsb0, f) &&
self.len.iter_bytes(lsb0, f)
} }
} }
@ -392,14 +394,19 @@ pub struct FnSig {
impl to_bytes::IterBytes for BareFnTy { impl to_bytes::IterBytes for BareFnTy {
fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
to_bytes::iter_bytes_3(&self.purity, &self.abis, &self.sig, lsb0, f) self.purity.iter_bytes(lsb0, f) &&
self.abis.iter_bytes(lsb0, f) &&
self.sig.iter_bytes(lsb0, f)
} }
} }
impl to_bytes::IterBytes for ClosureTy { impl to_bytes::IterBytes for ClosureTy {
fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
to_bytes::iter_bytes_5(&self.purity, &self.sigil, &self.onceness, self.purity.iter_bytes(lsb0, f) &&
&self.region, &self.sig, lsb0, f) self.sigil.iter_bytes(lsb0, f) &&
self.onceness.iter_bytes(lsb0, f) &&
self.region.iter_bytes(lsb0, f) &&
self.sig.iter_bytes(lsb0, f)
} }
} }
@ -717,9 +724,15 @@ pub enum InferTy {
impl to_bytes::IterBytes for InferTy { impl to_bytes::IterBytes for InferTy {
fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
match *self { match *self {
TyVar(ref tv) => to_bytes::iter_bytes_2(&0u8, tv, lsb0, f), TyVar(ref tv) => {
IntVar(ref iv) => to_bytes::iter_bytes_2(&1u8, iv, lsb0, f), 0u8.iter_bytes(lsb0, f) && tv.iter_bytes(lsb0, f)
FloatVar(ref fv) => to_bytes::iter_bytes_2(&2u8, fv, lsb0, f), }
IntVar(ref iv) => {
1u8.iter_bytes(lsb0, f) && iv.iter_bytes(lsb0, f)
}
FloatVar(ref fv) => {
2u8.iter_bytes(lsb0, f) && fv.iter_bytes(lsb0, f)
}
} }
} }
} }
@ -733,8 +746,12 @@ pub enum InferRegion {
impl to_bytes::IterBytes for InferRegion { impl to_bytes::IterBytes for InferRegion {
fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
match *self { match *self {
ReVar(ref rv) => to_bytes::iter_bytes_2(&0u8, rv, lsb0, f), ReVar(ref rv) => {
ReSkolemized(ref v, _) => to_bytes::iter_bytes_2(&1u8, v, lsb0, f) 0u8.iter_bytes(lsb0, f) && rv.iter_bytes(lsb0, f)
}
ReSkolemized(ref v, _) => {
1u8.iter_bytes(lsb0, f) && v.iter_bytes(lsb0, f)
}
} }
} }
} }
@ -2626,119 +2643,115 @@ impl cmp::TotalEq for bound_region {
impl to_bytes::IterBytes for vstore { impl to_bytes::IterBytes for vstore {
fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
match *self { match *self {
vstore_fixed(ref u) => vstore_fixed(ref u) => {
to_bytes::iter_bytes_2(&0u8, u, lsb0, f), 0u8.iter_bytes(lsb0, f) && u.iter_bytes(lsb0, f)
}
vstore_uniq => 1u8.iter_bytes(lsb0, f),
vstore_box => 2u8.iter_bytes(lsb0, f),
vstore_uniq => 1u8.iter_bytes(lsb0, f), vstore_slice(ref r) => {
vstore_box => 2u8.iter_bytes(lsb0, f), 3u8.iter_bytes(lsb0, f) && r.iter_bytes(lsb0, f)
}
vstore_slice(ref r) =>
to_bytes::iter_bytes_2(&3u8, r, lsb0, f),
} }
} }
} }
impl to_bytes::IterBytes for substs { impl to_bytes::IterBytes for substs {
fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
to_bytes::iter_bytes_3(&self.self_r, self.self_r.iter_bytes(lsb0, f) &&
&self.self_ty, self.self_ty.iter_bytes(lsb0, f) &&
&self.tps, lsb0, f) self.tps.iter_bytes(lsb0, f)
} }
} }
impl to_bytes::IterBytes for mt { impl to_bytes::IterBytes for mt {
fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
to_bytes::iter_bytes_2(&self.ty, self.ty.iter_bytes(lsb0, f) && self.mutbl.iter_bytes(lsb0, f)
&self.mutbl, lsb0, f)
} }
} }
impl to_bytes::IterBytes for field { impl to_bytes::IterBytes for field {
fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
to_bytes::iter_bytes_2(&self.ident, self.ident.iter_bytes(lsb0, f) && self.mt.iter_bytes(lsb0, f)
&self.mt, lsb0, f)
} }
} }
impl to_bytes::IterBytes for FnSig { impl to_bytes::IterBytes for FnSig {
fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
to_bytes::iter_bytes_2(&self.inputs, self.inputs.iter_bytes(lsb0, f) && self.output.iter_bytes(lsb0, f)
&self.output,
lsb0, f)
} }
} }
impl to_bytes::IterBytes for sty { impl to_bytes::IterBytes for sty {
fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
match *self { match *self {
ty_nil => 0u8.iter_bytes(lsb0, f), ty_nil => 0u8.iter_bytes(lsb0, f),
ty_bool => 1u8.iter_bytes(lsb0, f), ty_bool => 1u8.iter_bytes(lsb0, f),
ty_int(ref t) => ty_int(ref t) => 2u8.iter_bytes(lsb0, f) && t.iter_bytes(lsb0, f),
to_bytes::iter_bytes_2(&2u8, t, lsb0, f),
ty_uint(ref t) => ty_uint(ref t) => 3u8.iter_bytes(lsb0, f) && t.iter_bytes(lsb0, f),
to_bytes::iter_bytes_2(&3u8, t, lsb0, f),
ty_float(ref t) => ty_float(ref t) => 4u8.iter_bytes(lsb0, f) && t.iter_bytes(lsb0, f),
to_bytes::iter_bytes_2(&4u8, t, lsb0, f),
ty_estr(ref v) => ty_estr(ref v) => 5u8.iter_bytes(lsb0, f) && v.iter_bytes(lsb0, f),
to_bytes::iter_bytes_2(&5u8, v, lsb0, f),
ty_enum(ref did, ref substs) => ty_enum(ref did, ref substs) => {
to_bytes::iter_bytes_3(&6u8, did, substs, lsb0, f), 6u8.iter_bytes(lsb0, f) &&
did.iter_bytes(lsb0, f) &&
substs.iter_bytes(lsb0, f)
}
ty_box(ref mt) => ty_box(ref mt) => 7u8.iter_bytes(lsb0, f) && mt.iter_bytes(lsb0, f),
to_bytes::iter_bytes_2(&7u8, mt, lsb0, f),
ty_evec(ref mt, ref v) => ty_evec(ref mt, ref v) => {
to_bytes::iter_bytes_3(&8u8, mt, v, lsb0, f), 8u8.iter_bytes(lsb0, f) &&
mt.iter_bytes(lsb0, f) &&
v.iter_bytes(lsb0, f)
}
ty_unboxed_vec(ref mt) => ty_unboxed_vec(ref mt) => 9u8.iter_bytes(lsb0, f) && mt.iter_bytes(lsb0, f),
to_bytes::iter_bytes_2(&9u8, mt, lsb0, f),
ty_tup(ref ts) => ty_tup(ref ts) => 10u8.iter_bytes(lsb0, f) && ts.iter_bytes(lsb0, f),
to_bytes::iter_bytes_2(&10u8, ts, lsb0, f),
ty_bare_fn(ref ft) => ty_bare_fn(ref ft) => 12u8.iter_bytes(lsb0, f) && ft.iter_bytes(lsb0, f),
to_bytes::iter_bytes_2(&12u8, ft, lsb0, f),
ty_self(ref did) => to_bytes::iter_bytes_2(&13u8, did, lsb0, f), ty_self(ref did) => 13u8.iter_bytes(lsb0, f) && did.iter_bytes(lsb0, f),
ty_infer(ref v) => ty_infer(ref v) => 14u8.iter_bytes(lsb0, f) && v.iter_bytes(lsb0, f),
to_bytes::iter_bytes_2(&14u8, v, lsb0, f),
ty_param(ref p) => ty_param(ref p) => 15u8.iter_bytes(lsb0, f) && p.iter_bytes(lsb0, f),
to_bytes::iter_bytes_2(&15u8, p, lsb0, f),
ty_type => 16u8.iter_bytes(lsb0, f), ty_type => 16u8.iter_bytes(lsb0, f),
ty_bot => 17u8.iter_bytes(lsb0, f), ty_bot => 17u8.iter_bytes(lsb0, f),
ty_ptr(ref mt) => ty_ptr(ref mt) => 18u8.iter_bytes(lsb0, f) && mt.iter_bytes(lsb0, f),
to_bytes::iter_bytes_2(&18u8, mt, lsb0, f),
ty_uniq(ref mt) => ty_uniq(ref mt) => 19u8.iter_bytes(lsb0, f) && mt.iter_bytes(lsb0, f),
to_bytes::iter_bytes_2(&19u8, mt, lsb0, f),
ty_trait(ref did, ref substs, ref v, ref mutbl) => ty_trait(ref did, ref substs, ref v, ref mutbl) => {
to_bytes::iter_bytes_5(&20u8, did, substs, v, mutbl, lsb0, f), 20u8.iter_bytes(lsb0, f) &&
did.iter_bytes(lsb0, f) &&
substs.iter_bytes(lsb0, f) &&
v.iter_bytes(lsb0, f) &&
mutbl.iter_bytes(lsb0, f)
}
ty_opaque_closure_ptr(ref ck) => ty_opaque_closure_ptr(ref ck) => 21u8.iter_bytes(lsb0, f) && ck.iter_bytes(lsb0, f),
to_bytes::iter_bytes_2(&21u8, ck, lsb0, f),
ty_opaque_box => 22u8.iter_bytes(lsb0, f), ty_opaque_box => 22u8.iter_bytes(lsb0, f),
ty_struct(ref did, ref substs) => ty_struct(ref did, ref substs) => {
to_bytes::iter_bytes_3(&23u8, did, substs, lsb0, f), 23u8.iter_bytes(lsb0, f) && did.iter_bytes(lsb0, f) && substs.iter_bytes(lsb0, f)
}
ty_rptr(ref r, ref mt) => ty_rptr(ref r, ref mt) => {
to_bytes::iter_bytes_3(&24u8, r, mt, lsb0, f), 24u8.iter_bytes(lsb0, f) && r.iter_bytes(lsb0, f) && mt.iter_bytes(lsb0, f)
}
ty_err => 25u8.iter_bytes(lsb0, f), ty_err => 25u8.iter_bytes(lsb0, f),
ty_closure(ref ct) => ty_closure(ref ct) => 26u8.iter_bytes(lsb0, f) && ct.iter_bytes(lsb0, f),
to_bytes::iter_bytes_2(&26u8, ct, lsb0, f),
} }
} }
} }

21
src/librustc/middle/typeck/infer/region_inference.rs
View file

@ -564,14 +564,23 @@ enum Constraint {
impl to_bytes::IterBytes for Constraint { impl to_bytes::IterBytes for Constraint {
fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
match *self { match *self {
ConstrainVarSubVar(ref v0, ref v1) => ConstrainVarSubVar(ref v0, ref v1) => {
to_bytes::iter_bytes_3(&0u8, v0, v1, lsb0, f), 0u8.iter_bytes(lsb0, f) &&
v0.iter_bytes(lsb0, f) &&
v1.iter_bytes(lsb0, f)
}
ConstrainRegSubVar(ref ra, ref va) => ConstrainRegSubVar(ref ra, ref va) => {
to_bytes::iter_bytes_3(&1u8, ra, va, lsb0, f), 1u8.iter_bytes(lsb0, f) &&
ra.iter_bytes(lsb0, f) &&
va.iter_bytes(lsb0, f)
}
ConstrainVarSubReg(ref va, ref ra) => ConstrainVarSubReg(ref va, ref ra) => {
to_bytes::iter_bytes_3(&2u8, va, ra, lsb0, f) 2u8.iter_bytes(lsb0, f) &&
va.iter_bytes(lsb0, f) &&
ra.iter_bytes(lsb0, f)
}
} }
} }
} }

2
src/librustc/util/enum_set.rs
View file

@ -10,8 +10,6 @@
use core::prelude::*; use core::prelude::*;
use core;
#[deriving(Eq, IterBytes)] #[deriving(Eq, IterBytes)]
pub struct EnumSet<E> { pub struct EnumSet<E> {
// We must maintain the invariant that no bits are set // We must maintain the invariant that no bits are set

28
src/librustdoc/config.rs
View file

@ -278,26 +278,26 @@ mod test {
#[test] #[test]
fn should_error_with_no_crates() { fn should_error_with_no_crates() {
let config = parse_config(~[~"rustdoc"]); let config = parse_config([~"rustdoc"]);
assert!(config.get_err() == ~"no crates specified"); assert!(config.get_err() == ~"no crates specified");
} }
#[test] #[test]
fn should_error_with_multiple_crates() { fn should_error_with_multiple_crates() {
let config = let config =
parse_config(~[~"rustdoc", ~"crate1.rc", ~"crate2.rc"]); parse_config([~"rustdoc", ~"crate1.rc", ~"crate2.rc"]);
assert!(config.get_err() == ~"multiple crates specified"); assert!(config.get_err() == ~"multiple crates specified");
} }
#[test] #[test]
fn should_set_output_dir_to_cwd_if_not_provided() { fn should_set_output_dir_to_cwd_if_not_provided() {
let config = parse_config(~[~"rustdoc", ~"crate.rc"]); let config = parse_config([~"rustdoc", ~"crate.rc"]);
assert!(config.get().output_dir == Path(".")); assert!(config.get().output_dir == Path("."));
} }
#[test] #[test]
fn should_set_output_dir_if_provided() { fn should_set_output_dir_if_provided() {
let config = parse_config(~[ let config = parse_config([
~"rustdoc", ~"crate.rc", ~"--output-dir", ~"snuggles" ~"rustdoc", ~"crate.rc", ~"--output-dir", ~"snuggles"
]); ]);
assert!(config.get().output_dir == Path("snuggles")); assert!(config.get().output_dir == Path("snuggles"));
@ -305,13 +305,13 @@ mod test {
#[test] #[test]
fn should_set_output_format_to_pandoc_html_if_not_provided() { fn should_set_output_format_to_pandoc_html_if_not_provided() {
let config = parse_config(~[~"rustdoc", ~"crate.rc"]); let config = parse_config([~"rustdoc", ~"crate.rc"]);
assert!(config.get().output_format == PandocHtml); assert!(config.get().output_format == PandocHtml);
} }
#[test] #[test]
fn should_set_output_format_to_markdown_if_requested() { fn should_set_output_format_to_markdown_if_requested() {
let config = parse_config(~[ let config = parse_config([
~"rustdoc", ~"crate.rc", ~"--output-format", ~"markdown" ~"rustdoc", ~"crate.rc", ~"--output-format", ~"markdown"
]); ]);
assert!(config.get().output_format == Markdown); assert!(config.get().output_format == Markdown);
@ -319,7 +319,7 @@ mod test {
#[test] #[test]
fn should_set_output_format_to_pandoc_html_if_requested() { fn should_set_output_format_to_pandoc_html_if_requested() {
let config = parse_config(~[ let config = parse_config([
~"rustdoc", ~"crate.rc", ~"--output-format", ~"html" ~"rustdoc", ~"crate.rc", ~"--output-format", ~"html"
]); ]);
assert!(config.get().output_format == PandocHtml); assert!(config.get().output_format == PandocHtml);
@ -327,7 +327,7 @@ mod test {
#[test] #[test]
fn should_error_on_bogus_format() { fn should_error_on_bogus_format() {
let config = parse_config(~[ let config = parse_config([
~"rustdoc", ~"crate.rc", ~"--output-format", ~"bogus" ~"rustdoc", ~"crate.rc", ~"--output-format", ~"bogus"
]); ]);
assert!(config.get_err() == ~"unknown output format 'bogus'"); assert!(config.get_err() == ~"unknown output format 'bogus'");
@ -335,13 +335,13 @@ mod test {
#[test] #[test]
fn should_set_output_style_to_doc_per_mod_by_default() { fn should_set_output_style_to_doc_per_mod_by_default() {
let config = parse_config(~[~"rustdoc", ~"crate.rc"]); let config = parse_config([~"rustdoc", ~"crate.rc"]);
assert!(config.get().output_style == DocPerMod); assert!(config.get().output_style == DocPerMod);
} }
#[test] #[test]
fn should_set_output_style_to_one_doc_if_requested() { fn should_set_output_style_to_one_doc_if_requested() {
let config = parse_config(~[ let config = parse_config([
~"rustdoc", ~"crate.rc", ~"--output-style", ~"doc-per-crate" ~"rustdoc", ~"crate.rc", ~"--output-style", ~"doc-per-crate"
]); ]);
assert!(config.get().output_style == DocPerCrate); assert!(config.get().output_style == DocPerCrate);
@ -349,7 +349,7 @@ mod test {
#[test] #[test]
fn should_set_output_style_to_doc_per_mod_if_requested() { fn should_set_output_style_to_doc_per_mod_if_requested() {
let config = parse_config(~[ let config = parse_config([
~"rustdoc", ~"crate.rc", ~"--output-style", ~"doc-per-mod" ~"rustdoc", ~"crate.rc", ~"--output-style", ~"doc-per-mod"
]); ]);
assert!(config.get().output_style == DocPerMod); assert!(config.get().output_style == DocPerMod);
@ -357,7 +357,7 @@ mod test {
#[test] #[test]
fn should_error_on_bogus_output_style() { fn should_error_on_bogus_output_style() {
let config = parse_config(~[ let config = parse_config([
~"rustdoc", ~"crate.rc", ~"--output-style", ~"bogus" ~"rustdoc", ~"crate.rc", ~"--output-style", ~"bogus"
]); ]);
assert!(config.get_err() == ~"unknown output style 'bogus'"); assert!(config.get_err() == ~"unknown output style 'bogus'");
@ -365,7 +365,7 @@ mod test {
#[test] #[test]
fn should_set_pandoc_command_if_requested() { fn should_set_pandoc_command_if_requested() {
let config = parse_config(~[ let config = parse_config([
~"rustdoc", ~"crate.rc", ~"--pandoc-cmd", ~"panda-bear-doc" ~"rustdoc", ~"crate.rc", ~"--pandoc-cmd", ~"panda-bear-doc"
]); ]);
assert!(config.get().pandoc_cmd == Some(~"panda-bear-doc")); assert!(config.get().pandoc_cmd == Some(~"panda-bear-doc"));
@ -373,7 +373,7 @@ mod test {
#[test] #[test]
fn should_set_pandoc_command_when_using_pandoc() { fn should_set_pandoc_command_when_using_pandoc() {
let config = parse_config(~[~"rustdoc", ~"crate.rc"]); let config = parse_config([~"rustdoc", ~"crate.rc"]);
assert!(config.get().pandoc_cmd == Some(~"pandoc")); assert!(config.get().pandoc_cmd == Some(~"pandoc"));
} }
} }

4
src/librustdoc/desc_to_brief_pass.rs
View file

@ -220,13 +220,13 @@ mod test {
#[test] #[test]
fn test_paragraphs_1() { fn test_paragraphs_1() {
let paras = paragraphs(~"1\n\n2"); let paras = paragraphs("1\n\n2");
assert_eq!(paras, ~[~"1", ~"2"]); assert_eq!(paras, ~[~"1", ~"2"]);
} }
#[test] #[test]
fn test_paragraphs_2() { fn test_paragraphs_2() {
let paras = paragraphs(~"\n\n1\n1\n\n2\n\n"); let paras = paragraphs("\n\n1\n1\n\n2\n\n");
assert_eq!(paras, ~[~"1\n1", ~"2"]); assert_eq!(paras, ~[~"1\n1", ~"2"]);
} }

2
src/librustdoc/extract.rs
View file

@ -16,9 +16,7 @@ use astsrv;
use doc::ItemUtils; use doc::ItemUtils;
use doc; use doc;
use core::local_data::local_data_get;
use syntax::ast; use syntax::ast;
use syntax;
use syntax::parse::token::{ident_interner}; use syntax::parse::token::{ident_interner};
use syntax::parse::token; use syntax::parse::token;

16
src/librustdoc/markdown_index_pass.rs
View file

@ -193,21 +193,21 @@ mod test {
#[test] #[test]
fn should_remove_punctuation_from_headers() { fn should_remove_punctuation_from_headers() {
assert!(pandoc_header_id(~"impl foo of bar<A>") == assert!(pandoc_header_id("impl foo of bar<A>") ==
~"impl-foo-of-bara"); ~"impl-foo-of-bara");
assert!(pandoc_header_id(~"impl of num::num for int") assert!(pandoc_header_id("impl of num::num for int")
== ~"impl-of-numnum-for-int"); == ~"impl-of-numnum-for-int");
assert!(pandoc_header_id(~"impl of num::num for int/&") assert!(pandoc_header_id("impl of num::num for int/&")
== ~"impl-of-numnum-for-int"); == ~"impl-of-numnum-for-int");
assert!(pandoc_header_id(~"impl of num::num for ^int") assert!(pandoc_header_id("impl of num::num for ^int")
== ~"impl-of-numnum-for-int"); == ~"impl-of-numnum-for-int");
assert!(pandoc_header_id(~"impl for & condvar") assert!(pandoc_header_id("impl for & condvar")
== ~"impl-for-condvar"); == ~"impl-for-condvar");
assert!(pandoc_header_id(~"impl of Select<T, U> for (Left, Right)") assert!(pandoc_header_id("impl of Select<T, U> for (Left, Right)")
== ~"impl-of-selectt-u-for-left-right"); == ~"impl-of-selectt-u-for-left-right");
assert!(pandoc_header_id(~"impl of Condition<'self, T, U>") assert!(pandoc_header_id("impl of Condition<'self, T, U>")
== ~"impl-of-conditionself-t-u"); == ~"impl-of-conditionself-t-u");
assert!(pandoc_header_id(~"impl of Condition<T: Copy + Clone>") assert!(pandoc_header_id("impl of Condition<T: Copy + Clone>")
== ~"impl-of-conditiont-copy-clone"); == ~"impl-of-conditiont-copy-clone");
} }

110
src/librustdoc/markdown_pass.rs
View file

@ -587,13 +587,13 @@ mod test {
#[test] #[test]
fn write_markdown_should_write_mod_headers() { fn write_markdown_should_write_mod_headers() {
let markdown = render(~"mod moo { }"); let markdown = render(~"mod moo { }");
assert!(str::contains(markdown, ~"# Module `moo`")); assert!(str::contains(markdown, "# Module `moo`"));
} }
#[test] #[test]
fn should_leave_blank_line_after_header() { fn should_leave_blank_line_after_header() {
let markdown = render(~"mod morp { }"); let markdown = render(~"mod morp { }");
assert!(str::contains(markdown, ~"Module `morp`\n\n")); assert!(str::contains(markdown, "Module `morp`\n\n"));
} }
#[test] #[test]
@ -613,10 +613,10 @@ mod test {
fn d() { }" fn d() { }"
); );
let idx_a = str::find_str(markdown, ~"# Module `a`").get(); let idx_a = str::find_str(markdown, "# Module `a`").get();
let idx_b = str::find_str(markdown, ~"## Function `b`").get(); let idx_b = str::find_str(markdown, "## Function `b`").get();
let idx_c = str::find_str(markdown, ~"# Module `c`").get(); let idx_c = str::find_str(markdown, "# Module `c`").get();
let idx_d = str::find_str(markdown, ~"## Function `d`").get(); let idx_d = str::find_str(markdown, "## Function `d`").get();
assert!(idx_b < idx_d); assert!(idx_b < idx_d);
assert!(idx_d < idx_a); assert!(idx_d < idx_a);
@ -649,7 +649,7 @@ mod test {
let (page, markdown) = po.recv(); let (page, markdown) = po.recv();
match page { match page {
doc::CratePage(_) => { doc::CratePage(_) => {
assert!(str::contains(markdown, ~"% Crate core")); assert!(str::contains(markdown, "% Crate core"));
} }
doc::ItemPage(_) => { doc::ItemPage(_) => {
assert!(str::contains(markdown, ~"% Module a")); assert!(str::contains(markdown, ~"% Module a"));
@ -661,7 +661,7 @@ mod test {
#[test] #[test]
fn should_write_full_path_to_mod() { fn should_write_full_path_to_mod() {
let markdown = render(~"mod a { mod b { mod c { } } }"); let markdown = render(~"mod a { mod b { mod c { } } }");
assert!(str::contains(markdown, ~"# Module `a::b::c`")); assert!(str::contains(markdown, "# Module `a::b::c`"));
} }
#[test] #[test]
@ -672,13 +672,13 @@ mod test {
Body\"]\ Body\"]\
mod a { mod a {
}"); }");
assert!(str::contains(markdown, ~"#### Header\n\nBody\n\n")); assert!(str::contains(markdown, "#### Header\n\nBody\n\n"));
} }
#[test] #[test]
fn should_write_crate_description() { fn should_write_crate_description() {
let markdown = render(~"#[doc = \"this is the crate\"];"); let markdown = render(~"#[doc = \"this is the crate\"];");
assert!(str::contains(markdown, ~"this is the crate")); assert!(str::contains(markdown, "this is the crate"));
} }
@ -687,21 +687,21 @@ mod test {
let markdown = render(~"mod a { } mod b { }"); let markdown = render(~"mod a { } mod b { }");
assert!(str::contains( assert!(str::contains(
markdown, markdown,
~"\n\n* [Module `a`](#module-a)\n\ "\n\n* [Module `a`](#module-a)\n\
* [Module `b`](#module-b)\n\n" * [Module `b`](#module-b)\n\n"
)); ));
} }
#[test] #[test]
fn should_write_index_brief() { fn should_write_index_brief() {
let markdown = render(~"#[doc = \"test\"] mod a { }"); let markdown = render(~"#[doc = \"test\"] mod a { }");
assert!(str::contains(markdown, ~"(#module-a) - test\n")); assert!(str::contains(markdown, "(#module-a) - test\n"));
} }
#[test] #[test]
fn should_not_write_index_if_no_entries() { fn should_not_write_index_if_no_entries() {
let markdown = render(~""); let markdown = render(~"");
assert!(!str::contains(markdown, ~"\n\n\n")); assert!(!str::contains(markdown, "\n\n\n"));
} }
#[test] #[test]
@ -709,7 +709,7 @@ mod test {
let markdown = render(~"extern { fn a(); }"); let markdown = render(~"extern { fn a(); }");
assert!(str::contains( assert!(str::contains(
markdown, markdown,
~"\n\n* [Function `a`](#function-a)\n\n" "\n\n* [Function `a`](#function-a)\n\n"
)); ));
} }
@ -717,32 +717,32 @@ mod test {
fn should_write_foreign_fns() { fn should_write_foreign_fns() {
let markdown = render( let markdown = render(
~"extern { #[doc = \"test\"] fn a(); }"); ~"extern { #[doc = \"test\"] fn a(); }");
assert!(str::contains(markdown, ~"test")); assert!(str::contains(markdown, "test"));
} }
#[test] #[test]
fn should_write_foreign_fn_headers() { fn should_write_foreign_fn_headers() {
let markdown = render( let markdown = render(
~"extern { #[doc = \"test\"] fn a(); }"); ~"extern { #[doc = \"test\"] fn a(); }");
assert!(str::contains(markdown, ~"## Function `a`")); assert!(str::contains(markdown, "## Function `a`"));
} }
#[test] #[test]
fn write_markdown_should_write_function_header() { fn write_markdown_should_write_function_header() {
let markdown = render(~"fn func() { }"); let markdown = render(~"fn func() { }");
assert!(str::contains(markdown, ~"## Function `func`")); assert!(str::contains(markdown, "## Function `func`"));
} }
#[test] #[test]
fn should_write_the_function_signature() { fn should_write_the_function_signature() {
let markdown = render(~"#[doc = \"f\"] fn a() { }"); let markdown = render(~"#[doc = \"f\"] fn a() { }");
assert!(str::contains(markdown, ~"\n fn a()\n")); assert!(str::contains(markdown, "\n fn a()\n"));
} }
#[test] #[test]
fn should_insert_blank_line_after_fn_signature() { fn should_insert_blank_line_after_fn_signature() {
let markdown = render(~"#[doc = \"f\"] fn a() { }"); let markdown = render(~"#[doc = \"f\"] fn a() { }");
assert!(str::contains(markdown, ~"fn a()\n\n")); assert!(str::contains(markdown, "fn a()\n\n"));
} }
#[test] #[test]
@ -763,19 +763,19 @@ mod test {
] ]
}; };
let markdown = write_markdown_str(doc); let markdown = write_markdown_str(doc);
assert!(str::contains(markdown, ~" line 1\n line 2")); assert!(str::contains(markdown, " line 1\n line 2"));
} }
#[test] #[test]
fn should_leave_blank_line_between_fn_header_and_sig() { fn should_leave_blank_line_between_fn_header_and_sig() {
let markdown = render(~"fn a() { }"); let markdown = render(~"fn a() { }");
assert!(str::contains(markdown, ~"Function `a`\n\n fn a()")); assert!(str::contains(markdown, "Function `a`\n\n fn a()"));
} }
#[test] #[test]
fn should_write_const_header() { fn should_write_const_header() {
let markdown = render(~"static a: bool = true;"); let markdown = render(~"static a: bool = true;");
assert!(str::contains(markdown, ~"## Const `a`\n\n")); assert!(str::contains(markdown, "## Const `a`\n\n"));
} }
#[test] #[test]
@ -783,20 +783,19 @@ mod test {
let markdown = render( let markdown = render(
~"#[doc = \"b\"]\ ~"#[doc = \"b\"]\
static a: bool = true;"); static a: bool = true;");
assert!(str::contains(markdown, ~"\n\nb\n\n")); assert!(str::contains(markdown, "\n\nb\n\n"));
} }
#[test] #[test]
fn should_write_enum_header() { fn should_write_enum_header() {
let markdown = render(~"enum a { b }"); let markdown = render(~"enum a { b }");
assert!(str::contains(markdown, ~"## Enum `a`\n\n")); assert!(str::contains(markdown, "## Enum `a`\n\n"));
} }
#[test] #[test]
fn should_write_enum_description() { fn should_write_enum_description() {
let markdown = render( let markdown = render(~"#[doc = \"b\"] enum a { b }");
~"#[doc = \"b\"] enum a { b }"); assert!(str::contains(markdown, "\n\nb\n\n"));
assert!(str::contains(markdown, ~"\n\nb\n\n"));
} }
#[test] #[test]
@ -807,9 +806,9 @@ mod test {
#[doc = \"test\"] c }"); #[doc = \"test\"] c }");
assert!(str::contains( assert!(str::contains(
markdown, markdown,
~"\n\n#### Variants\n\ "\n\n#### Variants\n\
\n* `b` - test\ \n* `b` - test\
\n* `c` - test\n\n")); \n* `c` - test\n\n"));
} }
#[test] #[test]
@ -817,9 +816,9 @@ mod test {
let markdown = render(~"enum a { b, c }"); let markdown = render(~"enum a { b, c }");
assert!(str::contains( assert!(str::contains(
markdown, markdown,
~"\n\n#### Variants\n\ "\n\n#### Variants\n\
\n* `b`\ \n* `b`\
\n* `c`\n\n")); \n* `c`\n\n"));
} }
#[test] #[test]
@ -827,100 +826,97 @@ mod test {
let markdown = render(~"enum a { b(int), #[doc = \"a\"] c(int) }"); let markdown = render(~"enum a { b(int), #[doc = \"a\"] c(int) }");
assert!(str::contains( assert!(str::contains(
markdown, markdown,
~"\n\n#### Variants\n\ "\n\n#### Variants\n\
\n* `b(int)`\ \n* `b(int)`\
\n* `c(int)` - a\n\n")); \n* `c(int)` - a\n\n"));
} }
#[test] #[test]
fn should_write_trait_header() { fn should_write_trait_header() {
let markdown = render(~"trait i { fn a(); }"); let markdown = render(~"trait i { fn a(); }");
assert!(str::contains(markdown, ~"## Trait `i`")); assert!(str::contains(markdown, "## Trait `i`"));
} }
#[test] #[test]
fn should_write_trait_desc() { fn should_write_trait_desc() {
let markdown = render( let markdown = render(~"#[doc = \"desc\"] trait i { fn a(); }");
~"#[doc = \"desc\"] trait i { fn a(); }"); assert!(str::contains(markdown, "desc"));
assert!(str::contains(markdown, ~"desc"));
} }
#[test] #[test]
fn should_write_trait_method_header() { fn should_write_trait_method_header() {
let markdown = render( let markdown = render(~"trait i { fn a(); }");
~"trait i { fn a(); }"); assert!(str::contains(markdown, "### Method `a`"));
assert!(str::contains(markdown, ~"### Method `a`"));
} }
#[test] #[test]
fn should_write_trait_method_signature() { fn should_write_trait_method_signature() {
let markdown = render( let markdown = render(~"trait i { fn a(&self); }");
~"trait i { fn a(&self); }"); assert!(str::contains(markdown, "\n fn a(&self)"));
assert!(str::contains(markdown, ~"\n fn a(&self)"));
} }
#[test] #[test]
fn should_write_impl_header() { fn should_write_impl_header() {
let markdown = render(~"impl int { fn a() { } }"); let markdown = render(~"impl int { fn a() { } }");
assert!(str::contains(markdown, ~"## Implementation for `int`")); assert!(str::contains(markdown, "## Implementation for `int`"));
} }
#[test] #[test]
fn should_write_impl_header_with_bounds() { fn should_write_impl_header_with_bounds() {
let markdown = render(~"impl <T> int<T> { }"); let markdown = render(~"impl <T> int<T> { }");
assert!(str::contains(markdown, ~"## Implementation for `int<T>` where `<T>`")); assert!(str::contains(markdown, "## Implementation for `int<T>` where `<T>`"));
} }
#[test] #[test]
fn should_write_impl_header_with_trait() { fn should_write_impl_header_with_trait() {
let markdown = render(~"impl j for int { fn a() { } }"); let markdown = render(~"impl j for int { fn a() { } }");
assert!(str::contains(markdown, assert!(str::contains(markdown,
~"## Implementation of `j` for `int`")); "## Implementation of `j` for `int`"));
} }
#[test] #[test]
fn should_write_impl_desc() { fn should_write_impl_desc() {
let markdown = render( let markdown = render(
~"#[doc = \"desc\"] impl int { fn a() { } }"); ~"#[doc = \"desc\"] impl int { fn a() { } }");
assert!(str::contains(markdown, ~"desc")); assert!(str::contains(markdown, "desc"));
} }
#[test] #[test]
fn should_write_impl_method_header() { fn should_write_impl_method_header() {
let markdown = render( let markdown = render(
~"impl int { fn a() { } }"); ~"impl int { fn a() { } }");
assert!(str::contains(markdown, ~"### Method `a`")); assert!(str::contains(markdown, "### Method `a`"));
} }
#[test] #[test]
fn should_write_impl_method_signature() { fn should_write_impl_method_signature() {
let markdown = render( let markdown = render(
~"impl int { fn a(&mut self) { } }"); ~"impl int { fn a(&mut self) { } }");
assert!(str::contains(markdown, ~"\n fn a(&mut self)")); assert!(str::contains(markdown, "\n fn a(&mut self)"));
} }
#[test] #[test]
fn should_write_type_header() { fn should_write_type_header() {
let markdown = render(~"type t = int;"); let markdown = render(~"type t = int;");
assert!(str::contains(markdown, ~"## Type `t`")); assert!(str::contains(markdown, "## Type `t`"));
} }
#[test] #[test]
fn should_write_type_desc() { fn should_write_type_desc() {
let markdown = render( let markdown = render(
~"#[doc = \"desc\"] type t = int;"); ~"#[doc = \"desc\"] type t = int;");
assert!(str::contains(markdown, ~"\n\ndesc\n\n")); assert!(str::contains(markdown, "\n\ndesc\n\n"));
} }
#[test] #[test]
fn should_write_type_signature() { fn should_write_type_signature() {
let markdown = render(~"type t = int;"); let markdown = render(~"type t = int;");
assert!(str::contains(markdown, ~"\n\n type t = int\n\n")); assert!(str::contains(markdown, "\n\n type t = int\n\n"));
} }
#[test] #[test]
fn should_put_struct_header() { fn should_put_struct_header() {
let markdown = render(~"struct S { field: () }"); let markdown = render(~"struct S { field: () }");
assert!(str::contains(markdown, ~"## Struct `S`\n\n")); assert!(str::contains(markdown, "## Struct `S`\n\n"));
} }
} }

8
src/librustdoc/sectionalize_pass.rs
View file

@ -188,7 +188,7 @@ mod test {
}"); }");
assert!(str::contains( assert!(str::contains(
doc.cratemod().mods()[0].item.sections[0].header, doc.cratemod().mods()[0].item.sections[0].header,
~"Header")); "Header"));
} }
#[test] #[test]
@ -201,7 +201,7 @@ mod test {
}"); }");
assert!(str::contains( assert!(str::contains(
doc.cratemod().mods()[0].item.sections[0].body, doc.cratemod().mods()[0].item.sections[0].body,
~"Body")); "Body"));
} }
#[test] #[test]
@ -226,10 +226,10 @@ mod test {
}"); }");
assert!(!str::contains( assert!(!str::contains(
doc.cratemod().mods()[0].desc().get(), doc.cratemod().mods()[0].desc().get(),
~"Header")); "Header"));
assert!(!str::contains( assert!(!str::contains(
doc.cratemod().mods()[0].desc().get(), doc.cratemod().mods()[0].desc().get(),
~"Body")); "Body"));
} }
#[test] #[test]

6
src/librusti/rusti.rc
View file

@ -80,7 +80,7 @@ fn record(mut repl: Repl, blk: &ast::blk, intr: @token::ident_interner) -> Repl
let new_view_items = do with_pp(intr) |pp, writer| { let new_view_items = do with_pp(intr) |pp, writer| {
for blk.node.view_items.each |view_item| { for blk.node.view_items.each |view_item| {
pprust::print_view_item(pp, *view_item); pprust::print_view_item(pp, *view_item);
writer.write_line(~""); writer.write_line("");
} }
}; };
@ -94,7 +94,7 @@ fn record(mut repl: Repl, blk: &ast::blk, intr: @token::ident_interner) -> Repl
match stmt.node { match stmt.node {
ast::stmt_decl(*) | ast::stmt_mac(*) => { ast::stmt_decl(*) | ast::stmt_mac(*) => {
pprust::print_stmt(pp, *stmt); pprust::print_stmt(pp, *stmt);
writer.write_line(~""); writer.write_line("");
} }
ast::stmt_expr(expr, _) | ast::stmt_semi(expr, _) => { ast::stmt_expr(expr, _) | ast::stmt_semi(expr, _) => {
match expr.node { match expr.node {
@ -415,7 +415,7 @@ pub fn main() {
Some(line) => { Some(line) => {
if line.is_empty() { if line.is_empty() {
if istty { if istty {
io::println(~"()"); io::println("()");
} }
loop; loop;
} }

1
src/librustpkg/tests.rs
View file

@ -12,7 +12,6 @@
use context::Ctx; use context::Ctx;
use core::hashmap::HashMap; use core::hashmap::HashMap;
use core::path::Path;
use core::prelude::*; use core::prelude::*;
use std::tempfile::mkdtemp; use std::tempfile::mkdtemp;
use util::{PkgId, default_version}; use util::{PkgId, default_version};

1
src/libstd/cast.rs
View file

@ -11,7 +11,6 @@
//! Unsafe casting functions //! Unsafe casting functions
use sys; use sys;
use unstable;
use unstable::intrinsics; use unstable::intrinsics;
/// Casts the value at `src` to U. The two types must have the same length. /// Casts the value at `src` to U. The two types must have the same length.

2
src/libstd/hash.rs
View file

@ -488,7 +488,7 @@ mod tests {
assert!(f == i && f == v); assert!(f == i && f == v);
buf += ~[t as u8]; buf += ~[t as u8];
stream_inc.input(~[t as u8]); stream_inc.input([t as u8]);
t += 1; t += 1;
} }

28
src/libstd/io.rs
View file

@ -1839,7 +1839,7 @@ mod tests {
{ {
let out: @io::Writer = let out: @io::Writer =
result::get( result::get(
&io::file_writer(tmpfile, ~[io::Create, io::Truncate])); &io::file_writer(tmpfile, [io::Create, io::Truncate]));
out.write_str(frood); out.write_str(frood);
} }
let inp: @io::Reader = result::get(&io::file_reader(tmpfile)); let inp: @io::Reader = result::get(&io::file_reader(tmpfile));
@ -1850,7 +1850,7 @@ mod tests {
#[test] #[test]
fn test_readchars_empty() { fn test_readchars_empty() {
do io::with_str_reader(~"") |inp| { do io::with_str_reader("") |inp| {
let res : ~[char] = inp.read_chars(128); let res : ~[char] = inp.read_chars(128);
assert_eq!(res.len(), 0); assert_eq!(res.len(), 0);
} }
@ -1858,7 +1858,7 @@ mod tests {
#[test] #[test]
fn test_read_line_utf8() { fn test_read_line_utf8() {
do io::with_str_reader(~"生锈的汤匙切肉汤hello生锈的汤匙切肉汤") |inp| { do io::with_str_reader("生锈的汤匙切肉汤hello生锈的汤匙切肉汤") |inp| {
let line = inp.read_line(); let line = inp.read_line();
assert_eq!(line, ~"生锈的汤匙切肉汤hello生锈的汤匙切肉汤"); assert_eq!(line, ~"生锈的汤匙切肉汤hello生锈的汤匙切肉汤");
} }
@ -1866,15 +1866,15 @@ mod tests {
#[test] #[test]
fn test_read_lines() { 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"]); 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"]); 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()); assert!(inp.read_lines().is_empty());
} }
} }
@ -1909,7 +1909,7 @@ mod tests {
#[test] #[test]
fn test_readchar() { fn test_readchar() {
do io::with_str_reader(~"生") |inp| { do io::with_str_reader("生") |inp| {
let res : char = inp.read_char(); let res : char = inp.read_char();
assert_eq!(res as int, 29983); assert_eq!(res as int, 29983);
} }
@ -1917,7 +1917,7 @@ mod tests {
#[test] #[test]
fn test_readchar_empty() { fn test_readchar_empty() {
do io::with_str_reader(~"") |inp| { do io::with_str_reader("") |inp| {
let res : char = inp.read_char(); let res : char = inp.read_char();
assert_eq!(res as int, -1); assert_eq!(res as int, -1);
} }
@ -1966,7 +1966,7 @@ mod tests {
#[test] #[test]
fn file_writer_bad_name() { fn file_writer_bad_name() {
match io::file_writer(&Path("?/?"), ~[]) { match io::file_writer(&Path("?/?"), []) {
result::Err(copy e) => { result::Err(copy e) => {
assert!(str::starts_with(e, "error opening")); assert!(str::starts_with(e, "error opening"));
} }
@ -1987,15 +1987,15 @@ mod tests {
#[test] #[test]
fn bytes_buffer_overwrite() { fn bytes_buffer_overwrite() {
let wr = BytesWriter(); let wr = BytesWriter();
wr.write(~[0u8, 1u8, 2u8, 3u8]); wr.write([0u8, 1u8, 2u8, 3u8]);
assert!(*wr.bytes == ~[0u8, 1u8, 2u8, 3u8]); assert!(*wr.bytes == ~[0u8, 1u8, 2u8, 3u8]);
wr.seek(-2, SeekCur); 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]); assert!(*wr.bytes == ~[0u8, 1u8, 4u8, 5u8, 6u8, 7u8]);
wr.seek(-2, SeekEnd); wr.seek(-2, SeekEnd);
wr.write(~[8u8]); wr.write([8u8]);
wr.seek(1, SeekSet); wr.seek(1, SeekSet);
wr.write(~[9u8]); wr.write([9u8]);
assert!(*wr.bytes == ~[0u8, 9u8, 4u8, 5u8, 8u8, 7u8]); assert!(*wr.bytes == ~[0u8, 9u8, 4u8, 5u8, 8u8, 7u8]);
} }
@ -2085,7 +2085,7 @@ mod tests {
} }
} }
#[test] #[test]
fn test_read_write_f32() { fn test_read_write_f32() {
let path = Path("tmp/lib-io-test-read-write-f32.tmp"); let path = Path("tmp/lib-io-test-read-write-f32.tmp");
let f:f32 = 8.1250; let f:f32 = 8.1250;

1
src/libstd/num/f32.rs
View file

@ -951,7 +951,6 @@ impl num::FromStrRadix for f32 {
mod tests { mod tests {
use f32::*; use f32::*;
use num::*; use num::*;
use super::*;
use prelude::*; use prelude::*;
#[test] #[test]

1
src/libstd/num/f64.rs
View file

@ -993,7 +993,6 @@ impl num::FromStrRadix for f64 {
mod tests { mod tests {
use f64::*; use f64::*;
use num::*; use num::*;
use super::*;
use prelude::*; use prelude::*;
#[test] #[test]

138
src/libstd/num/float.rs
View file

@ -1251,101 +1251,101 @@ mod tests {
#[test] #[test]
pub fn test_from_str() { pub fn test_from_str() {
assert_eq!(from_str(~"3"), Some(3.)); 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("+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(~"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("25000000000.E-10"), Some(2.5));
assert_eq!(from_str(~"."), Some(0.)); assert_eq!(from_str("."), Some(0.));
assert_eq!(from_str(~".e1"), Some(0.)); assert_eq!(from_str(".e1"), Some(0.));
assert_eq!(from_str(~".e-1"), Some(0.)); assert_eq!(from_str(".e-1"), Some(0.));
assert_eq!(from_str(~"5."), Some(5.)); assert_eq!(from_str("5."), Some(5.));
assert_eq!(from_str(~".5"), Some(0.5)); assert_eq!(from_str(".5"), Some(0.5));
assert_eq!(from_str(~"0.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(-0.5));
assert_eq!(from_str(~"-5"), Some(-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(infinity)); assert_eq!(from_str("+inf"), Some(infinity));
assert_eq!(from_str(~"-inf"), Some(neg_infinity)); assert_eq!(from_str("-inf"), Some(neg_infinity));
// note: NaN != NaN, hence this slightly complex test // note: NaN != NaN, hence this slightly complex test
match from_str(~"NaN") { match from_str("NaN") {
Some(f) => assert!(f.is_NaN()), Some(f) => assert!(f.is_NaN()),
None => fail!() None => fail!()
} }
// note: -0 == 0, hence these slightly more complex tests // 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()), Some(v) if v.is_zero() => assert!(v.is_negative()),
_ => fail!() _ => fail!()
} }
match from_str(~"0") { match from_str("0") {
Some(v) if v.is_zero() => assert!(v.is_positive()), Some(v) if v.is_zero() => assert!(v.is_positive()),
_ => fail!() _ => fail!()
} }
assert!(from_str(~"").is_none()); assert!(from_str("").is_none());
assert!(from_str(~"x").is_none()); assert!(from_str("x").is_none());
assert!(from_str(~" ").is_none()); assert!(from_str(" ").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(~"E").is_none()); assert!(from_str("E").is_none());
assert!(from_str(~"E1").is_none()); assert!(from_str("E1").is_none());
assert!(from_str(~"1e1e1").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(~"1e1-1").is_none()); assert!(from_str("1e1-1").is_none());
} }
#[test] #[test]
pub fn test_from_str_hex() { pub fn test_from_str_hex() {
assert_eq!(from_str_hex(~"a4"), Some(164.)); 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("-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(~"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("ff0p-4"), Some(0xff as float));
assert_eq!(from_str_hex(~"."), Some(0.)); assert_eq!(from_str_hex("."), Some(0.));
assert_eq!(from_str_hex(~".p1"), Some(0.)); assert_eq!(from_str_hex(".p1"), Some(0.));
assert_eq!(from_str_hex(~".p-1"), 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(15.));
assert_eq!(from_str_hex(~".f"), Some(0.9375)); assert_eq!(from_str_hex(".f"), Some(0.9375));
assert_eq!(from_str_hex(~"0.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(-0.9375));
assert_eq!(from_str_hex(~"-f"), Some(-15.)); 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(infinity)); assert_eq!(from_str_hex("+inf"), Some(infinity));
assert_eq!(from_str_hex(~"-inf"), Some(neg_infinity)); assert_eq!(from_str_hex("-inf"), Some(neg_infinity));
// note: NaN != NaN, hence this slightly complex test // note: NaN != NaN, hence this slightly complex test
match from_str_hex(~"NaN") { match from_str_hex("NaN") {
Some(f) => assert!(f.is_NaN()), Some(f) => assert!(f.is_NaN()),
None => fail!() None => fail!()
} }
// note: -0 == 0, hence these slightly more complex tests // 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()), Some(v) if v.is_zero() => assert!(v.is_negative()),
_ => fail!() _ => fail!()
} }
match from_str_hex(~"0") { match from_str_hex("0") {
Some(v) if v.is_zero() => assert!(v.is_positive()), Some(v) if v.is_zero() => assert!(v.is_positive()),
_ => fail!() _ => fail!()
} }
assert_eq!(from_str_hex(~"e"), Some(14.)); assert_eq!(from_str_hex("e"), Some(14.));
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("E1"), Some(225.));
assert_eq!(from_str_hex(~"1e1e1"), Some(123361.)); assert_eq!(from_str_hex("1e1e1"), Some(123361.));
assert_eq!(from_str_hex(~"1e1.1"), Some(481.0625)); assert_eq!(from_str_hex("1e1.1"), Some(481.0625));
assert!(from_str_hex(~"").is_none()); assert!(from_str_hex("").is_none());
assert!(from_str_hex(~"x").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(~" ").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(~"P").is_none()); assert!(from_str_hex("P").is_none());
assert!(from_str_hex(~"P1").is_none()); assert!(from_str_hex("P1").is_none());
assert!(from_str_hex(~"1p1p1").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(~"1p1-1").is_none()); assert!(from_str_hex("1p1-1").is_none());
} }
#[test] #[test]
@ -1375,8 +1375,8 @@ mod tests {
#[test] #[test]
pub fn test_from_str_radix() { pub fn test_from_str_radix() {
assert_eq!(from_str_radix(~"10", 36u), Some(36.)); 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("1000.001", 2u), Some(8.125));
} }
#[test] #[test]

92
src/libstd/num/int-template.rs
View file

@ -755,45 +755,45 @@ mod tests {
#[test] #[test]
fn test_from_str() { fn test_from_str() {
assert_eq!(from_str(~"0"), Some(0 as T)); assert_eq!(from_str("0"), Some(0 as T));
assert_eq!(from_str(~"3"), Some(3 as T)); assert_eq!(from_str("3"), Some(3 as T));
assert_eq!(from_str(~"10"), Some(10 as T)); assert_eq!(from_str("10"), Some(10 as T));
assert_eq!(i32::from_str(~"123456789"), Some(123456789 as i32)); assert_eq!(i32::from_str("123456789"), Some(123456789 as i32));
assert_eq!(from_str(~"00100"), Some(100 as T)); assert_eq!(from_str("00100"), Some(100 as T));
assert_eq!(from_str(~"-1"), Some(-1 as T)); assert_eq!(from_str("-1"), Some(-1 as T));
assert_eq!(from_str(~"-3"), Some(-3 as T)); assert_eq!(from_str("-3"), Some(-3 as T));
assert_eq!(from_str(~"-10"), Some(-10 as T)); assert_eq!(from_str("-10"), Some(-10 as T));
assert_eq!(i32::from_str(~"-123456789"), Some(-123456789 as i32)); assert_eq!(i32::from_str("-123456789"), Some(-123456789 as i32));
assert_eq!(from_str(~"-00100"), Some(-100 as T)); assert_eq!(from_str("-00100"), Some(-100 as T));
assert!(from_str(~" ").is_none()); assert!(from_str(" ").is_none());
assert!(from_str(~"x").is_none()); assert!(from_str("x").is_none());
} }
#[test] #[test]
fn test_parse_bytes() { fn test_parse_bytes() {
use str::to_bytes; use str::to_bytes;
assert_eq!(parse_bytes(to_bytes(~"123"), 10u), Some(123 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("1001"), 2u), Some(9 as T));
assert_eq!(parse_bytes(to_bytes(~"123"), 8u), Some(83 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("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!(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(~"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("-123"), 10u), Some(-123 as T));
assert_eq!(parse_bytes(to_bytes(~"-1001"), 2u), Some(-9 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!(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("-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!(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(~"-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("Z"), 35u).is_none());
assert!(parse_bytes(to_bytes(~"-9"), 2u).is_none()); assert!(parse_bytes(to_bytes("-9"), 2u).is_none());
} }
#[test] #[test]
@ -836,36 +836,36 @@ mod tests {
#[test] #[test]
fn test_int_from_str_overflow() { fn test_int_from_str_overflow() {
let mut i8_val: i8 = 127_i8; let mut i8_val: i8 = 127_i8;
assert_eq!(i8::from_str(~"127"), Some(i8_val)); assert_eq!(i8::from_str("127"), Some(i8_val));
assert!(i8::from_str(~"128").is_none()); assert!(i8::from_str("128").is_none());
i8_val += 1 as i8; i8_val += 1 as i8;
assert_eq!(i8::from_str(~"-128"), Some(i8_val)); assert_eq!(i8::from_str("-128"), Some(i8_val));
assert!(i8::from_str(~"-129").is_none()); assert!(i8::from_str("-129").is_none());
let mut i16_val: i16 = 32_767_i16; let mut i16_val: i16 = 32_767_i16;
assert_eq!(i16::from_str(~"32767"), Some(i16_val)); assert_eq!(i16::from_str("32767"), Some(i16_val));
assert!(i16::from_str(~"32768").is_none()); assert!(i16::from_str("32768").is_none());
i16_val += 1 as i16; i16_val += 1 as i16;
assert_eq!(i16::from_str(~"-32768"), Some(i16_val)); assert_eq!(i16::from_str("-32768"), Some(i16_val));
assert!(i16::from_str(~"-32769").is_none()); assert!(i16::from_str("-32769").is_none());
let mut i32_val: i32 = 2_147_483_647_i32; let mut i32_val: i32 = 2_147_483_647_i32;
assert_eq!(i32::from_str(~"2147483647"), Some(i32_val)); assert_eq!(i32::from_str("2147483647"), Some(i32_val));
assert!(i32::from_str(~"2147483648").is_none()); assert!(i32::from_str("2147483648").is_none());
i32_val += 1 as i32; i32_val += 1 as i32;
assert_eq!(i32::from_str(~"-2147483648"), Some(i32_val)); assert_eq!(i32::from_str("-2147483648"), Some(i32_val));
assert!(i32::from_str(~"-2147483649").is_none()); assert!(i32::from_str("-2147483649").is_none());
let mut i64_val: i64 = 9_223_372_036_854_775_807_i64; let mut i64_val: i64 = 9_223_372_036_854_775_807_i64;
assert_eq!(i64::from_str(~"9223372036854775807"), Some(i64_val)); assert_eq!(i64::from_str("9223372036854775807"), Some(i64_val));
assert!(i64::from_str(~"9223372036854775808").is_none()); assert!(i64::from_str("9223372036854775808").is_none());
i64_val += 1 as i64; i64_val += 1 as i64;
assert_eq!(i64::from_str(~"-9223372036854775808"), Some(i64_val)); assert_eq!(i64::from_str("-9223372036854775808"), Some(i64_val));
assert!(i64::from_str(~"-9223372036854775809").is_none()); assert!(i64::from_str("-9223372036854775809").is_none());
} }
#[test] #[test]

64
src/libstd/num/uint-template.rs
View file

@ -472,29 +472,29 @@ mod tests {
#[test] #[test]
pub fn test_from_str() { pub fn test_from_str() {
assert_eq!(from_str(~"0"), Some(0u as T)); assert_eq!(from_str("0"), Some(0u as T));
assert_eq!(from_str(~"3"), Some(3u as T)); assert_eq!(from_str("3"), Some(3u as T));
assert_eq!(from_str(~"10"), Some(10u as T)); assert_eq!(from_str("10"), Some(10u as T));
assert_eq!(u32::from_str(~"123456789"), Some(123456789 as u32)); assert_eq!(u32::from_str("123456789"), Some(123456789 as u32));
assert_eq!(from_str(~"00100"), Some(100u as T)); assert_eq!(from_str("00100"), Some(100u as T));
assert!(from_str(~"").is_none()); assert!(from_str("").is_none());
assert!(from_str(~" ").is_none()); assert!(from_str(" ").is_none());
assert!(from_str(~"x").is_none()); assert!(from_str("x").is_none());
} }
#[test] #[test]
pub fn test_parse_bytes() { pub fn test_parse_bytes() {
use str::to_bytes; use str::to_bytes;
assert_eq!(parse_bytes(to_bytes(~"123"), 10u), Some(123u 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("1001"), 2u), Some(9u as T));
assert_eq!(parse_bytes(to_bytes(~"123"), 8u), Some(83u 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("123"), 16u), Some(291u as u16));
assert_eq!(u16::parse_bytes(to_bytes(~"ffff"), 16u), Some(65535u 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("z"), 36u), Some(35u as T));
assert!(parse_bytes(to_bytes(~"Z"), 10u).is_none()); assert!(parse_bytes(to_bytes("Z"), 10u).is_none());
assert!(parse_bytes(to_bytes(~"_"), 2u).is_none()); assert!(parse_bytes(to_bytes("_"), 2u).is_none());
} }
#[test] #[test]
@ -527,36 +527,36 @@ mod tests {
#[test] #[test]
fn test_uint_from_str_overflow() { fn test_uint_from_str_overflow() {
let mut u8_val: u8 = 255_u8; let mut u8_val: u8 = 255_u8;
assert_eq!(u8::from_str(~"255"), Some(u8_val)); assert_eq!(u8::from_str("255"), Some(u8_val));
assert!(u8::from_str(~"256").is_none()); assert!(u8::from_str("256").is_none());
u8_val += 1 as u8; u8_val += 1 as u8;
assert_eq!(u8::from_str(~"0"), Some(u8_val)); assert_eq!(u8::from_str("0"), Some(u8_val));
assert!(u8::from_str(~"-1").is_none()); assert!(u8::from_str("-1").is_none());
let mut u16_val: u16 = 65_535_u16; let mut u16_val: u16 = 65_535_u16;
assert_eq!(u16::from_str(~"65535"), Some(u16_val)); assert_eq!(u16::from_str("65535"), Some(u16_val));
assert!(u16::from_str(~"65536").is_none()); assert!(u16::from_str("65536").is_none());
u16_val += 1 as u16; u16_val += 1 as u16;
assert_eq!(u16::from_str(~"0"), Some(u16_val)); assert_eq!(u16::from_str("0"), Some(u16_val));
assert!(u16::from_str(~"-1").is_none()); assert!(u16::from_str("-1").is_none());
let mut u32_val: u32 = 4_294_967_295_u32; let mut u32_val: u32 = 4_294_967_295_u32;
assert_eq!(u32::from_str(~"4294967295"), Some(u32_val)); assert_eq!(u32::from_str("4294967295"), Some(u32_val));
assert!(u32::from_str(~"4294967296").is_none()); assert!(u32::from_str("4294967296").is_none());
u32_val += 1 as u32; u32_val += 1 as u32;
assert_eq!(u32::from_str(~"0"), Some(u32_val)); assert_eq!(u32::from_str("0"), Some(u32_val));
assert!(u32::from_str(~"-1").is_none()); assert!(u32::from_str("-1").is_none());
let mut u64_val: u64 = 18_446_744_073_709_551_615_u64; let mut u64_val: u64 = 18_446_744_073_709_551_615_u64;
assert_eq!(u64::from_str(~"18446744073709551615"), Some(u64_val)); assert_eq!(u64::from_str("18446744073709551615"), Some(u64_val));
assert!(u64::from_str(~"18446744073709551616").is_none()); assert!(u64::from_str("18446744073709551616").is_none());
u64_val += 1 as u64; u64_val += 1 as u64;
assert_eq!(u64::from_str(~"0"), Some(u64_val)); assert_eq!(u64::from_str("0"), Some(u64_val));
assert!(u64::from_str(~"-1").is_none()); assert!(u64::from_str("-1").is_none());
} }
#[test] #[test]

46
src/libstd/os.rs
View file

@ -1444,14 +1444,14 @@ mod tests {
#[test] #[test]
fn test_setenv() { fn test_setenv() {
let n = make_rand_name(); let n = make_rand_name();
setenv(n, ~"VALUE"); setenv(n, "VALUE");
assert_eq!(getenv(n), option::Some(~"VALUE")); assert_eq!(getenv(n), option::Some(~"VALUE"));
} }
#[test] #[test]
fn test_unsetenv() { fn test_unsetenv() {
let n = make_rand_name(); let n = make_rand_name();
setenv(n, ~"VALUE"); setenv(n, "VALUE");
unsetenv(n); unsetenv(n);
assert_eq!(getenv(n), option::None); assert_eq!(getenv(n), option::None);
} }
@ -1461,10 +1461,10 @@ mod tests {
#[ignore] #[ignore]
fn test_setenv_overwrite() { fn test_setenv_overwrite() {
let n = make_rand_name(); let n = make_rand_name();
setenv(n, ~"1"); setenv(n, "1");
setenv(n, ~"2"); setenv(n, "2");
assert_eq!(getenv(n), option::Some(~"2")); assert_eq!(getenv(n), option::Some(~"2"));
setenv(n, ~""); setenv(n, "");
assert_eq!(getenv(n), option::Some(~"")); assert_eq!(getenv(n), option::Some(~""));
} }
@ -1515,7 +1515,7 @@ mod tests {
let n = make_rand_name(); let n = make_rand_name();
let mut e = env(); let mut e = env();
setenv(n, ~"VALUE"); setenv(n, "VALUE");
assert!(!vec::contains(e, &(copy n, ~"VALUE"))); assert!(!vec::contains(e, &(copy n, ~"VALUE")));
e = env(); e = env();
@ -1526,7 +1526,7 @@ mod tests {
fn test() { fn test() {
assert!((!Path("test-path").is_absolute)); 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("test-path")));
debug!(make_absolute(&Path("/usr/bin"))); debug!(make_absolute(&Path("/usr/bin")));
@ -1535,43 +1535,43 @@ mod tests {
#[test] #[test]
#[cfg(unix)] #[cfg(unix)]
fn homedir() { 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"))); assert_eq!(os::homedir(), Some(Path("/home/MountainView")));
setenv(~"HOME", ~""); setenv("HOME", "");
assert!(os::homedir().is_none()); assert!(os::homedir().is_none());
for oldhome.each |s| { setenv(~"HOME", *s) } for oldhome.each |s| { setenv("HOME", *s) }
} }
#[test] #[test]
#[cfg(windows)] #[cfg(windows)]
fn homedir() { fn homedir() {
let oldhome = getenv(~"HOME"); let oldhome = getenv("HOME");
let olduserprofile = getenv(~"USERPROFILE"); let olduserprofile = getenv("USERPROFILE");
setenv(~"HOME", ~""); setenv("HOME", "");
setenv(~"USERPROFILE", ~""); setenv("USERPROFILE", "");
assert!(os::homedir().is_none()); assert!(os::homedir().is_none());
setenv(~"HOME", ~"/home/MountainView"); setenv("HOME", "/home/MountainView");
assert_eq!(os::homedir(), Some(Path("/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"))); assert_eq!(os::homedir(), Some(Path("/home/MountainView")));
setenv(~"HOME", ~"/home/MountainView"); setenv("HOME", "/home/MountainView");
setenv(~"USERPROFILE", ~"/home/PaloAlto"); setenv("USERPROFILE", "/home/PaloAlto");
assert_eq!(os::homedir(), Some(Path("/home/MountainView"))); assert_eq!(os::homedir(), Some(Path("/home/MountainView")));
oldhome.each(|s| {setenv(~"HOME", *s);true}); oldhome.each(|s| { setenv("HOME", *s); true });
olduserprofile.each(|s| {setenv(~"USERPROFILE", *s);true}); olduserprofile.each(|s| { setenv("USERPROFILE", *s); true });
} }
#[test] #[test]
@ -1646,7 +1646,7 @@ mod tests {
fail!("%s doesn't exist", in.to_str()); fail!("%s doesn't exist", in.to_str());
} }
assert!((rs)); 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!(rslt, 0);
assert_eq!(out.get_mode(), in_mode); assert_eq!(out.get_mode(), in_mode);
assert!((remove_file(&in))); assert!((remove_file(&in)));

18
src/libstd/rand.rs
View file

@ -988,10 +988,10 @@ mod tests {
#[test] #[test]
fn test_choose_weighted() { fn test_choose_weighted() {
let mut r = rng(); let mut r = rng();
assert!(r.choose_weighted(~[ assert!(r.choose_weighted([
Weighted { weight: 1u, item: 42 }, Weighted { weight: 1u, item: 42 },
]) == 42); ]) == 42);
assert!(r.choose_weighted(~[ assert!(r.choose_weighted([
Weighted { weight: 0u, item: 42 }, Weighted { weight: 0u, item: 42 },
Weighted { weight: 1u, item: 43 }, Weighted { weight: 1u, item: 43 },
]) == 43); ]) == 43);
@ -1000,10 +1000,10 @@ mod tests {
#[test] #[test]
fn test_choose_weighted_option() { fn test_choose_weighted_option() {
let mut r = rng(); let mut r = rng();
assert!(r.choose_weighted_option(~[ assert!(r.choose_weighted_option([
Weighted { weight: 1u, item: 42 }, Weighted { weight: 1u, item: 42 },
]) == Some(42)); ]) == Some(42));
assert!(r.choose_weighted_option(~[ assert!(r.choose_weighted_option([
Weighted { weight: 0u, item: 42 }, Weighted { weight: 0u, item: 42 },
Weighted { weight: 1u, item: 43 }, Weighted { weight: 1u, item: 43 },
]) == Some(43)); ]) == Some(43));
@ -1015,8 +1015,8 @@ mod tests {
fn test_weighted_vec() { fn test_weighted_vec() {
let mut r = rng(); let mut r = rng();
let empty: ~[int] = ~[]; let empty: ~[int] = ~[];
assert_eq!(r.weighted_vec(~[]), empty); assert_eq!(r.weighted_vec([]), empty);
assert!(r.weighted_vec(~[ assert!(r.weighted_vec([
Weighted { weight: 0u, item: 3u }, Weighted { weight: 0u, item: 3u },
Weighted { weight: 1u, item: 2u }, Weighted { weight: 1u, item: 2u },
Weighted { weight: 2u, item: 1u }, Weighted { weight: 2u, item: 1u },
@ -1027,15 +1027,15 @@ mod tests {
fn test_shuffle() { fn test_shuffle() {
let mut r = rng(); let mut r = rng();
let empty: ~[int] = ~[]; let empty: ~[int] = ~[];
assert_eq!(r.shuffle(~[]), empty); assert_eq!(r.shuffle([]), empty);
assert_eq!(r.shuffle(~[1, 1, 1]), ~[1, 1, 1]); assert_eq!(r.shuffle([1, 1, 1]), ~[1, 1, 1]);
} }
#[test] #[test]
fn test_task_rng() { fn test_task_rng() {
let mut r = task_rng(); let mut r = task_rng();
r.gen::<int>(); 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); assert_eq!(r.gen_uint_range(0u, 1u), 0u);
} }

2
src/libstd/rt/comm.rs
View file

@ -474,7 +474,7 @@ mod test {
#[test] #[test]
fn oneshot_single_thread_peek_open() { fn oneshot_single_thread_peek_open() {
do run_in_newsched_task { do run_in_newsched_task {
let (port, chan) = oneshot::<int>(); let (port, _) = oneshot::<int>();
assert!(!port.peek()); assert!(!port.peek());
} }
} }

6
src/libstd/rt/io/extensions.rs
View file

@ -587,12 +587,10 @@ fn extend_sign(val: u64, nbytes: uint) -> i64 {
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use super::{ReaderUtil, ReaderByteConversions, WriterByteConversions}; use super::ReaderUtil;
use u64;
use i32;
use option::{Some, None}; use option::{Some, None};
use cell::Cell; use cell::Cell;
use rt::io::mem::{MemReader, MemWriter}; use rt::io::mem::MemReader;
use rt::io::mock::MockReader; use rt::io::mock::MockReader;
use rt::io::{read_error, placeholder_error}; use rt::io::{read_error, placeholder_error};

8
src/libstd/rt/local.rs
View file

@ -33,7 +33,7 @@ impl Local for Scheduler {
} }
impl Local for Task { impl Local for Task {
fn put(value: ~Task) { abort!("unimpl") } fn put(_value: ~Task) { abort!("unimpl") }
fn take() -> ~Task { abort!("unimpl") } fn take() -> ~Task { abort!("unimpl") }
fn exists() -> bool { abort!("unimpl") } fn exists() -> bool { abort!("unimpl") }
fn borrow(f: &fn(&mut Task)) { 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 // XXX: This formulation won't work once ~IoFactoryObject is a real trait pointer
impl Local for IoFactoryObject { impl Local for IoFactoryObject {
fn put(value: ~IoFactoryObject) { abort!("unimpl") } fn put(_value: ~IoFactoryObject) { abort!("unimpl") }
fn take() -> ~IoFactoryObject { abort!("unimpl") } fn take() -> ~IoFactoryObject { abort!("unimpl") }
fn exists() -> bool { 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 { unsafe fn unsafe_borrow() -> *mut IoFactoryObject {
let sched = Local::unsafe_borrow::<Scheduler>(); let sched = Local::unsafe_borrow::<Scheduler>();
let io: *mut IoFactoryObject = (*sched).event_loop.io().unwrap(); let io: *mut IoFactoryObject = (*sched).event_loop.io().unwrap();
@ -115,4 +115,4 @@ mod test {
} }
let _scheduler: ~Scheduler = Local::take(); let _scheduler: ~Scheduler = Local::take();
} }
} }

1
src/libstd/rt/sched.rs
View file

@ -20,7 +20,6 @@ use super::context::Context;
use super::task::Task; use super::task::Task;
use rt::local_ptr; use rt::local_ptr;
use rt::local::Local; use rt::local::Local;
use rt::rtio::IoFactoryObject;
/// The Scheduler is responsible for coordinating execution of Coroutines /// The Scheduler is responsible for coordinating execution of Coroutines
/// on a single thread. When the scheduler is running it is owned by /// on a single thread. When the scheduler is running it is owned by

1
src/libstd/rt/task.rs
View file

@ -16,7 +16,6 @@
use prelude::*; use prelude::*;
use libc::{c_void, uintptr_t}; use libc::{c_void, uintptr_t};
use cast::transmute; use cast::transmute;
use super::sched::Scheduler;
use rt::local::Local; use rt::local::Local;
use super::local_heap::LocalHeap; use super::local_heap::LocalHeap;
use rt::logging::StdErrLogger; use rt::logging::StdErrLogger;

545
src/libstd/str.rs
View file

@ -2794,31 +2794,31 @@ mod tests {
#[test] #[test]
fn test_len() { fn test_len() {
assert_eq!(len(~""), 0u); assert_eq!(len(""), 0u);
assert_eq!(len(~"hello world"), 11u); assert_eq!(len("hello world"), 11u);
assert_eq!(len(~"\x63"), 1u); assert_eq!(len("\x63"), 1u);
assert_eq!(len(~"\xa2"), 2u); assert_eq!(len("\xa2"), 2u);
assert_eq!(len(~"\u03c0"), 2u); assert_eq!(len("\u03c0"), 2u);
assert_eq!(len(~"\u2620"), 3u); assert_eq!(len("\u2620"), 3u);
assert_eq!(len(~"\U0001d11e"), 4u); assert_eq!(len("\U0001d11e"), 4u);
assert_eq!(char_len(~""), 0u); assert_eq!(char_len(""), 0u);
assert_eq!(char_len(~"hello world"), 11u); assert_eq!(char_len("hello world"), 11u);
assert_eq!(char_len(~"\x63"), 1u); assert_eq!(char_len("\x63"), 1u);
assert_eq!(char_len(~"\xa2"), 1u); assert_eq!(char_len("\xa2"), 1u);
assert_eq!(char_len(~"\u03c0"), 1u); assert_eq!(char_len("\u03c0"), 1u);
assert_eq!(char_len(~"\u2620"), 1u); assert_eq!(char_len("\u2620"), 1u);
assert_eq!(char_len(~"\U0001d11e"), 1u); assert_eq!(char_len("\U0001d11e"), 1u);
assert_eq!(char_len(~"ประเทศไทย中华Việt Nam"), 19u); assert_eq!(char_len("ประเทศไทย中华Việt Nam"), 19u);
} }
#[test] #[test]
fn test_rfind_char() { fn test_rfind_char() {
assert_eq!(rfind_char(~"hello", 'l'), Some(3u)); assert_eq!(rfind_char("hello", 'l'), Some(3u));
assert_eq!(rfind_char(~"hello", 'o'), Some(4u)); assert_eq!(rfind_char("hello", 'o'), Some(4u));
assert_eq!(rfind_char(~"hello", 'h'), Some(0u)); assert_eq!(rfind_char("hello", 'h'), Some(0u));
assert!(rfind_char(~"hello", 'z').is_none()); assert!(rfind_char("hello", 'z').is_none());
assert_eq!(rfind_char(~"ประเทศไทย中华Việt Nam", '华'), Some(30u)); assert_eq!(rfind_char("ประเทศไทย中华Việt Nam", '华'), Some(30u));
} }
#[test] #[test]
@ -2848,66 +2848,66 @@ mod tests {
#[test] #[test]
fn test_split_char() { fn test_split_char() {
fn t(s: &str, c: char, u: &[~str]) { fn t(s: &str, c: char, u: &[~str]) {
debug!(~"split_byte: " + s); debug!("split_byte: %?", s);
let mut v = ~[]; let mut v = ~[];
for each_split_char(s, c) |s| { v.push(s.to_owned()) } for each_split_char(s, c) |s| { v.push(s.to_owned()) }
debug!("split_byte to: %?", v); debug!("split_byte to: %?", v);
assert!(vec::all2(v, u, |a,b| a == b)); assert!(vec::all2(v, u, |a,b| a == b));
} }
t(~"abc.hello.there", '.', ~[~"abc", ~"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("...hello.there.", '.', [~"", ~"", ~"", ~"hello", ~"there", ~""]);
t(~"", 'z', ~[~""]); t("", 'z', [~""]);
t(~"z", 'z', ~[~"",~""]); t("z", 'z', [~"",~""]);
t(~"ok", 'z', ~[~"ok"]); t("ok", 'z', [~"ok"]);
} }
#[test] #[test]
fn test_split_char_2() { fn test_split_char_2() {
fn t(s: &str, c: char, u: &[~str]) { fn t(s: &str, c: char, u: &[~str]) {
debug!(~"split_byte: " + s); debug!("split_byte: %?", s);
let mut v = ~[]; let mut v = ~[];
for each_split_char(s, c) |s| { v.push(s.to_owned()) } for each_split_char(s, c) |s| { v.push(s.to_owned()) }
debug!("split_byte to: %?", v); debug!("split_byte to: %?", v);
assert!(vec::all2(v, u, |a,b| a == b)); assert!(vec::all2(v, u, |a,b| a == b));
} }
let data = ~"ประเทศไทย中华Việt Nam"; let data = "ประเทศไทย中华Việt Nam";
t(data, 'V', ~[~"ประเทศไทย中华", ~"iệt Nam"]); t(data, 'V', [~"ประเทศไทย中华", ~"iệt Nam"]);
t(data, 'ท', ~[~"ประเ", ~"ศไ", ~"ย中华Việt Nam"]); t(data, 'ท', [~"ประเ", ~"ศไ", ~"ย中华Việt Nam"]);
} }
#[test] #[test]
fn test_splitn_char() { fn test_splitn_char() {
fn t(s: &str, c: char, n: uint, u: &[~str]) { fn t(s: &str, c: char, n: uint, u: &[~str]) {
debug!(~"splitn_byte: " + s); debug!("splitn_byte: %?", s);
let mut v = ~[]; let mut v = ~[];
for each_splitn_char(s, c, n) |s| { v.push(s.to_owned()) } for each_splitn_char(s, c, n) |s| { v.push(s.to_owned()) }
debug!("split_byte to: %?", v); debug!("split_byte to: %?", v);
debug!("comparing vs. %?", u); debug!("comparing vs. %?", u);
assert!(vec::all2(v, u, |a,b| a == b)); assert!(vec::all2(v, u, |a,b| a == b));
} }
t(~"abc.hello.there", '.', 0u, ~[~"abc.hello.there"]); t("abc.hello.there", '.', 0u, [~"abc.hello.there"]);
t(~"abc.hello.there", '.', 1u, ~[~"abc", ~"hello.there"]); t("abc.hello.there", '.', 1u, [~"abc", ~"hello.there"]);
t(~"abc.hello.there", '.', 2u, ~[~"abc", ~"hello", ~"there"]); t("abc.hello.there", '.', 2u, [~"abc", ~"hello", ~"there"]);
t(~"abc.hello.there", '.', 3u, ~[~"abc", ~"hello", ~"there"]); t("abc.hello.there", '.', 3u, [~"abc", ~"hello", ~"there"]);
t(~".hello.there", '.', 0u, ~[~".hello.there"]); t(".hello.there", '.', 0u, [~".hello.there"]);
t(~".hello.there", '.', 1u, ~[~"", ~"hello.there"]); t(".hello.there", '.', 1u, [~"", ~"hello.there"]);
t(~"...hello.there.", '.', 3u, ~[~"", ~"", ~"", ~"hello.there."]); t("...hello.there.", '.', 3u, [~"", ~"", ~"", ~"hello.there."]);
t(~"...hello.there.", '.', 5u, ~[~"", ~"", ~"", ~"hello", ~"there", ~""]); t("...hello.there.", '.', 5u, [~"", ~"", ~"", ~"hello", ~"there", ~""]);
t(~"", 'z', 5u, ~[~""]); t("", 'z', 5u, [~""]);
t(~"z", 'z', 5u, ~[~"",~""]); t("z", 'z', 5u, [~"",~""]);
t(~"ok", 'z', 5u, ~[~"ok"]); t("ok", 'z', 5u, [~"ok"]);
t(~"z", 'z', 0u, ~[~"z"]); t("z", 'z', 0u, [~"z"]);
t(~"w.x.y", '.', 0u, ~[~"w.x.y"]); t("w.x.y", '.', 0u, [~"w.x.y"]);
t(~"w.x.y", '.', 1u, ~[~"w",~"x.y"]); t("w.x.y", '.', 1u, [~"w",~"x.y"]);
} }
#[test] #[test]
fn test_splitn_char_2 () { fn test_splitn_char_2() {
fn t(s: &str, c: char, n: uint, u: &[~str]) { fn t(s: &str, c: char, n: uint, u: &[~str]) {
debug!(~"splitn_byte: " + s); debug!("splitn_byte: %?", s);
let mut v = ~[]; let mut v = ~[];
for each_splitn_char(s, c, n) |s| { v.push(s.to_owned()) } for each_splitn_char(s, c, n) |s| { v.push(s.to_owned()) }
debug!("split_byte to: %?", v); debug!("split_byte to: %?", v);
@ -2915,60 +2915,59 @@ mod tests {
assert!(vec::all2(v, u, |a,b| a == b)); assert!(vec::all2(v, u, |a,b| a == b));
} }
t(~"ประเทศไทย中华Việt Nam", '华', 1u, ~[~"ประเทศไทย中", ~"Việt Nam"]); t("ประเทศไทย中华Việt Nam", '华', 1u, [~"ประเทศไทย中", ~"Việt Nam"]);
t(~"zzXXXzYYYzWWWz", 'z', 3u, ~[~"", ~"", ~"XXX", ~"YYYzWWWz"]); t("zzXXXzYYYzWWWz", 'z', 3u, [~"", ~"", ~"XXX", ~"YYYzWWWz"]);
t(~"z", 'z', 5u, ~[~"",~""]); t("z", 'z', 5u, [~"",~""]);
t(~"", 'z', 5u, ~[~""]); t("", 'z', 5u, [~""]);
t(~"ok", 'z', 5u, ~[~"ok"]); t("ok", 'z', 5u, [~"ok"]);
} }
#[test] #[test]
fn test_splitn_char_3() { fn test_splitn_char_3() {
fn t(s: &str, c: char, n: uint, u: &[~str]) { fn t(s: &str, c: char, n: uint, u: &[~str]) {
debug!(~"splitn_byte: " + s); debug!("splitn_byte: %?", s);
let mut v = ~[]; let mut v = ~[];
for each_splitn_char(s, c, n) |s| { v.push(s.to_owned()) } for each_splitn_char(s, c, n) |s| { v.push(s.to_owned()) }
debug!("split_byte to: %?", v); debug!("split_byte to: %?", v);
debug!("comparing vs. %?", u); debug!("comparing vs. %?", u);
assert!(vec::all2(v, u, |a,b| a == b)); assert!(vec::all2(v, u, |a,b| a == b));
} }
let data = ~"ประเทศไทย中华Việt Nam"; let data = "ประเทศไทย中华Việt Nam";
t(data, 'V', 1u, ~[~"ประเทศไทย中华", ~"iệt Nam"]); t(data, 'V', 1u, [~"ประเทศไทย中华", ~"iệt Nam"]);
t(data, 'ท', 1u, ~[~"ประเ", ~"ศไทย中华Việt Nam"]); t(data, 'ท', 1u, [~"ประเ", ~"ศไทย中华Việt Nam"]);
} }
#[test] #[test]
fn test_split_char_no_trailing() { fn test_split_char_no_trailing() {
fn t(s: &str, c: char, u: &[~str]) { fn t(s: &str, c: char, u: &[~str]) {
debug!(~"split_byte: " + s); debug!("split_byte: %?", s);
let mut v = ~[]; let mut v = ~[];
for each_split_char_no_trailing(s, c) |s| { v.push(s.to_owned()) } for each_split_char_no_trailing(s, c) |s| { v.push(s.to_owned()) }
debug!("split_byte to: %?", v); debug!("split_byte to: %?", v);
assert!(vec::all2(v, u, |a,b| a == b)); assert!(vec::all2(v, u, |a,b| a == b));
} }
t(~"abc.hello.there", '.', ~[~"abc", ~"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("...hello.there.", '.', [~"", ~"", ~"", ~"hello", ~"there"]);
t(~"...hello.there.", '.', ~[~"", ~"", ~"", ~"hello", ~"there"]); t("...hello.there.", '.', [~"", ~"", ~"", ~"hello", ~"there"]);
t(~"", 'z', ~[]); t("", 'z', []);
t(~"z", 'z', ~[~""]); t("z", 'z', [~""]);
t(~"ok", 'z', ~[~"ok"]); t("ok", 'z', [~"ok"]);
} }
#[test] #[test]
fn test_split_char_no_trailing_2() { fn test_split_char_no_trailing_2() {
fn t(s: &str, c: char, u: &[~str]) { fn t(s: &str, c: char, u: &[~str]) {
debug!(~"split_byte: " + s); debug!("split_byte: %?", s);
let mut v = ~[]; let mut v = ~[];
for each_split_char_no_trailing(s, c) |s| { v.push(s.to_owned()) } for each_split_char_no_trailing(s, c) |s| { v.push(s.to_owned()) }
debug!("split_byte to: %?", v); debug!("split_byte to: %?", v);
assert!(vec::all2(v, u, |a,b| a == b)); assert!(vec::all2(v, u, |a,b| a == b));
} }
let data = ~"ประเทศไทย中华Việt Nam"; let data = "ประเทศไทย中华Việt Nam";
t(data, 'V', ~[~"ประเทศไทย中华", ~"iệt Nam"]); t(data, 'V', [~"ประเทศไทย中华", ~"iệt Nam"]);
t(data, 'ท', ~[~"ประเ", ~"ศไ", ~"ย中华Việt Nam"]); t(data, 'ท', [~"ประเ", ~"ศไ", ~"ย中华Việt Nam"]);
} }
#[test] #[test]
@ -2978,20 +2977,20 @@ mod tests {
for each_split_str(s, sep) |s| { v.push(s.to_owned()) } for each_split_str(s, sep) |s| { v.push(s.to_owned()) }
assert!(vec::all2(v, u, |a,b| a == b)); assert!(vec::all2(v, u, |a,b| a == b));
} }
t(~"--1233345--", ~"12345", ~[~"--1233345--"]); t("--1233345--", "12345", [~"--1233345--"]);
t(~"abc::hello::there", ~"::", ~[~"abc", ~"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("hello::there::", "::", [~"hello", ~"there", ~""]);
t(~"::hello::there::", ~"::", ~[~"", ~"hello", ~"there", ~""]); t("::hello::there::", "::", [~"", ~"hello", ~"there", ~""]);
t(~"ประเทศไทย中华Việt Nam", ~"中华", ~[~"ประเทศไทย", ~"Việt Nam"]); t("ประเทศไทย中华Việt Nam", "中华", [~"ประเทศไทย", ~"Việt Nam"]);
t(~"zzXXXzzYYYzz", ~"zz", ~[~"", ~"XXX", ~"YYY", ~""]); t("zzXXXzzYYYzz", "zz", [~"", ~"XXX", ~"YYY", ~""]);
t(~"zzXXXzYYYz", ~"XXX", ~[~"zz", ~"zYYYz"]); t("zzXXXzYYYz", "XXX", [~"zz", ~"zYYYz"]);
t(~".XXX.YYY.", ~".", ~[~"", ~"XXX", ~"YYY", ~""]); t(".XXX.YYY.", ".", [~"", ~"XXX", ~"YYY", ~""]);
t(~"", ~".", ~[~""]); t("", ".", [~""]);
t(~"zz", ~"zz", ~[~"",~""]); t("zz", "zz", [~"",~""]);
t(~"ok", ~"z", ~[~"ok"]); t("ok", "z", [~"ok"]);
t(~"zzz", ~"zz", ~[~"",~"z"]); t("zzz", "zz", [~"",~"z"]);
t(~"zzzzz", ~"zz", ~[~"",~"",~"z"]); t("zzzzz", "zz", [~"",~"",~"z"]);
} }
@ -3003,12 +3002,12 @@ mod tests {
assert!(vec::all2(v, u, |a,b| a == b)); assert!(vec::all2(v, u, |a,b| a == b));
} }
t(~"ประเทศไทย中华Việt Nam", |cc| cc == '华', ~[~"ประเทศไทย中", ~"Việt Nam"]); t("ประเทศไทย中华Việt Nam", |cc| cc == '华', [~"ประเทศไทย中", ~"Việt Nam"]);
t(~"zzXXXzYYYz", char::is_lowercase, ~[~"", ~"", ~"XXX", ~"YYY", ~""]); t("zzXXXzYYYz", char::is_lowercase, [~"", ~"", ~"XXX", ~"YYY", ~""]);
t(~"zzXXXzYYYz", char::is_uppercase, ~[~"zz", ~"", ~"", ~"z", ~"", ~"", ~"z"]); t("zzXXXzYYYz", char::is_uppercase, [~"zz", ~"", ~"", ~"z", ~"", ~"", ~"z"]);
t(~"z", |cc| cc == 'z', ~[~"",~""]); t("z", |cc| cc == 'z', [~"",~""]);
t(~"", |cc| cc == 'z', ~[~""]); t("", |cc| cc == 'z', [~""]);
t(~"ok", |cc| cc == 'z', ~[~"ok"]); t("ok", |cc| cc == 'z', [~"ok"]);
} }
#[test] #[test]
@ -3019,18 +3018,18 @@ mod tests {
assert!(vec::all2(v, u, |a,b| a == b)); assert!(vec::all2(v, u, |a,b| a == b));
} }
t(~"ประเทศไทย中华Việt Nam", |cc| cc == '华', ~[~"ประเทศไทย中", ~"Việt Nam"]); t("ประเทศไทย中华Việt Nam", |cc| cc == '华', [~"ประเทศไทย中", ~"Việt Nam"]);
t(~"zzXXXzYYYz", char::is_lowercase, ~[~"", ~"", ~"XXX", ~"YYY"]); t("zzXXXzYYYz", char::is_lowercase, [~"", ~"", ~"XXX", ~"YYY"]);
t(~"zzXXXzYYYz", char::is_uppercase, ~[~"zz", ~"", ~"", ~"z", ~"", ~"", ~"z"]); t("zzXXXzYYYz", char::is_uppercase, [~"zz", ~"", ~"", ~"z", ~"", ~"", ~"z"]);
t(~"z", |cc| cc == 'z', ~[~""]); t("z", |cc| cc == 'z', [~""]);
t(~"", |cc| cc == 'z', ~[]); t("", |cc| cc == 'z', []);
t(~"ok", |cc| cc == 'z', ~[~"ok"]); t("ok", |cc| cc == 'z', [~"ok"]);
} }
#[test] #[test]
fn test_lines() { fn test_lines() {
let lf = ~"\nMary had a little lamb\nLittle lamb\n"; let lf = "\nMary had a little lamb\nLittle lamb\n";
let crlf = ~"\r\nMary had a little lamb\r\nLittle lamb\r\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]) { fn t(s: &str, f: &fn(&str, &fn(&str) -> bool) -> bool, u: &[~str]) {
let mut v = ~[]; let mut v = ~[];
@ -3038,30 +3037,30 @@ mod tests {
assert!(vec::all2(v, u, |a,b| a == b)); assert!(vec::all2(v, u, |a,b| a == b));
} }
t(lf, each_line ,~[~"", ~"Mary had a little lamb", ~"Little lamb"]); t(lf, each_line, [~"", ~"Mary had a little lamb", ~"Little lamb"]);
t(lf, each_line_any, ~[~"", ~"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, [~"\r", ~"Mary had a little lamb\r", ~"Little lamb\r"]);
t(crlf, each_line_any, ~[~"", ~"Mary had a little lamb", ~"Little lamb"]); t(crlf, each_line_any, [~"", ~"Mary had a little lamb", ~"Little lamb"]);
t(~"", each_line, ~[]); t("", each_line, []);
t(~"", each_line_any, ~[]); t("", each_line_any, []);
t(~"\n", each_line, ~[~""]); t("\n", each_line, [~""]);
t(~"\n", each_line_any, ~[~""]); t("\n", each_line_any, [~""]);
t(~"banana", each_line, ~[~"banana"]); t("banana", each_line, [~"banana"]);
t(~"banana", each_line_any, ~[~"banana"]); t("banana", each_line_any, [~"banana"]);
} }
#[test] #[test]
fn test_words () { fn test_words() {
fn t(s: &str, f: &fn(&str, &fn(&str) -> bool) -> bool, u: &[~str]) { fn t(s: &str, f: &fn(&str, &fn(&str) -> bool) -> bool, u: &[~str]) {
let mut v = ~[]; let mut v = ~[];
for f(s) |s| { v.push(s.to_owned()) } for f(s) |s| { v.push(s.to_owned()) }
assert!(vec::all2(v, u, |a,b| a == b)); 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(data, each_word, [~"Mary",~"had",~"a",~"little",~"lamb",~"Little",~"lamb"]);
t(~"ok", each_word, ~[~"ok"]); t("ok", each_word, [~"ok"]);
t(~"", each_word, ~[]); t("", each_word, []);
} }
#[test] #[test]
@ -3071,53 +3070,53 @@ mod tests {
for each_split_within(s, i) |s| { v.push(s.to_owned()) } for each_split_within(s, i) |s| { v.push(s.to_owned()) }
assert!(vec::all2(v, u, |a,b| a == b)); assert!(vec::all2(v, u, |a,b| a == b));
} }
t(~"", 0, ~[]); t("", 0, []);
t(~"", 15, ~[]); t("", 15, []);
t(~"hello", 15, ~[~"hello"]); t("hello", 15, [~"hello"]);
t(~"\nMary had a little lamb\nLittle lamb\n", 15, t("\nMary had a little lamb\nLittle lamb\n", 15,
~[~"Mary had a", ~"little lamb", ~"Little lamb"]); [~"Mary had a", ~"little lamb", ~"Little lamb"]);
} }
#[test] #[test]
fn test_find_str() { fn test_find_str() {
// byte positions // byte positions
assert!(find_str(~"banana", ~"apple pie").is_none()); assert!(find_str("banana", "apple pie").is_none());
assert_eq!(find_str(~"", ~""), Some(0u)); assert_eq!(find_str("", ""), Some(0u));
let data = ~"ประเทศไทย中华Việt Nam"; 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( 0u)); assert_eq!(find_str(data, "ประเ"), Some( 0u));
assert_eq!(find_str(data, ~"ะเ"), Some( 6u)); assert_eq!(find_str(data, "ะเ"), Some( 6u));
assert_eq!(find_str(data, ~"中华"), Some(27u)); assert_eq!(find_str(data, "中华"), Some(27u));
assert!(find_str(data, ~"ไท华").is_none()); assert!(find_str(data, "ไท华").is_none());
} }
#[test] #[test]
fn test_find_str_between() { fn test_find_str_between() {
// byte positions // byte positions
assert_eq!(find_str_between(~"", ~"", 0u, 0u), Some(0u)); assert_eq!(find_str_between("", "", 0u, 0u), Some(0u));
let data = ~"abcabc"; let data = "abcabc";
assert_eq!(find_str_between(data, ~"ab", 0u, 6u), Some(0u)); assert_eq!(find_str_between(data, "ab", 0u, 6u), Some(0u));
assert_eq!(find_str_between(data, ~"ab", 2u, 6u), Some(3u)); assert_eq!(find_str_between(data, "ab", 2u, 6u), Some(3u));
assert!(find_str_between(data, ~"ab", 2u, 4u).is_none()); assert!(find_str_between(data, "ab", 2u, 4u).is_none());
let mut data = ~"ประเทศไทย中华Việt Nam"; let mut data = ~"ประเทศไทย中华Việt Nam";
data = data + data; data = data + data;
assert_eq!(find_str_between(data, ~"", 0u, 43u), Some(0u)); 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, "", 6u, 43u), Some(6u));
assert_eq!(find_str_between(data, ~"ประ", 0u, 43u), Some( 0u)); 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(12u));
assert_eq!(find_str_between(data, ~"ย中", 0u, 43u), Some(24u)); 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, "iệt", 0u, 43u), Some(34u));
assert_eq!(find_str_between(data, ~"Nam", 0u, 43u), Some(40u)); 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(43u));
assert_eq!(find_str_between(data, ~"ทศไ", 43u, 86u), Some(55u)); 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, "ย中", 43u, 86u), Some(67u));
assert_eq!(find_str_between(data, ~"iệt", 43u, 86u), Some(77u)); 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, "Nam", 43u, 86u), Some(83u));
} }
#[test] #[test]
@ -3135,10 +3134,10 @@ mod tests {
fn t(v: &[~str], s: &str) { fn t(v: &[~str], s: &str) {
assert_eq!(concat(v), s.to_str()); assert_eq!(concat(v), s.to_str());
} }
t(~[~"you", ~"know", ~"I'm", ~"no", ~"good"], ~"youknowI'mnogood"); t([~"you", ~"know", ~"I'm", ~"no", ~"good"], "youknowI'mnogood");
let v: ~[~str] = ~[]; let v: &[~str] = [];
t(v, ~""); t(v, "");
t(~[~"hi"], ~"hi"); t([~"hi"], "hi");
} }
#[test] #[test]
@ -3146,11 +3145,11 @@ mod tests {
fn t(v: &[~str], sep: &str, s: &str) { fn t(v: &[~str], sep: &str, s: &str) {
assert_eq!(connect(v, sep), s.to_str()); assert_eq!(connect(v, sep), s.to_str());
} }
t(~[~"you", ~"know", ~"I'm", ~"no", ~"good"], t([~"you", ~"know", ~"I'm", ~"no", ~"good"],
~" ", ~"you know I'm no good"); " ", "you know I'm no good");
let v: ~[~str] = ~[]; let v: &[~str] = ~[];
t(v, ~" ", ~""); t(v, " ", "");
t(~[~"hi"], ~" ", ~"hi"); t([~"hi"], " ", "hi");
} }
#[test] #[test]
@ -3166,11 +3165,11 @@ mod tests {
#[test] #[test]
fn test_repeat() { fn test_repeat() {
assert_eq!(repeat(~"x", 4), ~"xxxx"); assert_eq!(repeat("x", 4), ~"xxxx");
assert_eq!(repeat(~"hi", 4), ~"hihihihi"); assert_eq!(repeat("hi", 4), ~"hihihihi");
assert_eq!(repeat(~"ไท华", 3), ~"ไท华ไท华ไท华"); assert_eq!(repeat("ไท华", 3), ~"ไท华ไท华ไท华");
assert_eq!(repeat(~"", 4), ~""); assert_eq!(repeat("", 4), ~"");
assert_eq!(repeat(~"hi", 0), ~""); assert_eq!(repeat("hi", 0), ~"");
} }
#[test] #[test]
@ -3197,38 +3196,38 @@ mod tests {
#[test] #[test]
fn test_starts_with() { fn test_starts_with() {
assert!((starts_with(~"", ~""))); assert!((starts_with("", "")));
assert!((starts_with(~"abc", ~""))); assert!((starts_with("abc", "")));
assert!((starts_with(~"abc", ~"a"))); assert!((starts_with("abc", "a")));
assert!((!starts_with(~"a", ~"abc"))); assert!((!starts_with("a", "abc")));
assert!((!starts_with(~"", ~"abc"))); assert!((!starts_with("", "abc")));
} }
#[test] #[test]
fn test_ends_with() { fn test_ends_with() {
assert!((ends_with(~"", ~""))); assert!((ends_with("", "")));
assert!((ends_with(~"abc", ~""))); assert!((ends_with("abc", "")));
assert!((ends_with(~"abc", ~"c"))); assert!((ends_with("abc", "c")));
assert!((!ends_with(~"a", ~"abc"))); assert!((!ends_with("a", "abc")));
assert!((!ends_with(~"", ~"abc"))); assert!((!ends_with("", "abc")));
} }
#[test] #[test]
fn test_is_empty() { fn test_is_empty() {
assert!((is_empty(~""))); assert!((is_empty("")));
assert!((!is_empty(~"a"))); assert!((!is_empty("a")));
} }
#[test] #[test]
fn test_replace() { fn test_replace() {
let a = ~"a"; let a = "a";
assert_eq!(replace(~"", a, ~"b"), ~""); assert_eq!(replace("", a, "b"), ~"");
assert_eq!(replace(~"a", a, ~"b"), ~"b"); assert_eq!(replace("a", a, "b"), ~"b");
assert_eq!(replace(~"ab", a, ~"b"), ~"bb"); assert_eq!(replace("ab", a, "b"), ~"bb");
let test = ~"test"; let test = "test";
assert!(replace(~" test test ", test, ~"toast") == assert!(replace(" test test ", test, "toast") ==
~" toast toast "); ~" toast toast ");
assert_eq!(replace(~" test test ", test, ~""), ~" "); assert_eq!(replace(" test test ", test, ""), ~" ");
} }
#[test] #[test]
@ -3338,32 +3337,26 @@ mod tests {
#[test] #[test]
fn test_trim_left_chars() { fn test_trim_left_chars() {
assert!(trim_left_chars(" *** foo *** ", ~[]) == assert!(trim_left_chars(" *** foo *** ", []) == " *** foo *** ");
" *** foo *** "); assert!(trim_left_chars(" *** foo *** ", ['*', ' ']) == "foo *** ");
assert!(trim_left_chars(" *** foo *** ", ~['*', ' ']) == assert_eq!(trim_left_chars(" *** *** ", ['*', ' ']), "");
"foo *** "); assert!(trim_left_chars("foo *** ", ['*', ' ']) == "foo *** ");
assert_eq!(trim_left_chars(" *** *** ", ~['*', ' ']), "");
assert!(trim_left_chars("foo *** ", ~['*', ' ']) ==
"foo *** ");
} }
#[test] #[test]
fn test_trim_right_chars() { fn test_trim_right_chars() {
assert!(trim_right_chars(" *** foo *** ", ~[]) == assert!(trim_right_chars(" *** foo *** ", []) == " *** foo *** ");
" *** foo *** "); assert!(trim_right_chars(" *** foo *** ", ['*', ' ']) == " *** foo");
assert!(trim_right_chars(" *** foo *** ", ~['*', ' ']) == assert_eq!(trim_right_chars(" *** *** ", ['*', ' ']), "");
" *** foo"); assert!(trim_right_chars(" *** foo", ['*', ' ']) == " *** foo");
assert_eq!(trim_right_chars(" *** *** ", ~['*', ' ']), "");
assert!(trim_right_chars(" *** foo", ~['*', ' ']) ==
" *** foo");
} }
#[test] #[test]
fn test_trim_chars() { fn test_trim_chars() {
assert_eq!(trim_chars(" *** foo *** ", ~[]), " *** foo *** "); 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(" *** *** ", ['*', ' ']), "");
assert_eq!(trim_chars("foo", ~['*', ' ']), "foo"); assert_eq!(trim_chars("foo", ['*', ' ']), "foo");
} }
#[test] #[test]
@ -3398,11 +3391,11 @@ mod tests {
#[test] #[test]
fn test_is_whitespace() { fn test_is_whitespace() {
assert!((is_whitespace(~""))); assert!(is_whitespace(""));
assert!((is_whitespace(~" "))); assert!(is_whitespace(" "));
assert!((is_whitespace(~"\u2009"))); // Thin space assert!(is_whitespace("\u2009")); // Thin space
assert!((is_whitespace(~" \n\t "))); assert!(is_whitespace(" \n\t "));
assert!((!is_whitespace(~" _ "))); assert!(!is_whitespace(" _ "));
} }
#[test] #[test]
@ -3543,7 +3536,7 @@ mod tests {
#[test] #[test]
fn test_as_buf() { fn test_as_buf() {
let a = ~"Abcdefg"; let a = "Abcdefg";
let b = as_buf(a, |buf, _l| { let b = as_buf(a, |buf, _l| {
assert_eq!(unsafe { *buf }, 65u8); assert_eq!(unsafe { *buf }, 65u8);
100 100
@ -3553,7 +3546,7 @@ mod tests {
#[test] #[test]
fn test_as_buf_small() { fn test_as_buf_small() {
let a = ~"A"; let a = "A";
let b = as_buf(a, |buf, _l| { let b = as_buf(a, |buf, _l| {
assert_eq!(unsafe { *buf }, 65u8); assert_eq!(unsafe { *buf }, 65u8);
100 100
@ -3631,32 +3624,32 @@ mod tests {
#[test] #[test]
fn test_contains() { fn test_contains() {
assert!(contains(~"abcde", ~"bcd")); assert!(contains("abcde", "bcd"));
assert!(contains(~"abcde", ~"abcd")); assert!(contains("abcde", "abcd"));
assert!(contains(~"abcde", ~"bcde")); assert!(contains("abcde", "bcde"));
assert!(contains(~"abcde", ~"")); assert!(contains("abcde", ""));
assert!(contains(~"", ~"")); assert!(contains("", ""));
assert!(!contains(~"abcde", ~"def")); assert!(!contains("abcde", "def"));
assert!(!contains(~"", ~"a")); assert!(!contains("", "a"));
let data = ~"ประเทศไทย中华Việt Nam"; 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] #[test]
fn test_contains_char() { fn test_contains_char() {
assert!(contains_char(~"abc", 'b')); assert!(contains_char("abc", 'b'));
assert!(contains_char(~"a", 'a')); assert!(contains_char("a", 'a'));
assert!(!contains_char(~"abc", 'd')); assert!(!contains_char("abc", 'd'));
assert!(!contains_char(~"", 'a')); assert!(!contains_char("", 'a'));
} }
#[test] #[test]
fn test_split_char_each() { 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; let mut ii = 0;
@ -3674,7 +3667,7 @@ mod tests {
#[test] #[test]
fn test_splitn_char_each() { 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; let mut ii = 0;
@ -3691,7 +3684,7 @@ mod tests {
#[test] #[test]
fn test_words_each() { 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; let mut ii = 0;
@ -3706,12 +3699,12 @@ mod tests {
ii += 1; ii += 1;
} }
each_word(~"", |_x| fail!()); // should not fail each_word("", |_x| fail!()); // should not fail
} }
#[test] #[test]
fn test_lines_each () { 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; let mut ii = 0;
@ -3728,26 +3721,26 @@ mod tests {
#[test] #[test]
fn test_map() { fn test_map() {
assert_eq!(~"", map(~"", |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)); assert_eq!(~"YMCA", map("ymca", |c| unsafe {libc::toupper(c as c_char)} as char));
} }
#[test] #[test]
fn test_all() { fn test_all() {
assert_eq!(true, all(~"", char::is_uppercase)); assert_eq!(true, all("", char::is_uppercase));
assert_eq!(false, all(~"ymca", char::is_uppercase)); assert_eq!(false, all("ymca", char::is_uppercase));
assert_eq!(true, 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("yMCA", char::is_uppercase));
assert_eq!(false, all(~"YMCy", char::is_uppercase)); assert_eq!(false, all("YMCy", char::is_uppercase));
} }
#[test] #[test]
fn test_any() { fn test_any() {
assert_eq!(false, any(~"", char::is_uppercase)); assert_eq!(false, any("", char::is_uppercase));
assert_eq!(false, any(~"ymca", 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(~"yMCA", char::is_uppercase)); assert_eq!(true, any("yMCA", char::is_uppercase));
assert_eq!(true, any(~"Ymcy", char::is_uppercase)); assert_eq!(true, any("Ymcy", char::is_uppercase));
} }
#[test] #[test]
@ -3761,41 +3754,41 @@ mod tests {
#[test] #[test]
fn test_utf16() { fn test_utf16() {
let pairs = let pairs =
~[(~"𐍅𐌿𐌻𐍆𐌹𐌻𐌰\n", [(~"𐍅𐌿𐌻𐍆𐌹𐌻𐌰\n",
~[0xd800_u16, 0xdf45_u16, 0xd800_u16, 0xdf3f_u16, ~[0xd800_u16, 0xdf45_u16, 0xd800_u16, 0xdf3f_u16,
0xd800_u16, 0xdf3b_u16, 0xd800_u16, 0xdf46_u16, 0xd800_u16, 0xdf3b_u16, 0xd800_u16, 0xdf46_u16,
0xd800_u16, 0xdf39_u16, 0xd800_u16, 0xdf3b_u16, 0xd800_u16, 0xdf39_u16, 0xd800_u16, 0xdf3b_u16,
0xd800_u16, 0xdf30_u16, 0x000a_u16]), 0xd800_u16, 0xdf30_u16, 0x000a_u16]),
(~"𐐒𐑉𐐮𐑀𐐲𐑋 𐐏𐐲𐑍\n", (~"𐐒𐑉𐐮𐑀𐐲𐑋 𐐏𐐲𐑍\n",
~[0xd801_u16, 0xdc12_u16, 0xd801_u16, ~[0xd801_u16, 0xdc12_u16, 0xd801_u16,
0xdc49_u16, 0xd801_u16, 0xdc2e_u16, 0xd801_u16, 0xdc49_u16, 0xd801_u16, 0xdc2e_u16, 0xd801_u16,
0xdc40_u16, 0xd801_u16, 0xdc32_u16, 0xd801_u16, 0xdc40_u16, 0xd801_u16, 0xdc32_u16, 0xd801_u16,
0xdc4b_u16, 0x0020_u16, 0xd801_u16, 0xdc0f_u16, 0xdc4b_u16, 0x0020_u16, 0xd801_u16, 0xdc0f_u16,
0xd801_u16, 0xdc32_u16, 0xd801_u16, 0xdc4d_u16, 0xd801_u16, 0xdc32_u16, 0xd801_u16, 0xdc4d_u16,
0x000a_u16]), 0x000a_u16]),
(~"𐌀𐌖𐌋𐌄𐌑𐌉·𐌌𐌄𐌕𐌄𐌋𐌉𐌑\n", (~"𐌀𐌖𐌋𐌄𐌑𐌉·𐌌𐌄𐌕𐌄𐌋𐌉𐌑\n",
~[0xd800_u16, 0xdf00_u16, 0xd800_u16, 0xdf16_u16, ~[0xd800_u16, 0xdf00_u16, 0xd800_u16, 0xdf16_u16,
0xd800_u16, 0xdf0b_u16, 0xd800_u16, 0xdf04_u16, 0xd800_u16, 0xdf0b_u16, 0xd800_u16, 0xdf04_u16,
0xd800_u16, 0xdf11_u16, 0xd800_u16, 0xdf09_u16, 0xd800_u16, 0xdf11_u16, 0xd800_u16, 0xdf09_u16,
0x00b7_u16, 0xd800_u16, 0xdf0c_u16, 0xd800_u16, 0x00b7_u16, 0xd800_u16, 0xdf0c_u16, 0xd800_u16,
0xdf04_u16, 0xd800_u16, 0xdf15_u16, 0xd800_u16, 0xdf04_u16, 0xd800_u16, 0xdf15_u16, 0xd800_u16,
0xdf04_u16, 0xd800_u16, 0xdf0b_u16, 0xd800_u16, 0xdf04_u16, 0xd800_u16, 0xdf0b_u16, 0xd800_u16,
0xdf09_u16, 0xd800_u16, 0xdf11_u16, 0x000a_u16 ]), 0xdf09_u16, 0xd800_u16, 0xdf11_u16, 0x000a_u16 ]),
(~"𐒋𐒘𐒈𐒑𐒛𐒒 𐒕𐒓 𐒈𐒚𐒍 𐒏𐒜𐒒𐒖𐒆 𐒕𐒆\n", (~"𐒋𐒘𐒈𐒑𐒛𐒒 𐒕𐒓 𐒈𐒚𐒍 𐒏𐒜𐒒𐒖𐒆 𐒕𐒆\n",
~[0xd801_u16, 0xdc8b_u16, 0xd801_u16, 0xdc98_u16, ~[0xd801_u16, 0xdc8b_u16, 0xd801_u16, 0xdc98_u16,
0xd801_u16, 0xdc88_u16, 0xd801_u16, 0xdc91_u16, 0xd801_u16, 0xdc88_u16, 0xd801_u16, 0xdc91_u16,
0xd801_u16, 0xdc9b_u16, 0xd801_u16, 0xdc92_u16, 0xd801_u16, 0xdc9b_u16, 0xd801_u16, 0xdc92_u16,
0x0020_u16, 0xd801_u16, 0xdc95_u16, 0xd801_u16, 0x0020_u16, 0xd801_u16, 0xdc95_u16, 0xd801_u16,
0xdc93_u16, 0x0020_u16, 0xd801_u16, 0xdc88_u16, 0xdc93_u16, 0x0020_u16, 0xd801_u16, 0xdc88_u16,
0xd801_u16, 0xdc9a_u16, 0xd801_u16, 0xdc8d_u16, 0xd801_u16, 0xdc9a_u16, 0xd801_u16, 0xdc8d_u16,
0x0020_u16, 0xd801_u16, 0xdc8f_u16, 0xd801_u16, 0x0020_u16, 0xd801_u16, 0xdc8f_u16, 0xd801_u16,
0xdc9c_u16, 0xd801_u16, 0xdc92_u16, 0xd801_u16, 0xdc9c_u16, 0xd801_u16, 0xdc92_u16, 0xd801_u16,
0xdc96_u16, 0xd801_u16, 0xdc86_u16, 0x0020_u16, 0xdc96_u16, 0xd801_u16, 0xdc86_u16, 0x0020_u16,
0xd801_u16, 0xdc95_u16, 0xd801_u16, 0xdc86_u16, 0xd801_u16, 0xdc95_u16, 0xd801_u16, 0xdc86_u16,
0x000a_u16 ]) ]; 0x000a_u16 ]) ];
for pairs.each |p| { for pairs.each |p| {
let (s, u) = copy *p; let (s, u) = copy *p;
@ -3972,35 +3965,35 @@ mod tests {
#[test] #[test]
fn test_escape_unicode() { fn test_escape_unicode() {
assert_eq!(escape_unicode(~"abc"), ~"\\x61\\x62\\x63"); assert_eq!(escape_unicode("abc"), ~"\\x61\\x62\\x63");
assert_eq!(escape_unicode(~"a c"), ~"\\x61\\x20\\x63"); assert_eq!(escape_unicode("a c"), ~"\\x61\\x20\\x63");
assert_eq!(escape_unicode(~"\r\n\t"), ~"\\x0d\\x0a\\x09"); assert_eq!(escape_unicode("\r\n\t"), ~"\\x0d\\x0a\\x09");
assert_eq!(escape_unicode(~"'\"\\"), ~"\\x27\\x22\\x5c"); assert_eq!(escape_unicode("'\"\\"), ~"\\x27\\x22\\x5c");
assert!(escape_unicode(~"\x00\x01\xfe\xff") == assert!(escape_unicode("\x00\x01\xfe\xff") ==
~"\\x00\\x01\\xfe\\xff"); ~"\\x00\\x01\\xfe\\xff");
assert_eq!(escape_unicode(~"\u0100\uffff"), ~"\\u0100\\uffff"); assert_eq!(escape_unicode("\u0100\uffff"), ~"\\u0100\\uffff");
assert!(escape_unicode(~"\U00010000\U0010ffff") == assert!(escape_unicode("\U00010000\U0010ffff") ==
~"\\U00010000\\U0010ffff"); ~"\\U00010000\\U0010ffff");
assert_eq!(escape_unicode(~"ab\ufb00"), ~"\\x61\\x62\\ufb00"); assert_eq!(escape_unicode("ab\ufb00"), ~"\\x61\\x62\\ufb00");
assert_eq!(escape_unicode(~"\U0001d4ea\r"), ~"\\U0001d4ea\\x0d"); assert_eq!(escape_unicode("\U0001d4ea\r"), ~"\\U0001d4ea\\x0d");
} }
#[test] #[test]
fn test_escape_default() { fn test_escape_default() {
assert_eq!(escape_default(~"abc"), ~"abc"); assert_eq!(escape_default("abc"), ~"abc");
assert_eq!(escape_default(~"a c"), ~"a c"); assert_eq!(escape_default("a c"), ~"a c");
assert_eq!(escape_default(~"\r\n\t"), ~"\\r\\n\\t"); assert_eq!(escape_default("\r\n\t"), ~"\\r\\n\\t");
assert_eq!(escape_default(~"'\"\\"), ~"\\'\\\"\\\\"); assert_eq!(escape_default("'\"\\"), ~"\\'\\\"\\\\");
assert_eq!(escape_default(~"\u0100\uffff"), ~"\\u0100\\uffff"); assert_eq!(escape_default("\u0100\uffff"), ~"\\u0100\\uffff");
assert!(escape_default(~"\U00010000\U0010ffff") == assert!(escape_default("\U00010000\U0010ffff") ==
~"\\U00010000\\U0010ffff"); ~"\\U00010000\\U0010ffff");
assert_eq!(escape_default(~"ab\ufb00"), ~"ab\\ufb00"); assert_eq!(escape_default("ab\ufb00"), ~"ab\\ufb00");
assert_eq!(escape_default(~"\U0001d4ea\r"), ~"\\U0001d4ea\\r"); assert_eq!(escape_default("\U0001d4ea\r"), ~"\\U0001d4ea\\r");
} }
#[test] #[test]
fn test_to_managed() { 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"); assert_eq!(slice("abcdef", 1, 5).to_managed(), @"bcde");
} }

4
src/libstd/str/ascii.rs
View file

@ -228,8 +228,8 @@ mod tests {
assert_eq!('`'.to_ascii().to_upper().to_char(), '`'); assert_eq!('`'.to_ascii().to_upper().to_char(), '`');
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("banana", |c| c.is_ascii()));
assert!(! str::all(~"ประเทศไทย中华Việt Nam", |c| c.is_ascii())); assert!(! str::all("ประเทศไทย中华Việt Nam", |c| c.is_ascii()));
} }
#[test] #[test]

36
src/libstd/to_bytes.rs
View file

@ -236,42 +236,6 @@ impl<A:IterBytes> IterBytes for @[A] {
} }
} }
// NOTE: remove all of these after a snapshot, the new for-loop iteration
// protocol makes these unnecessary.
#[inline(always)]
pub fn iter_bytes_2<A:IterBytes,B:IterBytes>(a: &A, b: &B,
lsb0: bool, z: Cb) -> bool {
a.iter_bytes(lsb0, z) && b.iter_bytes(lsb0, z)
}
pub fn iter_bytes_3<A: IterBytes,
B: IterBytes,
C: IterBytes>(a: &A, b: &B, c: &C, lsb0: bool, z: Cb) -> bool {
a.iter_bytes(lsb0, z) && b.iter_bytes(lsb0, z) && c.iter_bytes(lsb0, z)
}
pub fn iter_bytes_4<A: IterBytes,
B: IterBytes,
C: IterBytes,
D: IterBytes>(a: &A, b: &B, c: &C,
d: &D,
lsb0: bool, z: Cb) -> bool {
a.iter_bytes(lsb0, z) && b.iter_bytes(lsb0, z) && c.iter_bytes(lsb0, z) &&
d.iter_bytes(lsb0, z)
}
pub fn iter_bytes_5<A: IterBytes,
B: IterBytes,
C: IterBytes,
D: IterBytes,
E: IterBytes>(a: &A, b: &B, c: &C,
d: &D, e: &E,
lsb0: bool, z: Cb) -> bool {
a.iter_bytes(lsb0, z) && b.iter_bytes(lsb0, z) && c.iter_bytes(lsb0, z) &&
d.iter_bytes(lsb0, z) && e.iter_bytes(lsb0, z)
}
impl<'self> IterBytes for &'self str { impl<'self> IterBytes for &'self str {
#[inline(always)] #[inline(always)]
fn iter_bytes(&self, _lsb0: bool, f: Cb) -> bool { fn iter_bytes(&self, _lsb0: bool, f: Cb) -> bool {

147
src/libstd/vec.rs
View file

@ -2962,8 +2962,8 @@ mod tests {
#[test] #[test]
fn test_is_empty() { fn test_is_empty() {
assert!(is_empty::<int>(~[])); assert!(is_empty::<int>([]));
assert!(!is_empty(~[0])); assert!(!is_empty([0]));
} }
#[test] #[test]
@ -3445,7 +3445,7 @@ mod tests {
#[test] #[test]
fn test_each_empty() { fn test_each_empty() {
for each::<int>(~[]) |_v| { for each::<int>([]) |_v| {
fail!(); // should never be executed fail!(); // should never be executed
} }
} }
@ -3453,7 +3453,7 @@ mod tests {
#[test] #[test]
fn test_each_nonempty() { fn test_each_nonempty() {
let mut i = 0; let mut i = 0;
for each(~[1, 2, 3]) |v| { for each([1, 2, 3]) |v| {
i += *v; i += *v;
} }
assert_eq!(i, 6); assert_eq!(i, 6);
@ -3462,7 +3462,7 @@ mod tests {
#[test] #[test]
fn test_eachi() { fn test_eachi() {
let mut i = 0; let mut i = 0;
for eachi(~[1, 2, 3]) |j, v| { for eachi([1, 2, 3]) |j, v| {
if i == 0 { assert!(*v == 1); } if i == 0 { assert!(*v == 1); }
assert_eq!(j + 1u, *v as uint); assert_eq!(j + 1u, *v as uint);
i += *v; i += *v;
@ -3481,7 +3481,7 @@ mod tests {
#[test] #[test]
fn test_each_reverse_nonempty() { fn test_each_reverse_nonempty() {
let mut i = 0; let mut i = 0;
for each_reverse(~[1, 2, 3]) |v| { for each_reverse([1, 2, 3]) |v| {
if i == 0 { assert!(*v == 3); } if i == 0 { assert!(*v == 3); }
i += *v i += *v
} }
@ -3491,7 +3491,7 @@ mod tests {
#[test] #[test]
fn test_eachi_reverse() { fn test_eachi_reverse() {
let mut i = 0; 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); } if i == 0 { assert!(*v == 2); }
assert_eq!(j, *v as uint); assert_eq!(j, *v as uint);
i += *v; i += *v;
@ -3512,48 +3512,48 @@ mod tests {
let mut results: ~[~[int]]; let mut results: ~[~[int]];
results = ~[]; results = ~[];
for each_permutation(~[]) |v| { results.push(to_owned(v)); } for each_permutation([]) |v| { results.push(to_owned(v)); }
assert_eq!(results, ~[~[]]); assert_eq!(results, ~[~[]]);
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]]); assert_eq!(results, ~[~[7]]);
results = ~[]; 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]]); assert_eq!(results, ~[~[1,1],~[1,1]]);
results = ~[]; 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 == assert!(results ==
~[~[5,2,0],~[5,0,2],~[2,5,0],~[2,0,5],~[0,5,2],~[0,2,5]]); ~[~[5,2,0],~[5,0,2],~[2,5,0],~[2,0,5],~[0,5,2],~[0,2,5]]);
} }
#[test] #[test]
fn test_any_and_all() { fn test_any_and_all() {
assert!(any(~[1u, 2u, 3u], is_three)); assert!(any([1u, 2u, 3u], is_three));
assert!(!any(~[0u, 1u, 2u], is_three)); assert!(!any([0u, 1u, 2u], is_three));
assert!(any(~[1u, 2u, 3u, 4u, 5u], is_three)); assert!(any([1u, 2u, 3u, 4u, 5u], is_three));
assert!(!any(~[1u, 2u, 4u, 5u, 6u], is_three)); assert!(!any([1u, 2u, 4u, 5u, 6u], is_three));
assert!(all(~[3u, 3u, 3u], is_three)); assert!(all([3u, 3u, 3u], is_three));
assert!(!all(~[3u, 3u, 2u], is_three)); assert!(!all([3u, 3u, 2u], is_three));
assert!(all(~[3u, 3u, 3u, 3u, 3u], is_three)); assert!(all([3u, 3u, 3u, 3u, 3u], is_three));
assert!(!all(~[3u, 3u, 0u, 1u, 2u], is_three)); assert!(!all([3u, 3u, 0u, 1u, 2u], is_three));
} }
#[test] #[test]
fn test_any2_and_all2() { fn test_any2_and_all2() {
assert!(any2(~[2u, 4u, 6u], ~[2u, 4u, 6u], 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, 3u], is_equal));
assert!(!any2(~[1u, 2u, 3u], ~[4u, 5u, 6u], 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], is_equal));
assert!(all2(~[2u, 4u, 6u], ~[2u, 4u, 6u], 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, 3u], is_equal));
assert!(!all2(~[1u, 2u, 3u], ~[4u, 5u, 6u], 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], is_equal));
} }
#[test] #[test]
@ -3576,7 +3576,7 @@ mod tests {
#[test] #[test]
fn test_position_elem() { fn test_position_elem() {
assert!(position_elem(~[], &1).is_none()); assert!(position_elem([], &1).is_none());
let v1 = ~[1, 2, 3, 3, 2, 5]; let v1 = ~[1, 2, 3, 3, 2, 5];
assert_eq!(position_elem(v1, &1), Some(0u)); assert_eq!(position_elem(v1, &1), Some(0u));
@ -3590,7 +3590,7 @@ mod tests {
fn less_than_three(i: &int) -> bool { *i < 3 } fn less_than_three(i: &int) -> bool { *i < 3 }
fn is_eighteen(i: &int) -> bool { *i == 18 } 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]; let v1 = ~[5, 4, 3, 2, 1];
assert_eq!(position(v1, less_than_three), Some(3u)); assert_eq!(position(v1, less_than_three), Some(3u));
@ -3599,7 +3599,7 @@ mod tests {
#[test] #[test]
fn test_position_between() { 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' } fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' }
let v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')]; let v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
@ -3627,7 +3627,7 @@ mod tests {
#[test] #[test]
fn test_find() { 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 f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' }
fn g(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'd' } fn g(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'd' }
@ -3639,7 +3639,7 @@ mod tests {
#[test] #[test]
fn test_find_between() { 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' } fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' }
let v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')]; let v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
@ -3667,7 +3667,7 @@ mod tests {
#[test] #[test]
fn test_rposition() { 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 f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' }
fn g(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'd' } fn g(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'd' }
@ -3679,7 +3679,7 @@ mod tests {
#[test] #[test]
fn test_rposition_between() { 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' } fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' }
let v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')]; let v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
@ -3707,7 +3707,7 @@ mod tests {
#[test] #[test]
fn test_rfind() { 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 f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' }
fn g(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'd' } fn g(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'd' }
@ -3719,7 +3719,7 @@ mod tests {
#[test] #[test]
fn test_rfind_between() { 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' } fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' }
let v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')]; let v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
@ -3798,14 +3798,14 @@ mod tests {
reverse(v); reverse(v);
assert_eq!(v[0], 20); assert_eq!(v[0], 20);
assert_eq!(v[1], 10); 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[0], 20);
assert_eq!(v2[1], 10); assert_eq!(v2[1], 10);
v[0] = 30; v[0] = 30;
assert_eq!(v2[0], 20); assert_eq!(v2[0], 20);
// Make sure they work with 0-length vectors too. // Make sure they work with 0-length vectors too.
let v4 = reversed::<int>(~[]); let v4 = reversed::<int>([]);
assert_eq!(v4, ~[]); assert_eq!(v4, ~[]);
let mut v3: ~[int] = ~[]; let mut v3: ~[int] = ~[];
reverse::<int>(v3); reverse::<int>(v3);
@ -3813,7 +3813,7 @@ mod tests {
#[test] #[test]
fn reversed_mut() { fn reversed_mut() {
let v2 = reversed::<int>(~[10, 20]); let v2 = reversed::<int>([10, 20]);
assert_eq!(v2[0], 20); assert_eq!(v2[0], 20);
assert_eq!(v2[1], 10); assert_eq!(v2[1], 10);
} }
@ -3822,22 +3822,22 @@ mod tests {
fn test_split() { fn test_split() {
fn f(x: &int) -> bool { *x == 3 } fn f(x: &int) -> bool { *x == 3 }
assert_eq!(split(~[], f), ~[]); assert_eq!(split([], f), ~[]);
assert_eq!(split(~[1, 2], f), ~[~[1, 2]]); assert_eq!(split([1, 2], f), ~[~[1, 2]]);
assert_eq!(split(~[3, 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], f), ~[~[1, 2], ~[]]);
assert_eq!(split(~[1, 2, 3, 4, 3, 5], f), ~[~[1, 2], ~[4], ~[5]]); assert_eq!(split([1, 2, 3, 4, 3, 5], f), ~[~[1, 2], ~[4], ~[5]]);
} }
#[test] #[test]
fn test_splitn() { fn test_splitn() {
fn f(x: &int) -> bool { *x == 3 } fn f(x: &int) -> bool { *x == 3 }
assert_eq!(splitn(~[], 1u, f), ~[]); assert_eq!(splitn([], 1u, f), ~[]);
assert_eq!(splitn(~[1, 2], 1u, f), ~[~[1, 2]]); assert_eq!(splitn([1, 2], 1u, f), ~[~[1, 2]]);
assert_eq!(splitn(~[3, 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_eq!(splitn([1, 2, 3], 1u, f), ~[~[1, 2], ~[]]);
assert!(splitn(~[1, 2, 3, 4, 3, 5], 1u, f) == assert!(splitn([1, 2, 3, 4, 3, 5], 1u, f) ==
~[~[1, 2], ~[4, 3, 5]]); ~[~[1, 2], ~[4, 3, 5]]);
} }
@ -3845,10 +3845,10 @@ mod tests {
fn test_rsplit() { fn test_rsplit() {
fn f(x: &int) -> bool { *x == 3 } fn f(x: &int) -> bool { *x == 3 }
assert_eq!(rsplit(~[], f), ~[]); assert_eq!(rsplit([], f), ~[]);
assert_eq!(rsplit(~[1, 2], f), ~[~[1, 2]]); assert_eq!(rsplit([1, 2], f), ~[~[1, 2]]);
assert_eq!(rsplit(~[1, 2, 3], f), ~[~[1, 2], ~[]]); assert_eq!(rsplit([1, 2, 3], f), ~[~[1, 2], ~[]]);
assert!(rsplit(~[1, 2, 3, 4, 3, 5], f) == assert!(rsplit([1, 2, 3, 4, 3, 5], f) ==
~[~[1, 2], ~[4], ~[5]]); ~[~[1, 2], ~[4], ~[5]]);
} }
@ -3856,53 +3856,46 @@ mod tests {
fn test_rsplitn() { fn test_rsplitn() {
fn f(x: &int) -> bool { *x == 3 } fn f(x: &int) -> bool { *x == 3 }
assert_eq!(rsplitn(~[], 1u, f), ~[]); assert_eq!(rsplitn([], 1u, f), ~[]);
assert_eq!(rsplitn(~[1, 2], 1u, f), ~[~[1, 2]]); 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], 1u, f), ~[~[1, 2], ~[]]);
assert!(rsplitn(~[1, 2, 3, 4, 3, 5], 1u, f) == assert_eq!(rsplitn([1, 2, 3, 4, 3, 5], 1u, f), ~[~[1, 2, 3, 4], ~[5]]);
~[~[1, 2, 3, 4], ~[5]]);
} }
#[test] #[test]
fn test_partition() { fn test_partition() {
// FIXME (#4355 maybe): using v.partition here crashes // FIXME (#4355 maybe): using v.partition here crashes
assert_eq!(partition(~[], |x: &int| *x < 3), (~[], ~[])); assert_eq!(partition(~[], |x: &int| *x < 3), (~[], ~[]));
assert!(partition(~[1, 2, 3], |x: &int| *x < 4) == assert_eq!(partition(~[1, 2, 3], |x: &int| *x < 4), (~[1, 2, 3], ~[]));
(~[1, 2, 3], ~[])); assert_eq!(partition(~[1, 2, 3], |x: &int| *x < 2), (~[1], ~[2, 3]));
assert!(partition(~[1, 2, 3], |x: &int| *x < 2) == assert_eq!(partition(~[1, 2, 3], |x: &int| *x < 0), (~[], ~[1, 2, 3]));
(~[1], ~[2, 3]));
assert!(partition(~[1, 2, 3], |x: &int| *x < 0) ==
(~[], ~[1, 2, 3]));
} }
#[test] #[test]
fn test_partitioned() { fn test_partitioned() {
assert_eq!((~[]).partitioned(|x: &int| *x < 3), (~[], ~[])) assert_eq!(([]).partitioned(|x: &int| *x < 3), (~[], ~[]))
assert!((~[1, 2, 3]).partitioned(|x: &int| *x < 4) == assert_eq!(([1, 2, 3]).partitioned(|x: &int| *x < 4), (~[1, 2, 3], ~[]));
(~[1, 2, 3], ~[])); assert_eq!(([1, 2, 3]).partitioned(|x: &int| *x < 2), (~[1], ~[2, 3]));
assert!((~[1, 2, 3]).partitioned(|x: &int| *x < 2) == assert_eq!(([1, 2, 3]).partitioned(|x: &int| *x < 0), (~[], ~[1, 2, 3]));
(~[1], ~[2, 3]));
assert!((~[1, 2, 3]).partitioned(|x: &int| *x < 0) ==
(~[], ~[1, 2, 3]));
} }
#[test] #[test]
fn test_concat() { fn test_concat() {
assert_eq!(concat(~[~[1], ~[2,3]]), ~[1, 2, 3]); assert_eq!(concat([~[1], ~[2,3]]), ~[1, 2, 3]);
} }
#[test] #[test]
fn test_connect() { fn test_connect() {
assert_eq!(connect(~[], &0), ~[]); 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, 3]);
assert_eq!(connect(~[~[1], ~[2], ~[3]], &0), ~[1, 0, 2, 0, 3]); assert_eq!(connect([~[1], ~[2], ~[3]], &0), ~[1, 0, 2, 0, 3]);
} }
#[test] #[test]
fn test_windowed () { fn test_windowed () {
fn t(n: uint, expected: &[&[int]]) { fn t(n: uint, expected: &[&[int]]) {
let mut i = 0; 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]); assert_eq!(v, expected[i]);
i += 1; i += 1;
} }
@ -3920,7 +3913,7 @@ mod tests {
#[should_fail] #[should_fail]
#[ignore(cfg(windows))] #[ignore(cfg(windows))]
fn test_windowed_() { fn test_windowed_() {
for windowed (0u, ~[1u,2u,3u,4u,5u,6u]) |_v| {} for windowed (0u, [1u,2u,3u,4u,5u,6u]) |_v| {}
} }
#[test] #[test]

25
src/libsyntax/ast.rs
View file

@ -17,9 +17,8 @@ use abi::AbiSet;
use opt_vec::OptVec; use opt_vec::OptVec;
use parse::token::get_ident_interner; use parse::token::get_ident_interner;
use core::cast;
use core::hashmap::HashMap; use core::hashmap::HashMap;
use core::option::{Option}; use core::option::Option;
use core::to_bytes::IterBytes; use core::to_bytes::IterBytes;
use core::to_bytes; use core::to_bytes;
use core::to_str::ToStr; use core::to_str::ToStr;
@ -112,7 +111,9 @@ pub struct Lifetime {
impl to_bytes::IterBytes for Lifetime { impl to_bytes::IterBytes for Lifetime {
fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
to_bytes::iter_bytes_3(&self.id, &self.span, &self.ident, lsb0, f) self.id.iter_bytes(lsb0, f) &&
self.span.iter_bytes(lsb0, f) &&
self.ident.iter_bytes(lsb0, f)
} }
} }
@ -266,7 +267,9 @@ impl to_bytes::IterBytes for binding_mode {
match *self { match *self {
bind_by_copy => 0u8.iter_bytes(lsb0, f), bind_by_copy => 0u8.iter_bytes(lsb0, f),
bind_by_ref(ref m) => to_bytes::iter_bytes_2(&1u8, m, lsb0, f), bind_by_ref(ref m) => {
1u8.iter_bytes(lsb0, f) && m.iter_bytes(lsb0, f)
}
bind_infer => 2u8.iter_bytes(lsb0, f), bind_infer => 2u8.iter_bytes(lsb0, f),
} }
@ -788,7 +791,7 @@ pub enum ty_ {
impl to_bytes::IterBytes for Ty { impl to_bytes::IterBytes for Ty {
fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
to_bytes::iter_bytes_2(&self.span.lo, &self.span.hi, lsb0, f) self.span.lo.iter_bytes(lsb0, f) && self.span.hi.iter_bytes(lsb0, f)
} }
} }
@ -876,9 +879,15 @@ impl to_bytes::IterBytes for explicit_self_ {
match *self { match *self {
sty_static => 0u8.iter_bytes(lsb0, f), sty_static => 0u8.iter_bytes(lsb0, f),
sty_value => 1u8.iter_bytes(lsb0, f), sty_value => 1u8.iter_bytes(lsb0, f),
sty_region(ref lft, ref mutbl) => to_bytes::iter_bytes_3(&2u8, &lft, mutbl, lsb0, f), sty_region(ref lft, ref mutbl) => {
sty_box(ref mutbl) => to_bytes::iter_bytes_2(&3u8, mutbl, lsb0, f), 2u8.iter_bytes(lsb0, f) && lft.iter_bytes(lsb0, f) && mutbl.iter_bytes(lsb0, f)
sty_uniq(ref mutbl) => to_bytes::iter_bytes_2(&4u8, mutbl, lsb0, f), }
sty_box(ref mutbl) => {
3u8.iter_bytes(lsb0, f) && mutbl.iter_bytes(lsb0, f)
}
sty_uniq(ref mutbl) => {
4u8.iter_bytes(lsb0, f) && mutbl.iter_bytes(lsb0, f)
}
} }
} }
} }

2
src/libsyntax/ast_util.rs
View file

@ -197,7 +197,7 @@ pub fn is_call_expr(e: @expr) -> bool {
impl to_bytes::IterBytes for def_id { impl to_bytes::IterBytes for def_id {
#[inline(always)] #[inline(always)]
fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
to_bytes::iter_bytes_2(&self.crate, &self.node, lsb0, f) self.crate.iter_bytes(lsb0, f) && self.node.iter_bytes(lsb0, f)
} }
} }

12
src/libsyntax/codemap.rs
View file

@ -140,7 +140,9 @@ impl<D:Decoder> Decodable<D> for span {
impl to_bytes::IterBytes for span { impl to_bytes::IterBytes for span {
fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
to_bytes::iter_bytes_3(&self.lo, &self.hi, &self.expn_info, lsb0, f) self.lo.iter_bytes(lsb0, f) &&
self.hi.iter_bytes(lsb0, f) &&
self.expn_info.iter_bytes(lsb0, f)
} }
} }
@ -193,7 +195,7 @@ pub struct NameAndSpan {name: ~str, span: Option<span>}
impl to_bytes::IterBytes for NameAndSpan { impl to_bytes::IterBytes for NameAndSpan {
fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
to_bytes::iter_bytes_2(&self.name, &self.span, lsb0, f) self.name.iter_bytes(lsb0, f) && self.span.iter_bytes(lsb0, f)
} }
} }
@ -204,7 +206,7 @@ pub struct CallInfo {
impl to_bytes::IterBytes for CallInfo { impl to_bytes::IterBytes for CallInfo {
fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
to_bytes::iter_bytes_2(&self.call_site, &self.callee, lsb0, f) self.call_site.iter_bytes(lsb0, f) && self.callee.iter_bytes(lsb0, f)
} }
} }
@ -216,7 +218,9 @@ pub enum ExpnInfo {
impl to_bytes::IterBytes for ExpnInfo { impl to_bytes::IterBytes for ExpnInfo {
fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
match *self { match *self {
ExpandedFrom(ref call_info) => to_bytes::iter_bytes_2(&0u8, call_info, lsb0, f) ExpandedFrom(ref call_info) => {
0u8.iter_bytes(lsb0, f) && call_info.iter_bytes(lsb0, f)
}
} }
} }
} }

2
src/libsyntax/ext/pipes/ast_builder.rs
View file

@ -15,11 +15,9 @@
use core::prelude::*; use core::prelude::*;
use abi::AbiSet;
use ast::ident; use ast::ident;
use ast; use ast;
use codemap::span; use codemap::span;
// use ext::quote::rt::*;
// Transitional reexports so qquote can find the paths it is looking for // Transitional reexports so qquote can find the paths it is looking for
mod syntax { mod syntax {

6
src/libsyntax/parse/parser.rs
View file

@ -2752,7 +2752,7 @@ pub impl Parser {
match *self.token { match *self.token {
token::SEMI => { token::SEMI => {
if !vec::is_empty(attributes_box) { if !vec::is_empty(attributes_box) {
self.span_err(*self.last_span,~"expected item after attributes"); self.span_err(*self.last_span, "expected item after attributes");
attributes_box = ~[]; attributes_box = ~[];
} }
self.bump(); // empty self.bump(); // empty
@ -2823,7 +2823,7 @@ pub impl Parser {
} }
if !vec::is_empty(attributes_box) { if !vec::is_empty(attributes_box) {
self.span_err(*self.last_span,~"expected item after attributes"); self.span_err(*self.last_span, "expected item after attributes");
} }
let hi = self.span.hi; let hi = self.span.hi;
@ -3742,7 +3742,7 @@ pub impl Parser {
} = self.parse_foreign_items(first_item_attrs, true); } = self.parse_foreign_items(first_item_attrs, true);
if (! attrs_remaining.is_empty()) { if (! attrs_remaining.is_empty()) {
self.span_err(*self.last_span, self.span_err(*self.last_span,
~"expected item after attributes"); "expected item after attributes");
} }
assert!(*self.token == token::RBRACE); assert!(*self.token == token::RBRACE);
ast::foreign_mod { ast::foreign_mod {