• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright 2017-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
3  */
4 
5 package kotlinx.serialization
6 
7 import kotlinx.serialization.descriptors.*
8 import kotlinx.serialization.encoding.*
9 import kotlinx.serialization.modules.*
10 import org.junit.Test
11 import kotlin.test.*
12 
13 class SerializationMethodInvocationOrderTest {
14 
15     @Serializable
16     @SerialName("kotlinx.serialization.Container")
17     data class Container(val data: Data)
18 
19     @Test
testRecnull20     fun testRec() {
21         val out = Out()
22         out.encodeSerializableValue(serializer(), Container(Data("s1", 42)))
23         out.done()
24 
25         val inp = Inp()
26         inp.decodeSerializableValue(serializer<Container>())
27         inp.done()
28     }
29 
30     companion object {
checkContainerDescnull31         fun checkContainerDesc(desc: SerialDescriptor) {
32             if (desc.serialName != "kotlinx.serialization.Container") fail("checkContainerDesc name $desc")
33             if (desc.getElementName(0) != "data") fail("checkContainerDesc $desc")
34         }
35 
checkDataDescnull36         fun checkDataDesc(desc: SerialDescriptor) {
37             if (desc.serialName != "kotlinx.serialization.Data") fail("checkDataDesc name $desc")
38             if (desc.getElementName(0) != "value1") fail("checkDataDesc.0 $desc")
39             if (desc.getElementName(1) != "value2") fail("checkDataDesc.1 $desc")
40         }
41     }
42 
43     class Out : AbstractEncoder() {
44         var step = 0
45 
46         override val serializersModule: SerializersModule = EmptySerializersModule()
47 
beginStructurenull48         override fun beginStructure(descriptor: SerialDescriptor): CompositeEncoder {
49             when (step) {
50                 1 -> {
51                     checkContainerDesc(descriptor); step++
52                     return this
53                 }
54                 4 -> {
55                     checkDataDesc(descriptor); step++
56                     return this
57                 }
58             }
59             fail("@$step: beginStructure($descriptor)")
60         }
61 
encodeElementnull62         override fun encodeElement(descriptor: SerialDescriptor, index: Int): Boolean {
63             when (step) {
64                 2 -> {
65                     checkContainerDesc(descriptor); if (index == 0) {
66                         step++
67                         return true
68                     }
69                 }
70                 5 -> {
71                     checkDataDesc(descriptor); if (index == 0) {
72                         step++
73                         return true
74                     }
75                 }
76                 7 -> {
77                     checkDataDesc(descriptor); if (index == 1) {
78                         step++
79                         return true
80                     }
81                 }
82             }
83             fail("@$step: encodeElement($descriptor, $index)")
84         }
85 
encodeSerializableValuenull86         override fun <T : Any?> encodeSerializableValue(serializer: SerializationStrategy<T>, value: T) {
87             when (step) {
88                 0, 3 -> {
89                     step++; serializer.serialize(this, value)
90                     return
91                 }
92             }
93             fail("@$step: encodeSerializableValue($value)")
94         }
95 
encodeStringnull96         override fun encodeString(value: String) {
97             when (step) {
98                 6 -> if (value == "s1") {
99                     step++
100                     return
101                 }
102             }
103             fail("@$step: encodeString($value)")
104         }
105 
encodeIntnull106         override fun encodeInt(value: Int) {
107             when (step) {
108                 8 -> if (value == 42) {
109                     step++
110                     return
111                 }
112             }
113             fail("@$step: decodeInt($value)")
114         }
115 
endStructurenull116         override fun endStructure(descriptor: SerialDescriptor) {
117             when (step) {
118                 9 -> {
119                     checkDataDesc(descriptor); step++
120                     return
121                 }
122                 10 -> {
123                     checkContainerDesc(descriptor); step++
124                     return
125                 }
126             }
127             fail("@$step: endStructure($descriptor)")
128         }
129 
donenull130         fun done() {
131             if (step != 11) fail("@$step: OUT FAIL")
132         }
133     }
134 
135     class Inp : AbstractDecoder() {
136         var step = 0
137 
138         override val serializersModule: SerializersModule = EmptySerializersModule()
139 
beginStructurenull140         override fun beginStructure(descriptor: SerialDescriptor): CompositeDecoder {
141             when (step) {
142                 1 -> {
143                     checkContainerDesc(descriptor); step++
144                     return this
145                 }
146                 4 -> {
147                     checkDataDesc(descriptor); step++
148                     return this
149                 }
150             }
151             fail("@$step: beginStructure($descriptor)")
152         }
153 
decodeElementIndexnull154         override fun decodeElementIndex(descriptor: SerialDescriptor): Int {
155             when (step) {
156                 2 -> {
157                     checkContainerDesc(descriptor); step++
158                     return 0
159                 }
160                 5 -> {
161                     checkDataDesc(descriptor); step++
162                     return 0
163                 }
164                 7 -> {
165                     checkDataDesc(descriptor); step++
166                     return 1
167                 }
168                 9 -> {
169                     checkDataDesc(descriptor); step++
170                     return -1
171                 }
172                 11 -> {
173                     checkContainerDesc(descriptor); step++
174                     return -1
175                 }
176             }
177             fail("@$step: decodeElementIndex($descriptor)")
178         }
179 
decodeSerializableValuenull180         override fun <T : Any?> decodeSerializableValue(deserializer: DeserializationStrategy<T>): T {
181             when (step) {
182                 0, 3 -> {
183                     step++
184                     return deserializer.deserialize(this)
185                 }
186             }
187             fail("@$step: decodeSerializableValue()")
188         }
189 
decodeStringnull190         override fun decodeString(): String {
191             when (step) {
192                 6 -> {
193                     step++
194                     return "s1"
195                 }
196             }
197             fail("@$step: decodeString()")
198         }
199 
decodeIntnull200         override fun decodeInt(): Int {
201             when (step) {
202                 8 -> {
203                     step++
204                     return 42
205                 }
206             }
207             fail("@$step: decodeInt()")
208         }
209 
endStructurenull210         override fun endStructure(descriptor: SerialDescriptor) {
211             when (step) {
212                 10 -> {
213                     checkDataDesc(descriptor); step++
214                     return
215                 }
216                 12 -> {
217                     checkContainerDesc(descriptor); step++
218                     return
219                 }
220             }
221             fail("@$step: endStructure($descriptor)")
222         }
223 
donenull224         fun done() {
225             if (step != 13) fail("@$step: INP FAIL")
226         }
227     }
228 }
229