diff options
Diffstat (limited to 'rust/rust_test.go')
| -rw-r--r-- | rust/rust_test.go | 375 |
1 files changed, 262 insertions, 113 deletions
diff --git a/rust/rust_test.go b/rust/rust_test.go index 020581dfc..6ae05d988 100644 --- a/rust/rust_test.go +++ b/rust/rust_test.go @@ -15,122 +15,136 @@ package rust import ( - "io/ioutil" "os" "runtime" "strings" "testing" - "android/soong/android" - "android/soong/cc" -) + "github.com/google/blueprint/proptools" -var ( - buildDir string + "android/soong/android" + "android/soong/genrule" ) -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()) + os.Exit(m.Run()) } -func testConfig(bp string) android.Config { - bp = bp + GatherRequiredDepsForTest() +var prepareForRustTest = android.GroupFixturePreparers( + android.PrepareForTestWithArchMutator, + android.PrepareForTestWithDefaults, + android.PrepareForTestWithPrebuilts, - fs := map[string][]byte{ - "foo.rs": nil, - "src/bar.rs": nil, - "liby.so": nil, - "libz.so": nil, - } + genrule.PrepareForTestWithGenRuleBuildComponents, - cc.GatherRequiredFilesForTest(fs) + PrepareForIntegrationTestWithRust, +) - return android.TestArchConfig(buildDir, nil, bp, fs) +var rustMockedFiles = android.MockFS{ + "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, + "data.txt": nil, } +// testRust returns a TestContext in which a basic environment has been setup. +// This environment contains a few mocked files. See rustMockedFiles for the list of these files. func testRust(t *testing.T, bp string) *android.TestContext { - // TODO (b/140435149) - if runtime.GOOS != "linux" { - t.Skip("Only the Linux toolchain is supported for Rust") - } - - t.Helper() - config := testConfig(bp) - - t.Helper() - ctx := CreateTestContext() - ctx.Register(config) + skipTestIfOsNotSupported(t) + result := android.GroupFixturePreparers( + prepareForRustTest, + rustMockedFiles.AddToFixture(), + ). + RunTestWithBp(t, bp) + return result.TestContext +} - _, errs := ctx.ParseFileList(".", []string{"Android.bp"}) - android.FailIfErrored(t, errs) - _, errs = ctx.PrepareBuildActions(config) - android.FailIfErrored(t, errs) +func testRustVndk(t *testing.T, bp string) *android.TestContext { + skipTestIfOsNotSupported(t) + result := android.GroupFixturePreparers( + prepareForRustTest, + rustMockedFiles.AddToFixture(), + android.FixtureModifyProductVariables( + func(variables android.FixtureProductVariables) { + variables.DeviceVndkVersion = StringPtr("current") + variables.ProductVndkVersion = StringPtr("current") + variables.Platform_vndk_version = StringPtr("29") + }, + ), + ).RunTestWithBp(t, bp) + return result.TestContext +} - return ctx +// 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 { + skipTestIfOsNotSupported(t) + result := android.GroupFixturePreparers( + prepareForRustTest, + rustMockedFiles.AddToFixture(), + android.FixtureModifyProductVariables( + func(variables android.FixtureProductVariables) { + variables.ClangCoverage = proptools.BoolPtr(true) + variables.Native_coverage = proptools.BoolPtr(true) + variables.NativeCoveragePaths = []string{"*"} + }, + ), + ).RunTestWithBp(t, bp) + return result.TestContext } +// 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) { - // TODO (b/140435149) - if runtime.GOOS != "linux" { - t.Skip("Only the Linux toolchain is supported for Rust") - } - - t.Helper() - config := testConfig(bp) - - ctx := CreateTestContext() - ctx.Register(config) - - _, errs := ctx.ParseFileList(".", []string{"Android.bp"}) - if len(errs) > 0 { - android.FailIfNoMatchingErrors(t, pattern, errs) - return - } - - _, errs = ctx.PrepareBuildActions(config) - if len(errs) > 0 { - android.FailIfNoMatchingErrors(t, pattern, errs) - return - } - - t.Fatalf("missing expected error %q (0 errors are returned)", pattern) + skipTestIfOsNotSupported(t) + android.GroupFixturePreparers( + prepareForRustTest, + rustMockedFiles.AddToFixture(), + ). + ExtendWithErrorHandler(android.FixtureExpectsAtLeastOneErrorMatchingPattern(pattern)). + RunTestWithBp(t, bp) } -// Test that we can extract the lib name from a lib path. -func TestLibNameFromFilePath(t *testing.T) { - libBarPath := android.PathForTesting("out/soong/.intermediates/external/libbar/libbar/linux_glibc_x86_64_shared/libbar.so.so") - libLibPath := android.PathForTesting("out/soong/.intermediates/external/libbar/libbar/linux_glibc_x86_64_shared/liblib.dylib.so") - - libBarName := libNameFromFilePath(libBarPath) - libLibName := libNameFromFilePath(libLibPath) +// testRustVndkError is similar to testRustError, but can be used to test VNDK-related errors. +func testRustVndkError(t *testing.T, pattern string, bp string) { + skipTestIfOsNotSupported(t) + android.GroupFixturePreparers( + prepareForRustTest, + rustMockedFiles.AddToFixture(), + android.FixtureModifyProductVariables( + func(variables android.FixtureProductVariables) { + variables.DeviceVndkVersion = StringPtr("current") + variables.ProductVndkVersion = StringPtr("current") + variables.Platform_vndk_version = StringPtr("VER") + }, + ), + ). + ExtendWithErrorHandler(android.FixtureExpectsAtLeastOneErrorMatchingPattern(pattern)). + RunTestWithBp(t, bp) +} - expectedResult := "bar.so" - if libBarName != expectedResult { - t.Errorf("libNameFromFilePath returned the wrong name; expected '%#v', got '%#v'", expectedResult, libBarName) - } +// 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 +} - expectedResult = "lib.dylib" - if libLibName != expectedResult { - t.Errorf("libNameFromFilePath returned the wrong name; expected '%#v', got '%#v'", expectedResult, libLibPath) +func skipTestIfOsNotSupported(t *testing.T) { + // TODO (b/140435149) + if runtime.GOOS != "linux" { + t.Skip("Rust Soong tests can only be run on Linux hosts currently") } } @@ -148,12 +162,17 @@ func TestLinkPathFromFilePath(t *testing.T) { // Test to make sure dependencies are being picked up correctly. func TestDepsTracking(t *testing.T) { ctx := testRust(t, ` - rust_library_host_static { + rust_ffi_host_static { name: "libstatic", srcs: ["foo.rs"], crate_name: "static", } - rust_library_host_shared { + rust_ffi_host_static { + name: "libwholestatic", + srcs: ["foo.rs"], + crate_name: "wholestatic", + } + rust_ffi_host_shared { name: "libshared", srcs: ["foo.rs"], crate_name: "shared", @@ -167,6 +186,8 @@ func TestDepsTracking(t *testing.T) { name: "librlib", srcs: ["foo.rs"], crate_name: "rlib", + static_libs: ["libstatic"], + whole_static_libs: ["libwholestatic"], } rust_proc_macro { name: "libpm", @@ -184,13 +205,14 @@ func TestDepsTracking(t *testing.T) { } `) module := ctx.ModuleForTests("fizz-buzz", "linux_glibc_x86_64").Module().(*Module) + rustc := ctx.ModuleForTests("librlib", "linux_glibc_x86_64_rlib_rlib-std").Rule("rustc") // 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", module.Properties.AndroidMkRlibs) { + if !android.InList("librlib.rlib-std", module.Properties.AndroidMkRlibs) { t.Errorf("Rlib dependency not detected (dependency missing from AndroidMkRlibs)") } @@ -205,6 +227,125 @@ func TestDepsTracking(t *testing.T) { if !android.InList("libstatic", module.Properties.AndroidMkStaticLibs) { t.Errorf("Static library dependency not detected (dependency missing from AndroidMkStaticLibs)") } + + if !strings.Contains(rustc.Args["rustcFlags"], "-lstatic=wholestatic") { + t.Errorf("-lstatic flag not being passed to rustc for static library %#v", rustc.Args["rustcFlags"]) + } + +} + +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. @@ -215,25 +356,6 @@ func TestProcMacroDeviceDeps(t *testing.T) { srcs: ["foo.rs"], crate_name: "bar", } - // Make a dummy libstd to let resolution go through - rust_library_dylib { - name: "libstd", - crate_name: "std", - srcs: ["foo.rs"], - no_stdlibs: true, - } - rust_library_dylib { - name: "libterm", - crate_name: "term", - srcs: ["foo.rs"], - no_stdlibs: true, - } - rust_library_dylib { - name: "libtest", - crate_name: "test", - srcs: ["foo.rs"], - no_stdlibs: true, - } rust_proc_macro { name: "libpm", rlibs: ["libbar"], @@ -259,7 +381,7 @@ func TestNoStdlibs(t *testing.T) { rust_binary { name: "fizz-buzz", srcs: ["foo.rs"], - no_stdlibs: true, + no_stdlibs: true, }`) module := ctx.ModuleForTests("fizz-buzz", "android_arm64_armv8-a").Module().(*Module) @@ -267,3 +389,30 @@ func TestNoStdlibs(t *testing.T) { 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") +} + +// Test that library size measurements are generated. +func TestLibrarySizes(t *testing.T) { + ctx := testRust(t, ` + rust_library_dylib { + name: "libwaldo", + srcs: ["foo.rs"], + crate_name: "waldo", + }`) + + m := ctx.SingletonForTests("file_metrics") + m.Output("libwaldo.dylib.so.bloaty.csv") + m.Output("stripped/libwaldo.dylib.so.bloaty.csv") +} |