wgtmac commented on code in PR #185:
URL: https://github.com/apache/iceberg-cpp/pull/185#discussion_r2380927806
##########
test/literal_test.cc:
##########
@@ -383,4 +382,214 @@ TEST(LiteralTest, DoubleZeroComparison) {
EXPECT_EQ(neg_zero <=> pos_zero, std::partial_ordering::less);
}
+struct LiteralRoundTripParam {
+ std::string test_name;
+ std::vector<uint8_t> input_bytes;
+ Literal expected_literal;
+ std::shared_ptr<PrimitiveType> type;
+};
+
+class LiteralSerializationParam : public
::testing::TestWithParam<LiteralRoundTripParam> {
Review Comment:
```suggestion
class LiteralSerDeTest : public ::testing::TestWithParam<LiteralParam> {
```
##########
test/literal_test.cc:
##########
@@ -383,4 +382,214 @@ TEST(LiteralTest, DoubleZeroComparison) {
EXPECT_EQ(neg_zero <=> pos_zero, std::partial_ordering::less);
}
+struct LiteralRoundTripParam {
+ std::string test_name;
+ std::vector<uint8_t> input_bytes;
+ Literal expected_literal;
+ std::shared_ptr<PrimitiveType> type;
Review Comment:
```suggestion
struct LiteralParam {
std::string test_name;
std::vector<uint8_t> serialized;
Literal value;
std::shared_ptr<PrimitiveType> type;
```
##########
test/literal_test.cc:
##########
@@ -383,4 +382,214 @@ TEST(LiteralTest, DoubleZeroComparison) {
EXPECT_EQ(neg_zero <=> pos_zero, std::partial_ordering::less);
}
+struct LiteralRoundTripParam {
+ std::string test_name;
+ std::vector<uint8_t> input_bytes;
+ Literal expected_literal;
+ std::shared_ptr<PrimitiveType> type;
+};
+
+class LiteralSerializationParam : public
::testing::TestWithParam<LiteralRoundTripParam> {
+};
+
+TEST_P(LiteralSerializationParam, RoundTrip) {
+ const auto& param = GetParam();
+
+ // Deserialize from bytes
+ Result<Literal> literal_result = Literal::Deserialize(param.input_bytes,
param.type);
+ ASSERT_TRUE(literal_result.has_value())
+ << "Deserialization failed: " << literal_result.error().message;
+
+ // Check type and value
+ EXPECT_EQ(*literal_result, param.expected_literal);
+
+ // Serialize back to bytes
+ Result<std::vector<uint8_t>> bytes_result = literal_result->Serialize();
+ ASSERT_TRUE(bytes_result.has_value())
+ << "Serialization failed: " << bytes_result.error().message;
+ EXPECT_EQ(*bytes_result, param.input_bytes);
+
+ // Deserialize again to verify idempotency
+ Result<Literal> final_literal = Literal::Deserialize(*bytes_result,
param.type);
+ ASSERT_TRUE(final_literal.has_value())
+ << "Final deserialization failed: " << final_literal.error().message;
+ EXPECT_EQ(*final_literal, param.expected_literal);
+}
+
+INSTANTIATE_TEST_SUITE_P(
+ BinarySerialization, LiteralSerializationParam,
+ ::testing::Values(
+ // Basic types
+ LiteralRoundTripParam{"BooleanTrue", {1}, Literal::Boolean(true),
boolean()},
+ LiteralRoundTripParam{"BooleanFalse", {0}, Literal::Boolean(false),
boolean()},
+
+ LiteralRoundTripParam{"Int", {32, 0, 0, 0}, Literal::Int(32), int32()},
+ LiteralRoundTripParam{
+ "IntMaxValue", {255, 255, 255, 127}, Literal::Int(2147483647),
int32()},
+ LiteralRoundTripParam{
+ "IntMinValue", {0, 0, 0, 128}, Literal::Int(-2147483648), int32()},
+ LiteralRoundTripParam{
+ "NegativeInt", {224, 255, 255, 255}, Literal::Int(-32), int32()},
+
+ LiteralRoundTripParam{
+ "Long", {32, 0, 0, 0, 0, 0, 0, 0}, Literal::Long(32), int64()},
+ LiteralRoundTripParam{"LongMaxValue",
+ {255, 255, 255, 255, 255, 255, 255, 127},
+
Literal::Long(std::numeric_limits<int64_t>::max()),
+ int64()},
+ LiteralRoundTripParam{"LongMinValue",
+ {0, 0, 0, 0, 0, 0, 0, 128},
+
Literal::Long(std::numeric_limits<int64_t>::min()),
+ int64()},
+ LiteralRoundTripParam{"NegativeLong",
+ {224, 255, 255, 255, 255, 255, 255, 255},
+ Literal::Long(-32),
+ int64()},
+
+ LiteralRoundTripParam{"Float", {0, 0, 128, 63}, Literal::Float(1.0f),
float32()},
+ LiteralRoundTripParam{"FloatNegativeInfinity",
+ {0, 0, 128, 255},
+
Literal::Float(-std::numeric_limits<float>::infinity()),
+ float32()},
+ LiteralRoundTripParam{"FloatMaxValue",
+ {255, 255, 127, 127},
+
Literal::Float(std::numeric_limits<float>::max()),
+ float32()},
+ LiteralRoundTripParam{"FloatMinValue",
+ {255, 255, 127, 255},
+
Literal::Float(std::numeric_limits<float>::lowest()),
+ float32()},
+
+ LiteralRoundTripParam{
+ "Double", {0, 0, 0, 0, 0, 0, 240, 63}, Literal::Double(1.0),
float64()},
+ LiteralRoundTripParam{"DoubleNegativeInfinity",
+ {0, 0, 0, 0, 0, 0, 240, 255},
+
Literal::Double(-std::numeric_limits<double>::infinity()),
+ float64()},
+ LiteralRoundTripParam{"DoubleMaxValue",
+ {255, 255, 255, 255, 255, 255, 239, 127},
+
Literal::Double(std::numeric_limits<double>::max()),
+ float64()},
+ LiteralRoundTripParam{"DoubleMinValue",
+ {255, 255, 255, 255, 255, 255, 239, 255},
+
Literal::Double(std::numeric_limits<double>::lowest()),
+ float64()},
+
+ LiteralRoundTripParam{"String",
+ {105, 99, 101, 98, 101, 114, 103},
+ Literal::String("iceberg"),
+ string()},
+ LiteralRoundTripParam{
+ "StringLong",
+ {65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65},
+ Literal::String("AAAAAAAAAAAAAAAA"),
+ string()},
+
+ LiteralRoundTripParam{"BinaryData",
+ {0x01, 0x02, 0x03, 0xFF},
+ Literal::Binary({0x01, 0x02, 0x03, 0xFF}),
+ binary()},
+ LiteralRoundTripParam{"BinarySingleByte", {42}, Literal::Binary({42}),
binary()},
+
+ // Fixed type
+ LiteralRoundTripParam{"FixedLength4",
+ {0x01, 0x02, 0x03, 0x04},
+ Literal::Fixed({0x01, 0x02, 0x03, 0x04}),
+ fixed(4)},
+ LiteralRoundTripParam{
+ "FixedLength8",
+ {0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x00, 0x11},
+ Literal::Fixed({0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x00, 0x11}),
+ fixed(8)},
+ LiteralRoundTripParam{
+ "FixedLength16",
+ {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A,
0x0B, 0x0C,
+ 0x0D, 0x0E, 0x0F},
+ Literal::Fixed({0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09,
+ 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F}),
+ fixed(16)},
+ LiteralRoundTripParam{
+ "FixedSingleByte", {0xFF}, Literal::Fixed({0xFF}), fixed(1)},
+
+ // Temporal types
+ LiteralRoundTripParam{"DateEpoch", {0, 0, 0, 0}, Literal::Date(0),
date()},
+ LiteralRoundTripParam{"DateNextDay", {1, 0, 0, 0}, Literal::Date(1),
date()},
+ LiteralRoundTripParam{"DateY2K", {205, 42, 0, 0},
Literal::Date(10957), date()},
+ LiteralRoundTripParam{
+ "DateNegative", {255, 255, 255, 255}, Literal::Date(-1), date()},
+
+ LiteralRoundTripParam{
+ "TimeMidnight", {0, 0, 0, 0, 0, 0, 0, 0}, Literal::Time(0),
time()},
+ LiteralRoundTripParam{"TimeNoon",
+ {128, 9, 230, 124, 10, 0, 0, 0},
+ Literal::Time(45045123456),
+ time()},
+ LiteralRoundTripParam{
+ "TimeOneSecond", {64, 66, 15, 0, 0, 0, 0, 0},
Literal::Time(1000000), time()},
+
+ LiteralRoundTripParam{"TimestampEpoch",
+ {0, 0, 0, 0, 0, 0, 0, 0},
+ Literal::Timestamp(0),
+ timestamp()},
+ LiteralRoundTripParam{"TimestampOneSecond",
+ {64, 66, 15, 0, 0, 0, 0, 0},
+ Literal::Timestamp(1000000),
+ timestamp()},
+ LiteralRoundTripParam{"TimestampNoon2024",
+ {128, 9, 230, 124, 10, 0, 0, 0},
+ Literal::Timestamp(45045123456),
+ timestamp()},
+
+ LiteralRoundTripParam{"TimestampTzEpoch",
+ {0, 0, 0, 0, 0, 0, 0, 0},
+ Literal::TimestampTz(0),
+ timestamp_tz()},
+ LiteralRoundTripParam{"TimestampTzOneHour",
+ {0, 164, 147, 214, 0, 0, 0, 0},
+ Literal::TimestampTz(3600000000),
+ timestamp_tz()}),
+
+ [](const testing::TestParamInfo<LiteralSerializationParam::ParamType>&
info) {
+ return info.param.test_name;
+ });
+
+TEST(LiteralSerializationTest, EmptyString) {
Review Comment:
Shouldn't this be a case of the above test? For example:
```cpp
LiteralRoundTripParam{"EmptyString",
{},
Literal::String({""}),
string()},
```
##########
test/literal_test.cc:
##########
@@ -383,4 +382,214 @@ TEST(LiteralTest, DoubleZeroComparison) {
EXPECT_EQ(neg_zero <=> pos_zero, std::partial_ordering::less);
}
+struct LiteralRoundTripParam {
+ std::string test_name;
+ std::vector<uint8_t> input_bytes;
+ Literal expected_literal;
+ std::shared_ptr<PrimitiveType> type;
+};
+
+class LiteralSerializationParam : public
::testing::TestWithParam<LiteralRoundTripParam> {
+};
+
+TEST_P(LiteralSerializationParam, RoundTrip) {
+ const auto& param = GetParam();
+
+ // Deserialize from bytes
+ Result<Literal> literal_result = Literal::Deserialize(param.input_bytes,
param.type);
+ ASSERT_TRUE(literal_result.has_value())
+ << "Deserialization failed: " << literal_result.error().message;
+
+ // Check type and value
+ EXPECT_EQ(*literal_result, param.expected_literal);
+
+ // Serialize back to bytes
+ Result<std::vector<uint8_t>> bytes_result = literal_result->Serialize();
+ ASSERT_TRUE(bytes_result.has_value())
+ << "Serialization failed: " << bytes_result.error().message;
+ EXPECT_EQ(*bytes_result, param.input_bytes);
+
+ // Deserialize again to verify idempotency
+ Result<Literal> final_literal = Literal::Deserialize(*bytes_result,
param.type);
+ ASSERT_TRUE(final_literal.has_value())
+ << "Final deserialization failed: " << final_literal.error().message;
+ EXPECT_EQ(*final_literal, param.expected_literal);
+}
+
+INSTANTIATE_TEST_SUITE_P(
+ BinarySerialization, LiteralSerializationParam,
+ ::testing::Values(
+ // Basic types
+ LiteralRoundTripParam{"BooleanTrue", {1}, Literal::Boolean(true),
boolean()},
+ LiteralRoundTripParam{"BooleanFalse", {0}, Literal::Boolean(false),
boolean()},
+
+ LiteralRoundTripParam{"Int", {32, 0, 0, 0}, Literal::Int(32), int32()},
+ LiteralRoundTripParam{
+ "IntMaxValue", {255, 255, 255, 127}, Literal::Int(2147483647),
int32()},
+ LiteralRoundTripParam{
+ "IntMinValue", {0, 0, 0, 128}, Literal::Int(-2147483648), int32()},
+ LiteralRoundTripParam{
+ "NegativeInt", {224, 255, 255, 255}, Literal::Int(-32), int32()},
+
+ LiteralRoundTripParam{
+ "Long", {32, 0, 0, 0, 0, 0, 0, 0}, Literal::Long(32), int64()},
+ LiteralRoundTripParam{"LongMaxValue",
+ {255, 255, 255, 255, 255, 255, 255, 127},
+
Literal::Long(std::numeric_limits<int64_t>::max()),
+ int64()},
+ LiteralRoundTripParam{"LongMinValue",
+ {0, 0, 0, 0, 0, 0, 0, 128},
+
Literal::Long(std::numeric_limits<int64_t>::min()),
+ int64()},
+ LiteralRoundTripParam{"NegativeLong",
+ {224, 255, 255, 255, 255, 255, 255, 255},
+ Literal::Long(-32),
+ int64()},
+
+ LiteralRoundTripParam{"Float", {0, 0, 128, 63}, Literal::Float(1.0f),
float32()},
+ LiteralRoundTripParam{"FloatNegativeInfinity",
+ {0, 0, 128, 255},
+
Literal::Float(-std::numeric_limits<float>::infinity()),
+ float32()},
+ LiteralRoundTripParam{"FloatMaxValue",
+ {255, 255, 127, 127},
+
Literal::Float(std::numeric_limits<float>::max()),
+ float32()},
+ LiteralRoundTripParam{"FloatMinValue",
+ {255, 255, 127, 255},
+
Literal::Float(std::numeric_limits<float>::lowest()),
+ float32()},
+
+ LiteralRoundTripParam{
+ "Double", {0, 0, 0, 0, 0, 0, 240, 63}, Literal::Double(1.0),
float64()},
+ LiteralRoundTripParam{"DoubleNegativeInfinity",
+ {0, 0, 0, 0, 0, 0, 240, 255},
+
Literal::Double(-std::numeric_limits<double>::infinity()),
+ float64()},
+ LiteralRoundTripParam{"DoubleMaxValue",
+ {255, 255, 255, 255, 255, 255, 239, 127},
+
Literal::Double(std::numeric_limits<double>::max()),
+ float64()},
+ LiteralRoundTripParam{"DoubleMinValue",
+ {255, 255, 255, 255, 255, 255, 239, 255},
+
Literal::Double(std::numeric_limits<double>::lowest()),
+ float64()},
+
+ LiteralRoundTripParam{"String",
+ {105, 99, 101, 98, 101, 114, 103},
+ Literal::String("iceberg"),
+ string()},
+ LiteralRoundTripParam{
+ "StringLong",
+ {65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65},
+ Literal::String("AAAAAAAAAAAAAAAA"),
+ string()},
+
+ LiteralRoundTripParam{"BinaryData",
+ {0x01, 0x02, 0x03, 0xFF},
+ Literal::Binary({0x01, 0x02, 0x03, 0xFF}),
+ binary()},
+ LiteralRoundTripParam{"BinarySingleByte", {42}, Literal::Binary({42}),
binary()},
+
+ // Fixed type
+ LiteralRoundTripParam{"FixedLength4",
+ {0x01, 0x02, 0x03, 0x04},
+ Literal::Fixed({0x01, 0x02, 0x03, 0x04}),
+ fixed(4)},
+ LiteralRoundTripParam{
+ "FixedLength8",
+ {0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x00, 0x11},
+ Literal::Fixed({0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x00, 0x11}),
+ fixed(8)},
+ LiteralRoundTripParam{
+ "FixedLength16",
+ {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A,
0x0B, 0x0C,
+ 0x0D, 0x0E, 0x0F},
+ Literal::Fixed({0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09,
+ 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F}),
+ fixed(16)},
+ LiteralRoundTripParam{
+ "FixedSingleByte", {0xFF}, Literal::Fixed({0xFF}), fixed(1)},
+
+ // Temporal types
+ LiteralRoundTripParam{"DateEpoch", {0, 0, 0, 0}, Literal::Date(0),
date()},
+ LiteralRoundTripParam{"DateNextDay", {1, 0, 0, 0}, Literal::Date(1),
date()},
+ LiteralRoundTripParam{"DateY2K", {205, 42, 0, 0},
Literal::Date(10957), date()},
+ LiteralRoundTripParam{
+ "DateNegative", {255, 255, 255, 255}, Literal::Date(-1), date()},
+
+ LiteralRoundTripParam{
+ "TimeMidnight", {0, 0, 0, 0, 0, 0, 0, 0}, Literal::Time(0),
time()},
+ LiteralRoundTripParam{"TimeNoon",
+ {128, 9, 230, 124, 10, 0, 0, 0},
+ Literal::Time(45045123456),
+ time()},
+ LiteralRoundTripParam{
+ "TimeOneSecond", {64, 66, 15, 0, 0, 0, 0, 0},
Literal::Time(1000000), time()},
+
+ LiteralRoundTripParam{"TimestampEpoch",
+ {0, 0, 0, 0, 0, 0, 0, 0},
+ Literal::Timestamp(0),
+ timestamp()},
+ LiteralRoundTripParam{"TimestampOneSecond",
+ {64, 66, 15, 0, 0, 0, 0, 0},
+ Literal::Timestamp(1000000),
+ timestamp()},
+ LiteralRoundTripParam{"TimestampNoon2024",
+ {128, 9, 230, 124, 10, 0, 0, 0},
+ Literal::Timestamp(45045123456),
+ timestamp()},
+
+ LiteralRoundTripParam{"TimestampTzEpoch",
+ {0, 0, 0, 0, 0, 0, 0, 0},
+ Literal::TimestampTz(0),
+ timestamp_tz()},
+ LiteralRoundTripParam{"TimestampTzOneHour",
+ {0, 164, 147, 214, 0, 0, 0, 0},
+ Literal::TimestampTz(3600000000),
+ timestamp_tz()}),
+
+ [](const testing::TestParamInfo<LiteralSerializationParam::ParamType>&
info) {
+ return info.param.test_name;
+ });
+
+TEST(LiteralSerializationTest, EmptyString) {
+ auto empty_string = Literal::String("");
+ auto empty_bytes = empty_string.Serialize();
+ ASSERT_TRUE(empty_bytes.has_value());
+ EXPECT_TRUE(empty_bytes->empty());
+
+ auto deserialize_result = Literal::Deserialize(*empty_bytes, string());
+ ASSERT_THAT(deserialize_result, IsOk());
+ EXPECT_TRUE(std::get<std::string>(deserialize_result->value()).empty());
+}
+
+TEST(LiteralSerializationTest, EmptyBinary) {
Review Comment:
ditto
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
