Skip to content

Commit 10c0da4

Browse files
JooHyukKimJooHyukKim
committed
Fix parameterizedTests
1 parent 017201d commit 10c0da4

File tree

9 files changed

+521
-114
lines changed

9 files changed

+521
-114
lines changed

‎avro/src/test/java/com/fasterxml/jackson/dataformat/avro/ConcurrencyTest.java‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2,9 +2,13 @@
22

33
import java.io.*;
44

5+
import org.junit.jupiter.api.Test;
6+
57
import com.fasterxml.jackson.databind.MappingIterator;
68
import com.fasterxml.jackson.databind.SequenceWriter;
79

10+
import static org.junit.jupiter.api.Assertions.*;
11+
812
/**
913
* Simple tests for some testable aspects of concurrent usage.
1014
* Specifically tries to ensure that usage of multiple parsers,

‎avro/src/test/java/com/fasterxml/jackson/dataformat/avro/interop/InteropTestBase.java‎

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -154,4 +154,14 @@ protected <T> T roundTrip(Type schemaType, T object) throws IOException {
154154
Schema schema = schemaFunctor.apply(schemaType);
155155
return (T) deserializeFunctor.apply(schema, serializeFunctor.apply(schema, object));
156156
}
157+
158+
protected void useParameters(Function<Type, Schema> schemaFunctor,
159+
BiFunction<Schema, Object, byte[]> serializeFunctor,
160+
BiFunction<Schema, byte[], Object> deserializeFunctor
161+
) {
162+
this.schemaFunctor = schemaFunctor;
163+
this.serializeFunctor = serializeFunctor;
164+
this.deserializeFunctor = deserializeFunctor;
165+
}
166+
157167
}

‎avro/src/test/java/com/fasterxml/jackson/dataformat/avro/interop/annotations/AvroAliasTest.java‎

Lines changed: 56 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -1,15 +1,18 @@
11
package com.fasterxml.jackson.dataformat.avro.interop.annotations;
22

33
import java.io.IOException;
4+
import java.lang.reflect.Type;
45

56
import org.apache.avro.Schema;
67
import org.apache.avro.SchemaCompatibility;
78
import org.apache.avro.reflect.AvroAlias;
89
import org.apache.avro.reflect.Nullable;
9-
import org.junit.jupiter.api.Test;
10-
10+
import org.junit.jupiter.params.ParameterizedTest;
11+
import org.junit.jupiter.params.provider.MethodSource;
1112
import com.fasterxml.jackson.dataformat.avro.AvroTestBase;
1213
import com.fasterxml.jackson.dataformat.avro.interop.InteropTestBase;
14+
import com.fasterxml.jackson.dataformat.avro.testsupport.BiFunction;
15+
import com.fasterxml.jackson.dataformat.avro.testsupport.Function;
1316

1417
import static org.assertj.core.api.Assertions.assertThat;
1518

@@ -58,30 +61,45 @@ public enum NewestSize {
5861
LARGE;
5962
}
6063

61-
@Test
62-
public void testAliasedRecordForwardsCompatible() throws IOException {
64+
@MethodSource("getParameters")
65+
@ParameterizedTest(name = "{3}")
66+
public void testAliasedRecordForwardsCompatible(
67+
Function<Type, Schema> schemaFunctor, BiFunction<Schema, Object, byte[]> serializeFunctor,
68+
BiFunction<Schema, byte[], Object> deserializeFunctor, String combinationName)
69+
throws IOException
70+
{
6371
Schema oldSchema = schemaFunctor.apply(AvroTestBase.Employee.class);
6472
Schema newSchema = schemaFunctor.apply(NewEmployee.class);
6573
//
6674
SchemaCompatibility.SchemaPairCompatibility compatibility =
67-
SchemaCompatibility.checkReaderWriterCompatibility(newSchema, oldSchema);
75+
SchemaCompatibility.checkReaderWriterCompatibility(newSchema, oldSchema);
6876
//
6977
checkSchemaIsCompatible(compatibility);
7078
}
7179

72-
@Test
73-
public void testAliasedRecordBackwardsCompatible() throws IOException {
80+
@MethodSource("getParameters")
81+
@ParameterizedTest(name = "{3}")
82+
public void testAliasedRecordBackwardsCompatible(
83+
Function<Type, Schema> schemaFunctor, BiFunction<Schema, Object, byte[]> serializeFunctor,
84+
BiFunction<Schema, byte[], Object> deserializeFunctor, String combinationName)
85+
throws IOException
86+
{
7487
Schema oldSchema = schemaFunctor.apply(AvroTestBase.Employee.class);
7588
Schema newSchema = schemaFunctor.apply(NewEmployee.class);
7689
//
7790
SchemaCompatibility.SchemaPairCompatibility compatibility =
78-
SchemaCompatibility.checkReaderWriterCompatibility(oldSchema, newSchema);
91+
SchemaCompatibility.checkReaderWriterCompatibility(oldSchema, newSchema);
7992
//
8093
assertThat(compatibility.getType()).isEqualTo(SchemaCompatibility.SchemaCompatibilityType.INCOMPATIBLE);
8194
}
8295

83-
@Test
84-
public void testAliasedRecordForwardsCompatibleSameNamespace() throws IOException {
96+
@MethodSource("getParameters")
97+
@ParameterizedTest(name = "{3}")
98+
public void testAliasedRecordForwardsCompatibleSameNamespace(
99+
Function<Type, Schema> schemaFunctor, BiFunction<Schema, Object, byte[]> serializeFunctor,
100+
BiFunction<Schema, byte[], Object> deserializeFunctor, String combinationName)
101+
throws IOException
102+
{
85103
Schema oldSchema = schemaFunctor.apply(NewEmployee.class);
86104
Schema newSchema = schemaFunctor.apply(AliasedNameEmployee.class);
87105
//
@@ -91,8 +109,13 @@ public void testAliasedRecordForwardsCompatibleSameNamespace() throws IOExceptio
91109
checkSchemaIsCompatible(compatibility);
92110
}
93111

94-
@Test
95-
public void testAliasedRecordBackwardsCompatibleSameNamespace() throws IOException {
112+
@MethodSource("getParameters")
113+
@ParameterizedTest(name = "{3}")
114+
public void testAliasedRecordBackwardsCompatibleSameNamespace(
115+
Function<Type, Schema> schemaFunctor, BiFunction<Schema, Object, byte[]> serializeFunctor,
116+
BiFunction<Schema, byte[], Object> deserializeFunctor, String combinationName)
117+
throws IOException
118+
{
96119
Schema oldSchema = schemaFunctor.apply(NewEmployee.class);
97120
Schema newSchema = schemaFunctor.apply(AliasedNameEmployee.class);
98121
//
@@ -102,8 +125,13 @@ public void testAliasedRecordBackwardsCompatibleSameNamespace() throws IOExcepti
102125
assertThat(compatibility.getType()).isEqualTo(SchemaCompatibility.SchemaCompatibilityType.INCOMPATIBLE);
103126
}
104127

105-
@Test
106-
public void testAliasedEnumForwardsCompatible() throws IOException {
128+
@MethodSource("getParameters")
129+
@ParameterizedTest(name = "{3}")
130+
public void testAliasedEnumForwardsCompatible(
131+
Function<Type, Schema> schemaFunctor, BiFunction<Schema, Object, byte[]> serializeFunctor,
132+
BiFunction<Schema, byte[], Object> deserializeFunctor, String combinationName)
133+
throws IOException
134+
{
107135
Schema oldSchema = schemaFunctor.apply(AvroTestBase.Size.class);
108136
Schema newSchema = schemaFunctor.apply(NewSize.class);
109137
//
@@ -113,8 +141,13 @@ public void testAliasedEnumForwardsCompatible() throws IOException {
113141
checkSchemaIsCompatible(compatibility);
114142
}
115143

116-
@Test
117-
public void testAliasedEnumBackwardsCompatible() throws IOException {
144+
@MethodSource("getParameters")
145+
@ParameterizedTest(name = "{3}")
146+
public void testAliasedEnumBackwardsCompatible(
147+
Function<Type, Schema> schemaFunctor, BiFunction<Schema, Object, byte[]> serializeFunctor,
148+
BiFunction<Schema, byte[], Object> deserializeFunctor, String combinationName)
149+
throws IOException
150+
{
118151
Schema oldSchema = schemaFunctor.apply(AvroTestBase.Size.class);
119152
Schema newSchema = schemaFunctor.apply(NewSize.class);
120153
//
@@ -124,8 +157,13 @@ public void testAliasedEnumBackwardsCompatible() throws IOException {
124157
assertThat(compatibility.getType()).isEqualTo(SchemaCompatibility.SchemaCompatibilityType.INCOMPATIBLE);
125158
}
126159

127-
@Test
128-
public void testAliasedEnumForwardsAndBackwardsCompatible() throws IOException {
160+
@MethodSource("getParameters")
161+
@ParameterizedTest(name = "{3}")
162+
public void testAliasedEnumForwardsAndBackwardsCompatible(
163+
Function<Type, Schema> schemaFunctor, BiFunction<Schema, Object, byte[]> serializeFunctor,
164+
BiFunction<Schema, byte[], Object> deserializeFunctor, String combinationName)
165+
throws IOException
166+
{
129167
Schema oldSchema = schemaFunctor.apply(NewerSize.class);
130168
Schema newSchema = schemaFunctor.apply(NewestSize.class);
131169
//

‎avro/src/test/java/com/fasterxml/jackson/dataformat/avro/interop/annotations/AvroEncodeTest.java‎

Lines changed: 86 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -1,18 +1,24 @@
11
package com.fasterxml.jackson.dataformat.avro.interop.annotations;
22

33
import java.io.IOException;
4+
import java.lang.reflect.Type;
45
import java.nio.ByteBuffer;
56
import java.util.*;
67

8+
import org.apache.avro.Schema;
79
import org.apache.avro.SchemaBuilder;
810
import org.apache.avro.io.Decoder;
911
import org.apache.avro.io.Encoder;
1012
import org.apache.avro.reflect.*;
1113
import org.junit.jupiter.api.BeforeEach;
1214
import org.junit.jupiter.api.Test;
15+
import org.junit.jupiter.params.ParameterizedTest;
16+
import org.junit.jupiter.params.provider.MethodSource;
1317

1418
import com.fasterxml.jackson.dataformat.avro.interop.ApacheAvroInteropUtil;
1519
import com.fasterxml.jackson.dataformat.avro.interop.InteropTestBase;
20+
import com.fasterxml.jackson.dataformat.avro.testsupport.BiFunction;
21+
import com.fasterxml.jackson.dataformat.avro.testsupport.Function;
1622

1723
import static org.assertj.core.api.Assertions.assertThat;
1824

@@ -162,47 +168,109 @@ public void setup() throws IOException {
162168
cc.stringValue = "Nested Hello World!";
163169
cc.uuidValue = UUID.randomUUID();
164170
wrapper.component.nestedRecordValue = cc;
165-
//
166-
result = roundTrip(wrapper);
167171
}
168172

169-
@Test
170-
public void testByteValue() {
173+
@MethodSource("getParameters")
174+
@ParameterizedTest(name = "{3}")
175+
public void testByteValue(
176+
Function<Type, Schema> schemaFunctor, BiFunction<Schema, Object, byte[]> serializeFunctor,
177+
BiFunction<Schema, byte[], Object> deserializeFunctor, String combinationName)
178+
throws IOException
179+
{
180+
useParameters(schemaFunctor, serializeFunctor, deserializeFunctor);
181+
182+
result = roundTrip(wrapper);
171183
assertThat(result.component.byteValue).isEqualTo(wrapper.component.byteValue);
172184
}
173185

174-
@Test
175-
public void testShortValue() {
186+
@MethodSource("getParameters")
187+
@ParameterizedTest(name = "{3}")
188+
public void testShortValue(
189+
Function<Type, Schema> schemaFunctor, BiFunction<Schema, Object, byte[]> serializeFunctor,
190+
BiFunction<Schema, byte[], Object> deserializeFunctor, String combinationName)
191+
throws IOException
192+
{
193+
useParameters(schemaFunctor, serializeFunctor, deserializeFunctor);
194+
result = roundTrip(wrapper);
195+
176196
assertThat(result.component.shortValue).isEqualTo(wrapper.component.shortValue);
177197
}
178198

179-
@Test
180-
public void testStringValue() {
199+
@MethodSource("getParameters")
200+
@ParameterizedTest(name = "{3}")
201+
public void testStringValue(
202+
Function<Type, Schema> schemaFunctor, BiFunction<Schema, Object, byte[]> serializeFunctor,
203+
BiFunction<Schema, byte[], Object> deserializeFunctor, String combinationName)
204+
throws IOException
205+
{
206+
useParameters(schemaFunctor, serializeFunctor, deserializeFunctor);
207+
result = roundTrip(wrapper);
208+
181209
assertThat(result.component.stringValue).isEqualTo(wrapper.component.stringValue);
182210
}
183211

184-
@Test
185-
public void testDoubleValue() {
212+
@MethodSource("getParameters")
213+
@ParameterizedTest(name = "{3}")
214+
public void testDoubleValue(
215+
Function<Type, Schema> schemaFunctor, BiFunction<Schema, Object, byte[]> serializeFunctor,
216+
BiFunction<Schema, byte[], Object> deserializeFunctor, String combinationName)
217+
throws IOException
218+
{
219+
useParameters(schemaFunctor, serializeFunctor, deserializeFunctor);
220+
result = roundTrip(wrapper);
221+
186222
assertThat(result.component.doubleValue).isEqualTo(wrapper.component.doubleValue);
187223
}
188224

189-
@Test
190-
public void testLongValue() {
225+
@MethodSource("getParameters")
226+
@ParameterizedTest(name = "{3}")
227+
public void testLongValue(
228+
Function<Type, Schema> schemaFunctor, BiFunction<Schema, Object, byte[]> serializeFunctor,
229+
BiFunction<Schema, byte[], Object> deserializeFunctor, String combinationName)
230+
throws IOException
231+
{
232+
useParameters(schemaFunctor, serializeFunctor, deserializeFunctor);
233+
result = roundTrip(wrapper);
234+
191235
assertThat(result.component.longValue).isEqualTo(wrapper.component.longValue);
192236
}
193237

194-
@Test
195-
public void testIntegerValue() {
238+
@MethodSource("getParameters")
239+
@ParameterizedTest(name = "{3}")
240+
public void testIntegerValue(
241+
Function<Type, Schema> schemaFunctor, BiFunction<Schema, Object, byte[]> serializeFunctor,
242+
BiFunction<Schema, byte[], Object> deserializeFunctor, String combinationName)
243+
throws IOException
244+
{
245+
useParameters(schemaFunctor, serializeFunctor, deserializeFunctor);
246+
result = roundTrip(wrapper);
247+
196248
assertThat(result.component.intValue).isEqualTo(wrapper.component.intValue);
197249
}
198250

199-
@Test
200-
public void testNestedUuidValue() {
251+
@MethodSource("getParameters")
252+
@ParameterizedTest(name = "{3}")
253+
public void testNestedUuidValue(
254+
Function<Type, Schema> schemaFunctor, BiFunction<Schema, Object, byte[]> serializeFunctor,
255+
BiFunction<Schema, byte[], Object> deserializeFunctor, String combinationName)
256+
throws IOException
257+
{
258+
useParameters(schemaFunctor, serializeFunctor, deserializeFunctor);
259+
result = roundTrip(wrapper);
260+
201261
assertThat(result.component.nestedRecordValue.uuidValue).isEqualTo(wrapper.component.nestedRecordValue.uuidValue);
202262
}
203263

204-
@Test
205-
public void testUuidValue() {
264+
@MethodSource("getParameters")
265+
@ParameterizedTest(name = "{3}")
266+
public void testUuidValue(
267+
Function<Type, Schema> schemaFunctor, BiFunction<Schema, Object, byte[]> serializeFunctor,
268+
BiFunction<Schema, byte[], Object> deserializeFunctor, String combinationName)
269+
throws IOException
270+
{
271+
useParameters(schemaFunctor, serializeFunctor, deserializeFunctor);
272+
result = roundTrip(wrapper);
273+
206274
assertThat(result.component.uuidValue).isEqualTo(wrapper.component.uuidValue);
207275
}
208276
}

0 commit comments

Comments
 (0)