mirror of
https://github.com/vlang/v.git
synced 2025-08-04 02:07:28 -04:00
484 lines
10 KiB
V
484 lines
10 KiB
V
fn a() {}
|
|
|
|
fn b() {}
|
|
|
|
fn c() {}
|
|
|
|
fn v() {}
|
|
|
|
fn test_any_all_of_ints() {
|
|
ia := [1, 2, 3]!
|
|
|
|
assert ia.any(it > 2)
|
|
assert ia.any(|x| x > 2)
|
|
assert [1, 2, 3]!.any(it > 2)
|
|
assert [1, 2, 3]!.any(|x| x > 2)
|
|
|
|
assert !ia.all(it > 1)
|
|
assert !ia.all(|x| x > 1)
|
|
assert ![1, 2, 3]!.all(it > 1)
|
|
assert ![1, 2, 3]!.all(|x| x > 1)
|
|
|
|
assert ia.any(it == 2)
|
|
assert ia.any(|x| x == 2)
|
|
assert [1, 2, 3]!.any(it == 2)
|
|
assert [1, 2, 3]!.any(|x| x == 2)
|
|
|
|
assert !ia.all(it == 3)
|
|
assert !ia.all(|x| x == 3)
|
|
assert ![1, 2, 3]!.all(it == 3)
|
|
assert ![1, 2, 3]!.all(|x| x == 3)
|
|
}
|
|
|
|
fn test_any_all_of_strings() {
|
|
sa := ['a', 'b', 'c']!
|
|
|
|
assert sa.any(it == 'b')
|
|
assert sa.any(|x| x == 'b')
|
|
assert ['a', 'b', 'c']!.any(it == 'b')
|
|
assert ['a', 'b', 'c']!.any(|x| x == 'b')
|
|
|
|
assert !sa.all(it == 'c')
|
|
assert !sa.all(|x| x == 'c')
|
|
assert !['a', 'b', 'c']!.all(it == 'c')
|
|
assert !['a', 'b', 'c']!.all(|x| x == 'c')
|
|
}
|
|
|
|
fn test_any_all_of_voidptrs() {
|
|
pa := [voidptr(123), voidptr(45), voidptr(99)]!
|
|
|
|
assert pa.any(it == voidptr(45))
|
|
assert pa.any(|x| x == voidptr(45))
|
|
assert [voidptr(123), voidptr(45), voidptr(99)]!.any(it == voidptr(45))
|
|
assert [voidptr(123), voidptr(45), voidptr(99)]!.any(|x| x == voidptr(45))
|
|
|
|
assert !pa.all(it == voidptr(123))
|
|
assert !pa.all(|x| x == voidptr(123))
|
|
assert ![voidptr(123), voidptr(45), voidptr(99)]!.all(it == voidptr(123))
|
|
assert ![voidptr(123), voidptr(45), voidptr(99)]!.all(|x| x == voidptr(123))
|
|
}
|
|
|
|
fn test_any_all_of_fns() {
|
|
fa := [a, b, c]!
|
|
|
|
assert fa.any(it == b)
|
|
assert fa.any(|x| x == b)
|
|
assert [a, b, c]!.any(it == b)
|
|
assert [a, b, c]!.any(|x| x == b)
|
|
|
|
assert !fa.all(it == v)
|
|
assert !fa.all(|x| x == v)
|
|
assert ![a, b, c]!.all(it == v)
|
|
assert ![a, b, c]!.all(|x| x == v)
|
|
}
|
|
|
|
fn test_contains_of_ints() {
|
|
ia := [1, 2, 3]!
|
|
mut ii := ia.contains(2)
|
|
dump(ii)
|
|
assert ii
|
|
assert [1, 2, 3]!.contains(2)
|
|
|
|
ii = ia.contains(5)
|
|
dump(ii)
|
|
assert !ii
|
|
assert ![1, 2, 3]!.contains(5)
|
|
}
|
|
|
|
fn test_contains_of_strings() {
|
|
sa := ['a', 'b', 'c']!
|
|
mut si := sa.contains('b')
|
|
dump(si)
|
|
assert si
|
|
assert ['a', 'b', 'c']!.contains('b')
|
|
|
|
si = sa.contains('v')
|
|
dump(si)
|
|
assert !si
|
|
assert !['a', 'b', 'c']!.contains('v')
|
|
}
|
|
|
|
fn test_contains_of_voidptrs() {
|
|
pa := [voidptr(123), voidptr(45), voidptr(99)]!
|
|
mut pi := pa.contains(voidptr(45))
|
|
dump(pi)
|
|
assert pi
|
|
assert [voidptr(123), voidptr(45), voidptr(99)]!.contains(voidptr(45))
|
|
|
|
pi = pa.contains(unsafe { nil })
|
|
dump(pi)
|
|
assert !pi
|
|
assert ![voidptr(123), voidptr(45), voidptr(99)]!.contains(unsafe { nil })
|
|
}
|
|
|
|
fn test_contains_of_fns() {
|
|
fa := [a, b, c]!
|
|
mut fi := fa.contains(b)
|
|
dump(fi)
|
|
assert fi
|
|
assert [a, b, c]!.contains(b)
|
|
|
|
fi = fa.contains(v)
|
|
dump(fi)
|
|
assert !fi
|
|
assert ![a, b, c]!.contains(v)
|
|
}
|
|
|
|
fn test_index_of_ints() {
|
|
ia := [1, 2, 3]!
|
|
mut ii := ia.index(2)
|
|
dump(ii)
|
|
assert ii == 1
|
|
assert [1, 2, 3]!.index(2) == 1
|
|
|
|
ii = ia.index(5)
|
|
dump(ii)
|
|
assert ii == -1
|
|
assert [1, 2, 3]!.index(5) == -1
|
|
}
|
|
|
|
fn test_index_of_strings() {
|
|
sa := ['a', 'b', 'c']!
|
|
mut si := sa.index('b')
|
|
dump(si)
|
|
assert si == 1
|
|
assert ['a', 'b', 'c']!.index('b') == 1
|
|
|
|
si = sa.index('v')
|
|
dump(si)
|
|
assert si == -1
|
|
assert ['a', 'b', 'c']!.index('v') == -1
|
|
}
|
|
|
|
fn test_index_of_voidptrs() {
|
|
pa := [voidptr(123), voidptr(45), voidptr(99)]!
|
|
mut pi := pa.index(voidptr(45))
|
|
dump(pi)
|
|
assert pi == 1
|
|
assert [voidptr(123), voidptr(45), voidptr(99)]!.index(voidptr(45)) == 1
|
|
|
|
pi = pa.index(unsafe { nil })
|
|
dump(pi)
|
|
assert pi == -1
|
|
assert [voidptr(123), voidptr(45), voidptr(99)]!.index(unsafe { nil }) == -1
|
|
}
|
|
|
|
fn test_index_of_fns() {
|
|
fa := [a, b, c]!
|
|
mut fi := fa.index(b)
|
|
dump(fi)
|
|
assert fi == 1
|
|
assert [a, b, c]!.index(b) == 1
|
|
|
|
fi = fa.index(v)
|
|
dump(fi)
|
|
assert fi == -1
|
|
assert [a, b, c]!.index(v) == -1
|
|
}
|
|
|
|
fn test_fixed_array_map() {
|
|
a := [1, 2, 3]!
|
|
|
|
b1 := a.map(it * 2)
|
|
println(b1)
|
|
assert b1 == [2, 4, 6]!
|
|
b10 := [1, 2, 3]!.map(it * 2)
|
|
assert b10 == [2, 4, 6]!
|
|
assert [1, 2, 3]!.map(it * 2) == [2, 4, 6]!
|
|
|
|
b11 := a.map(|x| x * 2)
|
|
println(b11)
|
|
assert b11 == [2, 4, 6]!
|
|
b110 := [1, 2, 3]!.map(|x| x * 2)
|
|
assert b110 == [2, 4, 6]!
|
|
assert [1, 2, 3]!.map(|x| x * 2) == [2, 4, 6]!
|
|
|
|
b2 := a.map('${it}')
|
|
println(b2)
|
|
assert b2 == ['1', '2', '3']!
|
|
b20 := [1, 2, 3]!.map('${it}')
|
|
assert b20 == ['1', '2', '3']!
|
|
assert [1, 2, 3]!.map('${it}') == ['1', '2', '3']!
|
|
|
|
b22 := a.map(|x| '${x}')
|
|
println(b22)
|
|
assert b22 == ['1', '2', '3']!
|
|
b220 := [1, 2, 3]!.map(|x| '${x}')
|
|
assert b220 == ['1', '2', '3']!
|
|
assert [1, 2, 3]!.map(|x| '${x}') == ['1', '2', '3']!
|
|
|
|
b3 := a.map(it + 2)
|
|
println(b3)
|
|
assert b3 == [3, 4, 5]!
|
|
b30 := [1, 2, 3]!.map(it + 2)
|
|
assert b30 == [3, 4, 5]!
|
|
assert [1, 2, 3]!.map(it + 2) == [3, 4, 5]!
|
|
|
|
b33 := a.map(|x| x + 2)
|
|
println(b33)
|
|
assert b33 == [3, 4, 5]!
|
|
b330 := [1, 2, 3]!.map(|x| x + 2)
|
|
assert b330 == [3, 4, 5]!
|
|
assert [1, 2, 3]!.map(|x| x + 2) == [3, 4, 5]!
|
|
}
|
|
|
|
struct User {
|
|
age int
|
|
name string
|
|
}
|
|
|
|
fn test_fixed_array_reverse_in_place() {
|
|
mut a := ['hi', '1', '5', '3']!
|
|
a.reverse_in_place()
|
|
assert a == ['3', '5', '1', 'hi']!
|
|
|
|
mut nums := [67, -3, 108, 42, 7]!
|
|
nums.reverse_in_place()
|
|
assert nums == [7, 42, 108, -3, 67]!
|
|
|
|
mut users := [User{22, 'Peter'}, User{20, 'Bob'}, User{25, 'Alice'}]!
|
|
users.reverse_in_place()
|
|
assert users[0].age == 25
|
|
assert users[1].age == 20
|
|
assert users[2].age == 22
|
|
assert users[0].name == 'Alice'
|
|
assert users[1].name == 'Bob'
|
|
assert users[2].name == 'Peter'
|
|
}
|
|
|
|
fn test_fixed_array_reverse() {
|
|
a := ['hi', '1', '5', '3']!
|
|
b := a.reverse()
|
|
assert a == ['hi', '1', '5', '3']!
|
|
assert b == ['3', '5', '1', 'hi']!
|
|
assert ['hi', '1', '5', '3']!.reverse() == ['3', '5', '1', 'hi']!
|
|
|
|
mut nums := [67, -3, 108, 42, 7]!
|
|
n := nums.reverse()
|
|
assert nums == [67, -3, 108, 42, 7]!
|
|
assert n == [7, 42, 108, -3, 67]!
|
|
assert [67, -3, 108, 42, 7]!.reverse() == [7, 42, 108, -3, 67]!
|
|
|
|
mut users := [User{22, 'Peter'}, User{20, 'Bob'}, User{25, 'Alice'}]!
|
|
u := users.reverse()
|
|
|
|
assert users[0].age == 22
|
|
assert users[1].age == 20
|
|
assert users[2].age == 25
|
|
assert users[0].name == 'Peter'
|
|
assert users[1].name == 'Bob'
|
|
assert users[2].name == 'Alice'
|
|
|
|
assert u[0].age == 25
|
|
assert u[1].age == 20
|
|
assert u[2].age == 22
|
|
assert u[0].name == 'Alice'
|
|
assert u[1].name == 'Bob'
|
|
assert u[2].name == 'Peter'
|
|
|
|
u2 := [User{22, 'Peter'}, User{20, 'Bob'}, User{25, 'Alice'}]!.reverse()
|
|
assert u2[0].age == 25
|
|
assert u2[1].age == 20
|
|
assert u2[2].age == 22
|
|
assert u2[0].name == 'Alice'
|
|
assert u2[1].name == 'Bob'
|
|
assert u2[2].name == 'Peter'
|
|
}
|
|
|
|
fn test_fixed_array_sort() {
|
|
mut a := ['hi', '1', '5', '3']!
|
|
a.sort()
|
|
assert a == ['1', '3', '5', 'hi']!
|
|
|
|
mut nums := [67, -3, 108, 42, 7]!
|
|
nums.sort()
|
|
assert nums == [-3, 7, 42, 67, 108]!
|
|
|
|
nums.sort(a < b)
|
|
assert nums == [-3, 7, 42, 67, 108]!
|
|
|
|
nums.sort(b < a)
|
|
assert nums == [108, 67, 42, 7, -3]!
|
|
|
|
mut users := [User{22, 'Peter'}, User{20, 'Bob'}, User{25, 'Alice'}]!
|
|
users.sort(a.age < b.age)
|
|
assert users[0].age == 20
|
|
assert users[1].age == 22
|
|
assert users[2].age == 25
|
|
assert users[0].name == 'Bob'
|
|
assert users[1].name == 'Peter'
|
|
assert users[2].name == 'Alice'
|
|
|
|
users.sort(a.age > b.age)
|
|
assert users[0].age == 25
|
|
assert users[1].age == 22
|
|
assert users[2].age == 20
|
|
|
|
users.sort(b.age > a.age)
|
|
assert users[0].age == 20
|
|
assert users[1].age == 22
|
|
assert users[2].age == 25
|
|
|
|
users.sort(a.name < b.name)
|
|
assert users[0].name == 'Alice'
|
|
assert users[1].name == 'Bob'
|
|
assert users[2].name == 'Peter'
|
|
}
|
|
|
|
fn test_sorted_immutable_original_should_not_change() {
|
|
a := ['hi', '1', '5', '3']!
|
|
b := a.sorted()
|
|
assert a == ['hi', '1', '5', '3']!
|
|
assert b == ['1', '3', '5', 'hi']!
|
|
assert ['hi', '1', '5', '3']!.sorted() == ['1', '3', '5', 'hi']!
|
|
}
|
|
|
|
fn test_sorted_mutable_original_should_not_change() {
|
|
mut a := ['hi', '1', '5', '3']!
|
|
b := a.sorted()
|
|
assert a == ['hi', '1', '5', '3']!
|
|
assert b == ['1', '3', '5', 'hi']!
|
|
assert ['hi', '1', '5', '3']!.sorted() == ['1', '3', '5', 'hi']!
|
|
}
|
|
|
|
fn test_sorted_reversed() {
|
|
aa := ['hi', '1', '5', '3']!
|
|
bb := aa.sorted(a > b)
|
|
assert aa == ['hi', '1', '5', '3']!
|
|
assert bb == ['hi', '5', '3', '1']!
|
|
assert ['hi', '1', '5', '3']!.sorted(a > b) == ['hi', '5', '3', '1']!
|
|
}
|
|
|
|
fn test_sorted_by_len() {
|
|
a := ['hi', 'abc', 'a', 'zzzzz']!
|
|
c := a.sorted(a.len < b.len)
|
|
assert c == ['a', 'hi', 'abc', 'zzzzz']!
|
|
assert ['hi', 'abc', 'a', 'zzzzz']!.sorted(a.len < b.len) == ['a', 'hi', 'abc', 'zzzzz']!
|
|
}
|
|
|
|
fn test_sort_with_compare_1() {
|
|
mut a := ['hi', '1', '5', '3']!
|
|
a.sort_with_compare(fn (a &string, b &string) int {
|
|
if a < b {
|
|
return -1
|
|
}
|
|
if a > b {
|
|
return 1
|
|
}
|
|
return 0
|
|
})
|
|
assert a == ['1', '3', '5', 'hi']!
|
|
}
|
|
|
|
fn test_sorted_with_compare_1() {
|
|
a := ['hi', '1', '5', '3']!
|
|
b := a.sorted_with_compare(fn (a &string, b &string) int {
|
|
if a < b {
|
|
return -1
|
|
}
|
|
if a > b {
|
|
return 1
|
|
}
|
|
return 0
|
|
})
|
|
assert a == ['hi', '1', '5', '3']!
|
|
assert b == ['1', '3', '5', 'hi']!
|
|
assert ['hi', '1', '5', '3']!.sorted_with_compare(fn (a &string, b &string) int {
|
|
if a < b {
|
|
return -1
|
|
}
|
|
if a > b {
|
|
return 1
|
|
}
|
|
return 0
|
|
}) == ['1', '3', '5', 'hi']!
|
|
}
|
|
|
|
struct Ka {
|
|
s string
|
|
i int
|
|
}
|
|
|
|
fn test_sort_with_compare_2() {
|
|
mut arr := [
|
|
Ka{
|
|
s: 'bbb'
|
|
i: 100
|
|
},
|
|
Ka{
|
|
s: 'aaa'
|
|
i: 101
|
|
},
|
|
Ka{
|
|
s: 'ccc'
|
|
i: 102
|
|
},
|
|
]!
|
|
cmp := fn (a &Ka, b &Ka) int {
|
|
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
|
|
}
|
|
|
|
fn test_sorted_with_compare_2() {
|
|
arr := [
|
|
Ka{
|
|
s: 'bbb'
|
|
i: 100
|
|
},
|
|
Ka{
|
|
s: 'aaa'
|
|
i: 101
|
|
},
|
|
Ka{
|
|
s: 'ccc'
|
|
i: 102
|
|
},
|
|
]!
|
|
cmp := fn (a &Ka, b &Ka) int {
|
|
return compare_strings(a.s, b.s)
|
|
}
|
|
b := arr.sorted_with_compare(cmp)
|
|
assert arr[0].s == 'bbb'
|
|
assert arr[0].i == 100
|
|
assert arr[1].s == 'aaa'
|
|
assert arr[1].i == 101
|
|
assert arr[2].s == 'ccc'
|
|
assert arr[2].i == 102
|
|
|
|
assert b[0].s == 'aaa'
|
|
assert b[0].i == 101
|
|
assert b[1].s == 'bbb'
|
|
assert b[1].i == 100
|
|
assert b[2].s == 'ccc'
|
|
assert b[2].i == 102
|
|
|
|
b2 := [
|
|
Ka{
|
|
s: 'bbb'
|
|
i: 100
|
|
},
|
|
Ka{
|
|
s: 'aaa'
|
|
i: 101
|
|
},
|
|
Ka{
|
|
s: 'ccc'
|
|
i: 102
|
|
},
|
|
]!.sorted_with_compare(cmp)
|
|
|
|
assert b2[0].s == 'aaa'
|
|
assert b2[0].i == 101
|
|
assert b2[1].s == 'bbb'
|
|
assert b2[1].i == 100
|
|
assert b2[2].s == 'ccc'
|
|
assert b2[2].i == 102
|
|
}
|