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 s := a.str() 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]' a.delete(0) assert a.str() == '[5, 2, 3, 4]' assert a.len == 4 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 } 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) 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() { mut chunks := []Chunk{} a := Chunk{} assert chunks.len == 0 chunks << a assert chunks.len == 1 chunks = []Chunk{} assert chunks.len == 0 chunks << a assert chunks.len == 1 } 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) // ---------------------------- // 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) // } fn test_strings() { a := ['a', 'b', 'c'] assert a.str() == '["a", "b", "c"]' } fn test_compare_ints() { 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 } 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' } } fn test_right() { a := [1, 2, 3, 4] b := a.right(1) c := a[1..a.len] d := a[1..] assert b[0] == 2 assert b[1] == 3 assert c[0] == 2 assert c[1] == 3 assert d[0] == 2 assert d[1] == 3 } 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 // 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 } fn test_left() { a := [1, 2, 3] b := a.left(2) c := a[0..2] d := a[..2] e := a.left(4) assert b[0] == 1 assert b[1] == 2 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 } fn test_slice() { a := [1, 2, 3, 4] b := a.slice(2, 4) assert b.len == 2 assert a.slice(1, 2).len == 1 assert a.len == 4 } fn test_push_many() { mut a := [1, 2, 3] b := [4, 5, 6] a << b assert a.len == 6 assert a[0] == 1 assert a[3] == 4 assert a[5] == 6 } fn test_reverse() { mut a := [1, 2, 3, 4] mut b := ['test', 'array', 'reverse'] 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] } } const ( N = 5 ) fn test_fixed() { 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 } fn test_mut_slice() { mut n := [1,2,3] modify(mut n[..2]) assert n[0] == 777 modify(mut n[2..]) assert n[2] == 777 println(n) } fn test_clone() { 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', b: []Test2 } 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}]' } fn test_single_element() { mut a := [1] a << 2 assert a.len == 2 assert a[0] == 1 assert a[1] == 2 println(a) } 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 } 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 //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) } 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 } fn test_filter() { a := [1, 2, 3, 4, 5, 6] b := a.filter(it % 2 == 0) assert b.len == 3 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' } 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' bools := c.map(it == 'v') assert bools.len == 3 assert bools[0] == true assert bools[1] == false assert bools[2] == false } 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 }