- 31d03284ca8017ba59d98d47e7d041f361d478a7 Release escaping microbenchmarks. by Alex Strelnikov <strel@google.com>

  - f183ce453db49ebc1948bb1d8eced37021cf63f7 Internal change. by Derek Mauro <dmauro@google.com>
  - b1660cb93e0fa37cdcecf37642766f5bfd12c7b0 Improve compatibility of some cc_test targets for portabl... by Abseil Team <absl-team@google.com>

GitOrigin-RevId: 31d03284ca8017ba59d98d47e7d041f361d478a7
Change-Id: I9c4c4d2ad12cfe10c914f7cfa9aaab67fcef5cb1

11 files changed, 189 insertions, 14 deletions

diff --git a/absl/base/BUILD.bazel b/absl/base/BUILD.bazel
index 3d3c7aea57..748f2f9f21 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 07d7e8ee1b..fd89a3f626 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 303410834b..897be90fc9 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 28cf2d2eba..e6bb7ff530 100644
--- a/absl/strings/BUILD.bazel
+++ b/absl/strings/BUILD.bazel
@@ -124,10 +124,31 @@ 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 97f36013bd..9903b0496b 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 0000000000..26ddc2d5f3
--- /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 <cstdio>
+#include <cstring>
+#include <random>
+
+#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 5bb39ca9b5..e372eea14c 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 c86a5952fa..e9d6769063 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 bb149d5c22..fffa7b9920 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 67ce7ff9bb..2502c53fff 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 53474b7b0b..2e6686a4c0 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