1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
package kotlinx.serialization.json
import kotlinx.serialization.*
import kotlin.test.*
/*
* Actual testing should be performed in subclasses.
* Subclasses implement serialization and deserialization for different types: serial Kotlin classes, JsonElement, dynamic etc
*/
@Ignore
abstract class AbstractJsonImplicitNullsTest {
@Serializable
data class Nullable(
val f0: Int?,
val f1: Int?,
val f2: Int?,
val f3: Int?,
)
@Serializable
data class WithNotNull(
val f0: Int?,
val f1: Int?,
val f2: Int,
)
@Serializable
data class WithOptional(
val f0: Int?,
val f1: Int? = 1,
val f2: Int = 2,
)
@Serializable
data class Outer(val i: Inner)
@Serializable
data class Inner(val s1: String?, val s2: String?)
@Serializable
data class ListWithNullable(val l: List<Int?>)
@Serializable
data class MapWithNullable(val m: Map<Int?, Int?>)
@Serializable
data class NullableList(val l: List<Int>?)
@Serializable
data class NullableMap(val m: Map<Int, Int>?)
private val format = Json { explicitNulls = false }
protected abstract fun <T> Json.encode(value: T, serializer: KSerializer<T>): String
protected abstract fun <T> Json.decode(json: String, serializer: KSerializer<T>): T
@Test
fun testExplicit() {
val plain = Nullable(null, 10, null, null)
val json = """{"f0":null,"f1":10,"f2":null,"f3":null}"""
assertEquals(json, Json.encode(plain, Nullable.serializer()))
assertEquals(plain, Json.decode(json, Nullable.serializer()))
}
@Test
fun testNullable() {
val plain = Nullable(null, 10, null, null)
val json = """{"f1":10}"""
assertEquals(json, format.encode(plain, Nullable.serializer()))
assertEquals(plain, format.decode(json, Nullable.serializer()))
}
@Test
fun testMissingNotNull() {
val json = """{"f1":10}"""
assertFailsWith(SerializationException::class) {
format.decode(json, WithNotNull.serializer())
}
}
@Test
fun testDecodeOptional() {
val json = """{}"""
val decoded = format.decode(json, WithOptional.serializer())
assertEquals(WithOptional(null), decoded)
}
@Test
fun testNestedJsonObject() {
val json = """{"i": {}}"""
val decoded = format.decode(json, Outer.serializer())
assertEquals(Outer(Inner(null, null)), decoded)
}
@Test
fun testListWithNullable() {
val jsonWithNull = """{"l":[null]}"""
val jsonWithEmptyList = """{"l":[]}"""
val encoded = format.encode(ListWithNullable(listOf(null)), ListWithNullable.serializer())
assertEquals(jsonWithNull, encoded)
val decoded = format.decode(jsonWithEmptyList, ListWithNullable.serializer())
assertEquals(ListWithNullable(emptyList()), decoded)
}
@Test
fun testMapWithNullable() {
val jsonWithNull = """{"m":{null:null}}"""
val jsonWithQuotedNull = """{"m":{"null":null}}"""
val jsonWithEmptyList = """{"m":{}}"""
val encoded = format.encode(MapWithNullable(mapOf(null to null)), MapWithNullable.serializer())
//Json encode map null key as `null:` but other external utilities may encode it as a String `"null":`
assertTrue { listOf(jsonWithNull, jsonWithQuotedNull).contains(encoded) }
val decoded = format.decode(jsonWithEmptyList, MapWithNullable.serializer())
assertEquals(MapWithNullable(emptyMap()), decoded)
}
@Test
fun testNullableList() {
val json = """{}"""
val encoded = format.encode(NullableList(null), NullableList.serializer())
assertEquals(json, encoded)
val decoded = format.decode(json, NullableList.serializer())
assertEquals(NullableList(null), decoded)
}
@Test
fun testNullableMap() {
val json = """{}"""
val encoded = format.encode(NullableMap(null), NullableMap.serializer())
assertEquals(json, encoded)
val decoded = format.decode(json, NullableMap.serializer())
assertEquals(NullableMap(null), decoded)
}
}
|
