1
0
mirror of https://github.com/vlang/v.git synced 2023-08-10 21:13:21 +03:00
v/vlib/builtin/array_test.v

528 lines
8.6 KiB
V
Raw Normal View History

2019-06-25 16:31:56 +03:00
const (
q = [1, 2, 3]
A = 8
)
fn test_ints() {
mut a := [1, 5, 2, 3]
assert a.len == 4
assert a[0] == 1
assert a[2] == 2
assert a.last() == 3
a << 4
assert a.len == 5
assert a[4] == 4
assert a.last() == 4
2019-07-25 15:06:26 +03:00
s := a.str()
2019-06-25 16:31:56 +03:00
assert s == '[1, 5, 2, 3, 4]'
assert a[1] == 5
assert a.last() == 4
}
fn test_deleting() {
mut a := [1, 5, 2, 3, 4]
assert a.len == 5
assert a.str() == '[1, 5, 2, 3, 4]'
2019-06-25 16:31:56 +03:00
a.delete(0)
assert a.str() == '[5, 2, 3, 4]'
assert a.len == 4
2019-06-25 16:31:56 +03:00
a.delete(1)
assert a.str() == '[5, 3, 4]'
assert a.len == 3
a.delete(a.len - 1)
assert a.str() == '[5, 3]'
assert a.len == 2
2019-06-25 16:31:56 +03:00
}
fn test_short() {
a := [1, 2, 3]
assert a.len == 3
assert a.cap == 3
assert a[0] == 1
assert a[1] == 2
assert a[2] == 3
}
fn test_large() {
mut a := [0].repeat(0)
2019-06-25 16:31:56 +03:00
for i := 0; i < 10000; i++ {
a << i
}
assert a.len == 10000
assert a[234] == 234
}
struct Chunk {
val string
}
struct K {
q []Chunk
}
fn test_empty() {
2019-11-14 10:00:22 +03:00
mut chunks := []Chunk
2019-06-25 16:31:56 +03:00
a := Chunk{}
assert chunks.len == 0
chunks << a
assert chunks.len == 1
2019-11-14 09:53:05 +03:00
chunks = []
2019-06-25 16:31:56 +03:00
assert chunks.len == 0
chunks << a
assert chunks.len == 1
}
2019-06-25 16:31:56 +03:00
fn test_push() {
mut a := []int
a << 1
a << 3
assert a[1] == 3
assert a.str() == '[1, 3]'
}
// TODO array.insert is broken
// Cannot pass literal or primitive type as it cannot be cast to voidptr.
// In the current state only that would work:
// i := 3
// a.insert(0, &i)
// ----------------------------
2019-11-11 17:18:32 +03:00
fn test_insert() {
// mut a := [1, 2]
// a.insert(0, 3)
// println(a)
}
// fn test_insert() {
// mut a := [1, 2]
// a.insert(0, 3)
// assert a[0] == 3
// assert a[2] == 2
// assert a.len == 3
// a.insert(1, 4)
// assert a[1] == 4
// assert a[2] == 1
// assert a.len == 4
// a.insert(4, 5)
// assert a[4] == 5
// assert a[3] == 2
// assert a.len == 5
// mut b := []f64
// assert b.len == 0
// b.insert(0, f64(1.1))
// assert b.len == 1
// assert b[0] == f64(1.1)
// }
// TODO array.prepend is broken
// It depends on array.insert
// -----------------------------
// fn test_prepend() {
// mut a := []int
// assert a.len == 0
// a.prepend(1)
// assert a.len == 1
// assert a[0] == 1
// mut b := []f64
// assert b.len == 0
// b.prepend(f64(1.1))
// assert b.len == 1
// assert b[0] == f64(1.1)
// }
2019-06-25 16:31:56 +03:00
fn test_strings() {
a := ['a', 'b', 'c']
assert a.str() == '["a", "b", "c"]'
}
fn test_compare_ints() {
2019-11-19 00:27:27 +03:00
/*
assert compare_ints(1, 2) == -1
assert compare_ints(2, 1) == 1
assert compare_ints(0, 0) == 0
a := 1
b := 2
assert compare_ints(a, b) == -1
assert compare_ints(b, a) == 1
assert compare_ints(a, a) == 0
2019-11-19 00:27:27 +03:00
*/
}
fn test_repeat() {
{
a := [0].repeat(5)
assert a.len == 5
assert a[0] == 0 && a[1] == 0 && a[2] == 0 && a[3] == 0 && a[4] == 0
}
{
a := [1.1].repeat(10)
// FIXME: assert aa[0] == 1.1 will fail, need fix
assert a[0] == f32(1.1)
assert a[5] == f32(1.1)
assert a[9] == f32(1.1)
}
{
a := [f32(1.1)].repeat(10)
assert a[0] == f32(1.1)
assert a[5] == f32(1.1)
assert a[9] == f32(1.1)
}
{
a := [f64(1.1)].repeat(10)
assert a[0] == f64(1.1)
assert a[5] == f64(1.1)
assert a[9] == f64(1.1)
}
{
a := [1, 2].repeat(2)
assert a[0] == 1
assert a[1] == 2
assert a[2] == 1
assert a[3] == 2
}
{
a := ['1', 'abc'].repeat(2)
assert a[0] == '1'
assert a[1] == 'abc'
assert a[2] == '1'
assert a[3] == 'abc'
}
{
mut a := ['1', 'abc'].repeat(0)
assert a.len == 0
a << 'abc'
assert a[0] == 'abc'
}
2019-06-25 16:31:56 +03:00
}
fn test_right() {
a := [1, 2, 3, 4]
b := a.right(1)
2019-10-27 01:37:29 +03:00
c := a[1..a.len]
d := a[1..]
2019-06-25 16:31:56 +03:00
assert b[0] == 2
assert b[1] == 3
2019-10-27 01:37:29 +03:00
assert c[0] == 2
assert c[1] == 3
assert d[0] == 2
assert d[1] == 3
2019-06-25 16:31:56 +03:00
}
fn test_right_with_n_bigger_than_array_size() {
a := [1, 2, 3, 4]
// NOTE: slice syntax wont return empty array
// instead will give index out of bounds
// mut b := a[10..]
mut b := a.right(10)
assert b.len == 0
2019-12-06 02:11:39 +03:00
// also check that the result of a.right
// is an array of the same type/element size as a:
b << 5
b << 6
assert b.len == 2
assert b[0] == 5
assert b[1] == 6
}
2019-06-25 16:31:56 +03:00
fn test_left() {
a := [1, 2, 3]
b := a.left(2)
2019-10-27 01:37:29 +03:00
c := a[0..2]
d := a[..2]
e := a.left(4)
2019-06-25 16:31:56 +03:00
assert b[0] == 1
assert b[1] == 2
2019-10-27 01:37:29 +03:00
assert c[0] == 1
assert c[1] == 2
assert d[0] == 1
assert d[1] == 2
assert e[0] == 1
assert e[2] == 3
assert e.len == 3
2019-06-25 16:31:56 +03:00
}
fn test_slice() {
a := [1, 2, 3, 4]
b := a.slice(2, 4)
assert b.len == 2
2019-06-25 16:31:56 +03:00
assert a.slice(1, 2).len == 1
assert a.len == 4
2019-06-25 16:31:56 +03:00
}
fn test_push_many() {
mut a := [1, 2, 3]
b := [4, 5, 6]
2019-09-14 23:48:30 +03:00
a << b
2019-06-25 16:31:56 +03:00
assert a.len == 6
assert a[0] == 1
assert a[3] == 4
assert a[5] == 6
}
2019-07-17 19:17:07 +03:00
fn test_reverse() {
a := [1, 2, 3, 4]
b := ['test', 'array', 'reverse']
2019-07-17 19:35:40 +03:00
c := a.reverse()
d := b.reverse()
for i, _ in c {
assert c[i] == a[a.len-i-1]
}
for i, _ in d {
assert d[i] == b[b.len-i-1]
}
2019-07-17 19:17:07 +03:00
}
const (
N = 5
2019-09-14 23:48:30 +03:00
)
2019-12-06 02:11:39 +03:00
struct Foooj {
a [N]int
}
fn test_fixed() {
2019-09-14 23:48:30 +03:00
mut nums := [4]int
assert nums[0] == 0
assert nums[1] == 0
assert nums[2] == 0
assert nums[3] == 0
nums[1] = 7
assert nums[1] == 7
nums2 := [N]int
assert nums2[N - 1] == 0
}
fn modify (numbers mut []int) {
numbers[0] = 777
}
2019-09-14 23:48:30 +03:00
fn test_mut_slice() {
2019-08-07 13:57:07 +03:00
mut n := [1,2,3]
modify(mut n[..2])
2019-09-14 23:48:30 +03:00
assert n[0] == 777
modify(mut n[2..])
2019-09-14 23:48:30 +03:00
assert n[2] == 777
2019-08-07 13:57:07 +03:00
println(n)
}
2019-08-12 14:41:34 +03:00
fn test_clone() {
2019-09-14 23:48:30 +03:00
nums := [1, 2, 3, 4, 100]
nums2 := nums.clone()
assert nums2.len == 5
assert nums2.str() == '[1, 2, 3, 4, 100]'
assert nums.slice(1, 3).str() == '[2, 3]'
}
fn test_doubling() {
mut nums := [1, 2, 3, 4, 5]
for i := 0; i < nums.len; i++ {
nums[i] *= 2
}
assert nums.str() == '[2, 4, 6, 8, 10]'
}
struct Test2 {
one int
two int
}
struct Test {
a string
mut:
b []Test2
}
fn (t Test2) str() string {
return '{$t.one $t.two}'
}
fn (t Test) str() string {
return '{$t.a $t.b}'
}
fn test_struct_print() {
mut a := Test {
a: 'Test',
2019-11-14 10:00:22 +03:00
b: []
}
b := Test2 {
one: 1,
two: 2
}
a.b << b
a.b << b
assert a.str() == '{Test [{1 2}, {1 2}] }'
assert b.str() == '{1 2}'
assert a.b.str() == '[{1 2}, {1 2}]'
}
2019-09-28 13:52:02 +03:00
fn test_single_element() {
mut a := [1]
a << 2
assert a.len == 2
assert a[0] == 1
assert a[1] == 2
println(a)
2019-12-06 02:11:39 +03:00
}
2019-10-04 23:07:19 +03:00
fn test_find_index() {
// string
a := ['v', 'is', 'great']
assert a.index('v') == 0
assert a.index('is') == 1
assert a.index('gre') == -1
// int
b := [1, 2, 3, 4]
assert b.index(1) == 0
assert b.index(4) == 3
assert b.index(5) == -1
// byte
c := [0x22, 0x33, 0x55]
assert c.index(0x22) == 0
assert c.index(0x55) == 2
assert c.index(0x99) == -1
// char
d := [`a`, `b`, `c`]
assert d.index(`b`) == 1
assert d.index(`c`) == 2
assert d.index(`u`) == -1
}
2019-10-05 16:03:13 +03:00
fn test_multi() {
a := [[1,2,3],[4,5,6]]
assert a.len == 2
assert a[0].len == 3
assert a[0][0] == 1
assert a[0][2] == 3
assert a[1][2] == 6
// TODO
2019-10-06 04:18:55 +03:00
//b := [ [[1,2,3],[4,5,6]], [[1,2]] ]
//assert b[0][0][0] == 1
}
fn test_in() {
a := [1,2,3]
assert 1 in a
assert 2 in a
assert 3 in a
assert !(4 in a)
assert !(0 in a)
}
2019-10-08 13:23:17 +03:00
2019-10-11 04:12:40 +03:00
fn sum(prev int, curr int) int {
return prev + curr
}
fn sub(prev int, curr int) int {
return prev - curr
}
fn test_reduce() {
a := [1, 2, 3, 4, 5]
b := a.reduce(sum, 0)
c := a.reduce(sum, 5)
d := a.reduce(sum, -1)
assert b == 15
assert c == 20
assert d == 14
e := [1, 2, 3]
f := e.reduce(sub, 0)
g := e.reduce(sub, -1)
assert f == -6
assert g == -7
}
2019-10-17 10:44:20 +03:00
fn test_filter() {
a := [1, 2, 3, 4, 5, 6]
b := a.filter(it % 2 == 0)
2019-10-26 14:32:56 +03:00
assert b.len == 3
2019-10-17 10:44:20 +03:00
assert b[0] == 2
assert b[1] == 4
assert b[2] == 6
c := ['v', 'is', 'awesome']
d := c.filter(it.len > 1)
assert d[0] == 'is'
assert d[1] == 'awesome'
2019-12-06 02:11:39 +03:00
}
2019-10-25 22:40:52 +03:00
2019-10-26 14:32:56 +03:00
fn test_map() {
a := [1, 2, 3, 4, 5, 6]
b := a.map(it * 10)
assert b.len == 6
assert b[0] == 10
assert b[1] == 20
assert b[2] == 30
c := ['v', 'is', 'awesome']
d := c.map(it.to_upper())
assert d[0] == 'V'
assert d[1] == 'IS'
assert d[2] == 'AWESOME'
2019-10-26 14:53:55 +03:00
bools := c.map(it == 'v')
assert bools.len == 3
assert bools[0] == true
assert bools[1] == false
assert bools[2] == false
2019-12-06 02:11:39 +03:00
}
2019-10-26 14:32:56 +03:00
2019-10-25 22:40:52 +03:00
fn test_array_str() {
numbers := [1, 2, 3]
numbers2 := [numbers, [4, 5, 6]] // dup str() bug
assert true
assert numbers.str() == '[1, 2, 3]'
assert numbers2.str() == '[[1, 2, 3], [4, 5, 6]]'
}
fn test_eq() {
assert [5,6,7].eq([6,7]) == false
assert [`a`,`b`].eq([`a`,`b`]) == true
}
2019-11-19 00:27:27 +03:00
fn test_sort() {
mut a := ['hi', '1', '5', '3']
a.sort()
assert a[0] == '1'
assert a[1] == '3'
assert a[2] == '5'
assert a[3] == 'hi'
//
mut nums := [67, -3, 108, 42, 7]
nums.sort()
assert nums[0] == -3
assert nums[1] == 7
assert nums[2] == 42
assert nums[3] == 67
assert nums[4] == 108
2019-12-06 02:11:39 +03:00
}
2019-11-19 00:27:27 +03:00
2019-11-06 18:19:03 +03:00
/*
fn test_for_last() {
numbers := [1, 2, 3, 4]
mut s := '['
for num in numbers {
s += '$num'
if !last {
s += ', '
2019-12-06 02:11:39 +03:00
}
}
s += ']'
assert s == '[1, 2, 3, 4]'
2019-12-06 02:11:39 +03:00
}
2019-11-06 18:19:03 +03:00
*/