Small test improvement

Author: Daeda88

firebase-common/src/commonMain/kotlin/dev/gitlive/firebase/Polymorphic.kt

@@ -16,7 +16,7 @@ internal fun <T> FirebaseEncoder.encodePolymorphically(
     value: T,
     ifPolymorphic: (String) -> Unit
 ) {
-    // If serializer is not an AbstractPolymorphicSerializer or if we are encoding this as a list, we can just use the regular serializer
+    // If serializer is not an AbstractPolymorphicSerializer we can just use the regular serializer
     // This will result in calling structureEncoder for complicated structures
     // For PolymorphicKind this will first encode the polymorphic discriminator as a String and the remaining StructureKind.Class as a map of key-value pairs
     // This will result in a list structured like: (type, { classKey = classValue })
@@ -25,7 +25,6 @@ internal fun <T> FirebaseEncoder.encodePolymorphically(
         return
     }
 
-    // When doing Polymorphic Serialization with EncodeDecodeSettings.PolymorphicStructure.MAP we will use the polymorphic serializer of the class.
     val casted = serializer as AbstractPolymorphicSerializer<Any>
     val baseClassDiscriminator = serializer.descriptor.classDiscriminator()
     val actualSerializer = casted.findPolymorphicSerializer(this, value as Any)
@@ -38,7 +37,7 @@ internal fun <T> FirebaseDecoder.decodeSerializableValuePolymorphic(
     value: Any?,
     deserializer: DeserializationStrategy<T>,
 ): T {
-    // If deserializer is not an AbstractPolymorphicSerializer or if we are decoding this from a list, we can just use the regular serializer
+    // If deserializer is not an AbstractPolymorphicSerializer we can just use the regular serializer
     if (deserializer !is AbstractPolymorphicSerializer<*>) {
         return deserializer.deserialize(this)
     }

firebase-common/src/commonMain/kotlin/dev/gitlive/firebase/decoders.kt

@@ -87,11 +87,7 @@ class FirebaseClassDecoder(
     override fun decodeElementIndex(descriptor: SerialDescriptor): Int {
         return (index until descriptor.elementsCount)
             .firstOrNull {
-                !descriptor.isElementOptional(it) || containsKey(
-                    descriptor.getElementName(
-                        it
-                    )
-                )
+                !descriptor.isElementOptional(it) || containsKey(descriptor.getElementName(it))
             }
             ?.also { index = it + 1 }
             ?: DECODE_DONE

firebase-common/src/commonTest/kotlin/dev/gitlive/firebase/EncodersTest.kt

@@ -58,6 +58,7 @@ data class ImplementedClass(override val value: String, val otherValue: Boolean)
 
 @Serializable
 data class NestedClass(
+    val testData: TestData,
     val sealed: SealedClass,
     val abstract: AbstractClass,
     val sealedList: List<SealedClass>,
@@ -185,18 +186,21 @@ class EncodersTest {
             }
         }
 
+        val testData = TestData(mapOf("key" to "value"), mapOf(1 to 1), true, null, ValueClass(42))
         val sealedClass: SealedClass = SealedClass.Test("value")
         val abstractClass: AbstractClass = ImplementedClass("value", true)
-        val nestedClass = NestedClass(sealedClass, abstractClass, listOf(sealedClass), listOf(abstractClass), mapOf(sealedClass to sealedClass), mapOf(abstractClass to abstractClass))
+        val nestedClass = NestedClass(testData, sealedClass, abstractClass, listOf(sealedClass), listOf(abstractClass), mapOf(sealedClass to sealedClass), mapOf(abstractClass to abstractClass))
         val encoded = encode(NestedClass.serializer(), nestedClass) {
             encodeDefaults = true
             serializersModule = module
         }
 
+        val testDataEncoded = nativeMapOf("map" to nativeMapOf("key" to "value"), "otherMap" to nativeMapOf(1 to 1), "bool" to true, "nullableBool" to null, "valueClass" to 42)
         val sealedEncoded = nativeMapOf("type" to "test", "value" to "value")
         val abstractEncoded = nativeMapOf("type" to "implemented", "value" to "value", "otherValue" to true)
         nativeAssertEquals(
             nativeMapOf(
+                "testData" to testDataEncoded,
                 "sealed" to sealedEncoded,
                 "abstract" to abstractEncoded,
                 "sealedList" to nativeListOf(sealedEncoded),
@@ -337,9 +341,10 @@ class EncodersTest {
             }
         }
 
+        val testData = TestData(mapOf("key" to "value"), mapOf(1 to 1), true, null, ValueClass(42))
         val sealedClass: SealedClass = SealedClass.Test("value")
         val abstractClass: AbstractClass = ImplementedClass("value", true)
-        val nestedClass = NestedClass(sealedClass, abstractClass, listOf(sealedClass), listOf(abstractClass), mapOf(sealedClass to sealedClass), mapOf(abstractClass to abstractClass))
+        val nestedClass = NestedClass(testData, sealedClass, abstractClass, listOf(sealedClass), listOf(abstractClass), mapOf(sealedClass to sealedClass), mapOf(abstractClass to abstractClass))
         val encoded = encode(NestedClass.serializer(), nestedClass) {
             encodeDefaults = true
             serializersModule = module
@@ -353,10 +358,12 @@ class EncodersTest {
             it.copy(sealed = SealedClass.Test("newValue"))
         }
 
+        val testDataEncoded = nativeMapOf("map" to nativeMapOf("key" to "value"), "otherMap" to nativeMapOf(1 to 1), "bool" to true, "nullableBool" to null, "valueClass" to 42)
         val sealedEncoded = nativeMapOf("type" to "test", "value" to "value")
         val abstractEncoded = nativeMapOf("type" to "implemented", "value" to "value", "otherValue" to true)
         nativeAssertEquals(
             nativeMapOf(
+                "testData" to testDataEncoded,
                 "sealed" to nativeMapOf("type" to "test", "value" to "newValue"),
                 "abstract" to abstractEncoded,
                 "sealedList" to nativeListOf(sealedEncoded),