archive/tar: merge 6700047 and 6814084

src/pkg/archive/tar/reader_test.go

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package tar
 
 import (
         "bytes"
         "crypto/md5"
         "fmt"
         "io"
         "os"
+        "reflect"
+        "strings"
         "testing"
         "time"
 )
 
 type untarTest struct {
         file    string
         headers []*Header
         cksums  []string
 }
 
@@ skipping 78 matching lines @@
                                 Name:     "small2.txt",
                                 Mode:     0444,
                                 Uid:      73025,
                                 Gid:      5000,
                                 Size:     11,
                                 ModTime:  time.Unix(1244593104, 0),
                                 Typeflag: '\x00',
                         },
                 },
         },
+        {
+                file: "testdata/pax.tar",
+                headers: []*Header{
+                        {
+                                Name:       "a/123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100",
+                                Mode:       0664,
+                                Uid:        1000,
+                                Gid:        1000,
+                                Uname:      "shane",
+                                Gname:      "shane",
+                                Size:       7,
+                                ModTime:    time.Unix(1350244992, 23960108),
+                                ChangeTime: time.Unix(1350244992, 23960108),
+                                AccessTime: time.Unix(1350244992, 23960108),
+                                Typeflag:   TypeReg,
+                        },
+                        {
+                                Name:       "a/b",
+                                Mode:       0777,
+                                Uid:        1000,
+                                Gid:        1000,
+                                Uname:      "shane",
+                                Gname:      "shane",
+                                Size:       0,
+                                ModTime:    time.Unix(1350266320, 910238425),
+                                ChangeTime: time.Unix(1350266320, 910238425),
+                                AccessTime: time.Unix(1350266320, 910238425),
+                                Typeflag:   TypeSymlink,
+                                Linkname:   "123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100",
+                        },
+                },
+        },
 }
 
 func TestReader(t *testing.T) {
 testLoop:
         for i, test := range untarTests {
                 f, err := os.Open(test.file)
                 if err != nil {
                         t.Errorf("test %d: Unexpected error: %v", i, err)
                         continue
                 }
                 tr := NewReader(f)
                 for j, header := range test.headers {
                         hdr, err := tr.Next()
                         if err != nil || hdr == nil {
                                 t.Errorf("test %d, entry %d: Didn't get entry: %v", i, j, err)
                                 f.Close()
                                 continue testLoop
                         }
                         if *hdr != *header {
                                 t.Errorf("test %d, entry %d: Incorrect header:\nhave %+v\nwant %+v",
                                         i, j, *hdr, *header)
                         }
                 }
                 hdr, err := tr.Next()
                 if err == io.EOF {
-                        break
+                        continue testLoop
                 }
                 if hdr != nil || err != nil {
                         t.Errorf("test %d: Unexpected entry or error: hdr=%v err=%v", i, hdr, err)
                 }
                 f.Close()
         }
 }
 
 func TestPartialRead(t *testing.T) {
         f, err := os.Open("testdata/gnu.tar")
@@ skipping 106 matching lines @@
                 }
                 if err != nil {
                         t.Fatalf("Unexpected error: %v", err)
                 }
         }
 
         if nread != len(test.headers) {
                 t.Errorf("Didn't process all files\nexpected: %d\nprocessed %d\n", len(test.headers), nread)
         }
 }
+
+func TestParsePAXHeader(t *testing.T) {
+        correctHeaders := []byte("30 mtime=1350244992.023960108\n")
+        reader := bytes.NewBuffer(correctHeaders)
+        headers, err := parsePAX(reader)
+        if err != nil {
+                t.Fatalf("Couldn't parse correctly formatted headers %s", err)
+        }
+        if strings.EqualFold(headers["mtime"], "mtime=1350244992.023960108") {
+                t.Fatalf("mtime header incorrectly parsed")
+        }
+        trailer := make([]byte, 100)
+        n, err := reader.Read(trailer)
+        if err != io.EOF || n != 0 {
+                t.Fatal("Buffer wasn't consumed")
+        }
+        badHeader := bytes.NewBuffer([]byte("3 somelongkey="))
+        if _, err := parsePAX(badHeader); err != ErrHeader {
+                t.Fatal("Unexpected success when parsing bad header")
+        }
+}
+
+func TestParsePAXTime(t *testing.T) {
+        // Some valid PAX time values
+        timestamps := map[string]time.Time{
+                "1350244992.023960108":  time.Unix(1350244992, 23960108), // The commoon case
+                "1350244992.02396010":   time.Unix(1350244992, 23960100), // Lower precision value
+                "1350244992.0239601089": time.Unix(1350244992, 23960108), // Higher precision value
+                "1350244992":            time.Unix(1350244992, 0),        // Low precision value
+        }
+        for input, expected := range timestamps {
+                ts, err := parsePAXTime(input)
+                if err != nil {
+                        t.Fatal(err)
+                }
+                if !ts.Equal(expected) {
+                        t.Fatalf("Time parsing failure %s %s", ts, expected)
+                }
+        }
+}
+
+func TestMergePAX(t *testing.T) {
+        hdr := new(Header)
+        // Test a string, integer, and time based value.
+        headers := map[string]string{
+                "path":  "a/b/c",
+                "uid":   "1000",
+                "mtime": "1350244992.023960108",
+        }
+        err := mergePAX(hdr, headers)
+        if err != nil {
+                t.Fatal(err)
+        }
+        want := &Header{
+                Name:    "a/b/c",
+                Uid:     1000,
+                ModTime: time.Unix(1350244992, 23960108),
+        }
+        if !reflect.DeepEqual(hdr, want) {
+                t.Errorf("incorrect merge: got %+v, want %+v", hdr, want)
+        }
+}