blob: a5db02f252466d0449a7fa2c096f0e0daaeb8929 [file] [log] [blame]
package crosstooltostarlarklib
import (
"fmt"
"strings"
"testing"
"log"
crosstoolpb "third_party/com/github/bazelbuild/bazel/src/main/protobuf/crosstool_config_go_proto"
"github.com/golang/protobuf/proto"
)
func makeCToolchainString(lines []string) string {
return fmt.Sprintf(`toolchain {
%s
}`, strings.Join(lines, "\n "))
}
func makeCrosstool(CToolchains []string) *crosstoolpb.CrosstoolRelease {
crosstool := &crosstoolpb.CrosstoolRelease{}
requiredFields := []string{
"major_version: '0'",
"minor_version: '0'",
"default_target_cpu: 'cpu'",
}
CToolchains = append(CToolchains, requiredFields...)
if err := proto.UnmarshalText(strings.Join(CToolchains, "\n"), crosstool); err != nil {
log.Fatalf("Failed to parse CROSSTOOL:", err)
}
return crosstool
}
func getSimpleCToolchain(id string) string {
lines := []string{
"toolchain_identifier: 'id-" + id + "'",
"host_system_name: 'host-" + id + "'",
"target_system_name: 'target-" + id + "'",
"target_cpu: 'cpu-" + id + "'",
"compiler: 'compiler-" + id + "'",
"target_libc: 'libc-" + id + "'",
"abi_version: 'version-" + id + "'",
"abi_libc_version: 'libc_version-" + id + "'",
}
return makeCToolchainString(lines)
}
func getCToolchain(id, cpu, compiler string, extraLines []string) string {
lines := []string{
"toolchain_identifier: '" + id + "'",
"host_system_name: 'host'",
"target_system_name: 'target'",
"target_cpu: '" + cpu + "'",
"compiler: '" + compiler + "'",
"target_libc: 'libc'",
"abi_version: 'version'",
"abi_libc_version: 'libc_version'",
}
lines = append(lines, extraLines...)
return makeCToolchainString(lines)
}
func TestStringFieldsConditionStatement(t *testing.T) {
toolchain1 := getSimpleCToolchain("1")
toolchain2 := getSimpleCToolchain("2")
toolchains := []string{toolchain1, toolchain2}
crosstool := makeCrosstool(toolchains)
testCases := []struct {
field string
expectedText string
}{
{field: "toolchain_identifier",
expectedText: `
if (ctx.attr.cpu == "cpu-1"):
toolchain_identifier = "id-1"
elif (ctx.attr.cpu == "cpu-2"):
toolchain_identifier = "id-2"
else:
fail("Unreachable")`},
{field: "host_system_name",
expectedText: `
if (ctx.attr.cpu == "cpu-1"):
host_system_name = "host-1"
elif (ctx.attr.cpu == "cpu-2"):
host_system_name = "host-2"
else:
fail("Unreachable")`},
{field: "target_system_name",
expectedText: `
if (ctx.attr.cpu == "cpu-1"):
target_system_name = "target-1"
elif (ctx.attr.cpu == "cpu-2"):
target_system_name = "target-2"
else:
fail("Unreachable")`},
{field: "target_cpu",
expectedText: `
if (ctx.attr.cpu == "cpu-1"):
target_cpu = "cpu-1"
elif (ctx.attr.cpu == "cpu-2"):
target_cpu = "cpu-2"
else:
fail("Unreachable")`},
{field: "target_libc",
expectedText: `
if (ctx.attr.cpu == "cpu-1"):
target_libc = "libc-1"
elif (ctx.attr.cpu == "cpu-2"):
target_libc = "libc-2"
else:
fail("Unreachable")`},
{field: "compiler",
expectedText: `
if (ctx.attr.cpu == "cpu-1"):
compiler = "compiler-1"
elif (ctx.attr.cpu == "cpu-2"):
compiler = "compiler-2"
else:
fail("Unreachable")`},
{field: "abi_version",
expectedText: `
if (ctx.attr.cpu == "cpu-1"):
abi_version = "version-1"
elif (ctx.attr.cpu == "cpu-2"):
abi_version = "version-2"
else:
fail("Unreachable")`},
{field: "abi_libc_version",
expectedText: `
if (ctx.attr.cpu == "cpu-1"):
abi_libc_version = "libc_version-1"
elif (ctx.attr.cpu == "cpu-2"):
abi_libc_version = "libc_version-2"
else:
fail("Unreachable")`}}
got, err := Transform(crosstool)
if err != nil {
t.Fatalf("CROSSTOOL conversion failed: %v", err)
}
failed := false
for _, tc := range testCases {
if !strings.Contains(got, tc.expectedText) {
t.Errorf("Failed to correctly convert '%s' field, expected to contain:\n%v\n",
tc.field, tc.expectedText)
failed = true
}
}
if failed {
t.Fatalf("Tested CROSSTOOL:\n%v\n\nGenerated rule:\n%v\n",
strings.Join(toolchains, "\n"), got)
}
}
func TestConditionsSameCpu(t *testing.T) {
toolchainAA := getCToolchain("1", "cpuA", "compilerA", []string{})
toolchainAB := getCToolchain("2", "cpuA", "compilerB", []string{})
toolchains := []string{toolchainAA, toolchainAB}
crosstool := makeCrosstool(toolchains)
testCases := []struct {
field string
expectedText string
}{
{field: "toolchain_identifier",
expectedText: `
if (ctx.attr.cpu == "cpuA" and ctx.attr.compiler == "compilerA"):
toolchain_identifier = "1"
elif (ctx.attr.cpu == "cpuA" and ctx.attr.compiler == "compilerB"):
toolchain_identifier = "2"
else:
fail("Unreachable")`},
{field: "host_system_name",
expectedText: `
host_system_name = "host"`},
{field: "target_system_name",
expectedText: `
target_system_name = "target"`},
{field: "target_cpu",
expectedText: `
target_cpu = "cpuA"`},
{field: "target_libc",
expectedText: `
target_libc = "libc"`},
{field: "compiler",
expectedText: `
if (ctx.attr.cpu == "cpuA" and ctx.attr.compiler == "compilerA"):
compiler = "compilerA"
elif (ctx.attr.cpu == "cpuA" and ctx.attr.compiler == "compilerB"):
compiler = "compilerB"
else:
fail("Unreachable")`},
{field: "abi_version",
expectedText: `
abi_version = "version"`},
{field: "abi_libc_version",
expectedText: `
abi_libc_version = "libc_version"`}}
got, err := Transform(crosstool)
if err != nil {
t.Fatalf("CROSSTOOL conversion failed: %v", err)
}
failed := false
for _, tc := range testCases {
if !strings.Contains(got, tc.expectedText) {
t.Errorf("Failed to correctly convert '%s' field, expected to contain:\n%v\n",
tc.field, tc.expectedText)
failed = true
}
}
if failed {
t.Fatalf("Tested CROSSTOOL:\n%v\n\nGenerated rule:\n%v\n",
strings.Join(toolchains, "\n"), got)
}
}
func TestConditionsSameCompiler(t *testing.T) {
toolchainAA := getCToolchain("1", "cpuA", "compilerA", []string{})
toolchainBA := getCToolchain("2", "cpuB", "compilerA", []string{})
toolchains := []string{toolchainAA, toolchainBA}
crosstool := makeCrosstool(toolchains)
testCases := []struct {
field string
expectedText string
}{
{field: "toolchain_identifier",
expectedText: `
if (ctx.attr.cpu == "cpuA"):
toolchain_identifier = "1"
elif (ctx.attr.cpu == "cpuB"):
toolchain_identifier = "2"
else:
fail("Unreachable")`},
{field: "target_cpu",
expectedText: `
if (ctx.attr.cpu == "cpuA"):
target_cpu = "cpuA"
elif (ctx.attr.cpu == "cpuB"):
target_cpu = "cpuB"
else:
fail("Unreachable")`},
{field: "compiler",
expectedText: `
compiler = "compilerA"`}}
got, err := Transform(crosstool)
if err != nil {
t.Fatalf("CROSSTOOL conversion failed: %v", err)
}
failed := false
for _, tc := range testCases {
if !strings.Contains(got, tc.expectedText) {
t.Errorf("Failed to correctly convert '%s' field, expected to contain:\n%v\n",
tc.field, tc.expectedText)
failed = true
}
}
if failed {
t.Fatalf("Tested CROSSTOOL:\n%v\n\nGenerated rule:\n%v\n",
strings.Join(toolchains, "\n"), got)
}
}
func TestNonMandatoryStrings(t *testing.T) {
toolchainAA := getCToolchain("1", "cpuA", "compilerA", []string{"cc_target_os: 'osA'"})
toolchainBB := getCToolchain("2", "cpuB", "compilerB", []string{})
toolchains := []string{toolchainAA, toolchainBB}
crosstool := makeCrosstool(toolchains)
testCases := []struct {
field string
expectedText string
}{
{field: "cc_target_os",
expectedText: `
if (ctx.attr.cpu == "cpuB"):
cc_target_os = None
elif (ctx.attr.cpu == "cpuA"):
cc_target_os = "osA"
else:
fail("Unreachable")`},
{field: "builtin_sysroot",
expectedText: `
builtin_sysroot = None`}}
got, err := Transform(crosstool)
if err != nil {
t.Fatalf("CROSSTOOL conversion failed: %v", err)
}
failed := false
for _, tc := range testCases {
if !strings.Contains(got, tc.expectedText) {
t.Errorf("Failed to correctly convert '%s' field, expected to contain:\n%v\n",
tc.field, tc.expectedText)
failed = true
}
}
if failed {
t.Fatalf("Tested CROSSTOOL:\n%v\n\nGenerated rule:\n%v\n",
strings.Join(toolchains, "\n"), got)
}
}
func TestBuiltinIncludeDirectories(t *testing.T) {
toolchainAA := getCToolchain("1", "cpuA", "compilerA", []string{})
toolchainBA := getCToolchain("2", "cpuB", "compilerA", []string{})
toolchainCA := getCToolchain("3", "cpuC", "compilerA",
[]string{"cxx_builtin_include_directory: 'dirC'"})
toolchainCB := getCToolchain("4", "cpuC", "compilerB",
[]string{"cxx_builtin_include_directory: 'dirC'",
"cxx_builtin_include_directory: 'dirB'"})
toolchainDA := getCToolchain("5", "cpuD", "compilerA",
[]string{"cxx_builtin_include_directory: 'dirC'"})
toolchainsEmpty := []string{toolchainAA, toolchainBA}
toolchainsOneNonempty := []string{toolchainAA, toolchainBA, toolchainCA}
toolchainsSameNonempty := []string{toolchainCA, toolchainDA}
allToolchains := []string{toolchainAA, toolchainBA, toolchainCA, toolchainCB, toolchainDA}
testCases := []struct {
field string
toolchains []string
expectedText string
}{
{field: "cxx_builtin_include_directories",
toolchains: toolchainsEmpty,
expectedText: `
cxx_builtin_include_directories = []`},
{field: "cxx_builtin_include_directories",
toolchains: toolchainsOneNonempty,
expectedText: `
if (ctx.attr.cpu == "cpuA"
or ctx.attr.cpu == "cpuB"):
cxx_builtin_include_directories = []
elif (ctx.attr.cpu == "cpuC"):
cxx_builtin_include_directories = ["dirC"]
else:
fail("Unreachable")`},
{field: "cxx_builtin_include_directories",
toolchains: toolchainsSameNonempty,
expectedText: `
cxx_builtin_include_directories = ["dirC"]`},
{field: "cxx_builtin_include_directories",
toolchains: allToolchains,
expectedText: `
if (ctx.attr.cpu == "cpuA"
or ctx.attr.cpu == "cpuB"):
cxx_builtin_include_directories = []
elif (ctx.attr.cpu == "cpuC" and ctx.attr.compiler == "compilerA"
or ctx.attr.cpu == "cpuD"):
cxx_builtin_include_directories = ["dirC"]
elif (ctx.attr.cpu == "cpuC" and ctx.attr.compiler == "compilerB"):
cxx_builtin_include_directories = ["dirC", "dirB"]`}}
for _, tc := range testCases {
crosstool := makeCrosstool(tc.toolchains)
got, err := Transform(crosstool)
if err != nil {
t.Fatalf("CROSSTOOL conversion failed: %v", err)
}
if !strings.Contains(got, tc.expectedText) {
t.Errorf("Failed to correctly convert '%s' field, expected to contain:\n%v\n",
tc.field, tc.expectedText)
t.Fatalf("Tested CROSSTOOL:\n%v\n\nGenerated rule:\n%v\n",
strings.Join(tc.toolchains, "\n"), got)
}
}
}
func TestMakeVariables(t *testing.T) {
toolchainEmpty1 := getCToolchain("1", "cpuA", "compilerA", []string{})
toolchainEmpty2 := getCToolchain("2", "cpuB", "compilerA", []string{})
toolchainA1 := getCToolchain("3", "cpuC", "compilerA",
[]string{"make_variable {name: 'A', value: 'a/b/c'}"})
toolchainA2 := getCToolchain("4", "cpuC", "compilerB",
[]string{"make_variable {name: 'A', value: 'a/b/c'}"})
toolchainAB := getCToolchain("5", "cpuC", "compilerC",
[]string{"make_variable {name: 'A', value: 'a/b/c'}",
"make_variable {name: 'B', value: 'a/b/c'}"})
toolchainBA := getCToolchain("6", "cpuD", "compilerA",
[]string{"make_variable {name: 'B', value: 'a/b/c'}",
"make_variable {name: 'A', value: 'a b c'}"})
toolchainsEmpty := []string{toolchainEmpty1, toolchainEmpty2}
toolchainsOneNonempty := []string{toolchainEmpty1, toolchainA1}
toolchainsSameNonempty := []string{toolchainA1, toolchainA2}
toolchainsDifferentOrder := []string{toolchainAB, toolchainBA}
allToolchains := []string{
toolchainEmpty1,
toolchainEmpty2,
toolchainA1,
toolchainA2,
toolchainAB,
toolchainBA,
}
testCases := []struct {
field string
toolchains []string
expectedText string
}{
{field: "make_variables",
toolchains: toolchainsEmpty,
expectedText: `
make_variables = []`},
{field: "make_variables",
toolchains: toolchainsOneNonempty,
expectedText: `
if (ctx.attr.cpu == "cpuA"):
make_variables = []
elif (ctx.attr.cpu == "cpuC"):
make_variables = [make_variable(name = "A", value = "a/b/c")]
else:
fail("Unreachable")`},
{field: "make_variables",
toolchains: toolchainsSameNonempty,
expectedText: `
make_variables = [make_variable(name = "A", value = "a/b/c")]`},
{field: "make_variables",
toolchains: toolchainsDifferentOrder,
expectedText: `
if (ctx.attr.cpu == "cpuC"):
make_variables = [
make_variable(name = "A", value = "a/b/c"),
make_variable(name = "B", value = "a/b/c"),
]
elif (ctx.attr.cpu == "cpuD"):
make_variables = [
make_variable(name = "B", value = "a/b/c"),
make_variable(name = "A", value = "a b c"),
]
else:
fail("Unreachable")`},
{field: "make_variables",
toolchains: allToolchains,
expectedText: `
if (ctx.attr.cpu == "cpuC" and ctx.attr.compiler == "compilerC"):
make_variables = [
make_variable(name = "A", value = "a/b/c"),
make_variable(name = "B", value = "a/b/c"),
]
elif (ctx.attr.cpu == "cpuD"):
make_variables = [
make_variable(name = "B", value = "a/b/c"),
make_variable(name = "A", value = "a b c"),
]
elif (ctx.attr.cpu == "cpuA"
or ctx.attr.cpu == "cpuB"):
make_variables = []
elif (ctx.attr.cpu == "cpuC" and ctx.attr.compiler == "compilerA"
or ctx.attr.cpu == "cpuC" and ctx.attr.compiler == "compilerB"):
make_variables = [make_variable(name = "A", value = "a/b/c")]
else:
fail("Unreachable")`}}
for _, tc := range testCases {
crosstool := makeCrosstool(tc.toolchains)
got, err := Transform(crosstool)
if err != nil {
t.Fatalf("CROSSTOOL conversion failed: %v", err)
}
if !strings.Contains(got, tc.expectedText) {
t.Errorf("Failed to correctly convert '%s' field, expected to contain:\n%v\n",
tc.field, tc.expectedText)
t.Fatalf("Tested CROSSTOOL:\n%v\n\nGenerated rule:\n%v\n",
strings.Join(tc.toolchains, "\n"), got)
}
}
}
func TestToolPaths(t *testing.T) {
toolchainEmpty1 := getCToolchain("1", "cpuA", "compilerA", []string{})
toolchainEmpty2 := getCToolchain("2", "cpuB", "compilerA", []string{})
toolchainA1 := getCToolchain("3", "cpuC", "compilerA",
[]string{"tool_path {name: 'A', path: 'a/b/c'}"})
toolchainA2 := getCToolchain("4", "cpuC", "compilerB",
[]string{"tool_path {name: 'A', path: 'a/b/c'}"})
toolchainAB := getCToolchain("5", "cpuC", "compilerC",
[]string{"tool_path {name: 'A', path: 'a/b/c'}",
"tool_path {name: 'B', path: 'a/b/c'}"})
toolchainBA := getCToolchain("6", "cpuD", "compilerA",
[]string{"tool_path {name: 'B', path: 'a/b/c'}",
"tool_path {name: 'A', path: 'a/b/c'}"})
toolchainsEmpty := []string{toolchainEmpty1, toolchainEmpty2}
toolchainsOneNonempty := []string{toolchainEmpty1, toolchainA1}
toolchainsSameNonempty := []string{toolchainA1, toolchainA2}
toolchainsDifferentOrder := []string{toolchainAB, toolchainBA}
allToolchains := []string{
toolchainEmpty1,
toolchainEmpty2,
toolchainA1,
toolchainA2,
toolchainAB,
toolchainBA,
}
testCases := []struct {
field string
toolchains []string
expectedText string
}{
{field: "tool_paths",
toolchains: toolchainsEmpty,
expectedText: `
tool_paths = []`},
{field: "tool_paths",
toolchains: toolchainsOneNonempty,
expectedText: `
if (ctx.attr.cpu == "cpuA"):
tool_paths = []
elif (ctx.attr.cpu == "cpuC"):
tool_paths = [tool_path(name = "A", path = "a/b/c")]
else:
fail("Unreachable")`},
{field: "tool_paths",
toolchains: toolchainsSameNonempty,
expectedText: `
tool_paths = [tool_path(name = "A", path = "a/b/c")]`},
{field: "tool_paths",
toolchains: toolchainsDifferentOrder,
expectedText: `
if (ctx.attr.cpu == "cpuC"):
tool_paths = [
tool_path(name = "A", path = "a/b/c"),
tool_path(name = "B", path = "a/b/c"),
]
elif (ctx.attr.cpu == "cpuD"):
tool_paths = [
tool_path(name = "B", path = "a/b/c"),
tool_path(name = "A", path = "a/b/c"),
]
else:
fail("Unreachable")`},
{field: "tool_paths",
toolchains: allToolchains,
expectedText: `
if (ctx.attr.cpu == "cpuC" and ctx.attr.compiler == "compilerC"):
tool_paths = [
tool_path(name = "A", path = "a/b/c"),
tool_path(name = "B", path = "a/b/c"),
]
elif (ctx.attr.cpu == "cpuD"):
tool_paths = [
tool_path(name = "B", path = "a/b/c"),
tool_path(name = "A", path = "a/b/c"),
]
elif (ctx.attr.cpu == "cpuA"
or ctx.attr.cpu == "cpuB"):
tool_paths = []
elif (ctx.attr.cpu == "cpuC" and ctx.attr.compiler == "compilerA"
or ctx.attr.cpu == "cpuC" and ctx.attr.compiler == "compilerB"):
tool_paths = [tool_path(name = "A", path = "a/b/c")]
else:
fail("Unreachable")`}}
for _, tc := range testCases {
crosstool := makeCrosstool(tc.toolchains)
got, err := Transform(crosstool)
if err != nil {
t.Fatalf("CROSSTOOL conversion failed: %v", err)
}
if !strings.Contains(got, tc.expectedText) {
t.Errorf("Failed to correctly convert '%s' field, expected to contain:\n%v\n",
tc.field, tc.expectedText)
t.Fatalf("Tested CROSSTOOL:\n%v\n\nGenerated rule:\n%v\n",
strings.Join(tc.toolchains, "\n"), got)
}
}
}
func getArtifactNamePattern(lines []string) string {
return fmt.Sprintf(`artifact_name_pattern {
%s
}`, strings.Join(lines, "\n "))
}
func TestArtifactNamePatterns(t *testing.T) {
toolchainEmpty1 := getCToolchain("1", "cpuA", "compilerA", []string{})
toolchainEmpty2 := getCToolchain("2", "cpuB", "compilerA", []string{})
toolchainA1 := getCToolchain("3", "cpuC", "compilerA",
[]string{
getArtifactNamePattern([]string{
"category_name: 'A'",
"prefix: 'p'",
"extension: '.exe'"}),
},
)
toolchainA2 := getCToolchain("4", "cpuC", "compilerB",
[]string{
getArtifactNamePattern([]string{
"category_name: 'A'",
"prefix: 'p'",
"extension: '.exe'"}),
},
)
toolchainAB := getCToolchain("5", "cpuC", "compilerC",
[]string{
getArtifactNamePattern([]string{
"category_name: 'A'",
"prefix: 'p'",
"extension: '.exe'"}),
getArtifactNamePattern([]string{
"category_name: 'B'",
"prefix: 'p'",
"extension: '.exe'"}),
},
)
toolchainBA := getCToolchain("6", "cpuD", "compilerA",
[]string{
getArtifactNamePattern([]string{
"category_name: 'B'",
"prefix: 'p'",
"extension: '.exe'"}),
getArtifactNamePattern([]string{
"category_name: 'A'",
"prefix: 'p'",
"extension: '.exe'"}),
},
)
toolchainsEmpty := []string{toolchainEmpty1, toolchainEmpty2}
toolchainsOneNonempty := []string{toolchainEmpty1, toolchainA1}
toolchainsSameNonempty := []string{toolchainA1, toolchainA2}
toolchainsDifferentOrder := []string{toolchainAB, toolchainBA}
allToolchains := []string{
toolchainEmpty1,
toolchainEmpty2,
toolchainA1,
toolchainA2,
toolchainAB,
toolchainBA,
}
testCases := []struct {
field string
toolchains []string
expectedText string
}{
{field: "artifact_name_patterns",
toolchains: toolchainsEmpty,
expectedText: `
artifact_name_patterns = []`},
{field: "artifact_name_patterns",
toolchains: toolchainsOneNonempty,
expectedText: `
if (ctx.attr.cpu == "cpuC"):
artifact_name_patterns = [
artifact_name_pattern(
category_name = "A",
prefix = "p",
extension = ".exe",
),
]
elif (ctx.attr.cpu == "cpuA"):
artifact_name_patterns = []
else:
fail("Unreachable")`},
{field: "artifact_name_patterns",
toolchains: toolchainsSameNonempty,
expectedText: `
artifact_name_patterns = [
artifact_name_pattern(
category_name = "A",
prefix = "p",
extension = ".exe",
),
]`},
{field: "artifact_name_patterns",
toolchains: toolchainsDifferentOrder,
expectedText: `
if (ctx.attr.cpu == "cpuC"):
artifact_name_patterns = [
artifact_name_pattern(
category_name = "A",
prefix = "p",
extension = ".exe",
),
artifact_name_pattern(
category_name = "B",
prefix = "p",
extension = ".exe",
),
]
elif (ctx.attr.cpu == "cpuD"):
artifact_name_patterns = [
artifact_name_pattern(
category_name = "B",
prefix = "p",
extension = ".exe",
),
artifact_name_pattern(
category_name = "A",
prefix = "p",
extension = ".exe",
),
]
else:
fail("Unreachable")`},
{field: "artifact_name_patterns",
toolchains: allToolchains,
expectedText: `
if (ctx.attr.cpu == "cpuC" and ctx.attr.compiler == "compilerC"):
artifact_name_patterns = [
artifact_name_pattern(
category_name = "A",
prefix = "p",
extension = ".exe",
),
artifact_name_pattern(
category_name = "B",
prefix = "p",
extension = ".exe",
),
]
elif (ctx.attr.cpu == "cpuC" and ctx.attr.compiler == "compilerA"
or ctx.attr.cpu == "cpuC" and ctx.attr.compiler == "compilerB"):
artifact_name_patterns = [
artifact_name_pattern(
category_name = "A",
prefix = "p",
extension = ".exe",
),
]
elif (ctx.attr.cpu == "cpuD"):
artifact_name_patterns = [
artifact_name_pattern(
category_name = "B",
prefix = "p",
extension = ".exe",
),
artifact_name_pattern(
category_name = "A",
prefix = "p",
extension = ".exe",
),
]
elif (ctx.attr.cpu == "cpuA"
or ctx.attr.cpu == "cpuB"):
artifact_name_patterns = []
else:
fail("Unreachable")`}}
for _, tc := range testCases {
crosstool := makeCrosstool(tc.toolchains)
got, err := Transform(crosstool)
if err != nil {
t.Fatalf("CROSSTOOL conversion failed: %v", err)
}
if !strings.Contains(got, tc.expectedText) {
t.Errorf("Failed to correctly convert '%s' field, expected to contain:\n%v\n",
tc.field, tc.expectedText)
t.Fatalf("Tested CROSSTOOL:\n%v\n\nGenerated rule:\n%v\n",
strings.Join(tc.toolchains, "\n"), got)
}
}
}
func getFeature(lines []string) string {
return fmt.Sprintf(`feature {
%s
}`, strings.Join(lines, "\n "))
}
func TestFeatureListAssignment(t *testing.T) {
toolchainEmpty1 := getCToolchain("1", "cpuA", "compilerA", []string{})
toolchainEmpty2 := getCToolchain("2", "cpuB", "compilerA", []string{})
toolchainA1 := getCToolchain("3", "cpuC", "compilerA",
[]string{getFeature([]string{"name: 'A'"})},
)
toolchainA2 := getCToolchain("4", "cpuC", "compilerB",
[]string{getFeature([]string{"name: 'A'"})},
)
toolchainAB := getCToolchain("5", "cpuC", "compilerC",
[]string{
getFeature([]string{"name: 'A'"}),
getFeature([]string{"name: 'B'"}),
},
)
toolchainBA := getCToolchain("6", "cpuD", "compilerA",
[]string{
getFeature([]string{"name: 'B'"}),
getFeature([]string{"name: 'A'"}),
},
)
toolchainsEmpty := []string{toolchainEmpty1, toolchainEmpty2}
toolchainsOneNonempty := []string{toolchainEmpty1, toolchainA1}
toolchainsSameNonempty := []string{toolchainA1, toolchainA2}
toolchainsDifferentOrder := []string{toolchainAB, toolchainBA}
allToolchains := []string{
toolchainEmpty1,
toolchainEmpty2,
toolchainA1,
toolchainA2,
toolchainAB,
toolchainBA,
}
testCases := []struct {
field string
toolchains []string
expectedText string
}{
{field: "features",
toolchains: toolchainsEmpty,
expectedText: `
features = []`},
{field: "features",
toolchains: toolchainsOneNonempty,
expectedText: `
if (ctx.attr.cpu == "cpuA"):
features = []
elif (ctx.attr.cpu == "cpuC"):
features = [a_feature]
else:
fail("Unreachable")`},
{field: "features",
toolchains: toolchainsSameNonempty,
expectedText: `
features = [a_feature]`},
{field: "features",
toolchains: toolchainsDifferentOrder,
expectedText: `
if (ctx.attr.cpu == "cpuC"):
features = [a_feature, b_feature]
elif (ctx.attr.cpu == "cpuD"):
features = [b_feature, a_feature]
else:
fail("Unreachable")`},
{field: "features",
toolchains: allToolchains,
expectedText: `
if (ctx.attr.cpu == "cpuA"
or ctx.attr.cpu == "cpuB"):
features = []
elif (ctx.attr.cpu == "cpuC" and ctx.attr.compiler == "compilerA"
or ctx.attr.cpu == "cpuC" and ctx.attr.compiler == "compilerB"):
features = [a_feature]
elif (ctx.attr.cpu == "cpuC" and ctx.attr.compiler == "compilerC"):
features = [a_feature, b_feature]
elif (ctx.attr.cpu == "cpuD"):
features = [b_feature, a_feature]
else:
fail("Unreachable")`}}
for _, tc := range testCases {
crosstool := makeCrosstool(tc.toolchains)
got, err := Transform(crosstool)
if err != nil {
t.Fatalf("CROSSTOOL conversion failed: %v", err)
}
if !strings.Contains(got, tc.expectedText) {
t.Errorf("Failed to correctly convert '%s' field, expected to contain:\n%v\n",
tc.field, tc.expectedText)
t.Fatalf("Tested CROSSTOOL:\n%v\n\nGenerated rule:\n%v\n",
strings.Join(tc.toolchains, "\n"), got)
}
}
}
func getActionConfig(lines []string) string {
return fmt.Sprintf(`action_config {
%s
}`, strings.Join(lines, "\n "))
}
func TestActionConfigListAssignment(t *testing.T) {
toolchainEmpty1 := getCToolchain("1", "cpuA", "compilerA", []string{})
toolchainEmpty2 := getCToolchain("2", "cpuB", "compilerA", []string{})
toolchainA1 := getCToolchain("3", "cpuC", "compilerA",
[]string{
getActionConfig([]string{"action_name: 'A'", "config_name: 'A'"}),
},
)
toolchainA2 := getCToolchain("4", "cpuC", "compilerB",
[]string{
getActionConfig([]string{"action_name: 'A'", "config_name: 'A'"}),
},
)
toolchainAB := getCToolchain("5", "cpuC", "compilerC",
[]string{
getActionConfig([]string{"action_name: 'A'", "config_name: 'A'"}),
getActionConfig([]string{"action_name: 'B'", "config_name: 'B'"}),
},
)
toolchainBA := getCToolchain("6", "cpuD", "compilerA",
[]string{
getActionConfig([]string{"action_name: 'B'", "config_name: 'B'"}),
getActionConfig([]string{"action_name: 'A'", "config_name: 'A'"}),
},
)
toolchainsEmpty := []string{toolchainEmpty1, toolchainEmpty2}
toolchainsOneNonempty := []string{toolchainEmpty1, toolchainA1}
toolchainsSameNonempty := []string{toolchainA1, toolchainA2}
toolchainsDifferentOrder := []string{toolchainAB, toolchainBA}
allToolchains := []string{
toolchainEmpty1,
toolchainEmpty2,
toolchainA1,
toolchainA2,
toolchainAB,
toolchainBA,
}
testCases := []struct {
field string
toolchains []string
expectedText string
}{
{field: "action_configs",
toolchains: toolchainsEmpty,
expectedText: `
action_configs = []`},
{field: "action_configs",
toolchains: toolchainsOneNonempty,
expectedText: `
if (ctx.attr.cpu == "cpuA"):
action_configs = []
elif (ctx.attr.cpu == "cpuC"):
action_configs = [a_action]
else:
fail("Unreachable")`},
{field: "action_configs",
toolchains: toolchainsSameNonempty,
expectedText: `
action_configs = [a_action]`},
{field: "action_configs",
toolchains: toolchainsDifferentOrder,
expectedText: `
if (ctx.attr.cpu == "cpuC"):
action_configs = [a_action, b_action]
elif (ctx.attr.cpu == "cpuD"):
action_configs = [b_action, a_action]
else:
fail("Unreachable")`},
{field: "action_configs",
toolchains: allToolchains,
expectedText: `
if (ctx.attr.cpu == "cpuA"
or ctx.attr.cpu == "cpuB"):
action_configs = []
elif (ctx.attr.cpu == "cpuC" and ctx.attr.compiler == "compilerA"
or ctx.attr.cpu == "cpuC" and ctx.attr.compiler == "compilerB"):
action_configs = [a_action]
elif (ctx.attr.cpu == "cpuC" and ctx.attr.compiler == "compilerC"):
action_configs = [a_action, b_action]
elif (ctx.attr.cpu == "cpuD"):
action_configs = [b_action, a_action]
else:
fail("Unreachable")`}}
for _, tc := range testCases {
crosstool := makeCrosstool(tc.toolchains)
got, err := Transform(crosstool)
if err != nil {
t.Fatalf("CROSSTOOL conversion failed: %v", err)
}
if !strings.Contains(got, tc.expectedText) {
t.Errorf("Failed to correctly convert '%s' field, expected to contain:\n%v\n",
tc.field, tc.expectedText)
t.Fatalf("Tested CROSSTOOL:\n%v\n\nGenerated rule:\n%v\n",
strings.Join(tc.toolchains, "\n"), got)
}
}
}
func TestAllAndNoneAvailableErrorsWhenMoreThanOneElement(t *testing.T) {
toolchainFeatureAllAvailable := getCToolchain("1", "cpu", "compiler",
[]string{getFeature([]string{
"name: 'A'",
"flag_set {",
" action: 'A'",
" flag_group {",
" flag: 'f'",
" expand_if_all_available: 'e1'",
" expand_if_all_available: 'e2'",
" }",
"}",
})},
)
toolchainFeatureNoneAvailable := getCToolchain("1", "cpu", "compiler",
[]string{getFeature([]string{
"name: 'A'",
"flag_set {",
" action: 'A'",
" flag_group {",
" flag: 'f'",
" expand_if_none_available: 'e1'",
" expand_if_none_available: 'e2'",
" }",
"}",
})},
)
toolchainActionConfigAllAvailable := getCToolchain("1", "cpu", "compiler",
[]string{getActionConfig([]string{
"config_name: 'A'",
"action_name: 'A'",
"flag_set {",
" action: 'A'",
" flag_group {",
" flag: 'f'",
" expand_if_all_available: 'e1'",
" expand_if_all_available: 'e2'",
" }",
"}",
})},
)
toolchainActionConfigNoneAvailable := getCToolchain("1", "cpu", "compiler",
[]string{getActionConfig([]string{
"config_name: 'A'",
"action_name: 'A'",
"flag_set {",
" action: 'A'",
" flag_group {",
" flag: 'f'",
" expand_if_none_available: 'e1'",
" expand_if_none_available: 'e2'",
" }",
"}",
})},
)
testCases := []struct {
field string
toolchain string
expectedText string
}{
{field: "features",
toolchain: toolchainFeatureAllAvailable,
expectedText: "Error in feature 'A': Flag group must not have more " +
"than one 'expand_if_all_available' field"},
{field: "features",
toolchain: toolchainFeatureNoneAvailable,
expectedText: "Error in feature 'A': Flag group must not have more " +
"than one 'expand_if_none_available' field"},
{field: "action_configs",
toolchain: toolchainActionConfigAllAvailable,
expectedText: "Error in action_config 'A': Flag group must not have more " +
"than one 'expand_if_all_available' field"},
{field: "action_configs",
toolchain: toolchainActionConfigNoneAvailable,
expectedText: "Error in action_config 'A': Flag group must not have more " +
"than one 'expand_if_none_available' field"},
}
for _, tc := range testCases {
crosstool := makeCrosstool([]string{tc.toolchain})
_, err := Transform(crosstool)
if err == nil || !strings.Contains(err.Error(), tc.expectedText) {
t.Errorf("Expected error: %s, got: %v", tc.expectedText, err)
}
}
}
func TestFeaturesAndActionConfigsSetToNoneWhenAllOptionsAreExausted(t *testing.T) {
toolchainFeatureAEnabled := getCToolchain("1", "cpuA", "compilerA",
[]string{getFeature([]string{"name: 'A'", "enabled: true"})},
)
toolchainFeatureADisabled := getCToolchain("2", "cpuA", "compilerB",
[]string{getFeature([]string{"name: 'A'", "enabled: false"})},
)
toolchainWithoutFeatureA := getCToolchain("3", "cpuA", "compilerC", []string{})
toolchainActionConfigAEnabled := getCToolchain("4", "cpuA", "compilerD",
[]string{getActionConfig([]string{
"config_name: 'A'",
"action_name: 'A'",
"enabled: true",
})})
toolchainActionConfigADisabled := getCToolchain("5", "cpuA", "compilerE",
[]string{getActionConfig([]string{
"config_name: 'A'",
"action_name: 'A'",
})})
toolchainWithoutActionConfigA := getCToolchain("6", "cpuA", "compilerF", []string{})
testCases := []struct {
field string
toolchains []string
expectedText string
}{
{field: "features",
toolchains: []string{
toolchainFeatureAEnabled, toolchainFeatureADisabled, toolchainWithoutFeatureA},
expectedText: `
if (ctx.attr.cpu == "cpuA" and ctx.attr.compiler == "compilerB"):
a_feature = feature(name = "A")
elif (ctx.attr.cpu == "cpuA" and ctx.attr.compiler == "compilerA"):
a_feature = feature(name = "A", enabled = True)
else:
a_feature = None
`},
{field: "action_config",
toolchains: []string{
toolchainActionConfigAEnabled, toolchainActionConfigADisabled, toolchainWithoutActionConfigA},
expectedText: `
if (ctx.attr.cpu == "cpuA" and ctx.attr.compiler == "compilerE"):
a_action = action_config(action_name = "A")
elif (ctx.attr.cpu == "cpuA" and ctx.attr.compiler == "compilerD"):
a_action = action_config(action_name = "A", enabled = True)
else:
a_action = None
`},
}
for _, tc := range testCases {
crosstool := makeCrosstool(tc.toolchains)
got, err := Transform(crosstool)
if err != nil {
t.Fatalf("CROSSTOOL conversion failed: %v", err)
}
if !strings.Contains(got, tc.expectedText) {
t.Errorf("Failed to correctly convert '%s' field, expected to contain:\n%v\n",
tc.field, tc.expectedText)
t.Fatalf("Tested CROSSTOOL:\n%v\n\nGenerated rule:\n%v\n",
strings.Join(tc.toolchains, "\n"), got)
}
}
}
func TestActionConfigDeclaration(t *testing.T) {
toolchainEmpty1 := getCToolchain("1", "cpuA", "compilerA", []string{})
toolchainEmpty2 := getCToolchain("2", "cpuB", "compilerA", []string{})
toolchainNameNotInDict := getCToolchain("3", "cpBC", "compilerB",
[]string{
getActionConfig([]string{"action_name: 'A-B.C'", "config_name: 'A-B.C'"}),
},
)
toolchainNameInDictA := getCToolchain("4", "cpuC", "compilerA",
[]string{
getActionConfig([]string{"action_name: 'c++-compile'", "config_name: 'c++-compile'"}),
},
)
toolchainNameInDictB := getCToolchain("5", "cpuC", "compilerB",
[]string{
getActionConfig([]string{
"action_name: 'c++-compile'",
"config_name: 'c++-compile'",
"tool {",
" tool_path: '/a/b/c'",
"}",
}),
},
)
toolchainComplexActionConfig := getCToolchain("6", "cpuC", "compilerC",
[]string{
getActionConfig([]string{
"action_name: 'action-complex'",
"config_name: 'action-complex'",
"enabled: true",
"tool {",
" tool_path: '/a/b/c'",
" with_feature {",
" feature: 'a'",
" feature: 'b'",
" not_feature: 'c'",
" not_feature: 'd'",
" }",
" with_feature{",
" feature: 'e'",
" }",
" execution_requirement: 'a'",
"}",
"tool {",
" tool_path: ''",
"}",
"flag_set {",
" flag_group {",
" flag: 'a'",
" flag: '%b'",
" iterate_over: 'c'",
" expand_if_all_available: 'd'",
" expand_if_none_available: 'e'",
" expand_if_true: 'f'",
" expand_if_false: 'g'",
" expand_if_equal {",
" variable: 'var'",
" value: 'val'",
" }",
" }",
" flag_group {",
" flag_group {",
" flag: 'a'",
" }",
" }",
"}",
"flag_set {",
" with_feature {",
" feature: 'a'",
" feature: 'b'",
" not_feature: 'c'",
" not_feature: 'd'",
" }",
"}",
"env_set {",
" action: 'a'",
" env_entry {",
" key: 'k'",
" value: 'v'",
" }",
" with_feature {",
" feature: 'a'",
" }",
"}",
"requires {",
" feature: 'a'",
" feature: 'b'",
"}",
"implies: 'a'",
"implies: 'b'",
}),
},
)
testCases := []struct {
toolchains []string
expectedText string
}{
{
toolchains: []string{toolchainEmpty1, toolchainEmpty2},
expectedText: `
action_configs = []`},
{
toolchains: []string{toolchainEmpty1, toolchainNameNotInDict},
expectedText: `
a_b_c_action = action_config(action_name = "A-B.C")`},
{
toolchains: []string{toolchainNameInDictA, toolchainNameInDictB},
expectedText: `
if (ctx.attr.cpu == "cpuC" and ctx.attr.compiler == "compilerB"):
cpp_compile_action = action_config(
action_name = ACTION_NAMES.cpp_compile,
tools = [tool(path = "/a/b/c")],
)
elif (ctx.attr.cpu == "cpuC" and ctx.attr.compiler == "compilerA"):
cpp_compile_action = action_config(action_name = ACTION_NAMES.cpp_compile)`},
{
toolchains: []string{toolchainComplexActionConfig},
expectedText: `
action_complex_action = action_config(
action_name = "action-complex",
enabled = True,
flag_sets = [
flag_set(
flag_groups = [
flag_group(
flags = ["a", "%b"],
iterate_over = "c",
expand_if_available = "d",
expand_if_not_available = "e",
expand_if_true = "f",
expand_if_false = "g",
expand_if_equal = variable_with_value(name = "var", value = "val"),
),
flag_group(flag_groups = [flag_group(flags = ["a"])]),
],
),
flag_set(
with_features = [
with_feature_set(
features = ["a", "b"],
not_features = ["c", "d"],
),
],
),
],
implies = ["a", "b"],
tools = [
tool(
path = "/a/b/c",
with_features = [
with_feature_set(
features = ["a", "b"],
not_features = ["c", "d"],
),
with_feature_set(features = ["e"]),
],
execution_requirements = ["a"],
),
tool(path = "NOT_USED"),
],
)`}}
for _, tc := range testCases {
crosstool := makeCrosstool(tc.toolchains)
got, err := Transform(crosstool)
if err != nil {
t.Fatalf("CROSSTOOL conversion failed: %v", err)
}
if !strings.Contains(got, tc.expectedText) {
t.Errorf("Failed to correctly declare an action_config, expected to contain:\n%v\n",
tc.expectedText)
t.Fatalf("Tested CROSSTOOL:\n%v\n\nGenerated rule:\n%v\n",
strings.Join(tc.toolchains, "\n"), got)
}
}
}
func TestFeatureDeclaration(t *testing.T) {
toolchainEmpty1 := getCToolchain("1", "cpuA", "compilerA", []string{})
toolchainEmpty2 := getCToolchain("2", "cpuB", "compilerA", []string{})
toolchainSimpleFeatureA1 := getCToolchain("3", "cpuB", "compilerB",
[]string{
getFeature([]string{"name: 'Feature-c++.a'", "enabled: true"}),
},
)
toolchainSimpleFeatureA2 := getCToolchain("4", "cpuC", "compilerA",
[]string{
getFeature([]string{"name: 'Feature-c++.a'"}),
},
)
toolchainComplexFeature := getCToolchain("5", "cpuC", "compilerC",
[]string{
getFeature([]string{
"name: 'complex-feature'",
"enabled: true",
"flag_set {",
" action: 'c++-compile'", // in ACTION_NAMES
" action: 'something-else'", // not in ACTION_NAMES
" flag_group {",
" flag: 'a'",
" flag: '%b'",
" iterate_over: 'c'",
" expand_if_all_available: 'd'",
" expand_if_none_available: 'e'",
" expand_if_true: 'f'",
" expand_if_false: 'g'",
" expand_if_equal {",
" variable: 'var'",
" value: 'val'",
" }",
" }",
" flag_group {",
" flag_group {",
" flag: 'a'",
" }",
" }",
"}",
"flag_set {", // all_compile_actions
" action: 'c-compile'",
" action: 'c++-compile'",
" action: 'linkstamp-compile'",
" action: 'assemble'",
" action: 'preprocess-assemble'",
" action: 'c++-header-parsing'",
" action: 'c++-module-compile'",
" action: 'c++-module-codegen'",
" action: 'clif-match'",
" action: 'lto-backend'",
"}",
"flag_set {", // all_cpp_compile_actions
" action: 'c++-compile'",
" action: 'linkstamp-compile'",
" action: 'c++-header-parsing'",
" action: 'c++-module-compile'",
" action: 'c++-module-codegen'",
" action: 'clif-match'",
"}",
"flag_set {", // all_link_actions
" action: 'c++-link-executable'",
" action: 'c++-link-dynamic-library'",
" action: 'c++-link-nodeps-dynamic-library'",
"}",
"flag_set {", // all_cpp_compile_actions + all_link_actions
" action: 'c++-compile'",
" action: 'linkstamp-compile'",
" action: 'c++-header-parsing'",
" action: 'c++-module-compile'",
" action: 'c++-module-codegen'",
" action: 'clif-match'",
" action: 'c++-link-executable'",
" action: 'c++-link-dynamic-library'",
" action: 'c++-link-nodeps-dynamic-library'",
"}",
"flag_set {", // all_link_actions + something else
" action: 'c++-link-executable'",
" action: 'c++-link-dynamic-library'",
" action: 'c++-link-nodeps-dynamic-library'",
" action: 'some.unknown-c++.action'",
"}",
"env_set {",
" action: 'a'",
" env_entry {",
" key: 'k'",
" value: 'v'",
" }",
" with_feature {",
" feature: 'a'",
" }",
"}",
"env_set {",
" action: 'c-compile'",
"}",
"env_set {", // all_compile_actions
" action: 'c-compile'",
" action: 'c++-compile'",
" action: 'linkstamp-compile'",
" action: 'assemble'",
" action: 'preprocess-assemble'",
" action: 'c++-header-parsing'",
" action: 'c++-module-compile'",
" action: 'c++-module-codegen'",
" action: 'clif-match'",
" action: 'lto-backend'",
"}",
"requires {",
" feature: 'a'",
" feature: 'b'",
"}",
"implies: 'a'",
"implies: 'b'",
"provides: 'c'",
"provides: 'd'",
}),
},
)
testCases := []struct {
toolchains []string
expectedText string
}{
{
toolchains: []string{toolchainEmpty1, toolchainEmpty2},
expectedText: `
features = []
`},
{
toolchains: []string{toolchainEmpty1, toolchainSimpleFeatureA1},
expectedText: `
feature_cpp_a_feature = feature(name = "Feature-c++.a", enabled = True)`},
{
toolchains: []string{toolchainSimpleFeatureA1, toolchainSimpleFeatureA2},
expectedText: `
if (ctx.attr.cpu == "cpuC"):
feature_cpp_a_feature = feature(name = "Feature-c++.a")
elif (ctx.attr.cpu == "cpuB"):
feature_cpp_a_feature = feature(name = "Feature-c++.a", enabled = True)`},
{
toolchains: []string{toolchainComplexFeature},
expectedText: `
complex_feature_feature = feature(
name = "complex-feature",
enabled = True,
flag_sets = [
flag_set(
actions = [ACTION_NAMES.cpp_compile, "something-else"],
flag_groups = [
flag_group(
flags = ["a", "%b"],
iterate_over = "c",
expand_if_available = "d",
expand_if_not_available = "e",
expand_if_true = "f",
expand_if_false = "g",
expand_if_equal = variable_with_value(name = "var", value = "val"),
),
flag_group(flag_groups = [flag_group(flags = ["a"])]),
],
),
flag_set(actions = all_compile_actions),
flag_set(actions = all_cpp_compile_actions),
flag_set(actions = all_link_actions),
flag_set(
actions = all_cpp_compile_actions +
all_link_actions,
),
flag_set(
actions = all_link_actions +
["some.unknown-c++.action"],
),
],
env_sets = [
env_set(
actions = ["a"],
env_entries = [env_entry(key = "k", value = "v")],
with_features = [with_feature_set(features = ["a"])],
),
env_set(actions = [ACTION_NAMES.c_compile]),
env_set(actions = all_compile_actions),
],
requires = [feature_set(features = ["a", "b"])],
implies = ["a", "b"],
provides = ["c", "d"],
)`}}
for _, tc := range testCases {
crosstool := makeCrosstool(tc.toolchains)
got, err := Transform(crosstool)
if err != nil {
t.Fatalf("CROSSTOOL conversion failed: %v", err)
}
if !strings.Contains(got, tc.expectedText) {
t.Errorf("Failed to correctly declare a feature, expected to contain:\n%v\n",
tc.expectedText)
t.Fatalf("Tested CROSSTOOL:\n%v\n\nGenerated rule:\n%v\n",
strings.Join(tc.toolchains, "\n"), got)
}
}
}
func TestRule(t *testing.T) {
simpleToolchain := getSimpleCToolchain("simple")
expected := `load("@bazel_tools//tools/cpp:cc_toolchain_config_lib.bzl",
"action_config",
"artifact_name_pattern",
"env_entry",
"env_set",
"feature",
"feature_set",
"flag_group",
"flag_set",
"make_variable",
"tool",
"tool_path",
"variable_with_value",
"with_feature_set",
)
load("@bazel_tools//tools/build_defs/cc:action_names.bzl", "ACTION_NAMES")
def _impl(ctx):
toolchain_identifier = "id-simple"
host_system_name = "host-simple"
target_system_name = "target-simple"
target_cpu = "cpu-simple"
target_libc = "libc-simple"
compiler = "compiler-simple"
abi_version = "version-simple"
abi_libc_version = "libc_version-simple"
cc_target_os = None
builtin_sysroot = None
all_compile_actions = [
ACTION_NAMES.c_compile,
ACTION_NAMES.cpp_compile,
ACTION_NAMES.linkstamp_compile,
ACTION_NAMES.assemble,
ACTION_NAMES.preprocess_assemble,
ACTION_NAMES.cpp_header_parsing,
ACTION_NAMES.cpp_module_compile,
ACTION_NAMES.cpp_module_codegen,
ACTION_NAMES.clif_match,
ACTION_NAMES.lto_backend,
]
all_cpp_compile_actions = [
ACTION_NAMES.cpp_compile,
ACTION_NAMES.linkstamp_compile,
ACTION_NAMES.cpp_header_parsing,
ACTION_NAMES.cpp_module_compile,
ACTION_NAMES.cpp_module_codegen,
ACTION_NAMES.clif_match,
]
preprocessor_compile_actions = [
ACTION_NAMES.c_compile,
ACTION_NAMES.cpp_compile,
ACTION_NAMES.linkstamp_compile,
ACTION_NAMES.preprocess_assemble,
ACTION_NAMES.cpp_header_parsing,
ACTION_NAMES.cpp_module_compile,
ACTION_NAMES.clif_match,
]
codegen_compile_actions = [
ACTION_NAMES.c_compile,
ACTION_NAMES.cpp_compile,
ACTION_NAMES.linkstamp_compile,
ACTION_NAMES.assemble,
ACTION_NAMES.preprocess_assemble,
ACTION_NAMES.cpp_module_codegen,
ACTION_NAMES.lto_backend,
]
all_link_actions = [
ACTION_NAMES.cpp_link_executable,
ACTION_NAMES.cpp_link_dynamic_library,
ACTION_NAMES.cpp_link_nodeps_dynamic_library,
]
action_configs = []
features = []
cxx_builtin_include_directories = []
artifact_name_patterns = []
make_variables = []
tool_paths = []
out = ctx.actions.declare_file(ctx.label.name)
ctx.actions.write(out, "Fake executable")
return [
cc_common.create_cc_toolchain_config_info(
ctx = ctx,
features = features,
action_configs = action_configs,
artifact_name_patterns = artifact_name_patterns,
cxx_builtin_include_directories = cxx_builtin_include_directories,
toolchain_identifier = toolchain_identifier,
host_system_name = host_system_name,
target_system_name = target_system_name,
target_cpu = target_cpu,
target_libc = target_libc,
compiler = compiler,
abi_version = abi_version,
abi_libc_version = abi_libc_version,
tool_paths = tool_paths,
make_variables = make_variables,
builtin_sysroot = builtin_sysroot,
cc_target_os = cc_target_os
),
DefaultInfo(
executable = out,
),
]
cc_toolchain_config = rule(
implementation = _impl,
attrs = {
"cpu": attr.string(mandatory=True, values=["cpu-simple"]),
},
provides = [CcToolchainConfigInfo],
executable = True,
)
`
crosstool := makeCrosstool([]string{simpleToolchain})
got, err := Transform(crosstool)
if err != nil {
t.Fatalf("CROSSTOOL conversion failed: %v", err)
}
if got != expected {
t.Fatalf("Expected:\n%v\nGot:\n%v\nTested CROSSTOOL:\n%v",
expected, got, simpleToolchain)
}
}
func TestAllowedCompilerValues(t *testing.T) {
toolchainAA := getCToolchain("1", "cpuA", "compilerA", []string{})
toolchainBA := getCToolchain("2", "cpuB", "compilerA", []string{})
toolchainBB := getCToolchain("3", "cpuB", "compilerB", []string{})
toolchainCC := getCToolchain("4", "cpuC", "compilerC", []string{})
testCases := []struct {
toolchains []string
expectedText string
}{
{
toolchains: []string{toolchainAA, toolchainBA},
expectedText: `
cc_toolchain_config = rule(
implementation = _impl,
attrs = {
"cpu": attr.string(mandatory=True, values=["cpuA", "cpuB"]),
},
provides = [CcToolchainConfigInfo],
executable = True,
)
`},
{
toolchains: []string{toolchainBA, toolchainBB},
expectedText: `
cc_toolchain_config = rule(
implementation = _impl,
attrs = {
"cpu": attr.string(mandatory=True, values=["cpuB"]),
"compiler": attr.string(mandatory=True, values=["compilerA", "compilerB"]),
},
provides = [CcToolchainConfigInfo],
executable = True,
)
`},
{
toolchains: []string{toolchainAA, toolchainBA, toolchainBB},
expectedText: `
cc_toolchain_config = rule(
implementation = _impl,
attrs = {
"cpu": attr.string(mandatory=True, values=["cpuA", "cpuB"]),
"compiler": attr.string(mandatory=True, values=["compilerA", "compilerB"]),
},
provides = [CcToolchainConfigInfo],
executable = True,
)
`},
{
toolchains: []string{toolchainAA, toolchainBA, toolchainBB, toolchainCC},
expectedText: `
cc_toolchain_config = rule(
implementation = _impl,
attrs = {
"cpu": attr.string(mandatory=True, values=["cpuA", "cpuB", "cpuC"]),
"compiler": attr.string(mandatory=True, values=["compilerA", "compilerB", "compilerC"]),
},
provides = [CcToolchainConfigInfo],
executable = True,
)
`}}
for _, tc := range testCases {
crosstool := makeCrosstool(tc.toolchains)
got, err := Transform(crosstool)
if err != nil {
t.Fatalf("CROSSTOOL conversion failed: %v", err)
}
if !strings.Contains(got, tc.expectedText) {
t.Errorf("Failed to correctly declare the rule, expected to contain:\n%v\n",
tc.expectedText)
t.Fatalf("Tested CROSSTOOL:\n%v\n\nGenerated rule:\n%v\n",
strings.Join(tc.toolchains, "\n"), got)
}
}
}