Mercurial > vim
annotate src/testdir/test_listdict.vim @ 30069:cb21745cbbab v9.0.0372
patch 9.0.0372: MS-Windows: "%T" time format does not appear to work
Commit: https://github.com/vim/vim/commit/5fbbec180b623cd6ebfc9528be6fa70b4cf664d4
Author: Bram Moolenaar <Bram@vim.org>
Date: Sat Sep 3 22:08:11 2022 +0100
patch 9.0.0372: MS-Windows: "%T" time format does not appear to work
Problem: MS-Windows: "%T" time format does not appear to work.
Solution: Use "%H:%M:%S" instead.
author | Bram Moolenaar <Bram@vim.org> |
---|---|
date | Sat, 03 Sep 2022 23:15:03 +0200 |
parents | fd855ad74887 |
children | d58afefecd6c |
rev | line source |
---|---|
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
1 " Tests for the List and Dict types |
26638
6fd15d82e898
patch 8.2.3848: cannot use reduce() for a string
Bram Moolenaar <Bram@vim.org>
parents:
26626
diff
changeset
|
2 scriptencoding utf-8 |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
3 |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
4 import './vim9.vim' as v9 |
25308
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
5 |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
6 func TearDown() |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
7 " Run garbage collection after every test |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
8 call test_garbagecollect_now() |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
9 endfunc |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
10 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
11 " Tests for List type |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
12 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
13 " List creation |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
14 func Test_list_create() |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
15 " Creating List directly with different types |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
16 let l = [1, 'as''d', [1, 2, function("strlen")], {'a': 1},] |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
17 call assert_equal("[1, 'as''d', [1, 2, function('strlen')], {'a': 1}]", string(l)) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
18 call assert_equal({'a' : 1}, l[-1]) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
19 call assert_equal(1, l[-4]) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
20 let x = 10 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
21 try |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
22 let x = l[-5] |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
23 catch |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
24 call assert_match('E684:', v:exception) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
25 endtry |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
26 call assert_equal(10, x) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
27 endfunc |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
28 |
21556
963913d80284
patch 8.2.1328: no space allowed before comma in list
Bram Moolenaar <Bram@vim.org>
parents:
21512
diff
changeset
|
29 " This was allowed in legacy Vim script |
963913d80284
patch 8.2.1328: no space allowed before comma in list
Bram Moolenaar <Bram@vim.org>
parents:
21512
diff
changeset
|
30 let s:list_with_spaces = [1 , 2 , 3] |
963913d80284
patch 8.2.1328: no space allowed before comma in list
Bram Moolenaar <Bram@vim.org>
parents:
21512
diff
changeset
|
31 |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
32 " List slices |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
33 func Test_list_slice() |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
34 let l = [1, 'as''d', [1, 2, function("strlen")], {'a': 1},] |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
35 call assert_equal([1, 'as''d', [1, 2, function('strlen')], {'a': 1}], l[:]) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
36 call assert_equal(['as''d', [1, 2, function('strlen')], {'a': 1}], l[1:]) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
37 call assert_equal([1, 'as''d', [1, 2, function('strlen')]], l[:-2]) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
38 call assert_equal([1, 'as''d', [1, 2, function('strlen')], {'a': 1}], l[0:8]) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
39 call assert_equal([], l[8:-1]) |
19724
b3e93a05c3ca
patch 8.2.0418: code in eval.c not sufficiently covered by tests
Bram Moolenaar <Bram@vim.org>
parents:
19689
diff
changeset
|
40 call assert_equal([], l[0:-10]) |
20128
0b35a7ffceb2
patch 8.2.0619: null dict is not handled like an empty dict
Bram Moolenaar <Bram@vim.org>
parents:
20109
diff
changeset
|
41 " perform an operation on a list slice |
0b35a7ffceb2
patch 8.2.0619: null dict is not handled like an empty dict
Bram Moolenaar <Bram@vim.org>
parents:
20109
diff
changeset
|
42 let l = [1, 2, 3] |
0b35a7ffceb2
patch 8.2.0619: null dict is not handled like an empty dict
Bram Moolenaar <Bram@vim.org>
parents:
20109
diff
changeset
|
43 let l[:1] += [1, 2] |
0b35a7ffceb2
patch 8.2.0619: null dict is not handled like an empty dict
Bram Moolenaar <Bram@vim.org>
parents:
20109
diff
changeset
|
44 let l[2:] -= [1] |
0b35a7ffceb2
patch 8.2.0619: null dict is not handled like an empty dict
Bram Moolenaar <Bram@vim.org>
parents:
20109
diff
changeset
|
45 call assert_equal([2, 4, 2], l) |
25599
b85e44974a08
patch 8.2.3336: behavior of negative index in list change changed
Bram Moolenaar <Bram@vim.org>
parents:
25597
diff
changeset
|
46 |
b85e44974a08
patch 8.2.3336: behavior of negative index in list change changed
Bram Moolenaar <Bram@vim.org>
parents:
25597
diff
changeset
|
47 let lines =<< trim END |
b85e44974a08
patch 8.2.3336: behavior of negative index in list change changed
Bram Moolenaar <Bram@vim.org>
parents:
25597
diff
changeset
|
48 VAR l = [1, 2] |
b85e44974a08
patch 8.2.3336: behavior of negative index in list change changed
Bram Moolenaar <Bram@vim.org>
parents:
25597
diff
changeset
|
49 call assert_equal([1, 2], l[:]) |
b85e44974a08
patch 8.2.3336: behavior of negative index in list change changed
Bram Moolenaar <Bram@vim.org>
parents:
25597
diff
changeset
|
50 call assert_equal([2], l[-1 : -1]) |
b85e44974a08
patch 8.2.3336: behavior of negative index in list change changed
Bram Moolenaar <Bram@vim.org>
parents:
25597
diff
changeset
|
51 call assert_equal([1, 2], l[-2 : -1]) |
b85e44974a08
patch 8.2.3336: behavior of negative index in list change changed
Bram Moolenaar <Bram@vim.org>
parents:
25597
diff
changeset
|
52 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
53 call v9.CheckLegacyAndVim9Success(lines) |
25599
b85e44974a08
patch 8.2.3336: behavior of negative index in list change changed
Bram Moolenaar <Bram@vim.org>
parents:
25597
diff
changeset
|
54 |
b85e44974a08
patch 8.2.3336: behavior of negative index in list change changed
Bram Moolenaar <Bram@vim.org>
parents:
25597
diff
changeset
|
55 let l = [1, 2] |
b85e44974a08
patch 8.2.3336: behavior of negative index in list change changed
Bram Moolenaar <Bram@vim.org>
parents:
25597
diff
changeset
|
56 call assert_equal([], l[-3 : -1]) |
b85e44974a08
patch 8.2.3336: behavior of negative index in list change changed
Bram Moolenaar <Bram@vim.org>
parents:
25597
diff
changeset
|
57 |
b85e44974a08
patch 8.2.3336: behavior of negative index in list change changed
Bram Moolenaar <Bram@vim.org>
parents:
25597
diff
changeset
|
58 let lines =<< trim END |
b85e44974a08
patch 8.2.3336: behavior of negative index in list change changed
Bram Moolenaar <Bram@vim.org>
parents:
25597
diff
changeset
|
59 var l = [1, 2] |
b85e44974a08
patch 8.2.3336: behavior of negative index in list change changed
Bram Moolenaar <Bram@vim.org>
parents:
25597
diff
changeset
|
60 assert_equal([1, 2], l[-3 : -1]) |
b85e44974a08
patch 8.2.3336: behavior of negative index in list change changed
Bram Moolenaar <Bram@vim.org>
parents:
25597
diff
changeset
|
61 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
62 call v9.CheckDefAndScriptSuccess(lines) |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
63 endfunc |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
64 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
65 " List identity |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
66 func Test_list_identity() |
25308
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
67 let lines =<< trim END |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
68 VAR l = [1, 'as''d', [1, 2, function("strlen")], {'a': 1},] |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
69 VAR ll = l |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
70 VAR lx = copy(l) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
71 call assert_true(l == ll) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
72 call assert_false(l isnot ll) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
73 call assert_true(l is ll) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
74 call assert_true(l == lx) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
75 call assert_false(l is lx) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
76 call assert_true(l isnot lx) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
77 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
78 call v9.CheckLegacyAndVim9Success(lines) |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
79 endfunc |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
80 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
81 " removing items with :unlet |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
82 func Test_list_unlet() |
25308
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
83 let lines =<< trim END |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
84 VAR l = [1, 'as''d', [1, 2, function("strlen")], {'a': 1},] |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
85 unlet l[2] |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
86 call assert_equal([1, 'as''d', {'a': 1}], l) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
87 LET l = range(8) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
88 unlet l[: 3] |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
89 unlet l[1 :] |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
90 call assert_equal([4], l) |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
91 |
25308
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
92 #" removing items out of range: silently skip items that don't exist |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
93 LET l = [0, 1, 2, 3] |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
94 unlet l[2 : 2] |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
95 call assert_equal([0, 1, 3], l) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
96 LET l = [0, 1, 2, 3] |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
97 unlet l[2 : 3] |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
98 call assert_equal([0, 1], l) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
99 LET l = [0, 1, 2, 3] |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
100 unlet l[2 : 4] |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
101 call assert_equal([0, 1], l) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
102 LET l = [0, 1, 2, 3] |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
103 unlet l[2 : 5] |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
104 call assert_equal([0, 1], l) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
105 LET l = [0, 1, 2, 3] |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
106 unlet l[-2 : 2] |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
107 call assert_equal([0, 1, 3], l) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
108 LET l = [0, 1, 2, 3] |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
109 unlet l[-3 : 2] |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
110 call assert_equal([0, 3], l) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
111 LET l = [0, 1, 2, 3] |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
112 unlet l[-4 : 2] |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
113 call assert_equal([3], l) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
114 LET l = [0, 1, 2, 3] |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
115 unlet l[-5 : 2] |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
116 call assert_equal([3], l) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
117 LET l = [0, 1, 2, 3] |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
118 unlet l[-6 : 2] |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
119 call assert_equal([3], l) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
120 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
121 call v9.CheckLegacyAndVim9Success(lines) |
25308
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
122 |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
123 let l = [0, 1, 2, 3] |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
124 unlet l[2:2] |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
125 call assert_equal([0, 1, 3], l) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
126 let l = [0, 1, 2, 3] |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
127 unlet l[2:3] |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
128 call assert_equal([0, 1], l) |
25308
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
129 |
25330
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
130 let lines =<< trim END |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
131 VAR l = [0, 1, 2, 3] |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
132 unlet l[2 : 1] |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
133 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
134 call v9.CheckLegacyAndVim9Failure(lines, 'E684:') |
25330
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
135 |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
136 let lines =<< trim END |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
137 VAR l = [0, 1, 2, 3] |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
138 unlet l[-1 : 2] |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
139 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
140 call v9.CheckLegacyAndVim9Failure(lines, 'E684:') |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
141 endfunc |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
142 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
143 " assignment to a list |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
144 func Test_list_assign() |
25308
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
145 let lines =<< trim END |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
146 VAR l = [0, 1, 2, 3] |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
147 VAR va = 0 |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
148 VAR vb = 0 |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
149 LET [va, vb] = l[2 : 3] |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
150 call assert_equal([2, 3], [va, vb]) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
151 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
152 call v9.CheckLegacyAndVim9Success(lines) |
25308
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
153 |
25330
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
154 let lines =<< trim END |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
155 let l = [0, 1, 2, 3] |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
156 let [va, vb] = l |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
157 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
158 call v9.CheckScriptFailure(lines, 'E687:') |
25330
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
159 let lines =<< trim END |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
160 var l = [0, 1, 2, 3] |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
161 var va = 0 |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
162 var vb = 0 |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
163 [va, vb] = l |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
164 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
165 call v9.CheckScriptFailure(['vim9script'] + lines, 'E687:') |
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
166 call v9.CheckDefExecFailure(lines, 'E1093: Expected 2 items but got 4') |
25330
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
167 |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
168 let lines =<< trim END |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
169 let l = [0, 1, 2, 3] |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
170 let [va, vb] = l[1:1] |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
171 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
172 call v9.CheckScriptFailure(lines, 'E688:') |
25330
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
173 let lines =<< trim END |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
174 var l = [0, 1, 2, 3] |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
175 var va = 0 |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
176 var vb = 0 |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
177 [va, vb] = l[1 : 1] |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
178 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
179 call v9.CheckScriptFailure(['vim9script'] + lines, 'E688:') |
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
180 call v9.CheckDefExecFailure(lines, 'E1093: Expected 2 items but got 1') |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
181 endfunc |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
182 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
183 " test for range assign |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
184 func Test_list_range_assign() |
25591
ea69398b40d1
patch 8.2.3332: Vim9: cannot assign to range in list
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
185 let lines =<< trim END |
ea69398b40d1
patch 8.2.3332: Vim9: cannot assign to range in list
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
186 VAR l = [0] |
ea69398b40d1
patch 8.2.3332: Vim9: cannot assign to range in list
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
187 LET l[:] = [1, 2] |
ea69398b40d1
patch 8.2.3332: Vim9: cannot assign to range in list
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
188 call assert_equal([1, 2], l) |
ea69398b40d1
patch 8.2.3332: Vim9: cannot assign to range in list
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
189 LET l[-4 : -1] = [5, 6] |
ea69398b40d1
patch 8.2.3332: Vim9: cannot assign to range in list
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
190 call assert_equal([5, 6], l) |
ea69398b40d1
patch 8.2.3332: Vim9: cannot assign to range in list
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
191 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
192 call v9.CheckLegacyAndVim9Success(lines) |
25603
525ef4d1d412
patch 8.2.3338: Vim9: no type check when assigning a list range
Bram Moolenaar <Bram@vim.org>
parents:
25599
diff
changeset
|
193 |
525ef4d1d412
patch 8.2.3338: Vim9: no type check when assigning a list range
Bram Moolenaar <Bram@vim.org>
parents:
25599
diff
changeset
|
194 let lines =<< trim END |
525ef4d1d412
patch 8.2.3338: Vim9: no type check when assigning a list range
Bram Moolenaar <Bram@vim.org>
parents:
25599
diff
changeset
|
195 var l = [7] |
525ef4d1d412
patch 8.2.3338: Vim9: no type check when assigning a list range
Bram Moolenaar <Bram@vim.org>
parents:
25599
diff
changeset
|
196 l[:] = ['text'] |
525ef4d1d412
patch 8.2.3338: Vim9: no type check when assigning a list range
Bram Moolenaar <Bram@vim.org>
parents:
25599
diff
changeset
|
197 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
198 call v9.CheckDefAndScriptFailure(lines, 'E1012:', 2) |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
199 endfunc |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
200 |
29978
34151eb6ae25
patch 9.0.0327: items() does not work on a list
Bram Moolenaar <Bram@vim.org>
parents:
29728
diff
changeset
|
201 func Test_list_items() |
34151eb6ae25
patch 9.0.0327: items() does not work on a list
Bram Moolenaar <Bram@vim.org>
parents:
29728
diff
changeset
|
202 let r = [] |
34151eb6ae25
patch 9.0.0327: items() does not work on a list
Bram Moolenaar <Bram@vim.org>
parents:
29728
diff
changeset
|
203 let l = ['a', 'b', 'c'] |
34151eb6ae25
patch 9.0.0327: items() does not work on a list
Bram Moolenaar <Bram@vim.org>
parents:
29728
diff
changeset
|
204 for [idx, val] in items(l) |
34151eb6ae25
patch 9.0.0327: items() does not work on a list
Bram Moolenaar <Bram@vim.org>
parents:
29728
diff
changeset
|
205 call extend(r, [[idx, val]]) |
34151eb6ae25
patch 9.0.0327: items() does not work on a list
Bram Moolenaar <Bram@vim.org>
parents:
29728
diff
changeset
|
206 endfor |
34151eb6ae25
patch 9.0.0327: items() does not work on a list
Bram Moolenaar <Bram@vim.org>
parents:
29728
diff
changeset
|
207 call assert_equal([[0, 'a'], [1, 'b'], [2, 'c']], r) |
34151eb6ae25
patch 9.0.0327: items() does not work on a list
Bram Moolenaar <Bram@vim.org>
parents:
29728
diff
changeset
|
208 |
29986
0ad8b72af148
patch 9.0.0331: cannot use items() on a string
Bram Moolenaar <Bram@vim.org>
parents:
29978
diff
changeset
|
209 call assert_fails('call items(3)', 'E1225:') |
0ad8b72af148
patch 9.0.0331: cannot use items() on a string
Bram Moolenaar <Bram@vim.org>
parents:
29978
diff
changeset
|
210 endfunc |
0ad8b72af148
patch 9.0.0331: cannot use items() on a string
Bram Moolenaar <Bram@vim.org>
parents:
29978
diff
changeset
|
211 |
0ad8b72af148
patch 9.0.0331: cannot use items() on a string
Bram Moolenaar <Bram@vim.org>
parents:
29978
diff
changeset
|
212 func Test_string_items() |
0ad8b72af148
patch 9.0.0331: cannot use items() on a string
Bram Moolenaar <Bram@vim.org>
parents:
29978
diff
changeset
|
213 let r = [] |
0ad8b72af148
patch 9.0.0331: cannot use items() on a string
Bram Moolenaar <Bram@vim.org>
parents:
29978
diff
changeset
|
214 let s = 'ábツ' |
0ad8b72af148
patch 9.0.0331: cannot use items() on a string
Bram Moolenaar <Bram@vim.org>
parents:
29978
diff
changeset
|
215 for [idx, val] in items(s) |
0ad8b72af148
patch 9.0.0331: cannot use items() on a string
Bram Moolenaar <Bram@vim.org>
parents:
29978
diff
changeset
|
216 call extend(r, [[idx, val]]) |
0ad8b72af148
patch 9.0.0331: cannot use items() on a string
Bram Moolenaar <Bram@vim.org>
parents:
29978
diff
changeset
|
217 endfor |
0ad8b72af148
patch 9.0.0331: cannot use items() on a string
Bram Moolenaar <Bram@vim.org>
parents:
29978
diff
changeset
|
218 call assert_equal([[0, 'á'], [1, 'b'], [2, 'ツ']], r) |
29978
34151eb6ae25
patch 9.0.0327: items() does not work on a list
Bram Moolenaar <Bram@vim.org>
parents:
29728
diff
changeset
|
219 endfunc |
34151eb6ae25
patch 9.0.0327: items() does not work on a list
Bram Moolenaar <Bram@vim.org>
parents:
29728
diff
changeset
|
220 |
14856
c5a2fb8b221d
patch 8.1.0440: remove() with a range not sufficiently tested
Christian Brabandt <cb@256bit.org>
parents:
12788
diff
changeset
|
221 " Test removing items in list |
c5a2fb8b221d
patch 8.1.0440: remove() with a range not sufficiently tested
Christian Brabandt <cb@256bit.org>
parents:
12788
diff
changeset
|
222 func Test_list_func_remove() |
25308
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
223 let lines =<< trim END |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
224 #" Test removing 1 element |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
225 VAR l = [1, 2, 3, 4] |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
226 call assert_equal(1, remove(l, 0)) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
227 call assert_equal([2, 3, 4], l) |
14856
c5a2fb8b221d
patch 8.1.0440: remove() with a range not sufficiently tested
Christian Brabandt <cb@256bit.org>
parents:
12788
diff
changeset
|
228 |
25308
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
229 LET l = [1, 2, 3, 4] |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
230 call assert_equal(2, remove(l, 1)) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
231 call assert_equal([1, 3, 4], l) |
14856
c5a2fb8b221d
patch 8.1.0440: remove() with a range not sufficiently tested
Christian Brabandt <cb@256bit.org>
parents:
12788
diff
changeset
|
232 |
25308
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
233 LET l = [1, 2, 3, 4] |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
234 call assert_equal(4, remove(l, -1)) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
235 call assert_equal([1, 2, 3], l) |
14856
c5a2fb8b221d
patch 8.1.0440: remove() with a range not sufficiently tested
Christian Brabandt <cb@256bit.org>
parents:
12788
diff
changeset
|
236 |
25308
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
237 #" Test removing range of element(s) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
238 LET l = [1, 2, 3, 4] |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
239 call assert_equal([3], remove(l, 2, 2)) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
240 call assert_equal([1, 2, 4], l) |
14856
c5a2fb8b221d
patch 8.1.0440: remove() with a range not sufficiently tested
Christian Brabandt <cb@256bit.org>
parents:
12788
diff
changeset
|
241 |
25308
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
242 LET l = [1, 2, 3, 4] |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
243 call assert_equal([2, 3], remove(l, 1, 2)) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
244 call assert_equal([1, 4], l) |
14856
c5a2fb8b221d
patch 8.1.0440: remove() with a range not sufficiently tested
Christian Brabandt <cb@256bit.org>
parents:
12788
diff
changeset
|
245 |
25308
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
246 LET l = [1, 2, 3, 4] |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
247 call assert_equal([2, 3], remove(l, -3, -2)) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
248 call assert_equal([1, 4], l) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
249 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
250 call v9.CheckLegacyAndVim9Success(lines) |
14856
c5a2fb8b221d
patch 8.1.0440: remove() with a range not sufficiently tested
Christian Brabandt <cb@256bit.org>
parents:
12788
diff
changeset
|
251 |
c5a2fb8b221d
patch 8.1.0440: remove() with a range not sufficiently tested
Christian Brabandt <cb@256bit.org>
parents:
12788
diff
changeset
|
252 " Test invalid cases |
c5a2fb8b221d
patch 8.1.0440: remove() with a range not sufficiently tested
Christian Brabandt <cb@256bit.org>
parents:
12788
diff
changeset
|
253 let l = [1, 2, 3, 4] |
c5a2fb8b221d
patch 8.1.0440: remove() with a range not sufficiently tested
Christian Brabandt <cb@256bit.org>
parents:
12788
diff
changeset
|
254 call assert_fails("call remove(l, 5)", 'E684:') |
c5a2fb8b221d
patch 8.1.0440: remove() with a range not sufficiently tested
Christian Brabandt <cb@256bit.org>
parents:
12788
diff
changeset
|
255 call assert_fails("call remove(l, 1, 5)", 'E684:') |
c5a2fb8b221d
patch 8.1.0440: remove() with a range not sufficiently tested
Christian Brabandt <cb@256bit.org>
parents:
12788
diff
changeset
|
256 call assert_fails("call remove(l, 3, 2)", 'E16:') |
15571
4af72c724093
patch 8.1.0793: incorrect error messages for functions that take a Blob
Bram Moolenaar <Bram@vim.org>
parents:
15406
diff
changeset
|
257 call assert_fails("call remove(1, 0)", 'E896:') |
14856
c5a2fb8b221d
patch 8.1.0440: remove() with a range not sufficiently tested
Christian Brabandt <cb@256bit.org>
parents:
12788
diff
changeset
|
258 call assert_fails("call remove(l, l)", 'E745:') |
c5a2fb8b221d
patch 8.1.0440: remove() with a range not sufficiently tested
Christian Brabandt <cb@256bit.org>
parents:
12788
diff
changeset
|
259 endfunc |
c5a2fb8b221d
patch 8.1.0440: remove() with a range not sufficiently tested
Christian Brabandt <cb@256bit.org>
parents:
12788
diff
changeset
|
260 |
20128
0b35a7ffceb2
patch 8.2.0619: null dict is not handled like an empty dict
Bram Moolenaar <Bram@vim.org>
parents:
20109
diff
changeset
|
261 " List add() function |
0b35a7ffceb2
patch 8.2.0619: null dict is not handled like an empty dict
Bram Moolenaar <Bram@vim.org>
parents:
20109
diff
changeset
|
262 func Test_list_add() |
25308
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
263 let lines =<< trim END |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
264 VAR l = [] |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
265 call add(l, 1) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
266 call add(l, [2, 3]) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
267 call add(l, []) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
268 call add(l, test_null_list()) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
269 call add(l, {'k': 3}) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
270 call add(l, {}) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
271 call add(l, test_null_dict()) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
272 call assert_equal([1, [2, 3], [], [], {'k': 3}, {}, {}], l) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
273 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
274 call v9.CheckLegacyAndVim9Success(lines) |
25308
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
275 |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
276 " weird legacy behavior |
20128
0b35a7ffceb2
patch 8.2.0619: null dict is not handled like an empty dict
Bram Moolenaar <Bram@vim.org>
parents:
20109
diff
changeset
|
277 call assert_equal(1, add(test_null_list(), 4)) |
0b35a7ffceb2
patch 8.2.0619: null dict is not handled like an empty dict
Bram Moolenaar <Bram@vim.org>
parents:
20109
diff
changeset
|
278 endfunc |
0b35a7ffceb2
patch 8.2.0619: null dict is not handled like an empty dict
Bram Moolenaar <Bram@vim.org>
parents:
20109
diff
changeset
|
279 |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
280 " Tests for Dictionary type |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
281 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
282 func Test_dict() |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
283 " Creating Dictionary directly with different types |
25308
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
284 let lines =<< trim END |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
285 VAR d = {'1': 'asd', 'b': [1, 2, function('strlen')], '-1': {'a': 1}, } |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
286 call assert_equal("{'1': 'asd', 'b': [1, 2, function('strlen')], '-1': {'a': 1}}", string(d)) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
287 call assert_equal('asd', d.1) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
288 call assert_equal(['-1', '1', 'b'], sort(keys(d))) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
289 call assert_equal(['asd', [1, 2, function('strlen')], {'a': 1}], values(d)) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
290 call extend(d, {3: 33, 1: 99}) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
291 call extend(d, {'b': 'bbb', 'c': 'ccc'}, "keep") |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
292 call assert_equal({'c': 'ccc', '1': 99, 'b': [1, 2, function('strlen')], '3': 33, '-1': {'a': 1}}, d) |
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
293 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
294 call v9.CheckLegacyAndVim9Success(lines) |
25308
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
295 |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
296 let d = {001: 'asd', 'b': [1, 2, function('strlen')], -1: {'a': 1},} |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
297 call assert_equal("{'1': 'asd', 'b': [1, 2, function('strlen')], '-1': {'a': 1}}", string(d)) |
25308
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
298 |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
299 let v = [] |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
300 for [key, val] in items(d) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
301 call extend(v, [key, val]) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
302 unlet key val |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
303 endfor |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
304 call assert_equal(['1','asd','b',[1, 2, function('strlen')],'-1',{'a': 1}], v) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
305 |
25308
a386f83499ed
patch 8.2.3191: Vim9: not enough code is tested
Bram Moolenaar <Bram@vim.org>
parents:
25036
diff
changeset
|
306 call extend(d, {3: 33, 1: 99}) |
22087
ff21e2962490
patch 8.2.1593: tests do not check the error number properly
Bram Moolenaar <Bram@vim.org>
parents:
21556
diff
changeset
|
307 call assert_fails("call extend(d, {3:333,4:444}, 'error')", 'E737:') |
20109
e82996ad131f
patch 8.2.0610: some tests are still old style
Bram Moolenaar <Bram@vim.org>
parents:
19932
diff
changeset
|
308 |
e82996ad131f
patch 8.2.0610: some tests are still old style
Bram Moolenaar <Bram@vim.org>
parents:
19932
diff
changeset
|
309 " duplicate key |
e82996ad131f
patch 8.2.0610: some tests are still old style
Bram Moolenaar <Bram@vim.org>
parents:
19932
diff
changeset
|
310 call assert_fails("let d = {'k' : 10, 'k' : 20}", 'E721:') |
e82996ad131f
patch 8.2.0610: some tests are still old style
Bram Moolenaar <Bram@vim.org>
parents:
19932
diff
changeset
|
311 " missing comma |
e82996ad131f
patch 8.2.0610: some tests are still old style
Bram Moolenaar <Bram@vim.org>
parents:
19932
diff
changeset
|
312 call assert_fails("let d = {'k' : 10 'k' : 20}", 'E722:') |
e82996ad131f
patch 8.2.0610: some tests are still old style
Bram Moolenaar <Bram@vim.org>
parents:
19932
diff
changeset
|
313 " missing curly brace |
e82996ad131f
patch 8.2.0610: some tests are still old style
Bram Moolenaar <Bram@vim.org>
parents:
19932
diff
changeset
|
314 call assert_fails("let d = {'k' : 10,", 'E723:') |
e82996ad131f
patch 8.2.0610: some tests are still old style
Bram Moolenaar <Bram@vim.org>
parents:
19932
diff
changeset
|
315 " invalid key |
e82996ad131f
patch 8.2.0610: some tests are still old style
Bram Moolenaar <Bram@vim.org>
parents:
19932
diff
changeset
|
316 call assert_fails('let d = #{++ : 10}', 'E15:') |
e82996ad131f
patch 8.2.0610: some tests are still old style
Bram Moolenaar <Bram@vim.org>
parents:
19932
diff
changeset
|
317 " wrong type for key |
e82996ad131f
patch 8.2.0610: some tests are still old style
Bram Moolenaar <Bram@vim.org>
parents:
19932
diff
changeset
|
318 call assert_fails('let d={[] : 10}', 'E730:') |
e82996ad131f
patch 8.2.0610: some tests are still old style
Bram Moolenaar <Bram@vim.org>
parents:
19932
diff
changeset
|
319 " undefined variable as value |
e82996ad131f
patch 8.2.0610: some tests are still old style
Bram Moolenaar <Bram@vim.org>
parents:
19932
diff
changeset
|
320 call assert_fails("let d={'k' : i}", 'E121:') |
26342
936f77929f16
patch 8.2.3702: first key in dict is seen as curly expression and fails
Bram Moolenaar <Bram@vim.org>
parents:
26329
diff
changeset
|
321 |
936f77929f16
patch 8.2.3702: first key in dict is seen as curly expression and fails
Bram Moolenaar <Bram@vim.org>
parents:
26329
diff
changeset
|
322 " allow key starting with number at the start, not a curly expression |
936f77929f16
patch 8.2.3702: first key in dict is seen as curly expression and fails
Bram Moolenaar <Bram@vim.org>
parents:
26329
diff
changeset
|
323 call assert_equal({'1foo': 77}, #{1foo: 77}) |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
324 endfunc |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
325 |
21556
963913d80284
patch 8.2.1328: no space allowed before comma in list
Bram Moolenaar <Bram@vim.org>
parents:
21512
diff
changeset
|
326 " This was allowed in legacy Vim script |
963913d80284
patch 8.2.1328: no space allowed before comma in list
Bram Moolenaar <Bram@vim.org>
parents:
21512
diff
changeset
|
327 let s:dict_with_spaces = {'one' : 1 , 'two' : 2 , 'three' : 3} |
963913d80284
patch 8.2.1328: no space allowed before comma in list
Bram Moolenaar <Bram@vim.org>
parents:
21512
diff
changeset
|
328 let s:dict_with_spaces_lit = #{one : 1 , two : 2 , three : 3} |
963913d80284
patch 8.2.1328: no space allowed before comma in list
Bram Moolenaar <Bram@vim.org>
parents:
21512
diff
changeset
|
329 |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
330 " Dictionary identity |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
331 func Test_dict_identity() |
25330
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
332 let lines =<< trim END |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
333 VAR d = {'1': 'asd', 'b': [1, 2, function('strlen')], -1: {'a': 1}, } |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
334 VAR dd = d |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
335 VAR dx = copy(d) |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
336 call assert_true(d == dd) |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
337 call assert_false(d isnot dd) |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
338 call assert_true(d is dd) |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
339 call assert_true(d == dx) |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
340 call assert_false(d is dx) |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
341 call assert_true(d isnot dx) |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
342 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
343 call v9.CheckLegacyAndVim9Success(lines) |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
344 endfunc |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
345 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
346 " removing items with :unlet |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
347 func Test_dict_unlet() |
25330
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
348 let lines =<< trim END |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
349 VAR d = {'b': 'bbb', '1': 99, '3': 33, '-1': {'a': 1}} |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
350 unlet d.b |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
351 unlet d[-1] |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
352 call assert_equal({'1': 99, '3': 33}, d) |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
353 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
354 call v9.CheckLegacyAndVim9Success(lines) |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
355 endfunc |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
356 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
357 " manipulating a big Dictionary (hashtable.c has a border of 1000 entries) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
358 func Test_dict_big() |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
359 let d = {} |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
360 for i in range(1500) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
361 let d[i] = 3000 - i |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
362 endfor |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
363 call assert_equal([3000, 2900, 2001, 1600, 1501], [d[0], d[100], d[999], d[1400], d[1499]]) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
364 let str = '' |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
365 try |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
366 let n = d[1500] |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
367 catch |
22754
837756417c5e
patch 8.2.1925: list/dict test fails
Bram Moolenaar <Bram@vim.org>
parents:
22547
diff
changeset
|
368 let str = substitute(v:exception, '\v(.{14}).*( "\d{4}").*', '\1\2', '') |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
369 endtry |
22754
837756417c5e
patch 8.2.1925: list/dict test fails
Bram Moolenaar <Bram@vim.org>
parents:
22547
diff
changeset
|
370 call assert_equal('Vim(let):E716: "1500"', str) |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
371 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
372 " lookup each items |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
373 for i in range(1500) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
374 call assert_equal(3000 - i, d[i]) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
375 endfor |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
376 let i += 1 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
377 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
378 " delete even items |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
379 while i >= 2 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
380 let i -= 2 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
381 unlet d[i] |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
382 endwhile |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
383 call assert_equal('NONE', get(d, 1500 - 100, 'NONE')) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
384 call assert_equal(2999, d[1]) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
385 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
386 " delete odd items, checking value, one intentionally wrong |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
387 let d[33] = 999 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
388 let i = 1 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
389 while i < 1500 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
390 if i != 33 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
391 call assert_equal(3000 - i, d[i]) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
392 else |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
393 call assert_equal(999, d[i]) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
394 endif |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
395 unlet d[i] |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
396 let i += 2 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
397 endwhile |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
398 call assert_equal({}, d) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
399 unlet d |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
400 endfunc |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
401 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
402 " Dictionary function |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
403 func Test_dict_func() |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
404 let d = {} |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
405 func d.func(a) dict |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
406 return a:a . len(self.data) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
407 endfunc |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
408 let d.data = [1,2,3] |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
409 call assert_equal('len: 3', d.func('len: ')) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
410 let x = d.func('again: ') |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
411 call assert_equal('again: 3', x) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
412 let Fn = d.func |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
413 call assert_equal('xxx3', Fn('xxx')) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
414 endfunc |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
415 |
21512
81c47a694479
patch 8.2.1306: checking for first character of dict key is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
21265
diff
changeset
|
416 func Test_dict_assign() |
81c47a694479
patch 8.2.1306: checking for first character of dict key is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
21265
diff
changeset
|
417 let d = {} |
81c47a694479
patch 8.2.1306: checking for first character of dict key is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
21265
diff
changeset
|
418 let d.1 = 1 |
81c47a694479
patch 8.2.1306: checking for first character of dict key is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
21265
diff
changeset
|
419 let d._ = 2 |
81c47a694479
patch 8.2.1306: checking for first character of dict key is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
21265
diff
changeset
|
420 call assert_equal({'1': 1, '_': 2}, d) |
25036
3b8d3b383fd6
patch 8.2.3055: strange error for assigning to "x.key" on non-dictionary
Bram Moolenaar <Bram@vim.org>
parents:
24822
diff
changeset
|
421 |
25330
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
422 let lines =<< trim END |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
423 VAR d = {} |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
424 LET d.a = 1 |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
425 LET d._ = 2 |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
426 call assert_equal({'a': 1, '_': 2}, d) |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
427 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
428 call v9.CheckLegacyAndVim9Success(lines) |
25330
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
429 |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
430 let lines =<< trim END |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
431 let n = 0 |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
432 let n.key = 3 |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
433 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
434 call v9.CheckScriptFailure(lines, 'E1203: Dot can only be used on a dictionary: n.key = 3') |
25330
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
435 let lines =<< trim END |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
436 vim9script |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
437 var n = 0 |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
438 n.key = 3 |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
439 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
440 call v9.CheckScriptFailure(lines, 'E1203: Dot can only be used on a dictionary: n.key = 3') |
25330
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
441 let lines =<< trim END |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
442 var n = 0 |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
443 n.key = 3 |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
444 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
445 call v9.CheckDefFailure(lines, 'E1141:') |
21512
81c47a694479
patch 8.2.1306: checking for first character of dict key is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
21265
diff
changeset
|
446 endfunc |
81c47a694479
patch 8.2.1306: checking for first character of dict key is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
21265
diff
changeset
|
447 |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
448 " Function in script-local List or Dict |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
449 func Test_script_local_dict_func() |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
450 let g:dict = {} |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
451 function g:dict.func() dict |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
452 return 'g:dict.func' . self.foo[1] . self.foo[0]('asdf') |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
453 endfunc |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
454 let g:dict.foo = ['-', 2, 3] |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
455 call insert(g:dict.foo, function('strlen')) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
456 call assert_equal('g:dict.func-4', g:dict.func()) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
457 unlet g:dict |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
458 endfunc |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
459 |
20109
e82996ad131f
patch 8.2.0610: some tests are still old style
Bram Moolenaar <Bram@vim.org>
parents:
19932
diff
changeset
|
460 " Test removing items in a dictionary |
14856
c5a2fb8b221d
patch 8.1.0440: remove() with a range not sufficiently tested
Christian Brabandt <cb@256bit.org>
parents:
12788
diff
changeset
|
461 func Test_dict_func_remove() |
25330
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
462 let lines =<< trim END |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
463 VAR d = {1: 'a', 2: 'b', 3: 'c'} |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
464 call assert_equal('b', remove(d, 2)) |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
465 call assert_equal({1: 'a', 3: 'c'}, d) |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
466 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
467 call v9.CheckLegacyAndVim9Success(lines) |
25330
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
468 |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
469 let lines =<< trim END |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
470 VAR d = {1: 'a', 3: 'c'} |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
471 call remove(d, 1, 2) |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
472 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
473 call v9.CheckLegacyAndVim9Failure(lines, 'E118:') |
14856
c5a2fb8b221d
patch 8.1.0440: remove() with a range not sufficiently tested
Christian Brabandt <cb@256bit.org>
parents:
12788
diff
changeset
|
474 |
25330
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
475 let lines =<< trim END |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
476 VAR d = {1: 'a', 3: 'c'} |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
477 call remove(d, 'a') |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
478 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
479 call v9.CheckLegacyAndVim9Failure(lines, 'E716:') |
25330
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
480 |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
481 let lines =<< trim END |
26329
8afd7aa25ab6
patch 8.2.3695: confusing error for missing key
Bram Moolenaar <Bram@vim.org>
parents:
25603
diff
changeset
|
482 let d = {'a-b': 55} |
8afd7aa25ab6
patch 8.2.3695: confusing error for missing key
Bram Moolenaar <Bram@vim.org>
parents:
25603
diff
changeset
|
483 echo d.a-b |
8afd7aa25ab6
patch 8.2.3695: confusing error for missing key
Bram Moolenaar <Bram@vim.org>
parents:
25603
diff
changeset
|
484 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
485 call v9.CheckScriptFailure(lines, 'E716: Key not present in Dictionary: "a"') |
26329
8afd7aa25ab6
patch 8.2.3695: confusing error for missing key
Bram Moolenaar <Bram@vim.org>
parents:
25603
diff
changeset
|
486 |
8afd7aa25ab6
patch 8.2.3695: confusing error for missing key
Bram Moolenaar <Bram@vim.org>
parents:
25603
diff
changeset
|
487 let lines =<< trim END |
8afd7aa25ab6
patch 8.2.3695: confusing error for missing key
Bram Moolenaar <Bram@vim.org>
parents:
25603
diff
changeset
|
488 vim9script |
8afd7aa25ab6
patch 8.2.3695: confusing error for missing key
Bram Moolenaar <Bram@vim.org>
parents:
25603
diff
changeset
|
489 var d = {'a-b': 55} |
8afd7aa25ab6
patch 8.2.3695: confusing error for missing key
Bram Moolenaar <Bram@vim.org>
parents:
25603
diff
changeset
|
490 echo d.a-b |
8afd7aa25ab6
patch 8.2.3695: confusing error for missing key
Bram Moolenaar <Bram@vim.org>
parents:
25603
diff
changeset
|
491 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
492 call v9.CheckScriptFailure(lines, 'E716: Key not present in Dictionary: "a"') |
26329
8afd7aa25ab6
patch 8.2.3695: confusing error for missing key
Bram Moolenaar <Bram@vim.org>
parents:
25603
diff
changeset
|
493 |
8afd7aa25ab6
patch 8.2.3695: confusing error for missing key
Bram Moolenaar <Bram@vim.org>
parents:
25603
diff
changeset
|
494 let lines =<< trim END |
8afd7aa25ab6
patch 8.2.3695: confusing error for missing key
Bram Moolenaar <Bram@vim.org>
parents:
25603
diff
changeset
|
495 var d = {'a-b': 55} |
8afd7aa25ab6
patch 8.2.3695: confusing error for missing key
Bram Moolenaar <Bram@vim.org>
parents:
25603
diff
changeset
|
496 echo d.a-b |
8afd7aa25ab6
patch 8.2.3695: confusing error for missing key
Bram Moolenaar <Bram@vim.org>
parents:
25603
diff
changeset
|
497 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
498 call v9.CheckDefFailure(lines, 'E1004: White space required before and after ''-''') |
26329
8afd7aa25ab6
patch 8.2.3695: confusing error for missing key
Bram Moolenaar <Bram@vim.org>
parents:
25603
diff
changeset
|
499 |
8afd7aa25ab6
patch 8.2.3695: confusing error for missing key
Bram Moolenaar <Bram@vim.org>
parents:
25603
diff
changeset
|
500 let lines =<< trim END |
25330
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
501 let d = {1: 'a', 3: 'c'} |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
502 call remove(d, []) |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
503 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
504 call v9.CheckScriptFailure(lines, 'E730:') |
25330
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
505 let lines =<< trim END |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
506 vim9script |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
507 var d = {1: 'a', 3: 'c'} |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
508 call remove(d, []) |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
509 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
510 call v9.CheckScriptFailure(lines, 'E1220: String or Number required for argument 2') |
25330
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
511 let lines =<< trim END |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
512 var d = {1: 'a', 3: 'c'} |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
513 call remove(d, []) |
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
514 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
515 call v9.CheckDefExecFailure(lines, 'E1013: Argument 2: type mismatch, expected string but got list<unknown>') |
14856
c5a2fb8b221d
patch 8.1.0440: remove() with a range not sufficiently tested
Christian Brabandt <cb@256bit.org>
parents:
12788
diff
changeset
|
516 endfunc |
c5a2fb8b221d
patch 8.1.0440: remove() with a range not sufficiently tested
Christian Brabandt <cb@256bit.org>
parents:
12788
diff
changeset
|
517 |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
518 " Nasty: remove func from Dict that's being called (works) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
519 func Test_dict_func_remove_in_use() |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
520 let d = {1:1} |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
521 func d.func(a) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
522 return "a:" . a:a |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
523 endfunc |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
524 let expected = 'a:' . string(get(d, 'func')) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
525 call assert_equal(expected, d.func(string(remove(d, 'func')))) |
25593
c6277019b8c1
patch 8.2.3333: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25591
diff
changeset
|
526 |
c6277019b8c1
patch 8.2.3333: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25591
diff
changeset
|
527 " similar, in a way it also works in Vim9 |
c6277019b8c1
patch 8.2.3333: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25591
diff
changeset
|
528 let lines =<< trim END |
c6277019b8c1
patch 8.2.3333: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25591
diff
changeset
|
529 VAR d = {1: 1, 2: 'x'} |
c6277019b8c1
patch 8.2.3333: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25591
diff
changeset
|
530 func GetArg(a) |
c6277019b8c1
patch 8.2.3333: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25591
diff
changeset
|
531 return "a:" .. a:a |
c6277019b8c1
patch 8.2.3333: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25591
diff
changeset
|
532 endfunc |
c6277019b8c1
patch 8.2.3333: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25591
diff
changeset
|
533 LET d.func = function('GetArg') |
c6277019b8c1
patch 8.2.3333: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25591
diff
changeset
|
534 VAR expected = 'a:' .. string(get(d, 'func')) |
c6277019b8c1
patch 8.2.3333: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25591
diff
changeset
|
535 call assert_equal(expected, d.func(string(remove(d, 'func')))) |
c6277019b8c1
patch 8.2.3333: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25591
diff
changeset
|
536 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
537 call v9.CheckTransLegacySuccess(lines) |
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
538 call v9.CheckTransVim9Success(lines) |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
539 endfunc |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
540 |
17368
6604ecb7a615
patch 8.1.1683: dictionary with string keys is longer than needed
Bram Moolenaar <Bram@vim.org>
parents:
15949
diff
changeset
|
541 func Test_dict_literal_keys() |
17413
40417757dffd
patch 8.1.1705: using ~{} for a literal dict is not nice
Bram Moolenaar <Bram@vim.org>
parents:
17387
diff
changeset
|
542 call assert_equal({'one': 1, 'two2': 2, '3three': 3, '44': 4}, #{one: 1, two2: 2, 3three: 3, 44: 4},) |
17387
2558f90045e5
patch 8.1.1692: using *{} for literal dict is not backwards compatible
Bram Moolenaar <Bram@vim.org>
parents:
17375
diff
changeset
|
543 |
25330
820395d1137b
patch 8.2.3202: Vim9: tests are only executed for legacy script
Bram Moolenaar <Bram@vim.org>
parents:
25308
diff
changeset
|
544 " why *{} cannot be used for a literal dictionary |
17387
2558f90045e5
patch 8.1.1692: using *{} for literal dict is not backwards compatible
Bram Moolenaar <Bram@vim.org>
parents:
17375
diff
changeset
|
545 let blue = 'blue' |
2558f90045e5
patch 8.1.1692: using *{} for literal dict is not backwards compatible
Bram Moolenaar <Bram@vim.org>
parents:
17375
diff
changeset
|
546 call assert_equal('6', trim(execute('echo 2 *{blue: 3}.blue'))) |
17368
6604ecb7a615
patch 8.1.1683: dictionary with string keys is longer than needed
Bram Moolenaar <Bram@vim.org>
parents:
15949
diff
changeset
|
547 endfunc |
6604ecb7a615
patch 8.1.1683: dictionary with string keys is longer than needed
Bram Moolenaar <Bram@vim.org>
parents:
15949
diff
changeset
|
548 |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
549 " Nasty: deepcopy() dict that refers to itself (fails when noref used) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
550 func Test_dict_deepcopy() |
25595
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
551 let lines =<< trim END |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
552 VAR d = {1: 1, 2: '2'} |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
553 VAR l = [4, d, 6] |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
554 LET d[3] = l |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
555 VAR dc = deepcopy(d) |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
556 call deepcopy(d, 1) |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
557 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
558 call v9.CheckLegacyAndVim9Failure(lines, 'E698:') |
25595
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
559 |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
560 let lines =<< trim END |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
561 VAR d = {1: 1, 2: '2'} |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
562 VAR l = [4, d, 6] |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
563 LET d[3] = l |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
564 VAR l2 = [0, l, l, 3] |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
565 LET l[1] = l2 |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
566 VAR l3 = deepcopy(l2) |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
567 call assert_true(l3[1] is l3[2]) |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
568 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
569 call v9.CheckLegacyAndVim9Success(lines) |
25595
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
570 |
30043
fd855ad74887
patch 9.0.0359: error message for wrong argument type is not specific
Bram Moolenaar <Bram@vim.org>
parents:
29994
diff
changeset
|
571 call assert_fails("call deepcopy([1, 2], 2)", 'E1212:') |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
572 endfunc |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
573 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
574 " Locked variables |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
575 func Test_list_locked_var() |
25595
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
576 " Not tested with :def function, local vars cannot be locked. |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
577 let lines =<< trim END |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
578 VAR expected = [ |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
579 \ [['1000-000', 'ppppppF'], |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
580 \ ['0000-000', 'ppppppp'], |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
581 \ ['0000-000', 'ppppppp']], |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
582 \ [['1000-000', 'ppppppF'], |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
583 \ ['0000-000', 'ppppppp'], |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
584 \ ['0000-000', 'ppppppp']], |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
585 \ [['1100-100', 'ppFppFF'], |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
586 \ ['0000-000', 'ppppppp'], |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
587 \ ['0000-000', 'ppppppp']], |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
588 \ [['1110-110', 'pFFpFFF'], |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
589 \ ['0010-010', 'pFppFpp'], |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
590 \ ['0000-000', 'ppppppp']], |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
591 \ [['1111-111', 'FFFFFFF'], |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
592 \ ['0011-011', 'FFpFFpp'], |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
593 \ ['0000-000', 'ppppppp']] |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
594 \ ] |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
595 for depth in range(5) |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
596 for u in range(3) |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
597 VAR l = [0, [1, [2, 3]], {4: 5, 6: {7: 8}}] |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
598 exe "lockvar " .. depth .. " l" |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
599 if u == 1 |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
600 exe "unlockvar l" |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
601 elseif u == 2 |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
602 exe "unlockvar " .. depth .. " l" |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
603 endif |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
604 VAR ps = islocked("l") .. islocked("l[1]") .. islocked("l[1][1]") .. islocked("l[1][1][0]") .. '-' .. islocked("l[2]") .. islocked("l[2]['6']") .. islocked("l[2]['6'][7]") |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
605 call assert_equal(expected[depth][u][0], ps, 'depth: ' .. depth) |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
606 LET ps = '' |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
607 try |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
608 LET l[1][1][0] = 99 |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
609 LET ps ..= 'p' |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
610 catch |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
611 LET ps ..= 'F' |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
612 endtry |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
613 try |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
614 LET l[1][1] = [99] |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
615 LET ps ..= 'p' |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
616 catch |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
617 LET ps ..= 'F' |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
618 endtry |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
619 try |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
620 LET l[1] = [99] |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
621 LET ps ..= 'p' |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
622 catch |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
623 LET ps ..= 'F' |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
624 endtry |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
625 try |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
626 LET l[2]['6'][7] = 99 |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
627 LET ps ..= 'p' |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
628 catch |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
629 LET ps ..= 'F' |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
630 endtry |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
631 try |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
632 LET l[2][6] = {99: 99} |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
633 LET ps ..= 'p' |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
634 catch |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
635 LET ps ..= 'F' |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
636 endtry |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
637 try |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
638 LET l[2] = {99: 99} |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
639 LET ps ..= 'p' |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
640 catch |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
641 LET ps ..= 'F' |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
642 endtry |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
643 try |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
644 LET l = [99] |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
645 LET ps ..= 'p' |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
646 catch |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
647 LET ps ..= 'F' |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
648 endtry |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
649 call assert_equal(expected[depth][u][1], ps, 'depth: ' .. depth) |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
650 unlock! l |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
651 endfor |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
652 endfor |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
653 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
654 call v9.CheckTransLegacySuccess(lines) |
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
655 call v9.CheckTransVim9Success(lines) |
25595
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
656 |
19783
546bdeef35f1
patch 8.2.0448: various functions not properly tested
Bram Moolenaar <Bram@vim.org>
parents:
19724
diff
changeset
|
657 call assert_fails("let x=islocked('a b')", 'E488:') |
546bdeef35f1
patch 8.2.0448: various functions not properly tested
Bram Moolenaar <Bram@vim.org>
parents:
19724
diff
changeset
|
658 let mylist = [1, 2, 3] |
546bdeef35f1
patch 8.2.0448: various functions not properly tested
Bram Moolenaar <Bram@vim.org>
parents:
19724
diff
changeset
|
659 call assert_fails("let x = islocked('mylist[1:2]')", 'E786:') |
546bdeef35f1
patch 8.2.0448: various functions not properly tested
Bram Moolenaar <Bram@vim.org>
parents:
19724
diff
changeset
|
660 let mydict = {'k' : 'v'} |
546bdeef35f1
patch 8.2.0448: various functions not properly tested
Bram Moolenaar <Bram@vim.org>
parents:
19724
diff
changeset
|
661 call assert_fails("let x = islocked('mydict.a')", 'E716:') |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
662 endfunc |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
663 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
664 " Unletting locked variables |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
665 func Test_list_locked_var_unlet() |
25595
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
666 " Not tested with Vim9: script and local variables cannot be unlocked |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
667 let expected = [ |
22298
07e48ee8c3bb
patch 8.2.1698: cannot lock a variable in legacy Vim script like in Vim9
Bram Moolenaar <Bram@vim.org>
parents:
22101
diff
changeset
|
668 \ [['1000-000', 'ppppppp'], |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
669 \ ['0000-000', 'ppppppp'], |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
670 \ ['0000-000', 'ppppppp']], |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
671 \ [['1000-000', 'ppFppFp'], |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
672 \ ['0000-000', 'ppppppp'], |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
673 \ ['0000-000', 'ppppppp']], |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
674 \ [['1100-100', 'pFFpFFp'], |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
675 \ ['0000-000', 'ppppppp'], |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
676 \ ['0000-000', 'ppppppp']], |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
677 \ [['1110-110', 'FFFFFFp'], |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
678 \ ['0010-010', 'FppFppp'], |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
679 \ ['0000-000', 'ppppppp']], |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
680 \ [['1111-111', 'FFFFFFp'], |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
681 \ ['0011-011', 'FppFppp'], |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
682 \ ['0000-000', 'ppppppp']] |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
683 \ ] |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
684 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
685 for depth in range(5) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
686 for u in range(3) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
687 unlet! l |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
688 let l = [0, [1, [2, 3]], {4: 5, 6: {7: 8}}] |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
689 exe "lockvar " . depth . " l" |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
690 if u == 1 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
691 exe "unlockvar l" |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
692 elseif u == 2 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
693 exe "unlockvar " . depth . " l" |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
694 endif |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
695 let ps = islocked("l").islocked("l[1]").islocked("l[1][1]").islocked("l[1][1][0]").'-'.islocked("l[2]").islocked("l[2]['6']").islocked("l[2]['6'][7]") |
22298
07e48ee8c3bb
patch 8.2.1698: cannot lock a variable in legacy Vim script like in Vim9
Bram Moolenaar <Bram@vim.org>
parents:
22101
diff
changeset
|
696 call assert_equal(expected[depth][u][0], ps, 'depth: ' .. depth) |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
697 let ps = '' |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
698 try |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
699 unlet l[2]['6'][7] |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
700 let ps .= 'p' |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
701 catch |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
702 let ps .= 'F' |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
703 endtry |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
704 try |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
705 unlet l[2][6] |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
706 let ps .= 'p' |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
707 catch |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
708 let ps .= 'F' |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
709 endtry |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
710 try |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
711 unlet l[2] |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
712 let ps .= 'p' |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
713 catch |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
714 let ps .= 'F' |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
715 endtry |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
716 try |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
717 unlet l[1][1][0] |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
718 let ps .= 'p' |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
719 catch |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
720 let ps .= 'F' |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
721 endtry |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
722 try |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
723 unlet l[1][1] |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
724 let ps .= 'p' |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
725 catch |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
726 let ps .= 'F' |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
727 endtry |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
728 try |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
729 unlet l[1] |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
730 let ps .= 'p' |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
731 catch |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
732 let ps .= 'F' |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
733 endtry |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
734 try |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
735 unlet l |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
736 let ps .= 'p' |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
737 catch |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
738 let ps .= 'F' |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
739 endtry |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
740 call assert_equal(expected[depth][u][1], ps) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
741 endfor |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
742 endfor |
26626
4d18b3a5254a
patch 8.2.3842: Vim9: can change locked list and list items
Bram Moolenaar <Bram@vim.org>
parents:
26624
diff
changeset
|
743 |
28152
b96409b84eaf
patch 8.2.4600: Vim9: not enough test coverage for executing :def function
Bram Moolenaar <Bram@vim.org>
parents:
27859
diff
changeset
|
744 " Deleting a list range with locked items works, but changing the items |
b96409b84eaf
patch 8.2.4600: Vim9: not enough test coverage for executing :def function
Bram Moolenaar <Bram@vim.org>
parents:
27859
diff
changeset
|
745 " fails. |
24695
13efbfc53054
patch 8.2.2886: various pieces of code not covered by tests
Bram Moolenaar <Bram@vim.org>
parents:
24618
diff
changeset
|
746 let l = [1, 2, 3, 4] |
13efbfc53054
patch 8.2.2886: various pieces of code not covered by tests
Bram Moolenaar <Bram@vim.org>
parents:
24618
diff
changeset
|
747 lockvar l[1:2] |
28152
b96409b84eaf
patch 8.2.4600: Vim9: not enough test coverage for executing :def function
Bram Moolenaar <Bram@vim.org>
parents:
27859
diff
changeset
|
748 call assert_fails('let l[1:2] = [8, 9]', 'E741:') |
b96409b84eaf
patch 8.2.4600: Vim9: not enough test coverage for executing :def function
Bram Moolenaar <Bram@vim.org>
parents:
27859
diff
changeset
|
749 unlet l[1:2] |
b96409b84eaf
patch 8.2.4600: Vim9: not enough test coverage for executing :def function
Bram Moolenaar <Bram@vim.org>
parents:
27859
diff
changeset
|
750 call assert_equal([1, 4], l) |
24695
13efbfc53054
patch 8.2.2886: various pieces of code not covered by tests
Bram Moolenaar <Bram@vim.org>
parents:
24618
diff
changeset
|
751 unlet l |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
752 endfunc |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
753 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
754 " Locked variables and :unlet or list / dict functions |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
755 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
756 " No :unlet after lock on dict: |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
757 func Test_dict_lock_unlet() |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
758 let d = {'a': 99, 'b': 100} |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
759 lockvar 1 d |
22087
ff21e2962490
patch 8.2.1593: tests do not check the error number properly
Bram Moolenaar <Bram@vim.org>
parents:
21556
diff
changeset
|
760 call assert_fails('unlet d.a', 'E741:') |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
761 endfunc |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
762 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
763 " unlet after lock on dict item |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
764 func Test_dict_item_lock_unlet() |
25595
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
765 let lines =<< trim END |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
766 VAR d = {'a': 99, 'b': 100} |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
767 lockvar d.a |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
768 unlet d.a |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
769 call assert_equal({'b': 100}, d) |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
770 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
771 call v9.CheckLegacyAndVim9Success(lines) |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
772 endfunc |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
773 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
774 " filter() after lock on dict item |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
775 func Test_dict_lock_filter() |
25595
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
776 let lines =<< trim END |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
777 VAR d = {'a': 99, 'b': 100} |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
778 lockvar d.a |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
779 call filter(d, 'v:key != "a"') |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
780 call assert_equal({'b': 100}, d) |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
781 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
782 call v9.CheckLegacyAndVim9Success(lines) |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
783 endfunc |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
784 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
785 " map() after lock on dict |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
786 func Test_dict_lock_map() |
25595
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
787 let lines =<< trim END |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
788 VAR d = {'a': 99, 'b': 100} |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
789 lockvar 1 d |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
790 call map(d, 'v:val + 200') |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
791 call assert_equal({'a': 299, 'b': 300}, d) |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
792 END |
c4e29355cd8b
patch 8.2.3334: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25593
diff
changeset
|
793 " This won't work in a :def function |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
794 call v9.CheckTransLegacySuccess(lines) |
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
795 call v9.CheckTransVim9Success(lines) |
26624
bdf11d8e3df3
patch 8.2.3841: Vim9: outdated TODO items, disabled tests that work
Bram Moolenaar <Bram@vim.org>
parents:
26342
diff
changeset
|
796 |
bdf11d8e3df3
patch 8.2.3841: Vim9: outdated TODO items, disabled tests that work
Bram Moolenaar <Bram@vim.org>
parents:
26342
diff
changeset
|
797 " For a :def function use a global dict. |
bdf11d8e3df3
patch 8.2.3841: Vim9: outdated TODO items, disabled tests that work
Bram Moolenaar <Bram@vim.org>
parents:
26342
diff
changeset
|
798 let lines =<< trim END |
bdf11d8e3df3
patch 8.2.3841: Vim9: outdated TODO items, disabled tests that work
Bram Moolenaar <Bram@vim.org>
parents:
26342
diff
changeset
|
799 let g:thedict = {'a': 77, 'b': 88} |
bdf11d8e3df3
patch 8.2.3841: Vim9: outdated TODO items, disabled tests that work
Bram Moolenaar <Bram@vim.org>
parents:
26342
diff
changeset
|
800 lockvar 1 g:thedict |
bdf11d8e3df3
patch 8.2.3841: Vim9: outdated TODO items, disabled tests that work
Bram Moolenaar <Bram@vim.org>
parents:
26342
diff
changeset
|
801 def Delkey() |
bdf11d8e3df3
patch 8.2.3841: Vim9: outdated TODO items, disabled tests that work
Bram Moolenaar <Bram@vim.org>
parents:
26342
diff
changeset
|
802 unlet g:thedict.a |
bdf11d8e3df3
patch 8.2.3841: Vim9: outdated TODO items, disabled tests that work
Bram Moolenaar <Bram@vim.org>
parents:
26342
diff
changeset
|
803 enddef |
bdf11d8e3df3
patch 8.2.3841: Vim9: outdated TODO items, disabled tests that work
Bram Moolenaar <Bram@vim.org>
parents:
26342
diff
changeset
|
804 call Delkey() |
bdf11d8e3df3
patch 8.2.3841: Vim9: outdated TODO items, disabled tests that work
Bram Moolenaar <Bram@vim.org>
parents:
26342
diff
changeset
|
805 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
806 call v9.CheckScriptFailure(lines, 'E741:') |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
807 endfunc |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
808 |
26684
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26650
diff
changeset
|
809 " Lock one item in a list |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26650
diff
changeset
|
810 func Test_list_item_lock_map() |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26650
diff
changeset
|
811 let lines =<< trim END |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26650
diff
changeset
|
812 VAR l = [99, 100, 101] |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26650
diff
changeset
|
813 lockvar l[1] |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26650
diff
changeset
|
814 call assert_fails("echo map(l, 'v:val + 200')", 'E741:') |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26650
diff
changeset
|
815 call assert_equal([299, 100, 101], l) |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26650
diff
changeset
|
816 END |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26650
diff
changeset
|
817 " This won't work in a :def function |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
818 call v9.CheckTransLegacySuccess(lines) |
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
819 call v9.CheckTransVim9Success(lines) |
26684
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26650
diff
changeset
|
820 endfunc |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26650
diff
changeset
|
821 |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26650
diff
changeset
|
822 " Lock one item in a dict |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26650
diff
changeset
|
823 func Test_dict_item_lock_map() |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26650
diff
changeset
|
824 let lines =<< trim END |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26650
diff
changeset
|
825 VAR d = {'a': 99, 'b': 100, 'c': 101} |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26650
diff
changeset
|
826 lockvar d.b |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26650
diff
changeset
|
827 call assert_fails("echo map(d, 'v:val + 200')", 'E741:') |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26650
diff
changeset
|
828 call assert_equal({'a': 299, 'b': 100, 'c': 101}, d) |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26650
diff
changeset
|
829 END |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26650
diff
changeset
|
830 " This won't work in a :def function |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
831 call v9.CheckTransLegacySuccess(lines) |
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
832 call v9.CheckTransVim9Success(lines) |
26684
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26650
diff
changeset
|
833 endfunc |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26650
diff
changeset
|
834 |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
835 " No extend() after lock on dict item |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
836 func Test_dict_lock_extend() |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
837 let d = {'a': 99, 'b': 100} |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
838 lockvar d.a |
22087
ff21e2962490
patch 8.2.1593: tests do not check the error number properly
Bram Moolenaar <Bram@vim.org>
parents:
21556
diff
changeset
|
839 call assert_fails("call extend(d, {'a' : 123})", 'E741:') |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
840 call assert_equal({'a': 99, 'b': 100}, d) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
841 endfunc |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
842 |
20136
fdf94ab9929b
patch 8.2.0623: typo in test comment
Bram Moolenaar <Bram@vim.org>
parents:
20128
diff
changeset
|
843 " Cannot use += with a locked dict |
20128
0b35a7ffceb2
patch 8.2.0619: null dict is not handled like an empty dict
Bram Moolenaar <Bram@vim.org>
parents:
20109
diff
changeset
|
844 func Test_dict_lock_operator() |
0b35a7ffceb2
patch 8.2.0619: null dict is not handled like an empty dict
Bram Moolenaar <Bram@vim.org>
parents:
20109
diff
changeset
|
845 let d = {} |
0b35a7ffceb2
patch 8.2.0619: null dict is not handled like an empty dict
Bram Moolenaar <Bram@vim.org>
parents:
20109
diff
changeset
|
846 lockvar d |
0b35a7ffceb2
patch 8.2.0619: null dict is not handled like an empty dict
Bram Moolenaar <Bram@vim.org>
parents:
20109
diff
changeset
|
847 call assert_fails("let d += {'k' : 10}", 'E741:') |
0b35a7ffceb2
patch 8.2.0619: null dict is not handled like an empty dict
Bram Moolenaar <Bram@vim.org>
parents:
20109
diff
changeset
|
848 unlockvar d |
0b35a7ffceb2
patch 8.2.0619: null dict is not handled like an empty dict
Bram Moolenaar <Bram@vim.org>
parents:
20109
diff
changeset
|
849 endfunc |
0b35a7ffceb2
patch 8.2.0619: null dict is not handled like an empty dict
Bram Moolenaar <Bram@vim.org>
parents:
20109
diff
changeset
|
850 |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
851 " No remove() of write-protected scope-level variable |
15406
63b02fcf1361
patch 8.1.0711: test files still use function!
Bram Moolenaar <Bram@vim.org>
parents:
14856
diff
changeset
|
852 func Tfunc1(this_is_a_long_parameter_name) |
22087
ff21e2962490
patch 8.2.1593: tests do not check the error number properly
Bram Moolenaar <Bram@vim.org>
parents:
21556
diff
changeset
|
853 call assert_fails("call remove(a:, 'this_is_a_long_parameter_name')", 'E742:') |
15406
63b02fcf1361
patch 8.1.0711: test files still use function!
Bram Moolenaar <Bram@vim.org>
parents:
14856
diff
changeset
|
854 endfunc |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
855 func Test_dict_scope_var_remove() |
15406
63b02fcf1361
patch 8.1.0711: test files still use function!
Bram Moolenaar <Bram@vim.org>
parents:
14856
diff
changeset
|
856 call Tfunc1('testval') |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
857 endfunc |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
858 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
859 " No extend() of write-protected scope-level variable |
15762
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
860 func Test_dict_scope_var_extend() |
22087
ff21e2962490
patch 8.2.1593: tests do not check the error number properly
Bram Moolenaar <Bram@vim.org>
parents:
21556
diff
changeset
|
861 call assert_fails("call extend(a:, {'this_is_a_long_parameter_name': 1234})", 'E742:') |
15762
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
862 endfunc |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
863 |
15406
63b02fcf1361
patch 8.1.0711: test files still use function!
Bram Moolenaar <Bram@vim.org>
parents:
14856
diff
changeset
|
864 func Tfunc2(this_is_a_long_parameter_name) |
22087
ff21e2962490
patch 8.2.1593: tests do not check the error number properly
Bram Moolenaar <Bram@vim.org>
parents:
21556
diff
changeset
|
865 call assert_fails("call extend(a:, {'this_is_a_long_parameter_name': 1234})", 'E742:') |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
866 endfunc |
15762
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
867 func Test_dict_scope_var_extend_overwrite() |
15406
63b02fcf1361
patch 8.1.0711: test files still use function!
Bram Moolenaar <Bram@vim.org>
parents:
14856
diff
changeset
|
868 call Tfunc2('testval') |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
869 endfunc |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
870 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
871 " No :unlet of variable in locked scope |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
872 func Test_lock_var_unlet() |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
873 let b:testvar = 123 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
874 lockvar 1 b: |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
875 call assert_fails('unlet b:testvar', 'E741:') |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
876 unlockvar 1 b: |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
877 unlet! b:testvar |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
878 endfunc |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
879 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
880 " No :let += of locked list variable |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
881 func Test_let_lock_list() |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
882 let l = ['a', 'b', 3] |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
883 lockvar 1 l |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
884 call assert_fails("let l += ['x']", 'E741:') |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
885 call assert_equal(['a', 'b', 3], l) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
886 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
887 unlet l |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
888 let l = [1, 2, 3, 4] |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
889 lockvar! l |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
890 call assert_equal([1, 2, 3, 4], l) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
891 unlockvar l[1] |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
892 call assert_fails('unlet l[0:1]', 'E741:') |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
893 call assert_equal([1, 2, 3, 4], l) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
894 call assert_fails('unlet l[1:2]', 'E741:') |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
895 call assert_equal([1, 2, 3, 4], l) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
896 unlockvar l[1] |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
897 call assert_fails('let l[0:1] = [0, 1]', 'E741:') |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
898 call assert_equal([1, 2, 3, 4], l) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
899 call assert_fails('let l[1:2] = [0, 1]', 'E741:') |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
900 call assert_equal([1, 2, 3, 4], l) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
901 unlet l |
26626
4d18b3a5254a
patch 8.2.3842: Vim9: can change locked list and list items
Bram Moolenaar <Bram@vim.org>
parents:
26624
diff
changeset
|
902 |
4d18b3a5254a
patch 8.2.3842: Vim9: can change locked list and list items
Bram Moolenaar <Bram@vim.org>
parents:
26624
diff
changeset
|
903 let lines =<< trim END |
4d18b3a5254a
patch 8.2.3842: Vim9: can change locked list and list items
Bram Moolenaar <Bram@vim.org>
parents:
26624
diff
changeset
|
904 def TryUnletListItem(l: list<any>) |
4d18b3a5254a
patch 8.2.3842: Vim9: can change locked list and list items
Bram Moolenaar <Bram@vim.org>
parents:
26624
diff
changeset
|
905 unlet l[0] |
4d18b3a5254a
patch 8.2.3842: Vim9: can change locked list and list items
Bram Moolenaar <Bram@vim.org>
parents:
26624
diff
changeset
|
906 enddef |
4d18b3a5254a
patch 8.2.3842: Vim9: can change locked list and list items
Bram Moolenaar <Bram@vim.org>
parents:
26624
diff
changeset
|
907 let l = [1, 2, 3, 4] |
4d18b3a5254a
patch 8.2.3842: Vim9: can change locked list and list items
Bram Moolenaar <Bram@vim.org>
parents:
26624
diff
changeset
|
908 lockvar! l |
4d18b3a5254a
patch 8.2.3842: Vim9: can change locked list and list items
Bram Moolenaar <Bram@vim.org>
parents:
26624
diff
changeset
|
909 call TryUnletListItem(l) |
4d18b3a5254a
patch 8.2.3842: Vim9: can change locked list and list items
Bram Moolenaar <Bram@vim.org>
parents:
26624
diff
changeset
|
910 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
911 call v9.CheckScriptFailure(lines, 'E741:') |
26626
4d18b3a5254a
patch 8.2.3842: Vim9: can change locked list and list items
Bram Moolenaar <Bram@vim.org>
parents:
26624
diff
changeset
|
912 unlet g:l |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
913 endfunc |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
914 |
19689
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
915 " Locking part of the list |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
916 func Test_let_lock_list_items() |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
917 let l = [1, 2, 3, 4] |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
918 lockvar l[2:] |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
919 call assert_equal(0, islocked('l[0]')) |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
920 call assert_equal(1, islocked('l[2]')) |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
921 call assert_equal(1, islocked('l[3]')) |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
922 call assert_fails('let l[2] = 10', 'E741:') |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
923 call assert_fails('let l[3] = 20', 'E741:') |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
924 unlet l |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
925 endfunc |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
926 |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
927 " lockvar/islocked() triggering script autoloading |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
928 func Test_lockvar_script_autoload() |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
929 let old_rtp = &rtp |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
930 set rtp+=./sautest |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
931 lockvar g:footest#x |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
932 unlockvar g:footest#x |
17914
af3d441845cd
patch 8.1.1953: more functions can be used as a method
Bram Moolenaar <Bram@vim.org>
parents:
17413
diff
changeset
|
933 call assert_equal(-1, 'g:footest#x'->islocked()) |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
934 call assert_equal(0, exists('g:footest#x')) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
935 call assert_equal(1, g:footest#x) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
936 let &rtp = old_rtp |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
937 endfunc |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
938 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
939 " a:000 function argument test |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
940 func s:arg_list_test(...) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
941 call assert_fails('let a:000 = [1, 2]', 'E46:') |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
942 call assert_fails('let a:000[0] = 9', 'E742:') |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
943 call assert_fails('let a:000[2] = [9, 10]', 'E742:') |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
944 call assert_fails('let a:000[3] = {9 : 10}', 'E742:') |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
945 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
946 " now the tests that should pass |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
947 let a:000[2][1] = 9 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
948 call extend(a:000[2], [5, 6]) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
949 let a:000[3][5] = 8 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
950 let a:000[3]['a'] = 12 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
951 call assert_equal([1, 2, [3, 9, 5, 6], {'a': 12, '5': 8}], a:000) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
952 endfunc |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
953 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
954 func Test_func_arg_list() |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
955 call s:arg_list_test(1, 2, [3, 4], {5: 6}) |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
956 endfunc |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
957 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
958 " Tests for reverse(), sort(), uniq() |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
959 func Test_reverse_sort_uniq() |
25597
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
960 let lines =<< trim END |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
961 VAR l = ['-0', 'A11', 2, 2, 'xaaa', 4, 'foo', 'foo6', 'foo', [0, 1, 2], 'x8', [0, 1, 2], 1.5] |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
962 call assert_equal(['-0', 'A11', 2, 'xaaa', 4, 'foo', 'foo6', 'foo', [0, 1, 2], 'x8', [0, 1, 2], 1.5], uniq(copy(l))) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
963 call assert_equal([1.5, [0, 1, 2], 'x8', [0, 1, 2], 'foo', 'foo6', 'foo', 4, 'xaaa', 2, 2, 'A11', '-0'], reverse(l)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
964 call assert_equal([1.5, [0, 1, 2], 'x8', [0, 1, 2], 'foo', 'foo6', 'foo', 4, 'xaaa', 2, 2, 'A11', '-0'], reverse(reverse(l))) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
965 if has('float') |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
966 call assert_equal(['-0', 'A11', 'foo', 'foo', 'foo6', 'x8', 'xaaa', 1.5, 2, 2, 4, [0, 1, 2], [0, 1, 2]], sort(l)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
967 call assert_equal([[0, 1, 2], [0, 1, 2], 4, 2, 2, 1.5, 'xaaa', 'x8', 'foo6', 'foo', 'foo', 'A11', '-0'], reverse(sort(l))) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
968 call assert_equal(['-0', 'A11', 'foo', 'foo', 'foo6', 'x8', 'xaaa', 1.5, 2, 2, 4, [0, 1, 2], [0, 1, 2]], sort(reverse(sort(l)))) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
969 call assert_equal(['-0', 'A11', 'foo', 'foo6', 'x8', 'xaaa', 1.5, 2, 4, [0, 1, 2]], uniq(sort(l))) |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
970 |
25597
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
971 LET l = [7, 9, 'one', 18, 12, 22, 'two', 10.0e-16, -1, 'three', 0xff, 0.22, 'four'] |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
972 call assert_equal([-1, 'one', 'two', 'three', 'four', 1.0e-15, 0.22, 7, 9, 12, 18, 22, 255], sort(copy(l), 'n')) |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
973 |
25597
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
974 LET l = [7, 9, 18, 12, 22, 10.0e-16, -1, 0xff, 0, -0, 0.22, 'bar', 'BAR', 'Bar', 'Foo', 'FOO', 'foo', 'FOOBAR', {}, []] |
27859
3cb1a109e987
patch 8.2.4455: accepting one and zero for second sort() argument is strange
Bram Moolenaar <Bram@vim.org>
parents:
27851
diff
changeset
|
975 call assert_equal(['bar', 'BAR', 'Bar', 'Foo', 'FOO', 'foo', 'FOOBAR', -1, 0, 0, 0.22, 1.0e-15, 12, 18, 22, 255, 7, 9, [], {}], sort(copy(l), 'i')) |
25597
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
976 call assert_equal(['bar', 'BAR', 'Bar', 'Foo', 'FOO', 'foo', 'FOOBAR', -1, 0, 0, 0.22, 1.0e-15, 12, 18, 22, 255, 7, 9, [], {}], sort(copy(l), 'i')) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
977 call assert_equal(['BAR', 'Bar', 'FOO', 'FOOBAR', 'Foo', 'bar', 'foo', -1, 0, 0, 0.22, 1.0e-15, 12, 18, 22, 255, 7, 9, [], {}], sort(copy(l))) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
978 endif |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
979 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
980 call v9.CheckLegacyAndVim9Success(lines) |
15571
4af72c724093
patch 8.1.0793: incorrect error messages for functions that take a Blob
Bram Moolenaar <Bram@vim.org>
parents:
15406
diff
changeset
|
981 |
15579
391ac26c9412
patch 8.1.0797: error E898 is used twice
Bram Moolenaar <Bram@vim.org>
parents:
15571
diff
changeset
|
982 call assert_fails('call reverse("")', 'E899:') |
21265
6a4806e326dd
patch 8.2.1183: assert_fails() checks the last error message
Bram Moolenaar <Bram@vim.org>
parents:
21064
diff
changeset
|
983 call assert_fails('call uniq([1, 2], {x, y -> []})', 'E745:') |
29994
86eb4aba16c3
patch 9.0.0335: checks for Dictionary argument often give a vague error
Bram Moolenaar <Bram@vim.org>
parents:
29986
diff
changeset
|
984 call assert_fails("call sort([1, 2], function('min'), 1)", "E1206:") |
20109
e82996ad131f
patch 8.2.0610: some tests are still old style
Bram Moolenaar <Bram@vim.org>
parents:
19932
diff
changeset
|
985 call assert_fails("call sort([1, 2], function('invalid_func'))", "E700:") |
21265
6a4806e326dd
patch 8.2.1183: assert_fails() checks the last error message
Bram Moolenaar <Bram@vim.org>
parents:
21064
diff
changeset
|
986 call assert_fails("call sort([1, 2], function('min'))", "E118:") |
27859
3cb1a109e987
patch 8.2.4455: accepting one and zero for second sort() argument is strange
Bram Moolenaar <Bram@vim.org>
parents:
27851
diff
changeset
|
987 |
3cb1a109e987
patch 8.2.4455: accepting one and zero for second sort() argument is strange
Bram Moolenaar <Bram@vim.org>
parents:
27851
diff
changeset
|
988 let lines =<< trim END |
3cb1a109e987
patch 8.2.4455: accepting one and zero for second sort() argument is strange
Bram Moolenaar <Bram@vim.org>
parents:
27851
diff
changeset
|
989 call sort(['a', 'b'], 0) |
3cb1a109e987
patch 8.2.4455: accepting one and zero for second sort() argument is strange
Bram Moolenaar <Bram@vim.org>
parents:
27851
diff
changeset
|
990 END |
3cb1a109e987
patch 8.2.4455: accepting one and zero for second sort() argument is strange
Bram Moolenaar <Bram@vim.org>
parents:
27851
diff
changeset
|
991 call v9.CheckDefAndScriptFailure(lines, 'E1256: String or function required for argument 2') |
3cb1a109e987
patch 8.2.4455: accepting one and zero for second sort() argument is strange
Bram Moolenaar <Bram@vim.org>
parents:
27851
diff
changeset
|
992 |
3cb1a109e987
patch 8.2.4455: accepting one and zero for second sort() argument is strange
Bram Moolenaar <Bram@vim.org>
parents:
27851
diff
changeset
|
993 let lines =<< trim END |
3cb1a109e987
patch 8.2.4455: accepting one and zero for second sort() argument is strange
Bram Moolenaar <Bram@vim.org>
parents:
27851
diff
changeset
|
994 call sort(['a', 'b'], 1) |
3cb1a109e987
patch 8.2.4455: accepting one and zero for second sort() argument is strange
Bram Moolenaar <Bram@vim.org>
parents:
27851
diff
changeset
|
995 END |
3cb1a109e987
patch 8.2.4455: accepting one and zero for second sort() argument is strange
Bram Moolenaar <Bram@vim.org>
parents:
27851
diff
changeset
|
996 call v9.CheckDefAndScriptFailure(lines, 'E1256: String or function required for argument 2') |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
997 endfunc |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
998 |
26638
6fd15d82e898
patch 8.2.3848: cannot use reduce() for a string
Bram Moolenaar <Bram@vim.org>
parents:
26626
diff
changeset
|
999 " reduce a list, blob or string |
20649
1fa0ace0ba65
patch 8.2.0878: no reduce() function
Bram Moolenaar <Bram@vim.org>
parents:
20158
diff
changeset
|
1000 func Test_reduce() |
25597
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1001 let lines =<< trim END |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1002 call assert_equal(1, reduce([], LSTART acc, val LMIDDLE acc + val LEND, 1)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1003 call assert_equal(10, reduce([1, 3, 5], LSTART acc, val LMIDDLE acc + val LEND, 1)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1004 call assert_equal(2 * (2 * ((2 * 1) + 2) + 3) + 4, reduce([2, 3, 4], LSTART acc, val LMIDDLE 2 * acc + val LEND, 1)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1005 call assert_equal('a x y z', ['x', 'y', 'z']->reduce(LSTART acc, val LMIDDLE acc .. ' ' .. val LEND, 'a')) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1006 call assert_equal([0, 1, 2, 3], reduce([1, 2, 3], function('add'), [0])) |
20649
1fa0ace0ba65
patch 8.2.0878: no reduce() function
Bram Moolenaar <Bram@vim.org>
parents:
20158
diff
changeset
|
1007 |
25597
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1008 VAR l = ['x', 'y', 'z'] |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1009 call assert_equal(42, reduce(l, function('get'), {'x': {'y': {'z': 42 } } })) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1010 call assert_equal(['x', 'y', 'z'], l) |
20649
1fa0ace0ba65
patch 8.2.0878: no reduce() function
Bram Moolenaar <Bram@vim.org>
parents:
20158
diff
changeset
|
1011 |
25597
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1012 call assert_equal(1, reduce([1], LSTART acc, val LMIDDLE acc + val LEND)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1013 call assert_equal('x y z', reduce(['x', 'y', 'z'], LSTART acc, val LMIDDLE acc .. ' ' .. val LEND)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1014 call assert_equal(120, range(1, 5)->reduce(LSTART acc, val LMIDDLE acc * val LEND)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1015 |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1016 call assert_equal(1, reduce(0z, LSTART acc, val LMIDDLE acc + val LEND, 1)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1017 call assert_equal(1 + 0xaf + 0xbf + 0xcf, reduce(0zAFBFCF, LSTART acc, val LMIDDLE acc + val LEND, 1)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1018 call assert_equal(2 * (2 * 1 + 0xaf) + 0xbf, 0zAFBF->reduce(LSTART acc, val LMIDDLE 2 * acc + val LEND, 1)) |
20649
1fa0ace0ba65
patch 8.2.0878: no reduce() function
Bram Moolenaar <Bram@vim.org>
parents:
20158
diff
changeset
|
1019 |
25597
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1020 call assert_equal(0xff, reduce(0zff, LSTART acc, val LMIDDLE acc + val LEND)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1021 call assert_equal(2 * (2 * 0xaf + 0xbf) + 0xcf, reduce(0zAFBFCF, LSTART acc, val LMIDDLE 2 * acc + val LEND)) |
26638
6fd15d82e898
patch 8.2.3848: cannot use reduce() for a string
Bram Moolenaar <Bram@vim.org>
parents:
26626
diff
changeset
|
1022 |
6fd15d82e898
patch 8.2.3848: cannot use reduce() for a string
Bram Moolenaar <Bram@vim.org>
parents:
26626
diff
changeset
|
1023 call assert_equal('x,y,z', 'xyz'->reduce(LSTART acc, val LMIDDLE acc .. ',' .. val LEND)) |
6fd15d82e898
patch 8.2.3848: cannot use reduce() for a string
Bram Moolenaar <Bram@vim.org>
parents:
26626
diff
changeset
|
1024 call assert_equal('', ''->reduce(LSTART acc, val LMIDDLE acc .. ',' .. val LEND, '')) |
6fd15d82e898
patch 8.2.3848: cannot use reduce() for a string
Bram Moolenaar <Bram@vim.org>
parents:
26626
diff
changeset
|
1025 call assert_equal('あ,い,う,え,お,😊,💕', 'あいうえお😊💕'->reduce(LSTART acc, val LMIDDLE acc .. ',' .. val LEND)) |
6fd15d82e898
patch 8.2.3848: cannot use reduce() for a string
Bram Moolenaar <Bram@vim.org>
parents:
26626
diff
changeset
|
1026 call assert_equal('😊,あ,い,う,え,お,💕', 'あいうえお💕'->reduce(LSTART acc, val LMIDDLE acc .. ',' .. val LEND, '😊')) |
6fd15d82e898
patch 8.2.3848: cannot use reduce() for a string
Bram Moolenaar <Bram@vim.org>
parents:
26626
diff
changeset
|
1027 call assert_equal('ऊ,ॠ,ॡ', reduce('ऊॠॡ', LSTART acc, val LMIDDLE acc .. ',' .. val LEND)) |
6fd15d82e898
patch 8.2.3848: cannot use reduce() for a string
Bram Moolenaar <Bram@vim.org>
parents:
26626
diff
changeset
|
1028 call assert_equal('c,à,t', reduce('càt', LSTART acc, val LMIDDLE acc .. ',' .. val LEND)) |
6fd15d82e898
patch 8.2.3848: cannot use reduce() for a string
Bram Moolenaar <Bram@vim.org>
parents:
26626
diff
changeset
|
1029 call assert_equal('Å,s,t,r,ö,m', reduce('Åström', LSTART acc, val LMIDDLE acc .. ',' .. val LEND)) |
6fd15d82e898
patch 8.2.3848: cannot use reduce() for a string
Bram Moolenaar <Bram@vim.org>
parents:
26626
diff
changeset
|
1030 call assert_equal('Å,s,t,r,ö,m', reduce('Åström', LSTART acc, val LMIDDLE acc .. ',' .. val LEND)) |
6fd15d82e898
patch 8.2.3848: cannot use reduce() for a string
Bram Moolenaar <Bram@vim.org>
parents:
26626
diff
changeset
|
1031 call assert_equal(',a,b,c', reduce('abc', LSTART acc, val LMIDDLE acc .. ',' .. val LEND, test_null_string())) |
25597
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1032 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
1033 call v9.CheckLegacyAndVim9Success(lines) |
20649
1fa0ace0ba65
patch 8.2.0878: no reduce() function
Bram Moolenaar <Bram@vim.org>
parents:
20158
diff
changeset
|
1034 |
25597
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1035 call assert_equal({'x': 1, 'y': 1, 'z': 1 }, ['x', 'y', 'z']->reduce({ acc, val -> extend(acc, { val: 1 }) }, {})) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1036 vim9 assert_equal({'x': 1, 'y': 1, 'z': 1 }, ['x', 'y', 'z']->reduce((acc, val) => extend(acc, {[val]: 1 }), {})) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1037 |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1038 call assert_fails("call reduce([], { acc, val -> acc + val })", 'E998: Reduce of an empty List with no initial value') |
20649
1fa0ace0ba65
patch 8.2.0878: no reduce() function
Bram Moolenaar <Bram@vim.org>
parents:
20158
diff
changeset
|
1039 call assert_fails("call reduce(0z, { acc, val -> acc + val })", 'E998: Reduce of an empty Blob with no initial value') |
28570
35e24d9de858
patch 8.2.4809: various things no6 properly tested
Bram Moolenaar <Bram@vim.org>
parents:
28152
diff
changeset
|
1040 call assert_fails("call reduce(test_null_blob(), { acc, val -> acc + val })", 'E998: Reduce of an empty Blob with no initial value') |
26638
6fd15d82e898
patch 8.2.3848: cannot use reduce() for a string
Bram Moolenaar <Bram@vim.org>
parents:
26626
diff
changeset
|
1041 call assert_fails("call reduce('', { acc, val -> acc + val })", 'E998: Reduce of an empty String with no initial value') |
6fd15d82e898
patch 8.2.3848: cannot use reduce() for a string
Bram Moolenaar <Bram@vim.org>
parents:
26626
diff
changeset
|
1042 call assert_fails("call reduce(test_null_string(), { acc, val -> acc + val })", 'E998: Reduce of an empty String with no initial value') |
20649
1fa0ace0ba65
patch 8.2.0878: no reduce() function
Bram Moolenaar <Bram@vim.org>
parents:
20158
diff
changeset
|
1043 |
26638
6fd15d82e898
patch 8.2.3848: cannot use reduce() for a string
Bram Moolenaar <Bram@vim.org>
parents:
26626
diff
changeset
|
1044 call assert_fails("call reduce({}, { acc, val -> acc + val }, 1)", 'E1098:') |
6fd15d82e898
patch 8.2.3848: cannot use reduce() for a string
Bram Moolenaar <Bram@vim.org>
parents:
26626
diff
changeset
|
1045 call assert_fails("call reduce(0, { acc, val -> acc + val }, 1)", 'E1098:') |
22510
7060df0b8ebf
patch 8.2.1803: a few failures are not tested
Bram Moolenaar <Bram@vim.org>
parents:
22375
diff
changeset
|
1046 call assert_fails("call reduce([1, 2], 'Xdoes_not_exist')", 'E117:') |
30043
fd855ad74887
patch 9.0.0359: error message for wrong argument type is not specific
Bram Moolenaar <Bram@vim.org>
parents:
29994
diff
changeset
|
1047 call assert_fails("echo reduce(0z01, { acc, val -> 2 * acc + val }, '')", 'E1210:') |
21000
3b29ac3394dc
patch 8.2.1051: crash when changing a list while using reduce() on it
Bram Moolenaar <Bram@vim.org>
parents:
20649
diff
changeset
|
1048 |
26638
6fd15d82e898
patch 8.2.3848: cannot use reduce() for a string
Bram Moolenaar <Bram@vim.org>
parents:
26626
diff
changeset
|
1049 call assert_fails("vim9 reduce(0, (acc, val) => (acc .. val), '')", 'E1252:') |
6fd15d82e898
patch 8.2.3848: cannot use reduce() for a string
Bram Moolenaar <Bram@vim.org>
parents:
26626
diff
changeset
|
1050 call assert_fails("vim9 reduce({}, (acc, val) => (acc .. val), '')", 'E1252:') |
6fd15d82e898
patch 8.2.3848: cannot use reduce() for a string
Bram Moolenaar <Bram@vim.org>
parents:
26626
diff
changeset
|
1051 call assert_fails("vim9 reduce(0.1, (acc, val) => (acc .. val), '')", 'E1252:') |
6fd15d82e898
patch 8.2.3848: cannot use reduce() for a string
Bram Moolenaar <Bram@vim.org>
parents:
26626
diff
changeset
|
1052 call assert_fails("vim9 reduce(function('tr'), (acc, val) => (acc .. val), '')", 'E1252:') |
30043
fd855ad74887
patch 9.0.0359: error message for wrong argument type is not specific
Bram Moolenaar <Bram@vim.org>
parents:
29994
diff
changeset
|
1053 call assert_fails("call reduce('', { acc, val -> acc + val }, 1)", 'E1174:') |
fd855ad74887
patch 9.0.0359: error message for wrong argument type is not specific
Bram Moolenaar <Bram@vim.org>
parents:
29994
diff
changeset
|
1054 call assert_fails("call reduce('', { acc, val -> acc + val }, {})", 'E1174:') |
fd855ad74887
patch 9.0.0359: error message for wrong argument type is not specific
Bram Moolenaar <Bram@vim.org>
parents:
29994
diff
changeset
|
1055 call assert_fails("call reduce('', { acc, val -> acc + val }, 0.1)", 'E1174:') |
fd855ad74887
patch 9.0.0359: error message for wrong argument type is not specific
Bram Moolenaar <Bram@vim.org>
parents:
29994
diff
changeset
|
1056 call assert_fails("call reduce('', { acc, val -> acc + val }, function('tr'))", 'E1174:') |
26640
7c055fdd6200
patch 8.2.3849: functions implementing reduce and map are too long
Bram Moolenaar <Bram@vim.org>
parents:
26638
diff
changeset
|
1057 call assert_fails("call reduce('abc', { a, v -> a10}, '')", 'E121:') |
28570
35e24d9de858
patch 8.2.4809: various things no6 properly tested
Bram Moolenaar <Bram@vim.org>
parents:
28152
diff
changeset
|
1058 call assert_fails("call reduce(0z0102, { a, v -> a10}, 1)", 'E121:') |
35e24d9de858
patch 8.2.4809: various things no6 properly tested
Bram Moolenaar <Bram@vim.org>
parents:
28152
diff
changeset
|
1059 call assert_fails("call reduce([1, 2], { a, v -> a10}, '')", 'E121:') |
26638
6fd15d82e898
patch 8.2.3848: cannot use reduce() for a string
Bram Moolenaar <Bram@vim.org>
parents:
26626
diff
changeset
|
1060 |
21000
3b29ac3394dc
patch 8.2.1051: crash when changing a list while using reduce() on it
Bram Moolenaar <Bram@vim.org>
parents:
20649
diff
changeset
|
1061 let g:lut = [1, 2, 3, 4] |
3b29ac3394dc
patch 8.2.1051: crash when changing a list while using reduce() on it
Bram Moolenaar <Bram@vim.org>
parents:
20649
diff
changeset
|
1062 func EvilRemove() |
3b29ac3394dc
patch 8.2.1051: crash when changing a list while using reduce() on it
Bram Moolenaar <Bram@vim.org>
parents:
20649
diff
changeset
|
1063 call remove(g:lut, 1) |
3b29ac3394dc
patch 8.2.1051: crash when changing a list while using reduce() on it
Bram Moolenaar <Bram@vim.org>
parents:
20649
diff
changeset
|
1064 return 1 |
3b29ac3394dc
patch 8.2.1051: crash when changing a list while using reduce() on it
Bram Moolenaar <Bram@vim.org>
parents:
20649
diff
changeset
|
1065 endfunc |
3b29ac3394dc
patch 8.2.1051: crash when changing a list while using reduce() on it
Bram Moolenaar <Bram@vim.org>
parents:
20649
diff
changeset
|
1066 call assert_fails("call reduce(g:lut, { acc, val -> EvilRemove() }, 1)", 'E742:') |
3b29ac3394dc
patch 8.2.1051: crash when changing a list while using reduce() on it
Bram Moolenaar <Bram@vim.org>
parents:
20649
diff
changeset
|
1067 unlet g:lut |
3b29ac3394dc
patch 8.2.1051: crash when changing a list while using reduce() on it
Bram Moolenaar <Bram@vim.org>
parents:
20649
diff
changeset
|
1068 delfunc EvilRemove |
21064
6dc8625889fe
patch 8.2.1083: crash when using reduce() on a NULL list
Bram Moolenaar <Bram@vim.org>
parents:
21000
diff
changeset
|
1069 |
6dc8625889fe
patch 8.2.1083: crash when using reduce() on a NULL list
Bram Moolenaar <Bram@vim.org>
parents:
21000
diff
changeset
|
1070 call assert_equal(42, reduce(test_null_list(), function('add'), 42)) |
6dc8625889fe
patch 8.2.1083: crash when using reduce() on a NULL list
Bram Moolenaar <Bram@vim.org>
parents:
21000
diff
changeset
|
1071 call assert_equal(42, reduce(test_null_blob(), function('add'), 42)) |
22794
42bb78d46354
patch 8.2.1945: crash when passing NULL function to reduce()
Bram Moolenaar <Bram@vim.org>
parents:
22754
diff
changeset
|
1072 |
42bb78d46354
patch 8.2.1945: crash when passing NULL function to reduce()
Bram Moolenaar <Bram@vim.org>
parents:
22754
diff
changeset
|
1073 " should not crash |
42bb78d46354
patch 8.2.1945: crash when passing NULL function to reduce()
Bram Moolenaar <Bram@vim.org>
parents:
22754
diff
changeset
|
1074 call assert_fails('echo reduce([1], test_null_function())', 'E1132:') |
24618
4aebea72c397
patch 8.2.2848: crash whn calling partial
Bram Moolenaar <Bram@vim.org>
parents:
24396
diff
changeset
|
1075 call assert_fails('echo reduce([1], test_null_partial())', 'E1132:') |
20649
1fa0ace0ba65
patch 8.2.0878: no reduce() function
Bram Moolenaar <Bram@vim.org>
parents:
20158
diff
changeset
|
1076 endfunc |
1fa0ace0ba65
patch 8.2.0878: no reduce() function
Bram Moolenaar <Bram@vim.org>
parents:
20158
diff
changeset
|
1077 |
19783
546bdeef35f1
patch 8.2.0448: various functions not properly tested
Bram Moolenaar <Bram@vim.org>
parents:
19724
diff
changeset
|
1078 " splitting a string to a List using split() |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
1079 func Test_str_split() |
25597
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1080 let lines =<< trim END |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1081 call assert_equal(['aa', 'bb'], split(' aa bb ')) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1082 call assert_equal(['aa', 'bb'], split(' aa bb ', '\W\+', 0)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1083 call assert_equal(['', 'aa', 'bb', ''], split(' aa bb ', '\W\+', 1)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1084 call assert_equal(['', '', 'aa', '', 'bb', '', ''], split(' aa bb ', '\W', 1)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1085 call assert_equal(['aa', '', 'bb'], split(':aa::bb:', ':', 0)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1086 call assert_equal(['', 'aa', '', 'bb', ''], split(':aa::bb:', ':', 1)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1087 call assert_equal(['aa', '', 'bb', 'cc', ''], split('aa,,bb, cc,', ',\s*', 1)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1088 call assert_equal(['a', 'b', 'c'], split('abc', '\zs')) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1089 call assert_equal(['', 'a', '', 'b', '', 'c', ''], split('abc', '\zs', 1)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1090 call assert_equal(['abc'], split('abc', '\\%(')) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1091 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
1092 call v9.CheckLegacyAndVim9Success(lines) |
25597
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1093 |
19783
546bdeef35f1
patch 8.2.0448: various functions not properly tested
Bram Moolenaar <Bram@vim.org>
parents:
19724
diff
changeset
|
1094 call assert_fails("call split('abc', [])", 'E730:') |
546bdeef35f1
patch 8.2.0448: various functions not properly tested
Bram Moolenaar <Bram@vim.org>
parents:
19724
diff
changeset
|
1095 call assert_fails("call split('abc', 'b', [])", 'E745:') |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
1096 endfunc |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
1097 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
1098 " compare recursively linked list and dict |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
1099 func Test_listdict_compare() |
25597
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1100 let lines =<< trim END |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1101 VAR l = [1, 2, 3, '4'] |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1102 VAR d = {'1': 1, '2': l, '3': 3} |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1103 LET l[1] = d |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1104 call assert_true(l == l) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1105 call assert_true(d == d) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1106 call assert_false(l != deepcopy(l)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1107 call assert_false(d != deepcopy(d)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1108 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
1109 call v9.CheckLegacyAndVim9Success(lines) |
19724
b3e93a05c3ca
patch 8.2.0418: code in eval.c not sufficiently covered by tests
Bram Moolenaar <Bram@vim.org>
parents:
19689
diff
changeset
|
1110 |
b3e93a05c3ca
patch 8.2.0418: code in eval.c not sufficiently covered by tests
Bram Moolenaar <Bram@vim.org>
parents:
19689
diff
changeset
|
1111 " comparison errors |
b3e93a05c3ca
patch 8.2.0418: code in eval.c not sufficiently covered by tests
Bram Moolenaar <Bram@vim.org>
parents:
19689
diff
changeset
|
1112 call assert_fails('echo [1, 2] =~ {}', 'E691:') |
b3e93a05c3ca
patch 8.2.0418: code in eval.c not sufficiently covered by tests
Bram Moolenaar <Bram@vim.org>
parents:
19689
diff
changeset
|
1113 call assert_fails('echo [1, 2] =~ [1, 2]', 'E692:') |
b3e93a05c3ca
patch 8.2.0418: code in eval.c not sufficiently covered by tests
Bram Moolenaar <Bram@vim.org>
parents:
19689
diff
changeset
|
1114 call assert_fails('echo {} =~ 5', 'E735:') |
b3e93a05c3ca
patch 8.2.0418: code in eval.c not sufficiently covered by tests
Bram Moolenaar <Bram@vim.org>
parents:
19689
diff
changeset
|
1115 call assert_fails('echo {} =~ {}', 'E736:') |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
1116 endfunc |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
1117 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
1118 " compare complex recursively linked list and dict |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
1119 func Test_listdict_compare_complex() |
25597
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1120 let lines =<< trim END |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1121 VAR l = [] |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1122 call add(l, l) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1123 VAR dict4 = {"l": l} |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1124 call add(dict4.l, dict4) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1125 VAR lcopy = deepcopy(l) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1126 VAR dict4copy = deepcopy(dict4) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1127 call assert_true(l == lcopy) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1128 call assert_true(dict4 == dict4copy) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1129 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
1130 call v9.CheckLegacyAndVim9Success(lines) |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
1131 endfunc |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
1132 |
20158
94f05de75e9f
patch 8.2.0634: crash with null partial and blob
Bram Moolenaar <Bram@vim.org>
parents:
20156
diff
changeset
|
1133 " Test for extending lists and dictionaries |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
1134 func Test_listdict_extend() |
15949
d8ab4fa99341
patch 8.1.0980: extend() insufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15762
diff
changeset
|
1135 " Test extend() with lists |
d8ab4fa99341
patch 8.1.0980: extend() insufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15762
diff
changeset
|
1136 |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
1137 " Pass the same List to extend() |
25597
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1138 let lines =<< trim END |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1139 VAR l = [1, 2, 3] |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1140 call assert_equal([1, 2, 3, 1, 2, 3], extend(l, l)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1141 call assert_equal([1, 2, 3, 1, 2, 3], l) |
15949
d8ab4fa99341
patch 8.1.0980: extend() insufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15762
diff
changeset
|
1142 |
25597
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1143 LET l = [1, 2, 3] |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1144 call assert_equal([1, 2, 3, 4, 5, 6], extend(l, [4, 5, 6])) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1145 call assert_equal([1, 2, 3, 4, 5, 6], l) |
15949
d8ab4fa99341
patch 8.1.0980: extend() insufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15762
diff
changeset
|
1146 |
25597
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1147 LET l = [1, 2, 3] |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1148 call extend(l, [4, 5, 6], 0) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1149 call assert_equal([4, 5, 6, 1, 2, 3], l) |
15949
d8ab4fa99341
patch 8.1.0980: extend() insufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15762
diff
changeset
|
1150 |
25597
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1151 LET l = [1, 2, 3] |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1152 call extend(l, [4, 5, 6], 1) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1153 call assert_equal([1, 4, 5, 6, 2, 3], l) |
15949
d8ab4fa99341
patch 8.1.0980: extend() insufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15762
diff
changeset
|
1154 |
25597
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1155 LET l = [1, 2, 3] |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1156 call extend(l, [4, 5, 6], 3) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1157 call assert_equal([1, 2, 3, 4, 5, 6], l) |
15949
d8ab4fa99341
patch 8.1.0980: extend() insufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15762
diff
changeset
|
1158 |
25597
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1159 LET l = [1, 2, 3] |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1160 call extend(l, [4, 5, 6], -1) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1161 call assert_equal([1, 2, 4, 5, 6, 3], l) |
15949
d8ab4fa99341
patch 8.1.0980: extend() insufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15762
diff
changeset
|
1162 |
25597
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1163 LET l = [1, 2, 3] |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1164 call extend(l, [4, 5, 6], -3) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1165 call assert_equal([4, 5, 6, 1, 2, 3], l) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1166 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
1167 call v9.CheckLegacyAndVim9Success(lines) |
15949
d8ab4fa99341
patch 8.1.0980: extend() insufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15762
diff
changeset
|
1168 |
d8ab4fa99341
patch 8.1.0980: extend() insufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15762
diff
changeset
|
1169 let l = [1, 2, 3] |
d8ab4fa99341
patch 8.1.0980: extend() insufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15762
diff
changeset
|
1170 call assert_fails("call extend(l, [4, 5, 6], 4)", 'E684:') |
d8ab4fa99341
patch 8.1.0980: extend() insufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15762
diff
changeset
|
1171 call assert_fails("call extend(l, [4, 5, 6], -4)", 'E684:') |
19249
2a017e9dc6da
patch 8.2.0183: tests fail when the float feature is disabled
Bram Moolenaar <Bram@vim.org>
parents:
17914
diff
changeset
|
1172 if has('float') |
2a017e9dc6da
patch 8.2.0183: tests fail when the float feature is disabled
Bram Moolenaar <Bram@vim.org>
parents:
17914
diff
changeset
|
1173 call assert_fails("call extend(l, [4, 5, 6], 1.2)", 'E805:') |
2a017e9dc6da
patch 8.2.0183: tests fail when the float feature is disabled
Bram Moolenaar <Bram@vim.org>
parents:
17914
diff
changeset
|
1174 endif |
15949
d8ab4fa99341
patch 8.1.0980: extend() insufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15762
diff
changeset
|
1175 |
d8ab4fa99341
patch 8.1.0980: extend() insufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15762
diff
changeset
|
1176 " Test extend() with dictionaries. |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
1177 |
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
1178 " Pass the same Dict to extend() |
25597
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1179 let lines =<< trim END |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1180 VAR d = {'a': {'b': 'B'}, 'x': 9} |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1181 call extend(d, d) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1182 call assert_equal({'a': {'b': 'B'}, 'x': 9}, d) |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
1183 |
25597
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1184 LET d = {'a': 'A', 'b': 9} |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1185 call assert_equal({'a': 'A', 'b': 0, 'c': 'C'}, extend(d, {'b': 0, 'c': 'C'})) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1186 call assert_equal({'a': 'A', 'b': 0, 'c': 'C'}, d) |
15949
d8ab4fa99341
patch 8.1.0980: extend() insufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15762
diff
changeset
|
1187 |
25597
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1188 LET d = {'a': 'A', 'b': 9} |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1189 call extend(d, {'a': 'A', 'b': 0, 'c': 'C'}, "force") |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1190 call assert_equal({'a': 'A', 'b': 0, 'c': 'C'}, d) |
15949
d8ab4fa99341
patch 8.1.0980: extend() insufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15762
diff
changeset
|
1191 |
25597
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1192 LET d = {'a': 'A', 'b': 9} |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1193 call extend(d, {'b': 0, 'c': 'C'}, "keep") |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1194 call assert_equal({'a': 'A', 'b': 9, 'c': 'C'}, d) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1195 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
1196 call v9.CheckLegacyAndVim9Success(lines) |
15949
d8ab4fa99341
patch 8.1.0980: extend() insufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15762
diff
changeset
|
1197 |
d8ab4fa99341
patch 8.1.0980: extend() insufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15762
diff
changeset
|
1198 let d = {'a': 'A', 'b': 'B'} |
d8ab4fa99341
patch 8.1.0980: extend() insufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15762
diff
changeset
|
1199 call assert_fails("call extend(d, {'b': 0, 'c':'C'}, 'error')", 'E737:') |
26759
31c23760d590
patch 8.2.3908: cannot use a script-local function for 'foldtext'
Bram Moolenaar <Bram@vim.org>
parents:
26684
diff
changeset
|
1200 call assert_fails("call extend(d, {'b': 0}, [])", 'E730:') |
15949
d8ab4fa99341
patch 8.1.0980: extend() insufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15762
diff
changeset
|
1201 call assert_fails("call extend(d, {'b': 0, 'c':'C'}, 'xxx')", 'E475:') |
19249
2a017e9dc6da
patch 8.2.0183: tests fail when the float feature is disabled
Bram Moolenaar <Bram@vim.org>
parents:
17914
diff
changeset
|
1202 if has('float') |
24822
5f8dd7b3ae41
patch 8.2.2949: tests failing because no error for float to string conversion
Bram Moolenaar <Bram@vim.org>
parents:
24695
diff
changeset
|
1203 call assert_fails("call extend(d, {'b': 0, 'c':'C'}, 1.2)", 'E475:') |
19249
2a017e9dc6da
patch 8.2.0183: tests fail when the float feature is disabled
Bram Moolenaar <Bram@vim.org>
parents:
17914
diff
changeset
|
1204 endif |
15949
d8ab4fa99341
patch 8.1.0980: extend() insufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15762
diff
changeset
|
1205 call assert_equal({'a': 'A', 'b': 'B'}, d) |
d8ab4fa99341
patch 8.1.0980: extend() insufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15762
diff
changeset
|
1206 |
d8ab4fa99341
patch 8.1.0980: extend() insufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15762
diff
changeset
|
1207 call assert_fails("call extend([1, 2], 1)", 'E712:') |
d8ab4fa99341
patch 8.1.0980: extend() insufficiently tested
Bram Moolenaar <Bram@vim.org>
parents:
15762
diff
changeset
|
1208 call assert_fails("call extend([1, 2], {})", 'E712:') |
20109
e82996ad131f
patch 8.2.0610: some tests are still old style
Bram Moolenaar <Bram@vim.org>
parents:
19932
diff
changeset
|
1209 |
e82996ad131f
patch 8.2.0610: some tests are still old style
Bram Moolenaar <Bram@vim.org>
parents:
19932
diff
changeset
|
1210 " Extend g: dictionary with an invalid variable name |
e82996ad131f
patch 8.2.0610: some tests are still old style
Bram Moolenaar <Bram@vim.org>
parents:
19932
diff
changeset
|
1211 call assert_fails("call extend(g:, {'-!' : 10})", 'E461:') |
24396
d406858354a6
patch 8.2.2738: extending a list with itself can give wrong result
Bram Moolenaar <Bram@vim.org>
parents:
23588
diff
changeset
|
1212 |
d406858354a6
patch 8.2.2738: extending a list with itself can give wrong result
Bram Moolenaar <Bram@vim.org>
parents:
23588
diff
changeset
|
1213 " Extend a list with itself. |
25597
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1214 let lines =<< trim END |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1215 VAR l = [1, 5, 7] |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1216 call extend(l, l, 0) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1217 call assert_equal([1, 5, 7, 1, 5, 7], l) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1218 LET l = [1, 5, 7] |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1219 call extend(l, l, 1) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1220 call assert_equal([1, 1, 5, 7, 5, 7], l) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1221 LET l = [1, 5, 7] |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1222 call extend(l, l, 2) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1223 call assert_equal([1, 5, 1, 5, 7, 7], l) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1224 LET l = [1, 5, 7] |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1225 call extend(l, l, 3) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1226 call assert_equal([1, 5, 7, 1, 5, 7], l) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1227 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
1228 call v9.CheckLegacyAndVim9Success(lines) |
12788
cb9b2774f21f
patch 8.0.1271: still too many old style tests
Christian Brabandt <cb@256bit.org>
parents:
diff
changeset
|
1229 endfunc |
15762
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1230 |
23588
510088f8c66f
patch 8.2.2336: Vim9: not possible to extend dictionary with different type
Bram Moolenaar <Bram@vim.org>
parents:
22806
diff
changeset
|
1231 func Test_listdict_extendnew() |
510088f8c66f
patch 8.2.2336: Vim9: not possible to extend dictionary with different type
Bram Moolenaar <Bram@vim.org>
parents:
22806
diff
changeset
|
1232 " Test extendnew() with lists |
510088f8c66f
patch 8.2.2336: Vim9: not possible to extend dictionary with different type
Bram Moolenaar <Bram@vim.org>
parents:
22806
diff
changeset
|
1233 let l = [1, 2, 3] |
510088f8c66f
patch 8.2.2336: Vim9: not possible to extend dictionary with different type
Bram Moolenaar <Bram@vim.org>
parents:
22806
diff
changeset
|
1234 call assert_equal([1, 2, 3, 4, 5], extendnew(l, [4, 5])) |
510088f8c66f
patch 8.2.2336: Vim9: not possible to extend dictionary with different type
Bram Moolenaar <Bram@vim.org>
parents:
22806
diff
changeset
|
1235 call assert_equal([1, 2, 3], l) |
510088f8c66f
patch 8.2.2336: Vim9: not possible to extend dictionary with different type
Bram Moolenaar <Bram@vim.org>
parents:
22806
diff
changeset
|
1236 |
510088f8c66f
patch 8.2.2336: Vim9: not possible to extend dictionary with different type
Bram Moolenaar <Bram@vim.org>
parents:
22806
diff
changeset
|
1237 " Test extend() with dictionaries. |
510088f8c66f
patch 8.2.2336: Vim9: not possible to extend dictionary with different type
Bram Moolenaar <Bram@vim.org>
parents:
22806
diff
changeset
|
1238 let d = {'a': {'b': 'B'}} |
510088f8c66f
patch 8.2.2336: Vim9: not possible to extend dictionary with different type
Bram Moolenaar <Bram@vim.org>
parents:
22806
diff
changeset
|
1239 call assert_equal({'a': {'b': 'B'}, 'c': 'cc'}, extendnew(d, {'c': 'cc'})) |
510088f8c66f
patch 8.2.2336: Vim9: not possible to extend dictionary with different type
Bram Moolenaar <Bram@vim.org>
parents:
22806
diff
changeset
|
1240 call assert_equal({'a': {'b': 'B'}}, d) |
510088f8c66f
patch 8.2.2336: Vim9: not possible to extend dictionary with different type
Bram Moolenaar <Bram@vim.org>
parents:
22806
diff
changeset
|
1241 endfunc |
510088f8c66f
patch 8.2.2336: Vim9: not possible to extend dictionary with different type
Bram Moolenaar <Bram@vim.org>
parents:
22806
diff
changeset
|
1242 |
15762
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1243 func s:check_scope_dict(x, fixed) |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1244 func s:gen_cmd(cmd, x) |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1245 return substitute(a:cmd, '\<x\ze:', a:x, 'g') |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1246 endfunc |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1247 |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1248 let cmd = s:gen_cmd('let x:foo = 1', a:x) |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1249 if a:fixed |
22087
ff21e2962490
patch 8.2.1593: tests do not check the error number properly
Bram Moolenaar <Bram@vim.org>
parents:
21556
diff
changeset
|
1250 call assert_fails(cmd, 'E461:') |
15762
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1251 else |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1252 exe cmd |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1253 exe s:gen_cmd('call assert_equal(1, x:foo)', a:x) |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1254 endif |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1255 |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1256 let cmd = s:gen_cmd('let x:["bar"] = 2', a:x) |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1257 if a:fixed |
22087
ff21e2962490
patch 8.2.1593: tests do not check the error number properly
Bram Moolenaar <Bram@vim.org>
parents:
21556
diff
changeset
|
1258 call assert_fails(cmd, 'E461:') |
15762
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1259 else |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1260 exe cmd |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1261 exe s:gen_cmd('call assert_equal(2, x:bar)', a:x) |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1262 endif |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1263 |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1264 let cmd = s:gen_cmd('call extend(x:, {"baz": 3})', a:x) |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1265 if a:fixed |
22087
ff21e2962490
patch 8.2.1593: tests do not check the error number properly
Bram Moolenaar <Bram@vim.org>
parents:
21556
diff
changeset
|
1266 call assert_fails(cmd, 'E742:') |
15762
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1267 else |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1268 exe cmd |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1269 exe s:gen_cmd('call assert_equal(3, x:baz)', a:x) |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1270 endif |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1271 |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1272 if a:fixed |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1273 if a:x ==# 'a' |
22087
ff21e2962490
patch 8.2.1593: tests do not check the error number properly
Bram Moolenaar <Bram@vim.org>
parents:
21556
diff
changeset
|
1274 call assert_fails('unlet a:x', 'E795:') |
ff21e2962490
patch 8.2.1593: tests do not check the error number properly
Bram Moolenaar <Bram@vim.org>
parents:
21556
diff
changeset
|
1275 call assert_fails('call remove(a:, "x")', 'E742:') |
15762
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1276 elseif a:x ==# 'v' |
22087
ff21e2962490
patch 8.2.1593: tests do not check the error number properly
Bram Moolenaar <Bram@vim.org>
parents:
21556
diff
changeset
|
1277 call assert_fails('unlet v:count', 'E795:') |
ff21e2962490
patch 8.2.1593: tests do not check the error number properly
Bram Moolenaar <Bram@vim.org>
parents:
21556
diff
changeset
|
1278 call assert_fails('call remove(v:, "count")', 'E742:') |
15762
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1279 endif |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1280 else |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1281 exe s:gen_cmd('unlet x:foo', a:x) |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1282 exe s:gen_cmd('unlet x:bar', a:x) |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1283 exe s:gen_cmd('call remove(x:, "baz")', a:x) |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1284 endif |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1285 |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1286 delfunc s:gen_cmd |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1287 endfunc |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1288 |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1289 func Test_scope_dict() |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1290 " Test for g: |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1291 call s:check_scope_dict('g', v:false) |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1292 |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1293 " Test for s: |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1294 call s:check_scope_dict('s', v:false) |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1295 |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1296 " Test for l: |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1297 call s:check_scope_dict('l', v:false) |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1298 |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1299 " Test for a: |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1300 call s:check_scope_dict('a', v:true) |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1301 |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1302 " Test for b: |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1303 call s:check_scope_dict('b', v:false) |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1304 |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1305 " Test for w: |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1306 call s:check_scope_dict('w', v:false) |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1307 |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1308 " Test for t: |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1309 call s:check_scope_dict('t', v:false) |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1310 |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1311 " Test for v: |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1312 call s:check_scope_dict('v', v:true) |
dff66c4670b1
patch 8.1.0888: the a: dict is not immutable as documented
Bram Moolenaar <Bram@vim.org>
parents:
15579
diff
changeset
|
1313 endfunc |
19689
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1314 |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1315 " Test for deep nesting of lists (> 100) |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1316 func Test_deep_nested_list() |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1317 let deep_list = [] |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1318 let l = deep_list |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1319 for i in range(102) |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1320 let newlist = [] |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1321 call add(l, newlist) |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1322 let l = newlist |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1323 endfor |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1324 call add(l, 102) |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1325 |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1326 call assert_fails('let m = deepcopy(deep_list)', 'E698:') |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1327 call assert_fails('lockvar 110 deep_list', 'E743:') |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1328 call assert_fails('unlockvar 110 deep_list', 'E743:') |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1329 call assert_fails('let x = execute("echo deep_list")', 'E724:') |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1330 call test_garbagecollect_now() |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1331 unlet deep_list |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1332 endfunc |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1333 |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1334 " Test for deep nesting of dicts (> 100) |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1335 func Test_deep_nested_dict() |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1336 let deep_dict = {} |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1337 let d = deep_dict |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1338 for i in range(102) |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1339 let newdict = {} |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1340 let d.k = newdict |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1341 let d = newdict |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1342 endfor |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1343 let d.k = 'v' |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1344 |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1345 call assert_fails('let m = deepcopy(deep_dict)', 'E698:') |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1346 call assert_fails('lockvar 110 deep_dict', 'E743:') |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1347 call assert_fails('unlockvar 110 deep_dict', 'E743:') |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1348 call assert_fails('let x = execute("echo deep_dict")', 'E724:') |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1349 call test_garbagecollect_now() |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1350 unlet deep_dict |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1351 endfunc |
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1352 |
19724
b3e93a05c3ca
patch 8.2.0418: code in eval.c not sufficiently covered by tests
Bram Moolenaar <Bram@vim.org>
parents:
19689
diff
changeset
|
1353 " List and dict indexing tests |
b3e93a05c3ca
patch 8.2.0418: code in eval.c not sufficiently covered by tests
Bram Moolenaar <Bram@vim.org>
parents:
19689
diff
changeset
|
1354 func Test_listdict_index() |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
1355 call v9.CheckLegacyAndVim9Failure(['echo function("min")[0]'], 'E695:') |
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
1356 call v9.CheckLegacyAndVim9Failure(['echo v:true[0]'], 'E909:') |
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
1357 call v9.CheckLegacyAndVim9Failure(['echo v:null[0]'], 'E909:') |
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
1358 call v9.CheckLegacyAndVim9Failure(['VAR d = {"k": 10}', 'echo d.'], ['E15:', 'E1127:', 'E15:']) |
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
1359 call v9.CheckLegacyAndVim9Failure(['VAR d = {"k": 10}', 'echo d[1 : 2]'], 'E719:') |
26646
6f8d3470fa90
patch 8.2.3852: Vim9: not enough tests
Bram Moolenaar <Bram@vim.org>
parents:
26640
diff
changeset
|
1360 |
19724
b3e93a05c3ca
patch 8.2.0418: code in eval.c not sufficiently covered by tests
Bram Moolenaar <Bram@vim.org>
parents:
19689
diff
changeset
|
1361 call assert_fails("let v = [4, 6][{-> 1}]", 'E729:') |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
1362 call v9.CheckDefAndScriptFailure(['var v = [4, 6][() => 1]'], ['E1012', 'E703:']) |
26646
6f8d3470fa90
patch 8.2.3852: Vim9: not enough tests
Bram Moolenaar <Bram@vim.org>
parents:
26640
diff
changeset
|
1363 |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
1364 call v9.CheckLegacyAndVim9Failure(['VAR v = range(5)[2 : []]'], ['E730:', 'E1012:', 'E730:']) |
26648
49c240ea23f4
patch 8.2.3853: Vim9: not enough tests
Bram Moolenaar <Bram@vim.org>
parents:
26646
diff
changeset
|
1365 |
21265
6a4806e326dd
patch 8.2.1183: assert_fails() checks the last error message
Bram Moolenaar <Bram@vim.org>
parents:
21064
diff
changeset
|
1366 call assert_fails("let v = range(5)[2:{-> 2}(]", ['E15:', 'E116:']) |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
1367 call v9.CheckDefAndScriptFailure(['var v = range(5)[2 : () => 2(]'], 'E15:') |
26648
49c240ea23f4
patch 8.2.3853: Vim9: not enough tests
Bram Moolenaar <Bram@vim.org>
parents:
26646
diff
changeset
|
1368 |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
1369 call v9.CheckLegacyAndVim9Failure(['VAR v = range(5)[2 : 3'], ['E111:', 'E1097:', 'E111:']) |
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
1370 call v9.CheckLegacyAndVim9Failure(['VAR l = insert([1, 2, 3], 4, 10)'], 'E684:') |
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
1371 call v9.CheckLegacyAndVim9Failure(['VAR l = insert([1, 2, 3], 4, -10)'], 'E684:') |
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
1372 call v9.CheckLegacyAndVim9Failure(['VAR l = insert([1, 2, 3], 4, [])'], ['E745:', 'E1013:', 'E1210:']) |
26648
49c240ea23f4
patch 8.2.3853: Vim9: not enough tests
Bram Moolenaar <Bram@vim.org>
parents:
26646
diff
changeset
|
1373 |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
1374 call v9.CheckLegacyAndVim9Failure(['VAR l = [1, 2, 3]', 'LET l[i] = 3'], ['E121:', 'E1001:', 'E121:']) |
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
1375 call v9.CheckLegacyAndVim9Failure(['VAR l = [1, 2, 3]', 'LET l[1.1] = 4'], ['E805:', 'E1012:', 'E805:']) |
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
1376 call v9.CheckLegacyAndVim9Failure(['VAR l = [1, 2, 3]', 'LET l[: i] = [4, 5]'], ['E121:', 'E1001:', 'E121:']) |
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
1377 call v9.CheckLegacyAndVim9Failure(['VAR l = [1, 2, 3]', 'LET l[: 3.2] = [4, 5]'], ['E805:', 'E1012:', 'E805:']) |
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
1378 call v9.CheckLegacyAndVim9Failure(['VAR t = test_unknown()', 'echo t[0]'], 'E685:') |
20109
e82996ad131f
patch 8.2.0610: some tests are still old style
Bram Moolenaar <Bram@vim.org>
parents:
19932
diff
changeset
|
1379 endfunc |
e82996ad131f
patch 8.2.0610: some tests are still old style
Bram Moolenaar <Bram@vim.org>
parents:
19932
diff
changeset
|
1380 |
e82996ad131f
patch 8.2.0610: some tests are still old style
Bram Moolenaar <Bram@vim.org>
parents:
19932
diff
changeset
|
1381 " Test for a null list |
e82996ad131f
patch 8.2.0610: some tests are still old style
Bram Moolenaar <Bram@vim.org>
parents:
19932
diff
changeset
|
1382 func Test_null_list() |
25597
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1383 let lines =<< trim END |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1384 VAR l = test_null_list() |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1385 call assert_equal('', join(test_null_list())) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1386 call assert_equal('', join(l)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1387 call assert_equal(0, len(l)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1388 call assert_equal(1, empty(l)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1389 call assert_equal([], split(test_null_string())) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1390 call assert_equal([], l[ : 2]) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1391 call assert_true([] == l) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1392 call assert_equal('[]', string(l)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1393 call assert_equal([], sort(test_null_list())) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1394 call assert_equal([], sort(l)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1395 call assert_equal([], uniq(test_null_list())) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1396 call assert_equal([], uniq(l)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1397 VAR k = [] + l |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1398 call assert_equal([], k) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1399 LET k = l + [] |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1400 call assert_equal([], k) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1401 call assert_equal(0, len(copy(l))) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1402 call assert_equal(0, count(l, 5)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1403 call assert_equal([], deepcopy(l)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1404 call assert_equal(5, get(l, 2, 5)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1405 call assert_equal(-1, index(l, 2, 5)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1406 call assert_equal(0, min(l)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1407 call assert_equal(0, max(l)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1408 call assert_equal(0, remove(test_null_list(), 0, 2)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1409 call assert_equal([], repeat(l, 2)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1410 call assert_equal([], reverse(test_null_list())) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1411 call assert_equal([], reverse(l)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1412 call assert_equal([], sort(test_null_list())) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1413 call assert_equal([], sort(l)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1414 call assert_equal('[]', string(l)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1415 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
1416 call v9.CheckLegacyAndVim9Success(lines) |
25597
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1417 |
20128
0b35a7ffceb2
patch 8.2.0619: null dict is not handled like an empty dict
Bram Moolenaar <Bram@vim.org>
parents:
20109
diff
changeset
|
1418 let l = test_null_list() |
25597
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1419 call assert_equal([], extend(l, l, 0)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1420 call assert_equal(0, insert(test_null_list(), 2, -1)) |
20109
e82996ad131f
patch 8.2.0610: some tests are still old style
Bram Moolenaar <Bram@vim.org>
parents:
19932
diff
changeset
|
1421 call assert_fails('let s = join([1, 2], [])', 'E730:') |
25597
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1422 call assert_fails('call remove(l, 0, 2)', 'E684:') |
22806
690b84a6a7ce
patch 8.2.1951: test for list and dict fails
Bram Moolenaar <Bram@vim.org>
parents:
22794
diff
changeset
|
1423 call assert_fails('call insert(l, 2, -1)', 'E684:') |
690b84a6a7ce
patch 8.2.1951: test for list and dict fails
Bram Moolenaar <Bram@vim.org>
parents:
22794
diff
changeset
|
1424 call assert_fails('call extend(test_null_list(), test_null_list())', 'E1134:') |
25597
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1425 |
20158
94f05de75e9f
patch 8.2.0634: crash with null partial and blob
Bram Moolenaar <Bram@vim.org>
parents:
20156
diff
changeset
|
1426 lockvar l |
94f05de75e9f
patch 8.2.0634: crash with null partial and blob
Bram Moolenaar <Bram@vim.org>
parents:
20156
diff
changeset
|
1427 call assert_equal(1, islocked('l')) |
94f05de75e9f
patch 8.2.0634: crash with null partial and blob
Bram Moolenaar <Bram@vim.org>
parents:
20156
diff
changeset
|
1428 unlockvar l |
20109
e82996ad131f
patch 8.2.0610: some tests are still old style
Bram Moolenaar <Bram@vim.org>
parents:
19932
diff
changeset
|
1429 endfunc |
e82996ad131f
patch 8.2.0610: some tests are still old style
Bram Moolenaar <Bram@vim.org>
parents:
19932
diff
changeset
|
1430 |
e82996ad131f
patch 8.2.0610: some tests are still old style
Bram Moolenaar <Bram@vim.org>
parents:
19932
diff
changeset
|
1431 " Test for a null dict |
e82996ad131f
patch 8.2.0610: some tests are still old style
Bram Moolenaar <Bram@vim.org>
parents:
19932
diff
changeset
|
1432 func Test_null_dict() |
25597
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1433 let lines =<< trim END |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1434 call assert_equal(test_null_dict(), test_null_dict()) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1435 VAR d = test_null_dict() |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1436 call assert_equal({}, d) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1437 call assert_equal(0, len(d)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1438 call assert_equal(1, empty(d)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1439 call assert_equal([], items(test_null_dict())) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1440 call assert_equal([], items(d)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1441 call assert_equal([], keys(test_null_dict())) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1442 call assert_equal([], keys(d)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1443 call assert_equal([], values(test_null_dict())) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1444 call assert_equal([], values(d)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1445 call assert_false(has_key(d, 'k')) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1446 call assert_equal('{}', string(d)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1447 call assert_equal({}, {}) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1448 call assert_equal(0, len(copy(d))) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1449 call assert_equal(0, count(d, 'k')) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1450 call assert_equal({}, deepcopy(d)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1451 call assert_equal(20, get(d, 'k', 20)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1452 call assert_equal(0, min(d)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1453 call assert_equal(0, max(d)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1454 call assert_equal(0, remove(test_null_dict(), 'k')) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1455 call assert_equal('{}', string(d)) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1456 END |
27457
4c16acb2525f
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
1457 call v9.CheckLegacyAndVim9Success(lines) |
25597
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1458 |
20128
0b35a7ffceb2
patch 8.2.0619: null dict is not handled like an empty dict
Bram Moolenaar <Bram@vim.org>
parents:
20109
diff
changeset
|
1459 let d = test_null_dict() |
25597
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1460 call assert_equal({}, extend(d, d, 'keep')) |
0fdacd8f0cf3
patch 8.2.3335: Vim9: not enough tests run with Vim9
Bram Moolenaar <Bram@vim.org>
parents:
25595
diff
changeset
|
1461 call assert_fails("call remove(d, 'k')", 'E716:') |
22806
690b84a6a7ce
patch 8.2.1951: test for list and dict fails
Bram Moolenaar <Bram@vim.org>
parents:
22794
diff
changeset
|
1462 call assert_fails('let x = d[10]', 'E716:') |
690b84a6a7ce
patch 8.2.1951: test for list and dict fails
Bram Moolenaar <Bram@vim.org>
parents:
22794
diff
changeset
|
1463 call assert_fails('call extend(test_null_dict(), test_null_dict())', 'E1133:') |
20158
94f05de75e9f
patch 8.2.0634: crash with null partial and blob
Bram Moolenaar <Bram@vim.org>
parents:
20156
diff
changeset
|
1464 lockvar d |
94f05de75e9f
patch 8.2.0634: crash with null partial and blob
Bram Moolenaar <Bram@vim.org>
parents:
20156
diff
changeset
|
1465 call assert_equal(1, islocked('d')) |
94f05de75e9f
patch 8.2.0634: crash with null partial and blob
Bram Moolenaar <Bram@vim.org>
parents:
20156
diff
changeset
|
1466 unlockvar d |
19724
b3e93a05c3ca
patch 8.2.0418: code in eval.c not sufficiently covered by tests
Bram Moolenaar <Bram@vim.org>
parents:
19689
diff
changeset
|
1467 endfunc |
b3e93a05c3ca
patch 8.2.0418: code in eval.c not sufficiently covered by tests
Bram Moolenaar <Bram@vim.org>
parents:
19689
diff
changeset
|
1468 |
29712
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1469 " Test for the indexof() function |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1470 func Test_indexof() |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1471 let l = [#{color: 'red'}, #{color: 'blue'}, #{color: 'green'}] |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1472 call assert_equal(0, indexof(l, {i, v -> v.color == 'red'})) |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1473 call assert_equal(2, indexof(l, {i, v -> v.color == 'green'})) |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1474 call assert_equal(-1, indexof(l, {i, v -> v.color == 'grey'})) |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1475 call assert_equal(1, indexof(l, "v:val.color == 'blue'")) |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1476 call assert_equal(-1, indexof(l, "v:val.color == 'cyan'")) |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1477 |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1478 let l = [#{n: 10}, #{n: 10}, #{n: 20}] |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1479 call assert_equal(0, indexof(l, "v:val.n == 10", #{startidx: 0})) |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1480 call assert_equal(1, indexof(l, "v:val.n == 10", #{startidx: -2})) |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1481 call assert_equal(-1, indexof(l, "v:val.n == 10", #{startidx: 4})) |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1482 call assert_equal(-1, indexof(l, "v:val.n == 10", #{startidx: -4})) |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1483 call assert_equal(0, indexof(l, "v:val.n == 10", test_null_dict())) |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1484 |
29728
cadc9851377d
patch 9.0.0204: indexof() may leak memory
Bram Moolenaar <Bram@vim.org>
parents:
29712
diff
changeset
|
1485 let s = ["a", "b", "c"] |
cadc9851377d
patch 9.0.0204: indexof() may leak memory
Bram Moolenaar <Bram@vim.org>
parents:
29712
diff
changeset
|
1486 call assert_equal(2, indexof(s, {_, v -> v == 'c'})) |
cadc9851377d
patch 9.0.0204: indexof() may leak memory
Bram Moolenaar <Bram@vim.org>
parents:
29712
diff
changeset
|
1487 call assert_equal(-1, indexof(s, {_, v -> v == 'd'})) |
cadc9851377d
patch 9.0.0204: indexof() may leak memory
Bram Moolenaar <Bram@vim.org>
parents:
29712
diff
changeset
|
1488 call assert_equal(-1, indexof(s, {_, v -> "v == 'd'"})) |
cadc9851377d
patch 9.0.0204: indexof() may leak memory
Bram Moolenaar <Bram@vim.org>
parents:
29712
diff
changeset
|
1489 |
29712
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1490 call assert_equal(-1, indexof([], {i, v -> v == 'a'})) |
29728
cadc9851377d
patch 9.0.0204: indexof() may leak memory
Bram Moolenaar <Bram@vim.org>
parents:
29712
diff
changeset
|
1491 call assert_equal(-1, indexof([1, 2, 3], {_, v -> "v == 2"})) |
29712
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1492 call assert_equal(-1, indexof(test_null_list(), {i, v -> v == 'a'})) |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1493 call assert_equal(-1, indexof(l, test_null_string())) |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1494 call assert_equal(-1, indexof(l, test_null_function())) |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1495 |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1496 " failure cases |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1497 call assert_fails('let i = indexof(l, "v:val == ''cyan''")', 'E735:') |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1498 call assert_fails('let i = indexof(l, "color == ''cyan''")', 'E121:') |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1499 call assert_fails('let i = indexof(l, {})', 'E1256:') |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1500 call assert_fails('let i = indexof({}, "v:val == 2")', 'E1226:') |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1501 call assert_fails('let i = indexof([], "v:val == 2", [])', 'E1206:') |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1502 |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1503 func TestIdx(k, v) |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1504 return a:v.n == 20 |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1505 endfunc |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1506 call assert_equal(2, indexof(l, function("TestIdx"))) |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1507 delfunc TestIdx |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1508 func TestIdx(k, v) |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1509 return {} |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1510 endfunc |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1511 call assert_fails('let i = indexof(l, function("TestIdx"))', 'E728:') |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1512 delfunc TestIdx |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1513 func TestIdx(k, v) |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1514 throw "IdxError" |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1515 endfunc |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1516 call assert_fails('let i = indexof(l, function("TestIdx"))', 'E605:') |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1517 delfunc TestIdx |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1518 endfunc |
bdb31515f78b
patch 9.0.0196: finding value in list may require a for loop
Bram Moolenaar <Bram@vim.org>
parents:
28570
diff
changeset
|
1519 |
19689
da98d2ed8dc5
patch 8.2.0401: not enough test coverage for evalvars.c
Bram Moolenaar <Bram@vim.org>
parents:
19249
diff
changeset
|
1520 " vim: shiftwidth=2 sts=2 expandtab |