1" Tests for the List and Dict types 2 3func TearDown() 4 " Run garbage collection after every test 5 call test_garbagecollect_now() 6endfunc 7 8" Tests for List type 9 10" List creation 11func Test_list_create() 12 " Creating List directly with different types 13 let l = [1, 'as''d', [1, 2, function("strlen")], {'a': 1},] 14 call assert_equal("[1, 'as''d', [1, 2, function('strlen')], {'a': 1}]", string(l)) 15 call assert_equal({'a' : 1}, l[-1]) 16 call assert_equal(1, l[-4]) 17 let x = 10 18 try 19 let x = l[-5] 20 catch 21 call assert_match('E684:', v:exception) 22 endtry 23 call assert_equal(10, x) 24endfunc 25 26" List slices 27func Test_list_slice() 28 let l = [1, 'as''d', [1, 2, function("strlen")], {'a': 1},] 29 call assert_equal([1, 'as''d', [1, 2, function('strlen')], {'a': 1}], l[:]) 30 call assert_equal(['as''d', [1, 2, function('strlen')], {'a': 1}], l[1:]) 31 call assert_equal([1, 'as''d', [1, 2, function('strlen')]], l[:-2]) 32 call assert_equal([1, 'as''d', [1, 2, function('strlen')], {'a': 1}], l[0:8]) 33 call assert_equal([], l[8:-1]) 34 call assert_equal([], l[0:-10]) 35 " perform an operation on a list slice 36 let l = [1, 2, 3] 37 let l[:1] += [1, 2] 38 let l[2:] -= [1] 39 call assert_equal([2, 4, 2], l) 40endfunc 41 42" List identity 43func Test_list_identity() 44 let l = [1, 'as''d', [1, 2, function("strlen")], {'a': 1},] 45 let ll = l 46 let lx = copy(l) 47 call assert_true(l == ll) 48 call assert_false(l isnot ll) 49 call assert_true(l is ll) 50 call assert_true(l == lx) 51 call assert_false(l is lx) 52 call assert_true(l isnot lx) 53endfunc 54 55" removing items with :unlet 56func Test_list_unlet() 57 let l = [1, 'as''d', [1, 2, function("strlen")], {'a': 1},] 58 unlet l[2] 59 call assert_equal([1, 'as''d', {'a': 1}], l) 60 let l = range(8) 61 unlet l[:3] 62 unlet l[1:] 63 call assert_equal([4], l) 64 65 " removing items out of range: silently skip items that don't exist 66 let l = [0, 1, 2, 3] 67 call assert_fails('unlet l[2:1]', 'E684') 68 let l = [0, 1, 2, 3] 69 unlet l[2:2] 70 call assert_equal([0, 1, 3], l) 71 let l = [0, 1, 2, 3] 72 unlet l[2:3] 73 call assert_equal([0, 1], l) 74 let l = [0, 1, 2, 3] 75 unlet l[2:4] 76 call assert_equal([0, 1], l) 77 let l = [0, 1, 2, 3] 78 unlet l[2:5] 79 call assert_equal([0, 1], l) 80 let l = [0, 1, 2, 3] 81 call assert_fails('unlet l[-1:2]', 'E684') 82 let l = [0, 1, 2, 3] 83 unlet l[-2:2] 84 call assert_equal([0, 1, 3], l) 85 let l = [0, 1, 2, 3] 86 unlet l[-3:2] 87 call assert_equal([0, 3], l) 88 let l = [0, 1, 2, 3] 89 unlet l[-4:2] 90 call assert_equal([3], l) 91 let l = [0, 1, 2, 3] 92 unlet l[-5:2] 93 call assert_equal([3], l) 94 let l = [0, 1, 2, 3] 95 unlet l[-6:2] 96 call assert_equal([3], l) 97endfunc 98 99" assignment to a list 100func Test_list_assign() 101 let l = [0, 1, 2, 3] 102 let [va, vb] = l[2:3] 103 call assert_equal([2, 3], [va, vb]) 104 call assert_fails('let [va, vb] = l', 'E687') 105 call assert_fails('let [va, vb] = l[1:1]', 'E688') 106endfunc 107 108" test for range assign 109func Test_list_range_assign() 110 let l = [0] 111 let l[:] = [1, 2] 112 call assert_equal([1, 2], l) 113 let l[-4:-1] = [5, 6] 114 call assert_equal([5, 6], l) 115endfunc 116 117" Test removing items in list 118func Test_list_func_remove() 119 " Test removing 1 element 120 let l = [1, 2, 3, 4] 121 call assert_equal(1, remove(l, 0)) 122 call assert_equal([2, 3, 4], l) 123 124 let l = [1, 2, 3, 4] 125 call assert_equal(2, remove(l, 1)) 126 call assert_equal([1, 3, 4], l) 127 128 let l = [1, 2, 3, 4] 129 call assert_equal(4, remove(l, -1)) 130 call assert_equal([1, 2, 3], l) 131 132 " Test removing range of element(s) 133 let l = [1, 2, 3, 4] 134 call assert_equal([3], remove(l, 2, 2)) 135 call assert_equal([1, 2, 4], l) 136 137 let l = [1, 2, 3, 4] 138 call assert_equal([2, 3], remove(l, 1, 2)) 139 call assert_equal([1, 4], l) 140 141 let l = [1, 2, 3, 4] 142 call assert_equal([2, 3], remove(l, -3, -2)) 143 call assert_equal([1, 4], l) 144 145 " Test invalid cases 146 let l = [1, 2, 3, 4] 147 call assert_fails("call remove(l, 5)", 'E684:') 148 call assert_fails("call remove(l, 1, 5)", 'E684:') 149 call assert_fails("call remove(l, 3, 2)", 'E16:') 150 call assert_fails("call remove(1, 0)", 'E896:') 151 call assert_fails("call remove(l, l)", 'E745:') 152endfunc 153 154" List add() function 155func Test_list_add() 156 let l = [] 157 call add(l, 1) 158 call add(l, [2, 3]) 159 call add(l, []) 160 call add(l, test_null_list()) 161 call add(l, {'k' : 3}) 162 call add(l, {}) 163 call add(l, test_null_dict()) 164 call assert_equal([1, [2, 3], [], [], {'k' : 3}, {}, {}], l) 165 call assert_equal(1, add(test_null_list(), 4)) 166endfunc 167 168" Tests for Dictionary type 169 170func Test_dict() 171 " Creating Dictionary directly with different types 172 let d = {001: 'asd', 'b': [1, 2, function('strlen')], -1: {'a': 1},} 173 call assert_equal("{'1': 'asd', 'b': [1, 2, function('strlen')], '-1': {'a': 1}}", string(d)) 174 call assert_equal('asd', d.1) 175 call assert_equal(['-1', '1', 'b'], sort(keys(d))) 176 call assert_equal(['asd', [1, 2, function('strlen')], {'a': 1}], values(d)) 177 let v = [] 178 for [key, val] in items(d) 179 call extend(v, [key, val]) 180 unlet key val 181 endfor 182 call assert_equal(['1','asd','b',[1, 2, function('strlen')],'-1',{'a': 1}], v) 183 184 call extend(d, {3:33, 1:99}) 185 call extend(d, {'b':'bbb', 'c':'ccc'}, "keep") 186 call assert_fails("call extend(d, {3:333,4:444}, 'error')", 'E737') 187 call assert_equal({'c': 'ccc', '1': 99, 'b': [1, 2, function('strlen')], '3': 33, '-1': {'a': 1}}, d) 188 call filter(d, 'v:key =~ ''[ac391]''') 189 call assert_equal({'c': 'ccc', '1': 99, '3': 33, '-1': {'a': 1}}, d) 190 191 " duplicate key 192 call assert_fails("let d = {'k' : 10, 'k' : 20}", 'E721:') 193 " missing comma 194 call assert_fails("let d = {'k' : 10 'k' : 20}", 'E722:') 195 " missing curly brace 196 call assert_fails("let d = {'k' : 10,", 'E723:') 197 " invalid key 198 call assert_fails('let d = #{++ : 10}', 'E15:') 199 " wrong type for key 200 call assert_fails('let d={[] : 10}', 'E730:') 201 " undefined variable as value 202 call assert_fails("let d={'k' : i}", 'E121:') 203endfunc 204 205" Dictionary identity 206func Test_dict_identity() 207 let d = {001: 'asd', 'b': [1, 2, function('strlen')], -1: {'a': 1},} 208 let dd = d 209 let dx = copy(d) 210 call assert_true(d == dd) 211 call assert_false(d isnot dd) 212 call assert_true(d is dd) 213 call assert_true(d == dx) 214 call assert_false(d is dx) 215 call assert_true(d isnot dx) 216endfunc 217 218" removing items with :unlet 219func Test_dict_unlet() 220 let d = {'b':'bbb', '1': 99, '3': 33, '-1': {'a': 1}} 221 unlet d.b 222 unlet d[-1] 223 call assert_equal({'1': 99, '3': 33}, d) 224endfunc 225 226" manipulating a big Dictionary (hashtable.c has a border of 1000 entries) 227func Test_dict_big() 228 let d = {} 229 for i in range(1500) 230 let d[i] = 3000 - i 231 endfor 232 call assert_equal([3000, 2900, 2001, 1600, 1501], [d[0], d[100], d[999], d[1400], d[1499]]) 233 let str = '' 234 try 235 let n = d[1500] 236 catch 237 let str=substitute(v:exception, '\v(.{14}).*( \d{4}).*', '\1\2', '') 238 endtry 239 call assert_equal('Vim(let):E716: 1500', str) 240 241 " lookup each items 242 for i in range(1500) 243 call assert_equal(3000 - i, d[i]) 244 endfor 245 let i += 1 246 247 " delete even items 248 while i >= 2 249 let i -= 2 250 unlet d[i] 251 endwhile 252 call assert_equal('NONE', get(d, 1500 - 100, 'NONE')) 253 call assert_equal(2999, d[1]) 254 255 " delete odd items, checking value, one intentionally wrong 256 let d[33] = 999 257 let i = 1 258 while i < 1500 259 if i != 33 260 call assert_equal(3000 - i, d[i]) 261 else 262 call assert_equal(999, d[i]) 263 endif 264 unlet d[i] 265 let i += 2 266 endwhile 267 call assert_equal({}, d) 268 unlet d 269endfunc 270 271" Dictionary function 272func Test_dict_func() 273 let d = {} 274 func d.func(a) dict 275 return a:a . len(self.data) 276 endfunc 277 let d.data = [1,2,3] 278 call assert_equal('len: 3', d.func('len: ')) 279 let x = d.func('again: ') 280 call assert_equal('again: 3', x) 281 let Fn = d.func 282 call assert_equal('xxx3', Fn('xxx')) 283endfunc 284 285" Function in script-local List or Dict 286func Test_script_local_dict_func() 287 let g:dict = {} 288 function g:dict.func() dict 289 return 'g:dict.func' . self.foo[1] . self.foo[0]('asdf') 290 endfunc 291 let g:dict.foo = ['-', 2, 3] 292 call insert(g:dict.foo, function('strlen')) 293 call assert_equal('g:dict.func-4', g:dict.func()) 294 unlet g:dict 295endfunc 296 297" Test removing items in a dictionary 298func Test_dict_func_remove() 299 let d = {1:'a', 2:'b', 3:'c'} 300 call assert_equal('b', remove(d, 2)) 301 call assert_equal({1:'a', 3:'c'}, d) 302 303 call assert_fails("call remove(d, 1, 2)", 'E118:') 304 call assert_fails("call remove(d, 'a')", 'E716:') 305 call assert_fails("call remove(d, [])", 'E730:') 306endfunc 307 308" Nasty: remove func from Dict that's being called (works) 309func Test_dict_func_remove_in_use() 310 let d = {1:1} 311 func d.func(a) 312 return "a:" . a:a 313 endfunc 314 let expected = 'a:' . string(get(d, 'func')) 315 call assert_equal(expected, d.func(string(remove(d, 'func')))) 316endfunc 317 318func Test_dict_literal_keys() 319 call assert_equal({'one': 1, 'two2': 2, '3three': 3, '44': 4}, #{one: 1, two2: 2, 3three: 3, 44: 4},) 320 321 " why *{} cannot be used 322 let blue = 'blue' 323 call assert_equal('6', trim(execute('echo 2 *{blue: 3}.blue'))) 324endfunc 325 326" Nasty: deepcopy() dict that refers to itself (fails when noref used) 327func Test_dict_deepcopy() 328 let d = {1:1, 2:2} 329 let l = [4, d, 6] 330 let d[3] = l 331 let dc = deepcopy(d) 332 call assert_fails('call deepcopy(d, 1)', 'E698') 333 let l2 = [0, l, l, 3] 334 let l[1] = l2 335 let l3 = deepcopy(l2) 336 call assert_true(l3[1] is l3[2]) 337 call assert_fails("call deepcopy([1, 2], 2)", 'E474:') 338endfunc 339 340" Locked variables 341func Test_list_locked_var() 342 let expected = [ 343 \ [['0000-000', 'ppppppp'], 344 \ ['0000-000', 'ppppppp'], 345 \ ['0000-000', 'ppppppp']], 346 \ [['1000-000', 'ppppppF'], 347 \ ['0000-000', 'ppppppp'], 348 \ ['0000-000', 'ppppppp']], 349 \ [['1100-100', 'ppFppFF'], 350 \ ['0000-000', 'ppppppp'], 351 \ ['0000-000', 'ppppppp']], 352 \ [['1110-110', 'pFFpFFF'], 353 \ ['0010-010', 'pFppFpp'], 354 \ ['0000-000', 'ppppppp']], 355 \ [['1111-111', 'FFFFFFF'], 356 \ ['0011-011', 'FFpFFpp'], 357 \ ['0000-000', 'ppppppp']] 358 \ ] 359 for depth in range(5) 360 for u in range(3) 361 unlet! l 362 let l = [0, [1, [2, 3]], {4: 5, 6: {7: 8}}] 363 exe "lockvar " . depth . " l" 364 if u == 1 365 exe "unlockvar l" 366 elseif u == 2 367 exe "unlockvar " . depth . " l" 368 endif 369 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]") 370 call assert_equal(expected[depth][u][0], ps) 371 let ps = '' 372 try 373 let l[1][1][0] = 99 374 let ps .= 'p' 375 catch 376 let ps .= 'F' 377 endtry 378 try 379 let l[1][1] = [99] 380 let ps .= 'p' 381 catch 382 let ps .= 'F' 383 endtry 384 try 385 let l[1] = [99] 386 let ps .= 'p' 387 catch 388 let ps .= 'F' 389 endtry 390 try 391 let l[2]['6'][7] = 99 392 let ps .= 'p' 393 catch 394 let ps .= 'F' 395 endtry 396 try 397 let l[2][6] = {99: 99} 398 let ps .= 'p' 399 catch 400 let ps .= 'F' 401 endtry 402 try 403 let l[2] = {99: 99} 404 let ps .= 'p' 405 catch 406 let ps .= 'F' 407 endtry 408 try 409 let l = [99] 410 let ps .= 'p' 411 catch 412 let ps .= 'F' 413 endtry 414 call assert_equal(expected[depth][u][1], ps) 415 endfor 416 endfor 417 call assert_fails("let x=islocked('a b')", 'E488:') 418 let mylist = [1, 2, 3] 419 call assert_fails("let x = islocked('mylist[1:2]')", 'E786:') 420 let mydict = {'k' : 'v'} 421 call assert_fails("let x = islocked('mydict.a')", 'E716:') 422endfunc 423 424" Unletting locked variables 425func Test_list_locked_var_unlet() 426 let expected = [ 427 \ [['0000-000', 'ppppppp'], 428 \ ['0000-000', 'ppppppp'], 429 \ ['0000-000', 'ppppppp']], 430 \ [['1000-000', 'ppFppFp'], 431 \ ['0000-000', 'ppppppp'], 432 \ ['0000-000', 'ppppppp']], 433 \ [['1100-100', 'pFFpFFp'], 434 \ ['0000-000', 'ppppppp'], 435 \ ['0000-000', 'ppppppp']], 436 \ [['1110-110', 'FFFFFFp'], 437 \ ['0010-010', 'FppFppp'], 438 \ ['0000-000', 'ppppppp']], 439 \ [['1111-111', 'FFFFFFp'], 440 \ ['0011-011', 'FppFppp'], 441 \ ['0000-000', 'ppppppp']] 442 \ ] 443 444 for depth in range(5) 445 for u in range(3) 446 unlet! l 447 let l = [0, [1, [2, 3]], {4: 5, 6: {7: 8}}] 448 exe "lockvar " . depth . " l" 449 if u == 1 450 exe "unlockvar l" 451 elseif u == 2 452 exe "unlockvar " . depth . " l" 453 endif 454 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]") 455 call assert_equal(expected[depth][u][0], ps) 456 let ps = '' 457 try 458 unlet l[2]['6'][7] 459 let ps .= 'p' 460 catch 461 let ps .= 'F' 462 endtry 463 try 464 unlet l[2][6] 465 let ps .= 'p' 466 catch 467 let ps .= 'F' 468 endtry 469 try 470 unlet l[2] 471 let ps .= 'p' 472 catch 473 let ps .= 'F' 474 endtry 475 try 476 unlet l[1][1][0] 477 let ps .= 'p' 478 catch 479 let ps .= 'F' 480 endtry 481 try 482 unlet l[1][1] 483 let ps .= 'p' 484 catch 485 let ps .= 'F' 486 endtry 487 try 488 unlet l[1] 489 let ps .= 'p' 490 catch 491 let ps .= 'F' 492 endtry 493 try 494 unlet l 495 let ps .= 'p' 496 catch 497 let ps .= 'F' 498 endtry 499 call assert_equal(expected[depth][u][1], ps) 500 endfor 501 endfor 502endfunc 503 504" Locked variables and :unlet or list / dict functions 505 506" No :unlet after lock on dict: 507func Test_dict_lock_unlet() 508 unlet! d 509 let d = {'a': 99, 'b': 100} 510 lockvar 1 d 511 call assert_fails('unlet d.a', 'E741') 512endfunc 513 514" unlet after lock on dict item 515func Test_dict_item_lock_unlet() 516 unlet! d 517 let d = {'a': 99, 'b': 100} 518 lockvar d.a 519 unlet d.a 520 call assert_equal({'b' : 100}, d) 521endfunc 522 523" filter() after lock on dict item 524func Test_dict_lock_filter() 525 unlet! d 526 let d = {'a': 99, 'b': 100} 527 lockvar d.a 528 call filter(d, 'v:key != "a"') 529 call assert_equal({'b' : 100}, d) 530endfunc 531 532" map() after lock on dict 533func Test_dict_lock_map() 534 unlet! d 535 let d = {'a': 99, 'b': 100} 536 lockvar 1 d 537 call map(d, 'v:val + 200') 538 call assert_equal({'a' : 299, 'b' : 300}, d) 539endfunc 540 541" No extend() after lock on dict item 542func Test_dict_lock_extend() 543 unlet! d 544 let d = {'a': 99, 'b': 100} 545 lockvar d.a 546 call assert_fails("call extend(d, {'a' : 123})", 'E741') 547 call assert_equal({'a': 99, 'b': 100}, d) 548endfunc 549 550" Cannot use += with a locked dict 551func Test_dict_lock_operator() 552 unlet! d 553 let d = {} 554 lockvar d 555 call assert_fails("let d += {'k' : 10}", 'E741:') 556 unlockvar d 557endfunc 558 559" No remove() of write-protected scope-level variable 560func Tfunc1(this_is_a_long_parameter_name) 561 call assert_fails("call remove(a:, 'this_is_a_long_parameter_name')", 'E742') 562endfunc 563func Test_dict_scope_var_remove() 564 call Tfunc1('testval') 565endfunc 566 567" No extend() of write-protected scope-level variable 568func Test_dict_scope_var_extend() 569 call assert_fails("call extend(a:, {'this_is_a_long_parameter_name': 1234})", 'E742') 570endfunc 571 572func Tfunc2(this_is_a_long_parameter_name) 573 call assert_fails("call extend(a:, {'this_is_a_long_parameter_name': 1234})", 'E742') 574endfunc 575func Test_dict_scope_var_extend_overwrite() 576 call Tfunc2('testval') 577endfunc 578 579" No :unlet of variable in locked scope 580func Test_lock_var_unlet() 581 let b:testvar = 123 582 lockvar 1 b: 583 call assert_fails('unlet b:testvar', 'E741:') 584 unlockvar 1 b: 585 unlet! b:testvar 586endfunc 587 588" No :let += of locked list variable 589func Test_let_lock_list() 590 let l = ['a', 'b', 3] 591 lockvar 1 l 592 call assert_fails("let l += ['x']", 'E741:') 593 call assert_equal(['a', 'b', 3], l) 594 595 unlet l 596 let l = [1, 2, 3, 4] 597 lockvar! l 598 call assert_equal([1, 2, 3, 4], l) 599 unlockvar l[1] 600 call assert_fails('unlet l[0:1]', 'E741:') 601 call assert_equal([1, 2, 3, 4], l) 602 call assert_fails('unlet l[1:2]', 'E741:') 603 call assert_equal([1, 2, 3, 4], l) 604 unlockvar l[1] 605 call assert_fails('let l[0:1] = [0, 1]', 'E741:') 606 call assert_equal([1, 2, 3, 4], l) 607 call assert_fails('let l[1:2] = [0, 1]', 'E741:') 608 call assert_equal([1, 2, 3, 4], l) 609 unlet l 610endfunc 611 612" Locking part of the list 613func Test_let_lock_list_items() 614 let l = [1, 2, 3, 4] 615 lockvar l[2:] 616 call assert_equal(0, islocked('l[0]')) 617 call assert_equal(1, islocked('l[2]')) 618 call assert_equal(1, islocked('l[3]')) 619 call assert_fails('let l[2] = 10', 'E741:') 620 call assert_fails('let l[3] = 20', 'E741:') 621 unlet l 622endfunc 623 624" lockvar/islocked() triggering script autoloading 625func Test_lockvar_script_autoload() 626 let old_rtp = &rtp 627 set rtp+=./sautest 628 lockvar g:footest#x 629 unlockvar g:footest#x 630 call assert_equal(-1, 'g:footest#x'->islocked()) 631 call assert_equal(0, exists('g:footest#x')) 632 call assert_equal(1, g:footest#x) 633 let &rtp = old_rtp 634endfunc 635 636" a:000 function argument test 637func s:arg_list_test(...) 638 call assert_fails('let a:000 = [1, 2]', 'E46:') 639 call assert_fails('let a:000[0] = 9', 'E742:') 640 call assert_fails('let a:000[2] = [9, 10]', 'E742:') 641 call assert_fails('let a:000[3] = {9 : 10}', 'E742:') 642 643 " now the tests that should pass 644 let a:000[2][1] = 9 645 call extend(a:000[2], [5, 6]) 646 let a:000[3][5] = 8 647 let a:000[3]['a'] = 12 648 call assert_equal([1, 2, [3, 9, 5, 6], {'a': 12, '5': 8}], a:000) 649endfunc 650 651func Test_func_arg_list() 652 call s:arg_list_test(1, 2, [3, 4], {5: 6}) 653endfunc 654 655" Tests for reverse(), sort(), uniq() 656func Test_reverse_sort_uniq() 657 let l = ['-0', 'A11', 2, 2, 'xaaa', 4, 'foo', 'foo6', 'foo', [0, 1, 2], 'x8', [0, 1, 2], 1.5] 658 call assert_equal(['-0', 'A11', 2, 'xaaa', 4, 'foo', 'foo6', 'foo', [0, 1, 2], 'x8', [0, 1, 2], 1.5], uniq(copy(l))) 659 call assert_equal([1.5, [0, 1, 2], 'x8', [0, 1, 2], 'foo', 'foo6', 'foo', 4, 'xaaa', 2, 2, 'A11', '-0'], reverse(l)) 660 call assert_equal([1.5, [0, 1, 2], 'x8', [0, 1, 2], 'foo', 'foo6', 'foo', 4, 'xaaa', 2, 2, 'A11', '-0'], reverse(reverse(l))) 661 if has('float') 662 call assert_equal(['-0', 'A11', 'foo', 'foo', 'foo6', 'x8', 'xaaa', 1.5, 2, 2, 4, [0, 1, 2], [0, 1, 2]], sort(l)) 663 call assert_equal([[0, 1, 2], [0, 1, 2], 4, 2, 2, 1.5, 'xaaa', 'x8', 'foo6', 'foo', 'foo', 'A11', '-0'], reverse(sort(l))) 664 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)))) 665 call assert_equal(['-0', 'A11', 'foo', 'foo6', 'x8', 'xaaa', 1.5, 2, 4, [0, 1, 2]], uniq(sort(l))) 666 667 let l = [7, 9, 'one', 18, 12, 22, 'two', 10.0e-16, -1, 'three', 0xff, 0.22, 'four'] 668 call assert_equal([-1, 'one', 'two', 'three', 'four', 1.0e-15, 0.22, 7, 9, 12, 18, 22, 255], sort(copy(l), 'n')) 669 670 let l = [7, 9, 18, 12, 22, 10.0e-16, -1, 0xff, 0, -0, 0.22, 'bar', 'BAR', 'Bar', 'Foo', 'FOO', 'foo', 'FOOBAR', {}, []] 671 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), 1)) 672 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')) 673 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))) 674 endif 675 676 call assert_fails('call reverse("")', 'E899:') 677 call assert_fails('call uniq([1, 2], {x, y -> []})', 'E882:') 678 call assert_fails("call sort([1, 2], function('min'), 1)", "E715:") 679 call assert_fails("call sort([1, 2], function('invalid_func'))", "E700:") 680 call assert_fails("call sort([1, 2], function('min'))", "E702:") 681endfunc 682 683" splitting a string to a List using split() 684func Test_str_split() 685 call assert_equal(['aa', 'bb'], split(' aa bb ')) 686 call assert_equal(['aa', 'bb'], split(' aa bb ', '\W\+', 0)) 687 call assert_equal(['', 'aa', 'bb', ''], split(' aa bb ', '\W\+', 1)) 688 call assert_equal(['', '', 'aa', '', 'bb', '', ''], split(' aa bb ', '\W', 1)) 689 call assert_equal(['aa', '', 'bb'], split(':aa::bb:', ':', 0)) 690 call assert_equal(['', 'aa', '', 'bb', ''], split(':aa::bb:', ':', 1)) 691 call assert_equal(['aa', '', 'bb', 'cc', ''], split('aa,,bb, cc,', ',\s*', 1)) 692 call assert_equal(['a', 'b', 'c'], split('abc', '\zs')) 693 call assert_equal(['', 'a', '', 'b', '', 'c', ''], split('abc', '\zs', 1)) 694 call assert_fails("call split('abc', [])", 'E730:') 695 call assert_fails("call split('abc', 'b', [])", 'E745:') 696endfunc 697 698" compare recursively linked list and dict 699func Test_listdict_compare() 700 let l = [1, 2, 3, 4] 701 let d = {'1': 1, '2': l, '3': 3} 702 let l[1] = d 703 call assert_true(l == l) 704 call assert_true(d == d) 705 call assert_false(l != deepcopy(l)) 706 call assert_false(d != deepcopy(d)) 707 708 " comparison errors 709 call assert_fails('echo [1, 2] =~ {}', 'E691:') 710 call assert_fails('echo [1, 2] =~ [1, 2]', 'E692:') 711 call assert_fails('echo {} =~ 5', 'E735:') 712 call assert_fails('echo {} =~ {}', 'E736:') 713endfunc 714 715 " compare complex recursively linked list and dict 716func Test_listdict_compare_complex() 717 let l = [] 718 call add(l, l) 719 let dict4 = {"l": l} 720 call add(dict4.l, dict4) 721 let lcopy = deepcopy(l) 722 let dict4copy = deepcopy(dict4) 723 call assert_true(l == lcopy) 724 call assert_true(dict4 == dict4copy) 725endfunc 726 727" Test for extending lists and dictionaries 728func Test_listdict_extend() 729 " Test extend() with lists 730 731 " Pass the same List to extend() 732 let l = [1, 2, 3] 733 call assert_equal([1, 2, 3, 1, 2, 3], extend(l, l)) 734 call assert_equal([1, 2, 3, 1, 2, 3], l) 735 736 let l = [1, 2, 3] 737 call assert_equal([1, 2, 3, 4, 5, 6], extend(l, [4, 5, 6])) 738 call assert_equal([1, 2, 3, 4, 5, 6], l) 739 740 let l = [1, 2, 3] 741 call extend(l, [4, 5, 6], 0) 742 call assert_equal([4, 5, 6, 1, 2, 3], l) 743 744 let l = [1, 2, 3] 745 call extend(l, [4, 5, 6], 1) 746 call assert_equal([1, 4, 5, 6, 2, 3], l) 747 748 let l = [1, 2, 3] 749 call extend(l, [4, 5, 6], 3) 750 call assert_equal([1, 2, 3, 4, 5, 6], l) 751 752 let l = [1, 2, 3] 753 call extend(l, [4, 5, 6], -1) 754 call assert_equal([1, 2, 4, 5, 6, 3], l) 755 756 let l = [1, 2, 3] 757 call extend(l, [4, 5, 6], -3) 758 call assert_equal([4, 5, 6, 1, 2, 3], l) 759 760 let l = [1, 2, 3] 761 call assert_fails("call extend(l, [4, 5, 6], 4)", 'E684:') 762 call assert_fails("call extend(l, [4, 5, 6], -4)", 'E684:') 763 if has('float') 764 call assert_fails("call extend(l, [4, 5, 6], 1.2)", 'E805:') 765 endif 766 767 " Test extend() with dictionaries. 768 769 " Pass the same Dict to extend() 770 let d = { 'a': {'b': 'B'}} 771 call extend(d, d) 772 call assert_equal({'a': {'b': 'B'}}, d) 773 774 let d = {'a': 'A', 'b': 'B'} 775 call assert_equal({'a': 'A', 'b': 0, 'c': 'C'}, extend(d, {'b': 0, 'c':'C'})) 776 call assert_equal({'a': 'A', 'b': 0, 'c': 'C'}, d) 777 778 let d = {'a': 'A', 'b': 'B'} 779 call extend(d, {'a': 'A', 'b': 0, 'c': 'C'}, "force") 780 call assert_equal({'a': 'A', 'b': 0, 'c': 'C'}, d) 781 782 let d = {'a': 'A', 'b': 'B'} 783 call extend(d, {'b': 0, 'c':'C'}, "keep") 784 call assert_equal({'a': 'A', 'b': 'B', 'c': 'C'}, d) 785 786 let d = {'a': 'A', 'b': 'B'} 787 call assert_fails("call extend(d, {'b': 0, 'c':'C'}, 'error')", 'E737:') 788 call assert_fails("call extend(d, {'b': 0, 'c':'C'}, 'xxx')", 'E475:') 789 if has('float') 790 call assert_fails("call extend(d, {'b': 0, 'c':'C'}, 1.2)", 'E806:') 791 endif 792 call assert_equal({'a': 'A', 'b': 'B'}, d) 793 794 call assert_fails("call extend([1, 2], 1)", 'E712:') 795 call assert_fails("call extend([1, 2], {})", 'E712:') 796 797 " Extend g: dictionary with an invalid variable name 798 call assert_fails("call extend(g:, {'-!' : 10})", 'E461:') 799endfunc 800 801func s:check_scope_dict(x, fixed) 802 func s:gen_cmd(cmd, x) 803 return substitute(a:cmd, '\<x\ze:', a:x, 'g') 804 endfunc 805 806 let cmd = s:gen_cmd('let x:foo = 1', a:x) 807 if a:fixed 808 call assert_fails(cmd, 'E461') 809 else 810 exe cmd 811 exe s:gen_cmd('call assert_equal(1, x:foo)', a:x) 812 endif 813 814 let cmd = s:gen_cmd('let x:["bar"] = 2', a:x) 815 if a:fixed 816 call assert_fails(cmd, 'E461') 817 else 818 exe cmd 819 exe s:gen_cmd('call assert_equal(2, x:bar)', a:x) 820 endif 821 822 let cmd = s:gen_cmd('call extend(x:, {"baz": 3})', a:x) 823 if a:fixed 824 call assert_fails(cmd, 'E742') 825 else 826 exe cmd 827 exe s:gen_cmd('call assert_equal(3, x:baz)', a:x) 828 endif 829 830 if a:fixed 831 if a:x ==# 'a' 832 call assert_fails('unlet a:x', 'E795') 833 call assert_fails('call remove(a:, "x")', 'E742') 834 elseif a:x ==# 'v' 835 call assert_fails('unlet v:count', 'E795') 836 call assert_fails('call remove(v:, "count")', 'E742') 837 endif 838 else 839 exe s:gen_cmd('unlet x:foo', a:x) 840 exe s:gen_cmd('unlet x:bar', a:x) 841 exe s:gen_cmd('call remove(x:, "baz")', a:x) 842 endif 843 844 delfunc s:gen_cmd 845endfunc 846 847func Test_scope_dict() 848 " Test for g: 849 call s:check_scope_dict('g', v:false) 850 851 " Test for s: 852 call s:check_scope_dict('s', v:false) 853 854 " Test for l: 855 call s:check_scope_dict('l', v:false) 856 857 " Test for a: 858 call s:check_scope_dict('a', v:true) 859 860 " Test for b: 861 call s:check_scope_dict('b', v:false) 862 863 " Test for w: 864 call s:check_scope_dict('w', v:false) 865 866 " Test for t: 867 call s:check_scope_dict('t', v:false) 868 869 " Test for v: 870 call s:check_scope_dict('v', v:true) 871endfunc 872 873" Test for deep nesting of lists (> 100) 874func Test_deep_nested_list() 875 let deep_list = [] 876 let l = deep_list 877 for i in range(102) 878 let newlist = [] 879 call add(l, newlist) 880 let l = newlist 881 endfor 882 call add(l, 102) 883 884 call assert_fails('let m = deepcopy(deep_list)', 'E698:') 885 call assert_fails('lockvar 110 deep_list', 'E743:') 886 call assert_fails('unlockvar 110 deep_list', 'E743:') 887 call assert_fails('let x = execute("echo deep_list")', 'E724:') 888 call test_garbagecollect_now() 889 unlet deep_list 890endfunc 891 892" Test for deep nesting of dicts (> 100) 893func Test_deep_nested_dict() 894 let deep_dict = {} 895 let d = deep_dict 896 for i in range(102) 897 let newdict = {} 898 let d.k = newdict 899 let d = newdict 900 endfor 901 let d.k = 'v' 902 903 call assert_fails('let m = deepcopy(deep_dict)', 'E698:') 904 call assert_fails('lockvar 110 deep_dict', 'E743:') 905 call assert_fails('unlockvar 110 deep_dict', 'E743:') 906 call assert_fails('let x = execute("echo deep_dict")', 'E724:') 907 call test_garbagecollect_now() 908 unlet deep_dict 909endfunc 910 911" List and dict indexing tests 912func Test_listdict_index() 913 call assert_fails('echo function("min")[0]', 'E695:') 914 call assert_fails('echo v:true[0]', 'E909:') 915 let d = {'k' : 10} 916 call assert_fails('echo d.', 'E15:') 917 call assert_fails('echo d[1:2]', 'E719:') 918 call assert_fails("let v = [4, 6][{-> 1}]", 'E729:') 919 call assert_fails("let v = range(5)[2:[]]", 'E730:') 920 call assert_fails("let v = range(5)[2:{-> 2}(]", 'E116:') 921 call assert_fails("let v = range(5)[2:3", 'E111:') 922 call assert_fails("let l = insert([1,2,3], 4, 10)", 'E684:') 923 call assert_fails("let l = insert([1,2,3], 4, -10)", 'E684:') 924 call assert_fails("let l = insert([1,2,3], 4, [])", 'E745:') 925 let l = [1, 2, 3] 926 call assert_fails("let l[i] = 3", 'E121:') 927 call assert_fails("let l[1.1] = 4", 'E806:') 928 call assert_fails("let l[:i] = [4, 5]", 'E121:') 929 call assert_fails("let l[:3.2] = [4, 5]", 'E806:') 930 let t = test_unknown() 931 call assert_fails("echo t[0]", 'E685:') 932endfunc 933 934" Test for a null list 935func Test_null_list() 936 let l = test_null_list() 937 call assert_equal(0, join(l)) 938 call assert_equal(0, len(l)) 939 call assert_equal(1, empty(l)) 940 call assert_fails('let s = join([1, 2], [])', 'E730:') 941 call assert_equal([], split(test_null_string())) 942 call assert_equal([], l[:2]) 943 call assert_true([] == l) 944 call assert_equal('[]', string(l)) 945 call assert_equal(0, sort(l)) 946 call assert_equal(0, uniq(l)) 947 call assert_fails("let k = [] + l", 'E15:') 948 call assert_fails("let k = l + []", 'E15:') 949 call assert_equal(0, len(copy(l))) 950 call assert_equal(0, count(l, 5)) 951 call assert_equal([], deepcopy(l)) 952 call assert_equal(5, get(l, 2, 5)) 953 call assert_equal(-1, index(l, 2, 5)) 954 call assert_equal(0, insert(l, 2, -1)) 955 call assert_equal(0, min(l)) 956 call assert_equal(0, max(l)) 957 call assert_equal(0, remove(l, 0, 2)) 958 call assert_equal([], repeat(l, 2)) 959 call assert_equal(0, reverse(l)) 960 call assert_equal(0, sort(l)) 961 call assert_equal('[]', string(l)) 962 call assert_equal(0, extend(l, l, 0)) 963 lockvar l 964 call assert_equal(1, islocked('l')) 965 unlockvar l 966endfunc 967 968" Test for a null dict 969func Test_null_dict() 970 call assert_equal(test_null_dict(), test_null_dict()) 971 let d = test_null_dict() 972 call assert_equal({}, d) 973 call assert_equal(0, len(d)) 974 call assert_equal(1, empty(d)) 975 call assert_equal(0, items(d)) 976 call assert_equal(0, keys(d)) 977 call assert_equal(0, values(d)) 978 call assert_false(has_key(d, 'k')) 979 call assert_equal('{}', string(d)) 980 call assert_fails('let x = d[10]') 981 call assert_equal({}, {}) 982 call assert_equal(0, len(copy(d))) 983 call assert_equal(0, count(d, 'k')) 984 call assert_equal({}, deepcopy(d)) 985 call assert_equal(20, get(d, 'k', 20)) 986 call assert_equal(0, min(d)) 987 call assert_equal(0, max(d)) 988 call assert_equal(0, remove(d, 'k')) 989 call assert_equal('{}', string(d)) 990 call assert_equal(0, extend(d, d, 0)) 991 lockvar d 992 call assert_equal(1, islocked('d')) 993 unlockvar d 994endfunc 995 996" vim: shiftwidth=2 sts=2 expandtab 997