Merge "Add TestProperties, gen test config, fix names"

am: 8d7ae1aefe

Change-Id: Idfc40a76b49026615596cc6c43982dbb409f2490

rust/androidmk.go

@@ -87,9 +87,23 @@ func (binary *binaryDecorator) AndroidMk(ctx AndroidMkContext, ret *android.Andr
 	})
 }
 
-func (test *testBinaryDecorator) AndroidMk(ctx AndroidMkContext, ret *android.AndroidMkData) {
+func (test *testDecorator) AndroidMk(ctx AndroidMkContext, ret *android.AndroidMkData) {
 	test.binaryDecorator.AndroidMk(ctx, ret)
-	ret.SubName = "_" + String(test.baseCompiler.Properties.Stem)
+	stem := String(test.baseCompiler.Properties.Stem)
+	if stem != "" && !strings.HasSuffix(ctx.Name(), "_"+stem) {
+		// Avoid repeated suffix in the module name.
+		ret.SubName = "_" + stem
+	}
+	ret.Extra = append(ret.Extra, func(w io.Writer, outputFile android.Path) {
+		if len(test.Properties.Test_suites) > 0 {
+			fmt.Fprintln(w, "LOCAL_COMPATIBILITY_SUITE :=",
+				strings.Join(test.Properties.Test_suites, " "))
+		}
+		if test.testConfig != nil {
+			fmt.Fprintln(w, "LOCAL_FULL_TEST_CONFIG :=", test.testConfig.String())
+		}
+	})
+	// TODO(chh): add test data with androidMkWriteTestData(test.data, ctx, ret)
 }
 
 func (library *libraryDecorator) AndroidMk(ctx AndroidMkContext, ret *android.AndroidMkData) {

rust/rust.go

@@ -218,6 +218,7 @@ func DefaultsFactory(props ...interface{}) android.Module {
 		&LibraryCompilerProperties{},
 		&ProcMacroCompilerProperties{},
 		&PrebuiltProperties{},
+		&TestProperties{},
 	)
 
 	android.InitDefaultsModule(module)

rust/test.go

@@ -19,19 +19,41 @@ import (
 	"strings"
 
 	"android/soong/android"
+	"android/soong/tradefed"
 )
 
+type TestProperties struct {
+	// the name of the test configuration (for example "AndroidTest.xml") that should be
+	// installed with the module.
+	Test_config *string `android:"arch_variant"`
+
+	// the name of the test configuration template (for example "AndroidTestTemplate.xml") that
+	// should be installed with the module.
+	Test_config_template *string `android:"arch_variant"`
+
+	// list of compatibility suites (for example "cts", "vts") that the module should be
+	// installed into.
+	Test_suites []string `android:"arch_variant"`
+
+	// Flag to indicate whether or not to create test config automatically. If AndroidTest.xml
+	// doesn't exist next to the Android.bp, this attribute doesn't need to be set to true
+	// explicitly.
+	Auto_gen_config *bool
+}
+
 // A test module is a binary module with extra --test compiler flag
 // and different default installation directory.
 // In golang, inheriance is written as a component.
-type testBinaryDecorator struct {
+type testDecorator struct {
 	*binaryDecorator
+	Properties TestProperties
+	testConfig android.Path
 }
 
-func NewRustTest(hod android.HostOrDeviceSupported) (*Module, *testBinaryDecorator) {
+func NewRustTest(hod android.HostOrDeviceSupported) (*Module, *testDecorator) {
 	module := newModule(hod, android.MultilibFirst)
 
-	test := &testBinaryDecorator{
+	test := &testDecorator{
 		binaryDecorator: &binaryDecorator{
 			// TODO(chh): set up dir64?
 			baseCompiler: NewBaseCompiler("testcases", ""),
@@ -43,7 +65,27 @@ func NewRustTest(hod android.HostOrDeviceSupported) (*Module, *testBinaryDecorat
 	return module, test
 }
 
-func (test *testBinaryDecorator) compilerFlags(ctx ModuleContext, flags Flags) Flags {
+func (test *testDecorator) compilerProps() []interface{} {
+	return append(test.binaryDecorator.compilerProps(), &test.Properties)
+}
+
+func (test *testDecorator) install(ctx ModuleContext, file android.Path) {
+	name := ctx.ModuleName() // default executable name
+	if stem := String(test.baseCompiler.Properties.Stem); stem != "" {
+		name = stem
+	}
+	if path := test.baseCompiler.relativeInstallPath(); path != "" {
+		name = path + "/" + name
+	}
+	test.testConfig = tradefed.AutoGenRustHostTestConfig(ctx, name,
+		test.Properties.Test_config,
+		test.Properties.Test_config_template,
+		test.Properties.Test_suites,
+		test.Properties.Auto_gen_config)
+	test.binaryDecorator.install(ctx, file)
+}
+
+func (test *testDecorator) compilerFlags(ctx ModuleContext, flags Flags) Flags {
 	flags = test.binaryDecorator.compilerFlags(ctx, flags)
 	flags.RustFlags = append(flags.RustFlags, "--test")
 	return flags
@@ -65,21 +107,21 @@ func RustTestHostFactory() android.Module {
 	return module.Init()
 }
 
-func (test *testBinaryDecorator) testPerSrc() bool {
+func (test *testDecorator) testPerSrc() bool {
 	return true
 }
 
-func (test *testBinaryDecorator) srcs() []string {
-	return test.Properties.Srcs
+func (test *testDecorator) srcs() []string {
+	return test.binaryDecorator.Properties.Srcs
 }
 
-func (test *testBinaryDecorator) setSrc(name, src string) {
-	test.Properties.Srcs = []string{src}
+func (test *testDecorator) setSrc(name, src string) {
+	test.binaryDecorator.Properties.Srcs = []string{src}
 	test.baseCompiler.Properties.Stem = StringPtr(name)
 }
 
-func (test *testBinaryDecorator) unsetSrc() {
-	test.Properties.Srcs = nil
+func (test *testDecorator) unsetSrc() {
+	test.binaryDecorator.Properties.Srcs = nil
 	test.baseCompiler.Properties.Stem = StringPtr("")
 }
 
@@ -90,7 +132,7 @@ type testPerSrc interface {
 	unsetSrc()
 }
 
-var _ testPerSrc = (*testBinaryDecorator)(nil)
+var _ testPerSrc = (*testDecorator)(nil)
 
 func TestPerSrcMutator(mctx android.BottomUpMutatorContext) {
 	if m, ok := mctx.Module().(*Module); ok {
@@ -101,10 +143,21 @@ func TestPerSrcMutator(mctx android.BottomUpMutatorContext) {
 					mctx.PropertyErrorf("srcs", "found a duplicate entry %q", duplicate)
 					return
 				}
+				// Rust compiler always compiles one source file at a time and
+				// uses the crate name as output file name.
+				// Cargo uses the test source file name as default crate name,
+				// but that can be redefined.
+				// So when there are multiple source files, the source file names will
+				// be the output file names, but when there is only one test file,
+				// use the crate name.
 				testNames := make([]string, numTests)
 				for i, src := range test.srcs() {
 					testNames[i] = strings.TrimSuffix(filepath.Base(src), filepath.Ext(src))
 				}
+				crateName := m.compiler.crateName()
+				if numTests == 1 && crateName != "" {
+					testNames[0] = crateName
+				}
 				// TODO(chh): Add an "all tests" variation like cc/test.go?
 				tests := mctx.CreateLocalVariations(testNames...)
 				for i, src := range test.srcs() {

rust/test_test.go

@@ -25,6 +25,7 @@ func TestRustTest(t *testing.T) {
 		rust_test_host {
 			name: "my_test",
 			srcs: ["foo.rs", "src/bar.rs"],
+			crate_name: "new_test", // not used for multiple source files
 			relative_install_path: "rust/my-test",
 		}`)
 
@@ -41,3 +42,22 @@ func TestRustTest(t *testing.T) {
 		}
 	}
 }
+
+// crate_name is output file name, when there is only one source file.
+func TestRustTestSingleFile(t *testing.T) {
+	ctx := testRust(t, `
+		rust_test_host {
+			name: "my-test",
+			srcs: ["foo.rs"],
+			crate_name: "new_test",
+			relative_install_path: "my-pkg",
+		}`)
+
+	name := "new_test"
+	testingModule := ctx.ModuleForTests("my-test", "linux_glibc_x86_64_"+name)
+	outPath := "/my-test/linux_glibc_x86_64_" + name + "/" + name
+	testingBuildParams := testingModule.Output(name)
+	if !strings.Contains(testingBuildParams.Output.String(), outPath) {
+		t.Errorf("wrong output: %v  expect: %v", testingBuildParams.Output, outPath)
+	}
+}

tradefed/autogen.go

@@ -105,6 +105,10 @@ func (ob Object) Config() string {
 }
 
 func autogenTemplate(ctx android.ModuleContext, output android.WritablePath, template string, configs []Config) {
+	autogenTemplateWithName(ctx, ctx.ModuleName(), output, template, configs)
+}
+
+func autogenTemplateWithName(ctx android.ModuleContext, name string, output android.WritablePath, template string, configs []Config) {
 	var configStrings []string
 	for _, config := range configs {
 		configStrings = append(configStrings, config.Config())
@@ -117,7 +121,7 @@ func autogenTemplate(ctx android.ModuleContext, output android.WritablePath, tem
 		Description: "test config",
 		Output:      output,
 		Args: map[string]string{
-			"name":         ctx.ModuleName(),
+			"name":         name,
 			"template":     template,
 			"extraConfigs": extraConfigs,
 		},
@@ -193,6 +197,21 @@ func AutoGenPythonBinaryHostTestConfig(ctx android.ModuleContext, testConfigProp
 	return path
 }
 
+func AutoGenRustHostTestConfig(ctx android.ModuleContext, name string, testConfigProp *string,
+	testConfigTemplateProp *string, testSuites []string, autoGenConfig *bool) android.Path {
+	path, autogenPath := testConfigPath(ctx, testConfigProp, testSuites, autoGenConfig)
+	if autogenPath != nil {
+		templatePathString := "${RustHostTestConfigTemplate}"
+		templatePath := getTestConfigTemplate(ctx, testConfigTemplateProp)
+		if templatePath.Valid() {
+			templatePathString = templatePath.String()
+		}
+		autogenTemplateWithName(ctx, name, autogenPath, templatePathString, nil)
+		return autogenPath
+	}
+	return path
+}
+
 var autogenInstrumentationTest = pctx.StaticRule("autogenInstrumentationTest", blueprint.RuleParams{
 	Command: "${AutoGenTestConfigScript} $out $in ${EmptyTestConfig} $template",
 	CommandDeps: []string{

tradefed/config.go

@@ -31,6 +31,7 @@ func init() {
 	pctx.SourcePathVariable("NativeHostTestConfigTemplate", "build/make/core/native_host_test_config_template.xml")
 	pctx.SourcePathVariable("NativeTestConfigTemplate", "build/make/core/native_test_config_template.xml")
 	pctx.SourcePathVariable("PythonBinaryHostTestConfigTemplate", "build/make/core/python_binary_host_test_config_template.xml")
+	pctx.SourcePathVariable("RustHostTestConfigTemplate", "build/make/core/rust_host_test_config_template.xml")
 
 	pctx.SourcePathVariable("EmptyTestConfig", "build/make/core/empty_test_config.xml")
 }

tradefed/makevars.go

@@ -31,6 +31,7 @@ func makeVarsProvider(ctx android.MakeVarsContext) {
 	ctx.Strict("NATIVE_HOST_TEST_CONFIG_TEMPLATE", "${NativeHostTestConfigTemplate}")
 	ctx.Strict("NATIVE_TEST_CONFIG_TEMPLATE", "${NativeTestConfigTemplate}")
 	ctx.Strict("PYTHON_BINARY_HOST_TEST_CONFIG_TEMPLATE", "${PythonBinaryHostTestConfigTemplate}")
+	ctx.Strict("RUST_HOST_TEST_CONFIG_TEMPLATE", "${RustHostTestConfigTemplate}")
 
 	ctx.Strict("EMPTY_TEST_CONFIG", "${EmptyTestConfig}")
 }