Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
int
Rust
提交
663d07d3
R
Rust
项目概览
int
/
Rust
大约 1 年 前同步成功
通知
1
Star
0
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
DevOps
流水线
流水线任务
计划
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
R
Rust
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
DevOps
DevOps
流水线
流水线任务
计划
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
流水线任务
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
提交
663d07d3
编写于
8月 22, 2011
作者:
B
Brian Anderson
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
Add std::istr. Issue #855
上级
55c54f0d
变更
5
隐藏空白更改
内联
并排
Showing
5 changed file
with
712 addition
and
0 deletion
+712
-0
src/lib/istr.rs
src/lib/istr.rs
+428
-0
src/lib/std.rc
src/lib/std.rc
+1
-0
src/test/run-pass/utf8_chars-istr.rs
src/test/run-pass/utf8_chars-istr.rs
+31
-0
src/test/stdtest/istr.rs
src/test/stdtest/istr.rs
+251
-0
src/test/stdtest/stdtest.rc
src/test/stdtest/stdtest.rc
+1
-0
未找到文件。
src/lib/istr.rs
0 → 100644
浏览文件 @
663d07d3
export
eq
,
lteq
,
hash
,
is_empty
,
is_not_empty
,
is_whitespace
,
byte_len
,
index
,
rindex
,
find
,
starts_with
,
ends_with
,
substr
,
slice
,
split
,
concat
,
connect
,
to_upper
,
replace
,
char_slice
,
trim_left
,
trim_right
,
trim
,
unshift_char
,
shift_char
,
pop_char
,
push_char
,
is_utf8
,
from_chars
,
to_chars
,
char_len
,
char_at
,
bytes
,
is_ascii
,
shift_byte
,
pop_byte
;
fn
eq
(
a
:
&
istr
,
b
:
&
istr
)
->
bool
{
a
==
b
}
fn
lteq
(
a
:
&
istr
,
b
:
&
istr
)
->
bool
{
a
<=
b
}
fn
hash
(
s
:
&
istr
)
->
uint
{
// djb hash.
// FIXME: replace with murmur.
let
u
:
uint
=
5381u
;
for
c
:
u8
in
s
{
u
*=
33u
;
u
+=
c
as
uint
;
}
ret
u
;
}
// UTF-8 tags and ranges
const
tag_cont_u8
:
u8
=
128u8
;
const
tag_cont
:
uint
=
128u
;
const
max_one_b
:
uint
=
128u
;
const
tag_two_b
:
uint
=
192u
;
const
max_two_b
:
uint
=
2048u
;
const
tag_three_b
:
uint
=
224u
;
const
max_three_b
:
uint
=
65536u
;
const
tag_four_b
:
uint
=
240u
;
const
max_four_b
:
uint
=
2097152u
;
const
tag_five_b
:
uint
=
248u
;
const
max_five_b
:
uint
=
67108864u
;
const
tag_six_b
:
uint
=
252u
;
fn
is_utf8
(
v
:
&
[
u8
])
->
bool
{
let
i
=
0u
;
let
total
=
vec
::
len
::
<
u8
>
(
v
);
while
i
<
total
{
let
chsize
=
utf8_char_width
(
v
[
i
]);
if
chsize
==
0u
{
ret
false
;
}
if
i
+
chsize
>
total
{
ret
false
;
}
i
+=
1u
;
while
chsize
>
1u
{
if
v
[
i
]
&
192u8
!=
tag_cont_u8
{
ret
false
;
}
i
+=
1u
;
chsize
-=
1u
;
}
}
ret
true
;
}
fn
is_ascii
(
s
:
&
istr
)
->
bool
{
let
i
:
uint
=
byte_len
(
s
);
while
i
>
0u
{
i
-=
1u
;
if
s
[
i
]
&
128u8
!=
0u8
{
ret
false
;
}
}
ret
true
;
}
/// Returns true if the string has length 0
pred
is_empty
(
s
:
&
istr
)
->
bool
{
for
c
:
u8
in
s
{
ret
false
;
}
ret
true
;
}
/// Returns true if the string has length greater than 0
pred
is_not_empty
(
s
:
&
istr
)
->
bool
{
!
is_empty
(
s
)
}
fn
is_whitespace
(
s
:
&
istr
)
->
bool
{
let
i
=
0u
;
let
len
=
char_len
(
s
);
while
i
<
len
{
if
!
char
::
is_whitespace
(
char_at
(
s
,
i
))
{
ret
false
;
}
i
+=
1u
}
ret
true
;
}
fn
byte_len
(
s
:
&
istr
)
->
uint
{
let
v
:
[
u8
]
=
unsafe
::
reinterpret_cast
(
s
);
let
vlen
=
vec
::
len
(
v
);
unsafe
::
leak
(
v
);
// There should always be a null terminator
assert
vlen
>
0u
;
ret
vlen
-
1u
;
}
fn
bytes
(
s
:
&
istr
)
->
[
u8
]
{
let
v
=
unsafe
::
reinterpret_cast
(
s
);
let
vcopy
=
vec
::
slice
(
v
,
0u
,
vec
::
len
(
v
)
-
1u
);
unsafe
::
leak
(
v
);
ret
vcopy
;
}
fn
unsafe_from_bytes
(
v
:
&
[
mutable
?
u8
])
->
istr
{
let
vcopy
:
[
u8
]
=
v
+
[
0u8
];
let
scopy
:
istr
=
unsafe
::
reinterpret_cast
(
vcopy
);
ret
scopy
;
}
fn
unsafe_from_byte
(
u
:
u8
)
->
istr
{
unsafe_from_bytes
([
u
])
}
fn
push_utf8_bytes
(
s
:
&
mutable
istr
,
ch
:
char
)
{
let
code
=
ch
as
uint
;
let
bytes
=
if
code
<
max_one_b
{
[
code
as
u8
]
}
else
if
code
<
max_two_b
{
[(
code
>>
6u
&
31u
|
tag_two_b
)
as
u8
,
(
code
&
63u
|
tag_cont
)
as
u8
]
}
else
if
code
<
max_three_b
{
[(
code
>>
12u
&
15u
|
tag_three_b
)
as
u8
,
(
code
>>
6u
&
63u
|
tag_cont
)
as
u8
,
(
code
&
63u
|
tag_cont
)
as
u8
]
}
else
if
code
<
max_four_b
{
[(
code
>>
18u
&
7u
|
tag_four_b
)
as
u8
,
(
code
>>
12u
&
63u
|
tag_cont
)
as
u8
,
(
code
>>
6u
&
63u
|
tag_cont
)
as
u8
,
(
code
&
63u
|
tag_cont
)
as
u8
]
}
else
if
code
<
max_five_b
{
[(
code
>>
24u
&
3u
|
tag_five_b
)
as
u8
,
(
code
>>
18u
&
63u
|
tag_cont
)
as
u8
,
(
code
>>
12u
&
63u
|
tag_cont
)
as
u8
,
(
code
>>
6u
&
63u
|
tag_cont
)
as
u8
,
(
code
&
63u
|
tag_cont
)
as
u8
]
}
else
{
[(
code
>>
30u
&
1u
|
tag_six_b
)
as
u8
,
(
code
>>
24u
&
63u
|
tag_cont
)
as
u8
,
(
code
>>
18u
&
63u
|
tag_cont
)
as
u8
,
(
code
>>
12u
&
63u
|
tag_cont
)
as
u8
,
(
code
>>
6u
&
63u
|
tag_cont
)
as
u8
,
(
code
&
63u
|
tag_cont
)
as
u8
]
};
push_bytes
(
s
,
bytes
);
}
fn
from_char
(
ch
:
char
)
->
istr
{
let
buf
=
~
""
;
push_utf8_bytes
(
buf
,
ch
);
ret
buf
;
}
fn
from_chars
(
chs
:
&
[
char
])
->
istr
{
let
buf
=
~
""
;
for
ch
:
char
in
chs
{
push_utf8_bytes
(
buf
,
ch
);
}
ret
buf
;
}
fn
utf8_char_width
(
b
:
u8
)
->
uint
{
let
byte
:
uint
=
b
as
uint
;
if
byte
<
128u
{
ret
1u
;
}
if
byte
<
192u
{
ret
0u
;
// Not a valid start byte
}
if
byte
<
224u
{
ret
2u
;
}
if
byte
<
240u
{
ret
3u
;
}
if
byte
<
248u
{
ret
4u
;
}
if
byte
<
252u
{
ret
5u
;
}
ret
6u
;
}
fn
char_range_at
(
s
:
&
istr
,
i
:
uint
)
->
{
ch
:
char
,
next
:
uint
}
{
let
b0
=
s
[
i
];
let
w
=
utf8_char_width
(
b0
);
assert
(
w
!=
0u
);
if
w
==
1u
{
ret
{
ch
:
b0
as
char
,
next
:
i
+
1u
};
}
let
val
=
0u
;
let
end
=
i
+
w
;
i
+=
1u
;
while
i
<
end
{
let
byte
=
s
[
i
];
assert
(
byte
&
192u8
==
tag_cont_u8
);
val
<<=
6u
;
val
+=
byte
&
63u8
as
uint
;
i
+=
1u
;
}
// Clunky way to get the right bits from the first byte. Uses two shifts,
// the first to clip off the marker bits at the left of the byte, and then
// a second (as uint) to get it to the right position.
val
+=
(
b0
<<
(
w
+
1u
as
u8
)
as
uint
)
<<
(
w
-
1u
)
*
6u
-
w
-
1u
;
ret
{
ch
:
val
as
char
,
next
:
i
};
}
fn
char_at
(
s
:
&
istr
,
i
:
uint
)
->
char
{
ret
char_range_at
(
s
,
i
)
.ch
;
}
fn
char_len
(
s
:
&
istr
)
->
uint
{
let
i
=
0u
;
let
len
=
0u
;
let
total
=
byte_len
(
s
);
while
i
<
total
{
let
chsize
=
utf8_char_width
(
s
[
i
]);
assert
(
chsize
>
0u
);
len
+=
1u
;
i
+=
chsize
;
}
assert
(
i
==
total
);
ret
len
;
}
fn
to_chars
(
s
:
&
istr
)
->
[
char
]
{
let
buf
:
[
char
]
=
[];
let
i
=
0u
;
let
len
=
byte_len
(
s
);
while
i
<
len
{
let
cur
=
char_range_at
(
s
,
i
);
buf
+=
[
cur
.ch
];
i
=
cur
.next
;
}
ret
buf
;
}
fn
push_char
(
s
:
&
mutable
istr
,
ch
:
char
)
{
s
+=
from_char
(
ch
);
}
fn
pop_char
(
s
:
&
mutable
istr
)
->
char
{
let
end
=
byte_len
(
s
);
while
end
>
0u
&&
s
[
end
-
1u
]
&
192u8
==
tag_cont_u8
{
end
-=
1u
;
}
assert
(
end
>
0u
);
let
ch
=
char_at
(
s
,
end
-
1u
);
s
=
substr
(
s
,
0u
,
end
-
1u
);
ret
ch
;
}
fn
shift_char
(
s
:
&
mutable
istr
)
->
char
{
let
r
=
char_range_at
(
s
,
0u
);
s
=
substr
(
s
,
r
.next
,
byte_len
(
s
)
-
r
.next
);
ret
r
.ch
;
}
fn
unshift_char
(
s
:
&
mutable
istr
,
ch
:
char
)
{
s
=
from_char
(
ch
)
+
s
;
}
fn
index
(
s
:
&
istr
,
c
:
u8
)
->
int
{
let
i
:
int
=
0
;
for
k
:
u8
in
s
{
if
k
==
c
{
ret
i
;
}
i
+=
1
;
}
ret
-
1
;
}
fn
rindex
(
s
:
&
istr
,
c
:
u8
)
->
int
{
let
n
:
int
=
byte_len
(
s
)
as
int
;
while
n
>=
0
{
if
s
[
n
]
==
c
{
ret
n
;
}
n
-=
1
;
}
ret
n
;
}
fn
find
(
haystack
:
&
istr
,
needle
:
&
istr
)
->
int
{
let
haystack_len
:
int
=
byte_len
(
haystack
)
as
int
;
let
needle_len
:
int
=
byte_len
(
needle
)
as
int
;
if
needle_len
==
0
{
ret
0
;
}
fn
match_at
(
haystack
:
&
istr
,
needle
:
&
istr
,
i
:
int
)
->
bool
{
let
j
:
int
=
i
;
for
c
:
u8
in
needle
{
if
haystack
[
j
]
!=
c
{
ret
false
;
}
j
+=
1
;
}
ret
true
;
}
let
i
:
int
=
0
;
while
i
<=
haystack_len
-
needle_len
{
if
match_at
(
haystack
,
needle
,
i
)
{
ret
i
;
}
i
+=
1
;
}
ret
-
1
;
}
fn
starts_with
(
haystack
:
&
istr
,
needle
:
&
istr
)
->
bool
{
let
haystack_len
:
uint
=
byte_len
(
haystack
);
let
needle_len
:
uint
=
byte_len
(
needle
);
if
needle_len
==
0u
{
ret
true
;
}
if
needle_len
>
haystack_len
{
ret
false
;
}
ret
eq
(
substr
(
haystack
,
0u
,
needle_len
),
needle
);
}
fn
ends_with
(
haystack
:
&
istr
,
needle
:
&
istr
)
->
bool
{
let
haystack_len
:
uint
=
byte_len
(
haystack
);
let
needle_len
:
uint
=
byte_len
(
needle
);
ret
if
needle_len
==
0u
{
true
}
else
if
needle_len
>
haystack_len
{
false
}
else
{
eq
(
substr
(
haystack
,
haystack_len
-
needle_len
,
needle_len
),
needle
)
};
}
fn
substr
(
s
:
&
istr
,
begin
:
uint
,
len
:
uint
)
->
istr
{
ret
slice
(
s
,
begin
,
begin
+
len
);
}
fn
slice
(
s
:
&
istr
,
begin
:
uint
,
end
:
uint
)
->
istr
{
// FIXME: Typestate precondition
assert
(
begin
<=
end
);
assert
(
end
<=
byte_len
(
s
));
let
v
:
[
u8
]
=
unsafe
::
reinterpret_cast
(
s
);
let
v2
=
vec
::
slice
(
v
,
begin
,
end
);
unsafe
::
leak
(
v
);
v2
+=
[
0u8
];
let
s2
:
istr
=
unsafe
::
reinterpret_cast
(
v2
);
unsafe
::
leak
(
v2
);
ret
s2
;
}
fn
safe_slice
(
s
:
&
istr
,
begin
:
uint
,
end
:
uint
)
:
uint
::
le
(
begin
,
end
)
->
istr
{
// would need some magic to make this a precondition
assert
(
end
<=
byte_len
(
s
));
ret
slice
(
s
,
begin
,
end
);
}
fn
shift_byte
(
s
:
&
mutable
istr
)
->
u8
{
let
len
=
byte_len
(
s
);
assert
(
len
>
0u
);
let
b
=
s
[
0
];
s
=
substr
(
s
,
1u
,
len
-
1u
);
ret
b
;
}
fn
pop_byte
(
s
:
&
mutable
istr
)
->
u8
{
let
len
=
byte_len
(
s
);
assert
(
len
>
0u
);
let
b
=
s
[
len
-
1u
];
s
=
substr
(
s
,
0u
,
len
-
1u
);
ret
b
;
}
fn
push_byte
(
s
:
&
mutable
istr
,
b
:
u8
)
{
s
+=
unsafe_from_byte
(
b
);
}
fn
push_bytes
(
s
:
&
mutable
istr
,
bytes
:
&
[
u8
])
{
for
byte
in
bytes
{
push_byte
(
s
,
byte
);
}
}
fn
split
(
s
:
&
istr
,
sep
:
u8
)
->
[
istr
]
{
let
v
:
[
istr
]
=
[];
let
accum
:
istr
=
~
""
;
let
ends_with_sep
:
bool
=
false
;
for
c
:
u8
in
s
{
if
c
==
sep
{
v
+=
[
accum
];
accum
=
~
""
;
ends_with_sep
=
true
;
}
else
{
accum
+=
unsafe_from_byte
(
c
);
ends_with_sep
=
false
;
}
}
if
byte_len
(
accum
)
!=
0u
||
ends_with_sep
{
v
+=
[
accum
];
}
ret
v
;
}
fn
concat
(
v
:
&
[
istr
])
->
istr
{
let
s
:
istr
=
~
""
;
for
ss
:
istr
in
v
{
s
+=
ss
;
}
ret
s
;
}
fn
connect
(
v
:
&
[
istr
],
sep
:
&
istr
)
->
istr
{
let
s
:
istr
=
~
""
;
let
first
:
bool
=
true
;
for
ss
:
istr
in
v
{
if
first
{
first
=
false
;
}
else
{
s
+=
sep
;
}
s
+=
ss
;
}
ret
s
;
}
// FIXME: This only handles ASCII
fn
to_upper
(
s
:
&
istr
)
->
istr
{
let
outstr
=
~
""
;
let
ascii_a
=
'a'
as
u8
;
let
ascii_z
=
'z'
as
u8
;
let
diff
=
32u8
;
for
byte
:
u8
in
s
{
let
next
;
if
ascii_a
<=
byte
&&
byte
<=
ascii_z
{
next
=
byte
-
diff
;
}
else
{
next
=
byte
;
}
push_byte
(
outstr
,
next
);
}
ret
outstr
;
}
// FIXME: This is super-inefficient
fn
replace
(
s
:
&
istr
,
from
:
&
istr
,
to
:
&
istr
)
:
is_not_empty
(
from
)
->
istr
{
// FIXME (694): Shouldn't have to check this
check
(
is_not_empty
(
from
));
if
byte_len
(
s
)
==
0u
{
ret
~
""
;
}
else
if
starts_with
(
s
,
from
)
{
ret
to
+
replace
(
slice
(
s
,
byte_len
(
from
),
byte_len
(
s
)),
from
,
to
);
}
else
{
ret
unsafe_from_byte
(
s
[
0
])
+
replace
(
slice
(
s
,
1u
,
byte_len
(
s
)),
from
,
to
);
}
}
// FIXME: Also not efficient
fn
char_slice
(
s
:
&
istr
,
begin
:
uint
,
end
:
uint
)
->
istr
{
from_chars
(
vec
::
slice
(
to_chars
(
s
),
begin
,
end
))
}
fn
trim_left
(
s
:
&
istr
)
->
istr
{
fn
count_whities
(
s
:
&
[
char
])
->
uint
{
let
i
=
0u
;
while
i
<
vec
::
len
(
s
)
{
if
!
char
::
is_whitespace
(
s
[
i
])
{
break
;
}
i
+=
1u
;
}
ret
i
;
}
let
chars
=
to_chars
(
s
);
let
whities
=
count_whities
(
chars
);
ret
from_chars
(
vec
::
slice
(
chars
,
whities
,
vec
::
len
(
chars
)));
}
fn
trim_right
(
s
:
&
istr
)
->
istr
{
fn
count_whities
(
s
:
&
[
char
])
->
uint
{
let
i
=
vec
::
len
(
s
);
while
0u
<
i
{
if
!
char
::
is_whitespace
(
s
[
i
-
1u
])
{
break
;
}
i
-=
1u
;
}
ret
i
;
}
let
chars
=
to_chars
(
s
);
let
whities
=
count_whities
(
chars
);
ret
from_chars
(
vec
::
slice
(
chars
,
0u
,
whities
));
}
fn
trim
(
s
:
&
istr
)
->
istr
{
trim_left
(
trim_right
(
s
))
}
\ No newline at end of file
src/lib/std.rc
浏览文件 @
663d07d3
...
...
@@ -16,6 +16,7 @@ mod u8;
mod u64;
mod vec;
mod str;
mod istr;
// General io and system-services modules.
...
...
src/test/run-pass/utf8_chars-istr.rs
0 → 100644
浏览文件 @
663d07d3
use
std
;
import
std
::
istr
;
import
std
::
vec
;
fn
main
()
{
// Chars of 1, 2, 3, and 4 bytes
let
chs
:
[
char
]
=
[
'e'
,
'é'
,
'€'
,
0x10000
as
char
];
let
s
:
istr
=
istr
::
from_chars
(
chs
);
assert
(
istr
::
byte_len
(
s
)
==
10u
);
assert
(
istr
::
char_len
(
s
)
==
4u
);
assert
(
vec
::
len
::
<
char
>
(
istr
::
to_chars
(
s
))
==
4u
);
assert
(
istr
::
eq
(
istr
::
from_chars
(
istr
::
to_chars
(
s
)),
s
));
assert
(
istr
::
char_at
(
s
,
0u
)
==
'e'
);
assert
(
istr
::
char_at
(
s
,
1u
)
==
'é'
);
assert
(
istr
::
is_utf8
(
istr
::
bytes
(
s
)));
assert
(
!
istr
::
is_utf8
([
0x80_u8
]));
assert
(
!
istr
::
is_utf8
([
0xc0_u8
]));
assert
(
!
istr
::
is_utf8
([
0xc0_u8
,
0x10_u8
]));
let
stack
=
~
"a×c€"
;
assert
(
istr
::
pop_char
(
stack
)
==
'€'
);
assert
(
istr
::
pop_char
(
stack
)
==
'c'
);
istr
::
push_char
(
stack
,
'u'
);
assert
(
istr
::
eq
(
stack
,
~
"a×u"
));
assert
(
istr
::
shift_char
(
stack
)
==
'a'
);
assert
(
istr
::
shift_char
(
stack
)
==
'×'
);
istr
::
unshift_char
(
stack
,
'ß'
);
assert
(
istr
::
eq
(
stack
,
~
"ßu"
));
}
src/test/stdtest/istr.rs
0 → 100644
浏览文件 @
663d07d3
import
std
::
istr
;
#[test]
fn
test_eq
()
{
assert
istr
::
eq
(
~
""
,
~
""
);
assert
istr
::
eq
(
~
"foo"
,
~
"foo"
);
assert
!
istr
::
eq
(
~
"foo"
,
~
"bar"
);
}
#[test]
fn
test_lteq
()
{
assert
istr
::
lteq
(
~
""
,
~
""
);
assert
istr
::
lteq
(
~
""
,
~
"foo"
);
assert
istr
::
lteq
(
~
"foo"
,
~
"foo"
);
assert
!
istr
::
eq
(
~
"foo"
,
~
"bar"
);
}
#[test]
fn
test_bytes_len
()
{
assert
(
istr
::
byte_len
(
~
""
)
==
0u
);
assert
(
istr
::
byte_len
(
~
"hello world"
)
==
11u
);
assert
(
istr
::
byte_len
(
~
"
\x63
"
)
==
1u
);
assert
(
istr
::
byte_len
(
~
"
\xa2
"
)
==
2u
);
assert
(
istr
::
byte_len
(
~
"
\u03c0
"
)
==
2u
);
assert
(
istr
::
byte_len
(
~
"
\u2620
"
)
==
3u
);
assert
(
istr
::
byte_len
(
~
"
\U0001d11e
"
)
==
4u
);
}
#[test]
fn
test_index_and_rindex
()
{
assert
(
istr
::
index
(
~
"hello"
,
'e'
as
u8
)
==
1
);
assert
(
istr
::
index
(
~
"hello"
,
'o'
as
u8
)
==
4
);
assert
(
istr
::
index
(
~
"hello"
,
'z'
as
u8
)
==
-
1
);
assert
(
istr
::
rindex
(
~
"hello"
,
'l'
as
u8
)
==
3
);
assert
(
istr
::
rindex
(
~
"hello"
,
'h'
as
u8
)
==
0
);
assert
(
istr
::
rindex
(
~
"hello"
,
'z'
as
u8
)
==
-
1
);
}
#[test]
fn
test_split
()
{
fn
t
(
s
:
&
istr
,
c
:
char
,
i
:
int
,
k
:
&
istr
)
{
log
~
"splitting: "
+
s
;
log
i
;
let
v
=
istr
::
split
(
s
,
c
as
u8
);
log
~
"split to: "
;
for
z
:
istr
in
v
{
log
z
;
}
log
~
"comparing: "
+
v
[
i
]
+
~
" vs. "
+
k
;
assert
(
istr
::
eq
(
v
[
i
],
k
));
}
t
(
~
"abc.hello.there"
,
'.'
,
0
,
~
"abc"
);
t
(
~
"abc.hello.there"
,
'.'
,
1
,
~
"hello"
);
t
(
~
"abc.hello.there"
,
'.'
,
2
,
~
"there"
);
t
(
~
".hello.there"
,
'.'
,
0
,
~
""
);
t
(
~
".hello.there"
,
'.'
,
1
,
~
"hello"
);
t
(
~
"...hello.there."
,
'.'
,
3
,
~
"hello"
);
t
(
~
"...hello.there."
,
'.'
,
5
,
~
""
);
}
#[test]
fn
test_find
()
{
fn
t
(
haystack
:
&
istr
,
needle
:
&
istr
,
i
:
int
)
{
let
j
:
int
=
istr
::
find
(
haystack
,
needle
);
log
~
"searched for "
+
needle
;
log
j
;
assert
(
i
==
j
);
}
t
(
~
"this is a simple"
,
~
"is a"
,
5
);
t
(
~
"this is a simple"
,
~
"is z"
,
-
1
);
t
(
~
"this is a simple"
,
~
""
,
0
);
t
(
~
"this is a simple"
,
~
"simple"
,
10
);
t
(
~
"this"
,
~
"simple"
,
-
1
);
}
#[test]
fn
test_substr
()
{
fn
t
(
a
:
&
istr
,
b
:
&
istr
,
start
:
int
)
{
assert
(
istr
::
eq
(
istr
::
substr
(
a
,
start
as
uint
,
istr
::
byte_len
(
b
)),
b
));
}
t
(
~
"hello"
,
~
"llo"
,
2
);
t
(
~
"hello"
,
~
"el"
,
1
);
t
(
~
"substr should not be a challenge"
,
~
"not"
,
14
);
}
#[test]
fn
test_concat
()
{
fn
t
(
v
:
&
[
istr
],
s
:
&
istr
)
{
assert
(
istr
::
eq
(
istr
::
concat
(
v
),
s
));
}
t
([
~
"you"
,
~
"know"
,
~
"I'm"
,
~
"no"
,
~
"good"
],
~
"youknowI'mnogood"
);
let
v
:
[
istr
]
=
[];
t
(
v
,
~
""
);
t
([
~
"hi"
],
~
"hi"
);
}
#[test]
fn
test_connect
()
{
fn
t
(
v
:
&
[
istr
],
sep
:
&
istr
,
s
:
&
istr
)
{
assert
(
istr
::
eq
(
istr
::
connect
(
v
,
sep
),
s
));
}
t
([
~
"you"
,
~
"know"
,
~
"I'm"
,
~
"no"
,
~
"good"
],
~
" "
,
~
"you know I'm no good"
);
let
v
:
[
istr
]
=
[];
t
(
v
,
~
" "
,
~
""
);
t
([
~
"hi"
],
~
" "
,
~
"hi"
);
}
#[test]
fn
test_to_upper
()
{
// to_upper doesn't understand unicode yet,
// but we need to at least preserve it
let
unicode
=
~
"
\u65e5\u672c
"
;
let
input
=
~
"abcDEF"
+
unicode
+
~
"xyz:.;"
;
let
expected
=
~
"ABCDEF"
+
unicode
+
~
"XYZ:.;"
;
let
actual
=
istr
::
to_upper
(
input
);
assert
(
istr
::
eq
(
expected
,
actual
));
}
#[test]
fn
test_slice
()
{
assert
(
istr
::
eq
(
~
"ab"
,
istr
::
slice
(
~
"abc"
,
0u
,
2u
)));
assert
(
istr
::
eq
(
~
"bc"
,
istr
::
slice
(
~
"abc"
,
1u
,
3u
)));
assert
(
istr
::
eq
(
~
""
,
istr
::
slice
(
~
"abc"
,
1u
,
1u
)));
fn
a_million_letter_a
()
->
istr
{
let
i
=
0
;
let
rs
=
~
""
;
while
i
<
100000
{
rs
+=
~
"aaaaaaaaaa"
;
i
+=
1
;
}
ret
rs
;
}
fn
half_a_million_letter_a
()
->
istr
{
let
i
=
0
;
let
rs
=
~
""
;
while
i
<
100000
{
rs
+=
~
"aaaaa"
;
i
+=
1
;
}
ret
rs
;
}
assert
(
istr
::
eq
(
half_a_million_letter_a
(),
istr
::
slice
(
a_million_letter_a
(),
0u
,
500000u
)));
}
#[test]
fn
test_starts_with
()
{
assert
(
istr
::
starts_with
(
~
""
,
~
""
));
assert
(
istr
::
starts_with
(
~
"abc"
,
~
""
));
assert
(
istr
::
starts_with
(
~
"abc"
,
~
"a"
));
assert
(
!
istr
::
starts_with
(
~
"a"
,
~
"abc"
));
assert
(
!
istr
::
starts_with
(
~
""
,
~
"abc"
));
}
#[test]
fn
test_ends_with
()
{
assert
(
istr
::
ends_with
(
~
""
,
~
""
));
assert
(
istr
::
ends_with
(
~
"abc"
,
~
""
));
assert
(
istr
::
ends_with
(
~
"abc"
,
~
"c"
));
assert
(
!
istr
::
ends_with
(
~
"a"
,
~
"abc"
));
assert
(
!
istr
::
ends_with
(
~
""
,
~
"abc"
));
}
#[test]
fn
test_is_empty
()
{
assert
(
istr
::
is_empty
(
~
""
));
assert
(
!
istr
::
is_empty
(
~
"a"
));
}
#[test]
fn
test_is_not_empty
()
{
assert
(
istr
::
is_not_empty
(
~
"a"
));
assert
(
!
istr
::
is_not_empty
(
~
""
));
}
#[test]
fn
test_replace
()
{
let
a
=
~
"a"
;
check
(
istr
::
is_not_empty
(
a
));
assert
(
istr
::
replace
(
~
""
,
a
,
~
"b"
)
==
~
""
);
assert
(
istr
::
replace
(
~
"a"
,
a
,
~
"b"
)
==
~
"b"
);
assert
(
istr
::
replace
(
~
"ab"
,
a
,
~
"b"
)
==
~
"bb"
);
let
test
=
~
"test"
;
check
(
istr
::
is_not_empty
(
test
));
assert
(
istr
::
replace
(
~
" test test "
,
test
,
~
"toast"
)
==
~
" toast toast "
);
assert
(
istr
::
replace
(
~
" test test "
,
test
,
~
""
)
==
~
" "
);
}
#[test]
fn
test_char_slice
()
{
assert
(
istr
::
eq
(
~
"ab"
,
istr
::
char_slice
(
~
"abc"
,
0u
,
2u
)));
assert
(
istr
::
eq
(
~
"bc"
,
istr
::
char_slice
(
~
"abc"
,
1u
,
3u
)));
assert
(
istr
::
eq
(
~
""
,
istr
::
char_slice
(
~
"abc"
,
1u
,
1u
)));
assert
(
istr
::
eq
(
~
"
\u65e5
"
,
istr
::
char_slice
(
~
"
\u65e5\u672c
"
,
0u
,
1u
)));
}
#[test]
fn
trim_left
()
{
assert
(
istr
::
trim_left
(
~
""
)
==
~
""
);
assert
(
istr
::
trim_left
(
~
"a"
)
==
~
"a"
);
assert
(
istr
::
trim_left
(
~
" "
)
==
~
""
);
assert
(
istr
::
trim_left
(
~
" blah"
)
==
~
"blah"
);
assert
(
istr
::
trim_left
(
~
"
\u3000
wut"
)
==
~
"wut"
);
assert
(
istr
::
trim_left
(
~
"hey "
)
==
~
"hey "
);
}
#[test]
fn
trim_right
()
{
assert
(
istr
::
trim_right
(
~
""
)
==
~
""
);
assert
(
istr
::
trim_right
(
~
"a"
)
==
~
"a"
);
assert
(
istr
::
trim_right
(
~
" "
)
==
~
""
);
assert
(
istr
::
trim_right
(
~
"blah "
)
==
~
"blah"
);
assert
(
istr
::
trim_right
(
~
"wut
\u3000
"
)
==
~
"wut"
);
assert
(
istr
::
trim_right
(
~
" hey"
)
==
~
" hey"
);
}
#[test]
fn
trim
()
{
assert
(
istr
::
trim
(
~
""
)
==
~
""
);
assert
(
istr
::
trim
(
~
"a"
)
==
~
"a"
);
assert
(
istr
::
trim
(
~
" "
)
==
~
""
);
assert
(
istr
::
trim
(
~
" blah "
)
==
~
"blah"
);
assert
(
istr
::
trim
(
~
"
\n
wut
\u3000
"
)
==
~
"wut"
);
assert
(
istr
::
trim
(
~
" hey dude "
)
==
~
"hey dude"
);
}
#[test]
fn
is_whitespace
()
{
assert
(
istr
::
is_whitespace
(
~
""
));
assert
(
istr
::
is_whitespace
(
~
" "
));
assert
(
istr
::
is_whitespace
(
~
"
\u2009
"
));
// Thin space
assert
(
istr
::
is_whitespace
(
~
"
\n\t
"
));
assert
(
!
istr
::
is_whitespace
(
~
" _ "
));
}
#[test]
fn
is_ascii
()
{
assert
istr
::
is_ascii
(
~
""
);
assert
istr
::
is_ascii
(
~
"a"
);
assert
!
istr
::
is_ascii
(
~
"
\u2009
"
);
}
#[test]
fn
shift_byte
()
{
let
s
=
~
"ABC"
;
let
b
=
istr
::
shift_byte
(
s
);
assert
s
==
~
"BC"
;
assert
b
==
65u8
;
}
#[test]
fn
pop_byte
()
{
let
s
=
~
"ABC"
;
let
b
=
istr
::
pop_byte
(
s
);
assert
s
==
~
"AB"
;
assert
b
==
67u8
;
}
src/test/stdtest/stdtest.rc
浏览文件 @
663d07d3
...
...
@@ -25,6 +25,7 @@ mod sha1;
mod sort;
mod str_buf;
mod str;
mod istr;
mod task;
mod test;
mod uint;
...
...
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录