Quelle  sh_binary.go   Sprache: unbekannt

// Copyright 2019 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 sh

import (
 "fmt"
 "path/filepath"
 "strings"

 "github.com/google/blueprint"
 "github.com/google/blueprint/proptools"

 "android/soong/android"
 "android/soong/cc"
 "android/soong/tradefed"
)

//go:generate go run ../../blueprint/gobtools/codegen

// sh_binary is for shell scripts (and batch files) that are installed as
// executable files into .../bin/
//
// Do not use them for prebuilt C/C++/etc files.  Use cc_prebuilt_binary
// instead.

var pctx = android.NewPackageContext("android/soong/sh")

func init() {
 pctx.Import("android/soong/android")

 registerShBuildComponents(android.InitRegistrationContext)
}

// @auto-generate: gob
type ShBinaryInfo struct {
 SubDir     string
 OutputFile android.Path
 Symlinks   []string
}

var ShBinaryInfoProvider = blueprint.NewProvider[ShBinaryInfo]()

func registerShBuildComponents(ctx android.RegistrationContext) {
 ctx.RegisterModuleType("sh_binary", ShBinaryFactory)
 ctx.RegisterModuleType("sh_binary_host", ShBinaryHostFactory)
 ctx.RegisterModuleType("sh_test", ShTestFactory)
 ctx.RegisterModuleType("sh_test_host", ShTestHostFactory)
 ctx.RegisterModuleType("sh_defaults", ShDefaultsFactory)
}

// Test fixture preparer that will register most sh build components.
//
// Singletons and mutators should only be added here if they are needed for a majority of sh
// module types, otherwise they should be added under a separate preparer to allow them to be
// selected only when needed to reduce test execution time.
//
// Module types do not have much of an overhead unless they are used so this should include as many
// module types as possible. The exceptions are those module types that require mutators and/or
// singletons in order to function in which case they should be kept together in a separate
// preparer.
var PrepareForTestWithShBuildComponents = android.GroupFixturePreparers(
 android.FixtureRegisterWithContext(registerShBuildComponents),
)

type shBinaryProperties struct {
 // Source file of this prebuilt.
 Src proptools.Configurable[string] `android:"path,arch_variant,replace_instead_of_append"`

 // optional subdirectory under which this file is installed into
 Sub_dir *string `android:"arch_variant"`

 // optional name for the installed file. If unspecified, name of the module is used as the file name
 Filename *string `android:"arch_variant"`

 // when set to true, and filename property is not set, the name for the installed file
 // is the same as the file name of the source file.
 Filename_from_src *bool `android:"arch_variant"`

 // Whether this module is directly installable to one of the partitions. Default: true.
 Installable *bool

 // install symlinks to the binary
 Symlinks []string `android:"arch_variant"`

 // Make this module available when building for ramdisk.
 // On device without a dedicated recovery partition, the module is only
 // available after switching root into
 // /first_stage_ramdisk. To expose the module before switching root, install
 // the recovery variant instead.
 Ramdisk_available *bool

 // Make this module available when building for vendor ramdisk.
 // On device without a dedicated recovery partition, the module is only
 // available after switching root into
 // /first_stage_ramdisk. To expose the module before switching root, install
 // the recovery variant instead.
 Vendor_ramdisk_available *bool

 // Make this module available when building for recovery.
 Recovery_available *bool

 // The name of the image this module is built for
 ImageVariation string `blueprint:"mutated"`

 // Suffix for the name of Android.mk entries generated by this module
 SubName string `blueprint:"mutated"`
}

type TestProperties struct {
 // list of compatibility suites (for example "cts", "vts") that the module should be
 // installed into.
 Test_suites []string `android:"arch_variant"`

 // the name of the test configuration (for example "AndroidTest.xml") that should be
 // installed with the module.
 Test_config proptools.Configurable[string] `android:"path,arch_variant,replace_instead_of_append"`

 // list of files or filegroup modules that provide data that should be installed alongside
 // the test.
 Data []string `android:"path,arch_variant"`

 // same as data, but adds dependencies using the device's os variation and the common
 // architecture's variation. Can be used to add a module built for device to the data of a
 // host test.
 Device_common_data []string `android:"path_device_common"`

 // same as data, but adds dependencies using the device's os variation and the device's first
 // architecture's variation. Can be used to add a module built for device to the data of a
 // host test.
 Device_first_data []string `android:"path_device_first"`

 // Same as data, but will add dependencies on modules using the host's os variation and
 // the common arch variation. Useful for a device test that wants to depend on a host
 // module, for example to include a custom Tradefed test runner.
 Host_common_data []string `android:"path_host_common"`

 // Add RootTargetPreparer to auto generated test config. This guarantees the test to run
 // with root permission.
 Require_root *bool

 // the name of the test configuration template (for example "AndroidTestTemplate.xml") that
 // should be installed with the module.
 Test_config_template *string `android:"path,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

 // list of binary modules that should be installed alongside the test
 Data_bins []string `android:"path,arch_variant"`

 // list of library modules that should be installed alongside the test
 Data_libs []string `android:"path,arch_variant"`

 // list of device binary modules that should be installed alongside the test.
 // Only available for host sh_test modules.
 Data_device_bins []string `android:"path,arch_variant"`

 // list of device library modules that should be installed alongside the test.
 // Only available for host sh_test modules.
 Data_device_libs []string `android:"path,arch_variant"`

 // list of java modules that provide data that should be installed alongside the test.
 Java_data []string

 // Install the test into a folder named for the module in all test suites.
 Per_testcase_directory *bool

 // Test options.
 Test_options android.CommonTestOptions

 // a list of extra test configuration files that should be installed with the module.
 Extra_test_configs []string `android:"path,arch_variant"`
}

type ShBinary struct {
 android.ModuleBase
 android.DefaultableModuleBase

 properties shBinaryProperties

 sourceFilePath android.Path
 outputFilePath android.OutputPath
 installedFile  android.InstallPath
}

var _ android.HostToolProvider = (*ShBinary)(nil)

type ShTest struct {
 ShBinary

 testProperties TestProperties

 installDir android.InstallPath

 data             []android.DataPath
 testConfig       android.Path
 extraTestConfigs android.Paths

 dataModules map[string]android.Path
}

func (s *ShBinary) HostToolPath() android.OptionalPath {
 return android.OptionalPathForPath(s.installedFile)
}

func (s *ShBinary) DepsMutator(ctx android.BottomUpMutatorContext) {
}

func (s *ShBinary) OutputFile() android.Path {
 return s.outputFilePath
}

func (s *ShBinary) SubDir() string {
 return proptools.String(s.properties.Sub_dir)
}

func (s *ShBinary) RelativeInstallPath() string {
 return s.SubDir()
}
func (s *ShBinary) Installable() bool {
 return s.properties.Installable == nil || proptools.Bool(s.properties.Installable)
}

func (s *ShBinary) Symlinks() []string {
 return s.properties.Symlinks
}

var _ android.ImageInterface = (*ShBinary)(nil)

func (s *ShBinary) ImageMutatorBegin(ctx android.ImageInterfaceContext) {}

func (s *ShBinary) ImageMutatorSupported() bool { return true }

func (s *ShBinary) VendorVariantNeeded(ctx android.ImageInterfaceContext) bool {
 return s.InstallInVendor()
}

func (s *ShBinary) ProductVariantNeeded(ctx android.ImageInterfaceContext) bool {
 return s.InstallInProduct()
}

func (s *ShBinary) CoreVariantNeeded(ctx android.ImageInterfaceContext) bool {
 return !s.InstallInRecovery() && !s.InstallInRamdisk() && !s.InstallInVendorRamdisk() && !s.ModuleBase.InstallInVendor()
}

func (s *ShBinary) RamdiskVariantNeeded(ctx android.ImageInterfaceContext) bool {
 return proptools.Bool(s.properties.Ramdisk_available) || s.InstallInRamdisk()
}

func (s *ShBinary) VendorRamdiskVariantNeeded(ctx android.ImageInterfaceContext) bool {
 return proptools.Bool(s.properties.Vendor_ramdisk_available) || s.InstallInVendorRamdisk()
}

func (s *ShBinary) DebugRamdiskVariantNeeded(ctx android.ImageInterfaceContext) bool {
 return false
}

func (s *ShBinary) RecoveryVariantNeeded(ctx android.ImageInterfaceContext) bool {
 return proptools.Bool(s.properties.Recovery_available) || s.InstallInRecovery()
}

func (s *ShBinary) ExtraImageVariations(ctx android.ImageInterfaceContext) []string {
 return nil
}

func (s *ShBinary) SetImageVariation(ctx android.ImageInterfaceContext, variation string) {
 s.properties.ImageVariation = variation
}

// Overrides ModuleBase.InstallInRamdisk() so that the install rule respects
// Ramdisk_available property for ramdisk variant
func (s *ShBinary) InstallInRamdisk() bool {
 return s.ModuleBase.InstallInRamdisk() ||
  (proptools.Bool(s.properties.Ramdisk_available) && s.properties.ImageVariation == android.RamdiskVariation)
}

// Overrides ModuleBase.InstallInVendorRamdisk() so that the install rule respects
// Vendor_ramdisk_available property for vendor ramdisk variant
func (s *ShBinary) InstallInVendorRamdisk() bool {
 return s.ModuleBase.InstallInVendorRamdisk() ||
  (proptools.Bool(s.properties.Vendor_ramdisk_available) && s.properties.ImageVariation == android.VendorRamdiskVariation)
}

// Overrides ModuleBase.InstallInRecovery() so that the install rule respects
// Recovery_available property for recovery variant
func (s *ShBinary) InstallInRecovery() bool {
 return s.ModuleBase.InstallInRecovery() ||
  (proptools.Bool(s.properties.Recovery_available) && s.properties.ImageVariation == android.RecoveryVariation)
}

func (s *ShBinary) generateAndroidBuildActions(ctx android.ModuleContext) {
 src := s.properties.Src.Get(ctx)

 if src.IsEmpty() {
  if ctx.Config().AllowMissingDependencies() {
   ctx.AddMissingDependencies([]string{"missing_prebuilt_source_file"})
  } else {
   ctx.PropertyErrorf("src", "missing prebuilt source file")
  }
 }

 s.sourceFilePath = android.PathForModuleSrc(ctx, src.Get())
 filename := proptools.String(s.properties.Filename)
 filenameFromSrc := proptools.Bool(s.properties.Filename_from_src)
 if filename == "" {
  if filenameFromSrc {
   filename = s.sourceFilePath.Base()
  } else {
   filename = ctx.ModuleName()
  }
 } else if filenameFromSrc {
  ctx.PropertyErrorf("filename_from_src", "filename is set. filename_from_src can't be true")
  return
 }
 s.outputFilePath = android.PathForModuleOut(ctx, filename).OutputPath

 // This ensures that outputFilePath has the correct name for others to
 // use, as the source file may have a different name.
 ctx.Build(pctx, android.BuildParams{
  Rule:   android.CpExecutable,
  Output: s.outputFilePath,
  Input:  s.sourceFilePath,
 })

 s.properties.SubName = s.GetSubname(ctx)

 android.SetProvider(ctx, ShBinaryInfoProvider, ShBinaryInfo{
  SubDir:     s.SubDir(),
  OutputFile: s.OutputFile(),
  Symlinks:   s.Symlinks(),
 })

 ctx.SetOutputFiles(android.Paths{s.outputFilePath}, "")
}

func (s *ShBinary) GetSubname(ctx android.ModuleContext) string {
 ret := ""
 if s.properties.ImageVariation != "" {
  if s.properties.ImageVariation != android.VendorVariation {
   ret = "." + s.properties.ImageVariation
  }
 }
 return ret
}

func (s *ShBinary) GenerateAndroidBuildActions(ctx android.ModuleContext) {
 s.generateAndroidBuildActions(ctx)
 installDir := android.PathForModuleInstall(ctx, "bin", proptools.String(s.properties.Sub_dir))
 if !s.Installable() {
  s.SkipInstall()
 }
 s.installedFile = ctx.InstallExecutable(installDir, s.outputFilePath.Base(), s.outputFilePath)
 for _, symlink := range s.Symlinks() {
  ctx.InstallSymlink(installDir, symlink, s.installedFile)
 }
 moduleInfoJSON := ctx.ModuleInfoJSON()
 moduleInfoJSON.Class = []string{"EXECUTABLES"}
}

func (s *ShBinary) AndroidMkEntries() []android.AndroidMkEntries {
 return []android.AndroidMkEntries{{
  Class:      "EXECUTABLES",
  OutputFile: android.OptionalPathForPath(s.outputFilePath),
  Include:    "$(BUILD_SYSTEM)/soong_cc_rust_prebuilt.mk",
  ExtraEntries: []android.AndroidMkExtraEntriesFunc{
   func(ctx android.AndroidMkExtraEntriesContext, entries *android.AndroidMkEntries) {
    s.customAndroidMkEntries(entries)
    entries.SetString("LOCAL_MODULE_RELATIVE_PATH", proptools.String(s.properties.Sub_dir))
    entries.SetBoolIfTrue("LOCAL_UNINSTALLABLE_MODULE", !s.Installable())
   },
  },
  SubName: s.properties.SubName,
 }}
}

func (s *ShBinary) customAndroidMkEntries(entries *android.AndroidMkEntries) {
 entries.SetString("LOCAL_MODULE_SUFFIX", "")
 entries.SetString("LOCAL_MODULE_STEM", s.outputFilePath.Rel())
 if len(s.properties.Symlinks) > 0 {
  entries.SetString("LOCAL_MODULE_SYMLINKS", strings.Join(s.properties.Symlinks, " "))
 }
 entries.SetBool("LOCAL_CHECK_ELF_FILES", false)
}

type dependencyTag struct {
 blueprint.BaseDependencyTag
 name string
}

var (
 shTestDataBinsTag       = dependencyTag{name: "dataBins"}
 shTestDataLibsTag       = dependencyTag{name: "dataLibs"}
 shTestDataDeviceBinsTag = dependencyTag{name: "dataDeviceBins"}
 shTestDataDeviceLibsTag = dependencyTag{name: "dataDeviceLibs"}
 shTestJavaDataTag       = dependencyTag{name: "javaData"}
)

var sharedLibVariations = []blueprint.Variation{{Mutator: "link", Variation: "shared"}}

func (s *ShTest) DepsMutator(ctx android.BottomUpMutatorContext) {
 s.ShBinary.DepsMutator(ctx)

 ctx.AddFarVariationDependencies(ctx.Target().Variations(), shTestDataBinsTag, s.testProperties.Data_bins...)
 ctx.AddFarVariationDependencies(append(ctx.Target().Variations(), sharedLibVariations...),
  shTestDataLibsTag, s.testProperties.Data_libs...)
 if ctx.Target().Os.Class == android.Host && len(ctx.Config().Targets[android.Android]) > 0 {
  deviceVariations := ctx.Config().AndroidFirstDeviceTarget.Variations()
  ctx.AddFarVariationDependencies(deviceVariations, shTestDataDeviceBinsTag, s.testProperties.Data_device_bins...)
  ctx.AddFarVariationDependencies(append(deviceVariations, sharedLibVariations...),
   shTestDataDeviceLibsTag, s.testProperties.Data_device_libs...)

  javaDataVariation := []blueprint.Variation{{"arch", android.Common.String()}}
  ctx.AddVariationDependencies(javaDataVariation, shTestJavaDataTag, s.testProperties.Java_data...)

 } else if ctx.Target().Os.Class != android.Host {
  if len(s.testProperties.Data_device_bins) > 0 {
   ctx.PropertyErrorf("data_device_bins", "only available for host modules")
  }
  if len(s.testProperties.Data_device_libs) > 0 {
   ctx.PropertyErrorf("data_device_libs", "only available for host modules")
  }
  if len(s.testProperties.Java_data) > 0 {
   ctx.PropertyErrorf("Java_data", "only available for host modules")
  }
 }
}

func (s *ShTest) addToDataModules(ctx android.ModuleContext, relPath string, path android.Path) {
 if _, exists := s.dataModules[relPath]; exists {
  ctx.ModuleErrorf("data modules have a conflicting installation path, %v - %s, %s",
   relPath, s.dataModules[relPath].String(), path.String())
  return
 }
 s.dataModules[relPath] = path
 s.data = append(s.data, android.DataPath{SrcPath: path})
}

func (s *ShTest) GenerateAndroidBuildActions(ctx android.ModuleContext) {
 s.ShBinary.generateAndroidBuildActions(ctx)

 expandedData := android.PathsForModuleSrc(ctx, s.testProperties.Data)
 expandedData = append(expandedData, android.PathsForModuleSrc(ctx, s.testProperties.Device_common_data)...)
 expandedData = append(expandedData, android.PathsForModuleSrc(ctx, s.testProperties.Device_first_data)...)
 expandedData = append(expandedData, android.PathsForModuleSrc(ctx, s.testProperties.Host_common_data)...)
 // Emulate the data property for java_data dependencies.
 for _, javaData := range ctx.GetDirectDepsProxyWithTag(shTestJavaDataTag) {
  expandedData = append(expandedData, android.OutputFilesForModule(ctx, javaData, "")...)
 }
 for _, d := range expandedData {
  s.data = append(s.data, android.DataPath{SrcPath: d})
 }

 testDir := "nativetest"
 if ctx.Target().Arch.ArchType.Multilib == "lib64" {
  testDir = "nativetest64"
 }
 if ctx.Target().NativeBridge == android.NativeBridgeEnabled {
  testDir = filepath.Join(testDir, ctx.Target().NativeBridgeRelativePath)
 } else if !ctx.Host() && ctx.Config().HasMultilibConflict(ctx.Arch().ArchType) {
  testDir = filepath.Join(testDir, ctx.Arch().ArchType.String())
 }
 if s.SubDir() != "" {
  // Don't add the module name to the installation path if sub_dir is specified for backward
  // compatibility.
  s.installDir = android.PathForModuleInstall(ctx, testDir, s.SubDir())
 } else {
  s.installDir = android.PathForModuleInstall(ctx, testDir, s.Name())
 }

 var configs []tradefed.Config
 if Bool(s.testProperties.Require_root) {
  configs = append(configs, tradefed.Object{"target_preparer", "com.android.tradefed.targetprep.RootTargetPreparer", nil})
 } else {
  options := []tradefed.Option{{Name: "force-root", Value: "false"}}
  configs = append(configs, tradefed.Object{"target_preparer", "com.android.tradefed.targetprep.RootTargetPreparer", options})
 }
 if len(s.testProperties.Data_device_bins) > 0 {
  moduleName := s.Name()
  remoteDir := "/data/local/tests/unrestricted/" + moduleName + "/"
  options := []tradefed.Option{{Name: "cleanup", Value: "true"}}
  for _, bin := range s.testProperties.Data_device_bins {
   options = append(options, tradefed.Option{Name: "push-file", Key: bin, Value: remoteDir + bin})
  }
  configs = append(configs, tradefed.Object{"target_preparer", "com.android.tradefed.targetprep.PushFilePreparer", options})
 }
 s.testConfig = tradefed.AutoGenTestConfig(ctx, tradefed.AutoGenTestConfigOptions{
  TestConfigProp:         s.testProperties.Test_config,
  TestConfigTemplateProp: s.testProperties.Test_config_template,
  TestSuites:             s.testProperties.Test_suites,
  Config:                 configs,
  AutoGenConfig:          s.testProperties.Auto_gen_config,
  OutputFileName:         s.outputFilePath.Base(),
  DeviceTemplate:         "${ShellTestConfigTemplate}",
  HostTemplate:           "${ShellTestConfigTemplate}",
 })

 s.extraTestConfigs = android.PathsForModuleSrc(ctx, s.testProperties.Extra_test_configs)
 s.dataModules = make(map[string]android.Path)
 ctx.VisitDirectDepsProxy(func(dep android.ModuleProxy) {
  depTag := ctx.OtherModuleDependencyTag(dep)
  switch depTag {
  case shTestDataBinsTag, shTestDataDeviceBinsTag:
   path := android.OutputFileForModule(ctx, dep, "")
   s.addToDataModules(ctx, path.Base(), path)
  case shTestDataLibsTag, shTestDataDeviceLibsTag:
   if _, isCc := android.OtherModuleProvider(ctx, dep, cc.CcInfoProvider); isCc {
    // Copy to an intermediate output directory to append "lib[64]" to the path,
    // so that it's compatible with the default rpath values.
    var relPath string
    linkableInfo := android.OtherModuleProviderOrDefault(ctx, dep, cc.LinkableInfoProvider)
    commonInfo := android.OtherModulePointerProviderOrDefault(ctx, dep, android.CommonModuleInfoProvider)

    if commonInfo.Target.Arch.ArchType.Multilib == "lib64" {
     relPath = filepath.Join("lib64", linkableInfo.OutputFile.Path().Base())
    } else {
     relPath = filepath.Join("lib", linkableInfo.OutputFile.Path().Base())
    }
    if _, exist := s.dataModules[relPath]; exist {
     return
    }
    relocatedLib := android.PathForModuleOut(ctx, "relocated").Join(ctx, relPath)
    ctx.Build(pctx, android.BuildParams{
     Rule:   android.CpRule,
     Input:  linkableInfo.OutputFile.Path(),
     Output: relocatedLib,
    })
    s.addToDataModules(ctx, relPath, relocatedLib)
    return
   }
   property := "data_libs"
   if depTag == shTestDataDeviceBinsTag {
    property = "data_device_libs"
   }
   ctx.PropertyErrorf(property, "%q of type %q is not supported", dep.Name(), ctx.OtherModuleType(dep))
  }
 })

 installedData := ctx.InstallTestData(s.installDir, s.data)
 s.installedFile = ctx.InstallExecutable(s.installDir, s.outputFilePath.Base(), s.outputFilePath, installedData...)

 ctx.SetTestSuiteInfo(android.TestSuiteInfo{
  TestSuites:           s.testProperties.Test_suites,
  MainFile:             s.outputFilePath,
  MainFileStem:         s.outputFilePath.Base(),
  ConfigFile:           s.testConfig,
  ExtraConfigs:         s.extraTestConfigs,
  Data:                 s.data,
  NeedsArchFolder:      true,
  PerTestcaseDirectory: proptools.Bool(s.testProperties.Per_testcase_directory),
  IsUnitTest:           Bool(s.testProperties.Test_options.Unit_test),
 })

 mkEntries := s.AndroidMkEntries()[0]
 android.SetProvider(ctx, tradefed.BaseTestProviderKey, tradefed.BaseTestProviderData{
  TestcaseRelDataFiles: addArch(ctx.Arch().ArchType.String(), installedData.Paths()),
  OutputFile:           s.outputFilePath,
  TestConfig:           s.testConfig,
  TestSuites:           s.testProperties.Test_suites,
  IsHost:               false,
  IsUnitTest:           Bool(s.testProperties.Test_options.Unit_test),
  MkInclude:            mkEntries.Include,
  MkAppClass:           mkEntries.Class,
  InstallDir:           s.installDir,
 })

 moduleInfoJSON := ctx.ModuleInfoJSON()
 moduleInfoJSON.Class = []string{"NATIVE_TESTS"}
 if len(s.testProperties.Test_suites) > 0 {
  moduleInfoJSON.CompatibilitySuites = append(moduleInfoJSON.CompatibilitySuites, s.testProperties.Test_suites...)
 } else {
  moduleInfoJSON.CompatibilitySuites = append(moduleInfoJSON.CompatibilitySuites, "null-suite")
 }
 if proptools.Bool(s.testProperties.Test_options.Unit_test) {
  moduleInfoJSON.IsUnitTest = "true"
  if ctx.Host() {
   moduleInfoJSON.CompatibilitySuites = append(moduleInfoJSON.CompatibilitySuites, "host-unit-tests")
  }
 }
 moduleInfoJSON.DataDependencies = append(moduleInfoJSON.DataDependencies, s.testProperties.Data_bins...)
 if s.testConfig != nil {
  if _, ok := s.testConfig.(android.WritablePath); ok {
   moduleInfoJSON.AutoTestConfig = []string{"true"}
  }
  moduleInfoJSON.TestConfig = append(moduleInfoJSON.TestConfig, s.testConfig.String())
 }
 moduleInfoJSON.TestConfig = append(moduleInfoJSON.TestConfig, s.extraTestConfigs.Strings()...)
}

func addArch(archType string, paths android.Paths) []string {
 archRelPaths := []string{}
 for _, p := range paths {
  archRelPaths = append(archRelPaths, fmt.Sprintf("%s/%s", archType, p.Rel()))
 }
 return archRelPaths
}

func (s *ShTest) InstallInData() bool {
 return true
}

func (s *ShTest) AndroidMkEntries() []android.AndroidMkEntries {
 return []android.AndroidMkEntries{android.AndroidMkEntries{
  Class:      "NATIVE_TESTS",
  OutputFile: android.OptionalPathForPath(s.outputFilePath),
  Include:    "$(BUILD_SYSTEM)/soong_cc_rust_prebuilt.mk",
  ExtraEntries: []android.AndroidMkExtraEntriesFunc{
   func(ctx android.AndroidMkExtraEntriesContext, entries *android.AndroidMkEntries) {
    s.customAndroidMkEntries(entries)
    entries.SetPath("LOCAL_MODULE_PATH", s.installDir)
    entries.AddCompatibilityTestSuites(s.testProperties.Test_suites...)
    if s.testConfig != nil {
     entries.SetPath("LOCAL_FULL_TEST_CONFIG", s.testConfig)
    }
    if s.testProperties.Data_bins != nil {
     entries.AddStrings("LOCAL_TEST_DATA_BINS", s.testProperties.Data_bins...)
    }
    entries.SetBoolIfTrue("LOCAL_COMPATIBILITY_PER_TESTCASE_DIRECTORY", Bool(s.testProperties.Per_testcase_directory))
    if len(s.extraTestConfigs) > 0 {
     entries.AddStrings("LOCAL_EXTRA_FULL_TEST_CONFIGS", s.extraTestConfigs.Strings()...)
    }

    entries.SetBoolIfTrue("LOCAL_DISABLE_AUTO_GENERATE_TEST_CONFIG", !proptools.BoolDefault(s.testProperties.Auto_gen_config, true))

    s.testProperties.Test_options.SetAndroidMkEntries(entries)
   },
  },
 }}
}

func initShBinaryModule(s *ShBinary) {
 s.AddProperties(&s.properties)
}

// sh_binary is for a shell script or batch file to be installed as an
// executable binary to <partition>/bin.
func ShBinaryFactory() android.Module {
 module := &ShBinary{}
 initShBinaryModule(module)
 android.InitAndroidArchModule(module, android.HostAndDeviceSupported, android.MultilibFirst)
 android.InitDefaultableModule(module)
 return module
}

// sh_binary_host is for a shell script to be installed as an executable binary
// to $(HOST_OUT)/bin.
func ShBinaryHostFactory() android.Module {
 module := &ShBinary{}
 initShBinaryModule(module)
 android.InitAndroidArchModule(module, android.HostSupported, android.MultilibFirst)
 android.InitDefaultableModule(module)
 return module
}

// sh_test defines a shell script based test module.
func ShTestFactory() android.Module {
 module := &ShTest{}
 initShBinaryModule(&module.ShBinary)
 module.AddProperties(&module.testProperties)

 android.InitAndroidArchModule(module, android.HostAndDeviceSupported, android.MultilibFirst)
 android.InitDefaultableModule(module)
 return module
}

// sh_test_host defines a shell script based test module that runs on a host.
func ShTestHostFactory() android.Module {
 module := &ShTest{}
 initShBinaryModule(&module.ShBinary)
 module.AddProperties(&module.testProperties)
 // Default sh_test_host to unit_tests = true
 if module.testProperties.Test_options.Unit_test == nil {
  module.testProperties.Test_options.Unit_test = proptools.BoolPtr(true)
 }

 android.InitAndroidArchModule(module, android.HostSupported, android.MultilibFirst)
 android.InitDefaultableModule(module)
 return module
}

type ShDefaults struct {
 android.ModuleBase
 android.DefaultsModuleBase
}

func ShDefaultsFactory() android.Module {
 module := &ShDefaults{}

 module.AddProperties(&shBinaryProperties{}, &TestProperties{})
 android.InitDefaultsModule(module)

 return module
}

var Bool = proptools.Bool