nastra commented on code in PR #9185:
URL: https://github.com/apache/iceberg/pull/9185#discussion_r1434948333
##########
flink/v1.17/flink/src/test/java/org/apache/iceberg/flink/TestHelpers.java:
##########
@@ -193,109 +192,106 @@ private static void assertEquals(
return;
}
- Assert.assertTrue(
- "expected and actual should be both null or not null", expected !=
null && actual != null);
+ assertThat(expected).isNotNull();
+ assertThat(actual).isNotNull();
switch (type.typeId()) {
case BOOLEAN:
- Assert.assertEquals("boolean value should be equal", expected, actual);
+ assertThat(actual).as("boolean value should be
equal").isEqualTo(expected);
break;
case INTEGER:
- Assert.assertEquals("int value should be equal", expected, actual);
+ assertThat(actual).as("int value should be equal").isEqualTo(expected);
break;
case LONG:
- Assert.assertEquals("long value should be equal", expected, actual);
+ assertThat(actual).as("long value should be
equal").isEqualTo(expected);
break;
case FLOAT:
- Assert.assertEquals("float value should be equal", expected, actual);
+ assertThat(actual).as("float value should be
equal").isEqualTo(expected);
break;
case DOUBLE:
- Assert.assertEquals("double value should be equal", expected, actual);
+ assertThat(actual).as("double value should be
equal").isEqualTo(expected);
break;
case STRING:
- Assertions.assertThat(expected)
- .as("Should expect a CharSequence")
- .isInstanceOf(CharSequence.class);
- Assert.assertEquals("string should be equal",
String.valueOf(expected), actual.toString());
+ assertThat(expected).as("Should expect a
CharSequence").isInstanceOf(CharSequence.class);
+ assertThat(actual.toString())
+ .as("string should be equal")
+ .isEqualTo(String.valueOf(expected));
break;
case DATE:
- Assertions.assertThat(expected).as("Should expect a
Date").isInstanceOf(LocalDate.class);
+ assertThat(expected).as("Should expect a
Date").isInstanceOf(LocalDate.class);
LocalDate date = DateTimeUtil.dateFromDays((int) actual);
- Assert.assertEquals("date should be equal", expected, date);
+ assertThat(date).as("date should be equal").isEqualTo(expected);
break;
case TIME:
- Assertions.assertThat(expected)
- .as("Should expect a LocalTime")
- .isInstanceOf(LocalTime.class);
+ assertThat(expected).as("Should expect a
LocalTime").isInstanceOf(LocalTime.class);
int milliseconds = (int) (((LocalTime) expected).toNanoOfDay() /
1000_000);
- Assert.assertEquals("time millis should be equal", milliseconds,
actual);
+ assertThat(actual).as("time millis should be
equal").isEqualTo(milliseconds);
break;
case TIMESTAMP:
if (((Types.TimestampType) type).shouldAdjustToUTC()) {
- Assertions.assertThat(expected)
+ assertThat(expected)
.as("Should expect a OffsetDataTime")
.isInstanceOf(OffsetDateTime.class);
OffsetDateTime ts = (OffsetDateTime) expected;
- Assert.assertEquals(
- "OffsetDataTime should be equal",
- ts.toLocalDateTime(),
- ((TimestampData) actual).toLocalDateTime());
+ assertThat(((TimestampData) actual).toLocalDateTime())
+ .as("OffsetDataTime should be equal")
+ .isEqualTo(ts.toLocalDateTime());
} else {
- Assertions.assertThat(expected)
+ assertThat(expected)
.as("Should expect a LocalDataTime")
.isInstanceOf(LocalDateTime.class);
LocalDateTime ts = (LocalDateTime) expected;
- Assert.assertEquals(
- "LocalDataTime should be equal", ts, ((TimestampData)
actual).toLocalDateTime());
+ assertThat(((TimestampData) actual).toLocalDateTime())
+ .as("LocalDataTime should be equal")
+ .isEqualTo(ts);
}
break;
case BINARY:
- Assertions.assertThat(expected)
+ assertThat(expected)
.as("Should expect a ByteBuffer")
- .isInstanceOf(ByteBuffer.class);
- Assert.assertEquals("binary should be equal", expected,
ByteBuffer.wrap((byte[]) actual));
+ .isInstanceOf(ByteBuffer.class)
+ .isEqualTo(ByteBuffer.wrap((byte[]) actual));
break;
case DECIMAL:
- Assertions.assertThat(expected)
- .as("Should expect a BigDecimal")
- .isInstanceOf(BigDecimal.class);
+ assertThat(expected).as("Should expect a
BigDecimal").isInstanceOf(BigDecimal.class);
BigDecimal bd = (BigDecimal) expected;
- Assert.assertEquals(
- "decimal value should be equal", bd, ((DecimalData)
actual).toBigDecimal());
+ assertThat(((DecimalData) actual).toBigDecimal())
+ .as("decimal value should be equal")
+ .isEqualTo(bd);
break;
case LIST:
- Assertions.assertThat(expected)
- .as("Should expect a Collection")
- .isInstanceOf(Collection.class);
+ assertThat(expected).as("Should expect a
Collection").isInstanceOf(Collection.class);
Collection<?> expectedArrayData = (Collection<?>) expected;
ArrayData actualArrayData = (ArrayData) actual;
LogicalType elementType = ((ArrayType) logicalType).getElementType();
- Assert.assertEquals(
- "array length should be equal", expectedArrayData.size(),
actualArrayData.size());
+ assertThat(actualArrayData.size())
+ .as("array length should be equal")
+ .isEqualTo(expectedArrayData.size());
assertArrayValues(
type.asListType().elementType(), elementType, expectedArrayData,
actualArrayData);
break;
case MAP:
- Assertions.assertThat(expected).as("Should expect a
Map").isInstanceOf(Map.class);
+ assertThat(expected).as("Should expect a Map").isInstanceOf(Map.class);
assertMapValues(type.asMapType(), logicalType, (Map<?, ?>) expected,
(MapData) actual);
break;
case STRUCT:
- Assertions.assertThat(expected).as("Should expect a
Record").isInstanceOf(StructLike.class);
+ assertThat(expected).as("Should expect a
Record").isInstanceOf(StructLike.class);
assertRowData(type.asStructType(), logicalType, (StructLike) expected,
(RowData) actual);
break;
case UUID:
- Assertions.assertThat(expected).as("Should expect a
UUID").isInstanceOf(UUID.class);
+ assertThat(expected).as("Should expect a
UUID").isInstanceOf(UUID.class);
ByteBuffer bb = ByteBuffer.wrap((byte[]) actual);
long firstLong = bb.getLong();
long secondLong = bb.getLong();
- Assert.assertEquals(
- "UUID should be equal",
- expected.toString(),
- new UUID(firstLong, secondLong).toString());
+ assertThat(new UUID(firstLong, secondLong).toString())
+ .as("UUID should be equal")
+ .isEqualTo(expected.toString());
break;
case FIXED:
- Assertions.assertThat(expected).as("Should expect
byte[]").isInstanceOf(byte[].class);
- Assert.assertArrayEquals("binary should be equal", (byte[]) expected,
(byte[]) actual);
+ assertThat(expected)
Review Comment:
actual/expected is the wrong way here
--
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: issues-unsubscr...@iceberg.apache.org
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: issues-unsubscr...@iceberg.apache.org
For additional commands, e-mail: issues-h...@iceberg.apache.org
