fix key tags

Author: JesusMcCloud

formats/cbor/commonMain/src/kotlinx/serialization/cbor/internal/Encoder.kt

@@ -287,7 +287,7 @@ internal class StructuredCborWriter(cbor: Cbor) : CborWriter(cbor) {
         //TODO check if cborelement and be done
         val name = descriptor.getElementName(index)
         if (!descriptor.hasArrayTag()) {
-            val keyTags = descriptor.getKeyTags(index)
+            val keyTags = if (cbor.configuration.encodeKeyTags) descriptor.getKeyTags(index) else null
 
             if ((descriptor.kind !is StructureKind.LIST) && (descriptor.kind !is StructureKind.MAP) && (descriptor.kind !is PolymorphicKind)) {
                 //indices are put into the name field. we don't want to write those, as it would result in double writes

formats/cbor/commonTest/src/kotlinx/serialization/cbor/CborTaggedTest.kt

@@ -236,7 +236,6 @@ class CborTaggedTest {
         val structFromHex = cbor.decodeFromHexString(CborElement.serializer(), referenceHexString)
         val struct = cbor.encodeToCbor(DataWithTags.serializer(), reference)
         assertEquals(struct, structFromHex)
-
         assertEquals(reference, cbor.decodeFromCbor(DataWithTags.serializer(), struct))
         assertEquals(referenceHexString, cbor.encodeToHexString(CborElement.serializer(), struct))
 
@@ -249,68 +248,99 @@ class CborTaggedTest {
             verifyValueTags = true
             verifyObjectTags = true
         }
-        assertEquals(
-            referenceHexStringDefLen,
-            cborDef.encodeToHexString(DataWithTags.serializer(), reference)
-        )
+        assertEquals(referenceHexStringDefLen, cborDef.encodeToHexString(DataWithTags.serializer(), reference))
+        val structDefFromHex = cborDef.decodeFromHexString(CborElement.serializer(), referenceHexStringDefLen)
+        val structDef = cborDef.encodeToCbor(DataWithTags.serializer(), reference)
+        assertEquals(structDef, structDefFromHex)
+        assertEquals(reference, cborDef.decodeFromCbor(DataWithTags.serializer(), structDef))
+        assertEquals(referenceHexStringDefLen, cborDef.encodeToHexString(CborElement.serializer(), structDef))
+
 
         assertEquals(reference, Cbor.CoseCompliant.decodeFromHexString(DataWithTags.serializer(), referenceHexString))
+        val structCoseFromHex = Cbor.CoseCompliant.decodeFromHexString(CborElement.serializer(), referenceHexString)
+        val structCose = Cbor.CoseCompliant.encodeToCbor(DataWithTags.serializer(), reference)
+        assertEquals(structCose, structCoseFromHex)
+        assertEquals(reference, Cbor.CoseCompliant.decodeFromCbor(DataWithTags.serializer(), structCose))
+
         assertEquals(
             reference,
             Cbor.CoseCompliant.decodeFromHexString(DataWithTags.serializer(), referenceHexStringDefLen)
         )
+        val structCoseFromHexDef =
+            Cbor.CoseCompliant.decodeFromHexString(CborElement.serializer(), referenceHexStringDefLen)
+        val structCoseDef = Cbor.CoseCompliant.encodeToCbor(DataWithTags.serializer(), reference)
+        assertEquals(structCoseDef, structCoseFromHexDef)
+        assertEquals(reference, Cbor.CoseCompliant.decodeFromCbor(DataWithTags.serializer(), structCoseDef))
 
     }
 
     @Test
     fun writeReadUntaggedKeys() {
-        assertEquals(noKeyTags, Cbor {
+        val cborNoKeyTags = Cbor {
             encodeKeyTags = false
             encodeValueTags = true
             encodeObjectTags = true
             verifyKeyTags = false
             verifyValueTags = true
             verifyObjectTags = true
-        }.encodeToHexString(DataWithTags.serializer(), reference))
-        assertEquals(
-            noKeyTagsDefLen,
-            Cbor {
-                useDefiniteLengthEncoding = true
-                encodeKeyTags = false
-                encodeValueTags = true
-                encodeObjectTags = true
-                verifyKeyTags = true
-                verifyValueTags = true
-                verifyObjectTags = true
-            }.encodeToHexString(
-                DataWithTags.serializer(),
-                reference
-            )
-        )
-        assertEquals(reference, Cbor {
-            encodeKeyTags = true
-            encodeValueTags = true
-            encodeObjectTags = true
-            verifyValueTags = true
-            verifyObjectTags = true
-            verifyKeyTags = false
-        }.decodeFromHexString(noKeyTags))
-        assertEquals(reference, Cbor {
-            encodeKeyTags = true
+        }
+        assertEquals(noKeyTags, cborNoKeyTags.encodeToHexString(DataWithTags.serializer(), reference))
+        (cborNoKeyTags to noKeyTags).let { (cbor, hex) ->
+            val struct = cbor.encodeToCbor(DataWithTags.serializer(), reference)
+            assertEquals(struct, cbor.decodeFromHexString(CborElement.serializer(), hex))
+            assertEquals(reference, cbor.decodeFromCbor(DataWithTags.serializer(), struct))
+        }
+
+        val cborNoKeyTagsDefLen = Cbor {
+            useDefiniteLengthEncoding = true
+            encodeKeyTags = false
             encodeValueTags = true
             encodeObjectTags = true
+            verifyKeyTags = true
             verifyValueTags = true
             verifyObjectTags = true
-            verifyKeyTags = false
-        }.decodeFromHexString(noKeyTagsDefLen))
-        assertEquals(reference, Cbor {
+        }
+        assertEquals(noKeyTagsDefLen, cborNoKeyTagsDefLen.encodeToHexString(DataWithTags.serializer(), reference))
+        (cborNoKeyTagsDefLen to noKeyTagsDefLen).let { (cbor, hex) ->
+            val struct = cbor.encodeToCbor(DataWithTags.serializer(), reference)
+            assertEquals(struct, cbor.decodeFromHexString(CborElement.serializer(), hex))
+            // this must fail, because encoding/decoding is not symmetric with the current config (the struct does not have the tags, but the hex string does)
+            assertFailsWith(CborDecodingException::class) {
+                assertEquals(reference, cbor.decodeFromCbor(DataWithTags.serializer(), struct))
+            }
+        }
+
+        val cborEncodingKeyTags = Cbor {
             encodeKeyTags = true
             encodeValueTags = true
             encodeObjectTags = true
             verifyValueTags = true
             verifyObjectTags = true
             verifyKeyTags = false
-        }.decodeFromHexString(referenceHexString))
+        }
+        assertEquals(reference, cborEncodingKeyTags.decodeFromHexString(noKeyTags))
+        (cborEncodingKeyTags to noKeyTags).let { (cbor, hex) ->
+            val struct = cbor.encodeToCbor(DataWithTags.serializer(), reference)
+            // this must not be equal, because the scruct has the tags, but the hex string doesn't
+            assertNotEquals(struct, cbor.decodeFromHexString(CborElement.serializer(), hex))
+            assertEquals(reference, cbor.decodeFromCbor(DataWithTags.serializer(), struct))
+        }
+
+        assertEquals(reference, cborEncodingKeyTags.decodeFromHexString(noKeyTagsDefLen))
+        (cborEncodingKeyTags to noKeyTagsDefLen).let { (cbor, hex) ->
+            val struct = cbor.encodeToCbor(DataWithTags.serializer(), reference)
+            // this must not be equals, because the scruct has the tags, but the hex string doesn't (as above)
+            assertNotEquals(struct, cbor.decodeFromHexString(CborElement.serializer(), hex))
+            assertEquals(reference, cbor.decodeFromCbor(DataWithTags.serializer(), struct))
+        }
+
+
+        assertEquals(reference, cborEncodingKeyTags.decodeFromHexString(referenceHexString))
+        (cborNoKeyTags to noKeyTags).let { (cbor, hex) ->
+            val struct = cbor.encodeToCbor(DataWithTags.serializer(), reference)
+            assertEquals(struct, cbor.decodeFromHexString(CborElement.serializer(), hex))
+            assertEquals(reference, cbor.decodeFromCbor(DataWithTags.serializer(), struct))
+        }
 
         assertFailsWith(CborDecodingException::class) {
             Cbor.CoseCompliant.decodeFromHexString(
@@ -320,14 +350,7 @@ class CborTaggedTest {
         }
 
         assertFailsWith(CborDecodingException::class) {
-            Cbor {
-                encodeKeyTags = true
-                encodeValueTags = true
-                encodeObjectTags = true
-                verifyValueTags = true
-                verifyObjectTags = true
-                verifyKeyTags = false
-            }.decodeFromHexString(DataWithTags.serializer(), noValueTags)
+            cborEncodingKeyTags.decodeFromHexString(DataWithTags.serializer(), noValueTags)
         }
     }