2019-09-23 12:42:20 +02:00
|
|
|
// import time
|
2019-08-31 15:24:37 +02:00
|
|
|
|
2019-06-30 22:44:15 +02:00
|
|
|
struct User {
|
2019-08-31 15:24:37 +02:00
|
|
|
name string
|
|
|
|
}
|
2019-06-30 22:44:15 +02:00
|
|
|
|
2019-06-30 13:44:08 +02:00
|
|
|
struct A {
|
2019-08-31 15:24:37 +02:00
|
|
|
m map[string]int
|
|
|
|
users map[string]User
|
2019-06-30 13:44:08 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
fn (a mut A) set(key string, val int) {
|
|
|
|
a.m[key] = val
|
|
|
|
}
|
|
|
|
|
|
|
|
fn test_map() {
|
2019-08-16 17:44:35 +02:00
|
|
|
mut m := map[string]int
|
2019-08-31 15:24:37 +02:00
|
|
|
assert m.size == 0
|
2019-06-30 13:44:08 +02:00
|
|
|
m['hi'] = 80
|
2019-08-31 15:24:37 +02:00
|
|
|
m['hello'] = 101
|
2019-06-30 13:44:08 +02:00
|
|
|
assert m['hi'] == 80
|
2019-08-31 15:24:37 +02:00
|
|
|
assert m['hello'] == 101
|
|
|
|
assert m.size == 2
|
|
|
|
assert 'hi' in m
|
2019-07-14 11:01:32 +02:00
|
|
|
mut sum := 0
|
2019-08-31 15:24:37 +02:00
|
|
|
// Test `for in`
|
2019-07-14 11:01:32 +02:00
|
|
|
for key, val in m {
|
2019-08-31 15:24:37 +02:00
|
|
|
sum += val
|
|
|
|
}
|
|
|
|
assert sum == 80 + 101
|
|
|
|
// Test `.keys()`
|
|
|
|
keys := m.keys()
|
|
|
|
assert keys.len == 2
|
2020-01-24 20:13:59 +01:00
|
|
|
assert 'hi' in keys
|
|
|
|
assert 'hello' in keys
|
2019-08-31 15:24:37 +02:00
|
|
|
m.delete('hi')
|
|
|
|
assert m.size == 1
|
2019-10-30 18:19:59 +01:00
|
|
|
m.delete('aloha')
|
|
|
|
assert m.size == 1
|
2019-07-31 10:46:00 +02:00
|
|
|
|
2019-07-30 21:27:31 +02:00
|
|
|
assert m['hi'] == 0
|
2019-08-31 15:24:37 +02:00
|
|
|
assert m.keys().len == 1
|
|
|
|
assert m.keys()[0] == 'hello'
|
|
|
|
////
|
|
|
|
mut users := map[string]User
|
|
|
|
users['1'] = User{'Peter'}
|
2019-06-30 22:44:15 +02:00
|
|
|
peter := users['1']
|
2019-08-31 15:24:37 +02:00
|
|
|
assert peter.name == 'Peter'
|
2019-06-30 13:44:08 +02:00
|
|
|
mut a := A{
|
2019-08-31 15:24:37 +02:00
|
|
|
m: map[string]int
|
|
|
|
users: map[string]User
|
2019-06-30 13:44:08 +02:00
|
|
|
}
|
2019-08-31 15:24:37 +02:00
|
|
|
a.users['Bob'] = User{'Bob'}
|
|
|
|
q := a.users['Bob']
|
|
|
|
assert q.name == 'Bob'
|
2019-06-30 13:44:08 +02:00
|
|
|
a.m['one'] = 1
|
|
|
|
a.set('two', 2)
|
|
|
|
assert a.m['one'] == 1
|
|
|
|
assert a.m['two'] == 2
|
|
|
|
}
|
2019-07-14 11:01:32 +02:00
|
|
|
|
2019-08-03 09:44:08 +02:00
|
|
|
fn test_map_init() {
|
2019-08-31 15:24:37 +02:00
|
|
|
m := { 'one': 1, 'two': 2 }
|
|
|
|
assert m['one'] == 1
|
|
|
|
assert m['two'] == 2
|
|
|
|
assert m['three'] == 0
|
|
|
|
}
|
2019-08-03 09:44:08 +02:00
|
|
|
|
2019-07-14 11:01:32 +02:00
|
|
|
fn test_string_map() {
|
|
|
|
//m := map[string]Fn
|
2019-08-31 15:24:37 +02:00
|
|
|
}
|
2019-07-14 11:01:32 +02:00
|
|
|
|
2019-08-31 15:24:37 +02:00
|
|
|
fn test_large_map() {
|
|
|
|
//ticks := time.ticks()
|
|
|
|
mut nums := map[string]int
|
2019-07-14 11:01:32 +02:00
|
|
|
N := 30 * 1000
|
2020-02-24 17:55:16 +01:00
|
|
|
for i in 0..N {
|
2019-07-14 11:01:32 +02:00
|
|
|
key := i.str()
|
|
|
|
nums[key] = i
|
|
|
|
}
|
2019-08-31 15:24:37 +02:00
|
|
|
assert nums['1'] == 1
|
|
|
|
assert nums['999'] == 999
|
|
|
|
assert nums['1000000'] == 0
|
|
|
|
//println(time.ticks() - ticks)
|
|
|
|
}
|
2019-07-15 12:33:18 +02:00
|
|
|
|
|
|
|
fn test_various_map_value() {
|
2019-08-16 17:44:35 +02:00
|
|
|
mut m1 := map[string]int
|
2019-07-15 12:33:18 +02:00
|
|
|
m1['test'] = 1
|
|
|
|
assert m1['test'] == 1
|
2019-12-19 19:17:12 +01:00
|
|
|
|
2019-08-16 17:44:35 +02:00
|
|
|
mut m2 := map[string]string
|
2019-07-15 12:33:18 +02:00
|
|
|
m2['test'] = 'test'
|
|
|
|
assert m2['test'] == 'test'
|
2019-12-19 19:17:12 +01:00
|
|
|
|
2019-08-16 17:44:35 +02:00
|
|
|
mut m3 := map[string]i8
|
2019-07-15 12:33:18 +02:00
|
|
|
m3['test'] = i8(0)
|
|
|
|
assert m3['test'] == i8(0)
|
2019-12-19 19:17:12 +01:00
|
|
|
|
2019-08-16 17:44:35 +02:00
|
|
|
mut m4 := map[string]i16
|
2019-07-15 12:33:18 +02:00
|
|
|
m4['test'] = i16(0)
|
|
|
|
assert m4['test'] == i16(0)
|
2019-12-19 19:17:12 +01:00
|
|
|
|
2019-08-16 17:44:35 +02:00
|
|
|
mut m7 := map[string]u16
|
2019-07-15 12:33:18 +02:00
|
|
|
m7['test'] = u16(0)
|
|
|
|
assert m7['test'] == u16(0)
|
2019-12-19 19:17:12 +01:00
|
|
|
|
2019-08-16 17:44:35 +02:00
|
|
|
mut m8 := map[string]u32
|
2019-07-15 12:33:18 +02:00
|
|
|
m8['test'] = u32(0)
|
|
|
|
assert m8['test'] == u32(0)
|
2019-12-19 19:17:12 +01:00
|
|
|
|
2019-08-16 17:44:35 +02:00
|
|
|
mut m9 := map[string]bool
|
2019-07-15 12:33:18 +02:00
|
|
|
m9['test'] = true
|
|
|
|
assert m9['test'] == true
|
2019-12-19 19:17:12 +01:00
|
|
|
|
2019-08-16 17:44:35 +02:00
|
|
|
mut m10 := map[string]byte
|
2019-07-15 12:33:18 +02:00
|
|
|
m10['test'] = byte(0)
|
|
|
|
assert m10['test'] == byte(0)
|
2019-12-19 19:17:12 +01:00
|
|
|
|
2019-08-16 17:44:35 +02:00
|
|
|
mut m11 := map[string]f32
|
2019-07-15 12:33:18 +02:00
|
|
|
m11['test'] = f32(0.0)
|
|
|
|
assert m11['test'] == f32(0.0)
|
2019-12-19 19:17:12 +01:00
|
|
|
|
2019-08-16 17:44:35 +02:00
|
|
|
mut m12 := map[string]f64
|
2019-07-15 12:33:18 +02:00
|
|
|
m12['test'] = f64(0.0)
|
|
|
|
assert m12['test'] == f64(0.0)
|
|
|
|
|
2019-08-16 17:44:35 +02:00
|
|
|
mut m13 := map[string]rune
|
2019-07-15 12:33:18 +02:00
|
|
|
m13['test'] = rune(0)
|
|
|
|
assert m13['test'] == rune(0)
|
|
|
|
|
2019-12-21 23:44:16 +01:00
|
|
|
mut m14 := map[string]voidptr
|
|
|
|
m14['test'] = voidptr(0)
|
|
|
|
assert m14['test'] == voidptr(0)
|
2019-07-15 12:33:18 +02:00
|
|
|
|
2019-12-21 23:44:16 +01:00
|
|
|
mut m15 := map[string]byteptr
|
|
|
|
m15['test'] = byteptr(0)
|
|
|
|
assert m15['test'] == byteptr(0)
|
2019-07-18 04:32:49 +02:00
|
|
|
|
2019-08-16 17:44:35 +02:00
|
|
|
mut m16 := map[string]i64
|
2019-07-18 04:32:49 +02:00
|
|
|
m16['test'] = i64(0)
|
|
|
|
assert m16['test'] == i64(0)
|
|
|
|
|
2019-08-16 17:44:35 +02:00
|
|
|
mut m17 := map[string]u64
|
2019-07-18 04:32:49 +02:00
|
|
|
m17['test'] = u64(0)
|
|
|
|
assert m17['test'] == u64(0)
|
2019-12-21 23:44:16 +01:00
|
|
|
|
|
|
|
mut m18 := map[string]&int
|
|
|
|
m18['test'] = &int(0)
|
|
|
|
assert m18['test'] == &int(0)
|
2019-07-15 12:33:18 +02:00
|
|
|
}
|
2019-08-16 17:44:35 +02:00
|
|
|
|
|
|
|
|
|
|
|
fn test_string_arr() {
|
2019-08-31 15:24:37 +02:00
|
|
|
mut m := map[string][]string
|
|
|
|
m['a'] = ['one', 'two']
|
|
|
|
assert m['a'].len == 2
|
|
|
|
assert m['a'][0] == 'one'
|
|
|
|
assert m['a'][1] == 'two'
|
|
|
|
}
|
|
|
|
|
2019-11-12 20:35:53 +01:00
|
|
|
fn mut_map(m mut map[string]int) {
|
|
|
|
m['a'] = 10
|
|
|
|
}
|
|
|
|
|
|
|
|
fn test_mut_arg() {
|
|
|
|
mut m := map[string]int
|
|
|
|
mut_map(mut m)
|
|
|
|
assert m['a'] == 10
|
|
|
|
}
|
|
|
|
|
2019-11-22 18:05:27 +01:00
|
|
|
fn test_delete() {
|
|
|
|
mut m := map[string]int
|
|
|
|
m['one'] = 1
|
|
|
|
m['two'] = 2
|
|
|
|
println(m['two']) // => "2"
|
|
|
|
m.delete('two')
|
|
|
|
println(m['two']) // => 0
|
|
|
|
assert 'two' in m == false
|
|
|
|
println('two' in m) // => true, on Linux and Windows <-- wrong !
|
2019-12-19 19:17:12 +01:00
|
|
|
}
|
2019-11-22 18:05:27 +01:00
|
|
|
|
2019-08-31 15:24:37 +02:00
|
|
|
/*
|
|
|
|
fn test_ref() {
|
|
|
|
m := { 'one': 1 }
|
|
|
|
// TODO "cannot take the address of m['one']"
|
|
|
|
mut one := &m['one']
|
|
|
|
one++
|
|
|
|
println(*one)
|
2019-12-19 19:17:12 +01:00
|
|
|
|
2019-08-31 15:24:37 +02:00
|
|
|
}
|
|
|
|
*/
|
2019-12-19 19:17:12 +01:00
|
|
|
|
|
|
|
fn test_delete_size() {
|
|
|
|
arr := ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
|
|
|
|
mut m := map[string]int
|
|
|
|
for _ in 0..10 {
|
|
|
|
for i in 0..10 {
|
|
|
|
m[arr[i]] = i
|
|
|
|
}
|
|
|
|
assert(m.size == 10)
|
|
|
|
println(m.size)
|
|
|
|
for i in 0..10 {
|
|
|
|
m.delete(arr[i])
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|