diff options
Diffstat (limited to 'java')
17 files changed, 2008 insertions, 754 deletions
diff --git a/java/src/main/java/com/google/protobuf/AbstractMessage.java b/java/src/main/java/com/google/protobuf/AbstractMessage.java index 2f61859d..24c32a47 100644 --- a/java/src/main/java/com/google/protobuf/AbstractMessage.java +++ b/java/src/main/java/com/google/protobuf/AbstractMessage.java @@ -86,8 +86,25 @@ public abstract class AbstractMessage implements Message { for (Map.Entry<FieldDescriptor, Object> entry : getAllFields().entrySet()) { FieldDescriptor field = entry.getKey(); if (field.isRepeated()) { - for (Object element : (List) entry.getValue()) { - output.writeField(field.getType(), field.getNumber(), element); + List valueList = (List) entry.getValue(); + if (field.getOptions().getPacked()) { + + output.writeTag(field.getNumber(), + WireFormat.WIRETYPE_LENGTH_DELIMITED); + int dataSize = 0; + for (Object element : valueList) { + dataSize += CodedOutputStream.computeFieldSizeNoTag( + field.getType(), element); + } + output.writeRawVarint32(dataSize); + + for (Object element : valueList) { + output.writeFieldNoTag(field.getType(), element); + } + } else { + for (Object element : valueList) { + output.writeField(field.getType(), field.getNumber(), element); + } } } else { output.writeField(field.getType(), field.getNumber(), entry.getValue()); @@ -145,9 +162,21 @@ public abstract class AbstractMessage implements Message { for (Map.Entry<FieldDescriptor, Object> entry : getAllFields().entrySet()) { FieldDescriptor field = entry.getKey(); if (field.isRepeated()) { - for (Object element : (List) entry.getValue()) { - size += CodedOutputStream.computeFieldSize( - field.getType(), field.getNumber(), element); + List valueList = (List) entry.getValue(); + if (field.getOptions().getPacked()) { + int dataSize = 0; + for (Object element : valueList) { + dataSize += CodedOutputStream.computeFieldSizeNoTag( + field.getType(), element); + } + size += dataSize; + size += CodedOutputStream.computeTagSize(field.getNumber()); + size += CodedOutputStream.computeRawVarint32Size(dataSize); + } else { + for (Object element : valueList) { + size += CodedOutputStream.computeFieldSize( + field.getType(), field.getNumber(), element); + } } } else { size += CodedOutputStream.computeFieldSize( @@ -165,7 +194,7 @@ public abstract class AbstractMessage implements Message { memoizedSize = size; return size; } - + @Override public boolean equals(Object other) { if (other == this) { @@ -180,7 +209,7 @@ public abstract class AbstractMessage implements Message { } return getAllFields().equals(otherMessage.getAllFields()); } - + @Override public int hashCode() { int hash = 41; diff --git a/java/src/main/java/com/google/protobuf/CodedInputStream.java b/java/src/main/java/com/google/protobuf/CodedInputStream.java index caef068b..8f277a9f 100644 --- a/java/src/main/java/com/google/protobuf/CodedInputStream.java +++ b/java/src/main/java/com/google/protobuf/CodedInputStream.java @@ -193,7 +193,7 @@ public final class CodedInputStream { /** Read a {@code string} field value from the stream. */ public String readString() throws IOException { int size = readRawVarint32(); - if (size < bufferSize - bufferPos && size > 0) { + if (size <= (bufferSize - bufferPos) && size > 0) { // Fast path: We already have the bytes in a contiguous buffer, so // just copy directly from it. String result = new String(buffer, bufferPos, size, "UTF-8"); @@ -584,6 +584,19 @@ public final class CodedInputStream { } /** + * Returns the number of bytes to be read before the current limit. + * If no limit is set, returns -1. + */ + public int getBytesUntilLimit() { + if (currentLimit == Integer.MAX_VALUE) { + return -1; + } + + int currentAbsolutePosition = totalBytesRetired + bufferPos; + return currentLimit - currentAbsolutePosition; + } + + /** * Called with {@code this.buffer} is empty to read more bytes from the * input. If {@code mustSucceed} is true, refillBuffer() gurantees that * either there will be at least one byte in the buffer when it returns diff --git a/java/src/main/java/com/google/protobuf/CodedOutputStream.java b/java/src/main/java/com/google/protobuf/CodedOutputStream.java index d232841a..e8be8611 100644 --- a/java/src/main/java/com/google/protobuf/CodedOutputStream.java +++ b/java/src/main/java/com/google/protobuf/CodedOutputStream.java @@ -118,71 +118,61 @@ public final class CodedOutputStream { /** Write a {@code double} field, including tag, to the stream. */ public void writeDouble(int fieldNumber, double value) throws IOException { writeTag(fieldNumber, WireFormat.WIRETYPE_FIXED64); - writeRawLittleEndian64(Double.doubleToRawLongBits(value)); + writeDoubleNoTag(value); } /** Write a {@code float} field, including tag, to the stream. */ public void writeFloat(int fieldNumber, float value) throws IOException { writeTag(fieldNumber, WireFormat.WIRETYPE_FIXED32); - writeRawLittleEndian32(Float.floatToRawIntBits(value)); + writeFloatNoTag(value); } /** Write a {@code uint64} field, including tag, to the stream. */ public void writeUInt64(int fieldNumber, long value) throws IOException { writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT); - writeRawVarint64(value); + writeUInt64NoTag(value); } /** Write an {@code int64} field, including tag, to the stream. */ public void writeInt64(int fieldNumber, long value) throws IOException { writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT); - writeRawVarint64(value); + writeInt64NoTag(value); } /** Write an {@code int32} field, including tag, to the stream. */ public void writeInt32(int fieldNumber, int value) throws IOException { writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT); - if (value >= 0) { - writeRawVarint32(value); - } else { - // Must sign-extend. - writeRawVarint64(value); - } + writeInt32NoTag(value); } /** Write a {@code fixed64} field, including tag, to the stream. */ public void writeFixed64(int fieldNumber, long value) throws IOException { writeTag(fieldNumber, WireFormat.WIRETYPE_FIXED64); - writeRawLittleEndian64(value); + writeFixed64NoTag(value); } /** Write a {@code fixed32} field, including tag, to the stream. */ public void writeFixed32(int fieldNumber, int value) throws IOException { writeTag(fieldNumber, WireFormat.WIRETYPE_FIXED32); - writeRawLittleEndian32(value); + writeFixed32NoTag(value); } /** Write a {@code bool} field, including tag, to the stream. */ public void writeBool(int fieldNumber, boolean value) throws IOException { writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT); - writeRawByte(value ? 1 : 0); + writeBoolNoTag(value); } /** Write a {@code string} field, including tag, to the stream. */ public void writeString(int fieldNumber, String value) throws IOException { writeTag(fieldNumber, WireFormat.WIRETYPE_LENGTH_DELIMITED); - // Unfortunately there does not appear to be any way to tell Java to encode - // UTF-8 directly into our buffer, so we have to let it create its own byte - // array and then copy. - byte[] bytes = value.getBytes("UTF-8"); - writeRawVarint32(bytes.length); - writeRawBytes(bytes); + writeStringNoTag(value); } /** Write a {@code group} field, including tag, to the stream. */ public void writeGroup(int fieldNumber, Message value) throws IOException { writeTag(fieldNumber, WireFormat.WIRETYPE_START_GROUP); - value.writeTo(this); + writeGroupNoTag(value); writeTag(fieldNumber, WireFormat.WIRETYPE_END_GROUP); } @@ -190,29 +180,26 @@ public final class CodedOutputStream { public void writeUnknownGroup(int fieldNumber, UnknownFieldSet value) throws IOException { writeTag(fieldNumber, WireFormat.WIRETYPE_START_GROUP); - value.writeTo(this); + writeUnknownGroupNoTag(value); writeTag(fieldNumber, WireFormat.WIRETYPE_END_GROUP); } /** Write an embedded message field, including tag, to the stream. */ public void writeMessage(int fieldNumber, Message value) throws IOException { writeTag(fieldNumber, WireFormat.WIRETYPE_LENGTH_DELIMITED); - writeRawVarint32(value.getSerializedSize()); - value.writeTo(this); + writeMessageNoTag(value); } /** Write a {@code bytes} field, including tag, to the stream. */ public void writeBytes(int fieldNumber, ByteString value) throws IOException { writeTag(fieldNumber, WireFormat.WIRETYPE_LENGTH_DELIMITED); - byte[] bytes = value.toByteArray(); - writeRawVarint32(bytes.length); - writeRawBytes(bytes); + writeBytesNoTag(value); } /** Write a {@code uint32} field, including tag, to the stream. */ public void writeUInt32(int fieldNumber, int value) throws IOException { writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT); - writeRawVarint32(value); + writeUInt32NoTag(value); } /** @@ -221,31 +208,31 @@ public final class CodedOutputStream { */ public void writeEnum(int fieldNumber, int value) throws IOException { writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT); - writeRawVarint32(value); + writeEnumNoTag(value); } /** Write an {@code sfixed32} field, including tag, to the stream. */ public void writeSFixed32(int fieldNumber, int value) throws IOException { writeTag(fieldNumber, WireFormat.WIRETYPE_FIXED32); - writeRawLittleEndian32(value); + writeSFixed32NoTag(value); } /** Write an {@code sfixed64} field, including tag, to the stream. */ public void writeSFixed64(int fieldNumber, long value) throws IOException { writeTag(fieldNumber, WireFormat.WIRETYPE_FIXED64); - writeRawLittleEndian64(value); + writeSFixed64NoTag(value); } /** Write an {@code sint32} field, including tag, to the stream. */ public void writeSInt32(int fieldNumber, int value) throws IOException { writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT); - writeRawVarint32(encodeZigZag32(value)); + writeSInt32NoTag(value); } /** Write an {@code sint64} field, including tag, to the stream. */ public void writeSInt64(int fieldNumber, long value) throws IOException { writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT); - writeRawVarint64(encodeZigZag64(value)); + writeSInt64NoTag(value); } /** @@ -283,32 +270,168 @@ public final class CodedOutputStream { * this field. */ public void writeField(Descriptors.FieldDescriptor.Type type, - int number, Object value) throws IOException { + int number, + Object value) throws IOException { + // Special case for groups, which need a start and end tag; other fields + // can just use writeTag() and writeFieldNoTag(). + if (type == Descriptors.FieldDescriptor.Type.GROUP) { + writeGroup(number, (Message) value); + } else { + writeTag(number, WireFormat.getWireFormatForFieldType(type)); + writeFieldNoTag(type, value); + } + } + + /** + * Write a field of arbitrary type, without its tag, to the stream. + * + * @param type The field's type. + * @param value Object representing the field's value. Must be of the exact + * type which would be returned by + * {@link Message#getField(Descriptors.FieldDescriptor)} for + * this field. + */ + public void writeFieldNoTag(Descriptors.FieldDescriptor.Type type, + Object value) throws IOException { switch (type) { - case DOUBLE : writeDouble (number, (Double )value); break; - case FLOAT : writeFloat (number, (Float )value); break; - case INT64 : writeInt64 (number, (Long )value); break; - case UINT64 : writeUInt64 (number, (Long )value); break; - case INT32 : writeInt32 (number, (Integer )value); break; - case FIXED64 : writeFixed64 (number, (Long )value); break; - case FIXED32 : writeFixed32 (number, (Integer )value); break; - case BOOL : writeBool (number, (Boolean )value); break; - case STRING : writeString (number, (String )value); break; - case GROUP : writeGroup (number, (Message )value); break; - case MESSAGE : writeMessage (number, (Message )value); break; - case BYTES : writeBytes (number, (ByteString)value); break; - case UINT32 : writeUInt32 (number, (Integer )value); break; - case SFIXED32: writeSFixed32(number, (Integer )value); break; - case SFIXED64: writeSFixed64(number, (Long )value); break; - case SINT32 : writeSInt32 (number, (Integer )value); break; - case SINT64 : writeSInt64 (number, (Long )value); break; + case DOUBLE : writeDoubleNoTag ((Double ) value); break; + case FLOAT : writeFloatNoTag ((Float ) value); break; + case INT64 : writeInt64NoTag ((Long ) value); break; + case UINT64 : writeUInt64NoTag ((Long ) value); break; + case INT32 : writeInt32NoTag ((Integer ) value); break; + case FIXED64 : writeFixed64NoTag ((Long ) value); break; + case FIXED32 : writeFixed32NoTag ((Integer ) value); break; + case BOOL : writeBoolNoTag ((Boolean ) value); break; + case STRING : writeStringNoTag ((String ) value); break; + case GROUP : writeGroupNoTag ((Message ) value); break; + case MESSAGE : writeMessageNoTag ((Message ) value); break; + case BYTES : writeBytesNoTag ((ByteString) value); break; + case UINT32 : writeUInt32NoTag ((Integer ) value); break; + case SFIXED32: writeSFixed32NoTag((Integer ) value); break; + case SFIXED64: writeSFixed64NoTag((Long ) value); break; + case SINT32 : writeSInt32NoTag ((Integer ) value); break; + case SINT64 : writeSInt64NoTag ((Long ) value); break; case ENUM: - writeEnum(number, ((Descriptors.EnumValueDescriptor)value).getNumber()); + writeEnumNoTag(((Descriptors.EnumValueDescriptor) value).getNumber()); break; } } + // ----------------------------------------------------------------- + + /** Write a {@code double} field to the stream. */ + public void writeDoubleNoTag(double value) throws IOException { + writeRawLittleEndian64(Double.doubleToRawLongBits(value)); + } + + /** Write a {@code float} field to the stream. */ + public void writeFloatNoTag(float value) throws IOException { + writeRawLittleEndian32(Float.floatToRawIntBits(value)); + } + + /** Write a {@code uint64} field to the stream. */ + public void writeUInt64NoTag(long value) throws IOException { + writeRawVarint64(value); + } + + /** Write an {@code int64} field to the stream. */ + public void writeInt64NoTag(long value) throws IOException { + writeRawVarint64(value); + } + + /** Write an {@code int32} field to the stream. */ + public void writeInt32NoTag(int value) throws IOException { + if (value >= 0) { + writeRawVarint32(value); + } else { + // Must sign-extend. + writeRawVarint64(value); + } + } + + /** Write a {@code fixed64} field to the stream. */ + public void writeFixed64NoTag(long value) throws IOException { + writeRawLittleEndian64(value); + } + + /** Write a {@code fixed32} field to the stream. */ + public void writeFixed32NoTag(int value) throws IOException { + writeRawLittleEndian32(value); + } + + /** Write a {@code bool} field to the stream. */ + public void writeBoolNoTag(boolean value) throws IOException { + writeRawByte(value ? 1 : 0); + } + + /** Write a {@code string} field to the stream. */ + public void writeStringNoTag(String value) throws IOException { + // Unfortunately there does not appear to be any way to tell Java to encode + // UTF-8 directly into our buffer, so we have to let it create its own byte + // array and then copy. + byte[] bytes = value.getBytes("UTF-8"); + writeRawVarint32(bytes.length); + writeRawBytes(bytes); + } + + /** Write a {@code group} field to the stream. */ + public void writeGroupNoTag(Message value) throws IOException { + value.writeTo(this); + } + + /** Write a group represented by an {@link UnknownFieldSet}. */ + public void writeUnknownGroupNoTag(UnknownFieldSet value) + throws IOException { + value.writeTo(this); + } + + /** Write an embedded message field to the stream. */ + public void writeMessageNoTag(Message value) throws IOException { + writeRawVarint32(value.getSerializedSize()); + value.writeTo(this); + } + + /** Write a {@code bytes} field to the stream. */ + public void writeBytesNoTag(ByteString value) throws IOException { + byte[] bytes = value.toByteArray(); + writeRawVarint32(bytes.length); + writeRawBytes(bytes); + } + + /** Write a {@code uint32} field to the stream. */ + public void writeUInt32NoTag(int value) throws IOException { + writeRawVarint32(value); + } + + /** + * Write an enum field to the stream. Caller is responsible + * for converting the enum value to its numeric value. + */ + public void writeEnumNoTag(int value) throws IOException { + writeRawVarint32(value); + } + + /** Write an {@code sfixed32} field to the stream. */ + public void writeSFixed32NoTag(int value) throws IOException { + writeRawLittleEndian32(value); + } + + /** Write an {@code sfixed64} field to the stream. */ + public void writeSFixed64NoTag(long value) throws IOException { + writeRawLittleEndian64(value); + } + + /** Write an {@code sint32} field to the stream. */ + public void writeSInt32NoTag(int value) throws IOException { + writeRawVarint32(encodeZigZag32(value)); + } + + /** Write an {@code sint64} field to the stream. */ + public void writeSInt64NoTag(long value) throws IOException { + writeRawVarint64(encodeZigZag64(value)); + } + // ================================================================= /** @@ -316,7 +439,7 @@ public final class CodedOutputStream { * {@code double} field, including tag. */ public static int computeDoubleSize(int fieldNumber, double value) { - return computeTagSize(fieldNumber) + LITTLE_ENDIAN_64_SIZE; + return computeTagSize(fieldNumber) + computeDoubleSizeNoTag(value); } /** @@ -324,7 +447,7 @@ public final class CodedOutputStream { * {@code float} field, including tag. */ public static int computeFloatSize(int fieldNumber, float value) { - return computeTagSize(fieldNumber) + LITTLE_ENDIAN_32_SIZE; + return computeTagSize(fieldNumber) + computeFloatSizeNoTag(value); } /** @@ -332,7 +455,7 @@ public final class CodedOutputStream { * {@code uint64} field, including tag. */ public static int computeUInt64Size(int fieldNumber, long value) { - return computeTagSize(fieldNumber) + computeRawVarint64Size(value); + return computeTagSize(fieldNumber) + computeUInt64SizeNoTag(value); } /** @@ -340,7 +463,7 @@ public final class CodedOutputStream { * {@code int64} field, including tag. */ public static int computeInt64Size(int fieldNumber, long value) { - return computeTagSize(fieldNumber) + computeRawVarint64Size(value); + return computeTagSize(fieldNumber) + computeInt64SizeNoTag(value); } /** @@ -348,12 +471,7 @@ public final class CodedOutputStream { * {@code int32} field, including tag. */ public static int computeInt32Size(int fieldNumber, int value) { - if (value >= 0) { - return computeTagSize(fieldNumber) + computeRawVarint32Size(value); - } else { - // Must sign-extend. - return computeTagSize(fieldNumber) + 10; - } + return computeTagSize(fieldNumber) + computeInt32SizeNoTag(value); } /** @@ -361,7 +479,7 @@ public final class CodedOutputStream { * {@code fixed64} field, including tag. */ public static int computeFixed64Size(int fieldNumber, long value) { - return computeTagSize(fieldNumber) + LITTLE_ENDIAN_64_SIZE; + return computeTagSize(fieldNumber) + computeFixed64SizeNoTag(value); } /** @@ -369,7 +487,7 @@ public final class CodedOutputStream { * {@code fixed32} field, including tag. */ public static int computeFixed32Size(int fieldNumber, int value) { - return computeTagSize(fieldNumber) + LITTLE_ENDIAN_32_SIZE; + return computeTagSize(fieldNumber) + computeFixed32SizeNoTag(value); } /** @@ -377,7 +495,7 @@ public final class CodedOutputStream { * {@code bool} field, including tag. */ public static int computeBoolSize(int fieldNumber, boolean value) { - return computeTagSize(fieldNumber) + 1; + return computeTagSize(fieldNumber) + computeBoolSizeNoTag(value); } /** @@ -385,14 +503,7 @@ public final class CodedOutputStream { * {@code string} field, including tag. */ public static int computeStringSize(int fieldNumber, String value) { - try { - byte[] bytes = value.getBytes("UTF-8"); - return computeTagSize(fieldNumber) + - computeRawVarint32Size(bytes.length) + - bytes.length; - } catch (java.io.UnsupportedEncodingException e) { - throw new RuntimeException("UTF-8 not supported.", e); - } + return computeTagSize(fieldNumber) + computeStringSizeNoTag(value); } /** @@ -400,7 +511,7 @@ public final class CodedOutputStream { * {@code group} field, including tag. */ public static int computeGroupSize(int fieldNumber, Message value) { - return computeTagSize(fieldNumber) * 2 + value.getSerializedSize(); + return computeTagSize(fieldNumber) * 2 + computeGroupSizeNoTag(value); } /** @@ -410,7 +521,8 @@ public final class CodedOutputStream { */ public static int computeUnknownGroupSize(int fieldNumber, UnknownFieldSet value) { - return computeTagSize(fieldNumber) * 2 + value.getSerializedSize(); + return computeTagSize(fieldNumber) * 2 + + computeUnknownGroupSizeNoTag(value); } /** @@ -418,8 +530,7 @@ public final class CodedOutputStream { * embedded message field, including tag. */ public static int computeMessageSize(int fieldNumber, Message value) { - int size = value.getSerializedSize(); - return computeTagSize(fieldNumber) + computeRawVarint32Size(size) + size; + return computeTagSize(fieldNumber) + computeMessageSizeNoTag(value); } /** @@ -427,9 +538,7 @@ public final class CodedOutputStream { * {@code bytes} field, including tag. */ public static int computeBytesSize(int fieldNumber, ByteString value) { - return computeTagSize(fieldNumber) + - computeRawVarint32Size(value.size()) + - value.size(); + return computeTagSize(fieldNumber) + computeBytesSizeNoTag(value); } /** @@ -437,7 +546,7 @@ public final class CodedOutputStream { * {@code uint32} field, including tag. */ public static int computeUInt32Size(int fieldNumber, int value) { - return computeTagSize(fieldNumber) + computeRawVarint32Size(value); + return computeTagSize(fieldNumber) + computeUInt32SizeNoTag(value); } /** @@ -446,7 +555,7 @@ public final class CodedOutputStream { * enum value to its numeric value. */ public static int computeEnumSize(int fieldNumber, int value) { - return computeTagSize(fieldNumber) + computeRawVarint32Size(value); + return computeTagSize(fieldNumber) + computeEnumSizeNoTag(value); } /** @@ -454,7 +563,7 @@ public final class CodedOutputStream { * {@code sfixed32} field, including tag. */ public static int computeSFixed32Size(int fieldNumber, int value) { - return computeTagSize(fieldNumber) + LITTLE_ENDIAN_32_SIZE; + return computeTagSize(fieldNumber) + computeSFixed32SizeNoTag(value); } /** @@ -462,7 +571,7 @@ public final class CodedOutputStream { * {@code sfixed64} field, including tag. */ public static int computeSFixed64Size(int fieldNumber, long value) { - return computeTagSize(fieldNumber) + LITTLE_ENDIAN_64_SIZE; + return computeTagSize(fieldNumber) + computeSFixed64SizeNoTag(value); } /** @@ -470,8 +579,7 @@ public final class CodedOutputStream { * {@code sint32} field, including tag. */ public static int computeSInt32Size(int fieldNumber, int value) { - return computeTagSize(fieldNumber) + - computeRawVarint32Size(encodeZigZag32(value)); + return computeTagSize(fieldNumber) + computeSInt32SizeNoTag(value); } /** @@ -479,8 +587,7 @@ public final class CodedOutputStream { * {@code sint64} field, including tag. */ public static int computeSInt64Size(int fieldNumber, long value) { - return computeTagSize(fieldNumber) + - computeRawVarint64Size(encodeZigZag64(value)); + return computeTagSize(fieldNumber) + computeSInt64SizeNoTag(value); } /** @@ -507,6 +614,174 @@ public final class CodedOutputStream { computeBytesSize(WireFormat.MESSAGE_SET_MESSAGE, value); } + // ----------------------------------------------------------------- + + /** + * Compute the number of bytes that would be needed to encode a + * {@code double} field, including tag. + */ + public static int computeDoubleSizeNoTag(double value) { + return LITTLE_ENDIAN_64_SIZE; + } + + /** + * Compute the number of bytes that would be needed to encode a + * {@code float} field, including tag. + */ + public static int computeFloatSizeNoTag(float value) { + return LITTLE_ENDIAN_32_SIZE; + } + + /** + * Compute the number of bytes that would be needed to encode a + * {@code uint64} field, including tag. + */ + public static int computeUInt64SizeNoTag(long value) { + return computeRawVarint64Size(value); + } + + /** + * Compute the number of bytes that would be needed to encode an + * {@code int64} field, including tag. + */ + public static int computeInt64SizeNoTag(long value) { + return computeRawVarint64Size(value); + } + + /** + * Compute the number of bytes that would be needed to encode an + * {@code int32} field, including tag. + */ + public static int computeInt32SizeNoTag(int value) { + if (value >= 0) { + return computeRawVarint32Size(value); + } else { + // Must sign-extend. + return 10; + } + } + + /** + * Compute the number of bytes that would be needed to encode a + * {@code fixed64} field. + */ + public static int computeFixed64SizeNoTag(long value) { + return LITTLE_ENDIAN_64_SIZE; + } + + /** + * Compute the number of bytes that would be needed to encode a + * {@code fixed32} field. + */ + public static int computeFixed32SizeNoTag(int value) { + return LITTLE_ENDIAN_32_SIZE; + } + + /** + * Compute the number of bytes that would be needed to encode a + * {@code bool} field. + */ + public static int computeBoolSizeNoTag(boolean value) { + return 1; + } + + /** + * Compute the number of bytes that would be needed to encode a + * {@code string} field. + */ + public static int computeStringSizeNoTag(String value) { + try { + byte[] bytes = value.getBytes("UTF-8"); + return computeRawVarint32Size(bytes.length) + + bytes.length; + } catch (java.io.UnsupportedEncodingException e) { + throw new RuntimeException("UTF-8 not supported.", e); + } + } + + /** + * Compute the number of bytes that would be needed to encode a + * {@code group} field. + */ + public static int computeGroupSizeNoTag(Message value) { + return value.getSerializedSize(); + } + + /** + * Compute the number of bytes that would be needed to encode a + * {@code group} field represented by an {@code UnknownFieldSet}, including + * tag. + */ + public static int computeUnknownGroupSizeNoTag(UnknownFieldSet value) { + return value.getSerializedSize(); + } + + /** + * Compute the number of bytes that would be needed to encode an embedded + * message field. + */ + public static int computeMessageSizeNoTag(Message value) { + int size = value.getSerializedSize(); + return computeRawVarint32Size(size) + size; + } + + /** + * Compute the number of bytes that would be needed to encode a + * {@code bytes} field. + */ + public static int computeBytesSizeNoTag(ByteString value) { + return computeRawVarint32Size(value.size()) + + value.size(); + } + + /** + * Compute the number of bytes that would be needed to encode a + * {@code uint32} field. + */ + public static int computeUInt32SizeNoTag(int value) { + return computeRawVarint32Size(value); + } + + /** + * Compute the number of bytes that would be needed to encode an enum field. + * Caller is responsible for converting the enum value to its numeric value. + */ + public static int computeEnumSizeNoTag(int value) { + return computeRawVarint32Size(value); + } + + /** + * Compute the number of bytes that would be needed to encode an + * {@code sfixed32} field. + */ + public static int computeSFixed32SizeNoTag(int value) { + return LITTLE_ENDIAN_32_SIZE; + } + + /** + * Compute the number of bytes that would be needed to encode an + * {@code sfixed64} field. + */ + public static int computeSFixed64SizeNoTag(long value) { + return LITTLE_ENDIAN_64_SIZE; + } + + /** + * Compute the number of bytes that would be needed to encode an + * {@code sint32} field. + */ + public static int computeSInt32SizeNoTag(int value) { + return computeRawVarint32Size(encodeZigZag32(value)); + } + + /** + * Compute the number of bytes that would be needed to encode an + * {@code sint64} field. + */ + public static int computeSInt64SizeNoTag(long value) { + return computeRawVarint64Size(encodeZigZag64(value)); + } + /** * Compute the number of bytes that would be needed to encode a * field of arbitrary type, including tag, to the stream. @@ -521,28 +796,48 @@ public final class CodedOutputStream { public static int computeFieldSize( Descriptors.FieldDescriptor.Type type, int number, Object value) { + int tagSize = computeTagSize(number); + if (type == Descriptors.FieldDescriptor.Type.GROUP) { + tagSize *= 2; + } + return tagSize + computeFieldSizeNoTag(type, value); + } + + /** + * Compute the number of bytes that would be needed to encode a + * field of arbitrary type, excluding tag, to the stream. + * + * @param type The field's type. + * @param number The field's number. + * @param value Object representing the field's value. Must be of the exact + * type which would be returned by + * {@link Message#getField(Descriptors.FieldDescriptor)} for + * this field. + */ + public static int computeFieldSizeNoTag( + Descriptors.FieldDescriptor.Type type, Object value) { switch (type) { - case DOUBLE : return computeDoubleSize (number, (Double )value); - case FLOAT : return computeFloatSize (number, (Float )value); - case INT64 : return computeInt64Size (number, (Long )value); - case UINT64 : return computeUInt64Size (number, (Long )value); - case INT32 : return computeInt32Size (number, (Integer )value); - case FIXED64 : return computeFixed64Size (number, (Long )value); - case FIXED32 : return computeFixed32Size (number, (Integer )value); - case BOOL : return computeBoolSize (number, (Boolean )value); - case STRING : return computeStringSize (number, (String )value); - case GROUP : return computeGroupSize (number, (Message )value); - case MESSAGE : return computeMessageSize (number, (Message )value); - case BYTES : return computeBytesSize (number, (ByteString)value); - case UINT32 : return computeUInt32Size (number, (Integer )value); - case SFIXED32: return computeSFixed32Size(number, (Integer )value); - case SFIXED64: return computeSFixed64Size(number, (Long )value); - case SINT32 : return computeSInt32Size (number, (Integer )value); - case SINT64 : return computeSInt64Size (number, (Long )value); + case DOUBLE : return computeDoubleSizeNoTag ((Double )value); + case FLOAT : return computeFloatSizeNoTag ((Float )value); + case INT64 : return computeInt64SizeNoTag ((Long )value); + case UINT64 : return computeUInt64SizeNoTag ((Long )value); + case INT32 : return computeInt32SizeNoTag ((Integer )value); + case FIXED64 : return computeFixed64SizeNoTag ((Long )value); + case FIXED32 : return computeFixed32SizeNoTag ((Integer )value); + case BOOL : return computeBoolSizeNoTag ((Boolean )value); + case STRING : return computeStringSizeNoTag ((String )value); + case GROUP : return computeGroupSizeNoTag ((Message )value); + case MESSAGE : return computeMessageSizeNoTag ((Message )value); + case BYTES : return computeBytesSizeNoTag ((ByteString)value); + case UINT32 : return computeUInt32SizeNoTag ((Integer )value); + case SFIXED32: return computeSFixed32SizeNoTag((Integer )value); + case SFIXED64: return computeSFixed64SizeNoTag((Long )value); + case SINT32 : return computeSInt32SizeNoTag ((Integer )value); + case SINT64 : return computeSInt64SizeNoTag ((Long )value); case ENUM: - return computeEnumSize(number, - ((Descriptors.EnumValueDescriptor)value).getNumber()); + return computeEnumSizeNoTag( + ((Descriptors.EnumValueDescriptor)value).getNumber()); } throw new RuntimeException( diff --git a/java/src/main/java/com/google/protobuf/Descriptors.java b/java/src/main/java/com/google/protobuf/Descriptors.java index ee4d4e3a..80266a59 100644 --- a/java/src/main/java/com/google/protobuf/Descriptors.java +++ b/java/src/main/java/com/google/protobuf/Descriptors.java @@ -857,6 +857,19 @@ public final class Descriptors { "Field numbers must be positive integers."); } + // Only repeated primitive fields may be packed. + if (proto.getOptions().getPacked()) { + if (proto.getLabel() != FieldDescriptorProto.Label.LABEL_REPEATED || + proto.getType() == FieldDescriptorProto.Type.TYPE_STRING || + proto.getType() == FieldDescriptorProto.Type.TYPE_GROUP || + proto.getType() == FieldDescriptorProto.Type.TYPE_MESSAGE || + proto.getType() == FieldDescriptorProto.Type.TYPE_BYTES) { + throw new DescriptorValidationException(this, + "[packed = true] can only be specified for repeated primitive " + + "fields."); + } + } + if (isExtension) { if (!proto.hasExtendee()) { throw new DescriptorValidationException(this, diff --git a/java/src/main/java/com/google/protobuf/DynamicMessage.java b/java/src/main/java/com/google/protobuf/DynamicMessage.java index fefa23ec..99ae253c 100644 --- a/java/src/main/java/com/google/protobuf/DynamicMessage.java +++ b/java/src/main/java/com/google/protobuf/DynamicMessage.java @@ -211,6 +211,10 @@ public final class DynamicMessage extends AbstractMessage { return new Builder(type); } + public Builder toBuilder() { + return newBuilderForType().mergeFrom(this); + } + /** Verifies that the field is a field of this message. */ private void verifyContainingType(FieldDescriptor field) { if (field.getContainingType() != type) { @@ -251,6 +255,7 @@ public final class DynamicMessage extends AbstractMessage { } fields.mergeFrom(other); + mergeUnknownFields(other.getUnknownFields()); return this; } diff --git a/java/src/main/java/com/google/protobuf/FieldSet.java b/java/src/main/java/com/google/protobuf/FieldSet.java index 98a1c328..01da3faf 100644 --- a/java/src/main/java/com/google/protobuf/FieldSet.java +++ b/java/src/main/java/com/google/protobuf/FieldSet.java @@ -351,8 +351,7 @@ final class FieldSet { setField(field, entry.getValue()); } else { setField(field, - existingValue.newBuilderForType() - .mergeFrom(existingValue) + existingValue.toBuilder() .mergeFrom((Message)entry.getValue()) .build()); } @@ -384,8 +383,7 @@ final class FieldSet { setField(field, value); } else { setField(field, - existingValue.newBuilderForType() - .mergeFrom(existingValue) + existingValue.toBuilder() .mergeFrom((Message)value) .build()); } @@ -463,60 +461,83 @@ final class FieldSet { } if (field == null || - wireType != WireFormat.getWireFormatForFieldType(field.getType())) { + wireType != WireFormat.getWireFormatForField(field)) { // Unknown field or wrong wire type. Skip. return unknownFields.mergeFieldFrom(tag, input); } else { - Object value; - switch (field.getType()) { - case GROUP: { - Message.Builder subBuilder; - if (defaultInstance != null) { - subBuilder = defaultInstance.newBuilderForType(); - } else { - subBuilder = builder.newBuilderForField(field); + if (field.getOptions().getPacked()) { + int length = input.readRawVarint32(); + int limit = input.pushLimit(length); + if (field.getType() == FieldDescriptor.Type.ENUM) { + while (input.getBytesUntilLimit() > 0) { + int rawValue = input.readEnum(); + Object value = field.getEnumType().findValueByNumber(rawValue); + if (value == null) { + // If the number isn't recognized as a valid value for this + // enum, drop it (don't even add it to unknownFields). + return true; + } + builder.addRepeatedField(field, value); } - if (!field.isRepeated()) { - subBuilder.mergeFrom((Message) builder.getField(field)); + } else { + while (input.getBytesUntilLimit() > 0) { + Object value = input.readPrimitiveField(field.getType()); + builder.addRepeatedField(field, value); } - input.readGroup(field.getNumber(), subBuilder, extensionRegistry); - value = subBuilder.build(); - break; } - case MESSAGE: { - Message.Builder subBuilder; - if (defaultInstance != null) { - subBuilder = defaultInstance.newBuilderForType(); - } else { - subBuilder = builder.newBuilderForField(field); + input.popLimit(limit); + } else { + Object value; + switch (field.getType()) { + case GROUP: { + Message.Builder subBuilder; + if (defaultInstance != null) { + subBuilder = defaultInstance.newBuilderForType(); + } else { + subBuilder = builder.newBuilderForField(field); + } + if (!field.isRepeated()) { + subBuilder.mergeFrom((Message) builder.getField(field)); + } + input.readGroup(field.getNumber(), subBuilder, extensionRegistry); + value = subBuilder.build(); + break; } - if (!field.isRepeated()) { - subBuilder.mergeFrom((Message) builder.getField(field)); + case MESSAGE: { + Message.Builder subBuilder; + if (defaultInstance != null) { + subBuilder = defaultInstance.newBuilderForType(); + } else { + subBuilder = builder.newBuilderForField(field); + } + if (!field.isRepeated()) { + subBuilder.mergeFrom((Message) builder.getField(field)); + } + input.readMessage(subBuilder, extensionRegistry); + value = subBuilder.build(); + break; } - input.readMessage(subBuilder, extensionRegistry); - value = subBuilder.build(); - break; - } - case ENUM: { - int rawValue = input.readEnum(); - value = field.getEnumType().findValueByNumber(rawValue); - // If the number isn't recognized as a valid value for this enum, - // drop it. - if (value == null) { - unknownFields.mergeVarintField(fieldNumber, rawValue); - return true; + case ENUM: { + int rawValue = input.readEnum(); + value = field.getEnumType().findValueByNumber(rawValue); + // If the number isn't recognized as a valid value for this enum, + // drop it. + if (value == null) { + unknownFields.mergeVarintField(fieldNumber, rawValue); + return true; + } + break; } - break; + default: + value = input.readPrimitiveField(field.getType()); + break; } - default: - value = input.readPrimitiveField(field.getType()); - break; - } - if (field.isRepeated()) { - builder.addRepeatedField(field, value); - } else { - builder.setField(field, value); + if (field.isRepeated()) { + builder.addRepeatedField(field, value); + } else { + builder.setField(field, value); + } } } @@ -636,8 +657,24 @@ final class FieldSet { output.writeMessageSetExtension(field.getNumber(), (Message)value); } else { if (field.isRepeated()) { - for (Object element : (List)value) { - output.writeField(field.getType(), field.getNumber(), element); + List valueList = (List)value; + if (field.getOptions().getPacked()) { + output.writeTag(field.getNumber(), + WireFormat.WIRETYPE_LENGTH_DELIMITED); + // Compute the total data size so the length can be written. + int dataSize = 0; + for (Object element : valueList) { + dataSize += output.computeFieldSizeNoTag(field.getType(), element); + } + output.writeRawVarint32(dataSize); + // Write the data itself, without any tags. + for (Object element : valueList) { + output.writeFieldNoTag(field.getType(), element); + } + } else { + for (Object element : valueList) { + output.writeField(field.getType(), field.getNumber(), element); + } } } else { output.writeField(field.getType(), field.getNumber(), value); @@ -658,12 +695,23 @@ final class FieldSet { if (field.isExtension() && field.getContainingType().getOptions().getMessageSetWireFormat()) { size += CodedOutputStream.computeMessageSetExtensionSize( - field.getNumber(), (Message)value); + field.getNumber(), (Message) value); } else { if (field.isRepeated()) { - for (Object element : (List)value) { - size += CodedOutputStream.computeFieldSize( - field.getType(), field.getNumber(), element); + if (field.getOptions().getPacked()) { + int dataSize = 0; + for (Object element : (List)value) { + dataSize += CodedOutputStream.computeFieldSizeNoTag( + field.getType(), element); + } + size += dataSize + + CodedOutputStream.computeTagSize(field.getNumber()) + + CodedOutputStream.computeRawVarint32Size(dataSize); + } else { + for (Object element : (List)value) { + size += CodedOutputStream.computeFieldSize( + field.getType(), field.getNumber(), element); + } } } else { size += CodedOutputStream.computeFieldSize( diff --git a/java/src/main/java/com/google/protobuf/GeneratedMessage.java b/java/src/main/java/com/google/protobuf/GeneratedMessage.java index b1be8b14..77c88c30 100644 --- a/java/src/main/java/com/google/protobuf/GeneratedMessage.java +++ b/java/src/main/java/com/google/protobuf/GeneratedMessage.java @@ -31,8 +31,8 @@ package com.google.protobuf; import com.google.protobuf.Descriptors.Descriptor; -import com.google.protobuf.Descriptors.FieldDescriptor; import com.google.protobuf.Descriptors.EnumValueDescriptor; +import com.google.protobuf.Descriptors.FieldDescriptor; import java.io.IOException; import java.lang.reflect.Method; @@ -75,7 +75,7 @@ public abstract class GeneratedMessage extends AbstractMessage { Descriptor descriptor = internalGetFieldAccessorTable().descriptor; for (FieldDescriptor field : descriptor.getFields()) { if (field.isRepeated()) { - List value = (List)getField(field); + List value = (List) getField(field); if (!value.isEmpty()) { result.put(field, value); } @@ -87,7 +87,7 @@ public abstract class GeneratedMessage extends AbstractMessage { } return result; } - + public boolean isInitialized() { for (FieldDescriptor field : getDescriptorForType().getFields()) { // Check that all required fields are present. @@ -99,7 +99,9 @@ public abstract class GeneratedMessage extends AbstractMessage { // Check that embedded messages are initialized. if (field.getJavaType() == FieldDescriptor.JavaType.MESSAGE) { if (field.isRepeated()) { - for (Message element : (List<Message>) getField(field)) { + @SuppressWarnings("unchecked") + List<Message> messageList = (List<Message>) getField(field); + for (Message element : messageList) { if (!element.isInitialized()) { return false; } @@ -189,7 +191,7 @@ public abstract class GeneratedMessage extends AbstractMessage { setField(field, entry.getValue()); } } - return (BuilderType)this; + return (BuilderType) this; } public Descriptor getDescriptorForType() { @@ -214,7 +216,7 @@ public abstract class GeneratedMessage extends AbstractMessage { // The underlying list object is still modifiable at this point. // Make sure not to expose the modifiable list to the caller. return Collections.unmodifiableList( - (List)internalGetResult().getField(field)); + (List) internalGetResult().getField(field)); } else { return internalGetResult().getField(field); } @@ -223,12 +225,12 @@ public abstract class GeneratedMessage extends AbstractMessage { public BuilderType setField(Descriptors.FieldDescriptor field, Object value) { internalGetFieldAccessorTable().getField(field).set(this, value); - return (BuilderType)this; + return (BuilderType) this; } public BuilderType clearField(Descriptors.FieldDescriptor field) { internalGetFieldAccessorTable().getField(field).clear(this); - return (BuilderType)this; + return (BuilderType) this; } public int getRepeatedFieldCount(Descriptors.FieldDescriptor field) { @@ -244,13 +246,13 @@ public abstract class GeneratedMessage extends AbstractMessage { int index, Object value) { internalGetFieldAccessorTable().getField(field) .setRepeated(this, index, value); - return (BuilderType)this; + return (BuilderType) this; } public BuilderType addRepeatedField(Descriptors.FieldDescriptor field, Object value) { internalGetFieldAccessorTable().getField(field).addRepeated(this, value); - return (BuilderType)this; + return (BuilderType) this; } public final UnknownFieldSet getUnknownFields() { @@ -259,7 +261,7 @@ public abstract class GeneratedMessage extends AbstractMessage { public final BuilderType setUnknownFields(UnknownFieldSet unknownFields) { internalGetResult().unknownFields = unknownFields; - return (BuilderType)this; + return (BuilderType) this; } public final BuilderType mergeUnknownFields(UnknownFieldSet unknownFields) { @@ -268,7 +270,7 @@ public abstract class GeneratedMessage extends AbstractMessage { UnknownFieldSet.newBuilder(result.unknownFields) .mergeFrom(unknownFields) .build(); - return (BuilderType)this; + return (BuilderType) this; } public boolean isInitialized() { @@ -287,7 +289,18 @@ public abstract class GeneratedMessage extends AbstractMessage { return unknownFields.mergeFieldFrom(tag, input); } + /** + * Adds the {@code values} to the {@code list}. + * + * @throws NullPointerException if any of the elements of {@code values} is + * null. + */ protected <T> void addAll(Iterable<T> values, Collection<? super T> list) { + for (T value : values) { + if (value == null) { + throw new NullPointerException(); + } + } if (values instanceof Collection) { @SuppressWarnings("unsafe") Collection<T> collection = (Collection<T>) values; @@ -378,9 +391,9 @@ public abstract class GeneratedMessage extends AbstractMessage { verifyExtensionContainingType(extension); Object value = extensions.getField(extension.getDescriptor()); if (value == null) { - return (Type)extension.getMessageDefaultInstance(); + return (Type) extension.getMessageDefaultInstance(); } else { - return (Type)extension.fromReflectionType(value); + return (Type) extension.fromReflectionType(value); } } @@ -389,7 +402,7 @@ public abstract class GeneratedMessage extends AbstractMessage { public final <Type> Type getExtension( GeneratedExtension<MessageType, List<Type>> extension, int index) { verifyExtensionContainingType(extension); - return (Type)extension.singularFromReflectionType( + return (Type) extension.singularFromReflectionType( extensions.getRepeatedField(extension.getDescriptor(), index)); } @@ -397,7 +410,7 @@ public abstract class GeneratedMessage extends AbstractMessage { protected boolean extensionsAreInitialized() { return extensions.isInitialized(); } - + public boolean isInitialized() { return super.isInitialized() && extensionsAreInitialized(); } @@ -580,7 +593,7 @@ public abstract class GeneratedMessage extends AbstractMessage { message.verifyExtensionContainingType(extension); message.extensions.setField(extension.getDescriptor(), extension.toReflectionType(value)); - return (BuilderType)this; + return (BuilderType) this; } /** Set the value of one element of a repeated extension. */ @@ -592,7 +605,7 @@ public abstract class GeneratedMessage extends AbstractMessage { message.extensions.setRepeatedField( extension.getDescriptor(), index, extension.singularToReflectionType(value)); - return (BuilderType)this; + return (BuilderType) this; } /** Append a value to a repeated extension. */ @@ -602,7 +615,7 @@ public abstract class GeneratedMessage extends AbstractMessage { message.verifyExtensionContainingType(extension); message.extensions.addRepeatedField( extension.getDescriptor(), extension.singularToReflectionType(value)); - return (BuilderType)this; + return (BuilderType) this; } /** Clear an extension. */ @@ -611,7 +624,7 @@ public abstract class GeneratedMessage extends AbstractMessage { ExtendableMessage<MessageType> message = internalGetResult(); message.verifyExtensionContainingType(extension); message.extensions.clearField(extension.getDescriptor()); - return (BuilderType)this; + return (BuilderType) this; } /** @@ -639,7 +652,7 @@ public abstract class GeneratedMessage extends AbstractMessage { ExtendableMessage<MessageType> message = internalGetResult(); message.verifyContainingType(field); message.extensions.setField(field, value); - return (BuilderType)this; + return (BuilderType) this; } else { return super.setField(field, value); } @@ -650,7 +663,7 @@ public abstract class GeneratedMessage extends AbstractMessage { ExtendableMessage<MessageType> message = internalGetResult(); message.verifyContainingType(field); message.extensions.clearField(field); - return (BuilderType)this; + return (BuilderType) this; } else { return super.clearField(field); } @@ -662,7 +675,7 @@ public abstract class GeneratedMessage extends AbstractMessage { ExtendableMessage<MessageType> message = internalGetResult(); message.verifyContainingType(field); message.extensions.setRepeatedField(field, index, value); - return (BuilderType)this; + return (BuilderType) this; } else { return super.setRepeatedField(field, index, value); } @@ -674,11 +687,15 @@ public abstract class GeneratedMessage extends AbstractMessage { ExtendableMessage<MessageType> message = internalGetResult(); message.verifyContainingType(field); message.extensions.addRepeatedField(field, value); - return (BuilderType)this; + return (BuilderType) this; } else { return super.addRepeatedField(field, value); } } + + protected final void mergeExtensionFields(ExtendableMessage other) { + internalGetResult().extensions.mergeFrom(other.extensions); + } } // ----------------------------------------------------------------- @@ -750,8 +767,8 @@ public abstract class GeneratedMessage extends AbstractMessage { enumValueOf = null; enumGetValueDescriptor = null; messageDefaultInstance = - (Message)invokeOrDie(getMethodOrDie(type, "getDefaultInstance"), - null); + (Message) invokeOrDie(getMethodOrDie(type, "getDefaultInstance"), + null); break; case ENUM: enumValueOf = getMethodOrDie(type, "valueOf", @@ -797,7 +814,7 @@ public abstract class GeneratedMessage extends AbstractMessage { descriptor.getJavaType() == FieldDescriptor.JavaType.ENUM) { // Must convert the whole list. List result = new ArrayList(); - for (Object element : (List)value) { + for (Object element : (List) value) { result.add(singularFromReflectionType(element)); } return result; @@ -826,10 +843,10 @@ public abstract class GeneratedMessage extends AbstractMessage { // This should not happen in normal use. But, to be nice, we'll // copy the message to whatever type the caller was expecting. return messageDefaultInstance.newBuilderForType() - .mergeFrom((Message)value).build(); + .mergeFrom((Message) value).build(); } case ENUM: - return invokeOrDie(enumValueOf, null, (EnumValueDescriptor)value); + return invokeOrDie(enumValueOf, null, (EnumValueDescriptor) value); default: return value; } @@ -847,7 +864,7 @@ public abstract class GeneratedMessage extends AbstractMessage { if (descriptor.getJavaType() == FieldDescriptor.JavaType.ENUM) { // Must convert the whole list. List result = new ArrayList(); - for (Object element : (List)value) { + for (Object element : (List) value) { result.add(singularToReflectionType(element)); } return result; @@ -900,9 +917,9 @@ public abstract class GeneratedMessage extends AbstractMessage { } catch (java.lang.reflect.InvocationTargetException e) { Throwable cause = e.getCause(); if (cause instanceof RuntimeException) { - throw (RuntimeException)cause; + throw (RuntimeException) cause; } else if (cause instanceof Error) { - throw (Error)cause; + throw (Error) cause; } else { throw new RuntimeException( "Unexpected exception thrown by generated accessor method.", cause); @@ -915,6 +932,7 @@ public abstract class GeneratedMessage extends AbstractMessage { * with access to the fields of a message object using Java reflection. */ public static final class FieldAccessorTable { + /** * Construct a FieldAccessorTable for a particular message class. Only * one FieldAccessorTable should ever be constructed per class. @@ -1039,7 +1057,7 @@ public abstract class GeneratedMessage extends AbstractMessage { "addRepeatedField() called on a singular field."); } public boolean has(GeneratedMessage message) { - return (Boolean)invokeOrDie(hasMethod, message); + return (Boolean) invokeOrDie(hasMethod, message); } public int getRepeatedCount(GeneratedMessage message) { throw new UnsupportedOperationException( @@ -1092,7 +1110,7 @@ public abstract class GeneratedMessage extends AbstractMessage { // 2) Insures that the caller cannot modify the list later on and // have the modifications be reflected in the message. clear(builder); - for (Object element : (List)value) { + for (Object element : (List) value) { addRepeated(builder, element); } } @@ -1111,7 +1129,7 @@ public abstract class GeneratedMessage extends AbstractMessage { "hasField() called on a singular field."); } public int getRepeatedCount(GeneratedMessage message) { - return (Integer)invokeOrDie(getCountMethod, message); + return (Integer) invokeOrDie(getCountMethod, message); } public void clear(GeneratedMessage.Builder builder) { invokeOrDie(clearMethod, builder); @@ -1169,7 +1187,7 @@ public abstract class GeneratedMessage extends AbstractMessage { @SuppressWarnings("unchecked") public Object get(GeneratedMessage message) { List newList = new ArrayList(); - for (Object element : (List)super.get(message)) { + for (Object element : (List) super.get(message)) { newList.add(invokeOrDie(getValueDescriptorMethod, element)); } return Collections.unmodifiableList(newList); @@ -1210,8 +1228,8 @@ public abstract class GeneratedMessage extends AbstractMessage { // is an alternative implementation of the same type -- e.g. a // DynamicMessage -- we should accept it. In this case we can make // a copy of the message. - return ((Message.Builder)invokeOrDie(newBuilderMethod, null)) - .mergeFrom((Message)value).build(); + return ((Message.Builder) invokeOrDie(newBuilderMethod, null)) + .mergeFrom((Message) value).build(); } } @@ -1219,7 +1237,7 @@ public abstract class GeneratedMessage extends AbstractMessage { super.set(builder, coerceType(value)); } public Message.Builder newBuilder() { - return (Message.Builder)invokeOrDie(newBuilderMethod, null); + return (Message.Builder) invokeOrDie(newBuilderMethod, null); } } @@ -1244,8 +1262,8 @@ public abstract class GeneratedMessage extends AbstractMessage { // is an alternative implementation of the same type -- e.g. a // DynamicMessage -- we should accept it. In this case we can make // a copy of the message. - return ((Message.Builder)invokeOrDie(newBuilderMethod, null)) - .mergeFrom((Message)value).build(); + return ((Message.Builder) invokeOrDie(newBuilderMethod, null)) + .mergeFrom((Message) value).build(); } } @@ -1257,7 +1275,7 @@ public abstract class GeneratedMessage extends AbstractMessage { super.addRepeated(builder, coerceType(value)); } public Message.Builder newBuilder() { - return (Message.Builder)invokeOrDie(newBuilderMethod, null); + return (Message.Builder) invokeOrDie(newBuilderMethod, null); } } } diff --git a/java/src/main/java/com/google/protobuf/Message.java b/java/src/main/java/com/google/protobuf/Message.java index 9635387a..2f8700db 100644 --- a/java/src/main/java/com/google/protobuf/Message.java +++ b/java/src/main/java/com/google/protobuf/Message.java @@ -195,6 +195,12 @@ public interface Message { Builder newBuilderForType(); /** + * Constructs a builder initialized with the current message. Use this to + * derive a new message from the current one. + */ + Builder toBuilder(); + + /** * Abstract interface implemented by Protocol Message builders. */ public static interface Builder extends Cloneable { diff --git a/java/src/main/java/com/google/protobuf/TextFormat.java b/java/src/main/java/com/google/protobuf/TextFormat.java index 3a1b1d4e..3dcf68c8 100644 --- a/java/src/main/java/com/google/protobuf/TextFormat.java +++ b/java/src/main/java/com/google/protobuf/TextFormat.java @@ -397,13 +397,15 @@ public final class TextFormat { private int previousLine = 0; private int previousColumn = 0; + // We use possesive quantifiers (*+ and ++) because otherwise the Java + // regex matcher has stack overflows on large inputs. private static Pattern WHITESPACE = - Pattern.compile("(\\s|(#.*$))+", Pattern.MULTILINE); + Pattern.compile("(\\s|(#.*$))++", Pattern.MULTILINE); private static Pattern TOKEN = Pattern.compile( - "[a-zA-Z_][0-9a-zA-Z_+-]*|" + // an identifier - "[0-9+-][0-9a-zA-Z_.+-]*|" + // a number - "\"([^\"\n\\\\]|\\\\.)*(\"|\\\\?$)|" + // a double-quoted string - "\'([^\"\n\\\\]|\\\\.)*(\'|\\\\?$)", // a single-quoted string + "[a-zA-Z_][0-9a-zA-Z_+-]*+|" + // an identifier + "[0-9+-][0-9a-zA-Z_.+-]*+|" + // a number + "\"([^\"\n\\\\]|\\\\.)*+(\"|\\\\?$)|" + // a double-quoted string + "\'([^\"\n\\\\]|\\\\.)*+(\'|\\\\?$)", // a single-quoted string Pattern.MULTILINE); private static Pattern DOUBLE_INFINITY = Pattern.compile( diff --git a/java/src/main/java/com/google/protobuf/WireFormat.java b/java/src/main/java/com/google/protobuf/WireFormat.java index ff042c05..2faf2448 100644 --- a/java/src/main/java/com/google/protobuf/WireFormat.java +++ b/java/src/main/java/com/google/protobuf/WireFormat.java @@ -96,6 +96,16 @@ public final class WireFormat { "There is no way to get here, but the compiler thinks otherwise."); } + /** Given a field descriptor, returns the wire type. This differs from + * getWireFormatForFieldType for packed repeated fields. */ + static int getWireFormatForField(Descriptors.FieldDescriptor descriptor) { + if (descriptor.getOptions().getPacked()) { + return WIRETYPE_LENGTH_DELIMITED; + } else { + return getWireFormatForFieldType(descriptor.getType()); + } + } + // Field numbers for feilds in MessageSet wire format. static final int MESSAGE_SET_ITEM = 1; static final int MESSAGE_SET_TYPE_ID = 2; diff --git a/java/src/test/java/com/google/protobuf/AbstractMessageTest.java b/java/src/test/java/com/google/protobuf/AbstractMessageTest.java index 10ab7e75..da073561 100644 --- a/java/src/test/java/com/google/protobuf/AbstractMessageTest.java +++ b/java/src/test/java/com/google/protobuf/AbstractMessageTest.java @@ -34,6 +34,7 @@ import protobuf_unittest.UnittestProto; import protobuf_unittest.UnittestProto.ForeignMessage; import protobuf_unittest.UnittestProto.TestAllTypes; import protobuf_unittest.UnittestProto.TestAllExtensions; +import protobuf_unittest.UnittestProto.TestPackedTypes; import protobuf_unittest.UnittestProto.TestRequired; import protobuf_unittest.UnittestProto.TestRequiredForeign; import protobuf_unittest.UnittestOptimizeFor.TestOptimizedForSize; @@ -91,6 +92,9 @@ public class AbstractMessageTest extends TestCase { public Builder newBuilderForType() { return new Builder(wrappedMessage.newBuilderForType()); } + public Builder toBuilder() { + return new Builder(wrappedMessage.toBuilder()); + } static class Builder extends AbstractMessage.Builder<Builder> { private final Message.Builder wrappedBuilder; @@ -215,6 +219,25 @@ public class AbstractMessageTest extends TestCase { TestUtil.assertAllFieldsSet((TestAllTypes) message.wrappedMessage); } + public void testPackedSerialization() throws Exception { + Message abstractMessage = + new AbstractMessageWrapper(TestUtil.getPackedSet()); + + TestUtil.assertPackedFieldsSet( + TestPackedTypes.parseFrom(abstractMessage.toByteString())); + + assertEquals(TestUtil.getPackedSet().toByteString(), + abstractMessage.toByteString()); + } + + public void testPackedParsing() throws Exception { + AbstractMessageWrapper.Builder builder = + new AbstractMessageWrapper.Builder(TestPackedTypes.newBuilder()); + AbstractMessageWrapper message = + builder.mergeFrom(TestUtil.getPackedSet().toByteString()).build(); + TestUtil.assertPackedFieldsSet((TestPackedTypes) message.wrappedMessage); + } + public void testOptimizedForSize() throws Exception { // We're mostly only checking that this class was compiled successfully. TestOptimizedForSize message = diff --git a/java/src/test/java/com/google/protobuf/CodedOutputStreamTest.java b/java/src/test/java/com/google/protobuf/CodedOutputStreamTest.java index 5a96e3e6..c42b485c 100644 --- a/java/src/test/java/com/google/protobuf/CodedOutputStreamTest.java +++ b/java/src/test/java/com/google/protobuf/CodedOutputStreamTest.java @@ -31,6 +31,7 @@ package com.google.protobuf; import protobuf_unittest.UnittestProto.TestAllTypes; +import protobuf_unittest.UnittestProto.TestPackedTypes; import junit.framework.TestCase; @@ -290,4 +291,14 @@ public class CodedOutputStreamTest extends TestCase { assertEqualBytes(rawBytes, rawOutput.toByteArray()); } } + + /** Tests writing a whole message with every packed field type. Ensures the + * wire format of packed fields is compatible with C++. */ + public void testWriteWholePackedFieldsMessage() throws Exception { + TestPackedTypes message = TestUtil.getPackedSet(); + + byte[] rawBytes = message.toByteArray(); + assertEqualBytes(TestUtil.getGoldenPackedFieldsMessage().toByteArray(), + rawBytes); + } } diff --git a/java/src/test/java/com/google/protobuf/DynamicMessageTest.java b/java/src/test/java/com/google/protobuf/DynamicMessageTest.java index e2c15c64..fc53c531 100644 --- a/java/src/test/java/com/google/protobuf/DynamicMessageTest.java +++ b/java/src/test/java/com/google/protobuf/DynamicMessageTest.java @@ -32,8 +32,10 @@ package com.google.protobuf; import protobuf_unittest.UnittestProto.TestAllTypes; import protobuf_unittest.UnittestProto.TestAllExtensions; +import protobuf_unittest.UnittestProto.TestPackedTypes; import junit.framework.TestCase; +import java.util.Arrays; /** * Unit test for {@link DynamicMessage}. See also {@link MessageTest}, which @@ -48,6 +50,8 @@ public class DynamicMessageTest extends TestCase { TestUtil.ReflectionTester extensionsReflectionTester = new TestUtil.ReflectionTester(TestAllExtensions.getDescriptor(), TestUtil.getExtensionRegistry()); + TestUtil.ReflectionTester packedReflectionTester = + new TestUtil.ReflectionTester(TestPackedTypes.getDescriptor(), null); public void testDynamicMessageAccessors() throws Exception { Message.Builder builder = @@ -57,6 +61,12 @@ public class DynamicMessageTest extends TestCase { reflectionTester.assertAllFieldsSetViaReflection(message); } + public void testDynamicMessageSettersRejectNull() throws Exception { + Message.Builder builder = + DynamicMessage.newBuilder(TestAllTypes.getDescriptor()); + reflectionTester.assertReflectionSettersRejectNull(builder); + } + public void testDynamicMessageExtensionAccessors() throws Exception { // We don't need to extensively test DynamicMessage's handling of // extensions because, frankly, it doesn't do anything special with them. @@ -68,6 +78,12 @@ public class DynamicMessageTest extends TestCase { extensionsReflectionTester.assertAllFieldsSetViaReflection(message); } + public void testDynamicMessageExtensionSettersRejectNull() throws Exception { + Message.Builder builder = + DynamicMessage.newBuilder(TestAllExtensions.getDescriptor()); + extensionsReflectionTester.assertReflectionSettersRejectNull(builder); + } + public void testDynamicMessageRepeatedSetters() throws Exception { Message.Builder builder = DynamicMessage.newBuilder(TestAllTypes.getDescriptor()); @@ -77,6 +93,12 @@ public class DynamicMessageTest extends TestCase { reflectionTester.assertRepeatedFieldsModifiedViaReflection(message); } + public void testDynamicMessageRepeatedSettersRejectNull() throws Exception { + Message.Builder builder = + DynamicMessage.newBuilder(TestAllTypes.getDescriptor()); + reflectionTester.assertReflectionRepeatedSettersRejectNull(builder); + } + public void testDynamicMessageDefaults() throws Exception { reflectionTester.assertClearViaReflection( DynamicMessage.getDefaultInstance(TestAllTypes.getDescriptor())); @@ -123,6 +145,33 @@ public class DynamicMessageTest extends TestCase { reflectionTester.assertAllFieldsSetViaReflection(message2); } + public void testDynamicMessagePackedSerialization() throws Exception { + Message.Builder builder = + DynamicMessage.newBuilder(TestPackedTypes.getDescriptor()); + packedReflectionTester.setPackedFieldsViaReflection(builder); + Message message = builder.build(); + + ByteString rawBytes = message.toByteString(); + TestPackedTypes message2 = TestPackedTypes.parseFrom(rawBytes); + + TestUtil.assertPackedFieldsSet(message2); + + // In fact, the serialized forms should be exactly the same, byte-for-byte. + assertEquals(TestUtil.getPackedSet().toByteString(), rawBytes); + } + + public void testDynamicMessagePackedParsing() throws Exception { + TestPackedTypes.Builder builder = TestPackedTypes.newBuilder(); + TestUtil.setPackedFields(builder); + TestPackedTypes message = builder.build(); + + ByteString rawBytes = message.toByteString(); + + Message message2 = + DynamicMessage.parseFrom(TestPackedTypes.getDescriptor(), rawBytes); + packedReflectionTester.assertPackedFieldsSetViaReflection(message2); + } + public void testDynamicMessageCopy() throws Exception { TestAllTypes.Builder builder = TestAllTypes.newBuilder(); TestUtil.setAllFields(builder); @@ -131,4 +180,23 @@ public class DynamicMessageTest extends TestCase { DynamicMessage copy = DynamicMessage.newBuilder(message).build(); reflectionTester.assertAllFieldsSetViaReflection(copy); } + + public void testToBuilder() throws Exception { + DynamicMessage.Builder builder = + DynamicMessage.newBuilder(TestAllTypes.getDescriptor()); + reflectionTester.setAllFieldsViaReflection(builder); + int unknownFieldNum = 9; + long unknownFieldVal = 90; + builder.setUnknownFields(UnknownFieldSet.newBuilder() + .addField(unknownFieldNum, + UnknownFieldSet.Field.newBuilder() + .addVarint(unknownFieldVal).build()) + .build()); + DynamicMessage message = builder.build(); + + DynamicMessage derived = message.toBuilder().build(); + reflectionTester.assertAllFieldsSetViaReflection(derived); + assertEquals(Arrays.asList(unknownFieldVal), + derived.getUnknownFields().getField(unknownFieldNum).getVarintList()); + } } diff --git a/java/src/test/java/com/google/protobuf/GeneratedMessageTest.java b/java/src/test/java/com/google/protobuf/GeneratedMessageTest.java index 95c269a2..0ecdc6ae 100644 --- a/java/src/test/java/com/google/protobuf/GeneratedMessageTest.java +++ b/java/src/test/java/com/google/protobuf/GeneratedMessageTest.java @@ -71,6 +71,72 @@ public class GeneratedMessageTest extends TestCase { TestUtil.assertAllFieldsSet(message); } + public void testSettersRejectNull() throws Exception { + TestAllTypes.Builder builder = TestAllTypes.newBuilder(); + try { + builder.setOptionalString(null); + fail("Exception was not thrown"); + } catch (NullPointerException e) { + // We expect this exception. + } + try { + builder.setOptionalBytes(null); + fail("Exception was not thrown"); + } catch (NullPointerException e) { + // We expect this exception. + } + try { + builder.setOptionalNestedMessage((TestAllTypes.NestedMessage) null); + fail("Exception was not thrown"); + } catch (NullPointerException e) { + // We expect this exception. + } + try { + builder.setOptionalNestedMessage( + (TestAllTypes.NestedMessage.Builder) null); + fail("Exception was not thrown"); + } catch (NullPointerException e) { + // We expect this exception. + } + try { + builder.setOptionalNestedEnum(null); + fail("Exception was not thrown"); + } catch (NullPointerException e) { + // We expect this exception. + } + try { + builder.addRepeatedString(null); + fail("Exception was not thrown"); + } catch (NullPointerException e) { + // We expect this exception. + } + try { + builder.addRepeatedBytes(null); + fail("Exception was not thrown"); + } catch (NullPointerException e) { + // We expect this exception. + } + try { + builder.addRepeatedNestedMessage((TestAllTypes.NestedMessage) null); + fail("Exception was not thrown"); + } catch (NullPointerException e) { + // We expect this exception. + } + try { + builder.addRepeatedNestedMessage( + (TestAllTypes.NestedMessage.Builder) null); + fail("Exception was not thrown"); + } catch (NullPointerException e) { + // We expect this exception. + } + try { + builder.addRepeatedNestedEnum(null); + fail("Exception was not thrown"); + } catch (NullPointerException e) { + // We expect this exception. + } + } + public void testRepeatedSetters() throws Exception { TestAllTypes.Builder builder = TestAllTypes.newBuilder(); TestUtil.setAllFields(builder); @@ -79,6 +145,55 @@ public class GeneratedMessageTest extends TestCase { TestUtil.assertRepeatedFieldsModified(message); } + public void testRepeatedSettersRejectNull() throws Exception { + TestAllTypes.Builder builder = TestAllTypes.newBuilder(); + + builder.addRepeatedString("one"); + builder.addRepeatedString("two"); + try { + builder.setRepeatedString(1, null); + fail("Exception was not thrown"); + } catch (NullPointerException e) { + // We expect this exception. + } + + builder.addRepeatedBytes(TestUtil.toBytes("one")); + builder.addRepeatedBytes(TestUtil.toBytes("two")); + try { + builder.setRepeatedBytes(1, null); + fail("Exception was not thrown"); + } catch (NullPointerException e) { + // We expect this exception. + } + + builder.addRepeatedNestedMessage( + TestAllTypes.NestedMessage.newBuilder().setBb(218).build()); + builder.addRepeatedNestedMessage( + TestAllTypes.NestedMessage.newBuilder().setBb(456).build()); + try { + builder.setRepeatedNestedMessage(1, (TestAllTypes.NestedMessage) null); + fail("Exception was not thrown"); + } catch (NullPointerException e) { + // We expect this exception. + } + try { + builder.setRepeatedNestedMessage( + 1, (TestAllTypes.NestedMessage.Builder) null); + fail("Exception was not thrown"); + } catch (NullPointerException e) { + // We expect this exception. + } + + builder.addRepeatedNestedEnum(TestAllTypes.NestedEnum.FOO); + builder.addRepeatedNestedEnum(TestAllTypes.NestedEnum.BAR); + try { + builder.setRepeatedNestedEnum(1, null); + fail("Exception was not thrown"); + } catch (NullPointerException e) { + // We expect this exception. + } + } + public void testRepeatedAppend() throws Exception { TestAllTypes.Builder builder = TestAllTypes.newBuilder(); @@ -97,6 +212,42 @@ public class GeneratedMessageTest extends TestCase { assertEquals(12, message.getRepeatedForeignMessage(0).getC()); } + public void testRepeatedAppendRejectsNull() throws Exception { + TestAllTypes.Builder builder = TestAllTypes.newBuilder(); + + ForeignMessage foreignMessage = + ForeignMessage.newBuilder().setC(12).build(); + try { + builder.addAllRepeatedForeignMessage( + Arrays.asList(foreignMessage, (ForeignMessage) null)); + fail("Exception was not thrown"); + } catch (NullPointerException e) { + // We expect this exception. + } + + try { + builder.addAllRepeatedForeignEnum( + Arrays.asList(ForeignEnum.FOREIGN_BAZ, null)); + fail("Exception was not thrown"); + } catch (NullPointerException e) { + // We expect this exception. + } + + try { + builder.addAllRepeatedString(Arrays.asList("one", null)); + fail("Exception was not thrown"); + } catch (NullPointerException e) { + // We expect this exception. + } + + try { + builder.addAllRepeatedBytes(Arrays.asList(TestUtil.toBytes("one"), null)); + fail("Exception was not thrown"); + } catch (NullPointerException e) { + // We expect this exception. + } + } + public void testSettingForeignMessageUsingBuilder() throws Exception { TestAllTypes message = TestAllTypes.newBuilder() // Pass builder for foreign message instance. @@ -146,6 +297,11 @@ public class GeneratedMessageTest extends TestCase { TestUtil.assertAllFieldsSet(message); } + public void testReflectionSettersRejectNull() throws Exception { + TestAllTypes.Builder builder = TestAllTypes.newBuilder(); + reflectionTester.assertReflectionSettersRejectNull(builder); + } + public void testReflectionRepeatedSetters() throws Exception { TestAllTypes.Builder builder = TestAllTypes.newBuilder(); reflectionTester.setAllFieldsViaReflection(builder); @@ -154,6 +310,11 @@ public class GeneratedMessageTest extends TestCase { TestUtil.assertRepeatedFieldsModified(message); } + public void testReflectionRepeatedSettersRejectNull() throws Exception { + TestAllTypes.Builder builder = TestAllTypes.newBuilder(); + reflectionTester.assertReflectionRepeatedSettersRejectNull(builder); + } + public void testReflectionDefaults() throws Exception { reflectionTester.assertClearViaReflection( TestAllTypes.getDefaultInstance()); @@ -161,6 +322,11 @@ public class GeneratedMessageTest extends TestCase { TestAllTypes.newBuilder().build()); } + public void testEnumInterface() throws Exception { + assertTrue(TestAllTypes.getDefaultInstance().getDefaultNestedEnum() + instanceof ProtocolMessageEnum); + } + // ================================================================= // Extensions. @@ -202,6 +368,11 @@ public class GeneratedMessageTest extends TestCase { TestUtil.assertAllExtensionsSet(message); } + public void testExtensionReflectionSettersRejectNull() throws Exception { + TestAllExtensions.Builder builder = TestAllExtensions.newBuilder(); + extensionsReflectionTester.assertReflectionSettersRejectNull(builder); + } + public void testExtensionReflectionRepeatedSetters() throws Exception { TestAllExtensions.Builder builder = TestAllExtensions.newBuilder(); extensionsReflectionTester.setAllFieldsViaReflection(builder); @@ -210,6 +381,13 @@ public class GeneratedMessageTest extends TestCase { TestUtil.assertRepeatedExtensionsModified(message); } + public void testExtensionReflectionRepeatedSettersRejectNull() + throws Exception { + TestAllExtensions.Builder builder = TestAllExtensions.newBuilder(); + extensionsReflectionTester.assertReflectionRepeatedSettersRejectNull( + builder); + } + public void testExtensionReflectionDefaults() throws Exception { extensionsReflectionTester.assertClearViaReflection( TestAllExtensions.getDefaultInstance()); @@ -231,6 +409,17 @@ public class GeneratedMessageTest extends TestCase { .getExtensionCount(UnittestProto.repeatedInt32Extension)); } + public void testExtensionMergeFrom() throws Exception { + TestAllExtensions original = + TestAllExtensions.newBuilder() + .setExtension(UnittestProto.optionalInt32Extension, 1).build(); + TestAllExtensions merged = + TestAllExtensions.newBuilder().mergeFrom(original).build(); + assertTrue(merged.hasExtension(UnittestProto.optionalInt32Extension)); + assertEquals( + 1, (int) merged.getExtension(UnittestProto.optionalInt32Extension)); + } + // ================================================================= // multiple_files_test @@ -266,7 +455,7 @@ public class GeneratedMessageTest extends TestCase { TestOptionalOptimizedForSize message = TestOptionalOptimizedForSize.getDefaultInstance(); assertTrue(message.isInitialized()); - + message = TestOptionalOptimizedForSize.newBuilder().setO( TestRequiredOptimizedForSize.newBuilder().buildPartial() ).buildPartial(); @@ -292,4 +481,11 @@ public class GeneratedMessageTest extends TestCase { assertTrue(builder.isInitialized()); assertTrue(builder.buildPartial().isInitialized()); } + + public void testToBuilder() throws Exception { + TestAllTypes.Builder builder = TestAllTypes.newBuilder(); + TestUtil.setAllFields(builder); + TestAllTypes message = builder.build(); + TestUtil.assertAllFieldsSet(message.toBuilder().build()); + } } diff --git a/java/src/test/java/com/google/protobuf/TestUtil.java b/java/src/test/java/com/google/protobuf/TestUtil.java index d99ab85e..2f47b714 100644 --- a/java/src/test/java/com/google/protobuf/TestUtil.java +++ b/java/src/test/java/com/google/protobuf/TestUtil.java @@ -28,17 +28,105 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// Note: This file contains many lines over 80 characters. It even contains -// many lines over 100 characters, which fails a presubmit test. However, -// given the extremely repetitive nature of the file, I (kenton) feel that -// having similar components of each statement line up is more important than -// avoiding horizontal scrolling. So, I am bypassing the presubmit check. - package com.google.protobuf; import protobuf_unittest.UnittestProto; -import protobuf_unittest.UnittestProto.TestAllTypes; + +// The static imports are to avoid 100+ char lines. The following is roughly equivalent to +// import static protobuf_unittest.UnittestProto.*; +import static protobuf_unittest.UnittestProto.defaultInt32Extension; +import static protobuf_unittest.UnittestProto.defaultInt64Extension; +import static protobuf_unittest.UnittestProto.defaultUint32Extension; +import static protobuf_unittest.UnittestProto.defaultUint64Extension; +import static protobuf_unittest.UnittestProto.defaultSint32Extension; +import static protobuf_unittest.UnittestProto.defaultSint64Extension; +import static protobuf_unittest.UnittestProto.defaultFixed32Extension; +import static protobuf_unittest.UnittestProto.defaultFixed64Extension; +import static protobuf_unittest.UnittestProto.defaultSfixed32Extension; +import static protobuf_unittest.UnittestProto.defaultSfixed64Extension; +import static protobuf_unittest.UnittestProto.defaultFloatExtension; +import static protobuf_unittest.UnittestProto.defaultDoubleExtension; +import static protobuf_unittest.UnittestProto.defaultBoolExtension; +import static protobuf_unittest.UnittestProto.defaultStringExtension; +import static protobuf_unittest.UnittestProto.defaultBytesExtension; +import static protobuf_unittest.UnittestProto.defaultNestedEnumExtension; +import static protobuf_unittest.UnittestProto.defaultForeignEnumExtension; +import static protobuf_unittest.UnittestProto.defaultImportEnumExtension; +import static protobuf_unittest.UnittestProto.defaultStringPieceExtension; +import static protobuf_unittest.UnittestProto.defaultCordExtension; + +import static protobuf_unittest.UnittestProto.optionalInt32Extension; +import static protobuf_unittest.UnittestProto.optionalInt64Extension; +import static protobuf_unittest.UnittestProto.optionalUint32Extension; +import static protobuf_unittest.UnittestProto.optionalUint64Extension; +import static protobuf_unittest.UnittestProto.optionalSint32Extension; +import static protobuf_unittest.UnittestProto.optionalSint64Extension; +import static protobuf_unittest.UnittestProto.optionalFixed32Extension; +import static protobuf_unittest.UnittestProto.optionalFixed64Extension; +import static protobuf_unittest.UnittestProto.optionalSfixed32Extension; +import static protobuf_unittest.UnittestProto.optionalSfixed64Extension; +import static protobuf_unittest.UnittestProto.optionalFloatExtension; +import static protobuf_unittest.UnittestProto.optionalDoubleExtension; +import static protobuf_unittest.UnittestProto.optionalBoolExtension; +import static protobuf_unittest.UnittestProto.optionalStringExtension; +import static protobuf_unittest.UnittestProto.optionalBytesExtension; +import static protobuf_unittest.UnittestProto.optionalGroupExtension; +import static protobuf_unittest.UnittestProto.optionalNestedMessageExtension; +import static protobuf_unittest.UnittestProto.optionalForeignMessageExtension; +import static protobuf_unittest.UnittestProto.optionalImportMessageExtension; +import static protobuf_unittest.UnittestProto.optionalNestedEnumExtension; +import static protobuf_unittest.UnittestProto.optionalForeignEnumExtension; +import static protobuf_unittest.UnittestProto.optionalImportEnumExtension; +import static protobuf_unittest.UnittestProto.optionalStringPieceExtension; +import static protobuf_unittest.UnittestProto.optionalCordExtension; + +import static protobuf_unittest.UnittestProto.repeatedInt32Extension; +import static protobuf_unittest.UnittestProto.repeatedInt64Extension; +import static protobuf_unittest.UnittestProto.repeatedUint32Extension; +import static protobuf_unittest.UnittestProto.repeatedUint64Extension; +import static protobuf_unittest.UnittestProto.repeatedSint32Extension; +import static protobuf_unittest.UnittestProto.repeatedSint64Extension; +import static protobuf_unittest.UnittestProto.repeatedFixed32Extension; +import static protobuf_unittest.UnittestProto.repeatedFixed64Extension; +import static protobuf_unittest.UnittestProto.repeatedSfixed32Extension; +import static protobuf_unittest.UnittestProto.repeatedSfixed64Extension; +import static protobuf_unittest.UnittestProto.repeatedFloatExtension; +import static protobuf_unittest.UnittestProto.repeatedDoubleExtension; +import static protobuf_unittest.UnittestProto.repeatedBoolExtension; +import static protobuf_unittest.UnittestProto.repeatedStringExtension; +import static protobuf_unittest.UnittestProto.repeatedBytesExtension; +import static protobuf_unittest.UnittestProto.repeatedGroupExtension; +import static protobuf_unittest.UnittestProto.repeatedNestedMessageExtension; +import static protobuf_unittest.UnittestProto.repeatedForeignMessageExtension; +import static protobuf_unittest.UnittestProto.repeatedImportMessageExtension; +import static protobuf_unittest.UnittestProto.repeatedNestedEnumExtension; +import static protobuf_unittest.UnittestProto.repeatedForeignEnumExtension; +import static protobuf_unittest.UnittestProto.repeatedImportEnumExtension; +import static protobuf_unittest.UnittestProto.repeatedStringPieceExtension; +import static protobuf_unittest.UnittestProto.repeatedCordExtension; + +import static protobuf_unittest.UnittestProto.OptionalGroup_extension; +import static protobuf_unittest.UnittestProto.RepeatedGroup_extension; + +import static protobuf_unittest.UnittestProto.packedInt32Extension; +import static protobuf_unittest.UnittestProto.packedInt64Extension; +import static protobuf_unittest.UnittestProto.packedUint32Extension; +import static protobuf_unittest.UnittestProto.packedUint64Extension; +import static protobuf_unittest.UnittestProto.packedSint32Extension; +import static protobuf_unittest.UnittestProto.packedSint64Extension; +import static protobuf_unittest.UnittestProto.packedFixed32Extension; +import static protobuf_unittest.UnittestProto.packedFixed64Extension; +import static protobuf_unittest.UnittestProto.packedSfixed32Extension; +import static protobuf_unittest.UnittestProto.packedSfixed64Extension; +import static protobuf_unittest.UnittestProto.packedFloatExtension; +import static protobuf_unittest.UnittestProto.packedDoubleExtension; +import static protobuf_unittest.UnittestProto.packedBoolExtension; +import static protobuf_unittest.UnittestProto.packedEnumExtension; + import protobuf_unittest.UnittestProto.TestAllExtensions; +import protobuf_unittest.UnittestProto.TestAllTypes; +import protobuf_unittest.UnittestProto.TestPackedExtensions; +import protobuf_unittest.UnittestProto.TestPackedTypes; import protobuf_unittest.UnittestProto.ForeignMessage; import protobuf_unittest.UnittestProto.ForeignEnum; import com.google.protobuf.test.UnittestImport.ImportMessage; @@ -63,7 +151,7 @@ class TestUtil { private TestUtil() {} /** Helper to convert a String to ByteString. */ - private static ByteString toBytes(String str) { + static ByteString toBytes(String str) { try { return ByteString.copyFrom(str.getBytes("UTF-8")); } catch(java.io.UnsupportedEncodingException e) { @@ -91,6 +179,18 @@ class TestUtil { return builder.build(); } + public static TestPackedTypes getPackedSet() { + TestPackedTypes.Builder builder = TestPackedTypes.newBuilder(); + setPackedFields(builder); + return builder.build(); + } + + public static TestPackedExtensions getPackedExtensionsSet() { + TestPackedExtensions.Builder builder = TestPackedExtensions.newBuilder(); + setPackedExtensions(builder); + return builder.build(); + } + /** * Set every field of {@code message} to the values expected by * {@code assertAllFieldsSet()}. @@ -770,141 +870,129 @@ class TestUtil { * {@code assertAllExtensionsSet()}. */ public static void setAllExtensions(TestAllExtensions.Builder message) { - message.setExtension(UnittestProto.optionalInt32Extension , 101); - message.setExtension(UnittestProto.optionalInt64Extension , 102L); - message.setExtension(UnittestProto.optionalUint32Extension , 103); - message.setExtension(UnittestProto.optionalUint64Extension , 104L); - message.setExtension(UnittestProto.optionalSint32Extension , 105); - message.setExtension(UnittestProto.optionalSint64Extension , 106L); - message.setExtension(UnittestProto.optionalFixed32Extension , 107); - message.setExtension(UnittestProto.optionalFixed64Extension , 108L); - message.setExtension(UnittestProto.optionalSfixed32Extension, 109); - message.setExtension(UnittestProto.optionalSfixed64Extension, 110L); - message.setExtension(UnittestProto.optionalFloatExtension , 111F); - message.setExtension(UnittestProto.optionalDoubleExtension , 112D); - message.setExtension(UnittestProto.optionalBoolExtension , true); - message.setExtension(UnittestProto.optionalStringExtension , "115"); - message.setExtension(UnittestProto.optionalBytesExtension , toBytes("116")); - - message.setExtension(UnittestProto.optionalGroupExtension, - UnittestProto.OptionalGroup_extension.newBuilder().setA(117).build()); - message.setExtension(UnittestProto.optionalNestedMessageExtension, + message.setExtension(optionalInt32Extension , 101); + message.setExtension(optionalInt64Extension , 102L); + message.setExtension(optionalUint32Extension , 103); + message.setExtension(optionalUint64Extension , 104L); + message.setExtension(optionalSint32Extension , 105); + message.setExtension(optionalSint64Extension , 106L); + message.setExtension(optionalFixed32Extension , 107); + message.setExtension(optionalFixed64Extension , 108L); + message.setExtension(optionalSfixed32Extension, 109); + message.setExtension(optionalSfixed64Extension, 110L); + message.setExtension(optionalFloatExtension , 111F); + message.setExtension(optionalDoubleExtension , 112D); + message.setExtension(optionalBoolExtension , true); + message.setExtension(optionalStringExtension , "115"); + message.setExtension(optionalBytesExtension , toBytes("116")); + + message.setExtension(optionalGroupExtension, + OptionalGroup_extension.newBuilder().setA(117).build()); + message.setExtension(optionalNestedMessageExtension, TestAllTypes.NestedMessage.newBuilder().setBb(118).build()); - message.setExtension(UnittestProto.optionalForeignMessageExtension, + message.setExtension(optionalForeignMessageExtension, ForeignMessage.newBuilder().setC(119).build()); - message.setExtension(UnittestProto.optionalImportMessageExtension, + message.setExtension(optionalImportMessageExtension, ImportMessage.newBuilder().setD(120).build()); - message.setExtension(UnittestProto.optionalNestedEnumExtension, - TestAllTypes.NestedEnum.BAZ); - message.setExtension(UnittestProto.optionalForeignEnumExtension, - ForeignEnum.FOREIGN_BAZ); - message.setExtension(UnittestProto.optionalImportEnumExtension, - ImportEnum.IMPORT_BAZ); + message.setExtension(optionalNestedEnumExtension, TestAllTypes.NestedEnum.BAZ); + message.setExtension(optionalForeignEnumExtension, ForeignEnum.FOREIGN_BAZ); + message.setExtension(optionalImportEnumExtension, ImportEnum.IMPORT_BAZ); - message.setExtension(UnittestProto.optionalStringPieceExtension, "124"); - message.setExtension(UnittestProto.optionalCordExtension, "125"); + message.setExtension(optionalStringPieceExtension, "124"); + message.setExtension(optionalCordExtension, "125"); // ----------------------------------------------------------------- - message.addExtension(UnittestProto.repeatedInt32Extension , 201); - message.addExtension(UnittestProto.repeatedInt64Extension , 202L); - message.addExtension(UnittestProto.repeatedUint32Extension , 203); - message.addExtension(UnittestProto.repeatedUint64Extension , 204L); - message.addExtension(UnittestProto.repeatedSint32Extension , 205); - message.addExtension(UnittestProto.repeatedSint64Extension , 206L); - message.addExtension(UnittestProto.repeatedFixed32Extension , 207); - message.addExtension(UnittestProto.repeatedFixed64Extension , 208L); - message.addExtension(UnittestProto.repeatedSfixed32Extension, 209); - message.addExtension(UnittestProto.repeatedSfixed64Extension, 210L); - message.addExtension(UnittestProto.repeatedFloatExtension , 211F); - message.addExtension(UnittestProto.repeatedDoubleExtension , 212D); - message.addExtension(UnittestProto.repeatedBoolExtension , true); - message.addExtension(UnittestProto.repeatedStringExtension , "215"); - message.addExtension(UnittestProto.repeatedBytesExtension , toBytes("216")); - - message.addExtension(UnittestProto.repeatedGroupExtension, - UnittestProto.RepeatedGroup_extension.newBuilder().setA(217).build()); - message.addExtension(UnittestProto.repeatedNestedMessageExtension, + message.addExtension(repeatedInt32Extension , 201); + message.addExtension(repeatedInt64Extension , 202L); + message.addExtension(repeatedUint32Extension , 203); + message.addExtension(repeatedUint64Extension , 204L); + message.addExtension(repeatedSint32Extension , 205); + message.addExtension(repeatedSint64Extension , 206L); + message.addExtension(repeatedFixed32Extension , 207); + message.addExtension(repeatedFixed64Extension , 208L); + message.addExtension(repeatedSfixed32Extension, 209); + message.addExtension(repeatedSfixed64Extension, 210L); + message.addExtension(repeatedFloatExtension , 211F); + message.addExtension(repeatedDoubleExtension , 212D); + message.addExtension(repeatedBoolExtension , true); + message.addExtension(repeatedStringExtension , "215"); + message.addExtension(repeatedBytesExtension , toBytes("216")); + + message.addExtension(repeatedGroupExtension, + RepeatedGroup_extension.newBuilder().setA(217).build()); + message.addExtension(repeatedNestedMessageExtension, TestAllTypes.NestedMessage.newBuilder().setBb(218).build()); - message.addExtension(UnittestProto.repeatedForeignMessageExtension, + message.addExtension(repeatedForeignMessageExtension, ForeignMessage.newBuilder().setC(219).build()); - message.addExtension(UnittestProto.repeatedImportMessageExtension, + message.addExtension(repeatedImportMessageExtension, ImportMessage.newBuilder().setD(220).build()); - message.addExtension(UnittestProto.repeatedNestedEnumExtension, - TestAllTypes.NestedEnum.BAR); - message.addExtension(UnittestProto.repeatedForeignEnumExtension, - ForeignEnum.FOREIGN_BAR); - message.addExtension(UnittestProto.repeatedImportEnumExtension, - ImportEnum.IMPORT_BAR); + message.addExtension(repeatedNestedEnumExtension, TestAllTypes.NestedEnum.BAR); + message.addExtension(repeatedForeignEnumExtension, ForeignEnum.FOREIGN_BAR); + message.addExtension(repeatedImportEnumExtension, ImportEnum.IMPORT_BAR); - message.addExtension(UnittestProto.repeatedStringPieceExtension, "224"); - message.addExtension(UnittestProto.repeatedCordExtension, "225"); + message.addExtension(repeatedStringPieceExtension, "224"); + message.addExtension(repeatedCordExtension, "225"); // Add a second one of each field. - message.addExtension(UnittestProto.repeatedInt32Extension , 301); - message.addExtension(UnittestProto.repeatedInt64Extension , 302L); - message.addExtension(UnittestProto.repeatedUint32Extension , 303); - message.addExtension(UnittestProto.repeatedUint64Extension , 304L); - message.addExtension(UnittestProto.repeatedSint32Extension , 305); - message.addExtension(UnittestProto.repeatedSint64Extension , 306L); - message.addExtension(UnittestProto.repeatedFixed32Extension , 307); - message.addExtension(UnittestProto.repeatedFixed64Extension , 308L); - message.addExtension(UnittestProto.repeatedSfixed32Extension, 309); - message.addExtension(UnittestProto.repeatedSfixed64Extension, 310L); - message.addExtension(UnittestProto.repeatedFloatExtension , 311F); - message.addExtension(UnittestProto.repeatedDoubleExtension , 312D); - message.addExtension(UnittestProto.repeatedBoolExtension , false); - message.addExtension(UnittestProto.repeatedStringExtension , "315"); - message.addExtension(UnittestProto.repeatedBytesExtension , toBytes("316")); - - message.addExtension(UnittestProto.repeatedGroupExtension, - UnittestProto.RepeatedGroup_extension.newBuilder().setA(317).build()); - message.addExtension(UnittestProto.repeatedNestedMessageExtension, + message.addExtension(repeatedInt32Extension , 301); + message.addExtension(repeatedInt64Extension , 302L); + message.addExtension(repeatedUint32Extension , 303); + message.addExtension(repeatedUint64Extension , 304L); + message.addExtension(repeatedSint32Extension , 305); + message.addExtension(repeatedSint64Extension , 306L); + message.addExtension(repeatedFixed32Extension , 307); + message.addExtension(repeatedFixed64Extension , 308L); + message.addExtension(repeatedSfixed32Extension, 309); + message.addExtension(repeatedSfixed64Extension, 310L); + message.addExtension(repeatedFloatExtension , 311F); + message.addExtension(repeatedDoubleExtension , 312D); + message.addExtension(repeatedBoolExtension , false); + message.addExtension(repeatedStringExtension , "315"); + message.addExtension(repeatedBytesExtension , toBytes("316")); + + message.addExtension(repeatedGroupExtension, + RepeatedGroup_extension.newBuilder().setA(317).build()); + message.addExtension(repeatedNestedMessageExtension, TestAllTypes.NestedMessage.newBuilder().setBb(318).build()); - message.addExtension(UnittestProto.repeatedForeignMessageExtension, + message.addExtension(repeatedForeignMessageExtension, ForeignMessage.newBuilder().setC(319).build()); - message.addExtension(UnittestProto.repeatedImportMessageExtension, + message.addExtension(repeatedImportMessageExtension, ImportMessage.newBuilder().setD(320).build()); - message.addExtension(UnittestProto.repeatedNestedEnumExtension, - TestAllTypes.NestedEnum.BAZ); - message.addExtension(UnittestProto.repeatedForeignEnumExtension, - ForeignEnum.FOREIGN_BAZ); - message.addExtension(UnittestProto.repeatedImportEnumExtension, - ImportEnum.IMPORT_BAZ); + message.addExtension(repeatedNestedEnumExtension, TestAllTypes.NestedEnum.BAZ); + message.addExtension(repeatedForeignEnumExtension, ForeignEnum.FOREIGN_BAZ); + message.addExtension(repeatedImportEnumExtension, ImportEnum.IMPORT_BAZ); - message.addExtension(UnittestProto.repeatedStringPieceExtension, "324"); - message.addExtension(UnittestProto.repeatedCordExtension, "325"); + message.addExtension(repeatedStringPieceExtension, "324"); + message.addExtension(repeatedCordExtension, "325"); // ----------------------------------------------------------------- - message.setExtension(UnittestProto.defaultInt32Extension , 401); - message.setExtension(UnittestProto.defaultInt64Extension , 402L); - message.setExtension(UnittestProto.defaultUint32Extension , 403); - message.setExtension(UnittestProto.defaultUint64Extension , 404L); - message.setExtension(UnittestProto.defaultSint32Extension , 405); - message.setExtension(UnittestProto.defaultSint64Extension , 406L); - message.setExtension(UnittestProto.defaultFixed32Extension , 407); - message.setExtension(UnittestProto.defaultFixed64Extension , 408L); - message.setExtension(UnittestProto.defaultSfixed32Extension, 409); - message.setExtension(UnittestProto.defaultSfixed64Extension, 410L); - message.setExtension(UnittestProto.defaultFloatExtension , 411F); - message.setExtension(UnittestProto.defaultDoubleExtension , 412D); - message.setExtension(UnittestProto.defaultBoolExtension , false); - message.setExtension(UnittestProto.defaultStringExtension , "415"); - message.setExtension(UnittestProto.defaultBytesExtension , toBytes("416")); - - message.setExtension(UnittestProto.defaultNestedEnumExtension, - TestAllTypes.NestedEnum.FOO); - message.setExtension(UnittestProto.defaultForeignEnumExtension, - ForeignEnum.FOREIGN_FOO); - message.setExtension(UnittestProto.defaultImportEnumExtension, - ImportEnum.IMPORT_FOO); - - message.setExtension(UnittestProto.defaultStringPieceExtension, "424"); - message.setExtension(UnittestProto.defaultCordExtension, "425"); + message.setExtension(defaultInt32Extension , 401); + message.setExtension(defaultInt64Extension , 402L); + message.setExtension(defaultUint32Extension , 403); + message.setExtension(defaultUint64Extension , 404L); + message.setExtension(defaultSint32Extension , 405); + message.setExtension(defaultSint64Extension , 406L); + message.setExtension(defaultFixed32Extension , 407); + message.setExtension(defaultFixed64Extension , 408L); + message.setExtension(defaultSfixed32Extension, 409); + message.setExtension(defaultSfixed64Extension, 410L); + message.setExtension(defaultFloatExtension , 411F); + message.setExtension(defaultDoubleExtension , 412D); + message.setExtension(defaultBoolExtension , false); + message.setExtension(defaultStringExtension , "415"); + message.setExtension(defaultBytesExtension , toBytes("416")); + + message.setExtension(defaultNestedEnumExtension, TestAllTypes.NestedEnum.FOO); + message.setExtension(defaultForeignEnumExtension, ForeignEnum.FOREIGN_FOO); + message.setExtension(defaultImportEnumExtension, ImportEnum.IMPORT_FOO); + + message.setExtension(defaultStringPieceExtension, "424"); + message.setExtension(defaultCordExtension, "425"); } // ------------------------------------------------------------------- @@ -915,40 +1003,37 @@ class TestUtil { */ public static void modifyRepeatedExtensions( TestAllExtensions.Builder message) { - message.setExtension(UnittestProto.repeatedInt32Extension , 1, 501); - message.setExtension(UnittestProto.repeatedInt64Extension , 1, 502L); - message.setExtension(UnittestProto.repeatedUint32Extension , 1, 503); - message.setExtension(UnittestProto.repeatedUint64Extension , 1, 504L); - message.setExtension(UnittestProto.repeatedSint32Extension , 1, 505); - message.setExtension(UnittestProto.repeatedSint64Extension , 1, 506L); - message.setExtension(UnittestProto.repeatedFixed32Extension , 1, 507); - message.setExtension(UnittestProto.repeatedFixed64Extension , 1, 508L); - message.setExtension(UnittestProto.repeatedSfixed32Extension, 1, 509); - message.setExtension(UnittestProto.repeatedSfixed64Extension, 1, 510L); - message.setExtension(UnittestProto.repeatedFloatExtension , 1, 511F); - message.setExtension(UnittestProto.repeatedDoubleExtension , 1, 512D); - message.setExtension(UnittestProto.repeatedBoolExtension , 1, true); - message.setExtension(UnittestProto.repeatedStringExtension , 1, "515"); - message.setExtension(UnittestProto.repeatedBytesExtension , 1, toBytes("516")); - - message.setExtension(UnittestProto.repeatedGroupExtension, 1, - UnittestProto.RepeatedGroup_extension.newBuilder().setA(517).build()); - message.setExtension(UnittestProto.repeatedNestedMessageExtension, 1, + message.setExtension(repeatedInt32Extension , 1, 501); + message.setExtension(repeatedInt64Extension , 1, 502L); + message.setExtension(repeatedUint32Extension , 1, 503); + message.setExtension(repeatedUint64Extension , 1, 504L); + message.setExtension(repeatedSint32Extension , 1, 505); + message.setExtension(repeatedSint64Extension , 1, 506L); + message.setExtension(repeatedFixed32Extension , 1, 507); + message.setExtension(repeatedFixed64Extension , 1, 508L); + message.setExtension(repeatedSfixed32Extension, 1, 509); + message.setExtension(repeatedSfixed64Extension, 1, 510L); + message.setExtension(repeatedFloatExtension , 1, 511F); + message.setExtension(repeatedDoubleExtension , 1, 512D); + message.setExtension(repeatedBoolExtension , 1, true); + message.setExtension(repeatedStringExtension , 1, "515"); + message.setExtension(repeatedBytesExtension , 1, toBytes("516")); + + message.setExtension(repeatedGroupExtension, 1, + RepeatedGroup_extension.newBuilder().setA(517).build()); + message.setExtension(repeatedNestedMessageExtension, 1, TestAllTypes.NestedMessage.newBuilder().setBb(518).build()); - message.setExtension(UnittestProto.repeatedForeignMessageExtension, 1, + message.setExtension(repeatedForeignMessageExtension, 1, ForeignMessage.newBuilder().setC(519).build()); - message.setExtension(UnittestProto.repeatedImportMessageExtension, 1, + message.setExtension(repeatedImportMessageExtension, 1, ImportMessage.newBuilder().setD(520).build()); - message.setExtension(UnittestProto.repeatedNestedEnumExtension , 1, - TestAllTypes.NestedEnum.FOO); - message.setExtension(UnittestProto.repeatedForeignEnumExtension, 1, - ForeignEnum.FOREIGN_FOO); - message.setExtension(UnittestProto.repeatedImportEnumExtension , 1, - ImportEnum.IMPORT_FOO); + message.setExtension(repeatedNestedEnumExtension , 1, TestAllTypes.NestedEnum.FOO); + message.setExtension(repeatedForeignEnumExtension, 1, ForeignEnum.FOREIGN_FOO); + message.setExtension(repeatedImportEnumExtension , 1, ImportEnum.IMPORT_FOO); - message.setExtension(UnittestProto.repeatedStringPieceExtension, 1, "524"); - message.setExtension(UnittestProto.repeatedCordExtension, 1, "525"); + message.setExtension(repeatedStringPieceExtension, 1, "524"); + message.setExtension(repeatedCordExtension, 1, "525"); } // ------------------------------------------------------------------- @@ -958,211 +1043,211 @@ class TestUtil { * {@code message} are set to the values assigned by {@code setAllExtensions}. */ public static void assertAllExtensionsSet(TestAllExtensions message) { - Assert.assertTrue(message.hasExtension(UnittestProto.optionalInt32Extension )); - Assert.assertTrue(message.hasExtension(UnittestProto.optionalInt64Extension )); - Assert.assertTrue(message.hasExtension(UnittestProto.optionalUint32Extension )); - Assert.assertTrue(message.hasExtension(UnittestProto.optionalUint64Extension )); - Assert.assertTrue(message.hasExtension(UnittestProto.optionalSint32Extension )); - Assert.assertTrue(message.hasExtension(UnittestProto.optionalSint64Extension )); - Assert.assertTrue(message.hasExtension(UnittestProto.optionalFixed32Extension )); - Assert.assertTrue(message.hasExtension(UnittestProto.optionalFixed64Extension )); - Assert.assertTrue(message.hasExtension(UnittestProto.optionalSfixed32Extension)); - Assert.assertTrue(message.hasExtension(UnittestProto.optionalSfixed64Extension)); - Assert.assertTrue(message.hasExtension(UnittestProto.optionalFloatExtension )); - Assert.assertTrue(message.hasExtension(UnittestProto.optionalDoubleExtension )); - Assert.assertTrue(message.hasExtension(UnittestProto.optionalBoolExtension )); - Assert.assertTrue(message.hasExtension(UnittestProto.optionalStringExtension )); - Assert.assertTrue(message.hasExtension(UnittestProto.optionalBytesExtension )); - - Assert.assertTrue(message.hasExtension(UnittestProto.optionalGroupExtension )); - Assert.assertTrue(message.hasExtension(UnittestProto.optionalNestedMessageExtension )); - Assert.assertTrue(message.hasExtension(UnittestProto.optionalForeignMessageExtension)); - Assert.assertTrue(message.hasExtension(UnittestProto.optionalImportMessageExtension )); - - Assert.assertTrue(message.getExtension(UnittestProto.optionalGroupExtension ).hasA()); - Assert.assertTrue(message.getExtension(UnittestProto.optionalNestedMessageExtension ).hasBb()); - Assert.assertTrue(message.getExtension(UnittestProto.optionalForeignMessageExtension).hasC()); - Assert.assertTrue(message.getExtension(UnittestProto.optionalImportMessageExtension ).hasD()); - - Assert.assertTrue(message.hasExtension(UnittestProto.optionalNestedEnumExtension )); - Assert.assertTrue(message.hasExtension(UnittestProto.optionalForeignEnumExtension)); - Assert.assertTrue(message.hasExtension(UnittestProto.optionalImportEnumExtension )); - - Assert.assertTrue(message.hasExtension(UnittestProto.optionalStringPieceExtension)); - Assert.assertTrue(message.hasExtension(UnittestProto.optionalCordExtension)); - - assertEqualsExactType(101 , message.getExtension(UnittestProto.optionalInt32Extension )); - assertEqualsExactType(102L , message.getExtension(UnittestProto.optionalInt64Extension )); - assertEqualsExactType(103 , message.getExtension(UnittestProto.optionalUint32Extension )); - assertEqualsExactType(104L , message.getExtension(UnittestProto.optionalUint64Extension )); - assertEqualsExactType(105 , message.getExtension(UnittestProto.optionalSint32Extension )); - assertEqualsExactType(106L , message.getExtension(UnittestProto.optionalSint64Extension )); - assertEqualsExactType(107 , message.getExtension(UnittestProto.optionalFixed32Extension )); - assertEqualsExactType(108L , message.getExtension(UnittestProto.optionalFixed64Extension )); - assertEqualsExactType(109 , message.getExtension(UnittestProto.optionalSfixed32Extension)); - assertEqualsExactType(110L , message.getExtension(UnittestProto.optionalSfixed64Extension)); - assertEqualsExactType(111F , message.getExtension(UnittestProto.optionalFloatExtension )); - assertEqualsExactType(112D , message.getExtension(UnittestProto.optionalDoubleExtension )); - assertEqualsExactType(true , message.getExtension(UnittestProto.optionalBoolExtension )); - assertEqualsExactType("115", message.getExtension(UnittestProto.optionalStringExtension )); - assertEqualsExactType(toBytes("116"), message.getExtension(UnittestProto.optionalBytesExtension)); - - assertEqualsExactType(117, message.getExtension(UnittestProto.optionalGroupExtension ).getA()); - assertEqualsExactType(118, message.getExtension(UnittestProto.optionalNestedMessageExtension ).getBb()); - assertEqualsExactType(119, message.getExtension(UnittestProto.optionalForeignMessageExtension).getC()); - assertEqualsExactType(120, message.getExtension(UnittestProto.optionalImportMessageExtension ).getD()); + Assert.assertTrue(message.hasExtension(optionalInt32Extension )); + Assert.assertTrue(message.hasExtension(optionalInt64Extension )); + Assert.assertTrue(message.hasExtension(optionalUint32Extension )); + Assert.assertTrue(message.hasExtension(optionalUint64Extension )); + Assert.assertTrue(message.hasExtension(optionalSint32Extension )); + Assert.assertTrue(message.hasExtension(optionalSint64Extension )); + Assert.assertTrue(message.hasExtension(optionalFixed32Extension )); + Assert.assertTrue(message.hasExtension(optionalFixed64Extension )); + Assert.assertTrue(message.hasExtension(optionalSfixed32Extension)); + Assert.assertTrue(message.hasExtension(optionalSfixed64Extension)); + Assert.assertTrue(message.hasExtension(optionalFloatExtension )); + Assert.assertTrue(message.hasExtension(optionalDoubleExtension )); + Assert.assertTrue(message.hasExtension(optionalBoolExtension )); + Assert.assertTrue(message.hasExtension(optionalStringExtension )); + Assert.assertTrue(message.hasExtension(optionalBytesExtension )); + + Assert.assertTrue(message.hasExtension(optionalGroupExtension )); + Assert.assertTrue(message.hasExtension(optionalNestedMessageExtension )); + Assert.assertTrue(message.hasExtension(optionalForeignMessageExtension)); + Assert.assertTrue(message.hasExtension(optionalImportMessageExtension )); + + Assert.assertTrue(message.getExtension(optionalGroupExtension ).hasA()); + Assert.assertTrue(message.getExtension(optionalNestedMessageExtension ).hasBb()); + Assert.assertTrue(message.getExtension(optionalForeignMessageExtension).hasC()); + Assert.assertTrue(message.getExtension(optionalImportMessageExtension ).hasD()); + + Assert.assertTrue(message.hasExtension(optionalNestedEnumExtension )); + Assert.assertTrue(message.hasExtension(optionalForeignEnumExtension)); + Assert.assertTrue(message.hasExtension(optionalImportEnumExtension )); + + Assert.assertTrue(message.hasExtension(optionalStringPieceExtension)); + Assert.assertTrue(message.hasExtension(optionalCordExtension)); + + assertEqualsExactType(101 , message.getExtension(optionalInt32Extension )); + assertEqualsExactType(102L , message.getExtension(optionalInt64Extension )); + assertEqualsExactType(103 , message.getExtension(optionalUint32Extension )); + assertEqualsExactType(104L , message.getExtension(optionalUint64Extension )); + assertEqualsExactType(105 , message.getExtension(optionalSint32Extension )); + assertEqualsExactType(106L , message.getExtension(optionalSint64Extension )); + assertEqualsExactType(107 , message.getExtension(optionalFixed32Extension )); + assertEqualsExactType(108L , message.getExtension(optionalFixed64Extension )); + assertEqualsExactType(109 , message.getExtension(optionalSfixed32Extension)); + assertEqualsExactType(110L , message.getExtension(optionalSfixed64Extension)); + assertEqualsExactType(111F , message.getExtension(optionalFloatExtension )); + assertEqualsExactType(112D , message.getExtension(optionalDoubleExtension )); + assertEqualsExactType(true , message.getExtension(optionalBoolExtension )); + assertEqualsExactType("115", message.getExtension(optionalStringExtension )); + assertEqualsExactType(toBytes("116"), message.getExtension(optionalBytesExtension)); + + assertEqualsExactType(117, message.getExtension(optionalGroupExtension ).getA()); + assertEqualsExactType(118, message.getExtension(optionalNestedMessageExtension ).getBb()); + assertEqualsExactType(119, message.getExtension(optionalForeignMessageExtension).getC()); + assertEqualsExactType(120, message.getExtension(optionalImportMessageExtension ).getD()); assertEqualsExactType(TestAllTypes.NestedEnum.BAZ, - message.getExtension(UnittestProto.optionalNestedEnumExtension)); + message.getExtension(optionalNestedEnumExtension)); assertEqualsExactType(ForeignEnum.FOREIGN_BAZ, - message.getExtension(UnittestProto.optionalForeignEnumExtension)); + message.getExtension(optionalForeignEnumExtension)); assertEqualsExactType(ImportEnum.IMPORT_BAZ, - message.getExtension(UnittestProto.optionalImportEnumExtension)); + message.getExtension(optionalImportEnumExtension)); - assertEqualsExactType("124", message.getExtension(UnittestProto.optionalStringPieceExtension)); - assertEqualsExactType("125", message.getExtension(UnittestProto.optionalCordExtension)); + assertEqualsExactType("124", message.getExtension(optionalStringPieceExtension)); + assertEqualsExactType("125", message.getExtension(optionalCordExtension)); // ----------------------------------------------------------------- - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedInt32Extension )); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedInt64Extension )); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedUint32Extension )); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedUint64Extension )); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedSint32Extension )); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedSint64Extension )); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedFixed32Extension )); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedFixed64Extension )); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedSfixed32Extension)); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedSfixed64Extension)); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedFloatExtension )); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedDoubleExtension )); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedBoolExtension )); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedStringExtension )); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedBytesExtension )); - - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedGroupExtension )); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedNestedMessageExtension )); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedForeignMessageExtension)); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedImportMessageExtension )); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedNestedEnumExtension )); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedForeignEnumExtension )); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedImportEnumExtension )); - - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedStringPieceExtension)); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedCordExtension)); - - assertEqualsExactType(201 , message.getExtension(UnittestProto.repeatedInt32Extension , 0)); - assertEqualsExactType(202L , message.getExtension(UnittestProto.repeatedInt64Extension , 0)); - assertEqualsExactType(203 , message.getExtension(UnittestProto.repeatedUint32Extension , 0)); - assertEqualsExactType(204L , message.getExtension(UnittestProto.repeatedUint64Extension , 0)); - assertEqualsExactType(205 , message.getExtension(UnittestProto.repeatedSint32Extension , 0)); - assertEqualsExactType(206L , message.getExtension(UnittestProto.repeatedSint64Extension , 0)); - assertEqualsExactType(207 , message.getExtension(UnittestProto.repeatedFixed32Extension , 0)); - assertEqualsExactType(208L , message.getExtension(UnittestProto.repeatedFixed64Extension , 0)); - assertEqualsExactType(209 , message.getExtension(UnittestProto.repeatedSfixed32Extension, 0)); - assertEqualsExactType(210L , message.getExtension(UnittestProto.repeatedSfixed64Extension, 0)); - assertEqualsExactType(211F , message.getExtension(UnittestProto.repeatedFloatExtension , 0)); - assertEqualsExactType(212D , message.getExtension(UnittestProto.repeatedDoubleExtension , 0)); - assertEqualsExactType(true , message.getExtension(UnittestProto.repeatedBoolExtension , 0)); - assertEqualsExactType("215", message.getExtension(UnittestProto.repeatedStringExtension , 0)); - assertEqualsExactType(toBytes("216"), message.getExtension(UnittestProto.repeatedBytesExtension, 0)); - - assertEqualsExactType(217, message.getExtension(UnittestProto.repeatedGroupExtension , 0).getA()); - assertEqualsExactType(218, message.getExtension(UnittestProto.repeatedNestedMessageExtension , 0).getBb()); - assertEqualsExactType(219, message.getExtension(UnittestProto.repeatedForeignMessageExtension, 0).getC()); - assertEqualsExactType(220, message.getExtension(UnittestProto.repeatedImportMessageExtension , 0).getD()); + Assert.assertEquals(2, message.getExtensionCount(repeatedInt32Extension )); + Assert.assertEquals(2, message.getExtensionCount(repeatedInt64Extension )); + Assert.assertEquals(2, message.getExtensionCount(repeatedUint32Extension )); + Assert.assertEquals(2, message.getExtensionCount(repeatedUint64Extension )); + Assert.assertEquals(2, message.getExtensionCount(repeatedSint32Extension )); + Assert.assertEquals(2, message.getExtensionCount(repeatedSint64Extension )); + Assert.assertEquals(2, message.getExtensionCount(repeatedFixed32Extension )); + Assert.assertEquals(2, message.getExtensionCount(repeatedFixed64Extension )); + Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed32Extension)); + Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed64Extension)); + Assert.assertEquals(2, message.getExtensionCount(repeatedFloatExtension )); + Assert.assertEquals(2, message.getExtensionCount(repeatedDoubleExtension )); + Assert.assertEquals(2, message.getExtensionCount(repeatedBoolExtension )); + Assert.assertEquals(2, message.getExtensionCount(repeatedStringExtension )); + Assert.assertEquals(2, message.getExtensionCount(repeatedBytesExtension )); + + Assert.assertEquals(2, message.getExtensionCount(repeatedGroupExtension )); + Assert.assertEquals(2, message.getExtensionCount(repeatedNestedMessageExtension )); + Assert.assertEquals(2, message.getExtensionCount(repeatedForeignMessageExtension)); + Assert.assertEquals(2, message.getExtensionCount(repeatedImportMessageExtension )); + Assert.assertEquals(2, message.getExtensionCount(repeatedNestedEnumExtension )); + Assert.assertEquals(2, message.getExtensionCount(repeatedForeignEnumExtension )); + Assert.assertEquals(2, message.getExtensionCount(repeatedImportEnumExtension )); + + Assert.assertEquals(2, message.getExtensionCount(repeatedStringPieceExtension)); + Assert.assertEquals(2, message.getExtensionCount(repeatedCordExtension)); + + assertEqualsExactType(201 , message.getExtension(repeatedInt32Extension , 0)); + assertEqualsExactType(202L , message.getExtension(repeatedInt64Extension , 0)); + assertEqualsExactType(203 , message.getExtension(repeatedUint32Extension , 0)); + assertEqualsExactType(204L , message.getExtension(repeatedUint64Extension , 0)); + assertEqualsExactType(205 , message.getExtension(repeatedSint32Extension , 0)); + assertEqualsExactType(206L , message.getExtension(repeatedSint64Extension , 0)); + assertEqualsExactType(207 , message.getExtension(repeatedFixed32Extension , 0)); + assertEqualsExactType(208L , message.getExtension(repeatedFixed64Extension , 0)); + assertEqualsExactType(209 , message.getExtension(repeatedSfixed32Extension, 0)); + assertEqualsExactType(210L , message.getExtension(repeatedSfixed64Extension, 0)); + assertEqualsExactType(211F , message.getExtension(repeatedFloatExtension , 0)); + assertEqualsExactType(212D , message.getExtension(repeatedDoubleExtension , 0)); + assertEqualsExactType(true , message.getExtension(repeatedBoolExtension , 0)); + assertEqualsExactType("215", message.getExtension(repeatedStringExtension , 0)); + assertEqualsExactType(toBytes("216"), message.getExtension(repeatedBytesExtension, 0)); + + assertEqualsExactType(217, message.getExtension(repeatedGroupExtension , 0).getA()); + assertEqualsExactType(218, message.getExtension(repeatedNestedMessageExtension , 0).getBb()); + assertEqualsExactType(219, message.getExtension(repeatedForeignMessageExtension, 0).getC()); + assertEqualsExactType(220, message.getExtension(repeatedImportMessageExtension , 0).getD()); assertEqualsExactType(TestAllTypes.NestedEnum.BAR, - message.getExtension(UnittestProto.repeatedNestedEnumExtension, 0)); + message.getExtension(repeatedNestedEnumExtension, 0)); assertEqualsExactType(ForeignEnum.FOREIGN_BAR, - message.getExtension(UnittestProto.repeatedForeignEnumExtension, 0)); + message.getExtension(repeatedForeignEnumExtension, 0)); assertEqualsExactType(ImportEnum.IMPORT_BAR, - message.getExtension(UnittestProto.repeatedImportEnumExtension, 0)); - - assertEqualsExactType("224", message.getExtension(UnittestProto.repeatedStringPieceExtension, 0)); - assertEqualsExactType("225", message.getExtension(UnittestProto.repeatedCordExtension, 0)); - - assertEqualsExactType(301 , message.getExtension(UnittestProto.repeatedInt32Extension , 1)); - assertEqualsExactType(302L , message.getExtension(UnittestProto.repeatedInt64Extension , 1)); - assertEqualsExactType(303 , message.getExtension(UnittestProto.repeatedUint32Extension , 1)); - assertEqualsExactType(304L , message.getExtension(UnittestProto.repeatedUint64Extension , 1)); - assertEqualsExactType(305 , message.getExtension(UnittestProto.repeatedSint32Extension , 1)); - assertEqualsExactType(306L , message.getExtension(UnittestProto.repeatedSint64Extension , 1)); - assertEqualsExactType(307 , message.getExtension(UnittestProto.repeatedFixed32Extension , 1)); - assertEqualsExactType(308L , message.getExtension(UnittestProto.repeatedFixed64Extension , 1)); - assertEqualsExactType(309 , message.getExtension(UnittestProto.repeatedSfixed32Extension, 1)); - assertEqualsExactType(310L , message.getExtension(UnittestProto.repeatedSfixed64Extension, 1)); - assertEqualsExactType(311F , message.getExtension(UnittestProto.repeatedFloatExtension , 1)); - assertEqualsExactType(312D , message.getExtension(UnittestProto.repeatedDoubleExtension , 1)); - assertEqualsExactType(false, message.getExtension(UnittestProto.repeatedBoolExtension , 1)); - assertEqualsExactType("315", message.getExtension(UnittestProto.repeatedStringExtension , 1)); - assertEqualsExactType(toBytes("316"), message.getExtension(UnittestProto.repeatedBytesExtension, 1)); - - assertEqualsExactType(317, message.getExtension(UnittestProto.repeatedGroupExtension , 1).getA()); - assertEqualsExactType(318, message.getExtension(UnittestProto.repeatedNestedMessageExtension , 1).getBb()); - assertEqualsExactType(319, message.getExtension(UnittestProto.repeatedForeignMessageExtension, 1).getC()); - assertEqualsExactType(320, message.getExtension(UnittestProto.repeatedImportMessageExtension , 1).getD()); + message.getExtension(repeatedImportEnumExtension, 0)); + + assertEqualsExactType("224", message.getExtension(repeatedStringPieceExtension, 0)); + assertEqualsExactType("225", message.getExtension(repeatedCordExtension, 0)); + + assertEqualsExactType(301 , message.getExtension(repeatedInt32Extension , 1)); + assertEqualsExactType(302L , message.getExtension(repeatedInt64Extension , 1)); + assertEqualsExactType(303 , message.getExtension(repeatedUint32Extension , 1)); + assertEqualsExactType(304L , message.getExtension(repeatedUint64Extension , 1)); + assertEqualsExactType(305 , message.getExtension(repeatedSint32Extension , 1)); + assertEqualsExactType(306L , message.getExtension(repeatedSint64Extension , 1)); + assertEqualsExactType(307 , message.getExtension(repeatedFixed32Extension , 1)); + assertEqualsExactType(308L , message.getExtension(repeatedFixed64Extension , 1)); + assertEqualsExactType(309 , message.getExtension(repeatedSfixed32Extension, 1)); + assertEqualsExactType(310L , message.getExtension(repeatedSfixed64Extension, 1)); + assertEqualsExactType(311F , message.getExtension(repeatedFloatExtension , 1)); + assertEqualsExactType(312D , message.getExtension(repeatedDoubleExtension , 1)); + assertEqualsExactType(false, message.getExtension(repeatedBoolExtension , 1)); + assertEqualsExactType("315", message.getExtension(repeatedStringExtension , 1)); + assertEqualsExactType(toBytes("316"), message.getExtension(repeatedBytesExtension, 1)); + + assertEqualsExactType(317, message.getExtension(repeatedGroupExtension , 1).getA()); + assertEqualsExactType(318, message.getExtension(repeatedNestedMessageExtension , 1).getBb()); + assertEqualsExactType(319, message.getExtension(repeatedForeignMessageExtension, 1).getC()); + assertEqualsExactType(320, message.getExtension(repeatedImportMessageExtension , 1).getD()); assertEqualsExactType(TestAllTypes.NestedEnum.BAZ, - message.getExtension(UnittestProto.repeatedNestedEnumExtension, 1)); + message.getExtension(repeatedNestedEnumExtension, 1)); assertEqualsExactType(ForeignEnum.FOREIGN_BAZ, - message.getExtension(UnittestProto.repeatedForeignEnumExtension, 1)); + message.getExtension(repeatedForeignEnumExtension, 1)); assertEqualsExactType(ImportEnum.IMPORT_BAZ, - message.getExtension(UnittestProto.repeatedImportEnumExtension, 1)); + message.getExtension(repeatedImportEnumExtension, 1)); - assertEqualsExactType("324", message.getExtension(UnittestProto.repeatedStringPieceExtension, 1)); - assertEqualsExactType("325", message.getExtension(UnittestProto.repeatedCordExtension, 1)); + assertEqualsExactType("324", message.getExtension(repeatedStringPieceExtension, 1)); + assertEqualsExactType("325", message.getExtension(repeatedCordExtension, 1)); // ----------------------------------------------------------------- - Assert.assertTrue(message.hasExtension(UnittestProto.defaultInt32Extension )); - Assert.assertTrue(message.hasExtension(UnittestProto.defaultInt64Extension )); - Assert.assertTrue(message.hasExtension(UnittestProto.defaultUint32Extension )); - Assert.assertTrue(message.hasExtension(UnittestProto.defaultUint64Extension )); - Assert.assertTrue(message.hasExtension(UnittestProto.defaultSint32Extension )); - Assert.assertTrue(message.hasExtension(UnittestProto.defaultSint64Extension )); - Assert.assertTrue(message.hasExtension(UnittestProto.defaultFixed32Extension )); - Assert.assertTrue(message.hasExtension(UnittestProto.defaultFixed64Extension )); - Assert.assertTrue(message.hasExtension(UnittestProto.defaultSfixed32Extension)); - Assert.assertTrue(message.hasExtension(UnittestProto.defaultSfixed64Extension)); - Assert.assertTrue(message.hasExtension(UnittestProto.defaultFloatExtension )); - Assert.assertTrue(message.hasExtension(UnittestProto.defaultDoubleExtension )); - Assert.assertTrue(message.hasExtension(UnittestProto.defaultBoolExtension )); - Assert.assertTrue(message.hasExtension(UnittestProto.defaultStringExtension )); - Assert.assertTrue(message.hasExtension(UnittestProto.defaultBytesExtension )); - - Assert.assertTrue(message.hasExtension(UnittestProto.defaultNestedEnumExtension )); - Assert.assertTrue(message.hasExtension(UnittestProto.defaultForeignEnumExtension)); - Assert.assertTrue(message.hasExtension(UnittestProto.defaultImportEnumExtension )); - - Assert.assertTrue(message.hasExtension(UnittestProto.defaultStringPieceExtension)); - Assert.assertTrue(message.hasExtension(UnittestProto.defaultCordExtension)); - - assertEqualsExactType(401 , message.getExtension(UnittestProto.defaultInt32Extension )); - assertEqualsExactType(402L , message.getExtension(UnittestProto.defaultInt64Extension )); - assertEqualsExactType(403 , message.getExtension(UnittestProto.defaultUint32Extension )); - assertEqualsExactType(404L , message.getExtension(UnittestProto.defaultUint64Extension )); - assertEqualsExactType(405 , message.getExtension(UnittestProto.defaultSint32Extension )); - assertEqualsExactType(406L , message.getExtension(UnittestProto.defaultSint64Extension )); - assertEqualsExactType(407 , message.getExtension(UnittestProto.defaultFixed32Extension )); - assertEqualsExactType(408L , message.getExtension(UnittestProto.defaultFixed64Extension )); - assertEqualsExactType(409 , message.getExtension(UnittestProto.defaultSfixed32Extension)); - assertEqualsExactType(410L , message.getExtension(UnittestProto.defaultSfixed64Extension)); - assertEqualsExactType(411F , message.getExtension(UnittestProto.defaultFloatExtension )); - assertEqualsExactType(412D , message.getExtension(UnittestProto.defaultDoubleExtension )); - assertEqualsExactType(false, message.getExtension(UnittestProto.defaultBoolExtension )); - assertEqualsExactType("415", message.getExtension(UnittestProto.defaultStringExtension )); - assertEqualsExactType(toBytes("416"), message.getExtension(UnittestProto.defaultBytesExtension)); + Assert.assertTrue(message.hasExtension(defaultInt32Extension )); + Assert.assertTrue(message.hasExtension(defaultInt64Extension )); + Assert.assertTrue(message.hasExtension(defaultUint32Extension )); + Assert.assertTrue(message.hasExtension(defaultUint64Extension )); + Assert.assertTrue(message.hasExtension(defaultSint32Extension )); + Assert.assertTrue(message.hasExtension(defaultSint64Extension )); + Assert.assertTrue(message.hasExtension(defaultFixed32Extension )); + Assert.assertTrue(message.hasExtension(defaultFixed64Extension )); + Assert.assertTrue(message.hasExtension(defaultSfixed32Extension)); + Assert.assertTrue(message.hasExtension(defaultSfixed64Extension)); + Assert.assertTrue(message.hasExtension(defaultFloatExtension )); + Assert.assertTrue(message.hasExtension(defaultDoubleExtension )); + Assert.assertTrue(message.hasExtension(defaultBoolExtension )); + Assert.assertTrue(message.hasExtension(defaultStringExtension )); + Assert.assertTrue(message.hasExtension(defaultBytesExtension )); + + Assert.assertTrue(message.hasExtension(defaultNestedEnumExtension )); + Assert.assertTrue(message.hasExtension(defaultForeignEnumExtension)); + Assert.assertTrue(message.hasExtension(defaultImportEnumExtension )); + + Assert.assertTrue(message.hasExtension(defaultStringPieceExtension)); + Assert.assertTrue(message.hasExtension(defaultCordExtension)); + + assertEqualsExactType(401 , message.getExtension(defaultInt32Extension )); + assertEqualsExactType(402L , message.getExtension(defaultInt64Extension )); + assertEqualsExactType(403 , message.getExtension(defaultUint32Extension )); + assertEqualsExactType(404L , message.getExtension(defaultUint64Extension )); + assertEqualsExactType(405 , message.getExtension(defaultSint32Extension )); + assertEqualsExactType(406L , message.getExtension(defaultSint64Extension )); + assertEqualsExactType(407 , message.getExtension(defaultFixed32Extension )); + assertEqualsExactType(408L , message.getExtension(defaultFixed64Extension )); + assertEqualsExactType(409 , message.getExtension(defaultSfixed32Extension)); + assertEqualsExactType(410L , message.getExtension(defaultSfixed64Extension)); + assertEqualsExactType(411F , message.getExtension(defaultFloatExtension )); + assertEqualsExactType(412D , message.getExtension(defaultDoubleExtension )); + assertEqualsExactType(false, message.getExtension(defaultBoolExtension )); + assertEqualsExactType("415", message.getExtension(defaultStringExtension )); + assertEqualsExactType(toBytes("416"), message.getExtension(defaultBytesExtension)); assertEqualsExactType(TestAllTypes.NestedEnum.FOO, - message.getExtension(UnittestProto.defaultNestedEnumExtension )); + message.getExtension(defaultNestedEnumExtension )); assertEqualsExactType(ForeignEnum.FOREIGN_FOO, - message.getExtension(UnittestProto.defaultForeignEnumExtension)); + message.getExtension(defaultForeignEnumExtension)); assertEqualsExactType(ImportEnum.IMPORT_FOO, - message.getExtension(UnittestProto.defaultImportEnumExtension)); + message.getExtension(defaultImportEnumExtension)); - assertEqualsExactType("424", message.getExtension(UnittestProto.defaultStringPieceExtension)); - assertEqualsExactType("425", message.getExtension(UnittestProto.defaultCordExtension)); + assertEqualsExactType("424", message.getExtension(defaultStringPieceExtension)); + assertEqualsExactType("425", message.getExtension(defaultCordExtension)); } // ------------------------------------------------------------------- @@ -1174,151 +1259,151 @@ class TestUtil { */ public static void assertExtensionsClear(TestAllExtensions message) { // hasBlah() should initially be false for all optional fields. - Assert.assertFalse(message.hasExtension(UnittestProto.optionalInt32Extension )); - Assert.assertFalse(message.hasExtension(UnittestProto.optionalInt64Extension )); - Assert.assertFalse(message.hasExtension(UnittestProto.optionalUint32Extension )); - Assert.assertFalse(message.hasExtension(UnittestProto.optionalUint64Extension )); - Assert.assertFalse(message.hasExtension(UnittestProto.optionalSint32Extension )); - Assert.assertFalse(message.hasExtension(UnittestProto.optionalSint64Extension )); - Assert.assertFalse(message.hasExtension(UnittestProto.optionalFixed32Extension )); - Assert.assertFalse(message.hasExtension(UnittestProto.optionalFixed64Extension )); - Assert.assertFalse(message.hasExtension(UnittestProto.optionalSfixed32Extension)); - Assert.assertFalse(message.hasExtension(UnittestProto.optionalSfixed64Extension)); - Assert.assertFalse(message.hasExtension(UnittestProto.optionalFloatExtension )); - Assert.assertFalse(message.hasExtension(UnittestProto.optionalDoubleExtension )); - Assert.assertFalse(message.hasExtension(UnittestProto.optionalBoolExtension )); - Assert.assertFalse(message.hasExtension(UnittestProto.optionalStringExtension )); - Assert.assertFalse(message.hasExtension(UnittestProto.optionalBytesExtension )); - - Assert.assertFalse(message.hasExtension(UnittestProto.optionalGroupExtension )); - Assert.assertFalse(message.hasExtension(UnittestProto.optionalNestedMessageExtension )); - Assert.assertFalse(message.hasExtension(UnittestProto.optionalForeignMessageExtension)); - Assert.assertFalse(message.hasExtension(UnittestProto.optionalImportMessageExtension )); - - Assert.assertFalse(message.hasExtension(UnittestProto.optionalNestedEnumExtension )); - Assert.assertFalse(message.hasExtension(UnittestProto.optionalForeignEnumExtension)); - Assert.assertFalse(message.hasExtension(UnittestProto.optionalImportEnumExtension )); - - Assert.assertFalse(message.hasExtension(UnittestProto.optionalStringPieceExtension)); - Assert.assertFalse(message.hasExtension(UnittestProto.optionalCordExtension)); + Assert.assertFalse(message.hasExtension(optionalInt32Extension )); + Assert.assertFalse(message.hasExtension(optionalInt64Extension )); + Assert.assertFalse(message.hasExtension(optionalUint32Extension )); + Assert.assertFalse(message.hasExtension(optionalUint64Extension )); + Assert.assertFalse(message.hasExtension(optionalSint32Extension )); + Assert.assertFalse(message.hasExtension(optionalSint64Extension )); + Assert.assertFalse(message.hasExtension(optionalFixed32Extension )); + Assert.assertFalse(message.hasExtension(optionalFixed64Extension )); + Assert.assertFalse(message.hasExtension(optionalSfixed32Extension)); + Assert.assertFalse(message.hasExtension(optionalSfixed64Extension)); + Assert.assertFalse(message.hasExtension(optionalFloatExtension )); + Assert.assertFalse(message.hasExtension(optionalDoubleExtension )); + Assert.assertFalse(message.hasExtension(optionalBoolExtension )); + Assert.assertFalse(message.hasExtension(optionalStringExtension )); + Assert.assertFalse(message.hasExtension(optionalBytesExtension )); + + Assert.assertFalse(message.hasExtension(optionalGroupExtension )); + Assert.assertFalse(message.hasExtension(optionalNestedMessageExtension )); + Assert.assertFalse(message.hasExtension(optionalForeignMessageExtension)); + Assert.assertFalse(message.hasExtension(optionalImportMessageExtension )); + + Assert.assertFalse(message.hasExtension(optionalNestedEnumExtension )); + Assert.assertFalse(message.hasExtension(optionalForeignEnumExtension)); + Assert.assertFalse(message.hasExtension(optionalImportEnumExtension )); + + Assert.assertFalse(message.hasExtension(optionalStringPieceExtension)); + Assert.assertFalse(message.hasExtension(optionalCordExtension)); // Optional fields without defaults are set to zero or something like it. - assertEqualsExactType(0 , message.getExtension(UnittestProto.optionalInt32Extension )); - assertEqualsExactType(0L , message.getExtension(UnittestProto.optionalInt64Extension )); - assertEqualsExactType(0 , message.getExtension(UnittestProto.optionalUint32Extension )); - assertEqualsExactType(0L , message.getExtension(UnittestProto.optionalUint64Extension )); - assertEqualsExactType(0 , message.getExtension(UnittestProto.optionalSint32Extension )); - assertEqualsExactType(0L , message.getExtension(UnittestProto.optionalSint64Extension )); - assertEqualsExactType(0 , message.getExtension(UnittestProto.optionalFixed32Extension )); - assertEqualsExactType(0L , message.getExtension(UnittestProto.optionalFixed64Extension )); - assertEqualsExactType(0 , message.getExtension(UnittestProto.optionalSfixed32Extension)); - assertEqualsExactType(0L , message.getExtension(UnittestProto.optionalSfixed64Extension)); - assertEqualsExactType(0F , message.getExtension(UnittestProto.optionalFloatExtension )); - assertEqualsExactType(0D , message.getExtension(UnittestProto.optionalDoubleExtension )); - assertEqualsExactType(false, message.getExtension(UnittestProto.optionalBoolExtension )); - assertEqualsExactType("" , message.getExtension(UnittestProto.optionalStringExtension )); - assertEqualsExactType(ByteString.EMPTY, message.getExtension(UnittestProto.optionalBytesExtension)); + assertEqualsExactType(0 , message.getExtension(optionalInt32Extension )); + assertEqualsExactType(0L , message.getExtension(optionalInt64Extension )); + assertEqualsExactType(0 , message.getExtension(optionalUint32Extension )); + assertEqualsExactType(0L , message.getExtension(optionalUint64Extension )); + assertEqualsExactType(0 , message.getExtension(optionalSint32Extension )); + assertEqualsExactType(0L , message.getExtension(optionalSint64Extension )); + assertEqualsExactType(0 , message.getExtension(optionalFixed32Extension )); + assertEqualsExactType(0L , message.getExtension(optionalFixed64Extension )); + assertEqualsExactType(0 , message.getExtension(optionalSfixed32Extension)); + assertEqualsExactType(0L , message.getExtension(optionalSfixed64Extension)); + assertEqualsExactType(0F , message.getExtension(optionalFloatExtension )); + assertEqualsExactType(0D , message.getExtension(optionalDoubleExtension )); + assertEqualsExactType(false, message.getExtension(optionalBoolExtension )); + assertEqualsExactType("" , message.getExtension(optionalStringExtension )); + assertEqualsExactType(ByteString.EMPTY, message.getExtension(optionalBytesExtension)); // Embedded messages should also be clear. - Assert.assertFalse(message.getExtension(UnittestProto.optionalGroupExtension ).hasA()); - Assert.assertFalse(message.getExtension(UnittestProto.optionalNestedMessageExtension ).hasBb()); - Assert.assertFalse(message.getExtension(UnittestProto.optionalForeignMessageExtension).hasC()); - Assert.assertFalse(message.getExtension(UnittestProto.optionalImportMessageExtension ).hasD()); + Assert.assertFalse(message.getExtension(optionalGroupExtension ).hasA()); + Assert.assertFalse(message.getExtension(optionalNestedMessageExtension ).hasBb()); + Assert.assertFalse(message.getExtension(optionalForeignMessageExtension).hasC()); + Assert.assertFalse(message.getExtension(optionalImportMessageExtension ).hasD()); - assertEqualsExactType(0, message.getExtension(UnittestProto.optionalGroupExtension ).getA()); - assertEqualsExactType(0, message.getExtension(UnittestProto.optionalNestedMessageExtension ).getBb()); - assertEqualsExactType(0, message.getExtension(UnittestProto.optionalForeignMessageExtension).getC()); - assertEqualsExactType(0, message.getExtension(UnittestProto.optionalImportMessageExtension ).getD()); + assertEqualsExactType(0, message.getExtension(optionalGroupExtension ).getA()); + assertEqualsExactType(0, message.getExtension(optionalNestedMessageExtension ).getBb()); + assertEqualsExactType(0, message.getExtension(optionalForeignMessageExtension).getC()); + assertEqualsExactType(0, message.getExtension(optionalImportMessageExtension ).getD()); // Enums without defaults are set to the first value in the enum. assertEqualsExactType(TestAllTypes.NestedEnum.FOO, - message.getExtension(UnittestProto.optionalNestedEnumExtension )); + message.getExtension(optionalNestedEnumExtension )); assertEqualsExactType(ForeignEnum.FOREIGN_FOO, - message.getExtension(UnittestProto.optionalForeignEnumExtension)); + message.getExtension(optionalForeignEnumExtension)); assertEqualsExactType(ImportEnum.IMPORT_FOO, - message.getExtension(UnittestProto.optionalImportEnumExtension)); + message.getExtension(optionalImportEnumExtension)); - assertEqualsExactType("", message.getExtension(UnittestProto.optionalStringPieceExtension)); - assertEqualsExactType("", message.getExtension(UnittestProto.optionalCordExtension)); + assertEqualsExactType("", message.getExtension(optionalStringPieceExtension)); + assertEqualsExactType("", message.getExtension(optionalCordExtension)); // Repeated fields are empty. - Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedInt32Extension )); - Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedInt64Extension )); - Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedUint32Extension )); - Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedUint64Extension )); - Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedSint32Extension )); - Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedSint64Extension )); - Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedFixed32Extension )); - Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedFixed64Extension )); - Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedSfixed32Extension)); - Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedSfixed64Extension)); - Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedFloatExtension )); - Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedDoubleExtension )); - Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedBoolExtension )); - Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedStringExtension )); - Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedBytesExtension )); - - Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedGroupExtension )); - Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedNestedMessageExtension )); - Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedForeignMessageExtension)); - Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedImportMessageExtension )); - Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedNestedEnumExtension )); - Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedForeignEnumExtension )); - Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedImportEnumExtension )); - - Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedStringPieceExtension)); - Assert.assertEquals(0, message.getExtensionCount(UnittestProto.repeatedCordExtension)); + Assert.assertEquals(0, message.getExtensionCount(repeatedInt32Extension )); + Assert.assertEquals(0, message.getExtensionCount(repeatedInt64Extension )); + Assert.assertEquals(0, message.getExtensionCount(repeatedUint32Extension )); + Assert.assertEquals(0, message.getExtensionCount(repeatedUint64Extension )); + Assert.assertEquals(0, message.getExtensionCount(repeatedSint32Extension )); + Assert.assertEquals(0, message.getExtensionCount(repeatedSint64Extension )); + Assert.assertEquals(0, message.getExtensionCount(repeatedFixed32Extension )); + Assert.assertEquals(0, message.getExtensionCount(repeatedFixed64Extension )); + Assert.assertEquals(0, message.getExtensionCount(repeatedSfixed32Extension)); + Assert.assertEquals(0, message.getExtensionCount(repeatedSfixed64Extension)); + Assert.assertEquals(0, message.getExtensionCount(repeatedFloatExtension )); + Assert.assertEquals(0, message.getExtensionCount(repeatedDoubleExtension )); + Assert.assertEquals(0, message.getExtensionCount(repeatedBoolExtension )); + Assert.assertEquals(0, message.getExtensionCount(repeatedStringExtension )); + Assert.assertEquals(0, message.getExtensionCount(repeatedBytesExtension )); + + Assert.assertEquals(0, message.getExtensionCount(repeatedGroupExtension )); + Assert.assertEquals(0, message.getExtensionCount(repeatedNestedMessageExtension )); + Assert.assertEquals(0, message.getExtensionCount(repeatedForeignMessageExtension)); + Assert.assertEquals(0, message.getExtensionCount(repeatedImportMessageExtension )); + Assert.assertEquals(0, message.getExtensionCount(repeatedNestedEnumExtension )); + Assert.assertEquals(0, message.getExtensionCount(repeatedForeignEnumExtension )); + Assert.assertEquals(0, message.getExtensionCount(repeatedImportEnumExtension )); + + Assert.assertEquals(0, message.getExtensionCount(repeatedStringPieceExtension)); + Assert.assertEquals(0, message.getExtensionCount(repeatedCordExtension)); // hasBlah() should also be false for all default fields. - Assert.assertFalse(message.hasExtension(UnittestProto.defaultInt32Extension )); - Assert.assertFalse(message.hasExtension(UnittestProto.defaultInt64Extension )); - Assert.assertFalse(message.hasExtension(UnittestProto.defaultUint32Extension )); - Assert.assertFalse(message.hasExtension(UnittestProto.defaultUint64Extension )); - Assert.assertFalse(message.hasExtension(UnittestProto.defaultSint32Extension )); - Assert.assertFalse(message.hasExtension(UnittestProto.defaultSint64Extension )); - Assert.assertFalse(message.hasExtension(UnittestProto.defaultFixed32Extension )); - Assert.assertFalse(message.hasExtension(UnittestProto.defaultFixed64Extension )); - Assert.assertFalse(message.hasExtension(UnittestProto.defaultSfixed32Extension)); - Assert.assertFalse(message.hasExtension(UnittestProto.defaultSfixed64Extension)); - Assert.assertFalse(message.hasExtension(UnittestProto.defaultFloatExtension )); - Assert.assertFalse(message.hasExtension(UnittestProto.defaultDoubleExtension )); - Assert.assertFalse(message.hasExtension(UnittestProto.defaultBoolExtension )); - Assert.assertFalse(message.hasExtension(UnittestProto.defaultStringExtension )); - Assert.assertFalse(message.hasExtension(UnittestProto.defaultBytesExtension )); - - Assert.assertFalse(message.hasExtension(UnittestProto.defaultNestedEnumExtension )); - Assert.assertFalse(message.hasExtension(UnittestProto.defaultForeignEnumExtension)); - Assert.assertFalse(message.hasExtension(UnittestProto.defaultImportEnumExtension )); - - Assert.assertFalse(message.hasExtension(UnittestProto.defaultStringPieceExtension)); - Assert.assertFalse(message.hasExtension(UnittestProto.defaultCordExtension)); + Assert.assertFalse(message.hasExtension(defaultInt32Extension )); + Assert.assertFalse(message.hasExtension(defaultInt64Extension )); + Assert.assertFalse(message.hasExtension(defaultUint32Extension )); + Assert.assertFalse(message.hasExtension(defaultUint64Extension )); + Assert.assertFalse(message.hasExtension(defaultSint32Extension )); + Assert.assertFalse(message.hasExtension(defaultSint64Extension )); + Assert.assertFalse(message.hasExtension(defaultFixed32Extension )); + Assert.assertFalse(message.hasExtension(defaultFixed64Extension )); + Assert.assertFalse(message.hasExtension(defaultSfixed32Extension)); + Assert.assertFalse(message.hasExtension(defaultSfixed64Extension)); + Assert.assertFalse(message.hasExtension(defaultFloatExtension )); + Assert.assertFalse(message.hasExtension(defaultDoubleExtension )); + Assert.assertFalse(message.hasExtension(defaultBoolExtension )); + Assert.assertFalse(message.hasExtension(defaultStringExtension )); + Assert.assertFalse(message.hasExtension(defaultBytesExtension )); + + Assert.assertFalse(message.hasExtension(defaultNestedEnumExtension )); + Assert.assertFalse(message.hasExtension(defaultForeignEnumExtension)); + Assert.assertFalse(message.hasExtension(defaultImportEnumExtension )); + + Assert.assertFalse(message.hasExtension(defaultStringPieceExtension)); + Assert.assertFalse(message.hasExtension(defaultCordExtension)); // Fields with defaults have their default values (duh). - assertEqualsExactType( 41 , message.getExtension(UnittestProto.defaultInt32Extension )); - assertEqualsExactType( 42L , message.getExtension(UnittestProto.defaultInt64Extension )); - assertEqualsExactType( 43 , message.getExtension(UnittestProto.defaultUint32Extension )); - assertEqualsExactType( 44L , message.getExtension(UnittestProto.defaultUint64Extension )); - assertEqualsExactType(-45 , message.getExtension(UnittestProto.defaultSint32Extension )); - assertEqualsExactType( 46L , message.getExtension(UnittestProto.defaultSint64Extension )); - assertEqualsExactType( 47 , message.getExtension(UnittestProto.defaultFixed32Extension )); - assertEqualsExactType( 48L , message.getExtension(UnittestProto.defaultFixed64Extension )); - assertEqualsExactType( 49 , message.getExtension(UnittestProto.defaultSfixed32Extension)); - assertEqualsExactType(-50L , message.getExtension(UnittestProto.defaultSfixed64Extension)); - assertEqualsExactType( 51.5F , message.getExtension(UnittestProto.defaultFloatExtension )); - assertEqualsExactType( 52e3D , message.getExtension(UnittestProto.defaultDoubleExtension )); - assertEqualsExactType(true , message.getExtension(UnittestProto.defaultBoolExtension )); - assertEqualsExactType("hello", message.getExtension(UnittestProto.defaultStringExtension )); - assertEqualsExactType(toBytes("world"), message.getExtension(UnittestProto.defaultBytesExtension)); + assertEqualsExactType( 41 , message.getExtension(defaultInt32Extension )); + assertEqualsExactType( 42L , message.getExtension(defaultInt64Extension )); + assertEqualsExactType( 43 , message.getExtension(defaultUint32Extension )); + assertEqualsExactType( 44L , message.getExtension(defaultUint64Extension )); + assertEqualsExactType(-45 , message.getExtension(defaultSint32Extension )); + assertEqualsExactType( 46L , message.getExtension(defaultSint64Extension )); + assertEqualsExactType( 47 , message.getExtension(defaultFixed32Extension )); + assertEqualsExactType( 48L , message.getExtension(defaultFixed64Extension )); + assertEqualsExactType( 49 , message.getExtension(defaultSfixed32Extension)); + assertEqualsExactType(-50L , message.getExtension(defaultSfixed64Extension)); + assertEqualsExactType( 51.5F , message.getExtension(defaultFloatExtension )); + assertEqualsExactType( 52e3D , message.getExtension(defaultDoubleExtension )); + assertEqualsExactType(true , message.getExtension(defaultBoolExtension )); + assertEqualsExactType("hello", message.getExtension(defaultStringExtension )); + assertEqualsExactType(toBytes("world"), message.getExtension(defaultBytesExtension)); assertEqualsExactType(TestAllTypes.NestedEnum.BAR, - message.getExtension(UnittestProto.defaultNestedEnumExtension )); + message.getExtension(defaultNestedEnumExtension )); assertEqualsExactType(ForeignEnum.FOREIGN_BAR, - message.getExtension(UnittestProto.defaultForeignEnumExtension)); + message.getExtension(defaultForeignEnumExtension)); assertEqualsExactType(ImportEnum.IMPORT_BAR, - message.getExtension(UnittestProto.defaultImportEnumExtension)); + message.getExtension(defaultImportEnumExtension)); - assertEqualsExactType("abc", message.getExtension(UnittestProto.defaultStringPieceExtension)); - assertEqualsExactType("123", message.getExtension(UnittestProto.defaultCordExtension)); + assertEqualsExactType("abc", message.getExtension(defaultStringPieceExtension)); + assertEqualsExactType("123", message.getExtension(defaultCordExtension)); } // ------------------------------------------------------------------- @@ -1333,97 +1418,261 @@ class TestUtil { // ModifyRepeatedFields only sets the second repeated element of each // field. In addition to verifying this, we also verify that the first // element and size were *not* modified. - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedInt32Extension )); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedInt64Extension )); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedUint32Extension )); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedUint64Extension )); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedSint32Extension )); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedSint64Extension )); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedFixed32Extension )); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedFixed64Extension )); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedSfixed32Extension)); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedSfixed64Extension)); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedFloatExtension )); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedDoubleExtension )); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedBoolExtension )); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedStringExtension )); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedBytesExtension )); - - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedGroupExtension )); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedNestedMessageExtension )); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedForeignMessageExtension)); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedImportMessageExtension )); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedNestedEnumExtension )); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedForeignEnumExtension )); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedImportEnumExtension )); - - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedStringPieceExtension)); - Assert.assertEquals(2, message.getExtensionCount(UnittestProto.repeatedCordExtension)); - - assertEqualsExactType(201 , message.getExtension(UnittestProto.repeatedInt32Extension , 0)); - assertEqualsExactType(202L , message.getExtension(UnittestProto.repeatedInt64Extension , 0)); - assertEqualsExactType(203 , message.getExtension(UnittestProto.repeatedUint32Extension , 0)); - assertEqualsExactType(204L , message.getExtension(UnittestProto.repeatedUint64Extension , 0)); - assertEqualsExactType(205 , message.getExtension(UnittestProto.repeatedSint32Extension , 0)); - assertEqualsExactType(206L , message.getExtension(UnittestProto.repeatedSint64Extension , 0)); - assertEqualsExactType(207 , message.getExtension(UnittestProto.repeatedFixed32Extension , 0)); - assertEqualsExactType(208L , message.getExtension(UnittestProto.repeatedFixed64Extension , 0)); - assertEqualsExactType(209 , message.getExtension(UnittestProto.repeatedSfixed32Extension, 0)); - assertEqualsExactType(210L , message.getExtension(UnittestProto.repeatedSfixed64Extension, 0)); - assertEqualsExactType(211F , message.getExtension(UnittestProto.repeatedFloatExtension , 0)); - assertEqualsExactType(212D , message.getExtension(UnittestProto.repeatedDoubleExtension , 0)); - assertEqualsExactType(true , message.getExtension(UnittestProto.repeatedBoolExtension , 0)); - assertEqualsExactType("215", message.getExtension(UnittestProto.repeatedStringExtension , 0)); - assertEqualsExactType(toBytes("216"), message.getExtension(UnittestProto.repeatedBytesExtension, 0)); - - assertEqualsExactType(217, message.getExtension(UnittestProto.repeatedGroupExtension , 0).getA()); - assertEqualsExactType(218, message.getExtension(UnittestProto.repeatedNestedMessageExtension , 0).getBb()); - assertEqualsExactType(219, message.getExtension(UnittestProto.repeatedForeignMessageExtension, 0).getC()); - assertEqualsExactType(220, message.getExtension(UnittestProto.repeatedImportMessageExtension , 0).getD()); + Assert.assertEquals(2, message.getExtensionCount(repeatedInt32Extension )); + Assert.assertEquals(2, message.getExtensionCount(repeatedInt64Extension )); + Assert.assertEquals(2, message.getExtensionCount(repeatedUint32Extension )); + Assert.assertEquals(2, message.getExtensionCount(repeatedUint64Extension )); + Assert.assertEquals(2, message.getExtensionCount(repeatedSint32Extension )); + Assert.assertEquals(2, message.getExtensionCount(repeatedSint64Extension )); + Assert.assertEquals(2, message.getExtensionCount(repeatedFixed32Extension )); + Assert.assertEquals(2, message.getExtensionCount(repeatedFixed64Extension )); + Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed32Extension)); + Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed64Extension)); + Assert.assertEquals(2, message.getExtensionCount(repeatedFloatExtension )); + Assert.assertEquals(2, message.getExtensionCount(repeatedDoubleExtension )); + Assert.assertEquals(2, message.getExtensionCount(repeatedBoolExtension )); + Assert.assertEquals(2, message.getExtensionCount(repeatedStringExtension )); + Assert.assertEquals(2, message.getExtensionCount(repeatedBytesExtension )); + + Assert.assertEquals(2, message.getExtensionCount(repeatedGroupExtension )); + Assert.assertEquals(2, message.getExtensionCount(repeatedNestedMessageExtension )); + Assert.assertEquals(2, message.getExtensionCount(repeatedForeignMessageExtension)); + Assert.assertEquals(2, message.getExtensionCount(repeatedImportMessageExtension )); + Assert.assertEquals(2, message.getExtensionCount(repeatedNestedEnumExtension )); + Assert.assertEquals(2, message.getExtensionCount(repeatedForeignEnumExtension )); + Assert.assertEquals(2, message.getExtensionCount(repeatedImportEnumExtension )); + + Assert.assertEquals(2, message.getExtensionCount(repeatedStringPieceExtension)); + Assert.assertEquals(2, message.getExtensionCount(repeatedCordExtension)); + + assertEqualsExactType(201 , message.getExtension(repeatedInt32Extension , 0)); + assertEqualsExactType(202L , message.getExtension(repeatedInt64Extension , 0)); + assertEqualsExactType(203 , message.getExtension(repeatedUint32Extension , 0)); + assertEqualsExactType(204L , message.getExtension(repeatedUint64Extension , 0)); + assertEqualsExactType(205 , message.getExtension(repeatedSint32Extension , 0)); + assertEqualsExactType(206L , message.getExtension(repeatedSint64Extension , 0)); + assertEqualsExactType(207 , message.getExtension(repeatedFixed32Extension , 0)); + assertEqualsExactType(208L , message.getExtension(repeatedFixed64Extension , 0)); + assertEqualsExactType(209 , message.getExtension(repeatedSfixed32Extension, 0)); + assertEqualsExactType(210L , message.getExtension(repeatedSfixed64Extension, 0)); + assertEqualsExactType(211F , message.getExtension(repeatedFloatExtension , 0)); + assertEqualsExactType(212D , message.getExtension(repeatedDoubleExtension , 0)); + assertEqualsExactType(true , message.getExtension(repeatedBoolExtension , 0)); + assertEqualsExactType("215", message.getExtension(repeatedStringExtension , 0)); + assertEqualsExactType(toBytes("216"), message.getExtension(repeatedBytesExtension, 0)); + + assertEqualsExactType(217, message.getExtension(repeatedGroupExtension , 0).getA()); + assertEqualsExactType(218, message.getExtension(repeatedNestedMessageExtension , 0).getBb()); + assertEqualsExactType(219, message.getExtension(repeatedForeignMessageExtension, 0).getC()); + assertEqualsExactType(220, message.getExtension(repeatedImportMessageExtension , 0).getD()); assertEqualsExactType(TestAllTypes.NestedEnum.BAR, - message.getExtension(UnittestProto.repeatedNestedEnumExtension, 0)); + message.getExtension(repeatedNestedEnumExtension, 0)); assertEqualsExactType(ForeignEnum.FOREIGN_BAR, - message.getExtension(UnittestProto.repeatedForeignEnumExtension, 0)); + message.getExtension(repeatedForeignEnumExtension, 0)); assertEqualsExactType(ImportEnum.IMPORT_BAR, - message.getExtension(UnittestProto.repeatedImportEnumExtension, 0)); + message.getExtension(repeatedImportEnumExtension, 0)); - assertEqualsExactType("224", message.getExtension(UnittestProto.repeatedStringPieceExtension, 0)); - assertEqualsExactType("225", message.getExtension(UnittestProto.repeatedCordExtension, 0)); + assertEqualsExactType("224", message.getExtension(repeatedStringPieceExtension, 0)); + assertEqualsExactType("225", message.getExtension(repeatedCordExtension, 0)); // Actually verify the second (modified) elements now. - assertEqualsExactType(501 , message.getExtension(UnittestProto.repeatedInt32Extension , 1)); - assertEqualsExactType(502L , message.getExtension(UnittestProto.repeatedInt64Extension , 1)); - assertEqualsExactType(503 , message.getExtension(UnittestProto.repeatedUint32Extension , 1)); - assertEqualsExactType(504L , message.getExtension(UnittestProto.repeatedUint64Extension , 1)); - assertEqualsExactType(505 , message.getExtension(UnittestProto.repeatedSint32Extension , 1)); - assertEqualsExactType(506L , message.getExtension(UnittestProto.repeatedSint64Extension , 1)); - assertEqualsExactType(507 , message.getExtension(UnittestProto.repeatedFixed32Extension , 1)); - assertEqualsExactType(508L , message.getExtension(UnittestProto.repeatedFixed64Extension , 1)); - assertEqualsExactType(509 , message.getExtension(UnittestProto.repeatedSfixed32Extension, 1)); - assertEqualsExactType(510L , message.getExtension(UnittestProto.repeatedSfixed64Extension, 1)); - assertEqualsExactType(511F , message.getExtension(UnittestProto.repeatedFloatExtension , 1)); - assertEqualsExactType(512D , message.getExtension(UnittestProto.repeatedDoubleExtension , 1)); - assertEqualsExactType(true , message.getExtension(UnittestProto.repeatedBoolExtension , 1)); - assertEqualsExactType("515", message.getExtension(UnittestProto.repeatedStringExtension , 1)); - assertEqualsExactType(toBytes("516"), message.getExtension(UnittestProto.repeatedBytesExtension, 1)); - - assertEqualsExactType(517, message.getExtension(UnittestProto.repeatedGroupExtension , 1).getA()); - assertEqualsExactType(518, message.getExtension(UnittestProto.repeatedNestedMessageExtension , 1).getBb()); - assertEqualsExactType(519, message.getExtension(UnittestProto.repeatedForeignMessageExtension, 1).getC()); - assertEqualsExactType(520, message.getExtension(UnittestProto.repeatedImportMessageExtension , 1).getD()); + assertEqualsExactType(501 , message.getExtension(repeatedInt32Extension , 1)); + assertEqualsExactType(502L , message.getExtension(repeatedInt64Extension , 1)); + assertEqualsExactType(503 , message.getExtension(repeatedUint32Extension , 1)); + assertEqualsExactType(504L , message.getExtension(repeatedUint64Extension , 1)); + assertEqualsExactType(505 , message.getExtension(repeatedSint32Extension , 1)); + assertEqualsExactType(506L , message.getExtension(repeatedSint64Extension , 1)); + assertEqualsExactType(507 , message.getExtension(repeatedFixed32Extension , 1)); + assertEqualsExactType(508L , message.getExtension(repeatedFixed64Extension , 1)); + assertEqualsExactType(509 , message.getExtension(repeatedSfixed32Extension, 1)); + assertEqualsExactType(510L , message.getExtension(repeatedSfixed64Extension, 1)); + assertEqualsExactType(511F , message.getExtension(repeatedFloatExtension , 1)); + assertEqualsExactType(512D , message.getExtension(repeatedDoubleExtension , 1)); + assertEqualsExactType(true , message.getExtension(repeatedBoolExtension , 1)); + assertEqualsExactType("515", message.getExtension(repeatedStringExtension , 1)); + assertEqualsExactType(toBytes("516"), message.getExtension(repeatedBytesExtension, 1)); + + assertEqualsExactType(517, message.getExtension(repeatedGroupExtension , 1).getA()); + assertEqualsExactType(518, message.getExtension(repeatedNestedMessageExtension , 1).getBb()); + assertEqualsExactType(519, message.getExtension(repeatedForeignMessageExtension, 1).getC()); + assertEqualsExactType(520, message.getExtension(repeatedImportMessageExtension , 1).getD()); assertEqualsExactType(TestAllTypes.NestedEnum.FOO, - message.getExtension(UnittestProto.repeatedNestedEnumExtension, 1)); + message.getExtension(repeatedNestedEnumExtension, 1)); assertEqualsExactType(ForeignEnum.FOREIGN_FOO, - message.getExtension(UnittestProto.repeatedForeignEnumExtension, 1)); + message.getExtension(repeatedForeignEnumExtension, 1)); assertEqualsExactType(ImportEnum.IMPORT_FOO, - message.getExtension(UnittestProto.repeatedImportEnumExtension, 1)); + message.getExtension(repeatedImportEnumExtension, 1)); + + assertEqualsExactType("524", message.getExtension(repeatedStringPieceExtension, 1)); + assertEqualsExactType("525", message.getExtension(repeatedCordExtension, 1)); + } - assertEqualsExactType("524", message.getExtension(UnittestProto.repeatedStringPieceExtension, 1)); - assertEqualsExactType("525", message.getExtension(UnittestProto.repeatedCordExtension, 1)); + /** + * Set every field of {@code message} to a unique value. + */ + public static void setPackedFields(TestPackedTypes.Builder message) { + message.addPackedInt32 (601); + message.addPackedInt64 (602); + message.addPackedUint32 (603); + message.addPackedUint64 (604); + message.addPackedSint32 (605); + message.addPackedSint64 (606); + message.addPackedFixed32 (607); + message.addPackedFixed64 (608); + message.addPackedSfixed32(609); + message.addPackedSfixed64(610); + message.addPackedFloat (611); + message.addPackedDouble (612); + message.addPackedBool (true); + message.addPackedEnum (ForeignEnum.FOREIGN_BAR); + // Add a second one of each field. + message.addPackedInt32 (701); + message.addPackedInt64 (702); + message.addPackedUint32 (703); + message.addPackedUint64 (704); + message.addPackedSint32 (705); + message.addPackedSint64 (706); + message.addPackedFixed32 (707); + message.addPackedFixed64 (708); + message.addPackedSfixed32(709); + message.addPackedSfixed64(710); + message.addPackedFloat (711); + message.addPackedDouble (712); + message.addPackedBool (false); + message.addPackedEnum (ForeignEnum.FOREIGN_BAZ); } + /** + * Assert (using {@code junit.framework.Assert}} that all fields of + * {@code message} are set to the values assigned by {@code setPackedFields}. + */ + public static void assertPackedFieldsSet(TestPackedTypes message) { + Assert.assertEquals(2, message.getPackedInt32Count ()); + Assert.assertEquals(2, message.getPackedInt64Count ()); + Assert.assertEquals(2, message.getPackedUint32Count ()); + Assert.assertEquals(2, message.getPackedUint64Count ()); + Assert.assertEquals(2, message.getPackedSint32Count ()); + Assert.assertEquals(2, message.getPackedSint64Count ()); + Assert.assertEquals(2, message.getPackedFixed32Count ()); + Assert.assertEquals(2, message.getPackedFixed64Count ()); + Assert.assertEquals(2, message.getPackedSfixed32Count()); + Assert.assertEquals(2, message.getPackedSfixed64Count()); + Assert.assertEquals(2, message.getPackedFloatCount ()); + Assert.assertEquals(2, message.getPackedDoubleCount ()); + Assert.assertEquals(2, message.getPackedBoolCount ()); + Assert.assertEquals(2, message.getPackedEnumCount ()); + Assert.assertEquals(601 , message.getPackedInt32 (0)); + Assert.assertEquals(602 , message.getPackedInt64 (0)); + Assert.assertEquals(603 , message.getPackedUint32 (0)); + Assert.assertEquals(604 , message.getPackedUint64 (0)); + Assert.assertEquals(605 , message.getPackedSint32 (0)); + Assert.assertEquals(606 , message.getPackedSint64 (0)); + Assert.assertEquals(607 , message.getPackedFixed32 (0)); + Assert.assertEquals(608 , message.getPackedFixed64 (0)); + Assert.assertEquals(609 , message.getPackedSfixed32(0)); + Assert.assertEquals(610 , message.getPackedSfixed64(0)); + Assert.assertEquals(611 , message.getPackedFloat (0), 0.0); + Assert.assertEquals(612 , message.getPackedDouble (0), 0.0); + Assert.assertEquals(true , message.getPackedBool (0)); + Assert.assertEquals(ForeignEnum.FOREIGN_BAR, message.getPackedEnum(0)); + Assert.assertEquals(701 , message.getPackedInt32 (1)); + Assert.assertEquals(702 , message.getPackedInt64 (1)); + Assert.assertEquals(703 , message.getPackedUint32 (1)); + Assert.assertEquals(704 , message.getPackedUint64 (1)); + Assert.assertEquals(705 , message.getPackedSint32 (1)); + Assert.assertEquals(706 , message.getPackedSint64 (1)); + Assert.assertEquals(707 , message.getPackedFixed32 (1)); + Assert.assertEquals(708 , message.getPackedFixed64 (1)); + Assert.assertEquals(709 , message.getPackedSfixed32(1)); + Assert.assertEquals(710 , message.getPackedSfixed64(1)); + Assert.assertEquals(711 , message.getPackedFloat (1), 0.0); + Assert.assertEquals(712 , message.getPackedDouble (1), 0.0); + Assert.assertEquals(false, message.getPackedBool (1)); + Assert.assertEquals(ForeignEnum.FOREIGN_BAZ, message.getPackedEnum(1)); + } + + public static void setPackedExtensions(TestPackedExtensions.Builder message) { + message.addExtension(packedInt32Extension , 601); + message.addExtension(packedInt64Extension , 602L); + message.addExtension(packedUint32Extension , 603); + message.addExtension(packedUint64Extension , 604L); + message.addExtension(packedSint32Extension , 605); + message.addExtension(packedSint64Extension , 606L); + message.addExtension(packedFixed32Extension , 607); + message.addExtension(packedFixed64Extension , 608L); + message.addExtension(packedSfixed32Extension, 609); + message.addExtension(packedSfixed64Extension, 610L); + message.addExtension(packedFloatExtension , 611F); + message.addExtension(packedDoubleExtension , 612D); + message.addExtension(packedBoolExtension , true); + message.addExtension(packedEnumExtension, ForeignEnum.FOREIGN_BAR); + // Add a second one of each field. + message.addExtension(packedInt32Extension , 701); + message.addExtension(packedInt64Extension , 702L); + message.addExtension(packedUint32Extension , 703); + message.addExtension(packedUint64Extension , 704L); + message.addExtension(packedSint32Extension , 705); + message.addExtension(packedSint64Extension , 706L); + message.addExtension(packedFixed32Extension , 707); + message.addExtension(packedFixed64Extension , 708L); + message.addExtension(packedSfixed32Extension, 709); + message.addExtension(packedSfixed64Extension, 710L); + message.addExtension(packedFloatExtension , 711F); + message.addExtension(packedDoubleExtension , 712D); + message.addExtension(packedBoolExtension , false); + message.addExtension(packedEnumExtension, ForeignEnum.FOREIGN_BAZ); + } + + public static void assertPackedExtensionsSet(TestPackedExtensions message) { + Assert.assertEquals(2, message.getExtensionCount(packedInt32Extension )); + Assert.assertEquals(2, message.getExtensionCount(packedInt64Extension )); + Assert.assertEquals(2, message.getExtensionCount(packedUint32Extension )); + Assert.assertEquals(2, message.getExtensionCount(packedUint64Extension )); + Assert.assertEquals(2, message.getExtensionCount(packedSint32Extension )); + Assert.assertEquals(2, message.getExtensionCount(packedSint64Extension )); + Assert.assertEquals(2, message.getExtensionCount(packedFixed32Extension )); + Assert.assertEquals(2, message.getExtensionCount(packedFixed64Extension )); + Assert.assertEquals(2, message.getExtensionCount(packedSfixed32Extension)); + Assert.assertEquals(2, message.getExtensionCount(packedSfixed64Extension)); + Assert.assertEquals(2, message.getExtensionCount(packedFloatExtension )); + Assert.assertEquals(2, message.getExtensionCount(packedDoubleExtension )); + Assert.assertEquals(2, message.getExtensionCount(packedBoolExtension )); + Assert.assertEquals(2, message.getExtensionCount(packedEnumExtension)); + assertEqualsExactType(601 , message.getExtension(packedInt32Extension , 0)); + assertEqualsExactType(602L , message.getExtension(packedInt64Extension , 0)); + assertEqualsExactType(603 , message.getExtension(packedUint32Extension , 0)); + assertEqualsExactType(604L , message.getExtension(packedUint64Extension , 0)); + assertEqualsExactType(605 , message.getExtension(packedSint32Extension , 0)); + assertEqualsExactType(606L , message.getExtension(packedSint64Extension , 0)); + assertEqualsExactType(607 , message.getExtension(packedFixed32Extension , 0)); + assertEqualsExactType(608L , message.getExtension(packedFixed64Extension , 0)); + assertEqualsExactType(609 , message.getExtension(packedSfixed32Extension, 0)); + assertEqualsExactType(610L , message.getExtension(packedSfixed64Extension, 0)); + assertEqualsExactType(611F , message.getExtension(packedFloatExtension , 0)); + assertEqualsExactType(612D , message.getExtension(packedDoubleExtension , 0)); + assertEqualsExactType(true , message.getExtension(packedBoolExtension , 0)); + assertEqualsExactType(ForeignEnum.FOREIGN_BAR, + message.getExtension(packedEnumExtension, 0)); + assertEqualsExactType(701 , message.getExtension(packedInt32Extension , 1)); + assertEqualsExactType(702L , message.getExtension(packedInt64Extension , 1)); + assertEqualsExactType(703 , message.getExtension(packedUint32Extension , 1)); + assertEqualsExactType(704L , message.getExtension(packedUint64Extension , 1)); + assertEqualsExactType(705 , message.getExtension(packedSint32Extension , 1)); + assertEqualsExactType(706L , message.getExtension(packedSint64Extension , 1)); + assertEqualsExactType(707 , message.getExtension(packedFixed32Extension , 1)); + assertEqualsExactType(708L , message.getExtension(packedFixed64Extension , 1)); + assertEqualsExactType(709 , message.getExtension(packedSfixed32Extension, 1)); + assertEqualsExactType(710L , message.getExtension(packedSfixed64Extension, 1)); + assertEqualsExactType(711F , message.getExtension(packedFloatExtension , 1)); + assertEqualsExactType(712D , message.getExtension(packedDoubleExtension , 1)); + assertEqualsExactType(false, message.getExtension(packedBoolExtension , 1)); + assertEqualsExactType(ForeignEnum.FOREIGN_BAZ, + message.getExtension(packedEnumExtension, 1)); + } + + // =================================================================== /** @@ -1487,7 +1736,7 @@ class TestUtil { this.importFile = file.getDependencies().get(0); Descriptors.Descriptor testAllTypes; - if (extensionRegistry == null) { + if (baseDescriptor.getName() == "TestAllTypes") { testAllTypes = baseDescriptor; } else { testAllTypes = file.findMessageTypeByName("TestAllTypes"); @@ -1495,10 +1744,13 @@ class TestUtil { } if (extensionRegistry == null) { + // Use testAllTypes, rather than baseDescriptor, to allow + // initialization using TestPackedTypes descriptors. These objects + // won't be used by the methods for packed fields. this.optionalGroup = - baseDescriptor.findNestedTypeByName("OptionalGroup"); + testAllTypes.findNestedTypeByName("OptionalGroup"); this.repeatedGroup = - baseDescriptor.findNestedTypeByName("RepeatedGroup"); + testAllTypes.findNestedTypeByName("RepeatedGroup"); } else { this.optionalGroup = file.findMessageTypeByName("OptionalGroup_extension"); @@ -2279,6 +2531,191 @@ class TestUtil { Assert.assertEquals("524", message.getRepeatedField(f("repeated_string_piece"), 1)); Assert.assertEquals("525", message.getRepeatedField(f("repeated_cord"), 1)); } + + public void setPackedFieldsViaReflection(Message.Builder message) { + message.addRepeatedField(f("packed_int32" ), 601 ); + message.addRepeatedField(f("packed_int64" ), 602L); + message.addRepeatedField(f("packed_uint32" ), 603 ); + message.addRepeatedField(f("packed_uint64" ), 604L); + message.addRepeatedField(f("packed_sint32" ), 605 ); + message.addRepeatedField(f("packed_sint64" ), 606L); + message.addRepeatedField(f("packed_fixed32" ), 607 ); + message.addRepeatedField(f("packed_fixed64" ), 608L); + message.addRepeatedField(f("packed_sfixed32"), 609 ); + message.addRepeatedField(f("packed_sfixed64"), 610L); + message.addRepeatedField(f("packed_float" ), 611F); + message.addRepeatedField(f("packed_double" ), 612D); + message.addRepeatedField(f("packed_bool" ), true); + message.addRepeatedField(f("packed_enum" ), foreignBar); + // Add a second one of each field. + message.addRepeatedField(f("packed_int32" ), 701 ); + message.addRepeatedField(f("packed_int64" ), 702L); + message.addRepeatedField(f("packed_uint32" ), 703 ); + message.addRepeatedField(f("packed_uint64" ), 704L); + message.addRepeatedField(f("packed_sint32" ), 705 ); + message.addRepeatedField(f("packed_sint64" ), 706L); + message.addRepeatedField(f("packed_fixed32" ), 707 ); + message.addRepeatedField(f("packed_fixed64" ), 708L); + message.addRepeatedField(f("packed_sfixed32"), 709 ); + message.addRepeatedField(f("packed_sfixed64"), 710L); + message.addRepeatedField(f("packed_float" ), 711F); + message.addRepeatedField(f("packed_double" ), 712D); + message.addRepeatedField(f("packed_bool" ), false); + message.addRepeatedField(f("packed_enum" ), foreignBaz); + } + + public void assertPackedFieldsSetViaReflection(Message message) { + Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_int32" ))); + Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_int64" ))); + Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_uint32" ))); + Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_uint64" ))); + Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_sint32" ))); + Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_sint64" ))); + Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_fixed32" ))); + Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_fixed64" ))); + Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_sfixed32"))); + Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_sfixed64"))); + Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_float" ))); + Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_double" ))); + Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_bool" ))); + Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_enum" ))); + Assert.assertEquals(601 , message.getRepeatedField(f("packed_int32" ), 0)); + Assert.assertEquals(602L , message.getRepeatedField(f("packed_int64" ), 0)); + Assert.assertEquals(603 , message.getRepeatedField(f("packed_uint32" ), 0)); + Assert.assertEquals(604L , message.getRepeatedField(f("packed_uint64" ), 0)); + Assert.assertEquals(605 , message.getRepeatedField(f("packed_sint32" ), 0)); + Assert.assertEquals(606L , message.getRepeatedField(f("packed_sint64" ), 0)); + Assert.assertEquals(607 , message.getRepeatedField(f("packed_fixed32" ), 0)); + Assert.assertEquals(608L , message.getRepeatedField(f("packed_fixed64" ), 0)); + Assert.assertEquals(609 , message.getRepeatedField(f("packed_sfixed32"), 0)); + Assert.assertEquals(610L , message.getRepeatedField(f("packed_sfixed64"), 0)); + Assert.assertEquals(611F , message.getRepeatedField(f("packed_float" ), 0)); + Assert.assertEquals(612D , message.getRepeatedField(f("packed_double" ), 0)); + Assert.assertEquals(true , message.getRepeatedField(f("packed_bool" ), 0)); + Assert.assertEquals(foreignBar, message.getRepeatedField(f("packed_enum" ),0)); + Assert.assertEquals(701 , message.getRepeatedField(f("packed_int32" ), 1)); + Assert.assertEquals(702L , message.getRepeatedField(f("packed_int64" ), 1)); + Assert.assertEquals(703 , message.getRepeatedField(f("packed_uint32" ), 1)); + Assert.assertEquals(704L , message.getRepeatedField(f("packed_uint64" ), 1)); + Assert.assertEquals(705 , message.getRepeatedField(f("packed_sint32" ), 1)); + Assert.assertEquals(706L , message.getRepeatedField(f("packed_sint64" ), 1)); + Assert.assertEquals(707 , message.getRepeatedField(f("packed_fixed32" ), 1)); + Assert.assertEquals(708L , message.getRepeatedField(f("packed_fixed64" ), 1)); + Assert.assertEquals(709 , message.getRepeatedField(f("packed_sfixed32"), 1)); + Assert.assertEquals(710L , message.getRepeatedField(f("packed_sfixed64"), 1)); + Assert.assertEquals(711F , message.getRepeatedField(f("packed_float" ), 1)); + Assert.assertEquals(712D , message.getRepeatedField(f("packed_double" ), 1)); + Assert.assertEquals(false, message.getRepeatedField(f("packed_bool" ), 1)); + Assert.assertEquals(foreignBaz, message.getRepeatedField(f("packed_enum" ),1)); + } + + /** + * Verifies that the reflection setters for the given.Builder object throw a + * NullPointerException if they are passed a null value. Uses Assert to throw an + * appropriate assertion failure, if the condition is not verified. + */ + public void assertReflectionSettersRejectNull(Message.Builder builder) + throws Exception { + try { + builder.setField(f("optional_string"), null); + Assert.fail("Exception was not thrown"); + } catch (NullPointerException e) { + // We expect this exception. + } + try { + builder.setField(f("optional_bytes"), null); + Assert.fail("Exception was not thrown"); + } catch (NullPointerException e) { + // We expect this exception. + } + try { + builder.setField(f("optional_nested_enum"), null); + Assert.fail("Exception was not thrown"); + } catch (NullPointerException e) { + // We expect this exception. + } + try { + builder.setField(f("optional_nested_message"), + (TestAllTypes.NestedMessage) null); + Assert.fail("Exception was not thrown"); + } catch (NullPointerException e) { + // We expect this exception. + } + try { + builder.setField(f("optional_nested_message"), + (TestAllTypes.NestedMessage.Builder) null); + Assert.fail("Exception was not thrown"); + } catch (NullPointerException e) { + // We expect this exception. + } + + try { + builder.addRepeatedField(f("repeated_string"), null); + Assert.fail("Exception was not thrown"); + } catch (NullPointerException e) { + // We expect this exception. + } + try { + builder.addRepeatedField(f("repeated_bytes"), null); + Assert.fail("Exception was not thrown"); + } catch (NullPointerException e) { + // We expect this exception. + } + try { + builder.addRepeatedField(f("repeated_nested_enum"), null); + Assert.fail("Exception was not thrown"); + } catch (NullPointerException e) { + // We expect this exception. + } + try { + builder.addRepeatedField(f("repeated_nested_message"), null); + Assert.fail("Exception was not thrown"); + } catch (NullPointerException e) { + // We expect this exception. + } + } + + /** + * Verifies that the reflection repeated setters for the given Builder object throw a + * NullPointerException if they are passed a null value. Uses Assert to throw an appropriate + * assertion failure, if the condition is not verified. + */ + public void assertReflectionRepeatedSettersRejectNull(Message.Builder builder) + throws Exception { + builder.addRepeatedField(f("repeated_string"), "one"); + try { + builder.setRepeatedField(f("repeated_string"), 0, null); + Assert.fail("Exception was not thrown"); + } catch (NullPointerException e) { + // We expect this exception. + } + + builder.addRepeatedField(f("repeated_bytes"), toBytes("one")); + try { + builder.setRepeatedField(f("repeated_bytes"), 0, null); + Assert.fail("Exception was not thrown"); + } catch (NullPointerException e) { + // We expect this exception. + } + + builder.addRepeatedField(f("repeated_nested_enum"), nestedBaz); + try { + builder.setRepeatedField(f("repeated_nested_enum"), 0, null); + Assert.fail("Exception was not thrown"); + } catch (NullPointerException e) { + // We expect this exception. + } + + builder.addRepeatedField( + f("repeated_nested_message"), + TestAllTypes.NestedMessage.newBuilder().setBb(218).build()); + try { + builder.setRepeatedField(f("repeated_nested_message"), 0, null); + Assert.fail("Exception was not thrown"); + } catch (NullPointerException e) { + // We expect this exception. + } + } } /** @@ -2344,4 +2781,21 @@ class TestUtil { return goldenMessage; } private static ByteString goldenMessage = null; + + /** + * Get the bytes of the "golden packed fields message". This is a serialized + * TestPackedTypes with all fields set as they would be by + * {@link setPackedFields(TestPackedTypes.Builder)}, but it is loaded from a + * file on disk rather than generated dynamically. The file is actually + * generated by C++ code, so testing against it verifies compatibility with + * C++. + */ + public static ByteString getGoldenPackedFieldsMessage() { + if (goldenPackedFieldsMessage == null) { + goldenPackedFieldsMessage = + readBytesFromFile("golden_packed_fields_message"); + } + return goldenPackedFieldsMessage; + } + private static ByteString goldenPackedFieldsMessage = null; } diff --git a/java/src/test/java/com/google/protobuf/TextFormatTest.java b/java/src/test/java/com/google/protobuf/TextFormatTest.java index 9557bdf6..ec4910a3 100644 --- a/java/src/test/java/com/google/protobuf/TextFormatTest.java +++ b/java/src/test/java/com/google/protobuf/TextFormatTest.java @@ -586,4 +586,32 @@ public class TextFormatTest extends TestCase { // success } } + + public void testParseLongString() throws Exception { + String longText = + "123456789012345678901234567890123456789012345678901234567890" + + "123456789012345678901234567890123456789012345678901234567890" + + "123456789012345678901234567890123456789012345678901234567890" + + "123456789012345678901234567890123456789012345678901234567890" + + "123456789012345678901234567890123456789012345678901234567890" + + "123456789012345678901234567890123456789012345678901234567890" + + "123456789012345678901234567890123456789012345678901234567890" + + "123456789012345678901234567890123456789012345678901234567890" + + "123456789012345678901234567890123456789012345678901234567890" + + "123456789012345678901234567890123456789012345678901234567890" + + "123456789012345678901234567890123456789012345678901234567890" + + "123456789012345678901234567890123456789012345678901234567890" + + "123456789012345678901234567890123456789012345678901234567890" + + "123456789012345678901234567890123456789012345678901234567890" + + "123456789012345678901234567890123456789012345678901234567890" + + "123456789012345678901234567890123456789012345678901234567890" + + "123456789012345678901234567890123456789012345678901234567890" + + "123456789012345678901234567890123456789012345678901234567890" + + "123456789012345678901234567890123456789012345678901234567890" + + "123456789012345678901234567890123456789012345678901234567890"; + + TestAllTypes.Builder builder = TestAllTypes.newBuilder(); + TextFormat.merge("optional_string: \"" + longText + "\"", builder); + assertEquals(longText, builder.getOptionalString()); + } } diff --git a/java/src/test/java/com/google/protobuf/WireFormatTest.java b/java/src/test/java/com/google/protobuf/WireFormatTest.java index 3fb54fcf..48453faf 100644 --- a/java/src/test/java/com/google/protobuf/WireFormatTest.java +++ b/java/src/test/java/com/google/protobuf/WireFormatTest.java @@ -32,9 +32,11 @@ package com.google.protobuf; import junit.framework.TestCase; import protobuf_unittest.UnittestProto; -import protobuf_unittest.UnittestProto.TestAllTypes; import protobuf_unittest.UnittestProto.TestAllExtensions; +import protobuf_unittest.UnittestProto.TestAllTypes; import protobuf_unittest.UnittestProto.TestFieldOrderings; +import protobuf_unittest.UnittestProto.TestPackedExtensions; +import protobuf_unittest.UnittestProto.TestPackedTypes; import protobuf_unittest.UnittestMset.TestMessageSet; import protobuf_unittest.UnittestMset.RawMessageSet; import protobuf_unittest.UnittestMset.TestMessageSetExtension1; @@ -57,9 +59,20 @@ public class WireFormatTest extends TestCase { TestUtil.assertAllFieldsSet(message2); } + public void testSerializationPacked() throws Exception { + TestPackedTypes message = TestUtil.getPackedSet(); + + ByteString rawBytes = message.toByteString(); + assertEquals(rawBytes.size(), message.getSerializedSize()); + + TestPackedTypes message2 = TestPackedTypes.parseFrom(rawBytes); + + TestUtil.assertPackedFieldsSet(message2); + } + public void testSerializeExtensions() throws Exception { // TestAllTypes and TestAllExtensions should have compatible wire formats, - // so if we serealize a TestAllExtensions then parse it as TestAllTypes + // so if we serialize a TestAllExtensions then parse it as TestAllTypes // it should work. TestAllExtensions message = TestUtil.getAllExtensionsSet(); @@ -71,17 +84,27 @@ public class WireFormatTest extends TestCase { TestUtil.assertAllFieldsSet(message2); } + public void testSerializePackedExtensions() throws Exception { + // TestPackedTypes and TestPackedExtensions should have compatible wire + // formats; check that they serialize to the same string. + TestPackedExtensions message = TestUtil.getPackedExtensionsSet(); + ByteString rawBytes = message.toByteString(); + + TestPackedTypes message2 = TestUtil.getPackedSet(); + ByteString rawBytes2 = message2.toByteString(); + + assertEquals(rawBytes, rawBytes2); + } + public void testParseExtensions() throws Exception { // TestAllTypes and TestAllExtensions should have compatible wire formats, - // so if we serealize a TestAllTypes then parse it as TestAllExtensions + // so if we serialize a TestAllTypes then parse it as TestAllExtensions // it should work. TestAllTypes message = TestUtil.getAllSet(); ByteString rawBytes = message.toByteString(); - ExtensionRegistry registry = ExtensionRegistry.newInstance(); - TestUtil.registerAllExtensions(registry); - registry = registry.getUnmodifiable(); + ExtensionRegistry registry = TestUtil.getExtensionRegistry(); TestAllExtensions message2 = TestAllExtensions.parseFrom(rawBytes, registry); @@ -89,6 +112,19 @@ public class WireFormatTest extends TestCase { TestUtil.assertAllExtensionsSet(message2); } + public void testParsePackedExtensions() throws Exception { + // Ensure that packed extensions can be properly parsed. + TestPackedExtensions message = TestUtil.getPackedExtensionsSet(); + ByteString rawBytes = message.toByteString(); + + ExtensionRegistry registry = TestUtil.getExtensionRegistry(); + + TestPackedExtensions message2 = + TestPackedExtensions.parseFrom(rawBytes, registry); + + TestUtil.assertPackedExtensionsSet(message2); + } + public void testExtensionsSerializedSize() throws Exception { assertEquals(TestUtil.getAllSet().getSerializedSize(), TestUtil.getAllExtensionsSet().getSerializedSize()); @@ -279,4 +315,3 @@ public class WireFormatTest extends TestCase { assertEquals("bar", field.getLengthDelimitedList().get(0).toStringUtf8()); } } - |