cmd/zip2zip/zip2zip_test.go

// Copyright 2017 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"
	"reflect"
	"testing"

	"android/soong/third_party/zip"
)

var testCases = []struct {
	name string

	inputFiles   []string
	sortGlobs    bool
	sortJava     bool
	args         []string
	excludes     []string
	includes     []string
	uncompresses []string

	outputFiles []string
	storedFiles []string
	err         error
}{
	{ // This is modelled after the update package build rules in build/make/core/Makefile
		name: "filter globs",

		inputFiles: []string{
			"RADIO/a",
			"IMAGES/system.img",
			"IMAGES/b.txt",
			"IMAGES/recovery.img",
			"IMAGES/vendor.img",
			"OTA/android-info.txt",
			"OTA/b",
		},
		args: []string{"OTA/android-info.txt:android-info.txt", "IMAGES/*.img:."},

		outputFiles: []string{
			"android-info.txt",
			"system.img",
			"recovery.img",
			"vendor.img",
		},
	},
	{
		name: "sorted filter globs",

		inputFiles: []string{
			"RADIO/a",
			"IMAGES/system.img",
			"IMAGES/b.txt",
			"IMAGES/recovery.img",
			"IMAGES/vendor.img",
			"OTA/android-info.txt",
			"OTA/b",
		},
		sortGlobs: true,
		args:      []string{"IMAGES/*.img:.", "OTA/android-info.txt:android-info.txt"},

		outputFiles: []string{
			"recovery.img",
			"system.img",
			"vendor.img",
			"android-info.txt",
		},
	},
	{
		name: "sort all",

		inputFiles: []string{
			"RADIO/",
			"RADIO/a",
			"IMAGES/",
			"IMAGES/system.img",
			"IMAGES/b.txt",
			"IMAGES/recovery.img",
			"IMAGES/vendor.img",
			"OTA/",
			"OTA/b",
			"OTA/android-info.txt",
		},
		sortGlobs: true,
		args:      []string{"**/*"},

		outputFiles: []string{
			"IMAGES/b.txt",
			"IMAGES/recovery.img",
			"IMAGES/system.img",
			"IMAGES/vendor.img",
			"OTA/android-info.txt",
			"OTA/b",
			"RADIO/a",
		},
	},
	{
		name: "sort all implicit",

		inputFiles: []string{
			"RADIO/",
			"RADIO/a",
			"IMAGES/",
			"IMAGES/system.img",
			"IMAGES/b.txt",
			"IMAGES/recovery.img",
			"IMAGES/vendor.img",
			"OTA/",
			"OTA/b",
			"OTA/android-info.txt",
		},
		sortGlobs: true,
		args:      nil,

		outputFiles: []string{
			"IMAGES/",
			"IMAGES/b.txt",
			"IMAGES/recovery.img",
			"IMAGES/system.img",
			"IMAGES/vendor.img",
			"OTA/",
			"OTA/android-info.txt",
			"OTA/b",
			"RADIO/",
			"RADIO/a",
		},
	},
	{
		name: "sort jar",

		inputFiles: []string{
			"MANIFEST.MF",
			"META-INF/MANIFEST.MF",
			"META-INF/aaa/",
			"META-INF/aaa/aaa",
			"META-INF/AAA",
			"META-INF.txt",
			"META-INF/",
			"AAA",
			"aaa",
		},
		sortJava: true,
		args:     nil,

		outputFiles: []string{
			"META-INF/",
			"META-INF/MANIFEST.MF",
			"META-INF/AAA",
			"META-INF/aaa/",
			"META-INF/aaa/aaa",
			"AAA",
			"MANIFEST.MF",
			"META-INF.txt",
			"aaa",
		},
	},
	{
		name: "double input",

		inputFiles: []string{
			"b",
			"a",
		},
		args: []string{"a:a2", "**/*"},

		outputFiles: []string{
			"a2",
			"b",
			"a",
		},
	},
	{
		name: "multiple matches",

		inputFiles: []string{
			"a/a",
		},
		args: []string{"a/a", "a/*"},

		outputFiles: []string{
			"a/a",
		},
	},
	{
		name: "multiple conflicting matches",

		inputFiles: []string{
			"a/a",
			"a/b",
		},
		args: []string{"a/b:a/a", "a/*"},

		err: fmt.Errorf(`multiple entries for "a/a" with different contents`),
	},
	{
		name: "excludes",

		inputFiles: []string{
			"a/a",
			"a/b",
		},
		args:     nil,
		excludes: []string{"a/a"},

		outputFiles: []string{
			"a/b",
		},
	},
	{
		name: "excludes with args",

		inputFiles: []string{
			"a/a",
			"a/b",
		},
		args:     []string{"a/*"},
		excludes: []string{"a/a"},

		outputFiles: []string{
			"a/b",
		},
	},
	{
		name: "excludes over args",

		inputFiles: []string{
			"a/a",
			"a/b",
		},
		args:     []string{"a/a"},
		excludes: []string{"a/*"},

		outputFiles: nil,
	},
	{
		name: "excludes with includes",

		inputFiles: []string{
			"a/a",
			"a/b",
		},
		args:     nil,
		excludes: []string{"a/*"},
		includes: []string{"a/b"},

		outputFiles: []string{"a/b"},
	},
	{
		name: "excludes with glob",

		inputFiles: []string{
			"a/a",
			"a/b",
		},
		args:     []string{"a/*"},
		excludes: []string{"a/*"},

		outputFiles: nil,
	},
	{
		name: "uncompress one",

		inputFiles: []string{
			"a/a",
			"a/b",
		},
		uncompresses: []string{"a/a"},

		outputFiles: []string{
			"a/a",
			"a/b",
		},
		storedFiles: []string{
			"a/a",
		},
	},
	{
		name: "uncompress two",

		inputFiles: []string{
			"a/a",
			"a/b",
		},
		uncompresses: []string{"a/a", "a/b"},

		outputFiles: []string{
			"a/a",
			"a/b",
		},
		storedFiles: []string{
			"a/a",
			"a/b",
		},
	},
	{
		name: "uncompress glob",

		inputFiles: []string{
			"a/a",
			"a/b",
			"a/c.so",
			"a/d.so",
		},
		uncompresses: []string{"a/*.so"},

		outputFiles: []string{
			"a/a",
			"a/b",
			"a/c.so",
			"a/d.so",
		},
		storedFiles: []string{
			"a/c.so",
			"a/d.so",
		},
	},
	{
		name: "uncompress rename",

		inputFiles: []string{
			"a/a",
		},
		args:         []string{"a/a:a/b"},
		uncompresses: []string{"a/b"},

		outputFiles: []string{
			"a/b",
		},
		storedFiles: []string{
			"a/b",
		},
	},
	{
		name: "recursive glob",

		inputFiles: []string{
			"a/a/a",
			"a/a/b",
		},
		args: []string{"a/**/*:b"},
		outputFiles: []string{
			"b/a/a",
			"b/a/b",
		},
	},
	{
		name: "glob",

		inputFiles: []string{
			"a/a/a",
			"a/a/b",
			"a/b",
			"a/c",
		},
		args: []string{"a/*:b"},
		outputFiles: []string{
			"b/b",
			"b/c",
		},
	},
	{
		name: "top level glob",

		inputFiles: []string{
			"a",
			"b",
		},
		args: []string{"*:b"},
		outputFiles: []string{
			"b/a",
			"b/b",
		},
	},
	{
		name: "multilple glob",

		inputFiles: []string{
			"a/a/a",
			"a/a/b",
		},
		args: []string{"a/*/*:b"},
		outputFiles: []string{
			"b/a/a",
			"b/a/b",
		},
	},
	{
		name: "escaping",

		inputFiles:  []string{"a"},
		args:        []string{"\\a"},
		outputFiles: []string{"a"},
	},
}

func errorString(e error) string {
	if e == nil {
		return ""
	}
	return e.Error()
}

func TestZip2Zip(t *testing.T) {
	for _, testCase := range testCases {
		t.Run(testCase.name, func(t *testing.T) {
			inputBuf := &bytes.Buffer{}
			outputBuf := &bytes.Buffer{}

			inputWriter := zip.NewWriter(inputBuf)
			for _, file := range testCase.inputFiles {
				w, err := inputWriter.Create(file)
				if err != nil {
					t.Fatal(err)
				}
				fmt.Fprintln(w, "test")
			}
			inputWriter.Close()
			inputBytes := inputBuf.Bytes()
			inputReader, err := zip.NewReader(bytes.NewReader(inputBytes), int64(len(inputBytes)))
			if err != nil {
				t.Fatal(err)
			}

			outputWriter := zip.NewWriter(outputBuf)
			err = zip2zip(inputReader, outputWriter, testCase.sortGlobs, testCase.sortJava, false,
				testCase.args, testCase.excludes, testCase.includes, testCase.uncompresses)
			if errorString(testCase.err) != errorString(err) {
				t.Fatalf("Unexpected error:\n got: %q\nwant: %q", errorString(err), errorString(testCase.err))
			}

			outputWriter.Close()
			outputBytes := outputBuf.Bytes()
			outputReader, err := zip.NewReader(bytes.NewReader(outputBytes), int64(len(outputBytes)))
			if err != nil {
				t.Fatal(err)
			}
			var outputFiles []string
			var storedFiles []string
			if len(outputReader.File) > 0 {
				outputFiles = make([]string, len(outputReader.File))
				for i, file := range outputReader.File {
					outputFiles[i] = file.Name
					if file.Method == zip.Store {
						storedFiles = append(storedFiles, file.Name)
					}
				}
			}

			if !reflect.DeepEqual(testCase.outputFiles, outputFiles) {
				t.Fatalf("Output file list does not match:\nwant: %v\n got: %v", testCase.outputFiles, outputFiles)
			}
			if !reflect.DeepEqual(testCase.storedFiles, storedFiles) {
				t.Fatalf("Stored file list does not match:\nwant: %v\n got: %v", testCase.storedFiles, storedFiles)
			}
		})
	}
}

// TestZip2Zip64 tests that zip2zip on zip file larger than 4GB produces a valid zip file.
func TestZip2Zip64(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping slow test in short mode")
	}
	inputBuf := &bytes.Buffer{}
	outputBuf := &bytes.Buffer{}

	inputWriter := zip.NewWriter(inputBuf)
	w, err := inputWriter.CreateHeaderAndroid(&zip.FileHeader{
		Name:   "a",
		Method: zip.Store,
	})
	if err != nil {
		t.Fatal(err)
	}
	buf := make([]byte, 4*1024*1024)
	for i := 0; i < 1025; i++ {
		w.Write(buf)
	}
	w, err = inputWriter.CreateHeaderAndroid(&zip.FileHeader{
		Name:   "b",
		Method: zip.Store,
	})
	for i := 0; i < 1025; i++ {
		w.Write(buf)
	}
	inputWriter.Close()
	inputBytes := inputBuf.Bytes()

	inputReader, err := zip.NewReader(bytes.NewReader(inputBytes), int64(len(inputBytes)))
	if err != nil {
		t.Fatal(err)
	}

	outputWriter := zip.NewWriter(outputBuf)
	err = zip2zip(inputReader, outputWriter, false, false, false,
		nil, nil, nil, nil)
	if err != nil {
		t.Fatal(err)
	}

	outputWriter.Close()
	outputBytes := outputBuf.Bytes()
	_, err = zip.NewReader(bytes.NewReader(outputBytes), int64(len(outputBytes)))
	if err != nil {
		t.Fatal(err)
	}
}

func TestConstantPartOfPattern(t *testing.T) {
	testCases := []struct{ in, out string }{
		{
			in:  "",
			out: "",
		},
		{
			in:  "a",
			out: "a",
		},
		{
			in:  "*",
			out: "",
		},
		{
			in:  "a/a",
			out: "a/a",
		},
		{
			in:  "a/*",
			out: "a",
		},
		{
			in:  "a/*/a",
			out: "a",
		},
		{
			in:  "a/**/*",
			out: "a",
		},
	}

	for _, test := range testCases {
		t.Run(test.in, func(t *testing.T) {
			got := constantPartOfPattern(test.in)
			if got != test.out {
				t.Errorf("want %q, got %q", test.out, got)
			}
		})
	}
}