Debian Codegraph @

test/zipfile.test

raw
1 # 2017 December 9
2 #
3 # The author disclaims copyright to this source code. In place of
4 # a legal notice, here is a blessing:
5 #
6 # May you do good and not evil.
7 # May you find forgiveness for yourself and forgive others.
8 # May you share freely, never taking more than you give.
9 #
10 #***********************************************************************
11 #
12
13 if {$tcl_version<8.6} {
14 puts "Requires TCL 8.6 or later"
15 return
16 }
17
18 set testdir [file dirname $argv0]
19 source $testdir/tester.tcl
20 set testprefix zipfile
21
22 ifcapable !vtab {
23 finish_test; return
24 }
25 if {[catch {load_static_extension db zipfile} error]} {
26 puts "Skipping zipfile tests, hit load error: $error"
27 finish_test; return
28 }
29 if {[catch {load_static_extension db fileio} error]} {
30 puts "Skipping zipfile tests, hit load error: $error"
31 finish_test; return
32 }
33
34 proc readfile {f} {
35 set fd [open $f]
36 fconfigure $fd -translation binary
37 set data [read $fd]
38 close $fd
39 set data
40 }
41
42 unset -nocomplain ::UNZIP
43
44 if {[catch {exec unzip} msg]==0 && \
45 [regexp -line {^UnZip \d+\.\d+ .*? Info-ZIP\.} $msg]} {
46 set ::UNZIP unzip
47 proc fix_stat_mode {name mode} {
48 if {$::tcl_platform(platform) eq "windows"} {
49 #
50 # NOTE: Set or unset the write bits of the file permissions
51 # based on the read-only attribute because the Win32
52 # version of UnZip does this.
53 #
54 set writebits 0x12; # 0o22
55 set result $mode
56 if {[file attributes $name -readonly]} {
57 set result [expr {$result | $writebits}]
58 } else {
59 set result [expr {$result & ~$writebits}]
60 }
61 return $result
62 } else {
63 return $mode
64 }
65 }
66 proc do_unzip {file} {
67 forcedelete test_unzip
68 file mkdir test_unzip
69 exec $::UNZIP -d test_unzip $file
70
71 db func modefix fix_stat_mode
72
73 set res [db eval {
74 SELECT replace(name,'test_unzip/',''),modefix(name,mode),mtime,data
75 FROM fsdir('test_unzip')
76 WHERE name!='test_unzip'
77 ORDER BY name
78 }]
79 set res
80 }
81 }
82
83
84 # The argument is a blob (not a hex string) containing a zip archive.
85 # This proc removes the extended timestamp fields from the archive
86 # and returns the result.
87 #
88 proc remove_timestamps {blob} {
89 set hex [binary encode hex $blob]
90 set hex [string map {55540500 00000500} $hex]
91 binary decode hex $hex
92 }
93
94
95 # Argument $file is the name of a zip archive on disk. This function
96 # executes test cases to check that the results of each of the following
97 # are the same:
98 #
99 # SELECT * FROM zipfile($file)
100 # SELECT * FROM zipfile( readfile($file) )
101 # SELECT * FROM zipfile(
102 # (SELECT zipfile(name,mode,mtime,data,method) FROM zipfile($file))
103 # )
104 #
105 proc do_zipfile_blob_test {tn file} {
106
107 db func r readfile
108 set q1 {SELECT name,mode,mtime,method,quote(data) FROM zipfile($file)}
109 set q2 {SELECT name,mode,mtime,method,quote(data) FROM zipfile( r($file) )}
110 set q3 {SELECT name,mode,mtime,method,quote(data) FROM zipfile(
111 ( SELECT zipfile(name,mode,mtime,data,method) FROM zipfile($file) )
112 )}
113
114
115 set r1 [db eval $q1]
116 set r2 [db eval $q2]
117 set r3 [db eval $q3]
118 #puts $r1
119 #puts $r2
120 #puts $r3
121
122 uplevel [list do_test $tn.1 [list set {} $r2] $r1]
123 uplevel [list do_test $tn.2 [list set {} $r3] $r1]
124 }
125
126 # Argument $file is a zip file on disk. This command runs tests to:
127 #
128 # 1. Unpack the archive with unix command [unzip] and compare the
129 # results to reading the same archive using the zipfile() table
130 # valued function.
131 #
132 # 2. Creates a new archive with the same contents using the zipfile()
133 # aggregate function as follows:
134 #
135 # SELECT writefile('test_unzip.zip',
136 # ( SELECT zipfile(name,mode,mtime,data,method) FROM zipfile($file) )
137 # );
138 #
139 # Then tests that unpacking the new archive using [unzip] produces
140 # the same results as in (1).
141 #
142 proc do_unzip_test {tn file} {
143 db func sss strip_slash
144
145 db eval {
146 SELECT writefile('test_unzip.zip',
147 ( SELECT zipfile(name,mode,mtime,data,method) FROM zipfile($file) )
148 );
149 }
150
151 set r1 [db eval {
152 SELECT sss(name),mode,mtime,data FROM zipfile($file) ORDER BY name
153 }]
154 set r2 [do_unzip $file]
155 set r3 [do_unzip test_unzip.zip]
156
157 uplevel [list do_test $tn.1 [list set {} $r2] $r1]
158 uplevel [list do_test $tn.2 [list set {} $r3] $r1]
159 }
160 proc strip_slash {in} { regsub {/$} $in {} }
161
162 proc do_zip_tests {tn file} {
163 uplevel do_zipfile_blob_test $tn.1 $file
164 if {[info exists ::UNZIP]} {
165 uplevel do_unzip_test $tn.2 $file
166 }
167 }
168
169 forcedelete test.zip
170 do_execsql_test 1.0 {
171 CREATE VIRTUAL TABLE temp.zz USING zipfile('test.zip');
172 PRAGMA table_info(zz);
173 } {
174 0 name {} 1 {} 1
175 1 mode {} 0 {} 0
176 2 mtime {} 0 {} 0
177 3 sz {} 0 {} 0
178 4 rawdata {} 0 {} 0
179 5 data {} 0 {} 0
180 6 method {} 0 {} 0
181 }
182
183 do_catchsql_test 1.1.0.1 {
184 INSERT INTO zz(name, mode, mtime, sz, rawdata, method)
185 VALUES('f.txt', '-rw-r--r--', 1000000000, 5, 'abcde', 0);
186 } {1 {rawdata must be NULL}}
187 do_catchsql_test 1.1.0.2 {
188 INSERT INTO zz(name, mtime, sz, data, method)
189 VALUES('g.txt', 1000000002, 5, '12345', 0);
190 } {1 {sz must be NULL}}
191 do_catchsql_test 1.1.0.3 {
192 INSERT INTO zz(name, mtime, rawdata, method)
193 VALUES('g.txt', 1000000002, '12345', 0);
194 } {1 {rawdata must be NULL}}
195 do_catchsql_test 1.1.0.4 {
196 INSERT INTO zz(name, data, method)
197 VALUES('g.txt', '12345', 7);
198 } {1 {unknown compression method: 7}}
199
200 do_execsql_test 1.1.1 {
201 INSERT INTO zz(name, mode, mtime, data, method)
202 VALUES('f.txt', '-rw-r--r--', 1000000000, 'abcde', 0);
203 }
204 do_execsql_test 1.1.2 {
205 INSERT INTO zz(name, mode, mtime, data, method)
206 VALUES('g.txt', NULL, 1000000002, '12345', 0);
207 }
208
209 do_execsql_test 1.2 {
210 SELECT name, mtime, data FROM zipfile('test.zip')
211 } {
212 f.txt 1000000000 abcde
213 g.txt 1000000002 12345
214 }
215 do_zip_tests 1.2a test.zip
216
217 do_execsql_test 1.3 {
218 INSERT INTO zz(name, mode, mtime, data) VALUES('h.txt',
219 '-rw-r--r--', 1000000004, 'aaaaaaaaaabbbbbbbbbb'
220 );
221 }
222 do_zip_tests 1.3a test.zip
223
224 do_execsql_test 1.4 {
225 SELECT name, mtime, data, method FROM zipfile('test.zip');
226 } {
227 f.txt 1000000000 abcde 0
228 g.txt 1000000002 12345 0
229 h.txt 1000000004 aaaaaaaaaabbbbbbbbbb 8
230 }
231
232 ifcapable json1 {
233 do_execsql_test 1.4.1 {
234 SELECT name, json_extract( zipfile_cds(z) , '$.crc32')!=0
235 FROM zipfile('test.zip');
236 } {
237 f.txt 1
238 g.txt 1
239 h.txt 1
240 }
241 }
242 do_catchsql_test 1.4.2 {
243 SELECT zipfile_cds(mode) FROM zipfile('test.zip');
244 } {0 {{} {} {}}}
245
246 do_execsql_test 1.5.1 {
247 BEGIN;
248 INSERT INTO zz(name, mode, mtime, data, method)
249 VALUES('i.txt', '-rw-r--r--', 1000000006, 'zxcvb', 0);
250 SELECT name FROM zz;
251 COMMIT;
252 } {f.txt g.txt h.txt i.txt}
253 do_execsql_test 1.5.2 {
254 SELECT name FROM zz;
255 } {f.txt g.txt h.txt i.txt}
256 do_execsql_test 1.5.3 {
257 SELECT data FROM zz WHERE name='i.txt';
258 } {zxcvb}
259
260 do_execsql_test 1.6.0 {
261 DELETE FROM zz WHERE name='g.txt';
262 SELECT name FROM zz;
263 } {f.txt h.txt i.txt}
264
265 do_execsql_test 1.6.1 {
266 SELECT name, mode, mtime, data, method FROM zipfile('test.zip');
267 } {
268 f.txt 33188 1000000000 abcde 0
269 h.txt 33188 1000000004 aaaaaaaaaabbbbbbbbbb 8
270 i.txt 33188 1000000006 zxcvb 0
271 }
272 do_zip_tests 1.6.1a test.zip
273
274 do_execsql_test 1.6.2 {
275 UPDATE zz SET mtime=4 WHERE name='i.txt';
276 SELECT name, mode, mtime, data, method FROM zipfile('test.zip');
277 } {
278 f.txt 33188 1000000000 abcde 0
279 h.txt 33188 1000000004 aaaaaaaaaabbbbbbbbbb 8
280 i.txt 33188 4 zxcvb 0
281 }
282
283 if {$::tcl_platform(platform) eq "unix"} {
284 set modes -rw-r--r-x
285 set perms 33189
286 } else {
287 set modes -rw-r--r--; # no execute bits on Win32
288 set perms 33188
289 }
290
291 do_execsql_test 1.6.3 {
292 UPDATE zz SET mode=$modes WHERE name='h.txt';
293 SELECT name, mode, mtime, data, method FROM zipfile('test.zip');
294 } [string map [list %perms% $perms] {
295 f.txt 33188 1000000000 abcde 0
296 h.txt %perms% 1000000004 aaaaaaaaaabbbbbbbbbb 8
297 i.txt 33188 4 zxcvb 0
298 }]
299 do_zip_tests 1.6.3a test.zip
300
301 do_execsql_test 1.6.4 {
302 UPDATE zz SET name = 'blue.txt' WHERE name='f.txt';
303 SELECT name, mode, mtime, data, method FROM zipfile('test.zip');
304 } [string map [list %perms% $perms] {
305 blue.txt 33188 1000000000 abcde 0
306 h.txt %perms% 1000000004 aaaaaaaaaabbbbbbbbbb 8
307 i.txt 33188 4 zxcvb 0
308 }]
309 do_zip_tests 1.6.4a test.zip
310
311 do_execsql_test 1.6.5 {
312 UPDATE zz SET data = 'edcba' WHERE name='blue.txt';
313 SELECT name, mode, mtime, data, method FROM zipfile('test.zip');
314 } [string map [list %perms% $perms] {
315 blue.txt 33188 1000000000 edcba 0
316 h.txt %perms% 1000000004 aaaaaaaaaabbbbbbbbbb 8
317 i.txt 33188 4 zxcvb 0
318 }]
319
320 do_execsql_test 1.6.6 {
321 UPDATE zz SET mode=NULL, data = NULL WHERE name='blue.txt';
322 SELECT name, mode, mtime, data, method FROM zipfile('test.zip');
323 } [string map [list %perms% $perms] {
324 blue.txt/ 16877 1000000000 {} 0
325 h.txt %perms% 1000000004 aaaaaaaaaabbbbbbbbbb 8
326 i.txt 33188 4 zxcvb 0
327 }]
328
329 do_catchsql_test 1.6.7 {
330 UPDATE zz SET data=NULL WHERE name='i.txt'
331 } {1 {zipfile: mode does not match data}}
332 do_execsql_test 1.6.8 {
333 SELECT name, mode, mtime, data, method FROM zipfile('test.zip');
334 } [string map [list %perms% $perms] {
335 blue.txt/ 16877 1000000000 {} 0
336 h.txt %perms% 1000000004 aaaaaaaaaabbbbbbbbbb 8
337 i.txt 33188 4 zxcvb 0
338 }]
339
340 do_execsql_test 1.6.9 {
341 UPDATE zz SET data = '' WHERE name='i.txt';
342 SELECT name,mode,mtime,data,method from zipfile('test.zip');
343 } [string map [list %perms% $perms] {
344 blue.txt/ 16877 1000000000 {} 0
345 h.txt %perms% 1000000004 aaaaaaaaaabbbbbbbbbb 8
346 i.txt 33188 4 {} 0
347 }]
348
349 do_execsql_test 1.6.10 {
350 SELECT a.name, a.data
351 FROM zz AS a, zz AS b
352 WHERE a.name=+b.name AND +a.mode=b.mode
353 } {
354 blue.txt/ {}
355 h.txt aaaaaaaaaabbbbbbbbbb
356 i.txt {}
357 }
358
359 do_execsql_test 1.6.11 {
360 SELECT name, data FROM zz WHERE name LIKE '%txt'
361 } {
362 h.txt aaaaaaaaaabbbbbbbbbb
363 i.txt {}
364 }
365
366 do_execsql_test 1.7 {
367 DELETE FROM zz;
368 SELECT * FROM zz;
369 } {}
370
371 #-------------------------------------------------------------------------
372 db close
373 forcedelete test.zip
374 reset_db
375 load_static_extension db fileio
376 load_static_extension db zipfile
377 do_execsql_test 2.1 {
378 CREATE VIRTUAL TABLE zzz USING zipfile('test.zip');
379 INSERT INTO zzz(name, mode) VALUES('dirname', 'drwxr-xr-x');
380 SELECT name, mode, data FROM zzz;
381 } {dirname/ 16877 {}}
382 do_execsql_test 2.2 {
383 INSERT INTO zzz(name, data) VALUES('dirname2', NULL);
384 INSERT INTO zzz(name, data) VALUES('dirname2/file1.txt', 'abcdefghijklmnop');
385 SELECT name, mode, data FROM zzz;
386 } {
387 dirname/ 16877 {}
388 dirname2/ 16877 {}
389 dirname2/file1.txt 33188 abcdefghijklmnop
390 }
391
392 do_catchsql_test 2.3 {
393 UPDATE zzz SET name = 'dirname3' WHERE name = 'dirname/';
394 } {0 {}}
395 do_execsql_test 2.4 {
396 SELECT name, mode, data FROM zzz;
397 } {
398 dirname3/ 16877 {}
399 dirname2/ 16877 {}
400 dirname2/file1.txt 33188 abcdefghijklmnop
401 }
402 do_zip_tests 2.4a test.zip
403
404 # Check that the [unzip] utility can unpack our archive.
405 #
406 if {[info exists ::UNZIP]} {
407 do_test 2.5.1 {
408 forcedelete dirname
409 forcedelete dirname2
410 if {$::tcl_platform(platform) eq "unix"} {
411 set null /dev/null
412 } else {
413 set null NUL
414 }
415 set rc [catch { exec $::UNZIP test.zip > $null } msg]
416 list $rc $msg
417 } {0 {}}
418 do_test 2.5.2 { file isdir dirname3 } 1
419 do_test 2.5.3 { file isdir dirname2 } 1
420 do_test 2.5.4 { file isdir dirname2/file1.txt } 0
421 do_test 2.5.5 {
422 set fd [open dirname2/file1.txt]
423 set data [read $fd]
424 close $fd
425 set data
426 } {abcdefghijklmnop}
427 }
428
429 #-------------------------------------------------------------------------
430 reset_db
431 forcedelete test.zip
432 load_static_extension db zipfile
433 load_static_extension db fileio
434
435 do_execsql_test 3.0 {
436 CREATE VIRTUAL TABLE temp.x1 USING zipfile('test.zip');
437 INSERT INTO x1(name, data) VALUES('dir1/', NULL);
438 INSERT INTO x1(name, data) VALUES('file1', '1234');
439 INSERT INTO x1(name, data) VALUES('dir1/file2', '5678');
440 }
441 foreach {tn fname} {
442 1 dir1
443 2 file1
444 3 dir1/file2
445 } {
446 do_catchsql_test 3.1.$tn.0 {
447 INSERT INTO x1(name, data) VALUES($fname, NULL);
448 } [list 1 "duplicate name: \"$fname/\""]
449 do_catchsql_test 3.1.$tn.1 {
450 INSERT INTO x1(name, data) VALUES($fname || '/', NULL);
451 } [list 1 "duplicate name: \"$fname/\""]
452 do_catchsql_test 3.1.$tn.2 {
453 INSERT INTO x1(name, data) VALUES($fname, 'abcd');
454 } [list 1 "duplicate name: \"$fname\""]
455 }
456
457 do_catchsql_test 3.2 {
458 SELECT rowid FROM x1
459 } {1 {no such column: rowid}}
460
461 #-------------------------------------------------------------------------
462 # Test some error conditions.
463 #
464 do_catchsql_test 4.1 {
465 CREATE VIRTUAL TABLE yyy USING zipfile();
466 } {1 {zipfile constructor requires one argument}}
467 do_catchsql_test 4.2 {
468 CREATE VIRTUAL TABLE yyy USING zipfile('test.zip', 'test.zip');
469 } {1 {zipfile constructor requires one argument}}
470
471 do_catchsql_test 4.3 {
472 SELECT * FROM zipfile()
473 } {1 {zipfile() function requires an argument}}
474
475 do_catchsql_test 4.4 {
476 SELECT * FROM zipfile('/path/that/does/not/exist')
477 } {1 {cannot open file: /path/that/does/not/exist}}
478
479 foreach {tn mode} {
480 1 abcd
481 2 brwxrwxrwx
482 3 lrwxrrxrwx
483 } {
484 do_catchsql_test 4.5.$tn {
485 WITH m(m) AS ( SELECT $mode)
486 SELECT zipfile('a.txt', m, 1000, 'xyz') FROM m
487 } [list 1 "zipfile: parse error in mode: $mode"]
488 }
489
490 do_catchsql_test 4.6 {
491 WITH c(name,data) AS ( SELECT 'a.txt', 'abc')
492 SELECT zipfile(name) FROM c
493 } {1 {wrong number of arguments to function zipfile()}}
494
495 do_catchsql_test 4.7 {
496 WITH c(name,data) AS (
497 SELECT 'a.txt', 'abc' UNION ALL
498 SELECT NULL, 'def'
499 )
500 SELECT zipfile(name,data) FROM c
501 } {1 {first argument to zipfile() must be non-NULL}}
502
503 do_catchsql_test 4.8 {
504 WITH c(name,data,method) AS (
505 SELECT 'a.txt', 'abc', 0
506 UNION SELECT 'b.txt', 'def', 8
507 UNION SELECT 'c.txt', 'ghi', 16
508 )
509 SELECT zipfile(name,NULL,NULL,data,method) FROM c
510 } {1 {illegal method value: 16}}
511
512 do_catchsql_test 4.9 {
513 WITH c(name,data) AS (
514 SELECT 'a.txt', 'abc'
515 UNION SELECT 'b.txt', 'def'
516 UNION SELECT 'c.txt/', 'ghi'
517 )
518 SELECT zipfile(name,NULL,NULL,data) FROM c
519 } {1 {non-directory name must not end with /}}
520
521 #--------------------------------------------------------------------------
522
523 db func rt remove_timestamps
524 do_execsql_test 5.0 {
525 WITH c(name,mtime,data) AS (
526 SELECT 'a.txt', 946684800, 'abc'
527 )
528 SELECT name,mtime,data FROM zipfile(
529 ( SELECT rt( zipfile(name,NULL,mtime,data,NULL) ) FROM c )
530 )
531 } {
532 a.txt 946684800 abc
533 }
534
535 if {[info exists ::UNZIP]} {
536 ifcapable datetime {
537 forcedelete test1.zip test2.zip
538 do_test 6.0 {
539 execsql {
540 WITH c(name,mtime,data) AS (
541 SELECT 'a.txt', 946684800, 'abc' UNION ALL
542 SELECT 'b.txt', 1000000000, 'abc' UNION ALL
543 SELECT 'c.txt', 1111111000, 'abc'
544 )
545 SELECT writefile('test1.zip', rt( zipfile(name, NULL, mtime, data) ) ),
546 writefile('test2.zip', ( zipfile(name, NULL, mtime, data) ) )
547 FROM c;
548 }
549 forcedelete test_unzip
550 file mkdir test_unzip
551 exec $::UNZIP -d test_unzip test1.zip
552
553 db eval {
554 SELECT name, strftime('%s', mtime, 'unixepoch', 'localtime')
555 FROM fsdir('test_unzip') WHERE name!='test_unzip'
556 ORDER BY name
557 }
558 } [list {*}{
559 test_unzip/a.txt 946684800
560 test_unzip/b.txt 1000000000
561 test_unzip/c.txt 1111111000
562 }]
563
564 # fsdir() issue reported on the mailing list on 2018-03-14 by Jack Thaw.
565 do_test 6.0b {
566 db eval {
567 SELECT sum(name LIKE '%/a.txt')
568 FROM (VALUES(1),(2),(3)) CROSS JOIN fsdir('test_unzip')
569 }
570 } {3}
571
572 do_execsql_test 6.1 {
573 SELECT name, mtime, data FROM zipfile('test1.zip')
574 } {
575 a.txt 946684800 abc
576 b.txt 1000000000 abc
577 c.txt 1111111000 abc
578 }
579
580 do_test 6.2 {
581 forcedelete test_unzip
582 file mkdir test_unzip
583 exec $::UNZIP -d test_unzip test2.zip
584
585 db eval {
586 SELECT name, mtime
587 FROM fsdir('test_unzip') WHERE name!='test_unzip'
588 ORDER BY name
589 }
590 } [list {*}{
591 test_unzip/a.txt 946684800
592 test_unzip/b.txt 1000000000
593 test_unzip/c.txt 1111111000
594 }]
595
596 do_execsql_test 6.3 {
597 SELECT name, mtime, sz, rawdata, data FROM zipfile('test2.zip')
598 } {
599 a.txt 946684800 3 abc abc
600 b.txt 1000000000 3 abc abc
601 c.txt 1111111000 3 abc abc
602 }
603 }
604 }
605
606 #-------------------------------------------------------------------------
607 # Force an IO error by truncating the zip archive to zero bytes in size
608 # while it is being read.
609 forcedelete test.zip
610 do_test 7.0 {
611 execsql {
612 WITH c(name,data) AS (
613 SELECT '1', randomblob(1000000) UNION ALL
614 SELECT '2', randomblob(1000000) UNION ALL
615 SELECT '3', randomblob(1000000)
616 )
617 SELECT writefile('test.zip', zipfile(name, data) ) FROM c;
618 }
619
620 list [catch {
621 db eval { SELECT name, data FROM zipfile('test.zip') } {
622 if {$name==2} { close [open test.zip w+] }
623 }
624 } msg] $msg
625 } {1 {error in fread()}}
626
627 forcedelete test.zip
628 do_execsql_test 8.0.1 {
629 CREATE VIRTUAL TABLE zz USING zipfile('test.zip');
630 BEGIN;
631 INSERT INTO zz(name, data) VALUES('a.txt', '1');
632 INSERT INTO zz(name, data) VALUES('b.txt', '2');
633 INSERT INTO zz(name, data) VALUES('c.txt', '1');
634 INSERT INTO zz(name, data) VALUES('d.txt', '2');
635 SELECT name, data FROM zz;
636 } {
637 a.txt 1 b.txt 2 c.txt 1 d.txt 2
638 }
639 do_test 8.0.2 {
640 db eval { SELECT name, data FROM zz } {
641 if { $data=="2" } { db eval { DELETE FROM zz WHERE name=$name } }
642 }
643 execsql { SELECT name, data FROM zz }
644 } {a.txt 1 c.txt 1}
645 do_test 8.0.3 {
646 db eval { SELECT name, data FROM zz } {
647 db eval { DELETE FROM zz WHERE name=$name }
648 }
649 execsql { SELECT name, data FROM zz }
650 } {}
651 execsql COMMIT
652
653 catch { forcedelete test_unzip }
654 catch { file mkdir test_unzip }
655 do_execsql_test 8.1.1 {
656 CREATE VIRTUAL TABLE nogood USING zipfile('test_unzip');
657 }
658 do_catchsql_test 8.1.2 {
659 INSERT INTO nogood(name, data) VALUES('abc', 'def');
660 } {1 {zipfile: failed to open file test_unzip for writing}}
661
662 do_execsql_test 8.2.1 {
663 DROP TABLE nogood;
664 BEGIN;
665 CREATE VIRTUAL TABLE nogood USING zipfile('test_unzip');
666 }
667 do_catchsql_test 8.2.2 {
668 INSERT INTO nogood(name, data) VALUES('abc', 'def');
669 } {1 {zipfile: failed to open file test_unzip for writing}}
670 do_execsql_test 8.2.3 {
671 COMMIT;
672 }
673
674 forcedelete test.zip
675 do_execsql_test 8.3.1 {
676 BEGIN;
677 CREATE VIRTUAL TABLE ok USING zipfile('test.zip');
678 INSERT INTO ok(name, data) VALUES ('sqlite3', 'elf');
679 COMMIT;
680 }
681
682 #-------------------------------------------------------------------------
683 # Test that the zipfile aggregate correctly adds and removes "/" from
684 # the ends of directory file names.
685 do_execsql_test 9.0 {
686 WITH src(nm) AS (
687 VALUES('dir1') UNION ALL
688 VALUES('dir2/') UNION ALL
689 VALUES('dir3//') UNION ALL
690 VALUES('dir4///') UNION ALL
691 VALUES('/')
692 )
693 SELECT name FROM zipfile((SELECT zipfile(nm, NULL) FROM src))
694 } {dir1/ dir2/ dir3/ dir4/ /}
695
696 #-------------------------------------------------------------------------
697 # INSERT OR REPLACE and INSERT OR IGNORE
698 #
699 catch {db close}
700 forcedelete test.zip test.db
701 sqlite3 db :memory:
702 load_static_extension db zipfile
703 load_static_extension db fileio
704
705 do_execsql_test 10.0 {
706 CREATE VIRTUAL TABLE z USING zipfile('test.zip');
707 } {}
708 do_catchsql_test 10.1 {
709 INSERT INTO z(name,data) VALUES('a0','one'),('a0','two');
710 } {1 {duplicate name: "a0"}}
711 do_execsql_test 10.2 {
712 SELECT name, data FROM z;
713 } {a0 one}
714 do_execsql_test 10.3 {
715 REPLACE INTO z(name,data) VALUES('a0','three'),('a0','four');
716 } {}
717 do_execsql_test 10.4 {
718 SELECT name, data FROM z;
719 } {a0 four}
720 do_execsql_test 10.5 {
721 INSERT OR IGNORE INTO z(name,data) VALUES('a0','five'),('a0','six');
722 } {}
723 do_execsql_test 10.6 {
724 SELECT name, data FROM z;
725 } {a0 four}
726
727 do_execsql_test 11.1 {
728 DELETE FROM z;
729 } {}
730 do_execsql_test 11.2 {
731 SELECT name, data FROM z;
732 } {}
733 do_execsql_test 11.3 {
734 INSERT INTO z (name,data) VALUES ('b0','one');
735 SELECT name, data FROM z;
736 } {b0 one}
737 do_execsql_test 11.4 {
738 UPDATE z SET name = 'b1' WHERE name = 'b0';
739 SELECT name, data FROM z;
740 } {b1 one}
741 do_execsql_test 11.5 {
742 INSERT INTO z (name,data) VALUES ('b0','one');
743 SELECT name, data FROM z ORDER BY name;
744 } {b0 one b1 one}
745 do_catchsql_test 11.6 {
746 UPDATE z SET name = 'b1' WHERE name = 'b0';
747 } {1 {duplicate name: "b1"}}
748 do_execsql_test 11.7 {
749 UPDATE z SET data = 'two' WHERE name = 'b0';
750 SELECT name, data FROM z ORDER BY name;
751 } {b0 two b1 one}
752 do_catchsql_test 11.8 {
753 UPDATE z SET name = 'b1';
754 } {1 {duplicate name: "b1"}}
755 do_catchsql_test 11.9 {
756 UPDATE z SET name = 'b2';
757 } {1 {duplicate name: "b2"}}
758 do_execsql_test 11.10 {
759 UPDATE z SET name = name;
760 SELECT name, data FROM z ORDER BY name;
761 } {b0 two b2 one}
762 do_execsql_test 11.11 {
763 UPDATE z SET name = name || 'suffix';
764 SELECT name, data FROM z ORDER BY name;
765 } {b0suffix two b2suffix one}
766
767
768 if {$tcl_platform(platform) ne "windows"} {
769 do_test 12.0 {
770 catch { file delete -force subdir }
771 foreach {path sz} {
772 subdir/x1.txt 143
773 subdir/x2.txt 153
774 } {
775 set dir [file dirname $path]
776 catch { file mkdir $dir }
777 set fd [open $path w]
778 puts -nonewline $fd [string repeat 1 $sz]
779 close $fd
780 }
781 } {}
782
783 do_execsql_test 12.1 {
784 SELECT name FROM fsdir('subdir') ORDER BY 1;
785 } {subdir subdir/x1.txt subdir/x2.txt}
786
787 do_execsql_test 12.2 {
788 CREATE TABLE d AS SELECT 'subdir' d;
789 CREATE TABLE x AS SELECT 1 x;
790 }
791
792 do_execsql_test 12.4 {
793 SELECT name FROM d JOIN x JOIN fsdir(d) ORDER BY 1;
794 } {subdir subdir/x1.txt subdir/x2.txt}
795
796 do_execsql_test 12.5 {
797 SELECT name FROM d JOIN x JOIN fsdir('.', d) ORDER BY 1;
798 } {. ./x1.txt ./x2.txt}
799 }
800
801 # 2019-12-18 Yongheng and Rui fuzzer
802 #
803 do_execsql_test 13.10 {
804 DROP TABLE IF EXISTS t0;
805 DROP TABLE IF EXISTS t1;
806 CREATE TABLE t0(a,b,c,d,e,f,g);
807 REPLACE INTO t0(c,b,f) VALUES(10,10,10);
808 CREATE VIRTUAL TABLE t1 USING zipfile('h.zip');
809 REPLACE INTO t1 SELECT * FROM t0;
810 SELECT quote(name),quote(mode),quote(mtime),quote(sz),quote(rawdata),
811 quote(data),quote(method) FROM t1;
812 } {'' 10 10 2 X'3130' X'3130' 0}
813
814 # 2019-12-23 Yongheng and Rui fuzzer
815 # Run using valgrind to see the problem.
816 #
817 do_execsql_test 14.10 {
818 DROP TABLE t1;
819 CREATE TABLE t1(x char);
820 INSERT INTO t1(x) VALUES('1');
821 INSERT INTO t1(x) SELECT zipfile(x, 'xyz') FROM t1;
822 INSERT INTO t1(x) SELECT zipfile(x, 'uvw') FROM t1;
823 SELECT count(*) FROM t1;
824 PRAGMA integrity_check;
825 } {3 ok}
826
827 # 2019-12-26 More problems in zipfile from the Yongheng and Rui fuzzer
828 #
829 do_execsql_test 15.10 {
830 DROP TABLE IF EXISTS t1;
831 CREATE VIRTUAL TABLE t1 USING zipfile(null);
832 REPLACE INTO t1 VALUES(null,null,0,null,null,null,null);
833 } {}
834 do_execsql_test 15.20 {
835 DROP TABLE IF EXISTS t2;
836 CREATE VIRTUAL TABLE t2 USING zipfile(null);
837 REPLACE INTO t2 values(null,null,null,null,null,10,null);
838 } {}
839
840 # 2020-01-02 Yongheng fuzzer discovery
841 #
842 do_catchsql_test 16.10 {
843 DELETE FROM zipfile;
844 } {1 {zipfile: missing filename}}
845 do_catchsql_test 16.20 {
846 REPLACE INTO zipfile VALUES(null,null,null,null,null,123,null);
847 } {1 {zipfile: missing filename}}
848
849 # 2021-04-22 forum https://sqlite.org/forum/forumpost/d82289d69f
850 do_execsql_test 17.1 {
851 WITH vlist(x) AS (
852 VALUES(9223372036854775807),
853 (-9223372036854775808),
854 (9223372036854775806),
855 (-9223372036854775807)
856 )
857 SELECT DISTINCT typeof(zipfile(0,0,x,0)) FROM vlist;
858 } {blob}
859
860 # 2023-01-04
861 # https://sqlite.org/forum/forumpost/d1c96a9032e564f8
862 # Call to fopen() with a NULL filename.
863 #
864 do_catchsql_test 18.1 {
865 SELECT * FROM zipfile(NULL);
866 } {1 {cannot open file: }}
867
868 # 2023-05-03 https://sqlite.org/forum/info/f03f1e4c5a5c9959
869 #
870 do_test 19.1 {
871 sqlite3 db :memory:
872 load_static_extension db zipfile
873 forcedelete zipfile19.zip
874 db eval {
875 CREATE VIRTUAL TABLE t1 USING zipfile('zipfile19.zip');
876 INSERT INTO t1 DEFAULT VALUES;
877 }
878 db close
879 sqlite3 db :memory:
880 load_static_extension db zipfile
881 db eval {
882 CREATE VIRTUAL TABLE v0 USING zipfile('zipfile19.zip');
883 SAVEPOINT y;
884 DELETE FROM v0 WHERE 9;
885 INSERT INTO v0 DEFAULT VALUES;
886 }
887 } {}
888 db close
889 forcedelete zipfile19.zip
890 sqlite3 db :memory:
891 load_static_extension db zipfile
892
893 #-------------------------------------------------------------------------
894 do_catchsql_test 20.0 {
895 SELECT * FROM zipfile(X'504b050600000000010001004000000000a3e1110000');
896 } {1 {zip archive is corrupt}}
897
898 do_catchsql_test 20.1 {
899 SELECT * FROM zipfile(unhex('
900 504b0304140000080000a60d3e5bd42728f602000000020000000500090068
901 2e74787455540500012836db682120504b01021e03140000080000a60d3e5b
902 d42728f602000000020000000500ffff0000000000000000a4810000000068
903 2e74787455540500012836db68504b050600000000010001003c0000002e00
904 00000000',char(0x0a,0x0d)));
905 } {1 {zip archive is corrupt}}
906
907 # https://sqlite.org/forum/forumpost/2025-12-30T23:57:19z
908 do_catchsql_test 20.2 {
909 SELECT * FROM zipfile(unhex('504b0304140000000000000000008b9ed9d30100000001000000010000007841504b01021e03140000000000000000008b9ed9d3010000000100000001001e000000000000000000a4810000000078504b050600000000010001002f000000200000000000'));
910 } {1 {zip archive is corrupt}}
911
912 # https://sqlite.org/forum/forumpost/2026-01-13T00:09:06Z
913 do_catchsql_test 21.0 {
914 SELECT * FROM zipfile(X'504B03040A0000000000000000000000000000000000000000000100000078504B010200000A0000000000000000000000000000000000000000000100000000000000000000000000E2FFFFFF78504B050600000000010001002F0000001F0000000000');
915 } {1 {failed to read LFH at offset -30}}
916
917
918 #--------------------------------------------------------------------------
919 reset_db
920 load_static_extension db zipfile
921
922 # This test requires a non-default SQLITE_MAX_LENGTH value to run.
923 #
924 if {[catch {db one {SELECT length( zeroblob(1200000000) )}}]==0} {
925 do_catchsql_test 23.0 {
926 SELECT length(zipfile(name,0,0,data,0)) FROM (
927 SELECT 'a' AS name, zeroblob(1000000000) AS data
928 UNION ALL SELECT 'b', zeroblob(1200000000)
929 );
930 } {1 {out of memory}}
931 }
932
933 # Bug 2026-06-03T10:58:51Z
934 do_catchsql_test 25.0 {
935 WITH t(v) AS (
936 SELECT unhex(
937 '504B03041400000000000000000000000000000000000000000001000000
938 61504B01021E031400000000000000000000000000000000000000000001
939 000000000000000000000000000000000061504B05060000000001000100
940 2F0000001F0000000000',char(10,13,32))
941 UNION ALL SELECT 'x'
942 ) SELECT z.name FROM t, zipfile(t.v) AS z;
943 } {1 {cannot open file: x}}
944 finish_test