diff options
Diffstat (limited to 'third_party/abseil_cpp/absl/strings/escaping_test.cc')
| -rw-r--r-- | third_party/abseil_cpp/absl/strings/escaping_test.cc | 664 |
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 |