tests

docs/formats.md

@@ -18,7 +18,6 @@ stable, these are currently experimental features of Kotlin Serialization.
   * [Integer types](#integer-types)
   * [Lists as repeated fields](#lists-as-repeated-fields)
   * [Packed fields](#packed-fields)
-  * [ProtoBuf schema generator (experimental)](#protobuf-schema-generator-experimental)
 * [Properties (experimental)](#properties-experimental)
 * [Custom formats (experimental)](#custom-formats-experimental)
   * [Basic encoder](#basic-encoder)

docs/serialization-guide.md

@@ -115,7 +115,7 @@ Once the project is set up, we can start serializing some classes.
   * <a name='explicit-nulls'></a>[Explicit nulls](json.md#explicit-nulls)
   * <a name='allowing-structured-map-keys'></a>[Allowing structured map keys](json.md#allowing-structured-map-keys)
   * <a name='allowing-special-floating-point-values'></a>[Allowing special floating-point values](json.md#allowing-special-floating-point-values)
-  * <a name='class-discriminator'></a>[Class discriminator](json.md#class-discriminator)
+  * <a name='class-discriminator-for-polymorphism'></a>[Class discriminator for polymorphism](json.md#class-discriminator-for-polymorphism)
 * <a name='json-elements'></a>[Json elements](json.md#json-elements)
   * <a name='parsing-to-json-element'></a>[Parsing to Json element](json.md#parsing-to-json-element)
   * <a name='types-of-json-elements'></a>[Types of Json elements](json.md#types-of-json-elements)
@@ -140,6 +140,7 @@ Once the project is set up, we can start serializing some classes.
   * <a name='field-numbers'></a>[Field numbers](formats.md#field-numbers)
   * <a name='integer-types'></a>[Integer types](formats.md#integer-types)
   * <a name='lists-as-repeated-fields'></a>[Lists as repeated fields](formats.md#lists-as-repeated-fields)
+  * <a name='packed-fields'></a>[Packed fields](formats.md#packed-fields)
 * <a name='properties-experimental'></a>[Properties (experimental)](formats.md#properties-experimental)
 * <a name='custom-formats-experimental'></a>[Custom formats (experimental)](formats.md#custom-formats-experimental)
   * <a name='basic-encoder'></a>[Basic encoder](formats.md#basic-encoder)

formats/json-tests/build.gradle.kts

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2017-2022 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+import Java9Modularity.configureJava9ModuleInfo
+
+plugins {
+    kotlin("multiplatform")
+    kotlin("plugin.serialization")
+}
+//
+apply(from = rootProject.file("gradle/native-targets.gradle"))
+apply(from = rootProject.file("gradle/configure-source-sets.gradle"))
+
+// disable kover tasks because there are no non-test classes in the project
+tasks.koverHtmlReport {
+    enabled = false
+}
+tasks.koverXmlReport {
+    enabled = false
+}
+tasks.koverVerify {
+    enabled = false
+}
+
+kotlin {
+    sourceSets {
+        val commonTest by getting {
+            dependencies {
+                api(project(":kotlinx-serialization-json"))
+                api(project(":kotlinx-serialization-json-okio"))
+                implementation("com.squareup.okio:okio:3.1.0")
+            }
+        }
+
+        val jvmTest by getting {
+            dependencies {
+                implementation("com.google.code.gson:gson:2.8.5")
+                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:${property("coroutines_version")}")
+            }
+        }
+    }
+}
+
+tasks.withType<SourceTask> {
+    if (this.name == "compileTestKotlinJsLegacy") {
+        this.exclude("**/PropertyInitializerTest.kt")
+    }
+}
+
+project.configureJava9ModuleInfo()

formats/json/commonTest/src/kotlinx/serialization/NotNullSerializersCompatibilityOnFileTest.kt → formats/json-tests/commonTest/src/kotlinx/serialization/NotNullSerializersCompatibilityOnFileTest.kt

@@ -86,7 +86,11 @@ class NotNullSerializersCompatibilityOnFileTest {
         val json = Json { serializersModule = module }
 
         assertEquals("""{"nullable":null,"nonNullable":"foo"}""", json.encodeToString(FileContextualHolder(null, FileContextualType("foo"))))
-        assertEquals("""{"nullable":"foo","nonNullable":"bar"}""", json.encodeToString(FileContextualHolder(FileContextualType("foo"), FileContextualType("bar"))))
+        assertEquals("""{"nullable":"foo","nonNullable":"bar"}""", json.encodeToString(
+            FileContextualHolder(
+                FileContextualType("foo"), FileContextualType("bar")
+            )
+        ))
 
         assertEquals(FileContextualHolder(null, FileContextualType("foo")), json.decodeFromString("""{"nullable":null,"nonNullable":"foo"}"""))
         assertEquals(FileContextualHolder(FileContextualType("foo"), FileContextualType("bar")), json.decodeFromString("""{"nullable":"foo","nonNullable":"bar"}"""))

formats/json/commonTest/src/kotlinx/serialization/features/CollectionSerializerTest.kt → formats/json-tests/commonTest/src/kotlinx/serialization/features/CollectionSerializerTest.kt

@@ -5,9 +5,7 @@
 package kotlinx.serialization.features
 
 import kotlinx.serialization.*
-import kotlinx.serialization.builtins.*
 import kotlinx.serialization.json.Json
-import kotlinx.serialization.test.*
 import kotlin.test.*
 
 class CollectionSerializerTest {

formats/json/commonTest/src/kotlinx/serialization/features/ContextAndPolymorphicTest.kt → formats/json-tests/commonTest/src/kotlinx/serialization/features/ContextAndPolymorphicTest.kt

@@ -69,7 +69,8 @@ class ContextAndPolymorphicTest {
 
     @Test
     fun testReadCustom() {
-        val s = json.decodeFromString(EnhancedData.serializer(),
+        val s = json.decodeFromString(
+            EnhancedData.serializer(),
             """{"data":{"a":100500,"b":42},"stringPayload":{"s":"string"},"binaryPayload":"62696E617279"}""")
         assertEquals(value, s)
     }

formats/json/commonTest/src/kotlinx/serialization/features/GenericCustomSerializerTest.kt → formats/json-tests/commonTest/src/kotlinx/serialization/features/GenericCustomSerializerTest.kt

@@ -99,7 +99,7 @@ class GenericCustomSerializerTest {
     fun testContextualGeneric() {
         val module = SerializersModule {
             @Suppress("UNCHECKED_CAST")
-            contextual(CheckedData::class) { args -> CheckedDataSerializer(args[0] as KSerializer<Any>)}
+            contextual(CheckedData::class) { args -> CheckedDataSerializer(args[0] as KSerializer<Any>) }
         }
         assertStringFormAndRestored(
             """{"data":{"data":"my data","checkSum":"2A20"}}""",

formats/json/commonTest/src/kotlinx/serialization/features/PolymorphismWithAnyTest.kt → formats/json-tests/commonTest/src/kotlinx/serialization/features/PolymorphismWithAnyTest.kt

@@ -9,7 +9,6 @@ import kotlinx.serialization.json.Json
 import kotlinx.serialization.modules.*
 import kotlinx.serialization.modules.plus
 import kotlinx.serialization.test.assertStringFormAndRestored
-import kotlinx.serialization.test.isJs
 import kotlin.test.*
 
 class PolymorphismWithAnyTest {

formats/json/commonTest/src/kotlinx/serialization/features/SealedClassesSerializationTest.kt → formats/json-tests/commonTest/src/kotlinx/serialization/features/SealedClassesSerializationTest.kt

@@ -11,7 +11,6 @@ import kotlinx.serialization.features.sealed.SealedParent
 import kotlinx.serialization.internal.*
 import kotlinx.serialization.json.*
 import kotlinx.serialization.modules.*
-import kotlinx.serialization.test.*
 import kotlin.test.*
 
 class SealedClassesSerializationTest : JsonTestBase() {

formats/json/commonTest/src/kotlinx/serialization/json/JsonCoerceInputValuesTest.kt → formats/json-tests/commonTest/src/kotlinx/serialization/json/JsonCoerceInputValuesTest.kt

@@ -6,6 +6,7 @@ package kotlinx.serialization.json
 
 import kotlinx.serialization.*
 import kotlinx.serialization.json.internal.*
+import kotlinx.serialization.test.assertFailsWithSerial
 import kotlin.test.*
 
 class JsonCoerceInputValuesTest : JsonTestBase() {
@@ -60,10 +61,10 @@ class JsonCoerceInputValuesTest : JsonTestBase() {
             WithEnum(),
             WithEnum.serializer()
         )
-        assertFailsWith<JsonDecodingException> {
+        assertFailsWithSerial("JsonDecodingException") {
             json.decodeFromString(WithEnum.serializer(), """{"e":{"x":"definitely not a valid enum value"}}""")
         }
-        assertFailsWith<JsonDecodingException> { // test user still sees exception on missing quotes
+        assertFailsWithSerial("JsonDecodingException") { // test user still sees exception on missing quotes
             Json(json) { isLenient = false }.decodeFromString(WithEnum.serializer(), """{"e":unknown_value}""")
         }
     }

formats/json/commonTest/src/kotlinx/serialization/json/JsonCustomSerializersTest.kt → formats/json-tests/commonTest/src/kotlinx/serialization/json/JsonCustomSerializersTest.kt

@@ -199,7 +199,7 @@ class JsonCustomSerializersTest : JsonTestBase() {
     fun testReadListOfOptional() = parametrizedTest { jsonTestingMode ->
         val obj = listOf(C(a = 1), C(b = 2), C(3, 4))
         val j = """[{"b":42,"a":1},{"b":2},{"b":4,"a":3}]"""
-        val s = jsonNoAltNames.decodeFromString(ListSerializer<kotlinx.serialization.json.JsonCustomSerializersTest.C>(C), j, jsonTestingMode)
+        val s = jsonNoAltNames.decodeFromString(ListSerializer<C>(C), j, jsonTestingMode)
         assertEquals(obj, s)
     }
 

formats/json/commonTest/src/kotlinx/serialization/json/JsonMapKeysTest.kt → formats/json-tests/commonTest/src/kotlinx/serialization/json/JsonMapKeysTest.kt

@@ -8,10 +8,8 @@ import kotlinx.serialization.*
 import kotlinx.serialization.descriptors.PrimitiveKind
 import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
 import kotlinx.serialization.descriptors.SerialDescriptor
-import kotlinx.serialization.descriptors.buildSerialDescriptor
 import kotlinx.serialization.encoding.Decoder
 import kotlinx.serialization.encoding.Encoder
-import kotlinx.serialization.json.internal.*
 import kotlinx.serialization.modules.SerializersModule
 import kotlinx.serialization.test.*
 import kotlin.jvm.*
@@ -81,10 +79,9 @@ class JsonMapKeysTest : JsonTestBase() {
     }
 
     private inline fun <reified T: Any> verifyProhibition(value: T, streaming: JsonTestingMode) {
-        val e = assertFailsWith<JsonException> {
+        assertFailsWithSerialMessage("JsonEncodingException", "can't be used in JSON as a key in the map") {
             Json.encodeToString(value, streaming)
         }
-        assertTrue(e.message?.contains("can't be used in JSON as a key in the map") == true)
     }
 
     @Test
@@ -143,7 +140,7 @@ class JsonMapKeysTest : JsonTestBase() {
             WithContextualKey(mapOf(ContextualValue("fooKey") to 1)),
             """{"map":{"fooKey":1}}""",
             Json {
-                serializersModule = SerializersModule { contextual(ContextualValue::class, ContextualValue.Companion) }
+                serializersModule = SerializersModule { contextual(ContextualValue::class, ContextualValue) }
             }
         )
     }

formats/json/commonTest/src/kotlinx/serialization/json/JsonParserFailureModesTest.kt → formats/json-tests/commonTest/src/kotlinx/serialization/json/JsonParserFailureModesTest.kt

@@ -5,7 +5,6 @@
 package kotlinx.serialization.json
 
 import kotlinx.serialization.*
-import kotlinx.serialization.json.internal.*
 import kotlinx.serialization.test.*
 import kotlin.test.*
 
@@ -18,80 +17,80 @@ class JsonParserFailureModesTest : JsonTestBase() {
 
     @Test
     fun testFailureModes() = parametrizedTest {
-        assertFailsWith<JsonDecodingException> {
+        assertFailsWithSerial("JsonDecodingException") {
             default.decodeFromString(
                 Holder.serializer(),
                 """{"id": "}""",
                 it
             )
         }
-        assertFailsWith<JsonDecodingException> {
+        assertFailsWithSerial("JsonDecodingException") {
             default.decodeFromString(
                 Holder.serializer(),
                 """{"id": ""}""",
                 it
             )
         }
-        assertFailsWith<JsonDecodingException> {
+        assertFailsWithSerial("JsonDecodingException") {
             default.decodeFromString(
                 Holder.serializer(),
                 """{"id":a}""",
                 it
             )
         }
-        assertFailsWith<JsonDecodingException> {
+        assertFailsWithSerial("JsonDecodingException") {
             default.decodeFromString(
                 Holder.serializer(),
                 """{"id":2.0}""",
                 it
             )
         }
-        assertFailsWith<JsonDecodingException> {
+        assertFailsWithSerial("JsonDecodingException") {
             default.decodeFromString(
                 Holder.serializer(),
                 """{"id2":2}""",
                 it
             )
         }
         // 9223372036854775807 is Long.MAX_VALUE
-        assertFailsWith<JsonDecodingException> {
+        assertFailsWithSerial("JsonDecodingException") {
             default.decodeFromString(
                 Holder.serializer(),
                 """{"id":${Long.MAX_VALUE}""" + "00" + "}",
                 it
             )
         }
         // -9223372036854775808 is Long.MIN_VALUE
-        assertFailsWith<JsonDecodingException> {
+        assertFailsWithSerial("JsonDecodingException") {
             default.decodeFromString(
                 Holder.serializer(),
                 """{"id":9223372036854775808}""",
                 it
             )
         }
-        assertFailsWith<JsonDecodingException> { default.decodeFromString(Holder.serializer(), """{"id"}""", it) }
-        assertFailsWith<JsonDecodingException> { default.decodeFromString(Holder.serializer(), """{"id}""", it) }
-        assertFailsWith<JsonDecodingException> { default.decodeFromString(Holder.serializer(), """{"i}""", it) }
-        assertFailsWith<JsonDecodingException> { default.decodeFromString(Holder.serializer(), """{"}""", it) }
+        assertFailsWithSerial("JsonDecodingException") { default.decodeFromString(Holder.serializer(), """{"id"}""", it) }
+        assertFailsWithSerial("JsonDecodingException") { default.decodeFromString(Holder.serializer(), """{"id}""", it) }
+        assertFailsWithSerial("JsonDecodingException") { default.decodeFromString(Holder.serializer(), """{"i}""", it) }
+        assertFailsWithSerial("JsonDecodingException") { default.decodeFromString(Holder.serializer(), """{"}""", it) }
         assertFailsWithMissingField { default.decodeFromString(Holder.serializer(), """{}""", it) }
-        assertFailsWith<JsonDecodingException> { default.decodeFromString(Holder.serializer(), """{""", it) }
-        assertFailsWith<JsonDecodingException> { default.decodeFromString(Holder.serializer(), """}""", it) }
-        assertFailsWith<JsonDecodingException> { default.decodeFromString(Holder.serializer(), """{""", it) }
+        assertFailsWithSerial("JsonDecodingException") { default.decodeFromString(Holder.serializer(), """{""", it) }
+        assertFailsWithSerial("JsonDecodingException") { default.decodeFromString(Holder.serializer(), """}""", it) }
+        assertFailsWithSerial("JsonDecodingException") { default.decodeFromString(Holder.serializer(), """{""", it) }
     }
 
     @Serializable
     class BooleanHolder(val b: Boolean)
 
     @Test
     fun testBoolean() = parametrizedTest {
-        assertFailsWith<JsonDecodingException> {
+        assertFailsWithSerial("JsonDecodingException") {
             default.decodeFromString(
                 BooleanHolder.serializer(),
                 """{"b": fals}""",
                 it
             )
         }
-        assertFailsWith<JsonDecodingException> {
+        assertFailsWithSerial("JsonDecodingException") {
             default.decodeFromString(
                 BooleanHolder.serializer(),
                 """{"b": 123}""",
@@ -108,11 +107,11 @@ class JsonParserFailureModesTest : JsonTestBase() {
     @Test
     fun testOverflow() = parametrizedTest {
         // Byte overflow
-        assertFailsWith<JsonDecodingException> { default.decodeFromString<PrimitiveHolder>("""{"b": 128}""", it) }
+        assertFailsWithSerial("JsonDecodingException") { default.decodeFromString<PrimitiveHolder>("""{"b": 128}""", it) }
         // Short overflow
-        assertFailsWith<JsonDecodingException> { default.decodeFromString<PrimitiveHolder>("""{"s": 32768}""", it) }
+        assertFailsWithSerial("JsonDecodingException") { default.decodeFromString<PrimitiveHolder>("""{"s": 32768}""", it) }
         // Int overflow
-        assertFailsWith<JsonDecodingException> {
+        assertFailsWithSerial("JsonDecodingException") {
             default.decodeFromString<PrimitiveHolder>(
                 """{"i": 2147483648}""",
                 it
@@ -134,14 +133,14 @@ class JsonParserFailureModesTest : JsonTestBase() {
 
     @Test
     fun testInvalidNumber() = parametrizedTest {
-        assertFailsWith<JsonDecodingException> { default.decodeFromString<Holder>("""{"id":-}""", it) }
-        assertFailsWith<JsonDecodingException> { default.decodeFromString<Holder>("""{"id":+}""", it) }
-        assertFailsWith<JsonDecodingException> { default.decodeFromString<Holder>("""{"id":--}""", it) }
-        assertFailsWith<JsonDecodingException> { default.decodeFromString<Holder>("""{"id":1-1}""", it) }
-        assertFailsWith<JsonDecodingException> { default.decodeFromString<Holder>("""{"id":0-1}""", it) }
-        assertFailsWith<JsonDecodingException> { default.decodeFromString<Holder>("""{"id":0-}""", it) }
-        assertFailsWith<JsonDecodingException> { default.decodeFromString<Holder>("""{"id":a}""", it) }
-        assertFailsWith<JsonDecodingException> { default.decodeFromString<Holder>("""{"id":-a}""", it) }
+        assertFailsWithSerial("JsonDecodingException") { default.decodeFromString<Holder>("""{"id":-}""", it) }
+        assertFailsWithSerial("JsonDecodingException") { default.decodeFromString<Holder>("""{"id":+}""", it) }
+        assertFailsWithSerial("JsonDecodingException") { default.decodeFromString<Holder>("""{"id":--}""", it) }
+        assertFailsWithSerial("JsonDecodingException") { default.decodeFromString<Holder>("""{"id":1-1}""", it) }
+        assertFailsWithSerial("JsonDecodingException") { default.decodeFromString<Holder>("""{"id":0-1}""", it) }
+        assertFailsWithSerial("JsonDecodingException") { default.decodeFromString<Holder>("""{"id":0-}""", it) }
+        assertFailsWithSerial("JsonDecodingException") { default.decodeFromString<Holder>("""{"id":a}""", it) }
+        assertFailsWithSerial("JsonDecodingException") { default.decodeFromString<Holder>("""{"id":-a}""", it) }
     }
 
 
@@ -153,9 +152,9 @@ class JsonParserFailureModesTest : JsonTestBase() {
 
     @Test
     fun testUnexpectedNull() = parametrizedTest {
-        assertFailsWith<JsonDecodingException> { default.decodeFromString<BooleanWrapper>("""{"b":{"b":"b"}}""", it) }
-        assertFailsWith<JsonDecodingException> { default.decodeFromString<BooleanWrapper>("""{"b":null}""", it) }
-        assertFailsWith<JsonDecodingException> { default.decodeFromString<StringWrapper>("""{"s":{"s":"s"}}""", it) }
-        assertFailsWith<JsonDecodingException> { default.decodeFromString<StringWrapper>("""{"s":null}""", it) }
+        assertFailsWithSerial("JsonDecodingException") { default.decodeFromString<BooleanWrapper>("""{"b":{"b":"b"}}""", it) }
+        assertFailsWithSerial("JsonDecodingException") { default.decodeFromString<BooleanWrapper>("""{"b":null}""", it) }
+        assertFailsWithSerial("JsonDecodingException") { default.decodeFromString<StringWrapper>("""{"s":{"s":"s"}}""", it) }
+        assertFailsWithSerial("JsonDecodingException") { default.decodeFromString<StringWrapper>("""{"s":null}""", it) }
     }
 }

formats/json/commonTest/src/kotlinx/serialization/json/JsonParserTest.kt → formats/json-tests/commonTest/src/kotlinx/serialization/json/JsonParserTest.kt

@@ -30,14 +30,14 @@ class JsonParserTest : JsonTestBase() {
 
     @Test
     fun testEmptyValue() {
-        assertFailsWith<JsonDecodingException> {
+        assertFailsWithSerial("JsonDecodingException") {
             parse("""{"X": "foo", "Y"}""")
         }
     }
 
     @Test
     fun testIncorrectUnicodeEscape() {
-        assertFailsWith<JsonDecodingException> {
+        assertFailsWithSerial("JsonDecodingException") {
             parse("""{"X": "\uDD1H"}""")
         }
     }
@@ -83,18 +83,16 @@ class JsonParserTest : JsonTestBase() {
     }
 
     private fun testTrailingComma(content: String) {
-        val e = assertFailsWith<JsonDecodingException> {  Json.parseToJsonElement(content) }
-        val msg = e.message!!
-        assertTrue(msg.contains("Unexpected trailing"))
+        assertFailsWithSerialMessage("JsonDecodingException", "Unexpected trailing") {  Json.parseToJsonElement(content) }
     }
 
     @Test
     fun testUnclosedStringLiteral() {
-        assertFailsWith<JsonDecodingException> {
+        assertFailsWithSerial("JsonDecodingException") {
             parse("\"")
         }
 
-        assertFailsWith<JsonDecodingException> {
+        assertFailsWithSerial("JsonDecodingException") {
             parse("""{"id":"""")
         }
     }