cmd/symbols_map/symbols_map_test.go

// Copyright 2022 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 (
	"io/ioutil"
	"os"
	"path/filepath"
	"strings"
	"testing"

	"android/soong/cmd/symbols_map/symbols_map_proto"

	"google.golang.org/protobuf/encoding/prototext"
	"google.golang.org/protobuf/proto"
)

func Test_mergeProtos(t *testing.T) {
	type testFile struct {
		filename string
		contents *symbols_map_proto.Mapping
		missing  bool
	}

	tests := []struct {
		name               string
		inputs             []testFile
		stripPrefix        string
		writeIfChanged     bool
		ignoreMissingFiles bool

		error  string
		output *symbols_map_proto.Mappings
	}{
		{
			name:   "empty",
			output: &symbols_map_proto.Mappings{},
		},
		{
			name: "merge",
			inputs: []testFile{
				{
					filename: "foo",
					contents: &symbols_map_proto.Mapping{
						Identifier: proto.String("foo"),
						Location:   proto.String("symbols/foo"),
						Type:       symbols_map_proto.Mapping_ELF.Enum(),
					},
				},
				{
					filename: "bar",
					contents: &symbols_map_proto.Mapping{
						Identifier: proto.String("bar"),
						Location:   proto.String("symbols/bar"),
						Type:       symbols_map_proto.Mapping_R8.Enum(),
					},
				},
			},
			output: &symbols_map_proto.Mappings{
				Mappings: []*symbols_map_proto.Mapping{
					{
						Identifier: proto.String("foo"),
						Location:   proto.String("symbols/foo"),
						Type:       symbols_map_proto.Mapping_ELF.Enum(),
					},
					{
						Identifier: proto.String("bar"),
						Location:   proto.String("symbols/bar"),
						Type:       symbols_map_proto.Mapping_R8.Enum(),
					},
				},
			},
		},
		{
			name: "strip prefix",
			inputs: []testFile{
				{
					filename: "foo",
					contents: &symbols_map_proto.Mapping{
						Identifier: proto.String("foo"),
						Location:   proto.String("symbols/foo"),
						Type:       symbols_map_proto.Mapping_ELF.Enum(),
					},
				},
				{
					filename: "bar",
					contents: &symbols_map_proto.Mapping{
						Identifier: proto.String("bar"),
						Location:   proto.String("symbols/bar"),
						Type:       symbols_map_proto.Mapping_R8.Enum(),
					},
				},
			},
			stripPrefix: "symbols/",
			output: &symbols_map_proto.Mappings{
				Mappings: []*symbols_map_proto.Mapping{
					{
						Identifier: proto.String("foo"),
						Location:   proto.String("foo"),
						Type:       symbols_map_proto.Mapping_ELF.Enum(),
					},
					{
						Identifier: proto.String("bar"),
						Location:   proto.String("bar"),
						Type:       symbols_map_proto.Mapping_R8.Enum(),
					},
				},
			},
		},
		{
			name: "missing",
			inputs: []testFile{
				{
					filename: "foo",
					contents: &symbols_map_proto.Mapping{
						Identifier: proto.String("foo"),
						Location:   proto.String("symbols/foo"),
						Type:       symbols_map_proto.Mapping_ELF.Enum(),
					},
				},
				{
					filename: "bar",
					missing:  true,
				},
			},
			error: "no such file or directory",
		},
		{
			name: "ignore missing",
			inputs: []testFile{
				{
					filename: "foo",
					contents: &symbols_map_proto.Mapping{
						Identifier: proto.String("foo"),
						Location:   proto.String("symbols/foo"),
						Type:       symbols_map_proto.Mapping_ELF.Enum(),
					},
				},
				{
					filename: "bar",
					missing:  true,
				},
			},
			ignoreMissingFiles: true,
			output: &symbols_map_proto.Mappings{
				Mappings: []*symbols_map_proto.Mapping{
					{
						Identifier: proto.String("foo"),
						Location:   proto.String("symbols/foo"),
						Type:       symbols_map_proto.Mapping_ELF.Enum(),
					},
				},
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			dir, err := os.MkdirTemp("", "test_mergeProtos")
			if err != nil {
				t.Fatalf("failed to create temporary directory: %s", err)
			}
			defer os.RemoveAll(dir)

			var inputs []string
			for _, in := range tt.inputs {
				path := filepath.Join(dir, in.filename)
				inputs = append(inputs, path)
				if !in.missing {
					err := writeTextProto(path, in.contents, false)
					if err != nil {
						t.Fatalf("failed to create input file %s: %s", path, err)
					}
				}
			}
			output := filepath.Join(dir, "out")

			err = mergeProtos(output, inputs, tt.stripPrefix, tt.writeIfChanged, tt.ignoreMissingFiles)
			if err != nil {
				if tt.error != "" {
					if !strings.Contains(err.Error(), tt.error) {
						t.Fatalf("expected error %q, got %s", tt.error, err.Error())
					}
				} else {
					t.Fatalf("unexpected error %q", err)
				}
			} else if tt.error != "" {
				t.Fatalf("missing error %q", tt.error)
			} else {
				data, err := ioutil.ReadFile(output)
				if err != nil {
					t.Fatalf("failed to read output file %s: %s", output, err)
				}
				var got symbols_map_proto.Mappings
				err = prototext.Unmarshal(data, &got)
				if err != nil {
					t.Fatalf("failed to unmarshal textproto %s: %s", output, err)
				}

				if !proto.Equal(tt.output, &got) {
					t.Fatalf("expected output %q, got %q", tt.output.String(), got.String())
				}
			}
		})
	}
}