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

208 lines
3.7 KiB
V
Raw Normal View History

2019-09-23 13:42:20 +03:00
// import time
2019-08-31 16:24:37 +03:00
struct User {
2019-08-31 16:24:37 +03:00
name string
}
2019-06-30 14:44:08 +03:00
struct A {
2019-08-31 16:24:37 +03:00
m map[string]int
users map[string]User
2019-06-30 14:44:08 +03:00
}
fn (a mut A) set(key string, val int) {
a.m[key] = val
}
fn test_map() {
2019-08-16 18:44:35 +03:00
mut m := map[string]int
2019-08-31 16:24:37 +03:00
assert m.size == 0
2019-06-30 14:44:08 +03:00
m['hi'] = 80
2019-08-31 16:24:37 +03:00
m['hello'] = 101
2019-06-30 14:44:08 +03:00
assert m['hi'] == 80
2019-08-31 16:24:37 +03:00
assert m['hello'] == 101
assert m.size == 2
assert 'hi' in m
2019-07-14 12:01:32 +03:00
mut sum := 0
2019-08-31 16:24:37 +03:00
mut key_sum := ''
// Test `for in`
2019-07-14 12:01:32 +03:00
for key, val in m {
2019-08-31 16:24:37 +03:00
sum += val
key_sum += key
}
assert sum == 80 + 101
assert key_sum == 'hihello'
// Test `.keys()`
keys := m.keys()
assert keys.len == 2
2019-07-14 12:01:32 +03:00
assert keys[0] == 'hi'
2019-08-31 16:24:37 +03:00
assert keys[1] == 'hello'
m.delete('hi')
assert m.size == 1
m.delete('aloha')
assert m.size == 1
2019-07-30 22:27:31 +03:00
assert m['hi'] == 0
2019-08-31 16:24:37 +03:00
assert m.keys().len == 1
assert m.keys()[0] == 'hello'
////
mut users := map[string]User
users['1'] = User{'Peter'}
peter := users['1']
2019-08-31 16:24:37 +03:00
assert peter.name == 'Peter'
2019-06-30 14:44:08 +03:00
mut a := A{
2019-08-31 16:24:37 +03:00
m: map[string]int
users: map[string]User
2019-06-30 14:44:08 +03:00
}
2019-08-31 16:24:37 +03:00
a.users['Bob'] = User{'Bob'}
q := a.users['Bob']
assert q.name == 'Bob'
2019-06-30 14:44:08 +03:00
a.m['one'] = 1
a.set('two', 2)
assert a.m['one'] == 1
assert a.m['two'] == 2
}
2019-07-14 12:01:32 +03:00
2019-08-03 10:44:08 +03:00
fn test_map_init() {
2019-08-31 16:24:37 +03:00
m := { 'one': 1, 'two': 2 }
assert m['one'] == 1
assert m['two'] == 2
assert m['three'] == 0
}
2019-08-03 10:44:08 +03:00
2019-07-14 12:01:32 +03:00
fn test_string_map() {
//m := map[string]Fn
2019-08-31 16:24:37 +03:00
}
2019-07-14 12:01:32 +03:00
2019-08-31 16:24:37 +03:00
fn test_large_map() {
//ticks := time.ticks()
mut nums := map[string]int
2019-07-14 12:01:32 +03:00
N := 30 * 1000
for i := 0; i < N; i++ {
key := i.str()
nums[key] = i
}
2019-08-31 16:24:37 +03:00
assert nums['1'] == 1
assert nums['999'] == 999
assert nums['1000000'] == 0
//println(time.ticks() - ticks)
}
2019-07-15 13:33:18 +03:00
fn test_various_map_value() {
2019-08-16 18:44:35 +03:00
mut m1 := map[string]int
2019-07-15 13:33:18 +03:00
m1['test'] = 1
assert m1['test'] == 1
2019-12-19 21:17:12 +03:00
2019-08-16 18:44:35 +03:00
mut m2 := map[string]string
2019-07-15 13:33:18 +03:00
m2['test'] = 'test'
assert m2['test'] == 'test'
2019-12-19 21:17:12 +03:00
2019-08-16 18:44:35 +03:00
mut m3 := map[string]i8
2019-07-15 13:33:18 +03:00
m3['test'] = i8(0)
assert m3['test'] == i8(0)
2019-12-19 21:17:12 +03:00
2019-08-16 18:44:35 +03:00
mut m4 := map[string]i16
2019-07-15 13:33:18 +03:00
m4['test'] = i16(0)
assert m4['test'] == i16(0)
2019-12-19 21:17:12 +03:00
2019-08-16 18:44:35 +03:00
mut m7 := map[string]u16
2019-07-15 13:33:18 +03:00
m7['test'] = u16(0)
assert m7['test'] == u16(0)
2019-12-19 21:17:12 +03:00
2019-08-16 18:44:35 +03:00
mut m8 := map[string]u32
2019-07-15 13:33:18 +03:00
m8['test'] = u32(0)
assert m8['test'] == u32(0)
2019-12-19 21:17:12 +03:00
2019-08-16 18:44:35 +03:00
mut m9 := map[string]bool
2019-07-15 13:33:18 +03:00
m9['test'] = true
assert m9['test'] == true
2019-12-19 21:17:12 +03:00
2019-08-16 18:44:35 +03:00
mut m10 := map[string]byte
2019-07-15 13:33:18 +03:00
m10['test'] = byte(0)
assert m10['test'] == byte(0)
2019-12-19 21:17:12 +03:00
2019-08-16 18:44:35 +03:00
mut m11 := map[string]f32
2019-07-15 13:33:18 +03:00
m11['test'] = f32(0.0)
assert m11['test'] == f32(0.0)
2019-12-19 21:17:12 +03:00
2019-08-16 18:44:35 +03:00
mut m12 := map[string]f64
2019-07-15 13:33:18 +03:00
m12['test'] = f64(0.0)
assert m12['test'] == f64(0.0)
2019-08-16 18:44:35 +03:00
mut m13 := map[string]rune
2019-07-15 13:33:18 +03:00
m13['test'] = rune(0)
assert m13['test'] == rune(0)
2019-08-16 18:44:35 +03:00
//mut m14 := map[string]voidptr
//m14['test'] = voidptr(0)
//assert m14['test'] == voidptr(0)
2019-07-15 13:33:18 +03:00
2019-08-16 18:44:35 +03:00
//mut m15 := map[string]byteptr
//m15['test'] = byteptr(0)
//assert m15['test'] == byteptr(0)
2019-07-18 05:32:49 +03:00
2019-08-16 18:44:35 +03:00
mut m16 := map[string]i64
2019-07-18 05:32:49 +03:00
m16['test'] = i64(0)
assert m16['test'] == i64(0)
2019-08-16 18:44:35 +03:00
mut m17 := map[string]u64
2019-07-18 05:32:49 +03:00
m17['test'] = u64(0)
assert m17['test'] == u64(0)
2019-07-15 13:33:18 +03:00
}
2019-08-16 18:44:35 +03:00
fn test_string_arr() {
2019-08-31 16:24:37 +03: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 22:35:53 +03: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 20:05:27 +03: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 21:17:12 +03:00
}
2019-11-22 20:05:27 +03:00
2019-08-31 16:24:37 +03: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 21:17:12 +03:00
2019-08-31 16:24:37 +03:00
}
*/
2019-12-19 21:17:12 +03: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])
}
}
}