android_test.go 5.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224
  1. // Copyright 2017 Google Inc. All rights reserved.
  2. //
  3. // Licensed under the Apache License, Version 2.0 (the "License");
  4. // you may not use this file except in compliance with the License.
  5. // You may obtain a copy of the License at
  6. //
  7. // http://www.apache.org/licenses/LICENSE-2.0
  8. //
  9. // Unless required by applicable law or agreed to in writing, software
  10. // distributed under the License is distributed on an "AS IS" BASIS,
  11. // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12. // See the License for the specific language governing permissions and
  13. // limitations under the License.
  14. package zip
  15. import (
  16. "bytes"
  17. "testing"
  18. )
  19. var stripZip64Testcases = []struct {
  20. name string
  21. in []byte
  22. out []byte
  23. }{
  24. {
  25. name: "empty",
  26. in: []byte{},
  27. out: []byte{},
  28. },
  29. {
  30. name: "trailing data",
  31. in: []byte{1, 2, 3},
  32. out: []byte{1, 2, 3},
  33. },
  34. {
  35. name: "valid non-zip64 extra",
  36. in: []byte{2, 0, 2, 0, 1, 2},
  37. out: []byte{2, 0, 2, 0, 1, 2},
  38. },
  39. {
  40. name: "two valid non-zip64 extras",
  41. in: []byte{2, 0, 2, 0, 1, 2, 2, 0, 0, 0},
  42. out: []byte{2, 0, 2, 0, 1, 2, 2, 0, 0, 0},
  43. },
  44. {
  45. name: "simple zip64 extra",
  46. in: []byte{1, 0, 8, 0, 1, 2, 3, 4, 5, 6, 7, 8},
  47. out: []byte{},
  48. },
  49. {
  50. name: "zip64 extra and valid non-zip64 extra",
  51. in: []byte{1, 0, 8, 0, 1, 2, 3, 4, 5, 6, 7, 8, 2, 0, 0, 0},
  52. out: []byte{2, 0, 0, 0},
  53. },
  54. {
  55. name: "invalid extra",
  56. in: []byte{0, 0, 8, 0, 0, 0},
  57. out: []byte{0, 0, 8, 0, 0, 0},
  58. },
  59. {
  60. name: "zip64 extra and extended-timestamp extra and valid non-zip64 extra",
  61. in: []byte{1, 0, 8, 0, 1, 2, 3, 4, 5, 6, 7, 8, 85, 84, 5, 0, 1, 1, 2, 3, 4, 2, 0, 0, 0},
  62. out: []byte{2, 0, 0, 0},
  63. },
  64. }
  65. func TestStripZip64Extras(t *testing.T) {
  66. for _, testcase := range stripZip64Testcases {
  67. got := stripExtras(testcase.in)
  68. if !bytes.Equal(got, testcase.out) {
  69. t.Errorf("Failed testcase %s\ninput: %v\n want: %v\n got: %v\n", testcase.name, testcase.in, testcase.out, got)
  70. }
  71. }
  72. }
  73. func TestCopyFromZip64(t *testing.T) {
  74. if testing.Short() {
  75. t.Skip("slow test; skipping")
  76. }
  77. const size = uint32max + 1
  78. fromZipBytes := &bytes.Buffer{}
  79. fromZip := NewWriter(fromZipBytes)
  80. w, err := fromZip.CreateHeaderAndroid(&FileHeader{
  81. Name: "large",
  82. Method: Store,
  83. UncompressedSize64: size,
  84. CompressedSize64: size,
  85. })
  86. if err != nil {
  87. t.Fatalf("Create: %v", err)
  88. }
  89. _, err = w.Write(make([]byte, size))
  90. if err != nil {
  91. t.Fatalf("Write: %v", err)
  92. }
  93. err = fromZip.Close()
  94. if err != nil {
  95. t.Fatalf("Close: %v", err)
  96. }
  97. fromZip = nil
  98. fromZipReader, err := NewReader(bytes.NewReader(fromZipBytes.Bytes()), int64(fromZipBytes.Len()))
  99. if err != nil {
  100. t.Fatalf("NewReader: %v", err)
  101. }
  102. toZipBytes := &bytes.Buffer{}
  103. toZip := NewWriter(toZipBytes)
  104. err = toZip.CopyFrom(fromZipReader.File[0], fromZipReader.File[0].Name)
  105. if err != nil {
  106. t.Fatalf("CopyFrom: %v", err)
  107. }
  108. err = toZip.Close()
  109. if err != nil {
  110. t.Fatalf("Close: %v", err)
  111. }
  112. // Save some memory
  113. fromZipReader = nil
  114. fromZipBytes.Reset()
  115. toZipReader, err := NewReader(bytes.NewReader(toZipBytes.Bytes()), int64(toZipBytes.Len()))
  116. if err != nil {
  117. t.Fatalf("NewReader: %v", err)
  118. }
  119. if len(toZipReader.File) != 1 {
  120. t.Fatalf("Expected 1 file in toZip, got %d", len(toZipReader.File))
  121. }
  122. if g, w := toZipReader.File[0].CompressedSize64, uint64(size); g != w {
  123. t.Errorf("Expected CompressedSize64 %d, got %d", w, g)
  124. }
  125. if g, w := toZipReader.File[0].UncompressedSize64, uint64(size); g != w {
  126. t.Errorf("Expected UnompressedSize64 %d, got %d", w, g)
  127. }
  128. }
  129. // Test for b/187485108: zip64 output can't be read by p7zip 16.02.
  130. func TestZip64P7ZipRecords(t *testing.T) {
  131. if testing.Short() {
  132. t.Skip("slow test; skipping")
  133. }
  134. const size = uint32max + 1
  135. zipBytes := &bytes.Buffer{}
  136. zip := NewWriter(zipBytes)
  137. f, err := zip.CreateHeaderAndroid(&FileHeader{
  138. Name: "large",
  139. Method: Store,
  140. UncompressedSize64: size,
  141. CompressedSize64: size,
  142. })
  143. if err != nil {
  144. t.Fatalf("Create: %v", err)
  145. }
  146. _, err = f.Write(make([]byte, size))
  147. if err != nil {
  148. t.Fatalf("Write: %v", err)
  149. }
  150. err = zip.Close()
  151. if err != nil {
  152. t.Fatalf("Close: %v", err)
  153. }
  154. buf := zipBytes.Bytes()
  155. p := findSignatureInBlock(buf)
  156. if p < 0 {
  157. t.Fatalf("Missing signature")
  158. }
  159. b := readBuf(buf[p+4:]) // skip signature
  160. d := &directoryEnd{
  161. diskNbr: uint32(b.uint16()),
  162. dirDiskNbr: uint32(b.uint16()),
  163. dirRecordsThisDisk: uint64(b.uint16()),
  164. directoryRecords: uint64(b.uint16()),
  165. directorySize: uint64(b.uint32()),
  166. directoryOffset: uint64(b.uint32()),
  167. commentLen: b.uint16(),
  168. }
  169. // p7zip 16.02 wants regular end record directoryRecords to be accurate.
  170. if g, w := d.directoryRecords, uint64(1); g != w {
  171. t.Errorf("wanted directoryRecords %d, got %d", w, g)
  172. }
  173. zip64ExtraBuf := 48 // 4x uint16 + 5x uint64
  174. expectedDirSize := directoryHeaderLen + zip64ExtraBuf + len("large") // name of header
  175. if g, w := d.directorySize, uint64(expectedDirSize); g != w {
  176. t.Errorf("wanted directorySize %d, got %d", w, g)
  177. }
  178. if g, w := d.directoryOffset, uint64(uint32max); g != w {
  179. t.Errorf("wanted directoryOffset %d, got %d", w, g)
  180. }
  181. r := bytes.NewReader(buf)
  182. p64, err := findDirectory64End(r, int64(p))
  183. if err != nil {
  184. t.Fatalf("findDirectory64End: %v", err)
  185. }
  186. if p < 0 {
  187. t.Fatalf("findDirectory64End: not found")
  188. }
  189. err = readDirectory64End(r, p64, d)
  190. if err != nil {
  191. t.Fatalf("readDirectory64End: %v", err)
  192. }
  193. if g, w := d.directoryRecords, uint64(1); g != w {
  194. t.Errorf("wanted directoryRecords %d, got %d", w, g)
  195. }
  196. if g, w := d.directoryOffset, uint64(uint32max); g <= w {
  197. t.Errorf("wanted directoryOffset > %d, got %d", w, g)
  198. }
  199. }