diff options
Diffstat (limited to 'libnativebridge/tests')
30 files changed, 1544 insertions, 0 deletions
diff --git a/libnativebridge/tests/Android.bp b/libnativebridge/tests/Android.bp new file mode 100644 index 0000000000..4ccf35e7d8 --- /dev/null +++ b/libnativebridge/tests/Android.bp @@ -0,0 +1,163 @@ +// +// Copyright (C) 2017 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. +// + +cc_defaults { + name: "libnativebridge-dummy-defaults", + defaults: [ + "art_defaults", + "art_test_defaults", + ], + // TODO(mast): Split up art_gtest_defaults so that it can be used for the + // following without pulling in lots of libs. + target: { + linux: { + cflags: [ + // gtest issue + "-Wno-used-but-marked-unused", + "-Wno-deprecated", + "-Wno-missing-noreturn", + ], + }, + }, + header_libs: ["libnativebridge-headers"], + cppflags: ["-fvisibility=protected"], +} + +cc_library_shared { + name: "libnativebridge-dummy", + srcs: ["DummyNativeBridge.cpp"], + defaults: ["libnativebridge-dummy-defaults"], +} + +cc_library_shared { + name: "libnativebridge2-dummy", + srcs: ["DummyNativeBridge2.cpp"], + defaults: ["libnativebridge-dummy-defaults"], +} + +cc_library_shared { + name: "libnativebridge3-dummy", + srcs: ["DummyNativeBridge3.cpp"], + defaults: ["libnativebridge-dummy-defaults"], +} + +cc_library_shared { + name: "libnativebridge6-dummy", + srcs: ["DummyNativeBridge6.cpp"], + defaults: ["libnativebridge-dummy-defaults"], + shared_libs: [ + "libnativebridge6prezygotefork", + ], +} + +// A helper library to produce dummy side effect of PreZygoteForkNativeBridge. +cc_library_shared { + name: "libnativebridge6prezygotefork", + srcs: ["NativeBridge6PreZygoteFork_lib.cpp"], + defaults: ["libnativebridge-dummy-defaults"], +} + +// Build the unit tests. +cc_defaults { + name: "libnativebridge-tests-defaults", + defaults: [ + "art_defaults", + "art_test_defaults", + ], + test_per_src: true, + // TODO(mast): Split up art_gtest_defaults so that it can be used for the + // following without pulling in lots of libs. + target: { + linux: { + cflags: [ + // gtest issue + "-Wno-used-but-marked-unused", + "-Wno-deprecated", + "-Wno-missing-noreturn", + ], + }, + }, + + srcs: [ + "CodeCacheCreate_test.cpp", + "CodeCacheExists_test.cpp", + "CodeCacheStatFail_test.cpp", + "CompleteFlow_test.cpp", + "InvalidCharsNativeBridge_test.cpp", + "NativeBridge2Signal_test.cpp", + "NativeBridgeVersion_test.cpp", + "NeedsNativeBridge_test.cpp", + "PreInitializeNativeBridge_test.cpp", + "PreInitializeNativeBridgeFail1_test.cpp", + "PreInitializeNativeBridgeFail2_test.cpp", + "ReSetupNativeBridge_test.cpp", + "UnavailableNativeBridge_test.cpp", + "ValidNameNativeBridge_test.cpp", + "NativeBridge3UnloadLibrary_test.cpp", + "NativeBridge3GetError_test.cpp", + "NativeBridge3IsPathSupported_test.cpp", + "NativeBridge3InitAnonymousNamespace_test.cpp", + "NativeBridge3CreateNamespace_test.cpp", + "NativeBridge3LoadLibraryExt_test.cpp", + "NativeBridge6PreZygoteFork_test.cpp", + ], + + shared_libs: [ + "liblog", + "libnativebridge-dummy", + "libnativebridge6prezygotefork", + ], + header_libs: ["libbase_headers"], +} + +cc_test { + name: "libnativebridge-tests", + defaults: ["libnativebridge-tests-defaults"], + shared_libs: ["libnativebridge"], +} + +cc_test { + name: "libnativebridge-lazy-tests", + defaults: ["libnativebridge-tests-defaults"], + host_supported: false, + shared_libs: ["libnativebridge_lazy"], +} + +// Build the test for the C API. +cc_test { + name: "libnativebridge-api-tests", + defaults: [ + "art_defaults", + "art_test_defaults", + ], + test_per_src: true, + // TODO(mast): Split up art_gtest_defaults so that it can be used for the + // following without pulling in lots of libs. + target: { + linux: { + cflags: [ + // gtest issue + "-Wno-used-but-marked-unused", + "-Wno-deprecated", + "-Wno-missing-noreturn", + ], + }, + }, + srcs: [ + "NativeBridgeApi.c", + ], + header_libs: ["libnativebridge-headers"], +} diff --git a/libnativebridge/tests/CodeCacheCreate_test.cpp b/libnativebridge/tests/CodeCacheCreate_test.cpp new file mode 100644 index 0000000000..58270c43dd --- /dev/null +++ b/libnativebridge/tests/CodeCacheCreate_test.cpp @@ -0,0 +1,51 @@ +/* + * Copyright (C) 2014 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. + */ + +#include "NativeBridgeTest.h" + +#include <errno.h> +#include <sys/stat.h> +#include <unistd.h> + +namespace android { + +// Tests that the bridge initialization creates the code_cache if it doesn't +// exists. +TEST_F(NativeBridgeTest, CodeCacheCreate) { + // Make sure that code_cache does not exists + struct stat st; + ASSERT_EQ(-1, stat(kCodeCache, &st)); + ASSERT_EQ(ENOENT, errno); + + // Init + ASSERT_TRUE(LoadNativeBridge(kNativeBridgeLibrary, nullptr)); + ASSERT_TRUE(PreInitializeNativeBridge(".", "isa")); + ASSERT_TRUE(InitializeNativeBridge(nullptr, nullptr)); + ASSERT_TRUE(NativeBridgeAvailable()); + ASSERT_FALSE(NativeBridgeError()); + + // Check that code_cache was created + ASSERT_EQ(0, stat(kCodeCache, &st)); + ASSERT_TRUE(S_ISDIR(st.st_mode)); + + // Clean up + UnloadNativeBridge(); + ASSERT_EQ(0, rmdir(kCodeCache)); + + ASSERT_FALSE(NativeBridgeError()); +} + +} // namespace android diff --git a/libnativebridge/tests/CodeCacheExists_test.cpp b/libnativebridge/tests/CodeCacheExists_test.cpp new file mode 100644 index 0000000000..8ba01586b5 --- /dev/null +++ b/libnativebridge/tests/CodeCacheExists_test.cpp @@ -0,0 +1,54 @@ +/* + * Copyright (C) 2014 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. + */ + +#include "NativeBridgeTest.h" + +#include <errno.h> +#include <sys/stat.h> +#include <unistd.h> + +namespace android { + +// Tests that the bridge is initialized without errors if the code_cache already +// exists. +TEST_F(NativeBridgeTest, CodeCacheExists) { + // Make sure that code_cache does not exists + struct stat st; + ASSERT_EQ(-1, stat(kCodeCache, &st)); + ASSERT_EQ(ENOENT, errno); + + // Create the code_cache + ASSERT_EQ(0, mkdir(kCodeCache, S_IRWXU | S_IRWXG | S_IXOTH)); + + // Init + ASSERT_TRUE(LoadNativeBridge(kNativeBridgeLibrary, nullptr)); + ASSERT_TRUE(PreInitializeNativeBridge(".", "isa")); + ASSERT_TRUE(InitializeNativeBridge(nullptr, nullptr)); + ASSERT_TRUE(NativeBridgeAvailable()); + ASSERT_FALSE(NativeBridgeError()); + + // Check that the code cache is still there + ASSERT_EQ(0, stat(kCodeCache, &st)); + ASSERT_TRUE(S_ISDIR(st.st_mode)); + + // Clean up + UnloadNativeBridge(); + ASSERT_EQ(0, rmdir(kCodeCache)); + + ASSERT_FALSE(NativeBridgeError()); +} + +} // namespace android diff --git a/libnativebridge/tests/CodeCacheStatFail_test.cpp b/libnativebridge/tests/CodeCacheStatFail_test.cpp new file mode 100644 index 0000000000..4ea519ee96 --- /dev/null +++ b/libnativebridge/tests/CodeCacheStatFail_test.cpp @@ -0,0 +1,51 @@ +/* + * Copyright (C) 2014 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. + */ + +#include "NativeBridgeTest.h" + +#include <errno.h> +#include <sys/stat.h> +#include <unistd.h> +#include <fcntl.h> + +namespace android { + +// Tests that the bridge is initialized without errors if the code_cache is +// existed as a file. +TEST_F(NativeBridgeTest, CodeCacheStatFail) { + int fd = creat(kCodeCache, O_RDWR); + ASSERT_NE(-1, fd); + close(fd); + + struct stat st; + ASSERT_EQ(-1, stat(kCodeCacheStatFail, &st)); + ASSERT_EQ(ENOTDIR, errno); + + // Init + ASSERT_TRUE(LoadNativeBridge(kNativeBridgeLibrary, nullptr)); + ASSERT_TRUE(PreInitializeNativeBridge(kCodeCacheStatFail, "isa")); + ASSERT_TRUE(InitializeNativeBridge(nullptr, nullptr)); + ASSERT_TRUE(NativeBridgeAvailable()); + ASSERT_FALSE(NativeBridgeError()); + + // Clean up + UnloadNativeBridge(); + + ASSERT_FALSE(NativeBridgeError()); + unlink(kCodeCache); +} + +} // namespace android diff --git a/libnativebridge/tests/CompleteFlow_test.cpp b/libnativebridge/tests/CompleteFlow_test.cpp new file mode 100644 index 0000000000..b033792301 --- /dev/null +++ b/libnativebridge/tests/CompleteFlow_test.cpp @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2014 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. + */ + +#include "NativeBridgeTest.h" + +#include <unistd.h> + +namespace android { + +TEST_F(NativeBridgeTest, CompleteFlow) { + // Init + ASSERT_TRUE(LoadNativeBridge(kNativeBridgeLibrary, nullptr)); + ASSERT_TRUE(NativeBridgeAvailable()); + ASSERT_TRUE(PreInitializeNativeBridge(".", "isa")); + ASSERT_TRUE(NativeBridgeAvailable()); + ASSERT_TRUE(InitializeNativeBridge(nullptr, nullptr)); + ASSERT_TRUE(NativeBridgeAvailable()); + + // Basic calls to check that nothing crashes + ASSERT_FALSE(NativeBridgeIsSupported(nullptr)); + ASSERT_EQ(nullptr, NativeBridgeLoadLibrary(nullptr, 0)); + ASSERT_EQ(nullptr, NativeBridgeGetTrampoline(nullptr, nullptr, nullptr, 0)); + + // Unload + UnloadNativeBridge(); + + ASSERT_FALSE(NativeBridgeAvailable()); + ASSERT_FALSE(NativeBridgeError()); + + // Clean-up code_cache + ASSERT_EQ(0, rmdir(kCodeCache)); +} + +} // namespace android diff --git a/libnativebridge/tests/DummyNativeBridge.cpp b/libnativebridge/tests/DummyNativeBridge.cpp new file mode 100644 index 0000000000..b9894f6b95 --- /dev/null +++ b/libnativebridge/tests/DummyNativeBridge.cpp @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2014 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. + */ + +// A dummy implementation of the native-bridge interface. + +#include "nativebridge/native_bridge.h" + +// NativeBridgeCallbacks implementations +extern "C" bool native_bridge_initialize(const android::NativeBridgeRuntimeCallbacks* /* art_cbs */, + const char* /* app_code_cache_dir */, + const char* /* isa */) { + return true; +} + +extern "C" void* native_bridge_loadLibrary(const char* /* libpath */, int /* flag */) { + return nullptr; +} + +extern "C" void* native_bridge_getTrampoline(void* /* handle */, const char* /* name */, + const char* /* shorty */, uint32_t /* len */) { + return nullptr; +} + +extern "C" bool native_bridge_isSupported(const char* /* libpath */) { + return false; +} + +extern "C" const struct android::NativeBridgeRuntimeValues* native_bridge_getAppEnv( + const char* /* abi */) { + return nullptr; +} + +android::NativeBridgeCallbacks NativeBridgeItf { + .version = 1, + .initialize = &native_bridge_initialize, + .loadLibrary = &native_bridge_loadLibrary, + .getTrampoline = &native_bridge_getTrampoline, + .isSupported = &native_bridge_isSupported, + .getAppEnv = &native_bridge_getAppEnv +}; diff --git a/libnativebridge/tests/DummyNativeBridge2.cpp b/libnativebridge/tests/DummyNativeBridge2.cpp new file mode 100644 index 0000000000..6920c74822 --- /dev/null +++ b/libnativebridge/tests/DummyNativeBridge2.cpp @@ -0,0 +1,76 @@ +/* + * Copyright (C) 2014 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. + */ + +// A dummy implementation of the native-bridge interface. + +#include "nativebridge/native_bridge.h" + +#include <signal.h> + +// NativeBridgeCallbacks implementations +extern "C" bool native_bridge2_initialize(const android::NativeBridgeRuntimeCallbacks* /* art_cbs */, + const char* /* app_code_cache_dir */, + const char* /* isa */) { + return true; +} + +extern "C" void* native_bridge2_loadLibrary(const char* /* libpath */, int /* flag */) { + return nullptr; +} + +extern "C" void* native_bridge2_getTrampoline(void* /* handle */, const char* /* name */, + const char* /* shorty */, uint32_t /* len */) { + return nullptr; +} + +extern "C" bool native_bridge2_isSupported(const char* /* libpath */) { + return false; +} + +extern "C" const struct android::NativeBridgeRuntimeValues* native_bridge2_getAppEnv( + const char* /* abi */) { + return nullptr; +} + +extern "C" bool native_bridge2_is_compatible_compatible_with(uint32_t version) { + // For testing, allow 1 and 2, but disallow 3+. + return version <= 2; +} + +static bool native_bridge2_dummy_signal_handler(int, siginfo_t*, void*) { + // TODO: Implement something here. We'd either have to have a death test with a log here, or + // we'd have to be able to resume after the faulting instruction... + return true; +} + +extern "C" android::NativeBridgeSignalHandlerFn native_bridge2_get_signal_handler(int signal) { + if (signal == SIGSEGV) { + return &native_bridge2_dummy_signal_handler; + } + return nullptr; +} + +android::NativeBridgeCallbacks NativeBridgeItf { + .version = 2, + .initialize = &native_bridge2_initialize, + .loadLibrary = &native_bridge2_loadLibrary, + .getTrampoline = &native_bridge2_getTrampoline, + .isSupported = &native_bridge2_isSupported, + .getAppEnv = &native_bridge2_getAppEnv, + .isCompatibleWith = &native_bridge2_is_compatible_compatible_with, + .getSignalHandler = &native_bridge2_get_signal_handler +}; + diff --git a/libnativebridge/tests/DummyNativeBridge3.cpp b/libnativebridge/tests/DummyNativeBridge3.cpp new file mode 100644 index 0000000000..4ef1c82733 --- /dev/null +++ b/libnativebridge/tests/DummyNativeBridge3.cpp @@ -0,0 +1,124 @@ +/* + * Copyright (C) 2016 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. + */ + +// A dummy implementation of the native-bridge interface. + +#include "nativebridge/native_bridge.h" + +#include <signal.h> + +// NativeBridgeCallbacks implementations +extern "C" bool native_bridge3_initialize( + const android::NativeBridgeRuntimeCallbacks* /* art_cbs */, + const char* /* app_code_cache_dir */, + const char* /* isa */) { + return true; +} + +extern "C" void* native_bridge3_loadLibrary(const char* /* libpath */, int /* flag */) { + return nullptr; +} + +extern "C" void* native_bridge3_getTrampoline(void* /* handle */, const char* /* name */, + const char* /* shorty */, uint32_t /* len */) { + return nullptr; +} + +extern "C" bool native_bridge3_isSupported(const char* /* libpath */) { + return false; +} + +extern "C" const struct android::NativeBridgeRuntimeValues* native_bridge3_getAppEnv( + const char* /* abi */) { + return nullptr; +} + +extern "C" bool native_bridge3_isCompatibleWith(uint32_t version) { + // For testing, allow 1-3, but disallow 4+. + return version <= 3; +} + +static bool native_bridge3_dummy_signal_handler(int, siginfo_t*, void*) { + // TODO: Implement something here. We'd either have to have a death test with a log here, or + // we'd have to be able to resume after the faulting instruction... + return true; +} + +extern "C" android::NativeBridgeSignalHandlerFn native_bridge3_getSignalHandler(int signal) { + if (signal == SIGSEGV) { + return &native_bridge3_dummy_signal_handler; + } + return nullptr; +} + +extern "C" int native_bridge3_unloadLibrary(void* /* handle */) { + return 0; +} + +extern "C" const char* native_bridge3_getError() { + return nullptr; +} + +extern "C" bool native_bridge3_isPathSupported(const char* /* path */) { + return true; +} + +extern "C" bool native_bridge3_initAnonymousNamespace(const char* /* public_ns_sonames */, + const char* /* anon_ns_library_path */) { + return true; +} + +extern "C" android::native_bridge_namespace_t* +native_bridge3_createNamespace(const char* /* name */, + const char* /* ld_library_path */, + const char* /* default_library_path */, + uint64_t /* type */, + const char* /* permitted_when_isolated_path */, + android::native_bridge_namespace_t* /* parent_ns */) { + return nullptr; +} + +extern "C" bool native_bridge3_linkNamespaces(android::native_bridge_namespace_t* /* from */, + android::native_bridge_namespace_t* /* to */, + const char* /* shared_libs_soname */) { + return true; +} + +extern "C" void* native_bridge3_loadLibraryExt(const char* /* libpath */, + int /* flag */, + android::native_bridge_namespace_t* /* ns */) { + return nullptr; +} + +android::NativeBridgeCallbacks NativeBridgeItf{ + // v1 + .version = 3, + .initialize = &native_bridge3_initialize, + .loadLibrary = &native_bridge3_loadLibrary, + .getTrampoline = &native_bridge3_getTrampoline, + .isSupported = &native_bridge3_isSupported, + .getAppEnv = &native_bridge3_getAppEnv, + // v2 + .isCompatibleWith = &native_bridge3_isCompatibleWith, + .getSignalHandler = &native_bridge3_getSignalHandler, + // v3 + .unloadLibrary = &native_bridge3_unloadLibrary, + .getError = &native_bridge3_getError, + .isPathSupported = &native_bridge3_isPathSupported, + .initAnonymousNamespace = &native_bridge3_initAnonymousNamespace, + .createNamespace = &native_bridge3_createNamespace, + .linkNamespaces = &native_bridge3_linkNamespaces, + .loadLibraryExt = &native_bridge3_loadLibraryExt}; diff --git a/libnativebridge/tests/DummyNativeBridge6.cpp b/libnativebridge/tests/DummyNativeBridge6.cpp new file mode 100644 index 0000000000..ce27e67d14 --- /dev/null +++ b/libnativebridge/tests/DummyNativeBridge6.cpp @@ -0,0 +1,133 @@ +/* + * Copyright (C) 2020 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. + */ + +// A dummy implementation of the native-bridge interface. + +#include "nativebridge/native_bridge.h" + +#include "NativeBridge6PreZygoteFork_lib.h" + +// NativeBridgeCallbacks implementations +extern "C" bool native_bridge6_initialize( + const android::NativeBridgeRuntimeCallbacks* /* art_cbs */, + const char* /* app_code_cache_dir */, + const char* /* isa */) { + return true; +} + +extern "C" void* native_bridge6_loadLibrary(const char* /* libpath */, int /* flag */) { + return nullptr; +} + +extern "C" void* native_bridge6_getTrampoline(void* /* handle */, const char* /* name */, + const char* /* shorty */, uint32_t /* len */) { + return nullptr; +} + +extern "C" bool native_bridge6_isSupported(const char* /* libpath */) { + return false; +} + +extern "C" const struct android::NativeBridgeRuntimeValues* native_bridge6_getAppEnv( + const char* /* abi */) { + return nullptr; +} + +extern "C" bool native_bridge6_isCompatibleWith(uint32_t version) { + // For testing, allow 1-6, but disallow 7+. + return version <= 6; +} + +extern "C" android::NativeBridgeSignalHandlerFn native_bridge6_getSignalHandler(int /* signal */) { + return nullptr; +} + +extern "C" int native_bridge6_unloadLibrary(void* /* handle */) { + return 0; +} + +extern "C" const char* native_bridge6_getError() { + return nullptr; +} + +extern "C" bool native_bridge6_isPathSupported(const char* /* path */) { + return true; +} + +extern "C" bool native_bridge6_initAnonymousNamespace(const char* /* public_ns_sonames */, + const char* /* anon_ns_library_path */) { + return true; +} + +extern "C" android::native_bridge_namespace_t* +native_bridge6_createNamespace(const char* /* name */, + const char* /* ld_library_path */, + const char* /* default_library_path */, + uint64_t /* type */, + const char* /* permitted_when_isolated_path */, + android::native_bridge_namespace_t* /* parent_ns */) { + return nullptr; +} + +extern "C" bool native_bridge6_linkNamespaces(android::native_bridge_namespace_t* /* from */, + android::native_bridge_namespace_t* /* to */, + const char* /* shared_libs_soname */) { + return true; +} + +extern "C" void* native_bridge6_loadLibraryExt(const char* /* libpath */, + int /* flag */, + android::native_bridge_namespace_t* /* ns */) { + return nullptr; +} + +extern "C" android::native_bridge_namespace_t* native_bridge6_getVendorNamespace() { + return nullptr; +} + +extern "C" android::native_bridge_namespace_t* native_bridge6_getExportedNamespace(const char* /* name */) { + return nullptr; +} + +extern "C" void native_bridge6_preZygoteFork() { + android::SetPreZygoteForkDone(); +} + +android::NativeBridgeCallbacks NativeBridgeItf{ + // v1 + .version = 6, + .initialize = &native_bridge6_initialize, + .loadLibrary = &native_bridge6_loadLibrary, + .getTrampoline = &native_bridge6_getTrampoline, + .isSupported = &native_bridge6_isSupported, + .getAppEnv = &native_bridge6_getAppEnv, + // v2 + .isCompatibleWith = &native_bridge6_isCompatibleWith, + .getSignalHandler = &native_bridge6_getSignalHandler, + // v3 + .unloadLibrary = &native_bridge6_unloadLibrary, + .getError = &native_bridge6_getError, + .isPathSupported = &native_bridge6_isPathSupported, + .initAnonymousNamespace = &native_bridge6_initAnonymousNamespace, + .createNamespace = &native_bridge6_createNamespace, + .linkNamespaces = &native_bridge6_linkNamespaces, + .loadLibraryExt = &native_bridge6_loadLibraryExt, + // v4 + &native_bridge6_getVendorNamespace, + // v5 + &native_bridge6_getExportedNamespace, + // v6 + &native_bridge6_preZygoteFork}; diff --git a/libnativebridge/tests/InvalidCharsNativeBridge_test.cpp b/libnativebridge/tests/InvalidCharsNativeBridge_test.cpp new file mode 100644 index 0000000000..8f7973df09 --- /dev/null +++ b/libnativebridge/tests/InvalidCharsNativeBridge_test.cpp @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2014 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. + */ + +#include "NativeBridgeTest.h" + +namespace android { + +static const char* kTestName = "../librandom$@-bridge_not.existing.so"; + +TEST_F(NativeBridgeTest, InvalidChars) { + // Do one test actually calling setup. + EXPECT_EQ(false, NativeBridgeError()); + LoadNativeBridge(kTestName, nullptr); + // This should lead to an error for invalid characters. + EXPECT_EQ(true, NativeBridgeError()); + + // Further tests need to use NativeBridgeNameAcceptable, as the error + // state can't be changed back. + EXPECT_EQ(false, NativeBridgeNameAcceptable(".")); + EXPECT_EQ(false, NativeBridgeNameAcceptable("..")); + EXPECT_EQ(false, NativeBridgeNameAcceptable("_")); + EXPECT_EQ(false, NativeBridgeNameAcceptable("-")); + EXPECT_EQ(false, NativeBridgeNameAcceptable("lib@.so")); + EXPECT_EQ(false, NativeBridgeNameAcceptable("lib$.so")); +} + +} // namespace android diff --git a/libnativebridge/tests/NativeBridge2Signal_test.cpp b/libnativebridge/tests/NativeBridge2Signal_test.cpp new file mode 100644 index 0000000000..44e45e3622 --- /dev/null +++ b/libnativebridge/tests/NativeBridge2Signal_test.cpp @@ -0,0 +1,42 @@ +/* + * Copyright (C) 2014 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. + */ + +#include "NativeBridgeTest.h" + +#include <signal.h> +#include <unistd.h> + +namespace android { + +constexpr const char* kNativeBridgeLibrary2 = "libnativebridge2-dummy.so"; + +TEST_F(NativeBridgeTest, V2_Signal) { + // Init + ASSERT_TRUE(LoadNativeBridge(kNativeBridgeLibrary2, nullptr)); + ASSERT_TRUE(NativeBridgeAvailable()); + ASSERT_TRUE(PreInitializeNativeBridge(".", "isa")); + ASSERT_TRUE(NativeBridgeAvailable()); + ASSERT_TRUE(InitializeNativeBridge(nullptr, nullptr)); + ASSERT_TRUE(NativeBridgeAvailable()); + + ASSERT_EQ(2U, NativeBridgeGetVersion()); + ASSERT_NE(nullptr, NativeBridgeGetSignalHandler(SIGSEGV)); + + // Clean-up code_cache + ASSERT_EQ(0, rmdir(kCodeCache)); +} + +} // namespace android diff --git a/libnativebridge/tests/NativeBridge3CreateNamespace_test.cpp b/libnativebridge/tests/NativeBridge3CreateNamespace_test.cpp new file mode 100644 index 0000000000..668d9428a0 --- /dev/null +++ b/libnativebridge/tests/NativeBridge3CreateNamespace_test.cpp @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2016 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. + */ + +#include "NativeBridgeTest.h" + +namespace android { + +constexpr const char* kNativeBridgeLibrary3 = "libnativebridge3-dummy.so"; + +TEST_F(NativeBridgeTest, V3_CreateNamespace) { + // Init + ASSERT_TRUE(LoadNativeBridge(kNativeBridgeLibrary3, nullptr)); + ASSERT_TRUE(NativeBridgeAvailable()); + ASSERT_TRUE(PreInitializeNativeBridge(".", "isa")); + ASSERT_TRUE(NativeBridgeAvailable()); + ASSERT_TRUE(InitializeNativeBridge(nullptr, nullptr)); + ASSERT_TRUE(NativeBridgeAvailable()); + + ASSERT_EQ(3U, NativeBridgeGetVersion()); + ASSERT_EQ(nullptr, NativeBridgeCreateNamespace(nullptr, nullptr, nullptr, + 0, nullptr, nullptr)); + + // Clean-up code_cache + ASSERT_EQ(0, rmdir(kCodeCache)); +} + +} // namespace android diff --git a/libnativebridge/tests/NativeBridge3GetError_test.cpp b/libnativebridge/tests/NativeBridge3GetError_test.cpp new file mode 100644 index 0000000000..0b9f5821f2 --- /dev/null +++ b/libnativebridge/tests/NativeBridge3GetError_test.cpp @@ -0,0 +1,39 @@ +/* + * Copyright (C) 2016 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. + */ + +#include "NativeBridgeTest.h" + +namespace android { + +constexpr const char* kNativeBridgeLibrary3 = "libnativebridge3-dummy.so"; + +TEST_F(NativeBridgeTest, V3_GetError) { + // Init + ASSERT_TRUE(LoadNativeBridge(kNativeBridgeLibrary3, nullptr)); + ASSERT_TRUE(NativeBridgeAvailable()); + ASSERT_TRUE(PreInitializeNativeBridge(".", "isa")); + ASSERT_TRUE(NativeBridgeAvailable()); + ASSERT_TRUE(InitializeNativeBridge(nullptr, nullptr)); + ASSERT_TRUE(NativeBridgeAvailable()); + + ASSERT_EQ(3U, NativeBridgeGetVersion()); + ASSERT_EQ(nullptr, NativeBridgeGetError()); + + // Clean-up code_cache + ASSERT_EQ(0, rmdir(kCodeCache)); +} + +} // namespace android diff --git a/libnativebridge/tests/NativeBridge3InitAnonymousNamespace_test.cpp b/libnativebridge/tests/NativeBridge3InitAnonymousNamespace_test.cpp new file mode 100644 index 0000000000..b0d6b09d13 --- /dev/null +++ b/libnativebridge/tests/NativeBridge3InitAnonymousNamespace_test.cpp @@ -0,0 +1,39 @@ +/* + * Copyright (C) 2016 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. + */ + +#include "NativeBridgeTest.h" + +namespace android { + +constexpr const char* kNativeBridgeLibrary3 = "libnativebridge3-dummy.so"; + +TEST_F(NativeBridgeTest, V3_InitAnonymousNamespace) { + // Init + ASSERT_TRUE(LoadNativeBridge(kNativeBridgeLibrary3, nullptr)); + ASSERT_TRUE(NativeBridgeAvailable()); + ASSERT_TRUE(PreInitializeNativeBridge(".", "isa")); + ASSERT_TRUE(NativeBridgeAvailable()); + ASSERT_TRUE(InitializeNativeBridge(nullptr, nullptr)); + ASSERT_TRUE(NativeBridgeAvailable()); + + ASSERT_EQ(3U, NativeBridgeGetVersion()); + ASSERT_EQ(true, NativeBridgeInitAnonymousNamespace(nullptr, nullptr)); + + // Clean-up code_cache + ASSERT_EQ(0, rmdir(kCodeCache)); +} + +} // namespace android diff --git a/libnativebridge/tests/NativeBridge3IsPathSupported_test.cpp b/libnativebridge/tests/NativeBridge3IsPathSupported_test.cpp new file mode 100644 index 0000000000..325e40b408 --- /dev/null +++ b/libnativebridge/tests/NativeBridge3IsPathSupported_test.cpp @@ -0,0 +1,39 @@ +/* + * Copyright (C) 2016 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. + */ + +#include "NativeBridgeTest.h" + +namespace android { + +constexpr const char* kNativeBridgeLibrary3 = "libnativebridge3-dummy.so"; + +TEST_F(NativeBridgeTest, V3_IsPathSupported) { + // Init + ASSERT_TRUE(LoadNativeBridge(kNativeBridgeLibrary3, nullptr)); + ASSERT_TRUE(NativeBridgeAvailable()); + ASSERT_TRUE(PreInitializeNativeBridge(".", "isa")); + ASSERT_TRUE(NativeBridgeAvailable()); + ASSERT_TRUE(InitializeNativeBridge(nullptr, nullptr)); + ASSERT_TRUE(NativeBridgeAvailable()); + + ASSERT_EQ(3U, NativeBridgeGetVersion()); + ASSERT_EQ(true, NativeBridgeIsPathSupported(nullptr)); + + // Clean-up code_cache + ASSERT_EQ(0, rmdir(kCodeCache)); +} + +} // namespace android diff --git a/libnativebridge/tests/NativeBridge3LoadLibraryExt_test.cpp b/libnativebridge/tests/NativeBridge3LoadLibraryExt_test.cpp new file mode 100644 index 0000000000..4caeb4481f --- /dev/null +++ b/libnativebridge/tests/NativeBridge3LoadLibraryExt_test.cpp @@ -0,0 +1,39 @@ +/* + * Copyright (C) 2016 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. + */ + +#include "NativeBridgeTest.h" + +namespace android { + +constexpr const char* kNativeBridgeLibrary3 = "libnativebridge3-dummy.so"; + +TEST_F(NativeBridgeTest, V3_LoadLibraryExt) { + // Init + ASSERT_TRUE(LoadNativeBridge(kNativeBridgeLibrary3, nullptr)); + ASSERT_TRUE(NativeBridgeAvailable()); + ASSERT_TRUE(PreInitializeNativeBridge(".", "isa")); + ASSERT_TRUE(NativeBridgeAvailable()); + ASSERT_TRUE(InitializeNativeBridge(nullptr, nullptr)); + ASSERT_TRUE(NativeBridgeAvailable()); + + ASSERT_EQ(3U, NativeBridgeGetVersion()); + ASSERT_EQ(nullptr, NativeBridgeLoadLibraryExt(nullptr, 0, nullptr)); + + // Clean-up code_cache + ASSERT_EQ(0, rmdir(kCodeCache)); +} + +} // namespace android diff --git a/libnativebridge/tests/NativeBridge3UnloadLibrary_test.cpp b/libnativebridge/tests/NativeBridge3UnloadLibrary_test.cpp new file mode 100644 index 0000000000..93a979c0a0 --- /dev/null +++ b/libnativebridge/tests/NativeBridge3UnloadLibrary_test.cpp @@ -0,0 +1,39 @@ +/* + * Copyright (C) 2016 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. + */ + +#include "NativeBridgeTest.h" + +namespace android { + +constexpr const char* kNativeBridgeLibrary3 = "libnativebridge3-dummy.so"; + +TEST_F(NativeBridgeTest, V3_UnloadLibrary) { + // Init + ASSERT_TRUE(LoadNativeBridge(kNativeBridgeLibrary3, nullptr)); + ASSERT_TRUE(NativeBridgeAvailable()); + ASSERT_TRUE(PreInitializeNativeBridge(".", "isa")); + ASSERT_TRUE(NativeBridgeAvailable()); + ASSERT_TRUE(InitializeNativeBridge(nullptr, nullptr)); + ASSERT_TRUE(NativeBridgeAvailable()); + + ASSERT_EQ(3U, NativeBridgeGetVersion()); + ASSERT_EQ(0, NativeBridgeUnloadLibrary(nullptr)); + + // Clean-up code_cache + ASSERT_EQ(0, rmdir(kCodeCache)); +} + +} // namespace android diff --git a/libnativebridge/tests/NativeBridge6PreZygoteFork_lib.cpp b/libnativebridge/tests/NativeBridge6PreZygoteFork_lib.cpp new file mode 100644 index 0000000000..0da5bb6c29 --- /dev/null +++ b/libnativebridge/tests/NativeBridge6PreZygoteFork_lib.cpp @@ -0,0 +1,29 @@ +/* + * Copyright (C) 2020 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. + */ + +namespace android { + +static bool g_pre_zygote_fork_done = false; + +bool IsPreZygoteForkDone() { + return g_pre_zygote_fork_done; +} + +void SetPreZygoteForkDone() { + g_pre_zygote_fork_done = true; +} + +} // namespace android diff --git a/libnativebridge/tests/NativeBridge6PreZygoteFork_lib.h b/libnativebridge/tests/NativeBridge6PreZygoteFork_lib.h new file mode 100644 index 0000000000..bcbf0d3a2a --- /dev/null +++ b/libnativebridge/tests/NativeBridge6PreZygoteFork_lib.h @@ -0,0 +1,27 @@ +/* + * Copyright (C) 2020 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. + */ + +#ifndef ART_LIBNATIVEBRIDGE_TESTS_NATIVEBRIDGE6PREZYGOTEFORK_LIB_H_ +#define ART_LIBNATIVEBRIDGE_TESTS_NATIVEBRIDGE6PREZYGOTEFORK_LIB_H_ + +namespace android { + +bool IsPreZygoteForkDone(); +void SetPreZygoteForkDone(); + +} // namespace android + +#endif // ART_LIBNATIVEBRIDGE_TESTS_NATIVEBRIDGE6PREZYGOTEFORK_LIB_H_ diff --git a/libnativebridge/tests/NativeBridge6PreZygoteFork_test.cpp b/libnativebridge/tests/NativeBridge6PreZygoteFork_test.cpp new file mode 100644 index 0000000000..9e348a2d26 --- /dev/null +++ b/libnativebridge/tests/NativeBridge6PreZygoteFork_test.cpp @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2020 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. + */ + +#include "NativeBridgeTest.h" +#include "NativeBridge6PreZygoteFork_lib.h" + +namespace android { + +constexpr const char* kNativeBridgeLibrary6 = "libnativebridge6-dummy.so"; + +TEST_F(NativeBridgeTest, V6_PreZygoteFork) { + // Init + ASSERT_TRUE(LoadNativeBridge(kNativeBridgeLibrary6, nullptr)); + ASSERT_TRUE(NativeBridgeAvailable()); + ASSERT_TRUE(PreInitializeNativeBridge(".", "isa")); + ASSERT_TRUE(NativeBridgeAvailable()); + ASSERT_TRUE(InitializeNativeBridge(nullptr, nullptr)); + ASSERT_TRUE(NativeBridgeAvailable()); + + ASSERT_EQ(6U, NativeBridgeGetVersion()); + + ASSERT_FALSE(IsPreZygoteForkDone()); + PreZygoteForkNativeBridge(); + ASSERT_TRUE(IsPreZygoteForkDone()); +} + +} // namespace android diff --git a/libnativebridge/tests/NativeBridgeApi.c b/libnativebridge/tests/NativeBridgeApi.c new file mode 100644 index 0000000000..7ab71fe814 --- /dev/null +++ b/libnativebridge/tests/NativeBridgeApi.c @@ -0,0 +1,25 @@ +/* + * Copyright (C) 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. + */ + +/* The main purpose of this test is to ensure this C header compiles in C, so + * that no C++ features inadvertently leak into the C ABI. */ +#include "nativebridge/native_bridge.h" + +int main(int argc, char** argv) { + (void)argc; + (void)argv; + return 0; +} diff --git a/libnativebridge/tests/NativeBridgeTest.h b/libnativebridge/tests/NativeBridgeTest.h new file mode 100644 index 0000000000..cc7990742e --- /dev/null +++ b/libnativebridge/tests/NativeBridgeTest.h @@ -0,0 +1,39 @@ +/* + * Copyright (C) 2014 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. + */ + +#ifndef ART_LIBNATIVEBRIDGE_TESTS_NATIVEBRIDGETEST_H_ +#define ART_LIBNATIVEBRIDGE_TESTS_NATIVEBRIDGETEST_H_ + +#define LOG_TAG "NativeBridge_test" + +#include <nativebridge/native_bridge.h> +#include <gtest/gtest.h> + +constexpr const char* kNativeBridgeLibrary = "libnativebridge-dummy.so"; +constexpr const char* kCodeCache = "./code_cache"; +constexpr const char* kCodeCacheStatFail = "./code_cache/temp"; +constexpr const char* kNativeBridgeLibrary2 = "libnativebridge2-dummy.so"; +constexpr const char* kNativeBridgeLibrary3 = "libnativebridge3-dummy.so"; + +namespace android { + +class NativeBridgeTest : public testing::Test { +}; + +}; // namespace android + +#endif // ART_LIBNATIVEBRIDGE_TESTS_NATIVEBRIDGETEST_H_ + diff --git a/libnativebridge/tests/NativeBridgeVersion_test.cpp b/libnativebridge/tests/NativeBridgeVersion_test.cpp new file mode 100644 index 0000000000..d3f9a80fc9 --- /dev/null +++ b/libnativebridge/tests/NativeBridgeVersion_test.cpp @@ -0,0 +1,38 @@ +/* + * Copyright (C) 2015 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. + */ + +#include "NativeBridgeTest.h" + +#include <unistd.h> + +namespace android { + +TEST_F(NativeBridgeTest, Version) { + // When a bridge isn't loaded, we expect 0. + EXPECT_EQ(NativeBridgeGetVersion(), 0U); + + // After our dummy bridge has been loaded, we expect 1. + ASSERT_TRUE(LoadNativeBridge(kNativeBridgeLibrary, nullptr)); + EXPECT_EQ(NativeBridgeGetVersion(), 1U); + + // Unload + UnloadNativeBridge(); + + // Version information is gone. + EXPECT_EQ(NativeBridgeGetVersion(), 0U); +} + +} // namespace android diff --git a/libnativebridge/tests/NeedsNativeBridge_test.cpp b/libnativebridge/tests/NeedsNativeBridge_test.cpp new file mode 100644 index 0000000000..3f80f8dcd5 --- /dev/null +++ b/libnativebridge/tests/NeedsNativeBridge_test.cpp @@ -0,0 +1,36 @@ +/* + * Copyright (C) 2014 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. + */ + +#include "NativeBridgeTest.h" + +#include <android-base/macros.h> + +namespace android { + +static const char* kISAs[] = { "arm", "arm64", "x86", "x86_64", "random", "64arm", + "64_x86", "64_x86_64", "", "reallylongstringabcd", nullptr }; + +TEST_F(NativeBridgeTest, NeedsNativeBridge) { + EXPECT_EQ(false, NeedsNativeBridge(ABI_STRING)); + + const size_t kISACount = sizeof(kISAs) / sizeof(kISAs[0]); + for (size_t i = 0; i < kISACount; i++) { + EXPECT_EQ(kISAs[i] == nullptr ? false : strcmp(kISAs[i], ABI_STRING) != 0, + NeedsNativeBridge(kISAs[i])); + } +} + +} // namespace android diff --git a/libnativebridge/tests/PreInitializeNativeBridgeFail1_test.cpp b/libnativebridge/tests/PreInitializeNativeBridgeFail1_test.cpp new file mode 100644 index 0000000000..5a2b0a150f --- /dev/null +++ b/libnativebridge/tests/PreInitializeNativeBridgeFail1_test.cpp @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2014 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. + */ + +#include "NativeBridgeTest.h" + +#include <dlfcn.h> +#include <errno.h> +#include <fcntl.h> +#include <stdio.h> +#include <sys/mount.h> +#include <sys/stat.h> + +#include <cstdio> +#include <cstring> + +#include <android/log.h> + +namespace android { + +TEST_F(NativeBridgeTest, PreInitializeNativeBridgeFail1) { + // Needs a valid application directory. + ASSERT_TRUE(LoadNativeBridge(kNativeBridgeLibrary, nullptr)); + ASSERT_FALSE(PreInitializeNativeBridge(nullptr, "isa")); + ASSERT_TRUE(NativeBridgeError()); +} + +} // namespace android diff --git a/libnativebridge/tests/PreInitializeNativeBridgeFail2_test.cpp b/libnativebridge/tests/PreInitializeNativeBridgeFail2_test.cpp new file mode 100644 index 0000000000..af976b1745 --- /dev/null +++ b/libnativebridge/tests/PreInitializeNativeBridgeFail2_test.cpp @@ -0,0 +1,39 @@ +/* + * Copyright (C) 2014 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. + */ + +#include <dlfcn.h> +#include <errno.h> +#include <fcntl.h> +#include <stdio.h> +#include <sys/mount.h> +#include <sys/stat.h> + +#include <cstdio> +#include <cstring> + +#include <android/log.h> + +#include "NativeBridgeTest.h" + +namespace android { + +TEST_F(NativeBridgeTest, PreInitializeNativeBridgeFail2) { + // Needs LoadNativeBridge() first + ASSERT_FALSE(PreInitializeNativeBridge(nullptr, "isa")); + ASSERT_TRUE(NativeBridgeError()); +} + +} // namespace android diff --git a/libnativebridge/tests/PreInitializeNativeBridge_test.cpp b/libnativebridge/tests/PreInitializeNativeBridge_test.cpp new file mode 100644 index 0000000000..cd5a8e24bb --- /dev/null +++ b/libnativebridge/tests/PreInitializeNativeBridge_test.cpp @@ -0,0 +1,68 @@ +/* + * Copyright (C) 2014 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. + */ + +#include <dlfcn.h> +#include <errno.h> +#include <fcntl.h> +#include <stdio.h> +#include <sys/mount.h> +#include <sys/stat.h> + +#include <cstdio> +#include <cstring> + +#include <android/log.h> + +#include "NativeBridgeTest.h" + +namespace android { + +TEST_F(NativeBridgeTest, PreInitializeNativeBridge) { + ASSERT_TRUE(LoadNativeBridge(kNativeBridgeLibrary, nullptr)); +#if !defined(__APPLE__) // Mac OS does not support bind-mount. +#if !defined(__ANDROID__) // Cannot write into the hard-wired location. + static constexpr const char* kTestData = "PreInitializeNativeBridge test."; + + // Try to create our mount namespace. + if (unshare(CLONE_NEWNS) != -1) { + // Create a dummy file. + FILE* cpuinfo = fopen("./cpuinfo", "w"); + ASSERT_NE(nullptr, cpuinfo) << strerror(errno); + fprintf(cpuinfo, kTestData); + fclose(cpuinfo); + + ASSERT_TRUE(PreInitializeNativeBridge("does not matter 1", "short 2")); + + // Read /proc/cpuinfo + FILE* proc_cpuinfo = fopen("/proc/cpuinfo", "r"); + ASSERT_NE(nullptr, proc_cpuinfo) << strerror(errno); + char buf[1024]; + EXPECT_NE(nullptr, fgets(buf, sizeof(buf), proc_cpuinfo)) << "Error reading."; + fclose(proc_cpuinfo); + + EXPECT_EQ(0, strcmp(buf, kTestData)); + + // Delete the file. + ASSERT_EQ(0, unlink("./cpuinfo")) << "Error unlinking temporary file."; + // Ending the test will tear down the mount namespace. + } else { + GTEST_LOG_(WARNING) << "Could not create mount namespace. Are you running this as root?"; + } +#endif +#endif +} + +} // namespace android diff --git a/libnativebridge/tests/ReSetupNativeBridge_test.cpp b/libnativebridge/tests/ReSetupNativeBridge_test.cpp new file mode 100644 index 0000000000..944e5d7e98 --- /dev/null +++ b/libnativebridge/tests/ReSetupNativeBridge_test.cpp @@ -0,0 +1,30 @@ +/* + * Copyright (C) 2014 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. + */ + +#include "NativeBridgeTest.h" + +namespace android { + +TEST_F(NativeBridgeTest, ReSetup) { + EXPECT_EQ(false, NativeBridgeError()); + LoadNativeBridge("", nullptr); + EXPECT_EQ(false, NativeBridgeError()); + LoadNativeBridge("", nullptr); + // This should lead to an error for trying to re-setup a native bridge. + EXPECT_EQ(true, NativeBridgeError()); +} + +} // namespace android diff --git a/libnativebridge/tests/UnavailableNativeBridge_test.cpp b/libnativebridge/tests/UnavailableNativeBridge_test.cpp new file mode 100644 index 0000000000..ad374a5e96 --- /dev/null +++ b/libnativebridge/tests/UnavailableNativeBridge_test.cpp @@ -0,0 +1,29 @@ +/* + * Copyright (C) 2011 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. + */ + +#include "NativeBridgeTest.h" + +namespace android { + +TEST_F(NativeBridgeTest, NoNativeBridge) { + EXPECT_EQ(false, NativeBridgeAvailable()); + // Try to initialize. This should fail as we are not set up. + EXPECT_EQ(false, InitializeNativeBridge(nullptr, nullptr)); + EXPECT_EQ(true, NativeBridgeError()); + EXPECT_EQ(false, NativeBridgeAvailable()); +} + +} // namespace android diff --git a/libnativebridge/tests/ValidNameNativeBridge_test.cpp b/libnativebridge/tests/ValidNameNativeBridge_test.cpp new file mode 100644 index 0000000000..690be4a302 --- /dev/null +++ b/libnativebridge/tests/ValidNameNativeBridge_test.cpp @@ -0,0 +1,35 @@ +/* + * Copyright (C) 2011 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. + */ + +#include <NativeBridgeTest.h> + +namespace android { + +static const char* kTestName = "librandom-bridge_not.existing.so"; + +TEST_F(NativeBridgeTest, ValidName) { + // Check that the name is acceptable. + EXPECT_EQ(true, NativeBridgeNameAcceptable(kTestName)); + + // Now check what happens on LoadNativeBridge. + EXPECT_EQ(false, NativeBridgeError()); + LoadNativeBridge(kTestName, nullptr); + // This will lead to an error as the library doesn't exist. + EXPECT_EQ(true, NativeBridgeError()); + EXPECT_EQ(false, NativeBridgeAvailable()); +} + +} // namespace android |