2021-03-16 08:29:14 +03:00
|
|
|
|
import strings
|
|
|
|
|
|
2021-01-18 15:20:06 +03:00
|
|
|
|
// Copyright (c) 2019-2021 Alexander Medvednikov. All rights reserved.
|
2019-06-23 05:21:30 +03:00
|
|
|
|
// Use of this source code is governed by an MIT license
|
|
|
|
|
// that can be found in the LICENSE file.
|
|
|
|
|
|
2020-03-26 19:03:14 +03:00
|
|
|
|
struct Foo {
|
|
|
|
|
bar int
|
|
|
|
|
mut:
|
|
|
|
|
str string
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-23 04:12:56 +03:00
|
|
|
|
fn test_add() {
|
|
|
|
|
mut a := 'a'
|
|
|
|
|
a += 'b'
|
2021-03-16 08:29:14 +03:00
|
|
|
|
assert a == ('ab')
|
2019-06-23 04:12:56 +03:00
|
|
|
|
a = 'a'
|
|
|
|
|
for i := 1; i < 1000; i++ {
|
|
|
|
|
a += 'b'
|
|
|
|
|
}
|
|
|
|
|
assert a.len == 1000
|
|
|
|
|
assert a.ends_with('bbbbb')
|
|
|
|
|
a += '123'
|
|
|
|
|
assert a.ends_with('3')
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn test_ends_with() {
|
|
|
|
|
a := 'browser.v'
|
|
|
|
|
assert a.ends_with('.v')
|
2020-05-15 20:37:14 +03:00
|
|
|
|
|
|
|
|
|
s := 'V Programming Language'
|
|
|
|
|
assert s.ends_with('guage') == true
|
|
|
|
|
assert s.ends_with('Language') == true
|
|
|
|
|
assert s.ends_with('Programming Language') == true
|
|
|
|
|
assert s.ends_with('V') == false
|
2019-06-23 04:12:56 +03:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn test_between() {
|
2021-03-16 08:29:14 +03:00
|
|
|
|
s := 'hello [man] how you doing'
|
2019-06-23 04:12:56 +03:00
|
|
|
|
assert s.find_between('[', ']') == 'man'
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn test_compare() {
|
|
|
|
|
a := 'Music'
|
|
|
|
|
b := 'src'
|
2021-04-12 16:01:03 +03:00
|
|
|
|
assert b >= a
|
2019-06-23 04:12:56 +03:00
|
|
|
|
}
|
|
|
|
|
|
2019-06-23 21:25:50 +03:00
|
|
|
|
fn test_lt() {
|
|
|
|
|
a := ''
|
|
|
|
|
b := 'a'
|
|
|
|
|
c := 'a'
|
|
|
|
|
d := 'b'
|
|
|
|
|
e := 'aa'
|
|
|
|
|
f := 'ab'
|
2021-04-12 16:01:03 +03:00
|
|
|
|
assert a < b
|
2019-08-26 13:32:53 +03:00
|
|
|
|
assert !(b < c)
|
2021-04-12 16:01:03 +03:00
|
|
|
|
assert c < d
|
2019-08-26 13:32:53 +03:00
|
|
|
|
assert !(d < e)
|
2021-04-12 16:01:03 +03:00
|
|
|
|
assert c < e
|
|
|
|
|
assert e < f
|
2019-06-23 21:25:50 +03:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn test_ge() {
|
|
|
|
|
a := 'aa'
|
|
|
|
|
b := 'aa'
|
|
|
|
|
c := 'ab'
|
|
|
|
|
d := 'abc'
|
|
|
|
|
e := 'aaa'
|
2021-04-12 16:01:03 +03:00
|
|
|
|
assert b >= a
|
|
|
|
|
assert c >= b
|
|
|
|
|
assert d >= c
|
2019-09-21 16:26:25 +03:00
|
|
|
|
assert !(c >= d)
|
2021-04-12 16:01:03 +03:00
|
|
|
|
assert e >= a
|
2019-06-23 21:25:50 +03:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn test_compare_strings() {
|
|
|
|
|
a := 'aa'
|
|
|
|
|
b := 'aa'
|
|
|
|
|
c := 'ab'
|
|
|
|
|
d := 'abc'
|
|
|
|
|
e := 'aaa'
|
|
|
|
|
assert compare_strings(a, b) == 0
|
|
|
|
|
assert compare_strings(b, c) == -1
|
|
|
|
|
assert compare_strings(c, d) == -1
|
|
|
|
|
assert compare_strings(d, e) == 1
|
|
|
|
|
assert compare_strings(a, e) == -1
|
|
|
|
|
assert compare_strings(e, a) == 1
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-23 04:12:56 +03:00
|
|
|
|
fn test_sort() {
|
|
|
|
|
mut vals := [
|
2021-03-16 08:29:14 +03:00
|
|
|
|
'arr',
|
|
|
|
|
'an',
|
|
|
|
|
'a',
|
|
|
|
|
'any',
|
2019-06-23 04:12:56 +03:00
|
|
|
|
]
|
|
|
|
|
len := vals.len
|
|
|
|
|
vals.sort()
|
|
|
|
|
assert len == vals.len
|
2019-06-23 21:25:50 +03:00
|
|
|
|
assert vals[0] == 'a'
|
|
|
|
|
assert vals[1] == 'an'
|
|
|
|
|
assert vals[2] == 'any'
|
|
|
|
|
assert vals[3] == 'arr'
|
2019-06-23 04:12:56 +03:00
|
|
|
|
}
|
|
|
|
|
|
2020-10-06 21:32:32 +03:00
|
|
|
|
fn test_sort_reverse() {
|
|
|
|
|
mut vals := [
|
2021-03-16 08:29:14 +03:00
|
|
|
|
'arr',
|
|
|
|
|
'an',
|
|
|
|
|
'a',
|
|
|
|
|
'any',
|
2020-10-06 21:32:32 +03:00
|
|
|
|
]
|
|
|
|
|
len := vals.len
|
2021-03-16 08:29:14 +03:00
|
|
|
|
vals.sort(b > a)
|
2020-10-06 21:32:32 +03:00
|
|
|
|
assert len == vals.len
|
2021-03-04 13:19:02 +03:00
|
|
|
|
assert vals[0] == 'a'
|
|
|
|
|
assert vals[1] == 'an'
|
|
|
|
|
assert vals[2] == 'any'
|
|
|
|
|
assert vals[3] == 'arr'
|
2020-10-06 21:32:32 +03:00
|
|
|
|
}
|
|
|
|
|
|
2019-12-01 16:10:13 +03:00
|
|
|
|
fn test_split_nth() {
|
2021-03-16 08:29:14 +03:00
|
|
|
|
a := '1,2,3'
|
|
|
|
|
assert a.split(',').len == 3
|
|
|
|
|
assert a.split_nth(',', -1).len == 3
|
|
|
|
|
assert a.split_nth(',', 0).len == 3
|
|
|
|
|
assert a.split_nth(',', 1).len == 1
|
|
|
|
|
assert a.split_nth(',', 2).len == 2
|
|
|
|
|
assert a.split_nth(',', 10).len == 3
|
|
|
|
|
b := '1::2::3'
|
|
|
|
|
assert b.split('::').len == 3
|
|
|
|
|
assert b.split_nth('::', -1).len == 3
|
|
|
|
|
assert b.split_nth('::', 0).len == 3
|
|
|
|
|
assert b.split_nth('::', 1).len == 1
|
|
|
|
|
assert b.split_nth('::', 2).len == 2
|
|
|
|
|
assert b.split_nth('::', 10).len == 3
|
|
|
|
|
c := 'ABCDEF'
|
2020-03-26 19:03:14 +03:00
|
|
|
|
println(c.split('').len)
|
2021-03-16 08:29:14 +03:00
|
|
|
|
assert c.split('').len == 6
|
|
|
|
|
assert c.split_nth('', 3).len == 3
|
|
|
|
|
assert c.split_nth('BC', -1).len == 2
|
|
|
|
|
d := ','
|
|
|
|
|
assert d.split(',').len == 2
|
|
|
|
|
assert d.split_nth('', 3).len == 1
|
|
|
|
|
assert d.split_nth(',', -1).len == 2
|
|
|
|
|
assert d.split_nth(',', 3).len == 2
|
|
|
|
|
e := ',,,0,,,,,a,,b,'
|
|
|
|
|
assert e.split(',,').len == 5
|
|
|
|
|
assert e.split_nth(',,', 3).len == 3
|
|
|
|
|
assert e.split_nth(',', -1).len == 12
|
|
|
|
|
assert e.split_nth(',', 3).len == 3
|
2019-12-01 16:10:13 +03:00
|
|
|
|
}
|
|
|
|
|
|
2020-01-24 22:12:36 +03:00
|
|
|
|
fn test_split_nth_values() {
|
|
|
|
|
line := 'CMD=eprintln(phase=1)'
|
2020-01-25 21:12:36 +03:00
|
|
|
|
|
2020-01-24 22:12:36 +03:00
|
|
|
|
a0 := line.split_nth('=', 0)
|
|
|
|
|
assert a0.len == 3
|
|
|
|
|
assert a0[0] == 'CMD'
|
|
|
|
|
assert a0[1] == 'eprintln(phase'
|
|
|
|
|
assert a0[2] == '1)'
|
|
|
|
|
|
|
|
|
|
a1 := line.split_nth('=', 1)
|
|
|
|
|
assert a1.len == 1
|
|
|
|
|
assert a1[0] == 'CMD=eprintln(phase=1)'
|
|
|
|
|
|
|
|
|
|
a2 := line.split_nth('=', 2)
|
|
|
|
|
assert a2.len == 2
|
|
|
|
|
assert a2[0] == 'CMD'
|
|
|
|
|
assert a2[1] == 'eprintln(phase=1)'
|
|
|
|
|
|
|
|
|
|
a3 := line.split_nth('=', 3)
|
|
|
|
|
assert a3.len == 3
|
|
|
|
|
assert a3[0] == 'CMD'
|
|
|
|
|
assert a3[1] == 'eprintln(phase'
|
|
|
|
|
assert a3[2] == '1)'
|
2020-01-25 21:12:36 +03:00
|
|
|
|
|
|
|
|
|
a4 := line.split_nth('=', 4)
|
|
|
|
|
assert a4.len == 3
|
|
|
|
|
assert a4[0] == 'CMD'
|
|
|
|
|
assert a4[1] == 'eprintln(phase'
|
|
|
|
|
assert a4[2] == '1)'
|
2020-01-24 22:12:36 +03:00
|
|
|
|
}
|
|
|
|
|
|
2019-06-23 04:12:56 +03:00
|
|
|
|
fn test_split() {
|
|
|
|
|
mut s := 'volt/twitch.v:34'
|
|
|
|
|
mut vals := s.split(':')
|
|
|
|
|
assert vals.len == 2
|
2019-08-26 13:32:53 +03:00
|
|
|
|
assert vals[0] == 'volt/twitch.v'
|
|
|
|
|
assert vals[1] == '34'
|
2019-11-28 16:49:35 +03:00
|
|
|
|
// /////////
|
2019-06-23 04:12:56 +03:00
|
|
|
|
s = '2018-01-01z13:01:02'
|
|
|
|
|
vals = s.split('z')
|
|
|
|
|
assert vals.len == 2
|
2021-03-16 08:29:14 +03:00
|
|
|
|
assert vals[0] == '2018-01-01'
|
2019-08-26 13:32:53 +03:00
|
|
|
|
assert vals[1] == '13:01:02'
|
|
|
|
|
// //////////
|
2019-06-23 04:12:56 +03:00
|
|
|
|
s = '4627a862c3dec29fb3182a06b8965e0025759e18___1530207969___blue'
|
|
|
|
|
vals = s.split('___')
|
|
|
|
|
assert vals.len == 3
|
2021-03-16 08:29:14 +03:00
|
|
|
|
assert vals[0] == '4627a862c3dec29fb3182a06b8965e0025759e18'
|
|
|
|
|
assert vals[1] == '1530207969'
|
|
|
|
|
assert vals[2] == 'blue'
|
2019-07-31 08:26:22 +03:00
|
|
|
|
// /////////
|
|
|
|
|
s = 'lalala'
|
2019-08-18 15:02:30 +03:00
|
|
|
|
vals = s.split('a')
|
2019-12-01 16:10:13 +03:00
|
|
|
|
assert vals.len == 4
|
2019-08-18 15:02:30 +03:00
|
|
|
|
assert vals[0] == 'l'
|
|
|
|
|
assert vals[1] == 'l'
|
|
|
|
|
assert vals[2] == 'l'
|
2019-12-01 16:10:13 +03:00
|
|
|
|
assert vals[3] == ''
|
2019-11-10 19:37:36 +03:00
|
|
|
|
// /////////
|
|
|
|
|
s = 'awesome'
|
|
|
|
|
a := s.split('')
|
|
|
|
|
assert a.len == 7
|
|
|
|
|
assert a[0] == 'a'
|
|
|
|
|
assert a[1] == 'w'
|
|
|
|
|
assert a[2] == 'e'
|
|
|
|
|
assert a[3] == 's'
|
|
|
|
|
assert a[4] == 'o'
|
|
|
|
|
assert a[5] == 'm'
|
|
|
|
|
assert a[6] == 'e'
|
2020-12-08 11:51:47 +03:00
|
|
|
|
// /////////
|
|
|
|
|
s = 'wavy turquoise bags'
|
|
|
|
|
vals = s.split(' bags')
|
|
|
|
|
assert vals.len == 2
|
|
|
|
|
assert vals[0] == 'wavy turquoise'
|
|
|
|
|
assert vals[1] == ''
|
2019-06-23 04:12:56 +03:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn test_trim_space() {
|
|
|
|
|
a := ' a '
|
|
|
|
|
assert a.trim_space() == 'a'
|
|
|
|
|
code := '
|
|
|
|
|
|
|
|
|
|
fn main() {
|
|
|
|
|
println(2)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
'
|
|
|
|
|
code_clean := 'fn main() {
|
|
|
|
|
println(2)
|
|
|
|
|
}'
|
|
|
|
|
assert code.trim_space() == code_clean
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn test_join() {
|
2021-03-16 08:29:14 +03:00
|
|
|
|
mut strings := ['a', 'b', 'c']
|
2019-06-23 04:12:56 +03:00
|
|
|
|
mut s := strings.join(' ')
|
|
|
|
|
assert s == 'a b c'
|
2021-03-16 08:29:14 +03:00
|
|
|
|
strings = [
|
|
|
|
|
'one
|
2019-06-23 04:12:56 +03:00
|
|
|
|
two ',
|
2021-03-16 08:29:14 +03:00
|
|
|
|
'three!
|
|
|
|
|
four!',
|
|
|
|
|
]
|
2019-06-23 04:12:56 +03:00
|
|
|
|
s = strings.join(' ')
|
|
|
|
|
assert s.contains('one') && s.contains('two ') && s.contains('four')
|
2021-03-16 08:29:14 +03:00
|
|
|
|
empty := []string{len: 0}
|
2020-10-18 01:48:06 +03:00
|
|
|
|
assert empty.join('A') == ''
|
2019-06-23 04:12:56 +03:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn test_clone() {
|
|
|
|
|
mut a := 'a'
|
|
|
|
|
a += 'a'
|
|
|
|
|
a += 'a'
|
2019-07-25 15:06:26 +03:00
|
|
|
|
b := a
|
2019-07-25 15:13:35 +03:00
|
|
|
|
c := a.clone()
|
2019-06-23 04:12:56 +03:00
|
|
|
|
assert c == a
|
|
|
|
|
assert c == 'aaa'
|
|
|
|
|
assert b == 'aaa'
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn test_replace() {
|
|
|
|
|
a := 'hello man!'
|
|
|
|
|
mut b := a.replace('man', 'world')
|
2021-03-16 08:29:14 +03:00
|
|
|
|
assert b == ('hello world!')
|
2019-06-23 04:12:56 +03:00
|
|
|
|
b = b.replace('!', '')
|
2021-03-16 08:29:14 +03:00
|
|
|
|
assert b == ('hello world')
|
2019-06-23 04:12:56 +03:00
|
|
|
|
b = b.replace('h', 'H')
|
2021-03-16 08:29:14 +03:00
|
|
|
|
assert b == ('Hello world')
|
2019-07-10 10:48:10 +03:00
|
|
|
|
b = b.replace('foo', 'bar')
|
2021-03-16 08:29:14 +03:00
|
|
|
|
assert b == ('Hello world')
|
2019-06-23 04:12:56 +03:00
|
|
|
|
s := 'hey man how are you'
|
|
|
|
|
assert s.replace('man ', '') == 'hey how are you'
|
|
|
|
|
lol := 'lol lol lol'
|
2019-07-10 10:48:10 +03:00
|
|
|
|
assert lol.replace('lol', 'LOL') == 'LOL LOL LOL'
|
2019-06-23 04:12:56 +03:00
|
|
|
|
b = 'oneBtwoBBthree'
|
|
|
|
|
assert b.replace('B', '') == 'onetwothree'
|
2019-12-01 10:33:26 +03:00
|
|
|
|
b = '*charptr'
|
|
|
|
|
assert b.replace('charptr', 'byteptr') == '*byteptr'
|
2021-03-16 08:29:14 +03:00
|
|
|
|
c := 'abc'
|
|
|
|
|
assert c.replace('', '-') == c
|
|
|
|
|
v := 'a b c d'
|
|
|
|
|
assert v.replace(' ', ' ') == 'a b c d'
|
2019-06-23 04:12:56 +03:00
|
|
|
|
}
|
|
|
|
|
|
2019-12-10 14:32:12 +03:00
|
|
|
|
fn test_replace_each() {
|
|
|
|
|
s := 'hello man man :)'
|
|
|
|
|
q := s.replace_each([
|
2021-03-16 08:29:14 +03:00
|
|
|
|
'man',
|
|
|
|
|
'dude',
|
|
|
|
|
'hello',
|
|
|
|
|
'hey',
|
2019-12-10 14:32:12 +03:00
|
|
|
|
])
|
|
|
|
|
assert q == 'hey dude dude :)'
|
|
|
|
|
bb := '[b]bold[/b] [code]code[/code]'
|
|
|
|
|
assert bb.replace_each([
|
2021-03-16 08:29:14 +03:00
|
|
|
|
'[b]',
|
|
|
|
|
'<b>',
|
|
|
|
|
'[/b]',
|
|
|
|
|
'</b>',
|
|
|
|
|
'[code]',
|
|
|
|
|
'<code>',
|
|
|
|
|
'[/code]',
|
|
|
|
|
'</code>',
|
2019-12-10 14:32:12 +03:00
|
|
|
|
]) == '<b>bold</b> <code>code</code>'
|
2019-12-11 03:20:30 +03:00
|
|
|
|
bb2 := '[b]cool[/b]'
|
|
|
|
|
assert bb2.replace_each([
|
2021-03-16 08:29:14 +03:00
|
|
|
|
'[b]',
|
|
|
|
|
'<b>',
|
|
|
|
|
'[/b]',
|
|
|
|
|
'</b>',
|
2019-12-11 03:20:30 +03:00
|
|
|
|
]) == '<b>cool</b>'
|
2020-09-12 03:31:06 +03:00
|
|
|
|
t := 'aaaaaaaa'
|
|
|
|
|
y := t.replace_each([
|
2021-03-16 08:29:14 +03:00
|
|
|
|
'aa',
|
|
|
|
|
'b',
|
2020-09-12 03:31:06 +03:00
|
|
|
|
])
|
|
|
|
|
assert y == 'bbbb'
|
2021-03-22 11:46:45 +03:00
|
|
|
|
s2 := 'hello_world hello'
|
|
|
|
|
assert s2.replace_each(['hello_world', 'aaa', 'hello', 'bbb']) == 'aaa bbb'
|
2019-12-10 14:32:12 +03:00
|
|
|
|
}
|
|
|
|
|
|
2019-06-23 04:12:56 +03:00
|
|
|
|
fn test_itoa() {
|
|
|
|
|
num := 777
|
|
|
|
|
assert num.str() == '777'
|
|
|
|
|
big := 7779998
|
|
|
|
|
assert big.str() == '7779998'
|
|
|
|
|
a := 3
|
|
|
|
|
assert a.str() == '3'
|
|
|
|
|
b := 5555
|
|
|
|
|
assert b.str() == '5555'
|
|
|
|
|
zero := 0
|
|
|
|
|
assert zero.str() == '0'
|
|
|
|
|
neg := -7
|
|
|
|
|
assert neg.str() == '-7'
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn test_reassign() {
|
|
|
|
|
a := 'hi'
|
|
|
|
|
mut b := a
|
|
|
|
|
b += '!'
|
|
|
|
|
assert a == 'hi'
|
|
|
|
|
assert b == 'hi!'
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn test_runes() {
|
|
|
|
|
s := 'привет'
|
|
|
|
|
assert s.len == 12
|
|
|
|
|
s2 := 'privet'
|
|
|
|
|
assert s2.len == 6
|
2021-07-03 20:14:09 +03:00
|
|
|
|
u := s.runes()
|
2019-06-23 04:12:56 +03:00
|
|
|
|
assert u.len == 6
|
|
|
|
|
assert s2.substr(1, 4).len == 3
|
|
|
|
|
assert s2.substr(1, 4) == 'riv'
|
2019-10-27 01:37:29 +03:00
|
|
|
|
assert s2[1..4].len == 3
|
|
|
|
|
assert s2[1..4] == 'riv'
|
2019-10-27 09:36:04 +03:00
|
|
|
|
assert s2[..4].len == 4
|
|
|
|
|
assert s2[..4] == 'priv'
|
|
|
|
|
assert s2[2..].len == 4
|
|
|
|
|
assert s2[2..] == 'ivet'
|
2021-07-03 20:14:09 +03:00
|
|
|
|
assert u[1..4].string().len == 6
|
|
|
|
|
assert u[1..4].string() == 'рив'
|
2019-06-23 04:12:56 +03:00
|
|
|
|
assert s2.substr(1, 2) == 'r'
|
2021-07-03 20:14:09 +03:00
|
|
|
|
assert u[1..2].string() == 'р'
|
|
|
|
|
assert s2.runes()[1] == `r`
|
|
|
|
|
assert u[1] == `р`
|
|
|
|
|
first := u[0]
|
|
|
|
|
last := u[u.len - 1]
|
|
|
|
|
assert first.str().len == 2
|
|
|
|
|
assert last.str().len == 2
|
2019-06-23 04:12:56 +03:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn test_contains() {
|
|
|
|
|
s := 'view.v'
|
|
|
|
|
assert s.contains('vi')
|
|
|
|
|
assert !s.contains('random')
|
2020-06-14 12:24:15 +03:00
|
|
|
|
assert ''.contains('')
|
|
|
|
|
assert 'abc'.contains('')
|
2019-06-23 04:12:56 +03:00
|
|
|
|
}
|
|
|
|
|
|
2020-07-29 22:48:50 +03:00
|
|
|
|
fn test_contains_any() {
|
|
|
|
|
assert !'team'.contains_any('i')
|
|
|
|
|
assert 'fail'.contains_any('ui')
|
|
|
|
|
assert 'ure'.contains_any('ui')
|
|
|
|
|
assert 'failure'.contains_any('ui')
|
|
|
|
|
assert !'foo'.contains_any('')
|
|
|
|
|
assert !''.contains_any('')
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn test_contains_any_substr() {
|
|
|
|
|
s := 'Some random text'
|
|
|
|
|
assert s.contains_any_substr(['false', 'not', 'rand'])
|
|
|
|
|
assert !s.contains_any_substr(['ABC', 'invalid'])
|
|
|
|
|
assert ''.contains_any_substr([])
|
|
|
|
|
assert 'abc'.contains_any_substr([''])
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-23 04:12:56 +03:00
|
|
|
|
fn test_arr_contains() {
|
|
|
|
|
a := ['a', 'b', 'c']
|
|
|
|
|
assert a.contains('b')
|
|
|
|
|
ints := [1, 2, 3]
|
|
|
|
|
assert ints.contains(2)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn test_to_num() {
|
|
|
|
|
s := '7'
|
2019-06-25 15:56:34 +03:00
|
|
|
|
assert s.int() == 7
|
2021-09-28 10:08:10 +03:00
|
|
|
|
assert s.byte() == 7
|
2019-10-15 04:26:19 +03:00
|
|
|
|
assert s.u64() == 7
|
2019-06-23 04:12:56 +03:00
|
|
|
|
f := '71.5 hasdf'
|
2020-04-02 11:15:35 +03:00
|
|
|
|
// QTODO
|
2020-04-22 10:35:14 +03:00
|
|
|
|
assert f.f32() == 71.5
|
2019-06-23 04:12:56 +03:00
|
|
|
|
vals := ['9']
|
2019-06-25 15:56:34 +03:00
|
|
|
|
assert vals[0].int() == 9
|
2019-10-15 04:26:19 +03:00
|
|
|
|
big := '93993993939322'
|
|
|
|
|
assert big.u64() == 93993993939322
|
|
|
|
|
assert big.i64() == 93993993939322
|
2019-06-23 04:12:56 +03:00
|
|
|
|
}
|
|
|
|
|
|
2020-04-11 18:25:39 +03:00
|
|
|
|
fn test_inter_format_string() {
|
|
|
|
|
float_num := 1.52345
|
2021-03-16 08:29:14 +03:00
|
|
|
|
float_num_string := '-${float_num:.3f}-'
|
2020-04-11 18:25:39 +03:00
|
|
|
|
assert float_num_string == '-1.523-'
|
|
|
|
|
int_num := 7
|
|
|
|
|
int_num_string := '-${int_num:03d}-'
|
|
|
|
|
assert int_num_string == '-007-'
|
|
|
|
|
ch := `a`
|
|
|
|
|
ch_string := '-${ch:c}-'
|
|
|
|
|
assert ch_string == '-a-'
|
|
|
|
|
hex_n := 192
|
|
|
|
|
hex_n_string := '-${hex_n:x}-'
|
|
|
|
|
assert hex_n_string == '-c0-'
|
|
|
|
|
oct_n := 192
|
|
|
|
|
oct_n_string := '-${oct_n:o}-'
|
|
|
|
|
assert oct_n_string == '-300-'
|
|
|
|
|
str := 'abc'
|
|
|
|
|
str_string := '-${str:s}-'
|
|
|
|
|
assert str_string == '-abc-'
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-23 04:12:56 +03:00
|
|
|
|
fn test_hash() {
|
|
|
|
|
s := '10000'
|
|
|
|
|
assert s.hash() == 46730161
|
|
|
|
|
s2 := '24640'
|
|
|
|
|
assert s2.hash() == 47778736
|
|
|
|
|
s3 := 'Content-Type'
|
|
|
|
|
assert s3.hash() == 949037134
|
|
|
|
|
s4 := 'bad_key'
|
|
|
|
|
assert s4.hash() == -346636507
|
|
|
|
|
s5 := '24640'
|
|
|
|
|
// From a map collision test
|
2021-03-16 08:29:14 +03:00
|
|
|
|
assert s5.hash() % ((1 << 20) - 1) == s.hash() % ((1 << 20) - 1)
|
|
|
|
|
assert s5.hash() % ((1 << 20) - 1) == 592861
|
2019-06-23 04:12:56 +03:00
|
|
|
|
}
|
|
|
|
|
|
2019-08-27 07:53:56 +03:00
|
|
|
|
fn test_trim() {
|
|
|
|
|
assert 'banana'.trim('bna') == ''
|
|
|
|
|
assert 'abc'.trim('ac') == 'b'
|
|
|
|
|
assert 'aaabccc'.trim('ac') == 'b'
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-23 04:12:56 +03:00
|
|
|
|
fn test_trim_left() {
|
|
|
|
|
mut s := 'module main'
|
|
|
|
|
assert s.trim_left(' ') == 'module main'
|
|
|
|
|
s = ' module main'
|
|
|
|
|
assert s.trim_left(' ') == 'module main'
|
2019-08-26 14:18:58 +03:00
|
|
|
|
// test cutset
|
|
|
|
|
s = 'banana'
|
|
|
|
|
assert s.trim_left('ba') == 'nana'
|
2020-04-06 15:30:25 +03:00
|
|
|
|
assert s.trim_left('ban') == ''
|
2019-06-23 04:12:56 +03:00
|
|
|
|
}
|
|
|
|
|
|
2019-08-17 20:07:40 +03:00
|
|
|
|
fn test_trim_right() {
|
|
|
|
|
mut s := 'module main'
|
|
|
|
|
assert s.trim_right(' ') == 'module main'
|
|
|
|
|
s = 'module main '
|
|
|
|
|
assert s.trim_right(' ') == 'module main'
|
2019-08-26 14:18:58 +03:00
|
|
|
|
// test cutset
|
|
|
|
|
s = 'banana'
|
|
|
|
|
assert s.trim_right('na') == 'b'
|
2020-04-06 15:30:25 +03:00
|
|
|
|
assert s.trim_right('ban') == ''
|
2019-08-17 20:07:40 +03:00
|
|
|
|
}
|
|
|
|
|
|
2020-02-20 22:14:21 +03:00
|
|
|
|
fn test_all_before() {
|
|
|
|
|
s := 'fn hello fn'
|
|
|
|
|
assert s.all_before(' ') == 'fn'
|
|
|
|
|
assert s.all_before('2') == s
|
|
|
|
|
assert s.all_before('') == s
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn test_all_before_last() {
|
|
|
|
|
s := 'fn hello fn'
|
|
|
|
|
assert s.all_before_last(' ') == 'fn hello'
|
|
|
|
|
assert s.all_before_last('2') == s
|
|
|
|
|
assert s.all_before_last('') == s
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-23 04:12:56 +03:00
|
|
|
|
fn test_all_after() {
|
|
|
|
|
s := 'fn hello'
|
2020-02-20 22:14:21 +03:00
|
|
|
|
assert s.all_after('fn ') == 'hello'
|
|
|
|
|
assert s.all_after('test') == s
|
|
|
|
|
assert s.all_after('') == s
|
2020-05-18 06:10:56 +03:00
|
|
|
|
assert s.after('e') == 'llo'
|
|
|
|
|
x := s.after('e')
|
|
|
|
|
assert x == 'llo'
|
2019-06-26 20:03:35 +03:00
|
|
|
|
}
|
2019-06-25 15:56:34 +03:00
|
|
|
|
|
2019-07-07 18:43:34 +03:00
|
|
|
|
fn test_reverse() {
|
2020-02-20 22:14:21 +03:00
|
|
|
|
assert 'hello'.reverse() == 'olleh'
|
|
|
|
|
assert ''.reverse() == ''
|
|
|
|
|
assert 'a'.reverse() == 'a'
|
2019-07-07 18:43:34 +03:00
|
|
|
|
}
|
2019-07-16 18:59:07 +03:00
|
|
|
|
|
2019-07-18 05:42:00 +03:00
|
|
|
|
fn test_bytes_to_string() {
|
2020-03-04 19:39:27 +03:00
|
|
|
|
mut buf := vcalloc(10)
|
2020-07-22 21:42:51 +03:00
|
|
|
|
unsafe {
|
|
|
|
|
buf[0] = `h`
|
|
|
|
|
buf[1] = `e`
|
|
|
|
|
buf[2] = `l`
|
|
|
|
|
buf[3] = `l`
|
|
|
|
|
buf[4] = `o`
|
2020-07-29 22:48:50 +03:00
|
|
|
|
}
|
2020-08-10 19:05:26 +03:00
|
|
|
|
assert unsafe { buf.vstring() } == 'hello'
|
|
|
|
|
assert unsafe { buf.vstring_with_len(2) } == 'he'
|
2020-08-27 07:46:18 +03:00
|
|
|
|
bytes := [byte(`h`), `e`, `l`, `l`, `o`]
|
2020-08-10 19:05:26 +03:00
|
|
|
|
assert bytes.bytestr() == 'hello'
|
2019-08-18 15:02:30 +03:00
|
|
|
|
}
|
2020-11-14 20:43:42 +03:00
|
|
|
|
|
|
|
|
|
fn test_charptr() {
|
2021-04-04 17:43:32 +03:00
|
|
|
|
foo := &char('VLANG'.str)
|
2021-01-07 22:32:02 +03:00
|
|
|
|
println(typeof(foo).name)
|
2021-04-04 17:43:32 +03:00
|
|
|
|
assert typeof(foo).name == '&char'
|
2020-11-14 20:43:42 +03:00
|
|
|
|
assert unsafe { foo.vstring() } == 'VLANG'
|
|
|
|
|
assert unsafe { foo.vstring_with_len(3) } == 'VLA'
|
|
|
|
|
}
|
2019-08-03 23:24:03 +03:00
|
|
|
|
|
|
|
|
|
fn test_count() {
|
|
|
|
|
assert ''.count('') == 0
|
|
|
|
|
assert ''.count('a') == 0
|
|
|
|
|
assert 'a'.count('') == 0
|
|
|
|
|
assert 'aa'.count('a') == 2
|
|
|
|
|
assert 'aa'.count('aa') == 1
|
|
|
|
|
assert 'aabbaa'.count('aa') == 2
|
|
|
|
|
assert 'bbaabb'.count('aa') == 1
|
|
|
|
|
}
|
2019-08-26 13:32:53 +03:00
|
|
|
|
|
2020-04-12 13:09:05 +03:00
|
|
|
|
fn test_lower() {
|
|
|
|
|
mut s := 'A'
|
|
|
|
|
assert !s.is_lower()
|
|
|
|
|
assert s.to_lower() == 'a'
|
|
|
|
|
assert s.to_lower().len == 1
|
|
|
|
|
s = 'HELLO'
|
|
|
|
|
assert !s.is_lower()
|
|
|
|
|
assert s.to_lower() == 'hello'
|
|
|
|
|
assert s.to_lower().len == 5
|
|
|
|
|
s = 'Aloha'
|
|
|
|
|
assert !s.is_lower()
|
|
|
|
|
assert s.to_lower() == 'aloha'
|
|
|
|
|
s = 'Have A nice Day!'
|
|
|
|
|
assert !s.is_lower()
|
|
|
|
|
assert s.to_lower() == 'have a nice day!'
|
|
|
|
|
s = 'hi'
|
|
|
|
|
assert s.is_lower()
|
|
|
|
|
assert s.to_lower() == 'hi'
|
|
|
|
|
assert 'aloha!'[0] == `a`
|
|
|
|
|
assert 'aloha!'[5] == `!`
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn test_upper() {
|
|
|
|
|
mut s := 'a'
|
|
|
|
|
assert !s.is_upper()
|
|
|
|
|
assert s.to_upper() == 'A'
|
|
|
|
|
assert s.to_upper().len == 1
|
|
|
|
|
s = 'hello'
|
|
|
|
|
assert !s.is_upper()
|
|
|
|
|
assert s.to_upper() == 'HELLO'
|
|
|
|
|
assert s.to_upper().len == 5
|
|
|
|
|
s = 'Aloha'
|
|
|
|
|
assert !s.is_upper()
|
|
|
|
|
assert s.to_upper() == 'ALOHA'
|
|
|
|
|
s = 'have a nice day!'
|
|
|
|
|
assert !s.is_upper()
|
|
|
|
|
assert s.to_upper() == 'HAVE A NICE DAY!'
|
|
|
|
|
s = 'HI'
|
|
|
|
|
assert s.is_upper()
|
|
|
|
|
assert s.to_upper() == 'HI'
|
|
|
|
|
}
|
|
|
|
|
|
2019-08-26 13:32:53 +03:00
|
|
|
|
fn test_capitalize() {
|
|
|
|
|
mut s := 'hello'
|
2020-04-12 13:09:05 +03:00
|
|
|
|
assert !s.is_capital()
|
2019-08-26 13:32:53 +03:00
|
|
|
|
assert s.capitalize() == 'Hello'
|
|
|
|
|
s = 'test'
|
2020-04-12 13:09:05 +03:00
|
|
|
|
assert !s.is_capital()
|
2019-08-26 13:32:53 +03:00
|
|
|
|
assert s.capitalize() == 'Test'
|
2021-03-16 08:29:14 +03:00
|
|
|
|
s = 'i am ray'
|
2020-04-12 13:09:05 +03:00
|
|
|
|
assert !s.is_capital()
|
2019-08-26 13:32:53 +03:00
|
|
|
|
assert s.capitalize() == 'I am ray'
|
2020-02-20 13:33:38 +03:00
|
|
|
|
s = ''
|
2020-04-12 13:09:05 +03:00
|
|
|
|
assert !s.is_capital()
|
2020-02-20 13:33:38 +03:00
|
|
|
|
assert s.capitalize() == ''
|
2020-04-12 13:09:05 +03:00
|
|
|
|
s = 'TEST IT'
|
|
|
|
|
assert !s.is_capital()
|
2020-08-09 04:57:54 +03:00
|
|
|
|
assert s.capitalize() == 'TEST IT'
|
2020-04-12 13:09:05 +03:00
|
|
|
|
s = 'Test it'
|
|
|
|
|
assert s.is_capital()
|
|
|
|
|
assert s.capitalize() == 'Test it'
|
2020-08-09 04:57:54 +03:00
|
|
|
|
assert 'GameMission_t'.capitalize() == 'GameMission_t'
|
2019-08-26 13:32:53 +03:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn test_title() {
|
2020-04-12 13:09:05 +03:00
|
|
|
|
mut s := 'hello world'
|
|
|
|
|
assert !s.is_title()
|
2019-08-26 13:32:53 +03:00
|
|
|
|
assert s.title() == 'Hello World'
|
2020-04-12 13:09:05 +03:00
|
|
|
|
s = 'HELLO WORLD'
|
|
|
|
|
assert !s.is_title()
|
2020-08-09 05:09:48 +03:00
|
|
|
|
assert s.title() == 'HELLO WORLD'
|
2020-04-12 13:09:05 +03:00
|
|
|
|
s = 'Hello World'
|
|
|
|
|
assert s.is_title()
|
2019-09-21 16:26:25 +03:00
|
|
|
|
assert s.title() == 'Hello World'
|
|
|
|
|
}
|
2019-08-29 19:46:03 +03:00
|
|
|
|
|
|
|
|
|
fn test_for_loop() {
|
|
|
|
|
mut i := 0
|
|
|
|
|
s := 'abcd'
|
|
|
|
|
|
|
|
|
|
for c in s {
|
|
|
|
|
assert c == s[i]
|
|
|
|
|
i++
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn test_for_loop_two() {
|
|
|
|
|
s := 'abcd'
|
|
|
|
|
|
|
|
|
|
for i, c in s {
|
|
|
|
|
assert c == s[i]
|
|
|
|
|
}
|
2019-09-02 15:02:25 +03:00
|
|
|
|
}
|
2019-09-11 15:21:20 +03:00
|
|
|
|
|
|
|
|
|
fn test_quote() {
|
2021-08-06 06:21:28 +03:00
|
|
|
|
a := `'`
|
2021-03-16 08:29:14 +03:00
|
|
|
|
println('testing double quotes')
|
|
|
|
|
b := 'hi'
|
2019-09-21 16:26:25 +03:00
|
|
|
|
assert b == 'hi'
|
2021-03-16 08:29:14 +03:00
|
|
|
|
assert a.str() == "'"
|
2019-09-11 15:21:20 +03:00
|
|
|
|
}
|
2019-09-20 19:07:38 +03:00
|
|
|
|
|
2020-02-20 22:14:21 +03:00
|
|
|
|
fn test_limit() {
|
|
|
|
|
s := 'hello'
|
|
|
|
|
assert s.limit(2) == 'he'
|
|
|
|
|
assert s.limit(9) == s
|
|
|
|
|
assert s.limit(0) == ''
|
|
|
|
|
// assert s.limit(-1) == ''
|
|
|
|
|
}
|
|
|
|
|
|
2019-09-26 22:54:53 +03:00
|
|
|
|
fn test_repeat() {
|
2020-02-29 17:25:31 +03:00
|
|
|
|
s1 := 'V! '
|
|
|
|
|
assert s1.repeat(5) == 'V! V! V! V! V! '
|
|
|
|
|
assert s1.repeat(1) == s1
|
|
|
|
|
assert s1.repeat(0) == ''
|
|
|
|
|
s2 := ''
|
|
|
|
|
assert s2.repeat(5) == s2
|
|
|
|
|
assert s2.repeat(1) == s2
|
|
|
|
|
assert s2.repeat(0) == s2
|
|
|
|
|
// TODO Add test for negative values
|
2019-09-26 22:54:53 +03:00
|
|
|
|
}
|
2019-10-06 03:56:08 +03:00
|
|
|
|
|
2020-05-15 20:37:14 +03:00
|
|
|
|
fn test_starts_with() {
|
|
|
|
|
s := 'V Programming Language'
|
|
|
|
|
assert s.starts_with('V') == true
|
|
|
|
|
assert s.starts_with('V Programming') == true
|
|
|
|
|
assert s.starts_with('Language') == false
|
|
|
|
|
}
|
|
|
|
|
|
2021-11-07 14:30:40 +03:00
|
|
|
|
fn test_starts_with_capital() {
|
|
|
|
|
assert 'A sentence'.starts_with_capital()
|
|
|
|
|
assert 'A paragraph. It also does.'.starts_with_capital()
|
|
|
|
|
assert ''.starts_with_capital() == false
|
|
|
|
|
assert 'no'.starts_with_capital() == false
|
|
|
|
|
assert ' No'.starts_with_capital() == false
|
|
|
|
|
}
|
|
|
|
|
|
2020-05-15 20:37:14 +03:00
|
|
|
|
fn test_trim_prefix() {
|
|
|
|
|
s := 'V Programming Language'
|
|
|
|
|
assert s.trim_prefix('V ') == 'Programming Language'
|
|
|
|
|
assert s.trim_prefix('V Programming ') == 'Language'
|
|
|
|
|
assert s.trim_prefix('Language') == s
|
2020-06-30 16:44:53 +03:00
|
|
|
|
|
|
|
|
|
s2 := 'TestTestTest'
|
|
|
|
|
assert s2.trim_prefix('Test') == 'TestTest'
|
|
|
|
|
assert s2.trim_prefix('TestTest') == 'Test'
|
|
|
|
|
|
|
|
|
|
s3 := '123Test123Test'
|
|
|
|
|
assert s3.trim_prefix('123') == 'Test123Test'
|
|
|
|
|
assert s3.trim_prefix('123Test') == '123Test'
|
2020-05-15 20:37:14 +03:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn test_trim_suffix() {
|
|
|
|
|
s := 'V Programming Language'
|
|
|
|
|
assert s.trim_suffix(' Language') == 'V Programming'
|
|
|
|
|
assert s.trim_suffix(' Programming Language') == 'V'
|
|
|
|
|
assert s.trim_suffix('V') == s
|
2020-06-30 16:44:53 +03:00
|
|
|
|
|
|
|
|
|
s2 := 'TestTestTest'
|
|
|
|
|
assert s2.trim_suffix('Test') == 'TestTest'
|
|
|
|
|
assert s2.trim_suffix('TestTest') == 'Test'
|
|
|
|
|
|
|
|
|
|
s3 := '123Test123Test'
|
|
|
|
|
assert s3.trim_suffix('123') == s3
|
|
|
|
|
assert s3.trim_suffix('123Test') == '123Test'
|
2020-05-15 20:37:14 +03:00
|
|
|
|
}
|
|
|
|
|
|
2019-10-06 03:56:08 +03:00
|
|
|
|
fn test_raw() {
|
|
|
|
|
raw := r'raw\nstring'
|
|
|
|
|
lines := raw.split('\n')
|
2020-04-02 11:15:35 +03:00
|
|
|
|
println(lines)
|
2019-10-06 03:56:08 +03:00
|
|
|
|
assert lines.len == 1
|
|
|
|
|
println('raw string: "$raw"')
|
2020-09-19 19:09:18 +03:00
|
|
|
|
|
|
|
|
|
raw2 := r'Hello V\0'
|
|
|
|
|
assert raw2[7] == `\\`
|
|
|
|
|
assert raw2[8] == `0`
|
2020-09-21 17:34:24 +03:00
|
|
|
|
|
|
|
|
|
raw3 := r'Hello V\x00'
|
|
|
|
|
assert raw3[7] == `\\`
|
|
|
|
|
assert raw3[8] == `x`
|
|
|
|
|
assert raw3[9] == `0`
|
2020-09-25 13:02:32 +03:00
|
|
|
|
assert raw3[10] == `0`
|
2019-11-28 16:49:35 +03:00
|
|
|
|
}
|
2019-10-07 01:09:11 +03:00
|
|
|
|
|
2020-02-09 18:29:05 +03:00
|
|
|
|
fn test_raw_with_quotes() {
|
|
|
|
|
raw := r"some'" + r'"thing' // " should be escaped in the generated C code
|
|
|
|
|
assert raw[0] == `s`
|
|
|
|
|
assert raw[5] == `"`
|
|
|
|
|
assert raw[6] == `t`
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-07 01:09:11 +03:00
|
|
|
|
fn test_escape() {
|
2020-10-27 17:25:44 +03:00
|
|
|
|
a := 10
|
2021-04-20 20:18:53 +03:00
|
|
|
|
println("\"$a")
|
|
|
|
|
assert "\"$a" == '"10'
|
2019-11-28 16:49:35 +03:00
|
|
|
|
}
|
2019-10-15 04:26:19 +03:00
|
|
|
|
|
2019-10-25 23:41:18 +03:00
|
|
|
|
fn test_atoi() {
|
|
|
|
|
assert '234232'.int() == 234232
|
|
|
|
|
assert '-9009'.int() == -9009
|
|
|
|
|
assert '0'.int() == 0
|
|
|
|
|
for n in -10000 .. 100000 {
|
|
|
|
|
s := n.str()
|
|
|
|
|
assert s.int() == n
|
2019-11-28 16:49:35 +03:00
|
|
|
|
}
|
|
|
|
|
}
|
2019-10-25 23:41:18 +03:00
|
|
|
|
|
2019-11-03 23:57:26 +03:00
|
|
|
|
fn test_raw_inter() {
|
|
|
|
|
world := 'world'
|
2019-11-06 06:57:04 +03:00
|
|
|
|
println(world)
|
2019-11-03 23:57:26 +03:00
|
|
|
|
s := r'hello\n$world'
|
|
|
|
|
assert s == r'hello\n$world'
|
|
|
|
|
assert s.contains('$')
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-16 22:16:58 +03:00
|
|
|
|
fn test_c_r() {
|
|
|
|
|
// This used to break because of r'' and c''
|
|
|
|
|
c := 42
|
|
|
|
|
println('$c')
|
|
|
|
|
r := 50
|
|
|
|
|
println('$r')
|
2019-12-03 13:08:57 +03:00
|
|
|
|
}
|
2019-11-28 16:49:35 +03:00
|
|
|
|
|
2019-12-03 13:08:57 +03:00
|
|
|
|
fn test_inter_before_comp_if() {
|
|
|
|
|
s := '123'
|
|
|
|
|
// This used to break ('123 $....')
|
|
|
|
|
$if linux {
|
|
|
|
|
println(s)
|
|
|
|
|
}
|
2019-12-12 13:51:05 +03:00
|
|
|
|
assert s == '123'
|
2019-11-28 16:49:35 +03:00
|
|
|
|
}
|
2019-11-16 22:16:58 +03:00
|
|
|
|
|
2019-12-08 20:06:00 +03:00
|
|
|
|
fn test_double_quote_inter() {
|
|
|
|
|
a := 1
|
|
|
|
|
b := 2
|
2021-03-16 08:29:14 +03:00
|
|
|
|
println('$a $b')
|
|
|
|
|
assert '$a $b' == '1 2'
|
|
|
|
|
assert '$a $b' == '1 2'
|
2019-12-08 20:06:00 +03:00
|
|
|
|
}
|
|
|
|
|
|
2020-06-17 13:26:55 +03:00
|
|
|
|
fn foo(b byte) byte {
|
2020-06-17 15:29:44 +03:00
|
|
|
|
return b - 10
|
2020-06-17 13:26:55 +03:00
|
|
|
|
}
|
|
|
|
|
|
2020-07-12 21:07:28 +03:00
|
|
|
|
fn filter(b byte) bool {
|
|
|
|
|
return b != `a`
|
|
|
|
|
}
|
|
|
|
|
|
2020-02-09 11:23:57 +03:00
|
|
|
|
fn test_split_into_lines() {
|
|
|
|
|
line_content := 'Line'
|
2021-03-16 08:29:14 +03:00
|
|
|
|
text_crlf := '$line_content\r\n$line_content\r\n$line_content'
|
2020-02-09 11:23:57 +03:00
|
|
|
|
lines_crlf := text_crlf.split_into_lines()
|
|
|
|
|
|
|
|
|
|
assert lines_crlf.len == 3
|
|
|
|
|
for line in lines_crlf {
|
|
|
|
|
assert line == line_content
|
|
|
|
|
}
|
|
|
|
|
|
2021-03-16 08:29:14 +03:00
|
|
|
|
text_lf := '$line_content\n$line_content\n$line_content'
|
2020-02-09 11:23:57 +03:00
|
|
|
|
lines_lf := text_lf.split_into_lines()
|
|
|
|
|
|
|
|
|
|
assert lines_lf.len == 3
|
|
|
|
|
for line in lines_lf {
|
|
|
|
|
assert line == line_content
|
|
|
|
|
}
|
|
|
|
|
}
|
2020-05-04 11:19:23 +03:00
|
|
|
|
|
2021-03-16 08:29:14 +03:00
|
|
|
|
fn test_string_literal_with_backslash() {
|
|
|
|
|
a := 'HelloWorld'
|
|
|
|
|
assert a == 'HelloWorld'
|
2020-05-04 11:19:23 +03:00
|
|
|
|
|
2021-03-16 08:29:14 +03:00
|
|
|
|
b := 'OneTwoThree'
|
2020-05-04 11:19:23 +03:00
|
|
|
|
assert b == 'OneTwoThree'
|
|
|
|
|
}
|
2020-05-16 17:12:23 +03:00
|
|
|
|
|
|
|
|
|
/*
|
2020-09-25 13:02:32 +03:00
|
|
|
|
type MyString = string
|
2020-05-16 17:12:23 +03:00
|
|
|
|
|
|
|
|
|
fn test_string_alias() {
|
|
|
|
|
s := MyString('hi')
|
|
|
|
|
ss := s + '!'
|
|
|
|
|
}
|
|
|
|
|
*/
|
2020-07-13 19:45:13 +03:00
|
|
|
|
|
|
|
|
|
// sort an array of structs, by their string field values
|
|
|
|
|
|
|
|
|
|
struct Ka {
|
|
|
|
|
s string
|
|
|
|
|
i int
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn test_sorter() {
|
|
|
|
|
mut arr := [
|
|
|
|
|
Ka{
|
|
|
|
|
s: 'bbb'
|
|
|
|
|
i: 100
|
|
|
|
|
},
|
|
|
|
|
Ka{
|
|
|
|
|
s: 'aaa'
|
|
|
|
|
i: 101
|
|
|
|
|
},
|
|
|
|
|
Ka{
|
|
|
|
|
s: 'ccc'
|
|
|
|
|
i: 102
|
2021-03-16 08:29:14 +03:00
|
|
|
|
},
|
2020-07-13 19:45:13 +03:00
|
|
|
|
]
|
2020-10-18 01:48:06 +03:00
|
|
|
|
cmp := fn (a &Ka, b &Ka) int {
|
2020-07-13 19:45:13 +03:00
|
|
|
|
return compare_strings(a.s, b.s)
|
|
|
|
|
}
|
|
|
|
|
arr.sort_with_compare(cmp)
|
|
|
|
|
assert arr[0].s == 'aaa'
|
|
|
|
|
assert arr[0].i == 101
|
|
|
|
|
assert arr[1].s == 'bbb'
|
|
|
|
|
assert arr[1].i == 100
|
|
|
|
|
assert arr[2].s == 'ccc'
|
|
|
|
|
assert arr[2].i == 102
|
|
|
|
|
}
|
2020-12-29 09:46:46 +03:00
|
|
|
|
|
2021-03-16 20:45:27 +03:00
|
|
|
|
fn test_fields() {
|
2021-03-16 08:29:14 +03:00
|
|
|
|
assert 'a bcde'.fields() == ['a', 'bcde']
|
|
|
|
|
assert ' sss \t ssss '.fields() == ['sss', 'ssss']
|
|
|
|
|
assert '\n xyz \t abc def'.fields() == ['xyz', 'abc', 'def']
|
2021-03-16 20:45:27 +03:00
|
|
|
|
assert 'hello'.fields() == ['hello']
|
2021-03-16 08:29:14 +03:00
|
|
|
|
assert ''.fields() == []
|
2020-12-29 09:46:46 +03:00
|
|
|
|
}
|
2021-01-28 16:38:00 +03:00
|
|
|
|
|
|
|
|
|
fn test_interpolation_after_quoted_variable_still_works() {
|
|
|
|
|
rr := 'abc'
|
|
|
|
|
tt := 'xyz'
|
|
|
|
|
|
|
|
|
|
// Basic interpolation, no internal quotes
|
|
|
|
|
yy := 'Replacing $rr with $tt'
|
|
|
|
|
assert yy == 'Replacing abc with xyz'
|
|
|
|
|
|
|
|
|
|
// Interpolation after quoted variable ending with 'r'quote
|
|
|
|
|
// that may be mistaken with the start of a raw string,
|
|
|
|
|
// ensure that it is not.
|
|
|
|
|
ss := 'Replacing "$rr" with "$tt"'
|
|
|
|
|
assert ss == 'Replacing "abc" with "xyz"'
|
|
|
|
|
zz := "Replacing '$rr' with '$tt'"
|
|
|
|
|
assert zz == "Replacing 'abc' with 'xyz'"
|
|
|
|
|
|
|
|
|
|
// Interpolation after quoted variable ending with 'c'quote
|
|
|
|
|
// may be mistaken with the start of a c string, so
|
|
|
|
|
// check it is not.
|
|
|
|
|
cc := 'abc'
|
|
|
|
|
ccc := "Replacing '$cc' with '$tt'"
|
|
|
|
|
assert ccc == "Replacing 'abc' with 'xyz'"
|
|
|
|
|
cccq := 'Replacing "$cc" with "$tt"'
|
|
|
|
|
assert cccq == 'Replacing "abc" with "xyz"'
|
|
|
|
|
}
|
2021-06-30 09:17:38 +03:00
|
|
|
|
|
|
|
|
|
fn test_emoji_to_runes() {
|
|
|
|
|
x := '👋'
|
|
|
|
|
assert x.runes()[0] == `👋`
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn test_string_to_rune() {
|
|
|
|
|
x := 'Hello World 👋'
|
|
|
|
|
assert x.runes().len == 13
|
|
|
|
|
}
|
2021-09-06 15:06:37 +03:00
|
|
|
|
|
|
|
|
|
fn test_index_any() {
|
|
|
|
|
x := 'abcdefghij'
|
|
|
|
|
assert x.index_any('ef') == 4
|
|
|
|
|
assert x.index_any('fe') == 4
|
|
|
|
|
}
|