| // Copyright 2018 Google Inc. All rights reserved. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| package main |
| |
| import ( |
| "bytes" |
| "fmt" |
| "os" |
| "strconv" |
| "strings" |
| "testing" |
| |
| "android/soong/jar" |
| "android/soong/third_party/zip" |
| ) |
| |
| type testZipEntry struct { |
| name string |
| mode os.FileMode |
| data []byte |
| } |
| |
| var ( |
| A = testZipEntry{"A", 0755, []byte("foo")} |
| a = testZipEntry{"a", 0755, []byte("foo")} |
| a2 = testZipEntry{"a", 0755, []byte("FOO2")} |
| a3 = testZipEntry{"a", 0755, []byte("Foo3")} |
| bDir = testZipEntry{"b/", os.ModeDir | 0755, nil} |
| bbDir = testZipEntry{"b/b/", os.ModeDir | 0755, nil} |
| bbb = testZipEntry{"b/b/b", 0755, nil} |
| ba = testZipEntry{"b/a", 0755, []byte("foob")} |
| bc = testZipEntry{"b/c", 0755, []byte("bar")} |
| bd = testZipEntry{"b/d", 0700, []byte("baz")} |
| be = testZipEntry{"b/e", 0700, []byte("")} |
| |
| metainfDir = testZipEntry{jar.MetaDir, os.ModeDir | 0755, nil} |
| manifestFile = testZipEntry{jar.ManifestFile, 0755, []byte("manifest")} |
| manifestFile2 = testZipEntry{jar.ManifestFile, 0755, []byte("manifest2")} |
| moduleInfoFile = testZipEntry{jar.ModuleInfoClass, 0755, []byte("module-info")} |
| ) |
| |
| func TestMergeZips(t *testing.T) { |
| testCases := []struct { |
| name string |
| in [][]testZipEntry |
| stripFiles []string |
| stripDirs []string |
| jar bool |
| sort bool |
| ignoreDuplicates bool |
| stripDirEntries bool |
| zipsToNotStrip map[string]bool |
| |
| out []testZipEntry |
| err string |
| }{ |
| { |
| name: "duplicates error", |
| in: [][]testZipEntry{ |
| {a}, |
| {a2}, |
| {a3}, |
| }, |
| out: []testZipEntry{a}, |
| err: "duplicate", |
| }, |
| { |
| name: "duplicates take first", |
| in: [][]testZipEntry{ |
| {a}, |
| {a2}, |
| {a3}, |
| }, |
| out: []testZipEntry{a}, |
| |
| ignoreDuplicates: true, |
| }, |
| { |
| name: "sort", |
| in: [][]testZipEntry{ |
| {be, bc, bDir, bbDir, bbb, A, metainfDir, manifestFile}, |
| }, |
| out: []testZipEntry{A, metainfDir, manifestFile, bDir, bbDir, bbb, bc, be}, |
| |
| sort: true, |
| }, |
| { |
| name: "jar sort", |
| in: [][]testZipEntry{ |
| {be, bc, bDir, A, metainfDir, manifestFile}, |
| }, |
| out: []testZipEntry{metainfDir, manifestFile, A, bDir, bc, be}, |
| |
| jar: true, |
| }, |
| { |
| name: "jar merge", |
| in: [][]testZipEntry{ |
| {metainfDir, manifestFile, bDir, be}, |
| {metainfDir, manifestFile2, bDir, bc}, |
| {metainfDir, manifestFile2, A}, |
| }, |
| out: []testZipEntry{metainfDir, manifestFile, A, bDir, bc, be}, |
| |
| jar: true, |
| }, |
| { |
| name: "merge", |
| in: [][]testZipEntry{ |
| {bDir, be}, |
| {bDir, bc}, |
| {A}, |
| }, |
| out: []testZipEntry{bDir, be, bc, A}, |
| }, |
| { |
| name: "strip dir entries", |
| in: [][]testZipEntry{ |
| {a, bDir, bbDir, bbb, bc, bd, be}, |
| }, |
| out: []testZipEntry{a, bbb, bc, bd, be}, |
| |
| stripDirEntries: true, |
| }, |
| { |
| name: "strip files", |
| in: [][]testZipEntry{ |
| {a, bDir, bbDir, bbb, bc, bd, be}, |
| }, |
| out: []testZipEntry{a, bDir, bbDir, bbb, bc}, |
| |
| stripFiles: []string{"b/d", "b/e"}, |
| }, |
| { |
| // merge_zips used to treat -stripFile a as stripping any file named a, it now only strips a in the |
| // root of the zip. |
| name: "strip file name", |
| in: [][]testZipEntry{ |
| {a, bDir, ba}, |
| }, |
| out: []testZipEntry{bDir, ba}, |
| |
| stripFiles: []string{"a"}, |
| }, |
| { |
| name: "strip files glob", |
| in: [][]testZipEntry{ |
| {a, bDir, ba}, |
| }, |
| out: []testZipEntry{bDir}, |
| |
| stripFiles: []string{"**/a"}, |
| }, |
| { |
| name: "strip dirs", |
| in: [][]testZipEntry{ |
| {a, bDir, bbDir, bbb, bc, bd, be}, |
| }, |
| out: []testZipEntry{a}, |
| |
| stripDirs: []string{"b"}, |
| }, |
| { |
| name: "strip dirs glob", |
| in: [][]testZipEntry{ |
| {a, bDir, bbDir, bbb, bc, bd, be}, |
| }, |
| out: []testZipEntry{a, bDir, bc, bd, be}, |
| |
| stripDirs: []string{"b/*"}, |
| }, |
| { |
| name: "zips to not strip", |
| in: [][]testZipEntry{ |
| {a, bDir, bc}, |
| {bDir, bd}, |
| {bDir, be}, |
| }, |
| out: []testZipEntry{a, bDir, bd}, |
| |
| stripDirs: []string{"b"}, |
| zipsToNotStrip: map[string]bool{ |
| "in1": true, |
| }, |
| }, |
| } |
| |
| for _, test := range testCases { |
| t.Run(test.name, func(t *testing.T) { |
| var readers []namedZipReader |
| for i, in := range test.in { |
| r := testZipEntriesToZipReader(in) |
| readers = append(readers, namedZipReader{ |
| path: "in" + strconv.Itoa(i), |
| reader: r, |
| }) |
| } |
| |
| want := testZipEntriesToBuf(test.out) |
| |
| out := &bytes.Buffer{} |
| writer := zip.NewWriter(out) |
| |
| err := mergeZips(readers, writer, "", "", "", |
| test.sort, test.jar, false, test.stripDirEntries, test.ignoreDuplicates, |
| test.stripFiles, test.stripDirs, test.zipsToNotStrip) |
| |
| closeErr := writer.Close() |
| if closeErr != nil { |
| t.Fatal(err) |
| } |
| |
| if test.err != "" { |
| if err == nil { |
| t.Fatal("missing err, expected: ", test.err) |
| } else if !strings.Contains(strings.ToLower(err.Error()), strings.ToLower(test.err)) { |
| t.Fatal("incorrect err, want:", test.err, "got:", err) |
| } |
| return |
| } |
| |
| if !bytes.Equal(want, out.Bytes()) { |
| t.Error("incorrect zip output") |
| t.Errorf("want:\n%s", dumpZip(want)) |
| t.Errorf("got:\n%s", dumpZip(out.Bytes())) |
| } |
| }) |
| } |
| } |
| |
| func testZipEntriesToBuf(entries []testZipEntry) []byte { |
| b := &bytes.Buffer{} |
| zw := zip.NewWriter(b) |
| |
| for _, e := range entries { |
| fh := zip.FileHeader{ |
| Name: e.name, |
| } |
| fh.SetMode(e.mode) |
| |
| w, err := zw.CreateHeader(&fh) |
| if err != nil { |
| panic(err) |
| } |
| |
| _, err = w.Write(e.data) |
| if err != nil { |
| panic(err) |
| } |
| } |
| |
| err := zw.Close() |
| if err != nil { |
| panic(err) |
| } |
| |
| return b.Bytes() |
| } |
| |
| func testZipEntriesToZipReader(entries []testZipEntry) *zip.Reader { |
| b := testZipEntriesToBuf(entries) |
| r := bytes.NewReader(b) |
| |
| zr, err := zip.NewReader(r, int64(len(b))) |
| if err != nil { |
| panic(err) |
| } |
| |
| return zr |
| } |
| |
| func dumpZip(buf []byte) string { |
| r := bytes.NewReader(buf) |
| zr, err := zip.NewReader(r, int64(len(buf))) |
| if err != nil { |
| panic(err) |
| } |
| |
| var ret string |
| |
| for _, f := range zr.File { |
| ret += fmt.Sprintf("%v: %v %v %08x\n", f.Name, f.Mode(), f.UncompressedSize64, f.CRC32) |
| } |
| |
| return ret |
| } |