- 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

6 files changed, 165 insertions, 13 deletions

diff --git a/absl/strings/BUILD.bazel b/absl/strings/BUILD.bazel
index 28cf2d2eba5a..e6bb7ff530e4 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 97f36013bd61..9903b0496b77 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 000000000000..26ddc2d5f318
--- /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 5bb39ca9b5a9..e372eea14ca8 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 c86a5952fab0..e9d676906382 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 bb149d5c224c..fffa7b99205f 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)