From 99477fa9f1e89a7d8253c8aeee331864710d080c Mon Sep 17 00:00:00 2001 From: Abseil Team Date: Thu, 24 May 2018 10:33:14 -0700 Subject: - 31d03284ca8017ba59d98d47e7d041f361d478a7 Release escaping microbenchmarks. by Alex Strelnikov - f183ce453db49ebc1948bb1d8eced37021cf63f7 Internal change. by Derek Mauro - b1660cb93e0fa37cdcecf37642766f5bfd12c7b0 Improve compatibility of some cc_test targets for portabl... by Abseil Team GitOrigin-RevId: 31d03284ca8017ba59d98d47e7d041f361d478a7 Change-Id: I9c4c4d2ad12cfe10c914f7cfa9aaab67fcef5cb1 --- absl/base/BUILD.bazel | 10 +++ absl/base/internal/exception_testing.h | 6 +- absl/container/BUILD.bazel | 5 ++ absl/strings/BUILD.bazel | 29 +++++++++ absl/strings/ascii_test.cc | 21 ++++--- absl/strings/escaping_benchmark.cc | 96 +++++++++++++++++++++++++++++ absl/strings/numbers_test.cc | 2 +- absl/strings/str_cat_test.cc | 14 ++++- absl/strings/string_view_test.cc | 16 ++++- absl/synchronization/BUILD.bazel | 3 + absl/synchronization/internal/graphcycles.h | 1 + 11 files changed, 189 insertions(+), 14 deletions(-) create mode 100644 absl/strings/escaping_benchmark.cc diff --git a/absl/base/BUILD.bazel b/absl/base/BUILD.bazel index 3d3c7aea..748f2f9f 100644 --- a/absl/base/BUILD.bazel +++ b/absl/base/BUILD.bazel @@ -371,6 +371,11 @@ cc_test( size = "small", srcs = ["internal/sysinfo_test.cc"], copts = ABSL_TEST_COPTS, + tags = [ + "no_test_android_arm", + "no_test_android_arm64", + "no_test_android_x86", + ], deps = [ ":base", "//absl/synchronization", @@ -387,6 +392,11 @@ cc_test( "//absl:windows": [], "//conditions:default": ["-pthread"], }), + tags = [ + "no_test_android_arm", + "no_test_android_arm64", + "no_test_android_x86", + ], deps = [":malloc_internal"], ) diff --git a/absl/base/internal/exception_testing.h b/absl/base/internal/exception_testing.h index 07d7e8ee..fd89a3f6 100644 --- a/absl/base/internal/exception_testing.h +++ b/absl/base/internal/exception_testing.h @@ -28,8 +28,12 @@ #define ABSL_BASE_INTERNAL_EXPECT_FAIL(expr, exception_t, text) \ EXPECT_THROW(expr, exception_t) +#elif defined(__ANDROID__) +// Android asserts do not log anywhere that gtest can currently inspect. +// So we expect exit, but cannot match the message. +#define ABSL_BASE_INTERNAL_EXPECT_FAIL(expr, exception_t, text) \ + EXPECT_DEATH(expr, ".*") #else - #define ABSL_BASE_INTERNAL_EXPECT_FAIL(expr, exception_t, text) \ EXPECT_DEATH(expr, text) diff --git a/absl/container/BUILD.bazel b/absl/container/BUILD.bazel index 30341083..897be90f 100644 --- a/absl/container/BUILD.bazel +++ b/absl/container/BUILD.bazel @@ -42,6 +42,11 @@ cc_test( name = "fixed_array_test", srcs = ["fixed_array_test.cc"], copts = ABSL_TEST_COPTS + ABSL_EXCEPTIONS_FLAG, + tags = [ + "no_test_android_arm", + "no_test_android_arm64", + "no_test_android_x86", + ], deps = [ ":fixed_array", "//absl/base:exception_testing", diff --git a/absl/strings/BUILD.bazel b/absl/strings/BUILD.bazel index 28cf2d2e..e6bb7ff5 100644 --- a/absl/strings/BUILD.bazel +++ b/absl/strings/BUILD.bazel @@ -123,11 +123,32 @@ cc_test( ], ) +cc_test( + name = "escaping_benchmark", + srcs = [ + "escaping_benchmark.cc", + "internal/escaping_test_common.inc", + ], + copts = ABSL_TEST_COPTS, + tags = ["benchmark"], + visibility = ["//visibility:private"], + deps = [ + ":strings", + "//absl/base", + "@com_github_google_benchmark//:benchmark", + ], +) + cc_test( name = "ascii_test", size = "small", srcs = ["ascii_test.cc"], copts = ABSL_TEST_COPTS, + tags = [ + "no_test_android_arm", + "no_test_android_arm64", + "no_test_android_x86", + ], visibility = ["//visibility:private"], deps = [ ":strings", @@ -350,6 +371,9 @@ cc_test( ], copts = ABSL_TEST_COPTS, tags = [ + "no_test_android_arm", + "no_test_android_arm64", + "no_test_android_x86", "no_test_loonix", ], visibility = ["//visibility:private"], @@ -377,6 +401,11 @@ cc_test( name = "char_map_test", srcs = ["internal/char_map_test.cc"], copts = ABSL_TEST_COPTS, + tags = [ + "no_test_android_arm", + "no_test_android_arm64", + "no_test_android_x86", + ], deps = [ ":internal", "@com_google_googletest//:gtest_main", diff --git a/absl/strings/ascii_test.cc b/absl/strings/ascii_test.cc index 97f36013..9903b049 100644 --- a/absl/strings/ascii_test.cc +++ b/absl/strings/ascii_test.cc @@ -130,9 +130,11 @@ TEST(AsciiIsFoo, All) { // Checks that absl::ascii_isfoo returns the same value as isfoo in the C // locale. TEST(AsciiIsFoo, SameAsIsFoo) { +#ifndef __ANDROID__ // temporarily change locale to C. It should already be C, but just for safety - std::string old_locale = setlocale(LC_CTYPE, nullptr); - ASSERT_TRUE(setlocale(LC_CTYPE, "C")); + const char* old_locale = setlocale(LC_CTYPE, "C"); + ASSERT_TRUE(old_locale != nullptr); +#endif for (int i = 0; i < 256; i++) { EXPECT_EQ(isalpha(i) != 0, absl::ascii_isalpha(i)) << i; @@ -150,14 +152,18 @@ TEST(AsciiIsFoo, SameAsIsFoo) { EXPECT_EQ(isascii(i) != 0, absl::ascii_isascii(i)) << i; } +#ifndef __ANDROID__ // restore the old locale. - ASSERT_TRUE(setlocale(LC_CTYPE, old_locale.c_str())); + ASSERT_TRUE(setlocale(LC_CTYPE, old_locale)); +#endif } TEST(AsciiToFoo, All) { +#ifndef __ANDROID__ // temporarily change locale to C. It should already be C, but just for safety - std::string old_locale = setlocale(LC_CTYPE, nullptr); - ASSERT_TRUE(setlocale(LC_CTYPE, "C")); + const char* old_locale = setlocale(LC_CTYPE, "C"); + ASSERT_TRUE(old_locale != nullptr); +#endif for (int i = 0; i < 256; i++) { if (absl::ascii_islower(i)) @@ -180,9 +186,10 @@ TEST(AsciiToFoo, All) { EXPECT_EQ(absl::ascii_tolower(i), absl::ascii_tolower(sc)) << i; EXPECT_EQ(absl::ascii_toupper(i), absl::ascii_toupper(sc)) << i; } - +#ifndef __ANDROID__ // restore the old locale. - ASSERT_TRUE(setlocale(LC_CTYPE, old_locale.c_str())); + ASSERT_TRUE(setlocale(LC_CTYPE, old_locale)); +#endif } TEST(AsciiStrTo, Lower) { diff --git a/absl/strings/escaping_benchmark.cc b/absl/strings/escaping_benchmark.cc new file mode 100644 index 00000000..26ddc2d5 --- /dev/null +++ b/absl/strings/escaping_benchmark.cc @@ -0,0 +1,96 @@ +// Copyright 2018 The Abseil Authors. +// +// 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 "absl/strings/escaping.h" + +#include +#include +#include + +#include "benchmark/benchmark.h" +#include "absl/base/internal/raw_logging.h" +#include "absl/strings/internal/escaping_test_common.inc" + +namespace { + +void BM_CUnescapeHexString(benchmark::State& state) { + std::string src; + for (int i = 0; i < 50; i++) { + src += "\\x55"; + } + std::string dest; + for (auto _ : state) { + absl::CUnescape(src, &dest); + } +} +BENCHMARK(BM_CUnescapeHexString); + +void BM_WebSafeBase64Escape_string(benchmark::State& state) { + std::string raw; + for (int i = 0; i < 10; ++i) { + for (const auto& test_set : base64_strings) { + raw += std::string(test_set.plaintext); + } + } + + // The actual benchmark loop is tiny... + std::string escaped; + for (auto _ : state) { + absl::WebSafeBase64Escape(raw, &escaped); + } + + // We want to be sure the compiler doesn't throw away the loop above, + // and the easiest way to ensure that is to round-trip the results and verify + // them. + std::string round_trip; + absl::WebSafeBase64Unescape(escaped, &round_trip); + ABSL_RAW_CHECK(round_trip == raw, ""); +} +BENCHMARK(BM_WebSafeBase64Escape_string); + +// Used for the CEscape benchmarks +const char kStringValueNoEscape[] = "1234567890"; +const char kStringValueSomeEscaped[] = "123\n56789\xA1"; +const char kStringValueMostEscaped[] = "\xA1\xA2\ny\xA4\xA5\xA6z\b\r"; + +void CEscapeBenchmarkHelper(benchmark::State& state, const char* string_value, + int max_len) { + std::string src; + while (src.size() < max_len) { + absl::StrAppend(&src, string_value); + } + + for (auto _ : state) { + absl::CEscape(src); + } +} + +void BM_CEscape_NoEscape(benchmark::State& state) { + CEscapeBenchmarkHelper(state, kStringValueNoEscape, state.range(0)); +} +BENCHMARK(BM_CEscape_NoEscape)->Range(1, 1 << 14); + +void BM_CEscape_SomeEscaped(benchmark::State& state) { + CEscapeBenchmarkHelper(state, kStringValueSomeEscaped, state.range(0)); +} +BENCHMARK(BM_CEscape_SomeEscaped)->Range(1, 1 << 14); + +void BM_CEscape_MostEscaped(benchmark::State& state) { + CEscapeBenchmarkHelper(state, kStringValueMostEscaped, state.range(0)); +} +BENCHMARK(BM_CEscape_MostEscaped)->Range(1, 1 << 14); + +} // namespace + +BENCHMARK_MAIN(); diff --git a/absl/strings/numbers_test.cc b/absl/strings/numbers_test.cc index 5bb39ca9..e372eea1 100644 --- a/absl/strings/numbers_test.cc +++ b/absl/strings/numbers_test.cc @@ -119,7 +119,7 @@ TEST(ToString, PerfectDtoa) { {1e-300, 1e-200, 1e-100, 0.1, 1.0, 10.0, 1e100, 1e300}) { double d = multiplier * i; std::string s = PerfectDtoa(d); - EXPECT_EQ(d, strtod(s.c_str(), nullptr)); + EXPECT_DOUBLE_EQ(d, strtod(s.c_str(), nullptr)); } } } diff --git a/absl/strings/str_cat_test.cc b/absl/strings/str_cat_test.cc index c86a5952..e9d67690 100644 --- a/absl/strings/str_cat_test.cc +++ b/absl/strings/str_cat_test.cc @@ -22,6 +22,15 @@ #include "gtest/gtest.h" #include "absl/strings/substitute.h" +#ifdef __ANDROID__ +// Android assert messages only go to system log, so death tests cannot inspect +// the message for matching. +#define ABSL_EXPECT_DEBUG_DEATH(statement, regex) \ + EXPECT_DEBUG_DEATH(statement, ".*") +#else +#define ABSL_EXPECT_DEBUG_DEATH EXPECT_DEBUG_DEATH +#endif + namespace { // Test absl::StrCat of ints and longs of various sizes and signdedness. @@ -396,8 +405,9 @@ TEST(StrAppend, Death) { std::string s = "self"; // on linux it's "assertion", on mac it's "Assertion", // on chromiumos it's "Assertion ... failed". - EXPECT_DEBUG_DEATH(absl::StrAppend(&s, s.c_str() + 1), "ssertion.*failed"); - EXPECT_DEBUG_DEATH(absl::StrAppend(&s, s), "ssertion.*failed"); + ABSL_EXPECT_DEBUG_DEATH(absl::StrAppend(&s, s.c_str() + 1), + "ssertion.*failed"); + ABSL_EXPECT_DEBUG_DEATH(absl::StrAppend(&s, s), "ssertion.*failed"); } #endif // GTEST_HAS_DEATH_TEST diff --git a/absl/strings/string_view_test.cc b/absl/strings/string_view_test.cc index bb149d5c..fffa7b99 100644 --- a/absl/strings/string_view_test.cc +++ b/absl/strings/string_view_test.cc @@ -29,6 +29,15 @@ #include "absl/base/config.h" #include "absl/base/dynamic_annotations.h" +#ifdef __ANDROID__ +// Android assert messages only go to system log, so death tests cannot inspect +// the message for matching. +#define ABSL_EXPECT_DEATH_IF_SUPPORTED(statement, regex) \ + EXPECT_DEATH_IF_SUPPORTED(statement, ".*") +#else +#define ABSL_EXPECT_DEATH_IF_SUPPORTED EXPECT_DEATH_IF_SUPPORTED +#endif + namespace { // A minimal allocator that uses malloc(). @@ -1068,7 +1077,8 @@ TEST(HugeStringView, TwoPointTwoGB) { #if !defined(NDEBUG) && !defined(ABSL_HAVE_STD_STRING_VIEW) TEST(NonNegativeLenTest, NonNegativeLen) { - EXPECT_DEATH_IF_SUPPORTED(absl::string_view("xyz", -1), "len <= kMaxSize"); + ABSL_EXPECT_DEATH_IF_SUPPORTED(absl::string_view("xyz", -1), + "len <= kMaxSize"); } TEST(LenExceedsMaxSizeTest, LenExceedsMaxSize) { @@ -1078,8 +1088,8 @@ TEST(LenExceedsMaxSizeTest, LenExceedsMaxSize) { absl::string_view ok_view("", max_size); // Adding one to the max should trigger an assertion. - EXPECT_DEATH_IF_SUPPORTED(absl::string_view("", max_size + 1), - "len <= kMaxSize"); + ABSL_EXPECT_DEATH_IF_SUPPORTED(absl::string_view("", max_size + 1), + "len <= kMaxSize"); } #endif // !defined(NDEBUG) && !defined(ABSL_HAVE_STD_STRING_VIEW) diff --git a/absl/synchronization/BUILD.bazel b/absl/synchronization/BUILD.bazel index 67ce7ff9..2502c53f 100644 --- a/absl/synchronization/BUILD.bazel +++ b/absl/synchronization/BUILD.bazel @@ -150,6 +150,9 @@ cc_test( srcs = ["mutex_test.cc"], copts = ABSL_TEST_COPTS, tags = [ + "no_test_android_arm", + "no_test_android_arm64", + "no_test_android_x86", "no_test_loonix", # Too slow. ], deps = [ diff --git a/absl/synchronization/internal/graphcycles.h b/absl/synchronization/internal/graphcycles.h index 53474b7b..2e6686a4 100644 --- a/absl/synchronization/internal/graphcycles.h +++ b/absl/synchronization/internal/graphcycles.h @@ -133,4 +133,5 @@ class GraphCycles { } // namespace synchronization_internal } // namespace absl + #endif -- cgit v1.2.3