diff options
Diffstat (limited to '')
-rw-r--r-- | dependencies/pkg/mod/golang.org/x/sys@v0.1.0/unix/internal/mkmerge/mkmerge_test.go | 506 |
1 files changed, 506 insertions, 0 deletions
diff --git a/dependencies/pkg/mod/golang.org/x/sys@v0.1.0/unix/internal/mkmerge/mkmerge_test.go b/dependencies/pkg/mod/golang.org/x/sys@v0.1.0/unix/internal/mkmerge/mkmerge_test.go new file mode 100644 index 0000000..e61d7d4 --- /dev/null +++ b/dependencies/pkg/mod/golang.org/x/sys@v0.1.0/unix/internal/mkmerge/mkmerge_test.go @@ -0,0 +1,506 @@ +// Copyright 2020 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 main + +import ( + "bytes" + "fmt" + "go/parser" + "go/token" + "html/template" + "strings" + "testing" +) + +func TestImports(t *testing.T) { + t.Run("importName", func(t *testing.T) { + cases := []struct { + src string + ident string + }{ + {`"syscall"`, "syscall"}, + {`. "foobar"`, "."}, + {`"go/ast"`, "ast"}, + {`moo "go/format"`, "moo"}, + {`. "go/token"`, "."}, + {`"golang.org/x/sys/unix"`, "unix"}, + {`nix "golang.org/x/sys/unix"`, "nix"}, + {`_ "golang.org/x/sys/unix"`, "_"}, + } + + for _, c := range cases { + pkgSrc := fmt.Sprintf("package main\nimport %s", c.src) + + f, err := parser.ParseFile(token.NewFileSet(), "", pkgSrc, parser.ImportsOnly) + if err != nil { + t.Error(err) + continue + } + if len(f.Imports) != 1 { + t.Errorf("Got %d imports, expected 1", len(f.Imports)) + continue + } + + got, err := importName(f.Imports[0]) + if err != nil { + t.Fatal(err) + } + if got != c.ident { + t.Errorf("Got %q, expected %q", got, c.ident) + } + } + }) + + t.Run("filterImports", func(t *testing.T) { + cases := []struct{ before, after string }{ + {`package test + + import ( + "foo" + "bar" + )`, + "package test\n"}, + {`package test + + import ( + "foo" + "bar" + ) + + func useFoo() { foo.Usage() }`, + `package test + +import ( + "foo" +) + +func useFoo() { foo.Usage() } +`}, + } + for _, c := range cases { + got, err := filterImports([]byte(c.before)) + if err != nil { + t.Error(err) + } + + if string(got) != c.after { + t.Errorf("Got:\n%s\nExpected:\n%s\n", got, c.after) + } + } + }) +} + +func TestMerge(t *testing.T) { + // Input architecture files + inTmpl := template.Must(template.New("input").Parse(` +// Package comments + +// build directives for arch{{.}} + +//go:build goos && arch{{.}} +// +build goos,arch{{.}} + +package main + +/* +#include <stdint.h> +#include <stddef.h> +int utimes(uintptr_t, uintptr_t); +int utimensat(int, uintptr_t, uintptr_t, int); +*/ +import "C" + +// The imports +import ( + "commonDep" + "uniqueDep{{.}}" +) + +// Vars +var ( + commonVar = commonDep.Use("common") + + uniqueVar{{.}} = "unique{{.}}" +) + +// Common free standing comment + +// Common comment +const COMMON_INDEPENDENT = 1234 +const UNIQUE_INDEPENDENT_{{.}} = "UNIQUE_INDEPENDENT_{{.}}" + +// Group comment +const ( + COMMON_GROUP = "COMMON_GROUP" + UNIQUE_GROUP_{{.}} = "UNIQUE_GROUP_{{.}}" +) + +// Group2 comment +const ( + UNIQUE_GROUP21_{{.}} = "UNIQUE_GROUP21_{{.}}" + UNIQUE_GROUP22_{{.}} = "UNIQUE_GROUP22_{{.}}" +) + +// Group3 comment +const ( + sub1Common1 = 11 + sub1Unique2{{.}} = 12 + sub1Common3_LONG = 13 + + sub2Unique1{{.}} = 21 + sub2Common2 = 22 + sub2Common3 = 23 + sub2Unique4{{.}} = 24 +) + +type commonInt int + +type uniqueInt{{.}} int + +func commonF() string { + return commonDep.Use("common") + } + +func uniqueF() string { + C.utimes(0, 0) + return uniqueDep{{.}}.Use("{{.}}") + } + +// Group4 comment +const ( + sub3Common1 = 31 + sub3Unique2{{.}} = 32 + sub3Unique3{{.}} = 33 + sub3Common4 = 34 + + sub4Common1, sub4Unique2{{.}} = 41, 42 + sub4Unique3{{.}}, sub4Common4 = 43, 44 +) +`)) + + // Filtered architecture files + outTmpl := template.Must(template.New("output").Parse(`// Package comments + +// build directives for arch{{.}} + +//go:build goos && arch{{.}} +// +build goos,arch{{.}} + +package main + +/* +#include <stdint.h> +#include <stddef.h> +int utimes(uintptr_t, uintptr_t); +int utimensat(int, uintptr_t, uintptr_t, int); +*/ +import "C" + +// The imports +import ( + "commonDep" + "uniqueDep{{.}}" +) + +// Vars +var ( + commonVar = commonDep.Use("common") + + uniqueVar{{.}} = "unique{{.}}" +) + +const UNIQUE_INDEPENDENT_{{.}} = "UNIQUE_INDEPENDENT_{{.}}" + +// Group comment +const ( + UNIQUE_GROUP_{{.}} = "UNIQUE_GROUP_{{.}}" +) + +// Group2 comment +const ( + UNIQUE_GROUP21_{{.}} = "UNIQUE_GROUP21_{{.}}" + UNIQUE_GROUP22_{{.}} = "UNIQUE_GROUP22_{{.}}" +) + +// Group3 comment +const ( + sub1Unique2{{.}} = 12 + + sub2Unique1{{.}} = 21 + sub2Unique4{{.}} = 24 +) + +type uniqueInt{{.}} int + +func uniqueF() string { + C.utimes(0, 0) + return uniqueDep{{.}}.Use("{{.}}") +} + +// Group4 comment +const ( + sub3Unique2{{.}} = 32 + sub3Unique3{{.}} = 33 + + sub4Common1, sub4Unique2{{.}} = 41, 42 + sub4Unique3{{.}}, sub4Common4 = 43, 44 +) +`)) + + const mergedFile = `// Package comments + +package main + +// The imports +import ( + "commonDep" +) + +// Common free standing comment + +// Common comment +const COMMON_INDEPENDENT = 1234 + +// Group comment +const ( + COMMON_GROUP = "COMMON_GROUP" +) + +// Group3 comment +const ( + sub1Common1 = 11 + sub1Common3_LONG = 13 + + sub2Common2 = 22 + sub2Common3 = 23 +) + +type commonInt int + +func commonF() string { + return commonDep.Use("common") +} + +// Group4 comment +const ( + sub3Common1 = 31 + sub3Common4 = 34 +) +` + + // Generate source code for different "architectures" + var inFiles, outFiles []srcFile + for _, arch := range strings.Fields("A B C D") { + buf := new(bytes.Buffer) + err := inTmpl.Execute(buf, arch) + if err != nil { + t.Fatal(err) + } + inFiles = append(inFiles, srcFile{"file" + arch, buf.Bytes()}) + + buf = new(bytes.Buffer) + err = outTmpl.Execute(buf, arch) + if err != nil { + t.Fatal(err) + } + outFiles = append(outFiles, srcFile{"file" + arch, buf.Bytes()}) + } + + t.Run("getCodeSet", func(t *testing.T) { + got, err := getCodeSet(inFiles[0].src) + if err != nil { + t.Fatal(err) + } + + expectedElems := []codeElem{ + {token.COMMENT, "Package comments\n"}, + {token.COMMENT, "build directives for archA\n"}, + {token.COMMENT, "+build goos,archA\n"}, + {token.CONST, `COMMON_INDEPENDENT = 1234`}, + {token.CONST, `UNIQUE_INDEPENDENT_A = "UNIQUE_INDEPENDENT_A"`}, + {token.CONST, `COMMON_GROUP = "COMMON_GROUP"`}, + {token.CONST, `UNIQUE_GROUP_A = "UNIQUE_GROUP_A"`}, + {token.CONST, `UNIQUE_GROUP21_A = "UNIQUE_GROUP21_A"`}, + {token.CONST, `UNIQUE_GROUP22_A = "UNIQUE_GROUP22_A"`}, + {token.CONST, `sub1Common1 = 11`}, + {token.CONST, `sub1Unique2A = 12`}, + {token.CONST, `sub1Common3_LONG = 13`}, + {token.CONST, `sub2Unique1A = 21`}, + {token.CONST, `sub2Common2 = 22`}, + {token.CONST, `sub2Common3 = 23`}, + {token.CONST, `sub2Unique4A = 24`}, + {token.CONST, `sub3Common1 = 31`}, + {token.CONST, `sub3Unique2A = 32`}, + {token.CONST, `sub3Unique3A = 33`}, + {token.CONST, `sub3Common4 = 34`}, + {token.CONST, `sub4Common1, sub4Unique2A = 41, 42`}, + {token.CONST, `sub4Unique3A, sub4Common4 = 43, 44`}, + {token.TYPE, `commonInt int`}, + {token.TYPE, `uniqueIntA int`}, + {token.FUNC, `func commonF() string { + return commonDep.Use("common") +}`}, + {token.FUNC, `func uniqueF() string { + C.utimes(0, 0) + return uniqueDepA.Use("A") +}`}, + } + expected := newCodeSet() + for _, d := range expectedElems { + expected.add(d) + } + + if len(got.set) != len(expected.set) { + t.Errorf("Got %d codeElems, expected %d", len(got.set), len(expected.set)) + } + for expElem := range expected.set { + if !got.has(expElem) { + t.Errorf("Didn't get expected codeElem %#v", expElem) + } + } + for gotElem := range got.set { + if !expected.has(gotElem) { + t.Errorf("Got unexpected codeElem %#v", gotElem) + } + } + }) + + t.Run("getCommonSet", func(t *testing.T) { + got, err := getCommonSet(inFiles) + if err != nil { + t.Fatal(err) + } + + expected := newCodeSet() + expected.add(codeElem{token.COMMENT, "Package comments\n"}) + expected.add(codeElem{token.CONST, `COMMON_INDEPENDENT = 1234`}) + expected.add(codeElem{token.CONST, `COMMON_GROUP = "COMMON_GROUP"`}) + expected.add(codeElem{token.CONST, `sub1Common1 = 11`}) + expected.add(codeElem{token.CONST, `sub1Common3_LONG = 13`}) + expected.add(codeElem{token.CONST, `sub2Common2 = 22`}) + expected.add(codeElem{token.CONST, `sub2Common3 = 23`}) + expected.add(codeElem{token.CONST, `sub3Common1 = 31`}) + expected.add(codeElem{token.CONST, `sub3Common4 = 34`}) + expected.add(codeElem{token.TYPE, `commonInt int`}) + expected.add(codeElem{token.FUNC, `func commonF() string { + return commonDep.Use("common") +}`}) + + if len(got.set) != len(expected.set) { + t.Errorf("Got %d codeElems, expected %d", len(got.set), len(expected.set)) + } + for expElem := range expected.set { + if !got.has(expElem) { + t.Errorf("Didn't get expected codeElem %#v", expElem) + } + } + for gotElem := range got.set { + if !expected.has(gotElem) { + t.Errorf("Got unexpected codeElem %#v", gotElem) + } + } + }) + + t.Run("filter(keepCommon)", func(t *testing.T) { + commonSet, err := getCommonSet(inFiles) + if err != nil { + t.Fatal(err) + } + + got, err := filter(inFiles[0].src, commonSet.keepCommon) + if err != nil { + t.Fatal(err) + } + + expected := []byte(mergedFile) + + if !bytes.Equal(got, expected) { + t.Errorf("Got:\n%s\nExpected:\n%s", addLineNr(got), addLineNr(expected)) + diffLines(t, got, expected) + } + }) + + t.Run("filter(keepArchSpecific)", func(t *testing.T) { + commonSet, err := getCommonSet(inFiles) + if err != nil { + t.Fatal(err) + } + + for i := range inFiles { + got, err := filter(inFiles[i].src, commonSet.keepArchSpecific) + if err != nil { + t.Fatal(err) + } + + expected := outFiles[i].src + + if !bytes.Equal(got, expected) { + t.Errorf("Got:\n%s\nExpected:\n%s", addLineNr(got), addLineNr(expected)) + diffLines(t, got, expected) + } + } + }) +} + +func TestMergedName(t *testing.T) { + t.Run("getValidGOOS", func(t *testing.T) { + testcases := []struct { + filename, goos string + ok bool + }{ + {"zerrors_aix.go", "aix", true}, + {"zerrors_darwin.go", "darwin", true}, + {"zerrors_dragonfly.go", "dragonfly", true}, + {"zerrors_freebsd.go", "freebsd", true}, + {"zerrors_linux.go", "linux", true}, + {"zerrors_netbsd.go", "netbsd", true}, + {"zerrors_openbsd.go", "openbsd", true}, + {"zerrors_solaris.go", "solaris", true}, + {"zerrors_multics.go", "", false}, + } + for _, tc := range testcases { + goos, ok := getValidGOOS(tc.filename) + if goos != tc.goos { + t.Errorf("got GOOS %q, expected %q", goos, tc.goos) + } + if ok != tc.ok { + t.Errorf("got ok %v, expected %v", ok, tc.ok) + } + } + }) +} + +// Helper functions to diff test sources + +func diffLines(t *testing.T, got, expected []byte) { + t.Helper() + + gotLines := bytes.Split(got, []byte{'\n'}) + expLines := bytes.Split(expected, []byte{'\n'}) + + i := 0 + for i < len(gotLines) && i < len(expLines) { + if !bytes.Equal(gotLines[i], expLines[i]) { + t.Errorf("Line %d: Got:\n%q\nExpected:\n%q", i+1, gotLines[i], expLines[i]) + return + } + i++ + } + + if i < len(gotLines) && i >= len(expLines) { + t.Errorf("Line %d: got %q, expected EOF", i+1, gotLines[i]) + } + if i >= len(gotLines) && i < len(expLines) { + t.Errorf("Line %d: got EOF, expected %q", i+1, gotLines[i]) + } +} + +func addLineNr(src []byte) []byte { + lines := bytes.Split(src, []byte("\n")) + for i, line := range lines { + lines[i] = []byte(fmt.Sprintf("%d: %s", i+1, line)) + } + return bytes.Join(lines, []byte("\n")) +} |