xref: /vim-8.2.3635/src/testdir/test_blob.vim (revision 820d5525) 
1" Tests for the Blob types
2
3source vim9.vim
4
5func TearDown()
6  " Run garbage collection after every test
7  call test_garbagecollect_now()
8endfunc
9
10" Tests for Blob type
11
12" Blob creation from constant
13func Test_blob_create()
14  let lines =<< trim END
15      VAR b = 0zDEADBEEF
16      call assert_equal(v:t_blob, type(b))
17      call assert_equal(4, len(b))
18      call assert_equal(0xDE, b[0])
19      call assert_equal(0xAD, b[1])
20      call assert_equal(0xBE, b[2])
21      call assert_equal(0xEF, b[3])
22      call assert_fails('VAR x = b[4]')
23
24      call assert_equal(0xDE, get(b, 0))
25      call assert_equal(0xEF, get(b, 3))
26
27      call assert_fails('VAR b = 0z1', 'E973:')
28      call assert_fails('VAR b = 0z1x', 'E973:')
29      call assert_fails('VAR b = 0z12345', 'E973:')
30
31      call assert_equal(0z, test_null_blob())
32
33      LET b = 0z001122.33445566.778899.aabbcc.dd
34      call assert_equal(0z00112233445566778899aabbccdd, b)
35      call assert_fails('VAR b = 0z1.1')
36      call assert_fails('VAR b = 0z.')
37      call assert_fails('VAR b = 0z001122.')
38      call assert_fails('call get("", 1)', 'E896:')
39      call assert_equal(0, len(test_null_blob()))
40  END
41  call CheckLegacyAndVim9Success(lines)
42endfunc
43
44" assignment to a blob
45func Test_blob_assign()
46  let lines =<< trim END
47      VAR b = 0zDEADBEEF
48      VAR b2 = b[1 : 2]
49      call assert_equal(0zADBE, b2)
50
51      VAR bcopy = b[:]
52      call assert_equal(b, bcopy)
53      call assert_false(b is bcopy)
54
55      LET b = 0zDEADBEEF
56      LET b2 = b
57      call assert_true(b is b2)
58      LET b[:] = 0z11223344
59      call assert_equal(0z11223344, b)
60      call assert_equal(0z11223344, b2)
61      call assert_true(b is b2)
62
63      LET b = 0zDEADBEEF
64      LET b[3 :] = 0z66
65      call assert_equal(0zDEADBE66, b)
66      LET b[: 1] = 0z8899
67      call assert_equal(0z8899BE66, b)
68
69      LET b = 0zDEADBEEF
70      LET b += 0z99
71      call assert_equal(0zDEADBEEF99, b)
72
73      VAR l = [0z12]
74      VAR m = deepcopy(l)
75      LET m[0] = 0z34	#" E742 or E741 should not occur.
76  END
77  call CheckLegacyAndVim9Success(lines)
78
79  let lines =<< trim END
80      VAR b = 0zDEADBEEF
81      LET b[2 : 3] = 0z112233
82  END
83  call CheckLegacyAndVim9Failure(lines, 'E972:')
84
85  let lines =<< trim END
86      VAR b = 0zDEADBEEF
87      LET b[2 : 3] = 0z11
88  END
89  call CheckLegacyAndVim9Failure(lines, 'E972:')
90
91  let lines =<< trim END
92      VAR b = 0zDEADBEEF
93      LET b[3 : 2] = 0z
94  END
95  call CheckLegacyAndVim9Failure(lines, 'E979:')
96
97  let lines =<< trim END
98      VAR b = 0zDEADBEEF
99      LET b ..= 0z33
100  END
101  call CheckLegacyAndVim9Failure(lines, ['E734:', 'E1019:', 'E734:'])
102
103  let lines =<< trim END
104      VAR b = 0zDEADBEEF
105      LET b ..= "xx"
106  END
107  call CheckLegacyAndVim9Failure(lines, ['E734:', 'E1019:', 'E734:'])
108
109  let lines =<< trim END
110      VAR b = 0zDEADBEEF
111      LET b += "xx"
112  END
113  call CheckLegacyAndVim9Failure(lines, ['E734:', 'E1012:', 'E734:'])
114
115  let lines =<< trim END
116      VAR b = 0zDEADBEEF
117      LET b[1 : 1] ..= 0z55
118  END
119  call CheckLegacyAndVim9Failure(lines, ['E734:', 'E1183:', 'E734:'])
120endfunc
121
122func Test_blob_get_range()
123  let lines =<< trim END
124      VAR b = 0z0011223344
125      call assert_equal(0z2233, b[2 : 3])
126      call assert_equal(0z223344, b[2 : -1])
127      call assert_equal(0z00, b[0 : -5])
128      call assert_equal(0z, b[0 : -11])
129      call assert_equal(0z44, b[-1 :])
130      call assert_equal(0z0011223344, b[:])
131      call assert_equal(0z0011223344, b[: -1])
132      call assert_equal(0z, b[5 : 6])
133      call assert_equal(0z0011, b[-10 : 1])
134  END
135  call CheckLegacyAndVim9Success(lines)
136
137  " legacy script white space
138  let b = 0z0011223344
139  call assert_equal(0z2233, b[2:3])
140endfunc
141
142func Test_blob_get()
143  let lines =<< trim END
144      VAR b = 0z0011223344
145      call assert_equal(0x00, get(b, 0))
146      call assert_equal(0x22, get(b, 2, 999))
147      call assert_equal(0x44, get(b, 4))
148      call assert_equal(0x44, get(b, -1))
149      call assert_equal(-1, get(b, 5))
150      call assert_equal(999, get(b, 5, 999))
151      call assert_equal(-1, get(b, -8))
152      call assert_equal(999, get(b, -8, 999))
153      call assert_equal(10, get(test_null_blob(), 2, 10))
154
155      call assert_equal(0x00, b[0])
156      call assert_equal(0x22, b[2])
157      call assert_equal(0x44, b[4])
158      call assert_equal(0x44, b[-1])
159  END
160  call CheckLegacyAndVim9Success(lines)
161
162  let lines =<< trim END
163      VAR b = 0z0011223344
164      echo b[5]
165  END
166  call CheckLegacyAndVim9Failure(lines, 'E979:')
167
168  let lines =<< trim END
169      VAR b = 0z0011223344
170      echo b[-8]
171  END
172  call CheckLegacyAndVim9Failure(lines, 'E979:')
173endfunc
174
175func Test_blob_to_string()
176  let lines =<< trim END
177      VAR b = 0z00112233445566778899aabbccdd
178      call assert_equal('0z00112233.44556677.8899AABB.CCDD', string(b))
179      call assert_equal(b, eval(string(b)))
180      call remove(b, 4, -1)
181      call assert_equal('0z00112233', string(b))
182      call remove(b, 0, 3)
183      call assert_equal('0z', string(b))
184      call assert_equal('0z', string(test_null_blob()))
185  END
186  call CheckLegacyAndVim9Success(lines)
187endfunc
188
189func Test_blob_compare()
190  let lines =<< trim END
191      VAR b1 = 0z0011
192      VAR b2 = 0z1100
193      VAR b3 = 0z001122
194      call assert_true(b1 == b1)
195      call assert_false(b1 == b2)
196      call assert_false(b1 == b3)
197      call assert_true(b1 != b2)
198      call assert_true(b1 != b3)
199      call assert_true(b1 == 0z0011)
200
201      call assert_false(b1 is b2)
202      LET b2 = b1
203      call assert_true(b1 == b2)
204      call assert_true(b1 is b2)
205      LET b2 = copy(b1)
206      call assert_true(b1 == b2)
207      call assert_false(b1 is b2)
208      LET b2 = b1[:]
209      call assert_true(b1 == b2)
210      call assert_false(b1 is b2)
211      call assert_true(b1 isnot b2)
212  END
213  call CheckLegacyAndVim9Success(lines)
214
215  let lines =<< trim END
216      VAR b1 = 0z0011
217      echo b1 == 9
218  END
219  call CheckLegacyAndVim9Failure(lines, ['E977:', 'E1072', 'E1072'])
220
221  let lines =<< trim END
222      VAR b1 = 0z0011
223      echo b1 != 9
224  END
225  call CheckLegacyAndVim9Failure(lines, ['E977:', 'E1072', 'E1072'])
226
227  let lines =<< trim END
228      VAR b1 = 0z0011
229      VAR b2 = 0z1100
230      VAR x = b1 > b2
231  END
232  call CheckLegacyAndVim9Failure(lines, ['E978:', 'E1072:', 'E1072:'])
233
234  let lines =<< trim END
235      VAR b1 = 0z0011
236      VAR b2 = 0z1100
237      VAR x = b1 < b2
238  END
239  call CheckLegacyAndVim9Failure(lines, ['E978:', 'E1072:', 'E1072:'])
240
241  let lines =<< trim END
242      VAR b1 = 0z0011
243      VAR b2 = 0z1100
244      VAR x = b1 - b2
245  END
246  call CheckLegacyAndVim9Failure(lines, ['E974:', 'E1036:', 'E974:'])
247
248  let lines =<< trim END
249      VAR b1 = 0z0011
250      VAR b2 = 0z1100
251      VAR x = b1 / b2
252  END
253  call CheckLegacyAndVim9Failure(lines, ['E974:', 'E1036:', 'E974:'])
254
255  let lines =<< trim END
256      VAR b1 = 0z0011
257      VAR b2 = 0z1100
258      VAR x = b1 * b2
259  END
260  call CheckLegacyAndVim9Failure(lines, ['E974:', 'E1036:', 'E974:'])
261endfunc
262
263func Test_blob_index_assign()
264  let lines =<< trim END
265      VAR b = 0z00
266      LET b[1] = 0x11
267      LET b[2] = 0x22
268      call assert_equal(0z001122, b)
269  END
270  call CheckLegacyAndVim9Success(lines)
271
272  let lines =<< trim END
273      VAR b = 0z00
274      LET b[2] = 0x33
275  END
276  call CheckLegacyAndVim9Failure(lines, 'E979:')
277
278  let lines =<< trim END
279      VAR b = 0z00
280      LET b[-2] = 0x33
281  END
282  call CheckLegacyAndVim9Failure(lines, 'E979:')
283endfunc
284
285func Test_blob_for_loop()
286  let lines =<< trim END
287      VAR blob = 0z00010203
288      VAR i = 0
289      for byte in blob
290        call assert_equal(i, byte)
291        LET i += 1
292      endfor
293      call assert_equal(4, i)
294
295      LET blob = 0z00
296      call remove(blob, 0)
297      call assert_equal(0, len(blob))
298      for byte in blob
299        call assert_report('loop over empty blob')
300      endfor
301
302      LET blob = 0z0001020304
303      LET i = 0
304      for byte in blob
305        call assert_equal(i, byte)
306        if i == 1
307          call remove(blob, 0)
308        elseif i == 3
309          call remove(blob, 3)
310        endif
311        LET i += 1
312      endfor
313      call assert_equal(5, i)
314  END
315  call CheckLegacyAndVim9Success(lines)
316endfunc
317
318func Test_blob_concatenate()
319  let lines =<< trim END
320      VAR b = 0z0011
321      LET b += 0z2233
322      call assert_equal(0z00112233, b)
323
324      LET b = 0zDEAD + 0zBEEF
325      call assert_equal(0zDEADBEEF, b)
326  END
327  call CheckLegacyAndVim9Success(lines)
328
329  let lines =<< trim END
330      VAR b = 0z0011
331      LET b += "a"
332  END
333  call CheckLegacyAndVim9Failure(lines, ['E734:', 'E1012:', 'E734:'])
334
335  let lines =<< trim END
336      VAR b = 0z0011
337      LET b += 88
338  END
339  call CheckLegacyAndVim9Failure(lines, ['E734:', 'E1012:', 'E734:'])
340endfunc
341
342func Test_blob_add()
343  let lines =<< trim END
344      VAR b = 0z0011
345      call add(b, 0x22)
346      call assert_equal(0z001122, b)
347  END
348  call CheckLegacyAndVim9Success(lines)
349
350  " Only works in legacy script
351  let b = 0z0011
352  call add(b, '51')
353  call assert_equal(0z001133, b)
354  call assert_equal(1, add(test_null_blob(), 0x22))
355
356  let lines =<< trim END
357      VAR b = 0z0011
358      call add(b, [9])
359  END
360  call CheckLegacyAndVim9Failure(lines, ['E745:', 'E1012:', 'E1210:'])
361
362  let lines =<< trim END
363      VAR b = 0z0011
364      call add("", 0x01)
365  END
366  call CheckLegacyAndVim9Failure(lines, ['E897:', 'E1013:', 'E1226:'])
367
368  let lines =<< trim END
369      add(test_null_blob(), 0x22)
370  END
371  call CheckDefExecAndScriptFailure(lines, 'E1131:')
372endfunc
373
374func Test_blob_empty()
375  call assert_false(empty(0z001122))
376  call assert_true(empty(0z))
377  call assert_true(empty(test_null_blob()))
378endfunc
379
380" Test removing items in blob
381func Test_blob_func_remove()
382  let lines =<< trim END
383      #" Test removing 1 element
384      VAR b = 0zDEADBEEF
385      call assert_equal(0xDE, remove(b, 0))
386      call assert_equal(0zADBEEF, b)
387
388      LET b = 0zDEADBEEF
389      call assert_equal(0xEF, remove(b, -1))
390      call assert_equal(0zDEADBE, b)
391
392      LET b = 0zDEADBEEF
393      call assert_equal(0xAD, remove(b, 1))
394      call assert_equal(0zDEBEEF, b)
395
396      #" Test removing range of element(s)
397      LET b = 0zDEADBEEF
398      call assert_equal(0zBE, remove(b, 2, 2))
399      call assert_equal(0zDEADEF, b)
400
401      LET b = 0zDEADBEEF
402      call assert_equal(0zADBE, remove(b, 1, 2))
403      call assert_equal(0zDEEF, b)
404  END
405  call CheckLegacyAndVim9Success(lines)
406
407  " Test invalid cases
408  let lines =<< trim END
409      VAR b = 0zDEADBEEF
410      call remove(b, 5)
411  END
412  call CheckLegacyAndVim9Failure(lines, 'E979:')
413
414  let lines =<< trim END
415      VAR b = 0zDEADBEEF
416      call remove(b, 1, 5)
417  END
418  call CheckLegacyAndVim9Failure(lines, 'E979:')
419
420  let lines =<< trim END
421      VAR b = 0zDEADBEEF
422      call remove(b, 3, 2)
423  END
424  call CheckLegacyAndVim9Failure(lines, 'E979:')
425
426  let lines =<< trim END
427      VAR b = 0zDEADBEEF
428      call remove(test_null_blob(), 1, 2)
429  END
430  call CheckLegacyAndVim9Failure(lines, 'E979:')
431
432  let lines =<< trim END
433      let b = 0zDEADBEEF
434      lockvar b
435      call remove(b, 0)
436      unlockvar b
437  END
438  call CheckScriptFailure(lines, 'E741:')
439
440  " can only check at script level, not in a :def function
441  let lines =<< trim END
442      vim9script
443      var b = 0zDEADBEEF
444      lockvar b
445      remove(b, 0)
446  END
447  call CheckScriptFailure(lines, 'E741:')
448endfunc
449
450func Test_blob_read_write()
451  let lines =<< trim END
452      VAR b = 0zDEADBEEF
453      call writefile(b, 'Xblob')
454      VAR br = readfile('Xblob', 'B')
455      call assert_equal(b, br)
456      call delete('Xblob')
457  END
458  call CheckLegacyAndVim9Success(lines)
459
460  " This was crashing when calling readfile() with a directory.
461  call assert_fails("call readfile('.', 'B')", 'E17: "." is a directory')
462endfunc
463
464" filter() item in blob
465func Test_blob_filter()
466  let lines =<< trim END
467      call assert_equal(test_null_blob(), filter(test_null_blob(), '0'))
468      call assert_equal(0z, filter(0zDEADBEEF, '0'))
469      call assert_equal(0zADBEEF, filter(0zDEADBEEF, 'v:val != 0xDE'))
470      call assert_equal(0zDEADEF, filter(0zDEADBEEF, 'v:val != 0xBE'))
471      call assert_equal(0zDEADBE, filter(0zDEADBEEF, 'v:val != 0xEF'))
472      call assert_equal(0zDEADBEEF, filter(0zDEADBEEF, '1'))
473      call assert_equal(0z01030103, filter(0z010203010203, 'v:val != 0x02'))
474      call assert_equal(0zADEF, filter(0zDEADBEEF, 'v:key % 2'))
475  END
476  call CheckLegacyAndVim9Success(lines)
477endfunc
478
479" map() item in blob
480func Test_blob_map()
481  let lines =<< trim END
482      call assert_equal(0zDFAEBFF0, map(0zDEADBEEF, 'v:val + 1'))
483      call assert_equal(0z00010203, map(0zDEADBEEF, 'v:key'))
484      call assert_equal(0zDEAEC0F2, map(0zDEADBEEF, 'v:key + v:val'))
485  END
486  call CheckLegacyAndVim9Success(lines)
487
488  let lines =<< trim END
489      call map(0z00, '[9]')
490  END
491  call CheckLegacyAndVim9Failure(lines, 'E978:')
492endfunc
493
494func Test_blob_index()
495  let lines =<< trim END
496      call assert_equal(2, index(0zDEADBEEF, 0xBE))
497      call assert_equal(-1, index(0zDEADBEEF, 0))
498      call assert_equal(2, index(0z11111111, 0x11, 2))
499      call assert_equal(3, 0z11110111->index(0x11, 2))
500      call assert_equal(2, index(0z11111111, 0x11, -2))
501      call assert_equal(3, index(0z11110111, 0x11, -2))
502      call assert_equal(0, index(0z11110111, 0x11, -10))
503      call assert_equal(-1, index(test_null_blob(), 1))
504  END
505  call CheckLegacyAndVim9Success(lines)
506endfunc
507
508func Test_blob_insert()
509  let lines =<< trim END
510      VAR b = 0zDEADBEEF
511      call insert(b, 0x33)
512      call assert_equal(0z33DEADBEEF, b)
513
514      LET b = 0zDEADBEEF
515      call insert(b, 0x33, 2)
516      call assert_equal(0zDEAD33BEEF, b)
517  END
518  call CheckLegacyAndVim9Success(lines)
519
520  " only works in legacy script
521  call assert_equal(0, insert(test_null_blob(), 0x33))
522
523  let lines =<< trim END
524      VAR b = 0zDEADBEEF
525      call insert(b, -1)
526  END
527  call CheckLegacyAndVim9Failure(lines, 'E475:')
528
529  let lines =<< trim END
530      VAR b = 0zDEADBEEF
531      call insert(b, 257)
532  END
533  call CheckLegacyAndVim9Failure(lines, 'E475:')
534
535  let lines =<< trim END
536      VAR b = 0zDEADBEEF
537      call insert(b, 0, [9])
538  END
539  call CheckLegacyAndVim9Failure(lines, ['E745:', 'E1013:', 'E1210:'])
540
541  let lines =<< trim END
542      VAR b = 0zDEADBEEF
543      call insert(b, 0, -20)
544  END
545  call CheckLegacyAndVim9Failure(lines, 'E475:')
546
547  let lines =<< trim END
548      VAR b = 0zDEADBEEF
549      call insert(b, 0, 20)
550  END
551  call CheckLegacyAndVim9Failure(lines, 'E475:')
552
553  let lines =<< trim END
554      VAR b = 0zDEADBEEF
555      call insert(b, [])
556  END
557  call CheckLegacyAndVim9Failure(lines, ['E745:', 'E1013:', 'E1210:'])
558
559  let lines =<< trim END
560      insert(test_null_blob(), 0x33)
561  END
562  call CheckDefExecAndScriptFailure(lines, 'E1131:')
563
564  let lines =<< trim END
565      let b = 0zDEADBEEF
566      lockvar b
567      call insert(b, 3)
568      unlockvar b
569  END
570  call CheckScriptFailure(lines, 'E741:')
571
572  let lines =<< trim END
573      vim9script
574      var b = 0zDEADBEEF
575      lockvar b
576      insert(b, 3)
577  END
578  call CheckScriptFailure(lines, 'E741:')
579endfunc
580
581func Test_blob_reverse()
582  let lines =<< trim END
583      call assert_equal(0zEFBEADDE, reverse(0zDEADBEEF))
584      call assert_equal(0zBEADDE, reverse(0zDEADBE))
585      call assert_equal(0zADDE, reverse(0zDEAD))
586      call assert_equal(0zDE, reverse(0zDE))
587      call assert_equal(0z, reverse(test_null_blob()))
588  END
589  call CheckLegacyAndVim9Success(lines)
590endfunc
591
592func Test_blob_json_encode()
593  let lines =<< trim END
594      call assert_equal('[222,173,190,239]', json_encode(0zDEADBEEF))
595      call assert_equal('[]', json_encode(0z))
596  END
597  call CheckLegacyAndVim9Success(lines)
598endfunc
599
600func Test_blob_lock()
601  let lines =<< trim END
602      let b = 0z112233
603      lockvar b
604      unlockvar b
605      let b = 0z44
606  END
607  call CheckScriptSuccess(lines)
608
609  let lines =<< trim END
610      vim9script
611      var b = 0z112233
612      lockvar b
613      unlockvar b
614      b = 0z44
615  END
616  call CheckScriptSuccess(lines)
617
618  let lines =<< trim END
619      let b = 0z112233
620      lockvar b
621      let b = 0z44
622  END
623  call CheckScriptFailure(lines, 'E741:')
624
625  let lines =<< trim END
626      vim9script
627      var b = 0z112233
628      lockvar b
629      b = 0z44
630  END
631  call CheckScriptFailure(lines, 'E741:')
632endfunc
633
634func Test_blob_sort()
635  if has('float')
636    call CheckLegacyAndVim9Failure(['call sort([1.0, 0z11], "f")'], 'E975:')
637  endif
638  call CheckLegacyAndVim9Failure(['call sort([11, 0z11], "N")'], 'E974:')
639endfunc
640
641" Tests for the blob2list() function
642func Test_blob2list()
643  call assert_fails('let v = blob2list(10)', 'E1238: Blob required for argument 1')
644  eval 0zFFFF->blob2list()->assert_equal([255, 255])
645  let tests = [[0z0102, [1, 2]],
646        \ [0z00, [0]],
647        \ [0z, []],
648        \ [0z00000000, [0, 0, 0, 0]],
649        \ [0zAABB.CCDD, [170, 187, 204, 221]]]
650  for t in tests
651    call assert_equal(t[0]->blob2list(), t[1])
652  endfor
653  exe 'let v = 0z' .. repeat('000102030405060708090A0B0C0D0E0F', 64)
654  call assert_equal(1024, blob2list(v)->len())
655  call assert_equal([4, 8, 15], [v[100], v[1000], v[1023]])
656  call assert_equal([], blob2list(test_null_blob()))
657endfunc
658
659" Tests for the list2blob() function
660func Test_list2blob()
661  call assert_fails('let b = list2blob(0z10)', 'E1211: List required for argument 1')
662  let tests = [[[1, 2], 0z0102],
663        \ [[0], 0z00],
664        \ [[], 0z],
665        \ [[0, 0, 0, 0], 0z00000000],
666        \ [[255, 255], 0zFFFF],
667        \ [[170, 187, 204, 221], 0zAABB.CCDD],
668        \ ]
669  for t in tests
670    call assert_equal(t[1], t[0]->list2blob())
671  endfor
672  call assert_fails('let b = list2blob([1, []])', 'E745:')
673  call assert_fails('let b = list2blob([-1])', 'E1239:')
674  call assert_fails('let b = list2blob([256])', 'E1239:')
675  let b = range(16)->repeat(64)->list2blob()
676  call assert_equal(1024, b->len())
677  call assert_equal([4, 8, 15], [b[100], b[1000], b[1023]])
678  call assert_equal(0z, list2blob(test_null_list()))
679endfunc
680
681" vim: shiftwidth=2 sts=2 expandtab
682