75539d62ae
Soong modules that are specific for the host platform (e.g. java_library_host, cc_binary_host, java_genrule_host, etc.) should not be built on the target platform (Android), so we add a target_compatible_with attribute to skip this type of module on an Android target build. Bug: 215229742 Test: go test ./bp2build Change-Id: Ifb76ef4e0dc4cb3adb6a64b5c375ce36f7973e48
668 lines
16 KiB
Go
668 lines
16 KiB
Go
// Copyright 2021 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 bp2build
|
|
|
|
import (
|
|
"android/soong/android"
|
|
"android/soong/cc"
|
|
"android/soong/genrule"
|
|
"android/soong/java"
|
|
"fmt"
|
|
"testing"
|
|
)
|
|
|
|
func registerGenruleModuleTypes(ctx android.RegistrationContext) {
|
|
ctx.RegisterModuleType("genrule_defaults", func() android.Module { return genrule.DefaultsFactory() })
|
|
}
|
|
|
|
func runGenruleTestCase(t *testing.T, tc bp2buildTestCase) {
|
|
t.Helper()
|
|
(&tc).moduleTypeUnderTest = "genrule"
|
|
(&tc).moduleTypeUnderTestFactory = genrule.GenRuleFactory
|
|
runBp2BuildTestCase(t, registerGenruleModuleTypes, tc)
|
|
}
|
|
|
|
func otherGenruleBp(genruleTarget string) map[string]string {
|
|
return map[string]string{
|
|
"other/Android.bp": fmt.Sprintf(`%s {
|
|
name: "foo.tool",
|
|
out: ["foo_tool.out"],
|
|
srcs: ["foo_tool.in"],
|
|
cmd: "cp $(in) $(out)",
|
|
}
|
|
%s {
|
|
name: "other.tool",
|
|
out: ["other_tool.out"],
|
|
srcs: ["other_tool.in"],
|
|
cmd: "cp $(in) $(out)",
|
|
}`, genruleTarget, genruleTarget),
|
|
}
|
|
}
|
|
|
|
func TestGenruleCliVariableReplacement(t *testing.T) {
|
|
testCases := []struct {
|
|
moduleType string
|
|
factory android.ModuleFactory
|
|
genDir string
|
|
}{
|
|
{
|
|
moduleType: "genrule",
|
|
factory: genrule.GenRuleFactory,
|
|
genDir: "$(GENDIR)",
|
|
},
|
|
{
|
|
moduleType: "cc_genrule",
|
|
factory: cc.GenRuleFactory,
|
|
genDir: "$(RULEDIR)",
|
|
},
|
|
{
|
|
moduleType: "java_genrule",
|
|
factory: java.GenRuleFactory,
|
|
genDir: "$(RULEDIR)",
|
|
},
|
|
{
|
|
moduleType: "java_genrule_host",
|
|
factory: java.GenRuleFactoryHost,
|
|
genDir: "$(RULEDIR)",
|
|
},
|
|
}
|
|
|
|
bp := `%s {
|
|
name: "foo.tool",
|
|
out: ["foo_tool.out"],
|
|
srcs: ["foo_tool.in"],
|
|
cmd: "cp $(in) $(out)",
|
|
bazel_module: { bp2build_available: false },
|
|
}
|
|
|
|
%s {
|
|
name: "foo",
|
|
out: ["foo.out"],
|
|
srcs: ["foo.in"],
|
|
tools: [":foo.tool"],
|
|
cmd: "$(location :foo.tool) --genDir=$(genDir) arg $(in) $(out)",
|
|
bazel_module: { bp2build_available: true },
|
|
}`
|
|
|
|
for _, tc := range testCases {
|
|
moduleAttrs := attrNameToString{
|
|
"cmd": fmt.Sprintf(`"$(location :foo.tool) --genDir=%s arg $(SRCS) $(OUTS)"`, tc.genDir),
|
|
"outs": `["foo.out"]`,
|
|
"srcs": `["foo.in"]`,
|
|
"tools": `[":foo.tool"]`,
|
|
}
|
|
|
|
if tc.moduleType == "java_genrule_host" {
|
|
moduleAttrs["target_compatible_with"] = `select({
|
|
"//build/bazel/platforms/os:android": ["@platforms//:incompatible"],
|
|
"//conditions:default": [],
|
|
})`
|
|
}
|
|
|
|
expectedBazelTargets := []string{
|
|
makeBazelTarget("genrule", "foo", moduleAttrs),
|
|
}
|
|
|
|
t.Run(tc.moduleType, func(t *testing.T) {
|
|
runBp2BuildTestCase(t, func(ctx android.RegistrationContext) {},
|
|
bp2buildTestCase{
|
|
moduleTypeUnderTest: tc.moduleType,
|
|
moduleTypeUnderTestFactory: tc.factory,
|
|
blueprint: fmt.Sprintf(bp, tc.moduleType, tc.moduleType),
|
|
expectedBazelTargets: expectedBazelTargets,
|
|
})
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGenruleLocationsLabel(t *testing.T) {
|
|
testCases := []struct {
|
|
moduleType string
|
|
factory android.ModuleFactory
|
|
}{
|
|
{
|
|
moduleType: "genrule",
|
|
factory: genrule.GenRuleFactory,
|
|
},
|
|
{
|
|
moduleType: "cc_genrule",
|
|
factory: cc.GenRuleFactory,
|
|
},
|
|
{
|
|
moduleType: "java_genrule",
|
|
factory: java.GenRuleFactory,
|
|
},
|
|
{
|
|
moduleType: "java_genrule_host",
|
|
factory: java.GenRuleFactoryHost,
|
|
},
|
|
}
|
|
|
|
bp := `%s {
|
|
name: "foo.tools",
|
|
out: ["foo_tool.out", "foo_tool2.out"],
|
|
srcs: ["foo_tool.in"],
|
|
cmd: "cp $(in) $(out)",
|
|
bazel_module: { bp2build_available: true },
|
|
}
|
|
|
|
%s {
|
|
name: "foo",
|
|
out: ["foo.out"],
|
|
srcs: ["foo.in"],
|
|
tools: [":foo.tools"],
|
|
cmd: "$(locations :foo.tools) -s $(out) $(in)",
|
|
bazel_module: { bp2build_available: true },
|
|
}`
|
|
|
|
for _, tc := range testCases {
|
|
fooAttrs := attrNameToString{
|
|
"cmd": `"$(locations :foo.tools) -s $(OUTS) $(SRCS)"`,
|
|
"outs": `["foo.out"]`,
|
|
"srcs": `["foo.in"]`,
|
|
"tools": `[":foo.tools"]`,
|
|
}
|
|
fooToolsAttrs := attrNameToString{
|
|
"cmd": `"cp $(SRCS) $(OUTS)"`,
|
|
"outs": `[
|
|
"foo_tool.out",
|
|
"foo_tool2.out",
|
|
]`,
|
|
"srcs": `["foo_tool.in"]`,
|
|
}
|
|
|
|
if tc.moduleType == "java_genrule_host" {
|
|
compatibilityAttrs := `select({
|
|
"//build/bazel/platforms/os:android": ["@platforms//:incompatible"],
|
|
"//conditions:default": [],
|
|
})`
|
|
fooAttrs["target_compatible_with"] = compatibilityAttrs
|
|
fooToolsAttrs["target_compatible_with"] = compatibilityAttrs
|
|
}
|
|
|
|
expectedBazelTargets := []string{
|
|
makeBazelTarget("genrule", "foo", fooAttrs),
|
|
makeBazelTarget("genrule", "foo.tools", fooToolsAttrs),
|
|
}
|
|
|
|
t.Run(tc.moduleType, func(t *testing.T) {
|
|
runBp2BuildTestCase(t, func(ctx android.RegistrationContext) {},
|
|
bp2buildTestCase{
|
|
moduleTypeUnderTest: tc.moduleType,
|
|
moduleTypeUnderTestFactory: tc.factory,
|
|
blueprint: fmt.Sprintf(bp, tc.moduleType, tc.moduleType),
|
|
expectedBazelTargets: expectedBazelTargets,
|
|
})
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGenruleLocationsAbsoluteLabel(t *testing.T) {
|
|
testCases := []struct {
|
|
moduleType string
|
|
factory android.ModuleFactory
|
|
}{
|
|
{
|
|
moduleType: "genrule",
|
|
factory: genrule.GenRuleFactory,
|
|
},
|
|
{
|
|
moduleType: "cc_genrule",
|
|
factory: cc.GenRuleFactory,
|
|
},
|
|
{
|
|
moduleType: "java_genrule",
|
|
factory: java.GenRuleFactory,
|
|
},
|
|
{
|
|
moduleType: "java_genrule_host",
|
|
factory: java.GenRuleFactoryHost,
|
|
},
|
|
}
|
|
|
|
bp := `%s {
|
|
name: "foo",
|
|
out: ["foo.out"],
|
|
srcs: ["foo.in"],
|
|
tool_files: [":foo.tool"],
|
|
cmd: "$(locations :foo.tool) -s $(out) $(in)",
|
|
bazel_module: { bp2build_available: true },
|
|
}`
|
|
|
|
for _, tc := range testCases {
|
|
moduleAttrs := attrNameToString{
|
|
"cmd": `"$(locations //other:foo.tool) -s $(OUTS) $(SRCS)"`,
|
|
"outs": `["foo.out"]`,
|
|
"srcs": `["foo.in"]`,
|
|
"tools": `["//other:foo.tool"]`,
|
|
}
|
|
|
|
if tc.moduleType == "java_genrule_host" {
|
|
moduleAttrs["target_compatible_with"] = `select({
|
|
"//build/bazel/platforms/os:android": ["@platforms//:incompatible"],
|
|
"//conditions:default": [],
|
|
})`
|
|
}
|
|
|
|
expectedBazelTargets := []string{
|
|
makeBazelTarget("genrule", "foo", moduleAttrs),
|
|
}
|
|
|
|
t.Run(tc.moduleType, func(t *testing.T) {
|
|
runBp2BuildTestCase(t, func(ctx android.RegistrationContext) {},
|
|
bp2buildTestCase{
|
|
moduleTypeUnderTest: tc.moduleType,
|
|
moduleTypeUnderTestFactory: tc.factory,
|
|
blueprint: fmt.Sprintf(bp, tc.moduleType),
|
|
expectedBazelTargets: expectedBazelTargets,
|
|
filesystem: otherGenruleBp(tc.moduleType),
|
|
})
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGenruleSrcsLocationsAbsoluteLabel(t *testing.T) {
|
|
testCases := []struct {
|
|
moduleType string
|
|
factory android.ModuleFactory
|
|
}{
|
|
{
|
|
moduleType: "genrule",
|
|
factory: genrule.GenRuleFactory,
|
|
},
|
|
{
|
|
moduleType: "cc_genrule",
|
|
factory: cc.GenRuleFactory,
|
|
},
|
|
{
|
|
moduleType: "java_genrule",
|
|
factory: java.GenRuleFactory,
|
|
},
|
|
{
|
|
moduleType: "java_genrule_host",
|
|
factory: java.GenRuleFactoryHost,
|
|
},
|
|
}
|
|
|
|
bp := `%s {
|
|
name: "foo",
|
|
out: ["foo.out"],
|
|
srcs: [":other.tool"],
|
|
tool_files: [":foo.tool"],
|
|
cmd: "$(locations :foo.tool) -s $(out) $(location :other.tool)",
|
|
bazel_module: { bp2build_available: true },
|
|
}`
|
|
|
|
for _, tc := range testCases {
|
|
moduleAttrs := attrNameToString{
|
|
"cmd": `"$(locations //other:foo.tool) -s $(OUTS) $(location //other:other.tool)"`,
|
|
"outs": `["foo.out"]`,
|
|
"srcs": `["//other:other.tool"]`,
|
|
"tools": `["//other:foo.tool"]`,
|
|
}
|
|
|
|
if tc.moduleType == "java_genrule_host" {
|
|
moduleAttrs["target_compatible_with"] = `select({
|
|
"//build/bazel/platforms/os:android": ["@platforms//:incompatible"],
|
|
"//conditions:default": [],
|
|
})`
|
|
}
|
|
|
|
expectedBazelTargets := []string{
|
|
makeBazelTarget("genrule", "foo", moduleAttrs),
|
|
}
|
|
|
|
t.Run(tc.moduleType, func(t *testing.T) {
|
|
runBp2BuildTestCase(t, func(ctx android.RegistrationContext) {},
|
|
bp2buildTestCase{
|
|
moduleTypeUnderTest: tc.moduleType,
|
|
moduleTypeUnderTestFactory: tc.factory,
|
|
blueprint: fmt.Sprintf(bp, tc.moduleType),
|
|
expectedBazelTargets: expectedBazelTargets,
|
|
filesystem: otherGenruleBp(tc.moduleType),
|
|
})
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGenruleLocationLabelShouldSubstituteFirstToolLabel(t *testing.T) {
|
|
testCases := []struct {
|
|
moduleType string
|
|
factory android.ModuleFactory
|
|
}{
|
|
{
|
|
moduleType: "genrule",
|
|
factory: genrule.GenRuleFactory,
|
|
},
|
|
{
|
|
moduleType: "cc_genrule",
|
|
factory: cc.GenRuleFactory,
|
|
},
|
|
{
|
|
moduleType: "java_genrule",
|
|
factory: java.GenRuleFactory,
|
|
},
|
|
{
|
|
moduleType: "java_genrule_host",
|
|
factory: java.GenRuleFactoryHost,
|
|
},
|
|
}
|
|
|
|
bp := `%s {
|
|
name: "foo",
|
|
out: ["foo.out"],
|
|
srcs: ["foo.in"],
|
|
tool_files: [":foo.tool", ":other.tool"],
|
|
cmd: "$(location) -s $(out) $(in)",
|
|
bazel_module: { bp2build_available: true },
|
|
}`
|
|
|
|
for _, tc := range testCases {
|
|
moduleAttrs := attrNameToString{
|
|
"cmd": `"$(location //other:foo.tool) -s $(OUTS) $(SRCS)"`,
|
|
"outs": `["foo.out"]`,
|
|
"srcs": `["foo.in"]`,
|
|
"tools": `[
|
|
"//other:foo.tool",
|
|
"//other:other.tool",
|
|
]`,
|
|
}
|
|
|
|
if tc.moduleType == "java_genrule_host" {
|
|
moduleAttrs["target_compatible_with"] = `select({
|
|
"//build/bazel/platforms/os:android": ["@platforms//:incompatible"],
|
|
"//conditions:default": [],
|
|
})`
|
|
}
|
|
|
|
expectedBazelTargets := []string{
|
|
makeBazelTarget("genrule", "foo", moduleAttrs),
|
|
}
|
|
|
|
t.Run(tc.moduleType, func(t *testing.T) {
|
|
runBp2BuildTestCase(t, func(ctx android.RegistrationContext) {},
|
|
bp2buildTestCase{
|
|
moduleTypeUnderTest: tc.moduleType,
|
|
moduleTypeUnderTestFactory: tc.factory,
|
|
blueprint: fmt.Sprintf(bp, tc.moduleType),
|
|
expectedBazelTargets: expectedBazelTargets,
|
|
filesystem: otherGenruleBp(tc.moduleType),
|
|
})
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGenruleLocationsLabelShouldSubstituteFirstToolLabel(t *testing.T) {
|
|
testCases := []struct {
|
|
moduleType string
|
|
factory android.ModuleFactory
|
|
}{
|
|
{
|
|
moduleType: "genrule",
|
|
factory: genrule.GenRuleFactory,
|
|
},
|
|
{
|
|
moduleType: "cc_genrule",
|
|
factory: cc.GenRuleFactory,
|
|
},
|
|
{
|
|
moduleType: "java_genrule",
|
|
factory: java.GenRuleFactory,
|
|
},
|
|
{
|
|
moduleType: "java_genrule_host",
|
|
factory: java.GenRuleFactoryHost,
|
|
},
|
|
}
|
|
|
|
bp := `%s {
|
|
name: "foo",
|
|
out: ["foo.out"],
|
|
srcs: ["foo.in"],
|
|
tool_files: [":foo.tool", ":other.tool"],
|
|
cmd: "$(locations) -s $(out) $(in)",
|
|
bazel_module: { bp2build_available: true },
|
|
}`
|
|
|
|
for _, tc := range testCases {
|
|
moduleAttrs := attrNameToString{
|
|
"cmd": `"$(locations //other:foo.tool) -s $(OUTS) $(SRCS)"`,
|
|
"outs": `["foo.out"]`,
|
|
"srcs": `["foo.in"]`,
|
|
"tools": `[
|
|
"//other:foo.tool",
|
|
"//other:other.tool",
|
|
]`,
|
|
}
|
|
|
|
if tc.moduleType == "java_genrule_host" {
|
|
moduleAttrs["target_compatible_with"] = `select({
|
|
"//build/bazel/platforms/os:android": ["@platforms//:incompatible"],
|
|
"//conditions:default": [],
|
|
})`
|
|
}
|
|
|
|
expectedBazelTargets := []string{
|
|
makeBazelTarget("genrule", "foo", moduleAttrs),
|
|
}
|
|
|
|
t.Run(tc.moduleType, func(t *testing.T) {
|
|
runBp2BuildTestCase(t, func(ctx android.RegistrationContext) {},
|
|
bp2buildTestCase{
|
|
moduleTypeUnderTest: tc.moduleType,
|
|
moduleTypeUnderTestFactory: tc.factory,
|
|
blueprint: fmt.Sprintf(bp, tc.moduleType),
|
|
expectedBazelTargets: expectedBazelTargets,
|
|
filesystem: otherGenruleBp(tc.moduleType),
|
|
})
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGenruleWithoutToolsOrToolFiles(t *testing.T) {
|
|
testCases := []struct {
|
|
moduleType string
|
|
factory android.ModuleFactory
|
|
}{
|
|
{
|
|
moduleType: "genrule",
|
|
factory: genrule.GenRuleFactory,
|
|
},
|
|
{
|
|
moduleType: "cc_genrule",
|
|
factory: cc.GenRuleFactory,
|
|
},
|
|
{
|
|
moduleType: "java_genrule",
|
|
factory: java.GenRuleFactory,
|
|
},
|
|
{
|
|
moduleType: "java_genrule_host",
|
|
factory: java.GenRuleFactoryHost,
|
|
},
|
|
}
|
|
|
|
bp := `%s {
|
|
name: "foo",
|
|
out: ["foo.out"],
|
|
srcs: ["foo.in"],
|
|
cmd: "cp $(in) $(out)",
|
|
bazel_module: { bp2build_available: true },
|
|
}`
|
|
|
|
for _, tc := range testCases {
|
|
moduleAttrs := attrNameToString{
|
|
"cmd": `"cp $(SRCS) $(OUTS)"`,
|
|
"outs": `["foo.out"]`,
|
|
"srcs": `["foo.in"]`,
|
|
}
|
|
|
|
if tc.moduleType == "java_genrule_host" {
|
|
moduleAttrs["target_compatible_with"] = `select({
|
|
"//build/bazel/platforms/os:android": ["@platforms//:incompatible"],
|
|
"//conditions:default": [],
|
|
})`
|
|
}
|
|
|
|
expectedBazelTargets := []string{
|
|
makeBazelTarget("genrule", "foo", moduleAttrs),
|
|
}
|
|
|
|
t.Run(tc.moduleType, func(t *testing.T) {
|
|
runBp2BuildTestCase(t, func(ctx android.RegistrationContext) {},
|
|
bp2buildTestCase{
|
|
moduleTypeUnderTest: tc.moduleType,
|
|
moduleTypeUnderTestFactory: tc.factory,
|
|
blueprint: fmt.Sprintf(bp, tc.moduleType),
|
|
expectedBazelTargets: expectedBazelTargets,
|
|
})
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGenruleBp2BuildInlinesDefaults(t *testing.T) {
|
|
testCases := []bp2buildTestCase{
|
|
{
|
|
description: "genrule applies properties from a genrule_defaults dependency if not specified",
|
|
blueprint: `genrule_defaults {
|
|
name: "gen_defaults",
|
|
cmd: "do-something $(in) $(out)",
|
|
}
|
|
genrule {
|
|
name: "gen",
|
|
out: ["out"],
|
|
srcs: ["in1"],
|
|
defaults: ["gen_defaults"],
|
|
bazel_module: { bp2build_available: true },
|
|
}
|
|
`,
|
|
expectedBazelTargets: []string{
|
|
makeBazelTarget("genrule", "gen", attrNameToString{
|
|
"cmd": `"do-something $(SRCS) $(OUTS)"`,
|
|
"outs": `["out"]`,
|
|
"srcs": `["in1"]`,
|
|
}),
|
|
},
|
|
},
|
|
{
|
|
description: "genrule does merges properties from a genrule_defaults dependency, latest-first",
|
|
blueprint: `genrule_defaults {
|
|
name: "gen_defaults",
|
|
out: ["out-from-defaults"],
|
|
srcs: ["in-from-defaults"],
|
|
cmd: "cmd-from-defaults",
|
|
}
|
|
genrule {
|
|
name: "gen",
|
|
out: ["out"],
|
|
srcs: ["in1"],
|
|
defaults: ["gen_defaults"],
|
|
cmd: "do-something $(in) $(out)",
|
|
bazel_module: { bp2build_available: true },
|
|
}
|
|
`,
|
|
expectedBazelTargets: []string{
|
|
makeBazelTarget("genrule", "gen", attrNameToString{
|
|
"cmd": `"do-something $(SRCS) $(OUTS)"`,
|
|
"outs": `[
|
|
"out-from-defaults",
|
|
"out",
|
|
]`,
|
|
"srcs": `[
|
|
"in-from-defaults",
|
|
"in1",
|
|
]`,
|
|
}),
|
|
},
|
|
},
|
|
{
|
|
description: "genrule applies properties from list of genrule_defaults",
|
|
blueprint: `genrule_defaults {
|
|
name: "gen_defaults1",
|
|
cmd: "cp $(in) $(out)",
|
|
}
|
|
|
|
genrule_defaults {
|
|
name: "gen_defaults2",
|
|
srcs: ["in1"],
|
|
}
|
|
|
|
genrule {
|
|
name: "gen",
|
|
out: ["out"],
|
|
defaults: ["gen_defaults1", "gen_defaults2"],
|
|
bazel_module: { bp2build_available: true },
|
|
}
|
|
`,
|
|
expectedBazelTargets: []string{
|
|
makeBazelTarget("genrule", "gen", attrNameToString{
|
|
"cmd": `"cp $(SRCS) $(OUTS)"`,
|
|
"outs": `["out"]`,
|
|
"srcs": `["in1"]`,
|
|
}),
|
|
},
|
|
},
|
|
{
|
|
description: "genrule applies properties from genrule_defaults transitively",
|
|
blueprint: `genrule_defaults {
|
|
name: "gen_defaults1",
|
|
defaults: ["gen_defaults2"],
|
|
cmd: "cmd1 $(in) $(out)", // overrides gen_defaults2's cmd property value.
|
|
}
|
|
|
|
genrule_defaults {
|
|
name: "gen_defaults2",
|
|
defaults: ["gen_defaults3"],
|
|
cmd: "cmd2 $(in) $(out)",
|
|
out: ["out-from-2"],
|
|
srcs: ["in1"],
|
|
}
|
|
|
|
genrule_defaults {
|
|
name: "gen_defaults3",
|
|
out: ["out-from-3"],
|
|
srcs: ["srcs-from-3"],
|
|
}
|
|
|
|
genrule {
|
|
name: "gen",
|
|
out: ["out"],
|
|
defaults: ["gen_defaults1"],
|
|
bazel_module: { bp2build_available: true },
|
|
}
|
|
`,
|
|
expectedBazelTargets: []string{
|
|
makeBazelTarget("genrule", "gen", attrNameToString{
|
|
"cmd": `"cmd1 $(SRCS) $(OUTS)"`,
|
|
"outs": `[
|
|
"out-from-3",
|
|
"out-from-2",
|
|
"out",
|
|
]`,
|
|
"srcs": `[
|
|
"srcs-from-3",
|
|
"in1",
|
|
]`,
|
|
}),
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, testCase := range testCases {
|
|
t.Run(testCase.description, func(t *testing.T) {
|
|
runGenruleTestCase(t, testCase)
|
|
})
|
|
}
|
|
}
|