diff --git a/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/DeserViaCreatorTest.java b/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/DeserViaCreatorTest.java index a0aa451f..9c3d6911 100644 --- a/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/DeserViaCreatorTest.java +++ b/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/DeserViaCreatorTest.java @@ -2,10 +2,14 @@ import jakarta.json.JsonObject; +import org.junit.jupiter.api.Test; + import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.databind.ObjectMapper; +import static org.junit.jupiter.api.Assertions.*; + public class DeserViaCreatorTest extends TestBase { static class Pojo { @@ -19,6 +23,7 @@ public Pojo(@JsonProperty("s") String s, @JsonProperty("o") JsonObject o) { } } + @Test public void testCreatorDeser() throws Exception { final ObjectMapper mapper = sharedMapper(); diff --git a/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/JsonMergePatchDeserializationTest.java b/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/JsonMergePatchDeserializationTest.java index 119f20ca..45bab2b6 100644 --- a/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/JsonMergePatchDeserializationTest.java +++ b/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/JsonMergePatchDeserializationTest.java @@ -9,14 +9,16 @@ import jakarta.json.JsonValue; import java.util.Objects; -import static org.hamcrest.CoreMatchers.instanceOf; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.AssertionsForClassTypes.assertThat; +import static org.junit.jupiter.api.Assertions.*; public class JsonMergePatchDeserializationTest extends TestBase { private static final ObjectMapper MAPPER = newMapper(); + @Test public void testObjectDeserializationAndPatching() throws Exception { final String json = "{" + "\"name\":\"Json\"" + @@ -24,22 +26,24 @@ public void testObjectDeserializationAndPatching() throws Exception { final JsonMergePatch jsonMergePatch = MAPPER.readValue(json, JsonMergePatch.class); final JsonValue jsonPatchAsJsonValue = jsonMergePatch.toJsonValue(); - assertThat(jsonPatchAsJsonValue, instanceOf(JsonObject.class)); + assertInstanceOf(JsonObject.class, jsonPatchAsJsonValue); final JsonObject jsonPatchAsJsonObject = jsonPatchAsJsonValue.asJsonObject(); assertTrue(jsonPatchAsJsonObject.containsKey("name")); - assertThat(jsonPatchAsJsonObject.get("name"), instanceOf(JsonString.class)); - assertThat(jsonPatchAsJsonObject.getString("name"), is("Json")); + assertInstanceOf(JsonString.class, jsonPatchAsJsonObject.get("name")); + assertEquals("Json", jsonPatchAsJsonObject.getString("name")); + - assertThat(serializeAsString(jsonPatchAsJsonValue), is(json)); + assertEquals(json, serializeAsString(jsonPatchAsJsonValue)); final Person person = new Person("John", "Smith"); final JsonValue personJson = MAPPER.convertValue(person, JsonValue.class); final JsonValue patchedPersonJson = jsonMergePatch.apply(personJson); final Person patchedPerson = MAPPER.convertValue(patchedPersonJson, Person.class); - assertThat(patchedPerson, is(new Person("Json", "Smith"))); + assertEquals(new Person("Json", "Smith"), patchedPerson); } + @Test public void testArrayDeserializationAndPatching() throws Exception { final String json = "[" + "\"name\",\"Json\"" + @@ -47,37 +51,39 @@ public void testArrayDeserializationAndPatching() throws Exception { final JsonMergePatch jsonMergePatch = MAPPER.readValue(json, JsonMergePatch.class); final JsonValue jsonPatchAsJsonValue = jsonMergePatch.toJsonValue(); - assertThat(jsonPatchAsJsonValue, instanceOf(JsonArray.class)); + assertThat(jsonPatchAsJsonValue).isInstanceOf(JsonArray.class); + final JsonArray jsonPatchAsJsonArray = jsonPatchAsJsonValue.asJsonArray(); - assertThat(jsonPatchAsJsonArray.size(), is(2)); - assertThat(jsonPatchAsJsonArray.get(0), instanceOf(JsonString.class)); - assertThat(((JsonString)jsonPatchAsJsonArray.get(0)).getString(), is("name")); - assertThat(jsonPatchAsJsonArray.get(1), instanceOf(JsonString.class)); - assertThat(((JsonString)jsonPatchAsJsonArray.get(1)).getString(), is("Json")); + assertThat(jsonPatchAsJsonArray.size()).isEqualTo(2); + assertThat(jsonPatchAsJsonArray.get(0)).isInstanceOf(JsonString.class); + assertThat(((JsonString) jsonPatchAsJsonArray.get(0)).getString()).isEqualTo("name"); + assertThat(jsonPatchAsJsonArray.get(1)).isInstanceOf(JsonString.class); + assertThat(((JsonString) jsonPatchAsJsonArray.get(1)).getString()).isEqualTo("Json"); - assertThat(serializeAsString(jsonPatchAsJsonValue), is(json)); + assertThat(serializeAsString(jsonPatchAsJsonValue)).isEqualTo(json); final Person person = new Person("John", "Smith"); final JsonValue personJson = MAPPER.convertValue(person, JsonValue.class); final JsonValue patchedPersonJson = jsonMergePatch.apply(personJson); - assertThat(patchedPersonJson, instanceOf(JsonArray.class)); + assertThat(patchedPersonJson).isInstanceOf(JsonArray.class); } + @Test public void testScalarDeserializationAndPatching() throws Exception { final String json = "\"name\""; final JsonMergePatch jsonMergePatch = MAPPER.readValue(json, JsonMergePatch.class); final JsonValue jsonPatchAsJsonValue = jsonMergePatch.toJsonValue(); - assertThat(jsonPatchAsJsonValue, instanceOf(JsonString.class)); + assertThat(jsonPatchAsJsonValue).isInstanceOf(JsonString.class); - assertThat(serializeAsString(jsonPatchAsJsonValue), is(json)); + assertThat(serializeAsString(jsonPatchAsJsonValue)).isEqualTo(json); final Person person = new Person("John", "Smith"); final JsonValue personJson = MAPPER.convertValue(person, JsonValue.class); final JsonValue patchedPersonJson = jsonMergePatch.apply(personJson); - assertThat(patchedPersonJson, instanceOf(JsonString.class)); - assertThat(((JsonString)patchedPersonJson).getString(), is("name")); + assertThat(patchedPersonJson).isInstanceOf(JsonString.class); + assertThat(((JsonString) patchedPersonJson).getString()).isEqualTo("name"); } static class Person { diff --git a/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/JsonMergePatchSerializationTest.java b/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/JsonMergePatchSerializationTest.java index 06ccfa86..dd16f2a4 100644 --- a/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/JsonMergePatchSerializationTest.java +++ b/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/JsonMergePatchSerializationTest.java @@ -4,10 +4,15 @@ import jakarta.json.JsonMergePatch; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + public class JsonMergePatchSerializationTest extends TestBase { private static final ObjectMapper MAPPER = newMapper(); + @Test public void testSimpleSerialization() throws Exception { // First need a patch so deserialization must work diff --git a/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/JsonPatchDeserializationTest.java b/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/JsonPatchDeserializationTest.java index 5ea6a15e..819c5594 100644 --- a/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/JsonPatchDeserializationTest.java +++ b/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/JsonPatchDeserializationTest.java @@ -6,14 +6,16 @@ import java.util.Objects; -import static org.hamcrest.CoreMatchers.instanceOf; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.AssertionsForClassTypes.assertThat; +import static org.junit.jupiter.api.Assertions.*; public class JsonPatchDeserializationTest extends TestBase { private static final ObjectMapper MAPPER = newMapper(); + @Test public void testDeserializationAndPatching() throws Exception { final String json = "[" + "{" + @@ -25,28 +27,28 @@ public void testDeserializationAndPatching() throws Exception { final JsonPatch jsonPatch = MAPPER.readValue(json, JsonPatch.class); final JsonArray jsonPatchAsJsonArray = jsonPatch.toJsonArray(); - assertThat(jsonPatchAsJsonArray.get(0), instanceOf(JsonObject.class)); + assertThat(jsonPatchAsJsonArray.get(0)).isInstanceOf(JsonObject.class); final JsonObject firstOperation = jsonPatchAsJsonArray.get(0).asJsonObject(); assertTrue(firstOperation.containsKey("op")); - assertThat(firstOperation.get("op"), instanceOf(JsonString.class)); - assertThat(firstOperation.getString("op"), is("replace")); + assertThat(firstOperation.get("op")).isInstanceOf(JsonString.class); + assertThat(firstOperation.getString("op")).isEqualTo("replace"); assertTrue(firstOperation.containsKey("path")); - assertThat(firstOperation.get("path"), instanceOf(JsonString.class)); - assertThat(firstOperation.getString("path"), is("/name")); + assertThat(firstOperation.get("path")).isInstanceOf(JsonString.class); + assertThat(firstOperation.getString("path")).isEqualTo("/name"); assertTrue(firstOperation.containsKey("value")); - assertThat(firstOperation.get("value"), instanceOf(JsonString.class)); - assertThat(firstOperation.getString("value"), is("Json")); + assertThat(firstOperation.get("value")).isInstanceOf(JsonString.class); + assertThat(firstOperation.getString("value")).isEqualTo("Json"); - assertThat(serializeAsString(jsonPatchAsJsonArray), is(json)); + assertThat(serializeAsString(jsonPatchAsJsonArray)).isEqualTo(json); final Person person = new Person("John", "Smith"); final JsonStructure personJson = MAPPER.convertValue(person, JsonStructure.class); final JsonStructure patchedPersonJson = jsonPatch.apply(personJson); final Person patchedPerson = MAPPER.convertValue(patchedPersonJson, Person.class); - assertThat(patchedPerson, is(new Person("Json", "Smith"))); + assertThat(patchedPerson).isEqualTo(new Person("Json", "Smith")); } static class Person { diff --git a/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/JsonPatchSerializationTest.java b/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/JsonPatchSerializationTest.java index 13c6763d..e74a5afb 100644 --- a/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/JsonPatchSerializationTest.java +++ b/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/JsonPatchSerializationTest.java @@ -4,10 +4,15 @@ import jakarta.json.JsonPatch; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + public class JsonPatchSerializationTest extends TestBase { private static final ObjectMapper MAPPER = newMapper(); + @Test public void testSimpleSerialization() throws Exception { // First need a patch so deserialization must work diff --git a/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/JsonValueDeserializationTest.java b/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/JsonValueDeserializationTest.java index 080bb916..60d811d0 100644 --- a/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/JsonValueDeserializationTest.java +++ b/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/JsonValueDeserializationTest.java @@ -3,12 +3,16 @@ import jakarta.json.*; import jakarta.json.JsonValue.ValueType; +import org.junit.jupiter.api.Test; + import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.node.ObjectNode; import java.beans.ConstructorProperties; import java.math.BigDecimal; +import static org.junit.jupiter.api.Assertions.*; + public class JsonValueDeserializationTest extends TestBase { static class ObjectImpl { @@ -24,6 +28,7 @@ public ObjectImpl(JsonValue obj1, JsonValue obj2) { private final ObjectMapper MAPPER = newMapper(); + @Test public void testSimpleArray() throws Exception { final String JSON = "[1,true,\"foo\"]"; @@ -43,6 +48,7 @@ public void testSimpleArray() throws Exception assertEquals(JSON, serializeAsString(v)); } + @Test public void testNestedArray() throws Exception { final String JSON = "[1,[false,45],{\"foo\":13}]"; @@ -58,6 +64,7 @@ public void testNestedArray() throws Exception assertEquals(JSON, serializeAsString(v)); } + @Test public void testSimpleObject() throws Exception { final String JSON = "{\"a\":12.5,\"b\":\"Text\"}"; @@ -79,6 +86,7 @@ public void testSimpleObject() throws Exception assertEquals(JSON, serializeAsString(v)); } + @Test public void testNestedObject() throws Exception { final String JSON = "{\"array\":[1,2],\"obj\":{\"first\":true}}"; @@ -101,6 +109,7 @@ public void testNestedObject() throws Exception } // for [datatype-jsr353#5] + @Test public void testBinaryNode() throws Exception { ObjectNode root = MAPPER.createObjectNode(); @@ -116,6 +125,7 @@ public void testBinaryNode() throws Exception } // for [datatype-jsr353#16] + @Test public void testNullNode() throws Exception { final String serializedNull = MAPPER.writeValueAsString(JsonValue.NULL); @@ -125,6 +135,7 @@ public void testNullNode() throws Exception } // for [datatype-jsr353#19] + @Test public void testConstructorProperties() throws Exception { ObjectImpl ob = MAPPER.readValue("{\"obj1\":{}}", ObjectImpl.class); @@ -136,6 +147,7 @@ public void testConstructorProperties() throws Exception assertSame(JsonValue.NULL, ob2.obj2); } + @Test public void testBigInteger() throws Exception { final String JSON = "[2e308]"; diff --git a/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/JsonValueSerializationTest.java b/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/JsonValueSerializationTest.java index 822545d6..0232ada9 100644 --- a/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/JsonValueSerializationTest.java +++ b/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/JsonValueSerializationTest.java @@ -4,8 +4,13 @@ import jakarta.json.*; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + public class JsonValueSerializationTest extends TestBase { + @Test public void testSimpleArray() throws Exception { JsonArray arr = arrayBuilder() @@ -17,6 +22,7 @@ public void testSimpleArray() throws Exception assertEquals("[true,null,123,15.25]", serializeAsString(arr)); } + @Test public void testNestedArray() throws Exception { JsonArray arr = arrayBuilder() @@ -27,6 +33,7 @@ public void testNestedArray() throws Exception assertEquals("[1,[false,45],{\"foo\":13}]", serializeAsString(arr)); } + @Test public void testSimpleObject() throws Exception { JsonObject ob = objectBuilder() @@ -37,6 +44,7 @@ public void testSimpleObject() throws Exception assertEquals("{\"a\":123,\"b\":\"Text\"}", serializeAsString(ob)); } + @Test public void testNestedObject() throws Exception { JsonObject ob = objectBuilder() diff --git a/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/PolymorphicTest.java b/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/PolymorphicTest.java index 8c9d4a11..c06ac725 100644 --- a/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/PolymorphicTest.java +++ b/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/PolymorphicTest.java @@ -2,9 +2,13 @@ import jakarta.json.*; +import org.junit.jupiter.api.Test; + import com.fasterxml.jackson.annotation.JsonTypeInfo; import com.fasterxml.jackson.databind.ObjectMapper; +import static org.junit.jupiter.api.Assertions.*; + public class PolymorphicTest extends TestBase { static class Wrapper { @@ -19,6 +23,7 @@ public Wrapper() { } .polymorphicTypeValidator(new NoCheckSubTypeValidator()) .build(); + @Test public void testObjectAsTyped() throws Exception { final String INPUT = "{\"array\":[1,2],\"obj\":{\"first\":true}}"; @@ -36,6 +41,7 @@ public void testObjectAsTyped() throws Exception assertEquals(1, arr.getInt(0)); } + @Test public void testArrayAsTyped() throws Exception { final String INPUT = "[1,{\"a\":true}]"; diff --git a/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/TestBase.java b/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/TestBase.java index 0034f700..230d155c 100644 --- a/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/TestBase.java +++ b/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/TestBase.java @@ -9,7 +9,7 @@ import com.fasterxml.jackson.databind.json.JsonMapper; import com.fasterxml.jackson.databind.jsontype.PolymorphicTypeValidator; -public abstract class TestBase extends junit.framework.TestCase +public abstract class TestBase { static class NoCheckSubTypeValidator extends PolymorphicTypeValidator.Base diff --git a/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/TestVersions.java b/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/TestVersions.java index 8c20187c..d9594797 100644 --- a/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/TestVersions.java +++ b/jakarta-jsonp/src/test/java/com/fasterxml/jackson/datatype/jsonp/TestVersions.java @@ -5,8 +5,13 @@ import com.fasterxml.jackson.core.Version; import com.fasterxml.jackson.core.Versioned; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + public class TestVersions extends TestBase { + @Test public void testModuleVersionAndName() throws IOException { JSONPModule module = new JSONPModule(); diff --git a/jakarta-mail/src/test/java/com/fasterxml/jackson/datatype/jakarta/mail/SerDesTests.java b/jakarta-mail/src/test/java/com/fasterxml/jackson/datatype/jakarta/mail/SerDesTests.java index 5fb0d8b0..dffc8b35 100644 --- a/jakarta-mail/src/test/java/com/fasterxml/jackson/datatype/jakarta/mail/SerDesTests.java +++ b/jakarta-mail/src/test/java/com/fasterxml/jackson/datatype/jakarta/mail/SerDesTests.java @@ -1,11 +1,9 @@ package com.fasterxml.jackson.datatype.jakarta.mail; -import static org.junit.Assert.assertEquals; - import java.io.IOException; import java.io.UnsupportedEncodingException; -import org.junit.Test; +import org.junit.jupiter.api.Test; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.exc.InvalidFormatException; @@ -13,6 +11,8 @@ import jakarta.mail.internet.AddressException; import jakarta.mail.internet.InternetAddress; +import static org.junit.jupiter.api.Assertions.*; + public class SerDesTests extends TestBase { private static final String ADDRESS = "alice.adams@example.test"; @@ -54,9 +54,10 @@ public void onlyAddress() throws IOException, AddressException { } - @Test(expected = InvalidFormatException.class) + @Test public void invalidThrows() throws JsonProcessingException { String json = "\"alice at example\""; - sharedMapper().readValue(json, InternetAddress.class); + assertThrows(InvalidFormatException.class, + () -> sharedMapper().readValue(json, InternetAddress.class)); } } diff --git a/jakarta-mail/src/test/java/com/fasterxml/jackson/datatype/jakarta/mail/VersionTest.java b/jakarta-mail/src/test/java/com/fasterxml/jackson/datatype/jakarta/mail/VersionTest.java index 60f7bb5b..422317f4 100644 --- a/jakarta-mail/src/test/java/com/fasterxml/jackson/datatype/jakarta/mail/VersionTest.java +++ b/jakarta-mail/src/test/java/com/fasterxml/jackson/datatype/jakarta/mail/VersionTest.java @@ -1,14 +1,14 @@ package com.fasterxml.jackson.datatype.jakarta.mail; -import static org.junit.Assert.assertEquals; - import java.io.IOException; -import org.junit.Test; +import org.junit.jupiter.api.Test; import com.fasterxml.jackson.core.Version; import com.fasterxml.jackson.core.Versioned; +import static org.junit.jupiter.api.Assertions.assertEquals; + public class VersionTest { @Test diff --git a/joda-money/pom.xml b/joda-money/pom.xml index f648e083..7d41990c 100644 --- a/joda-money/pom.xml +++ b/joda-money/pom.xml @@ -37,12 +37,6 @@ joda-money 1.0.1 - - pl.pragmatists - JUnitParams - 1.1.1 - test - diff --git a/joda-money/src/test/java/com/fasterxml/jackson/datatype/jodamoney/CurrencyUnitDeserializerTest.java b/joda-money/src/test/java/com/fasterxml/jackson/datatype/jodamoney/CurrencyUnitDeserializerTest.java index e15f0b88..db6d7282 100644 --- a/joda-money/src/test/java/com/fasterxml/jackson/datatype/jodamoney/CurrencyUnitDeserializerTest.java +++ b/joda-money/src/test/java/com/fasterxml/jackson/datatype/jodamoney/CurrencyUnitDeserializerTest.java @@ -2,19 +2,25 @@ import org.joda.money.CurrencyUnit; +import org.junit.jupiter.api.Test; + import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.exc.InvalidFormatException; +import static org.junit.jupiter.api.Assertions.*; + public final class CurrencyUnitDeserializerTest extends ModuleTestBase { private final ObjectMapper MAPPER = mapperWithModule(); + @Test public void testShouldDeserialize() throws Exception { assertEquals(CurrencyUnit.EUR, MAPPER.readValue("\"EUR\"", CurrencyUnit.class)); } + @Test public void testShouldNotDeserializeInvalidCurrency() throws Exception { try { diff --git a/joda-money/src/test/java/com/fasterxml/jackson/datatype/jodamoney/CurrencyUnitSerializerTest.java b/joda-money/src/test/java/com/fasterxml/jackson/datatype/jodamoney/CurrencyUnitSerializerTest.java index 24882b0e..7bd07df3 100644 --- a/joda-money/src/test/java/com/fasterxml/jackson/datatype/jodamoney/CurrencyUnitSerializerTest.java +++ b/joda-money/src/test/java/com/fasterxml/jackson/datatype/jodamoney/CurrencyUnitSerializerTest.java @@ -1,14 +1,19 @@ package com.fasterxml.jackson.datatype.jodamoney; +import org.junit.jupiter.api.Test; + import org.joda.money.CurrencyUnit; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; +import static org.junit.jupiter.api.Assertions.*; + public final class CurrencyUnitSerializerTest extends ModuleTestBase { private final ObjectMapper objectMapper = mapperWithModule(); + @Test public void testShouldSerialize() throws JsonProcessingException { final String expectedCurrencyUnit = "EUR"; diff --git a/joda-money/src/test/java/com/fasterxml/jackson/datatype/jodamoney/ModuleTestBase.java b/joda-money/src/test/java/com/fasterxml/jackson/datatype/jodamoney/ModuleTestBase.java index e73a6344..7b767406 100644 --- a/joda-money/src/test/java/com/fasterxml/jackson/datatype/jodamoney/ModuleTestBase.java +++ b/joda-money/src/test/java/com/fasterxml/jackson/datatype/jodamoney/ModuleTestBase.java @@ -4,12 +4,13 @@ import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.cfg.MapperBuilder; import com.fasterxml.jackson.databind.json.JsonMapper; -import junit.framework.TestCase; import java.util.Arrays; import java.util.function.Function; -public abstract class ModuleTestBase extends TestCase +import static org.junit.jupiter.api.Assertions.*; + +public abstract class ModuleTestBase { // mix-in class for force polymorphic handling @JsonTypeInfo(use = JsonTypeInfo.Id.CLASS) diff --git a/joda-money/src/test/java/com/fasterxml/jackson/datatype/jodamoney/MoneyDeserializerTest.java b/joda-money/src/test/java/com/fasterxml/jackson/datatype/jodamoney/MoneyDeserializerTest.java index 743af287..fba9fd0a 100644 --- a/joda-money/src/test/java/com/fasterxml/jackson/datatype/jodamoney/MoneyDeserializerTest.java +++ b/joda-money/src/test/java/com/fasterxml/jackson/datatype/jodamoney/MoneyDeserializerTest.java @@ -9,17 +9,16 @@ import com.fasterxml.jackson.databind.exc.MismatchedInputException; import com.fasterxml.jackson.databind.exc.UnrecognizedPropertyException; -import junitparams.JUnitParamsRunner; -import junitparams.Parameters; -import junitparams.naming.TestCaseName; import org.joda.money.CurrencyUnit; import org.joda.money.Money; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; + +import static org.junit.jupiter.api.Assertions.*; import static com.fasterxml.jackson.datatype.jodamoney.AmountRepresentation.*; -@RunWith(JUnitParamsRunner.class) public final class MoneyDeserializerTest extends ModuleTestBase { @@ -29,20 +28,19 @@ public final class MoneyDeserializerTest extends ModuleTestBase /********************************************************************** */ - @Test - @Parameters({ - "{'amount':19.99\\,'currency':'EUR'}, EUR, 19.99", - "{'amount':19.999\\,'currency':'KWD'}, KWD, 19.999", - "{'amount':19\\,'currency':'JPY'}, JPY, 19", - "{'amount':19.9\\,'currency':'EUR'}, EUR, 19.90", - "{'amount':-19.5\\,'currency':'EUR'}, EUR, -19.50", - "{'amount':0\\,'currency':'EUR'}, EUR, 0", - "{'amount':'19.99'\\,'currency':'EUR'}, EUR, 19.99", - "{'amount':'19.0'\\,'currency':'EUR'}, EUR, 19.00", - "{'amount':'19'\\,'currency':'EUR'}, EUR, 19.00", - "{'currency':'EUR'\\,'amount':'19.50'}, EUR, 19.50", - }) - @TestCaseName("should deserialize {0} as {1} {2}") + @CsvSource(value = { + "{'amount':19.99,'currency':'EUR'} | EUR | 19.99", + "{'amount':19.999,'currency':'KWD'} | KWD | 19.999", + "{'amount':19,'currency':'JPY'} | JPY | 19", + "{'amount':19.9,'currency':'EUR'} | EUR | 19.90", + "{'amount':-19.5,'currency':'EUR'} | EUR | -19.50", + "{'amount':0,'currency':'EUR'} | EUR | 0", + "{'amount':'19.99','currency':'EUR'} | EUR | 19.99", + "{'amount':'19.0','currency':'EUR'} | EUR | 19.00", + "{'amount':'19','currency':'EUR'} | EUR | 19.00", + "{'currency':'EUR','amount':'19.50'} | EUR | 19.50", + }, delimiterString = "|") + @ParameterizedTest(name = "should deserialize {0} as {1} {2}") public void testShouldDeserialize( String json, String currencyCode, @@ -57,20 +55,19 @@ public void testShouldDeserialize( assertEquals(Money.of(CurrencyUnit.of(currencyCode), amount), actual); } - @Test - @Parameters({ - "{'amount':19.99\\,'currency':'EUR'}, EUR, 19.99", - "{'amount':19.999\\,'currency':'KWD'}, KWD, 19.999", - "{'amount':19\\,'currency':'JPY'}, JPY, 19", - "{'amount':19.9\\,'currency':'EUR'}, EUR, 19.90", - "{'amount':-19.5\\,'currency':'EUR'}, EUR, -19.50", - "{'amount':0\\,'currency':'EUR'}, EUR, 0", - "{'amount':'19.99'\\,'currency':'EUR'}, EUR, 19.99", - "{'amount':'19.0'\\,'currency':'EUR'}, EUR, 19.00", - "{'amount':'19'\\,'currency':'EUR'}, EUR, 19.00", - "{'currency':'EUR'\\,'amount':'19.50'}, EUR, 19.50", - }) - @TestCaseName("should deserialize {0} as {1} {2}") + @CsvSource(value = { + "{'amount':19.99,'currency':'EUR'} | EUR | 19.99", + "{'amount':19.999,'currency':'KWD'} | KWD | 19.999", + "{'amount':19,'currency':'JPY'} | JPY | 19", + "{'amount':19.9,'currency':'EUR'} | EUR | 19.90", + "{'amount':-19.5,'currency':'EUR'} | EUR | -19.50", + "{'amount':0,'currency':'EUR'} | EUR | 0", + "{'amount':'19.99','currency':'EUR'} | EUR | 19.99", + "{'amount':'19.0','currency':'EUR'} | EUR | 19.00", + "{'amount':'19','currency':'EUR'} | EUR | 19.00", + "{'currency':'EUR','amount':'19.50'} | EUR | 19.50", + }, delimiterString = "|") + @ParameterizedTest(name = "should deserialize {0} as {1} {2}") public void testShouldDeserializeDecimalNumberAmount( String json, String currencyCode, @@ -85,19 +82,18 @@ public void testShouldDeserializeDecimalNumberAmount( assertEquals(Money.of(CurrencyUnit.of(currencyCode), amount), actual); } - @Test - @Parameters({ - "{'amount':'19.99'\\,'currency':'EUR'}, EUR, 19.99", - "{'amount':'19.999'\\,'currency':'KWD'}, KWD, 19.999", - "{'amount':'19'\\,'currency':'JPY'}, JPY, 19", - "{'amount':'19.9'\\,'currency':'EUR'}, EUR, 19.90", - "{'amount':'-19.5'\\,'currency':'EUR'}, EUR, -19.50", - "{'amount':'0'\\,'currency':'EUR'}, EUR, 0", - "{'amount':'19.0'\\,'currency':'EUR'}, EUR, 19.00", - "{'amount':'19'\\,'currency':'EUR'}, EUR, 19.00", - "{'currency':'EUR'\\,'amount':'19.50'}, EUR, 19.50", - }) - @TestCaseName("should deserialize {0} as {1} {2}") + @CsvSource(value = { + "{'amount':'19.99','currency':'EUR'} | EUR | 19.99", + "{'amount':'19.999','currency':'KWD'} | KWD | 19.999", + "{'amount':'19','currency':'JPY'} | JPY | 19", + "{'amount':'19.9','currency':'EUR'} | EUR | 19.90", + "{'amount':'-19.5','currency':'EUR'} | EUR | -19.50", + "{'amount':'0','currency':'EUR'} | EUR | 0", + "{'amount':'19.0','currency':'EUR'} | EUR | 19.00", + "{'amount':'19','currency':'EUR'} | EUR | 19.00", + "{'currency':'EUR','amount':'19.50'} | EUR | 19.50", + }, delimiterString = "|") + @ParameterizedTest(name = "should deserialize {0} as {1} {2}") public void testShouldDeserializeDecimalStringAmount( String json, String currencyCode, @@ -112,19 +108,18 @@ public void testShouldDeserializeDecimalStringAmount( assertEquals(Money.of(CurrencyUnit.of(currencyCode), amount), actual); } - @Test - @Parameters({ - "{'amount':1999\\,'currency':'EUR'}, EUR, 19.99", - "{'amount':19999\\,'currency':'KWD'}, KWD, 19.999", - "{'amount':19\\,'currency':'JPY'}, JPY, 19", - "{'amount':1990\\,'currency':'EUR'}, EUR, 19.90", - "{'amount':-1950\\,'currency':'EUR'}, EUR, -19.50", - "{'amount':0\\,'currency':'EUR'}, EUR, 0", - "{'amount':'-1950'\\,'currency':'EUR'}, EUR, -19.50", - "{'amount':'1900.00'\\,'currency':'EUR'}, EUR, 19.00", - "{'currency':'EUR'\\,'amount':1950}, EUR, 19.50", - }) - @TestCaseName("should deserialize {0} as {1} {2}") + @CsvSource(value = { + "{'amount':1999,'currency':'EUR'} | EUR | 19.99", + "{'amount':19999,'currency':'KWD'} | KWD | 19.999", + "{'amount':19,'currency':'JPY'} | JPY | 19", + "{'amount':1990,'currency':'EUR'} | EUR | 19.90", + "{'amount':-1950,'currency':'EUR'} | EUR | -19.50", + "{'amount':0,'currency':'EUR'} | EUR | 0", + "{'amount':'-1950','currency':'EUR'} | EUR | -19.50", + "{'amount':'1900.00','currency':'EUR'} | EUR | 19.00", + "{'currency':'EUR','amount':1950} | EUR | 19.50", + }, delimiterString = "|") + @ParameterizedTest(name = "should deserialize {0} as {1} {2}") public void testShouldDeserializeAmountInMinorCurrencyUnit( String json, String currencyCode, @@ -148,6 +143,7 @@ public void testShouldDeserializeAmountInMinorCurrencyUnit( private final ObjectMapper MAPPER = mapperWithModule(); private final ObjectReader R = MAPPER.readerFor(Money.class); + @Test public void testShouldFailDeserializationWithoutAmount() throws Exception { final String content = "{\"currency\":\"EUR\"}"; @@ -160,6 +156,7 @@ public void testShouldFailDeserializationWithoutAmount() throws Exception } } + @Test public void testShouldFailDeserializationWithoutCurrency() throws Exception { final String content = "{\"amount\":5000}"; @@ -172,6 +169,7 @@ public void testShouldFailDeserializationWithoutCurrency() throws Exception } } + @Test public void testShouldFailDeserializationWithUnknownProperties() throws Exception { final ObjectReader r = MAPPER.readerFor(Money.class) @@ -187,6 +185,7 @@ public void testShouldFailDeserializationWithUnknownProperties() throws Exceptio } } + @Test public void testShouldPerformDeserializationWithUnknownProperties() throws IOException { final ObjectReader r = MAPPER.readerFor(Money.class) diff --git a/joda-money/src/test/java/com/fasterxml/jackson/datatype/jodamoney/MoneySerializerTest.java b/joda-money/src/test/java/com/fasterxml/jackson/datatype/jodamoney/MoneySerializerTest.java index 0401c08e..aba518fd 100644 --- a/joda-money/src/test/java/com/fasterxml/jackson/datatype/jodamoney/MoneySerializerTest.java +++ b/joda-money/src/test/java/com/fasterxml/jackson/datatype/jodamoney/MoneySerializerTest.java @@ -4,22 +4,19 @@ import com.fasterxml.jackson.databind.ObjectMapper; -import junitparams.JUnitParamsRunner; -import junitparams.Parameters; -import junitparams.naming.TestCaseName; import org.joda.money.CurrencyUnit; import org.joda.money.Money; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; + +import static org.junit.jupiter.api.Assertions.*; import static com.fasterxml.jackson.datatype.jodamoney.AmountRepresentation.*; -@RunWith(JUnitParamsRunner.class) public final class MoneySerializerTest extends ModuleTestBase { - @Test - @Parameters({ + @CsvSource({ "EUR, 19.99, 19.99", "KWD, 19.999, 19.999", "JPY, 19, 19", @@ -27,7 +24,7 @@ public final class MoneySerializerTest extends ModuleTestBase "EUR, -19.5, -19.50", "EUR, 0, 0.00", }) - @TestCaseName("should serialize {0} {1} with amount representation {2}") + @ParameterizedTest(name = "should serialize {0} {1} with amount representation {2}") public void testShouldSerialize( String currencyCode, BigDecimal amount, @@ -40,8 +37,7 @@ public void testShouldSerialize( mapper.writeValueAsString(Money.of(CurrencyUnit.of(currencyCode), amount))); } - @Test - @Parameters({ + @CsvSource({ "EUR, 19.99, 19.99", "KWD, 19.999, 19.999", "JPY, 19, 19", @@ -49,7 +45,7 @@ public void testShouldSerialize( "EUR, -19.5, -19.50", "EUR, 0, 0.00", }) - @TestCaseName("should serialize {0} {1} with amount representation {2}") + @ParameterizedTest(name = "should serialize {0} {1} with amount representation {2}") public void testShouldSerializeAmountAsDecimalNumber( String currencyCode, BigDecimal amount, @@ -62,8 +58,7 @@ public void testShouldSerializeAmountAsDecimalNumber( mapper.writeValueAsString(Money.of(CurrencyUnit.of(currencyCode), amount))); } - @Test - @Parameters({ + @CsvSource({ "EUR, 19.99, 19.99", "KWD, 19.999, 19.999", "JPY, 19, 19", @@ -71,7 +66,7 @@ public void testShouldSerializeAmountAsDecimalNumber( "EUR, -19.5, -19.50", "EUR, 0, 0.00", }) - @TestCaseName("should serialize {0} {1} with amount representation {2}") + @ParameterizedTest(name = "should serialize {0} {1} with amount representation {2}") public void testShouldSerializeAmountAsDecimalString( String currencyCode, BigDecimal amount, @@ -84,8 +79,7 @@ public void testShouldSerializeAmountAsDecimalString( mapper.writeValueAsString(Money.of(CurrencyUnit.of(currencyCode), amount))); } - @Test - @Parameters({ + @CsvSource({ "EUR, 19.99, 1999", "KWD, 19.999, 19999", "JPY, 19, 19", @@ -93,7 +87,7 @@ public void testShouldSerializeAmountAsDecimalString( "EUR, -19.5, -1950", "EUR, 0, 0", }) - @TestCaseName("should serialize {0} {1} with amount representation {2}") + @ParameterizedTest(name = "should serialize {0} {1} with amount representation {2}") public void testShouldSerializeAmountInMinorCurrencyUnit( String currencyCode, BigDecimal amount, diff --git a/joda-money/src/test/java/com/fasterxml/jackson/datatype/jodamoney/PolymorphicHandlingTest.java b/joda-money/src/test/java/com/fasterxml/jackson/datatype/jodamoney/PolymorphicHandlingTest.java index 73e19eba..a055111b 100644 --- a/joda-money/src/test/java/com/fasterxml/jackson/datatype/jodamoney/PolymorphicHandlingTest.java +++ b/joda-money/src/test/java/com/fasterxml/jackson/datatype/jodamoney/PolymorphicHandlingTest.java @@ -5,10 +5,15 @@ import org.joda.money.CurrencyUnit; import org.joda.money.Money; +import org.junit.jupiter.api.Test; + import com.fasterxml.jackson.databind.*; +import static org.junit.jupiter.api.Assertions.*; + public class PolymorphicHandlingTest extends ModuleTestBase { + @Test public void testPolymorphicMoney() throws Exception { ObjectMapper mapper = polyMapperFor(Money.class); final Money input = Money.of(CurrencyUnit.CAD, BigDecimal.valueOf(17.25)); @@ -22,6 +27,7 @@ public void testPolymorphicMoney() throws Exception { assertEquals(1725, result.getAmountMinorInt()); } + @Test public void testPolymorphicCurrency() throws Exception { ObjectMapper mapper = polyMapperFor(CurrencyUnit.class); String json = mapper.writeValueAsString(CurrencyUnit.EUR); diff --git a/joda-money/src/test/java/com/fasterxml/jackson/datatype/jodamoney/TestVersions.java b/joda-money/src/test/java/com/fasterxml/jackson/datatype/jodamoney/TestVersions.java index e01ae8d1..cbe1da64 100644 --- a/joda-money/src/test/java/com/fasterxml/jackson/datatype/jodamoney/TestVersions.java +++ b/joda-money/src/test/java/com/fasterxml/jackson/datatype/jodamoney/TestVersions.java @@ -7,14 +7,20 @@ /** * Simple verification that version access works. */ +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + public class TestVersions extends ModuleTestBase { + @Test public void testVersions() throws IOException { assertVersion(new JodaMoneyModule()); } // just because name is assigned programmatically + @Test public void testModuleName() { assertEquals("jackson-datatype-joda-money", diff --git a/json-org/src/test/java/com/fasterxml/jackson/datatype/jsonorg/ConvertTest.java b/json-org/src/test/java/com/fasterxml/jackson/datatype/jsonorg/ConvertTest.java index fb79c345..20be117b 100644 --- a/json-org/src/test/java/com/fasterxml/jackson/datatype/jsonorg/ConvertTest.java +++ b/json-org/src/test/java/com/fasterxml/jackson/datatype/jsonorg/ConvertTest.java @@ -6,9 +6,13 @@ import org.json.JSONArray; import org.json.JSONObject; +import org.junit.jupiter.api.Test; + import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.exc.MismatchedInputException; +import static org.junit.jupiter.api.Assertions.*; + public class ConvertTest extends ModuleTestBase { static class TestDomain { @@ -24,6 +28,7 @@ static class TestDomain { private final ObjectMapper MAPPER = newMapper(); + @Test public void testIssue15() throws Exception { Map map = new HashMap<>(); diff --git a/json-org/src/test/java/com/fasterxml/jackson/datatype/jsonorg/ModuleTestBase.java b/json-org/src/test/java/com/fasterxml/jackson/datatype/jsonorg/ModuleTestBase.java index a1f3d516..c26ece5a 100644 --- a/json-org/src/test/java/com/fasterxml/jackson/datatype/jsonorg/ModuleTestBase.java +++ b/json-org/src/test/java/com/fasterxml/jackson/datatype/jsonorg/ModuleTestBase.java @@ -5,7 +5,7 @@ import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.json.JsonMapper; -public abstract class ModuleTestBase extends junit.framework.TestCase +public abstract class ModuleTestBase { public ObjectMapper newMapper() { return new ObjectMapper() diff --git a/json-org/src/test/java/com/fasterxml/jackson/datatype/jsonorg/SimpleReadTest.java b/json-org/src/test/java/com/fasterxml/jackson/datatype/jsonorg/SimpleReadTest.java index c1aae017..3bc8fd60 100644 --- a/json-org/src/test/java/com/fasterxml/jackson/datatype/jsonorg/SimpleReadTest.java +++ b/json-org/src/test/java/com/fasterxml/jackson/datatype/jsonorg/SimpleReadTest.java @@ -6,10 +6,15 @@ import java.math.BigDecimal; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + public class SimpleReadTest extends ModuleTestBase { private final ObjectMapper MAPPER = newMapper(); + @Test public void testReadObject() throws Exception { JSONObject ob = MAPPER.readValue("{\"a\":{\"b\":3}, \"c\":[9, -4], \"d\":null, \"e\":true}", @@ -26,6 +31,7 @@ public void testReadObject() throws Exception assertTrue(ob.getBoolean("e")); } + @Test public void testReadArray() throws Exception { JSONArray array = MAPPER.readValue("[null, 13, false, 1.25, \"abc\", {\"a\":13}, [ ] ]", @@ -43,12 +49,14 @@ public void testReadArray() throws Exception assertEquals(0, array2.length()); } + @Test public void testBigInteger() throws Exception { JSONObject val = MAPPER.readValue("{\"val\":2e308}", JSONObject.class); assertEquals(new BigDecimal("2e308").toBigInteger(), val.getBigInteger("val")); } + @Test public void testBigIntegerArray() throws Exception { JSONArray array = MAPPER.readValue("[2e308]", JSONArray.class); @@ -56,6 +64,7 @@ public void testBigIntegerArray() throws Exception assertEquals(new BigDecimal("2e308").toBigInteger(), array.getBigInteger(0)); } + @Test public void testDouble() throws Exception { JSONObject val = MAPPER.readValue("{\"val\": 0.5}", JSONObject.class); diff --git a/json-org/src/test/java/com/fasterxml/jackson/datatype/jsonorg/SimpleWriteTest.java b/json-org/src/test/java/com/fasterxml/jackson/datatype/jsonorg/SimpleWriteTest.java index 04f8bdf0..c24e8aae 100644 --- a/json-org/src/test/java/com/fasterxml/jackson/datatype/jsonorg/SimpleWriteTest.java +++ b/json-org/src/test/java/com/fasterxml/jackson/datatype/jsonorg/SimpleWriteTest.java @@ -4,8 +4,13 @@ import org.json.*; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + public class SimpleWriteTest extends ModuleTestBase { + @Test public void testWriteObject() throws Exception { final ObjectMapper mapper = newMapper(); @@ -23,6 +28,7 @@ public void testWriteObject() throws Exception assertEquals(JSON, mapper.writeValueAsString(ob)); } + @Test public void testWriteArray() throws Exception { final ObjectMapper mapper = newMapper(); diff --git a/json-org/src/test/java/com/fasterxml/jackson/datatype/jsonorg/TestVersions.java b/json-org/src/test/java/com/fasterxml/jackson/datatype/jsonorg/TestVersions.java index 94873f52..5608065f 100644 --- a/json-org/src/test/java/com/fasterxml/jackson/datatype/jsonorg/TestVersions.java +++ b/json-org/src/test/java/com/fasterxml/jackson/datatype/jsonorg/TestVersions.java @@ -5,8 +5,13 @@ import com.fasterxml.jackson.core.Version; import com.fasterxml.jackson.core.Versioned; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + public class TestVersions extends ModuleTestBase { + @Test public void testModuleVersionAndName() throws IOException { JsonOrgModule module = new JsonOrgModule(); diff --git a/json-org/src/test/java/com/fasterxml/jackson/datatype/jsonorg/TypeInformationTest.java b/json-org/src/test/java/com/fasterxml/jackson/datatype/jsonorg/TypeInformationTest.java index c657bc23..6a00d561 100644 --- a/json-org/src/test/java/com/fasterxml/jackson/datatype/jsonorg/TypeInformationTest.java +++ b/json-org/src/test/java/com/fasterxml/jackson/datatype/jsonorg/TypeInformationTest.java @@ -1,11 +1,15 @@ package com.fasterxml.jackson.datatype.jsonorg; +import org.junit.jupiter.api.Test; + import com.fasterxml.jackson.databind.*; import com.fasterxml.jackson.databind.cfg.MapperConfig; import com.fasterxml.jackson.databind.jsontype.PolymorphicTypeValidator; import org.json.*; +import static org.junit.jupiter.api.Assertions.*; + /** * Tests to verify that we can also use JSONObject and JSONArray * with polymorphic type information. @@ -36,6 +40,7 @@ public ObjectWrapper() { } .activateDefaultTyping(new NoCheckSubTypeValidator()) .build(); + @Test public void testWrappedArray() throws Exception { JSONTokener tok = new JSONTokener("[13]"); @@ -51,6 +56,7 @@ public void testWrappedArray() throws Exception assertEquals(13, resultArray.getInt(0)); } + @Test public void testWrappedObject() throws Exception { JSONTokener tok = new JSONTokener("{\"a\":true}"); diff --git a/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/DeserViaCreatorTest.java b/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/DeserViaCreatorTest.java index f01db8c8..87a5c203 100644 --- a/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/DeserViaCreatorTest.java +++ b/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/DeserViaCreatorTest.java @@ -2,10 +2,14 @@ import javax.json.JsonObject; +import org.junit.jupiter.api.Test; + import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.databind.ObjectMapper; +import static org.junit.jupiter.api.Assertions.*; + public class DeserViaCreatorTest extends TestBase { static class Pojo { @@ -19,6 +23,7 @@ public Pojo(@JsonProperty("s") String s, @JsonProperty("o") JsonObject o) { } } + @Test public void testCreatorDeser() throws Exception { final ObjectMapper mapper = sharedMapper(); diff --git a/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/JsonMergePatchDeserializationTest.java b/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/JsonMergePatchDeserializationTest.java index 8d0d0b78..b1dbb019 100644 --- a/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/JsonMergePatchDeserializationTest.java +++ b/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/JsonMergePatchDeserializationTest.java @@ -1,5 +1,7 @@ package com.fasterxml.jackson.datatype.jsr353; +import org.junit.jupiter.api.Test; + import com.fasterxml.jackson.databind.ObjectMapper; import javax.json.JsonArray; @@ -9,14 +11,14 @@ import javax.json.JsonValue; import java.util.Objects; -import static org.hamcrest.CoreMatchers.instanceOf; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.AssertionsForClassTypes.assertThat; +import static org.junit.jupiter.api.Assertions.*; public class JsonMergePatchDeserializationTest extends TestBase { private static final ObjectMapper MAPPER = newMapper(); + @Test public void testObjectDeserializationAndPatching() throws Exception { final String json = "{" + "\"name\":\"Json\"" + @@ -24,60 +26,62 @@ public void testObjectDeserializationAndPatching() throws Exception { final JsonMergePatch jsonMergePatch = MAPPER.readValue(json, JsonMergePatch.class); final JsonValue jsonPatchAsJsonValue = jsonMergePatch.toJsonValue(); - assertThat(jsonPatchAsJsonValue, instanceOf(JsonObject.class)); + assertThat(jsonPatchAsJsonValue).isInstanceOf(JsonObject.class); final JsonObject jsonPatchAsJsonObject = jsonPatchAsJsonValue.asJsonObject(); assertTrue(jsonPatchAsJsonObject.containsKey("name")); - assertThat(jsonPatchAsJsonObject.get("name"), instanceOf(JsonString.class)); - assertThat(jsonPatchAsJsonObject.getString("name"), is("Json")); + assertThat(jsonPatchAsJsonObject.get("name")).isInstanceOf(JsonString.class); + assertThat(jsonPatchAsJsonObject.getString("name")).isEqualTo("Json"); - assertThat(serializeAsString(jsonPatchAsJsonValue), is(json)); + assertThat(serializeAsString(jsonPatchAsJsonValue)).isEqualTo(json); final Person person = new Person("John", "Smith"); final JsonValue personJson = MAPPER.convertValue(person, JsonValue.class); final JsonValue patchedPersonJson = jsonMergePatch.apply(personJson); final Person patchedPerson = MAPPER.convertValue(patchedPersonJson, Person.class); - assertThat(patchedPerson, is(new Person("Json", "Smith"))); + assertThat(patchedPerson).isEqualTo(new Person("Json", "Smith")); } + @Test public void testArrayDeserializationAndPatching() throws Exception { final String json = "[" + - "\"name\",\"Json\"" + - "]"; + "\"name\",\"Json\"" + + "]"; final JsonMergePatch jsonMergePatch = MAPPER.readValue(json, JsonMergePatch.class); final JsonValue jsonPatchAsJsonValue = jsonMergePatch.toJsonValue(); - assertThat(jsonPatchAsJsonValue, instanceOf(JsonArray.class)); + assertThat(jsonPatchAsJsonValue).isInstanceOf(JsonArray.class); final JsonArray jsonPatchAsJsonArray = jsonPatchAsJsonValue.asJsonArray(); - assertThat(jsonPatchAsJsonArray.size(), is(2)); - assertThat(jsonPatchAsJsonArray.get(0), instanceOf(JsonString.class)); - assertThat(((JsonString)jsonPatchAsJsonArray.get(0)).getString(), is("name")); - assertThat(jsonPatchAsJsonArray.get(1), instanceOf(JsonString.class)); - assertThat(((JsonString)jsonPatchAsJsonArray.get(1)).getString(), is("Json")); + assertThat(jsonPatchAsJsonArray.size()).isEqualTo(2); + assertThat(jsonPatchAsJsonArray.get(0)).isInstanceOf(JsonString.class); + assertThat(((JsonString)jsonPatchAsJsonArray.get(0)).getString()).isEqualTo("name"); + assertThat(jsonPatchAsJsonArray.get(1)).isInstanceOf(JsonString.class); + assertThat(((JsonString)jsonPatchAsJsonArray.get(1)).getString()).isEqualTo("Json"); - assertThat(serializeAsString(jsonPatchAsJsonValue), is(json)); + assertThat(serializeAsString(jsonPatchAsJsonValue)).isEqualTo(json); final Person person = new Person("John", "Smith"); final JsonValue personJson = MAPPER.convertValue(person, JsonValue.class); final JsonValue patchedPersonJson = jsonMergePatch.apply(personJson); - assertThat(patchedPersonJson, instanceOf(JsonArray.class)); + assertThat(patchedPersonJson).isInstanceOf(JsonArray.class); } + @Test public void testScalarDeserializationAndPatching() throws Exception { final String json = "\"name\""; final JsonMergePatch jsonMergePatch = MAPPER.readValue(json, JsonMergePatch.class); final JsonValue jsonPatchAsJsonValue = jsonMergePatch.toJsonValue(); - assertThat(jsonPatchAsJsonValue, instanceOf(JsonString.class)); + assertThat(jsonPatchAsJsonValue).isInstanceOf(JsonString.class); - assertThat(serializeAsString(jsonPatchAsJsonValue), is(json)); + assertThat(serializeAsString(jsonPatchAsJsonValue)).isEqualTo(json); final Person person = new Person("John", "Smith"); final JsonValue personJson = MAPPER.convertValue(person, JsonValue.class); final JsonValue patchedPersonJson = jsonMergePatch.apply(personJson); - assertThat(patchedPersonJson, instanceOf(JsonString.class)); - assertThat(((JsonString)patchedPersonJson).getString(), is("name")); + assertThat(patchedPersonJson).isInstanceOf(JsonString.class); + assertThat(((JsonString)patchedPersonJson).getString()).isEqualTo("name"); } static class Person { diff --git a/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/JsonMergePatchSerializationTest.java b/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/JsonMergePatchSerializationTest.java index 5e4e6322..86b4fb88 100644 --- a/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/JsonMergePatchSerializationTest.java +++ b/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/JsonMergePatchSerializationTest.java @@ -2,12 +2,17 @@ import javax.json.JsonMergePatch; +import org.junit.jupiter.api.Test; + import com.fasterxml.jackson.databind.ObjectMapper; +import static org.junit.jupiter.api.Assertions.*; + public class JsonMergePatchSerializationTest extends TestBase { private static final ObjectMapper MAPPER = newMapper(); + @Test public void testSimpleSerialization() throws Exception { // First need a patch so deserialization must work diff --git a/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/JsonPatchDeserializationTest.java b/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/JsonPatchDeserializationTest.java index 63047727..57c28ba4 100644 --- a/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/JsonPatchDeserializationTest.java +++ b/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/JsonPatchDeserializationTest.java @@ -1,5 +1,7 @@ package com.fasterxml.jackson.datatype.jsr353; +import org.junit.jupiter.api.Test; + import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.exc.InvalidFormatException; @@ -7,11 +9,8 @@ import java.util.Objects; -import static org.hamcrest.CoreMatchers.containsString; -import static org.hamcrest.CoreMatchers.instanceOf; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.junit.Assert.assertThrows; +import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat; +import static org.junit.jupiter.api.Assertions.*; public class JsonPatchDeserializationTest extends TestBase { @@ -19,6 +18,7 @@ public class JsonPatchDeserializationTest extends TestBase { private static final ObjectMapper MAPPER = newMapper(); + @Test public void testArrayOfObjectsDeserializationAndPatching() throws Exception { final String json = "[" + "{" + @@ -30,30 +30,31 @@ public void testArrayOfObjectsDeserializationAndPatching() throws Exception { final JsonPatch jsonPatch = MAPPER.readValue(json, JsonPatch.class); final JsonArray jsonPatchAsJsonArray = jsonPatch.toJsonArray(); - assertThat(jsonPatchAsJsonArray.get(0), instanceOf(JsonObject.class)); + assertThat(jsonPatchAsJsonArray.get(0)).isInstanceOf(JsonObject.class); final JsonObject firstOperation = jsonPatchAsJsonArray.get(0).asJsonObject(); - assertTrue(firstOperation.containsKey("op")); - assertThat(firstOperation.get("op"), instanceOf(JsonString.class)); - assertThat(firstOperation.getString("op"), is("replace")); + assertThat(firstOperation).containsKey("op"); + assertThat(firstOperation.get("op")).isInstanceOf(JsonString.class); + assertThat(firstOperation.getString("op")).isEqualTo("replace"); - assertTrue(firstOperation.containsKey("path")); - assertThat(firstOperation.get("path"), instanceOf(JsonString.class)); - assertThat(firstOperation.getString("path"), is("/name")); + assertThat(firstOperation).containsKey("path"); + assertThat(firstOperation.get("path")).isInstanceOf(JsonString.class); + assertThat(firstOperation.getString("path")).isEqualTo("/name"); - assertTrue(firstOperation.containsKey("value")); - assertThat(firstOperation.get("value"), instanceOf(JsonString.class)); - assertThat(firstOperation.getString("value"), is("Json")); + assertThat(firstOperation).containsKey("value"); + assertThat(firstOperation.get("value")).isInstanceOf(JsonString.class); + assertThat(firstOperation.getString("value")).isEqualTo("Json"); - assertThat(serializeAsString(jsonPatchAsJsonArray), is(json)); + assertThat(serializeAsString(jsonPatchAsJsonArray)).isEqualTo(json); final Person person = new Person("John", "Smith"); final JsonStructure personJson = MAPPER.convertValue(person, JsonStructure.class); final JsonStructure patchedPersonJson = jsonPatch.apply(personJson); final Person patchedPerson = MAPPER.convertValue(patchedPersonJson, Person.class); - assertThat(patchedPerson, is(new Person("Json", "Smith"))); + assertThat(patchedPerson).isEqualTo(new Person("Json", "Smith")); } + @Test public void testObjectDeserializationAndPatching() { final String json = "{" + "\"op\":\"replace\"," + @@ -62,16 +63,17 @@ public void testObjectDeserializationAndPatching() { "}"; final InvalidFormatException ex = assertThrows(InvalidFormatException.class, - () -> MAPPER.readValue(json, JsonPatch.class)); - assertThat(ex.getMessage(), containsString(EXPECTED_MESSAGE)); + () -> MAPPER.readValue(json, JsonPatch.class)); + assertThat(ex.getMessage()).contains(EXPECTED_MESSAGE); } + @Test public void testScalarDeserializationAndPatching() { final String json = "\"op\""; final InvalidFormatException ex = assertThrows(InvalidFormatException.class, - () -> MAPPER.readValue(json, JsonPatch.class)); - assertThat(ex.getMessage(), containsString(EXPECTED_MESSAGE)); + () -> MAPPER.readValue(json, JsonPatch.class)); + assertThat(ex.getMessage()).contains(EXPECTED_MESSAGE); } static class Person { diff --git a/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/JsonPatchSerializationTest.java b/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/JsonPatchSerializationTest.java index 34b2c29f..3024c6fb 100644 --- a/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/JsonPatchSerializationTest.java +++ b/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/JsonPatchSerializationTest.java @@ -2,12 +2,17 @@ import javax.json.JsonPatch; +import org.junit.jupiter.api.Test; + import com.fasterxml.jackson.databind.ObjectMapper; +import static org.junit.jupiter.api.Assertions.*; + public class JsonPatchSerializationTest extends TestBase { private static final ObjectMapper MAPPER = newMapper(); + @Test public void testSimpleSerialization() throws Exception { // First need a patch so deserialization must work diff --git a/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/JsonValueDeserializationTest.java b/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/JsonValueDeserializationTest.java index db00856f..938de822 100644 --- a/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/JsonValueDeserializationTest.java +++ b/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/JsonValueDeserializationTest.java @@ -3,12 +3,16 @@ import javax.json.*; import javax.json.JsonValue.ValueType; +import org.junit.jupiter.api.Test; + import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.node.ObjectNode; import java.beans.ConstructorProperties; import java.math.BigDecimal; +import static org.junit.jupiter.api.Assertions.*; + public class JsonValueDeserializationTest extends TestBase { // for [datatype-jsr353#19] @@ -25,6 +29,7 @@ public ObjectImpl(JsonValue obj1, JsonValue obj2) { private final ObjectMapper MAPPER = newMapper(); + @Test public void testSimpleArray() throws Exception { final String JSON = "[1,true,\"foo\"]"; @@ -44,6 +49,7 @@ public void testSimpleArray() throws Exception assertEquals(JSON, serializeAsString(v)); } + @Test public void testNestedArray() throws Exception { final String JSON = "[1,[false,45],{\"foo\":13}]"; @@ -59,6 +65,7 @@ public void testNestedArray() throws Exception assertEquals(JSON, serializeAsString(v)); } + @Test public void testSimpleObject() throws Exception { final String JSON = "{\"a\":12.5,\"b\":\"Text\"}"; @@ -80,6 +87,7 @@ public void testSimpleObject() throws Exception assertEquals(JSON, serializeAsString(v)); } + @Test public void testNestedObject() throws Exception { final String JSON = "{\"array\":[1,2],\"obj\":{\"first\":true}}"; @@ -102,6 +110,7 @@ public void testNestedObject() throws Exception } // for [datatype-jsr353#5] + @Test public void testBinaryNode() throws Exception { ObjectNode root = MAPPER.createObjectNode(); @@ -117,6 +126,7 @@ public void testBinaryNode() throws Exception } // for [datatype-jsr353#16] + @Test public void testNullNode() throws Exception { final String serializedNull = MAPPER.writeValueAsString(JsonValue.NULL); @@ -126,6 +136,7 @@ public void testNullNode() throws Exception } // for [datatype-jsr353#19] + @Test public void testConstructorProperties() throws Exception { ObjectImpl ob = MAPPER.readValue("{\"obj1\":{}}", ObjectImpl.class); @@ -137,6 +148,7 @@ public void testConstructorProperties() throws Exception assertSame(JsonValue.NULL, ob2.obj2); } + @Test public void testBigInteger() throws Exception { final String JSON = "[2e308]"; @@ -156,6 +168,7 @@ public void testBigInteger() throws Exception assertEquals("[2E+308]", serializeAsString(v)); } + @Test public void testDouble() throws Exception { JsonValue val = MAPPER.readValue("{\"val\":0.5}", JsonValue.class); diff --git a/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/JsonValueSerializationTest.java b/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/JsonValueSerializationTest.java index 0b5738d2..dacac65f 100644 --- a/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/JsonValueSerializationTest.java +++ b/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/JsonValueSerializationTest.java @@ -2,10 +2,15 @@ import java.math.BigDecimal; +import org.junit.jupiter.api.Test; + import javax.json.*; +import static org.junit.jupiter.api.Assertions.*; + public class JsonValueSerializationTest extends TestBase { + @Test public void testSimpleArray() throws Exception { JsonArray arr = arrayBuilder() @@ -17,6 +22,7 @@ public void testSimpleArray() throws Exception assertEquals("[true,null,123,15.25]", serializeAsString(arr)); } + @Test public void testNestedArray() throws Exception { JsonArray arr = arrayBuilder() @@ -27,6 +33,7 @@ public void testNestedArray() throws Exception assertEquals("[1,[false,45],{\"foo\":13}]", serializeAsString(arr)); } + @Test public void testSimpleObject() throws Exception { JsonObject ob = objectBuilder() @@ -37,6 +44,7 @@ public void testSimpleObject() throws Exception assertEquals("{\"a\":123,\"b\":\"Text\"}", serializeAsString(ob)); } + @Test public void testNestedObject() throws Exception { JsonObject ob = objectBuilder() diff --git a/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/PolymorphicTest.java b/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/PolymorphicTest.java index e654743f..b3ed24d3 100644 --- a/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/PolymorphicTest.java +++ b/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/PolymorphicTest.java @@ -2,9 +2,13 @@ import javax.json.*; +import org.junit.jupiter.api.Test; + import com.fasterxml.jackson.annotation.JsonTypeInfo; import com.fasterxml.jackson.databind.ObjectMapper; +import static org.junit.jupiter.api.Assertions.*; + public class PolymorphicTest extends TestBase { static class Wrapper { @@ -17,6 +21,7 @@ public Wrapper() { } private final ObjectMapper MAPPER = newMapper(); + @Test public void testObjectAsTyped() throws Exception { final String INPUT = "{\"array\":[1,2],\"obj\":{\"first\":true}}"; @@ -34,6 +39,7 @@ public void testObjectAsTyped() throws Exception assertEquals(1, arr.getInt(0)); } + @Test public void testArrayAsTyped() throws Exception { final String INPUT = "[1,{\"a\":true}]"; diff --git a/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/TestBase.java b/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/TestBase.java index 7163eca7..6a2f44c6 100644 --- a/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/TestBase.java +++ b/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/TestBase.java @@ -10,7 +10,7 @@ import com.fasterxml.jackson.databind.json.JsonMapper; import com.fasterxml.jackson.databind.jsontype.PolymorphicTypeValidator; -public abstract class TestBase extends junit.framework.TestCase +public abstract class TestBase { static class NoCheckSubTypeValidator extends PolymorphicTypeValidator.Base diff --git a/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/TestVersions.java b/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/TestVersions.java index b6f9cd82..63c5af8e 100644 --- a/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/TestVersions.java +++ b/jsr-353/src/test/java/com/fasterxml/jackson/datatype/jsr353/TestVersions.java @@ -5,8 +5,13 @@ import com.fasterxml.jackson.core.Version; import com.fasterxml.jackson.core.Versioned; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + public class TestVersions extends TestBase { + @Test public void testModuleVersionAndName() throws IOException { JSR353Module module = new JSR353Module(); diff --git a/pom.xml b/pom.xml index 3df30cf0..06718a9f 100644 --- a/pom.xml +++ b/pom.xml @@ -52,12 +52,23 @@ jackson-databind - + - junit - junit + org.junit.jupiter + junit-jupiter test + + org.junit.jupiter + junit-jupiter-api + test + + + org.assertj + assertj-core + test + +