Add dependencies locally

deps/protobuf/java/kotlin/src/main/kotlin/com/google/protobuf/Anies.kt

@@ -0,0 +1,45 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package com.google.protobuf.kotlin
+
+import com.google.protobuf.Any as ProtoAny
+import com.google.protobuf.Message
+
+/** Returns `true` if this [com.google.protobuf.Any] contains a message of type `T`. */
+inline fun <reified T : Message> ProtoAny.isA(): Boolean = this.`is`(T::class.java)
+
+/**
+ * Returns the message of type `T` encoded in this [com.google.protobuf.Any].
+ *
+ * @throws InvalidProtocolBufferException if this [com.google.protobuf.Any] does not contain a `T`
+ * message.
+ */
+inline fun <reified T : Message> ProtoAny.unpack(): T = unpack(T::class.java)

deps/protobuf/java/kotlin/src/main/kotlin/com/google/protobuf/ByteStrings.kt

@@ -0,0 +1,50 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package com.google.protobuf.kotlin
+
+import com.google.protobuf.ByteString
+import java.nio.ByteBuffer
+
+/** Encodes this String into a sequence of UTF-8 bytes and returns the result as a [ByteString]. */
+fun String.toByteStringUtf8(): ByteString = ByteString.copyFromUtf8(this)
+// symmetric from ByteString.toStringUtf8()
+
+/** Concatenates the given [ByteString] to this one. */
+operator fun ByteString.plus(other: ByteString): ByteString = concat(other)
+
+/** Gets the byte at [index]. */
+operator fun ByteString.get(index: Int): Byte = byteAt(index)
+
+/** Returns a copy of this [ByteArray] as an immutable [ByteString]. */
+fun ByteArray.toByteString(): ByteString = ByteString.copyFrom(this)
+
+/** Copies the remaining bytes from this [ByteBuffer] to a [ByteString]. */
+fun ByteBuffer.toByteString(): ByteString = ByteString.copyFrom(this)

deps/protobuf/java/kotlin/src/main/kotlin/com/google/protobuf/DslList.kt

@@ -0,0 +1,59 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package com.google.protobuf.kotlin
+
+/**
+ * A simple wrapper around a [List] with an extra generic parameter that can be used to disambiguate
+ * extension methods.
+ *
+ * <p>This class is used by Kotlin protocol buffer extensions, and its constructor is public only
+ * because generated message code is in a different compilation unit.  Others should not use this
+ * class directly in any way.
+ */
+@Suppress("unused") // the unused type parameter
+class DslList<E, P : DslProxy> @OnlyForUseByGeneratedProtoCode constructor(
+  private val delegate: List<E>
+) : List<E> by delegate {
+  override fun iterator(): Iterator<E> = UnmodifiableIterator(delegate.iterator())
+
+  override fun listIterator(): ListIterator<E> = UnmodifiableListIterator(delegate.listIterator())
+
+  override fun listIterator(index: Int): ListIterator<E> =
+    UnmodifiableListIterator(delegate.listIterator(index))
+
+  override fun equals(other: Any?): Boolean = delegate == other
+
+  override fun hashCode(): Int = delegate.hashCode()
+
+  override fun toString(): String = delegate.toString()
+}
+
+// TODO(lowasser): investigate making this an inline class

deps/protobuf/java/kotlin/src/main/kotlin/com/google/protobuf/DslMap.kt

@@ -0,0 +1,62 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package com.google.protobuf.kotlin
+
+/**
+ * A simple wrapper around a [Map] with an extra generic parameter that can be used to disambiguate
+ * extension methods.
+ *
+ * <p>This class is used by Kotlin protocol buffer extensions, and its constructor is public only
+ * because generated message code is in a different compilation unit.  Others should not use this
+ * class directly in any way.
+ */
+@Suppress("unused") // the unused type parameter
+class DslMap<K, V, P : DslProxy> @OnlyForUseByGeneratedProtoCode constructor(
+  private val delegate: Map<K, V>
+) : Map<K, V> by delegate {
+  // We allocate the wrappers on calls to get, not with lazy {...}, because lazy allocates
+  // a few objects up front, and any kind of query operation on this object should be rare.
+
+  override val entries: Set<Map.Entry<K, V>>
+    get() = UnmodifiableMapEntries(delegate.entries)
+  override val keys: Set<K>
+    get() = UnmodifiableSet(delegate.keys)
+  override val values: Collection<V>
+    get() = UnmodifiableCollection(delegate.values)
+
+  override fun equals(other: Any?): Boolean = delegate == other
+
+  override fun hashCode(): Int = delegate.hashCode()
+
+  override fun toString(): String = delegate.toString()
+}
+
+// TODO(lowasser): investigate making this an inline class

deps/protobuf/java/kotlin/src/main/kotlin/com/google/protobuf/DslProxy.kt

@@ -0,0 +1,42 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package com.google.protobuf.kotlin
+
+/**
+ * A type meaningful only for its existence, never intended to be instantiated.  For example,
+ * a `DslList<Int, FooProxy>` can be given different extension methods than a
+ * `DslList<Int, BarProxy>`.
+ */
+abstract class DslProxy @OnlyForUseByGeneratedProtoCode protected constructor() {
+  init {
+    throw UnsupportedOperationException("A DslProxy should never be instantiated")
+  }
+}

deps/protobuf/java/kotlin/src/main/kotlin/com/google/protobuf/ExtendableMessageExtensions.kt

@@ -0,0 +1,56 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package com.google.protobuf.kotlin
+
+import com.google.protobuf.ExtensionLite
+import com.google.protobuf.GeneratedMessageV3
+
+/** Sets the current value of the proto extension in this builder.*/
+operator fun <
+  M : GeneratedMessageV3.ExtendableMessage<M>,
+  B : GeneratedMessageV3.ExtendableBuilder<M, B>,
+  T : Any
+  > B.set(extension: ExtensionLite<M, T>, value: T) {
+  setExtension(extension, value)
+}
+
+/** Gets the current value of the proto extension. */
+operator fun <
+  M : GeneratedMessageV3.ExtendableMessage<M>,
+  MorBT : GeneratedMessageV3.ExtendableMessageOrBuilder<M>,
+  T : Any
+  > MorBT.get(extension: ExtensionLite<M, T>): T = getExtension(extension)
+
+/** Returns true if the specified extension is set on this builder. */
+operator fun <
+  M : GeneratedMessageV3.ExtendableMessage<M>,
+  MorBT : GeneratedMessageV3.ExtendableMessageOrBuilder<M>
+  > MorBT.contains(extension: ExtensionLite<M, *>): Boolean = hasExtension(extension)

deps/protobuf/java/kotlin/src/main/kotlin/com/google/protobuf/ExtensionList.kt

@@ -0,0 +1,57 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package com.google.protobuf.kotlin
+
+import com.google.protobuf.ExtensionLite
+import com.google.protobuf.MessageLite
+
+/**
+ * Implementation for ExtensionList and ExtensionListLite. Like [DslList], represents an
+ * unmodifiable view of a repeated proto field -- in this case, an extension field -- but supports
+ * querying the extension.
+ */
+class ExtensionList<E, M : MessageLite>
+@OnlyForUseByGeneratedProtoCode
+constructor(val extension: ExtensionLite<M, List<E>>, private val delegate: List<E>) :
+  List<E> by delegate {
+  override fun iterator(): Iterator<E> = UnmodifiableIterator(delegate.iterator())
+
+  override fun listIterator(): ListIterator<E> = UnmodifiableListIterator(delegate.listIterator())
+
+  override fun listIterator(index: Int): ListIterator<E> =
+    UnmodifiableListIterator(delegate.listIterator(index))
+
+  override fun equals(other: Any?): Boolean = delegate == other
+
+  override fun hashCode(): Int = delegate.hashCode()
+
+  override fun toString(): String = delegate.toString()
+}

deps/protobuf/java/kotlin/src/main/kotlin/com/google/protobuf/OnlyForUseByGeneratedProtoCode.kt

@@ -0,0 +1,48 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package com.google.protobuf.kotlin
+
+/**
+ * Opt-in annotation to make it difficult to accidentally use APIs only intended for use by proto
+ * generated code.  See https://kotlinlang.org/docs/reference/opt-in-requirements.html for details
+ * on how this API works.
+ */
+@RequiresOptIn(
+  message =
+    """
+    This API is only intended for use by generated protobuf code, the code generator, and their own
+    tests.  If this does not describe your code, you should not be using this API.
+  """,
+  level = RequiresOptIn.Level.ERROR
+)
+@Retention(AnnotationRetention.BINARY)
+@Target(AnnotationTarget.CONSTRUCTOR, AnnotationTarget.ANNOTATION_CLASS)
+annotation class OnlyForUseByGeneratedProtoCode

deps/protobuf/java/kotlin/src/main/kotlin/com/google/protobuf/ProtoDslMarker.kt

@@ -0,0 +1,40 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package com.google.protobuf.kotlin
+
+/**
+ * Indicates an API that is part of a DSL to generate protocol buffer messages.
+ */
+@DslMarker
+@Target(AnnotationTarget.CLASS)
+@Retention(AnnotationRetention.BINARY)
+@OnlyForUseByGeneratedProtoCode
+annotation class ProtoDslMarker

deps/protobuf/java/kotlin/src/main/kotlin/com/google/protobuf/UnmodifiableCollections.kt

@@ -0,0 +1,69 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package com.google.protobuf.kotlin
+
+/** Wraps an [Iterator] and makes it unmodifiable even from Java. */
+internal class UnmodifiableIterator<E>(delegate: Iterator<E>) : Iterator<E> by delegate
+
+/** Wraps a [ListIterator] and makes it unmodifiable even from Java. */
+internal class UnmodifiableListIterator<E>(
+  delegate: ListIterator<E>
+) : ListIterator<E> by delegate
+
+/** Wraps a [Collection] and makes it unmodifiable even from Java. */
+internal open class UnmodifiableCollection<E>(
+  private val delegate: Collection<E>
+) : Collection<E> by delegate {
+  override fun iterator(): Iterator<E> = UnmodifiableIterator(delegate.iterator())
+}
+
+/** Wraps a [Set] and makes it unmodifiable even from Java. */
+internal class UnmodifiableSet<E>(
+  delegate: Collection<E>
+) : UnmodifiableCollection<E>(delegate), Set<E>
+
+/** Wraps a [Map.Entry] and makes it unmodifiable even from Java. */
+internal class UnmodifiableMapEntry<K, V>(delegate: Map.Entry<K, V>) : Map.Entry<K, V> by delegate
+
+/** Wraps a [Set] of map entries and makes it unmodifiable even from Java. */
+internal class UnmodifiableMapEntries<K, V>(
+  private val delegate: Set<Map.Entry<K, V>>
+) : UnmodifiableCollection<Map.Entry<K, V>>(delegate), Set<Map.Entry<K, V>> {
+
+  // Is this overkill? Probably.
+
+  override fun iterator(): Iterator<Map.Entry<K, V>> {
+    val itr = delegate.iterator()
+    return object : Iterator<Map.Entry<K, V>> by itr {
+      override fun next(): Map.Entry<K, V> = UnmodifiableMapEntry(itr.next())
+    }
+  }
+}

deps/protobuf/java/kotlin/src/test/kotlin/com/google/protobuf/AniesTest.kt

@@ -0,0 +1,70 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package com.google.protobuf.kotlin
+
+import com.google.common.truth.Truth.assertThat
+import com.google.protobuf.Any as ProtoAny
+import com.google.protobuf.InvalidProtocolBufferException
+import protobuf_unittest.UnittestProto.BoolMessage
+import protobuf_unittest.UnittestProto.Int32Message
+import protobuf_unittest.int32Message
+import kotlin.test.assertFailsWith
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+
+/** Tests for extension methods on [ProtoAny]. */
+@RunWith(JUnit4::class)
+class AniesTest {
+  companion object {
+    val anAny = ProtoAny.pack(int32Message { data = 5 })
+  }
+
+  @Test
+  fun isA_Positive() {
+    assertThat(anAny.isA<Int32Message>()).isTrue()
+  }
+
+  @Test
+  fun isA_Negative() {
+    assertThat(anAny.isA<BoolMessage>()).isFalse()
+  }
+
+  @Test
+  fun unpackValid() {
+    assertThat(anAny.unpack<Int32Message>().data).isEqualTo(5)
+  }
+
+  @Test
+  fun unpackInvalid() {
+    assertFailsWith<InvalidProtocolBufferException> { anAny.unpack<BoolMessage>() }
+  }
+}

deps/protobuf/java/kotlin/src/test/kotlin/com/google/protobuf/ByteStringsTest.kt

@@ -0,0 +1,98 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package com.google.protobuf.kotlin
+
+import com.google.common.truth.Truth.assertThat
+import com.google.protobuf.ByteString
+import java.lang.IndexOutOfBoundsException
+import java.nio.Buffer
+import java.nio.ByteBuffer
+import kotlin.test.assertFailsWith
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+
+/** Tests for the extension functions in ByteStrings.kt. */
+@RunWith(JUnit4::class)
+class ByteStringsTest {
+  @Test
+  fun toByteStringUtf8() {
+    assertThat("abc".toByteStringUtf8())
+      .isEqualTo(ByteString.copyFrom("abc".toByteArray(Charsets.UTF_8)))
+  }
+
+  @Test
+  fun plus() {
+    assertThat("abc".toByteStringUtf8() + "def".toByteStringUtf8())
+      .isEqualTo(ByteString.copyFrom("abcdef".toByteArray(Charsets.UTF_8)))
+  }
+
+  @Test
+  fun byteAt() {
+    val str = "abc".toByteStringUtf8()
+    assertThat(str[0]).isEqualTo('a'.toByte())
+    assertThat(str[2]).isEqualTo('c'.toByte())
+  }
+
+  @Test
+  fun byteAtBelowZero() {
+    val str = "abc".toByteStringUtf8()
+    assertFailsWith<IndexOutOfBoundsException> { str[-1] }
+    assertFailsWith<IndexOutOfBoundsException> { str[-2] }
+  }
+
+  @Test
+  fun byteAtAboveLength() {
+    val str = "abc".toByteStringUtf8()
+    assertFailsWith<IndexOutOfBoundsException> { str[3] }
+    assertFailsWith<IndexOutOfBoundsException> { str[4] }
+  }
+
+  @Test
+  fun byteArrayToByteString() {
+    assertThat("abc".toByteArray(Charsets.UTF_8).toByteString())
+      .isEqualTo(ByteString.copyFromUtf8("abc"))
+  }
+
+  @Test
+  fun byteBufferToByteString() {
+    val buffer = ByteBuffer.wrap("abc".toByteArray(Charsets.UTF_8))
+    assertThat(buffer.toByteString()).isEqualTo(ByteString.copyFromUtf8("abc"))
+  }
+
+  @Test
+  fun byteBufferToByteStringRespectsPositionAndLimit() {
+    val buffer = ByteBuffer.wrap("abc".toByteArray(Charsets.UTF_8))
+    (buffer as java.nio.Buffer).position(1)
+    (buffer as java.nio.Buffer).limit(2)
+    assertThat(buffer.toByteString()).isEqualTo(ByteString.copyFromUtf8("b"))
+  }
+}

deps/protobuf/java/kotlin/src/test/kotlin/com/google/protobuf/DslListTest.kt

@@ -0,0 +1,128 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package com.google.protobuf.kotlin
+
+import com.google.common.testing.EqualsTester
+import com.google.common.truth.Truth.assertThat
+import kotlin.test.assertFailsWith
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+
+/** Tests for [DslList]. */
+@RunWith(JUnit4::class)
+@OptIn(OnlyForUseByGeneratedProtoCode::class)
+class DslListTest {
+  class DummyProxy private constructor() : DslProxy()
+
+  @Test
+  fun matchesList() {
+    assertThat(DslList<Int, DummyProxy>(listOf(1, 2, 3))).containsExactly(1, 2, 3).inOrder()
+  }
+
+  @Test
+  fun reflectsChangesInList() {
+    val mutableList = mutableListOf(1, 2, 3)
+    val dslList = DslList<Int, DummyProxy>(mutableList)
+    mutableList.add(4)
+    assertThat(dslList).containsExactly(1, 2, 3, 4).inOrder()
+  }
+
+  @Test
+  fun dslListIsNotMutable() {
+    val dslList = DslList<Int, DummyProxy>(mutableListOf(1, 2, 3))
+    assertThat(dslList is MutableList<*>).isFalse()
+  }
+
+  @Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN", "UNCHECKED_CAST")
+  @Test
+  fun dslListIsNotEvenSecretlyMutable() {
+    val dslList = DslList<Int, DummyProxy>(mutableListOf(1, 2, 3))
+    val dslListAsJavaUtil = dslList as java.util.List<Int>
+    assertFailsWith<UnsupportedOperationException> {
+      dslListAsJavaUtil.add(4)
+    }
+  }
+
+  @Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN", "UNCHECKED_CAST")
+  @Test
+  fun dslList_IteratorIsNotEvenSecretlyMutable() {
+    val dslList = DslList<Int, DummyProxy>(mutableListOf(1, 2, 3))
+    val iterator = dslList.iterator() as java.util.Iterator<Int>
+    iterator.next()
+
+    assertFailsWith<UnsupportedOperationException> {
+      iterator.remove()
+    }
+  }
+
+  @Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN", "UNCHECKED_CAST")
+  @Test
+  fun dslList_ListIteratorIsNotEvenSecretlyMutable() {
+    val dslList = DslList<Int, DummyProxy>(mutableListOf(1, 2, 3))
+    val iterator = dslList.listIterator() as java.util.ListIterator<Int>
+    iterator.next()
+
+    assertFailsWith<UnsupportedOperationException> {
+      iterator.remove()
+    }
+  }
+
+  @Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN", "UNCHECKED_CAST")
+  @Test
+  fun dslList_ListIteratorIndexIsNotEvenSecretlyMutable() {
+    val dslList = DslList<Int, DummyProxy>(mutableListOf(1, 2, 3))
+    val iterator = dslList.listIterator(1) as java.util.ListIterator<Int>
+    iterator.next()
+
+    assertFailsWith<UnsupportedOperationException> {
+      iterator.remove()
+    }
+  }
+
+  @Test
+  fun expectedToString() {
+    assertThat(DslList<Int, DummyProxy>(listOf(1, 2)).toString()).isEqualTo("[1, 2]")
+  }
+
+  @Test
+  fun equality() {
+    EqualsTester()
+      .addEqualityGroup(DslList<Int, DummyProxy>(listOf(1, 2)), listOf(1, 2))
+      .addEqualityGroup(DslList<Int, DummyProxy>(listOf(2, 2)), listOf(2, 2))
+      .addEqualityGroup(
+        DslList<Int, DummyProxy>(emptyList()),
+        DslList<String, DummyProxy>(emptyList()),
+        emptyList<Int>()
+      )
+      .testEquals()
+  }
+}

deps/protobuf/java/kotlin/src/test/kotlin/com/google/protobuf/DslMapTest.kt

@@ -0,0 +1,194 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package com.google.protobuf.kotlin
+
+import com.google.common.testing.EqualsTester
+import com.google.common.truth.Truth.assertThat
+import kotlin.test.assertFailsWith
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+
+@RunWith(JUnit4::class)
+@OptIn(OnlyForUseByGeneratedProtoCode::class)
+class DslMapTest {
+  class DummyProxy private constructor() : DslProxy()
+
+  @Test
+  fun matchesMap() {
+    assertThat(DslMap<Int, Int, DummyProxy>(mapOf(1 to -1, 2 to -2)))
+      .containsExactly(1, -1, 2, -2)
+  }
+
+  @Test
+  fun reflectsChangesInMap() {
+    val mutableMap = mutableMapOf(1 to -1, 2 to -2)
+    val dslMap = DslMap<Int, Int, DummyProxy>(mutableMap)
+    mutableMap[3] = -3
+    assertThat(dslMap).containsExactly(1, -1, 2, -2, 3, -3).inOrder()
+  }
+
+  @Test
+  fun dslMapIsNotMutable() {
+    val dslMap = DslMap<Int, Int, DummyProxy>(mutableMapOf(1 to -1))
+    assertThat(dslMap is MutableMap<*, *>).isFalse()
+  }
+
+  @Test
+  fun dslMapKeysAreNotMutable() {
+    val dslMap = DslMap<Int, Int, DummyProxy>(mutableMapOf(1 to -1))
+    assertThat(dslMap.keys is MutableSet<*>).isFalse()
+  }
+
+  @Test
+  fun dslMapValuesAreNotMutable() {
+    val dslMap = DslMap<Int, Int, DummyProxy>(mutableMapOf(1 to -1))
+    assertThat(dslMap.values is MutableSet<*>).isFalse()
+  }
+
+  @Test
+  fun dslMapEntriesAreNotMutable() {
+    val dslMap = DslMap<Int, Int, DummyProxy>(mutableMapOf(1 to -1))
+    assertThat(dslMap.entries is MutableSet<*>).isFalse()
+  }
+
+  @Test
+  fun dslMapEntryObjectsAreNotMutable() {
+    val dslMap = DslMap<Int, Int, DummyProxy>(mutableMapOf(1 to -1))
+    assertThat(dslMap.entries.single() is MutableMap.MutableEntry<*, *>).isFalse()
+  }
+
+  @Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN", "UNCHECKED_CAST")
+  @Test
+  fun dslMapIsNotEvenSecretlyMutable() {
+    val dslMap = DslMap<Int, Int, DummyProxy>(mutableMapOf(1 to -1))
+    val dslMapAsJavaUtilMap = dslMap as java.util.Map<Int, Int>
+    assertFailsWith<UnsupportedOperationException> {
+      dslMapAsJavaUtilMap.put(2, -2)
+    }
+  }
+
+  @Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN", "UNCHECKED_CAST")
+  @Test
+  fun dslMapKeysAreNotEvenSecretlyMutable() {
+    val dslMap = DslMap<Int, Int, DummyProxy>(mutableMapOf(1 to -1))
+    val dslMapKeysAsJavaUtilSet = dslMap.keys as java.util.Set<Int>
+    assertFailsWith<UnsupportedOperationException> {
+      dslMapKeysAsJavaUtilSet.remove(1)
+    }
+  }
+
+  @Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN", "UNCHECKED_CAST")
+  @Test
+  fun dslMapKeysIteratorIsNotEvenSecretlyMutable() {
+    val dslMap = DslMap<Int, Int, DummyProxy>(mutableMapOf(1 to -1))
+    val dslMapKeysAsJavaUtilSet = dslMap.keys as java.util.Set<Int>
+    val itr = dslMapKeysAsJavaUtilSet.iterator()
+    itr.next()
+    assertFailsWith<UnsupportedOperationException> {
+      itr.remove()
+    }
+  }
+
+  @Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN", "UNCHECKED_CAST")
+  @Test
+  fun dslMapValuesAreNotEvenSecretlyMutable() {
+    val dslMap = DslMap<Int, Int, DummyProxy>(mutableMapOf(1 to -1))
+    val dslMapValuesAsJavaUtilCollection = dslMap.values as java.util.Collection<Int>
+    assertFailsWith<UnsupportedOperationException> {
+      dslMapValuesAsJavaUtilCollection.remove(1)
+    }
+  }
+
+  @Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN", "UNCHECKED_CAST")
+  @Test
+  fun dslMapValuesIteratorIsNotEvenSecretlyMutable() {
+    val dslMap = DslMap<Int, Int, DummyProxy>(mutableMapOf(1 to -1))
+    val dslMapValuesAsJavaUtilCollection = dslMap.values as java.util.Collection<Int>
+    val itr = dslMapValuesAsJavaUtilCollection.iterator()
+    itr.next()
+    assertFailsWith<UnsupportedOperationException> {
+      itr.remove()
+    }
+  }
+
+  @Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN", "UNCHECKED_CAST")
+  @Test
+  fun dslMapEntriesAreNotEvenSecretlyMutable() {
+    val dslMap = DslMap<Int, Int, DummyProxy>(mutableMapOf(1 to -1))
+    val dslMapEntriesAsJavaUtilSet = dslMap.entries as java.util.Set<Map.Entry<Int, Int>>
+    val entry = dslMap.entries.single()
+    assertFailsWith<UnsupportedOperationException> {
+      dslMapEntriesAsJavaUtilSet.remove(entry)
+    }
+  }
+
+  @Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN", "UNCHECKED_CAST")
+  @Test
+  fun dslMapEntriesIteratorIsNotEvenSecretlyMutable() {
+    val dslMap = DslMap<Int, Int, DummyProxy>(mutableMapOf(1 to -1))
+    val dslMapEntriesAsJavaUtilSet = dslMap.entries as java.util.Set<Map.Entry<Int, Int>>
+    val itr = dslMapEntriesAsJavaUtilSet.iterator()
+    itr.next()
+    assertFailsWith<UnsupportedOperationException> {
+      itr.remove()
+    }
+  }
+
+  @Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN", "UNCHECKED_CAST")
+  @Test
+  fun dslMapEntryObjectsAreNotEvenSecretlyMutable() {
+    val dslMap = DslMap<Int, Int, DummyProxy>(mutableMapOf(1 to -1))
+    val dslMapEntryAsJavaUtilMapEntry = dslMap.entries.single() as java.util.Map.Entry<Int, Int>
+    assertFailsWith<UnsupportedOperationException> {
+      dslMapEntryAsJavaUtilMapEntry.value = 2
+    }
+  }
+
+  @Test
+  fun expectedToString() {
+    assertThat(DslMap<Int, Int, DummyProxy>(mapOf(1 to 2, 2 to 3)).toString())
+      .isEqualTo("{1=2, 2=3}")
+  }
+
+  @Test
+  fun equality() {
+    EqualsTester()
+      .addEqualityGroup(DslMap<Int, Int, DummyProxy>(mapOf(1 to 2, 2 to 3)), mapOf(1 to 2, 2 to 3))
+      .addEqualityGroup(DslMap<Int, Int, DummyProxy>(mapOf(1 to 3, 2 to 3)), mapOf(1 to 3, 2 to 3))
+      .addEqualityGroup(
+        DslMap<Int, Int, DummyProxy>(emptyMap()),
+        DslMap<String, String, DummyProxy>(emptyMap()),
+        emptyMap<Int, Int>()
+      )
+      .testEquals()
+  }
+}

deps/protobuf/java/kotlin/src/test/kotlin/com/google/protobuf/ExtendableMessageExtensionsTest.kt

@@ -0,0 +1,90 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package com.google.protobuf.kotlin
+
+import com.google.common.truth.Truth.assertThat
+import com.google.protobuf.kotlin.test.ExampleExtensibleMessage
+import com.google.protobuf.kotlin.test.ExampleExtensibleMessageOuterClass as TestProto
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+
+@RunWith(JUnit4::class)
+class ExtendableMessageExtensionsTest {
+  @Test
+  fun setOnBuilder() {
+    val builder = ExampleExtensibleMessage.newBuilder()
+    builder[TestProto.int32Extension] = 5
+    assertThat(builder.build().getExtension(TestProto.int32Extension)).isEqualTo(5)
+  }
+
+  @Test
+  fun getOnBuilder() {
+    val builder = ExampleExtensibleMessage.newBuilder()
+      .setExtension(TestProto.int32Extension, 6)
+    assertThat(builder[TestProto.int32Extension]).isEqualTo(6)
+  }
+
+  @Test
+  fun getOnMessage() {
+    val message = ExampleExtensibleMessage.newBuilder()
+      .setExtension(TestProto.int32Extension, 6)
+      .build()
+    assertThat(message[TestProto.int32Extension]).isEqualTo(6)
+  }
+
+  @Test
+  fun containsPositiveOnMessage() {
+    val message = ExampleExtensibleMessage.newBuilder()
+      .setExtension(TestProto.int32Extension, 6)
+      .build()
+    assertThat(TestProto.int32Extension in message).isTrue()
+  }
+
+  @Test
+  fun containsPositiveOnBuilder() {
+    val builder = ExampleExtensibleMessage.newBuilder()
+      .setExtension(TestProto.int32Extension, 6)
+    assertThat(TestProto.int32Extension in builder).isTrue()
+  }
+
+  @Test
+  fun containsNegativeOnMessage() {
+    val message = ExampleExtensibleMessage.newBuilder().build()
+    assertThat(TestProto.int32Extension in message).isFalse()
+  }
+
+  @Test
+  fun containsNegativeOnBuilder() {
+    val builder = ExampleExtensibleMessage.newBuilder()
+    assertThat(TestProto.int32Extension in builder).isFalse()
+  }
+}

deps/protobuf/java/kotlin/src/test/kotlin/com/google/protobuf/ExtensionListTest.kt

@@ -0,0 +1,155 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package com.google.protobuf.kotlin
+
+import com.google.common.testing.EqualsTester
+import com.google.common.truth.Truth.assertThat
+import com.google.protobuf.kotlin.test.ExampleExtensibleMessage
+import com.google.protobuf.kotlin.test.ExampleExtensibleMessageOuterClass as TestProto
+import kotlin.test.assertFailsWith
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+
+/** Tests for [DslList]. */
+@RunWith(JUnit4::class)
+@OptIn(OnlyForUseByGeneratedProtoCode::class)
+class ExtensionListTest {
+  class DummyProxy private constructor() : DslProxy()
+
+  @Test
+  fun matchesList() {
+    assertThat(
+      ExtensionList<Int, ExampleExtensibleMessage>(
+        TestProto.repeatedExtension, listOf(1, 2, 3)
+      )
+    ).containsExactly(1, 2, 3).inOrder()
+  }
+
+  @Test
+  fun reflectsChangesInList() {
+    val mutableList = mutableListOf(1, 2, 3)
+    val extensionList = ExtensionList<Int, ExampleExtensibleMessage>(
+      TestProto.repeatedExtension, mutableList
+    )
+    mutableList.add(4)
+    assertThat(extensionList).containsExactly(1, 2, 3, 4).inOrder()
+  }
+
+  @Test
+  fun extensionListIsNotMutable() {
+    val extensionList = ExtensionList<Int, ExampleExtensibleMessage>(
+      TestProto.repeatedExtension, mutableListOf(1, 2, 3)
+    )
+    assertThat(extensionList is MutableList<*>).isFalse()
+  }
+
+  @Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN", "UNCHECKED_CAST")
+  @Test
+  fun extensionListIsNotEvenSecretlyMutable() {
+    val extensionList = ExtensionList<Int, ExampleExtensibleMessage>(
+      TestProto.repeatedExtension, mutableListOf(1, 2, 3)
+    )
+    val extensionListAsJavaUtil = extensionList as java.util.List<Int>
+    assertFailsWith<UnsupportedOperationException> {
+      extensionListAsJavaUtil.add(4)
+    }
+  }
+
+  @Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN", "UNCHECKED_CAST")
+  @Test
+  fun extensionList_IteratorIsNotEvenSecretlyMutable() {
+    val extensionList = ExtensionList<Int, ExampleExtensibleMessage>(
+      TestProto.repeatedExtension, mutableListOf(1, 2, 3)
+    )
+    val iterator = extensionList.iterator() as java.util.Iterator<Int>
+    iterator.next()
+
+    assertFailsWith<UnsupportedOperationException> {
+      iterator.remove()
+    }
+  }
+
+  @Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN", "UNCHECKED_CAST")
+  @Test
+  fun extensionList_ListIteratorIsNotEvenSecretlyMutable() {
+    val extensionList = ExtensionList<Int, ExampleExtensibleMessage>(
+      TestProto.repeatedExtension, mutableListOf(1, 2, 3)
+    )
+    val iterator = extensionList.listIterator() as java.util.ListIterator<Int>
+    iterator.next()
+
+    assertFailsWith<UnsupportedOperationException> {
+      iterator.remove()
+    }
+  }
+
+  @Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN", "UNCHECKED_CAST")
+  @Test
+  fun extensionList_ListIteratorIndexIsNotEvenSecretlyMutable() {
+    val extensionList = ExtensionList<Int, ExampleExtensibleMessage>(
+      TestProto.repeatedExtension, mutableListOf(1, 2, 3)
+    )
+    val iterator = extensionList.listIterator(1) as java.util.ListIterator<Int>
+    iterator.next()
+
+    assertFailsWith<UnsupportedOperationException> {
+      iterator.remove()
+    }
+  }
+
+  @Test
+  fun expectedToString() {
+    assertThat(
+      ExtensionList<Int, ExampleExtensibleMessage>(TestProto.repeatedExtension, listOf(1, 2))
+        .toString()
+    ).isEqualTo("[1, 2]")
+  }
+
+  @Test
+  fun equality() {
+    EqualsTester()
+      .addEqualityGroup(
+        ExtensionList<Int, ExampleExtensibleMessage>(TestProto.repeatedExtension, listOf(1, 2)),
+        ExtensionList<Int, ExampleExtensibleMessage>(TestProto.differentExtension, listOf(1, 2)),
+        listOf(1, 2)
+      )
+      .addEqualityGroup(
+        ExtensionList<Int, ExampleExtensibleMessage>(TestProto.repeatedExtension, listOf(2, 2)),
+        listOf(2, 2)
+      )
+      .addEqualityGroup(
+        ExtensionList<Int, ExampleExtensibleMessage>(TestProto.repeatedExtension, emptyList()),
+        emptyList<Int>()
+      )
+      .testEquals()
+  }
+}

deps/protobuf/java/kotlin/src/test/kotlin/com/google/protobuf/Proto2Test.kt

@@ -0,0 +1,969 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package com.google.protobuf.kotlin
+
+import com.google.common.truth.Truth.assertThat
+import com.google.protobuf.TestUtil
+import com.google.protobuf.TestUtil.toBytes
+import com.google.protobuf.kotlin.generator.EvilNamesProto2OuterClass.EvilNamesProto2
+import com.google.protobuf.kotlin.generator.EvilNamesProto2OuterClass.HardKeywordsAllTypesProto2
+import com.google.protobuf.kotlin.generator.EvilNamesProto2OuterClass.Interface
+import com.google.protobuf.kotlin.generator.HardKeywordsAllTypesProto2Kt
+import com.google.protobuf.kotlin.generator.evilNamesProto2
+import com.google.protobuf.kotlin.generator.hardKeywordsAllTypesProto2
+import com.google.protobuf.kotlin.generator.interface_
+import com.google.protobuf.test.UnittestImport.ImportEnum
+import com.google.protobuf.test.UnittestImport.ImportMessage
+import com.google.protobuf.test.UnittestImportPublic.PublicImportMessage
+import protobuf_unittest.MapProto2Unittest.Proto2MapEnum
+import protobuf_unittest.MapProto2Unittest.TestEnumMap
+import protobuf_unittest.MapProto2Unittest.TestIntIntMap
+import protobuf_unittest.MapProto2Unittest.TestMaps
+import protobuf_unittest.TestAllTypesKt
+import protobuf_unittest.TestAllTypesKt.nestedMessage
+import protobuf_unittest.UnittestProto
+import protobuf_unittest.UnittestProto.ForeignEnum
+import protobuf_unittest.UnittestProto.TestAllTypes
+import protobuf_unittest.UnittestProto.TestAllTypes.NestedEnum
+import protobuf_unittest.UnittestProto.TestEmptyMessage
+import protobuf_unittest.UnittestProto.TestEmptyMessageWithExtensions
+import protobuf_unittest.copy
+import protobuf_unittest.foreignMessage
+import protobuf_unittest.optionalGroupExtension
+import protobuf_unittest.optionalNestedMessageOrNull
+import protobuf_unittest.repeatedGroupExtension
+import protobuf_unittest.testAllExtensions
+import protobuf_unittest.testAllTypes
+import protobuf_unittest.testEmptyMessage
+import protobuf_unittest.testEmptyMessageWithExtensions
+import protobuf_unittest.testEnumMap
+import protobuf_unittest.testIntIntMap
+import protobuf_unittest.testMaps
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+
+@RunWith(JUnit4::class)
+class Proto2Test {
+  @Test
+  fun testSetters() {
+    assertThat(
+        testAllTypes {
+          optionalInt32 = 101
+          optionalInt64 = 102
+          optionalUint32 = 103
+          optionalUint64 = 104
+          optionalSint32 = 105
+          optionalSint64 = 106
+          optionalFixed32 = 107
+          optionalFixed64 = 108
+          optionalSfixed32 = 109
+          optionalSfixed64 = 110
+          optionalFloat = 111.0f
+          optionalDouble = 112.0
+          optionalBool = true
+          optionalString = "115"
+          optionalBytes = toBytes("116")
+          optionalGroup = TestAllTypesKt.optionalGroup { a = 117 }
+          optionalNestedMessage = nestedMessage { bb = 118 }
+          optionalForeignMessage = foreignMessage { c = 119 }
+          optionalImportMessage = ImportMessage.newBuilder().setD(120).build()
+          optionalPublicImportMessage = PublicImportMessage.newBuilder().setE(126).build()
+          optionalLazyMessage = nestedMessage { bb = 127 }
+          optionalNestedEnum = NestedEnum.BAZ
+          optionalForeignEnum = ForeignEnum.FOREIGN_BAZ
+          optionalImportEnum = ImportEnum.IMPORT_BAZ
+          optionalStringPiece = "124"
+          optionalCord = "125"
+          repeatedInt32.add(201)
+          repeatedInt64.add(202)
+          repeatedUint32.add(203)
+          repeatedUint64.add(204)
+          repeatedSint32.add(205)
+          repeatedSint64.add(206)
+          repeatedFixed32.add(207)
+          repeatedFixed64.add(208)
+          repeatedSfixed32.add(209)
+          repeatedSfixed64.add(210)
+          repeatedFloat.add(211f)
+          repeatedDouble.add(212.0)
+          repeatedBool.add(true)
+          repeatedString.add("215")
+          repeatedBytes.add(toBytes("216"))
+          repeatedGroup.add(TestAllTypesKt.repeatedGroup { a = 217 })
+          repeatedNestedMessage.add(nestedMessage { bb = 218 })
+          repeatedForeignMessage.add(foreignMessage { c = 219 })
+          repeatedImportMessage.add(ImportMessage.newBuilder().setD(220).build())
+          repeatedLazyMessage.add(nestedMessage { bb = 227 })
+          repeatedNestedEnum.add(NestedEnum.BAR)
+          repeatedForeignEnum.add(ForeignEnum.FOREIGN_BAR)
+          repeatedImportEnum.add(ImportEnum.IMPORT_BAR)
+          repeatedStringPiece.add("224")
+          repeatedCord.add("225")
+          repeatedInt32 += 301
+          repeatedInt64 += 302
+          repeatedUint32 += 303
+          repeatedUint64 += 304
+          repeatedSint32 += 305
+          repeatedSint64 += 306
+          repeatedFixed32 += 307
+          repeatedFixed64 += 308
+          repeatedSfixed32 += 309
+          repeatedSfixed64 += 310
+          repeatedFloat += 311f
+          repeatedDouble += 312.0
+          repeatedBool += false
+          repeatedString += "315"
+          repeatedBytes += toBytes("316")
+          repeatedGroup += TestAllTypesKt.repeatedGroup { a = 317 }
+          repeatedNestedMessage += nestedMessage { bb = 318 }
+          repeatedForeignMessage += foreignMessage { c = 319 }
+          repeatedImportMessage += ImportMessage.newBuilder().setD(320).build()
+          repeatedLazyMessage += TestAllTypesKt.nestedMessage { bb = 327 }
+          repeatedNestedEnum += NestedEnum.BAZ
+          repeatedForeignEnum += ForeignEnum.FOREIGN_BAZ
+          repeatedImportEnum += ImportEnum.IMPORT_BAZ
+          repeatedStringPiece += "324"
+          repeatedCord += "325"
+          defaultInt32 = 401
+          defaultInt64 = 402
+          defaultUint32 = 403
+          defaultUint64 = 404
+          defaultSint32 = 405
+          defaultSint64 = 406
+          defaultFixed32 = 407
+          defaultFixed64 = 408
+          defaultSfixed32 = 409
+          defaultSfixed64 = 410
+          defaultFloat = 411f
+          defaultDouble = 412.0
+          defaultBool = false
+          defaultString = "415"
+          defaultBytes = toBytes("416")
+          defaultNestedEnum = NestedEnum.FOO
+          defaultForeignEnum = ForeignEnum.FOREIGN_FOO
+          defaultImportEnum = ImportEnum.IMPORT_FOO
+          defaultStringPiece = "424"
+          defaultCord = "425"
+          oneofUint32 = 601
+          oneofNestedMessage = TestAllTypesKt.nestedMessage { bb = 602 }
+          oneofString = "603"
+          oneofBytes = toBytes("604")
+        }
+      )
+      .isEqualTo(TestUtil.getAllSetBuilder().build())
+  }
+
+  @Test
+  fun testGetters() {
+    testAllTypes {
+      optionalInt32 = 101
+      assertThat(optionalInt32).isEqualTo(101)
+      optionalString = "115"
+      assertThat(optionalString).isEqualTo("115")
+      optionalGroup = TestAllTypesKt.optionalGroup { a = 117 }
+      assertThat(optionalGroup).isEqualTo(TestAllTypesKt.optionalGroup { a = 117 })
+      optionalNestedMessage = TestAllTypesKt.nestedMessage { bb = 118 }
+      assertThat(optionalNestedMessage).isEqualTo(TestAllTypesKt.nestedMessage { bb = 118 })
+      optionalNestedEnum = NestedEnum.BAZ
+      assertThat(optionalNestedEnum).isEqualTo(NestedEnum.BAZ)
+      defaultInt32 = 401
+      assertThat(defaultInt32).isEqualTo(401)
+      oneofUint32 = 601
+      assertThat(oneofUint32).isEqualTo(601)
+    }
+  }
+
+  @Test
+  fun testDefaultGetters() {
+    testAllTypes {
+      assertThat(defaultInt32).isEqualTo(41)
+      assertThat(defaultString).isEqualTo("hello")
+      assertThat(defaultNestedEnum).isEqualTo(NestedEnum.BAR)
+      assertThat(defaultStringPiece).isEqualTo("abc")
+    }
+  }
+
+  @Test
+  fun testRepeatedGettersAndSetters() {
+    testAllTypes {
+      repeatedInt32.addAll(listOf(1, 2))
+      assertThat(repeatedInt32).isEqualTo(listOf(1, 2))
+      repeatedInt32 += listOf(3, 4)
+      assertThat(repeatedInt32).isEqualTo(listOf(1, 2, 3, 4))
+      repeatedInt32[0] = 5
+      assertThat(repeatedInt32).isEqualTo(listOf(5, 2, 3, 4))
+
+      repeatedString.addAll(listOf("1", "2"))
+      assertThat(repeatedString).isEqualTo(listOf("1", "2"))
+      repeatedString += listOf("3", "4")
+      assertThat(repeatedString).isEqualTo(listOf("1", "2", "3", "4"))
+      repeatedString[0] = "5"
+      assertThat(repeatedString).isEqualTo(listOf("5", "2", "3", "4"))
+
+      repeatedGroup.addAll(
+        listOf(TestAllTypesKt.repeatedGroup { a = 1 }, TestAllTypesKt.repeatedGroup { a = 2 })
+      )
+      assertThat(repeatedGroup)
+        .isEqualTo(
+          listOf(TestAllTypesKt.repeatedGroup { a = 1 }, TestAllTypesKt.repeatedGroup { a = 2 })
+        )
+      repeatedGroup +=
+        listOf(TestAllTypesKt.repeatedGroup { a = 3 }, TestAllTypesKt.repeatedGroup { a = 4 })
+      assertThat(repeatedGroup)
+        .isEqualTo(
+          listOf(
+            TestAllTypesKt.repeatedGroup { a = 1 },
+            TestAllTypesKt.repeatedGroup { a = 2 },
+            TestAllTypesKt.repeatedGroup { a = 3 },
+            TestAllTypesKt.repeatedGroup { a = 4 }
+          )
+        )
+      repeatedGroup[0] = TestAllTypesKt.repeatedGroup { a = 5 }
+      assertThat(repeatedGroup)
+        .isEqualTo(
+          listOf(
+            TestAllTypesKt.repeatedGroup { a = 5 },
+            TestAllTypesKt.repeatedGroup { a = 2 },
+            TestAllTypesKt.repeatedGroup { a = 3 },
+            TestAllTypesKt.repeatedGroup { a = 4 }
+          )
+        )
+
+      repeatedNestedMessage.addAll(listOf(nestedMessage { bb = 1 }, nestedMessage { bb = 2 }))
+      assertThat(repeatedNestedMessage)
+        .isEqualTo(listOf(nestedMessage { bb = 1 }, nestedMessage { bb = 2 }))
+      repeatedNestedMessage += listOf(nestedMessage { bb = 3 }, nestedMessage { bb = 4 })
+      assertThat(repeatedNestedMessage)
+        .isEqualTo(
+          listOf(
+            nestedMessage { bb = 1 },
+            nestedMessage { bb = 2 },
+            nestedMessage { bb = 3 },
+            nestedMessage { bb = 4 }
+          )
+        )
+      repeatedNestedMessage[0] = nestedMessage { bb = 5 }
+      assertThat(repeatedNestedMessage)
+        .isEqualTo(
+          listOf(
+            nestedMessage { bb = 5 },
+            nestedMessage { bb = 2 },
+            nestedMessage { bb = 3 },
+            nestedMessage { bb = 4 }
+          )
+        )
+
+      repeatedNestedEnum.addAll(listOf(NestedEnum.FOO, NestedEnum.BAR))
+      assertThat(repeatedNestedEnum).isEqualTo(listOf(NestedEnum.FOO, NestedEnum.BAR))
+      repeatedNestedEnum += listOf(NestedEnum.BAZ, NestedEnum.FOO)
+      assertThat(repeatedNestedEnum)
+        .isEqualTo(listOf(NestedEnum.FOO, NestedEnum.BAR, NestedEnum.BAZ, NestedEnum.FOO))
+      repeatedNestedEnum[0] = NestedEnum.BAR
+      assertThat(repeatedNestedEnum)
+        .isEqualTo(listOf(NestedEnum.BAR, NestedEnum.BAR, NestedEnum.BAZ, NestedEnum.FOO))
+    }
+  }
+
+  @Test
+  fun testHazzers() {
+    testAllTypes {
+      optionalInt32 = 101
+      assertThat(hasOptionalInt32()).isTrue()
+      assertThat(hasOptionalString()).isFalse()
+      optionalGroup = TestAllTypesKt.optionalGroup { a = 117 }
+      assertThat(hasOptionalGroup()).isTrue()
+      assertThat(hasOptionalNestedMessage()).isFalse()
+      optionalNestedEnum = NestedEnum.BAZ
+      assertThat(hasOptionalNestedEnum()).isTrue()
+      assertThat(hasDefaultInt32()).isFalse()
+      oneofUint32 = 601
+      assertThat(hasOneofUint32()).isTrue()
+    }
+
+    testAllTypes {
+      assertThat(hasOptionalInt32()).isFalse()
+      optionalString = "115"
+      assertThat(hasOptionalString()).isTrue()
+      assertThat(hasOptionalGroup()).isFalse()
+      optionalNestedMessage = TestAllTypesKt.nestedMessage { bb = 118 }
+      assertThat(hasOptionalNestedMessage()).isTrue()
+      assertThat(hasOptionalNestedEnum()).isFalse()
+      defaultInt32 = 401
+      assertThat(hasDefaultInt32()).isTrue()
+      assertThat(hasOneofUint32()).isFalse()
+    }
+  }
+
+  @Test
+  fun testClears() {
+    testAllTypes {
+      optionalInt32 = 101
+      clearOptionalInt32()
+      assertThat(hasOptionalInt32()).isFalse()
+
+      optionalString = "115"
+      clearOptionalString()
+      assertThat(hasOptionalString()).isFalse()
+
+      optionalGroup = TestAllTypesKt.optionalGroup { a = 117 }
+      clearOptionalGroup()
+      assertThat(hasOptionalGroup()).isFalse()
+
+      optionalNestedMessage = TestAllTypesKt.nestedMessage { bb = 118 }
+      clearOptionalNestedMessage()
+      assertThat(hasOptionalNestedMessage()).isFalse()
+
+      optionalNestedEnum = NestedEnum.BAZ
+      clearOptionalNestedEnum()
+      assertThat(hasOptionalNestedEnum()).isFalse()
+
+      defaultInt32 = 401
+      clearDefaultInt32()
+      assertThat(hasDefaultInt32()).isFalse()
+
+      oneofUint32 = 601
+      clearOneofUint32()
+      assertThat(hasOneofUint32()).isFalse()
+    }
+  }
+
+  @Test
+  fun testCopy() {
+    val message = testAllTypes {
+      optionalInt32 = 101
+      optionalString = "115"
+    }
+    val modifiedMessage = message.copy { optionalInt32 = 201 }
+
+    assertThat(message)
+      .isEqualTo(TestAllTypes.newBuilder().setOptionalInt32(101).setOptionalString("115").build())
+    assertThat(modifiedMessage)
+      .isEqualTo(TestAllTypes.newBuilder().setOptionalInt32(201).setOptionalString("115").build())
+  }
+
+  @Test
+  fun testOneof() {
+    val message = testAllTypes {
+      oneofString = "foo"
+      assertThat(oneofFieldCase).isEqualTo(TestAllTypes.OneofFieldCase.ONEOF_STRING)
+      assertThat(oneofString).isEqualTo("foo")
+      clearOneofField()
+      assertThat(hasOneofUint32()).isFalse()
+      assertThat(oneofFieldCase).isEqualTo(TestAllTypes.OneofFieldCase.ONEOFFIELD_NOT_SET)
+      oneofUint32 = 5
+    }
+
+    assertThat(message.getOneofFieldCase()).isEqualTo(TestAllTypes.OneofFieldCase.ONEOF_UINT32)
+    assertThat(message.getOneofUint32()).isEqualTo(5)
+  }
+
+  @Test
+  fun testExtensionsSet() {
+    assertThat(
+        testAllExtensions {
+          this[UnittestProto.optionalInt32Extension] = 101
+          this[UnittestProto.optionalInt64Extension] = 102L
+          this[UnittestProto.optionalUint32Extension] = 103
+          this[UnittestProto.optionalUint64Extension] = 104L
+          this[UnittestProto.optionalSint32Extension] = 105
+          this[UnittestProto.optionalSint64Extension] = 106L
+          this[UnittestProto.optionalFixed32Extension] = 107
+          this[UnittestProto.optionalFixed64Extension] = 108L
+          this[UnittestProto.optionalSfixed32Extension] = 109
+          this[UnittestProto.optionalSfixed64Extension] = 110L
+          this[UnittestProto.optionalFloatExtension] = 111F
+          this[UnittestProto.optionalDoubleExtension] = 112.0
+          this[UnittestProto.optionalBoolExtension] = true
+          this[UnittestProto.optionalStringExtension] = "115"
+          this[UnittestProto.optionalBytesExtension] = toBytes("116")
+          this[UnittestProto.optionalGroupExtension] = optionalGroupExtension { a = 117 }
+          this[UnittestProto.optionalNestedMessageExtension] =
+            TestAllTypesKt.nestedMessage { bb = 118 }
+          this[UnittestProto.optionalForeignMessageExtension] = foreignMessage { c = 119 }
+          this[UnittestProto.optionalImportMessageExtension] =
+            ImportMessage.newBuilder().setD(120).build()
+          this[UnittestProto.optionalPublicImportMessageExtension] =
+            PublicImportMessage.newBuilder().setE(126).build()
+          this[UnittestProto.optionalLazyMessageExtension] =
+            TestAllTypesKt.nestedMessage { bb = 127 }
+          this[UnittestProto.optionalNestedEnumExtension] = NestedEnum.BAZ
+          this[UnittestProto.optionalForeignEnumExtension] = ForeignEnum.FOREIGN_BAZ
+          this[UnittestProto.optionalImportEnumExtension] = ImportEnum.IMPORT_BAZ
+          this[UnittestProto.optionalStringPieceExtension] = "124"
+          this[UnittestProto.optionalCordExtension] = "125"
+          this[UnittestProto.repeatedInt32Extension].add(201)
+          this[UnittestProto.repeatedInt64Extension].add(202L)
+          this[UnittestProto.repeatedUint32Extension].add(203)
+          this[UnittestProto.repeatedUint64Extension].add(204L)
+          this[UnittestProto.repeatedSint32Extension].add(205)
+          this[UnittestProto.repeatedSint64Extension].add(206L)
+          this[UnittestProto.repeatedFixed32Extension].add(207)
+          this[UnittestProto.repeatedFixed64Extension].add(208L)
+          this[UnittestProto.repeatedSfixed32Extension].add(209)
+          this[UnittestProto.repeatedSfixed64Extension].add(210L)
+          this[UnittestProto.repeatedFloatExtension].add(211F)
+          this[UnittestProto.repeatedDoubleExtension].add(212.0)
+          this[UnittestProto.repeatedBoolExtension].add(true)
+          this[UnittestProto.repeatedStringExtension].add("215")
+          this[UnittestProto.repeatedBytesExtension].add(toBytes("216"))
+          this[UnittestProto.repeatedGroupExtension].add(repeatedGroupExtension { a = 217 })
+          this[UnittestProto.repeatedNestedMessageExtension].add(
+            TestAllTypesKt.nestedMessage { bb = 218 }
+          )
+          this[UnittestProto.repeatedForeignMessageExtension].add(foreignMessage { c = 219 })
+          this[UnittestProto.repeatedImportMessageExtension].add(
+            ImportMessage.newBuilder().setD(220).build()
+          )
+          this[UnittestProto.repeatedLazyMessageExtension].add(
+            TestAllTypesKt.nestedMessage { bb = 227 }
+          )
+          this[UnittestProto.repeatedNestedEnumExtension].add(NestedEnum.BAR)
+          this[UnittestProto.repeatedForeignEnumExtension].add(ForeignEnum.FOREIGN_BAR)
+          this[UnittestProto.repeatedImportEnumExtension].add(ImportEnum.IMPORT_BAR)
+          this[UnittestProto.repeatedStringPieceExtension].add("224")
+          this[UnittestProto.repeatedCordExtension].add("225")
+          this[UnittestProto.repeatedInt32Extension] += 301
+          this[UnittestProto.repeatedInt64Extension] += 302L
+          this[UnittestProto.repeatedUint32Extension] += 303
+          this[UnittestProto.repeatedUint64Extension] += 304L
+          this[UnittestProto.repeatedSint32Extension] += 305
+          this[UnittestProto.repeatedSint64Extension] += 306L
+          this[UnittestProto.repeatedFixed32Extension] += 307
+          this[UnittestProto.repeatedFixed64Extension] += 308L
+          this[UnittestProto.repeatedSfixed32Extension] += 309
+          this[UnittestProto.repeatedSfixed64Extension] += 310L
+          this[UnittestProto.repeatedFloatExtension] += 311F
+          this[UnittestProto.repeatedDoubleExtension] += 312.0
+          this[UnittestProto.repeatedBoolExtension] += false
+          this[UnittestProto.repeatedStringExtension] += "315"
+          this[UnittestProto.repeatedBytesExtension] += toBytes("316")
+          this[UnittestProto.repeatedGroupExtension] += repeatedGroupExtension { a = 317 }
+          this[UnittestProto.repeatedNestedMessageExtension] +=
+            TestAllTypesKt.nestedMessage { bb = 318 }
+          this[UnittestProto.repeatedForeignMessageExtension] += foreignMessage { c = 319 }
+          this[UnittestProto.repeatedImportMessageExtension] +=
+            ImportMessage.newBuilder().setD(320).build()
+          this[UnittestProto.repeatedLazyMessageExtension] +=
+            TestAllTypesKt.nestedMessage { bb = 327 }
+          this[UnittestProto.repeatedNestedEnumExtension] += NestedEnum.BAZ
+          this[UnittestProto.repeatedForeignEnumExtension] += ForeignEnum.FOREIGN_BAZ
+          this[UnittestProto.repeatedImportEnumExtension] += ImportEnum.IMPORT_BAZ
+          this[UnittestProto.repeatedStringPieceExtension] += "324"
+          this[UnittestProto.repeatedCordExtension] += "325"
+          this[UnittestProto.defaultInt32Extension] = 401
+          this[UnittestProto.defaultInt64Extension] = 402L
+          this[UnittestProto.defaultUint32Extension] = 403
+          this[UnittestProto.defaultUint64Extension] = 404L
+          this[UnittestProto.defaultSint32Extension] = 405
+          this[UnittestProto.defaultSint64Extension] = 406L
+          this[UnittestProto.defaultFixed32Extension] = 407
+          this[UnittestProto.defaultFixed64Extension] = 408L
+          this[UnittestProto.defaultSfixed32Extension] = 409
+          this[UnittestProto.defaultSfixed64Extension] = 410L
+          this[UnittestProto.defaultFloatExtension] = 411F
+          this[UnittestProto.defaultDoubleExtension] = 412.0
+          this[UnittestProto.defaultBoolExtension] = false
+          this[UnittestProto.defaultStringExtension] = "415"
+          this[UnittestProto.defaultBytesExtension] = toBytes("416")
+          this[UnittestProto.defaultNestedEnumExtension] = NestedEnum.FOO
+          this[UnittestProto.defaultForeignEnumExtension] = ForeignEnum.FOREIGN_FOO
+          this[UnittestProto.defaultImportEnumExtension] = ImportEnum.IMPORT_FOO
+          this[UnittestProto.defaultStringPieceExtension] = "424"
+          this[UnittestProto.defaultCordExtension] = "425"
+          this[UnittestProto.oneofUint32Extension] = 601
+          this[UnittestProto.oneofNestedMessageExtension] =
+            TestAllTypesKt.nestedMessage { bb = 602 }
+          this[UnittestProto.oneofStringExtension] = "603"
+          this[UnittestProto.oneofBytesExtension] = toBytes("604")
+        }
+      )
+      .isEqualTo(TestUtil.getAllExtensionsSet())
+  }
+
+  @Test
+  fun testExtensionGetters() {
+    testAllExtensions {
+      this[UnittestProto.optionalInt32Extension] = 101
+      assertThat(this[UnittestProto.optionalInt32Extension]).isEqualTo(101)
+      this[UnittestProto.optionalStringExtension] = "115"
+      assertThat(this[UnittestProto.optionalStringExtension]).isEqualTo("115")
+      this[UnittestProto.optionalGroupExtension] = optionalGroupExtension { a = 117 }
+      assertThat(this[UnittestProto.optionalGroupExtension])
+        .isEqualTo(optionalGroupExtension { a = 117 })
+      this[UnittestProto.optionalNestedMessageExtension] = TestAllTypesKt.nestedMessage { bb = 118 }
+      assertThat(this[UnittestProto.optionalNestedMessageExtension])
+        .isEqualTo(TestAllTypesKt.nestedMessage { bb = 118 })
+      this[UnittestProto.optionalNestedEnumExtension] = NestedEnum.BAZ
+      assertThat(this[UnittestProto.optionalNestedEnumExtension]).isEqualTo(NestedEnum.BAZ)
+      this[UnittestProto.defaultInt32Extension] = 401
+      assertThat(this[UnittestProto.defaultInt32Extension]).isEqualTo(401)
+      this[UnittestProto.oneofUint32Extension] = 601
+      assertThat(this[UnittestProto.oneofUint32Extension]).isEqualTo(601)
+    }
+  }
+
+  @Test
+  fun testRepeatedExtensionGettersAndSetters() {
+    testAllExtensions {
+      this[UnittestProto.repeatedInt32Extension].addAll(listOf(1, 2))
+      assertThat(this[UnittestProto.repeatedInt32Extension]).isEqualTo(listOf(1, 2))
+      this[UnittestProto.repeatedInt32Extension] += listOf(3, 4)
+      assertThat(this[UnittestProto.repeatedInt32Extension]).isEqualTo(listOf(1, 2, 3, 4))
+      this[UnittestProto.repeatedInt32Extension][0] = 5
+      assertThat(this[UnittestProto.repeatedInt32Extension]).isEqualTo(listOf(5, 2, 3, 4))
+
+      this[UnittestProto.repeatedStringExtension].addAll(listOf("1", "2"))
+      assertThat(this[UnittestProto.repeatedStringExtension]).isEqualTo(listOf("1", "2"))
+      this[UnittestProto.repeatedStringExtension] += listOf("3", "4")
+      assertThat(this[UnittestProto.repeatedStringExtension]).isEqualTo(listOf("1", "2", "3", "4"))
+      this[UnittestProto.repeatedStringExtension][0] = "5"
+      assertThat(this[UnittestProto.repeatedStringExtension]).isEqualTo(listOf("5", "2", "3", "4"))
+
+      this[UnittestProto.repeatedGroupExtension].addAll(
+        listOf(repeatedGroupExtension { a = 1 }, repeatedGroupExtension { a = 2 })
+      )
+      assertThat(this[UnittestProto.repeatedGroupExtension])
+        .isEqualTo(listOf(repeatedGroupExtension { a = 1 }, repeatedGroupExtension { a = 2 }))
+      this[UnittestProto.repeatedGroupExtension] +=
+        listOf(repeatedGroupExtension { a = 3 }, repeatedGroupExtension { a = 4 })
+      assertThat(this[UnittestProto.repeatedGroupExtension])
+        .isEqualTo(
+          listOf(
+            repeatedGroupExtension { a = 1 },
+            repeatedGroupExtension { a = 2 },
+            repeatedGroupExtension { a = 3 },
+            repeatedGroupExtension { a = 4 }
+          )
+        )
+      this[UnittestProto.repeatedGroupExtension][0] = repeatedGroupExtension { a = 5 }
+      assertThat(this[UnittestProto.repeatedGroupExtension])
+        .isEqualTo(
+          listOf(
+            repeatedGroupExtension { a = 5 },
+            repeatedGroupExtension { a = 2 },
+            repeatedGroupExtension { a = 3 },
+            repeatedGroupExtension { a = 4 }
+          )
+        )
+
+      this[UnittestProto.repeatedNestedMessageExtension].addAll(
+        listOf(nestedMessage { bb = 1 }, nestedMessage { bb = 2 })
+      )
+      assertThat(this[UnittestProto.repeatedNestedMessageExtension])
+        .isEqualTo(listOf(nestedMessage { bb = 1 }, nestedMessage { bb = 2 }))
+      this[UnittestProto.repeatedNestedMessageExtension] +=
+        listOf(nestedMessage { bb = 3 }, nestedMessage { bb = 4 })
+      assertThat(this[UnittestProto.repeatedNestedMessageExtension])
+        .isEqualTo(
+          listOf(
+            nestedMessage { bb = 1 },
+            nestedMessage { bb = 2 },
+            nestedMessage { bb = 3 },
+            nestedMessage { bb = 4 }
+          )
+        )
+      this[UnittestProto.repeatedNestedMessageExtension][0] = nestedMessage { bb = 5 }
+      assertThat(this[UnittestProto.repeatedNestedMessageExtension])
+        .isEqualTo(
+          listOf(
+            nestedMessage { bb = 5 },
+            nestedMessage { bb = 2 },
+            nestedMessage { bb = 3 },
+            nestedMessage { bb = 4 }
+          )
+        )
+
+      this[UnittestProto.repeatedNestedEnumExtension].addAll(listOf(NestedEnum.FOO, NestedEnum.BAR))
+      assertThat(this[UnittestProto.repeatedNestedEnumExtension])
+        .isEqualTo(listOf(NestedEnum.FOO, NestedEnum.BAR))
+      this[UnittestProto.repeatedNestedEnumExtension] += listOf(NestedEnum.BAZ, NestedEnum.FOO)
+      assertThat(this[UnittestProto.repeatedNestedEnumExtension])
+        .isEqualTo(listOf(NestedEnum.FOO, NestedEnum.BAR, NestedEnum.BAZ, NestedEnum.FOO))
+    }
+  }
+
+  @Test
+  fun testExtensionContains() {
+    testAllExtensions {
+      this[UnittestProto.optionalInt32Extension] = 101
+      assertThat(contains(UnittestProto.optionalInt32Extension)).isTrue()
+      assertThat(contains(UnittestProto.optionalStringExtension)).isFalse()
+      this[UnittestProto.optionalGroupExtension] = optionalGroupExtension { a = 117 }
+      assertThat(contains(UnittestProto.optionalGroupExtension)).isTrue()
+      assertThat(contains(UnittestProto.optionalNestedMessageExtension)).isFalse()
+      this[UnittestProto.optionalNestedEnumExtension] = NestedEnum.BAZ
+      assertThat(contains(UnittestProto.optionalNestedEnumExtension)).isTrue()
+      assertThat(contains(UnittestProto.defaultInt32Extension)).isFalse()
+      this[UnittestProto.oneofUint32Extension] = 601
+      assertThat(contains(UnittestProto.optionalInt32Extension)).isTrue()
+    }
+
+    testAllExtensions {
+      assertThat(contains(UnittestProto.optionalInt32Extension)).isFalse()
+      this[UnittestProto.optionalStringExtension] = "115"
+      assertThat(contains(UnittestProto.optionalStringExtension)).isTrue()
+      assertThat(contains(UnittestProto.optionalGroupExtension)).isFalse()
+      this[UnittestProto.optionalNestedMessageExtension] = TestAllTypesKt.nestedMessage { bb = 118 }
+      assertThat(contains(UnittestProto.optionalNestedMessageExtension)).isTrue()
+      assertThat(contains(UnittestProto.optionalNestedEnumExtension)).isFalse()
+      this[UnittestProto.defaultInt32Extension] = 401
+      assertThat(contains(UnittestProto.defaultInt32Extension)).isTrue()
+      assertThat(contains(UnittestProto.oneofUint32Extension)).isFalse()
+    }
+  }
+
+  @Test
+  fun testExtensionClears() {
+    testAllExtensions {
+      this[UnittestProto.optionalInt32Extension] = 101
+      clear(UnittestProto.optionalInt32Extension)
+      assertThat(contains(UnittestProto.optionalInt32Extension)).isFalse()
+
+      this[UnittestProto.optionalStringExtension] = "115"
+      clear(UnittestProto.optionalStringExtension)
+      assertThat(contains(UnittestProto.optionalStringExtension)).isFalse()
+
+      this[UnittestProto.optionalGroupExtension] = optionalGroupExtension { a = 117 }
+      clear(UnittestProto.optionalGroupExtension)
+      assertThat(contains(UnittestProto.optionalGroupExtension)).isFalse()
+
+      this[UnittestProto.optionalNestedMessageExtension] = TestAllTypesKt.nestedMessage { bb = 118 }
+      clear(UnittestProto.optionalNestedMessageExtension)
+      assertThat(contains(UnittestProto.optionalNestedMessageExtension)).isFalse()
+
+      this[UnittestProto.optionalNestedEnumExtension] = NestedEnum.BAZ
+      clear(UnittestProto.optionalNestedEnumExtension)
+      assertThat(contains(UnittestProto.optionalNestedEnumExtension)).isFalse()
+
+      this[UnittestProto.defaultInt32Extension] = 401
+      clear(UnittestProto.defaultInt32Extension)
+      assertThat(contains(UnittestProto.oneofUint32Extension)).isFalse()
+    }
+  }
+
+  @Test
+  fun testEmptyMessages() {
+    assertThat(testEmptyMessage {}).isEqualTo(TestEmptyMessage.newBuilder().build())
+
+    assertThat(testEmptyMessageWithExtensions {})
+      .isEqualTo(TestEmptyMessageWithExtensions.newBuilder().build())
+  }
+
+  @Test
+  fun testMapSetters() {
+    val intMap = testIntIntMap { m[1] = 2 }
+    assertThat(intMap).isEqualTo(TestIntIntMap.newBuilder().putM(1, 2).build())
+
+    assertThat(
+        testMaps {
+          mInt32[1] = intMap
+          mInt64[1L] = intMap
+          mUint32[1] = intMap
+          mUint64[1L] = intMap
+          mSint32[1] = intMap
+          mSint64[1L] = intMap
+          mFixed32[1] = intMap
+          mFixed64[1L] = intMap
+          mSfixed32[1] = intMap
+          mSfixed64[1] = intMap
+          mBool[true] = intMap
+          mString["1"] = intMap
+        }
+      )
+      .isEqualTo(
+        TestMaps.newBuilder()
+          .putMInt32(1, intMap)
+          .putMInt64(1L, intMap)
+          .putMUint32(1, intMap)
+          .putMUint64(1L, intMap)
+          .putMSint32(1, intMap)
+          .putMSint64(1L, intMap)
+          .putMFixed32(1, intMap)
+          .putMFixed64(1L, intMap)
+          .putMSfixed32(1, intMap)
+          .putMSfixed64(1L, intMap)
+          .putMBool(true, intMap)
+          .putMString("1", intMap)
+          .build()
+      )
+
+    assertThat(testEnumMap { knownMapField[1] = Proto2MapEnum.PROTO2_MAP_ENUM_FOO })
+      .isEqualTo(
+        TestEnumMap.newBuilder().putKnownMapField(1, Proto2MapEnum.PROTO2_MAP_ENUM_FOO).build()
+      )
+  }
+
+  @Test
+  fun testMapGettersAndSetters() {
+    val intMap = testIntIntMap {
+      m.put(1, 2)
+      assertThat(m).isEqualTo(mapOf(1 to 2))
+      m[3] = 4
+      assertThat(m).isEqualTo(mapOf(1 to 2, 3 to 4))
+      m.putAll(mapOf(5 to 6, 7 to 8))
+      assertThat(m).isEqualTo(mapOf(1 to 2, 3 to 4, 5 to 6, 7 to 8))
+    }
+
+    testMaps {
+      mInt32.put(1, intMap)
+      assertThat(mInt32).isEqualTo(mapOf(1 to intMap))
+      mInt32[2] = intMap
+      assertThat(mInt32).isEqualTo(mapOf(1 to intMap, 2 to intMap))
+      mInt32.putAll(mapOf(3 to intMap, 4 to intMap))
+      assertThat(mInt32).isEqualTo(mapOf(1 to intMap, 2 to intMap, 3 to intMap, 4 to intMap))
+
+      mString.put("1", intMap)
+      assertThat(mString).isEqualTo(mapOf("1" to intMap))
+      mString["2"] = intMap
+      assertThat(mString).isEqualTo(mapOf("1" to intMap, "2" to intMap))
+      mString.putAll(mapOf("3" to intMap, "4" to intMap))
+      assertThat(mString)
+        .isEqualTo(mapOf("1" to intMap, "2" to intMap, "3" to intMap, "4" to intMap))
+    }
+
+    testEnumMap {
+      knownMapField.put(1, Proto2MapEnum.PROTO2_MAP_ENUM_FOO)
+      assertThat(knownMapField).isEqualTo(mapOf(1 to Proto2MapEnum.PROTO2_MAP_ENUM_FOO))
+      knownMapField[2] = Proto2MapEnum.PROTO2_MAP_ENUM_BAR
+      assertThat(knownMapField)
+        .isEqualTo(
+          mapOf(1 to Proto2MapEnum.PROTO2_MAP_ENUM_FOO, 2 to Proto2MapEnum.PROTO2_MAP_ENUM_BAR)
+        )
+      knownMapField.putAll(
+        mapOf(3 to Proto2MapEnum.PROTO2_MAP_ENUM_BAZ, 4 to Proto2MapEnum.PROTO2_MAP_ENUM_FOO)
+      )
+      assertThat(knownMapField)
+        .isEqualTo(
+          mapOf(
+            1 to Proto2MapEnum.PROTO2_MAP_ENUM_FOO,
+            2 to Proto2MapEnum.PROTO2_MAP_ENUM_BAR,
+            3 to Proto2MapEnum.PROTO2_MAP_ENUM_BAZ,
+            4 to Proto2MapEnum.PROTO2_MAP_ENUM_FOO
+          )
+        )
+    }
+  }
+
+  @Test
+  fun testMapRemove() {
+    val intMap = testIntIntMap {
+      m.putAll(mapOf(1 to 2, 3 to 4))
+      m.remove(1)
+      assertThat(m).isEqualTo(mapOf(3 to 4))
+    }
+
+    testMaps {
+      mInt32.putAll(mapOf(1 to intMap, 2 to intMap))
+      mInt32.remove(1)
+      assertThat(mInt32).isEqualTo(mapOf(2 to intMap))
+
+      mString.putAll(mapOf("1" to intMap, "2" to intMap))
+      mString.remove("1")
+      assertThat(mString).isEqualTo(mapOf("2" to intMap))
+    }
+
+    testEnumMap {
+      knownMapField.putAll(
+        mapOf(1 to Proto2MapEnum.PROTO2_MAP_ENUM_FOO, 2 to Proto2MapEnum.PROTO2_MAP_ENUM_BAR)
+      )
+      knownMapField.remove(1)
+      assertThat(knownMapField).isEqualTo(mapOf(2 to Proto2MapEnum.PROTO2_MAP_ENUM_BAR))
+    }
+  }
+
+  @Test
+  fun testMapClear() {
+    val intMap = testIntIntMap {
+      m.putAll(mapOf(1 to 2, 3 to 4))
+      m.clear()
+      assertThat(m.isEmpty()).isTrue()
+    }
+
+    testMaps {
+      mInt32.putAll(mapOf(1 to intMap, 2 to intMap))
+      mInt32.clear()
+      assertThat(mInt32.isEmpty()).isTrue()
+
+      mString.putAll(mapOf("1" to intMap, "2" to intMap))
+      mString.clear()
+      assertThat(mString.isEmpty()).isTrue()
+    }
+
+    testEnumMap {
+      knownMapField.putAll(
+        mapOf(1 to Proto2MapEnum.PROTO2_MAP_ENUM_FOO, 2 to Proto2MapEnum.PROTO2_MAP_ENUM_BAR)
+      )
+      knownMapField.clear()
+      assertThat(knownMapField.isEmpty()).isTrue()
+    }
+  }
+
+  @Test
+  fun testEvilNames() {
+    assertThat(
+        evilNamesProto2 {
+          initialized = true
+          hasFoo = true
+          bar = "foo"
+          isInitialized = true
+          fooBar = "foo"
+          aLLCAPS += "foo"
+          aLLCAPSMAP[1] = true
+          hasUnderbarPrecedingNumeric1Foo = true
+          hasUnderbarPrecedingNumeric42Bar = true
+          hasUnderbarPrecedingNumeric123Foo42BarBaz = true
+          extension += "foo"
+          class_ += 1
+          int = 1.0
+          long = true
+          boolean = 1L
+          sealed = "foo"
+          interface_ = 1F
+          in_ = 1
+          object_ = "foo"
+          cachedSize_ = "foo"
+          serializedSize_ = true
+          by = "foo"
+        }
+      )
+      .isEqualTo(
+        EvilNamesProto2.newBuilder()
+          .setInitialized(true)
+          .setHasFoo(true)
+          .setBar("foo")
+          .setIsInitialized(true)
+          .setFooBar("foo")
+          .addALLCAPS("foo")
+          .putALLCAPSMAP(1, true)
+          .setHasUnderbarPrecedingNumeric1Foo(true)
+          .setHasUnderbarPrecedingNumeric42Bar(true)
+          .setHasUnderbarPrecedingNumeric123Foo42BarBaz(true)
+          .addExtension("foo")
+          .addClass_(1)
+          .setInt(1.0)
+          .setLong(true)
+          .setBoolean(1L)
+          .setSealed("foo")
+          .setInterface(1F)
+          .setIn(1)
+          .setObject("foo")
+          .setCachedSize_("foo")
+          .setSerializedSize_(true)
+          .setBy("foo")
+          .build()
+      )
+
+    assertThat(interface_ {}).isEqualTo(Interface.newBuilder().build())
+  }
+
+  @Test
+  fun testHardKeywordGettersAndSetters() {
+    hardKeywordsAllTypesProto2 {
+      as_ = 1
+      assertThat(as_).isEqualTo(1)
+
+      in_ = "foo"
+      assertThat(in_).isEqualTo("foo")
+
+      break_ = HardKeywordsAllTypesProto2.NestedEnum.FOO
+      assertThat(break_).isEqualTo(HardKeywordsAllTypesProto2.NestedEnum.FOO)
+
+      do_ = HardKeywordsAllTypesProto2Kt.nestedMessage { while_ = 1 }
+      assertThat(do_).isEqualTo(HardKeywordsAllTypesProto2Kt.nestedMessage { while_ = 1 })
+
+      continue_[1] = 1
+      assertThat(continue_[1]).isEqualTo(1)
+
+      else_ += 1
+      assertThat(else_).isEqualTo(listOf(1))
+
+      for_ += "foo"
+      assertThat(for_).isEqualTo(listOf("foo"))
+
+      fun_ += HardKeywordsAllTypesProto2.NestedEnum.FOO
+      assertThat(fun_).isEqualTo(listOf(HardKeywordsAllTypesProto2.NestedEnum.FOO))
+
+      if_ += HardKeywordsAllTypesProto2Kt.nestedMessage { while_ = 1 }
+      assertThat(if_).isEqualTo(listOf(HardKeywordsAllTypesProto2Kt.nestedMessage { while_ = 1 }))
+    }
+  }
+
+  @Test
+  fun testHardKeywordHazzers() {
+    hardKeywordsAllTypesProto2 {
+      as_ = 1
+      assertThat(hasAs_()).isTrue()
+
+      in_ = "foo"
+      assertThat(hasIn_()).isTrue()
+
+      break_ = HardKeywordsAllTypesProto2.NestedEnum.FOO
+      assertThat(hasBreak_()).isTrue()
+
+      do_ = HardKeywordsAllTypesProto2Kt.nestedMessage { while_ = 1 }
+      assertThat(hasDo_()).isTrue()
+    }
+  }
+
+  @Test
+  fun testHardKeywordClears() {
+    hardKeywordsAllTypesProto2 {
+      as_ = 1
+      clearAs_()
+      assertThat(hasAs_()).isFalse()
+
+      in_ = "foo"
+      clearIn_()
+      assertThat(hasIn_()).isFalse()
+
+      break_ = HardKeywordsAllTypesProto2.NestedEnum.FOO
+      clearBreak_()
+      assertThat(hasBreak_()).isFalse()
+
+      do_ = HardKeywordsAllTypesProto2Kt.nestedMessage { while_ = 1 }
+      clearDo_()
+      assertThat(hasDo_()).isFalse()
+    }
+  }
+
+  @Test
+  fun testGetOrNull() {
+    val noNestedMessage = testAllTypes {}
+    assertThat(noNestedMessage.optionalNestedMessageOrNull).isEqualTo(null)
+
+    val someNestedMessage = testAllTypes {
+      optionalNestedMessage = TestAllTypesKt.nestedMessage { bb = 118 }
+    }
+    assertThat(someNestedMessage.optionalNestedMessageOrNull)
+      .isEqualTo(TestAllTypesKt.nestedMessage { bb = 118 })
+  }
+}

deps/protobuf/java/kotlin/src/test/kotlin/com/google/protobuf/Proto3Test.kt

@@ -0,0 +1,355 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package com.google.protobuf.kotlin
+
+import com.google.common.truth.Truth.assertThat
+import com.google.protobuf.kotlin.generator.EvilNamesProto3OuterClass.Class
+import com.google.protobuf.kotlin.generator.EvilNamesProto3OuterClass.EvilNamesProto3
+import com.google.protobuf.kotlin.generator.EvilNamesProto3OuterClass.HardKeywordsAllTypesProto3
+import com.google.protobuf.kotlin.generator.HardKeywordsAllTypesProto3Kt
+import com.google.protobuf.kotlin.generator.class_
+import com.google.protobuf.kotlin.generator.evilNamesProto3
+import com.google.protobuf.kotlin.generator.hardKeywordsAllTypesProto3
+import proto3_unittest.TestAllTypesKt
+import proto3_unittest.TestAllTypesKt.nestedMessage
+import proto3_unittest.UnittestProto3.TestAllTypes
+import proto3_unittest.UnittestProto3.TestAllTypes.NestedEnum
+import proto3_unittest.UnittestProto3.TestEmptyMessage
+import proto3_unittest.copy
+import proto3_unittest.optionalForeignMessageOrNull
+import proto3_unittest.optionalNestedMessageOrNull
+import proto3_unittest.testAllTypes
+import proto3_unittest.testEmptyMessage
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+
+@RunWith(JUnit4::class)
+class Proto3Test {
+  @Test
+  fun testGettersAndSetters() {
+    testAllTypes {
+      optionalInt32 = 101
+      assertThat(optionalInt32).isEqualTo(101)
+      optionalString = "115"
+      assertThat(optionalString).isEqualTo("115")
+      optionalNestedMessage = TestAllTypesKt.nestedMessage { bb = 118 }
+      assertThat(optionalNestedMessage).isEqualTo(TestAllTypesKt.nestedMessage { bb = 118 })
+      optionalNestedEnum = NestedEnum.BAZ
+      assertThat(optionalNestedEnum).isEqualTo(NestedEnum.BAZ)
+      oneofUint32 = 601
+      assertThat(oneofUint32).isEqualTo(601)
+    }
+  }
+
+  @Test
+  fun testRepeatedGettersAndSetters() {
+    testAllTypes {
+      repeatedInt32.addAll(listOf(1, 2))
+      assertThat(repeatedInt32).isEqualTo(listOf(1, 2))
+      repeatedInt32 += listOf(3, 4)
+      assertThat(repeatedInt32).isEqualTo(listOf(1, 2, 3, 4))
+      repeatedInt32[0] = 5
+      assertThat(repeatedInt32).isEqualTo(listOf(5, 2, 3, 4))
+
+      repeatedString.addAll(listOf("1", "2"))
+      assertThat(repeatedString).isEqualTo(listOf("1", "2"))
+      repeatedString += listOf("3", "4")
+      assertThat(repeatedString).isEqualTo(listOf("1", "2", "3", "4"))
+      repeatedString[0] = "5"
+      assertThat(repeatedString).isEqualTo(listOf("5", "2", "3", "4"))
+
+      repeatedNestedMessage.addAll(listOf(nestedMessage { bb = 1 }, nestedMessage { bb = 2 }))
+      assertThat(repeatedNestedMessage)
+        .isEqualTo(listOf(nestedMessage { bb = 1 }, nestedMessage { bb = 2 }))
+      repeatedNestedMessage += listOf(nestedMessage { bb = 3 }, nestedMessage { bb = 4 })
+      assertThat(repeatedNestedMessage)
+        .isEqualTo(
+          listOf(
+            nestedMessage { bb = 1 },
+            nestedMessage { bb = 2 },
+            nestedMessage { bb = 3 },
+            nestedMessage { bb = 4 }
+          )
+        )
+      repeatedNestedMessage[0] = nestedMessage { bb = 5 }
+      assertThat(repeatedNestedMessage)
+        .isEqualTo(
+          listOf(
+            nestedMessage { bb = 5 },
+            nestedMessage { bb = 2 },
+            nestedMessage { bb = 3 },
+            nestedMessage { bb = 4 }
+          )
+        )
+
+      repeatedNestedEnum.addAll(listOf(NestedEnum.FOO, NestedEnum.BAR))
+      assertThat(repeatedNestedEnum).isEqualTo(listOf(NestedEnum.FOO, NestedEnum.BAR))
+      repeatedNestedEnum += listOf(NestedEnum.BAZ, NestedEnum.FOO)
+      assertThat(repeatedNestedEnum)
+        .isEqualTo(listOf(NestedEnum.FOO, NestedEnum.BAR, NestedEnum.BAZ, NestedEnum.FOO))
+      repeatedNestedEnum[0] = NestedEnum.BAR
+      assertThat(repeatedNestedEnum)
+        .isEqualTo(listOf(NestedEnum.BAR, NestedEnum.BAR, NestedEnum.BAZ, NestedEnum.FOO))
+    }
+  }
+
+  @Test
+  fun testClears() {
+    assertThat(
+        testAllTypes {
+          optionalInt32 = 101
+          clearOptionalInt32()
+
+          optionalString = "115"
+          clearOptionalString()
+
+          optionalNestedMessage = TestAllTypesKt.nestedMessage { bb = 118 }
+          clearOptionalNestedMessage()
+
+          optionalNestedEnum = NestedEnum.BAZ
+          clearOptionalNestedEnum()
+
+          oneofUint32 = 601
+          clearOneofUint32()
+        }
+      )
+      .isEqualTo(TestAllTypes.newBuilder().build())
+  }
+
+  @Test
+  fun testCopy() {
+    val message = testAllTypes {
+      optionalInt32 = 101
+      optionalString = "115"
+    }
+    val modifiedMessage = message.copy { optionalInt32 = 201 }
+
+    assertThat(message)
+      .isEqualTo(TestAllTypes.newBuilder().setOptionalInt32(101).setOptionalString("115").build())
+    assertThat(modifiedMessage)
+      .isEqualTo(TestAllTypes.newBuilder().setOptionalInt32(201).setOptionalString("115").build())
+  }
+
+  @Test
+  fun testOneof() {
+    val message = testAllTypes {
+      oneofString = "foo"
+      assertThat(oneofFieldCase).isEqualTo(TestAllTypes.OneofFieldCase.ONEOF_STRING)
+      assertThat(oneofString).isEqualTo("foo")
+      clearOneofField()
+      assertThat(oneofFieldCase).isEqualTo(TestAllTypes.OneofFieldCase.ONEOFFIELD_NOT_SET)
+      oneofUint32 = 5
+    }
+
+    assertThat(message.getOneofFieldCase()).isEqualTo(TestAllTypes.OneofFieldCase.ONEOF_UINT32)
+    assertThat(message.getOneofUint32()).isEqualTo(5)
+  }
+
+  @Test
+  fun testEmptyMessages() {
+    assertThat(testEmptyMessage {}).isEqualTo(TestEmptyMessage.newBuilder().build())
+  }
+
+  @Test
+  fun testEvilNames() {
+    assertThat(
+        evilNamesProto3 {
+          initialized = true
+          hasFoo = true
+          bar = "foo"
+          isInitialized = true
+          fooBar = "foo"
+          aLLCAPS += "foo"
+          aLLCAPSMAP[1] = true
+          hasUnderbarPrecedingNumeric1Foo = true
+          hasUnderbarPrecedingNumeric42Bar = true
+          hasUnderbarPrecedingNumeric123Foo42BarBaz = true
+          extension += "foo"
+          class_ = "foo"
+          int = 1.0
+          long = true
+          boolean = 1L
+          sealed = "foo"
+          interface_ = 1F
+          in_ = 1
+          object_ = "foo"
+          cachedSize_ = "foo"
+          serializedSize_ = true
+          value = "foo"
+          index = 1L
+          values += "foo"
+          newValues += "foo"
+          builder = true
+          k[1] = 1
+          v["foo"] = "foo"
+          key["foo"] = 1
+          map[1] = "foo"
+          pairs["foo"] = 1
+          LeadingUnderscore = "foo"
+          option = 1
+        }
+      )
+      .isEqualTo(
+        EvilNamesProto3.newBuilder()
+          .setInitialized(true)
+          .setHasFoo(true)
+          .setBar("foo")
+          .setIsInitialized(true)
+          .setFooBar("foo")
+          .addALLCAPS("foo")
+          .putALLCAPSMAP(1, true)
+          .setHasUnderbarPrecedingNumeric1Foo(true)
+          .setHasUnderbarPrecedingNumeric42Bar(true)
+          .setHasUnderbarPrecedingNumeric123Foo42BarBaz(true)
+          .addExtension("foo")
+          .setClass_("foo")
+          .setInt(1.0)
+          .setLong(true)
+          .setBoolean(1L)
+          .setSealed("foo")
+          .setInterface(1F)
+          .setIn(1)
+          .setObject("foo")
+          .setCachedSize_("foo")
+          .setSerializedSize_(true)
+          .setValue("foo")
+          .setIndex(1L)
+          .addValues("foo")
+          .addNewValues("foo")
+          .setBuilder(true)
+          .putK(1, 1)
+          .putV("foo", "foo")
+          .putKey("foo", 1)
+          .putMap(1, "foo")
+          .putPairs("foo", 1)
+          .setLeadingUnderscore("foo")
+          .setOption(1)
+          .build()
+      )
+
+    assertThat(class_ {}).isEqualTo(Class.newBuilder().build())
+  }
+
+  @Test
+  fun testHardKeywordGettersAndSetters() {
+    hardKeywordsAllTypesProto3 {
+      as_ = 1
+      assertThat(as_).isEqualTo(1)
+
+      in_ = "foo"
+      assertThat(in_).isEqualTo("foo")
+
+      break_ = HardKeywordsAllTypesProto3.NestedEnum.FOO
+      assertThat(break_).isEqualTo(HardKeywordsAllTypesProto3.NestedEnum.FOO)
+
+      do_ = HardKeywordsAllTypesProto3Kt.nestedMessage { while_ = 1 }
+      assertThat(do_).isEqualTo(HardKeywordsAllTypesProto3Kt.nestedMessage { while_ = 1 })
+
+      continue_[1] = 1
+      assertThat(continue_[1]).isEqualTo(1)
+
+      else_ += 1
+      assertThat(else_).isEqualTo(listOf(1))
+
+      for_ += "foo"
+      assertThat(for_).isEqualTo(listOf("foo"))
+
+      fun_ += HardKeywordsAllTypesProto3.NestedEnum.FOO
+      assertThat(fun_).isEqualTo(listOf(HardKeywordsAllTypesProto3.NestedEnum.FOO))
+
+      if_ += HardKeywordsAllTypesProto3Kt.nestedMessage { while_ = 1 }
+      assertThat(if_).isEqualTo(listOf(HardKeywordsAllTypesProto3Kt.nestedMessage { while_ = 1 }))
+    }
+  }
+
+  @Test
+  fun testHardKeywordHazzers() {
+    hardKeywordsAllTypesProto3 {
+      as_ = 1
+      assertThat(hasAs_()).isTrue()
+
+      in_ = "foo"
+      assertThat(hasIn_()).isTrue()
+
+      break_ = HardKeywordsAllTypesProto3.NestedEnum.FOO
+      assertThat(hasBreak_()).isTrue()
+
+      do_ = HardKeywordsAllTypesProto3Kt.nestedMessage { while_ = 1 }
+      assertThat(hasDo_()).isTrue()
+    }
+  }
+
+  @Test
+  fun testHardKeywordClears() {
+    hardKeywordsAllTypesProto3 {
+      as_ = 1
+      clearAs_()
+      assertThat(hasAs_()).isFalse()
+
+      in_ = "foo"
+      clearIn_()
+      assertThat(hasIn_()).isFalse()
+
+      break_ = HardKeywordsAllTypesProto3.NestedEnum.FOO
+      clearBreak_()
+      assertThat(hasBreak_()).isFalse()
+
+      do_ = HardKeywordsAllTypesProto3Kt.nestedMessage { while_ = 1 }
+      clearDo_()
+      assertThat(hasDo_()).isFalse()
+    }
+  }
+
+  @Test
+  fun testMultipleFiles() {
+    assertThat(com.google.protobuf.kotlin.generator.multipleFilesMessageA {})
+      .isEqualTo(com.google.protobuf.kotlin.generator.MultipleFilesMessageA.newBuilder().build())
+
+    assertThat(com.google.protobuf.kotlin.generator.multipleFilesMessageB {})
+      .isEqualTo(com.google.protobuf.kotlin.generator.MultipleFilesMessageB.newBuilder().build())
+  }
+
+  @Test
+  fun testGetOrNull() {
+    val noNestedMessage = testAllTypes {}
+    assertThat(noNestedMessage.optionalNestedMessageOrNull).isEqualTo(null)
+
+    val someNestedMessage = testAllTypes {
+      optionalNestedMessage = TestAllTypesKt.nestedMessage { bb = 118 }
+    }
+    assertThat(someNestedMessage.optionalNestedMessageOrNull)
+      .isEqualTo(TestAllTypesKt.nestedMessage { bb = 118 })
+
+    // No optional keyword, OrNull should still be generated
+    assertThat(someNestedMessage.optionalForeignMessageOrNull).isEqualTo(null)
+  }
+}

deps/protobuf/java/kotlin/src/test/proto/com/google/protobuf/evil_names_proto2.proto

@@ -0,0 +1,93 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// LINT: LEGACY_NAMES
+syntax = "proto2";
+
+package protobuf.kotlin.generator;
+
+option java_package = "com.google.protobuf.kotlin.generator";
+
+message EvilNamesProto2 {
+  optional bool initialized = 1;
+  optional bool has_foo = 2;
+  optional string Bar = 3;
+  optional bool is_initialized = 4;
+
+  oneof camelCase {
+    string fooBar = 5;
+  }
+
+  repeated string ALL_CAPS = 7;
+  map<int32, bool> ALL_CAPS_MAP = 8;
+
+  optional bool has_underbar_preceding_numeric_1foo = 9;
+  optional bool has_underbar_preceding_numeric_42bar = 13;
+  optional bool has_underbar_preceding_numeric_123foo42bar_baz = 14;
+
+  extensions 100 to max;
+
+  repeated string extension = 12;
+  repeated int32 class = 15;
+  optional double int = 16;
+  optional bool long = 17;
+  optional int64 boolean = 18;
+  optional string sealed = 19;
+  optional float interface = 20;
+  optional int32 in = 21;
+  optional string object = 22;
+  optional string cached_size = 23;
+  optional bool serialized_size = 24;
+  optional string by = 25;
+}
+
+message HardKeywordsAllTypesProto2 {
+  message NestedMessage {
+    optional int32 while = 1;
+  }
+
+  enum NestedEnum {
+    FOO = 1;
+    BAR = 2;
+  }
+
+  optional int32 as = 1;
+  optional string in = 2;
+  optional NestedEnum break = 3;
+  map<int32, int32> continue = 4;
+  optional NestedMessage do = 5;
+
+  repeated int32 else = 6;
+  repeated string for = 7;
+  repeated NestedEnum fun = 8;
+  repeated NestedMessage if = 9;
+}
+
+message Interface {}

deps/protobuf/java/kotlin/src/test/proto/com/google/protobuf/evil_names_proto3.proto

@@ -0,0 +1,107 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// LINT: LEGACY_NAMES
+syntax = "proto3";
+
+package protobuf.kotlin.generator;
+
+option java_package = "com.google.protobuf.kotlin.generator";
+
+message EvilNamesProto3 {
+  bool initialized = 1;
+  bool has_foo = 2;
+  string Bar = 3;
+  bool is_initialized = 4;
+
+  oneof camelCase {
+    string fooBar = 5;
+  }
+
+  repeated string ALL_CAPS = 7;
+  map<int32, bool> ALL_CAPS_MAP = 8;
+
+  bool has_underbar_preceding_numeric_1foo = 9;
+  bool has_underbar_preceding_numeric_42bar = 10;
+  bool has_underbar_preceding_numeric_123foo42bar_baz = 11;
+
+  repeated string extension = 12;
+
+  string class = 13;
+  double int = 14;
+  bool long = 15;
+  int64 boolean = 16;
+  string sealed = 17;
+  float interface = 18;
+  int32 in = 19;
+  string object = 20;
+  string cached_size = 21;
+  bool serialized_size = 22;
+  string value = 23;
+  int64 index = 24;
+  repeated string values = 25;
+  repeated string new_values = 26;
+  bool builder = 27;
+  map<int32, int32> k = 28;
+  map<string, string> v = 29;
+  map<string, int32> key = 30;
+  map<int32, string> map = 31;
+  map<string, int32> pairs = 32;
+
+  string _leading_underscore = 33;
+  oneof _leading_underscore_oneof {
+    int32 option = 34;
+  }
+}
+
+message HardKeywordsAllTypesProto3 {
+  message NestedMessage {
+    optional int32 while = 1;
+  }
+
+  enum NestedEnum {
+    ZERO = 0;
+    FOO = 1;
+    BAR = 2;
+  }
+
+  optional int32 as = 1;
+  optional string in = 2;
+  optional NestedEnum break = 3;
+  map<int32, int32> continue = 4;
+  optional NestedMessage do = 5;
+
+  repeated int32 else = 6;
+  repeated string for = 7;
+  repeated NestedEnum fun = 8;
+  repeated NestedMessage if = 9;
+}
+
+message Class {}

deps/protobuf/java/kotlin/src/test/proto/com/google/protobuf/example_extensible_message.proto

@@ -0,0 +1,46 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+syntax = "proto2";
+
+package protobuf.kotlin.test;
+
+option java_package = "com.google.protobuf.kotlin.test";
+option java_multiple_files = true;
+
+message ExampleExtensibleMessage {
+  extensions 10 to 20;
+}
+
+extend ExampleExtensibleMessage {
+  repeated int32 repeated_extension = 10;
+  repeated int32 different_extension = 11;
+  optional int32 int32_extension = 12;
+}

deps/protobuf/java/kotlin/src/test/proto/com/google/protobuf/multiple_files_proto3.proto

@@ -0,0 +1,42 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+syntax = "proto3";
+
+package protobuf.kotlin.generator;
+
+option java_package = "com.google.protobuf.kotlin.generator";
+option java_multiple_files = true;
+
+enum NestedEnum { FOO = 0; }
+
+message MultipleFilesMessageA {}
+
+message MultipleFilesMessageB {}