Migrate to JUnit5 notation

from https://github.com/ProjectMapK/jackson-module-kogera/blob/ecc766d97dc4c2bec574fba7cc6bdeacc2b07c29/src/test/kotlin/io/github/projectmapk/jackson/module/kogera/zPorted/test/ExtensionMethodsTests.kt

Author: k163377

src/test/kotlin/com/fasterxml/jackson/module/kotlin/test/ExtensionMethodsTests.kt

@@ -14,12 +14,11 @@ import com.fasterxml.jackson.module.kotlin.minusAssign
 import com.fasterxml.jackson.module.kotlin.plusAssign
 import com.fasterxml.jackson.module.kotlin.readValue
 import com.fasterxml.jackson.module.kotlin.treeToValue
-import org.hamcrest.CoreMatchers.`is`
-import org.hamcrest.CoreMatchers.equalTo
-import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.Test
 
-class TestExtensionMethods {
+private class TestExtensionMethods {
     val mapper: ObjectMapper = jacksonObjectMapper().configure(SerializationFeature.INDENT_OUTPUT, false)
 
     data class BasicPerson(val name: String, val age: Int)
@@ -33,17 +32,17 @@ class TestExtensionMethods {
 
         val expectedPerson = BasicPerson("John Smith", 30)
 
-        assertThat(inferRightSide, equalTo(expectedPerson))
-        assertThat(inferLeftSide, equalTo(expectedPerson))
-        assertThat(person, equalTo(expectedPerson))
+        assertEquals(expectedPerson, inferRightSide)
+        assertEquals(expectedPerson, inferLeftSide)
+        assertEquals(expectedPerson, person)
     }
 
     data class MyData(val a: String, val b: Int)
 
     @Test fun testStackOverflow33368328() {
         val jsonStr = """[{"a": "value1", "b": 1}, {"a": "value2", "b": 2}]"""
         val myList: List<MyData> = mapper.readValue(jsonStr)
-        assertThat(myList, equalTo(listOf(MyData("value1", 1), MyData("value2", 2))))
+        assertEquals(listOf(MyData("value1", 1), MyData("value2", 2)), myList)
     }
 
     @Test fun testOperatorFunExtensions() {
@@ -56,8 +55,8 @@ class TestExtensionMethods {
         objectNode -= "foo1"
         objectNode -= listOf("foo2")
 
-        assertThat("foo1" !in objectNode, `is`(true))
-        assertThat("foo3" in objectNode, `is`(true))
+        assertTrue("foo1" !in objectNode)
+        assertTrue("foo3" in objectNode)
 
         val arrayNode = factory.arrayNode()
         arrayNode += "foo"
@@ -66,35 +65,34 @@ class TestExtensionMethods {
         arrayNode += 1.0
         arrayNode += "bar".toByteArray()
 
-        assertThat(arrayNode.size(), `is`(5))
+        assertEquals(5, arrayNode.size())
 
         (4 downTo 0).forEach { arrayNode -= it }
-        assertThat(arrayNode.size(), `is`(0))
+        assertEquals(0, arrayNode.size())
     }
 
-    @Test fun noTypeErasure(){
+    @Test fun noTypeErasure() {
         data class Person(val name: String)
         val source = """[ { "name" : "Neo" } ]"""
         val tree = mapper.readTree(source)
 
         val readValueResult: List<Person> = mapper.readValue(source)
-        assertThat(readValueResult, `is`(listOf(Person("Neo"))))
+        assertEquals(listOf(Person("Neo")), readValueResult)
 
         val treeToValueResult: List<Person> = mapper.treeToValue(tree)
-        assertThat(treeToValueResult, `is`(listOf(Person("Neo"))))
+        assertEquals(listOf(Person("Neo")), treeToValueResult)
 
         val convertValueResult: List<Person> = mapper.convertValue(tree)
-        assertThat(convertValueResult, `is`(listOf(Person("Neo"))))
+        assertEquals(listOf(Person("Neo")), convertValueResult)
     }
 
     @Test fun mixInExtensionTest() {
-
         data class Person(val name: String)
         abstract class PersonMixIn { @JsonIgnore var name: String = "" }
 
         val mapper: JsonMapper = jsonMapper { addMixIn<Person, PersonMixIn>() }
         val serializedPerson: String = mapper.writeValueAsString(Person("test"))
 
-        assertThat(serializedPerson, `is`("{}"))
+        assertEquals("{}", serializedPerson)
     }
 }