1 | import rand |
2 | |
3 | const strings = unique_strings(7000, 10) |
4 | |
5 | fn unique_strings(arr_len int, str_len int) []string { |
6 | mut arr := []string{cap: arr_len} |
7 | for arr.len < arr_len { |
8 | str := rand.string(str_len) |
9 | if str !in arr { |
10 | arr << str |
11 | } |
12 | } |
13 | return arr |
14 | } |
15 | |
16 | fn test_get_and_set_many() { |
17 | mut m := map[string]int{} |
18 | for i, s in strings { |
19 | m[s] = i |
20 | assert m[s] == i |
21 | assert m.len == i + 1 |
22 | } |
23 | for i, s in strings { |
24 | assert m[s] == i |
25 | } |
26 | assert m.len == strings.len |
27 | } |
28 | |
29 | fn test_for_in_many() { |
30 | mut m := map[string]int{} |
31 | for i, s in strings { |
32 | m[s] = i |
33 | } |
34 | for k, v in m { |
35 | assert m[k] == v |
36 | } |
37 | } |
38 | |
39 | fn test_keys_many() { |
40 | mut m := map[string]int{} |
41 | for i, s in strings { |
42 | m[s] = i |
43 | } |
44 | keys := m.keys() |
45 | assert keys.len == strings.len |
46 | assert keys.len == m.len |
47 | assert keys == strings |
48 | } |
49 | |
50 | fn test_values_many() { |
51 | mut m := map[string]int{} |
52 | for i, s in strings { |
53 | m[s] = i |
54 | } |
55 | values := m.values() |
56 | assert values.len == strings.len |
57 | assert values.len == m.len |
58 | } |
59 | |
60 | fn test_deletes_many() { |
61 | mut m := map[string]int{} |
62 | for i, s in strings { |
63 | m[s] = i |
64 | } |
65 | for i, s in strings { |
66 | m.delete(s) |
67 | assert m[s] == 0 |
68 | assert m.len == strings.len - (i + 1) |
69 | } |
70 | assert m.len == 0 |
71 | assert m.keys().len == 0 |
72 | assert m.values().len == 0 |
73 | } |
74 | |
75 | struct User { |
76 | mut: |
77 | name string |
78 | } |
79 | |
80 | struct Aaa { |
81 | mut: |
82 | m map[string]int |
83 | users map[string]User |
84 | } |
85 | |
86 | fn (mut a Aaa) set(key string, val int) { |
87 | a.m[key] = val |
88 | } |
89 | |
90 | fn test_map() { |
91 | mut m := map[string]int{} |
92 | assert m.len == 0 |
93 | m['hi'] = 80 |
94 | m['hello'] = 101 |
95 | assert m['hi'] == 80 |
96 | assert m['hello'] == 101 |
97 | assert m.len == 2 |
98 | assert 'hi' in m |
99 | mut sum := 0 |
100 | // Test `for in` |
101 | for _, val in m { |
102 | sum += val |
103 | } |
104 | assert sum == 80 + 101 |
105 | // Test `.keys()` |
106 | keys := m.keys() |
107 | assert keys.len == 2 |
108 | assert 'hi' in keys |
109 | assert 'hello' in keys |
110 | m.delete('hi') |
111 | assert m.len == 1 |
112 | m.delete('aloha') |
113 | assert m.len == 1 |
114 | assert m['hi'] == 0 |
115 | assert m.keys().len == 1 |
116 | assert m.keys()[0] == 'hello' |
117 | // Test `.values()` |
118 | values := m.values() |
119 | assert values.len == 1 |
120 | assert 80 !in values |
121 | assert 101 in values |
122 | assert m.values().len == 1 |
123 | assert m.values()[0] == 101 |
124 | // // |
125 | mut users := map[string]User{} |
126 | users['1'] = User{'Peter'} |
127 | peter := users['1'] |
128 | assert peter.name == 'Peter' |
129 | mut a := Aaa{ |
130 | m: map[string]int{} |
131 | users: map[string]User{} |
132 | } |
133 | a.users['Bob'] = User{'Bob'} |
134 | q := a.users['Bob'] |
135 | assert q.name == 'Bob' |
136 | // test struct field change |
137 | a.users['Bob'].name = 'bob' |
138 | q2 := a.users['Bob'] |
139 | assert q2.name == 'bob' |
140 | a.m['one'] = 1 |
141 | a.set('two', 2) |
142 | assert a.m['one'] == 1 |
143 | assert a.m['two'] == 2 |
144 | } |
145 | |
146 | fn test_map_init() { |
147 | one := 'one' |
148 | three := 'three' |
149 | m := { |
150 | one: 1 |
151 | 'two': 2 |
152 | three: 1 + 2 |
153 | } |
154 | assert m['one'] == 1 |
155 | assert m['two'] == 2 |
156 | assert m['three'] == 3 |
157 | assert m['unknown'] == 0 |
158 | } |
159 | |
160 | fn test_string_map() { |
161 | // m := map[string]Fn |
162 | } |
163 | |
164 | fn test_large_map() { |
165 | // ticks := time.ticks() |
166 | mut nums := map[string]int{} |
167 | n := 30 * 1000 |
168 | for i in 0 .. n { |
169 | key := i.str() |
170 | nums[key] = i |
171 | } |
172 | assert nums['1'] == 1 |
173 | assert nums['999'] == 999 |
174 | assert nums['1000000'] == 0 |
175 | // println(time.ticks() - ticks) |
176 | } |
177 | |
178 | fn test_various_map_value() { |
179 | mut m1 := map[string]int{} |
180 | m1['test'] = 1 |
181 | assert m1['test'] == 1 |
182 | mut m2 := map[string]string{} |
183 | m2['test'] = 'test' |
184 | assert m2['test'] == 'test' |
185 | mut m3 := map[string]i8{} |
186 | m3['test'] = i8(0) |
187 | assert m3['test'] == i8(0) |
188 | mut m4 := map[string]i16{} |
189 | m4['test'] = i16(0) |
190 | assert m4['test'] == i16(0) |
191 | mut m7 := map[string]u16{} |
192 | m7['test'] = u16(0) |
193 | assert m7['test'] == u16(0) |
194 | mut m8 := map[string]u32{} |
195 | m8['test'] = u32(0) |
196 | assert m8['test'] == u32(0) |
197 | mut m9 := map[string]bool{} |
198 | m9['test'] = true |
199 | assert m9['test'] == true |
200 | mut m10 := map[string]u8{} |
201 | m10['test'] = u8(0) |
202 | assert m10['test'] == u8(0) |
203 | mut m11 := map[string]f32{} |
204 | m11['test'] = f32(0.0) |
205 | assert m11['test'] == f32(0.0) |
206 | mut m12 := map[string]f64{} |
207 | m12['test'] = f64(0.0) |
208 | assert m12['test'] == f64(0.0) |
209 | // mut m13 := map[string]rune |
210 | // m13['test'] = rune(0) |
211 | // assert m13['test'] == rune(0) |
212 | mut m14 := map[string]voidptr{} |
213 | m14['test'] = unsafe { nil } |
214 | assert m14['test'] == unsafe { nil } |
215 | mut m15 := map[string]&u8{} |
216 | m15['test'] = &u8(0) |
217 | assert m15['test'] == &u8(0) |
218 | mut m16 := map[string]i64{} |
219 | m16['test'] = i64(0) |
220 | assert m16['test'] == i64(0) |
221 | mut m17 := map[string]u64{} |
222 | m17['test'] = u64(0) |
223 | assert m17['test'] == u64(0) |
224 | mut m18 := map[string]&int{} |
225 | m18['test'] = &int(0) |
226 | assert m18['test'] == &int(0) |
227 | } |
228 | |
229 | fn test_string_arr() { |
230 | mut m := map[string][]string{} |
231 | m['a'] = ['one', 'two'] |
232 | assert m['a'].len == 2 |
233 | assert m['a'][0] == 'one' |
234 | assert m['a'][1] == 'two' |
235 | } |
236 | |
237 | fn mut_map(mut m map[string]int) { |
238 | m['a'] = 10 |
239 | } |
240 | |
241 | fn test_mut_arg() { |
242 | mut m := map[string]int{} |
243 | mut_map(mut m) |
244 | a := m['a'] |
245 | assert a == 10 |
246 | } |
247 | |
248 | fn test_clear() { |
249 | mut m := map[string]int{} |
250 | m['one'] = 1 |
251 | m['two'] = 2 |
252 | m.clear() |
253 | assert m.len == 0 |
254 | } |
255 | |
256 | fn test_delete() { |
257 | mut m := map[string]int{} |
258 | m['one'] = 1 |
259 | m['two'] = 2 |
260 | println(m['two']) // => "2" |
261 | m.delete('two') |
262 | println(m['two'].str()) // => 0 |
263 | assert ('two' in m) == false |
264 | println('two' in m) // => true, on Linux and Windows <-- wrong ! |
265 | } |
266 | |
267 | fn test_delete_size() { |
268 | arr := ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'] |
269 | mut m := map[string]int{} |
270 | for _ in 0 .. 10 { |
271 | for i in 0 .. 10 { |
272 | m[arr[i]] = i |
273 | } |
274 | assert m.len == 10 |
275 | println(m.len) |
276 | for i in 0 .. 10 { |
277 | m.delete(arr[i]) |
278 | } |
279 | } |
280 | } |
281 | |
282 | fn test_nested_for_in() { |
283 | mut m := map[string]int{} |
284 | for i in 0 .. 1000 { |
285 | m[i.str()] = i |
286 | } |
287 | mut i := 0 |
288 | for key1, _ in m { |
289 | assert key1 == i.str() |
290 | i++ |
291 | mut j := 0 |
292 | for key2, _ in m { |
293 | assert key2 == j.str() |
294 | j++ |
295 | } |
296 | } |
297 | } |
298 | |
299 | fn test_delete_in_for_in() { |
300 | mut m := map[string]string{} |
301 | for i in 0 .. 1000 { |
302 | m[i.str()] = i.str() |
303 | } |
304 | mut i := 0 |
305 | for key, _ in m { |
306 | assert key == i.str() |
307 | m.delete(key) |
308 | i++ |
309 | } |
310 | assert m.str() == '{}' |
311 | assert m.len == 0 |
312 | } |
313 | |
314 | fn test_set_in_for_in() { |
315 | mut m := map[string]string{} |
316 | for i in 0 .. 10 { |
317 | m[i.str()] = i.str() |
318 | } |
319 | mut last_key := '' |
320 | mut i := 0 |
321 | for key, _ in m { |
322 | m['10'] = '10' |
323 | assert key == i.str() |
324 | last_key = key |
325 | i++ |
326 | } |
327 | assert last_key == '10' |
328 | } |
329 | |
330 | fn test_delete_and_set_in_for_in() { |
331 | mut m := map[string]string{} |
332 | for i in 0 .. 1000 { |
333 | m[i.str()] = i.str() |
334 | } |
335 | mut i := 0 |
336 | for key, _ in m { |
337 | assert key == i.str() |
338 | m.delete(key) |
339 | m[key] = i.str() |
340 | if i == 999 { |
341 | break |
342 | } |
343 | i++ |
344 | } |
345 | assert m.len == 1000 |
346 | i = 0 |
347 | for key, _ in m { |
348 | assert m[key] == i.str() |
349 | i++ |
350 | } |
351 | assert i == 1000 |
352 | } |
353 | |
354 | struct Mstruct1 { |
355 | pub mut: |
356 | mymap map[string]int |
357 | } |
358 | |
359 | struct Mstruct2 { |
360 | pub mut: |
361 | mymap map[string]f64 |
362 | } |
363 | |
364 | struct Mstruct3 { |
365 | pub mut: |
366 | mymap map[string]u16 |
367 | } |
368 | |
369 | fn test_map_assign() { |
370 | mut a := map[string]f64{} |
371 | mut b := map[string]int{} |
372 | mut c := map[string]u16{} |
373 | a = { |
374 | 'x': 12.4 |
375 | 'y': 3 |
376 | } |
377 | b = { |
378 | 'u': -13 |
379 | 'v': 12 |
380 | } |
381 | c = { |
382 | 's': u16(5) |
383 | 't': 3 |
384 | } |
385 | _ := Mstruct1{{ |
386 | 'p': 12 |
387 | }} |
388 | _ := Mstruct2{{ |
389 | 'q': 1.7 |
390 | }} |
391 | _ := Mstruct3{{ |
392 | 'r': u16(6) |
393 | 's': 5 |
394 | }} |
395 | } |
396 | |
397 | fn test_postfix_op_directly() { |
398 | mut a := map[string]int{} |
399 | a['aaa']++ |
400 | assert a['aaa'] == 1 |
401 | a['aaa']++ |
402 | assert a['aaa'] == 2 |
403 | a['bbb']-- |
404 | assert a['bbb'] == -1 |
405 | a['bbb']-- |
406 | assert a['bbb'] == -2 |
407 | } |
408 | |
409 | fn test_map_push_directly() { |
410 | mut a := map[string][]string{} |
411 | a['aaa'] << ['a', 'b', 'c'] |
412 | assert a['aaa'].len == 3 |
413 | assert a['aaa'] == ['a', 'b', 'c'] |
414 | } |
415 | |
416 | fn test_assign_directly() { |
417 | mut a := map[string]int{} |
418 | a['aaa'] += 4 |
419 | assert a['aaa'] == 4 |
420 | a['aaa'] -= 2 |
421 | assert a['aaa'] == 2 |
422 | } |
423 | |
424 | fn test_map_in_directly() { |
425 | for k, v in { |
426 | 'aa': 1 |
427 | } { |
428 | assert k == 'aa' |
429 | assert v == 1 |
430 | } |
431 | } |
432 | |
433 | fn test_plus_assign_string() { |
434 | mut m := { |
435 | 'one': '' |
436 | } |
437 | m['one'] += '1' |
438 | assert m.len == 1 |
439 | assert m['one'] == '1' |
440 | } |
441 | |
442 | fn test_map_keys_to_array() { |
443 | m := { |
444 | 'a': 'b' |
445 | 'c': 'd' |
446 | } |
447 | mut arr := []string{} |
448 | for k, _ in m { |
449 | arr << k |
450 | } |
451 | sarr := arr.str() |
452 | println(sarr) |
453 | assert sarr == "['a', 'c']" |
454 | } |
455 | |
456 | fn map_in_mut(mut m map[string]int) { |
457 | if 'one' in m { |
458 | m['one'] = 2 |
459 | } |
460 | } |
461 | |
462 | fn test_map_in_mut() { |
463 | mut m := { |
464 | 'one': 1 |
465 | } |
466 | map_in_mut(mut m) |
467 | assert m['one'] == 2 |
468 | } |
469 | |
470 | fn test_map_in() { |
471 | m := { |
472 | 'Foo': 'bar' |
473 | } |
474 | if 'foo'.capitalize() in m { |
475 | assert true |
476 | } else { |
477 | assert false |
478 | } |
479 | } |
480 | |
481 | fn mut_map_with_relation_op_in_fn(mut m map[string]int) { |
482 | if m['one'] == 1 { |
483 | m['three'] = 3 |
484 | } |
485 | if m['two'] != 1 { |
486 | m['four'] = 4 |
487 | } |
488 | if m['one'] > 0 { |
489 | m['five'] = 5 |
490 | } |
491 | if m['one'] < 2 { |
492 | m['six'] = 6 |
493 | } |
494 | if m['two'] >= 2 { |
495 | m['seven'] = 7 |
496 | } |
497 | if m['two'] <= 2 { |
498 | m['eight'] = 8 |
499 | } |
500 | } |
501 | |
502 | fn test_mut_map_with_relation_op_in_fn() { |
503 | mut m := { |
504 | 'one': 1 |
505 | 'two': 2 |
506 | } |
507 | mut_map_with_relation_op_in_fn(mut m) |
508 | assert 'three' in m |
509 | assert 'four' in m |
510 | assert 'five' in m |
511 | assert 'six' in m |
512 | assert 'seven' in m |
513 | assert 'eight' in m |
514 | } |
515 | |
516 | fn test_map_str_after_delete() { |
517 | mut m := { |
518 | 'first': 1 |
519 | 'second': 2 |
520 | 'third': 3 |
521 | } |
522 | osm := '${m}' |
523 | m.delete('second') |
524 | nsm := '${m}' |
525 | println('m: ${m}') |
526 | assert osm == "{'first': 1, 'second': 2, 'third': 3}" |
527 | assert nsm == "{'first': 1, 'third': 3}" |
528 | } |
529 | |
530 | fn test_modify_map_value() { |
531 | mut m1 := { |
532 | 'foo': 3 |
533 | 'bar': -7 |
534 | } |
535 | m1['foo'] += 5 |
536 | m1['bar'] *= -2 |
537 | assert m1['foo'] == 8 |
538 | assert m1['bar'] == 14 |
539 | } |
540 | |
541 | fn test_map_clone() { |
542 | mut nums := { |
543 | 'foo': 1 |
544 | 'bar': 2 |
545 | } |
546 | mut nums2 := nums.clone() |
547 | nums2['foo']++ |
548 | nums2['bar'] *= 4 |
549 | assert nums['foo'] == 1 |
550 | assert nums['bar'] == 2 |
551 | assert nums2['foo'] == 2 |
552 | assert nums2['bar'] == 8 |
553 | } |
554 | |
555 | struct MValue { |
556 | name string |
557 | misc map[string]string |
558 | } |
559 | |
560 | fn test_map_default_zero() { |
561 | m := map[string]MValue{} |
562 | v := m['unknown'] |
563 | x := v.misc['x'] |
564 | println(x) |
565 | assert x == '' |
566 | } |
567 | |
568 | fn test_map_or() { |
569 | m := { |
570 | 'first': 1 |
571 | 'second': 2 |
572 | 'third': 3 |
573 | } |
574 | _ = m |
575 | // num := m['first'] or { return } |
576 | } |
577 | |
578 | fn test_int_keys() { |
579 | mut m := map[int]int{} |
580 | m[3] = 9 |
581 | m[4] = 16 |
582 | assert m.len == 2 |
583 | assert m[3] == 9 |
584 | assert m[4] == 16 |
585 | m[5] += 24 |
586 | m[5]++ |
587 | assert m[5] == 25 |
588 | mut m2 := { |
589 | 3: 9 |
590 | 4: 16 |
591 | 5: 25 |
592 | } |
593 | |
594 | four := 4 |
595 | m2.delete(3) |
596 | m2.delete(four) |
597 | m2.delete(5) |
598 | assert m2.len == 0 |
599 | assert m2[3] == 0 |
600 | assert m2[4] == 0 |
601 | assert m2[5] == 0 |
602 | assert m2.keys() == [] |
603 | |
604 | m2 = { |
605 | 3: 9 |
606 | 4: 16 |
607 | 5: 25 |
608 | } |
609 | assert m2.values() == [9, 16, 25] |
610 | |
611 | assert m2.len == 3 |
612 | // clone |
613 | mc := m.clone() |
614 | same := mc == m |
615 | assert same |
616 | assert mc.len == 3 |
617 | assert mc.keys() == [3, 4, 5] |
618 | mut all := []int{} |
619 | for k, v in mc { |
620 | assert m[k] == v |
621 | all << k |
622 | all << v |
623 | } |
624 | assert all == [3, 9, 4, 16, 5, 25] |
625 | |
626 | mut m3 := { |
627 | 1: 'one' |
628 | 2: 'two' |
629 | } |
630 | assert m3[1] == 'one' |
631 | m3.delete(1) |
632 | } |
633 | |
634 | enum Color { |
635 | red |
636 | green |
637 | blue |
638 | } |
639 | |
640 | type ColorAlias = Color |
641 | |
642 | fn test_alias_enum() { |
643 | mut m := map[ColorAlias]string{} |
644 | m[Color.red] = 'hi' |
645 | assert m[Color.red] == 'hi' |
646 | } |
647 | |
648 | fn test_enum_in_map() { |
649 | mut m := map[Color]string{} |
650 | m[Color.red] = 'hi' |
651 | assert Color.red in m |
652 | assert Color.green !in m |
653 | assert Color.blue !in m |
654 | } |
655 | |
656 | fn test_voidptr_keys() { |
657 | mut m := map[voidptr]string{} |
658 | v := 5 |
659 | m[&v] = 'var' |
660 | m[&m] = 'map' |
661 | assert m[&v] == 'var' |
662 | assert m[&m] == 'map' |
663 | assert m.len == 2 |
664 | } |
665 | |
666 | fn test_voidptr_values() { |
667 | mut m := map[string]voidptr{} |
668 | v := 5 |
669 | m['var'] = &v |
670 | m['map'] = &m |
671 | assert m['var'] == &v |
672 | assert m['map'] == &m |
673 | assert m.values().len == 2 |
674 | } |
675 | |
676 | fn test_rune_keys() { |
677 | mut m := { |
678 | `!`: 2 |
679 | `%`: 3 |
680 | } |
681 | assert typeof(m).name == 'map[rune]int' |
682 | assert m[`!`] == 2 |
683 | m[`@`] = 7 |
684 | assert m.len == 3 |
685 | println(m) |
686 | assert '${m}' == '{`!`: 2, `%`: 3, `@`: 7}' |
687 | |
688 | mut a := []rune{} |
689 | for k, v in m { |
690 | a << k |
691 | a << rune(v) + `0` |
692 | } |
693 | assert a == [`!`, `2`, `%`, `3`, `@`, `7`] |
694 | } |
695 | |
696 | fn test_eq() { |
697 | a := { |
698 | 'a': 1 |
699 | 'b': 2 |
700 | } |
701 | assert a == { |
702 | 'a': 1 |
703 | 'b': 2 |
704 | } |
705 | b := { |
706 | 'a': [[1]] |
707 | 'b': [[2]] |
708 | } |
709 | assert b == { |
710 | 'a': [[1]] |
711 | 'b': [[2]] |
712 | } |
713 | c := { |
714 | 'a': { |
715 | '11': 1 |
716 | } |
717 | 'b': { |
718 | '22': 2 |
719 | } |
720 | } |
721 | assert c == { |
722 | 'a': { |
723 | '11': 1 |
724 | } |
725 | 'b': { |
726 | '22': 2 |
727 | } |
728 | } |
729 | d := { |
730 | 'a': MValue{ |
731 | name: 'aa' |
732 | misc: { |
733 | '11': '1' |
734 | } |
735 | } |
736 | 'b': MValue{ |
737 | name: 'bb' |
738 | misc: { |
739 | '22': '2' |
740 | } |
741 | } |
742 | } |
743 | assert d == { |
744 | 'a': MValue{ |
745 | name: 'aa' |
746 | misc: { |
747 | '11': '1' |
748 | } |
749 | } |
750 | 'b': MValue{ |
751 | name: 'bb' |
752 | misc: { |
753 | '22': '2' |
754 | } |
755 | } |
756 | } |
757 | } |
758 | |
759 | fn test_non_string_key_map_str() { |
760 | assert { |
761 | 23: 4 |
762 | }.str() == '{23: 4}' |
763 | assert { |
764 | `a`: 12 |
765 | `b`: 13 |
766 | }.str() == '{`a`: 12, `b`: 13}' |
767 | assert { |
768 | 23: 'foo' |
769 | 25: 'bar' |
770 | }.str() == "{23: 'foo', 25: 'bar'}" |
771 | } |
772 | |
773 | fn test_map_assign_empty_map_init() { |
774 | mut a := { |
775 | 'one': 1 |
776 | } |
777 | a = {} |
778 | println(a) |
779 | assert a == map[string]int{} |
780 | assert '${a}' == '{}' |
781 | } |
782 | |
783 | fn test_in_map_literal() { |
784 | assert 1 in { |
785 | 1: 'one' |
786 | } |
787 | } |
788 | |
789 | fn test_byte_keys() { |
790 | mut m := map[u8]u8{} |
791 | byte_max := u8(255) |
792 | for i in u8(0) .. byte_max { |
793 | m[i] = i |
794 | assert m[i] == i |
795 | } |
796 | for k, v in m { |
797 | assert k == v |
798 | } |
799 | for i in u8(0) .. 100 { |
800 | m[i]++ |
801 | assert m[i] == i + 1 |
802 | } |
803 | assert m.len == byte_max |
804 | keys := m.keys() |
805 | for i in u8(0) .. byte_max { |
806 | assert keys[i] == i |
807 | } |
808 | for i in u8(0) .. byte_max { |
809 | m.delete(i) |
810 | assert m[i] == 0 |
811 | } |
812 | assert m.len == 0 |
813 | } |
814 | |
815 | fn test_i16_keys() { |
816 | mut m := map[i16]i16{} |
817 | end := i16(1000) |
818 | for i in i16(0) .. end { |
819 | m[i] = i |
820 | assert m[i] == i |
821 | } |
822 | for k, v in m { |
823 | assert k == v |
824 | } |
825 | for i in i16(0) .. 500 { |
826 | m[i]++ |
827 | assert m[i] == i + 1 |
828 | } |
829 | assert m.len == end |
830 | keys := m.keys() |
831 | for i in i16(0) .. end { |
832 | assert keys[i] == i |
833 | } |
834 | for i in i16(0) .. end { |
835 | m.delete(i) |
836 | assert m[i] == 0 |
837 | } |
838 | assert m.len == 0 |
839 | } |
840 | |
841 | fn test_u16_keys() { |
842 | mut m := map[u16]u16{} |
843 | end := u16(1000) |
844 | for i in u16(0) .. end { |
845 | m[i] = i |
846 | assert m[i] == i |
847 | } |
848 | for k, v in m { |
849 | assert k == v |
850 | } |
851 | for i in u16(0) .. 500 { |
852 | m[i]++ |
853 | assert m[i] == i + 1 |
854 | } |
855 | assert m.len == end |
856 | keys := m.keys() |
857 | for i in u16(0) .. end { |
858 | assert keys[i] == i |
859 | } |
860 | for i in u16(0) .. end { |
861 | m.delete(i) |
862 | assert m[i] == 0 |
863 | } |
864 | assert m.len == 0 |
865 | } |
866 | |
867 | fn test_u32_keys() { |
868 | mut m := map[u32]u32{} |
869 | end := u32(1000) |
870 | for i in u32(0) .. end { |
871 | m[i] = i |
872 | assert m[i] == i |
873 | } |
874 | for k, v in m { |
875 | assert k == v |
876 | } |
877 | for i in u32(0) .. 500 { |
878 | m[i]++ |
879 | assert m[i] == i + 1 |
880 | } |
881 | assert m.len == end |
882 | keys := m.keys() |
883 | for i in u32(0) .. end { |
884 | assert keys[i] == i |
885 | } |
886 | for i in u32(0) .. end { |
887 | m.delete(i) |
888 | assert m[i] == 0 |
889 | } |
890 | assert m.len == 0 |
891 | } |
892 | |
893 | fn test_int_keys2() { |
894 | mut m := map[int]int{} |
895 | end := 1000 |
896 | for i in int(0) .. end { |
897 | m[i] = i |
898 | assert m[i] == i |
899 | } |
900 | for k, v in m { |
901 | assert k == v |
902 | } |
903 | for i in int(0) .. 500 { |
904 | m[i]++ |
905 | assert m[i] == i + 1 |
906 | } |
907 | assert m.len == end |
908 | keys := m.keys() |
909 | for i in int(0) .. end { |
910 | assert keys[i] == i |
911 | } |
912 | for i in int(0) .. end { |
913 | m.delete(i) |
914 | assert m[i] == 0 |
915 | } |
916 | assert m.len == 0 |
917 | } |
918 | |
919 | fn test_i64_keys() { |
920 | mut m := map[i64]i64{} |
921 | end := i64(1000) |
922 | for i in i64(0) .. end { |
923 | m[i] = i |
924 | assert m[i] == i |
925 | } |
926 | for k, v in m { |
927 | assert k == v |
928 | } |
929 | for i in i64(0) .. 500 { |
930 | m[i]++ |
931 | assert m[i] == i + 1 |
932 | } |
933 | assert m.len == end |
934 | keys := m.keys() |
935 | for i in i64(0) .. end { |
936 | assert keys[i] == i |
937 | } |
938 | for i in i64(0) .. end { |
939 | m.delete(i) |
940 | assert m[i] == 0 |
941 | } |
942 | assert m.len == 0 |
943 | } |
944 | |
945 | fn test_u64_keys() { |
946 | mut m := map[u64]u64{} |
947 | end := u64(1000) |
948 | for i in u64(0) .. end { |
949 | m[i] = i |
950 | assert m[i] == i |
951 | } |
952 | for k, v in m { |
953 | assert k == v |
954 | } |
955 | for i in u64(0) .. 500 { |
956 | m[i]++ |
957 | assert m[i] == i + 1 |
958 | } |
959 | assert u64(m.len) == end |
960 | keys := m.keys() |
961 | for i in u64(0) .. end { |
962 | assert keys[i] == i |
963 | } |
964 | for i in u64(0) .. end { |
965 | m.delete(i) |
966 | assert m[i] == 0 |
967 | } |
968 | assert m.len == 0 |
969 | } |
970 | |
971 | fn test_map_set_fixed_array_variable() { |
972 | mut m := map[string][2]f64{} |
973 | m['A'] = [1.1, 2.2]! |
974 | println(m) |
975 | assert '${m}' == "{'A': [1.1, 2.2]}" |
976 | |
977 | mut m2 := map[string][2]f64{} |
978 | arr := [1.1, 2.2]! |
979 | m2['A'] = arr |
980 | println(m2) |
981 | assert '${m2}' == "{'A': [1.1, 2.2]}" |
982 | } |
983 | |
984 | type Map = map[int]int |
985 | |
986 | fn test_alias_of_map_delete() { |
987 | mut m := Map(map[int]int{}) |
988 | m[11] = 111 |
989 | m[22] = 222 |
990 | println(m) |
991 | m.delete(11) |
992 | println(m) |
993 | assert m.len == 1 |
994 | assert m[22] == 222 |
995 | } |
996 | |
997 | struct State { |
998 | mut: |
999 | state map[string]rune |
1000 | } |
1001 | |
1002 | struct Foo { |
1003 | bar int |
1004 | baz int |
1005 | } |
1006 | |
1007 | fn (mut st State) add(s string, r rune) { |
1008 | st.state[s] = r |
1009 | } |
1010 | |
1011 | fn (mut st State) add2(foos []Foo) { |
1012 | for f in foos { |
1013 | st.state['${f.bar},${f.baz}'] = `z` |
1014 | } |
1015 | } |
1016 | |
1017 | fn (mut st State) reset() { |
1018 | st.state.clear() |
1019 | } |
1020 | |
1021 | fn test_map_clear() { |
1022 | mut s := State{} |
1023 | |
1024 | item1 := [Foo{ |
1025 | bar: 1 |
1026 | baz: 2 |
1027 | }, Foo{ |
1028 | bar: 3 |
1029 | baz: 4 |
1030 | }] |
1031 | s.add2(item1) |
1032 | assert s.state.len == 2 |
1033 | |
1034 | s.reset() |
1035 | s.add2(item1) |
1036 | assert s.state.len == 2 |
1037 | } |