TEST_F(HexadecimalTest, LargeOutput) {
int64_t const digits_size = kDigits + 42;
UniqueBytes digits(digits_size);
std::memset(digits.data.get(), 'X', digits_size);
HexadecimalEncode(bytes_.get(), digits.get());
EXPECT_EQ(uppercase_digits_, Bytes(digits.data.get(), kDigits));
EXPECT_THAT(std::vector<uint8_t>(&digits.data[kDigits],
&digits.data[digits_size]),
Each('X'));
int64_t const bytes_size = kBytes + 42;
UniqueBytes bytes(bytes_size);
std::memset(bytes.data.get(), 'Y', bytes_size);
HexadecimalDecode(uppercase_digits_.get(), bytes.get());
EXPECT_EQ(bytes_, Bytes(bytes.data.get(), kBytes));
EXPECT_THAT(std::vector<uint8_t>(&bytes.data[kBytes],
&bytes.data[bytes_size]),
Each('Y'));
}
TEST_F(HexadecimalTest, LargeOutput) {
std::int64_t const digits_size = digit_count + 42;
UniqueArray<char> const digits(digits_size);
std::memset(digits.data.get(), 'X', digits_size);
encoder_.Encode(bytes_, digits.get());
EXPECT_EQ(uppercase_digits_, Array<char>(digits.data.get(), digit_count));
EXPECT_THAT(std::vector<std::uint8_t>(&digits.data[digit_count],
&digits.data[digits_size]),
Each('X'));
std::int64_t const bytes_size = byte_count + 42;
UniqueArray<std::uint8_t> bytes(bytes_size);
std::memset(bytes.data.get(), 'Y', bytes_size);
encoder_.Decode(uppercase_digits_, bytes.get());
EXPECT_EQ(bytes_, Array<std::uint8_t>(bytes.data.get(), byte_count));
EXPECT_THAT(std::vector<std::uint8_t>(&bytes.data[byte_count],
&bytes.data[bytes_size]),
Each('Y'));
}
TEST(PointwiseTest, WorksForLhsNativeArray)
{
const int lhs[] = { 1, 2, 3 };
::std::vector<int> rhs;
rhs.push_back(2);
rhs.push_back(4);
rhs.push_back(6);
EXPECT_THAT(lhs, Pointwise(Lt(), rhs));
EXPECT_THAT(lhs, Not(Pointwise(Gt(), rhs)));
EXPECT_THAT(lhs, Each(Lt(0)));
}
