From fba787386c4ef87b0cc7612436bf4ad53ff2f507 Mon Sep 17 00:00:00 2001 From: dsavvinov Date: Wed, 17 Aug 2016 19:36:48 +0300 Subject: [PATCH] Protobuf: added tests for nativ environment --- .../tests/input/proto_crossbranch_test.txt | 3 + .../tests/input/proto_location_test.txt | 3 + .../tests/input/proto_multiple_messages.txt | 3 + .../tests/input/proto_repeated_varint.txt | 4 + .../tests/input/proto_repeated_zigzag.txt | 4 + .../tests/input/proto_tagorder_test.txt | 2 + .../test/kotlin/tests/input/proto_varint.txt | 5 + .../test/kotlin/tests/input/proto_zigzag.txt | 6 + .../tests/kotlin/proto_crossbranch_test.kt | 1073 ++++++++++++++ .../tests/kotlin/proto_location_test.kt | 466 ++++++ .../tests/kotlin/proto_multiple_messages.kt | 495 +++++++ .../tests/kotlin/proto_repeated_varint.kt | 1293 +++++++++++++++++ .../tests/kotlin/proto_repeated_zigzag.kt | 546 +++++++ .../tests/kotlin/proto_tagorder_test.kt | 788 ++++++++++ .../test/kotlin/tests/kotlin/proto_varint.kt | 491 +++++++ .../test/kotlin/tests/kotlin/proto_zigzag.kt | 217 +++ 16 files changed, 5399 insertions(+) create mode 100644 translator/src/test/kotlin/tests/input/proto_crossbranch_test.txt create mode 100644 translator/src/test/kotlin/tests/input/proto_location_test.txt create mode 100644 translator/src/test/kotlin/tests/input/proto_multiple_messages.txt create mode 100644 translator/src/test/kotlin/tests/input/proto_repeated_varint.txt create mode 100644 translator/src/test/kotlin/tests/input/proto_repeated_zigzag.txt create mode 100644 translator/src/test/kotlin/tests/input/proto_tagorder_test.txt create mode 100644 translator/src/test/kotlin/tests/input/proto_varint.txt create mode 100644 translator/src/test/kotlin/tests/input/proto_zigzag.txt create mode 100644 translator/src/test/kotlin/tests/kotlin/proto_crossbranch_test.kt create mode 100644 translator/src/test/kotlin/tests/kotlin/proto_location_test.kt create mode 100644 translator/src/test/kotlin/tests/kotlin/proto_multiple_messages.kt create mode 100644 translator/src/test/kotlin/tests/kotlin/proto_repeated_varint.kt create mode 100644 translator/src/test/kotlin/tests/kotlin/proto_repeated_zigzag.kt create mode 100644 translator/src/test/kotlin/tests/kotlin/proto_tagorder_test.kt create mode 100644 translator/src/test/kotlin/tests/kotlin/proto_varint.kt create mode 100644 translator/src/test/kotlin/tests/kotlin/proto_zigzag.kt diff --git a/translator/src/test/kotlin/tests/input/proto_crossbranch_test.txt b/translator/src/test/kotlin/tests/input/proto_crossbranch_test.txt new file mode 100644 index 00000000000..5587dda54e7 --- /dev/null +++ b/translator/src/test/kotlin/tests/input/proto_crossbranch_test.txt @@ -0,0 +1,3 @@ +testTrivialValues() == 0 +testMaxValues() == 0 +testMinValues() == 0 diff --git a/translator/src/test/kotlin/tests/input/proto_location_test.txt b/translator/src/test/kotlin/tests/input/proto_location_test.txt new file mode 100644 index 00000000000..1d001fca6b8 --- /dev/null +++ b/translator/src/test/kotlin/tests/input/proto_location_test.txt @@ -0,0 +1,3 @@ +testTrivialLocationResponse() == 0 +testMaxLocationResponse() == 0 +testMinLocationResponse() == 0 diff --git a/translator/src/test/kotlin/tests/input/proto_multiple_messages.txt b/translator/src/test/kotlin/tests/input/proto_multiple_messages.txt new file mode 100644 index 00000000000..9c2f4ecabd7 --- /dev/null +++ b/translator/src/test/kotlin/tests/input/proto_multiple_messages.txt @@ -0,0 +1,3 @@ +testThirdCase() == 0 +testSecondCase() == 0 +testFirstCase() == 0 diff --git a/translator/src/test/kotlin/tests/input/proto_repeated_varint.txt b/translator/src/test/kotlin/tests/input/proto_repeated_varint.txt new file mode 100644 index 00000000000..d5e5ffa9e09 --- /dev/null +++ b/translator/src/test/kotlin/tests/input/proto_repeated_varint.txt @@ -0,0 +1,4 @@ +testArraysOfDefaultValues() == 0 +testArraysOfMinValues() == 0 +testArraysOfMaxValues() == 0 +testRepVarints() == 0 diff --git a/translator/src/test/kotlin/tests/input/proto_repeated_zigzag.txt b/translator/src/test/kotlin/tests/input/proto_repeated_zigzag.txt new file mode 100644 index 00000000000..1ffd5649916 --- /dev/null +++ b/translator/src/test/kotlin/tests/input/proto_repeated_zigzag.txt @@ -0,0 +1,4 @@ +testRepZigZag() == 0 +testArraysOfMinValues() == 0 +testArraysOfMaxValues() == 0 +testArraysOfDefaultValues() == 0 diff --git a/translator/src/test/kotlin/tests/input/proto_tagorder_test.txt b/translator/src/test/kotlin/tests/input/proto_tagorder_test.txt new file mode 100644 index 00000000000..374a1b28f17 --- /dev/null +++ b/translator/src/test/kotlin/tests/input/proto_tagorder_test.txt @@ -0,0 +1,2 @@ +testTagToShuffled() == 0 +testShuffledToTag() == 0 diff --git a/translator/src/test/kotlin/tests/input/proto_varint.txt b/translator/src/test/kotlin/tests/input/proto_varint.txt new file mode 100644 index 00000000000..c610d8177a3 --- /dev/null +++ b/translator/src/test/kotlin/tests/input/proto_varint.txt @@ -0,0 +1,5 @@ +testVarintDefaultMessage() == 0 +testVarintTrivialMessage() == 0 +testVarintNegativeMessage() == 0 +testVarintMaxValues() == 0 +testVarintMinValues() == 0 diff --git a/translator/src/test/kotlin/tests/input/proto_zigzag.txt b/translator/src/test/kotlin/tests/input/proto_zigzag.txt new file mode 100644 index 00000000000..15156624cfd --- /dev/null +++ b/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 diff --git a/translator/src/test/kotlin/tests/kotlin/proto_crossbranch_test.kt b/translator/src/test/kotlin/tests/kotlin/proto_crossbranch_test.kt new file mode 100644 index 00000000000..b1c0906a57a --- /dev/null +++ b/translator/src/test/kotlin/tests/kotlin/proto_crossbranch_test.kt @@ -0,0 +1,1073 @@ +class CrossBranch private constructor () { + //========== Properties =========== + var errorCode: Int = 0 + + //========== Nested classes declarations =========== + class Grandfather private constructor (var rf: CrossBranch.Grandfather.RightFather) { + //========== Properties =========== + //message rf = 1 + + var errorCode: Int = 0 + + //========== Nested classes declarations =========== + class LeftFather private constructor () { + //========== Properties =========== + var errorCode: Int = 0 + + //========== Nested classes declarations =========== + class LeftLeftSon private constructor (var son_field: Int) { + //========== Properties =========== + //int32 son_field = 1 + + var errorCode: Int = 0 + + //========== Serialization methods =========== + fun writeTo (output: CodedOutputStream) { + //int32 son_field = 1 + if (son_field != 0) { + output.writeInt32 (1, son_field) + } + + } + + fun mergeWith (other: CrossBranch.Grandfather.LeftFather.LeftLeftSon) { + son_field = other.son_field + this.errorCode = other.errorCode + } + + fun mergeFromWithSize (input: CodedInputStream, expectedSize: Int) { + val builder = CrossBranch.Grandfather.LeftFather.LeftLeftSon.BuilderLeftLeftSon(0) + mergeWith(builder.parseFromWithSize(input, expectedSize).build()) + } + + fun mergeFrom (input: CodedInputStream) { + val builder = CrossBranch.Grandfather.LeftFather.LeftLeftSon.BuilderLeftLeftSon(0) + mergeWith(builder.parseFrom(input).build()) + } + + //========== Size-related methods =========== + fun getSize(fieldNumber: Int): Int { + var size = 0 + if (son_field != 0) { + size += WireFormat.getInt32Size(1, son_field) + } + size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED) + return size + } + + fun getSizeNoTag(): Int { + var size = 0 + if (son_field != 0) { + size += WireFormat.getInt32Size(1, son_field) + } + return size + } + + //========== Builder =========== + class BuilderLeftLeftSon constructor (var son_field: Int) { + //========== Properties =========== + //int32 son_field = 1 + fun setSon_field(value: Int): CrossBranch.Grandfather.LeftFather.LeftLeftSon.BuilderLeftLeftSon { + son_field = value + return this + } + + var errorCode: Int = 0 + + //========== Serialization methods =========== + fun writeTo (output: CodedOutputStream) { + //int32 son_field = 1 + if (son_field != 0) { + output.writeInt32 (1, son_field) + } + + } + + //========== Mutating methods =========== + fun build(): CrossBranch.Grandfather.LeftFather.LeftLeftSon { + val res = CrossBranch.Grandfather.LeftFather.LeftLeftSon(son_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 + } + son_field = input.readInt32NoTag() + } + else -> errorCode = 4 + } + return true + } + + fun parseFromWithSize(input: CodedInputStream, expectedSize: Int): CrossBranch.Grandfather.LeftFather.LeftLeftSon.BuilderLeftLeftSon { + while(getSizeNoTag() < expectedSize) { + parseFieldFrom(input) + } + if (getSizeNoTag() > expectedSize) { errorCode = 2 } + return this + } + + fun parseFrom(input: CodedInputStream): CrossBranch.Grandfather.LeftFather.LeftLeftSon.BuilderLeftLeftSon { + while(parseFieldFrom(input)) {} + return this + } + + //========== Size-related methods =========== + fun getSize(fieldNumber: Int): Int { + var size = 0 + if (son_field != 0) { + size += WireFormat.getInt32Size(1, son_field) + } + size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED) + return size + } + + fun getSizeNoTag(): Int { + var size = 0 + if (son_field != 0) { + size += WireFormat.getInt32Size(1, son_field) + } + return size + } + + } + + } + + class LeftRightSon private constructor (var son_field: Int) { + //========== Properties =========== + //int32 son_field = 1 + + var errorCode: Int = 0 + + //========== Serialization methods =========== + fun writeTo (output: CodedOutputStream) { + //int32 son_field = 1 + if (son_field != 0) { + output.writeInt32 (1, son_field) + } + + } + + fun mergeWith (other: CrossBranch.Grandfather.LeftFather.LeftRightSon) { + son_field = other.son_field + this.errorCode = other.errorCode + } + + fun mergeFromWithSize (input: CodedInputStream, expectedSize: Int) { + val builder = CrossBranch.Grandfather.LeftFather.LeftRightSon.BuilderLeftRightSon(0) + mergeWith(builder.parseFromWithSize(input, expectedSize).build()) + } + + fun mergeFrom (input: CodedInputStream) { + val builder = CrossBranch.Grandfather.LeftFather.LeftRightSon.BuilderLeftRightSon(0) + mergeWith(builder.parseFrom(input).build()) + } + + //========== Size-related methods =========== + fun getSize(fieldNumber: Int): Int { + var size = 0 + if (son_field != 0) { + size += WireFormat.getInt32Size(1, son_field) + } + size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED) + return size + } + + fun getSizeNoTag(): Int { + var size = 0 + if (son_field != 0) { + size += WireFormat.getInt32Size(1, son_field) + } + return size + } + + //========== Builder =========== + class BuilderLeftRightSon constructor (var son_field: Int) { + //========== Properties =========== + //int32 son_field = 1 + fun setSon_field(value: Int): CrossBranch.Grandfather.LeftFather.LeftRightSon.BuilderLeftRightSon { + son_field = value + return this + } + + var errorCode: Int = 0 + + //========== Serialization methods =========== + fun writeTo (output: CodedOutputStream) { + //int32 son_field = 1 + if (son_field != 0) { + output.writeInt32 (1, son_field) + } + + } + + //========== Mutating methods =========== + fun build(): CrossBranch.Grandfather.LeftFather.LeftRightSon { + val res = CrossBranch.Grandfather.LeftFather.LeftRightSon(son_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 + } + son_field = input.readInt32NoTag() + } + else -> errorCode = 4 + } + return true + } + + fun parseFromWithSize(input: CodedInputStream, expectedSize: Int): CrossBranch.Grandfather.LeftFather.LeftRightSon.BuilderLeftRightSon { + while(getSizeNoTag() < expectedSize) { + parseFieldFrom(input) + } + if (getSizeNoTag() > expectedSize) { errorCode = 2 } + return this + } + + fun parseFrom(input: CodedInputStream): CrossBranch.Grandfather.LeftFather.LeftRightSon.BuilderLeftRightSon { + while(parseFieldFrom(input)) {} + return this + } + + //========== Size-related methods =========== + fun getSize(fieldNumber: Int): Int { + var size = 0 + if (son_field != 0) { + size += WireFormat.getInt32Size(1, son_field) + } + size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED) + return size + } + + fun getSizeNoTag(): Int { + var size = 0 + if (son_field != 0) { + size += WireFormat.getInt32Size(1, son_field) + } + return size + } + + } + + } + + //========== Serialization methods =========== + fun writeTo (output: CodedOutputStream) { + } + + fun mergeWith (other: CrossBranch.Grandfather.LeftFather) { + this.errorCode = other.errorCode + } + + fun mergeFromWithSize (input: CodedInputStream, expectedSize: Int) { + val builder = CrossBranch.Grandfather.LeftFather.BuilderLeftFather() + mergeWith(builder.parseFromWithSize(input, expectedSize).build()) + } + + fun mergeFrom (input: CodedInputStream) { + val builder = CrossBranch.Grandfather.LeftFather.BuilderLeftFather() + mergeWith(builder.parseFrom(input).build()) + } + + //========== Size-related methods =========== + fun getSize(fieldNumber: Int): Int { + var size = 0 + size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED) + return size + } + + fun getSizeNoTag(): Int { + var size = 0 + return size + } + + //========== Builder =========== + class BuilderLeftFather constructor () { + //========== Properties =========== + var errorCode: Int = 0 + + //========== Serialization methods =========== + fun writeTo (output: CodedOutputStream) { + } + + //========== Mutating methods =========== + fun build(): CrossBranch.Grandfather.LeftFather { + val res = CrossBranch.Grandfather.LeftFather() + 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) { + else -> errorCode = 4 + } + return true + } + + fun parseFromWithSize(input: CodedInputStream, expectedSize: Int): CrossBranch.Grandfather.LeftFather.BuilderLeftFather { + while(getSizeNoTag() < expectedSize) { + parseFieldFrom(input) + } + if (getSizeNoTag() > expectedSize) { errorCode = 2 } + return this + } + + fun parseFrom(input: CodedInputStream): CrossBranch.Grandfather.LeftFather.BuilderLeftFather { + while(parseFieldFrom(input)) {} + return this + } + + //========== Size-related methods =========== + fun getSize(fieldNumber: Int): Int { + var size = 0 + size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED) + return size + } + + fun getSizeNoTag(): Int { + var size = 0 + return size + } + + } + + } + + class RightFather private constructor (var rls: CrossBranch.Grandfather.RightFather.RightLeftSon, var rrs: CrossBranch.Grandfather.RightFather.RightRightSon) { + //========== Properties =========== + //message rls = 1 + + //message rrs = 2 + + var errorCode: Int = 0 + + //========== Nested classes declarations =========== + class RightLeftSon private constructor (var son_field: CrossBranch.Grandfather.LeftFather.LeftLeftSon) { + //========== Properties =========== + //message son_field = 1 + + var errorCode: Int = 0 + + //========== Serialization methods =========== + fun writeTo (output: CodedOutputStream) { + //message son_field = 1 + output.writeTag(1, WireType.LENGTH_DELIMITED) + output.writeInt32NoTag(son_field.getSizeNoTag()) + son_field.writeTo(output) + + } + + fun mergeWith (other: CrossBranch.Grandfather.RightFather.RightLeftSon) { + son_field = other.son_field + this.errorCode = other.errorCode + } + + fun mergeFromWithSize (input: CodedInputStream, expectedSize: Int) { + val builder = CrossBranch.Grandfather.RightFather.RightLeftSon.BuilderRightLeftSon(CrossBranch.Grandfather.LeftFather.LeftLeftSon.BuilderLeftLeftSon(0).build()) + mergeWith(builder.parseFromWithSize(input, expectedSize).build()) + } + + fun mergeFrom (input: CodedInputStream) { + val builder = CrossBranch.Grandfather.RightFather.RightLeftSon.BuilderRightLeftSon(CrossBranch.Grandfather.LeftFather.LeftLeftSon.BuilderLeftLeftSon(0).build()) + mergeWith(builder.parseFrom(input).build()) + } + + //========== Size-related methods =========== + fun getSize(fieldNumber: Int): Int { + var size = 0 + if (son_field != CrossBranch.Grandfather.LeftFather.LeftLeftSon.BuilderLeftLeftSon(0).build()) { + size += son_field.getSize(1) + } + size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED) + return size + } + + fun getSizeNoTag(): Int { + var size = 0 + if (son_field != CrossBranch.Grandfather.LeftFather.LeftLeftSon.BuilderLeftLeftSon(0).build()) { + size += son_field.getSize(1) + } + return size + } + + //========== Builder =========== + class BuilderRightLeftSon constructor (var son_field: CrossBranch.Grandfather.LeftFather.LeftLeftSon) { + //========== Properties =========== + //message son_field = 1 + fun setSon_field(value: CrossBranch.Grandfather.LeftFather.LeftLeftSon): CrossBranch.Grandfather.RightFather.RightLeftSon.BuilderRightLeftSon { + son_field = value + return this + } + + var errorCode: Int = 0 + + //========== Serialization methods =========== + fun writeTo (output: CodedOutputStream) { + //message son_field = 1 + output.writeTag(1, WireType.LENGTH_DELIMITED) + output.writeInt32NoTag(son_field.getSizeNoTag()) + son_field.writeTo(output) + + } + + //========== Mutating methods =========== + fun build(): CrossBranch.Grandfather.RightFather.RightLeftSon { + val res = CrossBranch.Grandfather.RightFather.RightLeftSon(son_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.LENGTH_DELIMITED.id) { + errorCode = 1 + return false + } + do { + val expectedSize = input.readInt32NoTag() + son_field.mergeFromWithSize(input, expectedSize) + if (expectedSize != son_field.getSizeNoTag()) { errorCode = 3; return false } + } while(false) + } + else -> errorCode = 4 + } + return true + } + + fun parseFromWithSize(input: CodedInputStream, expectedSize: Int): CrossBranch.Grandfather.RightFather.RightLeftSon.BuilderRightLeftSon { + while(getSizeNoTag() < expectedSize) { + parseFieldFrom(input) + } + if (getSizeNoTag() > expectedSize) { errorCode = 2 } + return this + } + + fun parseFrom(input: CodedInputStream): CrossBranch.Grandfather.RightFather.RightLeftSon.BuilderRightLeftSon { + while(parseFieldFrom(input)) {} + return this + } + + //========== Size-related methods =========== + fun getSize(fieldNumber: Int): Int { + var size = 0 + if (son_field != CrossBranch.Grandfather.LeftFather.LeftLeftSon.BuilderLeftLeftSon(0).build()) { + size += son_field.getSize(1) + } + size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED) + return size + } + + fun getSizeNoTag(): Int { + var size = 0 + if (son_field != CrossBranch.Grandfather.LeftFather.LeftLeftSon.BuilderLeftLeftSon(0).build()) { + size += son_field.getSize(1) + } + return size + } + + } + + } + + class RightRightSon private constructor (var son_field: CrossBranch.Grandfather.LeftFather.LeftRightSon) { + //========== Properties =========== + //message son_field = 1 + + var errorCode: Int = 0 + + //========== Serialization methods =========== + fun writeTo (output: CodedOutputStream) { + //message son_field = 1 + output.writeTag(1, WireType.LENGTH_DELIMITED) + output.writeInt32NoTag(son_field.getSizeNoTag()) + son_field.writeTo(output) + + } + + fun mergeWith (other: CrossBranch.Grandfather.RightFather.RightRightSon) { + son_field = other.son_field + this.errorCode = other.errorCode + } + + fun mergeFromWithSize (input: CodedInputStream, expectedSize: Int) { + val builder = CrossBranch.Grandfather.RightFather.RightRightSon.BuilderRightRightSon(CrossBranch.Grandfather.LeftFather.LeftRightSon.BuilderLeftRightSon(0).build()) + mergeWith(builder.parseFromWithSize(input, expectedSize).build()) + } + + fun mergeFrom (input: CodedInputStream) { + val builder = CrossBranch.Grandfather.RightFather.RightRightSon.BuilderRightRightSon(CrossBranch.Grandfather.LeftFather.LeftRightSon.BuilderLeftRightSon(0).build()) + mergeWith(builder.parseFrom(input).build()) + } + + //========== Size-related methods =========== + fun getSize(fieldNumber: Int): Int { + var size = 0 + if (son_field != CrossBranch.Grandfather.LeftFather.LeftRightSon.BuilderLeftRightSon(0).build()) { + size += son_field.getSize(1) + } + size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED) + return size + } + + fun getSizeNoTag(): Int { + var size = 0 + if (son_field != CrossBranch.Grandfather.LeftFather.LeftRightSon.BuilderLeftRightSon(0).build()) { + size += son_field.getSize(1) + } + return size + } + + //========== Builder =========== + class BuilderRightRightSon constructor (var son_field: CrossBranch.Grandfather.LeftFather.LeftRightSon) { + //========== Properties =========== + //message son_field = 1 + fun setSon_field(value: CrossBranch.Grandfather.LeftFather.LeftRightSon): CrossBranch.Grandfather.RightFather.RightRightSon.BuilderRightRightSon { + son_field = value + return this + } + + var errorCode: Int = 0 + + //========== Serialization methods =========== + fun writeTo (output: CodedOutputStream) { + //message son_field = 1 + output.writeTag(1, WireType.LENGTH_DELIMITED) + output.writeInt32NoTag(son_field.getSizeNoTag()) + son_field.writeTo(output) + + } + + //========== Mutating methods =========== + fun build(): CrossBranch.Grandfather.RightFather.RightRightSon { + val res = CrossBranch.Grandfather.RightFather.RightRightSon(son_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.LENGTH_DELIMITED.id) { + errorCode = 1 + return false + } + do { + val expectedSize = input.readInt32NoTag() + son_field.mergeFromWithSize(input, expectedSize) + if (expectedSize != son_field.getSizeNoTag()) { errorCode = 3; return false } + } while(false) + } + else -> errorCode = 4 + } + return true + } + + fun parseFromWithSize(input: CodedInputStream, expectedSize: Int): CrossBranch.Grandfather.RightFather.RightRightSon.BuilderRightRightSon { + while(getSizeNoTag() < expectedSize) { + parseFieldFrom(input) + } + if (getSizeNoTag() > expectedSize) { errorCode = 2 } + return this + } + + fun parseFrom(input: CodedInputStream): CrossBranch.Grandfather.RightFather.RightRightSon.BuilderRightRightSon { + while(parseFieldFrom(input)) {} + return this + } + + //========== Size-related methods =========== + fun getSize(fieldNumber: Int): Int { + var size = 0 + if (son_field != CrossBranch.Grandfather.LeftFather.LeftRightSon.BuilderLeftRightSon(0).build()) { + size += son_field.getSize(1) + } + size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED) + return size + } + + fun getSizeNoTag(): Int { + var size = 0 + if (son_field != CrossBranch.Grandfather.LeftFather.LeftRightSon.BuilderLeftRightSon(0).build()) { + size += son_field.getSize(1) + } + return size + } + + } + + } + + //========== Serialization methods =========== + fun writeTo (output: CodedOutputStream) { + //message rls = 1 + output.writeTag(1, WireType.LENGTH_DELIMITED) + output.writeInt32NoTag(rls.getSizeNoTag()) + rls.writeTo(output) + + //message rrs = 2 + output.writeTag(2, WireType.LENGTH_DELIMITED) + output.writeInt32NoTag(rrs.getSizeNoTag()) + rrs.writeTo(output) + + } + + fun mergeWith (other: CrossBranch.Grandfather.RightFather) { + rls = other.rls + rrs = other.rrs + this.errorCode = other.errorCode + } + + fun mergeFromWithSize (input: CodedInputStream, expectedSize: Int) { + val builder = CrossBranch.Grandfather.RightFather.BuilderRightFather(CrossBranch.Grandfather.RightFather.RightLeftSon.BuilderRightLeftSon(CrossBranch.Grandfather.LeftFather.LeftLeftSon.BuilderLeftLeftSon(0).build()).build(), CrossBranch.Grandfather.RightFather.RightRightSon.BuilderRightRightSon(CrossBranch.Grandfather.LeftFather.LeftRightSon.BuilderLeftRightSon(0).build()).build()) + mergeWith(builder.parseFromWithSize(input, expectedSize).build()) + } + + fun mergeFrom (input: CodedInputStream) { + val builder = CrossBranch.Grandfather.RightFather.BuilderRightFather(CrossBranch.Grandfather.RightFather.RightLeftSon.BuilderRightLeftSon(CrossBranch.Grandfather.LeftFather.LeftLeftSon.BuilderLeftLeftSon(0).build()).build(), CrossBranch.Grandfather.RightFather.RightRightSon.BuilderRightRightSon(CrossBranch.Grandfather.LeftFather.LeftRightSon.BuilderLeftRightSon(0).build()).build()) + mergeWith(builder.parseFrom(input).build()) + } + + //========== Size-related methods =========== + fun getSize(fieldNumber: Int): Int { + var size = 0 + if (rls != CrossBranch.Grandfather.RightFather.RightLeftSon.BuilderRightLeftSon(CrossBranch.Grandfather.LeftFather.LeftLeftSon.BuilderLeftLeftSon(0).build()).build()) { + size += rls.getSize(1) + } + if (rrs != CrossBranch.Grandfather.RightFather.RightRightSon.BuilderRightRightSon(CrossBranch.Grandfather.LeftFather.LeftRightSon.BuilderLeftRightSon(0).build()).build()) { + size += rrs.getSize(2) + } + size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED) + return size + } + + fun getSizeNoTag(): Int { + var size = 0 + if (rls != CrossBranch.Grandfather.RightFather.RightLeftSon.BuilderRightLeftSon(CrossBranch.Grandfather.LeftFather.LeftLeftSon.BuilderLeftLeftSon(0).build()).build()) { + size += rls.getSize(1) + } + if (rrs != CrossBranch.Grandfather.RightFather.RightRightSon.BuilderRightRightSon(CrossBranch.Grandfather.LeftFather.LeftRightSon.BuilderLeftRightSon(0).build()).build()) { + size += rrs.getSize(2) + } + return size + } + + //========== Builder =========== + class BuilderRightFather constructor (var rls: CrossBranch.Grandfather.RightFather.RightLeftSon, var rrs: CrossBranch.Grandfather.RightFather.RightRightSon) { + //========== Properties =========== + //message rls = 1 + fun setRls(value: CrossBranch.Grandfather.RightFather.RightLeftSon): CrossBranch.Grandfather.RightFather.BuilderRightFather { + rls = value + return this + } + + //message rrs = 2 + fun setRrs(value: CrossBranch.Grandfather.RightFather.RightRightSon): CrossBranch.Grandfather.RightFather.BuilderRightFather { + rrs = value + return this + } + + var errorCode: Int = 0 + + //========== Serialization methods =========== + fun writeTo (output: CodedOutputStream) { + //message rls = 1 + output.writeTag(1, WireType.LENGTH_DELIMITED) + output.writeInt32NoTag(rls.getSizeNoTag()) + rls.writeTo(output) + + //message rrs = 2 + output.writeTag(2, WireType.LENGTH_DELIMITED) + output.writeInt32NoTag(rrs.getSizeNoTag()) + rrs.writeTo(output) + + } + + //========== Mutating methods =========== + fun build(): CrossBranch.Grandfather.RightFather { + val res = CrossBranch.Grandfather.RightFather(rls, rrs) + 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() + rls.mergeFromWithSize(input, expectedSize) + if (expectedSize != rls.getSizeNoTag()) { errorCode = 3; return false } + } while(false) + } + 2 -> { + if (wireType.id != WireType.LENGTH_DELIMITED.id) { + errorCode = 1 + return false + } + do { + val expectedSize = input.readInt32NoTag() + rrs.mergeFromWithSize(input, expectedSize) + if (expectedSize != rrs.getSizeNoTag()) { errorCode = 3; return false } + } while(false) + } + else -> errorCode = 4 + } + return true + } + + fun parseFromWithSize(input: CodedInputStream, expectedSize: Int): CrossBranch.Grandfather.RightFather.BuilderRightFather { + while(getSizeNoTag() < expectedSize) { + parseFieldFrom(input) + } + if (getSizeNoTag() > expectedSize) { errorCode = 2 } + return this + } + + fun parseFrom(input: CodedInputStream): CrossBranch.Grandfather.RightFather.BuilderRightFather { + while(parseFieldFrom(input)) {} + return this + } + + //========== Size-related methods =========== + fun getSize(fieldNumber: Int): Int { + var size = 0 + if (rls != CrossBranch.Grandfather.RightFather.RightLeftSon.BuilderRightLeftSon(CrossBranch.Grandfather.LeftFather.LeftLeftSon.BuilderLeftLeftSon(0).build()).build()) { + size += rls.getSize(1) + } + if (rrs != CrossBranch.Grandfather.RightFather.RightRightSon.BuilderRightRightSon(CrossBranch.Grandfather.LeftFather.LeftRightSon.BuilderLeftRightSon(0).build()).build()) { + size += rrs.getSize(2) + } + size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED) + return size + } + + fun getSizeNoTag(): Int { + var size = 0 + if (rls != CrossBranch.Grandfather.RightFather.RightLeftSon.BuilderRightLeftSon(CrossBranch.Grandfather.LeftFather.LeftLeftSon.BuilderLeftLeftSon(0).build()).build()) { + size += rls.getSize(1) + } + if (rrs != CrossBranch.Grandfather.RightFather.RightRightSon.BuilderRightRightSon(CrossBranch.Grandfather.LeftFather.LeftRightSon.BuilderLeftRightSon(0).build()).build()) { + size += rrs.getSize(2) + } + return size + } + + } + + } + + //========== Serialization methods =========== + fun writeTo (output: CodedOutputStream) { + //message rf = 1 + output.writeTag(1, WireType.LENGTH_DELIMITED) + output.writeInt32NoTag(rf.getSizeNoTag()) + rf.writeTo(output) + + } + + fun mergeWith (other: CrossBranch.Grandfather) { + rf = other.rf + this.errorCode = other.errorCode + } + + fun mergeFromWithSize (input: CodedInputStream, expectedSize: Int) { + val builder = CrossBranch.Grandfather.BuilderGrandfather(CrossBranch.Grandfather.RightFather.BuilderRightFather(CrossBranch.Grandfather.RightFather.RightLeftSon.BuilderRightLeftSon(CrossBranch.Grandfather.LeftFather.LeftLeftSon.BuilderLeftLeftSon(0).build()).build(), CrossBranch.Grandfather.RightFather.RightRightSon.BuilderRightRightSon(CrossBranch.Grandfather.LeftFather.LeftRightSon.BuilderLeftRightSon(0).build()).build()).build()) + mergeWith(builder.parseFromWithSize(input, expectedSize).build()) + } + + fun mergeFrom (input: CodedInputStream) { + val builder = CrossBranch.Grandfather.BuilderGrandfather(CrossBranch.Grandfather.RightFather.BuilderRightFather(CrossBranch.Grandfather.RightFather.RightLeftSon.BuilderRightLeftSon(CrossBranch.Grandfather.LeftFather.LeftLeftSon.BuilderLeftLeftSon(0).build()).build(), CrossBranch.Grandfather.RightFather.RightRightSon.BuilderRightRightSon(CrossBranch.Grandfather.LeftFather.LeftRightSon.BuilderLeftRightSon(0).build()).build()).build()) + mergeWith(builder.parseFrom(input).build()) + } + + //========== Size-related methods =========== + fun getSize(fieldNumber: Int): Int { + var size = 0 + if (rf != CrossBranch.Grandfather.RightFather.BuilderRightFather(CrossBranch.Grandfather.RightFather.RightLeftSon.BuilderRightLeftSon(CrossBranch.Grandfather.LeftFather.LeftLeftSon.BuilderLeftLeftSon(0).build()).build(), CrossBranch.Grandfather.RightFather.RightRightSon.BuilderRightRightSon(CrossBranch.Grandfather.LeftFather.LeftRightSon.BuilderLeftRightSon(0).build()).build()).build()) { + size += rf.getSize(1) + } + size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED) + return size + } + + fun getSizeNoTag(): Int { + var size = 0 + if (rf != CrossBranch.Grandfather.RightFather.BuilderRightFather(CrossBranch.Grandfather.RightFather.RightLeftSon.BuilderRightLeftSon(CrossBranch.Grandfather.LeftFather.LeftLeftSon.BuilderLeftLeftSon(0).build()).build(), CrossBranch.Grandfather.RightFather.RightRightSon.BuilderRightRightSon(CrossBranch.Grandfather.LeftFather.LeftRightSon.BuilderLeftRightSon(0).build()).build()).build()) { + size += rf.getSize(1) + } + return size + } + + //========== Builder =========== + class BuilderGrandfather constructor (var rf: CrossBranch.Grandfather.RightFather) { + //========== Properties =========== + //message rf = 1 + fun setRf(value: CrossBranch.Grandfather.RightFather): CrossBranch.Grandfather.BuilderGrandfather { + rf = value + return this + } + + var errorCode: Int = 0 + + //========== Serialization methods =========== + fun writeTo (output: CodedOutputStream) { + //message rf = 1 + output.writeTag(1, WireType.LENGTH_DELIMITED) + output.writeInt32NoTag(rf.getSizeNoTag()) + rf.writeTo(output) + + } + + //========== Mutating methods =========== + fun build(): CrossBranch.Grandfather { + val res = CrossBranch.Grandfather(rf) + 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() + rf.mergeFromWithSize(input, expectedSize) + if (expectedSize != rf.getSizeNoTag()) { errorCode = 3; return false } + } while(false) + } + else -> errorCode = 4 + } + return true + } + + fun parseFromWithSize(input: CodedInputStream, expectedSize: Int): CrossBranch.Grandfather.BuilderGrandfather { + while(getSizeNoTag() < expectedSize) { + parseFieldFrom(input) + } + if (getSizeNoTag() > expectedSize) { errorCode = 2 } + return this + } + + fun parseFrom(input: CodedInputStream): CrossBranch.Grandfather.BuilderGrandfather { + while(parseFieldFrom(input)) {} + return this + } + + //========== Size-related methods =========== + fun getSize(fieldNumber: Int): Int { + var size = 0 + if (rf != CrossBranch.Grandfather.RightFather.BuilderRightFather(CrossBranch.Grandfather.RightFather.RightLeftSon.BuilderRightLeftSon(CrossBranch.Grandfather.LeftFather.LeftLeftSon.BuilderLeftLeftSon(0).build()).build(), CrossBranch.Grandfather.RightFather.RightRightSon.BuilderRightRightSon(CrossBranch.Grandfather.LeftFather.LeftRightSon.BuilderLeftRightSon(0).build()).build()).build()) { + size += rf.getSize(1) + } + size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED) + return size + } + + fun getSizeNoTag(): Int { + var size = 0 + if (rf != CrossBranch.Grandfather.RightFather.BuilderRightFather(CrossBranch.Grandfather.RightFather.RightLeftSon.BuilderRightLeftSon(CrossBranch.Grandfather.LeftFather.LeftLeftSon.BuilderLeftLeftSon(0).build()).build(), CrossBranch.Grandfather.RightFather.RightRightSon.BuilderRightRightSon(CrossBranch.Grandfather.LeftFather.LeftRightSon.BuilderLeftRightSon(0).build()).build()).build()) { + size += rf.getSize(1) + } + return size + } + + } + + } + + //========== Serialization methods =========== + fun writeTo (output: CodedOutputStream) { + } + + fun mergeWith (other: CrossBranch) { + this.errorCode = other.errorCode + } + + fun mergeFromWithSize (input: CodedInputStream, expectedSize: Int) { + val builder = CrossBranch.BuilderCrossBranch() + mergeWith(builder.parseFromWithSize(input, expectedSize).build()) + } + + fun mergeFrom (input: CodedInputStream) { + val builder = CrossBranch.BuilderCrossBranch() + mergeWith(builder.parseFrom(input).build()) + } + + //========== Size-related methods =========== + fun getSize(fieldNumber: Int): Int { + var size = 0 + size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED) + return size + } + + fun getSizeNoTag(): Int { + var size = 0 + return size + } + + //========== Builder =========== + class BuilderCrossBranch constructor () { + //========== Properties =========== + var errorCode: Int = 0 + + //========== Serialization methods =========== + fun writeTo (output: CodedOutputStream) { + } + + //========== Mutating methods =========== + fun build(): CrossBranch { + val res = CrossBranch() + 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) { + else -> errorCode = 4 + } + return true + } + + fun parseFromWithSize(input: CodedInputStream, expectedSize: Int): CrossBranch.BuilderCrossBranch { + while(getSizeNoTag() < expectedSize) { + parseFieldFrom(input) + } + if (getSizeNoTag() > expectedSize) { errorCode = 2 } + return this + } + + fun parseFrom(input: CodedInputStream): CrossBranch.BuilderCrossBranch { + while(parseFieldFrom(input)) {} + return this + } + + //========== Size-related methods =========== + fun getSize(fieldNumber: Int): Int { + var size = 0 + size += WireFormat.getVarint32Size(size) + WireFormat.getTagSize(fieldNumber, WireType.LENGTH_DELIMITED) + return size + } + + fun getSizeNoTag(): Int { + var size = 0 + return size + } + + } + +} + +fun compareGrandfathers(lhs: CrossBranch.Grandfather, rhs: CrossBranch.Grandfather): Boolean { + return (lhs.rf.rls.son_field.son_field == rhs.rf.rls.son_field.son_field) and + (lhs.rf.rrs.son_field.son_field == rhs.rf.rrs.son_field.son_field) +} + +fun buildGrandfather(val1: Int, val2: Int): CrossBranch.Grandfather { + return CrossBranch.Grandfather.BuilderGrandfather( + CrossBranch.Grandfather.RightFather.BuilderRightFather( + CrossBranch.Grandfather.RightFather.RightLeftSon.BuilderRightLeftSon( + CrossBranch.Grandfather.LeftFather.LeftLeftSon.BuilderLeftLeftSon( + val1 + ).build() + ).build() + , + CrossBranch.Grandfather.RightFather.RightRightSon.BuilderRightRightSon( + CrossBranch.Grandfather.LeftFather.LeftRightSon.BuilderLeftRightSon( + val2 + ).build() + ).build() + ).build() + ).build() +} + +fun checkGFSerializationIdentity(msg: CrossBranch.Grandfather): Int { + val outs = CodedOutputStream(ByteArray(msg.getSizeNoTag())) + msg.writeTo(outs) + + val ins = CodedInputStream(outs.buffer) + val readMsg = buildGrandfather(0, 0) + readMsg.mergeFrom(ins) + + if (readMsg.errorCode != 0) { + return 1 + } + if (compareGrandfathers(msg, readMsg)) { + return 0 + } else { + return 1 + } +} + +fun testTrivialValues(): Int { + val msg = buildGrandfather(3213213, -217864283) + return checkGFSerializationIdentity(msg) +} + +fun testMaxValues(): Int { + val msg = buildGrandfather(2147483647, 2147483647) + return checkGFSerializationIdentity(msg) +} + +fun testMinValues(): Int { + val msg = buildGrandfather(-2147483647, -2147483647) + return checkGFSerializationIdentity(msg) +} \ No newline at end of file diff --git a/translator/src/test/kotlin/tests/kotlin/proto_location_test.kt b/translator/src/test/kotlin/tests/kotlin/proto_location_test.kt new file mode 100644 index 00000000000..d15fbba9d83 --- /dev/null +++ b/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) +} \ No newline at end of file diff --git a/translator/src/test/kotlin/tests/kotlin/proto_multiple_messages.kt b/translator/src/test/kotlin/tests/kotlin/proto_multiple_messages.kt new file mode 100644 index 00000000000..d29b594db5f --- /dev/null +++ b/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) +} + diff --git a/translator/src/test/kotlin/tests/kotlin/proto_repeated_varint.kt b/translator/src/test/kotlin/tests/kotlin/proto_repeated_varint.kt new file mode 100644 index 00000000000..6c907abc3b9 --- /dev/null +++ b/translator/src/test/kotlin/tests/kotlin/proto_repeated_varint.kt @@ -0,0 +1,1293 @@ +class MessageRepeatedVarints private constructor (var int: IntArray, var long: LongArray, var sint: IntArray, var slong: LongArray, var bl: BooleanArray, var uint: IntArray, var ulong: LongArray) { + //========== Properties =========== + //repeated int32 int = 1 + + //repeated int64 long = 2 + + //repeated sint32 sint = 3 + + //repeated sint64 slong = 4 + + //repeated bool bl = 5 + + //repeated uint32 uint = 7 + + //repeated uint64 ulong = 8 + + var errorCode: Int = 0 + + //========== Serialization methods =========== + fun writeTo (output: CodedOutputStream) { + //repeated int32 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.getInt32SizeNoTag(int[i]) + i += 1 + } + arrayByteSize += arraySize + } while(false) + } + output.writeInt32NoTag(arrayByteSize) + + do { + var i = 0 + while (i < int.size) { + output.writeInt32NoTag (int[i]) + i += 1 + } + } while(false) + } + + //repeated int64 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.getInt64SizeNoTag(long[i]) + i += 1 + } + arrayByteSize += arraySize + } while(false) + } + output.writeInt32NoTag(arrayByteSize) + + do { + var i = 0 + while (i < long.size) { + output.writeInt64NoTag (long[i]) + i += 1 + } + } while(false) + } + + //repeated sint32 sint = 3 + if (sint.size > 0) { + output.writeTag(3, WireType.LENGTH_DELIMITED) + var arrayByteSize = 0 + + if (sint.size != 0) { + do { + var arraySize = 0 + var i = 0 + while (i < sint.size) { + arraySize += WireFormat.getSInt32SizeNoTag(sint[i]) + i += 1 + } + arrayByteSize += arraySize + } while(false) + } + output.writeInt32NoTag(arrayByteSize) + + do { + var i = 0 + while (i < sint.size) { + output.writeSInt32NoTag (sint[i]) + i += 1 + } + } while(false) + } + + //repeated sint64 slong = 4 + if (slong.size > 0) { + output.writeTag(4, WireType.LENGTH_DELIMITED) + var arrayByteSize = 0 + + if (slong.size != 0) { + do { + var arraySize = 0 + var i = 0 + while (i < slong.size) { + arraySize += WireFormat.getSInt64SizeNoTag(slong[i]) + i += 1 + } + arrayByteSize += arraySize + } while(false) + } + output.writeInt32NoTag(arrayByteSize) + + do { + var i = 0 + while (i < slong.size) { + output.writeSInt64NoTag (slong[i]) + i += 1 + } + } while(false) + } + + //repeated bool bl = 5 + if (bl.size > 0) { + output.writeTag(5, WireType.LENGTH_DELIMITED) + var arrayByteSize = 0 + + if (bl.size != 0) { + do { + var arraySize = 0 + var i = 0 + while (i < bl.size) { + arraySize += WireFormat.getBoolSizeNoTag(bl[i]) + i += 1 + } + arrayByteSize += arraySize + } while(false) + } + output.writeInt32NoTag(arrayByteSize) + + do { + var i = 0 + while (i < bl.size) { + output.writeBoolNoTag (bl[i]) + i += 1 + } + } while(false) + } + + //repeated uint32 uint = 7 + if (uint.size > 0) { + output.writeTag(7, WireType.LENGTH_DELIMITED) + var arrayByteSize = 0 + + if (uint.size != 0) { + do { + var arraySize = 0 + var i = 0 + while (i < uint.size) { + arraySize += WireFormat.getUInt32SizeNoTag(uint[i]) + i += 1 + } + arrayByteSize += arraySize + } while(false) + } + output.writeInt32NoTag(arrayByteSize) + + do { + var i = 0 + while (i < uint.size) { + output.writeUInt32NoTag (uint[i]) + i += 1 + } + } while(false) + } + + //repeated uint64 ulong = 8 + if (ulong.size > 0) { + output.writeTag(8, WireType.LENGTH_DELIMITED) + var arrayByteSize = 0 + + if (ulong.size != 0) { + do { + var arraySize = 0 + var i = 0 + while (i < ulong.size) { + arraySize += WireFormat.getUInt64SizeNoTag(ulong[i]) + i += 1 + } + arrayByteSize += arraySize + } while(false) + } + output.writeInt32NoTag(arrayByteSize) + + do { + var i = 0 + while (i < ulong.size) { + output.writeUInt64NoTag (ulong[i]) + i += 1 + } + } while(false) + } + + } + + fun mergeWith (other: MessageRepeatedVarints) { + int = int.plus((other.int)) + long = long.plus((other.long)) + sint = sint.plus((other.sint)) + slong = slong.plus((other.slong)) + bl = bl.plus((other.bl)) + uint = uint.plus((other.uint)) + ulong = ulong.plus((other.ulong)) + this.errorCode = other.errorCode + } + + fun mergeFromWithSize (input: CodedInputStream, expectedSize: Int) { + val builder = MessageRepeatedVarints.BuilderMessageRepeatedVarints(IntArray(0), LongArray(0), IntArray(0), LongArray(0), BooleanArray(0), IntArray(0), LongArray(0)) + mergeWith(builder.parseFromWithSize(input, expectedSize).build()) + } + + fun mergeFrom (input: CodedInputStream) { + val builder = MessageRepeatedVarints.BuilderMessageRepeatedVarints(IntArray(0), LongArray(0), IntArray(0), LongArray(0), BooleanArray(0), 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.getInt32SizeNoTag(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.getInt64SizeNoTag(long[i]) + i += 1 + } + size += arraySize + size += WireFormat.getInt32SizeNoTag(arraySize) + } while(false) + } + if (sint.size != 0) { + do { + var arraySize = 0 + size += WireFormat.getTagSize(3, WireType.LENGTH_DELIMITED) + var i = 0 + while (i < sint.size) { + arraySize += WireFormat.getSInt32SizeNoTag(sint[i]) + i += 1 + } + size += arraySize + size += WireFormat.getInt32SizeNoTag(arraySize) + } while(false) + } + if (slong.size != 0) { + do { + var arraySize = 0 + size += WireFormat.getTagSize(4, WireType.LENGTH_DELIMITED) + var i = 0 + while (i < slong.size) { + arraySize += WireFormat.getSInt64SizeNoTag(slong[i]) + i += 1 + } + size += arraySize + size += WireFormat.getInt32SizeNoTag(arraySize) + } while(false) + } + if (bl.size != 0) { + do { + var arraySize = 0 + size += WireFormat.getTagSize(5, WireType.LENGTH_DELIMITED) + var i = 0 + while (i < bl.size) { + arraySize += WireFormat.getBoolSizeNoTag(bl[i]) + i += 1 + } + size += arraySize + size += WireFormat.getInt32SizeNoTag(arraySize) + } while(false) + } + if (uint.size != 0) { + do { + var arraySize = 0 + size += WireFormat.getTagSize(7, WireType.LENGTH_DELIMITED) + var i = 0 + while (i < uint.size) { + arraySize += WireFormat.getUInt32SizeNoTag(uint[i]) + i += 1 + } + size += arraySize + size += WireFormat.getInt32SizeNoTag(arraySize) + } while(false) + } + if (ulong.size != 0) { + do { + var arraySize = 0 + size += WireFormat.getTagSize(8, WireType.LENGTH_DELIMITED) + var i = 0 + while (i < ulong.size) { + arraySize += WireFormat.getUInt64SizeNoTag(ulong[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.getInt32SizeNoTag(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.getInt64SizeNoTag(long[i]) + i += 1 + } + size += arraySize + size += WireFormat.getInt32SizeNoTag(arraySize) + } while(false) + } + if (sint.size != 0) { + do { + var arraySize = 0 + size += WireFormat.getTagSize(3, WireType.LENGTH_DELIMITED) + var i = 0 + while (i < sint.size) { + arraySize += WireFormat.getSInt32SizeNoTag(sint[i]) + i += 1 + } + size += arraySize + size += WireFormat.getInt32SizeNoTag(arraySize) + } while(false) + } + if (slong.size != 0) { + do { + var arraySize = 0 + size += WireFormat.getTagSize(4, WireType.LENGTH_DELIMITED) + var i = 0 + while (i < slong.size) { + arraySize += WireFormat.getSInt64SizeNoTag(slong[i]) + i += 1 + } + size += arraySize + size += WireFormat.getInt32SizeNoTag(arraySize) + } while(false) + } + if (bl.size != 0) { + do { + var arraySize = 0 + size += WireFormat.getTagSize(5, WireType.LENGTH_DELIMITED) + var i = 0 + while (i < bl.size) { + arraySize += WireFormat.getBoolSizeNoTag(bl[i]) + i += 1 + } + size += arraySize + size += WireFormat.getInt32SizeNoTag(arraySize) + } while(false) + } + if (uint.size != 0) { + do { + var arraySize = 0 + size += WireFormat.getTagSize(7, WireType.LENGTH_DELIMITED) + var i = 0 + while (i < uint.size) { + arraySize += WireFormat.getUInt32SizeNoTag(uint[i]) + i += 1 + } + size += arraySize + size += WireFormat.getInt32SizeNoTag(arraySize) + } while(false) + } + if (ulong.size != 0) { + do { + var arraySize = 0 + size += WireFormat.getTagSize(8, WireType.LENGTH_DELIMITED) + var i = 0 + while (i < ulong.size) { + arraySize += WireFormat.getUInt64SizeNoTag(ulong[i]) + i += 1 + } + size += arraySize + size += WireFormat.getInt32SizeNoTag(arraySize) + } while(false) + } + return size + } + + //========== Builder =========== + class BuilderMessageRepeatedVarints constructor (var int: IntArray, var long: LongArray, var sint: IntArray, var slong: LongArray, var bl: BooleanArray, var uint: IntArray, var ulong: LongArray) { + //========== Properties =========== + //repeated int32 int = 1 + fun setInt(value: IntArray): MessageRepeatedVarints.BuilderMessageRepeatedVarints { + int = value + return this + } + fun setintByIndex(index: Int, value: Int): MessageRepeatedVarints.BuilderMessageRepeatedVarints { + int[index] = value + return this + } + + //repeated int64 long = 2 + fun setLong(value: LongArray): MessageRepeatedVarints.BuilderMessageRepeatedVarints { + long = value + return this + } + fun setlongByIndex(index: Int, value: Long): MessageRepeatedVarints.BuilderMessageRepeatedVarints { + long[index] = value + return this + } + + //repeated sint32 sint = 3 + fun setSint(value: IntArray): MessageRepeatedVarints.BuilderMessageRepeatedVarints { + sint = value + return this + } + fun setsintByIndex(index: Int, value: Int): MessageRepeatedVarints.BuilderMessageRepeatedVarints { + sint[index] = value + return this + } + + //repeated sint64 slong = 4 + fun setSlong(value: LongArray): MessageRepeatedVarints.BuilderMessageRepeatedVarints { + slong = value + return this + } + fun setslongByIndex(index: Int, value: Long): MessageRepeatedVarints.BuilderMessageRepeatedVarints { + slong[index] = value + return this + } + + //repeated bool bl = 5 + fun setBl(value: BooleanArray): MessageRepeatedVarints.BuilderMessageRepeatedVarints { + bl = value + return this + } + fun setblByIndex(index: Int, value: Boolean): MessageRepeatedVarints.BuilderMessageRepeatedVarints { + bl[index] = value + return this + } + + //repeated uint32 uint = 7 + fun setUint(value: IntArray): MessageRepeatedVarints.BuilderMessageRepeatedVarints { + uint = value + return this + } + fun setuintByIndex(index: Int, value: Int): MessageRepeatedVarints.BuilderMessageRepeatedVarints { + uint[index] = value + return this + } + + //repeated uint64 ulong = 8 + fun setUlong(value: LongArray): MessageRepeatedVarints.BuilderMessageRepeatedVarints { + ulong = value + return this + } + fun setulongByIndex(index: Int, value: Long): MessageRepeatedVarints.BuilderMessageRepeatedVarints { + ulong[index] = value + return this + } + + var errorCode: Int = 0 + + //========== Serialization methods =========== + fun writeTo (output: CodedOutputStream) { + //repeated int32 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.getInt32SizeNoTag(int[i]) + i += 1 + } + arrayByteSize += arraySize + } while(false) + } + output.writeInt32NoTag(arrayByteSize) + + do { + var i = 0 + while (i < int.size) { + output.writeInt32NoTag (int[i]) + i += 1 + } + } while(false) + } + + //repeated int64 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.getInt64SizeNoTag(long[i]) + i += 1 + } + arrayByteSize += arraySize + } while(false) + } + output.writeInt32NoTag(arrayByteSize) + + do { + var i = 0 + while (i < long.size) { + output.writeInt64NoTag (long[i]) + i += 1 + } + } while(false) + } + + //repeated sint32 sint = 3 + if (sint.size > 0) { + output.writeTag(3, WireType.LENGTH_DELIMITED) + var arrayByteSize = 0 + + if (sint.size != 0) { + do { + var arraySize = 0 + var i = 0 + while (i < sint.size) { + arraySize += WireFormat.getSInt32SizeNoTag(sint[i]) + i += 1 + } + arrayByteSize += arraySize + } while(false) + } + output.writeInt32NoTag(arrayByteSize) + + do { + var i = 0 + while (i < sint.size) { + output.writeSInt32NoTag (sint[i]) + i += 1 + } + } while(false) + } + + //repeated sint64 slong = 4 + if (slong.size > 0) { + output.writeTag(4, WireType.LENGTH_DELIMITED) + var arrayByteSize = 0 + + if (slong.size != 0) { + do { + var arraySize = 0 + var i = 0 + while (i < slong.size) { + arraySize += WireFormat.getSInt64SizeNoTag(slong[i]) + i += 1 + } + arrayByteSize += arraySize + } while(false) + } + output.writeInt32NoTag(arrayByteSize) + + do { + var i = 0 + while (i < slong.size) { + output.writeSInt64NoTag (slong[i]) + i += 1 + } + } while(false) + } + + //repeated bool bl = 5 + if (bl.size > 0) { + output.writeTag(5, WireType.LENGTH_DELIMITED) + var arrayByteSize = 0 + + if (bl.size != 0) { + do { + var arraySize = 0 + var i = 0 + while (i < bl.size) { + arraySize += WireFormat.getBoolSizeNoTag(bl[i]) + i += 1 + } + arrayByteSize += arraySize + } while(false) + } + output.writeInt32NoTag(arrayByteSize) + + do { + var i = 0 + while (i < bl.size) { + output.writeBoolNoTag (bl[i]) + i += 1 + } + } while(false) + } + + //repeated uint32 uint = 7 + if (uint.size > 0) { + output.writeTag(7, WireType.LENGTH_DELIMITED) + var arrayByteSize = 0 + + if (uint.size != 0) { + do { + var arraySize = 0 + var i = 0 + while (i < uint.size) { + arraySize += WireFormat.getUInt32SizeNoTag(uint[i]) + i += 1 + } + arrayByteSize += arraySize + } while(false) + } + output.writeInt32NoTag(arrayByteSize) + + do { + var i = 0 + while (i < uint.size) { + output.writeUInt32NoTag (uint[i]) + i += 1 + } + } while(false) + } + + //repeated uint64 ulong = 8 + if (ulong.size > 0) { + output.writeTag(8, WireType.LENGTH_DELIMITED) + var arrayByteSize = 0 + + if (ulong.size != 0) { + do { + var arraySize = 0 + var i = 0 + while (i < ulong.size) { + arraySize += WireFormat.getUInt64SizeNoTag(ulong[i]) + i += 1 + } + arrayByteSize += arraySize + } while(false) + } + output.writeInt32NoTag(arrayByteSize) + + do { + var i = 0 + while (i < ulong.size) { + output.writeUInt64NoTag (ulong[i]) + i += 1 + } + } while(false) + } + + } + + //========== Mutating methods =========== + fun build(): MessageRepeatedVarints { + val res = MessageRepeatedVarints(int, long, sint, slong, bl, 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.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.readInt32NoTag() + newArray = newArray.plus(tmp) + readSize += WireFormat.getInt32SizeNoTag(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.readInt64NoTag() + newArray = newArray.plus(tmp) + readSize += WireFormat.getInt64SizeNoTag(tmp[0]) + } + long = newArray + } while (false) + } + 3 -> { + 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]) + } + sint = newArray + } while (false) + } + 4 -> { + 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 = newArray + } while (false) + } + 5 -> { + if (wireType.id != WireType.LENGTH_DELIMITED.id) { + errorCode = 1 + return false + } + val expectedByteSize = input.readInt32NoTag() + var newArray = BooleanArray(0) + var readSize = 0 + do { + var i = 0 + while(readSize < expectedByteSize) { + var tmp = BooleanArray(1) + tmp[0] = input.readBoolNoTag() + newArray = newArray.plus(tmp) + readSize += WireFormat.getBoolSizeNoTag(tmp[0]) + } + bl = newArray + } while (false) + } + 7 -> { + 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.readUInt32NoTag() + newArray = newArray.plus(tmp) + readSize += WireFormat.getUInt32SizeNoTag(tmp[0]) + } + uint = newArray + } while (false) + } + 8 -> { + 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.readUInt64NoTag() + newArray = newArray.plus(tmp) + readSize += WireFormat.getUInt64SizeNoTag(tmp[0]) + } + ulong = newArray + } while (false) + } + else -> errorCode = 4 + } + return true + } + + fun parseFromWithSize(input: CodedInputStream, expectedSize: Int): MessageRepeatedVarints.BuilderMessageRepeatedVarints { + while(getSizeNoTag() < expectedSize) { + parseFieldFrom(input) + } + if (getSizeNoTag() > expectedSize) { errorCode = 2 } + return this + } + + fun parseFrom(input: CodedInputStream): MessageRepeatedVarints.BuilderMessageRepeatedVarints { + 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.getInt32SizeNoTag(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.getInt64SizeNoTag(long[i]) + i += 1 + } + size += arraySize + size += WireFormat.getInt32SizeNoTag(arraySize) + } while(false) + } + if (sint.size != 0) { + do { + var arraySize = 0 + size += WireFormat.getTagSize(3, WireType.LENGTH_DELIMITED) + var i = 0 + while (i < sint.size) { + arraySize += WireFormat.getSInt32SizeNoTag(sint[i]) + i += 1 + } + size += arraySize + size += WireFormat.getInt32SizeNoTag(arraySize) + } while(false) + } + if (slong.size != 0) { + do { + var arraySize = 0 + size += WireFormat.getTagSize(4, WireType.LENGTH_DELIMITED) + var i = 0 + while (i < slong.size) { + arraySize += WireFormat.getSInt64SizeNoTag(slong[i]) + i += 1 + } + size += arraySize + size += WireFormat.getInt32SizeNoTag(arraySize) + } while(false) + } + if (bl.size != 0) { + do { + var arraySize = 0 + size += WireFormat.getTagSize(5, WireType.LENGTH_DELIMITED) + var i = 0 + while (i < bl.size) { + arraySize += WireFormat.getBoolSizeNoTag(bl[i]) + i += 1 + } + size += arraySize + size += WireFormat.getInt32SizeNoTag(arraySize) + } while(false) + } + if (uint.size != 0) { + do { + var arraySize = 0 + size += WireFormat.getTagSize(7, WireType.LENGTH_DELIMITED) + var i = 0 + while (i < uint.size) { + arraySize += WireFormat.getUInt32SizeNoTag(uint[i]) + i += 1 + } + size += arraySize + size += WireFormat.getInt32SizeNoTag(arraySize) + } while(false) + } + if (ulong.size != 0) { + do { + var arraySize = 0 + size += WireFormat.getTagSize(8, WireType.LENGTH_DELIMITED) + var i = 0 + while (i < ulong.size) { + arraySize += WireFormat.getUInt64SizeNoTag(ulong[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.getInt32SizeNoTag(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.getInt64SizeNoTag(long[i]) + i += 1 + } + size += arraySize + size += WireFormat.getInt32SizeNoTag(arraySize) + } while(false) + } + if (sint.size != 0) { + do { + var arraySize = 0 + size += WireFormat.getTagSize(3, WireType.LENGTH_DELIMITED) + var i = 0 + while (i < sint.size) { + arraySize += WireFormat.getSInt32SizeNoTag(sint[i]) + i += 1 + } + size += arraySize + size += WireFormat.getInt32SizeNoTag(arraySize) + } while(false) + } + if (slong.size != 0) { + do { + var arraySize = 0 + size += WireFormat.getTagSize(4, WireType.LENGTH_DELIMITED) + var i = 0 + while (i < slong.size) { + arraySize += WireFormat.getSInt64SizeNoTag(slong[i]) + i += 1 + } + size += arraySize + size += WireFormat.getInt32SizeNoTag(arraySize) + } while(false) + } + if (bl.size != 0) { + do { + var arraySize = 0 + size += WireFormat.getTagSize(5, WireType.LENGTH_DELIMITED) + var i = 0 + while (i < bl.size) { + arraySize += WireFormat.getBoolSizeNoTag(bl[i]) + i += 1 + } + size += arraySize + size += WireFormat.getInt32SizeNoTag(arraySize) + } while(false) + } + if (uint.size != 0) { + do { + var arraySize = 0 + size += WireFormat.getTagSize(7, WireType.LENGTH_DELIMITED) + var i = 0 + while (i < uint.size) { + arraySize += WireFormat.getUInt32SizeNoTag(uint[i]) + i += 1 + } + size += arraySize + size += WireFormat.getInt32SizeNoTag(arraySize) + } while(false) + } + if (ulong.size != 0) { + do { + var arraySize = 0 + size += WireFormat.getTagSize(8, WireType.LENGTH_DELIMITED) + var i = 0 + while (i < ulong.size) { + arraySize += WireFormat.getUInt64SizeNoTag(ulong[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 compareRepeatedVarints(kt1: MessageRepeatedVarints, kt2: MessageRepeatedVarints): Boolean { + return compareIntArrays(kt1.int, kt2.int) and + compareLongArrays(kt1.long, kt2.long) and + compareIntArrays(kt1.sint, kt2.sint) and + compareLongArrays(kt1.slong, kt2.slong) and + compareBooleanArrays(kt1.bl, kt2.bl) and + compareIntArrays(kt1.uint, kt2.uint) and + compareLongArrays(kt1.ulong, kt2.ulong) +} + +fun checkRepSerializationIdentity(msg: MessageRepeatedVarints): Int { + val outs = CodedOutputStream(ByteArray(msg.getSizeNoTag())) + msg.writeTo(outs) + + val ins = CodedInputStream(outs.buffer) + val readMsg = MessageRepeatedVarints.BuilderMessageRepeatedVarints( + IntArray(0), + LongArray(0), + IntArray(0), + LongArray(0), + BooleanArray(0), + IntArray(0), + LongArray(0) + ).parseFrom(ins).build() + + if (readMsg.errorCode != 0) { + return 1 + } + if (compareRepeatedVarints(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 nextBool(): Boolean { + val int = nextInt(-2147483647, 2147483647) + if (int and 1 == 1) { + return true + } + return false +} + +fun generateBooleanArray(): BooleanArray { + val size = nextInt(0, 10000) + val arr = BooleanArray(size) + var i = 0 + while (i < size) { + arr[i] = nextBool() + i += 1 + } + return arr +} + +fun generateRandomMessage(): MessageRepeatedVarints { + return MessageRepeatedVarints.BuilderMessageRepeatedVarints( + generateIntArray(), + generateLongArray(), + generateIntArray(), + generateLongArray(), + generateBooleanArray(), + generateIntArray(), + generateLongArray() + ).build() +} + +fun testRepVarints(): Int { + var i = 0 + val testRuns = 100 + while (i < 100) { + val msg = generateRandomMessage() + if (checkRepSerializationIdentity(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 boolArr = BooleanArray(100) + i = 1 + while (i < 100) { + boolArr[i] = false + i += 1 + } + + val msg = MessageRepeatedVarints.BuilderMessageRepeatedVarints( + intArr, longArr, intArr, longArr, boolArr, intArr, longArr + ).build() + return checkRepSerializationIdentity(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 boolArr = BooleanArray(100) + i = 1 + while (i < 100) { + boolArr[i] = true + i += 1 + } + + val msg = MessageRepeatedVarints.BuilderMessageRepeatedVarints( + intArr, longArr, intArr, longArr, boolArr, intArr, longArr + ).build() + return checkRepSerializationIdentity(msg) +} + +fun testArraysOfDefaultValues(): Int { + val intArr = IntArray(100) + + val longArr = LongArray(100) + + val boolArr = BooleanArray(100) + + val msg = MessageRepeatedVarints.BuilderMessageRepeatedVarints( + intArr, longArr, intArr, longArr, boolArr, intArr, longArr + ).build() + + return checkRepSerializationIdentity(msg) +} diff --git a/translator/src/test/kotlin/tests/kotlin/proto_repeated_zigzag.kt b/translator/src/test/kotlin/tests/kotlin/proto_repeated_zigzag.kt new file mode 100644 index 00000000000..dcea6007d0a --- /dev/null +++ b/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) +} diff --git a/translator/src/test/kotlin/tests/kotlin/proto_tagorder_test.kt b/translator/src/test/kotlin/tests/kotlin/proto_tagorder_test.kt new file mode 100644 index 00000000000..b253399a9cc --- /dev/null +++ b/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) +} \ No newline at end of file diff --git a/translator/src/test/kotlin/tests/kotlin/proto_varint.kt b/translator/src/test/kotlin/tests/kotlin/proto_varint.kt new file mode 100644 index 00000000000..dc1043ed696 --- /dev/null +++ b/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) +} \ No newline at end of file diff --git a/translator/src/test/kotlin/tests/kotlin/proto_zigzag.kt b/translator/src/test/kotlin/tests/kotlin/proto_zigzag.kt new file mode 100644 index 00000000000..3fad3b92846 --- /dev/null +++ b/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) +} \ No newline at end of file