• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Protocol Buffers - Google's data interchange format
2 // Copyright 2008 Google Inc.  All rights reserved.
3 //
4 // Use of this source code is governed by a BSD-style
5 // license that can be found in the LICENSE file or at
6 // https://developers.google.com/open-source/licenses/bsd
7 
8 package com.google.protobuf.kotlin
9 
10 import com.google.common.truth.Truth.assertThat
11 import com.google.protobuf.TestUtil
12 import com.google.protobuf.TestUtil.toBytes
13 import com.google.protobuf.test.UnittestImport.ImportEnum
14 import com.google.protobuf.test.UnittestImport.ImportMessage
15 import com.google.protobuf.test.UnittestImportPublic.PublicImportMessage
16 import protobuf_unittest.MapProto2Unittest.Proto2MapEnum
17 import protobuf_unittest.MapProto2Unittest.TestEnumMap
18 import protobuf_unittest.MapProto2Unittest.TestIntIntMap
19 import protobuf_unittest.MapProto2Unittest.TestMaps
20 import protobuf_unittest.TestAllTypesKt
21 import protobuf_unittest.TestAllTypesKt.nestedMessage
22 import protobuf_unittest.UnittestProto
23 import protobuf_unittest.UnittestProto.ForeignEnum
24 import protobuf_unittest.UnittestProto.TestAllTypes
25 import protobuf_unittest.UnittestProto.TestAllTypes.NestedEnum
26 import protobuf_unittest.UnittestProto.TestEmptyMessage
27 import protobuf_unittest.UnittestProto.TestEmptyMessageWithExtensions
28 import protobuf_unittest.copy
29 import protobuf_unittest.deprecatedMessageOrNull
30 import protobuf_unittest.foreignMessage
31 import protobuf_unittest.optionalGroupExtension
32 import protobuf_unittest.optionalNestedMessageOrNull
33 import protobuf_unittest.repeatedGroupExtension
34 import protobuf_unittest.testAllExtensions
35 import protobuf_unittest.testAllTypes
36 import protobuf_unittest.testDeprecatedFields
37 import protobuf_unittest.testEmptyMessage
38 import protobuf_unittest.testEmptyMessageWithExtensions
39 import protobuf_unittest.testEnumMap
40 import protobuf_unittest.testIntIntMap
41 import protobuf_unittest.testMaps
42 import `in`.com.google.protobuf.kotlin.generator.EvilNamesProto2
43 import `in`.com.google.protobuf.kotlin.generator.HardKeywordsAllTypesProto2
44 import `in`.com.google.protobuf.kotlin.generator.HardKeywordsAllTypesProto2Kt
45 import `in`.com.google.protobuf.kotlin.generator.Interface
46 import `in`.com.google.protobuf.kotlin.generator.evilNamesProto2
47 import `in`.com.google.protobuf.kotlin.generator.hardKeywordsAllTypesProto2
48 import `in`.com.google.protobuf.kotlin.generator.interface_
49 import org.junit.Test
50 import org.junit.runner.RunWith
51 import org.junit.runners.JUnit4
52 
53 @RunWith(JUnit4::class)
54 class Proto2Test {
55   @Test
testSettersnull56   fun testSetters() {
57     assertThat(
58         testAllTypes {
59           optionalInt32 = 101
60           optionalInt64 = 102
61           optionalUint32 = 103
62           optionalUint64 = 104
63           optionalSint32 = 105
64           optionalSint64 = 106
65           optionalFixed32 = 107
66           optionalFixed64 = 108
67           optionalSfixed32 = 109
68           optionalSfixed64 = 110
69           optionalFloat = 111.0f
70           optionalDouble = 112.0
71           optionalBool = true
72           optionalString = "115"
73           optionalBytes = toBytes("116")
74           optionalGroup = TestAllTypesKt.optionalGroup { a = 117 }
75           optionalNestedMessage = nestedMessage { bb = 118 }
76           optionalForeignMessage = foreignMessage { c = 119 }
77           optionalImportMessage = ImportMessage.newBuilder().setD(120).build()
78           optionalPublicImportMessage = PublicImportMessage.newBuilder().setE(126).build()
79           optionalLazyMessage = nestedMessage { bb = 127 }
80           optionalUnverifiedLazyMessage = nestedMessage { bb = 128 }
81           optionalNestedEnum = NestedEnum.BAZ
82           optionalForeignEnum = ForeignEnum.FOREIGN_BAZ
83           optionalImportEnum = ImportEnum.IMPORT_BAZ
84           optionalStringPiece = "124"
85           optionalCord = "125"
86           repeatedInt32.add(201)
87           repeatedInt64.add(202)
88           repeatedUint32.add(203)
89           repeatedUint64.add(204)
90           repeatedSint32.add(205)
91           repeatedSint64.add(206)
92           repeatedFixed32.add(207)
93           repeatedFixed64.add(208)
94           repeatedSfixed32.add(209)
95           repeatedSfixed64.add(210)
96           repeatedFloat.add(211f)
97           repeatedDouble.add(212.0)
98           repeatedBool.add(true)
99           repeatedString.add("215")
100           repeatedBytes.add(toBytes("216"))
101           repeatedGroup.add(TestAllTypesKt.repeatedGroup { a = 217 })
102           repeatedNestedMessage.add(nestedMessage { bb = 218 })
103           repeatedForeignMessage.add(foreignMessage { c = 219 })
104           repeatedImportMessage.add(ImportMessage.newBuilder().setD(220).build())
105           repeatedLazyMessage.add(nestedMessage { bb = 227 })
106           repeatedNestedEnum.add(NestedEnum.BAR)
107           repeatedForeignEnum.add(ForeignEnum.FOREIGN_BAR)
108           repeatedImportEnum.add(ImportEnum.IMPORT_BAR)
109           repeatedStringPiece.add("224")
110           repeatedCord.add("225")
111           repeatedInt32 += 301
112           repeatedInt64 += 302
113           repeatedUint32 += 303
114           repeatedUint64 += 304
115           repeatedSint32 += 305
116           repeatedSint64 += 306
117           repeatedFixed32 += 307
118           repeatedFixed64 += 308
119           repeatedSfixed32 += 309
120           repeatedSfixed64 += 310
121           repeatedFloat += 311f
122           repeatedDouble += 312.0
123           repeatedBool += false
124           repeatedString += "315"
125           repeatedBytes += toBytes("316")
126           repeatedGroup += TestAllTypesKt.repeatedGroup { a = 317 }
127           repeatedNestedMessage += nestedMessage { bb = 318 }
128           repeatedForeignMessage += foreignMessage { c = 319 }
129           repeatedImportMessage += ImportMessage.newBuilder().setD(320).build()
130           repeatedLazyMessage += TestAllTypesKt.nestedMessage { bb = 327 }
131           repeatedNestedEnum += NestedEnum.BAZ
132           repeatedForeignEnum += ForeignEnum.FOREIGN_BAZ
133           repeatedImportEnum += ImportEnum.IMPORT_BAZ
134           repeatedStringPiece += "324"
135           repeatedCord += "325"
136           defaultInt32 = 401
137           defaultInt64 = 402
138           defaultUint32 = 403
139           defaultUint64 = 404
140           defaultSint32 = 405
141           defaultSint64 = 406
142           defaultFixed32 = 407
143           defaultFixed64 = 408
144           defaultSfixed32 = 409
145           defaultSfixed64 = 410
146           defaultFloat = 411f
147           defaultDouble = 412.0
148           defaultBool = false
149           defaultString = "415"
150           defaultBytes = toBytes("416")
151           defaultNestedEnum = NestedEnum.FOO
152           defaultForeignEnum = ForeignEnum.FOREIGN_FOO
153           defaultImportEnum = ImportEnum.IMPORT_FOO
154           defaultStringPiece = "424"
155           defaultCord = "425"
156           oneofUint32 = 601
157           oneofNestedMessage = TestAllTypesKt.nestedMessage { bb = 602 }
158           oneofString = "603"
159           oneofBytes = toBytes("604")
160         }
161       )
162       .isEqualTo(TestUtil.getAllSetBuilder().build())
163   }
164 
165   @Suppress("CheckReturnValue")
166   @Test
testGettersnull167   fun testGetters() {
168     testAllTypes {
169       optionalInt32 = 101
170       assertThat(optionalInt32).isEqualTo(101)
171       optionalString = "115"
172       assertThat(optionalString).isEqualTo("115")
173       optionalGroup = TestAllTypesKt.optionalGroup { a = 117 }
174       assertThat(optionalGroup).isEqualTo(TestAllTypesKt.optionalGroup { a = 117 })
175       optionalNestedMessage = TestAllTypesKt.nestedMessage { bb = 118 }
176       assertThat(optionalNestedMessage).isEqualTo(TestAllTypesKt.nestedMessage { bb = 118 })
177       optionalNestedEnum = NestedEnum.BAZ
178       assertThat(optionalNestedEnum).isEqualTo(NestedEnum.BAZ)
179       defaultInt32 = 401
180       assertThat(defaultInt32).isEqualTo(401)
181       oneofUint32 = 601
182       assertThat(oneofUint32).isEqualTo(601)
183     }
184   }
185 
186   @Suppress("CheckReturnValue")
187   @Test
testDefaultGettersnull188   fun testDefaultGetters() {
189     testAllTypes {
190       assertThat(defaultInt32).isEqualTo(41)
191       assertThat(defaultString).isEqualTo("hello")
192       assertThat(defaultNestedEnum).isEqualTo(NestedEnum.BAR)
193       assertThat(defaultStringPiece).isEqualTo("abc")
194     }
195   }
196 
197   @Suppress("CheckReturnValue")
198   @Test
testRepeatedGettersAndSettersnull199   fun testRepeatedGettersAndSetters() {
200     testAllTypes {
201       repeatedInt32.addAll(listOf(1, 2))
202       assertThat(repeatedInt32).isEqualTo(listOf(1, 2))
203       repeatedInt32 += listOf(3, 4)
204       assertThat(repeatedInt32).isEqualTo(listOf(1, 2, 3, 4))
205       repeatedInt32[0] = 5
206       assertThat(repeatedInt32).isEqualTo(listOf(5, 2, 3, 4))
207 
208       repeatedString.addAll(listOf("1", "2"))
209       assertThat(repeatedString).isEqualTo(listOf("1", "2"))
210       repeatedString += listOf("3", "4")
211       assertThat(repeatedString).isEqualTo(listOf("1", "2", "3", "4"))
212       repeatedString[0] = "5"
213       assertThat(repeatedString).isEqualTo(listOf("5", "2", "3", "4"))
214 
215       repeatedGroup.addAll(
216         listOf(TestAllTypesKt.repeatedGroup { a = 1 }, TestAllTypesKt.repeatedGroup { a = 2 })
217       )
218       assertThat(repeatedGroup)
219         .isEqualTo(
220           listOf(TestAllTypesKt.repeatedGroup { a = 1 }, TestAllTypesKt.repeatedGroup { a = 2 })
221         )
222       repeatedGroup +=
223         listOf(TestAllTypesKt.repeatedGroup { a = 3 }, TestAllTypesKt.repeatedGroup { a = 4 })
224       assertThat(repeatedGroup)
225         .isEqualTo(
226           listOf(
227             TestAllTypesKt.repeatedGroup { a = 1 },
228             TestAllTypesKt.repeatedGroup { a = 2 },
229             TestAllTypesKt.repeatedGroup { a = 3 },
230             TestAllTypesKt.repeatedGroup { a = 4 },
231           )
232         )
233       repeatedGroup[0] = TestAllTypesKt.repeatedGroup { a = 5 }
234       assertThat(repeatedGroup)
235         .isEqualTo(
236           listOf(
237             TestAllTypesKt.repeatedGroup { a = 5 },
238             TestAllTypesKt.repeatedGroup { a = 2 },
239             TestAllTypesKt.repeatedGroup { a = 3 },
240             TestAllTypesKt.repeatedGroup { a = 4 },
241           )
242         )
243 
244       repeatedNestedMessage.addAll(listOf(nestedMessage { bb = 1 }, nestedMessage { bb = 2 }))
245       assertThat(repeatedNestedMessage)
246         .isEqualTo(listOf(nestedMessage { bb = 1 }, nestedMessage { bb = 2 }))
247       repeatedNestedMessage += listOf(nestedMessage { bb = 3 }, nestedMessage { bb = 4 })
248       assertThat(repeatedNestedMessage)
249         .isEqualTo(
250           listOf(
251             nestedMessage { bb = 1 },
252             nestedMessage { bb = 2 },
253             nestedMessage { bb = 3 },
254             nestedMessage { bb = 4 },
255           )
256         )
257       repeatedNestedMessage[0] = nestedMessage { bb = 5 }
258       assertThat(repeatedNestedMessage)
259         .isEqualTo(
260           listOf(
261             nestedMessage { bb = 5 },
262             nestedMessage { bb = 2 },
263             nestedMessage { bb = 3 },
264             nestedMessage { bb = 4 },
265           )
266         )
267 
268       repeatedNestedEnum.addAll(listOf(NestedEnum.FOO, NestedEnum.BAR))
269       assertThat(repeatedNestedEnum).isEqualTo(listOf(NestedEnum.FOO, NestedEnum.BAR))
270       repeatedNestedEnum += listOf(NestedEnum.BAZ, NestedEnum.FOO)
271       assertThat(repeatedNestedEnum)
272         .isEqualTo(listOf(NestedEnum.FOO, NestedEnum.BAR, NestedEnum.BAZ, NestedEnum.FOO))
273       repeatedNestedEnum[0] = NestedEnum.BAR
274       assertThat(repeatedNestedEnum)
275         .isEqualTo(listOf(NestedEnum.BAR, NestedEnum.BAR, NestedEnum.BAZ, NestedEnum.FOO))
276     }
277   }
278 
279   @Suppress("CheckReturnValue")
280   @Test
testHazzersnull281   fun testHazzers() {
282     testAllTypes {
283       optionalInt32 = 101
284       assertThat(hasOptionalInt32()).isTrue()
285       assertThat(hasOptionalString()).isFalse()
286       optionalGroup = TestAllTypesKt.optionalGroup { a = 117 }
287       assertThat(hasOptionalGroup()).isTrue()
288       assertThat(hasOptionalNestedMessage()).isFalse()
289       optionalNestedEnum = NestedEnum.BAZ
290       assertThat(hasOptionalNestedEnum()).isTrue()
291       assertThat(hasDefaultInt32()).isFalse()
292       oneofUint32 = 601
293       assertThat(hasOneofUint32()).isTrue()
294     }
295 
296     testAllTypes {
297       assertThat(hasOptionalInt32()).isFalse()
298       optionalString = "115"
299       assertThat(hasOptionalString()).isTrue()
300       assertThat(hasOptionalGroup()).isFalse()
301       optionalNestedMessage = TestAllTypesKt.nestedMessage { bb = 118 }
302       assertThat(hasOptionalNestedMessage()).isTrue()
303       assertThat(hasOptionalNestedEnum()).isFalse()
304       defaultInt32 = 401
305       assertThat(hasDefaultInt32()).isTrue()
306       assertThat(hasOneofUint32()).isFalse()
307     }
308   }
309 
310   @Suppress("CheckReturnValue")
311   @Test
testClearsnull312   fun testClears() {
313     testAllTypes {
314       optionalInt32 = 101
315       clearOptionalInt32()
316       assertThat(hasOptionalInt32()).isFalse()
317 
318       optionalString = "115"
319       clearOptionalString()
320       assertThat(hasOptionalString()).isFalse()
321 
322       optionalGroup = TestAllTypesKt.optionalGroup { a = 117 }
323       clearOptionalGroup()
324       assertThat(hasOptionalGroup()).isFalse()
325 
326       optionalNestedMessage = TestAllTypesKt.nestedMessage { bb = 118 }
327       clearOptionalNestedMessage()
328       assertThat(hasOptionalNestedMessage()).isFalse()
329 
330       optionalNestedEnum = NestedEnum.BAZ
331       clearOptionalNestedEnum()
332       assertThat(hasOptionalNestedEnum()).isFalse()
333 
334       defaultInt32 = 401
335       clearDefaultInt32()
336       assertThat(hasDefaultInt32()).isFalse()
337 
338       oneofUint32 = 601
339       clearOneofUint32()
340       assertThat(hasOneofUint32()).isFalse()
341     }
342   }
343 
344   @Test
testCopynull345   fun testCopy() {
346     val message = testAllTypes {
347       optionalInt32 = 101
348       optionalString = "115"
349     }
350     val modifiedMessage = message.copy { optionalInt32 = 201 }
351 
352     assertThat(message)
353       .isEqualTo(TestAllTypes.newBuilder().setOptionalInt32(101).setOptionalString("115").build())
354     assertThat(modifiedMessage)
355       .isEqualTo(TestAllTypes.newBuilder().setOptionalInt32(201).setOptionalString("115").build())
356   }
357 
358   @Test
testOneofnull359   fun testOneof() {
360     val message = testAllTypes {
361       oneofString = "foo"
362       assertThat(oneofFieldCase).isEqualTo(TestAllTypes.OneofFieldCase.ONEOF_STRING)
363       assertThat(oneofString).isEqualTo("foo")
364       clearOneofField()
365       assertThat(hasOneofUint32()).isFalse()
366       assertThat(oneofFieldCase).isEqualTo(TestAllTypes.OneofFieldCase.ONEOFFIELD_NOT_SET)
367       oneofUint32 = 5
368     }
369 
370     assertThat(message.getOneofFieldCase()).isEqualTo(TestAllTypes.OneofFieldCase.ONEOF_UINT32)
371     assertThat(message.getOneofUint32()).isEqualTo(5)
372   }
373 
374   @Test
testExtensionsSetnull375   fun testExtensionsSet() {
376     assertThat(
377         testAllExtensions {
378           this[UnittestProto.optionalInt32Extension] = 101
379           this[UnittestProto.optionalInt64Extension] = 102L
380           this[UnittestProto.optionalUint32Extension] = 103
381           this[UnittestProto.optionalUint64Extension] = 104L
382           this[UnittestProto.optionalSint32Extension] = 105
383           this[UnittestProto.optionalSint64Extension] = 106L
384           this[UnittestProto.optionalFixed32Extension] = 107
385           this[UnittestProto.optionalFixed64Extension] = 108L
386           this[UnittestProto.optionalSfixed32Extension] = 109
387           this[UnittestProto.optionalSfixed64Extension] = 110L
388           this[UnittestProto.optionalFloatExtension] = 111F
389           this[UnittestProto.optionalDoubleExtension] = 112.0
390           this[UnittestProto.optionalBoolExtension] = true
391           this[UnittestProto.optionalStringExtension] = "115"
392           this[UnittestProto.optionalBytesExtension] = toBytes("116")
393           this[UnittestProto.optionalGroupExtension] = optionalGroupExtension { a = 117 }
394           this[UnittestProto.optionalNestedMessageExtension] =
395             TestAllTypesKt.nestedMessage { bb = 118 }
396           this[UnittestProto.optionalForeignMessageExtension] = foreignMessage { c = 119 }
397           this[UnittestProto.optionalImportMessageExtension] =
398             ImportMessage.newBuilder().setD(120).build()
399           this[UnittestProto.optionalPublicImportMessageExtension] =
400             PublicImportMessage.newBuilder().setE(126).build()
401           this[UnittestProto.optionalLazyMessageExtension] =
402             TestAllTypesKt.nestedMessage { bb = 127 }
403           this[UnittestProto.optionalUnverifiedLazyMessageExtension] =
404             TestAllTypesKt.nestedMessage { bb = 128 }
405           this[UnittestProto.optionalNestedEnumExtension] = NestedEnum.BAZ
406           this[UnittestProto.optionalForeignEnumExtension] = ForeignEnum.FOREIGN_BAZ
407           this[UnittestProto.optionalImportEnumExtension] = ImportEnum.IMPORT_BAZ
408           this[UnittestProto.optionalStringPieceExtension] = "124"
409           this[UnittestProto.optionalCordExtension] = "125"
410           this[UnittestProto.repeatedInt32Extension].add(201)
411           this[UnittestProto.repeatedInt64Extension].add(202L)
412           this[UnittestProto.repeatedUint32Extension].add(203)
413           this[UnittestProto.repeatedUint64Extension].add(204L)
414           this[UnittestProto.repeatedSint32Extension].add(205)
415           this[UnittestProto.repeatedSint64Extension].add(206L)
416           this[UnittestProto.repeatedFixed32Extension].add(207)
417           this[UnittestProto.repeatedFixed64Extension].add(208L)
418           this[UnittestProto.repeatedSfixed32Extension].add(209)
419           this[UnittestProto.repeatedSfixed64Extension].add(210L)
420           this[UnittestProto.repeatedFloatExtension].add(211F)
421           this[UnittestProto.repeatedDoubleExtension].add(212.0)
422           this[UnittestProto.repeatedBoolExtension].add(true)
423           this[UnittestProto.repeatedStringExtension].add("215")
424           this[UnittestProto.repeatedBytesExtension].add(toBytes("216"))
425           this[UnittestProto.repeatedGroupExtension].add(repeatedGroupExtension { a = 217 })
426           this[UnittestProto.repeatedNestedMessageExtension].add(
427             TestAllTypesKt.nestedMessage { bb = 218 }
428           )
429           this[UnittestProto.repeatedForeignMessageExtension].add(foreignMessage { c = 219 })
430           this[UnittestProto.repeatedImportMessageExtension].add(
431             ImportMessage.newBuilder().setD(220).build()
432           )
433           this[UnittestProto.repeatedLazyMessageExtension].add(
434             TestAllTypesKt.nestedMessage { bb = 227 }
435           )
436           this[UnittestProto.repeatedNestedEnumExtension].add(NestedEnum.BAR)
437           this[UnittestProto.repeatedForeignEnumExtension].add(ForeignEnum.FOREIGN_BAR)
438           this[UnittestProto.repeatedImportEnumExtension].add(ImportEnum.IMPORT_BAR)
439           this[UnittestProto.repeatedStringPieceExtension].add("224")
440           this[UnittestProto.repeatedCordExtension].add("225")
441           this[UnittestProto.repeatedInt32Extension] += 301
442           this[UnittestProto.repeatedInt64Extension] += 302L
443           this[UnittestProto.repeatedUint32Extension] += 303
444           this[UnittestProto.repeatedUint64Extension] += 304L
445           this[UnittestProto.repeatedSint32Extension] += 305
446           this[UnittestProto.repeatedSint64Extension] += 306L
447           this[UnittestProto.repeatedFixed32Extension] += 307
448           this[UnittestProto.repeatedFixed64Extension] += 308L
449           this[UnittestProto.repeatedSfixed32Extension] += 309
450           this[UnittestProto.repeatedSfixed64Extension] += 310L
451           this[UnittestProto.repeatedFloatExtension] += 311F
452           this[UnittestProto.repeatedDoubleExtension] += 312.0
453           this[UnittestProto.repeatedBoolExtension] += false
454           this[UnittestProto.repeatedStringExtension] += "315"
455           this[UnittestProto.repeatedBytesExtension] += toBytes("316")
456           this[UnittestProto.repeatedGroupExtension] += repeatedGroupExtension { a = 317 }
457           this[UnittestProto.repeatedNestedMessageExtension] +=
458             TestAllTypesKt.nestedMessage { bb = 318 }
459           this[UnittestProto.repeatedForeignMessageExtension] += foreignMessage { c = 319 }
460           this[UnittestProto.repeatedImportMessageExtension] +=
461             ImportMessage.newBuilder().setD(320).build()
462           this[UnittestProto.repeatedLazyMessageExtension] +=
463             TestAllTypesKt.nestedMessage { bb = 327 }
464           this[UnittestProto.repeatedNestedEnumExtension] += NestedEnum.BAZ
465           this[UnittestProto.repeatedForeignEnumExtension] += ForeignEnum.FOREIGN_BAZ
466           this[UnittestProto.repeatedImportEnumExtension] += ImportEnum.IMPORT_BAZ
467           this[UnittestProto.repeatedStringPieceExtension] += "324"
468           this[UnittestProto.repeatedCordExtension] += "325"
469           setExtension(UnittestProto.defaultInt32Extension, 401)
470           setExtension(UnittestProto.defaultInt64Extension, 402L)
471           setExtension(UnittestProto.defaultUint32Extension, 403)
472           setExtension(UnittestProto.defaultUint64Extension, 404L)
473           setExtension(UnittestProto.defaultSint32Extension, 405)
474           setExtension(UnittestProto.defaultSint64Extension, 406L)
475           setExtension(UnittestProto.defaultFixed32Extension, 407)
476           setExtension(UnittestProto.defaultFixed64Extension, 408L)
477           setExtension(UnittestProto.defaultSfixed32Extension, 409)
478           setExtension(UnittestProto.defaultSfixed64Extension, 410L)
479           setExtension(UnittestProto.defaultFloatExtension, 411F)
480           setExtension(UnittestProto.defaultDoubleExtension, 412.0)
481           setExtension(UnittestProto.defaultBoolExtension, false)
482           setExtension(UnittestProto.defaultStringExtension, "415")
483           setExtension(UnittestProto.defaultBytesExtension, toBytes("416"))
484           setExtension(UnittestProto.defaultNestedEnumExtension, NestedEnum.FOO)
485           setExtension(UnittestProto.defaultForeignEnumExtension, ForeignEnum.FOREIGN_FOO)
486           setExtension(UnittestProto.defaultImportEnumExtension, ImportEnum.IMPORT_FOO)
487           setExtension(UnittestProto.defaultStringPieceExtension, "424")
488           setExtension(UnittestProto.defaultCordExtension, "425")
489           this[UnittestProto.oneofUint32Extension] = 601
490           this[UnittestProto.oneofNestedMessageExtension] =
491             TestAllTypesKt.nestedMessage { bb = 602 }
492           this[UnittestProto.oneofStringExtension] = "603"
493           this[UnittestProto.oneofBytesExtension] = toBytes("604")
494         }
495       )
496       .isEqualTo(TestUtil.getAllExtensionsSet())
497   }
498 
499   @Suppress("CheckReturnValue")
500   @Test
testExtensionGettersnull501   fun testExtensionGetters() {
502     testAllExtensions {
503       this[UnittestProto.optionalInt32Extension] = 101
504       assertThat(this[UnittestProto.optionalInt32Extension]).isEqualTo(101)
505       this[UnittestProto.optionalStringExtension] = "115"
506       assertThat(this[UnittestProto.optionalStringExtension]).isEqualTo("115")
507       this[UnittestProto.optionalGroupExtension] = optionalGroupExtension { a = 117 }
508       assertThat(this[UnittestProto.optionalGroupExtension])
509         .isEqualTo(optionalGroupExtension { a = 117 })
510       this[UnittestProto.optionalNestedMessageExtension] = TestAllTypesKt.nestedMessage { bb = 118 }
511       assertThat(this[UnittestProto.optionalNestedMessageExtension])
512         .isEqualTo(TestAllTypesKt.nestedMessage { bb = 118 })
513       this[UnittestProto.optionalNestedEnumExtension] = NestedEnum.BAZ
514       assertThat(this[UnittestProto.optionalNestedEnumExtension]).isEqualTo(NestedEnum.BAZ)
515       this[UnittestProto.defaultInt32Extension] = 401
516       assertThat(this[UnittestProto.defaultInt32Extension]).isEqualTo(401)
517       this[UnittestProto.oneofUint32Extension] = 601
518       assertThat(this[UnittestProto.oneofUint32Extension]).isEqualTo(601)
519     }
520   }
521 
522   @Suppress("CheckReturnValue")
523   @Test
testRepeatedExtensionGettersAndSettersnull524   fun testRepeatedExtensionGettersAndSetters() {
525     testAllExtensions {
526       this[UnittestProto.repeatedInt32Extension].addAll(listOf(1, 2))
527       assertThat(this[UnittestProto.repeatedInt32Extension]).isEqualTo(listOf(1, 2))
528       this[UnittestProto.repeatedInt32Extension] += listOf(3, 4)
529       assertThat(this[UnittestProto.repeatedInt32Extension]).isEqualTo(listOf(1, 2, 3, 4))
530       this[UnittestProto.repeatedInt32Extension][0] = 5
531       assertThat(this[UnittestProto.repeatedInt32Extension]).isEqualTo(listOf(5, 2, 3, 4))
532 
533       this[UnittestProto.repeatedStringExtension].addAll(listOf("1", "2"))
534       assertThat(this[UnittestProto.repeatedStringExtension]).isEqualTo(listOf("1", "2"))
535       this[UnittestProto.repeatedStringExtension] += listOf("3", "4")
536       assertThat(this[UnittestProto.repeatedStringExtension]).isEqualTo(listOf("1", "2", "3", "4"))
537       this[UnittestProto.repeatedStringExtension][0] = "5"
538       assertThat(this[UnittestProto.repeatedStringExtension]).isEqualTo(listOf("5", "2", "3", "4"))
539 
540       this[UnittestProto.repeatedGroupExtension].addAll(
541         listOf(repeatedGroupExtension { a = 1 }, repeatedGroupExtension { a = 2 })
542       )
543       assertThat(this[UnittestProto.repeatedGroupExtension])
544         .isEqualTo(listOf(repeatedGroupExtension { a = 1 }, repeatedGroupExtension { a = 2 }))
545       this[UnittestProto.repeatedGroupExtension] +=
546         listOf(repeatedGroupExtension { a = 3 }, repeatedGroupExtension { a = 4 })
547       assertThat(this[UnittestProto.repeatedGroupExtension])
548         .isEqualTo(
549           listOf(
550             repeatedGroupExtension { a = 1 },
551             repeatedGroupExtension { a = 2 },
552             repeatedGroupExtension { a = 3 },
553             repeatedGroupExtension { a = 4 },
554           )
555         )
556       this[UnittestProto.repeatedGroupExtension][0] = repeatedGroupExtension { a = 5 }
557       assertThat(this[UnittestProto.repeatedGroupExtension])
558         .isEqualTo(
559           listOf(
560             repeatedGroupExtension { a = 5 },
561             repeatedGroupExtension { a = 2 },
562             repeatedGroupExtension { a = 3 },
563             repeatedGroupExtension { a = 4 },
564           )
565         )
566 
567       this[UnittestProto.repeatedNestedMessageExtension].addAll(
568         listOf(nestedMessage { bb = 1 }, nestedMessage { bb = 2 })
569       )
570       assertThat(this[UnittestProto.repeatedNestedMessageExtension])
571         .isEqualTo(listOf(nestedMessage { bb = 1 }, nestedMessage { bb = 2 }))
572       this[UnittestProto.repeatedNestedMessageExtension] +=
573         listOf(nestedMessage { bb = 3 }, nestedMessage { bb = 4 })
574       assertThat(this[UnittestProto.repeatedNestedMessageExtension])
575         .isEqualTo(
576           listOf(
577             nestedMessage { bb = 1 },
578             nestedMessage { bb = 2 },
579             nestedMessage { bb = 3 },
580             nestedMessage { bb = 4 },
581           )
582         )
583       this[UnittestProto.repeatedNestedMessageExtension][0] = nestedMessage { bb = 5 }
584       assertThat(this[UnittestProto.repeatedNestedMessageExtension])
585         .isEqualTo(
586           listOf(
587             nestedMessage { bb = 5 },
588             nestedMessage { bb = 2 },
589             nestedMessage { bb = 3 },
590             nestedMessage { bb = 4 },
591           )
592         )
593 
594       this[UnittestProto.repeatedNestedEnumExtension].addAll(listOf(NestedEnum.FOO, NestedEnum.BAR))
595       assertThat(this[UnittestProto.repeatedNestedEnumExtension])
596         .isEqualTo(listOf(NestedEnum.FOO, NestedEnum.BAR))
597       this[UnittestProto.repeatedNestedEnumExtension] += listOf(NestedEnum.BAZ, NestedEnum.FOO)
598       assertThat(this[UnittestProto.repeatedNestedEnumExtension])
599         .isEqualTo(listOf(NestedEnum.FOO, NestedEnum.BAR, NestedEnum.BAZ, NestedEnum.FOO))
600     }
601   }
602 
603   @Suppress("CheckReturnValue")
604   @Test
testExtensionContainsnull605   fun testExtensionContains() {
606     testAllExtensions {
607       this[UnittestProto.optionalInt32Extension] = 101
608       assertThat(contains(UnittestProto.optionalInt32Extension)).isTrue()
609       assertThat(contains(UnittestProto.optionalStringExtension)).isFalse()
610       this[UnittestProto.optionalGroupExtension] = optionalGroupExtension { a = 117 }
611       assertThat(contains(UnittestProto.optionalGroupExtension)).isTrue()
612       assertThat(contains(UnittestProto.optionalNestedMessageExtension)).isFalse()
613       this[UnittestProto.optionalNestedEnumExtension] = NestedEnum.BAZ
614       assertThat(contains(UnittestProto.optionalNestedEnumExtension)).isTrue()
615       assertThat(contains(UnittestProto.defaultInt32Extension)).isFalse()
616       this[UnittestProto.oneofUint32Extension] = 601
617       assertThat(contains(UnittestProto.optionalInt32Extension)).isTrue()
618     }
619 
620     testAllExtensions {
621       assertThat(contains(UnittestProto.optionalInt32Extension)).isFalse()
622       this[UnittestProto.optionalStringExtension] = "115"
623       assertThat(contains(UnittestProto.optionalStringExtension)).isTrue()
624       assertThat(contains(UnittestProto.optionalGroupExtension)).isFalse()
625       this[UnittestProto.optionalNestedMessageExtension] = TestAllTypesKt.nestedMessage { bb = 118 }
626       assertThat(contains(UnittestProto.optionalNestedMessageExtension)).isTrue()
627       assertThat(contains(UnittestProto.optionalNestedEnumExtension)).isFalse()
628       this[UnittestProto.defaultInt32Extension] = 401
629       assertThat(contains(UnittestProto.defaultInt32Extension)).isTrue()
630       assertThat(contains(UnittestProto.oneofUint32Extension)).isFalse()
631     }
632   }
633 
634   @Suppress("CheckReturnValue")
635   @Test
testExtensionClearsnull636   fun testExtensionClears() {
637     testAllExtensions {
638       this[UnittestProto.optionalInt32Extension] = 101
639       clear(UnittestProto.optionalInt32Extension)
640       assertThat(contains(UnittestProto.optionalInt32Extension)).isFalse()
641 
642       this[UnittestProto.optionalStringExtension] = "115"
643       clear(UnittestProto.optionalStringExtension)
644       assertThat(contains(UnittestProto.optionalStringExtension)).isFalse()
645 
646       this[UnittestProto.optionalGroupExtension] = optionalGroupExtension { a = 117 }
647       clear(UnittestProto.optionalGroupExtension)
648       assertThat(contains(UnittestProto.optionalGroupExtension)).isFalse()
649 
650       this[UnittestProto.optionalNestedMessageExtension] = TestAllTypesKt.nestedMessage { bb = 118 }
651       clear(UnittestProto.optionalNestedMessageExtension)
652       assertThat(contains(UnittestProto.optionalNestedMessageExtension)).isFalse()
653 
654       this[UnittestProto.optionalNestedEnumExtension] = NestedEnum.BAZ
655       clear(UnittestProto.optionalNestedEnumExtension)
656       assertThat(contains(UnittestProto.optionalNestedEnumExtension)).isFalse()
657 
658       this[UnittestProto.defaultInt32Extension] = 401
659       clear(UnittestProto.defaultInt32Extension)
660       assertThat(contains(UnittestProto.oneofUint32Extension)).isFalse()
661     }
662   }
663 
664   @Test
testEmptyMessagesnull665   fun testEmptyMessages() {
666     assertThat(testEmptyMessage {}).isEqualTo(TestEmptyMessage.newBuilder().build())
667 
668     assertThat(testEmptyMessageWithExtensions {})
669       .isEqualTo(TestEmptyMessageWithExtensions.newBuilder().build())
670   }
671 
672   @Test
testMapSettersnull673   fun testMapSetters() {
674     val intMap = testIntIntMap { m[1] = 2 }
675     assertThat(intMap).isEqualTo(TestIntIntMap.newBuilder().putM(1, 2).build())
676 
677     assertThat(
678         testMaps {
679           mInt32[1] = intMap
680           mInt64[1L] = intMap
681           mUint32[1] = intMap
682           mUint64[1L] = intMap
683           mSint32[1] = intMap
684           mSint64[1L] = intMap
685           mFixed32[1] = intMap
686           mFixed64[1L] = intMap
687           mSfixed32[1] = intMap
688           mSfixed64[1] = intMap
689           mBool[true] = intMap
690           mString["1"] = intMap
691         }
692       )
693       .isEqualTo(
694         TestMaps.newBuilder()
695           .putMInt32(1, intMap)
696           .putMInt64(1L, intMap)
697           .putMUint32(1, intMap)
698           .putMUint64(1L, intMap)
699           .putMSint32(1, intMap)
700           .putMSint64(1L, intMap)
701           .putMFixed32(1, intMap)
702           .putMFixed64(1L, intMap)
703           .putMSfixed32(1, intMap)
704           .putMSfixed64(1L, intMap)
705           .putMBool(true, intMap)
706           .putMString("1", intMap)
707           .build()
708       )
709 
710     assertThat(testEnumMap { knownMapField[1] = Proto2MapEnum.PROTO2_MAP_ENUM_FOO })
711       .isEqualTo(
712         TestEnumMap.newBuilder().putKnownMapField(1, Proto2MapEnum.PROTO2_MAP_ENUM_FOO).build()
713       )
714   }
715 
716   @Suppress("CheckReturnValue")
717   @Test
testMapGettersAndSettersnull718   fun testMapGettersAndSetters() {
719     val intMap = testIntIntMap {
720       m.put(1, 2)
721       assertThat(m).isEqualTo(mapOf(1 to 2))
722       m[3] = 4
723       assertThat(m).isEqualTo(mapOf(1 to 2, 3 to 4))
724       m.putAll(mapOf(5 to 6, 7 to 8))
725       assertThat(m).isEqualTo(mapOf(1 to 2, 3 to 4, 5 to 6, 7 to 8))
726     }
727 
728     testMaps {
729       mInt32.put(1, intMap)
730       assertThat(mInt32).isEqualTo(mapOf(1 to intMap))
731       mInt32[2] = intMap
732       assertThat(mInt32).isEqualTo(mapOf(1 to intMap, 2 to intMap))
733       mInt32.putAll(mapOf(3 to intMap, 4 to intMap))
734       assertThat(mInt32).isEqualTo(mapOf(1 to intMap, 2 to intMap, 3 to intMap, 4 to intMap))
735 
736       mString.put("1", intMap)
737       assertThat(mString).isEqualTo(mapOf("1" to intMap))
738       mString["2"] = intMap
739       assertThat(mString).isEqualTo(mapOf("1" to intMap, "2" to intMap))
740       mString.putAll(mapOf("3" to intMap, "4" to intMap))
741       assertThat(mString)
742         .isEqualTo(mapOf("1" to intMap, "2" to intMap, "3" to intMap, "4" to intMap))
743     }
744 
745     testEnumMap {
746       knownMapField.put(1, Proto2MapEnum.PROTO2_MAP_ENUM_FOO)
747       assertThat(knownMapField).isEqualTo(mapOf(1 to Proto2MapEnum.PROTO2_MAP_ENUM_FOO))
748       knownMapField[2] = Proto2MapEnum.PROTO2_MAP_ENUM_BAR
749       assertThat(knownMapField)
750         .isEqualTo(
751           mapOf(1 to Proto2MapEnum.PROTO2_MAP_ENUM_FOO, 2 to Proto2MapEnum.PROTO2_MAP_ENUM_BAR)
752         )
753       knownMapField.putAll(
754         mapOf(3 to Proto2MapEnum.PROTO2_MAP_ENUM_BAZ, 4 to Proto2MapEnum.PROTO2_MAP_ENUM_FOO)
755       )
756       assertThat(knownMapField)
757         .isEqualTo(
758           mapOf(
759             1 to Proto2MapEnum.PROTO2_MAP_ENUM_FOO,
760             2 to Proto2MapEnum.PROTO2_MAP_ENUM_BAR,
761             3 to Proto2MapEnum.PROTO2_MAP_ENUM_BAZ,
762             4 to Proto2MapEnum.PROTO2_MAP_ENUM_FOO,
763           )
764         )
765     }
766   }
767 
768   @Suppress("CheckReturnValue")
769   @Test
testMapRemovenull770   fun testMapRemove() {
771     val intMap = testIntIntMap {
772       m.putAll(mapOf(1 to 2, 3 to 4))
773       m.remove(1)
774       assertThat(m).isEqualTo(mapOf(3 to 4))
775     }
776 
777     testMaps {
778       mInt32.putAll(mapOf(1 to intMap, 2 to intMap))
779       mInt32.remove(1)
780       assertThat(mInt32).isEqualTo(mapOf(2 to intMap))
781 
782       mString.putAll(mapOf("1" to intMap, "2" to intMap))
783       mString.remove("1")
784       assertThat(mString).isEqualTo(mapOf("2" to intMap))
785     }
786 
787     testEnumMap {
788       knownMapField.putAll(
789         mapOf(1 to Proto2MapEnum.PROTO2_MAP_ENUM_FOO, 2 to Proto2MapEnum.PROTO2_MAP_ENUM_BAR)
790       )
791       knownMapField.remove(1)
792       assertThat(knownMapField).isEqualTo(mapOf(2 to Proto2MapEnum.PROTO2_MAP_ENUM_BAR))
793     }
794   }
795 
796   @Suppress("CheckReturnValue")
797   @Test
testMapClearnull798   fun testMapClear() {
799     val intMap = testIntIntMap {
800       m.putAll(mapOf(1 to 2, 3 to 4))
801       m.clear()
802       assertThat(m.isEmpty()).isTrue()
803     }
804 
805     testMaps {
806       mInt32.putAll(mapOf(1 to intMap, 2 to intMap))
807       mInt32.clear()
808       assertThat(mInt32.isEmpty()).isTrue()
809 
810       mString.putAll(mapOf("1" to intMap, "2" to intMap))
811       mString.clear()
812       assertThat(mString.isEmpty()).isTrue()
813     }
814 
815     testEnumMap {
816       knownMapField.putAll(
817         mapOf(1 to Proto2MapEnum.PROTO2_MAP_ENUM_FOO, 2 to Proto2MapEnum.PROTO2_MAP_ENUM_BAR)
818       )
819       knownMapField.clear()
820       assertThat(knownMapField.isEmpty()).isTrue()
821     }
822   }
823 
824   @Test
testEvilNamesnull825   fun testEvilNames() {
826     assertThat(
827         evilNamesProto2 {
828           initialized = true
829           hasFoo = true
830           bar = "foo"
831           isInitialized = true
832           fooBar = "foo"
833           aLLCAPS += "foo"
834           aLLCAPSMAP[1] = true
835           hasUnderbarPrecedingNumeric1Foo = true
836           hasUnderbarPrecedingNumeric42Bar = true
837           hasUnderbarPrecedingNumeric123Foo42BarBaz = true
838           extension += "foo"
839           class_ += 1
840           int = 1.0
841           long = true
842           boolean = 1L
843           sealed = "foo"
844           interface_ = 1F
845           object_ = "foo"
846           cachedSize_ = "foo"
847           serializedSize_ = true
848           by = "foo"
849           dEPRECATEDFoo = "foo"
850           DEPRECATEDBar = "foo"
851           iD = "foo"
852           aBNotification = "foo"
853           notDEPRECATEDFoo = "foo"
854         }
855       )
856       .isEqualTo(
857         EvilNamesProto2.newBuilder()
858           .setInitialized(true)
859           .setHasFoo(true)
860           .setBar("foo")
861           .setIsInitialized(true)
862           .setFooBar("foo")
863           .addALLCAPS("foo")
864           .putALLCAPSMAP(1, true)
865           .setHasUnderbarPrecedingNumeric1Foo(true)
866           .setHasUnderbarPrecedingNumeric42Bar(true)
867           .setHasUnderbarPrecedingNumeric123Foo42BarBaz(true)
868           .addExtension("foo")
869           .addClass_(1)
870           .setInt(1.0)
871           .setLong(true)
872           .setBoolean(1L)
873           .setSealed("foo")
874           .setInterface(1F)
875           .setObject("foo")
876           .setCachedSize_("foo")
877           .setSerializedSize_(true)
878           .setBy("foo")
879           .setDEPRECATEDFoo("foo")
880           .setDEPRECATEDBar("foo")
881           .setID("foo")
882           .setABNotification("foo")
883           .setNotDEPRECATEDFoo("foo")
884           .build()
885       )
886 
887     assertThat(interface_ {}).isEqualTo(Interface.newBuilder().build())
888   }
889 
890   @Suppress("CheckReturnValue")
891   @Test
testHardKeywordGettersAndSettersnull892   fun testHardKeywordGettersAndSetters() {
893     hardKeywordsAllTypesProto2 {
894       as_ = 1
895       assertThat(as_).isEqualTo(1)
896 
897       break_ = HardKeywordsAllTypesProto2.NestedEnum.FOO
898       assertThat(break_).isEqualTo(HardKeywordsAllTypesProto2.NestedEnum.FOO)
899 
900       do_ = HardKeywordsAllTypesProto2Kt.nestedMessage { while_ = 1 }
901       assertThat(do_).isEqualTo(HardKeywordsAllTypesProto2Kt.nestedMessage { while_ = 1 })
902 
903       continue_[1] = 1
904       assertThat(continue_[1]).isEqualTo(1)
905 
906       else_ += 1
907       assertThat(else_).isEqualTo(listOf(1))
908 
909       for_ += "foo"
910       assertThat(for_).isEqualTo(listOf("foo"))
911 
912       fun_ += HardKeywordsAllTypesProto2.NestedEnum.FOO
913       assertThat(fun_).isEqualTo(listOf(HardKeywordsAllTypesProto2.NestedEnum.FOO))
914 
915       if_ += HardKeywordsAllTypesProto2Kt.nestedMessage { while_ = 1 }
916       assertThat(if_).isEqualTo(listOf(HardKeywordsAllTypesProto2Kt.nestedMessage { while_ = 1 }))
917     }
918   }
919 
920   @Suppress("CheckReturnValue")
921   @Test
testHardKeywordHazzersnull922   fun testHardKeywordHazzers() {
923     hardKeywordsAllTypesProto2 {
924       as_ = 1
925       assertThat(hasAs_()).isTrue()
926 
927       break_ = HardKeywordsAllTypesProto2.NestedEnum.FOO
928       assertThat(hasBreak_()).isTrue()
929 
930       do_ = HardKeywordsAllTypesProto2Kt.nestedMessage { while_ = 1 }
931       assertThat(hasDo_()).isTrue()
932     }
933   }
934 
935   @Suppress("CheckReturnValue")
936   @Test
testHardKeywordClearsnull937   fun testHardKeywordClears() {
938     hardKeywordsAllTypesProto2 {
939       as_ = 1
940       clearAs_()
941       assertThat(hasAs_()).isFalse()
942 
943       break_ = HardKeywordsAllTypesProto2.NestedEnum.FOO
944       clearBreak_()
945       assertThat(hasBreak_()).isFalse()
946 
947       do_ = HardKeywordsAllTypesProto2Kt.nestedMessage { while_ = 1 }
948       clearDo_()
949       assertThat(hasDo_()).isFalse()
950     }
951   }
952 
953   @Test
testGetOrNullnull954   fun testGetOrNull() {
955     val noNestedMessage = testAllTypes {}
956     assertThat(noNestedMessage.optionalNestedMessageOrNull).isEqualTo(null)
957 
958     val someNestedMessage = testAllTypes {
959       optionalNestedMessage = TestAllTypesKt.nestedMessage { bb = 118 }
960     }
961     assertThat(someNestedMessage.optionalNestedMessageOrNull)
962       .isEqualTo(TestAllTypesKt.nestedMessage { bb = 118 })
963   }
964 
965   @Test
testDeprecatednull966   fun testDeprecated() {
967     val testInstance =
968       protobuf_unittest.UnittestProto.TestDeprecatedFields.getDefaultInstance()
969     assertThat(testInstance::deprecatedMessageOrNull.annotations.any { it is Deprecated }).isTrue()
970 
971     val unused = testDeprecatedFields {
972       assertThat(::deprecatedMessage.annotations.any { it is Deprecated }).isTrue()
973     }
974   }
975 }
976