Skip to content

GH-3615: Use assertThat checks in parquet-column tests #3664

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
nastra wants to merge 1 commit into
base: master
Choose a base branch
from
Open

GH-3615: Use assertThat checks in parquet-column tests #3664

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
89 changes: 33 additions & 56 deletions parquet-arrow/src/test/java/org/apache/parquet/arrow/schema/TestSchemaConverter.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -30,6 +30,7 @@
import static org.apache.parquet.schema.PrimitiveType.PrimitiveTypeName.INT32;
import static org.apache.parquet.schema.PrimitiveType.PrimitiveTypeName.INT64;
import static org.apache.parquet.schema.PrimitiveType.PrimitiveTypeName.INT96;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;

import java.io.IOException;
Expand All @@ -55,7 +56,6 @@
import org.apache.parquet.schema.LogicalTypeAnnotation;
import org.apache.parquet.schema.MessageType;
import org.apache.parquet.schema.Types;
import org.junit.Assert;
import org.junit.Test;

/**
Expand Down Expand Up @@ -363,54 +363,35 @@ private static Field field(String name, ArrowType type, Field... children) {
@Test
public void testComplexArrowToParquet() {
MessageType parquet = converter.fromArrow(complexArrowSchema).getParquetSchema();
Assert.assertEquals(complexParquetSchema.toString(), parquet.toString()); // easier to read
Assert.assertEquals(complexParquetSchema, parquet);
assertThat(parquet).asString().isEqualTo(complexParquetSchema.toString()); // easier to read
assertThat(parquet).isEqualTo(complexParquetSchema);
}

@Test
public void testAllArrowToParquet() {
MessageType parquet = converter.fromArrow(allTypesArrowSchema).getParquetSchema();
Assert.assertEquals(allTypesParquetSchema.toString(), parquet.toString()); // easier to read
Assert.assertEquals(allTypesParquetSchema, parquet);
assertThat(parquet).asString().isEqualTo(allTypesParquetSchema.toString()); // easier to read
assertThat(parquet).isEqualTo(allTypesParquetSchema);
}

@Test
public void testSupportedParquetToArrow() {
Schema arrow = converter.fromParquet(supportedTypesParquetSchema).getArrowSchema();
assertEquals(supportedTypesArrowSchema, arrow);
assertThat(arrow).isEqualTo(supportedTypesArrowSchema);
}

@Test
public void testRepeatedParquetToArrow() {
Schema arrow = converter.fromParquet(Paper.schema).getArrowSchema();
assertEquals(paperArrowSchema, arrow);
}

public void assertEquals(Schema left, Schema right) {

@nastra nastra Jul 14, 2026

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

not used anywhere anymore

compareFields(left.getFields(), right.getFields());
Assert.assertEquals(left, right);
}

/**
* for more pinpointed error on what is different
*/
private void compareFields(List<Field> left, List<Field> right) {
Assert.assertEquals(left + "\n" + right, left.size(), right.size());
int size = left.size();
for (int i = 0; i < size; i++) {
Field expectedField = left.get(i);
Field field = right.get(i);
compareFields(expectedField.getChildren(), field.getChildren());
Assert.assertEquals(expectedField, field);
}
assertThat(arrow).isEqualTo(paperArrowSchema);
}

@Test
public void testAllMap() {
SchemaMapping map = converter.map(allTypesArrowSchema, allTypesParquetSchema);
Assert.assertEquals(
"p, s<p>, l<p>, l<p>, u<p>, p, p, p, p, p, p, p, p, p, p, p, p, p, p, p, p, p, p, p, p, p, p, p",
toSummaryString(map));
assertThat(toSummaryString(map))
.isEqualTo(
"p, s<p>, l<p>, l<p>, u<p>, p, p, p, p, p, p, p, p, p, p, p, p, p, p, p, p, p, p, p, p, p, p, p");
}

private String toSummaryString(SchemaMapping map) {
Expand Down Expand Up @@ -467,7 +448,7 @@ public String visit(RepeatedTypeMapping repeatedTypeMapping) {
@Test
public void testRepeatedMap() throws IOException {
SchemaMapping map = converter.map(paperArrowSchema, Paper.schema);
Assert.assertEquals("p, s<r<p>, r<p>>, r<s<r<s<p, p>>, p>>", toSummaryString(map));
assertThat(toSummaryString(map)).isEqualTo("p, s<r<p>, r<p>>, r<s<r<s<p, p>>, p>>");
}

@Test
Expand All @@ -484,27 +465,25 @@ public void testArrowTimeMillisecondToParquet() {
MessageType expected = converter
.fromArrow(new Schema(asList(field("a", new ArrowType.Time(TimeUnit.MILLISECOND, 32)))))
.getParquetSchema();
Assert.assertEquals(
expected,
Types.buildMessage()
assertThat(Types.buildMessage()
.addField(Types.optional(INT32)
.as(LogicalTypeAnnotation.timeType(false, MILLIS))
.named("a"))
.named("root"));
.named("root"))
.isEqualTo(expected);
}

@Test
public void testArrowTimeMicrosecondToParquet() {
MessageType expected = converter
.fromArrow(new Schema(asList(field("a", new ArrowType.Time(TimeUnit.MICROSECOND, 64)))))
.getParquetSchema();
Assert.assertEquals(
expected,
Types.buildMessage()
assertThat(Types.buildMessage()
.addField(Types.optional(INT64)
.as(LogicalTypeAnnotation.timeType(false, MICROS))
.named("a"))
.named("root"));
.named("root"))
.isEqualTo(expected);
}

@Test
Expand All @@ -515,7 +494,7 @@ public void testParquetInt32TimeMillisToArrow() {
.named("a"))
.named("root");
Schema expected = new Schema(asList(field("a", new ArrowType.Time(TimeUnit.MILLISECOND, 32))));
Assert.assertEquals(expected, converter.fromParquet(parquet).getArrowSchema());
assertThat(converter.fromParquet(parquet).getArrowSchema()).isEqualTo(expected);
}

@Test
Expand All @@ -526,7 +505,7 @@ public void testParquetInt64TimeMicrosToArrow() {
.named("a"))
.named("root");
Schema expected = new Schema(asList(field("a", new ArrowType.Time(TimeUnit.MICROSECOND, 64))));
Assert.assertEquals(expected, converter.fromParquet(parquet).getArrowSchema());
assertThat(converter.fromParquet(parquet).getArrowSchema()).isEqualTo(expected);
}

@Test
Expand All @@ -535,7 +514,7 @@ public void testParquetFixedBinaryToArrow() {
.addField(Types.optional(FIXED_LEN_BYTE_ARRAY).length(12).named("a"))
.named("root");
Schema expected = new Schema(asList(field("a", new ArrowType.Binary())));
Assert.assertEquals(expected, converter.fromParquet(parquet).getArrowSchema());
assertThat(converter.fromParquet(parquet).getArrowSchema()).isEqualTo(expected);
}

@Test
Expand All @@ -550,7 +529,7 @@ public void testParquetMapToArrow() {
SchemaMapping mapping = converter.fromParquet(parquet);
Schema actual = mapping.getArrowSchema();

Assert.assertEquals(expected, actual);
assertThat(actual).isEqualTo(expected);
}

@Test
Expand All @@ -562,15 +541,15 @@ public void testParquetFixedBinaryToArrowDecimal() {
.named("a"))
.named("root");
Schema expected = new Schema(asList(field("a", new ArrowType.Decimal(8, 2))));
Assert.assertEquals(expected, converter.fromParquet(parquet).getArrowSchema());
assertThat(converter.fromParquet(parquet).getArrowSchema()).isEqualTo(expected);
}

@Test
public void testParquetInt96ToArrowBinary() {
MessageType parquet =
Types.buildMessage().addField(Types.optional(INT96).named("a")).named("root");
Schema expected = new Schema(asList(field("a", new ArrowType.Binary())));
Assert.assertEquals(expected, converter.fromParquet(parquet).getArrowSchema());
assertThat(converter.fromParquet(parquet).getArrowSchema()).isEqualTo(expected);
}

@Test
Expand All @@ -579,8 +558,8 @@ public void testParquetInt96ToArrowTimestamp() {
MessageType parquet =
Types.buildMessage().addField(Types.optional(INT96).named("a")).named("root");
Schema expected = new Schema(asList(field("a", new ArrowType.Timestamp(TimeUnit.NANOSECOND, null))));
Assert.assertEquals(
expected, converterInt96ToTimestamp.fromParquet(parquet).getArrowSchema());
assertThat(converterInt96ToTimestamp.fromParquet(parquet).getArrowSchema())
.isEqualTo(expected);
}

@Test
Expand Down Expand Up @@ -619,27 +598,25 @@ public void testArrowTimestampMillisecondToParquet() {
MessageType expected = converter
.fromArrow(new Schema(asList(field("a", new ArrowType.Timestamp(TimeUnit.MILLISECOND, "UTC")))))
.getParquetSchema();
Assert.assertEquals(
expected,
Types.buildMessage()
assertThat(Types.buildMessage()
.addField(Types.optional(INT64)
.as(LogicalTypeAnnotation.timestampType(true, MILLIS))
.named("a"))
.named("root"));
.named("root"))
.isEqualTo(expected);
}

@Test
public void testArrowTimestampMicrosecondToParquet() {
MessageType expected = converter
.fromArrow(new Schema(asList(field("a", new ArrowType.Timestamp(TimeUnit.MICROSECOND, "UTC")))))
.getParquetSchema();
Assert.assertEquals(
expected,
Types.buildMessage()
assertThat(Types.buildMessage()
.addField(Types.optional(INT64)
.as(LogicalTypeAnnotation.timestampType(true, MICROS))
.named("a"))
.named("root"));
.named("root"))
.isEqualTo(expected);
}

@Test
Expand All @@ -650,7 +627,7 @@ public void testParquetInt64TimestampMillisToArrow() {
.named("a"))
.named("root");
Schema expected = new Schema(asList(field("a", new ArrowType.Timestamp(TimeUnit.MILLISECOND, "UTC"))));
Assert.assertEquals(expected, converter.fromParquet(parquet).getArrowSchema());
assertThat(converter.fromParquet(parquet).getArrowSchema()).isEqualTo(expected);
}

@Test
Expand All @@ -661,7 +638,7 @@ public void testParquetInt64TimestampMicrosToArrow() {
.named("a"))
.named("root");
Schema expected = new Schema(asList(field("a", new ArrowType.Timestamp(TimeUnit.MICROSECOND, "UTC"))));
Assert.assertEquals(expected, converter.fromParquet(parquet).getArrowSchema());
assertThat(converter.fromParquet(parquet).getArrowSchema()).isEqualTo(expected);
}

@Test
Expand Down
Loading
Loading