about summary refs log tree commit diff
path: root/third_party/abseil_cpp/absl/strings/escaping_test.cc
diff options
context:
space:
mode:
Diffstat (limited to 'third_party/abseil_cpp/absl/strings/escaping_test.cc')
-rw-r--r--third_party/abseil_cpp/absl/strings/escaping_test.cc664
1 files changed, 0 insertions, 664 deletions
diff --git a/third_party/abseil_cpp/absl/strings/escaping_test.cc b/third_party/abseil_cpp/absl/strings/escaping_test.cc
deleted file mode 100644
index 45671a0ed598..000000000000
--- a/third_party/abseil_cpp/absl/strings/escaping_test.cc
+++ /dev/null
@@ -1,664 +0,0 @@
-// Copyright 2017 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
-//
-//      https://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 <array>
-#include <cstdio>
-#include <cstring>
-#include <memory>
-#include <vector>
-
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-#include "absl/container/fixed_array.h"
-#include "absl/strings/str_cat.h"
-
-#include "absl/strings/internal/escaping_test_common.h"
-
-namespace {
-
-struct epair {
-  std::string escaped;
-  std::string unescaped;
-};
-
-TEST(CEscape, EscapeAndUnescape) {
-  const std::string inputs[] = {
-      std::string("foo\nxx\r\b\0023"),
-      std::string(""),
-      std::string("abc"),
-      std::string("\1chad_rules"),
-      std::string("\1arnar_drools"),
-      std::string("xxxx\r\t'\"\\"),
-      std::string("\0xx\0", 4),
-      std::string("\x01\x31"),
-      std::string("abc\xb\x42\141bc"),
-      std::string("123\1\x31\x32\x33"),
-      std::string("\xc1\xca\x1b\x62\x19o\xcc\x04"),
-      std::string(
-          "\\\"\xe8\xb0\xb7\xe6\xad\x8c\\\" is Google\\\'s Chinese name"),
-  };
-  // Do this twice, once for octal escapes and once for hex escapes.
-  for (int kind = 0; kind < 4; kind++) {
-    for (const std::string& original : inputs) {
-      std::string escaped;
-      switch (kind) {
-        case 0:
-          escaped = absl::CEscape(original);
-          break;
-        case 1:
-          escaped = absl::CHexEscape(original);
-          break;
-        case 2:
-          escaped = absl::Utf8SafeCEscape(original);
-          break;
-        case 3:
-          escaped = absl::Utf8SafeCHexEscape(original);
-          break;
-      }
-      std::string unescaped_str;
-      EXPECT_TRUE(absl::CUnescape(escaped, &unescaped_str));
-      EXPECT_EQ(unescaped_str, original);
-
-      unescaped_str.erase();
-      std::string error;
-      EXPECT_TRUE(absl::CUnescape(escaped, &unescaped_str, &error));
-      EXPECT_EQ(error, "");
-
-      // Check in-place unescaping
-      std::string s = escaped;
-      EXPECT_TRUE(absl::CUnescape(s, &s));
-      ASSERT_EQ(s, original);
-    }
-  }
-  // Check that all possible two character strings can be escaped then
-  // unescaped successfully.
-  for (int char0 = 0; char0 < 256; char0++) {
-    for (int char1 = 0; char1 < 256; char1++) {
-      char chars[2];
-      chars[0] = char0;
-      chars[1] = char1;
-      std::string s(chars, 2);
-      std::string escaped = absl::CHexEscape(s);
-      std::string unescaped;
-      EXPECT_TRUE(absl::CUnescape(escaped, &unescaped));
-      EXPECT_EQ(s, unescaped);
-    }
-  }
-}
-
-TEST(CEscape, BasicEscaping) {
-  epair oct_values[] = {
-      {"foo\\rbar\\nbaz\\t", "foo\rbar\nbaz\t"},
-      {"\\'full of \\\"sound\\\" and \\\"fury\\\"\\'",
-       "'full of \"sound\" and \"fury\"'"},
-      {"signi\\\\fying\\\\ nothing\\\\", "signi\\fying\\ nothing\\"},
-      {"\\010\\t\\n\\013\\014\\r", "\010\011\012\013\014\015"}
-  };
-  epair hex_values[] = {
-      {"ubik\\rubik\\nubik\\t", "ubik\rubik\nubik\t"},
-      {"I\\\'ve just seen a \\\"face\\\"",
-       "I've just seen a \"face\""},
-      {"hel\\\\ter\\\\skel\\\\ter\\\\", "hel\\ter\\skel\\ter\\"},
-      {"\\x08\\t\\n\\x0b\\x0c\\r", "\010\011\012\013\014\015"}
-  };
-  epair utf8_oct_values[] = {
-      {"\xe8\xb0\xb7\xe6\xad\x8c\\r\xe8\xb0\xb7\xe6\xad\x8c\\nbaz\\t",
-       "\xe8\xb0\xb7\xe6\xad\x8c\r\xe8\xb0\xb7\xe6\xad\x8c\nbaz\t"},
-      {"\\\"\xe8\xb0\xb7\xe6\xad\x8c\\\" is Google\\\'s Chinese name",
-       "\"\xe8\xb0\xb7\xe6\xad\x8c\" is Google\'s Chinese name"},
-      {"\xe3\x83\xa1\xe3\x83\xbc\xe3\x83\xab\\\\are\\\\Japanese\\\\chars\\\\",
-       "\xe3\x83\xa1\xe3\x83\xbc\xe3\x83\xab\\are\\Japanese\\chars\\"},
-      {"\xed\x81\xac\xeb\xa1\xac\\010\\t\\n\\013\\014\\r",
-       "\xed\x81\xac\xeb\xa1\xac\010\011\012\013\014\015"}
-  };
-  epair utf8_hex_values[] = {
-      {"\x20\xe4\xbd\xa0\\t\xe5\xa5\xbd,\\r!\\n",
-       "\x20\xe4\xbd\xa0\t\xe5\xa5\xbd,\r!\n"},
-      {"\xe8\xa9\xa6\xe9\xa8\x93\\\' means \\\"test\\\"",
-       "\xe8\xa9\xa6\xe9\xa8\x93\' means \"test\""},
-      {"\\\\\xe6\x88\x91\\\\:\\\\\xe6\x9d\xa8\xe6\xac\xa2\\\\",
-       "\\\xe6\x88\x91\\:\\\xe6\x9d\xa8\xe6\xac\xa2\\"},
-      {"\xed\x81\xac\xeb\xa1\xac\\x08\\t\\n\\x0b\\x0c\\r",
-       "\xed\x81\xac\xeb\xa1\xac\010\011\012\013\014\015"}
-  };
-
-  for (const epair& val : oct_values) {
-    std::string escaped = absl::CEscape(val.unescaped);
-    EXPECT_EQ(escaped, val.escaped);
-  }
-  for (const epair& val : hex_values) {
-    std::string escaped = absl::CHexEscape(val.unescaped);
-    EXPECT_EQ(escaped, val.escaped);
-  }
-  for (const epair& val : utf8_oct_values) {
-    std::string escaped = absl::Utf8SafeCEscape(val.unescaped);
-    EXPECT_EQ(escaped, val.escaped);
-  }
-  for (const epair& val : utf8_hex_values) {
-    std::string escaped = absl::Utf8SafeCHexEscape(val.unescaped);
-    EXPECT_EQ(escaped, val.escaped);
-  }
-}
-
-TEST(Unescape, BasicFunction) {
-  epair tests[] =
-    {{"", ""},
-     {"\\u0030", "0"},
-     {"\\u00A3", "\xC2\xA3"},
-     {"\\u22FD", "\xE2\x8B\xBD"},
-     {"\\U00010000", "\xF0\x90\x80\x80"},
-     {"\\U0010FFFD", "\xF4\x8F\xBF\xBD"}};
-  for (const epair& val : tests) {
-    std::string out;
-    EXPECT_TRUE(absl::CUnescape(val.escaped, &out));
-    EXPECT_EQ(out, val.unescaped);
-  }
-  std::string bad[] = {"\\u1",         // too short
-                       "\\U1",         // too short
-                       "\\Uffffff",    // exceeds 0x10ffff (largest Unicode)
-                       "\\U00110000",  // exceeds 0x10ffff (largest Unicode)
-                       "\\uD835",      // surrogate character (D800-DFFF)
-                       "\\U0000DD04",  // surrogate character (D800-DFFF)
-                       "\\777",        // exceeds 0xff
-                       "\\xABCD"};     // exceeds 0xff
-  for (const std::string& e : bad) {
-    std::string error;
-    std::string out;
-    EXPECT_FALSE(absl::CUnescape(e, &out, &error));
-    EXPECT_FALSE(error.empty());
-
-    out.erase();
-    EXPECT_FALSE(absl::CUnescape(e, &out));
-  }
-}
-
-class CUnescapeTest : public testing::Test {
- protected:
-  static const char kStringWithMultipleOctalNulls[];
-  static const char kStringWithMultipleHexNulls[];
-  static const char kStringWithMultipleUnicodeNulls[];
-
-  std::string result_string_;
-};
-
-const char CUnescapeTest::kStringWithMultipleOctalNulls[] =
-    "\\0\\n"    // null escape \0 plus newline
-    "0\\n"      // just a number 0 (not a null escape) plus newline
-    "\\00\\12"  // null escape \00 plus octal newline code
-    "\\000";    // null escape \000
-
-// This has the same ingredients as kStringWithMultipleOctalNulls
-// but with \x hex escapes instead of octal escapes.
-const char CUnescapeTest::kStringWithMultipleHexNulls[] =
-    "\\x0\\n"
-    "0\\n"
-    "\\x00\\xa"
-    "\\x000";
-
-const char CUnescapeTest::kStringWithMultipleUnicodeNulls[] =
-    "\\u0000\\n"    // short-form (4-digit) null escape plus newline
-    "0\\n"          // just a number 0 (not a null escape) plus newline
-    "\\U00000000";  // long-form (8-digit) null escape
-
-TEST_F(CUnescapeTest, Unescapes1CharOctalNull) {
-  std::string original_string = "\\0";
-  EXPECT_TRUE(absl::CUnescape(original_string, &result_string_));
-  EXPECT_EQ(std::string("\0", 1), result_string_);
-}
-
-TEST_F(CUnescapeTest, Unescapes2CharOctalNull) {
-  std::string original_string = "\\00";
-  EXPECT_TRUE(absl::CUnescape(original_string, &result_string_));
-  EXPECT_EQ(std::string("\0", 1), result_string_);
-}
-
-TEST_F(CUnescapeTest, Unescapes3CharOctalNull) {
-  std::string original_string = "\\000";
-  EXPECT_TRUE(absl::CUnescape(original_string, &result_string_));
-  EXPECT_EQ(std::string("\0", 1), result_string_);
-}
-
-TEST_F(CUnescapeTest, Unescapes1CharHexNull) {
-  std::string original_string = "\\x0";
-  EXPECT_TRUE(absl::CUnescape(original_string, &result_string_));
-  EXPECT_EQ(std::string("\0", 1), result_string_);
-}
-
-TEST_F(CUnescapeTest, Unescapes2CharHexNull) {
-  std::string original_string = "\\x00";
-  EXPECT_TRUE(absl::CUnescape(original_string, &result_string_));
-  EXPECT_EQ(std::string("\0", 1), result_string_);
-}
-
-TEST_F(CUnescapeTest, Unescapes3CharHexNull) {
-  std::string original_string = "\\x000";
-  EXPECT_TRUE(absl::CUnescape(original_string, &result_string_));
-  EXPECT_EQ(std::string("\0", 1), result_string_);
-}
-
-TEST_F(CUnescapeTest, Unescapes4CharUnicodeNull) {
-  std::string original_string = "\\u0000";
-  EXPECT_TRUE(absl::CUnescape(original_string, &result_string_));
-  EXPECT_EQ(std::string("\0", 1), result_string_);
-}
-
-TEST_F(CUnescapeTest, Unescapes8CharUnicodeNull) {
-  std::string original_string = "\\U00000000";
-  EXPECT_TRUE(absl::CUnescape(original_string, &result_string_));
-  EXPECT_EQ(std::string("\0", 1), result_string_);
-}
-
-TEST_F(CUnescapeTest, UnescapesMultipleOctalNulls) {
-  std::string original_string(kStringWithMultipleOctalNulls);
-  EXPECT_TRUE(absl::CUnescape(original_string, &result_string_));
-  // All escapes, including newlines and null escapes, should have been
-  // converted to the equivalent characters.
-  EXPECT_EQ(std::string("\0\n"
-                        "0\n"
-                        "\0\n"
-                        "\0",
-                        7),
-            result_string_);
-}
-
-
-TEST_F(CUnescapeTest, UnescapesMultipleHexNulls) {
-  std::string original_string(kStringWithMultipleHexNulls);
-  EXPECT_TRUE(absl::CUnescape(original_string, &result_string_));
-  EXPECT_EQ(std::string("\0\n"
-                        "0\n"
-                        "\0\n"
-                        "\0",
-                        7),
-            result_string_);
-}
-
-TEST_F(CUnescapeTest, UnescapesMultipleUnicodeNulls) {
-  std::string original_string(kStringWithMultipleUnicodeNulls);
-  EXPECT_TRUE(absl::CUnescape(original_string, &result_string_));
-  EXPECT_EQ(std::string("\0\n"
-                        "0\n"
-                        "\0",
-                        5),
-            result_string_);
-}
-
-static struct {
-  absl::string_view plaintext;
-  absl::string_view cyphertext;
-} const base64_tests[] = {
-    // Empty string.
-    {{"", 0}, {"", 0}},
-    {{nullptr, 0},
-     {"", 0}},  // if length is zero, plaintext ptr must be ignored!
-
-    // Basic bit patterns;
-    // values obtained with "echo -n '...' | uuencode -m test"
-
-    {{"\000", 1}, "AA=="},
-    {{"\001", 1}, "AQ=="},
-    {{"\002", 1}, "Ag=="},
-    {{"\004", 1}, "BA=="},
-    {{"\010", 1}, "CA=="},
-    {{"\020", 1}, "EA=="},
-    {{"\040", 1}, "IA=="},
-    {{"\100", 1}, "QA=="},
-    {{"\200", 1}, "gA=="},
-
-    {{"\377", 1}, "/w=="},
-    {{"\376", 1}, "/g=="},
-    {{"\375", 1}, "/Q=="},
-    {{"\373", 1}, "+w=="},
-    {{"\367", 1}, "9w=="},
-    {{"\357", 1}, "7w=="},
-    {{"\337", 1}, "3w=="},
-    {{"\277", 1}, "vw=="},
-    {{"\177", 1}, "fw=="},
-    {{"\000\000", 2}, "AAA="},
-    {{"\000\001", 2}, "AAE="},
-    {{"\000\002", 2}, "AAI="},
-    {{"\000\004", 2}, "AAQ="},
-    {{"\000\010", 2}, "AAg="},
-    {{"\000\020", 2}, "ABA="},
-    {{"\000\040", 2}, "ACA="},
-    {{"\000\100", 2}, "AEA="},
-    {{"\000\200", 2}, "AIA="},
-    {{"\001\000", 2}, "AQA="},
-    {{"\002\000", 2}, "AgA="},
-    {{"\004\000", 2}, "BAA="},
-    {{"\010\000", 2}, "CAA="},
-    {{"\020\000", 2}, "EAA="},
-    {{"\040\000", 2}, "IAA="},
-    {{"\100\000", 2}, "QAA="},
-    {{"\200\000", 2}, "gAA="},
-
-    {{"\377\377", 2}, "//8="},
-    {{"\377\376", 2}, "//4="},
-    {{"\377\375", 2}, "//0="},
-    {{"\377\373", 2}, "//s="},
-    {{"\377\367", 2}, "//c="},
-    {{"\377\357", 2}, "/+8="},
-    {{"\377\337", 2}, "/98="},
-    {{"\377\277", 2}, "/78="},
-    {{"\377\177", 2}, "/38="},
-    {{"\376\377", 2}, "/v8="},
-    {{"\375\377", 2}, "/f8="},
-    {{"\373\377", 2}, "+/8="},
-    {{"\367\377", 2}, "9/8="},
-    {{"\357\377", 2}, "7/8="},
-    {{"\337\377", 2}, "3/8="},
-    {{"\277\377", 2}, "v/8="},
-    {{"\177\377", 2}, "f/8="},
-
-    {{"\000\000\000", 3}, "AAAA"},
-    {{"\000\000\001", 3}, "AAAB"},
-    {{"\000\000\002", 3}, "AAAC"},
-    {{"\000\000\004", 3}, "AAAE"},
-    {{"\000\000\010", 3}, "AAAI"},
-    {{"\000\000\020", 3}, "AAAQ"},
-    {{"\000\000\040", 3}, "AAAg"},
-    {{"\000\000\100", 3}, "AABA"},
-    {{"\000\000\200", 3}, "AACA"},
-    {{"\000\001\000", 3}, "AAEA"},
-    {{"\000\002\000", 3}, "AAIA"},
-    {{"\000\004\000", 3}, "AAQA"},
-    {{"\000\010\000", 3}, "AAgA"},
-    {{"\000\020\000", 3}, "ABAA"},
-    {{"\000\040\000", 3}, "ACAA"},
-    {{"\000\100\000", 3}, "AEAA"},
-    {{"\000\200\000", 3}, "AIAA"},
-    {{"\001\000\000", 3}, "AQAA"},
-    {{"\002\000\000", 3}, "AgAA"},
-    {{"\004\000\000", 3}, "BAAA"},
-    {{"\010\000\000", 3}, "CAAA"},
-    {{"\020\000\000", 3}, "EAAA"},
-    {{"\040\000\000", 3}, "IAAA"},
-    {{"\100\000\000", 3}, "QAAA"},
-    {{"\200\000\000", 3}, "gAAA"},
-
-    {{"\377\377\377", 3}, "////"},
-    {{"\377\377\376", 3}, "///+"},
-    {{"\377\377\375", 3}, "///9"},
-    {{"\377\377\373", 3}, "///7"},
-    {{"\377\377\367", 3}, "///3"},
-    {{"\377\377\357", 3}, "///v"},
-    {{"\377\377\337", 3}, "///f"},
-    {{"\377\377\277", 3}, "//+/"},
-    {{"\377\377\177", 3}, "//9/"},
-    {{"\377\376\377", 3}, "//7/"},
-    {{"\377\375\377", 3}, "//3/"},
-    {{"\377\373\377", 3}, "//v/"},
-    {{"\377\367\377", 3}, "//f/"},
-    {{"\377\357\377", 3}, "/+//"},
-    {{"\377\337\377", 3}, "/9//"},
-    {{"\377\277\377", 3}, "/7//"},
-    {{"\377\177\377", 3}, "/3//"},
-    {{"\376\377\377", 3}, "/v//"},
-    {{"\375\377\377", 3}, "/f//"},
-    {{"\373\377\377", 3}, "+///"},
-    {{"\367\377\377", 3}, "9///"},
-    {{"\357\377\377", 3}, "7///"},
-    {{"\337\377\377", 3}, "3///"},
-    {{"\277\377\377", 3}, "v///"},
-    {{"\177\377\377", 3}, "f///"},
-
-    // Random numbers: values obtained with
-    //
-    //  #! /bin/bash
-    //  dd bs=$1 count=1 if=/dev/random of=/tmp/bar.random
-    //  od -N $1 -t o1 /tmp/bar.random
-    //  uuencode -m test < /tmp/bar.random
-    //
-    // where $1 is the number of bytes (2, 3)
-
-    {{"\243\361", 2}, "o/E="},
-    {{"\024\167", 2}, "FHc="},
-    {{"\313\252", 2}, "y6o="},
-    {{"\046\041", 2}, "JiE="},
-    {{"\145\236", 2}, "ZZ4="},
-    {{"\254\325", 2}, "rNU="},
-    {{"\061\330", 2}, "Mdg="},
-    {{"\245\032", 2}, "pRo="},
-    {{"\006\000", 2}, "BgA="},
-    {{"\375\131", 2}, "/Vk="},
-    {{"\303\210", 2}, "w4g="},
-    {{"\040\037", 2}, "IB8="},
-    {{"\261\372", 2}, "sfo="},
-    {{"\335\014", 2}, "3Qw="},
-    {{"\233\217", 2}, "m48="},
-    {{"\373\056", 2}, "+y4="},
-    {{"\247\232", 2}, "p5o="},
-    {{"\107\053", 2}, "Rys="},
-    {{"\204\077", 2}, "hD8="},
-    {{"\276\211", 2}, "vok="},
-    {{"\313\110", 2}, "y0g="},
-    {{"\363\376", 2}, "8/4="},
-    {{"\251\234", 2}, "qZw="},
-    {{"\103\262", 2}, "Q7I="},
-    {{"\142\312", 2}, "Yso="},
-    {{"\067\211", 2}, "N4k="},
-    {{"\220\001", 2}, "kAE="},
-    {{"\152\240", 2}, "aqA="},
-    {{"\367\061", 2}, "9zE="},
-    {{"\133\255", 2}, "W60="},
-    {{"\176\035", 2}, "fh0="},
-    {{"\032\231", 2}, "Gpk="},
-
-    {{"\013\007\144", 3}, "Cwdk"},
-    {{"\030\112\106", 3}, "GEpG"},
-    {{"\047\325\046", 3}, "J9Um"},
-    {{"\310\160\022", 3}, "yHAS"},
-    {{"\131\100\237", 3}, "WUCf"},
-    {{"\064\342\134", 3}, "NOJc"},
-    {{"\010\177\004", 3}, "CH8E"},
-    {{"\345\147\205", 3}, "5WeF"},
-    {{"\300\343\360", 3}, "wOPw"},
-    {{"\061\240\201", 3}, "MaCB"},
-    {{"\225\333\044", 3}, "ldsk"},
-    {{"\215\137\352", 3}, "jV/q"},
-    {{"\371\147\160", 3}, "+Wdw"},
-    {{"\030\320\051", 3}, "GNAp"},
-    {{"\044\174\241", 3}, "JHyh"},
-    {{"\260\127\037", 3}, "sFcf"},
-    {{"\111\045\033", 3}, "SSUb"},
-    {{"\202\114\107", 3}, "gkxH"},
-    {{"\057\371\042", 3}, "L/ki"},
-    {{"\223\247\244", 3}, "k6ek"},
-    {{"\047\216\144", 3}, "J45k"},
-    {{"\203\070\327", 3}, "gzjX"},
-    {{"\247\140\072", 3}, "p2A6"},
-    {{"\124\115\116", 3}, "VE1O"},
-    {{"\157\162\050", 3}, "b3Io"},
-    {{"\357\223\004", 3}, "75ME"},
-    {{"\052\117\156", 3}, "Kk9u"},
-    {{"\347\154\000", 3}, "52wA"},
-    {{"\303\012\142", 3}, "wwpi"},
-    {{"\060\035\362", 3}, "MB3y"},
-    {{"\130\226\361", 3}, "WJbx"},
-    {{"\173\013\071", 3}, "ews5"},
-    {{"\336\004\027", 3}, "3gQX"},
-    {{"\357\366\234", 3}, "7/ac"},
-    {{"\353\304\111", 3}, "68RJ"},
-    {{"\024\264\131", 3}, "FLRZ"},
-    {{"\075\114\251", 3}, "PUyp"},
-    {{"\315\031\225", 3}, "zRmV"},
-    {{"\154\201\276", 3}, "bIG+"},
-    {{"\200\066\072", 3}, "gDY6"},
-    {{"\142\350\267", 3}, "Yui3"},
-    {{"\033\000\166", 3}, "GwB2"},
-    {{"\210\055\077", 3}, "iC0/"},
-    {{"\341\037\124", 3}, "4R9U"},
-    {{"\161\103\152", 3}, "cUNq"},
-    {{"\270\142\131", 3}, "uGJZ"},
-    {{"\337\076\074", 3}, "3z48"},
-    {{"\375\106\362", 3}, "/Uby"},
-    {{"\227\301\127", 3}, "l8FX"},
-    {{"\340\002\234", 3}, "4AKc"},
-    {{"\121\064\033", 3}, "UTQb"},
-    {{"\157\134\143", 3}, "b1xj"},
-    {{"\247\055\327", 3}, "py3X"},
-    {{"\340\142\005", 3}, "4GIF"},
-    {{"\060\260\143", 3}, "MLBj"},
-    {{"\075\203\170", 3}, "PYN4"},
-    {{"\143\160\016", 3}, "Y3AO"},
-    {{"\313\013\063", 3}, "ywsz"},
-    {{"\174\236\135", 3}, "fJ5d"},
-    {{"\103\047\026", 3}, "QycW"},
-    {{"\365\005\343", 3}, "9QXj"},
-    {{"\271\160\223", 3}, "uXCT"},
-    {{"\362\255\172", 3}, "8q16"},
-    {{"\113\012\015", 3}, "SwoN"},
-
-    // various lengths, generated by this python script:
-    //
-    // from std::string import lowercase as lc
-    // for i in range(27):
-    //   print '{ %2d, "%s",%s "%s" },' % (i, lc[:i], ' ' * (26-i),
-    //                                     lc[:i].encode('base64').strip())
-
-    {{"", 0}, {"", 0}},
-    {"a", "YQ=="},
-    {"ab", "YWI="},
-    {"abc", "YWJj"},
-    {"abcd", "YWJjZA=="},
-    {"abcde", "YWJjZGU="},
-    {"abcdef", "YWJjZGVm"},
-    {"abcdefg", "YWJjZGVmZw=="},
-    {"abcdefgh", "YWJjZGVmZ2g="},
-    {"abcdefghi", "YWJjZGVmZ2hp"},
-    {"abcdefghij", "YWJjZGVmZ2hpag=="},
-    {"abcdefghijk", "YWJjZGVmZ2hpams="},
-    {"abcdefghijkl", "YWJjZGVmZ2hpamts"},
-    {"abcdefghijklm", "YWJjZGVmZ2hpamtsbQ=="},
-    {"abcdefghijklmn", "YWJjZGVmZ2hpamtsbW4="},
-    {"abcdefghijklmno", "YWJjZGVmZ2hpamtsbW5v"},
-    {"abcdefghijklmnop", "YWJjZGVmZ2hpamtsbW5vcA=="},
-    {"abcdefghijklmnopq", "YWJjZGVmZ2hpamtsbW5vcHE="},
-    {"abcdefghijklmnopqr", "YWJjZGVmZ2hpamtsbW5vcHFy"},
-    {"abcdefghijklmnopqrs", "YWJjZGVmZ2hpamtsbW5vcHFycw=="},
-    {"abcdefghijklmnopqrst", "YWJjZGVmZ2hpamtsbW5vcHFyc3Q="},
-    {"abcdefghijklmnopqrstu", "YWJjZGVmZ2hpamtsbW5vcHFyc3R1"},
-    {"abcdefghijklmnopqrstuv", "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dg=="},
-    {"abcdefghijklmnopqrstuvw", "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnc="},
-    {"abcdefghijklmnopqrstuvwx", "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4"},
-    {"abcdefghijklmnopqrstuvwxy", "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eQ=="},
-    {"abcdefghijklmnopqrstuvwxyz", "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXo="},
-};
-
-template <typename StringType>
-void TestEscapeAndUnescape() {
-  // Check the short strings; this tests the math (and boundaries)
-  for (const auto& tc : base64_tests) {
-    StringType encoded("this junk should be ignored");
-    absl::Base64Escape(tc.plaintext, &encoded);
-    EXPECT_EQ(encoded, tc.cyphertext);
-    EXPECT_EQ(absl::Base64Escape(tc.plaintext), tc.cyphertext);
-
-    StringType decoded("this junk should be ignored");
-    EXPECT_TRUE(absl::Base64Unescape(encoded, &decoded));
-    EXPECT_EQ(decoded, tc.plaintext);
-
-    StringType websafe(tc.cyphertext);
-    for (int c = 0; c < websafe.size(); ++c) {
-      if ('+' == websafe[c]) websafe[c] = '-';
-      if ('/' == websafe[c]) websafe[c] = '_';
-      if ('=' == websafe[c]) {
-        websafe.resize(c);
-        break;
-      }
-    }
-
-    encoded = "this junk should be ignored";
-    absl::WebSafeBase64Escape(tc.plaintext, &encoded);
-    EXPECT_EQ(encoded, websafe);
-    EXPECT_EQ(absl::WebSafeBase64Escape(tc.plaintext), websafe);
-
-    // Let's try the string version of the decoder
-    decoded = "this junk should be ignored";
-    EXPECT_TRUE(absl::WebSafeBase64Unescape(websafe, &decoded));
-    EXPECT_EQ(decoded, tc.plaintext);
-  }
-
-  // Now try the long strings, this tests the streaming
-  for (const auto& tc : absl::strings_internal::base64_strings()) {
-    StringType buffer;
-    absl::WebSafeBase64Escape(tc.plaintext, &buffer);
-    EXPECT_EQ(tc.cyphertext, buffer);
-    EXPECT_EQ(absl::WebSafeBase64Escape(tc.plaintext), tc.cyphertext);
-  }
-
-  // Verify the behavior when decoding bad data
-  {
-    absl::string_view data_set[] = {"ab-/", absl::string_view("\0bcd", 4),
-                                    absl::string_view("abc.\0", 5)};
-    for (absl::string_view bad_data : data_set) {
-      StringType buf;
-      EXPECT_FALSE(absl::Base64Unescape(bad_data, &buf));
-      EXPECT_FALSE(absl::WebSafeBase64Unescape(bad_data, &buf));
-      EXPECT_TRUE(buf.empty());
-    }
-  }
-}
-
-TEST(Base64, EscapeAndUnescape) {
-  TestEscapeAndUnescape<std::string>();
-}
-
-TEST(Base64, DISABLED_HugeData) {
-  const size_t kSize = size_t(3) * 1000 * 1000 * 1000;
-  static_assert(kSize % 3 == 0, "kSize must be divisible by 3");
-  const std::string huge(kSize, 'x');
-
-  std::string escaped;
-  absl::Base64Escape(huge, &escaped);
-
-  // Generates the string that should match a base64 encoded "xxx..." string.
-  // "xxx" in base64 is "eHh4".
-  std::string expected_encoding;
-  expected_encoding.reserve(kSize / 3 * 4);
-  for (size_t i = 0; i < kSize / 3; ++i) {
-    expected_encoding.append("eHh4");
-  }
-  EXPECT_EQ(expected_encoding, escaped);
-
-  std::string unescaped;
-  EXPECT_TRUE(absl::Base64Unescape(escaped, &unescaped));
-  EXPECT_EQ(huge, unescaped);
-}
-
-TEST(HexAndBack, HexStringToBytes_and_BytesToHexString) {
-  std::string hex_mixed = "0123456789abcdefABCDEF";
-  std::string bytes_expected = "\x01\x23\x45\x67\x89\xab\xcd\xef\xAB\xCD\xEF";
-  std::string hex_only_lower = "0123456789abcdefabcdef";
-
-  std::string bytes_result = absl::HexStringToBytes(hex_mixed);
-  EXPECT_EQ(bytes_expected, bytes_result);
-
-  std::string prefix_valid = hex_mixed + "?";
-  std::string prefix_valid_result = absl::HexStringToBytes(
-      absl::string_view(prefix_valid.data(), prefix_valid.size() - 1));
-  EXPECT_EQ(bytes_expected, prefix_valid_result);
-
-  std::string infix_valid = "?" + hex_mixed + "???";
-  std::string infix_valid_result = absl::HexStringToBytes(
-      absl::string_view(infix_valid.data() + 1, hex_mixed.size()));
-  EXPECT_EQ(bytes_expected, infix_valid_result);
-
-  std::string hex_result = absl::BytesToHexString(bytes_expected);
-  EXPECT_EQ(hex_only_lower, hex_result);
-}
-
-}  // namespace