Make vectors uglier ([]/~). Sorry. Should be temporary. Closes #2725.
This commit is contained in:
Michael Sullivan
parent
c087aaf56b
commit
329eca6044
418 changed files with 4123 additions and 4034 deletions
|
|
@ -122,7 +122,7 @@ Convert a vector of bytes to a UTF-8 string
|
|||
|
||||
Fails if invalid UTF-8
|
||||
"]
|
||||
pure fn from_bytes(vv: [u8]) -> str {
|
||||
pure fn from_bytes(vv: [u8]/~) -> str {
|
||||
assert is_utf8(vv);
|
||||
ret unsafe { unsafe::from_bytes(vv) };
|
||||
}
|
||||
|
|
@ -136,7 +136,7 @@ Fails if invalid UTF-8
|
|||
"]
|
||||
pure fn from_byte(b: u8) -> str {
|
||||
assert b < 128u8;
|
||||
let mut v = [b, 0u8];
|
||||
let mut v = [b, 0u8]/~;
|
||||
unsafe { ::unsafe::transmute(v) }
|
||||
}
|
||||
|
||||
|
|
@ -209,7 +209,7 @@ fn push_char(&s: str, ch: char) {
|
|||
}
|
||||
|
||||
as_bytes(s) {|bytes|
|
||||
let mut mut_bytes: [u8] = ::unsafe::reinterpret_cast(bytes);
|
||||
let mut mut_bytes: [u8]/~ = ::unsafe::reinterpret_cast(bytes);
|
||||
vec::unsafe::set_len(mut_bytes, new_len + 1u);
|
||||
::unsafe::forget(mut_bytes);
|
||||
}
|
||||
|
|
@ -322,10 +322,10 @@ Converts a string to a vector of bytes
|
|||
|
||||
The result vector is not null-terminated.
|
||||
"]
|
||||
pure fn bytes(s: str) -> [u8] {
|
||||
pure fn bytes(s: str) -> [u8]/~ {
|
||||
unsafe {
|
||||
let mut s_copy = s;
|
||||
let mut v: [u8] = ::unsafe::transmute(s_copy);
|
||||
let mut v: [u8]/~ = ::unsafe::transmute(s_copy);
|
||||
vec::unsafe::set_len(v, len(s));
|
||||
ret v;
|
||||
}
|
||||
|
|
@ -342,12 +342,12 @@ pure fn byte_slice<T>(s: str/&, f: fn([u8]/&) -> T) -> T {
|
|||
}
|
||||
|
||||
#[doc = "Convert a string to a vector of characters"]
|
||||
pure fn chars(s: str/&) -> [char] {
|
||||
let mut buf = [], i = 0u;
|
||||
pure fn chars(s: str/&) -> [char]/~ {
|
||||
let mut buf = []/~, i = 0u;
|
||||
let len = len(s);
|
||||
while i < len {
|
||||
let {ch, next} = char_range_at(s, i);
|
||||
buf += [ch];
|
||||
buf += [ch]/~;
|
||||
i = next;
|
||||
}
|
||||
ret buf;
|
||||
|
|
@ -378,7 +378,7 @@ pure fn slice(s: str/&, begin: uint, end: uint) -> str {
|
|||
#[doc = "
|
||||
Splits a string into substrings at each occurrence of a given character
|
||||
"]
|
||||
pure fn split_char(s: str/&, sep: char) -> [str] {
|
||||
pure fn split_char(s: str/&, sep: char) -> [str]/~ {
|
||||
split_char_inner(s, sep, len(s), true)
|
||||
}
|
||||
|
||||
|
|
@ -388,27 +388,27 @@ character up to 'count' times
|
|||
|
||||
The byte must be a valid UTF-8/ASCII byte
|
||||
"]
|
||||
pure fn splitn_char(s: str/&, sep: char, count: uint) -> [str] {
|
||||
pure fn splitn_char(s: str/&, sep: char, count: uint) -> [str]/~ {
|
||||
split_char_inner(s, sep, count, true)
|
||||
}
|
||||
|
||||
#[doc = "
|
||||
Like `split_char`, but omits empty strings from the returned vector
|
||||
"]
|
||||
pure fn split_char_nonempty(s: str/&, sep: char) -> [str] {
|
||||
pure fn split_char_nonempty(s: str/&, sep: char) -> [str]/~ {
|
||||
split_char_inner(s, sep, len(s), false)
|
||||
}
|
||||
|
||||
pure fn split_char_inner(s: str/&, sep: char, count: uint, allow_empty: bool)
|
||||
-> [str] {
|
||||
-> [str]/~ {
|
||||
if sep < 128u as char {
|
||||
let b = sep as u8, l = len(s);
|
||||
let mut result = [], done = 0u;
|
||||
let mut result = []/~, done = 0u;
|
||||
let mut i = 0u, start = 0u;
|
||||
while i < l && done < count {
|
||||
if s[i] == b {
|
||||
if allow_empty || start < i {
|
||||
result += [unsafe { unsafe::slice_bytes(s, start, i) }];
|
||||
result += [unsafe { unsafe::slice_bytes(s, start, i) }]/~;
|
||||
}
|
||||
start = i + 1u;
|
||||
done += 1u;
|
||||
|
|
@ -416,7 +416,7 @@ pure fn split_char_inner(s: str/&, sep: char, count: uint, allow_empty: bool)
|
|||
i += 1u;
|
||||
}
|
||||
if allow_empty || start < l {
|
||||
result += [unsafe { unsafe::slice_bytes(s, start, l) }];
|
||||
result += [unsafe { unsafe::slice_bytes(s, start, l) }]/~;
|
||||
}
|
||||
result
|
||||
} else {
|
||||
|
|
@ -426,7 +426,7 @@ pure fn split_char_inner(s: str/&, sep: char, count: uint, allow_empty: bool)
|
|||
|
||||
|
||||
#[doc = "Splits a string into substrings using a character function"]
|
||||
pure fn split(s: str/&, sepfn: fn(char) -> bool) -> [str] {
|
||||
pure fn split(s: str/&, sepfn: fn(char) -> bool) -> [str]/~ {
|
||||
split_inner(s, sepfn, len(s), true)
|
||||
}
|
||||
|
||||
|
|
@ -434,24 +434,24 @@ pure fn split(s: str/&, sepfn: fn(char) -> bool) -> [str] {
|
|||
Splits a string into substrings using a character function, cutting at
|
||||
most `count` times.
|
||||
"]
|
||||
pure fn splitn(s: str/&, sepfn: fn(char) -> bool, count: uint) -> [str] {
|
||||
pure fn splitn(s: str/&, sepfn: fn(char) -> bool, count: uint) -> [str]/~ {
|
||||
split_inner(s, sepfn, count, true)
|
||||
}
|
||||
|
||||
#[doc = "Like `split`, but omits empty strings from the returned vector"]
|
||||
pure fn split_nonempty(s: str/&, sepfn: fn(char) -> bool) -> [str] {
|
||||
pure fn split_nonempty(s: str/&, sepfn: fn(char) -> bool) -> [str]/~ {
|
||||
split_inner(s, sepfn, len(s), false)
|
||||
}
|
||||
|
||||
pure fn split_inner(s: str/&, sepfn: fn(cc: char) -> bool, count: uint,
|
||||
allow_empty: bool) -> [str] {
|
||||
allow_empty: bool) -> [str]/~ {
|
||||
let l = len(s);
|
||||
let mut result = [], i = 0u, start = 0u, done = 0u;
|
||||
let mut result = []/~, i = 0u, start = 0u, done = 0u;
|
||||
while i < l && done < count {
|
||||
let {ch, next} = char_range_at(s, i);
|
||||
if sepfn(ch) {
|
||||
if allow_empty || start < i {
|
||||
result += [unsafe { unsafe::slice_bytes(s, start, i) }];
|
||||
result += [unsafe { unsafe::slice_bytes(s, start, i) }]/~;
|
||||
}
|
||||
start = next;
|
||||
done += 1u;
|
||||
|
|
@ -459,7 +459,7 @@ pure fn split_inner(s: str/&, sepfn: fn(cc: char) -> bool, count: uint,
|
|||
i = next;
|
||||
}
|
||||
if allow_empty || start < l {
|
||||
result += [unsafe { unsafe::slice_bytes(s, start, l) }];
|
||||
result += [unsafe { unsafe::slice_bytes(s, start, l) }]/~;
|
||||
}
|
||||
result
|
||||
}
|
||||
|
|
@ -510,19 +510,19 @@ Splits a string into a vector of the substrings separated by a given string
|
|||
assert [\"\", \"XXX\", \"YYY\", \"\"] == split_str(\".XXX.YYY.\", \".\")
|
||||
~~~
|
||||
"]
|
||||
pure fn split_str(s: str/&a, sep: str/&b) -> [str] {
|
||||
let mut result = [];
|
||||
pure fn split_str(s: str/&a, sep: str/&b) -> [str]/~ {
|
||||
let mut result = []/~;
|
||||
iter_between_matches(s, sep) {|from, to|
|
||||
unsafe { result += [unsafe::slice_bytes(s, from, to)]; }
|
||||
unsafe { result += [unsafe::slice_bytes(s, from, to)]/~; }
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
pure fn split_str_nonempty(s: str/&a, sep: str/&b) -> [str] {
|
||||
let mut result = [];
|
||||
pure fn split_str_nonempty(s: str/&a, sep: str/&b) -> [str]/~ {
|
||||
let mut result = []/~;
|
||||
iter_between_matches(s, sep) {|from, to|
|
||||
if to > from {
|
||||
unsafe { result += [unsafe::slice_bytes(s, from, to)]; }
|
||||
unsafe { result += [unsafe::slice_bytes(s, from, to)]/~; }
|
||||
}
|
||||
}
|
||||
result
|
||||
|
|
@ -531,13 +531,13 @@ pure fn split_str_nonempty(s: str/&a, sep: str/&b) -> [str] {
|
|||
#[doc = "
|
||||
Splits a string into a vector of the substrings separated by LF ('\\n')
|
||||
"]
|
||||
pure fn lines(s: str/&) -> [str] { split_char(s, '\n') }
|
||||
pure fn lines(s: str/&) -> [str]/~ { split_char(s, '\n') }
|
||||
|
||||
#[doc = "
|
||||
Splits a string into a vector of the substrings separated by LF ('\\n')
|
||||
and/or CR LF ('\\r\\n')
|
||||
"]
|
||||
pure fn lines_any(s: str/&) -> [str] {
|
||||
pure fn lines_any(s: str/&) -> [str]/~ {
|
||||
vec::map(lines(s), {|s|
|
||||
let l = len(s);
|
||||
let mut cp = s;
|
||||
|
|
@ -551,7 +551,7 @@ pure fn lines_any(s: str/&) -> [str] {
|
|||
#[doc = "
|
||||
Splits a string into a vector of the substrings separated by whitespace
|
||||
"]
|
||||
pure fn words(s: str/&) -> [str] {
|
||||
pure fn words(s: str/&) -> [str]/~ {
|
||||
split_nonempty(s, {|c| char::is_whitespace(c)})
|
||||
}
|
||||
|
||||
|
|
@ -1264,8 +1264,8 @@ pure fn is_utf16(v: [const u16]/&) -> bool {
|
|||
}
|
||||
|
||||
#[doc = "Converts to a vector of `u16` encoded as UTF-16"]
|
||||
pure fn to_utf16(s: str/&) -> [u16] {
|
||||
let mut u = [];
|
||||
pure fn to_utf16(s: str/&) -> [u16]/~ {
|
||||
let mut u = []/~;
|
||||
chars_iter(s) {|cch|
|
||||
// Arithmetic with u32 literals is easier on the eyes than chars.
|
||||
let mut ch = cch as u32;
|
||||
|
|
@ -1273,14 +1273,14 @@ pure fn to_utf16(s: str/&) -> [u16] {
|
|||
if (ch & 0xFFFF_u32) == ch {
|
||||
// The BMP falls through (assuming non-surrogate, as it should)
|
||||
assert ch <= 0xD7FF_u32 || ch >= 0xE000_u32;
|
||||
u += [ch as u16]
|
||||
u += [ch as u16]/~
|
||||
} else {
|
||||
// Supplementary planes break into surrogates.
|
||||
assert ch >= 0x1_0000_u32 && ch <= 0x10_FFFF_u32;
|
||||
ch -= 0x1_0000_u32;
|
||||
let w1 = 0xD800_u16 | ((ch >> 10) as u16);
|
||||
let w2 = 0xDC00_u16 | ((ch as u16) & 0x3FF_u16);
|
||||
u += [w1, w2]
|
||||
u += [w1, w2]/~
|
||||
}
|
||||
}
|
||||
ret u;
|
||||
|
|
@ -1568,9 +1568,9 @@ interop.
|
|||
let i = str::as_bytes(\"Hello World\") { |bytes| vec::len(bytes) };
|
||||
~~~
|
||||
"]
|
||||
pure fn as_bytes<T>(s: str, f: fn([u8]) -> T) -> T {
|
||||
pure fn as_bytes<T>(s: str, f: fn([u8]/~) -> T) -> T {
|
||||
unsafe {
|
||||
let v: *[u8] = ::unsafe::reinterpret_cast(ptr::addr_of(s));
|
||||
let v: *[u8]/~ = ::unsafe::reinterpret_cast(ptr::addr_of(s));
|
||||
f(*v)
|
||||
}
|
||||
}
|
||||
|
|
@ -1723,7 +1723,7 @@ mod unsafe {
|
|||
|
||||
#[doc = "Create a Rust string from a *u8 buffer of the given length"]
|
||||
unsafe fn from_buf_len(buf: *u8, len: uint) -> str {
|
||||
let mut v: [u8] = [];
|
||||
let mut v: [u8]/~ = []/~;
|
||||
vec::reserve(v, len + 1u);
|
||||
vec::as_buf(v) {|b| ptr::memcpy(b, buf, len); }
|
||||
vec::unsafe::set_len(v, len);
|
||||
|
|
@ -1750,9 +1750,9 @@ mod unsafe {
|
|||
|
||||
Does not verify that the vector contains valid UTF-8.
|
||||
"]
|
||||
unsafe fn from_bytes(v: [const u8]) -> str {
|
||||
unsafe fn from_bytes(v: [const u8]/~) -> str {
|
||||
unsafe {
|
||||
let mut vcopy : [u8] = ::unsafe::transmute(copy v);
|
||||
let mut vcopy = ::unsafe::transmute(copy v);
|
||||
vec::push(vcopy, 0u8);
|
||||
::unsafe::transmute(vcopy)
|
||||
}
|
||||
|
|
@ -1763,7 +1763,7 @@ mod unsafe {
|
|||
|
||||
Does not verify that the byte is valid UTF-8.
|
||||
"]
|
||||
unsafe fn from_byte(u: u8) -> str { unsafe::from_bytes([u]) }
|
||||
unsafe fn from_byte(u: u8) -> str { unsafe::from_bytes([u]/~) }
|
||||
|
||||
#[doc = "
|
||||
Takes a bytewise (not UTF-8) slice from a string.
|
||||
|
|
@ -1780,7 +1780,7 @@ mod unsafe {
|
|||
assert (begin <= end);
|
||||
assert (end <= n);
|
||||
|
||||
let mut v = [];
|
||||
let mut v = []/~;
|
||||
vec::reserve(v, end - begin + 1u);
|
||||
unsafe {
|
||||
vec::as_buf(v) { |vbuf|
|
||||
|
|
@ -1788,7 +1788,7 @@ mod unsafe {
|
|||
ptr::memcpy(vbuf, src, end - begin);
|
||||
}
|
||||
vec::unsafe::set_len(v, end - begin);
|
||||
v += [0u8];
|
||||
v += [0u8]/~;
|
||||
::unsafe::transmute(v)
|
||||
}
|
||||
}
|
||||
|
|
@ -1800,7 +1800,7 @@ mod unsafe {
|
|||
}
|
||||
|
||||
#[doc = "Appends a vector of bytes to a string. (Not UTF-8 safe)."]
|
||||
unsafe fn push_bytes(&s: str, bytes: [u8]) {
|
||||
unsafe fn push_bytes(&s: str, bytes: [u8]/~) {
|
||||
for vec::each(bytes) {|byte| rustrt::rust_str_push(s, byte); }
|
||||
}
|
||||
|
||||
|
|
@ -1839,7 +1839,7 @@ mod unsafe {
|
|||
#[test]
|
||||
fn test_from_buf_len() {
|
||||
unsafe {
|
||||
let a = [65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 0u8];
|
||||
let a = [65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 0u8]/~;
|
||||
let b = vec::unsafe::to_ptr(a);
|
||||
let c = from_buf_len(b, 3u);
|
||||
assert (c == "AAA");
|
||||
|
|
@ -1920,18 +1920,18 @@ impl extensions/& for str/& {
|
|||
fn slice(begin: uint, end: uint) -> str { slice(self, begin, end) }
|
||||
#[doc = "Splits a string into substrings using a character function"]
|
||||
#[inline]
|
||||
fn split(sepfn: fn(char) -> bool) -> [str] { split(self, sepfn) }
|
||||
fn split(sepfn: fn(char) -> bool) -> [str]/~ { split(self, sepfn) }
|
||||
#[doc = "
|
||||
Splits a string into substrings at each occurrence of a given character
|
||||
"]
|
||||
#[inline]
|
||||
fn split_char(sep: char) -> [str] { split_char(self, sep) }
|
||||
fn split_char(sep: char) -> [str]/~ { split_char(self, sep) }
|
||||
#[doc = "
|
||||
Splits a string into a vector of the substrings separated by a given
|
||||
string
|
||||
"]
|
||||
#[inline]
|
||||
fn split_str(sep: str/&a) -> [str] { split_str(self, sep) }
|
||||
fn split_str(sep: str/&a) -> [str]/~ { split_str(self, sep) }
|
||||
#[doc = "Returns true if one string starts with another"]
|
||||
#[inline]
|
||||
fn starts_with(needle: str/&a) -> bool { starts_with(self, needle) }
|
||||
|
|
@ -2032,79 +2032,79 @@ mod tests {
|
|||
|
||||
#[test]
|
||||
fn test_split_char() {
|
||||
fn t(s: str, c: char, u: [str]) {
|
||||
fn t(s: str, c: char, u: [str]/~) {
|
||||
log(debug, "split_byte: " + s);
|
||||
let v = split_char(s, c);
|
||||
#debug("split_byte to: %?", v);
|
||||
assert vec::all2(v, u, { |a,b| a == b });
|
||||
}
|
||||
t("abc.hello.there", '.', ["abc", "hello", "there"]);
|
||||
t(".hello.there", '.', ["", "hello", "there"]);
|
||||
t("...hello.there.", '.', ["", "", "", "hello", "there", ""]);
|
||||
t("abc.hello.there", '.', ["abc", "hello", "there"]/~);
|
||||
t(".hello.there", '.', ["", "hello", "there"]/~);
|
||||
t("...hello.there.", '.', ["", "", "", "hello", "there", ""]/~);
|
||||
|
||||
assert ["", "", "", "hello", "there", ""]
|
||||
assert ["", "", "", "hello", "there", ""]/~
|
||||
== split_char("...hello.there.", '.');
|
||||
|
||||
assert [""] == split_char("", 'z');
|
||||
assert ["",""] == split_char("z", 'z');
|
||||
assert ["ok"] == split_char("ok", 'z');
|
||||
assert [""]/~ == split_char("", 'z');
|
||||
assert ["",""]/~ == split_char("z", 'z');
|
||||
assert ["ok"]/~ == split_char("ok", 'z');
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_split_char_2() {
|
||||
let data = "ประเทศไทย中华Việt Nam";
|
||||
assert ["ประเทศไทย中华", "iệt Nam"]
|
||||
assert ["ประเทศไทย中华", "iệt Nam"]/~
|
||||
== split_char(data, 'V');
|
||||
assert ["ประเ", "ศไ", "ย中华Việt Nam"]
|
||||
assert ["ประเ", "ศไ", "ย中华Việt Nam"]/~
|
||||
== split_char(data, 'ท');
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_splitn_char() {
|
||||
fn t(s: str, c: char, n: uint, u: [str]) {
|
||||
fn t(s: str, c: char, n: uint, u: [str]/~) {
|
||||
log(debug, "splitn_byte: " + s);
|
||||
let v = splitn_char(s, c, n);
|
||||
#debug("split_byte to: %?", v);
|
||||
#debug("comparing vs. %?", u);
|
||||
assert vec::all2(v, u, { |a,b| a == b });
|
||||
}
|
||||
t("abc.hello.there", '.', 0u, ["abc.hello.there"]);
|
||||
t("abc.hello.there", '.', 1u, ["abc", "hello.there"]);
|
||||
t("abc.hello.there", '.', 2u, ["abc", "hello", "there"]);
|
||||
t("abc.hello.there", '.', 3u, ["abc", "hello", "there"]);
|
||||
t(".hello.there", '.', 0u, [".hello.there"]);
|
||||
t(".hello.there", '.', 1u, ["", "hello.there"]);
|
||||
t("...hello.there.", '.', 3u, ["", "", "", "hello.there."]);
|
||||
t("...hello.there.", '.', 5u, ["", "", "", "hello", "there", ""]);
|
||||
t("abc.hello.there", '.', 0u, ["abc.hello.there"]/~);
|
||||
t("abc.hello.there", '.', 1u, ["abc", "hello.there"]/~);
|
||||
t("abc.hello.there", '.', 2u, ["abc", "hello", "there"]/~);
|
||||
t("abc.hello.there", '.', 3u, ["abc", "hello", "there"]/~);
|
||||
t(".hello.there", '.', 0u, [".hello.there"]/~);
|
||||
t(".hello.there", '.', 1u, ["", "hello.there"]/~);
|
||||
t("...hello.there.", '.', 3u, ["", "", "", "hello.there."]/~);
|
||||
t("...hello.there.", '.', 5u, ["", "", "", "hello", "there", ""]/~);
|
||||
|
||||
assert [""] == splitn_char("", 'z', 5u);
|
||||
assert ["",""] == splitn_char("z", 'z', 5u);
|
||||
assert ["ok"] == splitn_char("ok", 'z', 5u);
|
||||
assert ["z"] == splitn_char("z", 'z', 0u);
|
||||
assert ["w.x.y"] == splitn_char("w.x.y", '.', 0u);
|
||||
assert ["w","x.y"] == splitn_char("w.x.y", '.', 1u);
|
||||
assert [""]/~ == splitn_char("", 'z', 5u);
|
||||
assert ["",""]/~ == splitn_char("z", 'z', 5u);
|
||||
assert ["ok"]/~ == splitn_char("ok", 'z', 5u);
|
||||
assert ["z"]/~ == splitn_char("z", 'z', 0u);
|
||||
assert ["w.x.y"]/~ == splitn_char("w.x.y", '.', 0u);
|
||||
assert ["w","x.y"]/~ == splitn_char("w.x.y", '.', 1u);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_splitn_char_2 () {
|
||||
let data = "ประเทศไทย中华Việt Nam";
|
||||
assert ["ประเทศไทย中", "Việt Nam"]
|
||||
assert ["ประเทศไทย中", "Việt Nam"]/~
|
||||
== splitn_char(data, '华', 1u);
|
||||
|
||||
assert ["", "", "XXX", "YYYzWWWz"]
|
||||
assert ["", "", "XXX", "YYYzWWWz"]/~
|
||||
== splitn_char("zzXXXzYYYzWWWz", 'z', 3u);
|
||||
assert ["",""] == splitn_char("z", 'z', 5u);
|
||||
assert [""] == splitn_char("", 'z', 5u);
|
||||
assert ["ok"] == splitn_char("ok", 'z', 5u);
|
||||
assert ["",""]/~ == splitn_char("z", 'z', 5u);
|
||||
assert [""]/~ == splitn_char("", 'z', 5u);
|
||||
assert ["ok"]/~ == splitn_char("ok", 'z', 5u);
|
||||
}
|
||||
|
||||
|
||||
#[test]
|
||||
fn test_splitn_char_3() {
|
||||
let data = "ประเทศไทย中华Việt Nam";
|
||||
assert ["ประเทศไทย中华", "iệt Nam"]
|
||||
assert ["ประเทศไทย中华", "iệt Nam"]/~
|
||||
== splitn_char(data, 'V', 1u);
|
||||
assert ["ประเ", "ศไทย中华Việt Nam"]
|
||||
assert ["ประเ", "ศไทย中华Việt Nam"]/~
|
||||
== splitn_char(data, 'ท', 1u);
|
||||
|
||||
}
|
||||
|
|
@ -2125,40 +2125,40 @@ mod tests {
|
|||
t("::hello::there::", "::", 3, "");
|
||||
|
||||
let data = "ประเทศไทย中华Việt Nam";
|
||||
assert ["ประเทศไทย", "Việt Nam"]
|
||||
assert ["ประเทศไทย", "Việt Nam"]/~
|
||||
== split_str (data, "中华");
|
||||
|
||||
assert ["", "XXX", "YYY", ""]
|
||||
assert ["", "XXX", "YYY", ""]/~
|
||||
== split_str("zzXXXzzYYYzz", "zz");
|
||||
|
||||
assert ["zz", "zYYYz"]
|
||||
assert ["zz", "zYYYz"]/~
|
||||
== split_str("zzXXXzYYYz", "XXX");
|
||||
|
||||
|
||||
assert ["", "XXX", "YYY", ""] == split_str(".XXX.YYY.", ".");
|
||||
assert [""] == split_str("", ".");
|
||||
assert ["",""] == split_str("zz", "zz");
|
||||
assert ["ok"] == split_str("ok", "z");
|
||||
assert ["","z"] == split_str("zzz", "zz");
|
||||
assert ["","","z"] == split_str("zzzzz", "zz");
|
||||
assert ["", "XXX", "YYY", ""]/~ == split_str(".XXX.YYY.", ".");
|
||||
assert [""]/~ == split_str("", ".");
|
||||
assert ["",""]/~ == split_str("zz", "zz");
|
||||
assert ["ok"]/~ == split_str("ok", "z");
|
||||
assert ["","z"]/~ == split_str("zzz", "zz");
|
||||
assert ["","","z"]/~ == split_str("zzzzz", "zz");
|
||||
}
|
||||
|
||||
|
||||
#[test]
|
||||
fn test_split() {
|
||||
let data = "ประเทศไทย中华Việt Nam";
|
||||
assert ["ประเทศไทย中", "Việt Nam"]
|
||||
assert ["ประเทศไทย中", "Việt Nam"]/~
|
||||
== split (data, {|cc| cc == '华'});
|
||||
|
||||
assert ["", "", "XXX", "YYY", ""]
|
||||
assert ["", "", "XXX", "YYY", ""]/~
|
||||
== split("zzXXXzYYYz", char::is_lowercase);
|
||||
|
||||
assert ["zz", "", "", "z", "", "", "z"]
|
||||
assert ["zz", "", "", "z", "", "", "z"]/~
|
||||
== split("zzXXXzYYYz", char::is_uppercase);
|
||||
|
||||
assert ["",""] == split("z", {|cc| cc == 'z'});
|
||||
assert [""] == split("", {|cc| cc == 'z'});
|
||||
assert ["ok"] == split("ok", {|cc| cc == 'z'});
|
||||
assert ["",""]/~ == split("z", {|cc| cc == 'z'});
|
||||
assert [""]/~ == split("", {|cc| cc == 'z'});
|
||||
assert ["ok"]/~ == split("ok", {|cc| cc == 'z'});
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -2166,34 +2166,34 @@ mod tests {
|
|||
let lf = "\nMary had a little lamb\nLittle lamb\n";
|
||||
let crlf = "\r\nMary had a little lamb\r\nLittle lamb\r\n";
|
||||
|
||||
assert ["", "Mary had a little lamb", "Little lamb", ""]
|
||||
assert ["", "Mary had a little lamb", "Little lamb", ""]/~
|
||||
== lines(lf);
|
||||
|
||||
assert ["", "Mary had a little lamb", "Little lamb", ""]
|
||||
assert ["", "Mary had a little lamb", "Little lamb", ""]/~
|
||||
== lines_any(lf);
|
||||
|
||||
assert ["\r", "Mary had a little lamb\r", "Little lamb\r", ""]
|
||||
assert ["\r", "Mary had a little lamb\r", "Little lamb\r", ""]/~
|
||||
== lines(crlf);
|
||||
|
||||
assert ["", "Mary had a little lamb", "Little lamb", ""]
|
||||
assert ["", "Mary had a little lamb", "Little lamb", ""]/~
|
||||
== lines_any(crlf);
|
||||
|
||||
assert [""] == lines ("");
|
||||
assert [""] == lines_any("");
|
||||
assert ["",""] == lines ("\n");
|
||||
assert ["",""] == lines_any("\n");
|
||||
assert ["banana"] == lines ("banana");
|
||||
assert ["banana"] == lines_any("banana");
|
||||
assert [""]/~ == lines ("");
|
||||
assert [""]/~ == lines_any("");
|
||||
assert ["",""]/~ == lines ("\n");
|
||||
assert ["",""]/~ == lines_any("\n");
|
||||
assert ["banana"]/~ == lines ("banana");
|
||||
assert ["banana"]/~ == lines_any("banana");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_words () {
|
||||
let data = "\nMary had a little lamb\nLittle lamb\n";
|
||||
assert ["Mary","had","a","little","lamb","Little","lamb"]
|
||||
assert ["Mary","had","a","little","lamb","Little","lamb"]/~
|
||||
== words(data);
|
||||
|
||||
assert ["ok"] == words("ok");
|
||||
assert [] == words("");
|
||||
assert ["ok"]/~ == words("ok");
|
||||
assert []/~ == words("");
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -2250,22 +2250,23 @@ mod tests {
|
|||
|
||||
#[test]
|
||||
fn test_concat() {
|
||||
fn t(v: [str], s: str) { assert (eq(concat(v), s)); }
|
||||
t(["you", "know", "I'm", "no", "good"], "youknowI'mnogood");
|
||||
let v: [str] = [];
|
||||
fn t(v: [str]/~, s: str) { assert (eq(concat(v), s)); }
|
||||
t(["you", "know", "I'm", "no", "good"]/~, "youknowI'mnogood");
|
||||
let v: [str]/~ = []/~;
|
||||
t(v, "");
|
||||
t(["hi"], "hi");
|
||||
t(["hi"]/~, "hi");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_connect() {
|
||||
fn t(v: [str], sep: str, s: str) {
|
||||
fn t(v: [str]/~, sep: str, s: str) {
|
||||
assert (eq(connect(v, sep), s));
|
||||
}
|
||||
t(["you", "know", "I'm", "no", "good"], " ", "you know I'm no good");
|
||||
let v: [str] = [];
|
||||
t(["you", "know", "I'm", "no", "good"]/~,
|
||||
" ", "you know I'm no good");
|
||||
let v: [str]/~ = []/~;
|
||||
t(v, " ", "");
|
||||
t(["hi"], " ", "hi");
|
||||
t(["hi"]/~, " ", "hi");
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -2517,7 +2518,7 @@ mod tests {
|
|||
|
||||
#[test]
|
||||
fn test_unsafe_from_bytes() {
|
||||
let a = [65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8];
|
||||
let a = [65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8]/~;
|
||||
let b = unsafe { unsafe::from_bytes(a) };
|
||||
assert (b == "AAAAAAA");
|
||||
}
|
||||
|
|
@ -2534,7 +2535,7 @@ mod tests {
|
|||
0x56_u8, 0x69_u8, 0xe1_u8,
|
||||
0xbb_u8, 0x87_u8, 0x74_u8,
|
||||
0x20_u8, 0x4e_u8, 0x61_u8,
|
||||
0x6d_u8];
|
||||
0x6d_u8]/~;
|
||||
|
||||
assert ss == from_bytes(bb);
|
||||
}
|
||||
|
|
@ -2552,7 +2553,7 @@ mod tests {
|
|||
0x56_u8, 0x69_u8, 0xe1_u8,
|
||||
0xbb_u8, 0x87_u8, 0x74_u8,
|
||||
0x20_u8, 0x4e_u8, 0x61_u8,
|
||||
0x6d_u8];
|
||||
0x6d_u8]/~;
|
||||
|
||||
let _x = from_bytes(bb);
|
||||
}
|
||||
|
|
@ -2560,7 +2561,7 @@ mod tests {
|
|||
#[test]
|
||||
fn test_from_buf() {
|
||||
unsafe {
|
||||
let a = [65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 0u8];
|
||||
let a = [65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 0u8]/~;
|
||||
let b = vec::unsafe::to_ptr(a);
|
||||
let c = unsafe::from_buf(b);
|
||||
assert (c == "AAAAAAA");
|
||||
|
|
@ -2609,7 +2610,7 @@ mod tests {
|
|||
fn vec_str_conversions() {
|
||||
let s1: str = "All mimsy were the borogoves";
|
||||
|
||||
let v: [u8] = bytes(s1);
|
||||
let v: [u8]/~ = bytes(s1);
|
||||
let s2: str = from_bytes(v);
|
||||
let mut i: uint = 0u;
|
||||
let n1: uint = len(s1);
|
||||
|
|
@ -2774,7 +2775,7 @@ mod tests {
|
|||
#[test]
|
||||
fn test_chars() {
|
||||
let ss = "ศไทย中华Việt Nam";
|
||||
assert ['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m']
|
||||
assert ['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m']/~
|
||||
== chars(ss);
|
||||
}
|
||||
|
||||
|
|
@ -2785,7 +2786,7 @@ mod tests {
|
|||
[0xd800_u16, 0xdf45_u16, 0xd800_u16, 0xdf3f_u16,
|
||||
0xd800_u16, 0xdf3b_u16, 0xd800_u16, 0xdf46_u16,
|
||||
0xd800_u16, 0xdf39_u16, 0xd800_u16, 0xdf3b_u16,
|
||||
0xd800_u16, 0xdf30_u16, 0x000a_u16]),
|
||||
0xd800_u16, 0xdf30_u16, 0x000a_u16]/~),
|
||||
|
||||
("𐐒𐑉𐐮𐑀𐐲𐑋 𐐏𐐲𐑍\n",
|
||||
[0xd801_u16, 0xdc12_u16, 0xd801_u16,
|
||||
|
|
@ -2793,7 +2794,7 @@ mod tests {
|
|||
0xdc40_u16, 0xd801_u16, 0xdc32_u16, 0xd801_u16,
|
||||
0xdc4b_u16, 0x0020_u16, 0xd801_u16, 0xdc0f_u16,
|
||||
0xd801_u16, 0xdc32_u16, 0xd801_u16, 0xdc4d_u16,
|
||||
0x000a_u16]),
|
||||
0x000a_u16]/~),
|
||||
|
||||
("𐌀𐌖𐌋𐌄𐌑𐌉·𐌌𐌄𐌕𐌄𐌋𐌉𐌑\n",
|
||||
[0xd800_u16, 0xdf00_u16, 0xd800_u16, 0xdf16_u16,
|
||||
|
|
@ -2802,7 +2803,7 @@ mod tests {
|
|||
0x00b7_u16, 0xd800_u16, 0xdf0c_u16, 0xd800_u16,
|
||||
0xdf04_u16, 0xd800_u16, 0xdf15_u16, 0xd800_u16,
|
||||
0xdf04_u16, 0xd800_u16, 0xdf0b_u16, 0xd800_u16,
|
||||
0xdf09_u16, 0xd800_u16, 0xdf11_u16, 0x000a_u16 ]),
|
||||
0xdf09_u16, 0xd800_u16, 0xdf11_u16, 0x000a_u16 ]/~),
|
||||
|
||||
("𐒋𐒘𐒈𐒑𐒛𐒒 𐒕𐒓 𐒈𐒚𐒍 𐒏𐒜𐒒𐒖𐒆 𐒕𐒆\n",
|
||||
[0xd801_u16, 0xdc8b_u16, 0xd801_u16, 0xdc98_u16,
|
||||
|
|
@ -2815,7 +2816,7 @@ mod tests {
|
|||
0xdc9c_u16, 0xd801_u16, 0xdc92_u16, 0xd801_u16,
|
||||
0xdc96_u16, 0xd801_u16, 0xdc86_u16, 0x0020_u16,
|
||||
0xd801_u16, 0xdc95_u16, 0xd801_u16, 0xdc86_u16,
|
||||
0x000a_u16 ]) ];
|
||||
0x000a_u16 ]/~) ]/~;
|
||||
|
||||
for vec::each(pairs) {|p|
|
||||
let (s, u) = p;
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue