Source file
src/archive/tar/reader_test.go
1
2
3
4
5 package tar
6
7 import (
8 "bytes"
9 "crypto/md5"
10 "errors"
11 "fmt"
12 "io"
13 "math"
14 "os"
15 "path"
16 "reflect"
17 "strconv"
18 "strings"
19 "testing"
20 "time"
21 )
22
23 func TestReader(t *testing.T) {
24 vectors := []struct {
25 file string
26 headers []*Header
27 chksums []string
28 err error
29 }{{
30 file: "testdata/gnu.tar",
31 headers: []*Header{{
32 Name: "small.txt",
33 Mode: 0640,
34 Uid: 73025,
35 Gid: 5000,
36 Size: 5,
37 ModTime: time.Unix(1244428340, 0),
38 Typeflag: '0',
39 Uname: "dsymonds",
40 Gname: "eng",
41 Format: FormatGNU,
42 }, {
43 Name: "small2.txt",
44 Mode: 0640,
45 Uid: 73025,
46 Gid: 5000,
47 Size: 11,
48 ModTime: time.Unix(1244436044, 0),
49 Typeflag: '0',
50 Uname: "dsymonds",
51 Gname: "eng",
52 Format: FormatGNU,
53 }},
54 chksums: []string{
55 "e38b27eaccb4391bdec553a7f3ae6b2f",
56 "c65bd2e50a56a2138bf1716f2fd56fe9",
57 },
58 }, {
59 file: "testdata/sparse-formats.tar",
60 headers: []*Header{{
61 Name: "sparse-gnu",
62 Mode: 420,
63 Uid: 1000,
64 Gid: 1000,
65 Size: 200,
66 ModTime: time.Unix(1392395740, 0),
67 Typeflag: 0x53,
68 Linkname: "",
69 Uname: "david",
70 Gname: "david",
71 Devmajor: 0,
72 Devminor: 0,
73 Format: FormatGNU,
74 }, {
75 Name: "sparse-posix-0.0",
76 Mode: 420,
77 Uid: 1000,
78 Gid: 1000,
79 Size: 200,
80 ModTime: time.Unix(1392342187, 0),
81 Typeflag: 0x30,
82 Linkname: "",
83 Uname: "david",
84 Gname: "david",
85 Devmajor: 0,
86 Devminor: 0,
87 PAXRecords: map[string]string{
88 "GNU.sparse.size": "200",
89 "GNU.sparse.numblocks": "95",
90 "GNU.sparse.map": "1,1,3,1,5,1,7,1,9,1,11,1,13,1,15,1,17,1,19,1,21,1,23,1,25,1,27,1,29,1,31,1,33,1,35,1,37,1,39,1,41,1,43,1,45,1,47,1,49,1,51,1,53,1,55,1,57,1,59,1,61,1,63,1,65,1,67,1,69,1,71,1,73,1,75,1,77,1,79,1,81,1,83,1,85,1,87,1,89,1,91,1,93,1,95,1,97,1,99,1,101,1,103,1,105,1,107,1,109,1,111,1,113,1,115,1,117,1,119,1,121,1,123,1,125,1,127,1,129,1,131,1,133,1,135,1,137,1,139,1,141,1,143,1,145,1,147,1,149,1,151,1,153,1,155,1,157,1,159,1,161,1,163,1,165,1,167,1,169,1,171,1,173,1,175,1,177,1,179,1,181,1,183,1,185,1,187,1,189,1",
91 },
92 Format: FormatPAX,
93 }, {
94 Name: "sparse-posix-0.1",
95 Mode: 420,
96 Uid: 1000,
97 Gid: 1000,
98 Size: 200,
99 ModTime: time.Unix(1392340456, 0),
100 Typeflag: 0x30,
101 Linkname: "",
102 Uname: "david",
103 Gname: "david",
104 Devmajor: 0,
105 Devminor: 0,
106 PAXRecords: map[string]string{
107 "GNU.sparse.size": "200",
108 "GNU.sparse.numblocks": "95",
109 "GNU.sparse.map": "1,1,3,1,5,1,7,1,9,1,11,1,13,1,15,1,17,1,19,1,21,1,23,1,25,1,27,1,29,1,31,1,33,1,35,1,37,1,39,1,41,1,43,1,45,1,47,1,49,1,51,1,53,1,55,1,57,1,59,1,61,1,63,1,65,1,67,1,69,1,71,1,73,1,75,1,77,1,79,1,81,1,83,1,85,1,87,1,89,1,91,1,93,1,95,1,97,1,99,1,101,1,103,1,105,1,107,1,109,1,111,1,113,1,115,1,117,1,119,1,121,1,123,1,125,1,127,1,129,1,131,1,133,1,135,1,137,1,139,1,141,1,143,1,145,1,147,1,149,1,151,1,153,1,155,1,157,1,159,1,161,1,163,1,165,1,167,1,169,1,171,1,173,1,175,1,177,1,179,1,181,1,183,1,185,1,187,1,189,1",
110 "GNU.sparse.name": "sparse-posix-0.1",
111 },
112 Format: FormatPAX,
113 }, {
114 Name: "sparse-posix-1.0",
115 Mode: 420,
116 Uid: 1000,
117 Gid: 1000,
118 Size: 200,
119 ModTime: time.Unix(1392337404, 0),
120 Typeflag: 0x30,
121 Linkname: "",
122 Uname: "david",
123 Gname: "david",
124 Devmajor: 0,
125 Devminor: 0,
126 PAXRecords: map[string]string{
127 "GNU.sparse.major": "1",
128 "GNU.sparse.minor": "0",
129 "GNU.sparse.realsize": "200",
130 "GNU.sparse.name": "sparse-posix-1.0",
131 },
132 Format: FormatPAX,
133 }, {
134 Name: "end",
135 Mode: 420,
136 Uid: 1000,
137 Gid: 1000,
138 Size: 4,
139 ModTime: time.Unix(1392398319, 0),
140 Typeflag: 0x30,
141 Linkname: "",
142 Uname: "david",
143 Gname: "david",
144 Devmajor: 0,
145 Devminor: 0,
146 Format: FormatGNU,
147 }},
148 chksums: []string{
149 "6f53234398c2449fe67c1812d993012f",
150 "6f53234398c2449fe67c1812d993012f",
151 "6f53234398c2449fe67c1812d993012f",
152 "6f53234398c2449fe67c1812d993012f",
153 "b0061974914468de549a2af8ced10316",
154 },
155 }, {
156 file: "testdata/star.tar",
157 headers: []*Header{{
158 Name: "small.txt",
159 Mode: 0640,
160 Uid: 73025,
161 Gid: 5000,
162 Size: 5,
163 ModTime: time.Unix(1244592783, 0),
164 Typeflag: '0',
165 Uname: "dsymonds",
166 Gname: "eng",
167 AccessTime: time.Unix(1244592783, 0),
168 ChangeTime: time.Unix(1244592783, 0),
169 }, {
170 Name: "small2.txt",
171 Mode: 0640,
172 Uid: 73025,
173 Gid: 5000,
174 Size: 11,
175 ModTime: time.Unix(1244592783, 0),
176 Typeflag: '0',
177 Uname: "dsymonds",
178 Gname: "eng",
179 AccessTime: time.Unix(1244592783, 0),
180 ChangeTime: time.Unix(1244592783, 0),
181 }},
182 }, {
183 file: "testdata/v7.tar",
184 headers: []*Header{{
185 Name: "small.txt",
186 Mode: 0444,
187 Uid: 73025,
188 Gid: 5000,
189 Size: 5,
190 ModTime: time.Unix(1244593104, 0),
191 Typeflag: '0',
192 }, {
193 Name: "small2.txt",
194 Mode: 0444,
195 Uid: 73025,
196 Gid: 5000,
197 Size: 11,
198 ModTime: time.Unix(1244593104, 0),
199 Typeflag: '0',
200 }},
201 }, {
202 file: "testdata/pax.tar",
203 headers: []*Header{{
204 Name: "a/123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100",
205 Mode: 0664,
206 Uid: 1000,
207 Gid: 1000,
208 Uname: "shane",
209 Gname: "shane",
210 Size: 7,
211 ModTime: time.Unix(1350244992, 23960108),
212 ChangeTime: time.Unix(1350244992, 23960108),
213 AccessTime: time.Unix(1350244992, 23960108),
214 Typeflag: TypeReg,
215 PAXRecords: map[string]string{
216 "path": "a/123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100",
217 "mtime": "1350244992.023960108",
218 "atime": "1350244992.023960108",
219 "ctime": "1350244992.023960108",
220 },
221 Format: FormatPAX,
222 }, {
223 Name: "a/b",
224 Mode: 0777,
225 Uid: 1000,
226 Gid: 1000,
227 Uname: "shane",
228 Gname: "shane",
229 Size: 0,
230 ModTime: time.Unix(1350266320, 910238425),
231 ChangeTime: time.Unix(1350266320, 910238425),
232 AccessTime: time.Unix(1350266320, 910238425),
233 Typeflag: TypeSymlink,
234 Linkname: "123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100",
235 PAXRecords: map[string]string{
236 "linkpath": "123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100",
237 "mtime": "1350266320.910238425",
238 "atime": "1350266320.910238425",
239 "ctime": "1350266320.910238425",
240 },
241 Format: FormatPAX,
242 }},
243 }, {
244 file: "testdata/pax-bad-hdr-file.tar",
245 err: ErrHeader,
246 }, {
247 file: "testdata/pax-bad-mtime-file.tar",
248 err: ErrHeader,
249 }, {
250 file: "testdata/pax-pos-size-file.tar",
251 headers: []*Header{{
252 Name: "foo",
253 Mode: 0640,
254 Uid: 319973,
255 Gid: 5000,
256 Size: 999,
257 ModTime: time.Unix(1442282516, 0),
258 Typeflag: '0',
259 Uname: "joetsai",
260 Gname: "eng",
261 PAXRecords: map[string]string{
262 "size": "000000000000000000000999",
263 },
264 Format: FormatPAX,
265 }},
266 chksums: []string{
267 "0afb597b283fe61b5d4879669a350556",
268 },
269 }, {
270 file: "testdata/pax-records.tar",
271 headers: []*Header{{
272 Typeflag: TypeReg,
273 Name: "file",
274 Uname: strings.Repeat("long", 10),
275 ModTime: time.Unix(0, 0),
276 PAXRecords: map[string]string{
277 "GOLANG.pkg": "tar",
278 "comment": "Hello, 世界",
279 "uname": strings.Repeat("long", 10),
280 },
281 Format: FormatPAX,
282 }},
283 }, {
284 file: "testdata/pax-global-records.tar",
285 headers: []*Header{{
286 Typeflag: TypeXGlobalHeader,
287 Name: "global1",
288 PAXRecords: map[string]string{"path": "global1", "mtime": "1500000000.0"},
289 Format: FormatPAX,
290 }, {
291 Typeflag: TypeReg,
292 Name: "file1",
293 ModTime: time.Unix(0, 0),
294 Format: FormatUSTAR,
295 }, {
296 Typeflag: TypeReg,
297 Name: "file2",
298 PAXRecords: map[string]string{"path": "file2"},
299 ModTime: time.Unix(0, 0),
300 Format: FormatPAX,
301 }, {
302 Typeflag: TypeXGlobalHeader,
303 Name: "GlobalHead.0.0",
304 PAXRecords: map[string]string{"path": ""},
305 Format: FormatPAX,
306 }, {
307 Typeflag: TypeReg,
308 Name: "file3",
309 ModTime: time.Unix(0, 0),
310 Format: FormatUSTAR,
311 }, {
312 Typeflag: TypeReg,
313 Name: "file4",
314 ModTime: time.Unix(1400000000, 0),
315 PAXRecords: map[string]string{"mtime": "1400000000"},
316 Format: FormatPAX,
317 }},
318 }, {
319 file: "testdata/nil-uid.tar",
320 headers: []*Header{{
321 Name: "P1050238.JPG.log",
322 Mode: 0664,
323 Uid: 0,
324 Gid: 0,
325 Size: 14,
326 ModTime: time.Unix(1365454838, 0),
327 Typeflag: TypeReg,
328 Linkname: "",
329 Uname: "eyefi",
330 Gname: "eyefi",
331 Devmajor: 0,
332 Devminor: 0,
333 Format: FormatGNU,
334 }},
335 }, {
336 file: "testdata/xattrs.tar",
337 headers: []*Header{{
338 Name: "small.txt",
339 Mode: 0644,
340 Uid: 1000,
341 Gid: 10,
342 Size: 5,
343 ModTime: time.Unix(1386065770, 448252320),
344 Typeflag: '0',
345 Uname: "alex",
346 Gname: "wheel",
347 AccessTime: time.Unix(1389782991, 419875220),
348 ChangeTime: time.Unix(1389782956, 794414986),
349 Xattrs: map[string]string{
350 "user.key": "value",
351 "user.key2": "value2",
352
353 "security.selinux": "unconfined_u:object_r:default_t:s0\x00",
354 },
355 PAXRecords: map[string]string{
356 "mtime": "1386065770.44825232",
357 "atime": "1389782991.41987522",
358 "ctime": "1389782956.794414986",
359 "SCHILY.xattr.user.key": "value",
360 "SCHILY.xattr.user.key2": "value2",
361 "SCHILY.xattr.security.selinux": "unconfined_u:object_r:default_t:s0\x00",
362 },
363 Format: FormatPAX,
364 }, {
365 Name: "small2.txt",
366 Mode: 0644,
367 Uid: 1000,
368 Gid: 10,
369 Size: 11,
370 ModTime: time.Unix(1386065770, 449252304),
371 Typeflag: '0',
372 Uname: "alex",
373 Gname: "wheel",
374 AccessTime: time.Unix(1389782991, 419875220),
375 ChangeTime: time.Unix(1386065770, 449252304),
376 Xattrs: map[string]string{
377 "security.selinux": "unconfined_u:object_r:default_t:s0\x00",
378 },
379 PAXRecords: map[string]string{
380 "mtime": "1386065770.449252304",
381 "atime": "1389782991.41987522",
382 "ctime": "1386065770.449252304",
383 "SCHILY.xattr.security.selinux": "unconfined_u:object_r:default_t:s0\x00",
384 },
385 Format: FormatPAX,
386 }},
387 }, {
388
389 file: "testdata/gnu-multi-hdrs.tar",
390 headers: []*Header{{
391 Name: "GNU2/GNU2/long-path-name",
392 Linkname: "GNU4/GNU4/long-linkpath-name",
393 ModTime: time.Unix(0, 0),
394 Typeflag: '2',
395 Format: FormatGNU,
396 }},
397 }, {
398
399
400
401 file: "testdata/gnu-incremental.tar",
402 headers: []*Header{{
403 Name: "test2/",
404 Mode: 16877,
405 Uid: 1000,
406 Gid: 1000,
407 Size: 14,
408 ModTime: time.Unix(1441973427, 0),
409 Typeflag: 'D',
410 Uname: "rawr",
411 Gname: "dsnet",
412 AccessTime: time.Unix(1441974501, 0),
413 ChangeTime: time.Unix(1441973436, 0),
414 Format: FormatGNU,
415 }, {
416 Name: "test2/foo",
417 Mode: 33188,
418 Uid: 1000,
419 Gid: 1000,
420 Size: 64,
421 ModTime: time.Unix(1441973363, 0),
422 Typeflag: '0',
423 Uname: "rawr",
424 Gname: "dsnet",
425 AccessTime: time.Unix(1441974501, 0),
426 ChangeTime: time.Unix(1441973436, 0),
427 Format: FormatGNU,
428 }, {
429 Name: "test2/sparse",
430 Mode: 33188,
431 Uid: 1000,
432 Gid: 1000,
433 Size: 536870912,
434 ModTime: time.Unix(1441973427, 0),
435 Typeflag: 'S',
436 Uname: "rawr",
437 Gname: "dsnet",
438 AccessTime: time.Unix(1441991948, 0),
439 ChangeTime: time.Unix(1441973436, 0),
440 Format: FormatGNU,
441 }},
442 }, {
443
444 file: "testdata/pax-multi-hdrs.tar",
445 headers: []*Header{{
446 Name: "bar",
447 Linkname: "PAX4/PAX4/long-linkpath-name",
448 ModTime: time.Unix(0, 0),
449 Typeflag: '2',
450 PAXRecords: map[string]string{
451 "linkpath": "PAX4/PAX4/long-linkpath-name",
452 },
453 Format: FormatPAX,
454 }},
455 }, {
456
457
458
459 file: "testdata/gnu-long-nul.tar",
460 headers: []*Header{{
461 Name: "0123456789",
462 Mode: 0644,
463 Uid: 1000,
464 Gid: 1000,
465 ModTime: time.Unix(1486082191, 0),
466 Typeflag: '0',
467 Uname: "rawr",
468 Gname: "dsnet",
469 Format: FormatGNU,
470 }},
471 }, {
472
473
474
475
476
477 file: "testdata/gnu-utf8.tar",
478 headers: []*Header{{
479 Name: "☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹",
480 Mode: 0644,
481 Uid: 1000, Gid: 1000,
482 ModTime: time.Unix(0, 0),
483 Typeflag: '0',
484 Uname: "☺",
485 Gname: "⚹",
486 Format: FormatGNU,
487 }},
488 }, {
489
490
491
492
493
494 file: "testdata/gnu-not-utf8.tar",
495 headers: []*Header{{
496 Name: "hi\x80\x81\x82\x83bye",
497 Mode: 0644,
498 Uid: 1000,
499 Gid: 1000,
500 ModTime: time.Unix(0, 0),
501 Typeflag: '0',
502 Uname: "rawr",
503 Gname: "dsnet",
504 Format: FormatGNU,
505 }},
506 }, {
507
508
509 file: "testdata/pax-nul-xattrs.tar",
510 err: ErrHeader,
511 }, {
512
513
514
515
516
517 file: "testdata/pax-nul-path.tar",
518 err: ErrHeader,
519 }, {
520 file: "testdata/neg-size.tar",
521 err: ErrHeader,
522 }, {
523 file: "testdata/issue10968.tar",
524 err: ErrHeader,
525 }, {
526 file: "testdata/issue11169.tar",
527 err: ErrHeader,
528 }, {
529 file: "testdata/issue12435.tar",
530 err: ErrHeader,
531 }, {
532
533
534 file: "testdata/invalid-go17.tar",
535 headers: []*Header{{
536 Name: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/foo",
537 Uid: 010000000,
538 ModTime: time.Unix(0, 0),
539 Typeflag: '0',
540 }},
541 }, {
542
543 file: "testdata/ustar-file-devs.tar",
544 headers: []*Header{{
545 Name: "file",
546 Mode: 0644,
547 Typeflag: '0',
548 ModTime: time.Unix(0, 0),
549 Devmajor: 1,
550 Devminor: 1,
551 Format: FormatUSTAR,
552 }},
553 }, {
554
555 file: "testdata/gnu-nil-sparse-data.tar",
556 headers: []*Header{{
557 Name: "sparse.db",
558 Typeflag: TypeGNUSparse,
559 Size: 1000,
560 ModTime: time.Unix(0, 0),
561 Format: FormatGNU,
562 }},
563 }, {
564
565 file: "testdata/gnu-nil-sparse-hole.tar",
566 headers: []*Header{{
567 Name: "sparse.db",
568 Typeflag: TypeGNUSparse,
569 Size: 1000,
570 ModTime: time.Unix(0, 0),
571 Format: FormatGNU,
572 }},
573 }, {
574
575 file: "testdata/pax-nil-sparse-data.tar",
576 headers: []*Header{{
577 Name: "sparse.db",
578 Typeflag: TypeReg,
579 Size: 1000,
580 ModTime: time.Unix(0, 0),
581 PAXRecords: map[string]string{
582 "size": "1512",
583 "GNU.sparse.major": "1",
584 "GNU.sparse.minor": "0",
585 "GNU.sparse.realsize": "1000",
586 "GNU.sparse.name": "sparse.db",
587 },
588 Format: FormatPAX,
589 }},
590 }, {
591
592 file: "testdata/pax-nil-sparse-hole.tar",
593 headers: []*Header{{
594 Name: "sparse.db",
595 Typeflag: TypeReg,
596 Size: 1000,
597 ModTime: time.Unix(0, 0),
598 PAXRecords: map[string]string{
599 "size": "512",
600 "GNU.sparse.major": "1",
601 "GNU.sparse.minor": "0",
602 "GNU.sparse.realsize": "1000",
603 "GNU.sparse.name": "sparse.db",
604 },
605 Format: FormatPAX,
606 }},
607 }, {
608 file: "testdata/trailing-slash.tar",
609 headers: []*Header{{
610 Typeflag: TypeDir,
611 Name: strings.Repeat("123456789/", 30),
612 ModTime: time.Unix(0, 0),
613 PAXRecords: map[string]string{
614 "path": strings.Repeat("123456789/", 30),
615 },
616 Format: FormatPAX,
617 }},
618 }}
619
620 for _, v := range vectors {
621 t.Run(path.Base(v.file), func(t *testing.T) {
622 f, err := os.Open(v.file)
623 if err != nil {
624 t.Fatalf("unexpected error: %v", err)
625 }
626 defer f.Close()
627
628
629 var (
630 tr = NewReader(f)
631 hdrs []*Header
632 chksums []string
633 rdbuf = make([]byte, 8)
634 )
635 for {
636 var hdr *Header
637 hdr, err = tr.Next()
638 if err != nil {
639 if err == io.EOF {
640 err = nil
641 }
642 break
643 }
644 hdrs = append(hdrs, hdr)
645
646 if v.chksums == nil {
647 continue
648 }
649 h := md5.New()
650 _, err = io.CopyBuffer(h, tr, rdbuf)
651 if err != nil {
652 break
653 }
654 chksums = append(chksums, fmt.Sprintf("%x", h.Sum(nil)))
655 }
656
657 for i, hdr := range hdrs {
658 if i >= len(v.headers) {
659 t.Fatalf("entry %d: unexpected header:\ngot %+v", i, *hdr)
660 continue
661 }
662 if !reflect.DeepEqual(*hdr, *v.headers[i]) {
663 t.Fatalf("entry %d: incorrect header:\ngot %+v\nwant %+v", i, *hdr, *v.headers[i])
664 }
665 }
666 if len(hdrs) != len(v.headers) {
667 t.Fatalf("got %d headers, want %d headers", len(hdrs), len(v.headers))
668 }
669
670 for i, sum := range chksums {
671 if i >= len(v.chksums) {
672 t.Fatalf("entry %d: unexpected sum: got %s", i, sum)
673 continue
674 }
675 if sum != v.chksums[i] {
676 t.Fatalf("entry %d: incorrect checksum: got %s, want %s", i, sum, v.chksums[i])
677 }
678 }
679
680 if err != v.err {
681 t.Fatalf("unexpected error: got %v, want %v", err, v.err)
682 }
683 f.Close()
684 })
685 }
686 }
687
688 func TestPartialRead(t *testing.T) {
689 type testCase struct {
690 cnt int
691 output string
692 }
693 vectors := []struct {
694 file string
695 cases []testCase
696 }{{
697 file: "testdata/gnu.tar",
698 cases: []testCase{
699 {4, "Kilt"},
700 {6, "Google"},
701 },
702 }, {
703 file: "testdata/sparse-formats.tar",
704 cases: []testCase{
705 {2, "\x00G"},
706 {4, "\x00G\x00o"},
707 {6, "\x00G\x00o\x00G"},
708 {8, "\x00G\x00o\x00G\x00o"},
709 {4, "end\n"},
710 },
711 }}
712
713 for _, v := range vectors {
714 t.Run(path.Base(v.file), func(t *testing.T) {
715 f, err := os.Open(v.file)
716 if err != nil {
717 t.Fatalf("Open() error: %v", err)
718 }
719 defer f.Close()
720
721 tr := NewReader(f)
722 for i, tc := range v.cases {
723 hdr, err := tr.Next()
724 if err != nil || hdr == nil {
725 t.Fatalf("entry %d, Next(): got %v, want %v", i, err, nil)
726 }
727 buf := make([]byte, tc.cnt)
728 if _, err := io.ReadFull(tr, buf); err != nil {
729 t.Fatalf("entry %d, ReadFull(): got %v, want %v", i, err, nil)
730 }
731 if string(buf) != tc.output {
732 t.Fatalf("entry %d, ReadFull(): got %q, want %q", i, string(buf), tc.output)
733 }
734 }
735
736 if _, err := tr.Next(); err != io.EOF {
737 t.Fatalf("Next(): got %v, want EOF", err)
738 }
739 })
740 }
741 }
742
743 func TestUninitializedRead(t *testing.T) {
744 f, err := os.Open("testdata/gnu.tar")
745 if err != nil {
746 t.Fatalf("Unexpected error: %v", err)
747 }
748 defer f.Close()
749
750 tr := NewReader(f)
751 _, err = tr.Read([]byte{})
752 if err == nil || err != io.EOF {
753 t.Errorf("Unexpected error: %v, wanted %v", err, io.EOF)
754 }
755
756 }
757
758 type reader struct{ io.Reader }
759 type readSeeker struct{ io.ReadSeeker }
760 type readBadSeeker struct{ io.ReadSeeker }
761
762 func (rbs *readBadSeeker) Seek(int64, int) (int64, error) { return 0, fmt.Errorf("illegal seek") }
763
764
765
766
767 func TestReadTruncation(t *testing.T) {
768 var ss []string
769 for _, p := range []string{
770 "testdata/gnu.tar",
771 "testdata/ustar-file-reg.tar",
772 "testdata/pax-path-hdr.tar",
773 "testdata/sparse-formats.tar",
774 } {
775 buf, err := os.ReadFile(p)
776 if err != nil {
777 t.Fatalf("unexpected error: %v", err)
778 }
779 ss = append(ss, string(buf))
780 }
781
782 data1, data2, pax, sparse := ss[0], ss[1], ss[2], ss[3]
783 data2 += strings.Repeat("\x00", 10*512)
784 trash := strings.Repeat("garbage ", 64)
785
786 vectors := []struct {
787 input string
788 cnt int
789 err error
790 }{
791 {"", 0, io.EOF},
792 {data1[:511], 0, io.ErrUnexpectedEOF},
793 {data1[:512], 1, io.ErrUnexpectedEOF},
794 {data1[:1024], 1, io.EOF},
795 {data1[:1536], 2, io.ErrUnexpectedEOF},
796 {data1[:2048], 2, io.EOF},
797 {data1, 2, io.EOF},
798 {data1[:2048] + data2[:1536], 3, io.EOF},
799 {data2[:511], 0, io.ErrUnexpectedEOF},
800 {data2[:512], 1, io.ErrUnexpectedEOF},
801 {data2[:1195], 1, io.ErrUnexpectedEOF},
802 {data2[:1196], 1, io.EOF},
803 {data2[:1200], 1, io.EOF},
804 {data2[:1535], 1, io.EOF},
805 {data2[:1536], 1, io.EOF},
806 {data2[:1536] + trash[:1], 1, io.ErrUnexpectedEOF},
807 {data2[:1536] + trash[:511], 1, io.ErrUnexpectedEOF},
808 {data2[:1536] + trash, 1, ErrHeader},
809 {data2[:2048], 1, io.EOF},
810 {data2[:2048] + trash[:1], 1, io.ErrUnexpectedEOF},
811 {data2[:2048] + trash[:511], 1, io.ErrUnexpectedEOF},
812 {data2[:2048] + trash, 1, ErrHeader},
813 {data2[:2560], 1, io.EOF},
814 {data2[:2560] + trash[:1], 1, io.EOF},
815 {data2[:2560] + trash[:511], 1, io.EOF},
816 {data2[:2560] + trash, 1, io.EOF},
817 {data2[:3072], 1, io.EOF},
818 {pax, 0, io.EOF},
819 {pax + trash[:1], 0, io.ErrUnexpectedEOF},
820 {pax + trash[:511], 0, io.ErrUnexpectedEOF},
821 {sparse[:511], 0, io.ErrUnexpectedEOF},
822 {sparse[:512], 0, io.ErrUnexpectedEOF},
823 {sparse[:3584], 1, io.EOF},
824 {sparse[:9200], 1, io.EOF},
825 {sparse[:9216], 1, io.EOF},
826 {sparse[:9728], 2, io.ErrUnexpectedEOF},
827 {sparse[:10240], 2, io.EOF},
828 {sparse[:11264], 2, io.ErrUnexpectedEOF},
829 {sparse, 5, io.EOF},
830 {sparse + trash, 5, io.EOF},
831 }
832
833 for i, v := range vectors {
834 for j := 0; j < 6; j++ {
835 var tr *Reader
836 var s1, s2 string
837
838 switch j {
839 case 0:
840 tr = NewReader(&reader{strings.NewReader(v.input)})
841 s1, s2 = "io.Reader", "auto"
842 case 1:
843 tr = NewReader(&reader{strings.NewReader(v.input)})
844 s1, s2 = "io.Reader", "manual"
845 case 2:
846 tr = NewReader(&readSeeker{strings.NewReader(v.input)})
847 s1, s2 = "io.ReadSeeker", "auto"
848 case 3:
849 tr = NewReader(&readSeeker{strings.NewReader(v.input)})
850 s1, s2 = "io.ReadSeeker", "manual"
851 case 4:
852 tr = NewReader(&readBadSeeker{strings.NewReader(v.input)})
853 s1, s2 = "ReadBadSeeker", "auto"
854 case 5:
855 tr = NewReader(&readBadSeeker{strings.NewReader(v.input)})
856 s1, s2 = "ReadBadSeeker", "manual"
857 }
858
859 var cnt int
860 var err error
861 for {
862 if _, err = tr.Next(); err != nil {
863 break
864 }
865 cnt++
866 if s2 == "manual" {
867 if _, err = tr.writeTo(io.Discard); err != nil {
868 break
869 }
870 }
871 }
872 if err != v.err {
873 t.Errorf("test %d, NewReader(%s) with %s discard: got %v, want %v",
874 i, s1, s2, err, v.err)
875 }
876 if cnt != v.cnt {
877 t.Errorf("test %d, NewReader(%s) with %s discard: got %d headers, want %d headers",
878 i, s1, s2, cnt, v.cnt)
879 }
880 }
881 }
882 }
883
884
885
886 func TestReadHeaderOnly(t *testing.T) {
887 f, err := os.Open("testdata/hdr-only.tar")
888 if err != nil {
889 t.Fatalf("unexpected error: %v", err)
890 }
891 defer f.Close()
892
893 var hdrs []*Header
894 tr := NewReader(f)
895 for {
896 hdr, err := tr.Next()
897 if err == io.EOF {
898 break
899 }
900 if err != nil {
901 t.Errorf("Next(): got %v, want %v", err, nil)
902 continue
903 }
904 hdrs = append(hdrs, hdr)
905
906
907 cnt, _ := io.ReadFull(tr, []byte{0})
908 if cnt > 0 && hdr.Typeflag != TypeReg {
909 t.Errorf("ReadFull(...): got %d bytes, want 0 bytes", cnt)
910 }
911 }
912
913
914
915 if len(hdrs) != 16 {
916 t.Fatalf("len(hdrs): got %d, want %d", len(hdrs), 16)
917 }
918 for i := 0; i < 8; i++ {
919 hdr1, hdr2 := hdrs[i+0], hdrs[i+8]
920 hdr1.Size, hdr2.Size = 0, 0
921 if !reflect.DeepEqual(*hdr1, *hdr2) {
922 t.Errorf("incorrect header:\ngot %+v\nwant %+v", *hdr1, *hdr2)
923 }
924 }
925 }
926
927 func TestMergePAX(t *testing.T) {
928 vectors := []struct {
929 in map[string]string
930 want *Header
931 ok bool
932 }{{
933 in: map[string]string{
934 "path": "a/b/c",
935 "uid": "1000",
936 "mtime": "1350244992.023960108",
937 },
938 want: &Header{
939 Name: "a/b/c",
940 Uid: 1000,
941 ModTime: time.Unix(1350244992, 23960108),
942 PAXRecords: map[string]string{
943 "path": "a/b/c",
944 "uid": "1000",
945 "mtime": "1350244992.023960108",
946 },
947 },
948 ok: true,
949 }, {
950 in: map[string]string{
951 "gid": "gtgergergersagersgers",
952 },
953 ok: false,
954 }, {
955 in: map[string]string{
956 "missing": "missing",
957 "SCHILY.xattr.key": "value",
958 },
959 want: &Header{
960 Xattrs: map[string]string{"key": "value"},
961 PAXRecords: map[string]string{
962 "missing": "missing",
963 "SCHILY.xattr.key": "value",
964 },
965 },
966 ok: true,
967 }}
968
969 for i, v := range vectors {
970 got := new(Header)
971 err := mergePAX(got, v.in)
972 if v.ok && !reflect.DeepEqual(*got, *v.want) {
973 t.Errorf("test %d, mergePAX(...):\ngot %+v\nwant %+v", i, *got, *v.want)
974 }
975 if ok := err == nil; ok != v.ok {
976 t.Errorf("test %d, mergePAX(...): got %v, want %v", i, ok, v.ok)
977 }
978 }
979 }
980
981 func TestParsePAX(t *testing.T) {
982 vectors := []struct {
983 in string
984 want map[string]string
985 ok bool
986 }{
987 {"", nil, true},
988 {"6 k=1\n", map[string]string{"k": "1"}, true},
989 {"10 a=name\n", map[string]string{"a": "name"}, true},
990 {"9 a=name\n", map[string]string{"a": "name"}, true},
991 {"30 mtime=1350244992.023960108\n", map[string]string{"mtime": "1350244992.023960108"}, true},
992 {"3 somelongkey=\n", nil, false},
993 {"50 tooshort=\n", nil, false},
994 {"13 key1=haha\n13 key2=nana\n13 key3=kaka\n",
995 map[string]string{"key1": "haha", "key2": "nana", "key3": "kaka"}, true},
996 {"13 key1=val1\n13 key2=val2\n8 key1=\n",
997 map[string]string{"key1": "", "key2": "val2"}, true},
998 {"22 GNU.sparse.size=10\n26 GNU.sparse.numblocks=2\n" +
999 "23 GNU.sparse.offset=1\n25 GNU.sparse.numbytes=2\n" +
1000 "23 GNU.sparse.offset=3\n25 GNU.sparse.numbytes=4\n",
1001 map[string]string{paxGNUSparseSize: "10", paxGNUSparseNumBlocks: "2", paxGNUSparseMap: "1,2,3,4"}, true},
1002 {"22 GNU.sparse.size=10\n26 GNU.sparse.numblocks=1\n" +
1003 "25 GNU.sparse.numbytes=2\n23 GNU.sparse.offset=1\n",
1004 nil, false},
1005 {"22 GNU.sparse.size=10\n26 GNU.sparse.numblocks=1\n" +
1006 "25 GNU.sparse.offset=1,2\n25 GNU.sparse.numbytes=2\n",
1007 nil, false},
1008 }
1009
1010 for i, v := range vectors {
1011 r := strings.NewReader(v.in)
1012 got, err := parsePAX(r)
1013 if !reflect.DeepEqual(got, v.want) && !(len(got) == 0 && len(v.want) == 0) {
1014 t.Errorf("test %d, parsePAX():\ngot %v\nwant %v", i, got, v.want)
1015 }
1016 if ok := err == nil; ok != v.ok {
1017 t.Errorf("test %d, parsePAX(): got %v, want %v", i, ok, v.ok)
1018 }
1019 }
1020 }
1021
1022 func TestReadOldGNUSparseMap(t *testing.T) {
1023 populateSparseMap := func(sa sparseArray, sps []string) []string {
1024 for i := 0; len(sps) > 0 && i < sa.MaxEntries(); i++ {
1025 copy(sa.Entry(i), sps[0])
1026 sps = sps[1:]
1027 }
1028 if len(sps) > 0 {
1029 copy(sa.IsExtended(), "\x80")
1030 }
1031 return sps
1032 }
1033
1034 makeInput := func(format Format, size string, sps ...string) (out []byte) {
1035
1036 var blk block
1037 gnu := blk.GNU()
1038 sparse := gnu.Sparse()
1039 copy(gnu.RealSize(), size)
1040 sps = populateSparseMap(sparse, sps)
1041 if format != FormatUnknown {
1042 blk.SetFormat(format)
1043 }
1044 out = append(out, blk[:]...)
1045
1046
1047 for len(sps) > 0 {
1048 var blk block
1049 sps = populateSparseMap(blk.Sparse(), sps)
1050 out = append(out, blk[:]...)
1051 }
1052 return out
1053 }
1054
1055 makeSparseStrings := func(sp []sparseEntry) (out []string) {
1056 var f formatter
1057 for _, s := range sp {
1058 var b [24]byte
1059 f.formatNumeric(b[:12], s.Offset)
1060 f.formatNumeric(b[12:], s.Length)
1061 out = append(out, string(b[:]))
1062 }
1063 return out
1064 }
1065
1066 vectors := []struct {
1067 input []byte
1068 wantMap sparseDatas
1069 wantSize int64
1070 wantErr error
1071 }{{
1072 input: makeInput(FormatUnknown, ""),
1073 wantErr: ErrHeader,
1074 }, {
1075 input: makeInput(FormatGNU, "1234", "fewa"),
1076 wantSize: 01234,
1077 wantErr: ErrHeader,
1078 }, {
1079 input: makeInput(FormatGNU, "0031"),
1080 wantSize: 031,
1081 }, {
1082 input: makeInput(FormatGNU, "80"),
1083 wantErr: ErrHeader,
1084 }, {
1085 input: makeInput(FormatGNU, "1234",
1086 makeSparseStrings(sparseDatas{{0, 0}, {1, 1}})...),
1087 wantMap: sparseDatas{{0, 0}, {1, 1}},
1088 wantSize: 01234,
1089 }, {
1090 input: makeInput(FormatGNU, "1234",
1091 append(makeSparseStrings(sparseDatas{{0, 0}, {1, 1}}), []string{"", "blah"}...)...),
1092 wantMap: sparseDatas{{0, 0}, {1, 1}},
1093 wantSize: 01234,
1094 }, {
1095 input: makeInput(FormatGNU, "3333",
1096 makeSparseStrings(sparseDatas{{0, 1}, {2, 1}, {4, 1}, {6, 1}})...),
1097 wantMap: sparseDatas{{0, 1}, {2, 1}, {4, 1}, {6, 1}},
1098 wantSize: 03333,
1099 }, {
1100 input: makeInput(FormatGNU, "",
1101 append(append(
1102 makeSparseStrings(sparseDatas{{0, 1}, {2, 1}}),
1103 []string{"", ""}...),
1104 makeSparseStrings(sparseDatas{{4, 1}, {6, 1}})...)...),
1105 wantMap: sparseDatas{{0, 1}, {2, 1}, {4, 1}, {6, 1}},
1106 }, {
1107 input: makeInput(FormatGNU, "",
1108 makeSparseStrings(sparseDatas{{0, 1}, {2, 1}, {4, 1}, {6, 1}, {8, 1}, {10, 1}})...)[:blockSize],
1109 wantErr: io.ErrUnexpectedEOF,
1110 }, {
1111 input: makeInput(FormatGNU, "",
1112 makeSparseStrings(sparseDatas{{0, 1}, {2, 1}, {4, 1}, {6, 1}, {8, 1}, {10, 1}})...)[:3*blockSize/2],
1113 wantErr: io.ErrUnexpectedEOF,
1114 }, {
1115 input: makeInput(FormatGNU, "",
1116 makeSparseStrings(sparseDatas{{0, 1}, {2, 1}, {4, 1}, {6, 1}, {8, 1}, {10, 1}})...),
1117 wantMap: sparseDatas{{0, 1}, {2, 1}, {4, 1}, {6, 1}, {8, 1}, {10, 1}},
1118 }, {
1119 input: makeInput(FormatGNU, "",
1120 makeSparseStrings(sparseDatas{{10 << 30, 512}, {20 << 30, 512}})...),
1121 wantMap: sparseDatas{{10 << 30, 512}, {20 << 30, 512}},
1122 }}
1123
1124 for i, v := range vectors {
1125 var blk block
1126 var hdr Header
1127 v.input = v.input[copy(blk[:], v.input):]
1128 tr := Reader{r: bytes.NewReader(v.input)}
1129 got, err := tr.readOldGNUSparseMap(&hdr, &blk)
1130 if !equalSparseEntries(got, v.wantMap) {
1131 t.Errorf("test %d, readOldGNUSparseMap(): got %v, want %v", i, got, v.wantMap)
1132 }
1133 if err != v.wantErr {
1134 t.Errorf("test %d, readOldGNUSparseMap() = %v, want %v", i, err, v.wantErr)
1135 }
1136 if hdr.Size != v.wantSize {
1137 t.Errorf("test %d, Header.Size = %d, want %d", i, hdr.Size, v.wantSize)
1138 }
1139 }
1140 }
1141
1142 func TestReadGNUSparsePAXHeaders(t *testing.T) {
1143 padInput := func(s string) string {
1144 return s + string(zeroBlock[:blockPadding(int64(len(s)))])
1145 }
1146
1147 vectors := []struct {
1148 inputData string
1149 inputHdrs map[string]string
1150 wantMap sparseDatas
1151 wantSize int64
1152 wantName string
1153 wantErr error
1154 }{{
1155 inputHdrs: nil,
1156 wantErr: nil,
1157 }, {
1158 inputHdrs: map[string]string{
1159 paxGNUSparseNumBlocks: strconv.FormatInt(math.MaxInt64, 10),
1160 paxGNUSparseMap: "0,1,2,3",
1161 },
1162 wantErr: ErrHeader,
1163 }, {
1164 inputHdrs: map[string]string{
1165 paxGNUSparseNumBlocks: "4\x00",
1166 paxGNUSparseMap: "0,1,2,3",
1167 },
1168 wantErr: ErrHeader,
1169 }, {
1170 inputHdrs: map[string]string{
1171 paxGNUSparseNumBlocks: "4",
1172 paxGNUSparseMap: "0,1,2,3",
1173 },
1174 wantErr: ErrHeader,
1175 }, {
1176 inputHdrs: map[string]string{
1177 paxGNUSparseNumBlocks: "2",
1178 paxGNUSparseMap: "0,1,2,3",
1179 },
1180 wantMap: sparseDatas{{0, 1}, {2, 3}},
1181 }, {
1182 inputHdrs: map[string]string{
1183 paxGNUSparseNumBlocks: "2",
1184 paxGNUSparseMap: "0, 1,2,3",
1185 },
1186 wantErr: ErrHeader,
1187 }, {
1188 inputHdrs: map[string]string{
1189 paxGNUSparseNumBlocks: "2",
1190 paxGNUSparseMap: "0,1,02,3",
1191 paxGNUSparseRealSize: "4321",
1192 },
1193 wantMap: sparseDatas{{0, 1}, {2, 3}},
1194 wantSize: 4321,
1195 }, {
1196 inputHdrs: map[string]string{
1197 paxGNUSparseNumBlocks: "2",
1198 paxGNUSparseMap: "0,one1,2,3",
1199 },
1200 wantErr: ErrHeader,
1201 }, {
1202 inputHdrs: map[string]string{
1203 paxGNUSparseMajor: "0",
1204 paxGNUSparseMinor: "0",
1205 paxGNUSparseNumBlocks: "2",
1206 paxGNUSparseMap: "0,1,2,3",
1207 paxGNUSparseSize: "1234",
1208 paxGNUSparseRealSize: "4321",
1209 paxGNUSparseName: "realname",
1210 },
1211 wantMap: sparseDatas{{0, 1}, {2, 3}},
1212 wantSize: 1234,
1213 wantName: "realname",
1214 }, {
1215 inputHdrs: map[string]string{
1216 paxGNUSparseMajor: "0",
1217 paxGNUSparseMinor: "0",
1218 paxGNUSparseNumBlocks: "1",
1219 paxGNUSparseMap: "10737418240,512",
1220 paxGNUSparseSize: "10737418240",
1221 paxGNUSparseName: "realname",
1222 },
1223 wantMap: sparseDatas{{10737418240, 512}},
1224 wantSize: 10737418240,
1225 wantName: "realname",
1226 }, {
1227 inputHdrs: map[string]string{
1228 paxGNUSparseMajor: "0",
1229 paxGNUSparseMinor: "0",
1230 paxGNUSparseNumBlocks: "0",
1231 paxGNUSparseMap: "",
1232 },
1233 wantMap: sparseDatas{},
1234 }, {
1235 inputHdrs: map[string]string{
1236 paxGNUSparseMajor: "0",
1237 paxGNUSparseMinor: "1",
1238 paxGNUSparseNumBlocks: "4",
1239 paxGNUSparseMap: "0,5,10,5,20,5,30,5",
1240 },
1241 wantMap: sparseDatas{{0, 5}, {10, 5}, {20, 5}, {30, 5}},
1242 }, {
1243 inputHdrs: map[string]string{
1244 paxGNUSparseMajor: "1",
1245 paxGNUSparseMinor: "0",
1246 paxGNUSparseNumBlocks: "4",
1247 paxGNUSparseMap: "0,5,10,5,20,5,30,5",
1248 },
1249 wantErr: io.ErrUnexpectedEOF,
1250 }, {
1251 inputData: padInput("0\n"),
1252 inputHdrs: map[string]string{paxGNUSparseMajor: "1", paxGNUSparseMinor: "0"},
1253 wantMap: sparseDatas{},
1254 }, {
1255 inputData: padInput("0\n")[:blockSize-1] + "#",
1256 inputHdrs: map[string]string{paxGNUSparseMajor: "1", paxGNUSparseMinor: "0"},
1257 wantMap: sparseDatas{},
1258 }, {
1259 inputData: padInput("0"),
1260 inputHdrs: map[string]string{paxGNUSparseMajor: "1", paxGNUSparseMinor: "0"},
1261 wantErr: io.ErrUnexpectedEOF,
1262 }, {
1263 inputData: padInput("ab\n"),
1264 inputHdrs: map[string]string{paxGNUSparseMajor: "1", paxGNUSparseMinor: "0"},
1265 wantErr: ErrHeader,
1266 }, {
1267 inputData: padInput("1\n2\n3\n"),
1268 inputHdrs: map[string]string{paxGNUSparseMajor: "1", paxGNUSparseMinor: "0"},
1269 wantMap: sparseDatas{{2, 3}},
1270 }, {
1271 inputData: padInput("1\n2\n"),
1272 inputHdrs: map[string]string{paxGNUSparseMajor: "1", paxGNUSparseMinor: "0"},
1273 wantErr: io.ErrUnexpectedEOF,
1274 }, {
1275 inputData: padInput("1\n2\n\n"),
1276 inputHdrs: map[string]string{paxGNUSparseMajor: "1", paxGNUSparseMinor: "0"},
1277 wantErr: ErrHeader,
1278 }, {
1279 inputData: string(zeroBlock[:]) + padInput("0\n"),
1280 inputHdrs: map[string]string{paxGNUSparseMajor: "1", paxGNUSparseMinor: "0"},
1281 wantErr: ErrHeader,
1282 }, {
1283 inputData: strings.Repeat("0", blockSize) + padInput("1\n5\n1\n"),
1284 inputHdrs: map[string]string{paxGNUSparseMajor: "1", paxGNUSparseMinor: "0"},
1285 wantMap: sparseDatas{{5, 1}},
1286 }, {
1287 inputData: padInput(fmt.Sprintf("%d\n", int64(math.MaxInt64))),
1288 inputHdrs: map[string]string{paxGNUSparseMajor: "1", paxGNUSparseMinor: "0"},
1289 wantErr: ErrHeader,
1290 }, {
1291 inputData: padInput(strings.Repeat("0", 300) + "1\n" + strings.Repeat("0", 1000) + "5\n" + strings.Repeat("0", 800) + "2\n"),
1292 inputHdrs: map[string]string{paxGNUSparseMajor: "1", paxGNUSparseMinor: "0"},
1293 wantMap: sparseDatas{{5, 2}},
1294 }, {
1295 inputData: padInput("2\n10737418240\n512\n21474836480\n512\n"),
1296 inputHdrs: map[string]string{paxGNUSparseMajor: "1", paxGNUSparseMinor: "0"},
1297 wantMap: sparseDatas{{10737418240, 512}, {21474836480, 512}},
1298 }, {
1299 inputData: padInput("100\n" + func() string {
1300 var ss []string
1301 for i := 0; i < 100; i++ {
1302 ss = append(ss, fmt.Sprintf("%d\n%d\n", int64(i)<<30, 512))
1303 }
1304 return strings.Join(ss, "")
1305 }()),
1306 inputHdrs: map[string]string{paxGNUSparseMajor: "1", paxGNUSparseMinor: "0"},
1307 wantMap: func() (spd sparseDatas) {
1308 for i := 0; i < 100; i++ {
1309 spd = append(spd, sparseEntry{int64(i) << 30, 512})
1310 }
1311 return spd
1312 }(),
1313 }}
1314
1315 for i, v := range vectors {
1316 var hdr Header
1317 hdr.PAXRecords = v.inputHdrs
1318 r := strings.NewReader(v.inputData + "#")
1319 tr := Reader{curr: ®FileReader{r, int64(r.Len())}}
1320 got, err := tr.readGNUSparsePAXHeaders(&hdr)
1321 if !equalSparseEntries(got, v.wantMap) {
1322 t.Errorf("test %d, readGNUSparsePAXHeaders(): got %v, want %v", i, got, v.wantMap)
1323 }
1324 if err != v.wantErr {
1325 t.Errorf("test %d, readGNUSparsePAXHeaders() = %v, want %v", i, err, v.wantErr)
1326 }
1327 if hdr.Size != v.wantSize {
1328 t.Errorf("test %d, Header.Size = %d, want %d", i, hdr.Size, v.wantSize)
1329 }
1330 if hdr.Name != v.wantName {
1331 t.Errorf("test %d, Header.Name = %s, want %s", i, hdr.Name, v.wantName)
1332 }
1333 if v.wantErr == nil && r.Len() == 0 {
1334 t.Errorf("test %d, canary byte unexpectedly consumed", i)
1335 }
1336 }
1337 }
1338
1339
1340
1341 type testNonEmptyReader struct{ io.Reader }
1342
1343 func (r testNonEmptyReader) Read(b []byte) (int, error) {
1344 if len(b) == 0 {
1345 return 0, errors.New("unexpected empty Read call")
1346 }
1347 return r.Reader.Read(b)
1348 }
1349
1350 func TestFileReader(t *testing.T) {
1351 type (
1352 testRead struct {
1353 cnt int
1354 wantStr string
1355 wantErr error
1356 }
1357 testWriteTo struct {
1358 ops fileOps
1359 wantCnt int64
1360 wantErr error
1361 }
1362 testRemaining struct {
1363 wantLCnt int64
1364 wantPCnt int64
1365 }
1366 testFnc interface{}
1367 )
1368
1369 type (
1370 makeReg struct {
1371 str string
1372 size int64
1373 }
1374 makeSparse struct {
1375 makeReg makeReg
1376 spd sparseDatas
1377 size int64
1378 }
1379 fileMaker interface{}
1380 )
1381
1382 vectors := []struct {
1383 maker fileMaker
1384 tests []testFnc
1385 }{{
1386 maker: makeReg{"", 0},
1387 tests: []testFnc{
1388 testRemaining{0, 0},
1389 testRead{0, "", io.EOF},
1390 testRead{1, "", io.EOF},
1391 testWriteTo{nil, 0, nil},
1392 testRemaining{0, 0},
1393 },
1394 }, {
1395 maker: makeReg{"", 1},
1396 tests: []testFnc{
1397 testRemaining{1, 1},
1398 testRead{5, "", io.ErrUnexpectedEOF},
1399 testWriteTo{nil, 0, io.ErrUnexpectedEOF},
1400 testRemaining{1, 1},
1401 },
1402 }, {
1403 maker: makeReg{"hello", 5},
1404 tests: []testFnc{
1405 testRemaining{5, 5},
1406 testRead{5, "hello", io.EOF},
1407 testRemaining{0, 0},
1408 },
1409 }, {
1410 maker: makeReg{"hello, world", 50},
1411 tests: []testFnc{
1412 testRemaining{50, 50},
1413 testRead{7, "hello, ", nil},
1414 testRemaining{43, 43},
1415 testRead{5, "world", nil},
1416 testRemaining{38, 38},
1417 testWriteTo{nil, 0, io.ErrUnexpectedEOF},
1418 testRead{1, "", io.ErrUnexpectedEOF},
1419 testRemaining{38, 38},
1420 },
1421 }, {
1422 maker: makeReg{"hello, world", 5},
1423 tests: []testFnc{
1424 testRemaining{5, 5},
1425 testRead{0, "", nil},
1426 testRead{4, "hell", nil},
1427 testRemaining{1, 1},
1428 testWriteTo{fileOps{"o"}, 1, nil},
1429 testRemaining{0, 0},
1430 testWriteTo{nil, 0, nil},
1431 testRead{0, "", io.EOF},
1432 },
1433 }, {
1434 maker: makeSparse{makeReg{"abcde", 5}, sparseDatas{{0, 2}, {5, 3}}, 8},
1435 tests: []testFnc{
1436 testRemaining{8, 5},
1437 testRead{3, "ab\x00", nil},
1438 testRead{10, "\x00\x00cde", io.EOF},
1439 testRemaining{0, 0},
1440 },
1441 }, {
1442 maker: makeSparse{makeReg{"abcde", 5}, sparseDatas{{0, 2}, {5, 3}}, 8},
1443 tests: []testFnc{
1444 testRemaining{8, 5},
1445 testWriteTo{fileOps{"ab", int64(3), "cde"}, 8, nil},
1446 testRemaining{0, 0},
1447 },
1448 }, {
1449 maker: makeSparse{makeReg{"abcde", 5}, sparseDatas{{0, 2}, {5, 3}}, 10},
1450 tests: []testFnc{
1451 testRemaining{10, 5},
1452 testRead{100, "ab\x00\x00\x00cde\x00\x00", io.EOF},
1453 testRemaining{0, 0},
1454 },
1455 }, {
1456 maker: makeSparse{makeReg{"abc", 5}, sparseDatas{{0, 2}, {5, 3}}, 10},
1457 tests: []testFnc{
1458 testRemaining{10, 5},
1459 testRead{100, "ab\x00\x00\x00c", io.ErrUnexpectedEOF},
1460 testRemaining{4, 2},
1461 },
1462 }, {
1463 maker: makeSparse{makeReg{"abcde", 5}, sparseDatas{{1, 3}, {6, 2}}, 8},
1464 tests: []testFnc{
1465 testRemaining{8, 5},
1466 testRead{8, "\x00abc\x00\x00de", io.EOF},
1467 testRemaining{0, 0},
1468 },
1469 }, {
1470 maker: makeSparse{makeReg{"abcde", 5}, sparseDatas{{1, 3}, {6, 0}, {6, 0}, {6, 2}}, 8},
1471 tests: []testFnc{
1472 testRemaining{8, 5},
1473 testRead{8, "\x00abc\x00\x00de", io.EOF},
1474 testRemaining{0, 0},
1475 },
1476 }, {
1477 maker: makeSparse{makeReg{"abcde", 5}, sparseDatas{{1, 3}, {6, 0}, {6, 0}, {6, 2}}, 8},
1478 tests: []testFnc{
1479 testRemaining{8, 5},
1480 testWriteTo{fileOps{int64(1), "abc", int64(2), "de"}, 8, nil},
1481 testRemaining{0, 0},
1482 },
1483 }, {
1484 maker: makeSparse{makeReg{"abcde", 5}, sparseDatas{{1, 3}, {6, 2}}, 10},
1485 tests: []testFnc{
1486 testRead{100, "\x00abc\x00\x00de\x00\x00", io.EOF},
1487 },
1488 }, {
1489 maker: makeSparse{makeReg{"abcde", 5}, sparseDatas{{1, 3}, {6, 2}}, 10},
1490 tests: []testFnc{
1491 testWriteTo{fileOps{int64(1), "abc", int64(2), "de", int64(1), "\x00"}, 10, nil},
1492 },
1493 }, {
1494 maker: makeSparse{makeReg{"abcde", 5}, sparseDatas{{1, 3}, {6, 2}, {8, 0}, {8, 0}, {8, 0}, {8, 0}}, 10},
1495 tests: []testFnc{
1496 testRead{100, "\x00abc\x00\x00de\x00\x00", io.EOF},
1497 },
1498 }, {
1499 maker: makeSparse{makeReg{"", 0}, sparseDatas{}, 2},
1500 tests: []testFnc{
1501 testRead{100, "\x00\x00", io.EOF},
1502 },
1503 }, {
1504 maker: makeSparse{makeReg{"", 8}, sparseDatas{{1, 3}, {6, 5}}, 15},
1505 tests: []testFnc{
1506 testRead{100, "\x00", io.ErrUnexpectedEOF},
1507 },
1508 }, {
1509 maker: makeSparse{makeReg{"ab", 2}, sparseDatas{{1, 3}, {6, 5}}, 15},
1510 tests: []testFnc{
1511 testRead{100, "\x00ab", errMissData},
1512 },
1513 }, {
1514 maker: makeSparse{makeReg{"ab", 8}, sparseDatas{{1, 3}, {6, 5}}, 15},
1515 tests: []testFnc{
1516 testRead{100, "\x00ab", io.ErrUnexpectedEOF},
1517 },
1518 }, {
1519 maker: makeSparse{makeReg{"abc", 3}, sparseDatas{{1, 3}, {6, 5}}, 15},
1520 tests: []testFnc{
1521 testRead{100, "\x00abc\x00\x00", errMissData},
1522 },
1523 }, {
1524 maker: makeSparse{makeReg{"abc", 8}, sparseDatas{{1, 3}, {6, 5}}, 15},
1525 tests: []testFnc{
1526 testRead{100, "\x00abc\x00\x00", io.ErrUnexpectedEOF},
1527 },
1528 }, {
1529 maker: makeSparse{makeReg{"abcde", 5}, sparseDatas{{1, 3}, {6, 5}}, 15},
1530 tests: []testFnc{
1531 testRead{100, "\x00abc\x00\x00de", errMissData},
1532 },
1533 }, {
1534 maker: makeSparse{makeReg{"abcde", 5}, sparseDatas{{1, 3}, {6, 5}}, 15},
1535 tests: []testFnc{
1536 testWriteTo{fileOps{int64(1), "abc", int64(2), "de"}, 8, errMissData},
1537 },
1538 }, {
1539 maker: makeSparse{makeReg{"abcde", 8}, sparseDatas{{1, 3}, {6, 5}}, 15},
1540 tests: []testFnc{
1541 testRead{100, "\x00abc\x00\x00de", io.ErrUnexpectedEOF},
1542 },
1543 }, {
1544 maker: makeSparse{makeReg{"abcdefghEXTRA", 13}, sparseDatas{{1, 3}, {6, 5}}, 15},
1545 tests: []testFnc{
1546 testRemaining{15, 13},
1547 testRead{100, "\x00abc\x00\x00defgh\x00\x00\x00\x00", errUnrefData},
1548 testWriteTo{nil, 0, errUnrefData},
1549 testRemaining{0, 5},
1550 },
1551 }, {
1552 maker: makeSparse{makeReg{"abcdefghEXTRA", 13}, sparseDatas{{1, 3}, {6, 5}}, 15},
1553 tests: []testFnc{
1554 testRemaining{15, 13},
1555 testWriteTo{fileOps{int64(1), "abc", int64(2), "defgh", int64(4)}, 15, errUnrefData},
1556 testRead{100, "", errUnrefData},
1557 testRemaining{0, 5},
1558 },
1559 }}
1560
1561 for i, v := range vectors {
1562 var fr fileReader
1563 switch maker := v.maker.(type) {
1564 case makeReg:
1565 r := testNonEmptyReader{strings.NewReader(maker.str)}
1566 fr = ®FileReader{r, maker.size}
1567 case makeSparse:
1568 if !validateSparseEntries(maker.spd, maker.size) {
1569 t.Fatalf("invalid sparse map: %v", maker.spd)
1570 }
1571 sph := invertSparseEntries(maker.spd, maker.size)
1572 r := testNonEmptyReader{strings.NewReader(maker.makeReg.str)}
1573 fr = ®FileReader{r, maker.makeReg.size}
1574 fr = &sparseFileReader{fr, sph, 0}
1575 default:
1576 t.Fatalf("test %d, unknown make operation: %T", i, maker)
1577 }
1578
1579 for j, tf := range v.tests {
1580 switch tf := tf.(type) {
1581 case testRead:
1582 b := make([]byte, tf.cnt)
1583 n, err := fr.Read(b)
1584 if got := string(b[:n]); got != tf.wantStr || err != tf.wantErr {
1585 t.Errorf("test %d.%d, Read(%d):\ngot (%q, %v)\nwant (%q, %v)", i, j, tf.cnt, got, err, tf.wantStr, tf.wantErr)
1586 }
1587 case testWriteTo:
1588 f := &testFile{ops: tf.ops}
1589 got, err := fr.WriteTo(f)
1590 if _, ok := err.(testError); ok {
1591 t.Errorf("test %d.%d, WriteTo(): %v", i, j, err)
1592 } else if got != tf.wantCnt || err != tf.wantErr {
1593 t.Errorf("test %d.%d, WriteTo() = (%d, %v), want (%d, %v)", i, j, got, err, tf.wantCnt, tf.wantErr)
1594 }
1595 if len(f.ops) > 0 {
1596 t.Errorf("test %d.%d, expected %d more operations", i, j, len(f.ops))
1597 }
1598 case testRemaining:
1599 if got := fr.LogicalRemaining(); got != tf.wantLCnt {
1600 t.Errorf("test %d.%d, LogicalRemaining() = %d, want %d", i, j, got, tf.wantLCnt)
1601 }
1602 if got := fr.PhysicalRemaining(); got != tf.wantPCnt {
1603 t.Errorf("test %d.%d, PhysicalRemaining() = %d, want %d", i, j, got, tf.wantPCnt)
1604 }
1605 default:
1606 t.Fatalf("test %d.%d, unknown test operation: %T", i, j, tf)
1607 }
1608 }
1609 }
1610 }
1611
View as plain text