2019-06-25 15:31:56 +02:00
|
|
|
const (
|
|
|
|
q = [1, 2, 3]
|
|
|
|
A = 8
|
|
|
|
)
|
|
|
|
|
2019-12-18 01:26:04 +01:00
|
|
|
fn test_pointer() {
|
2020-04-26 16:25:54 +02:00
|
|
|
mut arr := []&int{}
|
2019-12-18 01:26:04 +01:00
|
|
|
a := 1
|
|
|
|
b := 2
|
|
|
|
c := 3
|
|
|
|
arr << &a
|
|
|
|
arr << &b
|
|
|
|
arr << &c
|
|
|
|
assert *arr[0] == 1
|
|
|
|
arr[1] = &c
|
|
|
|
assert *arr[1] == 3
|
2019-12-21 23:44:16 +01:00
|
|
|
mut d_arr := [arr] // [][]&int
|
|
|
|
d_arr << arr
|
|
|
|
assert *d_arr[0][1] == 3
|
2020-03-26 22:09:25 +01:00
|
|
|
println(*d_arr[0][1])
|
2019-12-21 23:44:16 +01:00
|
|
|
assert *d_arr[1][0] == 1
|
2019-12-18 01:26:04 +01:00
|
|
|
}
|
|
|
|
|
2020-04-14 20:32:06 +02:00
|
|
|
fn test_assign() {
|
2020-04-26 11:56:27 +02:00
|
|
|
mut arr := [2, 4, 8, 16, 32, 64, 128]
|
2020-04-14 20:32:06 +02:00
|
|
|
|
|
|
|
arr[0] = 2
|
|
|
|
arr[1] &= 255
|
|
|
|
arr[2] |= 255
|
|
|
|
arr[3] <<= 4
|
|
|
|
arr[4] >>= 4
|
|
|
|
arr[5] %= 5
|
|
|
|
arr[6] ^= 3
|
|
|
|
|
|
|
|
assert arr[0] == 2
|
|
|
|
assert arr[1] == 4 & 255
|
|
|
|
assert arr[2] == 8 | 255
|
|
|
|
assert arr[3] == 16 << 4
|
|
|
|
assert arr[4] == 32 >> 4
|
|
|
|
assert arr[5] == 64 % 5
|
|
|
|
assert arr[6] == 128 ^ 3
|
|
|
|
}
|
|
|
|
|
2019-06-25 15:31:56 +02:00
|
|
|
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 14:06:26 +02:00
|
|
|
s := a.str()
|
2019-06-25 15:31:56 +02:00
|
|
|
assert s == '[1, 5, 2, 3, 4]'
|
|
|
|
assert a[1] == 5
|
|
|
|
assert a.last() == 4
|
2019-06-29 22:49:57 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
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 15:31:56 +02:00
|
|
|
a.delete(0)
|
|
|
|
assert a.str() == '[5, 2, 3, 4]'
|
2019-06-29 22:49:57 +02:00
|
|
|
assert a.len == 4
|
2019-06-25 15:31:56 +02:00
|
|
|
a.delete(1)
|
|
|
|
assert a.str() == '[5, 3, 4]'
|
2019-06-29 22:49:57 +02:00
|
|
|
assert a.len == 3
|
2020-01-21 18:49:30 +01:00
|
|
|
a.delete(a.len - 1)
|
2019-10-31 19:50:20 +01:00
|
|
|
assert a.str() == '[5, 3]'
|
|
|
|
assert a.len == 2
|
2019-06-25 15:31:56 +02: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() {
|
2019-09-15 11:26:05 +02:00
|
|
|
mut a := [0].repeat(0)
|
2020-02-24 17:55:16 +01:00
|
|
|
for i in 0..10000 {
|
2019-06-25 15:31:56 +02:00
|
|
|
a << i
|
|
|
|
}
|
|
|
|
assert a.len == 10000
|
|
|
|
assert a[234] == 234
|
|
|
|
}
|
|
|
|
|
|
|
|
struct Chunk {
|
|
|
|
val string
|
|
|
|
}
|
|
|
|
|
|
|
|
struct K {
|
|
|
|
q []Chunk
|
|
|
|
}
|
|
|
|
|
|
|
|
fn test_empty() {
|
2020-04-26 11:56:27 +02:00
|
|
|
mut chunks := []Chunk{}
|
2019-06-25 15:31:56 +02:00
|
|
|
a := Chunk{}
|
|
|
|
assert chunks.len == 0
|
|
|
|
chunks << a
|
|
|
|
assert chunks.len == 1
|
2019-11-14 07:53:05 +01:00
|
|
|
chunks = []
|
2019-06-25 15:31:56 +02:00
|
|
|
assert chunks.len == 0
|
|
|
|
chunks << a
|
|
|
|
assert chunks.len == 1
|
|
|
|
}
|
2019-06-29 22:49:57 +02:00
|
|
|
|
2019-06-25 15:31:56 +02:00
|
|
|
fn test_push() {
|
2020-04-26 11:56:27 +02:00
|
|
|
mut a := []int{}
|
2019-06-25 15:31:56 +02:00
|
|
|
a << 1
|
|
|
|
a << 3
|
|
|
|
assert a[1] == 3
|
|
|
|
assert a.str() == '[1, 3]'
|
|
|
|
}
|
|
|
|
|
2019-10-31 19:50:20 +01:00
|
|
|
// 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:
|
2020-01-21 18:49:30 +01:00
|
|
|
// i := 3
|
|
|
|
// a.insert(0, &i)
|
2019-10-31 19:50:20 +01:00
|
|
|
// ----------------------------
|
2020-01-21 18:49:30 +01:00
|
|
|
/*
|
2019-11-11 15:18:32 +01:00
|
|
|
fn test_insert() {
|
2020-01-21 18:49:30 +01:00
|
|
|
mut a := [1, 2]
|
|
|
|
a.insert(0, 3)
|
|
|
|
println(a)
|
|
|
|
}
|
|
|
|
*/
|
2019-10-31 19:50:20 +01:00
|
|
|
// fn test_insert() {
|
2020-01-21 18:49:30 +01:00
|
|
|
// 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
|
2020-04-26 13:49:31 +02:00
|
|
|
// mut b := []f64{}
|
2020-01-21 18:49:30 +01:00
|
|
|
// assert b.len == 0
|
|
|
|
// b.insert(0, f64(1.1))
|
|
|
|
// assert b.len == 1
|
|
|
|
// assert b[0] == f64(1.1)
|
2019-10-31 19:50:20 +01:00
|
|
|
// }
|
|
|
|
// TODO array.prepend is broken
|
|
|
|
// It depends on array.insert
|
|
|
|
// -----------------------------
|
|
|
|
// fn test_prepend() {
|
2020-04-26 13:49:31 +02:00
|
|
|
// mut a := []int{}
|
2020-01-21 18:49:30 +01:00
|
|
|
// assert a.len == 0
|
|
|
|
// a.prepend(1)
|
|
|
|
// assert a.len == 1
|
|
|
|
// assert a[0] == 1
|
2020-04-26 13:49:31 +02:00
|
|
|
// mut b := []f64{}
|
2020-01-21 18:49:30 +01:00
|
|
|
// assert b.len == 0
|
|
|
|
// b.prepend(f64(1.1))
|
|
|
|
// assert b.len == 1
|
|
|
|
// assert b[0] == f64(1.1)
|
2019-10-31 19:50:20 +01:00
|
|
|
// }
|
2019-06-25 15:31:56 +02:00
|
|
|
fn test_strings() {
|
|
|
|
a := ['a', 'b', 'c']
|
|
|
|
assert a.str() == '["a", "b", "c"]'
|
|
|
|
}
|
|
|
|
|
2020-01-21 18:49:30 +01:00
|
|
|
/*
|
2019-10-31 19:50:20 +01:00
|
|
|
fn test_compare_ints() {
|
|
|
|
assert compare_ints(1, 2) == -1
|
|
|
|
assert compare_ints(2, 1) == 1
|
|
|
|
assert compare_ints(0, 0) == 0
|
2019-10-31 13:47:56 +01:00
|
|
|
|
2019-10-31 19:50:20 +01:00
|
|
|
a := 1
|
|
|
|
b := 2
|
|
|
|
assert compare_ints(a, b) == -1
|
|
|
|
assert compare_ints(b, a) == 1
|
|
|
|
assert compare_ints(a, a) == 0
|
|
|
|
}
|
2020-01-21 18:49:30 +01:00
|
|
|
*/
|
|
|
|
|
2019-10-31 19:50:20 +01:00
|
|
|
|
|
|
|
fn test_repeat() {
|
2019-07-04 10:46:39 +02:00
|
|
|
{
|
2019-10-31 19:50:20 +01:00
|
|
|
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)
|
2020-01-21 18:49:30 +01:00
|
|
|
assert a[0] == 1.1
|
|
|
|
assert a[5] == 1.1
|
|
|
|
assert a[9] == 1.1
|
2019-10-31 19:50:20 +01:00
|
|
|
}
|
|
|
|
{
|
2020-01-21 18:49:30 +01:00
|
|
|
a := [i64(-123)].repeat(10)
|
|
|
|
assert a[0] == -123
|
|
|
|
assert a[5] == -123
|
|
|
|
assert a[9] == -123
|
|
|
|
}
|
|
|
|
{
|
|
|
|
a := [u64(123)].repeat(10)
|
|
|
|
assert a[0] == 123
|
|
|
|
assert a[5] == 123
|
|
|
|
assert a[9] == 123
|
2019-10-31 19:50:20 +01:00
|
|
|
}
|
|
|
|
{
|
2020-03-19 07:24:49 +01:00
|
|
|
a := [1.1].repeat(10)
|
|
|
|
assert a[0] == 1.1
|
|
|
|
assert a[5] == 1.1
|
|
|
|
assert a[9] == 1.1
|
2019-10-31 19:50:20 +01:00
|
|
|
}
|
|
|
|
{
|
|
|
|
a := [1, 2].repeat(2)
|
|
|
|
assert a[0] == 1
|
|
|
|
assert a[1] == 2
|
|
|
|
assert a[2] == 1
|
|
|
|
assert a[3] == 2
|
2019-07-04 10:46:39 +02:00
|
|
|
}
|
|
|
|
{
|
2019-10-31 19:50:20 +01:00
|
|
|
a := ['1', 'abc'].repeat(2)
|
|
|
|
assert a[0] == '1'
|
|
|
|
assert a[1] == 'abc'
|
|
|
|
assert a[2] == '1'
|
|
|
|
assert a[3] == 'abc'
|
2019-07-04 10:46:39 +02:00
|
|
|
}
|
|
|
|
{
|
2019-10-31 19:50:20 +01:00
|
|
|
mut a := ['1', 'abc'].repeat(0)
|
|
|
|
assert a.len == 0
|
|
|
|
a << 'abc'
|
|
|
|
assert a[0] == 'abc'
|
2019-07-04 10:46:39 +02:00
|
|
|
}
|
2019-06-25 15:31:56 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
fn test_right() {
|
|
|
|
a := [1, 2, 3, 4]
|
2019-10-27 00:37:29 +02:00
|
|
|
c := a[1..a.len]
|
2019-10-27 07:36:04 +01:00
|
|
|
d := a[1..]
|
2019-10-27 00:37:29 +02:00
|
|
|
assert c[0] == 2
|
|
|
|
assert c[1] == 3
|
2019-10-27 07:36:04 +01:00
|
|
|
assert d[0] == 2
|
|
|
|
assert d[1] == 3
|
2019-06-25 15:31:56 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
fn test_left() {
|
|
|
|
a := [1, 2, 3]
|
2019-10-27 00:37:29 +02:00
|
|
|
c := a[0..2]
|
2019-10-27 07:36:04 +01:00
|
|
|
d := a[..2]
|
2019-10-27 00:37:29 +02:00
|
|
|
assert c[0] == 1
|
|
|
|
assert c[1] == 2
|
2019-10-27 07:36:04 +01:00
|
|
|
assert d[0] == 1
|
|
|
|
assert d[1] == 2
|
2019-06-25 15:31:56 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
fn test_slice() {
|
|
|
|
a := [1, 2, 3, 4]
|
|
|
|
b := a.slice(2, 4)
|
2019-06-29 22:49:57 +02:00
|
|
|
assert b.len == 2
|
2019-06-25 15:31:56 +02:00
|
|
|
assert a.slice(1, 2).len == 1
|
2019-06-29 22:49:57 +02:00
|
|
|
assert a.len == 4
|
2019-06-25 15:31:56 +02:00
|
|
|
}
|
|
|
|
|
2020-03-31 16:47:55 +02:00
|
|
|
|
2019-06-25 15:31:56 +02:00
|
|
|
fn test_push_many() {
|
|
|
|
mut a := [1, 2, 3]
|
|
|
|
b := [4, 5, 6]
|
2019-09-14 22:48:30 +02:00
|
|
|
a << b
|
2019-06-25 15:31:56 +02:00
|
|
|
assert a.len == 6
|
|
|
|
assert a[0] == 1
|
|
|
|
assert a[3] == 4
|
|
|
|
assert a[5] == 6
|
|
|
|
}
|
|
|
|
|
2019-07-17 18:17:07 +02:00
|
|
|
fn test_reverse() {
|
2019-11-06 04:57:04 +01:00
|
|
|
a := [1, 2, 3, 4]
|
|
|
|
b := ['test', 'array', 'reverse']
|
2019-07-17 18:35:40 +02:00
|
|
|
c := a.reverse()
|
2020-03-18 18:54:08 +01:00
|
|
|
println(c)
|
2019-07-17 18:35:40 +02:00
|
|
|
d := b.reverse()
|
2020-01-21 18:49:30 +01:00
|
|
|
for i, _ in c {
|
|
|
|
assert c[i] == a[a.len - i - 1]
|
2019-07-17 18:35:40 +02:00
|
|
|
}
|
|
|
|
for i, _ in d {
|
2020-01-21 18:49:30 +01:00
|
|
|
assert d[i] == b[b.len - i - 1]
|
2019-07-17 18:35:40 +02:00
|
|
|
}
|
2020-04-26 11:56:27 +02:00
|
|
|
e := []int{}
|
2020-02-29 20:44:02 +01:00
|
|
|
f := e.reverse()
|
|
|
|
assert f.len == 0
|
2019-07-17 18:17:07 +02:00
|
|
|
}
|
2019-08-04 03:59:12 +02:00
|
|
|
|
|
|
|
const (
|
|
|
|
N = 5
|
2019-09-14 22:48:30 +02:00
|
|
|
)
|
2019-08-04 03:59:12 +02:00
|
|
|
|
2019-12-06 00:11:39 +01:00
|
|
|
struct Foooj {
|
2020-03-24 16:18:37 +01:00
|
|
|
a [5]int // N
|
2019-12-06 00:11:39 +01:00
|
|
|
}
|
|
|
|
|
2019-08-04 03:59:12 +02:00
|
|
|
fn test_fixed() {
|
2019-09-14 22:48:30 +02:00
|
|
|
mut nums := [4]int
|
2020-03-31 17:16:12 +02:00
|
|
|
//x := nums[1..3]
|
|
|
|
//assert x.len == 2
|
2019-09-14 22:48:30 +02:00
|
|
|
assert nums[0] == 0
|
|
|
|
assert nums[1] == 0
|
|
|
|
assert nums[2] == 0
|
|
|
|
assert nums[3] == 0
|
|
|
|
nums[1] = 7
|
|
|
|
assert nums[1] == 7
|
2020-03-25 14:24:48 +01:00
|
|
|
nums2 := [5]int // N
|
2019-09-14 22:48:30 +02:00
|
|
|
assert nums2[N - 1] == 0
|
|
|
|
}
|
2019-08-07 12:09:24 +02:00
|
|
|
|
2020-01-21 18:49:30 +01:00
|
|
|
fn modify(numbers mut []int) {
|
|
|
|
numbers[0] = 777
|
2019-08-07 12:09:24 +02:00
|
|
|
}
|
|
|
|
|
2019-09-14 22:48:30 +02:00
|
|
|
fn test_mut_slice() {
|
2020-03-26 22:09:25 +01:00
|
|
|
/*
|
|
|
|
QTODO
|
2020-01-21 18:49:30 +01:00
|
|
|
mut n := [1, 2, 3]
|
2020-03-25 14:24:48 +01:00
|
|
|
//modify(mut n)
|
2019-10-27 08:03:15 +01:00
|
|
|
modify(mut n[..2])
|
2019-09-14 22:48:30 +02:00
|
|
|
assert n[0] == 777
|
2019-10-27 08:03:15 +01:00
|
|
|
modify(mut n[2..])
|
2019-09-14 22:48:30 +02:00
|
|
|
assert n[2] == 777
|
2019-08-07 12:57:07 +02:00
|
|
|
println(n)
|
2020-03-26 22:09:25 +01:00
|
|
|
*/
|
2019-08-07 12:09:24 +02:00
|
|
|
}
|
2019-08-12 13:41:34 +02:00
|
|
|
|
2020-04-04 14:09:58 +02:00
|
|
|
fn double_up(a mut []int) {
|
|
|
|
for i := 0; i < a.len; i++ {
|
|
|
|
a[i] = a[i]*2
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn double_up_v2(a mut []int) {
|
|
|
|
for i, val in a {
|
|
|
|
a[i] = a[i]*2 // or val*2, doesn't matter
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn test_mut_arg() {
|
|
|
|
mut arr := [1,2,3,4,5,6,7,8,9,10]
|
|
|
|
double_up(mut arr)
|
|
|
|
assert arr.str() == '[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]'
|
|
|
|
arr = [1,2,3,4,5,6,7,8,9,10]
|
|
|
|
double_up_v2(mut arr)
|
|
|
|
assert arr.str() == '[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]'
|
|
|
|
}
|
|
|
|
|
2019-08-12 13:41:34 +02:00
|
|
|
fn test_clone() {
|
2019-09-14 22:48:30 +02:00
|
|
|
nums := [1, 2, 3, 4, 100]
|
|
|
|
nums2 := nums.clone()
|
|
|
|
assert nums2.len == 5
|
2020-03-26 11:32:29 +01:00
|
|
|
assert nums.str() == '[1, 2, 3, 4, 100]'
|
2019-09-14 22:48:30 +02:00
|
|
|
assert nums2.str() == '[1, 2, 3, 4, 100]'
|
|
|
|
assert nums.slice(1, 3).str() == '[2, 3]'
|
|
|
|
}
|
|
|
|
|
2019-08-22 03:27:57 +02:00
|
|
|
fn test_doubling() {
|
|
|
|
mut nums := [1, 2, 3, 4, 5]
|
2020-02-24 17:55:16 +01:00
|
|
|
for i in 0..nums.len {
|
2019-08-22 03:27:57 +02:00
|
|
|
nums[i] *= 2
|
|
|
|
}
|
2020-03-26 22:09:25 +01:00
|
|
|
println(nums.str())
|
2019-08-22 03:27:57 +02:00
|
|
|
assert nums.str() == '[2, 4, 6, 8, 10]'
|
2019-08-22 06:56:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
struct Test2 {
|
|
|
|
one int
|
|
|
|
two int
|
|
|
|
}
|
|
|
|
|
|
|
|
struct Test {
|
|
|
|
a string
|
2019-08-30 19:19:06 +02:00
|
|
|
mut:
|
2019-08-22 06:56:29 +02:00
|
|
|
b []Test2
|
|
|
|
}
|
|
|
|
|
2020-03-27 10:47:24 +01:00
|
|
|
// TODO: default array/struct str methods
|
|
|
|
pub fn (ta []Test2) str() string {
|
|
|
|
mut s := '['
|
|
|
|
for i, t in ta {
|
|
|
|
s += t.str()
|
|
|
|
if i < ta.len-1 {
|
|
|
|
s += ', '
|
|
|
|
}
|
|
|
|
}
|
|
|
|
s += ']'
|
|
|
|
return s
|
|
|
|
}
|
|
|
|
|
2019-12-11 01:24:26 +01:00
|
|
|
pub fn (t Test2) str() string {
|
2019-08-22 06:56:29 +02:00
|
|
|
return '{$t.one $t.two}'
|
|
|
|
}
|
|
|
|
|
2020-01-21 18:49:30 +01:00
|
|
|
pub fn (t Test) str() string {
|
2019-08-22 06:56:29 +02:00
|
|
|
return '{$t.a $t.b}'
|
|
|
|
}
|
|
|
|
|
|
|
|
fn test_struct_print() {
|
2020-01-21 18:49:30 +01:00
|
|
|
mut a := Test{
|
|
|
|
a: 'Test'
|
2019-11-14 08:00:22 +01:00
|
|
|
b: []
|
2019-08-22 06:56:29 +02:00
|
|
|
}
|
2020-01-21 18:49:30 +01:00
|
|
|
b := Test2{
|
|
|
|
one: 1
|
2019-08-22 06:56:29 +02:00
|
|
|
two: 2
|
|
|
|
}
|
|
|
|
a.b << b
|
|
|
|
a.b << b
|
2020-04-23 04:23:19 +02:00
|
|
|
assert a.str() == '{Test [{1 2}, {1 2}]}'
|
|
|
|
assert b.str() == '{1 2}'
|
2019-08-22 06:56:29 +02:00
|
|
|
assert a.b.str() == '[{1 2}, {1 2}]'
|
|
|
|
}
|
2019-09-28 12:52:02 +02: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 00:11:39 +01:00
|
|
|
}
|
2019-10-04 22:07:19 +02:00
|
|
|
|
|
|
|
fn test_find_index() {
|
|
|
|
// string
|
|
|
|
a := ['v', 'is', 'great']
|
|
|
|
assert a.index('v') == 0
|
|
|
|
assert a.index('is') == 1
|
2020-01-21 18:49:30 +01:00
|
|
|
assert a.index('gre') == -1
|
2019-10-04 22:07:19 +02:00
|
|
|
// 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 15:03:13 +02:00
|
|
|
|
|
|
|
fn test_multi() {
|
2020-01-21 18:49:30 +01:00
|
|
|
a := [[1, 2, 3], [4, 5, 6]]
|
2019-10-05 15:03:13 +02:00
|
|
|
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
|
2020-01-21 18:49:30 +01:00
|
|
|
// b := [ [[1,2,3],[4,5,6]], [[1,2]] ]
|
|
|
|
// assert b[0][0][0] == 1
|
2019-10-09 14:26:27 +02:00
|
|
|
}
|
2019-10-06 03:27:29 +02:00
|
|
|
|
|
|
|
fn test_in() {
|
2020-01-21 18:49:30 +01:00
|
|
|
a := [1, 2, 3]
|
2019-10-06 03:27:29 +02:00
|
|
|
assert 1 in a
|
|
|
|
assert 2 in a
|
|
|
|
assert 3 in a
|
|
|
|
assert !(4 in a)
|
|
|
|
assert !(0 in a)
|
2020-04-11 23:01:50 +02:00
|
|
|
assert 0 !in a
|
|
|
|
assert 4 !in a
|
2019-10-09 14:26:27 +02:00
|
|
|
}
|
2019-10-08 12:23:17 +02:00
|
|
|
|
2019-10-11 03:12:40 +02:00
|
|
|
fn sum(prev int, curr int) int {
|
|
|
|
return prev + curr
|
|
|
|
}
|
|
|
|
|
|
|
|
fn sub(prev int, curr int) int {
|
|
|
|
return prev - curr
|
|
|
|
}
|
|
|
|
|
2020-02-18 18:13:34 +01:00
|
|
|
/*
|
2019-10-11 03:12:40 +02:00
|
|
|
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
|
|
|
|
}
|
2020-02-18 18:13:34 +01:00
|
|
|
*/
|
2019-10-17 09:44:20 +02:00
|
|
|
|
|
|
|
fn test_filter() {
|
|
|
|
a := [1, 2, 3, 4, 5, 6]
|
|
|
|
b := a.filter(it % 2 == 0)
|
2019-10-26 13:32:56 +02:00
|
|
|
assert b.len == 3
|
2019-10-17 09:44:20 +02: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'
|
2020-04-11 23:01:50 +02:00
|
|
|
////////
|
|
|
|
arr :=[1,2,3,4,5,6,7,8,9,10]
|
|
|
|
println(arr.filter(it % 2 == 0 || it % 3 == 0))
|
|
|
|
assert true
|
|
|
|
assert [1,2,3].len == 3
|
2020-04-11 23:32:00 +02:00
|
|
|
mut mut_arr := [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
|
|
|
|
mut_arr = mut_arr.filter(it < 4)
|
|
|
|
assert mut_arr.len == 3
|
|
|
|
|
2020-04-11 23:01:50 +02:00
|
|
|
// TODO
|
|
|
|
//assert arr.filter(arr % 2).len == 5
|
2019-12-06 00:11:39 +01:00
|
|
|
}
|
2019-10-25 21:40:52 +02:00
|
|
|
|
2019-10-26 13:32:56 +02:00
|
|
|
fn test_map() {
|
2020-03-25 17:04:13 +01:00
|
|
|
// QTODO
|
|
|
|
/*
|
2020-04-23 04:23:19 +02:00
|
|
|
println(1)
|
2019-10-26 13:32:56 +02:00
|
|
|
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 13:53:55 +02:00
|
|
|
bools := c.map(it == 'v')
|
|
|
|
assert bools.len == 3
|
|
|
|
assert bools[0] == true
|
|
|
|
assert bools[1] == false
|
|
|
|
assert bools[2] == false
|
2020-03-25 17:04:13 +01:00
|
|
|
*/
|
2019-12-06 00:11:39 +01:00
|
|
|
}
|
2019-10-26 13:32:56 +02:00
|
|
|
|
2019-10-25 21:40:52 +02:00
|
|
|
fn test_array_str() {
|
|
|
|
numbers := [1, 2, 3]
|
2020-04-23 04:23:19 +02:00
|
|
|
assert numbers == [1,2,3]
|
2019-10-25 21:40:52 +02:00
|
|
|
numbers2 := [numbers, [4, 5, 6]] // dup str() bug
|
2020-04-26 17:52:27 +02:00
|
|
|
_=numbers2
|
2019-10-25 21:40:52 +02:00
|
|
|
assert true
|
|
|
|
assert numbers.str() == '[1, 2, 3]'
|
2020-04-23 04:23:19 +02:00
|
|
|
// QTODO
|
|
|
|
//assert numbers2.str() == '[[1, 2, 3], [4, 5, 6]]'
|
|
|
|
|
2019-10-29 12:26:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
fn test_eq() {
|
2020-02-04 08:29:50 +01:00
|
|
|
/*
|
2020-01-21 18:49:30 +01:00
|
|
|
assert [5, 6, 7].eq([6, 7]) == false
|
|
|
|
assert [`a`, `b`].eq([`a`, `b`]) == true
|
2020-02-04 08:29:50 +01:00
|
|
|
*/
|
2019-10-29 12:26:00 +01:00
|
|
|
}
|
2019-11-05 15:15:19 +01:00
|
|
|
|
2019-11-18 22:27:27 +01: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 00:11:39 +01:00
|
|
|
}
|
2019-11-18 22:27:27 +01:00
|
|
|
|
2020-01-21 18:49:30 +01:00
|
|
|
fn test_f32_sort() {
|
2020-03-19 07:24:49 +01:00
|
|
|
mut f := [f32(50.0), 15, 1, 79, 38, 0, 27]
|
2020-01-21 18:49:30 +01:00
|
|
|
f.sort_with_compare(compare_f32)
|
|
|
|
assert f[0] == 0.0
|
|
|
|
assert f[1] == 1.0
|
|
|
|
assert f[6] == 79.0
|
|
|
|
}
|
2019-11-18 22:27:27 +01:00
|
|
|
|
2020-01-21 18:49:30 +01:00
|
|
|
fn test_f64_sort() {
|
2020-03-19 07:24:49 +01:00
|
|
|
mut f := [50.0, 15, 1, 79, 38, 0, 27]
|
2020-01-21 18:49:30 +01:00
|
|
|
f.sort_with_compare(compare_f64)
|
|
|
|
assert f[0] == 0.0
|
|
|
|
assert f[1] == 1.0
|
|
|
|
assert f[6] == 79.0
|
|
|
|
}
|
|
|
|
|
|
|
|
fn test_i64_sort() {
|
|
|
|
mut f := [i64(50), 15, 1, 79, 38, 0, 27]
|
|
|
|
f.sort_with_compare(compare_i64)
|
|
|
|
assert f[0] == 0
|
|
|
|
assert f[1] == 1
|
|
|
|
assert f[6] == 79
|
|
|
|
}
|
2019-11-18 22:27:27 +01:00
|
|
|
|
2019-11-06 16:19:03 +01:00
|
|
|
/*
|
2019-11-05 15:15:19 +01:00
|
|
|
fn test_for_last() {
|
|
|
|
numbers := [1, 2, 3, 4]
|
|
|
|
mut s := '['
|
|
|
|
for num in numbers {
|
|
|
|
s += '$num'
|
|
|
|
if !last {
|
|
|
|
s += ', '
|
2019-12-06 00:11:39 +01:00
|
|
|
|
|
|
|
}
|
|
|
|
}
|
2019-11-05 15:15:19 +01:00
|
|
|
s += ']'
|
|
|
|
assert s == '[1, 2, 3, 4]'
|
2019-12-06 00:11:39 +01:00
|
|
|
}
|
2019-11-06 16:19:03 +01:00
|
|
|
*/
|
2019-12-27 04:09:09 +01:00
|
|
|
|
2020-01-21 18:49:30 +01:00
|
|
|
|
2019-12-27 04:09:09 +01:00
|
|
|
struct Foo {
|
2020-01-21 18:49:30 +01:00
|
|
|
mut:
|
2019-12-27 04:09:09 +01:00
|
|
|
bar []int
|
|
|
|
}
|
|
|
|
|
|
|
|
fn test_in_struct() {
|
|
|
|
mut baz := Foo{
|
|
|
|
bar: [0, 0, 0]
|
|
|
|
}
|
|
|
|
baz.bar[0] += 2
|
|
|
|
baz.bar[0]++
|
|
|
|
assert baz.bar[0] == 3
|
|
|
|
}
|
2020-01-09 12:00:39 +01:00
|
|
|
|
|
|
|
fn test_bools() {
|
|
|
|
println('test b')
|
|
|
|
mut a := [true, false]
|
|
|
|
a << true
|
|
|
|
println(a)
|
|
|
|
}
|
2020-01-19 22:15:37 +01:00
|
|
|
|
|
|
|
fn test_push_many_self() {
|
|
|
|
mut actual_arr := [1, 2, 3, 4]
|
|
|
|
actual_arr << actual_arr
|
|
|
|
expected_arr := [1, 2, 3, 4, 1, 2, 3, 4]
|
|
|
|
assert actual_arr.len == expected_arr.len
|
2020-02-24 17:55:16 +01:00
|
|
|
for i in 0..actual_arr.len {
|
2020-01-19 22:15:37 +01:00
|
|
|
assert actual_arr[i] == expected_arr[i]
|
|
|
|
}
|
|
|
|
}
|
2020-01-21 03:22:18 +01:00
|
|
|
|
|
|
|
fn test_for() {
|
|
|
|
nums := [1,2,3]
|
|
|
|
mut sum := 0
|
2020-03-25 14:24:48 +01:00
|
|
|
for num in nums {
|
2020-01-21 03:22:18 +01:00
|
|
|
sum += num
|
|
|
|
}
|
|
|
|
assert sum == 6
|
|
|
|
}
|
2020-01-27 22:31:48 +01:00
|
|
|
|
|
|
|
fn test_clear() {
|
|
|
|
mut arr := [1,2,3]
|
|
|
|
assert arr.len == 3
|
|
|
|
arr.clear()
|
|
|
|
assert arr.len == 0
|
2020-02-04 08:29:50 +01:00
|
|
|
|
2020-01-27 22:31:48 +01:00
|
|
|
arr << 3
|
|
|
|
arr << 2
|
|
|
|
arr << 1
|
|
|
|
arr << 0
|
|
|
|
assert arr.len == 4
|
|
|
|
assert arr[0] == 3
|
|
|
|
assert arr[1] == 2
|
|
|
|
assert arr[2] == 1
|
|
|
|
assert arr[3] == 0
|
2020-02-04 08:29:50 +01:00
|
|
|
|
2020-01-27 22:31:48 +01:00
|
|
|
arr.clear()
|
|
|
|
assert arr.len == 0
|
2020-01-22 21:34:38 +01:00
|
|
|
}
|
2020-02-17 20:31:40 +01:00
|
|
|
|
|
|
|
fn test_trim() {
|
|
|
|
mut arr := [1,2,3,4,5,6,7,8,9]
|
|
|
|
assert arr.len == 9
|
2020-02-18 18:13:34 +01:00
|
|
|
|
2020-02-17 20:31:40 +01:00
|
|
|
arr.trim(9)
|
|
|
|
assert arr.len == 9
|
|
|
|
assert arr.last() == 9
|
2020-02-18 18:13:34 +01:00
|
|
|
|
2020-02-17 20:31:40 +01:00
|
|
|
arr.trim(7)
|
|
|
|
assert arr.len == 7
|
|
|
|
assert arr.last() == 7
|
2020-02-18 18:13:34 +01:00
|
|
|
|
2020-02-17 20:31:40 +01:00
|
|
|
arr.trim(2)
|
|
|
|
assert arr.len == 2
|
|
|
|
assert arr.last() == 2
|
|
|
|
}
|
2020-03-11 00:38:11 +01:00
|
|
|
|
|
|
|
fn test_hex(){
|
|
|
|
// array hex
|
|
|
|
st := [byte(`V`),`L`,`A`,`N`,`G`]
|
|
|
|
assert st.hex() == "564c414e47"
|
|
|
|
assert st.hex().len == 10
|
|
|
|
|
|
|
|
st1 := [byte(0x41)].repeat(100)
|
|
|
|
assert st1.hex() == "41".repeat(100)
|
|
|
|
}
|
2020-04-14 18:09:59 +02:00
|
|
|
|
2020-04-14 19:38:11 +02:00
|
|
|
fn test_left_shift_precendence() {
|
2020-04-26 11:56:27 +02:00
|
|
|
mut arr := []int{}
|
2020-04-14 19:38:11 +02:00
|
|
|
arr << 1 + 1
|
|
|
|
arr << 1 - 1
|
|
|
|
arr << 2 / 1
|
|
|
|
arr << 2 * 1
|
|
|
|
|
|
|
|
assert arr[0] == 2
|
|
|
|
assert arr[1] == 0
|
|
|
|
assert arr[2] == 2
|
|
|
|
assert arr[3] == 2
|
|
|
|
}
|
|
|
|
|
2020-04-14 18:09:59 +02:00
|
|
|
fn test_array_with_cap() {
|
2020-04-26 17:28:43 +02:00
|
|
|
a4 := []int{cap:10, len:1 }
|
|
|
|
assert a4.len == 1
|
|
|
|
assert a4.cap == 10
|
2020-04-26 17:52:27 +02:00
|
|
|
a5 := []int{len:1, cap:10}
|
|
|
|
assert a5.len == 1
|
|
|
|
assert a5.cap == 10
|
2020-04-14 18:09:59 +02:00
|
|
|
}
|