blob: 48c8d74f6c60900d6a54eb7b1b50e3ae110dc802 [file] [log] [blame]
// Copyright 2019 The Android Open Source Project
//
// 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 rust
import (
"io/ioutil"
"os"
"runtime"
"strings"
"testing"
"github.com/google/blueprint/proptools"
"android/soong/android"
"android/soong/cc"
)
var (
buildDir string
)
func setUp() {
var err error
buildDir, err = ioutil.TempDir("", "soong_rust_test")
if err != nil {
panic(err)
}
}
func tearDown() {
os.RemoveAll(buildDir)
}
func TestMain(m *testing.M) {
run := func() int {
setUp()
defer tearDown()
return m.Run()
}
os.Exit(run())
}
// testRust returns a TestContext in which a basic environment has been setup.
// This environment contains a few mocked files. See testRustCtx.useMockedFs
// for the list of these files.
func testRust(t *testing.T, bp string) *android.TestContext {
tctx := newTestRustCtx(t, bp)
tctx.useMockedFs()
tctx.generateConfig()
return tctx.parse(t)
}
// testRustCov returns a TestContext in which a basic environment has been
// setup. This environment explicitly enables coverage.
func testRustCov(t *testing.T, bp string) *android.TestContext {
tctx := newTestRustCtx(t, bp)
tctx.useMockedFs()
tctx.generateConfig()
tctx.enableCoverage(t)
return tctx.parse(t)
}
// testRustError ensures that at least one error was raised and its value
// matches the pattern provided. The error can be either in the parsing of the
// Blueprint or when generating the build actions.
func testRustError(t *testing.T, pattern string, bp string) {
tctx := newTestRustCtx(t, bp)
tctx.useMockedFs()
tctx.generateConfig()
tctx.parseError(t, pattern)
}
// testRustCtx is used to build a particular test environment. Unless your
// tests requires a specific setup, prefer the wrapping functions: testRust,
// testRustCov or testRustError.
type testRustCtx struct {
bp string
fs map[string][]byte
env map[string]string
config *android.Config
}
// newTestRustCtx returns a new testRustCtx for the Blueprint definition argument.
func newTestRustCtx(t *testing.T, bp string) *testRustCtx {
// TODO (b/140435149)
if runtime.GOOS != "linux" {
t.Skip("Rust Soong tests can only be run on Linux hosts currently")
}
return &testRustCtx{bp: bp}
}
// useMockedFs setup a default mocked filesystem for the test environment.
func (tctx *testRustCtx) useMockedFs() {
tctx.fs = map[string][]byte{
"foo.rs": nil,
"foo.c": nil,
"src/bar.rs": nil,
"src/any.h": nil,
"proto.proto": nil,
"proto/buf.proto": nil,
"buf.proto": nil,
"foo.proto": nil,
"liby.so": nil,
"libz.so": nil,
}
}
// generateConfig creates the android.Config based on the bp, fs and env
// attributes of the testRustCtx.
func (tctx *testRustCtx) generateConfig() {
tctx.bp = tctx.bp + GatherRequiredDepsForTest()
tctx.bp = tctx.bp + cc.GatherRequiredDepsForTest(android.NoOsType)
cc.GatherRequiredFilesForTest(tctx.fs)
config := android.TestArchConfig(buildDir, tctx.env, tctx.bp, tctx.fs)
tctx.config = &config
}
// enableCoverage configures the test to enable coverage.
func (tctx *testRustCtx) enableCoverage(t *testing.T) {
if tctx.config == nil {
t.Fatalf("tctx.config not been generated yet. Please call generateConfig first.")
}
tctx.config.TestProductVariables.GcovCoverage = proptools.BoolPtr(true)
tctx.config.TestProductVariables.Native_coverage = proptools.BoolPtr(true)
tctx.config.TestProductVariables.NativeCoveragePaths = []string{"*"}
}
// parse validates the configuration and parses the Blueprint file. It returns
// a TestContext which can be used to retrieve the generated modules via
// ModuleForTests.
func (tctx testRustCtx) parse(t *testing.T) *android.TestContext {
if tctx.config == nil {
t.Fatalf("tctx.config not been generated yet. Please call generateConfig first.")
}
ctx := CreateTestContext(*tctx.config)
ctx.Register()
_, errs := ctx.ParseFileList(".", []string{"Android.bp"})
android.FailIfErrored(t, errs)
_, errs = ctx.PrepareBuildActions(*tctx.config)
android.FailIfErrored(t, errs)
return ctx
}
// parseError parses the Blueprint file and ensure that at least one error
// matching the provided pattern is observed.
func (tctx testRustCtx) parseError(t *testing.T, pattern string) {
if tctx.config == nil {
t.Fatalf("tctx.config not been generated yet. Please call generateConfig first.")
}
ctx := CreateTestContext(*tctx.config)
ctx.Register()
_, errs := ctx.ParseFileList(".", []string{"Android.bp"})
if len(errs) > 0 {
android.FailIfNoMatchingErrors(t, pattern, errs)
return
}
_, errs = ctx.PrepareBuildActions(*tctx.config)
if len(errs) > 0 {
android.FailIfNoMatchingErrors(t, pattern, errs)
return
}
t.Fatalf("missing expected error %q (0 errors are returned)", pattern)
}
// Test that we can extract the link path from a lib path.
func TestLinkPathFromFilePath(t *testing.T) {
barPath := android.PathForTesting("out/soong/.intermediates/external/libbar/libbar/linux_glibc_x86_64_shared/libbar.so")
libName := linkPathFromFilePath(barPath)
expectedResult := "out/soong/.intermediates/external/libbar/libbar/linux_glibc_x86_64_shared/"
if libName != expectedResult {
t.Errorf("libNameFromFilePath returned the wrong name; expected '%#v', got '%#v'", expectedResult, libName)
}
}
// Test to make sure dependencies are being picked up correctly.
func TestDepsTracking(t *testing.T) {
ctx := testRust(t, `
rust_ffi_host_static {
name: "libstatic",
srcs: ["foo.rs"],
crate_name: "static",
}
rust_ffi_host_shared {
name: "libshared",
srcs: ["foo.rs"],
crate_name: "shared",
}
rust_library_host_dylib {
name: "libdylib",
srcs: ["foo.rs"],
crate_name: "dylib",
}
rust_library_host_rlib {
name: "librlib",
srcs: ["foo.rs"],
crate_name: "rlib",
}
rust_proc_macro {
name: "libpm",
srcs: ["foo.rs"],
crate_name: "pm",
}
rust_binary_host {
name: "fizz-buzz",
dylibs: ["libdylib"],
rlibs: ["librlib"],
proc_macros: ["libpm"],
static_libs: ["libstatic"],
shared_libs: ["libshared"],
srcs: ["foo.rs"],
}
`)
module := ctx.ModuleForTests("fizz-buzz", "linux_glibc_x86_64").Module().(*Module)
// Since dependencies are added to AndroidMk* properties, we can check these to see if they've been picked up.
if !android.InList("libdylib", module.Properties.AndroidMkDylibs) {
t.Errorf("Dylib dependency not detected (dependency missing from AndroidMkDylibs)")
}
if !android.InList("librlib.rlib-std", module.Properties.AndroidMkRlibs) {
t.Errorf("Rlib dependency not detected (dependency missing from AndroidMkRlibs)")
}
if !android.InList("libpm", module.Properties.AndroidMkProcMacroLibs) {
t.Errorf("Proc_macro dependency not detected (dependency missing from AndroidMkProcMacroLibs)")
}
if !android.InList("libshared", module.Properties.AndroidMkSharedLibs) {
t.Errorf("Shared library dependency not detected (dependency missing from AndroidMkSharedLibs)")
}
if !android.InList("libstatic", module.Properties.AndroidMkStaticLibs) {
t.Errorf("Static library dependency not detected (dependency missing from AndroidMkStaticLibs)")
}
}
func TestSourceProviderDeps(t *testing.T) {
ctx := testRust(t, `
rust_binary {
name: "fizz-buzz-dep",
srcs: [
"foo.rs",
":my_generator",
":libbindings",
],
rlibs: ["libbindings"],
}
rust_proc_macro {
name: "libprocmacro",
srcs: [
"foo.rs",
":my_generator",
":libbindings",
],
rlibs: ["libbindings"],
crate_name: "procmacro",
}
rust_library {
name: "libfoo",
srcs: [
"foo.rs",
":my_generator",
":libbindings",
],
rlibs: ["libbindings"],
crate_name: "foo",
}
genrule {
name: "my_generator",
tools: ["any_rust_binary"],
cmd: "$(location) -o $(out) $(in)",
srcs: ["src/any.h"],
out: ["src/any.rs"],
}
rust_binary_host {
name: "any_rust_binary",
srcs: [
"foo.rs",
],
}
rust_bindgen {
name: "libbindings",
crate_name: "bindings",
source_stem: "bindings",
host_supported: true,
wrapper_src: "src/any.h",
}
`)
libfoo := ctx.ModuleForTests("libfoo", "android_arm64_armv8-a_rlib_dylib-std").Rule("rustc")
if !android.SuffixInList(libfoo.Implicits.Strings(), "/out/bindings.rs") {
t.Errorf("rust_bindgen generated source not included as implicit input for libfoo; Implicits %#v", libfoo.Implicits.Strings())
}
if !android.SuffixInList(libfoo.Implicits.Strings(), "/out/any.rs") {
t.Errorf("genrule generated source not included as implicit input for libfoo; Implicits %#v", libfoo.Implicits.Strings())
}
fizzBuzz := ctx.ModuleForTests("fizz-buzz-dep", "android_arm64_armv8-a").Rule("rustc")
if !android.SuffixInList(fizzBuzz.Implicits.Strings(), "/out/bindings.rs") {
t.Errorf("rust_bindgen generated source not included as implicit input for fizz-buzz-dep; Implicits %#v", libfoo.Implicits.Strings())
}
if !android.SuffixInList(fizzBuzz.Implicits.Strings(), "/out/any.rs") {
t.Errorf("genrule generated source not included as implicit input for fizz-buzz-dep; Implicits %#v", libfoo.Implicits.Strings())
}
libprocmacro := ctx.ModuleForTests("libprocmacro", "linux_glibc_x86_64").Rule("rustc")
if !android.SuffixInList(libprocmacro.Implicits.Strings(), "/out/bindings.rs") {
t.Errorf("rust_bindgen generated source not included as implicit input for libprocmacro; Implicits %#v", libfoo.Implicits.Strings())
}
if !android.SuffixInList(libprocmacro.Implicits.Strings(), "/out/any.rs") {
t.Errorf("genrule generated source not included as implicit input for libprocmacro; Implicits %#v", libfoo.Implicits.Strings())
}
// Check that our bindings are picked up as crate dependencies as well
libfooMod := ctx.ModuleForTests("libfoo", "android_arm64_armv8-a_dylib").Module().(*Module)
if !android.InList("libbindings.dylib-std", libfooMod.Properties.AndroidMkRlibs) {
t.Errorf("bindgen dependency not detected as a rlib dependency (dependency missing from AndroidMkRlibs)")
}
fizzBuzzMod := ctx.ModuleForTests("fizz-buzz-dep", "android_arm64_armv8-a").Module().(*Module)
if !android.InList("libbindings.dylib-std", fizzBuzzMod.Properties.AndroidMkRlibs) {
t.Errorf("bindgen dependency not detected as a rlib dependency (dependency missing from AndroidMkRlibs)")
}
libprocmacroMod := ctx.ModuleForTests("libprocmacro", "linux_glibc_x86_64").Module().(*Module)
if !android.InList("libbindings.rlib-std", libprocmacroMod.Properties.AndroidMkRlibs) {
t.Errorf("bindgen dependency not detected as a rlib dependency (dependency missing from AndroidMkRlibs)")
}
}
func TestSourceProviderTargetMismatch(t *testing.T) {
// This might error while building the dependency tree or when calling depsToPaths() depending on the lunched
// target, which results in two different errors. So don't check the error, just confirm there is one.
testRustError(t, ".*", `
rust_proc_macro {
name: "libprocmacro",
srcs: [
"foo.rs",
":libbindings",
],
crate_name: "procmacro",
}
rust_bindgen {
name: "libbindings",
crate_name: "bindings",
source_stem: "bindings",
wrapper_src: "src/any.h",
}
`)
}
// Test to make sure proc_macros use host variants when building device modules.
func TestProcMacroDeviceDeps(t *testing.T) {
ctx := testRust(t, `
rust_library_host_rlib {
name: "libbar",
srcs: ["foo.rs"],
crate_name: "bar",
}
rust_proc_macro {
name: "libpm",
rlibs: ["libbar"],
srcs: ["foo.rs"],
crate_name: "pm",
}
rust_binary {
name: "fizz-buzz",
proc_macros: ["libpm"],
srcs: ["foo.rs"],
}
`)
rustc := ctx.ModuleForTests("libpm", "linux_glibc_x86_64").Rule("rustc")
if !strings.Contains(rustc.Args["libFlags"], "libbar/linux_glibc_x86_64") {
t.Errorf("Proc_macro is not using host variant of dependent modules.")
}
}
// Test that no_stdlibs suppresses dependencies on rust standard libraries
func TestNoStdlibs(t *testing.T) {
ctx := testRust(t, `
rust_binary {
name: "fizz-buzz",
srcs: ["foo.rs"],
no_stdlibs: true,
}`)
module := ctx.ModuleForTests("fizz-buzz", "android_arm64_armv8-a").Module().(*Module)
if android.InList("libstd", module.Properties.AndroidMkDylibs) {
t.Errorf("no_stdlibs did not suppress dependency on libstd")
}
}
// Test that libraries provide both 32-bit and 64-bit variants.
func TestMultilib(t *testing.T) {
ctx := testRust(t, `
rust_library_rlib {
name: "libfoo",
srcs: ["foo.rs"],
crate_name: "foo",
}`)
_ = ctx.ModuleForTests("libfoo", "android_arm64_armv8-a_rlib_dylib-std")
_ = ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_rlib_dylib-std")
}