From f04935c85e0b466f0d30d2cd4c0fa2fff62e7d6d Mon Sep 17 00:00:00 2001 From: Christopher Ferris Date: Fri, 20 Dec 2013 18:43:21 -0800 Subject: [PATCH] Make sure that the same tests are on all platforms. In order to be able to generate a list of tests for cts, the same set of tests must exist across all platforms. This CL adds empty tests where a test was conditionally compiled out. This CL creates a single library libBionicTests that includes all of the tests found in bionic-unit-tests-static. Also fix a few missing include files in some test files. Tested by running and compiling the tests for every platform and verifying the same number of tests are on each platform. Change-Id: I9989d4bfebb0f9c409a0ce7e87169299eac605a2 --- tests/Android.build.mk | 85 +++++++++ tests/Android.mk | 298 ++++++++++++++++--------------- tests/eventfd_test.cpp | 20 ++- tests/fortify_test.cpp | 72 +++++++- tests/getauxval_test.cpp | 12 +- tests/inttypes_test.cpp | 2 - tests/libc_logging_test.cpp | 33 +++- tests/libgen_test.cpp | 18 +- tests/math_test.cpp | 66 ++++--- tests/pthread_test.cpp | 46 +++-- tests/stack_protector_test.cpp | 47 ++--- tests/stack_unwinding_test.cpp | 9 +- tests/stdio_test.cpp | 14 +- tests/string_test.cpp | 35 ++-- tests/stubs_test.cpp | 9 +- tests/sys_epoll_test.cpp | 1 + tests/sys_select_test.cpp | 1 + tests/sys_sendfile_test.cpp | 2 - tests/system_properties_test.cpp | 135 +++++++++----- tests/time_test.cpp | 17 +- 20 files changed, 617 insertions(+), 305 deletions(-) create mode 100644 tests/Android.build.mk diff --git a/tests/Android.build.mk b/tests/Android.build.mk new file mode 100644 index 000000000..33e0a0bd8 --- /dev/null +++ b/tests/Android.build.mk @@ -0,0 +1,85 @@ +# +# 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 $(CLEAR_VARS) + +LOCAL_MODULE := $(module) +LOCAL_MODULE_TAGS := $(module_tag) + +LOCAL_CLANG := $($(module)_clang_$(build_type)) + +LOCAL_FORCE_STATIC_EXECUTABLE := $($(module)_force_static_executable) + +LOCAL_ADDITIONAL_DEPENDENCIES := \ + $(LOCAL_PATH)/Android.mk \ + $(LOCAL_PATH)/Android.build.mk \ + +LOCAL_CFLAGS := \ + $(common_cflags) \ + $($(module)_cflags) \ + $($(module)_cflags_$(build_type)) \ + +LOCAL_CONLYFLAGS += \ + $(common_conlyflags) \ + $($(module)_conlyflags) \ + $($(module)_conlyflags_$(build_type)) \ + +LOCAL_CPPFLAGS += \ + $(common_cppflags) \ + $($(module)_cppflags) \ + $($(module)_cppflags_$(build_type)) \ + +LOCAL_C_INCLUDES := \ + $(common_c_includes) \ + $($(module)_c_includes) \ + $($(module)_c_includes_$(build_type)) \ + +LOCAL_SRC_FILES := \ + $($(module)_src_files) \ + $($(module)_src_files_$(build_type)) \ + +LOCAL_STATIC_LIBRARIES := \ + $($(module)_static_libraries) \ + $($(module)_static_libraries_$(build_type)) \ + +LOCAL_SHARED_LIBRARIES := \ + $($(module)_shared_libraries) \ + $($(module)_shared_libraries_$(build_type)) \ + +LOCAL_WHOLE_STATIC_LIBRARIES := \ + $($(module)_whole_static_libraries) \ + $($(module)_whole_static_libraries_$(build_type)) \ + +LOCAL_LDFLAGS := \ + $($(module)_ldflags) \ + $($(module)_ldflags_$(build_type)) \ + +LOCAL_LDLIBS := \ + $($(module)_ldlibs) \ + $($(module)_ldlibs_$(build_type)) \ + +ifeq ($(build_type),target) + include external/stlport/libstlport.mk + + include $(BUILD_$(build_target)) +endif + +ifeq ($(build_type),host) + # Only build if host builds are supported. + ifeq ($(build_host),true) + include $(BUILD_HOST_$(build_target)) + endif +endif diff --git a/tests/Android.mk b/tests/Android.mk index ee22c3520..e658b4d52 100644 --- a/tests/Android.mk +++ b/tests/Android.mk @@ -22,19 +22,23 @@ LOCAL_PATH := $(call my-dir) # Unit tests. # ----------------------------------------------------------------------------- -test_c_flags = \ +ifeq ($(HOST_OS)-$(HOST_ARCH),$(filter $(HOST_OS)-$(HOST_ARCH),linux-x86 linux-x86_64)) +build_host := true +else +build_host := false +endif + +# ----------------------------------------------------------------------------- +# All standard tests. +# ----------------------------------------------------------------------------- +test_cflags = \ -fstack-protector-all \ -g \ -Wall -Wextra \ -Werror \ -fno-builtin \ -ifeq ($(TARGET_ARCH),arm64) - $(info TODO: $(LOCAL_PATH)/Android.mk -fstack-protector not yet available for the AArch64 toolchain) - test_c_flags += -fno-stack-protector -endif # arm64 - -test_src_files = \ +libBionicStandardTests_src_files := \ buffer_tests.cpp \ dirent_test.cpp \ eventfd_test.cpp \ @@ -54,6 +58,7 @@ test_src_files = \ signal_test.cpp \ stack_protector_test.cpp \ stack_unwinding_test.cpp \ + stack_unwinding_test_impl.c \ statvfs_test.cpp \ stdio_test.cpp \ stdlib_test.cpp \ @@ -73,106 +78,168 @@ test_src_files = \ time_test.cpp \ unistd_test.cpp \ -test_dynamic_ldflags = -Wl,--export-dynamic -Wl,-u,DlSymTestFunction -test_dynamic_src_files = \ - dlfcn_test.cpp \ +libBionicStandardTests_cflags := \ + $(test_cflags) \ -test_fortify_static_libraries = \ - fortify1-tests-gcc fortify2-tests-gcc fortify1-tests-clang fortify2-tests-clang +libBionicStandardTests_ldlibs_host := \ + -lrt \ -include $(CLEAR_VARS) -LOCAL_MODULE := bionic-unit-tests-unwind-test-impl -LOCAL_CFLAGS += $(test_c_flags) -fexceptions -fnon-call-exceptions -LOCAL_SRC_FILES := stack_unwinding_test_impl.c -include $(BUILD_STATIC_LIBRARY) - -include $(CLEAR_VARS) -LOCAL_MODULE := bionic-unit-tests-unwind-test-impl-host -LOCAL_CFLAGS += $(test_c_flags) -fexceptions -fnon-call-exceptions -LOCAL_SRC_FILES := stack_unwinding_test_impl.c -include $(BUILD_HOST_STATIC_LIBRARY) - -# Build tests for the device (with bionic's .so). Run with: -# adb shell /data/nativetest/bionic-unit-tests/bionic-unit-tests -include $(CLEAR_VARS) -LOCAL_MODULE := bionic-unit-tests -LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk -LOCAL_CFLAGS += $(test_c_flags) -LOCAL_LDFLAGS += $(test_dynamic_ldflags) -LOCAL_SHARED_LIBRARIES += libdl -LOCAL_SRC_FILES := $(test_src_files) $(test_dynamic_src_files) -LOCAL_WHOLE_STATIC_LIBRARIES := $(test_fortify_static_libraries) -LOCAL_STATIC_LIBRARIES += bionic-unit-tests-unwind-test-impl -include $(BUILD_NATIVE_TEST) - -# Build tests for the device (with bionic's .a). Run with: -# adb shell /data/nativetest/bionic-unit-tests-static/bionic-unit-tests-static -include $(CLEAR_VARS) -LOCAL_MODULE := bionic-unit-tests-static -LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk -LOCAL_FORCE_STATIC_EXECUTABLE := true -LOCAL_WHOLE_STATIC_LIBRARIES += libBionicTests -LOCAL_STATIC_LIBRARIES += libstlport_static libstdc++ libm libc -include $(BUILD_NATIVE_TEST) +module := libBionicStandardTests +module_tag := optional +build_type := target +build_target := STATIC_TEST_LIBRARY +include $(LOCAL_PATH)/Android.build.mk +build_type := host +include $(LOCAL_PATH)/Android.build.mk # ----------------------------------------------------------------------------- -# We build the static unit tests as a library so they can be used both for -# bionic-unit-tests-static and also as part of CTS. +# Fortify tests. # ----------------------------------------------------------------------------- +$(foreach compiler,gcc clang, \ + $(foreach test,1 2, \ + $(eval fortify$(test)-tests-$(compiler)_cflags := \ + $(test_cflags) \ + -U_FORTIFY_SOURCE \ + -D_FORTIFY_SOURCE=$(test) \ + -DTEST_NAME=Fortify$(test)_$(compiler)); \ + $(eval fortify$(test)-tests-$(compiler)_cflags_host := \ + -Wno-error); \ + $(eval fortify$(test)-tests-$(compiler)_src_files := \ + fortify_test.cpp); \ + $(eval fortify_libs += fortify$(test)-tests-$(compiler)); \ + ) \ +) -include $(CLEAR_VARS) -LOCAL_MODULE := libBionicTests -LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk -LOCAL_CFLAGS += $(test_c_flags) -LOCAL_SRC_FILES := $(test_src_files) -LOCAL_CFLAGS += \ - -DGTEST_OS_LINUX_ANDROID \ - -DGTEST_HAS_STD_STRING \ +module := fortify1-tests-gcc +module_tag := optional +build_type := target +build_target := STATIC_TEST_LIBRARY +include $(LOCAL_PATH)/Android.build.mk +build_type := host +include $(LOCAL_PATH)/Android.build.mk -LOCAL_C_INCLUDES += \ - bionic bionic/libstdc++/include \ - external/gtest/include \ - external/stlport/stlport \ +module := fortify2-tests-gcc +module_tag := optional +build_type := target +build_target := STATIC_TEST_LIBRARY +include $(LOCAL_PATH)/Android.build.mk +build_type := host +include $(LOCAL_PATH)/Android.build.mk -LOCAL_WHOLE_STATIC_LIBRARIES := \ - $(test_fortify_static_libraries) \ - bionic-unit-tests-unwind-test-impl \ +fortify1-tests-clang_clang_target := true +fortify1-tests-clang_cflags_host := -D__clang__ -include $(BUILD_STATIC_LIBRARY) +module := fortify1-tests-clang +module_tag := optional +build_type := target +build_target := STATIC_TEST_LIBRARY +include $(LOCAL_PATH)/Android.build.mk +build_type := host +include $(LOCAL_PATH)/Android.build.mk + +fortify2-tests-clang_clang_target := true + +fortify2-tests-clang_cflags_host := -D__clang__ + +module := fortify2-tests-clang +module_tag := optional +build_type := target +build_target := STATIC_TEST_LIBRARY +include $(LOCAL_PATH)/Android.build.mk +build_type := host +include $(LOCAL_PATH)/Android.build.mk # ----------------------------------------------------------------------------- -# Test library for the unit tests. +# Library of all tests (excluding the dynamic linker tests). # ----------------------------------------------------------------------------- +libBionicTests_whole_static_libraries := \ + libBionicStandardTests \ + $(fortify_libs) \ -# Build no-elf-hash-table-library.so to test dlopen(3) on a library that -# only has a GNU-style hash table. MIPS doesn't support GNU hash style. -ifneq ($(TARGET_ARCH),mips) -include $(CLEAR_VARS) -LOCAL_MODULE := no-elf-hash-table-library -LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk -LOCAL_SRC_FILES := empty.cpp -LOCAL_LDFLAGS := -Wl,--hash-style=gnu -include $(BUILD_SHARED_LIBRARY) +module := libBionicTests +module_tag := optional +build_type := target +build_target := STATIC_TEST_LIBRARY +include $(LOCAL_PATH)/Android.build.mk +build_type := host +include $(LOCAL_PATH)/Android.build.mk + +# ----------------------------------------------------------------------------- +# Library used by dlfcn tests. +# ----------------------------------------------------------------------------- +ifneq ($(TARGET_ARCH),$(filter $(TARGET_ARCH),mips mips64)) +no-elf-hash-table-library_src_files := \ + empty.cpp \ + +no-elf-hash-table-library_ldflags := \ + -Wl,--hash-style=gnu \ + +module := no-elf-hash-table-library +module_tag := optional +build_type := target +build_target := SHARED_LIBRARY +include $(LOCAL_PATH)/Android.build.mk endif # ----------------------------------------------------------------------------- -# Unit tests built against glibc. +# Tests for the device using bionic's .so. Run with: +# adb shell /data/nativetest/bionic-unit-tests/bionic-unit-tests # ----------------------------------------------------------------------------- +bionic-unit-tests_whole_static_libraries := \ + libBionicTests \ -# Build tests for the host (with glibc). -# Note that this will build against glibc, so it's not useful for testing -# bionic's implementation, but it does let you use glibc as a reference -# implementation for testing the tests themselves. -ifeq ($(HOST_OS)-$(HOST_ARCH),linux-x86) -include $(CLEAR_VARS) -LOCAL_MODULE := bionic-unit-tests-glibc -LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk -LOCAL_CFLAGS += $(test_c_flags) -LOCAL_LDFLAGS += -lpthread -ldl -lrt -LOCAL_LDFLAGS += $(test_dynamic_ldflags) -LOCAL_SRC_FILES := $(test_src_files) $(test_dynamic_src_files) -LOCAL_STATIC_LIBRARIES += bionic-unit-tests-unwind-test-impl-host -include $(BUILD_HOST_NATIVE_TEST) +bionic-unit-tests_src_files := \ + dlfcn_test.cpp \ + +bionic-unit-tests_ldflags := \ + -Wl,--export-dynamic \ + -Wl,-u,DlSymTestFunction \ + +bionic-unit-tests_shared_libraries_target := \ + libdl \ + +module := bionic-unit-tests +module_tag := optional +build_type := target +build_target := NATIVE_TEST +include $(LOCAL_PATH)/Android.build.mk + +# ----------------------------------------------------------------------------- +# Tests for the device linked against bionic's static library. Run with: +# adb shell /data/nativetest/bionic-unit-tests-static/bionic-unit-tests-static +# ----------------------------------------------------------------------------- +bionic-unit-tests-static_whole_static_libraries := \ + libBionicTests \ + +bionic-unit-tests-static_static_libraries := \ + libstlport_static \ + libm \ + libc \ + libstdc++ \ + +bionic-unit-tests-static_force_static_executable := true + +module := bionic-unit-tests-static +module_tag := optional +build_type := target +build_target := NATIVE_TEST +include $(LOCAL_PATH)/Android.build.mk + +# ----------------------------------------------------------------------------- +# Tests to run on the host and linked against glibc. Run with: +# cd bionic/tests; mm bionic-unit-tests-glibc-run +# ----------------------------------------------------------------------------- +bionic-unit-tests-glibc_whole_static_libraries := \ + libBionicStandardTests \ + +bionic-unit-tests-glibc_ldlibs := \ + -lrt \ + +module := bionic-unit-tests-glibc +module_tag := optional +build_type := host +build_target := NATIVE_TEST +include $(LOCAL_PATH)/Android.build.mk # gtest needs ANDROID_DATA/local/tmp for death test output. # Make sure to create ANDROID_DATA/local/tmp if doesn't exist. @@ -182,12 +249,10 @@ bionic-unit-tests-glibc-run: bionic-unit-tests-glibc ANDROID_DATA=$(TARGET_OUT_DATA) \ ANDROID_ROOT=$(TARGET_OUT) \ $(HOST_OUT_EXECUTABLES)/bionic-unit-tests-glibc -endif # ----------------------------------------------------------------------------- # Run the unit tests built against x86 bionic on an x86 host. # ----------------------------------------------------------------------------- - ifeq ($(HOST_OS)-$(HOST_ARCH),linux-x86) ifeq ($(TARGET_ARCH),$(filter $(TARGET_ARCH),x86 x86_64)) ifeq ($(TARGET_ARCH),x86) @@ -213,55 +278,4 @@ bionic-unit-tests-run-on-host: bionic-unit-tests $(TARGET_OUT_EXECUTABLES)/$(LIN endif endif -# ----------------------------------------------------------------------------- -# FORTIFY_SOURCE tests -# ----------------------------------------------------------------------------- - -fortify_c_includes = \ - bionic \ - bionic/libstdc++/include \ - external/stlport/stlport \ - external/gtest/include -fortify_test_files = fortify_test.cpp - -# -Wno-error=unused-parameter needed as -# external/stlport/stlport/stl/_threads.c (included from -# external/gtest/include/gtest/gtest.h) does not compile cleanly under -# clang. TODO: fix this. -fortify_c_flags = $(test_c_flags) -Wno-error=unused-parameter - -include $(CLEAR_VARS) -LOCAL_SRC_FILES := $(fortify_test_files) -LOCAL_MODULE := fortify1-tests-gcc -LOCAL_CFLAGS += $(fortify_c_flags) -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=1 -DTEST_NAME=Fortify1_Gcc -LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk -LOCAL_C_INCLUDES += $(fortify_c_includes) -include $(BUILD_STATIC_LIBRARY) - -include $(CLEAR_VARS) -LOCAL_SRC_FILES := $(fortify_test_files) -LOCAL_MODULE := fortify2-tests-gcc -LOCAL_CFLAGS += $(fortify_c_flags) -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2 -DTEST_NAME=Fortify2_Gcc -LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk -LOCAL_C_INCLUDES += $(fortify_c_includes) -include $(BUILD_STATIC_LIBRARY) - -include $(CLEAR_VARS) -LOCAL_SRC_FILES := $(fortify_test_files) -LOCAL_MODULE := fortify1-tests-clang -LOCAL_CLANG := true -LOCAL_CFLAGS += $(fortify_c_flags) -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=1 -DTEST_NAME=Fortify1_Clang -LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk -LOCAL_C_INCLUDES += $(fortify_c_includes) -include $(BUILD_STATIC_LIBRARY) - -include $(CLEAR_VARS) -LOCAL_SRC_FILES := $(fortify_test_files) -LOCAL_MODULE := fortify2-tests-clang -LOCAL_CLANG := true -LOCAL_CFLAGS += $(fortify_c_flags) -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2 -DTEST_NAME=Fortify2_Clang -LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk -LOCAL_C_INCLUDES += $(fortify_c_includes) -include $(BUILD_STATIC_LIBRARY) - endif # !BUILD_TINY_ANDROID diff --git a/tests/eventfd_test.cpp b/tests/eventfd_test.cpp index 2c2c5f07e..aa88a3b9d 100644 --- a/tests/eventfd_test.cpp +++ b/tests/eventfd_test.cpp @@ -14,11 +14,25 @@ * limitations under the License. */ +#include +#include + #include -#if !defined(__GLIBC__) // Android's prebuilt gcc's header files don't include . - +#if defined(__BIONIC__) // Android's prebuilt gcc's header files don't include . #include +#else +// Include the necessary components of sys/eventfd.h right here. +#include + +typedef uint64_t eventfd_t; + +__BEGIN_DECLS +extern int eventfd(int, int); +extern int eventfd_read(int, eventfd_t*); +extern int eventfd_write(int, eventfd_t); +__END_DECLS +#endif TEST(eventfd, smoke) { unsigned int initial_value = 2; @@ -43,5 +57,3 @@ TEST(eventfd, smoke) { close(fd); } - -#endif diff --git a/tests/fortify_test.cpp b/tests/fortify_test.cpp index 408991ef7..67e197e6b 100644 --- a/tests/fortify_test.cpp +++ b/tests/fortify_test.cpp @@ -15,6 +15,7 @@ */ #include +#include #include #include #include @@ -139,19 +140,21 @@ TEST(DEATHTEST, vsnprintf2_fortified2) { } #endif -#if __BIONIC__ - #ifndef __clang__ // zero sized target with "\0" source (should fail) // This test is disabled in clang because clang doesn't properly detect // this buffer overflow. TODO: Fix clang. TEST(DEATHTEST, strcpy_fortified2) { +#if defined(__BIONIC__) ::testing::FLAGS_gtest_death_test_style = "threadsafe"; foo myfoo; char* src = strdup(""); ASSERT_EXIT(strcpy(myfoo.empty, src), testing::KilledBySignal(SIGABRT), ""); free(src); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } #endif @@ -160,12 +163,16 @@ TEST(DEATHTEST, strcpy_fortified2) { // This test is disabled in clang because clang doesn't properly detect // this buffer overflow. TODO: Fix clang. TEST(DEATHTEST, strcpy2_fortified2) { +#if defined(__BIONIC__) ::testing::FLAGS_gtest_death_test_style = "threadsafe"; foo myfoo; char* src = strdup("1"); ASSERT_EXIT(strcpy(myfoo.empty, src), testing::KilledBySignal(SIGABRT), ""); free(src); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } #endif @@ -174,12 +181,16 @@ TEST(DEATHTEST, strcpy2_fortified2) { // This test is disabled in clang because clang doesn't properly detect // this buffer overflow. TODO: Fix clang. TEST(DEATHTEST, strcpy3_fortified2) { +#if defined(__BIONIC__) ::testing::FLAGS_gtest_death_test_style = "threadsafe"; foo myfoo; char* src = strdup("12"); ASSERT_EXIT(strcpy(myfoo.one, src), testing::KilledBySignal(SIGABRT), ""); free(src); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } #endif @@ -187,12 +198,16 @@ TEST(DEATHTEST, strcpy3_fortified2) { // This test is disabled in clang because clang doesn't properly detect // this buffer overflow. TODO: Fix clang. TEST(DEATHTEST, strchr_fortified2) { +#if defined(__BIONIC__) ::testing::FLAGS_gtest_death_test_style = "threadsafe"; foo myfoo; memcpy(myfoo.a, "0123456789", sizeof(myfoo.a)); myfoo.b[0] = '\0'; ASSERT_EXIT(printf("%s", strchr(myfoo.a, 'a')), testing::KilledBySignal(SIGABRT), ""); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } #endif @@ -200,12 +215,16 @@ TEST(DEATHTEST, strchr_fortified2) { // This test is disabled in clang because clang doesn't properly detect // this buffer overflow. TODO: Fix clang. TEST(DEATHTEST, strrchr_fortified2) { +#if defined(__BIONIC__) ::testing::FLAGS_gtest_death_test_style = "threadsafe"; foo myfoo; memcpy(myfoo.a, "0123456789", 10); memcpy(myfoo.b, "01234", 6); ASSERT_EXIT(printf("%s", strrchr(myfoo.a, 'a')), testing::KilledBySignal(SIGABRT), ""); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } #endif @@ -213,12 +232,16 @@ TEST(DEATHTEST, strrchr_fortified2) { // This test is disabled in clang because clang doesn't properly detect // this buffer overflow. TODO: Fix clang. TEST(DEATHTEST, strlcpy_fortified2) { +#if defined(__BIONIC__) ::testing::FLAGS_gtest_death_test_style = "threadsafe"; foo myfoo; strcpy(myfoo.a, "01"); size_t n = strlen(myfoo.a); ASSERT_EXIT(strlcpy(myfoo.one, myfoo.a, n), testing::KilledBySignal(SIGABRT), ""); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } #endif @@ -226,6 +249,7 @@ TEST(DEATHTEST, strlcpy_fortified2) { // This test is disabled in clang because clang doesn't properly detect // this buffer overflow. TODO: Fix clang. TEST(DEATHTEST, strlcat_fortified2) { +#if defined(__BIONIC__) ::testing::FLAGS_gtest_death_test_style = "threadsafe"; foo myfoo; strcpy(myfoo.a, "01"); @@ -233,11 +257,12 @@ TEST(DEATHTEST, strlcat_fortified2) { size_t n = strlen(myfoo.a); ASSERT_EXIT(strlcat(myfoo.one, myfoo.a, n), testing::KilledBySignal(SIGABRT), ""); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } #endif -#endif /* __BIONIC__ */ - #ifndef __clang__ // This test is disabled in clang because clang doesn't properly detect // this buffer overflow. TODO: Fix clang. @@ -310,74 +335,106 @@ TEST(DEATHTEST, bzero_fortified2) { #endif /* defined(_FORTIFY_SOURCE) && _FORTIFY_SOURCE=2 */ -#if __BIONIC__ // multibyte target where we over fill (should fail) TEST(DEATHTEST, strcpy_fortified) { +#if defined(__BIONIC__) ::testing::FLAGS_gtest_death_test_style = "threadsafe"; char buf[10]; char *orig = strdup("0123456789"); ASSERT_EXIT(strcpy(buf, orig), testing::KilledBySignal(SIGABRT), ""); free(orig); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } // zero sized target with "\0" source (should fail) TEST(DEATHTEST, strcpy2_fortified) { +#if defined(__BIONIC__) ::testing::FLAGS_gtest_death_test_style = "threadsafe"; char buf[0]; char *orig = strdup(""); ASSERT_EXIT(strcpy(buf, orig), testing::KilledBySignal(SIGABRT), ""); free(orig); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } // zero sized target with longer source (should fail) TEST(DEATHTEST, strcpy3_fortified) { +#if defined(__BIONIC__) ::testing::FLAGS_gtest_death_test_style = "threadsafe"; char buf[0]; char *orig = strdup("1"); ASSERT_EXIT(strcpy(buf, orig), testing::KilledBySignal(SIGABRT), ""); free(orig); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } // one byte target with longer source (should fail) TEST(DEATHTEST, strcpy4_fortified) { +#if defined(__BIONIC__) ::testing::FLAGS_gtest_death_test_style = "threadsafe"; char buf[1]; char *orig = strdup("12"); ASSERT_EXIT(strcpy(buf, orig), testing::KilledBySignal(SIGABRT), ""); free(orig); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } TEST(DEATHTEST, strlen_fortified) { +#if defined(__BIONIC__) ::testing::FLAGS_gtest_death_test_style = "threadsafe"; char buf[10]; memcpy(buf, "0123456789", sizeof(buf)); ASSERT_EXIT(printf("%zd", strlen(buf)), testing::KilledBySignal(SIGABRT), ""); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } TEST(DEATHTEST, strchr_fortified) { +#if defined(__BIONIC__) ::testing::FLAGS_gtest_death_test_style = "threadsafe"; char buf[10]; memcpy(buf, "0123456789", sizeof(buf)); ASSERT_EXIT(printf("%s", strchr(buf, 'a')), testing::KilledBySignal(SIGABRT), ""); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } TEST(DEATHTEST, strrchr_fortified) { +#if defined(__BIONIC__) ::testing::FLAGS_gtest_death_test_style = "threadsafe"; char buf[10]; memcpy(buf, "0123456789", sizeof(buf)); ASSERT_EXIT(printf("%s", strrchr(buf, 'a')), testing::KilledBySignal(SIGABRT), ""); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } TEST(DEATHTEST, strlcpy_fortified) { +#if defined(__BIONIC__) ::testing::FLAGS_gtest_death_test_style = "threadsafe"; char bufa[15]; char bufb[10]; strcpy(bufa, "01234567890123"); size_t n = strlen(bufa); ASSERT_EXIT(strlcpy(bufb, bufa, n), testing::KilledBySignal(SIGABRT), ""); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } TEST(DEATHTEST, strlcat_fortified) { +#if defined(__BIONIC__) ::testing::FLAGS_gtest_death_test_style = "threadsafe"; char bufa[15]; char bufb[10]; @@ -385,10 +442,11 @@ TEST(DEATHTEST, strlcat_fortified) { strcpy(bufa, "01234567890123"); size_t n = strlen(bufa); ASSERT_EXIT(strlcat(bufb, bufa, n), testing::KilledBySignal(SIGABRT), ""); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } -#endif - TEST(DEATHTEST, sprintf_fortified) { ::testing::FLAGS_gtest_death_test_style = "threadsafe"; char buf[10]; diff --git a/tests/getauxval_test.cpp b/tests/getauxval_test.cpp index 01c11c3c2..51c9db84e 100644 --- a/tests/getauxval_test.cpp +++ b/tests/getauxval_test.cpp @@ -31,10 +31,11 @@ #endif #if defined(GETAUXVAL_CAN_COMPILE) - #include +#endif TEST(getauxval, expected_values) { +#if defined(GETAUXVAL_CAN_COMPILE) ASSERT_EQ((unsigned long int) 0, getauxval(AT_SECURE)); ASSERT_EQ(getuid(), getauxval(AT_UID)); ASSERT_EQ(geteuid(), getauxval(AT_EUID)); @@ -46,10 +47,15 @@ TEST(getauxval, expected_values) { ASSERT_NE((unsigned long int) 0, getauxval(AT_PHNUM)); ASSERT_NE((unsigned long int) 0, getauxval(AT_ENTRY)); ASSERT_NE((unsigned long int) 0, getauxval(AT_PAGESZ)); +#else + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif } TEST(getauxval, unexpected_values) { +#if defined(GETAUXVAL_CAN_COMPILE) ASSERT_EQ((unsigned long int) 0, getauxval(0xdeadbeef)); +#else + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif } - -#endif /* GETAUXVAL_CAN_COMPILE */ diff --git a/tests/inttypes_test.cpp b/tests/inttypes_test.cpp index df02d1fc1..ac37e6295 100644 --- a/tests/inttypes_test.cpp +++ b/tests/inttypes_test.cpp @@ -19,7 +19,6 @@ #include #include -#if defined(__BIONIC__) // Doesn't work on glibc because we use -m32. TEST(inttypes, misc) { char buf[512]; @@ -39,4 +38,3 @@ TEST(inttypes, misc) { sscanf(buf, "%08" SCNuPTR, &u); sscanf(buf, "%08" SCNxPTR, &u); } -#endif diff --git a/tests/libc_logging_test.cpp b/tests/libc_logging_test.cpp index c44b85b96..950161e78 100644 --- a/tests/libc_logging_test.cpp +++ b/tests/libc_logging_test.cpp @@ -17,12 +17,12 @@ #include #if defined(__BIONIC__) - #include "../libc/bionic/libc_logging.cpp" - extern int __libc_format_buffer(char* buffer, size_t buffer_size, const char* format, ...); +#endif // __BIONIC__ TEST(libc_logging, smoke) { +#if defined(__BIONIC__) char buf[BUFSIZ]; __libc_format_buffer(buf, sizeof(buf), "a"); @@ -104,21 +104,33 @@ TEST(libc_logging, smoke) { __libc_format_buffer(buf, sizeof(buf), "a%lld,%d,%d,%dz", 0x1000000000LL, 6, 7, 8); EXPECT_STREQ("a68719476736,6,7,8z", buf); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } TEST(libc_logging, d_INT_MAX) { +#if defined(__BIONIC__) char buf[BUFSIZ]; __libc_format_buffer(buf, sizeof(buf), "%d", INT_MAX); EXPECT_STREQ("2147483647", buf); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } TEST(libc_logging, d_INT_MIN) { +#if defined(__BIONIC__) char buf[BUFSIZ]; __libc_format_buffer(buf, sizeof(buf), "%d", INT_MIN); EXPECT_STREQ("-2147483648", buf); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } TEST(libc_logging, ld_LONG_MAX) { +#if defined(__BIONIC__) char buf[BUFSIZ]; __libc_format_buffer(buf, sizeof(buf), "%ld", LONG_MAX); #if __LP64__ @@ -126,9 +138,13 @@ TEST(libc_logging, ld_LONG_MAX) { #else EXPECT_STREQ("2147483647", buf); #endif +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } TEST(libc_logging, ld_LONG_MIN) { +#if defined(__BIONIC__) char buf[BUFSIZ]; __libc_format_buffer(buf, sizeof(buf), "%ld", LONG_MIN); #if __LP64__ @@ -136,18 +152,27 @@ TEST(libc_logging, ld_LONG_MIN) { #else EXPECT_STREQ("-2147483648", buf); #endif +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } TEST(libc_logging, lld_LLONG_MAX) { +#if defined(__BIONIC__) char buf[BUFSIZ]; __libc_format_buffer(buf, sizeof(buf), "%lld", LLONG_MAX); EXPECT_STREQ("9223372036854775807", buf); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } TEST(libc_logging, lld_LLONG_MIN) { +#if defined(__BIONIC__) char buf[BUFSIZ]; __libc_format_buffer(buf, sizeof(buf), "%lld", LLONG_MIN); EXPECT_STREQ("-9223372036854775808", buf); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } - -#endif diff --git a/tests/libgen_test.cpp b/tests/libgen_test.cpp index c2c01f6b8..cae646f25 100644 --- a/tests/libgen_test.cpp +++ b/tests/libgen_test.cpp @@ -38,7 +38,9 @@ static void TestDirname(const char* in, const char* expected_out) { free(writable_in); } -TEST(libgen, basename) { +// Do not use basename as the test name, it's defined to another value in glibc +// so leads to a differently named test on host versus target architectures. +TEST(libgen, basename_smoke) { TestBasename(NULL, "."); TestBasename("", "."); TestBasename("/usr/lib", "lib"); @@ -62,8 +64,7 @@ TEST(libgen, dirname) { TestDirname("/", "/"); } -#if __BIONIC__ - +#if defined(__BIONIC__) static void TestBasename(const char* in, const char* expected_out, int expected_rc, char* buf, size_t buf_size, int expected_errno) { errno = 0; @@ -85,8 +86,10 @@ static void TestDirname(const char* in, const char* expected_out, int expected_r } ASSERT_EQ(expected_errno, errno) << in; } +#endif // __BIONIC__ TEST(libgen, basename_r) { +#if defined(__BIONIC__) char buf[256]; TestBasename("", ".", 1, NULL, 0, 0); TestBasename("", ".", -1, buf, 0, ERANGE); @@ -99,9 +102,13 @@ TEST(libgen, basename_r) { TestBasename("/", "/", 1, buf, sizeof(buf), 0); TestBasename(".", ".", 1, buf, sizeof(buf), 0); TestBasename("..", "..", 2, buf, sizeof(buf), 0); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } TEST(libgen, dirname_r) { +#if defined(__BIONIC__) char buf[256]; TestDirname("", ".", 1, NULL, 0, 0); TestDirname("", ".", -1, buf, 0, ERANGE); @@ -112,6 +119,7 @@ TEST(libgen, dirname_r) { TestDirname("usr", ".", 1, buf, sizeof(buf), 0); TestDirname(".", ".", 1, buf, sizeof(buf), 0); TestDirname("..", ".", 1, buf, sizeof(buf), 0); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } - -#endif diff --git a/tests/math_test.cpp b/tests/math_test.cpp index 454646d7d..c8974d3b0 100644 --- a/tests/math_test.cpp +++ b/tests/math_test.cpp @@ -104,61 +104,73 @@ TEST(math, signbit) { } */ -#if defined(__BIONIC__) TEST(math, __fpclassifyd) { +#if defined(__BIONIC__) ASSERT_EQ(FP_INFINITE, __fpclassifyd(HUGE_VAL)); ASSERT_EQ(FP_NAN, __fpclassifyd(nan(""))); ASSERT_EQ(FP_NORMAL, __fpclassifyd(1.0)); ASSERT_EQ(FP_SUBNORMAL, __fpclassifyd(double_subnormal())); ASSERT_EQ(FP_ZERO, __fpclassifyd(0.0)); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } -#endif -#if defined(__BIONIC__) TEST(math, __fpclassifyf) { +#if defined(__BIONIC__) ASSERT_EQ(FP_INFINITE, __fpclassifyf(HUGE_VALF)); ASSERT_EQ(FP_NAN, __fpclassifyf(nanf(""))); ASSERT_EQ(FP_NORMAL, __fpclassifyf(1.0f)); ASSERT_EQ(FP_SUBNORMAL, __fpclassifyf(float_subnormal())); ASSERT_EQ(FP_ZERO, __fpclassifyf(0.0f)); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } -#endif -#if defined(__BIONIC__) TEST(math, __fpclassifyl) { +#if defined(__BIONIC__) EXPECT_EQ(FP_INFINITE, __fpclassifyl(HUGE_VALL)); EXPECT_EQ(FP_NAN, __fpclassifyl(nanl(""))); EXPECT_EQ(FP_NORMAL, __fpclassifyl(1.0)); EXPECT_EQ(FP_SUBNORMAL, __fpclassifyl(double_subnormal())); EXPECT_EQ(FP_ZERO, __fpclassifyl(0.0)); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } -#endif TEST(math, finitef) { ASSERT_TRUE(finitef(123.0f)); ASSERT_FALSE(finitef(HUGE_VALF)); } -#if defined(__BIONIC__) TEST(math, __isfinite) { +#if defined(__BIONIC__) ASSERT_TRUE(__isfinite(123.0)); ASSERT_FALSE(__isfinite(HUGE_VAL)); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } -#endif -#if defined(__BIONIC__) TEST(math, __isfinitef) { +#if defined(__BIONIC__) ASSERT_TRUE(__isfinitef(123.0f)); ASSERT_FALSE(__isfinitef(HUGE_VALF)); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } -#endif -#if defined(__BIONIC__) TEST(math, __isfinitel) { +#if defined(__BIONIC__) ASSERT_TRUE(__isfinitel(123.0f)); ASSERT_FALSE(__isfinitel(HUGE_VALL)); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } -#endif TEST(math, finite) { ASSERT_TRUE(finite(123.0)); @@ -190,26 +202,32 @@ TEST(math, isnanf) { ASSERT_TRUE(isnanf(nanf(""))); } -#if defined(__BIONIC__) TEST(math, __isnormal) { +#if defined(__BIONIC__) ASSERT_TRUE(__isnormal(123.0)); ASSERT_FALSE(__isnormal(double_subnormal())); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } -#endif -#if defined(__BIONIC__) TEST(math, __isnormalf) { +#if defined(__BIONIC__) ASSERT_TRUE(__isnormalf(123.0f)); ASSERT_FALSE(__isnormalf(float_subnormal())); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } -#endif -#if defined(__BIONIC__) TEST(math, __isnormall) { +#if defined(__BIONIC__) ASSERT_TRUE(__isnormall(123.0)); ASSERT_FALSE(__isnormall(double_subnormal())); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } -#endif TEST(math, __signbit) { ASSERT_EQ(0, __signbit(0.0)); @@ -1005,21 +1023,25 @@ TEST(math, gammaf) { ASSERT_FLOAT_EQ(logf(24.0f), gammaf(5.0f)); } -#if defined(__BIONIC__) TEST(math, gamma_r) { +#if defined(__BIONIC__) int sign; ASSERT_FLOAT_EQ(log(24.0), gamma_r(5.0, &sign)); ASSERT_EQ(1, sign); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } -#endif -#if defined(__BIONIC__) TEST(math, gammaf_r) { +#if defined(__BIONIC__) int sign; ASSERT_FLOAT_EQ(logf(24.0f), gammaf_r(5.0f, &sign)); ASSERT_EQ(1, sign); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } -#endif TEST(math, lgamma) { ASSERT_FLOAT_EQ(log(24.0), lgamma(5.0)); diff --git a/tests/pthread_test.cpp b/tests/pthread_test.cpp index 33317d995..d2341188b 100644 --- a/tests/pthread_test.cpp +++ b/tests/pthread_test.cpp @@ -20,6 +20,7 @@ #include #include #include +#include #include #include @@ -31,8 +32,8 @@ TEST(pthread, pthread_key_create) { ASSERT_EQ(EINVAL, pthread_key_delete(key)); } -#if !defined(__GLIBC__) // glibc uses keys internally that its sysconf value doesn't account for. TEST(pthread, pthread_key_create_lots) { +#if defined(__BIONIC__) // glibc uses keys internally that its sysconf value doesn't account for. // POSIX says PTHREAD_KEYS_MAX should be at least 128. ASSERT_GE(PTHREAD_KEYS_MAX, 128); @@ -59,8 +60,10 @@ TEST(pthread, pthread_key_create_lots) { for (size_t i = 0; i < keys.size(); ++i) { ASSERT_EQ(0, pthread_key_delete(keys[i])); } +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } -#endif static void* IdFn(void* arg) { return arg; @@ -249,31 +252,40 @@ TEST(pthread, pthread_sigmask) { ASSERT_EQ(0, pthread_sigmask(SIG_SETMASK, &original_set, NULL)); } -#if __BIONIC__ +#if defined(__BIONIC__) extern "C" pid_t __bionic_clone(int flags, void* child_stack, pid_t* parent_tid, void* tls, pid_t* child_tid, int (*fn)(void*), void* arg); +#endif // __BIONIC__ + TEST(pthread, __bionic_clone) { +#if defined(__BIONIC__) // Check that our hand-written clone assembler sets errno correctly on failure. uintptr_t fake_child_stack[16]; errno = 0; ASSERT_EQ(-1, __bionic_clone(CLONE_THREAD, &fake_child_stack[16], NULL, NULL, NULL, NULL, NULL)); ASSERT_EQ(EINVAL, errno); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } -#endif -#if __BIONIC__ // Not all build servers have a new enough glibc? TODO: remove when they're on gprecise. TEST(pthread, pthread_setname_np__too_long) { +#if defined(__BIONIC__) // Not all build servers have a new enough glibc? TODO: remove when they're on gprecise. ASSERT_EQ(ERANGE, pthread_setname_np(pthread_self(), "this name is far too long for linux")); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } -#endif -#if __BIONIC__ // Not all build servers have a new enough glibc? TODO: remove when they're on gprecise. TEST(pthread, pthread_setname_np__self) { +#if defined(__BIONIC__) // Not all build servers have a new enough glibc? TODO: remove when they're on gprecise. ASSERT_EQ(0, pthread_setname_np(pthread_self(), "short 1")); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } -#endif -#if __BIONIC__ // Not all build servers have a new enough glibc? TODO: remove when they're on gprecise. TEST(pthread, pthread_setname_np__other) { +#if defined(__BIONIC__) // Not all build servers have a new enough glibc? TODO: remove when they're on gprecise. // Emulator kernels don't currently support setting the name of other threads. char* filename = NULL; asprintf(&filename, "/proc/self/task/%d/comm", gettid()); @@ -288,18 +300,22 @@ TEST(pthread, pthread_setname_np__other) { } else { fprintf(stderr, "skipping test: this kernel doesn't have /proc/self/task/tid/comm files!\n"); } +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } -#endif -#if __BIONIC__ // Not all build servers have a new enough glibc? TODO: remove when they're on gprecise. TEST(pthread, pthread_setname_np__no_such_thread) { +#if defined(__BIONIC__) // Not all build servers have a new enough glibc? TODO: remove when they're on gprecise. pthread_t dead_thread; MakeDeadThread(dead_thread); // Call pthread_setname_np after thread has already exited. ASSERT_EQ(ESRCH, pthread_setname_np(dead_thread, "short 3")); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } -#endif TEST(pthread, pthread_kill__0) { // Signal 0 just tests that the thread exists, so it's safe to call on ourselves. @@ -511,13 +527,13 @@ TEST(pthread, pthread_attr_setstacksize) { ASSERT_EQ(0, pthread_attr_setstacksize(&attributes, 32*1024 + 1)); ASSERT_EQ(0, pthread_attr_getstacksize(&attributes, &stack_size)); ASSERT_EQ(32*1024U + 1, stack_size); -#if __BIONIC__ +#if defined(__BIONIC__) // Bionic rounds up, which is what POSIX allows. ASSERT_EQ(GetActualStackSize(attributes), (32 + 4)*1024U); -#else +#else // __BIONIC__ // glibc rounds down, in violation of POSIX. They document this in their BUGS section. ASSERT_EQ(GetActualStackSize(attributes), 32*1024U); -#endif +#endif // __BIONIC__ } TEST(pthread, pthread_rwlock_smoke) { diff --git a/tests/stack_protector_test.cpp b/tests/stack_protector_test.cpp index 2ba8a87ce..fea24d887 100644 --- a/tests/stack_protector_test.cpp +++ b/tests/stack_protector_test.cpp @@ -27,17 +27,13 @@ #include #include -#ifdef __GLIBC__ - +#if defined(__GLIBC__) // glibc doesn't expose gettid(2). pid_t gettid() { return syscall(__NR_gettid); } - -#endif - -#ifdef __i386__ +#endif // __GLIBC__ // For x86, bionic and glibc have per-thread stack guard values (all identical). - +#if defined(__i386__) static uint32_t GetGuardFromTls() { uint32_t guard; asm ("mov %%gs:0x14, %0": "=d" (guard)); @@ -71,8 +67,10 @@ static void* ThreadGuardHelper(void* arg) { checker->Check(); return NULL; } +#endif // __i386__ TEST(stack_protector, same_guard_per_thread) { +#if defined(__i386__) stack_protector_checker checker; size_t thread_count = 10; for (size_t i = 0; i < thread_count; ++i) { @@ -86,24 +84,19 @@ TEST(stack_protector, same_guard_per_thread) { // bionic and glibc use the same guard for every thread. ASSERT_EQ(1U, checker.guards.size()); +#else // __i386__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __i386__ } -#endif - -#if defined(__BIONIC__) || defined(__arm__) || defined(__mips__) - // For ARM and MIPS, glibc has a global stack check guard value. +#if defined(__BIONIC__) || defined(__arm__) || defined(__mips__) +#define TEST_STACK_CHK_GUARD // Bionic has the global for x86 too, to support binaries that can run on // Android releases that didn't implement the TLS guard value. - extern "C" uintptr_t __stack_chk_guard; -TEST(stack_protector, global_guard) { - ASSERT_NE(0, gettid()); - ASSERT_NE(0U, __stack_chk_guard); -} - /* * When this function returns, the stack canary will be inconsistent * with the previous value, which will generate a call to __stack_chk_fail(), @@ -116,10 +109,22 @@ __attribute__ ((noinline)) static void do_modify_stack_chk_guard() { __stack_chk_guard = 0x12345678; } +#endif -TEST(stack_protector_DeathTest, modify_stack_protector) { - ::testing::FLAGS_gtest_death_test_style = "threadsafe"; - ASSERT_EXIT(do_modify_stack_chk_guard(), testing::KilledBySignal(SIGABRT), ""); +TEST(stack_protector, global_guard) { +#if defined(TEST_STACK_CHK_GUARD) + ASSERT_NE(0, gettid()); + ASSERT_NE(0U, __stack_chk_guard); +#else // TEST_STACK_CHK_GUARD + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // TEST_STACK_CHK_GUARD } -#endif +TEST(stack_protector_DeathTest, modify_stack_protector) { +#if defined(TEST_STACK_CHK_GUARD) + ::testing::FLAGS_gtest_death_test_style = "threadsafe"; + ASSERT_EXIT(do_modify_stack_chk_guard(), testing::KilledBySignal(SIGABRT), ""); +#else // TEST_STACK_CHK_GUARD + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // TEST_STACK_CHK_GUARD +} diff --git a/tests/stack_unwinding_test.cpp b/tests/stack_unwinding_test.cpp index 3b18daa58..1024f28f1 100644 --- a/tests/stack_unwinding_test.cpp +++ b/tests/stack_unwinding_test.cpp @@ -20,8 +20,6 @@ #include -#if defined(i386) // Only our x86 unwinding is good enough. Switch to libunwind? - extern "C" { void do_test(); } @@ -29,8 +27,11 @@ extern "C" { // We have to say "DeathTest" here so gtest knows to run this test (which exits) // in its own process. TEST(stack_unwinding_DeathTest, unwinding_through_signal_frame) { +// Only our x86 unwinding is good enough. Switch to libunwind? +#if defined(__BIONIC__) && defined(__i386__) ::testing::FLAGS_gtest_death_test_style = "threadsafe"; ASSERT_EXIT(do_test(), ::testing::ExitedWithCode(42), ""); +#else // __i386__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __i386__ } - -#endif diff --git a/tests/stdio_test.cpp b/tests/stdio_test.cpp index bd3c548ac..027de3437 100644 --- a/tests/stdio_test.cpp +++ b/tests/stdio_test.cpp @@ -107,7 +107,7 @@ TEST(stdio, getdelim_invalid) { // glibc sometimes doesn't set errno in this particular case. #if defined(__BIONIC__) ASSERT_EQ(EBADF, errno); -#endif +#endif // __BIONIC__ } TEST(stdio, getline) { @@ -176,7 +176,7 @@ TEST(stdio, getline_invalid) { // glibc sometimes doesn't set errno in this particular case. #if defined(__BIONIC__) ASSERT_EQ(EBADF, errno); -#endif +#endif // __BIONIC__ } TEST(stdio, printf_ssize_t) { @@ -191,8 +191,8 @@ TEST(stdio, printf_ssize_t) { snprintf(buf, sizeof(buf), "%zd", v); } -#if !defined(__GLIBC__) TEST(stdio, snprintf_n_format_specifier_not_implemented) { +#if defined(__BIONIC__) char buf[32]; int i = 0; // We deliberately don't implement %n, so it's treated like @@ -200,8 +200,10 @@ TEST(stdio, snprintf_n_format_specifier_not_implemented) { EXPECT_EQ(5, snprintf(buf, sizeof(buf), "a %n b", &i)); EXPECT_EQ(0, i); EXPECT_STREQ("a n b", buf); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } -#endif TEST(stdio, snprintf_smoke) { char buf[BUFSIZ]; @@ -283,9 +285,9 @@ TEST(stdio, snprintf_smoke) { snprintf(buf, sizeof(buf), "a%d,%pz", 5, p); #if defined(__BIONIC__) EXPECT_STREQ("a5,0x0z", buf); -#else +#else // __BIONIC__ EXPECT_STREQ("a5,(nil)z", buf); -#endif +#endif // __BIONIC__ snprintf(buf, sizeof(buf), "a%lld,%d,%d,%dz", 0x1000000000LL, 6, 7, 8); EXPECT_STREQ("a68719476736,6,7,8z", buf); diff --git a/tests/string_test.cpp b/tests/string_test.cpp index 1a7e27d92..c35976a3e 100644 --- a/tests/string_test.cpp +++ b/tests/string_test.cpp @@ -46,14 +46,16 @@ TEST(string, strerror) { ASSERT_STREQ("Unknown error 1234", strerror(1234)); } -#if __BIONIC__ // glibc's strerror isn't thread safe, only its strsignal. - +#if defined(__BIONIC__) static void* ConcurrentStrErrorFn(void*) { bool equal = (strcmp("Unknown error 2002", strerror(2002)) == 0); return reinterpret_cast(equal); } +#endif // __BIONIC__ +// glibc's strerror isn't thread safe, only its strsignal. TEST(string, strerror_concurrent) { +#if defined(__BIONIC__) const char* strerror1001 = strerror(1001); ASSERT_STREQ("Unknown error 1001", strerror1001); @@ -64,12 +66,13 @@ TEST(string, strerror_concurrent) { ASSERT_TRUE(static_cast(result)); ASSERT_STREQ("Unknown error 1001", strerror1001); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } -#endif - -#if __BIONIC__ // glibc's strerror_r doesn't even have the same signature as the POSIX one. TEST(string, strerror_r) { +#if defined(__BIONIC__) // glibc's strerror_r doesn't even have the same signature as the POSIX one. char buf[256]; // Valid. @@ -87,8 +90,10 @@ TEST(string, strerror_r) { // Buffer too small. ASSERT_EQ(-1, strerror_r(0, buf, 2)); ASSERT_EQ(ERANGE, errno); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } -#endif TEST(string, strsignal) { // A regular signal. @@ -478,8 +483,8 @@ TEST(string, strcpy) { } -#if __BIONIC__ TEST(string, strlcat) { +#if defined(__BIONIC__) StringTestState state(SMALL); for (size_t i = 0; i < state.n; i++) { for (size_t j = 0; j < POS_ITER; j++) { @@ -504,11 +509,13 @@ TEST(string, strlcat) { ASSERT_TRUE(memcmp(state.ptr, state.ptr2, state.MAX_LEN + state.len[i]) == 0); } } +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } -#endif -#if __BIONIC__ TEST(string, strlcpy) { +#if defined(__BIONIC__) StringTestState state(SMALL); for (size_t j = 0; j < POS_ITER; j++) { state.NewIteration(); @@ -539,8 +546,10 @@ TEST(string, strlcpy) { ASSERT_FALSE((memcmp(state.ptr1, state.ptr, state.MAX_LEN) != 0) || (memcmp(state.ptr2, state.ptr + state.MAX_LEN, state.MAX_LEN) != 0)); } +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } -#endif TEST(string, strncat) { StringTestState state(SMALL); @@ -732,10 +741,10 @@ TEST(string, memcmp) { } } -#if defined(__BIONIC__) extern "C" int __memcmp16(const unsigned short *ptr1, const unsigned short *ptr2, size_t n); TEST(string, __memcmp16) { +#if defined(__BIONIC__) StringTestState state(SMALL); for (size_t i = 0; i < state.n; i++) { @@ -758,8 +767,10 @@ TEST(string, __memcmp16) { ASSERT_EQ(expected, actual); } } +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } -#endif TEST(string, wmemcmp) { StringTestState state(SMALL); diff --git a/tests/stubs_test.cpp b/tests/stubs_test.cpp index 2e1acc11a..7d70aa61f 100644 --- a/tests/stubs_test.cpp +++ b/tests/stubs_test.cpp @@ -23,8 +23,7 @@ #include #include -#if __BIONIC__ - +#if defined(__BIONIC__) #define CHECK_GETPWNAM_FOR(username, uid, uid_type) \ SCOPED_TRACE(username); \ ASSERT_NO_FATAL_FAILURE(check_getpwnam(username, uid, uid_type)); @@ -51,6 +50,10 @@ static void check_getpwnam(const char* username, uid_t uid, uid_type_t uid_type) EXPECT_STREQ("/system/bin/sh", pwd->pw_shell); } +#else +#define CHECK_GETPWNAM_FOR(username, uid, uid_type) \ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif TEST(getpwnam, system_id_root) { CHECK_GETPWNAM_FOR("root", 0, TYPE_SYSTEM); @@ -104,5 +107,3 @@ TEST(getpwnam, app_id_u1_a0) { TEST(getpwnam, app_id_u1_i0) { CHECK_GETPWNAM_FOR("u1_i0", 199000, TYPE_APP); } - -#endif /* __BIONIC__ */ diff --git a/tests/sys_epoll_test.cpp b/tests/sys_epoll_test.cpp index e4e047b2a..daa064a88 100644 --- a/tests/sys_epoll_test.cpp +++ b/tests/sys_epoll_test.cpp @@ -17,6 +17,7 @@ #include #include +#include #include TEST(sys_epoll, smoke) { diff --git a/tests/sys_select_test.cpp b/tests/sys_select_test.cpp index 57afc9b8d..4bb2d180c 100644 --- a/tests/sys_select_test.cpp +++ b/tests/sys_select_test.cpp @@ -17,6 +17,7 @@ #include #include +#include #include #include diff --git a/tests/sys_sendfile_test.cpp b/tests/sys_sendfile_test.cpp index bf23d3d8d..3d6b5cca2 100644 --- a/tests/sys_sendfile_test.cpp +++ b/tests/sys_sendfile_test.cpp @@ -42,7 +42,6 @@ TEST(sys_sendfile, sendfile) { ASSERT_STREQ("ll", buf); } -#if __BIONIC__ TEST(sys_sendfile, sendfile64) { TemporaryFile src_file; ASSERT_EQ(5, TEMP_FAILURE_RETRY(write(src_file.fd, "hello", 5))); @@ -61,4 +60,3 @@ TEST(sys_sendfile, sendfile64) { ASSERT_EQ(2, TEMP_FAILURE_RETRY(read(dst_file.fd, &buf, 2))); ASSERT_STREQ("ll", buf); } -#endif diff --git a/tests/system_properties_test.cpp b/tests/system_properties_test.cpp index 536797261..bfd585431 100644 --- a/tests/system_properties_test.cpp +++ b/tests/system_properties_test.cpp @@ -20,7 +20,7 @@ #include #include -#if __BIONIC__ +#if defined(__BIONIC__) #define _REALLY_INCLUDE_SYS__SYSTEM_PROPERTIES_H_ #include @@ -69,7 +69,54 @@ private: void *old_pa; }; +static void foreach_test_callback(const prop_info *pi, void* cookie) { + size_t *count = static_cast(cookie); + + ASSERT_NE((prop_info *)NULL, pi); + (*count)++; +} + +static void hierarchical_test_callback(const prop_info *pi, void *cookie) { + bool (*ok)[8][8] = static_cast(cookie); + + char name[PROP_NAME_MAX]; + char value[PROP_VALUE_MAX]; + + __system_property_read(pi, name, value); + + int name_i, name_j, name_k; + int value_i, value_j, value_k; + ASSERT_EQ(3, sscanf(name, "property_%d.%d.%d", &name_i, &name_j, &name_k)); + ASSERT_EQ(3, sscanf(value, "value_%d.%d.%d", &value_i, &value_j, &value_k)); + ASSERT_EQ(name_i, value_i); + ASSERT_GE(name_i, 0); + ASSERT_LT(name_i, 8); + ASSERT_EQ(name_j, value_j); + ASSERT_GE(name_j, 0); + ASSERT_LT(name_j, 8); + ASSERT_EQ(name_k, value_k); + ASSERT_GE(name_k, 0); + ASSERT_LT(name_k, 8); + + ok[name_i][name_j][name_k] = true; +} + +static void *PropertyWaitHelperFn(void *arg) { + int *flag = (int *)arg; + prop_info *pi; + pi = (prop_info *)__system_property_find("property"); + usleep(100000); + + *flag = 1; + __system_property_update(pi, "value3", 6); + + return NULL; +} + +#endif // __BIONIC__ + TEST(properties, add) { +#if defined(__BIONIC__) LocalPropertyTestState pa; ASSERT_TRUE(pa.valid); @@ -87,9 +134,13 @@ TEST(properties, add) { ASSERT_EQ(6, __system_property_get("property_other", propvalue)); ASSERT_STREQ(propvalue, "value3"); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } TEST(properties, update) { +#if defined(__BIONIC__) LocalPropertyTestState pa; ASSERT_TRUE(pa.valid); @@ -120,9 +171,13 @@ TEST(properties, update) { ASSERT_EQ(6, __system_property_get("property_other", propvalue)); ASSERT_STREQ(propvalue, "value6"); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } TEST(properties, fill) { +#if defined(__BIONIC__) LocalPropertyTestState pa; ASSERT_TRUE(pa.valid); char prop_name[PROP_NAME_MAX]; @@ -161,16 +216,13 @@ TEST(properties, fill) { ASSERT_EQ(PROP_VALUE_MAX - 1, __system_property_get(prop_name, prop_value_ret)); ASSERT_EQ(0, memcmp(prop_value, prop_value_ret, PROP_VALUE_MAX)); } -} - -static void foreach_test_callback(const prop_info *pi, void* cookie) { - size_t *count = static_cast(cookie); - - ASSERT_NE((prop_info *)NULL, pi); - (*count)++; +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } TEST(properties, foreach) { +#if defined(__BIONIC__) LocalPropertyTestState pa; ASSERT_TRUE(pa.valid); size_t count = 0; @@ -181,9 +233,13 @@ TEST(properties, foreach) { ASSERT_EQ(0, __system_property_foreach(foreach_test_callback, &count)); ASSERT_EQ(3U, count); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } TEST(properties, find_nth) { +#if defined(__BIONIC__) LocalPropertyTestState pa; ASSERT_TRUE(pa.valid); @@ -201,34 +257,13 @@ TEST(properties, find_nth) { ASSERT_EQ((const prop_info *)NULL, __system_property_find_nth(100)); ASSERT_EQ((const prop_info *)NULL, __system_property_find_nth(200)); ASSERT_EQ((const prop_info *)NULL, __system_property_find_nth(247)); -} - -static void hierarchical_test_callback(const prop_info *pi, void *cookie) { - bool (*ok)[8][8] = static_cast(cookie); - - char name[PROP_NAME_MAX]; - char value[PROP_VALUE_MAX]; - - __system_property_read(pi, name, value); - - int name_i, name_j, name_k; - int value_i, value_j, value_k; - ASSERT_EQ(3, sscanf(name, "property_%d.%d.%d", &name_i, &name_j, &name_k)); - ASSERT_EQ(3, sscanf(value, "value_%d.%d.%d", &value_i, &value_j, &value_k)); - ASSERT_EQ(name_i, value_i); - ASSERT_GE(name_i, 0); - ASSERT_LT(name_i, 8); - ASSERT_EQ(name_j, value_j); - ASSERT_GE(name_j, 0); - ASSERT_LT(name_j, 8); - ASSERT_EQ(name_k, value_k); - ASSERT_GE(name_k, 0); - ASSERT_LT(name_k, 8); - - ok[name_i][name_j][name_k] = true; +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } TEST(properties, fill_hierarchical) { +#if defined(__BIONIC__) LocalPropertyTestState pa; ASSERT_TRUE(pa.valid); char prop_name[PROP_NAME_MAX]; @@ -279,9 +314,13 @@ TEST(properties, fill_hierarchical) { } } } +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } TEST(properties, errors) { +#if defined(__BIONIC__) LocalPropertyTestState pa; ASSERT_TRUE(pa.valid); char prop_value[PROP_NAME_MAX]; @@ -296,9 +335,13 @@ TEST(properties, errors) { ASSERT_EQ(-1, __system_property_add("name", PROP_NAME_MAX, "value", 5)); ASSERT_EQ(-1, __system_property_add("name", 4, "value", PROP_VALUE_MAX)); ASSERT_EQ(-1, __system_property_update(NULL, "value", PROP_VALUE_MAX)); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } TEST(properties, serial) { +#if defined(__BIONIC__) LocalPropertyTestState pa; ASSERT_TRUE(pa.valid); const prop_info *pi; @@ -309,22 +352,13 @@ TEST(properties, serial) { serial = __system_property_serial(pi); ASSERT_EQ(0, __system_property_update((prop_info *)pi, "value2", 6)); ASSERT_NE(serial, __system_property_serial(pi)); -} - -static void *PropertyWaitHelperFn(void *arg) -{ - int *flag = (int *)arg; - prop_info *pi; - pi = (prop_info *)__system_property_find("property"); - usleep(100000); - - *flag = 1; - __system_property_update(pi, "value3", 6); - - return NULL; +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } TEST(properties, wait) { +#if defined(__BIONIC__) LocalPropertyTestState pa; ASSERT_TRUE(pa.valid); unsigned int serial; @@ -346,6 +380,9 @@ TEST(properties, wait) { void* result; ASSERT_EQ(0, pthread_join(t, &result)); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } class KilledByFault { @@ -362,6 +399,7 @@ bool KilledByFault::operator()(int exit_status) const { } TEST(properties_DeathTest, read_only) { +#if defined(__BIONIC__) ::testing::FLAGS_gtest_death_test_style = "threadsafe"; // This test only makes sense if we're talking to the real system property service. @@ -371,6 +409,7 @@ TEST(properties_DeathTest, read_only) { } ASSERT_EXIT(__system_property_add("property", 8, "value", 5), KilledByFault(), ""); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } - -#endif diff --git a/tests/time_test.cpp b/tests/time_test.cpp index fb5a4a71f..869ee4baa 100644 --- a/tests/time_test.cpp +++ b/tests/time_test.cpp @@ -20,9 +20,12 @@ #include -#ifdef __BIONIC__ // mktime_tz is a bionic extension. +#if defined(__BIONIC__) // mktime_tz is a bionic extension. #include +#endif // __BIONIC__ + TEST(time, mktime_tz) { +#if defined(__BIONIC__) struct tm epoch; memset(&epoch, 0, sizeof(tm)); epoch.tm_year = 1970 - 1900; @@ -40,8 +43,10 @@ TEST(time, mktime_tz) { // Missing. Falls back to UTC. ASSERT_EQ(2678400, mktime_tz(&epoch, "PST")); +#else // __BIONIC__ + GTEST_LOG_(INFO) << "This test does nothing.\n"; +#endif // __BIONIC__ } -#endif TEST(time, gmtime) { time_t t = 0; @@ -55,7 +60,6 @@ TEST(time, gmtime) { ASSERT_EQ(1970, broken_down->tm_year + 1900); } -#if __BIONIC__ TEST(time, mktime_10310929) { struct tm t; memset(&t, 0, sizeof(tm)); @@ -66,7 +70,9 @@ TEST(time, mktime_10310929) { #if !defined(__LP64__) // 32-bit bionic stupidly had a signed 32-bit time_t. ASSERT_EQ(-1, mktime(&t)); +#if defined(__BIONIC__) ASSERT_EQ(-1, mktime_tz(&t, "UTC")); +#endif #else // Everyone else should be using a signed 64-bit time_t. ASSERT_GE(sizeof(time_t) * 8, 64U); @@ -74,12 +80,15 @@ TEST(time, mktime_10310929) { setenv("TZ", "America/Los_Angeles", 1); tzset(); ASSERT_EQ(static_cast(4108348800U), mktime(&t)); +#if defined(__BIONIC__) ASSERT_EQ(static_cast(4108320000U), mktime_tz(&t, "UTC")); +#endif setenv("TZ", "UTC", 1); tzset(); ASSERT_EQ(static_cast(4108320000U), mktime(&t)); +#if defined(__BIONIC__) ASSERT_EQ(static_cast(4108348800U), mktime_tz(&t, "America/Los_Angeles")); #endif -} #endif +}