Golang程序
|
445行
|
10.96 KB
// 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 python
import (
"errors"
"fmt"
"io/ioutil"
"os"
"path/filepath"
"reflect"
"sort"
"strings"
"testing"
"android/soong/android"
)
type pyModule struct {
name string
actualVersion string
pyRunfiles []string
srcsZip string
depsSrcsZips []string
}
var (
buildNamePrefix = "soong_python_test"
moduleVariantErrTemplate = "%s: module %q variant %q: "
pkgPathErrTemplate = moduleVariantErrTemplate +
"pkg_path: %q must be a relative path contained in par file."
badIdentifierErrTemplate = moduleVariantErrTemplate +
"srcs: the path %q contains invalid token %q."
dupRunfileErrTemplate = moduleVariantErrTemplate +
"found two files to be placed at the same location within zip %q." +
" First file: in module %s at path %q." +
" Second file: in module %s at path %q."
noSrcFileErr = moduleVariantErrTemplate + "doesn't have any source files!"
badSrcFileExtErr = moduleVariantErrTemplate + "srcs: found non (.py|.proto) file: %q!"
badDataFileExtErr = moduleVariantErrTemplate + "data: found (.py|.proto) file: %q!"
bpFile = "Blueprints"
data = []struct {
desc string
mockFiles map[string][]byte
errors []string
expectedBinaries []pyModule
}{
{
desc: "module without any src files",
mockFiles: map[string][]byte{
bpFile: []byte(`subdirs = ["dir"]`),
filepath.Join("dir", bpFile): []byte(
`python_library_host {
name: "lib1",
}`,
),
},
errors: []string{
fmt.Sprintf(noSrcFileErr,
"dir/Blueprints:1:1", "lib1", "PY3"),
},
},
{
desc: "module with bad src file ext",
mockFiles: map[string][]byte{
bpFile: []byte(`subdirs = ["dir"]`),
filepath.Join("dir", bpFile): []byte(
`python_library_host {
name: "lib1",
srcs: [
"file1.exe",
],
}`,
),
"dir/file1.exe": nil,
},
errors: []string{
fmt.Sprintf(badSrcFileExtErr,
"dir/Blueprints:3:11", "lib1", "PY3", "dir/file1.exe"),
},
},
{
desc: "module with bad data file ext",
mockFiles: map[string][]byte{
bpFile: []byte(`subdirs = ["dir"]`),
filepath.Join("dir", bpFile): []byte(
`python_library_host {
name: "lib1",
srcs: [
"file1.py",
],
data: [
"file2.py",
],
}`,
),
"dir/file1.py": nil,
"dir/file2.py": nil,
},
errors: []string{
fmt.Sprintf(badDataFileExtErr,
"dir/Blueprints:6:11", "lib1", "PY3", "dir/file2.py"),
},
},
{
desc: "module with bad pkg_path format",
mockFiles: map[string][]byte{
bpFile: []byte(`subdirs = ["dir"]`),
filepath.Join("dir", bpFile): []byte(
`python_library_host {
name: "lib1",
pkg_path: "a/c/../../",
srcs: [
"file1.py",
],
}
python_library_host {
name: "lib2",
pkg_path: "a/c/../../../",
srcs: [
"file1.py",
],
}
python_library_host {
name: "lib3",
pkg_path: "/a/c/../../",
srcs: [
"file1.py",
],
}`,
),
"dir/file1.py": nil,
},
errors: []string{
fmt.Sprintf(pkgPathErrTemplate,
"dir/Blueprints:11:15", "lib2", "PY3", "a/c/../../../"),
fmt.Sprintf(pkgPathErrTemplate,
"dir/Blueprints:19:15", "lib3", "PY3", "/a/c/../../"),
},
},
{
desc: "module with bad runfile src path format",
mockFiles: map[string][]byte{
bpFile: []byte(`subdirs = ["dir"]`),
filepath.Join("dir", bpFile): []byte(
`python_library_host {
name: "lib1",
pkg_path: "a/b/c/",
srcs: [
".file1.py",
"123/file1.py",
"-e/f/file1.py",
],
}`,
),
"dir/.file1.py": nil,
"dir/123/file1.py": nil,
"dir/-e/f/file1.py": nil,
},
errors: []string{
fmt.Sprintf(badIdentifierErrTemplate, "dir/Blueprints:4:11",
"lib1", "PY3", "a/b/c/-e/f/file1.py", "-e"),
fmt.Sprintf(badIdentifierErrTemplate, "dir/Blueprints:4:11",
"lib1", "PY3", "a/b/c/.file1.py", ".file1"),
fmt.Sprintf(badIdentifierErrTemplate, "dir/Blueprints:4:11",
"lib1", "PY3", "a/b/c/123/file1.py", "123"),
},
},
{
desc: "module with duplicate runfile path",
mockFiles: map[string][]byte{
bpFile: []byte(`subdirs = ["dir"]`),
filepath.Join("dir", bpFile): []byte(
`python_library_host {
name: "lib1",
pkg_path: "a/b/",
srcs: [
"c/file1.py",
],
}
python_library_host {
name: "lib2",
pkg_path: "a/b/c/",
srcs: [
"file1.py",
],
libs: [
"lib1",
],
}
`,
),
"dir/c/file1.py": nil,
"dir/file1.py": nil,
},
errors: []string{
fmt.Sprintf(dupRunfileErrTemplate, "dir/Blueprints:9:6",
"lib2", "PY3", "a/b/c/file1.py", "lib2", "dir/file1.py",
"lib1", "dir/c/file1.py"),
},
},
{
desc: "module for testing dependencies",
mockFiles: map[string][]byte{
bpFile: []byte(`subdirs = ["dir"]`),
filepath.Join("dir", bpFile): []byte(
`python_defaults {
name: "default_lib",
srcs: [
"default.py",
],
version: {
py2: {
enabled: true,
srcs: [
"default_py2.py",
],
},
py3: {
enabled: false,
srcs: [
"default_py3.py",
],
},
},
}
python_library_host {
name: "lib5",
pkg_path: "a/b/",
srcs: [
"file1.py",
],
version: {
py2: {
enabled: true,
},
py3: {
enabled: true,
},
},
}
python_library_host {
name: "lib6",
pkg_path: "c/d/",
srcs: [
"file2.py",
],
libs: [
"lib5",
],
}
python_binary_host {
name: "bin",
defaults: ["default_lib"],
pkg_path: "e/",
srcs: [
"bin.py",
],
libs: [
"lib5",
],
version: {
py3: {
enabled: true,
srcs: [
"file4.py",
],
libs: [
"lib6",
],
},
},
}`,
),
filepath.Join("dir", "default.py"): nil,
filepath.Join("dir", "default_py2.py"): nil,
filepath.Join("dir", "default_py3.py"): nil,
filepath.Join("dir", "file1.py"): nil,
filepath.Join("dir", "file2.py"): nil,
filepath.Join("dir", "bin.py"): nil,
filepath.Join("dir", "file4.py"): nil,
stubTemplateHost: []byte(`PYTHON_BINARY = '%interpreter%'
MAIN_FILE = '%main%'`),
},
expectedBinaries: []pyModule{
{
name: "bin",
actualVersion: "PY3",
pyRunfiles: []string{
"e/default.py",
"e/bin.py",
"e/default_py3.py",
"e/file4.py",
},
srcsZip: "@prefix@/.intermediates/dir/bin/PY3/bin.py.srcszip",
depsSrcsZips: []string{
"@prefix@/.intermediates/dir/lib5/PY3/lib5.py.srcszip",
"@prefix@/.intermediates/dir/lib6/PY3/lib6.py.srcszip",
},
},
},
},
}
)
func TestPythonModule(t *testing.T) {
config, buildDir := setupBuildEnv(t)
defer tearDownBuildEnv(buildDir)
for _, d := range data {
t.Run(d.desc, func(t *testing.T) {
ctx := android.NewTestContext()
ctx.PreDepsMutators(func(ctx android.RegisterMutatorsContext) {
ctx.BottomUp("version_split", versionSplitMutator()).Parallel()
})
ctx.RegisterModuleType("python_library_host",
android.ModuleFactoryAdaptor(PythonLibraryHostFactory))
ctx.RegisterModuleType("python_binary_host",
android.ModuleFactoryAdaptor(PythonBinaryHostFactory))
ctx.RegisterModuleType("python_defaults",
android.ModuleFactoryAdaptor(defaultsFactory))
ctx.PreArchMutators(android.RegisterDefaultsPreArchMutators)
ctx.Register()
ctx.MockFileSystem(d.mockFiles)
_, testErrs := ctx.ParseBlueprintsFiles(bpFile)
android.FailIfErrored(t, testErrs)
_, actErrs := ctx.PrepareBuildActions(config)
if len(actErrs) > 0 {
testErrs = append(testErrs, expectErrors(t, actErrs, d.errors)...)
} else {
for _, e := range d.expectedBinaries {
testErrs = append(testErrs,
expectModule(t, ctx, buildDir, e.name,
e.actualVersion,
e.srcsZip,
e.pyRunfiles,
e.depsSrcsZips)...)
}
}
android.FailIfErrored(t, testErrs)
})
}
}
func expectErrors(t *testing.T, actErrs []error, expErrs []string) (testErrs []error) {
actErrStrs := []string{}
for _, v := range actErrs {
actErrStrs = append(actErrStrs, v.Error())
}
sort.Strings(actErrStrs)
if len(actErrStrs) != len(expErrs) {
t.Errorf("got (%d) errors, expected (%d) errors!", len(actErrStrs), len(expErrs))
for _, v := range actErrStrs {
testErrs = append(testErrs, errors.New(v))
}
} else {
sort.Strings(expErrs)
for i, v := range actErrStrs {
if v != expErrs[i] {
testErrs = append(testErrs, errors.New(v))
}
}
}
return
}
func expectModule(t *testing.T, ctx *android.TestContext, buildDir, name, variant, expectedSrcsZip string,
expectedPyRunfiles, expectedDepsSrcsZips []string) (testErrs []error) {
module := ctx.ModuleForTests(name, variant)
base, baseOk := module.Module().(*Module)
if !baseOk {
t.Fatalf("%s is not Python module!", name)
}
actualPyRunfiles := []string{}
for _, path := range base.srcsPathMappings {
actualPyRunfiles = append(actualPyRunfiles, path.dest)
}
if !reflect.DeepEqual(actualPyRunfiles, expectedPyRunfiles) {
testErrs = append(testErrs, errors.New(fmt.Sprintf(
`binary "%s" variant "%s" has unexpected pyRunfiles: %q!`,
base.Name(),
base.properties.Actual_version,
actualPyRunfiles)))
}
if base.srcsZip.String() != strings.Replace(expectedSrcsZip, "@prefix@", buildDir, 1) {
testErrs = append(testErrs, errors.New(fmt.Sprintf(
`binary "%s" variant "%s" has unexpected srcsZip: %q!`,
base.Name(),
base.properties.Actual_version,
base.srcsZip)))
}
for i, _ := range expectedDepsSrcsZips {
expectedDepsSrcsZips[i] = strings.Replace(expectedDepsSrcsZips[i], "@prefix@", buildDir, 1)
}
if !reflect.DeepEqual(base.depsSrcsZips.Strings(), expectedDepsSrcsZips) {
testErrs = append(testErrs, errors.New(fmt.Sprintf(
`binary "%s" variant "%s" has unexpected depsSrcsZips: %q!`,
base.Name(),
base.properties.Actual_version,
base.depsSrcsZips)))
}
return
}
func setupBuildEnv(t *testing.T) (config android.Config, buildDir string) {
buildDir, err := ioutil.TempDir("", buildNamePrefix)
if err != nil {
t.Fatal(err)
}
config = android.TestConfig(buildDir, nil)
return
}
func tearDownBuildEnv(buildDir string) {
os.RemoveAll(buildDir)
}