Move quic::test::CompareCharArraysWithHexError to Quiche gfe-relnote: n/a, no functional change PiperOrigin-RevId: 288560303 Change-Id: I82c3d1c60617d3c94abff40ea01ca5c8cecf95e2
diff --git a/common/platform/api/quiche_test.h b/common/platform/api/quiche_test.h index f51c85e..6b64984 100644 --- a/common/platform/api/quiche_test.h +++ b/common/platform/api/quiche_test.h
@@ -7,4 +7,7 @@ #include "net/quiche/common/platform/impl/quiche_test_impl.h" +template <class T> +using QuicheTestWithParam = quiche::test::QuicheTestWithParamImpl<T>; + #endif // QUICHE_COMMON_PLATFORM_API_QUICHE_TEST_H_
diff --git a/common/test_tools/quiche_test_utils.cc b/common/test_tools/quiche_test_utils.cc new file mode 100644 index 0000000..0a84635 --- /dev/null +++ b/common/test_tools/quiche_test_utils.cc
@@ -0,0 +1,91 @@ +// Copyright (c) 2020 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h" + +#include "net/third_party/quiche/src/common/platform/api/quiche_logging.h" +#include "net/third_party/quiche/src/common/platform/api/quiche_test.h" + +#include <string> + +namespace { + +std::string HexDumpWithMarks(const char* data, + int length, + const bool* marks, + int mark_length) { + static const char kHexChars[] = "0123456789abcdef"; + static const int kColumns = 4; + + const int kSizeLimit = 1024; + if (length > kSizeLimit || mark_length > kSizeLimit) { + QUICHE_LOG(ERROR) << "Only dumping first " << kSizeLimit << " bytes."; + length = std::min(length, kSizeLimit); + mark_length = std::min(mark_length, kSizeLimit); + } + + std::string hex; + for (const char* row = data; length > 0; + row += kColumns, length -= kColumns) { + for (const char* p = row; p < row + 4; ++p) { + if (p < row + length) { + const bool mark = + (marks && (p - data) < mark_length && marks[p - data]); + hex += mark ? '*' : ' '; + hex += kHexChars[(*p & 0xf0) >> 4]; + hex += kHexChars[*p & 0x0f]; + hex += mark ? '*' : ' '; + } else { + hex += " "; + } + } + hex = hex + " "; + + for (const char* p = row; p < row + 4 && p < row + length; ++p) { + hex += (*p >= 0x20 && *p <= 0x7f) ? (*p) : '.'; + } + + hex = hex + '\n'; + } + return hex; +} + +} // namespace + +namespace quiche { +namespace test { + +void CompareCharArraysWithHexError(const std::string& description, + const char* actual, + const int actual_len, + const char* expected, + const int expected_len) { + EXPECT_EQ(actual_len, expected_len); + const int min_len = std::min(actual_len, expected_len); + const int max_len = std::max(actual_len, expected_len); + std::unique_ptr<bool[]> marks(new bool[max_len]); + bool identical = (actual_len == expected_len); + for (int i = 0; i < min_len; ++i) { + if (actual[i] != expected[i]) { + marks[i] = true; + identical = false; + } else { + marks[i] = false; + } + } + for (int i = min_len; i < max_len; ++i) { + marks[i] = true; + } + if (identical) + return; + ADD_FAILURE() << "Description:\n" + << description << "\n\nExpected:\n" + << HexDumpWithMarks(expected, expected_len, marks.get(), + max_len) + << "\nActual:\n" + << HexDumpWithMarks(actual, actual_len, marks.get(), max_len); +} + +} // namespace test +} // namespace quiche
diff --git a/common/test_tools/quiche_test_utils.h b/common/test_tools/quiche_test_utils.h new file mode 100644 index 0000000..45a526b --- /dev/null +++ b/common/test_tools/quiche_test_utils.h
@@ -0,0 +1,22 @@ +// Copyright (c) 2020 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef QUICHE_COMMON_QUICHE_TEST_UTILS_H_ +#define QUICHE_COMMON_QUICHE_TEST_UTILS_H_ + +#include <string> + +namespace quiche { +namespace test { + +void CompareCharArraysWithHexError(const std::string& description, + const char* actual, + const int actual_len, + const char* expected, + const int expected_len); + +} // namespace test +} // namespace quiche + +#endif // QUICHE_COMMON_QUICHE_TEST_UTILS_H_
diff --git a/quic/core/crypto/aes_128_gcm_12_decrypter_test.cc b/quic/core/crypto/aes_128_gcm_12_decrypter_test.cc index cfd6812..0319d42 100644 --- a/quic/core/crypto/aes_128_gcm_12_decrypter_test.cc +++ b/quic/core/crypto/aes_128_gcm_12_decrypter_test.cc
@@ -13,6 +13,7 @@ #include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h" #include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" #include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h" +#include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h" namespace { @@ -277,8 +278,8 @@ EXPECT_TRUE(has_pt); ASSERT_EQ(pt.length(), decrypted->length()); - test::CompareCharArraysWithHexError("plaintext", decrypted->data(), - pt.length(), pt.data(), pt.length()); + quiche::test::CompareCharArraysWithHexError( + "plaintext", decrypted->data(), pt.length(), pt.data(), pt.length()); } } }
diff --git a/quic/core/crypto/aes_128_gcm_12_encrypter_test.cc b/quic/core/crypto/aes_128_gcm_12_encrypter_test.cc index 3241b07..bc3f611 100644 --- a/quic/core/crypto/aes_128_gcm_12_encrypter_test.cc +++ b/quic/core/crypto/aes_128_gcm_12_encrypter_test.cc
@@ -13,6 +13,7 @@ #include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h" #include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" #include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h" +#include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h" namespace { @@ -215,9 +216,9 @@ tag.resize(Aes128Gcm12Encrypter::kAuthTagSize); ASSERT_EQ(ct.length() + tag.length(), encrypted->length()); - test::CompareCharArraysWithHexError("ciphertext", encrypted->data(), - ct.length(), ct.data(), ct.length()); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( + "ciphertext", encrypted->data(), ct.length(), ct.data(), ct.length()); + quiche::test::CompareCharArraysWithHexError( "authentication tag", encrypted->data() + ct.length(), tag.length(), tag.data(), tag.length()); }
diff --git a/quic/core/crypto/aes_128_gcm_decrypter_test.cc b/quic/core/crypto/aes_128_gcm_decrypter_test.cc index 5b9aa5c..a444284 100644 --- a/quic/core/crypto/aes_128_gcm_decrypter_test.cc +++ b/quic/core/crypto/aes_128_gcm_decrypter_test.cc
@@ -12,6 +12,7 @@ #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h" #include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h" #include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h" +#include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h" namespace { @@ -265,8 +266,8 @@ EXPECT_TRUE(has_pt); ASSERT_EQ(pt.length(), decrypted->length()); - test::CompareCharArraysWithHexError("plaintext", decrypted->data(), - pt.length(), pt.data(), pt.length()); + quiche::test::CompareCharArraysWithHexError( + "plaintext", decrypted->data(), pt.length(), pt.data(), pt.length()); } } } @@ -282,9 +283,9 @@ std::string mask = decrypter.GenerateHeaderProtectionMask(&sample_reader); std::string expected_mask = quiche::QuicheTextUtils::HexDecode("b132c37d6164da4ea4dc9b763aceec27"); - test::CompareCharArraysWithHexError("header protection mask", mask.data(), - mask.size(), expected_mask.data(), - expected_mask.size()); + quiche::test::CompareCharArraysWithHexError( + "header protection mask", mask.data(), mask.size(), expected_mask.data(), + expected_mask.size()); } } // namespace test
diff --git a/quic/core/crypto/aes_128_gcm_encrypter_test.cc b/quic/core/crypto/aes_128_gcm_encrypter_test.cc index 1fa8a47..69f8c4d 100644 --- a/quic/core/crypto/aes_128_gcm_encrypter_test.cc +++ b/quic/core/crypto/aes_128_gcm_encrypter_test.cc
@@ -12,6 +12,7 @@ #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h" #include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h" #include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h" +#include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h" namespace { @@ -208,9 +209,9 @@ ASSERT_TRUE(encrypted.get()); ASSERT_EQ(ct.length() + tag.length(), encrypted->length()); - test::CompareCharArraysWithHexError("ciphertext", encrypted->data(), - ct.length(), ct.data(), ct.length()); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( + "ciphertext", encrypted->data(), ct.length(), ct.data(), ct.length()); + quiche::test::CompareCharArraysWithHexError( "authentication tag", encrypted->data() + ct.length(), tag.length(), tag.data(), tag.length()); } @@ -239,8 +240,8 @@ ASSERT_TRUE(encrypter.EncryptPacket(packet_num, aad, pt, out.data(), &out_size, out.size())); EXPECT_EQ(out_size, out.size()); - test::CompareCharArraysWithHexError("ciphertext", out.data(), out.size(), - ct.data(), ct.size()); + quiche::test::CompareCharArraysWithHexError("ciphertext", out.data(), + out.size(), ct.data(), ct.size()); } TEST_F(Aes128GcmEncrypterTest, GetMaxPlaintextSize) { @@ -267,9 +268,9 @@ std::string mask = encrypter.GenerateHeaderProtectionMask(sample); std::string expected_mask = quiche::QuicheTextUtils::HexDecode("b132c37d6164da4ea4dc9b763aceec27"); - test::CompareCharArraysWithHexError("header protection mask", mask.data(), - mask.size(), expected_mask.data(), - expected_mask.size()); + quiche::test::CompareCharArraysWithHexError( + "header protection mask", mask.data(), mask.size(), expected_mask.data(), + expected_mask.size()); } } // namespace test
diff --git a/quic/core/crypto/aes_256_gcm_decrypter_test.cc b/quic/core/crypto/aes_256_gcm_decrypter_test.cc index abd2651..7c69724 100644 --- a/quic/core/crypto/aes_256_gcm_decrypter_test.cc +++ b/quic/core/crypto/aes_256_gcm_decrypter_test.cc
@@ -13,6 +13,7 @@ #include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h" #include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" #include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h" +#include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h" namespace { @@ -270,8 +271,8 @@ EXPECT_TRUE(has_pt); ASSERT_EQ(pt.length(), decrypted->length()); - test::CompareCharArraysWithHexError("plaintext", decrypted->data(), - pt.length(), pt.data(), pt.length()); + quiche::test::CompareCharArraysWithHexError( + "plaintext", decrypted->data(), pt.length(), pt.data(), pt.length()); } } } @@ -287,9 +288,9 @@ std::string mask = decrypter.GenerateHeaderProtectionMask(&sample_reader); std::string expected_mask = quiche::QuicheTextUtils::HexDecode("db9ed4e6ccd033af2eae01407199c56e"); - test::CompareCharArraysWithHexError("header protection mask", mask.data(), - mask.size(), expected_mask.data(), - expected_mask.size()); + quiche::test::CompareCharArraysWithHexError( + "header protection mask", mask.data(), mask.size(), expected_mask.data(), + expected_mask.size()); } } // namespace test
diff --git a/quic/core/crypto/aes_256_gcm_encrypter_test.cc b/quic/core/crypto/aes_256_gcm_encrypter_test.cc index 16c96e2..0899262 100644 --- a/quic/core/crypto/aes_256_gcm_encrypter_test.cc +++ b/quic/core/crypto/aes_256_gcm_encrypter_test.cc
@@ -13,6 +13,7 @@ #include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h" #include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" #include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h" +#include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h" namespace { @@ -216,9 +217,9 @@ ASSERT_TRUE(encrypted.get()); ASSERT_EQ(ct.length() + tag.length(), encrypted->length()); - test::CompareCharArraysWithHexError("ciphertext", encrypted->data(), - ct.length(), ct.data(), ct.length()); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( + "ciphertext", encrypted->data(), ct.length(), ct.data(), ct.length()); + quiche::test::CompareCharArraysWithHexError( "authentication tag", encrypted->data() + ct.length(), tag.length(), tag.data(), tag.length()); } @@ -249,9 +250,9 @@ std::string mask = encrypter.GenerateHeaderProtectionMask(sample); std::string expected_mask = quiche::QuicheTextUtils::HexDecode("db9ed4e6ccd033af2eae01407199c56e"); - test::CompareCharArraysWithHexError("header protection mask", mask.data(), - mask.size(), expected_mask.data(), - expected_mask.size()); + quiche::test::CompareCharArraysWithHexError( + "header protection mask", mask.data(), mask.size(), expected_mask.data(), + expected_mask.size()); } } // namespace test
diff --git a/quic/core/crypto/chacha20_poly1305_decrypter_test.cc b/quic/core/crypto/chacha20_poly1305_decrypter_test.cc index 7be2251..83e52b1 100644 --- a/quic/core/crypto/chacha20_poly1305_decrypter_test.cc +++ b/quic/core/crypto/chacha20_poly1305_decrypter_test.cc
@@ -12,6 +12,7 @@ #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h" #include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" #include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h" +#include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h" namespace { @@ -170,8 +171,8 @@ EXPECT_EQ(12u, ct.size() - decrypted->length()); ASSERT_EQ(pt.length(), decrypted->length()); - test::CompareCharArraysWithHexError("plaintext", decrypted->data(), - pt.length(), pt.data(), pt.length()); + quiche::test::CompareCharArraysWithHexError( + "plaintext", decrypted->data(), pt.length(), pt.data(), pt.length()); } }
diff --git a/quic/core/crypto/chacha20_poly1305_encrypter_test.cc b/quic/core/crypto/chacha20_poly1305_encrypter_test.cc index a15fbc5..47ee3d0 100644 --- a/quic/core/crypto/chacha20_poly1305_encrypter_test.cc +++ b/quic/core/crypto/chacha20_poly1305_encrypter_test.cc
@@ -14,6 +14,7 @@ #include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h" #include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" #include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h" +#include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h" namespace { @@ -136,9 +137,9 @@ EXPECT_EQ(12u, ct.size() - pt.size()); EXPECT_EQ(12u, encrypted->length() - pt.size()); - test::CompareCharArraysWithHexError("ciphertext", encrypted->data(), - encrypted->length(), ct.data(), - ct.length()); + quiche::test::CompareCharArraysWithHexError("ciphertext", encrypted->data(), + encrypted->length(), ct.data(), + ct.length()); } }
diff --git a/quic/core/crypto/chacha20_poly1305_tls_decrypter_test.cc b/quic/core/crypto/chacha20_poly1305_tls_decrypter_test.cc index d4fcd2b..9127cd4 100644 --- a/quic/core/crypto/chacha20_poly1305_tls_decrypter_test.cc +++ b/quic/core/crypto/chacha20_poly1305_tls_decrypter_test.cc
@@ -12,6 +12,7 @@ #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h" #include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" #include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h" +#include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h" namespace { @@ -165,8 +166,8 @@ EXPECT_EQ(16u, ct.size() - decrypted->length()); ASSERT_EQ(pt.length(), decrypted->length()); - test::CompareCharArraysWithHexError("plaintext", decrypted->data(), - pt.length(), pt.data(), pt.length()); + quiche::test::CompareCharArraysWithHexError( + "plaintext", decrypted->data(), pt.length(), pt.data(), pt.length()); } } @@ -180,9 +181,9 @@ ASSERT_TRUE(decrypter.SetHeaderProtectionKey(key)); std::string mask = decrypter.GenerateHeaderProtectionMask(&sample_reader); std::string expected_mask = quiche::QuicheTextUtils::HexDecode("1cc2cd98dc"); - test::CompareCharArraysWithHexError("header protection mask", mask.data(), - mask.size(), expected_mask.data(), - expected_mask.size()); + quiche::test::CompareCharArraysWithHexError( + "header protection mask", mask.data(), mask.size(), expected_mask.data(), + expected_mask.size()); } } // namespace test
diff --git a/quic/core/crypto/chacha20_poly1305_tls_encrypter_test.cc b/quic/core/crypto/chacha20_poly1305_tls_encrypter_test.cc index 628ecc8..dd642a3 100644 --- a/quic/core/crypto/chacha20_poly1305_tls_encrypter_test.cc +++ b/quic/core/crypto/chacha20_poly1305_tls_encrypter_test.cc
@@ -14,6 +14,7 @@ #include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h" #include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" #include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h" +#include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h" namespace { @@ -136,9 +137,9 @@ EXPECT_EQ(16u, ct.size() - pt.size()); EXPECT_EQ(16u, encrypted->length() - pt.size()); - test::CompareCharArraysWithHexError("ciphertext", encrypted->data(), - encrypted->length(), ct.data(), - ct.length()); + quiche::test::CompareCharArraysWithHexError("ciphertext", encrypted->data(), + encrypted->length(), ct.data(), + ct.length()); } } @@ -165,9 +166,9 @@ ASSERT_TRUE(encrypter.SetHeaderProtectionKey(key)); std::string mask = encrypter.GenerateHeaderProtectionMask(sample); std::string expected_mask = quiche::QuicheTextUtils::HexDecode("1cc2cd98dc"); - test::CompareCharArraysWithHexError("header protection mask", mask.data(), - mask.size(), expected_mask.data(), - expected_mask.size()); + quiche::test::CompareCharArraysWithHexError( + "header protection mask", mask.data(), mask.size(), expected_mask.data(), + expected_mask.size()); } } // namespace test
diff --git a/quic/core/crypto/crypto_framer_test.cc b/quic/core/crypto/crypto_framer_test.cc index fed6b53..d598c49 100644 --- a/quic/core/crypto/crypto_framer_test.cc +++ b/quic/core/crypto/crypto_framer_test.cc
@@ -17,6 +17,7 @@ #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h" #include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h" #include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" +#include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h" namespace quic { namespace test { @@ -82,9 +83,9 @@ CryptoFramer framer; std::unique_ptr<QuicData> data = framer.ConstructHandshakeMessage(message); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(packet), - QUICHE_ARRAYSIZE(packet)); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(packet), + QUICHE_ARRAYSIZE(packet)); } TEST(CryptoFramerTest, ConstructHandshakeMessageWithTwoKeys) { @@ -118,9 +119,9 @@ std::unique_ptr<QuicData> data = framer.ConstructHandshakeMessage(message); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(packet), - QUICHE_ARRAYSIZE(packet)); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(packet), + QUICHE_ARRAYSIZE(packet)); } TEST(CryptoFramerTest, ConstructHandshakeMessageZeroLength) { @@ -145,9 +146,9 @@ std::unique_ptr<QuicData> data = framer.ConstructHandshakeMessage(message); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(packet), - QUICHE_ARRAYSIZE(packet)); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(packet), + QUICHE_ARRAYSIZE(packet)); } TEST(CryptoFramerTest, ConstructHandshakeMessageTooManyEntries) { @@ -195,9 +196,9 @@ std::unique_ptr<QuicData> data = framer.ConstructHandshakeMessage(message); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(packet), - QUICHE_ARRAYSIZE(packet)); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(packet), + QUICHE_ARRAYSIZE(packet)); } TEST(CryptoFramerTest, ConstructHandshakeMessageMinimumSizePadLast) { @@ -231,9 +232,9 @@ std::unique_ptr<QuicData> data = framer.ConstructHandshakeMessage(message); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(packet), - QUICHE_ARRAYSIZE(packet)); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(packet), + QUICHE_ARRAYSIZE(packet)); } TEST(CryptoFramerTest, ProcessInput) {
diff --git a/quic/core/crypto/crypto_utils_test.cc b/quic/core/crypto/crypto_utils_test.cc index 247bd5d..edf8051 100644 --- a/quic/core/crypto/crypto_utils_test.cc +++ b/quic/core/crypto/crypto_utils_test.cc
@@ -11,6 +11,7 @@ #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h" #include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h" #include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h" +#include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h" namespace quic { namespace test { @@ -70,9 +71,9 @@ EXPECT_EQ(expect_ok, ok); if (expect_ok) { EXPECT_EQ(result_len, result.length()); - test::CompareCharArraysWithHexError("HKDF output", result.data(), - result.length(), expected.data(), - expected.length()); + quiche::test::CompareCharArraysWithHexError( + "HKDF output", result.data(), result.length(), expected.data(), + expected.length()); } } }
diff --git a/quic/core/crypto/null_encrypter_test.cc b/quic/core/crypto/null_encrypter_test.cc index 83b61ef..c9b00d4 100644 --- a/quic/core/crypto/null_encrypter_test.cc +++ b/quic/core/crypto/null_encrypter_test.cc
@@ -6,6 +6,7 @@ #include "net/third_party/quiche/src/quic/platform/api/quic_test.h" #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h" #include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h" +#include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h" namespace quic { namespace test { @@ -42,7 +43,7 @@ NullEncrypter encrypter(Perspective::IS_CLIENT); ASSERT_TRUE(encrypter.EncryptPacket(0, "hello world!", "goodbye!", encrypted, &encrypted_len, 256)); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "encrypted data", encrypted, encrypted_len, reinterpret_cast<const char*>(expected), QUICHE_ARRAYSIZE(expected)); } @@ -77,7 +78,7 @@ NullEncrypter encrypter(Perspective::IS_SERVER); ASSERT_TRUE(encrypter.EncryptPacket(0, "hello world!", "goodbye!", encrypted, &encrypted_len, 256)); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "encrypted data", encrypted, encrypted_len, reinterpret_cast<const char*>(expected), QUICHE_ARRAYSIZE(expected)); }
diff --git a/quic/core/http/http_encoder_test.cc b/quic/core/http/http_encoder_test.cc index 062df95..5c99b7d 100644 --- a/quic/core/http/http_encoder_test.cc +++ b/quic/core/http/http_encoder_test.cc
@@ -7,6 +7,7 @@ #include "net/third_party/quiche/src/quic/platform/api/quic_test.h" #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h" #include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h" +#include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h" namespace quic { namespace test { @@ -20,8 +21,8 @@ // length 0x05}; EXPECT_EQ(QUICHE_ARRAYSIZE(output), length); - CompareCharArraysWithHexError("DATA", buffer.get(), length, output, - QUICHE_ARRAYSIZE(output)); + quiche::test::CompareCharArraysWithHexError("DATA", buffer.get(), length, + output, QUICHE_ARRAYSIZE(output)); } TEST(HttpEncoderTest, SerializeHeadersFrameHeader) { @@ -33,8 +34,8 @@ // length 0x07}; EXPECT_EQ(QUICHE_ARRAYSIZE(output), length); - CompareCharArraysWithHexError("HEADERS", buffer.get(), length, output, - QUICHE_ARRAYSIZE(output)); + quiche::test::CompareCharArraysWithHexError("HEADERS", buffer.get(), length, + output, QUICHE_ARRAYSIZE(output)); } TEST(HttpEncoderTest, SerializePriorityFrame) { @@ -61,8 +62,8 @@ std::unique_ptr<char[]> buffer; uint64_t length = HttpEncoder::SerializePriorityFrame(priority, &buffer); EXPECT_EQ(QUICHE_ARRAYSIZE(output), length); - CompareCharArraysWithHexError("PRIORITY", buffer.get(), length, output, - QUICHE_ARRAYSIZE(output)); + quiche::test::CompareCharArraysWithHexError("PRIORITY", buffer.get(), length, + output, QUICHE_ARRAYSIZE(output)); PriorityFrame priority2; priority2.prioritized_type = ROOT_OF_TREE; @@ -82,8 +83,8 @@ 0xff}; length = HttpEncoder::SerializePriorityFrame(priority2, &buffer); EXPECT_EQ(QUICHE_ARRAYSIZE(output2), length); - CompareCharArraysWithHexError("PRIORITY", buffer.get(), length, output2, - QUICHE_ARRAYSIZE(output2)); + quiche::test::CompareCharArraysWithHexError( + "PRIORITY", buffer.get(), length, output2, QUICHE_ARRAYSIZE(output2)); PriorityFrame priority3; priority3.prioritized_type = ROOT_OF_TREE; @@ -100,8 +101,8 @@ 0xff}; length = HttpEncoder::SerializePriorityFrame(priority3, &buffer); EXPECT_EQ(QUICHE_ARRAYSIZE(output3), length); - CompareCharArraysWithHexError("PRIORITY", buffer.get(), length, output3, - QUICHE_ARRAYSIZE(output3)); + quiche::test::CompareCharArraysWithHexError( + "PRIORITY", buffer.get(), length, output3, QUICHE_ARRAYSIZE(output3)); } TEST(HttpEncoderTest, SerializeCancelPushFrame) { @@ -116,8 +117,8 @@ std::unique_ptr<char[]> buffer; uint64_t length = HttpEncoder::SerializeCancelPushFrame(cancel_push, &buffer); EXPECT_EQ(QUICHE_ARRAYSIZE(output), length); - CompareCharArraysWithHexError("CANCEL_PUSH", buffer.get(), length, output, - QUICHE_ARRAYSIZE(output)); + quiche::test::CompareCharArraysWithHexError( + "CANCEL_PUSH", buffer.get(), length, output, QUICHE_ARRAYSIZE(output)); } TEST(HttpEncoderTest, SerializeSettingsFrame) { @@ -144,8 +145,8 @@ std::unique_ptr<char[]> buffer; uint64_t length = HttpEncoder::SerializeSettingsFrame(settings, &buffer); EXPECT_EQ(QUICHE_ARRAYSIZE(output), length); - CompareCharArraysWithHexError("SETTINGS", buffer.get(), length, output, - QUICHE_ARRAYSIZE(output)); + quiche::test::CompareCharArraysWithHexError("SETTINGS", buffer.get(), length, + output, QUICHE_ARRAYSIZE(output)); } TEST(HttpEncoderTest, SerializePushPromiseFrameWithOnlyPushId) { @@ -162,8 +163,8 @@ uint64_t length = HttpEncoder::SerializePushPromiseFrameWithOnlyPushId( push_promise, &buffer); EXPECT_EQ(QUICHE_ARRAYSIZE(output), length); - CompareCharArraysWithHexError("PUSH_PROMISE", buffer.get(), length, output, - QUICHE_ARRAYSIZE(output)); + quiche::test::CompareCharArraysWithHexError( + "PUSH_PROMISE", buffer.get(), length, output, QUICHE_ARRAYSIZE(output)); } TEST(HttpEncoderTest, SerializeGoAwayFrame) { @@ -178,8 +179,8 @@ std::unique_ptr<char[]> buffer; uint64_t length = HttpEncoder::SerializeGoAwayFrame(goaway, &buffer); EXPECT_EQ(QUICHE_ARRAYSIZE(output), length); - CompareCharArraysWithHexError("GOAWAY", buffer.get(), length, output, - QUICHE_ARRAYSIZE(output)); + quiche::test::CompareCharArraysWithHexError("GOAWAY", buffer.get(), length, + output, QUICHE_ARRAYSIZE(output)); } TEST(HttpEncoderTest, SerializeMaxPushIdFrame) { @@ -194,8 +195,8 @@ std::unique_ptr<char[]> buffer; uint64_t length = HttpEncoder::SerializeMaxPushIdFrame(max_push_id, &buffer); EXPECT_EQ(QUICHE_ARRAYSIZE(output), length); - CompareCharArraysWithHexError("MAX_PUSH_ID", buffer.get(), length, output, - QUICHE_ARRAYSIZE(output)); + quiche::test::CompareCharArraysWithHexError( + "MAX_PUSH_ID", buffer.get(), length, output, QUICHE_ARRAYSIZE(output)); } TEST(HttpEncoderTest, SerializeDuplicatePushFrame) { @@ -211,8 +212,8 @@ uint64_t length = HttpEncoder::SerializeDuplicatePushFrame(duplicate_push, &buffer); EXPECT_EQ(QUICHE_ARRAYSIZE(output), length); - CompareCharArraysWithHexError("DUPLICATE_PUSH", buffer.get(), length, output, - QUICHE_ARRAYSIZE(output)); + quiche::test::CompareCharArraysWithHexError( + "DUPLICATE_PUSH", buffer.get(), length, output, QUICHE_ARRAYSIZE(output)); } } // namespace test
diff --git a/quic/core/quic_coalesced_packet_test.cc b/quic/core/quic_coalesced_packet_test.cc index 8213480..6e7c32a 100644 --- a/quic/core/quic_coalesced_packet_test.cc +++ b/quic/core/quic_coalesced_packet_test.cc
@@ -7,6 +7,7 @@ #include "net/third_party/quiche/src/quic/platform/api/quic_expect_bug.h" #include "net/third_party/quiche/src/quic/platform/api/quic_test.h" #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h" +#include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h" namespace quic { namespace test { @@ -105,8 +106,8 @@ char expected[1000]; memset(expected, 'a', 500); memset(expected + 500, 'b', 500); - test::CompareCharArraysWithHexError("copied buffers", copy_buffer, - length_copied, expected, 1000); + quiche::test::CompareCharArraysWithHexError("copied buffers", copy_buffer, + length_copied, expected, 1000); } } // namespace
diff --git a/quic/core/quic_crypto_client_stream_test.cc b/quic/core/quic_crypto_client_stream_test.cc index 576eb57..a2e40c4 100644 --- a/quic/core/quic_crypto_client_stream_test.cc +++ b/quic/core/quic_crypto_client_stream_test.cc
@@ -23,6 +23,7 @@ #include "net/third_party/quiche/src/quic/test_tools/simple_quic_framer.h" #include "net/third_party/quiche/src/quic/test_tools/simple_session_cache.h" #include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h" +#include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h" using testing::_; @@ -296,7 +297,7 @@ EXPECT_EQ("xstk", state->source_address_token()); const std::string& cached_scfg = state->server_config(); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "scfg", cached_scfg.data(), cached_scfg.length(), reinterpret_cast<char*>(scfg), QUICHE_ARRAYSIZE(scfg));
diff --git a/quic/core/quic_data_writer_test.cc b/quic/core/quic_data_writer_test.cc index 3c38673..e655905 100644 --- a/quic/core/quic_data_writer_test.cc +++ b/quic/core/quic_data_writer_test.cc
@@ -18,6 +18,7 @@ #include "net/third_party/quiche/src/common/platform/api/quiche_endian.h" #include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h" #include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" +#include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h" namespace quic { namespace test { @@ -272,9 +273,9 @@ char buffer[255]; QuicDataWriter writer(connection_id.length(), buffer, GetParam().endianness); EXPECT_TRUE(writer.WriteConnectionId(connection_id)); - test::CompareCharArraysWithHexError("connection_id", buffer, - connection_id.length(), big_endian, - connection_id.length()); + quiche::test::CompareCharArraysWithHexError( + "connection_id", buffer, connection_id.length(), big_endian, + connection_id.length()); QuicConnectionId read_connection_id; QuicDataReader reader(buffer, connection_id.length(), GetParam().endianness); @@ -294,7 +295,7 @@ char buffer[kConnectionIdLengthSize + 255] = {}; QuicDataWriter writer(QUICHE_ARRAYSIZE(buffer), buffer); EXPECT_TRUE(writer.WriteLengthPrefixedConnectionId(connection_id)); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "WriteLengthPrefixedConnectionId", buffer, writer.length(), length_prefixed_connection_id, QUICHE_ARRAYSIZE(length_prefixed_connection_id)); @@ -304,7 +305,7 @@ QuicDataWriter writer2(QUICHE_ARRAYSIZE(buffer), buffer); EXPECT_TRUE(writer2.WriteUInt8(connection_id.length())); EXPECT_TRUE(writer2.WriteConnectionId(connection_id)); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "Write length then ConnectionId", buffer, writer2.length(), length_prefixed_connection_id, QUICHE_ARRAYSIZE(length_prefixed_connection_id)); @@ -372,8 +373,8 @@ char buffer[kBufferLength]; QuicDataWriter writer(kBufferLength, buffer, GetParam().endianness); writer.WriteTag(kCHLO); - test::CompareCharArraysWithHexError("CHLO", buffer, kBufferLength, CHLO, - kBufferLength); + quiche::test::CompareCharArraysWithHexError("CHLO", buffer, kBufferLength, + CHLO, kBufferLength); QuicTag read_chlo; QuicDataReader reader(buffer, kBufferLength, GetParam().endianness); @@ -389,7 +390,7 @@ uint16_t in_memory16 = 0x1122; QuicDataWriter writer(2, buffer16, GetParam().endianness); writer.WriteUInt16(in_memory16); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "uint16_t", buffer16, 2, GetParam().endianness == quiche::NETWORK_BYTE_ORDER ? big_endian16 : little_endian16, @@ -405,7 +406,7 @@ uint64_t in_memory16 = 0x0000000000001122; QuicDataWriter writer(2, buffer16, GetParam().endianness); writer.WriteBytesToUInt64(2, in_memory16); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "uint16_t", buffer16, 2, GetParam().endianness == quiche::NETWORK_BYTE_ORDER ? big_endian16 : little_endian16, @@ -425,7 +426,7 @@ uint64_t in_memory24 = 0x0000000000112233; QuicDataWriter writer(3, buffer24, GetParam().endianness); writer.WriteBytesToUInt64(3, in_memory24); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "uint24", buffer24, 3, GetParam().endianness == quiche::NETWORK_BYTE_ORDER ? big_endian24 : little_endian24, @@ -445,7 +446,7 @@ uint32_t in_memory32 = 0x11223344; QuicDataWriter writer(4, buffer32, GetParam().endianness); writer.WriteUInt32(in_memory32); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "uint32_t", buffer32, 4, GetParam().endianness == quiche::NETWORK_BYTE_ORDER ? big_endian32 : little_endian32, @@ -461,7 +462,7 @@ uint64_t in_memory32 = 0x11223344; QuicDataWriter writer(4, buffer32, GetParam().endianness); writer.WriteBytesToUInt64(4, in_memory32); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "uint32_t", buffer32, 4, GetParam().endianness == quiche::NETWORK_BYTE_ORDER ? big_endian32 : little_endian32, @@ -481,7 +482,7 @@ char buffer40[5]; QuicDataWriter writer(5, buffer40, GetParam().endianness); writer.WriteBytesToUInt64(5, in_memory40); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "uint40", buffer40, 5, GetParam().endianness == quiche::NETWORK_BYTE_ORDER ? big_endian40 : little_endian40, @@ -500,7 +501,7 @@ char buffer48[6]; QuicDataWriter writer(6, buffer48, GetParam().endianness); writer.WriteBytesToUInt64(6, in_memory48); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "uint48", buffer48, 6, GetParam().endianness == quiche::NETWORK_BYTE_ORDER ? big_endian48 : little_endian48, @@ -519,7 +520,7 @@ char buffer56[7]; QuicDataWriter writer(7, buffer56, GetParam().endianness); writer.WriteBytesToUInt64(7, in_memory56); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "uint56", buffer56, 7, GetParam().endianness == quiche::NETWORK_BYTE_ORDER ? big_endian56 : little_endian56, @@ -540,7 +541,7 @@ char buffer64[8]; QuicDataWriter writer(8, buffer64, GetParam().endianness); writer.WriteBytesToUInt64(8, in_memory64); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "uint64_t", buffer64, 8, GetParam().endianness == quiche::NETWORK_BYTE_ORDER ? AsChars(big_endian64) @@ -554,7 +555,7 @@ QuicDataWriter writer2(8, buffer64, GetParam().endianness); writer2.WriteUInt64(in_memory64); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "uint64_t", buffer64, 8, GetParam().endianness == quiche::NETWORK_BYTE_ORDER ? AsChars(big_endian64) @@ -1134,7 +1135,8 @@ EXPECT_FALSE(writer.WriteRandomBytes(&random, 30)); EXPECT_TRUE(writer.WriteRandomBytes(&random, 20)); - test::CompareCharArraysWithHexError("random", buffer, 20, expected, 20); + quiche::test::CompareCharArraysWithHexError("random", buffer, 20, expected, + 20); } TEST_P(QuicDataWriterTest, PeekVarInt62Length) { @@ -1261,30 +1263,30 @@ QuicDataReader reader(buffer, sizeof(buffer)); char first_read_buffer[4] = {}; EXPECT_TRUE(reader.ReadBytes(first_read_buffer, sizeof(first_read_buffer))); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "first read", first_read_buffer, sizeof(first_read_buffer), expected_first_read, sizeof(expected_first_read)); quiche::QuicheStringPiece peeked_remaining_payload = reader.PeekRemainingPayload(); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "peeked_remaining_payload", peeked_remaining_payload.data(), peeked_remaining_payload.length(), expected_remaining, sizeof(expected_remaining)); quiche::QuicheStringPiece full_payload = reader.FullPayload(); - test::CompareCharArraysWithHexError("full_payload", full_payload.data(), - full_payload.length(), buffer, - sizeof(buffer)); + quiche::test::CompareCharArraysWithHexError( + "full_payload", full_payload.data(), full_payload.length(), buffer, + sizeof(buffer)); quiche::QuicheStringPiece read_remaining_payload = reader.ReadRemainingPayload(); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "read_remaining_payload", read_remaining_payload.data(), read_remaining_payload.length(), expected_remaining, sizeof(expected_remaining)); EXPECT_TRUE(reader.IsDoneReading()); quiche::QuicheStringPiece full_payload2 = reader.FullPayload(); - test::CompareCharArraysWithHexError("full_payload2", full_payload2.data(), - full_payload2.length(), buffer, - sizeof(buffer)); + quiche::test::CompareCharArraysWithHexError( + "full_payload2", full_payload2.data(), full_payload2.length(), buffer, + sizeof(buffer)); } } // namespace
diff --git a/quic/core/quic_dispatcher_test.cc b/quic/core/quic_dispatcher_test.cc index dc0b4a7..83bb756 100644 --- a/quic/core/quic_dispatcher_test.cc +++ b/quic/core/quic_dispatcher_test.cc
@@ -35,6 +35,7 @@ #include "net/third_party/quiche/src/quic/tools/quic_simple_crypto_server_stream_helper.h" #include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h" #include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h" +#include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h" using testing::_; using testing::ByMove; @@ -1122,7 +1123,7 @@ // The source connection ID of the probe response should match the // destination connection ID of the probe request. - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "parsed probe", source_connection_id_bytes, source_connection_id_length, destination_connection_id_bytes, sizeof(destination_connection_id_bytes)); } @@ -1166,7 +1167,7 @@ // The source connection ID of the probe response should match the // destination connection ID of the probe request. - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "parsed probe", source_connection_id_bytes, source_connection_id_length, destination_connection_id_bytes, sizeof(destination_connection_id_bytes)); } @@ -1211,7 +1212,7 @@ 0x75, 0x76, 0x77, 0x78}; ASSERT_GE((*(saving_writer->packets()))[0]->length(), 1u + sizeof(connection_id_bytes)); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "response connection ID", &(*(saving_writer->packets()))[0]->data()[1], sizeof(connection_id_bytes), connection_id_bytes, sizeof(connection_id_bytes)); @@ -1259,7 +1260,7 @@ 0x75, 0x76, 0x77, 0x78}; ASSERT_GE((*(saving_writer->packets()))[0]->length(), 1u + sizeof(connection_id_bytes)); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "response connection ID", &(*(saving_writer->packets()))[0]->data()[1], sizeof(connection_id_bytes), connection_id_bytes, sizeof(connection_id_bytes));
diff --git a/quic/core/quic_framer_test.cc b/quic/core/quic_framer_test.cc index 2daac1e..17779bd 100644 --- a/quic/core/quic_framer_test.cc +++ b/quic/core/quic_framer_test.cc
@@ -33,6 +33,7 @@ #include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h" #include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" #include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h" +#include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h" using testing::_; using testing::Return; @@ -5815,7 +5816,7 @@ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "constructed packet", data->data(), data->length(), AsChars(p), framer_.transport_version() > QUIC_VERSION_43 ? QUICHE_ARRAYSIZE(packet46) : QUICHE_ARRAYSIZE(packet)); @@ -5931,8 +5932,8 @@ } QuicEncryptedPacket encrypted(AsChars(p), p_size, false); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(p), p_size); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(p), p_size); } TEST_P(QuicFramerTest, Build4ByteSequenceNumberPaddingFramePacket) { @@ -6004,7 +6005,7 @@ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "constructed packet", data->data(), data->length(), AsChars(p), framer_.transport_version() > QUIC_VERSION_43 ? QUICHE_ARRAYSIZE(packet46) : QUICHE_ARRAYSIZE(packet)); @@ -6079,7 +6080,7 @@ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "constructed packet", data->data(), data->length(), AsChars(p), framer_.transport_version() > QUIC_VERSION_43 ? QUICHE_ARRAYSIZE(packet46) : QUICHE_ARRAYSIZE(packet)); @@ -6154,7 +6155,7 @@ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "constructed packet", data->data(), data->length(), AsChars(p), framer_.transport_version() > QUIC_VERSION_43 ? QUICHE_ARRAYSIZE(packet46) : QUICHE_ARRAYSIZE(packet)); @@ -6253,8 +6254,8 @@ p = packet46; p_size = QUICHE_ARRAYSIZE(packet46); } - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(p), p_size); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(p), p_size); } TEST_P(QuicFramerTest, BuildStreamFramePacketWithVersionFlag) { @@ -6386,8 +6387,8 @@ p = packet46; p_size = QUICHE_ARRAYSIZE(packet46); } - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(p), p_size); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(p), p_size); } TEST_P(QuicFramerTest, BuildCryptoFramePacket) { @@ -6465,9 +6466,9 @@ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(packet), - packet_size); + quiche::test::CompareCharArraysWithHexError("constructed packet", + data->data(), data->length(), + AsChars(packet), packet_size); } TEST_P(QuicFramerTest, CryptoFrame) { @@ -6612,8 +6613,8 @@ framer_.transport_version() > QUIC_VERSION_43, framer_.version().HasLengthPrefixedConnectionIds(), SupportedVersions(GetParam()))); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(p), p_size); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(p), p_size); } TEST_P(QuicFramerTest, BuildVersionNegotiationPacketWithClientConnectionId) { @@ -6647,9 +6648,9 @@ QuicFramer::BuildVersionNegotiationPacket( server_connection_id, client_connection_id, true, true, SupportedVersions(GetParam()))); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(packet), - QUICHE_ARRAYSIZE(packet)); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(packet), + QUICHE_ARRAYSIZE(packet)); } TEST_P(QuicFramerTest, BuildAckFramePacketOneAckBlock) { @@ -6741,8 +6742,8 @@ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(p), p_size); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(p), p_size); } TEST_P(QuicFramerTest, BuildAckFramePacketOneAckBlockMaxLength) { @@ -6834,8 +6835,8 @@ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(p), p_size); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(p), p_size); } TEST_P(QuicFramerTest, BuildAckFramePacketMultipleAckBlocks) { @@ -6983,8 +6984,8 @@ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(p), p_size); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(p), p_size); } TEST_P(QuicFramerTest, BuildAckFramePacketMaxAckBlocks) { @@ -7292,8 +7293,8 @@ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(p), p_size); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(p), p_size); } TEST_P(QuicFramerTest, BuildNewStopWaitingPacket) { @@ -7332,9 +7333,9 @@ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(packet), - QUICHE_ARRAYSIZE(packet)); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(packet), + QUICHE_ARRAYSIZE(packet)); } TEST_P(QuicFramerTest, BuildRstFramePacketQuic) { @@ -7428,8 +7429,8 @@ } QuicEncryptedPacket encrypted(AsChars(p), p_size, false); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(p), p_size); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(p), p_size); } TEST_P(QuicFramerTest, BuildCloseFramePacket) { @@ -7529,8 +7530,8 @@ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(p), p_size); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(p), p_size); } TEST_P(QuicFramerTest, BuildCloseFramePacketExtendedInfo) { @@ -7634,8 +7635,8 @@ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(p), p_size); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(p), p_size); } TEST_P(QuicFramerTest, BuildTruncatedCloseFramePacket) { @@ -7819,8 +7820,8 @@ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(p), p_size); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(p), p_size); } TEST_P(QuicFramerTest, BuildApplicationCloseFramePacket) { @@ -7870,9 +7871,9 @@ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(packet99), - QUICHE_ARRAYSIZE(packet99)); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(packet99), + QUICHE_ARRAYSIZE(packet99)); } TEST_P(QuicFramerTest, BuildTruncatedApplicationCloseFramePacket) { @@ -7952,9 +7953,9 @@ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(packet99), - QUICHE_ARRAYSIZE(packet99)); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(packet99), + QUICHE_ARRAYSIZE(packet99)); } TEST_P(QuicFramerTest, BuildGoAwayPacket) { @@ -8035,8 +8036,8 @@ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(p), p_size); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(p), p_size); } TEST_P(QuicFramerTest, BuildTruncatedGoAwayPacket) { @@ -8172,8 +8173,8 @@ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(p), p_size); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(p), p_size); } TEST_P(QuicFramerTest, BuildWindowUpdatePacket) { @@ -8256,8 +8257,8 @@ p_size = QUICHE_ARRAYSIZE(packet46); } - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(p), p_size); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(p), p_size); } TEST_P(QuicFramerTest, BuildMaxStreamDataPacket) { @@ -8300,9 +8301,9 @@ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(packet99), - QUICHE_ARRAYSIZE(packet99)); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(packet99), + QUICHE_ARRAYSIZE(packet99)); } TEST_P(QuicFramerTest, BuildMaxDataPacket) { @@ -8344,9 +8345,9 @@ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(packet99), - QUICHE_ARRAYSIZE(packet99)); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(packet99), + QUICHE_ARRAYSIZE(packet99)); } TEST_P(QuicFramerTest, BuildBlockedPacket) { @@ -8428,8 +8429,8 @@ p_size = QUICHE_ARRAYSIZE(packet46); } - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(p), p_size); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(p), p_size); } TEST_P(QuicFramerTest, BuildPingPacket) { @@ -8490,7 +8491,7 @@ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "constructed packet", data->data(), data->length(), AsChars(p), framer_.transport_version() > QUIC_VERSION_43 ? QUICHE_ARRAYSIZE(packet46) : QUICHE_ARRAYSIZE(packet)); @@ -8562,9 +8563,9 @@ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(p), - QUICHE_ARRAYSIZE(packet46)); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(p), + QUICHE_ARRAYSIZE(packet46)); } @@ -8627,7 +8628,7 @@ p = packet46; } - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "constructed packet", data->data(), data->length(), AsChars(p), framer_.transport_version() > QUIC_VERSION_43 ? QUICHE_ARRAYSIZE(packet46) : QUICHE_ARRAYSIZE(packet)); @@ -8665,9 +8666,9 @@ std::unique_ptr<QuicEncryptedPacket> data( framer_.BuildPublicResetPacket(reset_packet)); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(packet), - QUICHE_ARRAYSIZE(packet)); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(packet), + QUICHE_ARRAYSIZE(packet)); } TEST_P(QuicFramerTest, BuildPublicResetPacketWithClientAddress) { @@ -8714,9 +8715,9 @@ framer_.BuildPublicResetPacket(reset_packet)); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(packet), - QUICHE_ARRAYSIZE(packet)); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(packet), + QUICHE_ARRAYSIZE(packet)); } TEST_P(QuicFramerTest, BuildPublicResetPacketWithEndpointId) { @@ -8788,11 +8789,11 @@ // Variant 1 ends with char 'd'. Variant 1 ends with char 0xAB. if ('d' == data->data()[data->length() - 1]) { - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "constructed packet", data->data(), data->length(), AsChars(packet_variant1), QUICHE_ARRAYSIZE(packet_variant1)); } else { - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "constructed packet", data->data(), data->length(), AsChars(packet_variant2), QUICHE_ARRAYSIZE(packet_variant2)); } @@ -8816,13 +8817,13 @@ kTestStatelessResetToken)); ASSERT_TRUE(data != nullptr); // Skip packet number byte which is random in stateless reset packet. - test::CompareCharArraysWithHexError("constructed packet", data->data(), 1, - AsChars(packet), 1); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), 1, AsChars(packet), 1); const size_t random_bytes_length = data->length() - kPacketHeaderTypeSize - sizeof(kTestStatelessResetToken); EXPECT_EQ(kMinRandomBytesLengthInStatelessReset, random_bytes_length); // Verify stateless reset token is correct. - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "constructed packet", data->data() + data->length() - sizeof(kTestStatelessResetToken), sizeof(kTestStatelessResetToken), @@ -9436,9 +9437,9 @@ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(packet99), - QUICHE_ARRAYSIZE(packet99)); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(packet99), + QUICHE_ARRAYSIZE(packet99)); } TEST_P(QuicFramerTest, IetfStreamBlockedFrame) { @@ -9524,9 +9525,9 @@ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(packet99), - QUICHE_ARRAYSIZE(packet99)); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(packet99), + QUICHE_ARRAYSIZE(packet99)); } TEST_P(QuicFramerTest, BiDiMaxStreamsFrame) { @@ -10173,9 +10174,9 @@ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(packet99), - QUICHE_ARRAYSIZE(packet99)); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(packet99), + QUICHE_ARRAYSIZE(packet99)); } TEST_P(QuicFramerTest, BuildUniStreamsBlockedPacket) { @@ -10215,9 +10216,9 @@ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(packet99), - QUICHE_ARRAYSIZE(packet99)); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(packet99), + QUICHE_ARRAYSIZE(packet99)); } TEST_P(QuicFramerTest, BuildBiDiMaxStreamsPacket) { @@ -10257,9 +10258,9 @@ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(packet99), - QUICHE_ARRAYSIZE(packet99)); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(packet99), + QUICHE_ARRAYSIZE(packet99)); } TEST_P(QuicFramerTest, BuildUniDiMaxStreamsPacket) { @@ -10302,9 +10303,9 @@ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(packet99), - QUICHE_ARRAYSIZE(packet99)); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(packet99), + QUICHE_ARRAYSIZE(packet99)); } TEST_P(QuicFramerTest, NewConnectionIdFrame) { @@ -10576,9 +10577,9 @@ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(packet99), - QUICHE_ARRAYSIZE(packet99)); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(packet99), + QUICHE_ARRAYSIZE(packet99)); } TEST_P(QuicFramerTest, NewTokenFrame) { @@ -10670,9 +10671,9 @@ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(packet), - QUICHE_ARRAYSIZE(packet)); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(packet), + QUICHE_ARRAYSIZE(packet)); } TEST_P(QuicFramerTest, IetfStopSendingFrame) { @@ -10758,9 +10759,9 @@ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(packet99), - QUICHE_ARRAYSIZE(packet99)); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(packet99), + QUICHE_ARRAYSIZE(packet99)); } TEST_P(QuicFramerTest, IetfPathChallengeFrame) { @@ -10841,9 +10842,9 @@ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(packet99), - QUICHE_ARRAYSIZE(packet99)); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(packet99), + QUICHE_ARRAYSIZE(packet99)); } TEST_P(QuicFramerTest, IetfPathResponseFrame) { @@ -10924,9 +10925,9 @@ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(packet99), - QUICHE_ARRAYSIZE(packet99)); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(packet99), + QUICHE_ARRAYSIZE(packet99)); } TEST_P(QuicFramerTest, GetRetransmittableControlFrameSize) { @@ -11729,9 +11730,9 @@ std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames)); ASSERT_TRUE(data != nullptr); - test::CompareCharArraysWithHexError("constructed packet", data->data(), - data->length(), AsChars(packet99), - QUICHE_ARRAYSIZE(packet99)); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data->data(), data->length(), AsChars(packet99), + QUICHE_ARRAYSIZE(packet99)); } TEST_P(QuicFramerTest, AckFrameWithInvalidLargestObserved) { @@ -12259,7 +12260,7 @@ ASSERT_EQ(1u, visitor_.undecryptable_packets_.size()); ASSERT_EQ(1u, visitor_.undecryptable_decryption_levels_.size()); ASSERT_EQ(1u, visitor_.undecryptable_has_decryption_keys_.size()); - CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "undecryptable packet", visitor_.undecryptable_packets_[0]->data(), visitor_.undecryptable_packets_[0]->length(), AsChars(p), p_length); if (framer_.version().KnowsWhichDecrypterToUse()) { @@ -12361,7 +12362,7 @@ ASSERT_EQ(1u, visitor_.undecryptable_packets_.size()); ASSERT_EQ(1u, visitor_.undecryptable_decryption_levels_.size()); ASSERT_EQ(1u, visitor_.undecryptable_has_decryption_keys_.size()); - CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "undecryptable packet", visitor_.undecryptable_packets_[0]->data(), visitor_.undecryptable_packets_[0]->length(), AsChars(p), p_length); if (framer_.version().KnowsWhichDecrypterToUse()) { @@ -12527,10 +12528,10 @@ ASSERT_EQ(1u, visitor_.undecryptable_has_decryption_keys_.size()); // Make sure we only receive the first undecryptable packet and not the // full packet including the second coalesced packet. - CompareCharArraysWithHexError("undecryptable packet", - visitor_.undecryptable_packets_[0]->data(), - visitor_.undecryptable_packets_[0]->length(), - AsChars(p), length_of_first_coalesced_packet); + quiche::test::CompareCharArraysWithHexError( + "undecryptable packet", visitor_.undecryptable_packets_[0]->data(), + visitor_.undecryptable_packets_[0]->length(), AsChars(p), + length_of_first_coalesced_packet); EXPECT_EQ(ENCRYPTION_HANDSHAKE, visitor_.undecryptable_decryption_levels_[0]); EXPECT_TRUE(visitor_.undecryptable_has_decryption_keys_[0]); @@ -13254,9 +13255,9 @@ EXPECT_TRUE(QuicFramer::WriteClientVersionNegotiationProbePacket( packet, sizeof(packet), destination_connection_id_bytes, sizeof(destination_connection_id_bytes))); - test::CompareCharArraysWithHexError("constructed packet", packet, - sizeof(packet), expected_packet, - sizeof(expected_packet)); + quiche::test::CompareCharArraysWithHexError("constructed packet", packet, + sizeof(packet), expected_packet, + sizeof(expected_packet)); QuicEncryptedPacket encrypted(reinterpret_cast<const char*>(packet), sizeof(packet), false); // Make sure we fail to parse this packet for the version under test. @@ -13354,9 +13355,9 @@ EXPECT_TRUE(QuicFramer::WriteClientVersionNegotiationProbePacket( packet, sizeof(packet), destination_connection_id_bytes, sizeof(destination_connection_id_bytes))); - test::CompareCharArraysWithHexError("constructed packet", packet, - sizeof(packet), expected_packet, - sizeof(expected_packet)); + quiche::test::CompareCharArraysWithHexError("constructed packet", packet, + sizeof(packet), expected_packet, + sizeof(expected_packet)); QuicEncryptedPacket encrypted(reinterpret_cast<const char*>(packet), sizeof(packet), false); if (!framer_.version().HasLengthPrefixedConnectionIds()) { @@ -13555,7 +13556,7 @@ reinterpret_cast<char*>(parsed_probe_payload_bytes), &parsed_probe_payload_length, &parse_detailed_error)); EXPECT_EQ("", parse_detailed_error); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "parsed probe", parsed_probe_payload_bytes, parsed_probe_payload_length, probe_payload_bytes, sizeof(probe_payload_bytes)); } @@ -13586,7 +13587,7 @@ reinterpret_cast<char*>(parsed_probe_payload_bytes), &parsed_probe_payload_length, &parse_detailed_error)); EXPECT_EQ("", parse_detailed_error); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "parsed probe", parsed_probe_payload_bytes, parsed_probe_payload_length, probe_payload_bytes, sizeof(probe_payload_bytes)); }
diff --git a/quic/core/quic_packet_creator_test.cc b/quic/core/quic_packet_creator_test.cc index cbf18a4..0f3a778 100644 --- a/quic/core/quic_packet_creator_test.cc +++ b/quic/core/quic_packet_creator_test.cc
@@ -33,6 +33,7 @@ #include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h" #include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h" #include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" +#include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h" using testing::_; using testing::DoAll; @@ -656,7 +657,7 @@ QuicPacket data(creator_.transport_version(), buffer.release(), length, true, header); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "constructed packet", data.data(), data.length(), reinterpret_cast<char*>(packet), QUICHE_ARRAYSIZE(packet)); } @@ -734,9 +735,9 @@ QuicPacket data(creator_.transport_version(), buffer.release(), length, true, header); - test::CompareCharArraysWithHexError("constructed packet", data.data(), - data.length(), reinterpret_cast<char*>(p), - packet_size); + quiche::test::CompareCharArraysWithHexError( + "constructed packet", data.data(), data.length(), + reinterpret_cast<char*>(p), packet_size); } // Several tests that the path response connectivity probing packet is @@ -783,7 +784,7 @@ QuicPacket data(creator_.transport_version(), buffer.release(), length, true, header); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "constructed packet", data.data(), data.length(), reinterpret_cast<char*>(packet), QUICHE_ARRAYSIZE(packet)); } @@ -830,7 +831,7 @@ QuicPacket data(creator_.transport_version(), buffer.release(), length, true, header); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "constructed packet", data.data(), data.length(), reinterpret_cast<char*>(packet), QUICHE_ARRAYSIZE(packet)); } @@ -882,7 +883,7 @@ QuicPacket data(creator_.transport_version(), buffer.release(), length, true, header); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "constructed packet", data.data(), data.length(), reinterpret_cast<char*>(packet), QUICHE_ARRAYSIZE(packet)); } @@ -936,7 +937,7 @@ QuicPacket data(creator_.transport_version(), buffer.release(), length, true, header); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "constructed packet", data.data(), data.length(), reinterpret_cast<char*>(packet), QUICHE_ARRAYSIZE(packet)); } @@ -1968,7 +1969,7 @@ ASSERT_TRUE(header.version_flag); ASSERT_EQ(header.long_packet_type, INITIAL); ASSERT_EQ(header.retry_token.length(), sizeof(retry_token_bytes)); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "retry token", header.retry_token.data(), header.retry_token.length(), retry_token_bytes, sizeof(retry_token_bytes)); DeleteFrames(&frames_);
diff --git a/quic/core/quic_packets_test.cc b/quic/core/quic_packets_test.cc index e080cd8..1ccaabc 100644 --- a/quic/core/quic_packets_test.cc +++ b/quic/core/quic_packets_test.cc
@@ -7,6 +7,7 @@ #include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.h" #include "net/third_party/quiche/src/quic/platform/api/quic_test.h" #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h" +#include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h" namespace quic { namespace test { @@ -97,7 +98,7 @@ EXPECT_EQ(ACK_FRAME, copy->nonretransmittable_frames[0].type); EXPECT_EQ(PADDING_FRAME, copy->nonretransmittable_frames[1].type); EXPECT_EQ(1000u, copy->encrypted_length); - test::CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "encrypted_buffer", copy->encrypted_buffer, copy->encrypted_length, packet.encrypted_buffer, packet.encrypted_length);
diff --git a/quic/test_tools/crypto_test_utils.cc b/quic/test_tools/crypto_test_utils.cc index 7197427..a28f85c 100644 --- a/quic/test_tools/crypto_test_utils.cc +++ b/quic/test_tools/crypto_test_utils.cc
@@ -39,6 +39,7 @@ #include "net/third_party/quiche/src/quic/test_tools/simple_quic_framer.h" #include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" #include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h" +#include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h" namespace quic { namespace test { @@ -558,12 +559,12 @@ quiche::QuicheStringPiece encrypter_iv = encrypter->GetNoncePrefix(); quiche::QuicheStringPiece decrypter_key = decrypter->GetKey(); quiche::QuicheStringPiece decrypter_iv = decrypter->GetNoncePrefix(); - CompareCharArraysWithHexError(label + " key", encrypter_key.data(), - encrypter_key.length(), decrypter_key.data(), - decrypter_key.length()); - CompareCharArraysWithHexError(label + " iv", encrypter_iv.data(), - encrypter_iv.length(), decrypter_iv.data(), - decrypter_iv.length()); + quiche::test::CompareCharArraysWithHexError( + label + " key", encrypter_key.data(), encrypter_key.length(), + decrypter_key.data(), decrypter_key.length()); + quiche::test::CompareCharArraysWithHexError( + label + " iv", encrypter_iv.data(), encrypter_iv.length(), + decrypter_iv.data(), decrypter_iv.length()); } } // namespace @@ -601,10 +602,10 @@ client->crypto_negotiated_params().subkey_secret; quiche::QuicheStringPiece server_subkey_secret = server->crypto_negotiated_params().subkey_secret; - CompareCharArraysWithHexError("subkey secret", client_subkey_secret.data(), - client_subkey_secret.length(), - server_subkey_secret.data(), - server_subkey_secret.length()); + quiche::test::CompareCharArraysWithHexError( + "subkey secret", client_subkey_secret.data(), + client_subkey_secret.length(), server_subkey_secret.data(), + server_subkey_secret.length()); const char kSampleLabel[] = "label"; const char kSampleContext[] = "context"; @@ -617,7 +618,7 @@ EXPECT_TRUE(server->ExportKeyingMaterial(kSampleLabel, kSampleContext, kSampleOutputLength, &server_key_extraction)); - CompareCharArraysWithHexError( + quiche::test::CompareCharArraysWithHexError( "sample key extraction", client_key_extraction.data(), client_key_extraction.length(), server_key_extraction.data(), server_key_extraction.length());
diff --git a/quic/test_tools/quic_test_utils.cc b/quic/test_tools/quic_test_utils.cc index f86f2b5..2e01c66 100644 --- a/quic/test_tools/quic_test_utils.cc +++ b/quic/test_tools/quic_test_utils.cc
@@ -767,50 +767,6 @@ MockNetworkChangeVisitor::~MockNetworkChangeVisitor() {} -namespace { - -std::string HexDumpWithMarks(const char* data, - int length, - const bool* marks, - int mark_length) { - static const char kHexChars[] = "0123456789abcdef"; - static const int kColumns = 4; - - const int kSizeLimit = 1024; - if (length > kSizeLimit || mark_length > kSizeLimit) { - QUIC_LOG(ERROR) << "Only dumping first " << kSizeLimit << " bytes."; - length = std::min(length, kSizeLimit); - mark_length = std::min(mark_length, kSizeLimit); - } - - std::string hex; - for (const char* row = data; length > 0; - row += kColumns, length -= kColumns) { - for (const char* p = row; p < row + 4; ++p) { - if (p < row + length) { - const bool mark = - (marks && (p - data) < mark_length && marks[p - data]); - hex += mark ? '*' : ' '; - hex += kHexChars[(*p & 0xf0) >> 4]; - hex += kHexChars[*p & 0x0f]; - hex += mark ? '*' : ' '; - } else { - hex += " "; - } - } - hex = hex + " "; - - for (const char* p = row; p < row + 4 && p < row + length; ++p) { - hex += (*p >= 0x20 && *p <= 0x7f) ? (*p) : '.'; - } - - hex = hex + '\n'; - } - return hex; -} - -} // namespace - QuicIpAddress TestPeerIPAddress() { return QuicIpAddress::Loopback4(); } @@ -1067,37 +1023,6 @@ return new QuicEncryptedPacket(buffer, encrypted_length, true); } -void CompareCharArraysWithHexError(const std::string& description, - const char* actual, - const int actual_len, - const char* expected, - const int expected_len) { - EXPECT_EQ(actual_len, expected_len); - const int min_len = std::min(actual_len, expected_len); - const int max_len = std::max(actual_len, expected_len); - std::unique_ptr<bool[]> marks(new bool[max_len]); - bool identical = (actual_len == expected_len); - for (int i = 0; i < min_len; ++i) { - if (actual[i] != expected[i]) { - marks[i] = true; - identical = false; - } else { - marks[i] = false; - } - } - for (int i = min_len; i < max_len; ++i) { - marks[i] = true; - } - if (identical) - return; - ADD_FAILURE() << "Description:\n" - << description << "\n\nExpected:\n" - << HexDumpWithMarks(expected, expected_len, marks.get(), - max_len) - << "\nActual:\n" - << HexDumpWithMarks(actual, actual_len, marks.get(), max_len); -} - QuicConfig DefaultQuicConfig() { QuicConfig config; config.SetInitialMaxStreamDataBytesIncomingBidirectionalToSend(
diff --git a/quic/test_tools/quic_test_utils.h b/quic/test_tools/quic_test_utils.h index 15d8111..7a59f7d 100644 --- a/quic/test_tools/quic_test_utils.h +++ b/quic/test_tools/quic_test_utils.h
@@ -168,12 +168,6 @@ ParsedQuicVersion version, Perspective perspective); -void CompareCharArraysWithHexError(const std::string& description, - const char* actual, - const int actual_len, - const char* expected, - const int expected_len); - // Returns QuicConfig set to default values. QuicConfig DefaultQuicConfig();