Protobuf: added tests for nativ environment

translator/src/test/kotlin/tests/input/proto_crossbranch_test.txt

@@ -0,0 +1,3 @@
+testTrivialValues() == 0
+testMaxValues() == 0
+testMinValues() == 0

translator/src/test/kotlin/tests/input/proto_location_test.txt

@@ -0,0 +1,3 @@
+testTrivialLocationResponse() == 0
+testMaxLocationResponse() == 0
+testMinLocationResponse() == 0

translator/src/test/kotlin/tests/input/proto_multiple_messages.txt

@@ -0,0 +1,3 @@
+testThirdCase() == 0
+testSecondCase() == 0
+testFirstCase() == 0

translator/src/test/kotlin/tests/input/proto_repeated_varint.txt

@@ -0,0 +1,4 @@
+testArraysOfDefaultValues() == 0
+testArraysOfMinValues() == 0
+testArraysOfMaxValues() == 0
+testRepVarints() == 0

translator/src/test/kotlin/tests/input/proto_repeated_zigzag.txt

@@ -0,0 +1,4 @@
+testRepZigZag() == 0
+testArraysOfMinValues() == 0
+testArraysOfMaxValues() == 0
+testArraysOfDefaultValues() == 0

translator/src/test/kotlin/tests/input/proto_tagorder_test.txt

@@ -0,0 +1,2 @@
+testTagToShuffled() == 0
+testShuffledToTag() == 0

translator/src/test/kotlin/tests/input/proto_varint.txt

@@ -0,0 +1,5 @@
+testVarintDefaultMessage() == 0
+testVarintTrivialMessage() == 0
+testVarintNegativeMessage() == 0
+testVarintMaxValues() == 0
+testVarintMinValues() == 0

translator/src/test/kotlin/tests/input/proto_zigzag.txt

@@ -0,0 +1,6 @@
+testZigZagDefaultValues() == 0
+testZigZagRandomValues() == 0
+testZigZagNegativeValues() == 0
+testZigZagPositiveValues() == 0
+testZigZagMaxValues() == 0
+testZigZagMinValues() == 0

translator/src/test/kotlin/tests/kotlin/proto_location_test.kt

@@ -0,0 +1,466 @@
+class LocationResponse private constructor (var locationResponseData: LocationResponse.LocationData, var code: Int, var errorMsg: Int) {
+    //========== Properties ===========
+    //message locationResponseData = 1
+
+    //int32 code = 2
+
+    //int32 errorMsg = 3
+
+    var errorCode: Int = 0
+
+    //========== Nested classes declarations ===========
+    class LocationData private constructor (var x: Int, var y: Int, var angle: Int) {
+        //========== Properties ===========
+        //int32 x = 1
+
+        //int32 y = 2
+
+        //int32 angle = 3
+
+        var errorCode: Int = 0
+
+        //========== Serialization methods ===========
+        fun writeTo (output: CodedOutputStream) {
+            //int32 x = 1
+            if (x != 0) {
+                output.writeInt32 (1, x)
+            }
+
+            //int32 y = 2
+            if (y != 0) {
+                output.writeInt32 (2, y)
+            }
+
+            //int32 angle = 3
+            if (angle != 0) {
+                output.writeInt32 (3, angle)
+            }
+
+        }
+
+        fun mergeWith (other: LocationResponse.LocationData) {
+            x = other.x
+            y = other.y
+            angle = other.angle
+            this.errorCode = other.errorCode
+        }
+
+        fun mergeFromWithSize (input: CodedInputStream, expectedSize: Int) {
+            val builder = LocationResponse.LocationData.BuilderLocationData(0, 0, 0)
+            mergeWith(builder.parseFromWithSize(input, expectedSize).build())
+        }
+
+        fun mergeFrom (input: CodedInputStream) {
+            val builder = LocationResponse.LocationData.BuilderLocationData(0, 0, 0)
+            mergeWith(builder.parseFrom(input).build())
+        }
+
+        //========== Size-related methods ===========
+        fun getSize(fieldNumber: Int): Int {
+            var size = 0
+            if (x != 0) {
+                size += WireFormat.getInt32Size(1, x)
+            }
+            if (y != 0) {
+                size += WireFormat.getInt32Size(2, y)
+            }
+            if (angle != 0) {
+                size += WireFormat.getInt32Size(3, angle)
+            }
+            size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED)
+            return size
+        }
+
+        fun getSizeNoTag(): Int {
+            var size = 0
+            if (x != 0) {
+                size += WireFormat.getInt32Size(1, x)
+            }
+            if (y != 0) {
+                size += WireFormat.getInt32Size(2, y)
+            }
+            if (angle != 0) {
+                size += WireFormat.getInt32Size(3, angle)
+            }
+            return size
+        }
+
+        //========== Builder ===========
+        class BuilderLocationData constructor (var x: Int, var y: Int, var angle: Int) {
+            //========== Properties ===========
+            //int32 x = 1
+            fun setX(value: Int): LocationResponse.LocationData.BuilderLocationData {
+                x = value
+                return this
+            }
+
+            //int32 y = 2
+            fun setY(value: Int): LocationResponse.LocationData.BuilderLocationData {
+                y = value
+                return this
+            }
+
+            //int32 angle = 3
+            fun setAngle(value: Int): LocationResponse.LocationData.BuilderLocationData {
+                angle = value
+                return this
+            }
+
+            var errorCode: Int = 0
+
+            //========== Serialization methods ===========
+            fun writeTo (output: CodedOutputStream) {
+                //int32 x = 1
+                if (x != 0) {
+                    output.writeInt32 (1, x)
+                }
+
+                //int32 y = 2
+                if (y != 0) {
+                    output.writeInt32 (2, y)
+                }
+
+                //int32 angle = 3
+                if (angle != 0) {
+                    output.writeInt32 (3, angle)
+                }
+
+            }
+
+            //========== Mutating methods ===========
+            fun build(): LocationResponse.LocationData {
+                val res = LocationResponse.LocationData(x, y, angle)
+                res.errorCode = errorCode
+                return res
+            }
+
+            fun parseFieldFrom(input: CodedInputStream): Boolean {
+                if (input.isAtEnd()) { return false }
+                val tag = input.readInt32NoTag()
+                if (tag == 0) { return false }
+                val fieldNumber = WireFormat.getTagFieldNumber(tag)
+                val wireType = WireFormat.getTagWireType(tag)
+                when(fieldNumber) {
+                    1 -> {
+                        if (wireType.id != WireType.VARINT.id) {
+                            errorCode = 1
+                            return false
+                        }
+                        x = input.readInt32NoTag()
+                    }
+                    2 -> {
+                        if (wireType.id != WireType.VARINT.id) {
+                            errorCode = 1
+                            return false
+                        }
+                        y = input.readInt32NoTag()
+                    }
+                    3 -> {
+                        if (wireType.id != WireType.VARINT.id) {
+                            errorCode = 1
+                            return false
+                        }
+                        angle = input.readInt32NoTag()
+                    }
+                    else -> errorCode = 4
+                }
+                return true
+            }
+
+            fun parseFromWithSize(input: CodedInputStream, expectedSize: Int): LocationResponse.LocationData.BuilderLocationData {
+                while(getSizeNoTag() < expectedSize) {
+                    parseFieldFrom(input)
+                }
+                if (getSizeNoTag() > expectedSize) { errorCode = 2 }
+                return this
+            }
+
+            fun parseFrom(input: CodedInputStream): LocationResponse.LocationData.BuilderLocationData {
+                while(parseFieldFrom(input)) {}
+                return this
+            }
+
+            //========== Size-related methods ===========
+            fun getSize(fieldNumber: Int): Int {
+                var size = 0
+                if (x != 0) {
+                    size += WireFormat.getInt32Size(1, x)
+                }
+                if (y != 0) {
+                    size += WireFormat.getInt32Size(2, y)
+                }
+                if (angle != 0) {
+                    size += WireFormat.getInt32Size(3, angle)
+                }
+                size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED)
+                return size
+            }
+
+            fun getSizeNoTag(): Int {
+                var size = 0
+                if (x != 0) {
+                    size += WireFormat.getInt32Size(1, x)
+                }
+                if (y != 0) {
+                    size += WireFormat.getInt32Size(2, y)
+                }
+                if (angle != 0) {
+                    size += WireFormat.getInt32Size(3, angle)
+                }
+                return size
+            }
+
+        }
+
+    }
+
+    //========== Serialization methods ===========
+    fun writeTo (output: CodedOutputStream) {
+        //message locationResponseData = 1
+        output.writeTag(1, WireType.LENGTH_DELIMITED)
+        output.writeInt32NoTag(locationResponseData.getSizeNoTag())
+        locationResponseData.writeTo(output)
+
+        //int32 code = 2
+        if (code != 0) {
+            output.writeInt32 (2, code)
+        }
+
+        //int32 errorMsg = 3
+        if (errorMsg != 0) {
+            output.writeInt32 (3, errorMsg)
+        }
+
+    }
+
+    fun mergeWith (other: LocationResponse) {
+        locationResponseData = other.locationResponseData
+        code = other.code
+        errorMsg = other.errorMsg
+        this.errorCode = other.errorCode
+    }
+
+    fun mergeFromWithSize (input: CodedInputStream, expectedSize: Int) {
+        val builder = LocationResponse.BuilderLocationResponse(LocationResponse.LocationData.BuilderLocationData(0, 0, 0).build(), 0, 0)
+        mergeWith(builder.parseFromWithSize(input, expectedSize).build())
+    }
+
+    fun mergeFrom (input: CodedInputStream) {
+        val builder = LocationResponse.BuilderLocationResponse(LocationResponse.LocationData.BuilderLocationData(0, 0, 0).build(), 0, 0)
+        mergeWith(builder.parseFrom(input).build())
+    }
+
+    //========== Size-related methods ===========
+    fun getSize(fieldNumber: Int): Int {
+        var size = 0
+        if (locationResponseData != LocationResponse.LocationData.BuilderLocationData(0, 0, 0).build()) {
+            size += locationResponseData.getSize(1)
+        }
+        if (code != 0) {
+            size += WireFormat.getInt32Size(2, code)
+        }
+        if (errorMsg != 0) {
+            size += WireFormat.getInt32Size(3, errorMsg)
+        }
+        size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED)
+        return size
+    }
+
+    fun getSizeNoTag(): Int {
+        var size = 0
+        if (locationResponseData != LocationResponse.LocationData.BuilderLocationData(0, 0, 0).build()) {
+            size += locationResponseData.getSize(1)
+        }
+        if (code != 0) {
+            size += WireFormat.getInt32Size(2, code)
+        }
+        if (errorMsg != 0) {
+            size += WireFormat.getInt32Size(3, errorMsg)
+        }
+        return size
+    }
+
+    //========== Builder ===========
+    class BuilderLocationResponse constructor (var locationResponseData: LocationResponse.LocationData, var code: Int, var errorMsg: Int) {
+        //========== Properties ===========
+        //message locationResponseData = 1
+        fun setLocationResponseData(value: LocationResponse.LocationData): LocationResponse.BuilderLocationResponse {
+            locationResponseData = value
+            return this
+        }
+
+        //int32 code = 2
+        fun setCode(value: Int): LocationResponse.BuilderLocationResponse {
+            code = value
+            return this
+        }
+
+        //int32 errorMsg = 3
+        fun setErrorMsg(value: Int): LocationResponse.BuilderLocationResponse {
+            errorMsg = value
+            return this
+        }
+
+        var errorCode: Int = 0
+
+        //========== Serialization methods ===========
+        fun writeTo (output: CodedOutputStream) {
+            //message locationResponseData = 1
+            output.writeTag(1, WireType.LENGTH_DELIMITED)
+            output.writeInt32NoTag(locationResponseData.getSizeNoTag())
+            locationResponseData.writeTo(output)
+
+            //int32 code = 2
+            if (code != 0) {
+                output.writeInt32 (2, code)
+            }
+
+            //int32 errorMsg = 3
+            if (errorMsg != 0) {
+                output.writeInt32 (3, errorMsg)
+            }
+
+        }
+
+        //========== Mutating methods ===========
+        fun build(): LocationResponse {
+            val res = LocationResponse(locationResponseData, code, errorMsg)
+            res.errorCode = errorCode
+            return res
+        }
+
+        fun parseFieldFrom(input: CodedInputStream): Boolean {
+            if (input.isAtEnd()) { return false }
+            val tag = input.readInt32NoTag()
+            if (tag == 0) { return false }
+            val fieldNumber = WireFormat.getTagFieldNumber(tag)
+            val wireType = WireFormat.getTagWireType(tag)
+            when(fieldNumber) {
+                1 -> {
+                    if (wireType.id != WireType.LENGTH_DELIMITED.id) {
+                        errorCode = 1
+                        return false
+                    }
+                    do {
+                        val expectedSize = input.readInt32NoTag()
+                        locationResponseData.mergeFromWithSize(input, expectedSize)
+                        if (expectedSize != locationResponseData.getSizeNoTag()) { errorCode = 3; return false }
+                    } while(false)
+                }
+                2 -> {
+                    if (wireType.id != WireType.VARINT.id) {
+                        errorCode = 1
+                        return false
+                    }
+                    code = input.readInt32NoTag()
+                }
+                3 -> {
+                    if (wireType.id != WireType.VARINT.id) {
+                        errorCode = 1
+                        return false
+                    }
+                    errorMsg = input.readInt32NoTag()
+                }
+                else -> errorCode = 4
+            }
+            return true
+        }
+
+        fun parseFromWithSize(input: CodedInputStream, expectedSize: Int): LocationResponse.BuilderLocationResponse {
+            while(getSizeNoTag() < expectedSize) {
+                parseFieldFrom(input)
+            }
+            if (getSizeNoTag() > expectedSize) { errorCode = 2 }
+            return this
+        }
+
+        fun parseFrom(input: CodedInputStream): LocationResponse.BuilderLocationResponse {
+            while(parseFieldFrom(input)) {}
+            return this
+        }
+
+        //========== Size-related methods ===========
+        fun getSize(fieldNumber: Int): Int {
+            var size = 0
+            if (locationResponseData != LocationResponse.LocationData.BuilderLocationData(0, 0, 0).build()) {
+                size += locationResponseData.getSize(1)
+            }
+            if (code != 0) {
+                size += WireFormat.getInt32Size(2, code)
+            }
+            if (errorMsg != 0) {
+                size += WireFormat.getInt32Size(3, errorMsg)
+            }
+            size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED)
+            return size
+        }
+
+        fun getSizeNoTag(): Int {
+            var size = 0
+            if (locationResponseData != LocationResponse.LocationData.BuilderLocationData(0, 0, 0).build()) {
+                size += locationResponseData.getSize(1)
+            }
+            if (code != 0) {
+                size += WireFormat.getInt32Size(2, code)
+            }
+            if (errorMsg != 0) {
+                size += WireFormat.getInt32Size(3, errorMsg)
+            }
+            return size
+        }
+
+    }
+
+}
+
+fun compareLocationDatas(lhs: LocationResponse.LocationData, rhs: LocationResponse.LocationData): Boolean {
+    return (lhs.angle == rhs.angle) and (lhs.x == rhs.x) and (lhs.y == rhs.y)
+}
+
+fun compareLocationResponses(lhs: LocationResponse, rhs: LocationResponse): Boolean {
+    return (lhs.code == rhs.code) and
+            (lhs.errorMsg == rhs.errorMsg) and
+            compareLocationDatas(lhs.locationResponseData, rhs.locationResponseData)
+}
+
+fun buildLocationResponse(code: Int, errorMsg: Int, angle: Int, x: Int, y: Int): LocationResponse.BuilderLocationResponse {
+    return LocationResponse.BuilderLocationResponse(
+            LocationResponse.LocationData.BuilderLocationData(
+                x, y, angle
+            ).build(),
+            code,
+            errorMsg
+        )
+}
+
+fun checkLocationResponse(msg: LocationResponse): Int {
+    val outs = CodedOutputStream(ByteArray(msg.getSizeNoTag()))
+    msg.writeTo(outs)
+
+    val ins = CodedInputStream(outs.buffer)
+    val readMsg = buildLocationResponse(0, 0, 0, 0, 0).parseFrom(ins).build()
+
+    if (readMsg.errorCode != 0) {
+        return 1
+    }
+    if (compareLocationResponses(msg, readMsg)) {
+        return 0
+    } else {
+        return 1
+    }
+}
+
+fun testTrivialLocationResponse(): Int {
+    val msg = buildLocationResponse(3125321, -12673123, 4334, 423542673, 234516534).build()
+    return checkLocationResponse(msg)
+}
+
+fun testMaxLocationResponse(): Int {
+    val msg = buildLocationResponse(2147483647, 2147483647, 2147483647, 2147483647, 2147483647).build()
+    return checkLocationResponse(msg)
+}
+
+fun testMinLocationResponse(): Int {
+    val msg = buildLocationResponse(-2147483647, -2147483647, -2147483647, -2147483647, -2147483647).build()
+    return checkLocationResponse(msg)
+}

translator/src/test/kotlin/tests/kotlin/proto_multiple_messages.kt

@@ -0,0 +1,495 @@
+class ThirdMessage private constructor (var second_msg: SecondMessage) {
+    //========== Properties ===========
+    //message second_msg = 1
+
+    var errorCode: Int = 0
+
+    //========== Serialization methods ===========
+    fun writeTo (output: CodedOutputStream) {
+        //message second_msg = 1
+        output.writeTag(1, WireType.LENGTH_DELIMITED)
+        output.writeInt32NoTag(second_msg.getSizeNoTag())
+        second_msg.writeTo(output)
+
+    }
+
+    fun mergeWith (other: ThirdMessage) {
+        second_msg = other.second_msg
+        this.errorCode = other.errorCode
+    }
+
+    fun mergeFromWithSize (input: CodedInputStream, expectedSize: Int) {
+        val builder = ThirdMessage.BuilderThirdMessage(SecondMessage.BuilderSecondMessage(FirstMessage.BuilderFirstMessage(0).build()).build())
+        mergeWith(builder.parseFromWithSize(input, expectedSize).build())
+    }
+
+    fun mergeFrom (input: CodedInputStream) {
+        val builder = ThirdMessage.BuilderThirdMessage(SecondMessage.BuilderSecondMessage(FirstMessage.BuilderFirstMessage(0).build()).build())
+        mergeWith(builder.parseFrom(input).build())
+    }
+
+    //========== Size-related methods ===========
+    fun getSize(fieldNumber: Int): Int {
+        var size = 0
+        if (second_msg != SecondMessage.BuilderSecondMessage(FirstMessage.BuilderFirstMessage(0).build()).build()) {
+            size += second_msg.getSize(1)
+        }
+        size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED)
+        return size
+    }
+
+    fun getSizeNoTag(): Int {
+        var size = 0
+        if (second_msg != SecondMessage.BuilderSecondMessage(FirstMessage.BuilderFirstMessage(0).build()).build()) {
+            size += second_msg.getSize(1)
+        }
+        return size
+    }
+
+    //========== Builder ===========
+    class BuilderThirdMessage constructor (var second_msg: SecondMessage) {
+        //========== Properties ===========
+        //message second_msg = 1
+        fun setSecond_msg(value: SecondMessage): ThirdMessage.BuilderThirdMessage {
+            second_msg = value
+            return this
+        }
+
+        var errorCode: Int = 0
+
+        //========== Serialization methods ===========
+        fun writeTo (output: CodedOutputStream) {
+            //message second_msg = 1
+            output.writeTag(1, WireType.LENGTH_DELIMITED)
+            output.writeInt32NoTag(second_msg.getSizeNoTag())
+            second_msg.writeTo(output)
+
+        }
+
+        //========== Mutating methods ===========
+        fun build(): ThirdMessage {
+            val res = ThirdMessage(second_msg)
+            res.errorCode = errorCode
+            return res
+        }
+
+        fun parseFieldFrom(input: CodedInputStream): Boolean {
+            if (input.isAtEnd()) { return false }
+            val tag = input.readInt32NoTag()
+            if (tag == 0) { return false }
+            val fieldNumber = WireFormat.getTagFieldNumber(tag)
+            val wireType = WireFormat.getTagWireType(tag)
+            when(fieldNumber) {
+                1 -> {
+                    if (wireType.id != WireType.LENGTH_DELIMITED.id) {
+                        errorCode = 1
+                        return false
+                    }
+                    do {
+                        val expectedSize = input.readInt32NoTag()
+                        second_msg.mergeFromWithSize(input, expectedSize)
+                        if (expectedSize != second_msg.getSizeNoTag()) { errorCode = 3; return false }
+                    } while(false)
+                }
+                else -> errorCode = 4
+            }
+            return true
+        }
+
+        fun parseFromWithSize(input: CodedInputStream, expectedSize: Int): ThirdMessage.BuilderThirdMessage {
+            while(getSizeNoTag() < expectedSize) {
+                parseFieldFrom(input)
+            }
+            if (getSizeNoTag() > expectedSize) { errorCode = 2 }
+            return this
+        }
+
+        fun parseFrom(input: CodedInputStream): ThirdMessage.BuilderThirdMessage {
+            while(parseFieldFrom(input)) {}
+            return this
+        }
+
+        //========== Size-related methods ===========
+        fun getSize(fieldNumber: Int): Int {
+            var size = 0
+            if (second_msg != SecondMessage.BuilderSecondMessage(FirstMessage.BuilderFirstMessage(0).build()).build()) {
+                size += second_msg.getSize(1)
+            }
+            size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED)
+            return size
+        }
+
+        fun getSizeNoTag(): Int {
+            var size = 0
+            if (second_msg != SecondMessage.BuilderSecondMessage(FirstMessage.BuilderFirstMessage(0).build()).build()) {
+                size += second_msg.getSize(1)
+            }
+            return size
+        }
+
+    }
+
+}
+
+class SecondMessage private constructor (var first_msg: FirstMessage) {
+    //========== Properties ===========
+    //message first_msg = 1
+
+    var errorCode: Int = 0
+
+    //========== Serialization methods ===========
+    fun writeTo (output: CodedOutputStream) {
+        //message first_msg = 1
+        output.writeTag(1, WireType.LENGTH_DELIMITED)
+        output.writeInt32NoTag(first_msg.getSizeNoTag())
+        first_msg.writeTo(output)
+
+    }
+
+    fun mergeWith (other: SecondMessage) {
+        first_msg = other.first_msg
+        this.errorCode = other.errorCode
+    }
+
+    fun mergeFromWithSize (input: CodedInputStream, expectedSize: Int) {
+        val builder = SecondMessage.BuilderSecondMessage(FirstMessage.BuilderFirstMessage(0).build())
+        mergeWith(builder.parseFromWithSize(input, expectedSize).build())
+    }
+
+    fun mergeFrom (input: CodedInputStream) {
+        val builder = SecondMessage.BuilderSecondMessage(FirstMessage.BuilderFirstMessage(0).build())
+        mergeWith(builder.parseFrom(input).build())
+    }
+
+    //========== Size-related methods ===========
+    fun getSize(fieldNumber: Int): Int {
+        var size = 0
+        if (first_msg != FirstMessage.BuilderFirstMessage(0).build()) {
+            size += first_msg.getSize(1)
+        }
+        size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED)
+        return size
+    }
+
+    fun getSizeNoTag(): Int {
+        var size = 0
+        if (first_msg != FirstMessage.BuilderFirstMessage(0).build()) {
+            size += first_msg.getSize(1)
+        }
+        return size
+    }
+
+    //========== Builder ===========
+    class BuilderSecondMessage constructor (var first_msg: FirstMessage) {
+        //========== Properties ===========
+        //message first_msg = 1
+        fun setFirst_msg(value: FirstMessage): SecondMessage.BuilderSecondMessage {
+            first_msg = value
+            return this
+        }
+
+        var errorCode: Int = 0
+
+        //========== Serialization methods ===========
+        fun writeTo (output: CodedOutputStream) {
+            //message first_msg = 1
+            output.writeTag(1, WireType.LENGTH_DELIMITED)
+            output.writeInt32NoTag(first_msg.getSizeNoTag())
+            first_msg.writeTo(output)
+
+        }
+
+        //========== Mutating methods ===========
+        fun build(): SecondMessage {
+            val res = SecondMessage(first_msg)
+            res.errorCode = errorCode
+            return res
+        }
+
+        fun parseFieldFrom(input: CodedInputStream): Boolean {
+            if (input.isAtEnd()) { return false }
+            val tag = input.readInt32NoTag()
+            if (tag == 0) { return false }
+            val fieldNumber = WireFormat.getTagFieldNumber(tag)
+            val wireType = WireFormat.getTagWireType(tag)
+            when(fieldNumber) {
+                1 -> {
+                    if (wireType.id != WireType.LENGTH_DELIMITED.id) {
+                        errorCode = 1
+                        return false
+                    }
+                    do {
+                        val expectedSize = input.readInt32NoTag()
+                        first_msg.mergeFromWithSize(input, expectedSize)
+                        if (expectedSize != first_msg.getSizeNoTag()) { errorCode = 3; return false }
+                    } while(false)
+                }
+                else -> errorCode = 4
+            }
+            return true
+        }
+
+        fun parseFromWithSize(input: CodedInputStream, expectedSize: Int): SecondMessage.BuilderSecondMessage {
+            while(getSizeNoTag() < expectedSize) {
+                parseFieldFrom(input)
+            }
+            if (getSizeNoTag() > expectedSize) { errorCode = 2 }
+            return this
+        }
+
+        fun parseFrom(input: CodedInputStream): SecondMessage.BuilderSecondMessage {
+            while(parseFieldFrom(input)) {}
+            return this
+        }
+
+        //========== Size-related methods ===========
+        fun getSize(fieldNumber: Int): Int {
+            var size = 0
+            if (first_msg != FirstMessage.BuilderFirstMessage(0).build()) {
+                size += first_msg.getSize(1)
+            }
+            size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED)
+            return size
+        }
+
+        fun getSizeNoTag(): Int {
+            var size = 0
+            if (first_msg != FirstMessage.BuilderFirstMessage(0).build()) {
+                size += first_msg.getSize(1)
+            }
+            return size
+        }
+
+    }
+
+}
+
+class FirstMessage private constructor (var int_field: Int) {
+    //========== Properties ===========
+    //int32 int_field = 1
+
+    var errorCode: Int = 0
+
+    //========== Serialization methods ===========
+    fun writeTo (output: CodedOutputStream) {
+        //int32 int_field = 1
+        if (int_field != 0) {
+            output.writeInt32 (1, int_field)
+        }
+
+    }
+
+    fun mergeWith (other: FirstMessage) {
+        int_field = other.int_field
+        this.errorCode = other.errorCode
+    }
+
+    fun mergeFromWithSize (input: CodedInputStream, expectedSize: Int) {
+        val builder = FirstMessage.BuilderFirstMessage(0)
+        mergeWith(builder.parseFromWithSize(input, expectedSize).build())
+    }
+
+    fun mergeFrom (input: CodedInputStream) {
+        val builder = FirstMessage.BuilderFirstMessage(0)
+        mergeWith(builder.parseFrom(input).build())
+    }
+
+    //========== Size-related methods ===========
+    fun getSize(fieldNumber: Int): Int {
+        var size = 0
+        if (int_field != 0) {
+            size += WireFormat.getInt32Size(1, int_field)
+        }
+        size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED)
+        return size
+    }
+
+    fun getSizeNoTag(): Int {
+        var size = 0
+        if (int_field != 0) {
+            size += WireFormat.getInt32Size(1, int_field)
+        }
+        return size
+    }
+
+    //========== Builder ===========
+    class BuilderFirstMessage constructor (var int_field: Int) {
+        //========== Properties ===========
+        //int32 int_field = 1
+        fun setInt_field(value: Int): FirstMessage.BuilderFirstMessage {
+            int_field = value
+            return this
+        }
+
+        var errorCode: Int = 0
+
+        //========== Serialization methods ===========
+        fun writeTo (output: CodedOutputStream) {
+            //int32 int_field = 1
+            if (int_field != 0) {
+                output.writeInt32 (1, int_field)
+            }
+
+        }
+
+        //========== Mutating methods ===========
+        fun build(): FirstMessage {
+            val res = FirstMessage(int_field)
+            res.errorCode = errorCode
+            return res
+        }
+
+        fun parseFieldFrom(input: CodedInputStream): Boolean {
+            if (input.isAtEnd()) { return false }
+            val tag = input.readInt32NoTag()
+            if (tag == 0) { return false }
+            val fieldNumber = WireFormat.getTagFieldNumber(tag)
+            val wireType = WireFormat.getTagWireType(tag)
+            when(fieldNumber) {
+                1 -> {
+                    if (wireType.id != WireType.VARINT.id) {
+                        errorCode = 1
+                        return false
+                    }
+                    int_field = input.readInt32NoTag()
+                }
+                else -> errorCode = 4
+            }
+            return true
+        }
+
+        fun parseFromWithSize(input: CodedInputStream, expectedSize: Int): FirstMessage.BuilderFirstMessage {
+            while(getSizeNoTag() < expectedSize) {
+                parseFieldFrom(input)
+            }
+            if (getSizeNoTag() > expectedSize) { errorCode = 2 }
+            return this
+        }
+
+        fun parseFrom(input: CodedInputStream): FirstMessage.BuilderFirstMessage {
+            while(parseFieldFrom(input)) {}
+            return this
+        }
+
+        //========== Size-related methods ===========
+        fun getSize(fieldNumber: Int): Int {
+            var size = 0
+            if (int_field != 0) {
+                size += WireFormat.getInt32Size(1, int_field)
+            }
+            size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED)
+            return size
+        }
+
+        fun getSizeNoTag(): Int {
+            var size = 0
+            if (int_field != 0) {
+                size += WireFormat.getInt32Size(1, int_field)
+            }
+            return size
+        }
+
+    }
+
+}
+
+fun compareThirdMessages(kt1: ThirdMessage, kt2: ThirdMessage): Boolean {
+    return kt1.second_msg.first_msg.int_field == kt2.second_msg.first_msg.int_field
+}
+
+fun compareSecondMessages(lhs: SecondMessage, rhs: SecondMessage): Boolean {
+    return lhs.first_msg.int_field == rhs.first_msg.int_field
+}
+
+fun compareFirstMessages(lhs: FirstMessage, rhs: FirstMessage): Boolean {
+    return lhs.int_field == rhs.int_field
+}
+
+fun buildThirdMessage(value: Int): ThirdMessage.BuilderThirdMessage {
+    return ThirdMessage.BuilderThirdMessage(
+            SecondMessage.BuilderSecondMessage(
+                    FirstMessage.BuilderFirstMessage(
+                            value
+                    ).build()
+            ).build()
+        )
+}
+
+fun buildSecondMessage(value: Int): SecondMessage.BuilderSecondMessage {
+    return SecondMessage.BuilderSecondMessage(
+            FirstMessage.BuilderFirstMessage(
+                    value
+            ).build()
+        )
+}
+
+fun buildFirstMessage(value: Int): FirstMessage.BuilderFirstMessage {
+    return FirstMessage.BuilderFirstMessage(value)
+}
+
+fun checkThird(msg: ThirdMessage): Int {
+    val outs = CodedOutputStream(ByteArray(msg.getSizeNoTag()))
+    msg.writeTo(outs)
+
+    val ins = CodedInputStream(outs.buffer)
+    val readMsg = buildThirdMessage(0).parseFrom(ins).build()
+
+    if (readMsg.errorCode != 0) {
+        return 1
+    }
+    if (compareThirdMessages(msg, readMsg)) {
+        return 0
+    } else {
+        return 1
+    }
+}
+
+fun checkSecond(msg: SecondMessage): Int {
+    val outs = CodedOutputStream(ByteArray(msg.getSizeNoTag()))
+    msg.writeTo(outs)
+
+    val ins = CodedInputStream(outs.buffer)
+    val readMsg = buildSecondMessage(0).parseFrom(ins).build()
+
+    if (readMsg.errorCode != 0) {
+        return 1
+    }
+    if (compareSecondMessages(msg, readMsg)) {
+        return 0
+    } else {
+        return 1
+    }
+}
+
+fun checkFirst(msg: FirstMessage): Int {
+    val outs = CodedOutputStream(ByteArray(msg.getSizeNoTag()))
+    msg.writeTo(outs)
+
+    val ins = CodedInputStream(outs.buffer)
+    val readMsg = buildFirstMessage(0).parseFrom(ins).build()
+
+    if (readMsg.errorCode != 0) {
+        return 1
+    }
+    if (compareFirstMessages(msg, readMsg)) {
+        return 0
+    } else {
+        return 1
+    }
+}
+
+fun testThirdCase(): Int {
+    val msg = buildThirdMessage(5).build()
+    return checkThird(msg)
+}
+
+fun testSecondCase(): Int {
+    val msg = buildSecondMessage(-31241501).build()
+    return checkSecond(msg)
+}
+
+fun testFirstCase(): Int {
+    val msg = buildFirstMessage(321311430).build()
+    return checkFirst(msg)
+}
+

translator/src/test/kotlin/tests/kotlin/proto_repeated_zigzag.kt

@@ -0,0 +1,546 @@
+class MessageRepeatedZigZag private constructor (var int: IntArray, var long: LongArray) {
+    //========== Properties ===========
+    //repeated sint32 int = 1
+
+    //repeated sint64 long = 2
+
+    var errorCode: Int = 0
+
+    //========== Serialization methods ===========
+    fun writeTo (output: CodedOutputStream) {
+        //repeated sint32 int = 1
+        if (int.size > 0) {
+            output.writeTag(1, WireType.LENGTH_DELIMITED)
+            var arrayByteSize = 0
+
+            if (int.size != 0) {
+                do {
+                    var arraySize = 0
+                    var i = 0
+                    while (i < int.size) {
+                        arraySize += WireFormat.getSInt32SizeNoTag(int[i])
+                        i += 1
+                    }
+                    arrayByteSize += arraySize
+                } while(false)
+            }
+            output.writeInt32NoTag(arrayByteSize)
+
+            do {
+                var i = 0
+                while (i < int.size) {
+                    output.writeSInt32NoTag (int[i])
+                    i += 1
+                }
+            } while(false)
+        }
+
+        //repeated sint64 long = 2
+        if (long.size > 0) {
+            output.writeTag(2, WireType.LENGTH_DELIMITED)
+            var arrayByteSize = 0
+
+            if (long.size != 0) {
+                do {
+                    var arraySize = 0
+                    var i = 0
+                    while (i < long.size) {
+                        arraySize += WireFormat.getSInt64SizeNoTag(long[i])
+                        i += 1
+                    }
+                    arrayByteSize += arraySize
+                } while(false)
+            }
+            output.writeInt32NoTag(arrayByteSize)
+
+            do {
+                var i = 0
+                while (i < long.size) {
+                    output.writeSInt64NoTag (long[i])
+                    i += 1
+                }
+            } while(false)
+        }
+
+    }
+
+    fun mergeWith (other: MessageRepeatedZigZag) {
+        int = int.plus((other.int))
+        long = long.plus((other.long))
+        this.errorCode = other.errorCode
+    }
+
+    fun mergeFromWithSize (input: CodedInputStream, expectedSize: Int) {
+        val builder = MessageRepeatedZigZag.BuilderMessageRepeatedZigZag(IntArray(0), LongArray(0))
+        mergeWith(builder.parseFromWithSize(input, expectedSize).build())
+    }
+
+    fun mergeFrom (input: CodedInputStream) {
+        val builder = MessageRepeatedZigZag.BuilderMessageRepeatedZigZag(IntArray(0), LongArray(0))
+        mergeWith(builder.parseFrom(input).build())
+    }
+
+    //========== Size-related methods ===========
+    fun getSize(fieldNumber: Int): Int {
+        var size = 0
+        if (int.size != 0) {
+            do {
+                var arraySize = 0
+                size += WireFormat.getTagSize(1, WireType.LENGTH_DELIMITED)
+                var i = 0
+                while (i < int.size) {
+                    arraySize += WireFormat.getSInt32SizeNoTag(int[i])
+                    i += 1
+                }
+                size += arraySize
+                size += WireFormat.getInt32SizeNoTag(arraySize)
+            } while(false)
+        }
+        if (long.size != 0) {
+            do {
+                var arraySize = 0
+                size += WireFormat.getTagSize(2, WireType.LENGTH_DELIMITED)
+                var i = 0
+                while (i < long.size) {
+                    arraySize += WireFormat.getSInt64SizeNoTag(long[i])
+                    i += 1
+                }
+                size += arraySize
+                size += WireFormat.getInt32SizeNoTag(arraySize)
+            } while(false)
+        }
+        size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED)
+        return size
+    }
+
+    fun getSizeNoTag(): Int {
+        var size = 0
+        if (int.size != 0) {
+            do {
+                var arraySize = 0
+                size += WireFormat.getTagSize(1, WireType.LENGTH_DELIMITED)
+                var i = 0
+                while (i < int.size) {
+                    arraySize += WireFormat.getSInt32SizeNoTag(int[i])
+                    i += 1
+                }
+                size += arraySize
+                size += WireFormat.getInt32SizeNoTag(arraySize)
+            } while(false)
+        }
+        if (long.size != 0) {
+            do {
+                var arraySize = 0
+                size += WireFormat.getTagSize(2, WireType.LENGTH_DELIMITED)
+                var i = 0
+                while (i < long.size) {
+                    arraySize += WireFormat.getSInt64SizeNoTag(long[i])
+                    i += 1
+                }
+                size += arraySize
+                size += WireFormat.getInt32SizeNoTag(arraySize)
+            } while(false)
+        }
+        return size
+    }
+
+    //========== Builder ===========
+    class BuilderMessageRepeatedZigZag constructor (var int: IntArray, var long: LongArray) {
+        //========== Properties ===========
+        //repeated sint32 int = 1
+        fun setInt(value: IntArray): MessageRepeatedZigZag.BuilderMessageRepeatedZigZag {
+            int = value
+            return this
+        }
+        fun setintByIndex(index: Int, value: Int): MessageRepeatedZigZag.BuilderMessageRepeatedZigZag {
+            int[index] = value
+            return this
+        }
+
+        //repeated sint64 long = 2
+        fun setLong(value: LongArray): MessageRepeatedZigZag.BuilderMessageRepeatedZigZag {
+            long = value
+            return this
+        }
+        fun setlongByIndex(index: Int, value: Long): MessageRepeatedZigZag.BuilderMessageRepeatedZigZag {
+            long[index] = value
+            return this
+        }
+
+        var errorCode: Int = 0
+
+        //========== Serialization methods ===========
+        fun writeTo (output: CodedOutputStream) {
+            //repeated sint32 int = 1
+            if (int.size > 0) {
+                output.writeTag(1, WireType.LENGTH_DELIMITED)
+                var arrayByteSize = 0
+
+                if (int.size != 0) {
+                    do {
+                        var arraySize = 0
+                        var i = 0
+                        while (i < int.size) {
+                            arraySize += WireFormat.getSInt32SizeNoTag(int[i])
+                            i += 1
+                        }
+                        arrayByteSize += arraySize
+                    } while(false)
+                }
+                output.writeInt32NoTag(arrayByteSize)
+
+                do {
+                    var i = 0
+                    while (i < int.size) {
+                        output.writeSInt32NoTag (int[i])
+                        i += 1
+                    }
+                } while(false)
+            }
+
+            //repeated sint64 long = 2
+            if (long.size > 0) {
+                output.writeTag(2, WireType.LENGTH_DELIMITED)
+                var arrayByteSize = 0
+
+                if (long.size != 0) {
+                    do {
+                        var arraySize = 0
+                        var i = 0
+                        while (i < long.size) {
+                            arraySize += WireFormat.getSInt64SizeNoTag(long[i])
+                            i += 1
+                        }
+                        arrayByteSize += arraySize
+                    } while(false)
+                }
+                output.writeInt32NoTag(arrayByteSize)
+
+                do {
+                    var i = 0
+                    while (i < long.size) {
+                        output.writeSInt64NoTag (long[i])
+                        i += 1
+                    }
+                } while(false)
+            }
+
+        }
+
+        //========== Mutating methods ===========
+        fun build(): MessageRepeatedZigZag {
+            val res = MessageRepeatedZigZag(int, long)
+            res.errorCode = errorCode
+            return res
+        }
+
+        fun parseFieldFrom(input: CodedInputStream): Boolean {
+            if (input.isAtEnd()) { return false }
+            val tag = input.readInt32NoTag()
+            if (tag == 0) { return false }
+            val fieldNumber = WireFormat.getTagFieldNumber(tag)
+            val wireType = WireFormat.getTagWireType(tag)
+            when(fieldNumber) {
+                1 -> {
+                    if (wireType.id != WireType.LENGTH_DELIMITED.id) {
+                        errorCode = 1
+                        return false
+                    }
+                    val expectedByteSize = input.readInt32NoTag()
+                    var newArray = IntArray(0)
+                    var readSize = 0
+                    do {
+                        var i = 0
+                        while(readSize < expectedByteSize) {
+                            var tmp = IntArray(1)
+                            tmp[0] = input.readSInt32NoTag()
+                            newArray = newArray.plus(tmp)
+                            readSize += WireFormat.getSInt32SizeNoTag(tmp[0])
+                        }
+                        int = newArray
+                    } while (false)
+                }
+                2 -> {
+                    if (wireType.id != WireType.LENGTH_DELIMITED.id) {
+                        errorCode = 1
+                        return false
+                    }
+                    val expectedByteSize = input.readInt32NoTag()
+                    var newArray = LongArray(0)
+                    var readSize = 0
+                    do {
+                        var i = 0
+                        while(readSize < expectedByteSize) {
+                            var tmp = LongArray(1)
+                            tmp[0] = input.readSInt64NoTag()
+                            newArray = newArray.plus(tmp)
+                            readSize += WireFormat.getSInt64SizeNoTag(tmp[0])
+                        }
+                        long = newArray
+                    } while (false)
+                }
+                else -> errorCode = 4
+            }
+            return true
+        }
+
+        fun parseFromWithSize(input: CodedInputStream, expectedSize: Int): MessageRepeatedZigZag.BuilderMessageRepeatedZigZag {
+            while(getSizeNoTag() < expectedSize) {
+                parseFieldFrom(input)
+            }
+            if (getSizeNoTag() > expectedSize) { errorCode = 2 }
+            return this
+        }
+
+        fun parseFrom(input: CodedInputStream): MessageRepeatedZigZag.BuilderMessageRepeatedZigZag {
+            while(parseFieldFrom(input)) {}
+            return this
+        }
+
+        //========== Size-related methods ===========
+        fun getSize(fieldNumber: Int): Int {
+            var size = 0
+            if (int.size != 0) {
+                do {
+                    var arraySize = 0
+                    size += WireFormat.getTagSize(1, WireType.LENGTH_DELIMITED)
+                    var i = 0
+                    while (i < int.size) {
+                        arraySize += WireFormat.getSInt32SizeNoTag(int[i])
+                        i += 1
+                    }
+                    size += arraySize
+                    size += WireFormat.getInt32SizeNoTag(arraySize)
+                } while(false)
+            }
+            if (long.size != 0) {
+                do {
+                    var arraySize = 0
+                    size += WireFormat.getTagSize(2, WireType.LENGTH_DELIMITED)
+                    var i = 0
+                    while (i < long.size) {
+                        arraySize += WireFormat.getSInt64SizeNoTag(long[i])
+                        i += 1
+                    }
+                    size += arraySize
+                    size += WireFormat.getInt32SizeNoTag(arraySize)
+                } while(false)
+            }
+            size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED)
+            return size
+        }
+
+        fun getSizeNoTag(): Int {
+            var size = 0
+            if (int.size != 0) {
+                do {
+                    var arraySize = 0
+                    size += WireFormat.getTagSize(1, WireType.LENGTH_DELIMITED)
+                    var i = 0
+                    while (i < int.size) {
+                        arraySize += WireFormat.getSInt32SizeNoTag(int[i])
+                        i += 1
+                    }
+                    size += arraySize
+                    size += WireFormat.getInt32SizeNoTag(arraySize)
+                } while(false)
+            }
+            if (long.size != 0) {
+                do {
+                    var arraySize = 0
+                    size += WireFormat.getTagSize(2, WireType.LENGTH_DELIMITED)
+                    var i = 0
+                    while (i < long.size) {
+                        arraySize += WireFormat.getSInt64SizeNoTag(long[i])
+                        i += 1
+                    }
+                    size += arraySize
+                    size += WireFormat.getInt32SizeNoTag(arraySize)
+                } while(false)
+            }
+            return size
+        }
+
+    }
+
+}
+
+fun compareIntArrays(lhs: IntArray, rhs: IntArray): Boolean {
+    if (lhs.size != rhs.size) {
+        return false
+    }
+
+    var i = 0
+    while (i < lhs.size) {
+        if (lhs[i] != rhs[i]) {
+            return false
+        }
+        i += 1
+    }
+    return true
+}
+
+fun compareLongArrays(lhs: LongArray, rhs: LongArray): Boolean {
+    if (lhs.size != rhs.size) {
+        return false
+    }
+
+    var i = 0
+    while (i < lhs.size) {
+        if (lhs[i] != rhs[i]) {
+            return false
+        }
+        i += 1
+    }
+    return true
+}
+
+fun compareBooleanArrays(lhs: BooleanArray, rhs: BooleanArray): Boolean {
+    if (lhs.size != rhs.size) {
+        return false
+    }
+
+    var i = 0
+    while (i < lhs.size) {
+        if (lhs[i] != rhs[i]) {
+            return false
+        }
+        i += 1
+    }
+    return true
+}
+
+fun compareRepeatedZigZags(kt1: MessageRepeatedZigZag, kt2: MessageRepeatedZigZag): Boolean {
+    return  compareIntArrays(kt1.int, kt2.int) and
+            compareLongArrays(kt1.long, kt2.long)
+}
+
+fun checkRepZZSerializationIdentity(msg: MessageRepeatedZigZag): Int {
+    val outs = CodedOutputStream(ByteArray(msg.getSizeNoTag()))
+    msg.writeTo(outs)
+
+    val ins = CodedInputStream(outs.buffer)
+    val readMsg = MessageRepeatedZigZag.BuilderMessageRepeatedZigZag(
+            IntArray(0),
+            LongArray(0)
+        ).parseFrom(ins).build()
+
+    if (readMsg.errorCode != 0) {
+        return 1
+    }
+    if (compareRepeatedZigZags(msg, readMsg)) {
+        return 0
+    } else {
+        return 1
+    }
+}
+
+object Rng {
+    var rngState = 0.6938893903907228
+
+    val point = 762939453125
+    fun rng(): Double {
+        val res = rngState - rngState.toInt().toDouble()
+        rngState *= point.toDouble()
+        return res
+    }
+}
+
+fun nextInt(minVal: Int, maxVal: Int): Int {
+    return (Rng.rng() * (maxVal - minVal + 1).toDouble()).toInt()
+}
+
+fun nextLong(): Long {
+    val lowerHalf = nextInt(-2147483647, 2147483647)
+    val upperHalf = nextInt(-2147483647, 2147483647)
+    return (upperHalf.toLong() shl 32) + lowerHalf.toLong()
+}
+
+fun generateIntArray(): IntArray {
+    val size = nextInt(0, 10000)
+    val arr = IntArray(size)
+    var i = 0
+    while (i < size) {
+        arr[i] = nextInt(-2147483647, 2147483647)
+        i += 1
+    }
+    return arr
+}
+
+fun generateLongArray(): LongArray {
+    val size = nextInt(0, 10000)
+    val arr = LongArray(size)
+    var i = 0
+    while (i < size) {
+        arr[i] = nextLong()
+        i += 1
+    }
+    return arr
+}
+
+fun generateRandomMessage(): MessageRepeatedZigZag {
+    return MessageRepeatedZigZag.BuilderMessageRepeatedZigZag(
+            generateIntArray(),
+            generateLongArray()
+    ).build()
+}
+
+fun testRepZigZag(): Int {
+    var i = 0
+    val testRuns = 100
+    while (i < 100) {
+        val msg = generateRandomMessage()
+        if (checkRepZZSerializationIdentity(msg) == 1) {
+            return 1
+        }
+        i += 1
+    }
+    return 0
+}
+
+fun testArraysOfMinValues(): Int {
+    val intArr = IntArray(100)
+    var i = 0
+    while (i < 100) {
+        intArr[i] = -2147483647
+        i += 1
+    }
+
+    val longArr = LongArray(100)
+    i = 0
+    while (i < 100) {
+        longArr[i] = -9223372036854775807L
+        i += 1
+    }
+
+    val msg = MessageRepeatedZigZag.BuilderMessageRepeatedZigZag(intArr, longArr).build()
+    return checkRepZZSerializationIdentity(msg)
+}
+
+fun testArraysOfMaxValues(): Int {
+    val intArr = IntArray(100)
+    var i = 0
+    while (i < 100) {
+        intArr[i] = 2147483647
+        i += 1
+    }
+
+    val longArr = LongArray(100)
+    i = 0
+    while (i < 100) {
+        longArr[i] = 9223372036854775807L
+        i += 1
+    }
+
+    val msg = MessageRepeatedZigZag.BuilderMessageRepeatedZigZag(intArr, longArr).build()
+    return checkRepZZSerializationIdentity(msg)
+}
+
+fun testArraysOfDefaultValues(): Int {
+    val intArr = IntArray(100)
+
+    val longArr = LongArray(100)
+
+    val msg = MessageRepeatedZigZag.BuilderMessageRepeatedZigZag(intArr, longArr).build()
+    return checkRepZZSerializationIdentity(msg)
+}

translator/src/test/kotlin/tests/kotlin/proto_tagorder_test.kt

@@ -0,0 +1,788 @@
+class TagOrder private constructor (var sint: Int, var int: Int, var slong_array: LongArray, var enum_field: TagOrder.Enum) {
+    //========== Properties ===========
+    //sint32 sint = 8
+
+    //int32 int = 3423
+
+    //repeated sint64 slong_array = 12321
+
+    //enum enum_field = 938423
+
+    var errorCode: Int = 0
+
+    //========== Nested enums declarations ===========
+    enum class Enum(val id: Int) {
+        first_val (0),
+        second_val (1),
+        Unexpected(2);
+
+        companion object {
+            fun fromIntToEnum (ord: Int): Enum {
+                return when (ord) {
+                    0 -> Enum.first_val
+                    1 -> Enum.second_val
+                    else -> Unexpected
+                }
+            }
+        }
+    }
+    //========== Serialization methods ===========
+    fun writeTo (output: CodedOutputStream) {
+        //sint32 sint = 8
+        if (sint != 0) {
+            output.writeSInt32 (8, sint)
+        }
+
+        //int32 int = 3423
+        if (int != 0) {
+            output.writeInt32 (3423, int)
+        }
+
+        //repeated sint64 slong_array = 12321
+        if (slong_array.size > 0) {
+            output.writeTag(12321, WireType.LENGTH_DELIMITED)
+            var arrayByteSize = 0
+
+            if (slong_array.size != 0) {
+                do {
+                    var arraySize = 0
+                    var i = 0
+                    while (i < slong_array.size) {
+                        arraySize += WireFormat.getSInt64SizeNoTag(slong_array[i])
+                        i += 1
+                    }
+                    arrayByteSize += arraySize
+                } while(false)
+            }
+            output.writeInt32NoTag(arrayByteSize)
+
+            do {
+                var i = 0
+                while (i < slong_array.size) {
+                    output.writeSInt64NoTag (slong_array[i])
+                    i += 1
+                }
+            } while(false)
+        }
+
+        //enum enum_field = 938423
+        if (enum_field.id != TagOrder.Enum.fromIntToEnum(0).id) {
+            output.writeEnum (938423, enum_field.id)
+        }
+
+    }
+
+    fun mergeWith (other: TagOrder) {
+        sint = other.sint
+        int = other.int
+        slong_array = slong_array.plus((other.slong_array))
+        enum_field = other.enum_field
+        this.errorCode = other.errorCode
+    }
+
+    fun mergeFromWithSize (input: CodedInputStream, expectedSize: Int) {
+        val builder = TagOrder.BuilderTagOrder(0, 0, LongArray(0), TagOrder.Enum.fromIntToEnum(0))
+        mergeWith(builder.parseFromWithSize(input, expectedSize).build())
+    }
+
+    fun mergeFrom (input: CodedInputStream) {
+        val builder = TagOrder.BuilderTagOrder(0, 0, LongArray(0), TagOrder.Enum.fromIntToEnum(0))
+        mergeWith(builder.parseFrom(input).build())
+    }
+
+    //========== Size-related methods ===========
+    fun getSize(fieldNumber: Int): Int {
+        var size = 0
+        if (sint != 0) {
+            size += WireFormat.getSInt32Size(8, sint)
+        }
+        if (int != 0) {
+            size += WireFormat.getInt32Size(3423, int)
+        }
+        if (slong_array.size != 0) {
+            do {
+                var arraySize = 0
+                size += WireFormat.getTagSize(12321, WireType.LENGTH_DELIMITED)
+                var i = 0
+                while (i < slong_array.size) {
+                    arraySize += WireFormat.getSInt64SizeNoTag(slong_array[i])
+                    i += 1
+                }
+                size += arraySize
+                size += WireFormat.getInt32SizeNoTag(arraySize)
+            } while(false)
+        }
+        if (enum_field != TagOrder.Enum.fromIntToEnum(0)) {
+            size += WireFormat.getEnumSize(938423, enum_field.id)
+        }
+        size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED)
+        return size
+    }
+
+    fun getSizeNoTag(): Int {
+        var size = 0
+        if (sint != 0) {
+            size += WireFormat.getSInt32Size(8, sint)
+        }
+        if (int != 0) {
+            size += WireFormat.getInt32Size(3423, int)
+        }
+        if (slong_array.size != 0) {
+            do {
+                var arraySize = 0
+                size += WireFormat.getTagSize(12321, WireType.LENGTH_DELIMITED)
+                var i = 0
+                while (i < slong_array.size) {
+                    arraySize += WireFormat.getSInt64SizeNoTag(slong_array[i])
+                    i += 1
+                }
+                size += arraySize
+                size += WireFormat.getInt32SizeNoTag(arraySize)
+            } while(false)
+        }
+        if (enum_field != TagOrder.Enum.fromIntToEnum(0)) {
+            size += WireFormat.getEnumSize(938423, enum_field.id)
+        }
+        return size
+    }
+
+    //========== Builder ===========
+    class BuilderTagOrder constructor (var sint: Int, var int: Int, var slong_array: LongArray, var enum_field: TagOrder.Enum) {
+        //========== Properties ===========
+        //sint32 sint = 8
+        fun setSint(value: Int): TagOrder.BuilderTagOrder {
+            sint = value
+            return this
+        }
+
+        //int32 int = 3423
+        fun setInt(value: Int): TagOrder.BuilderTagOrder {
+            int = value
+            return this
+        }
+
+        //repeated sint64 slong_array = 12321
+        fun setSlong_array(value: LongArray): TagOrder.BuilderTagOrder {
+            slong_array = value
+            return this
+        }
+        fun setslong_arrayByIndex(index: Int, value: Long): TagOrder.BuilderTagOrder {
+            slong_array[index] = value
+            return this
+        }
+
+        //enum enum_field = 938423
+        fun setEnum_field(value: TagOrder.Enum): TagOrder.BuilderTagOrder {
+            enum_field = value
+            return this
+        }
+
+        var errorCode: Int = 0
+
+        //========== Serialization methods ===========
+        fun writeTo (output: CodedOutputStream) {
+            //sint32 sint = 8
+            if (sint != 0) {
+                output.writeSInt32 (8, sint)
+            }
+
+            //int32 int = 3423
+            if (int != 0) {
+                output.writeInt32 (3423, int)
+            }
+
+            //repeated sint64 slong_array = 12321
+            if (slong_array.size > 0) {
+                output.writeTag(12321, WireType.LENGTH_DELIMITED)
+                var arrayByteSize = 0
+
+                if (slong_array.size != 0) {
+                    do {
+                        var arraySize = 0
+                        var i = 0
+                        while (i < slong_array.size) {
+                            arraySize += WireFormat.getSInt64SizeNoTag(slong_array[i])
+                            i += 1
+                        }
+                        arrayByteSize += arraySize
+                    } while(false)
+                }
+                output.writeInt32NoTag(arrayByteSize)
+
+                do {
+                    var i = 0
+                    while (i < slong_array.size) {
+                        output.writeSInt64NoTag (slong_array[i])
+                        i += 1
+                    }
+                } while(false)
+            }
+
+            //enum enum_field = 938423
+            if (enum_field.id != TagOrder.Enum.fromIntToEnum(0).id) {
+                output.writeEnum (938423, enum_field.id)
+            }
+
+        }
+
+        //========== Mutating methods ===========
+        fun build(): TagOrder {
+            val res = TagOrder(sint, int, slong_array, enum_field)
+            res.errorCode = errorCode
+            return res
+        }
+
+        fun parseFieldFrom(input: CodedInputStream): Boolean {
+            if (input.isAtEnd()) { return false }
+            val tag = input.readInt32NoTag()
+            if (tag == 0) { return false }
+            val fieldNumber = WireFormat.getTagFieldNumber(tag)
+            val wireType = WireFormat.getTagWireType(tag)
+            when(fieldNumber) {
+                8 -> {
+                    if (wireType.id != WireType.VARINT.id) {
+                        errorCode = 1
+                        return false
+                    }
+                    sint = input.readSInt32NoTag()
+                }
+                3423 -> {
+                    if (wireType.id != WireType.VARINT.id) {
+                        errorCode = 1
+                        return false
+                    }
+                    int = input.readInt32NoTag()
+                }
+                12321 -> {
+                    if (wireType.id != WireType.LENGTH_DELIMITED.id) {
+                        errorCode = 1
+                        return false
+                    }
+                    val expectedByteSize = input.readInt32NoTag()
+                    var newArray = LongArray(0)
+                    var readSize = 0
+                    do {
+                        var i = 0
+                        while(readSize < expectedByteSize) {
+                            var tmp = LongArray(1)
+                            tmp[0] = input.readSInt64NoTag()
+                            newArray = newArray.plus(tmp)
+                            readSize += WireFormat.getSInt64SizeNoTag(tmp[0])
+                        }
+                        slong_array = newArray
+                    } while (false)
+                }
+                938423 -> {
+                    if (wireType.id != WireType.VARINT.id) {
+                        errorCode = 1
+                        return false
+                    }
+                    enum_field = TagOrder.Enum.fromIntToEnum(input.readEnumNoTag())
+                }
+                else -> errorCode = 4
+            }
+            return true
+        }
+
+        fun parseFromWithSize(input: CodedInputStream, expectedSize: Int): TagOrder.BuilderTagOrder {
+            while(getSizeNoTag() < expectedSize) {
+                parseFieldFrom(input)
+            }
+            if (getSizeNoTag() > expectedSize) { errorCode = 2 }
+            return this
+        }
+
+        fun parseFrom(input: CodedInputStream): TagOrder.BuilderTagOrder {
+            while(parseFieldFrom(input)) {}
+            return this
+        }
+
+        //========== Size-related methods ===========
+        fun getSize(fieldNumber: Int): Int {
+            var size = 0
+            if (sint != 0) {
+                size += WireFormat.getSInt32Size(8, sint)
+            }
+            if (int != 0) {
+                size += WireFormat.getInt32Size(3423, int)
+            }
+            if (slong_array.size != 0) {
+                do {
+                    var arraySize = 0
+                    size += WireFormat.getTagSize(12321, WireType.LENGTH_DELIMITED)
+                    var i = 0
+                    while (i < slong_array.size) {
+                        arraySize += WireFormat.getSInt64SizeNoTag(slong_array[i])
+                        i += 1
+                    }
+                    size += arraySize
+                    size += WireFormat.getInt32SizeNoTag(arraySize)
+                } while(false)
+            }
+            if (enum_field != TagOrder.Enum.fromIntToEnum(0)) {
+                size += WireFormat.getEnumSize(938423, enum_field.id)
+            }
+            size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED)
+            return size
+        }
+
+        fun getSizeNoTag(): Int {
+            var size = 0
+            if (sint != 0) {
+                size += WireFormat.getSInt32Size(8, sint)
+            }
+            if (int != 0) {
+                size += WireFormat.getInt32Size(3423, int)
+            }
+            if (slong_array.size != 0) {
+                do {
+                    var arraySize = 0
+                    size += WireFormat.getTagSize(12321, WireType.LENGTH_DELIMITED)
+                    var i = 0
+                    while (i < slong_array.size) {
+                        arraySize += WireFormat.getSInt64SizeNoTag(slong_array[i])
+                        i += 1
+                    }
+                    size += arraySize
+                    size += WireFormat.getInt32SizeNoTag(arraySize)
+                } while(false)
+            }
+            if (enum_field != TagOrder.Enum.fromIntToEnum(0)) {
+                size += WireFormat.getEnumSize(938423, enum_field.id)
+            }
+            return size
+        }
+
+    }
+
+}
+
+class TagOrderShuffled private constructor (var sint: Int, var int: Int, var slong_array: LongArray, var enum_field: TagOrderShuffled.Enum) {
+    //========== Properties ===========
+    //sint32 sint = 8
+
+    //int32 int = 3423
+
+    //repeated sint64 slong_array = 12321
+
+    //enum enum_field = 938423
+
+    var errorCode: Int = 0
+
+    //========== Nested enums declarations ===========
+    enum class Enum(val id: Int) {
+        first_val (0),
+        second_val (1),
+        Unexpected(2);
+
+        companion object {
+            fun fromIntToEnum (ord: Int): Enum {
+                return when (ord) {
+                    0 -> Enum.first_val
+                    1 -> Enum.second_val
+                    else -> Unexpected
+                }
+            }
+        }
+    }
+    //========== Serialization methods ===========
+    fun writeTo (output: CodedOutputStream) {
+        //sint32 sint = 8
+        if (sint != 0) {
+            output.writeSInt32 (8, sint)
+        }
+
+        //int32 int = 3423
+        if (int != 0) {
+            output.writeInt32 (3423, int)
+        }
+
+        //repeated sint64 slong_array = 12321
+        if (slong_array.size > 0) {
+            output.writeTag(12321, WireType.LENGTH_DELIMITED)
+            var arrayByteSize = 0
+
+            if (slong_array.size != 0) {
+                do {
+                    var arraySize = 0
+                    var i = 0
+                    while (i < slong_array.size) {
+                        arraySize += WireFormat.getSInt64SizeNoTag(slong_array[i])
+                        i += 1
+                    }
+                    arrayByteSize += arraySize
+                } while(false)
+            }
+            output.writeInt32NoTag(arrayByteSize)
+
+            do {
+                var i = 0
+                while (i < slong_array.size) {
+                    output.writeSInt64NoTag (slong_array[i])
+                    i += 1
+                }
+            } while(false)
+        }
+
+        //enum enum_field = 938423
+        if (enum_field.id != TagOrderShuffled.Enum.fromIntToEnum(0).id) {
+            output.writeEnum (938423, enum_field.id)
+        }
+
+    }
+
+    fun mergeWith (other: TagOrderShuffled) {
+        sint = other.sint
+        int = other.int
+        slong_array = slong_array.plus((other.slong_array))
+        enum_field = other.enum_field
+        this.errorCode = other.errorCode
+    }
+
+    fun mergeFromWithSize (input: CodedInputStream, expectedSize: Int) {
+        val builder = TagOrderShuffled.BuilderTagOrderShuffled(0, 0, LongArray(0), TagOrderShuffled.Enum.fromIntToEnum(0))
+        mergeWith(builder.parseFromWithSize(input, expectedSize).build())
+    }
+
+    fun mergeFrom (input: CodedInputStream) {
+        val builder = TagOrderShuffled.BuilderTagOrderShuffled(0, 0, LongArray(0), TagOrderShuffled.Enum.fromIntToEnum(0))
+        mergeWith(builder.parseFrom(input).build())
+    }
+
+    //========== Size-related methods ===========
+    fun getSize(fieldNumber: Int): Int {
+        var size = 0
+        if (sint != 0) {
+            size += WireFormat.getSInt32Size(8, sint)
+        }
+        if (int != 0) {
+            size += WireFormat.getInt32Size(3423, int)
+        }
+        if (slong_array.size != 0) {
+            do {
+                var arraySize = 0
+                size += WireFormat.getTagSize(12321, WireType.LENGTH_DELIMITED)
+                var i = 0
+                while (i < slong_array.size) {
+                    arraySize += WireFormat.getSInt64SizeNoTag(slong_array[i])
+                    i += 1
+                }
+                size += arraySize
+                size += WireFormat.getInt32SizeNoTag(arraySize)
+            } while(false)
+        }
+        if (enum_field != TagOrderShuffled.Enum.fromIntToEnum(0)) {
+            size += WireFormat.getEnumSize(938423, enum_field.id)
+        }
+        size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED)
+        return size
+    }
+
+    fun getSizeNoTag(): Int {
+        var size = 0
+        if (sint != 0) {
+            size += WireFormat.getSInt32Size(8, sint)
+        }
+        if (int != 0) {
+            size += WireFormat.getInt32Size(3423, int)
+        }
+        if (slong_array.size != 0) {
+            do {
+                var arraySize = 0
+                size += WireFormat.getTagSize(12321, WireType.LENGTH_DELIMITED)
+                var i = 0
+                while (i < slong_array.size) {
+                    arraySize += WireFormat.getSInt64SizeNoTag(slong_array[i])
+                    i += 1
+                }
+                size += arraySize
+                size += WireFormat.getInt32SizeNoTag(arraySize)
+            } while(false)
+        }
+        if (enum_field != TagOrderShuffled.Enum.fromIntToEnum(0)) {
+            size += WireFormat.getEnumSize(938423, enum_field.id)
+        }
+        return size
+    }
+
+    //========== Builder ===========
+    class BuilderTagOrderShuffled constructor (var sint: Int, var int: Int, var slong_array: LongArray, var enum_field: TagOrderShuffled.Enum) {
+        //========== Properties ===========
+        //sint32 sint = 8
+        fun setSint(value: Int): TagOrderShuffled.BuilderTagOrderShuffled {
+            sint = value
+            return this
+        }
+
+        //int32 int = 3423
+        fun setInt(value: Int): TagOrderShuffled.BuilderTagOrderShuffled {
+            int = value
+            return this
+        }
+
+        //repeated sint64 slong_array = 12321
+        fun setSlong_array(value: LongArray): TagOrderShuffled.BuilderTagOrderShuffled {
+            slong_array = value
+            return this
+        }
+        fun setslong_arrayByIndex(index: Int, value: Long): TagOrderShuffled.BuilderTagOrderShuffled {
+            slong_array[index] = value
+            return this
+        }
+
+        //enum enum_field = 938423
+        fun setEnum_field(value: TagOrderShuffled.Enum): TagOrderShuffled.BuilderTagOrderShuffled {
+            enum_field = value
+            return this
+        }
+
+        var errorCode: Int = 0
+
+        //========== Serialization methods ===========
+        fun writeTo (output: CodedOutputStream) {
+            //sint32 sint = 8
+            if (sint != 0) {
+                output.writeSInt32 (8, sint)
+            }
+
+            //int32 int = 3423
+            if (int != 0) {
+                output.writeInt32 (3423, int)
+            }
+
+            //repeated sint64 slong_array = 12321
+            if (slong_array.size > 0) {
+                output.writeTag(12321, WireType.LENGTH_DELIMITED)
+                var arrayByteSize = 0
+
+                if (slong_array.size != 0) {
+                    do {
+                        var arraySize = 0
+                        var i = 0
+                        while (i < slong_array.size) {
+                            arraySize += WireFormat.getSInt64SizeNoTag(slong_array[i])
+                            i += 1
+                        }
+                        arrayByteSize += arraySize
+                    } while(false)
+                }
+                output.writeInt32NoTag(arrayByteSize)
+
+                do {
+                    var i = 0
+                    while (i < slong_array.size) {
+                        output.writeSInt64NoTag (slong_array[i])
+                        i += 1
+                    }
+                } while(false)
+            }
+
+            //enum enum_field = 938423
+            if (enum_field.id != TagOrderShuffled.Enum.fromIntToEnum(0).id) {
+                output.writeEnum (938423, enum_field.id)
+            }
+
+        }
+
+        //========== Mutating methods ===========
+        fun build(): TagOrderShuffled {
+            val res = TagOrderShuffled(sint, int, slong_array, enum_field)
+            res.errorCode = errorCode
+            return res
+        }
+
+        fun parseFieldFrom(input: CodedInputStream): Boolean {
+            if (input.isAtEnd()) { return false }
+            val tag = input.readInt32NoTag()
+            if (tag == 0) { return false }
+            val fieldNumber = WireFormat.getTagFieldNumber(tag)
+            val wireType = WireFormat.getTagWireType(tag)
+            when(fieldNumber) {
+                8 -> {
+                    if (wireType.id != WireType.VARINT.id) {
+                        errorCode = 1
+                        return false
+                    }
+                    sint = input.readSInt32NoTag()
+                }
+                3423 -> {
+                    if (wireType.id != WireType.VARINT.id) {
+                        errorCode = 1
+                        return false
+                    }
+                    int = input.readInt32NoTag()
+                }
+                12321 -> {
+                    if (wireType.id != WireType.LENGTH_DELIMITED.id) {
+                        errorCode = 1
+                        return false
+                    }
+                    val expectedByteSize = input.readInt32NoTag()
+                    var newArray = LongArray(0)
+                    var readSize = 0
+                    do {
+                        var i = 0
+                        while(readSize < expectedByteSize) {
+                            var tmp = LongArray(1)
+                            tmp[0] = input.readSInt64NoTag()
+                            newArray = newArray.plus(tmp)
+                            readSize += WireFormat.getSInt64SizeNoTag(tmp[0])
+                        }
+                        slong_array = newArray
+                    } while (false)
+                }
+                938423 -> {
+                    if (wireType.id != WireType.VARINT.id) {
+                        errorCode = 1
+                        return false
+                    }
+                    enum_field = TagOrderShuffled.Enum.fromIntToEnum(input.readEnumNoTag())
+                }
+                else -> errorCode = 4
+            }
+            return true
+        }
+
+        fun parseFromWithSize(input: CodedInputStream, expectedSize: Int): TagOrderShuffled.BuilderTagOrderShuffled {
+            while(getSizeNoTag() < expectedSize) {
+                parseFieldFrom(input)
+            }
+            if (getSizeNoTag() > expectedSize) { errorCode = 2 }
+            return this
+        }
+
+        fun parseFrom(input: CodedInputStream): TagOrderShuffled.BuilderTagOrderShuffled {
+            while(parseFieldFrom(input)) {}
+            return this
+        }
+
+        //========== Size-related methods ===========
+        fun getSize(fieldNumber: Int): Int {
+            var size = 0
+            if (sint != 0) {
+                size += WireFormat.getSInt32Size(8, sint)
+            }
+            if (int != 0) {
+                size += WireFormat.getInt32Size(3423, int)
+            }
+            if (slong_array.size != 0) {
+                do {
+                    var arraySize = 0
+                    size += WireFormat.getTagSize(12321, WireType.LENGTH_DELIMITED)
+                    var i = 0
+                    while (i < slong_array.size) {
+                        arraySize += WireFormat.getSInt64SizeNoTag(slong_array[i])
+                        i += 1
+                    }
+                    size += arraySize
+                    size += WireFormat.getInt32SizeNoTag(arraySize)
+                } while(false)
+            }
+            if (enum_field != TagOrderShuffled.Enum.fromIntToEnum(0)) {
+                size += WireFormat.getEnumSize(938423, enum_field.id)
+            }
+            size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED)
+            return size
+        }
+
+        fun getSizeNoTag(): Int {
+            var size = 0
+            if (sint != 0) {
+                size += WireFormat.getSInt32Size(8, sint)
+            }
+            if (int != 0) {
+                size += WireFormat.getInt32Size(3423, int)
+            }
+            if (slong_array.size != 0) {
+                do {
+                    var arraySize = 0
+                    size += WireFormat.getTagSize(12321, WireType.LENGTH_DELIMITED)
+                    var i = 0
+                    while (i < slong_array.size) {
+                        arraySize += WireFormat.getSInt64SizeNoTag(slong_array[i])
+                        i += 1
+                    }
+                    size += arraySize
+                    size += WireFormat.getInt32SizeNoTag(arraySize)
+                } while(false)
+            }
+            if (enum_field != TagOrderShuffled.Enum.fromIntToEnum(0)) {
+                size += WireFormat.getEnumSize(938423, enum_field.id)
+            }
+            return size
+        }
+
+    }
+
+}
+
+fun compareLongArrays(lhs: LongArray, rhs: LongArray): Boolean {
+    if (lhs.size != rhs.size) {
+        return false
+    }
+
+    var i = 0
+    while (i < lhs.size) {
+        if (lhs[i] != rhs[i]) {
+            return false
+        }
+        i += 1
+    }
+    return true
+}
+
+fun compareTagAndShuffledTag(kt1: TagOrder, kt2: TagOrderShuffled): Boolean {
+    return (kt1.enum_field.id == kt2.enum_field.id) and
+            (kt1.int == kt2.int) and
+            (kt1.sint == kt2.sint) and
+            compareLongArrays(kt1.slong_array, kt2.slong_array)
+}
+
+fun checkTagToShuffled(msg: TagOrder): Int {
+    val outs = CodedOutputStream(ByteArray(msg.getSizeNoTag()))
+    msg.writeTo(outs)
+
+    val ins = CodedInputStream(outs.buffer)
+    val readMsg = TagOrderShuffled.BuilderTagOrderShuffled(0, 0, LongArray(0), TagOrderShuffled.Enum.first_val).parseFrom(ins).build()
+
+    if (compareTagAndShuffledTag(msg, readMsg)) {
+        return 0
+    } else {
+        return 1
+    }
+}
+
+fun checkShuffledToTag(msg: TagOrderShuffled): Int {
+    val outs = CodedOutputStream(ByteArray(msg.getSizeNoTag()))
+    msg.writeTo(outs)
+
+    val ins = CodedInputStream(outs.buffer)
+    val readMsg = TagOrder.BuilderTagOrder(0, 0, LongArray(0), TagOrder.Enum.first_val).parseFrom(ins).build()
+
+    if (readMsg.errorCode != 0) {
+        return 1
+    }
+    if (compareTagAndShuffledTag(readMsg, msg)) {
+        return 0
+    } else {
+        return 1
+    }
+}
+
+fun testTagToShuffled(): Int {
+    val arr = LongArray(3)
+    arr[0] = 94289342345678289L
+    arr[1]  = -423643342423442342L
+
+    val msg = TagOrder.BuilderTagOrder(312321, -34268, arr, TagOrder.Enum.first_val).build()
+    return checkTagToShuffled(msg)
+}
+
+fun testShuffledToTag(): Int {
+    val arr = LongArray(3)
+    arr[0] = 94289342345678289L
+    arr[1]  = -423643342423442342L
+
+    val msg = TagOrderShuffled.BuilderTagOrderShuffled(312321, -34268, arr, TagOrderShuffled.Enum.first_val).build()
+    return checkShuffledToTag(msg)
+}

translator/src/test/kotlin/tests/kotlin/proto_varint.kt

@@ -0,0 +1,491 @@
+class MessageVarints private constructor (var int: Int, var long: Long, var sint: Int, var slong: Long, var bl: Boolean, var enumField: MessageVarints.TestEnum, var uint: Int, var ulong: Long) {
+    //========== Properties ===========
+    //int32 int = 1
+
+    //int64 long = 2
+
+    //sint32 sint = 3
+
+    //sint64 slong = 4
+
+    //bool bl = 5
+
+    //enum enumField = 6
+
+    //uint32 uint = 7
+
+    //uint64 ulong = 8
+
+    var errorCode: Int = 0
+
+    //========== Nested enums declarations ===========
+    enum class TestEnum(val id: Int) {
+        firstVal (0),
+        secondVal (1),
+        thirdVal (2),
+        Unexpected(3);
+
+        companion object {
+            fun fromIntToTestEnum (ord: Int): TestEnum {
+                return when (ord) {
+                    0 -> TestEnum.firstVal
+                    1 -> TestEnum.secondVal
+                    2 -> TestEnum.thirdVal
+                    else -> Unexpected
+                }
+            }
+        }
+    }
+    //========== Serialization methods ===========
+    fun writeTo (output: CodedOutputStream) {
+        //int32 int = 1
+        if (int != 0) {
+            output.writeInt32 (1, int)
+        }
+
+        //int64 long = 2
+        if (long != 0L) {
+            output.writeInt64 (2, long)
+        }
+
+        //sint32 sint = 3
+        if (sint != 0) {
+            output.writeSInt32 (3, sint)
+        }
+
+        //sint64 slong = 4
+        if (slong != 0L) {
+            output.writeSInt64 (4, slong)
+        }
+
+        //bool bl = 5
+        if (bl != false) {
+            output.writeBool (5, bl)
+        }
+
+        //enum enumField = 6
+        if (enumField.id != MessageVarints.TestEnum.fromIntToTestEnum(0).id) {
+            output.writeEnum (6, enumField.id)
+        }
+
+        //uint32 uint = 7
+        if (uint != 0) {
+            output.writeUInt32 (7, uint)
+        }
+
+        //uint64 ulong = 8
+        if (ulong != 0L) {
+            output.writeUInt64 (8, ulong)
+        }
+
+    }
+
+    fun mergeWith (other: MessageVarints) {
+        int = other.int
+        long = other.long
+        sint = other.sint
+        slong = other.slong
+        bl = other.bl
+        enumField = other.enumField
+        uint = other.uint
+        ulong = other.ulong
+        this.errorCode = other.errorCode
+    }
+
+    fun mergeFromWithSize (input: CodedInputStream, expectedSize: Int) {
+        val builder = MessageVarints.BuilderMessageVarints(0, 0L, 0, 0L, false, MessageVarints.TestEnum.fromIntToTestEnum(0), 0, 0L)
+        mergeWith(builder.parseFromWithSize(input, expectedSize).build())
+    }
+
+    fun mergeFrom (input: CodedInputStream) {
+        val builder = MessageVarints.BuilderMessageVarints(0, 0L, 0, 0L, false, MessageVarints.TestEnum.fromIntToTestEnum(0), 0, 0L)
+        mergeWith(builder.parseFrom(input).build())
+    }
+
+    //========== Size-related methods ===========
+    fun getSize(fieldNumber: Int): Int {
+        var size = 0
+        if (int != 0) {
+            size += WireFormat.getInt32Size(1, int)
+        }
+        if (long != 0L) {
+            size += WireFormat.getInt64Size(2, long)
+        }
+        if (sint != 0) {
+            size += WireFormat.getSInt32Size(3, sint)
+        }
+        if (slong != 0L) {
+            size += WireFormat.getSInt64Size(4, slong)
+        }
+        if (bl != false) {
+            size += WireFormat.getBoolSize(5, bl)
+        }
+        if (enumField != MessageVarints.TestEnum.fromIntToTestEnum(0)) {
+            size += WireFormat.getEnumSize(6, enumField.id)
+        }
+        if (uint != 0) {
+            size += WireFormat.getUInt32Size(7, uint)
+        }
+        if (ulong != 0L) {
+            size += WireFormat.getUInt64Size(8, ulong)
+        }
+        size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED)
+        return size
+    }
+
+    fun getSizeNoTag(): Int {
+        var size = 0
+        if (int != 0) {
+            size += WireFormat.getInt32Size(1, int)
+        }
+        if (long != 0L) {
+            size += WireFormat.getInt64Size(2, long)
+        }
+        if (sint != 0) {
+            size += WireFormat.getSInt32Size(3, sint)
+        }
+        if (slong != 0L) {
+            size += WireFormat.getSInt64Size(4, slong)
+        }
+        if (bl != false) {
+            size += WireFormat.getBoolSize(5, bl)
+        }
+        if (enumField != MessageVarints.TestEnum.fromIntToTestEnum(0)) {
+            size += WireFormat.getEnumSize(6, enumField.id)
+        }
+        if (uint != 0) {
+            size += WireFormat.getUInt32Size(7, uint)
+        }
+        if (ulong != 0L) {
+            size += WireFormat.getUInt64Size(8, ulong)
+        }
+        return size
+    }
+
+    //========== Builder ===========
+    class BuilderMessageVarints constructor (var int: Int, var long: Long, var sint: Int, var slong: Long, var bl: Boolean, var enumField: MessageVarints.TestEnum, var uint: Int, var ulong: Long) {
+        //========== Properties ===========
+        //int32 int = 1
+        fun setInt(value: Int): MessageVarints.BuilderMessageVarints {
+            int = value
+            return this
+        }
+
+        //int64 long = 2
+        fun setLong(value: Long): MessageVarints.BuilderMessageVarints {
+            long = value
+            return this
+        }
+
+        //sint32 sint = 3
+        fun setSint(value: Int): MessageVarints.BuilderMessageVarints {
+            sint = value
+            return this
+        }
+
+        //sint64 slong = 4
+        fun setSlong(value: Long): MessageVarints.BuilderMessageVarints {
+            slong = value
+            return this
+        }
+
+        //bool bl = 5
+        fun setBl(value: Boolean): MessageVarints.BuilderMessageVarints {
+            bl = value
+            return this
+        }
+
+        //enum enumField = 6
+        fun setEnumField(value: MessageVarints.TestEnum): MessageVarints.BuilderMessageVarints {
+            enumField = value
+            return this
+        }
+
+        //uint32 uint = 7
+        fun setUint(value: Int): MessageVarints.BuilderMessageVarints {
+            uint = value
+            return this
+        }
+
+        //uint64 ulong = 8
+        fun setUlong(value: Long): MessageVarints.BuilderMessageVarints {
+            ulong = value
+            return this
+        }
+
+        var errorCode: Int = 0
+
+        //========== Serialization methods ===========
+        fun writeTo (output: CodedOutputStream) {
+            //int32 int = 1
+            if (int != 0) {
+                output.writeInt32 (1, int)
+            }
+
+            //int64 long = 2
+            if (long != 0L) {
+                output.writeInt64 (2, long)
+            }
+
+            //sint32 sint = 3
+            if (sint != 0) {
+                output.writeSInt32 (3, sint)
+            }
+
+            //sint64 slong = 4
+            if (slong != 0L) {
+                output.writeSInt64 (4, slong)
+            }
+
+            //bool bl = 5
+            if (bl != false) {
+                output.writeBool (5, bl)
+            }
+
+            //enum enumField = 6
+            if (enumField.id != MessageVarints.TestEnum.fromIntToTestEnum(0).id) {
+                output.writeEnum (6, enumField.id)
+            }
+
+            //uint32 uint = 7
+            if (uint != 0) {
+                output.writeUInt32 (7, uint)
+            }
+
+            //uint64 ulong = 8
+            if (ulong != 0L) {
+                output.writeUInt64 (8, ulong)
+            }
+
+        }
+
+        //========== Mutating methods ===========
+        fun build(): MessageVarints {
+            val res = MessageVarints(int, long, sint, slong, bl, enumField, uint, ulong)
+            res.errorCode = errorCode
+            return res
+        }
+
+        fun parseFieldFrom(input: CodedInputStream): Boolean {
+            if (input.isAtEnd()) { return false }
+            val tag = input.readInt32NoTag()
+            if (tag == 0) { return false }
+            val fieldNumber = WireFormat.getTagFieldNumber(tag)
+            val wireType = WireFormat.getTagWireType(tag)
+            when(fieldNumber) {
+                1 -> {
+                    if (wireType.id != WireType.VARINT.id) {
+                        errorCode = 1
+                        return false
+                    }
+                    int = input.readInt32NoTag()
+                }
+                2 -> {
+                    if (wireType.id != WireType.VARINT.id) {
+                        errorCode = 1
+                        return false
+                    }
+                    long = input.readInt64NoTag()
+                }
+                3 -> {
+                    if (wireType.id != WireType.VARINT.id) {
+                        errorCode = 1
+                        return false
+                    }
+                    sint = input.readSInt32NoTag()
+                }
+                4 -> {
+                    if (wireType.id != WireType.VARINT.id) {
+                        errorCode = 1
+                        return false
+                    }
+                    slong = input.readSInt64NoTag()
+                }
+                5 -> {
+                    if (wireType.id != WireType.VARINT.id) {
+                        errorCode = 1
+                        return false
+                    }
+                    bl = input.readBoolNoTag()
+                }
+                6 -> {
+                    if (wireType.id != WireType.VARINT.id) {
+                        errorCode = 1
+                        return false
+                    }
+                    enumField = MessageVarints.TestEnum.fromIntToTestEnum(input.readEnumNoTag())
+                }
+                7 -> {
+                    if (wireType.id != WireType.VARINT.id) {
+                        errorCode = 1
+                        return false
+                    }
+                    uint = input.readUInt32NoTag()
+                }
+                8 -> {
+                    if (wireType.id != WireType.VARINT.id) {
+                        errorCode = 1
+                        return false
+                    }
+                    ulong = input.readUInt64NoTag()
+                }
+                else -> errorCode = 4
+            }
+            return true
+        }
+
+        fun parseFromWithSize(input: CodedInputStream, expectedSize: Int): MessageVarints.BuilderMessageVarints {
+            while(getSizeNoTag() < expectedSize) {
+                parseFieldFrom(input)
+            }
+            if (getSizeNoTag() > expectedSize) { errorCode = 2 }
+            return this
+        }
+
+        fun parseFrom(input: CodedInputStream): MessageVarints.BuilderMessageVarints {
+            while(parseFieldFrom(input)) {}
+            return this
+        }
+
+        //========== Size-related methods ===========
+        fun getSize(fieldNumber: Int): Int {
+            var size = 0
+            if (int != 0) {
+                size += WireFormat.getInt32Size(1, int)
+            }
+            if (long != 0L) {
+                size += WireFormat.getInt64Size(2, long)
+            }
+            if (sint != 0) {
+                size += WireFormat.getSInt32Size(3, sint)
+            }
+            if (slong != 0L) {
+                size += WireFormat.getSInt64Size(4, slong)
+            }
+            if (bl != false) {
+                size += WireFormat.getBoolSize(5, bl)
+            }
+            if (enumField != MessageVarints.TestEnum.fromIntToTestEnum(0)) {
+                size += WireFormat.getEnumSize(6, enumField.id)
+            }
+            if (uint != 0) {
+                size += WireFormat.getUInt32Size(7, uint)
+            }
+            if (ulong != 0L) {
+                size += WireFormat.getUInt64Size(8, ulong)
+            }
+            size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED)
+            return size
+        }
+
+        fun getSizeNoTag(): Int {
+            var size = 0
+            if (int != 0) {
+                size += WireFormat.getInt32Size(1, int)
+            }
+            if (long != 0L) {
+                size += WireFormat.getInt64Size(2, long)
+            }
+            if (sint != 0) {
+                size += WireFormat.getSInt32Size(3, sint)
+            }
+            if (slong != 0L) {
+                size += WireFormat.getSInt64Size(4, slong)
+            }
+            if (bl != false) {
+                size += WireFormat.getBoolSize(5, bl)
+            }
+            if (enumField != MessageVarints.TestEnum.fromIntToTestEnum(0)) {
+                size += WireFormat.getEnumSize(6, enumField.id)
+            }
+            if (uint != 0) {
+                size += WireFormat.getUInt32Size(7, uint)
+            }
+            if (ulong != 0L) {
+                size += WireFormat.getUInt64Size(8, ulong)
+            }
+            return size
+        }
+
+    }
+
+}
+
+fun compareVarints(kt1: MessageVarints, kt2: MessageVarints): Boolean {
+    return (kt1.int == kt2.int) and
+            (kt1.long == kt2.long) and
+            (kt1.sint == kt2.sint) and
+            (kt1.slong == kt2.slong) and
+            (kt1.bl == kt2.bl) and
+            (kt1.uint == kt2.uint) and
+            (kt1.ulong == kt2.ulong) and
+            (kt1.enumField.id == kt2.enumField.id)
+}
+
+fun checkVarintsSerializationIdentity(msg: MessageVarints): Int {
+    val outs = CodedOutputStream(ByteArray(msg.getSizeNoTag()))
+    msg.writeTo(outs)
+
+    val ins = CodedInputStream(outs.buffer)
+    val readMsg = MessageVarints.BuilderMessageVarints(0, 0L, 0, 0L, false, MessageVarints.TestEnum.fromIntToTestEnum(0), 0, 0L)
+            .parseFrom(ins).build()
+
+    if (readMsg.errorCode != 0) {
+        return 1
+    }
+    if (compareVarints(msg, readMsg)) {
+        return 0
+    } else {
+        return 1
+    }
+}
+
+fun testVarintDefaultMessage(): Int {
+    val msg = MessageVarints.BuilderMessageVarints(0, 0L, 0, 0L, false, MessageVarints.TestEnum.fromIntToTestEnum(0), 0, 0L).build()
+    return checkVarintsSerializationIdentity(msg)
+}
+
+fun testVarintTrivialMessage(): Int {
+    val msg = MessageVarints.BuilderMessageVarints(
+                21312, -2131231231L, 5346734, 42121313211L, true, MessageVarints.TestEnum.fromIntToTestEnum(2), 3672356, 3478787863467834678L
+            ).build()
+    return checkVarintsSerializationIdentity(msg)
+}
+
+fun testVarintNegativeMessage(): Int {
+    val msg = MessageVarints.BuilderMessageVarints(
+            -312732, -2131231231L, -5346734, -42121313211L, true, MessageVarints.TestEnum.fromIntToTestEnum(3), 3672356, 3478787863467834678L
+    ).build()
+
+    return checkVarintsSerializationIdentity(msg)
+}
+
+fun testVarintMaxValues(): Int {
+    val msg = MessageVarints.BuilderMessageVarints(
+            2147483647,
+            9223372036854775807L,
+            2147483647,
+            9223372036854775807L,
+            true,
+            MessageVarints.TestEnum.fromIntToTestEnum(3),
+            2147483647,
+            9223372036854775807L
+    ).build()
+
+    return checkVarintsSerializationIdentity(msg)
+}
+
+fun testVarintMinValues(): Int {
+    val msg = MessageVarints.BuilderMessageVarints(
+            -2147483647,
+            -9223372036854775807L,
+            -2147483647,
+            -9223372036854775807L,
+            false,
+            MessageVarints.TestEnum.fromIntToTestEnum(0),
+            -2147483647,
+            -9223372036854775807L
+    ).build()
+
+    return checkVarintsSerializationIdentity(msg)
+}

translator/src/test/kotlin/tests/kotlin/proto_zigzag.kt

@@ -0,0 +1,217 @@
+class MessageZigZag private constructor (var int: Int, var long: Long) {
+    //========== Properties ===========
+    //sint32 int = 1
+
+    //sint64 long = 2
+
+    var errorCode: Int = 0
+
+    //========== Serialization methods ===========
+    fun writeTo (output: CodedOutputStream) {
+        //sint32 int = 1
+        if (int != 0) {
+            output.writeSInt32 (1, int)
+        }
+
+        //sint64 long = 2
+        if (long != 0L) {
+            output.writeSInt64 (2, long)
+        }
+
+    }
+
+    fun mergeWith (other: MessageZigZag) {
+        int = other.int
+        long = other.long
+        this.errorCode = other.errorCode
+    }
+
+    fun mergeFromWithSize (input: CodedInputStream, expectedSize: Int) {
+        val builder = MessageZigZag.BuilderMessageZigZag(0, 0L)
+        mergeWith(builder.parseFromWithSize(input, expectedSize).build())
+    }
+
+    fun mergeFrom (input: CodedInputStream) {
+        val builder = MessageZigZag.BuilderMessageZigZag(0, 0L)
+        mergeWith(builder.parseFrom(input).build())
+    }
+
+    //========== Size-related methods ===========
+    fun getSize(fieldNumber: Int): Int {
+        var size = 0
+        if (int != 0) {
+            size += WireFormat.getSInt32Size(1, int)
+        }
+        if (long != 0L) {
+            size += WireFormat.getSInt64Size(2, long)
+        }
+        size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED)
+        return size
+    }
+
+    fun getSizeNoTag(): Int {
+        var size = 0
+        if (int != 0) {
+            size += WireFormat.getSInt32Size(1, int)
+        }
+        if (long != 0L) {
+            size += WireFormat.getSInt64Size(2, long)
+        }
+        return size
+    }
+
+    //========== Builder ===========
+    class BuilderMessageZigZag constructor (var int: Int, var long: Long) {
+        //========== Properties ===========
+        //sint32 int = 1
+        fun setInt(value: Int): MessageZigZag.BuilderMessageZigZag {
+            int = value
+            return this
+        }
+
+        //sint64 long = 2
+        fun setLong(value: Long): MessageZigZag.BuilderMessageZigZag {
+            long = value
+            return this
+        }
+
+        var errorCode: Int = 0
+
+        //========== Serialization methods ===========
+        fun writeTo (output: CodedOutputStream) {
+            //sint32 int = 1
+            if (int != 0) {
+                output.writeSInt32 (1, int)
+            }
+
+            //sint64 long = 2
+            if (long != 0L) {
+                output.writeSInt64 (2, long)
+            }
+
+        }
+
+        //========== Mutating methods ===========
+        fun build(): MessageZigZag {
+            val res = MessageZigZag(int, long)
+            res.errorCode = errorCode
+            return res
+        }
+
+        fun parseFieldFrom(input: CodedInputStream): Boolean {
+            if (input.isAtEnd()) { return false }
+            val tag = input.readInt32NoTag()
+            if (tag == 0) { return false }
+            val fieldNumber = WireFormat.getTagFieldNumber(tag)
+            val wireType = WireFormat.getTagWireType(tag)
+            when(fieldNumber) {
+                1 -> {
+                    if (wireType.id != WireType.VARINT.id) {
+                        errorCode = 1
+                        return false
+                    }
+                    int = input.readSInt32NoTag()
+                }
+                2 -> {
+                    if (wireType.id != WireType.VARINT.id) {
+                        errorCode = 1
+                        return false
+                    }
+                    long = input.readSInt64NoTag()
+                }
+                else -> errorCode = 4
+            }
+            return true
+        }
+
+        fun parseFromWithSize(input: CodedInputStream, expectedSize: Int): MessageZigZag.BuilderMessageZigZag {
+            while(getSizeNoTag() < expectedSize) {
+                parseFieldFrom(input)
+            }
+            if (getSizeNoTag() > expectedSize) { errorCode = 2 }
+            return this
+        }
+
+        fun parseFrom(input: CodedInputStream): MessageZigZag.BuilderMessageZigZag {
+            while(parseFieldFrom(input)) {}
+            return this
+        }
+
+        //========== Size-related methods ===========
+        fun getSize(fieldNumber: Int): Int {
+            var size = 0
+            if (int != 0) {
+                size += WireFormat.getSInt32Size(1, int)
+            }
+            if (long != 0L) {
+                size += WireFormat.getSInt64Size(2, long)
+            }
+            size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED)
+            return size
+        }
+
+        fun getSizeNoTag(): Int {
+            var size = 0
+            if (int != 0) {
+                size += WireFormat.getSInt32Size(1, int)
+            }
+            if (long != 0L) {
+                size += WireFormat.getSInt64Size(2, long)
+            }
+            return size
+        }
+
+    }
+
+}
+
+fun compareZigZags(kt1: MessageZigZag, kt2: MessageZigZag): Boolean {
+    return (kt1.int == kt2.int) and (kt1.long == kt2.long)
+}
+
+fun checkZigZagSerializationIdentity(msg: MessageZigZag): Int {
+    val outs = CodedOutputStream(ByteArray(msg.getSizeNoTag()))
+    msg.writeTo(outs)
+
+    val ins = CodedInputStream(outs.buffer)
+    val readMsg = MessageZigZag.BuilderMessageZigZag(0, 0L).parseFrom(ins).build()
+
+    if (readMsg.errorCode != 0) {
+        return 1
+    }
+    if (compareZigZags(msg, readMsg)) {
+        return 0
+    } else {
+        return 1
+    }
+}
+
+fun testZigZagDefaultValues(): Int {
+    val msg = MessageZigZag.BuilderMessageZigZag(0, 0L).build()
+    return checkZigZagSerializationIdentity(msg)
+}
+
+fun testZigZagRandomValues(): Int {
+    val msg = MessageZigZag.BuilderMessageZigZag(321782363, -466328364782634782L).build()
+    return checkZigZagSerializationIdentity(msg)
+}
+
+fun testZigZagNegativeValues(): Int {
+    val msg = MessageZigZag.BuilderMessageZigZag(-1321782363, -323721963313L).build()
+    return checkZigZagSerializationIdentity(msg)
+}
+
+fun testZigZagPositiveValues(): Int {
+    val msg = MessageZigZag.BuilderMessageZigZag(4788923, 240384293674L).build()
+    return checkZigZagSerializationIdentity(msg)
+}
+
+fun testZigZagMaxValues(): Int {
+    val msg = MessageZigZag.BuilderMessageZigZag(2147483647, 9223372036854775807L).build()
+    return checkZigZagSerializationIdentity(msg)
+}
+
+fun testZigZagMinValues(): Int {
+    val msg = MessageZigZag.BuilderMessageZigZag(-2147483647, -9223372036854775807L).build()
+    return checkZigZagSerializationIdentity(msg)
+}