LiteTest.java
Go to the documentation of this file.
1 // Protocol Buffers - Google's data interchange format
2 // Copyright 2008 Google Inc. All rights reserved.
3 // https://developers.google.com/protocol-buffers/
4 //
5 // Redistribution and use in source and binary forms, with or without
6 // modification, are permitted provided that the following conditions are
7 // met:
8 //
9 // * Redistributions of source code must retain the above copyright
10 // notice, this list of conditions and the following disclaimer.
11 // * Redistributions in binary form must reproduce the above
12 // copyright notice, this list of conditions and the following disclaimer
13 // in the documentation and/or other materials provided with the
14 // distribution.
15 // * Neither the name of Google Inc. nor the names of its
16 // contributors may be used to endorse or promote products derived from
17 // this software without specific prior written permission.
18 //
19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 
31 package com.google.protobuf;
32 
33 import static java.util.Collections.emptyList;
34 import static java.util.Collections.singletonList;
35 
36 import com.google.protobuf.FieldPresenceTestProto.TestAllTypes;
37 import com.google.protobuf.UnittestImportLite.ImportEnumLite;
38 import com.google.protobuf.UnittestImportPublicLite.PublicImportMessageLite;
39 import com.google.protobuf.UnittestLite.ForeignEnumLite;
40 import com.google.protobuf.UnittestLite.ForeignMessageLite;
41 import com.google.protobuf.UnittestLite.TestAllExtensionsLite;
42 import com.google.protobuf.UnittestLite.TestAllTypesLite;
43 import com.google.protobuf.UnittestLite.TestAllTypesLite.NestedEnum;
44 import com.google.protobuf.UnittestLite.TestAllTypesLite.NestedMessage;
45 import com.google.protobuf.UnittestLite.TestAllTypesLite.OneofFieldCase;
46 import com.google.protobuf.UnittestLite.TestAllTypesLite.OptionalGroup;
47 import com.google.protobuf.UnittestLite.TestAllTypesLite.RepeatedGroup;
48 import com.google.protobuf.UnittestLite.TestAllTypesLiteOrBuilder;
49 import com.google.protobuf.UnittestLite.TestHugeFieldNumbersLite;
50 import com.google.protobuf.UnittestLite.TestNestedExtensionLite;
51 import map_lite_test.MapTestProto.TestMap;
52 import map_lite_test.MapTestProto.TestMap.MessageValue;
53 import protobuf_unittest.NestedExtensionLite;
54 import protobuf_unittest.NonNestedExtensionLite;
55 import protobuf_unittest.lite_equals_and_hash.LiteEqualsAndHash.Bar;
56 import protobuf_unittest.lite_equals_and_hash.LiteEqualsAndHash.BarPrime;
57 import protobuf_unittest.lite_equals_and_hash.LiteEqualsAndHash.Foo;
58 import protobuf_unittest.lite_equals_and_hash.LiteEqualsAndHash.TestOneofEquals;
59 import protobuf_unittest.lite_equals_and_hash.LiteEqualsAndHash.TestRecursiveOneof;
60 import java.io.ByteArrayInputStream;
61 import java.io.ByteArrayOutputStream;
62 import java.io.IOException;
63 import java.io.OutputStream;
64 import java.lang.reflect.Field;
65 import java.nio.ByteBuffer;
66 import java.util.ArrayList;
67 import java.util.Arrays;
68 import java.util.Iterator;
69 import java.util.List;
70 import junit.framework.TestCase;
71 
77 public class LiteTest extends TestCase {
78  @Override
79  public void setUp() throws Exception {
80  // Test that nested extensions are initialized correctly even if the outer
81  // class has not been accessed directly. This was once a bug with lite
82  // messages.
83  //
84  // We put this in setUp() rather than in its own test method because we
85  // need to make sure it runs before any actual tests.
86  assertNotNull(TestNestedExtensionLite.nestedExtension);
87  }
88 
89  public void testLite() throws Exception {
90  // Since lite messages are a subset of regular messages, we can mostly
91  // assume that the functionality of lite messages is already thoroughly
92  // tested by the regular tests. All this test really verifies is that
93  // a proto with optimize_for = LITE_RUNTIME compiles correctly when
94  // linked only against the lite library. That is all tested at compile
95  // time, leaving not much to do in this method. Let's just do some random
96  // stuff to make sure the lite message is actually here and usable.
97 
98  TestAllTypesLite message =
99  TestAllTypesLite.newBuilder()
100  .setOptionalInt32(123)
101  .addRepeatedString("hello")
102  .setOptionalNestedMessage(NestedMessage.newBuilder().setBb(7))
103  .build();
104 
105  ByteString data = message.toByteString();
106 
107  TestAllTypesLite message2 = TestAllTypesLite.parseFrom(data);
108 
109  assertEquals(123, message2.getOptionalInt32());
110  assertEquals(1, message2.getRepeatedStringCount());
111  assertEquals("hello", message2.getRepeatedString(0));
112  assertEquals(7, message2.getOptionalNestedMessage().getBb());
113  }
114 
115  public void testLite_unknownEnumAtListBoundary() throws Exception {
116  ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
117  CodedOutputStream output = CodedOutputStream.newInstance(byteStream);
118  for (int i = 0; i < AbstractProtobufList.DEFAULT_CAPACITY; i++) {
119  output.writeInt32(TestAllTypesLite.REPEATED_NESTED_ENUM_FIELD_NUMBER, 1);
120  }
121  // 0 is not a valid enum value for NestedEnum
122  output.writeInt32(TestAllTypesLite.REPEATED_NESTED_ENUM_FIELD_NUMBER, 0);
123  output.flush();
124  // This tests a bug we had once with removal right at the boundary of the array. It would throw
125  // at runtime so no need to assert.
126  TestAllTypesLite.parseFrom(new ByteArrayInputStream(byteStream.toByteArray()));
127  }
128 
129  public void testLiteExtensions() throws Exception {
130  // TODO(kenton): Unlike other features of the lite library, extensions are
131  // implemented completely differently from the regular library. We
132  // should probably test them more thoroughly.
133 
134  TestAllExtensionsLite message =
135  TestAllExtensionsLite.newBuilder()
136  .setExtension(UnittestLite.optionalInt32ExtensionLite, 123)
137  .addExtension(UnittestLite.repeatedStringExtensionLite, "hello")
138  .setExtension(UnittestLite.optionalNestedEnumExtensionLite, NestedEnum.BAZ)
139  .setExtension(
140  UnittestLite.optionalNestedMessageExtensionLite,
141  NestedMessage.newBuilder().setBb(7).build())
142  .build();
143 
144  // Test copying a message, since coping extensions actually does use a
145  // different code path between lite and regular libraries, and as of this
146  // writing, parsing hasn't been implemented yet.
147  TestAllExtensionsLite message2 = message.toBuilder().build();
148 
149  assertEquals(123, (int) message2.getExtension(UnittestLite.optionalInt32ExtensionLite));
150  assertEquals(1, message2.getExtensionCount(UnittestLite.repeatedStringExtensionLite));
151  assertEquals(1, message2.getExtension(UnittestLite.repeatedStringExtensionLite).size());
152  assertEquals("hello", message2.getExtension(UnittestLite.repeatedStringExtensionLite, 0));
153  assertEquals(
154  NestedEnum.BAZ, message2.getExtension(UnittestLite.optionalNestedEnumExtensionLite));
155  assertEquals(7, message2.getExtension(UnittestLite.optionalNestedMessageExtensionLite).getBb());
156  }
157 
158  public void testClone() {
159  TestAllTypesLite.Builder expected = TestAllTypesLite.newBuilder().setOptionalInt32(123);
160  assertEquals(expected.getOptionalInt32(), expected.clone().getOptionalInt32());
161 
162  TestAllExtensionsLite.Builder expected2 =
163  TestAllExtensionsLite.newBuilder()
164  .setExtension(UnittestLite.optionalInt32ExtensionLite, 123);
165  assertEquals(
166  expected2.getExtension(UnittestLite.optionalInt32ExtensionLite),
167  expected2.clone().getExtension(UnittestLite.optionalInt32ExtensionLite));
168  }
169 
170  public void testAddAll() {
171  try {
172  TestAllTypesLite.newBuilder().addAllRepeatedBytes(null);
173  fail();
174  } catch (NullPointerException e) {
175  // expected.
176  }
177  }
178 
179  public void testMemoization() throws Exception {
180  TestAllExtensionsLite message = TestUtilLite.getAllLiteExtensionsSet();
181 
182  // Test serialized size is memoized
183  message.memoizedSerializedSize = -1;
184  int size = message.getSerializedSize();
185  assertTrue(size > 0);
186  assertEquals(size, message.memoizedSerializedSize);
187 
188  // Test hashCode is memoized
189  assertEquals(0, message.memoizedHashCode);
190  int hashCode = message.hashCode();
191  assertTrue(hashCode != 0);
192  assertEquals(hashCode, message.memoizedHashCode);
193 
194  // Test isInitialized is memoized
195  Field memo = message.getClass().getDeclaredField("memoizedIsInitialized");
196  memo.setAccessible(true);
197  memo.set(message, (byte) -1);
198  boolean initialized = message.isInitialized();
199  assertTrue(initialized);
200  // We have to cast to Byte first. Casting to byte causes a type error
201  assertEquals(1, ((Byte) memo.get(message)).intValue());
202  }
203 
204  public void testSanityCopyOnWrite() throws InvalidProtocolBufferException {
205  // Since builders are implemented as a thin wrapper around a message
206  // instance, we attempt to verify that we can't cause the builder to modify
207  // a produced message.
208 
209  TestAllTypesLite.Builder builder = TestAllTypesLite.newBuilder();
210  TestAllTypesLite message = builder.build();
211  TestAllTypesLite messageAfterBuild;
212  builder.setOptionalBool(true);
213  assertEquals(false, message.getOptionalBool());
214  assertEquals(true, builder.getOptionalBool());
215  messageAfterBuild = builder.build();
216  assertEquals(true, messageAfterBuild.getOptionalBool());
217  assertEquals(false, message.getOptionalBool());
218  builder.clearOptionalBool();
219  assertEquals(false, builder.getOptionalBool());
220  assertEquals(true, messageAfterBuild.getOptionalBool());
221 
222  message = builder.build();
223  builder.setOptionalBytes(ByteString.copyFromUtf8("hi"));
224  assertEquals(ByteString.EMPTY, message.getOptionalBytes());
225  assertEquals(ByteString.copyFromUtf8("hi"), builder.getOptionalBytes());
226  messageAfterBuild = builder.build();
227  assertEquals(ByteString.copyFromUtf8("hi"), messageAfterBuild.getOptionalBytes());
228  assertEquals(ByteString.EMPTY, message.getOptionalBytes());
229  builder.clearOptionalBytes();
230  assertEquals(ByteString.EMPTY, builder.getOptionalBytes());
231  assertEquals(ByteString.copyFromUtf8("hi"), messageAfterBuild.getOptionalBytes());
232 
233  message = builder.build();
234  builder.setOptionalCord("hi");
235  assertEquals("", message.getOptionalCord());
236  assertEquals("hi", builder.getOptionalCord());
237  messageAfterBuild = builder.build();
238  assertEquals("hi", messageAfterBuild.getOptionalCord());
239  assertEquals("", message.getOptionalCord());
240  builder.clearOptionalCord();
241  assertEquals("", builder.getOptionalCord());
242  assertEquals("hi", messageAfterBuild.getOptionalCord());
243 
244  message = builder.build();
245  builder.setOptionalCordBytes(ByteString.copyFromUtf8("no"));
246  assertEquals(ByteString.EMPTY, message.getOptionalCordBytes());
247  assertEquals(ByteString.copyFromUtf8("no"), builder.getOptionalCordBytes());
248  messageAfterBuild = builder.build();
249  assertEquals(ByteString.copyFromUtf8("no"), messageAfterBuild.getOptionalCordBytes());
250  assertEquals(ByteString.EMPTY, message.getOptionalCordBytes());
251  builder.clearOptionalCord();
252  assertEquals(ByteString.EMPTY, builder.getOptionalCordBytes());
253  assertEquals(ByteString.copyFromUtf8("no"), messageAfterBuild.getOptionalCordBytes());
254 
255  message = builder.build();
256  builder.setOptionalDouble(1);
257  assertEquals(0D, message.getOptionalDouble(), 0.0);
258  assertEquals(1D, builder.getOptionalDouble(), 0.0);
259  messageAfterBuild = builder.build();
260  assertEquals(1D, messageAfterBuild.getOptionalDouble(), 0.0);
261  assertEquals(0D, message.getOptionalDouble(), 0.0);
262  builder.clearOptionalDouble();
263  assertEquals(0D, builder.getOptionalDouble(), 0.0);
264  assertEquals(1D, messageAfterBuild.getOptionalDouble(), 0.0);
265 
266  message = builder.build();
267  builder.setOptionalFixed32(1);
268  assertEquals(0, message.getOptionalFixed32());
269  assertEquals(1, builder.getOptionalFixed32());
270  messageAfterBuild = builder.build();
271  assertEquals(1, messageAfterBuild.getOptionalFixed32());
272  assertEquals(0, message.getOptionalFixed32());
273  builder.clearOptionalFixed32();
274  assertEquals(0, builder.getOptionalFixed32());
275  assertEquals(1, messageAfterBuild.getOptionalFixed32());
276 
277  message = builder.build();
278  builder.setOptionalFixed64(1);
279  assertEquals(0L, message.getOptionalFixed64());
280  assertEquals(1L, builder.getOptionalFixed64());
281  messageAfterBuild = builder.build();
282  assertEquals(1L, messageAfterBuild.getOptionalFixed64());
283  assertEquals(0L, message.getOptionalFixed64());
284  builder.clearOptionalFixed64();
285  assertEquals(0L, builder.getOptionalFixed64());
286  assertEquals(1L, messageAfterBuild.getOptionalFixed64());
287 
288  message = builder.build();
289  builder.setOptionalFloat(1);
290  assertEquals(0F, message.getOptionalFloat(), 0.0f);
291  assertEquals(1F, builder.getOptionalFloat(), 0.0f);
292  messageAfterBuild = builder.build();
293  assertEquals(1F, messageAfterBuild.getOptionalFloat(), 0.0f);
294  assertEquals(0F, message.getOptionalFloat(), 0.0f);
295  builder.clearOptionalFloat();
296  assertEquals(0F, builder.getOptionalFloat(), 0.0f);
297  assertEquals(1F, messageAfterBuild.getOptionalFloat(), 0.0f);
298 
299  message = builder.build();
300  builder.setOptionalForeignEnum(ForeignEnumLite.FOREIGN_LITE_BAR);
301  assertEquals(ForeignEnumLite.FOREIGN_LITE_FOO, message.getOptionalForeignEnum());
302  assertEquals(ForeignEnumLite.FOREIGN_LITE_BAR, builder.getOptionalForeignEnum());
303  messageAfterBuild = builder.build();
304  assertEquals(ForeignEnumLite.FOREIGN_LITE_BAR, messageAfterBuild.getOptionalForeignEnum());
305  assertEquals(ForeignEnumLite.FOREIGN_LITE_FOO, message.getOptionalForeignEnum());
306  builder.clearOptionalForeignEnum();
307  assertEquals(ForeignEnumLite.FOREIGN_LITE_FOO, builder.getOptionalForeignEnum());
308  assertEquals(ForeignEnumLite.FOREIGN_LITE_BAR, messageAfterBuild.getOptionalForeignEnum());
309 
310  message = builder.build();
311  ForeignMessageLite foreignMessage = ForeignMessageLite.newBuilder().setC(1).build();
312  builder.setOptionalForeignMessage(foreignMessage);
313  assertEquals(ForeignMessageLite.getDefaultInstance(), message.getOptionalForeignMessage());
314  assertEquals(foreignMessage, builder.getOptionalForeignMessage());
315  messageAfterBuild = builder.build();
316  assertEquals(foreignMessage, messageAfterBuild.getOptionalForeignMessage());
317  assertEquals(ForeignMessageLite.getDefaultInstance(), message.getOptionalForeignMessage());
318  builder.clearOptionalForeignMessage();
319  assertEquals(ForeignMessageLite.getDefaultInstance(), builder.getOptionalForeignMessage());
320  assertEquals(foreignMessage, messageAfterBuild.getOptionalForeignMessage());
321 
322  message = builder.build();
323  ForeignMessageLite foreignMessageC3 = ForeignMessageLite.newBuilder().setC(3).build();
324  builder.setOptionalForeignMessage(foreignMessageC3);
325  assertEquals(ForeignMessageLite.getDefaultInstance(), message.getOptionalForeignMessage());
326  assertEquals(foreignMessageC3, builder.getOptionalForeignMessage());
327  messageAfterBuild = builder.build();
328  assertEquals(foreignMessageC3, messageAfterBuild.getOptionalForeignMessage());
329  assertEquals(ForeignMessageLite.getDefaultInstance(), message.getOptionalForeignMessage());
330  builder.clearOptionalForeignMessage();
331  assertEquals(ForeignMessageLite.getDefaultInstance(), builder.getOptionalForeignMessage());
332  assertEquals(foreignMessageC3, messageAfterBuild.getOptionalForeignMessage());
333 
334  message = builder.build();
335  OptionalGroup optionalGroup = OptionalGroup.newBuilder().setA(1).build();
336  builder.setOptionalGroup(optionalGroup);
337  assertEquals(OptionalGroup.getDefaultInstance(), message.getOptionalGroup());
338  assertEquals(optionalGroup, builder.getOptionalGroup());
339  messageAfterBuild = builder.build();
340  assertEquals(optionalGroup, messageAfterBuild.getOptionalGroup());
341  assertEquals(OptionalGroup.getDefaultInstance(), message.getOptionalGroup());
342  builder.clearOptionalGroup();
343  assertEquals(OptionalGroup.getDefaultInstance(), builder.getOptionalGroup());
344  assertEquals(optionalGroup, messageAfterBuild.getOptionalGroup());
345 
346  message = builder.build();
347  OptionalGroup.Builder optionalGroupBuilder = OptionalGroup.newBuilder().setA(3);
348  builder.setOptionalGroup(optionalGroupBuilder);
349  assertEquals(OptionalGroup.getDefaultInstance(), message.getOptionalGroup());
350  assertEquals(optionalGroupBuilder.build(), builder.getOptionalGroup());
351  messageAfterBuild = builder.build();
352  assertEquals(optionalGroupBuilder.build(), messageAfterBuild.getOptionalGroup());
353  assertEquals(OptionalGroup.getDefaultInstance(), message.getOptionalGroup());
354  builder.clearOptionalGroup();
355  assertEquals(OptionalGroup.getDefaultInstance(), builder.getOptionalGroup());
356  assertEquals(optionalGroupBuilder.build(), messageAfterBuild.getOptionalGroup());
357 
358  message = builder.build();
359  builder.setOptionalInt32(1);
360  assertEquals(0, message.getOptionalInt32());
361  assertEquals(1, builder.getOptionalInt32());
362  messageAfterBuild = builder.build();
363  assertEquals(1, messageAfterBuild.getOptionalInt32());
364  assertEquals(0, message.getOptionalInt32());
365  builder.clearOptionalInt32();
366  assertEquals(0, builder.getOptionalInt32());
367  assertEquals(1, messageAfterBuild.getOptionalInt32());
368 
369  message = builder.build();
370  builder.setOptionalInt64(1);
371  assertEquals(0L, message.getOptionalInt64());
372  assertEquals(1L, builder.getOptionalInt64());
373  messageAfterBuild = builder.build();
374  assertEquals(1L, messageAfterBuild.getOptionalInt64());
375  assertEquals(0L, message.getOptionalInt64());
376  builder.clearOptionalInt64();
377  assertEquals(0L, builder.getOptionalInt64());
378  assertEquals(1L, messageAfterBuild.getOptionalInt64());
379 
380  message = builder.build();
381  NestedMessage nestedMessage = NestedMessage.newBuilder().setBb(1).build();
382  builder.setOptionalLazyMessage(nestedMessage);
383  assertEquals(NestedMessage.getDefaultInstance(), message.getOptionalLazyMessage());
384  assertEquals(nestedMessage, builder.getOptionalLazyMessage());
385  messageAfterBuild = builder.build();
386  assertEquals(nestedMessage, messageAfterBuild.getOptionalLazyMessage());
387  assertEquals(NestedMessage.getDefaultInstance(), message.getOptionalLazyMessage());
388  builder.clearOptionalLazyMessage();
389  assertEquals(NestedMessage.getDefaultInstance(), builder.getOptionalLazyMessage());
390  assertEquals(nestedMessage, messageAfterBuild.getOptionalLazyMessage());
391 
392  message = builder.build();
393  NestedMessage.Builder nestedMessageBuilder = NestedMessage.newBuilder().setBb(3);
394  builder.setOptionalLazyMessage(nestedMessageBuilder);
395  assertEquals(NestedMessage.getDefaultInstance(), message.getOptionalLazyMessage());
396  assertEquals(nestedMessageBuilder.build(), builder.getOptionalLazyMessage());
397  messageAfterBuild = builder.build();
398  assertEquals(nestedMessageBuilder.build(), messageAfterBuild.getOptionalLazyMessage());
399  assertEquals(NestedMessage.getDefaultInstance(), message.getOptionalLazyMessage());
400  builder.clearOptionalLazyMessage();
401  assertEquals(NestedMessage.getDefaultInstance(), builder.getOptionalLazyMessage());
402  assertEquals(nestedMessageBuilder.build(), messageAfterBuild.getOptionalLazyMessage());
403 
404  message = builder.build();
405  builder.setOptionalSfixed32(1);
406  assertEquals(0, message.getOptionalSfixed32());
407  assertEquals(1, builder.getOptionalSfixed32());
408  messageAfterBuild = builder.build();
409  assertEquals(1, messageAfterBuild.getOptionalSfixed32());
410  assertEquals(0, message.getOptionalSfixed32());
411  builder.clearOptionalSfixed32();
412  assertEquals(0, builder.getOptionalSfixed32());
413  assertEquals(1, messageAfterBuild.getOptionalSfixed32());
414 
415  message = builder.build();
416  builder.setOptionalSfixed64(1);
417  assertEquals(0L, message.getOptionalSfixed64());
418  assertEquals(1L, builder.getOptionalSfixed64());
419  messageAfterBuild = builder.build();
420  assertEquals(1L, messageAfterBuild.getOptionalSfixed64());
421  assertEquals(0L, message.getOptionalSfixed64());
422  builder.clearOptionalSfixed64();
423  assertEquals(0L, builder.getOptionalSfixed64());
424  assertEquals(1L, messageAfterBuild.getOptionalSfixed64());
425 
426  message = builder.build();
427  builder.setOptionalSint32(1);
428  assertEquals(0, message.getOptionalSint32());
429  assertEquals(1, builder.getOptionalSint32());
430  messageAfterBuild = builder.build();
431  assertEquals(1, messageAfterBuild.getOptionalSint32());
432  builder.clearOptionalSint32();
433  assertEquals(0, builder.getOptionalSint32());
434  assertEquals(1, messageAfterBuild.getOptionalSint32());
435 
436  message = builder.build();
437  builder.setOptionalSint64(1);
438  assertEquals(0L, message.getOptionalSint64());
439  assertEquals(1L, builder.getOptionalSint64());
440  messageAfterBuild = builder.build();
441  assertEquals(1L, messageAfterBuild.getOptionalSint64());
442  assertEquals(0L, message.getOptionalSint64());
443  builder.clearOptionalSint64();
444  assertEquals(0L, builder.getOptionalSint64());
445  assertEquals(1L, messageAfterBuild.getOptionalSint64());
446 
447  message = builder.build();
448  builder.setOptionalString("hi");
449  assertEquals("", message.getOptionalString());
450  assertEquals("hi", builder.getOptionalString());
451  messageAfterBuild = builder.build();
452  assertEquals("hi", messageAfterBuild.getOptionalString());
453  assertEquals("", message.getOptionalString());
454  builder.clearOptionalString();
455  assertEquals("", builder.getOptionalString());
456  assertEquals("hi", messageAfterBuild.getOptionalString());
457 
458  message = builder.build();
459  builder.setOptionalStringBytes(ByteString.copyFromUtf8("no"));
460  assertEquals(ByteString.EMPTY, message.getOptionalStringBytes());
461  assertEquals(ByteString.copyFromUtf8("no"), builder.getOptionalStringBytes());
462  messageAfterBuild = builder.build();
463  assertEquals(ByteString.copyFromUtf8("no"), messageAfterBuild.getOptionalStringBytes());
464  assertEquals(ByteString.EMPTY, message.getOptionalStringBytes());
465  builder.clearOptionalString();
466  assertEquals(ByteString.EMPTY, builder.getOptionalStringBytes());
467  assertEquals(ByteString.copyFromUtf8("no"), messageAfterBuild.getOptionalStringBytes());
468 
469  message = builder.build();
470  builder.setOptionalStringPiece("hi");
471  assertEquals("", message.getOptionalStringPiece());
472  assertEquals("hi", builder.getOptionalStringPiece());
473  messageAfterBuild = builder.build();
474  assertEquals("hi", messageAfterBuild.getOptionalStringPiece());
475  assertEquals("", message.getOptionalStringPiece());
476  builder.clearOptionalStringPiece();
477  assertEquals("", builder.getOptionalStringPiece());
478  assertEquals("hi", messageAfterBuild.getOptionalStringPiece());
479 
480  message = builder.build();
481  builder.setOptionalStringPieceBytes(ByteString.copyFromUtf8("no"));
482  assertEquals(ByteString.EMPTY, message.getOptionalStringPieceBytes());
483  assertEquals(ByteString.copyFromUtf8("no"), builder.getOptionalStringPieceBytes());
484  messageAfterBuild = builder.build();
485  assertEquals(ByteString.copyFromUtf8("no"), messageAfterBuild.getOptionalStringPieceBytes());
486  assertEquals(ByteString.EMPTY, message.getOptionalStringPieceBytes());
487  builder.clearOptionalStringPiece();
488  assertEquals(ByteString.EMPTY, builder.getOptionalStringPieceBytes());
489  assertEquals(ByteString.copyFromUtf8("no"), messageAfterBuild.getOptionalStringPieceBytes());
490 
491  message = builder.build();
492  builder.setOptionalUint32(1);
493  assertEquals(0, message.getOptionalUint32());
494  assertEquals(1, builder.getOptionalUint32());
495  messageAfterBuild = builder.build();
496  assertEquals(1, messageAfterBuild.getOptionalUint32());
497  assertEquals(0, message.getOptionalUint32());
498  builder.clearOptionalUint32();
499  assertEquals(0, builder.getOptionalUint32());
500  assertEquals(1, messageAfterBuild.getOptionalUint32());
501 
502  message = builder.build();
503  builder.setOptionalUint64(1);
504  assertEquals(0L, message.getOptionalUint64());
505  assertEquals(1L, builder.getOptionalUint64());
506  messageAfterBuild = builder.build();
507  assertEquals(1L, messageAfterBuild.getOptionalUint64());
508  assertEquals(0L, message.getOptionalUint64());
509  builder.clearOptionalUint64();
510  assertEquals(0L, builder.getOptionalUint64());
511  assertEquals(1L, messageAfterBuild.getOptionalUint64());
512 
513  message = builder.build();
514  builder.addAllRepeatedBool(singletonList(true));
515  assertEquals(emptyList(), message.getRepeatedBoolList());
516  assertEquals(singletonList(true), builder.getRepeatedBoolList());
517  assertEquals(emptyList(), message.getRepeatedBoolList());
518  messageAfterBuild = builder.build();
519  builder.clearRepeatedBool();
520  assertEquals(emptyList(), builder.getRepeatedBoolList());
521  assertEquals(singletonList(true), messageAfterBuild.getRepeatedBoolList());
522 
523  message = builder.build();
524  builder.addAllRepeatedBytes(singletonList(ByteString.copyFromUtf8("hi")));
525  assertEquals(emptyList(), message.getRepeatedBytesList());
526  assertEquals(singletonList(ByteString.copyFromUtf8("hi")), builder.getRepeatedBytesList());
527  assertEquals(emptyList(), message.getRepeatedBytesList());
528  messageAfterBuild = builder.build();
529  builder.clearRepeatedBytes();
530  assertEquals(emptyList(), builder.getRepeatedBytesList());
531  assertEquals(
532  singletonList(ByteString.copyFromUtf8("hi")), messageAfterBuild.getRepeatedBytesList());
533 
534  message = builder.build();
535  builder.addAllRepeatedCord(singletonList("hi"));
536  assertEquals(emptyList(), message.getRepeatedCordList());
537  assertEquals(singletonList("hi"), builder.getRepeatedCordList());
538  assertEquals(emptyList(), message.getRepeatedCordList());
539  messageAfterBuild = builder.build();
540  builder.clearRepeatedCord();
541  assertEquals(emptyList(), builder.getRepeatedCordList());
542  assertEquals(singletonList("hi"), messageAfterBuild.getRepeatedCordList());
543 
544  message = builder.build();
545  builder.addAllRepeatedDouble(singletonList(1D));
546  assertEquals(emptyList(), message.getRepeatedDoubleList());
547  assertEquals(singletonList(1D), builder.getRepeatedDoubleList());
548  assertEquals(emptyList(), message.getRepeatedDoubleList());
549  messageAfterBuild = builder.build();
550  builder.clearRepeatedDouble();
551  assertEquals(emptyList(), builder.getRepeatedDoubleList());
552  assertEquals(singletonList(1D), messageAfterBuild.getRepeatedDoubleList());
553 
554  message = builder.build();
555  builder.addAllRepeatedFixed32(singletonList(1));
556  assertEquals(emptyList(), message.getRepeatedFixed32List());
557  assertEquals(singletonList(1), builder.getRepeatedFixed32List());
558  assertEquals(emptyList(), message.getRepeatedFixed32List());
559  messageAfterBuild = builder.build();
560  builder.clearRepeatedFixed32();
561  assertEquals(emptyList(), builder.getRepeatedFixed32List());
562  assertEquals(singletonList(1), messageAfterBuild.getRepeatedFixed32List());
563 
564  message = builder.build();
565  builder.addAllRepeatedFixed64(singletonList(1L));
566  assertEquals(emptyList(), message.getRepeatedFixed64List());
567  assertEquals(singletonList(1L), builder.getRepeatedFixed64List());
568  assertEquals(emptyList(), message.getRepeatedFixed64List());
569  messageAfterBuild = builder.build();
570  builder.clearRepeatedFixed64();
571  assertEquals(emptyList(), builder.getRepeatedFixed64List());
572  assertEquals(singletonList(1L), messageAfterBuild.getRepeatedFixed64List());
573 
574  message = builder.build();
575  builder.addAllRepeatedFloat(singletonList(1F));
576  assertEquals(emptyList(), message.getRepeatedFloatList());
577  assertEquals(singletonList(1F), builder.getRepeatedFloatList());
578  assertEquals(emptyList(), message.getRepeatedFloatList());
579  messageAfterBuild = builder.build();
580  builder.clearRepeatedFloat();
581  assertEquals(emptyList(), builder.getRepeatedFloatList());
582  assertEquals(singletonList(1F), messageAfterBuild.getRepeatedFloatList());
583 
584  message = builder.build();
585  builder.addAllRepeatedForeignEnum(singletonList(ForeignEnumLite.FOREIGN_LITE_BAR));
586  assertEquals(emptyList(), message.getRepeatedForeignEnumList());
587  assertEquals(
588  singletonList(ForeignEnumLite.FOREIGN_LITE_BAR), builder.getRepeatedForeignEnumList());
589  assertEquals(emptyList(), message.getRepeatedForeignEnumList());
590  messageAfterBuild = builder.build();
591  builder.clearRepeatedForeignEnum();
592  assertEquals(emptyList(), builder.getRepeatedForeignEnumList());
593  assertEquals(
594  singletonList(ForeignEnumLite.FOREIGN_LITE_BAR),
595  messageAfterBuild.getRepeatedForeignEnumList());
596 
597  message = builder.build();
598  builder.addAllRepeatedForeignMessage(singletonList(foreignMessage));
599  assertEquals(emptyList(), message.getRepeatedForeignMessageList());
600  assertEquals(singletonList(foreignMessage), builder.getRepeatedForeignMessageList());
601  assertEquals(emptyList(), message.getRepeatedForeignMessageList());
602  messageAfterBuild = builder.build();
603  builder.clearRepeatedForeignMessage();
604  assertEquals(emptyList(), builder.getRepeatedForeignMessageList());
605  assertEquals(singletonList(foreignMessage), messageAfterBuild.getRepeatedForeignMessageList());
606 
607  message = builder.build();
608  builder.addAllRepeatedGroup(singletonList(RepeatedGroup.getDefaultInstance()));
609  assertEquals(emptyList(), message.getRepeatedGroupList());
610  assertEquals(singletonList(RepeatedGroup.getDefaultInstance()), builder.getRepeatedGroupList());
611  assertEquals(emptyList(), message.getRepeatedGroupList());
612  messageAfterBuild = builder.build();
613  builder.clearRepeatedGroup();
614  assertEquals(emptyList(), builder.getRepeatedGroupList());
615  assertEquals(
616  singletonList(RepeatedGroup.getDefaultInstance()),
617  messageAfterBuild.getRepeatedGroupList());
618 
619  message = builder.build();
620  builder.addAllRepeatedInt32(singletonList(1));
621  assertEquals(emptyList(), message.getRepeatedInt32List());
622  assertEquals(singletonList(1), builder.getRepeatedInt32List());
623  assertEquals(emptyList(), message.getRepeatedInt32List());
624  messageAfterBuild = builder.build();
625  builder.clearRepeatedInt32();
626  assertEquals(emptyList(), builder.getRepeatedInt32List());
627  assertEquals(singletonList(1), messageAfterBuild.getRepeatedInt32List());
628 
629  message = builder.build();
630  builder.addAllRepeatedInt64(singletonList(1L));
631  assertEquals(emptyList(), message.getRepeatedInt64List());
632  assertEquals(singletonList(1L), builder.getRepeatedInt64List());
633  assertEquals(emptyList(), message.getRepeatedInt64List());
634  messageAfterBuild = builder.build();
635  builder.clearRepeatedInt64();
636  assertEquals(emptyList(), builder.getRepeatedInt64List());
637  assertEquals(singletonList(1L), messageAfterBuild.getRepeatedInt64List());
638 
639  message = builder.build();
640  builder.addAllRepeatedLazyMessage(singletonList(nestedMessage));
641  assertEquals(emptyList(), message.getRepeatedLazyMessageList());
642  assertEquals(singletonList(nestedMessage), builder.getRepeatedLazyMessageList());
643  assertEquals(emptyList(), message.getRepeatedLazyMessageList());
644  messageAfterBuild = builder.build();
645  builder.clearRepeatedLazyMessage();
646  assertEquals(emptyList(), builder.getRepeatedLazyMessageList());
647  assertEquals(singletonList(nestedMessage), messageAfterBuild.getRepeatedLazyMessageList());
648 
649  message = builder.build();
650  builder.addAllRepeatedSfixed32(singletonList(1));
651  assertEquals(emptyList(), message.getRepeatedSfixed32List());
652  assertEquals(singletonList(1), builder.getRepeatedSfixed32List());
653  assertEquals(emptyList(), message.getRepeatedSfixed32List());
654  messageAfterBuild = builder.build();
655  builder.clearRepeatedSfixed32();
656  assertEquals(emptyList(), builder.getRepeatedSfixed32List());
657  assertEquals(singletonList(1), messageAfterBuild.getRepeatedSfixed32List());
658 
659  message = builder.build();
660  builder.addAllRepeatedSfixed64(singletonList(1L));
661  assertEquals(emptyList(), message.getRepeatedSfixed64List());
662  assertEquals(singletonList(1L), builder.getRepeatedSfixed64List());
663  assertEquals(emptyList(), message.getRepeatedSfixed64List());
664  messageAfterBuild = builder.build();
665  builder.clearRepeatedSfixed64();
666  assertEquals(emptyList(), builder.getRepeatedSfixed64List());
667  assertEquals(singletonList(1L), messageAfterBuild.getRepeatedSfixed64List());
668 
669  message = builder.build();
670  builder.addAllRepeatedSint32(singletonList(1));
671  assertEquals(emptyList(), message.getRepeatedSint32List());
672  assertEquals(singletonList(1), builder.getRepeatedSint32List());
673  assertEquals(emptyList(), message.getRepeatedSint32List());
674  messageAfterBuild = builder.build();
675  builder.clearRepeatedSint32();
676  assertEquals(emptyList(), builder.getRepeatedSint32List());
677  assertEquals(singletonList(1), messageAfterBuild.getRepeatedSint32List());
678 
679  message = builder.build();
680  builder.addAllRepeatedSint64(singletonList(1L));
681  assertEquals(emptyList(), message.getRepeatedSint64List());
682  assertEquals(singletonList(1L), builder.getRepeatedSint64List());
683  assertEquals(emptyList(), message.getRepeatedSint64List());
684  messageAfterBuild = builder.build();
685  builder.clearRepeatedSint64();
686  assertEquals(emptyList(), builder.getRepeatedSint64List());
687  assertEquals(singletonList(1L), messageAfterBuild.getRepeatedSint64List());
688 
689  message = builder.build();
690  builder.addAllRepeatedString(singletonList("hi"));
691  assertEquals(emptyList(), message.getRepeatedStringList());
692  assertEquals(singletonList("hi"), builder.getRepeatedStringList());
693  assertEquals(emptyList(), message.getRepeatedStringList());
694  messageAfterBuild = builder.build();
695  builder.clearRepeatedString();
696  assertEquals(emptyList(), builder.getRepeatedStringList());
697  assertEquals(singletonList("hi"), messageAfterBuild.getRepeatedStringList());
698 
699  message = builder.build();
700  builder.addAllRepeatedStringPiece(singletonList("hi"));
701  assertEquals(emptyList(), message.getRepeatedStringPieceList());
702  assertEquals(singletonList("hi"), builder.getRepeatedStringPieceList());
703  assertEquals(emptyList(), message.getRepeatedStringPieceList());
704  messageAfterBuild = builder.build();
705  builder.clearRepeatedStringPiece();
706  assertEquals(emptyList(), builder.getRepeatedStringPieceList());
707  assertEquals(singletonList("hi"), messageAfterBuild.getRepeatedStringPieceList());
708 
709  message = builder.build();
710  builder.addAllRepeatedUint32(singletonList(1));
711  assertEquals(emptyList(), message.getRepeatedUint32List());
712  assertEquals(singletonList(1), builder.getRepeatedUint32List());
713  assertEquals(emptyList(), message.getRepeatedUint32List());
714  messageAfterBuild = builder.build();
715  builder.clearRepeatedUint32();
716  assertEquals(emptyList(), builder.getRepeatedUint32List());
717  assertEquals(singletonList(1), messageAfterBuild.getRepeatedUint32List());
718 
719  message = builder.build();
720  builder.addAllRepeatedUint64(singletonList(1L));
721  assertEquals(emptyList(), message.getRepeatedUint64List());
722  assertEquals(singletonList(1L), builder.getRepeatedUint64List());
723  assertEquals(emptyList(), message.getRepeatedUint64List());
724  messageAfterBuild = builder.build();
725  builder.clearRepeatedUint64();
726  assertEquals(emptyList(), builder.getRepeatedUint64List());
727  assertEquals(singletonList(1L), messageAfterBuild.getRepeatedUint64List());
728 
729  message = builder.build();
730  builder.addRepeatedBool(true);
731  assertEquals(emptyList(), message.getRepeatedBoolList());
732  assertEquals(singletonList(true), builder.getRepeatedBoolList());
733  assertEquals(emptyList(), message.getRepeatedBoolList());
734  messageAfterBuild = builder.build();
735  builder.clearRepeatedBool();
736  assertEquals(emptyList(), builder.getRepeatedBoolList());
737  assertEquals(singletonList(true), messageAfterBuild.getRepeatedBoolList());
738 
739  message = builder.build();
740  builder.addRepeatedBytes(ByteString.copyFromUtf8("hi"));
741  assertEquals(emptyList(), message.getRepeatedBytesList());
742  assertEquals(singletonList(ByteString.copyFromUtf8("hi")), builder.getRepeatedBytesList());
743  assertEquals(emptyList(), message.getRepeatedBytesList());
744  messageAfterBuild = builder.build();
745  builder.clearRepeatedBytes();
746  assertEquals(emptyList(), builder.getRepeatedBytesList());
747  assertEquals(
748  singletonList(ByteString.copyFromUtf8("hi")), messageAfterBuild.getRepeatedBytesList());
749 
750  message = builder.build();
751  builder.addRepeatedCord("hi");
752  assertEquals(emptyList(), message.getRepeatedCordList());
753  assertEquals(singletonList("hi"), builder.getRepeatedCordList());
754  assertEquals(emptyList(), message.getRepeatedCordList());
755  messageAfterBuild = builder.build();
756  builder.clearRepeatedCord();
757  assertEquals(emptyList(), builder.getRepeatedCordList());
758  assertEquals(singletonList("hi"), messageAfterBuild.getRepeatedCordList());
759 
760  message = builder.build();
761  builder.addRepeatedDouble(1D);
762  assertEquals(emptyList(), message.getRepeatedDoubleList());
763  assertEquals(singletonList(1D), builder.getRepeatedDoubleList());
764  assertEquals(emptyList(), message.getRepeatedDoubleList());
765  messageAfterBuild = builder.build();
766  builder.clearRepeatedDouble();
767  assertEquals(emptyList(), builder.getRepeatedDoubleList());
768  assertEquals(singletonList(1D), messageAfterBuild.getRepeatedDoubleList());
769 
770  message = builder.build();
771  builder.addRepeatedFixed32(1);
772  assertEquals(emptyList(), message.getRepeatedFixed32List());
773  assertEquals(singletonList(1), builder.getRepeatedFixed32List());
774  assertEquals(emptyList(), message.getRepeatedFixed32List());
775  messageAfterBuild = builder.build();
776  builder.clearRepeatedFixed32();
777  assertEquals(emptyList(), builder.getRepeatedFixed32List());
778  assertEquals(singletonList(1), messageAfterBuild.getRepeatedFixed32List());
779 
780  message = builder.build();
781  builder.addRepeatedFixed64(1L);
782  assertEquals(emptyList(), message.getRepeatedFixed64List());
783  assertEquals(singletonList(1L), builder.getRepeatedFixed64List());
784  assertEquals(emptyList(), message.getRepeatedFixed64List());
785  messageAfterBuild = builder.build();
786  builder.clearRepeatedFixed64();
787  assertEquals(emptyList(), builder.getRepeatedFixed64List());
788  assertEquals(singletonList(1L), messageAfterBuild.getRepeatedFixed64List());
789 
790  message = builder.build();
791  builder.addRepeatedFloat(1F);
792  assertEquals(emptyList(), message.getRepeatedFloatList());
793  assertEquals(singletonList(1F), builder.getRepeatedFloatList());
794  assertEquals(emptyList(), message.getRepeatedFloatList());
795  messageAfterBuild = builder.build();
796  builder.clearRepeatedFloat();
797  assertEquals(emptyList(), builder.getRepeatedFloatList());
798  assertEquals(singletonList(1F), messageAfterBuild.getRepeatedFloatList());
799 
800  message = builder.build();
801  builder.addRepeatedForeignEnum(ForeignEnumLite.FOREIGN_LITE_BAR);
802  assertEquals(emptyList(), message.getRepeatedForeignEnumList());
803  assertEquals(
804  singletonList(ForeignEnumLite.FOREIGN_LITE_BAR), builder.getRepeatedForeignEnumList());
805  assertEquals(emptyList(), message.getRepeatedForeignEnumList());
806  messageAfterBuild = builder.build();
807  builder.clearRepeatedForeignEnum();
808  assertEquals(emptyList(), builder.getRepeatedForeignEnumList());
809  assertEquals(
810  singletonList(ForeignEnumLite.FOREIGN_LITE_BAR),
811  messageAfterBuild.getRepeatedForeignEnumList());
812 
813  message = builder.build();
814  builder.addRepeatedForeignMessage(foreignMessage);
815  assertEquals(emptyList(), message.getRepeatedForeignMessageList());
816  assertEquals(singletonList(foreignMessage), builder.getRepeatedForeignMessageList());
817  assertEquals(emptyList(), message.getRepeatedForeignMessageList());
818  messageAfterBuild = builder.build();
819  builder.removeRepeatedForeignMessage(0);
820  assertEquals(emptyList(), builder.getRepeatedForeignMessageList());
821  assertEquals(singletonList(foreignMessage), messageAfterBuild.getRepeatedForeignMessageList());
822 
823  message = builder.build();
824  builder.addRepeatedGroup(RepeatedGroup.getDefaultInstance());
825  assertEquals(emptyList(), message.getRepeatedGroupList());
826  assertEquals(singletonList(RepeatedGroup.getDefaultInstance()), builder.getRepeatedGroupList());
827  assertEquals(emptyList(), message.getRepeatedGroupList());
828  messageAfterBuild = builder.build();
829  builder.removeRepeatedGroup(0);
830  assertEquals(emptyList(), builder.getRepeatedGroupList());
831  assertEquals(
832  singletonList(RepeatedGroup.getDefaultInstance()),
833  messageAfterBuild.getRepeatedGroupList());
834 
835  message = builder.build();
836  builder.addRepeatedInt32(1);
837  assertEquals(emptyList(), message.getRepeatedInt32List());
838  assertEquals(singletonList(1), builder.getRepeatedInt32List());
839  assertEquals(emptyList(), message.getRepeatedInt32List());
840  messageAfterBuild = builder.build();
841  builder.clearRepeatedInt32();
842  assertEquals(emptyList(), builder.getRepeatedInt32List());
843  assertEquals(singletonList(1), messageAfterBuild.getRepeatedInt32List());
844 
845  message = builder.build();
846  builder.addRepeatedInt64(1L);
847  assertEquals(emptyList(), message.getRepeatedInt64List());
848  assertEquals(singletonList(1L), builder.getRepeatedInt64List());
849  assertEquals(emptyList(), message.getRepeatedInt64List());
850  messageAfterBuild = builder.build();
851  builder.clearRepeatedInt64();
852  assertEquals(emptyList(), builder.getRepeatedInt64List());
853  assertEquals(singletonList(1L), messageAfterBuild.getRepeatedInt64List());
854 
855  message = builder.build();
856  builder.addRepeatedLazyMessage(nestedMessage);
857  assertEquals(emptyList(), message.getRepeatedLazyMessageList());
858  assertEquals(singletonList(nestedMessage), builder.getRepeatedLazyMessageList());
859  assertEquals(emptyList(), message.getRepeatedLazyMessageList());
860  messageAfterBuild = builder.build();
861  builder.removeRepeatedLazyMessage(0);
862  assertEquals(emptyList(), builder.getRepeatedLazyMessageList());
863  assertEquals(singletonList(nestedMessage), messageAfterBuild.getRepeatedLazyMessageList());
864 
865  message = builder.build();
866  builder.addRepeatedSfixed32(1);
867  assertEquals(emptyList(), message.getRepeatedSfixed32List());
868  assertEquals(singletonList(1), builder.getRepeatedSfixed32List());
869  assertEquals(emptyList(), message.getRepeatedSfixed32List());
870  messageAfterBuild = builder.build();
871  builder.clearRepeatedSfixed32();
872  assertEquals(emptyList(), builder.getRepeatedSfixed32List());
873  assertEquals(singletonList(1), messageAfterBuild.getRepeatedSfixed32List());
874 
875  message = builder.build();
876  builder.addRepeatedSfixed64(1L);
877  assertEquals(emptyList(), message.getRepeatedSfixed64List());
878  assertEquals(singletonList(1L), builder.getRepeatedSfixed64List());
879  assertEquals(emptyList(), message.getRepeatedSfixed64List());
880  messageAfterBuild = builder.build();
881  builder.clearRepeatedSfixed64();
882  assertEquals(emptyList(), builder.getRepeatedSfixed64List());
883  assertEquals(singletonList(1L), messageAfterBuild.getRepeatedSfixed64List());
884 
885  message = builder.build();
886  builder.addRepeatedSint32(1);
887  assertEquals(emptyList(), message.getRepeatedSint32List());
888  assertEquals(singletonList(1), builder.getRepeatedSint32List());
889  assertEquals(emptyList(), message.getRepeatedSint32List());
890  messageAfterBuild = builder.build();
891  builder.clearRepeatedSint32();
892  assertEquals(emptyList(), builder.getRepeatedSint32List());
893  assertEquals(singletonList(1), messageAfterBuild.getRepeatedSint32List());
894 
895  message = builder.build();
896  builder.addRepeatedSint64(1L);
897  assertEquals(emptyList(), message.getRepeatedSint64List());
898  assertEquals(singletonList(1L), builder.getRepeatedSint64List());
899  assertEquals(emptyList(), message.getRepeatedSint64List());
900  messageAfterBuild = builder.build();
901  builder.clearRepeatedSint64();
902  assertEquals(emptyList(), builder.getRepeatedSint64List());
903  assertEquals(singletonList(1L), messageAfterBuild.getRepeatedSint64List());
904 
905  message = builder.build();
906  builder.addRepeatedString("hi");
907  assertEquals(emptyList(), message.getRepeatedStringList());
908  assertEquals(singletonList("hi"), builder.getRepeatedStringList());
909  assertEquals(emptyList(), message.getRepeatedStringList());
910  messageAfterBuild = builder.build();
911  builder.clearRepeatedString();
912  assertEquals(emptyList(), builder.getRepeatedStringList());
913  assertEquals(singletonList("hi"), messageAfterBuild.getRepeatedStringList());
914 
915  message = builder.build();
916  builder.addRepeatedStringPiece("hi");
917  assertEquals(emptyList(), message.getRepeatedStringPieceList());
918  assertEquals(singletonList("hi"), builder.getRepeatedStringPieceList());
919  assertEquals(emptyList(), message.getRepeatedStringPieceList());
920  messageAfterBuild = builder.build();
921  builder.clearRepeatedStringPiece();
922  assertEquals(emptyList(), builder.getRepeatedStringPieceList());
923  assertEquals(singletonList("hi"), messageAfterBuild.getRepeatedStringPieceList());
924 
925  message = builder.build();
926  builder.addRepeatedUint32(1);
927  assertEquals(emptyList(), message.getRepeatedUint32List());
928  assertEquals(singletonList(1), builder.getRepeatedUint32List());
929  assertEquals(emptyList(), message.getRepeatedUint32List());
930  messageAfterBuild = builder.build();
931  builder.clearRepeatedUint32();
932  assertEquals(emptyList(), builder.getRepeatedUint32List());
933  assertEquals(singletonList(1), messageAfterBuild.getRepeatedUint32List());
934 
935  message = builder.build();
936  builder.addRepeatedUint64(1L);
937  assertEquals(emptyList(), message.getRepeatedUint64List());
938  assertEquals(singletonList(1L), builder.getRepeatedUint64List());
939  assertEquals(emptyList(), message.getRepeatedUint64List());
940  messageAfterBuild = builder.build();
941  builder.clearRepeatedUint64();
942  assertEquals(emptyList(), builder.getRepeatedUint64List());
943  assertEquals(singletonList(1L), messageAfterBuild.getRepeatedUint64List());
944 
945  message = builder.build();
946  builder.addRepeatedBool(true);
947  messageAfterBuild = builder.build();
948  assertEquals(0, message.getRepeatedBoolCount());
949  builder.setRepeatedBool(0, false);
950  assertEquals(true, messageAfterBuild.getRepeatedBool(0));
951  assertEquals(false, builder.getRepeatedBool(0));
952  builder.clearRepeatedBool();
953 
954  message = builder.build();
955  builder.addRepeatedBytes(ByteString.copyFromUtf8("hi"));
956  messageAfterBuild = builder.build();
957  assertEquals(0, message.getRepeatedBytesCount());
958  builder.setRepeatedBytes(0, ByteString.EMPTY);
959  assertEquals(ByteString.copyFromUtf8("hi"), messageAfterBuild.getRepeatedBytes(0));
960  assertEquals(ByteString.EMPTY, builder.getRepeatedBytes(0));
961  builder.clearRepeatedBytes();
962 
963  message = builder.build();
964  builder.addRepeatedCord("hi");
965  messageAfterBuild = builder.build();
966  assertEquals(0, message.getRepeatedCordCount());
967  builder.setRepeatedCord(0, "");
968  assertEquals("hi", messageAfterBuild.getRepeatedCord(0));
969  assertEquals("", builder.getRepeatedCord(0));
970  builder.clearRepeatedCord();
971  message = builder.build();
972 
973  builder.addRepeatedCordBytes(ByteString.copyFromUtf8("hi"));
974  messageAfterBuild = builder.build();
975  assertEquals(0, message.getRepeatedCordCount());
976  builder.setRepeatedCord(0, "");
977  assertEquals(ByteString.copyFromUtf8("hi"), messageAfterBuild.getRepeatedCordBytes(0));
978  assertEquals(ByteString.EMPTY, builder.getRepeatedCordBytes(0));
979  builder.clearRepeatedCord();
980 
981  message = builder.build();
982  builder.addRepeatedDouble(1D);
983  messageAfterBuild = builder.build();
984  assertEquals(0, message.getRepeatedDoubleCount());
985  builder.setRepeatedDouble(0, 0D);
986  assertEquals(1D, messageAfterBuild.getRepeatedDouble(0), 0.0);
987  assertEquals(0D, builder.getRepeatedDouble(0), 0.0);
988  builder.clearRepeatedDouble();
989 
990  message = builder.build();
991  builder.addRepeatedFixed32(1);
992  messageAfterBuild = builder.build();
993  assertEquals(0, message.getRepeatedFixed32Count());
994  builder.setRepeatedFixed32(0, 0);
995  assertEquals(1, messageAfterBuild.getRepeatedFixed32(0));
996  assertEquals(0, builder.getRepeatedFixed32(0));
997  builder.clearRepeatedFixed32();
998 
999  message = builder.build();
1000  builder.addRepeatedFixed64(1L);
1001  messageAfterBuild = builder.build();
1002  assertEquals(0, message.getRepeatedFixed64Count());
1003  builder.setRepeatedFixed64(0, 0L);
1004  assertEquals(1L, messageAfterBuild.getRepeatedFixed64(0));
1005  assertEquals(0L, builder.getRepeatedFixed64(0));
1006  builder.clearRepeatedFixed64();
1007 
1008  message = builder.build();
1009  builder.addRepeatedFloat(1F);
1010  messageAfterBuild = builder.build();
1011  assertEquals(0, message.getRepeatedFloatCount());
1012  builder.setRepeatedFloat(0, 0F);
1013  assertEquals(1F, messageAfterBuild.getRepeatedFloat(0), 0.0f);
1014  assertEquals(0F, builder.getRepeatedFloat(0), 0.0f);
1015  builder.clearRepeatedFloat();
1016 
1017  message = builder.build();
1018  builder.addRepeatedForeignEnum(ForeignEnumLite.FOREIGN_LITE_BAR);
1019  messageAfterBuild = builder.build();
1020  assertEquals(0, message.getRepeatedForeignEnumCount());
1021  builder.setRepeatedForeignEnum(0, ForeignEnumLite.FOREIGN_LITE_FOO);
1022  assertEquals(ForeignEnumLite.FOREIGN_LITE_BAR, messageAfterBuild.getRepeatedForeignEnum(0));
1023  assertEquals(ForeignEnumLite.FOREIGN_LITE_FOO, builder.getRepeatedForeignEnum(0));
1024  builder.clearRepeatedForeignEnum();
1025 
1026  message = builder.build();
1027  builder.addRepeatedForeignMessage(foreignMessage);
1028  messageAfterBuild = builder.build();
1029  assertEquals(0, message.getRepeatedForeignMessageCount());
1030  builder.setRepeatedForeignMessage(0, ForeignMessageLite.getDefaultInstance());
1031  assertEquals(foreignMessage, messageAfterBuild.getRepeatedForeignMessage(0));
1032  assertEquals(ForeignMessageLite.getDefaultInstance(), builder.getRepeatedForeignMessage(0));
1033  builder.clearRepeatedForeignMessage();
1034 
1035  message = builder.build();
1036  builder.addRepeatedForeignMessage(foreignMessageC3);
1037  messageAfterBuild = builder.build();
1038  assertEquals(0, message.getRepeatedForeignMessageCount());
1039  builder.setRepeatedForeignMessage(0, ForeignMessageLite.getDefaultInstance());
1040  assertEquals(foreignMessageC3, messageAfterBuild.getRepeatedForeignMessage(0));
1041  assertEquals(ForeignMessageLite.getDefaultInstance(), builder.getRepeatedForeignMessage(0));
1042  builder.clearRepeatedForeignMessage();
1043 
1044  message = builder.build();
1045  builder.addRepeatedForeignMessage(0, foreignMessage);
1046  messageAfterBuild = builder.build();
1047  assertEquals(0, message.getRepeatedForeignMessageCount());
1048  builder.setRepeatedForeignMessage(0, foreignMessageC3);
1049  assertEquals(foreignMessage, messageAfterBuild.getRepeatedForeignMessage(0));
1050  assertEquals(foreignMessageC3, builder.getRepeatedForeignMessage(0));
1051  builder.clearRepeatedForeignMessage();
1052 
1053  message = builder.build();
1054  RepeatedGroup repeatedGroup = RepeatedGroup.newBuilder().setA(1).build();
1055  builder.addRepeatedGroup(repeatedGroup);
1056  messageAfterBuild = builder.build();
1057  assertEquals(0, message.getRepeatedGroupCount());
1058  builder.setRepeatedGroup(0, RepeatedGroup.getDefaultInstance());
1059  assertEquals(repeatedGroup, messageAfterBuild.getRepeatedGroup(0));
1060  assertEquals(RepeatedGroup.getDefaultInstance(), builder.getRepeatedGroup(0));
1061  builder.clearRepeatedGroup();
1062 
1063  message = builder.build();
1064  builder.addRepeatedGroup(0, repeatedGroup);
1065  messageAfterBuild = builder.build();
1066  assertEquals(0, message.getRepeatedGroupCount());
1067  builder.setRepeatedGroup(0, RepeatedGroup.getDefaultInstance());
1068  assertEquals(repeatedGroup, messageAfterBuild.getRepeatedGroup(0));
1069  assertEquals(RepeatedGroup.getDefaultInstance(), builder.getRepeatedGroup(0));
1070  builder.clearRepeatedGroup();
1071 
1072  message = builder.build();
1073  RepeatedGroup.Builder repeatedGroupBuilder = RepeatedGroup.newBuilder().setA(3);
1074  builder.addRepeatedGroup(repeatedGroupBuilder);
1075  messageAfterBuild = builder.build();
1076  assertEquals(0, message.getRepeatedGroupCount());
1077  builder.setRepeatedGroup(0, RepeatedGroup.getDefaultInstance());
1078  assertEquals(repeatedGroupBuilder.build(), messageAfterBuild.getRepeatedGroup(0));
1079  assertEquals(RepeatedGroup.getDefaultInstance(), builder.getRepeatedGroup(0));
1080  builder.clearRepeatedGroup();
1081 
1082  message = builder.build();
1083  builder.addRepeatedGroup(0, repeatedGroupBuilder);
1084  messageAfterBuild = builder.build();
1085  assertEquals(0, message.getRepeatedGroupCount());
1086  builder.setRepeatedGroup(0, RepeatedGroup.getDefaultInstance());
1087  assertEquals(repeatedGroupBuilder.build(), messageAfterBuild.getRepeatedGroup(0));
1088  assertEquals(RepeatedGroup.getDefaultInstance(), builder.getRepeatedGroup(0));
1089  builder.clearRepeatedGroup();
1090 
1091  message = builder.build();
1092  builder.addRepeatedInt32(1);
1093  messageAfterBuild = builder.build();
1094  assertEquals(0, message.getRepeatedInt32Count());
1095  builder.setRepeatedInt32(0, 0);
1096  assertEquals(1, messageAfterBuild.getRepeatedInt32(0));
1097  assertEquals(0, builder.getRepeatedInt32(0));
1098  builder.clearRepeatedInt32();
1099 
1100  message = builder.build();
1101  builder.addRepeatedInt64(1L);
1102  messageAfterBuild = builder.build();
1103  assertEquals(0L, message.getRepeatedInt64Count());
1104  builder.setRepeatedInt64(0, 0L);
1105  assertEquals(1L, messageAfterBuild.getRepeatedInt64(0));
1106  assertEquals(0L, builder.getRepeatedInt64(0));
1107  builder.clearRepeatedInt64();
1108 
1109  message = builder.build();
1110  builder.addRepeatedLazyMessage(nestedMessage);
1111  messageAfterBuild = builder.build();
1112  assertEquals(0, message.getRepeatedLazyMessageCount());
1113  builder.setRepeatedLazyMessage(0, NestedMessage.getDefaultInstance());
1114  assertEquals(nestedMessage, messageAfterBuild.getRepeatedLazyMessage(0));
1115  assertEquals(NestedMessage.getDefaultInstance(), builder.getRepeatedLazyMessage(0));
1116  builder.clearRepeatedLazyMessage();
1117 
1118  message = builder.build();
1119  builder.addRepeatedLazyMessage(0, nestedMessage);
1120  messageAfterBuild = builder.build();
1121  assertEquals(0, message.getRepeatedLazyMessageCount());
1122  builder.setRepeatedLazyMessage(0, NestedMessage.getDefaultInstance());
1123  assertEquals(nestedMessage, messageAfterBuild.getRepeatedLazyMessage(0));
1124  assertEquals(NestedMessage.getDefaultInstance(), builder.getRepeatedLazyMessage(0));
1125  builder.clearRepeatedLazyMessage();
1126 
1127  message = builder.build();
1128  builder.addRepeatedLazyMessage(nestedMessageBuilder);
1129  messageAfterBuild = builder.build();
1130  assertEquals(0, message.getRepeatedLazyMessageCount());
1131  builder.setRepeatedLazyMessage(0, NestedMessage.getDefaultInstance());
1132  assertEquals(nestedMessageBuilder.build(), messageAfterBuild.getRepeatedLazyMessage(0));
1133  assertEquals(NestedMessage.getDefaultInstance(), builder.getRepeatedLazyMessage(0));
1134  builder.clearRepeatedLazyMessage();
1135 
1136  message = builder.build();
1137  builder.addRepeatedLazyMessage(0, nestedMessageBuilder);
1138  messageAfterBuild = builder.build();
1139  assertEquals(0, message.getRepeatedLazyMessageCount());
1140  builder.setRepeatedLazyMessage(0, NestedMessage.getDefaultInstance());
1141  assertEquals(nestedMessageBuilder.build(), messageAfterBuild.getRepeatedLazyMessage(0));
1142  assertEquals(NestedMessage.getDefaultInstance(), builder.getRepeatedLazyMessage(0));
1143  builder.clearRepeatedLazyMessage();
1144 
1145  message = builder.build();
1146  builder.addRepeatedSfixed32(1);
1147  messageAfterBuild = builder.build();
1148  assertEquals(0, message.getRepeatedSfixed32Count());
1149  builder.setRepeatedSfixed32(0, 0);
1150  assertEquals(1, messageAfterBuild.getRepeatedSfixed32(0));
1151  assertEquals(0, builder.getRepeatedSfixed32(0));
1152  builder.clearRepeatedSfixed32();
1153 
1154  message = builder.build();
1155  builder.addRepeatedSfixed64(1L);
1156  messageAfterBuild = builder.build();
1157  assertEquals(0L, message.getRepeatedSfixed64Count());
1158  builder.setRepeatedSfixed64(0, 0L);
1159  assertEquals(1L, messageAfterBuild.getRepeatedSfixed64(0));
1160  assertEquals(0L, builder.getRepeatedSfixed64(0));
1161  builder.clearRepeatedSfixed64();
1162 
1163  message = builder.build();
1164  builder.addRepeatedSint32(1);
1165  messageAfterBuild = builder.build();
1166  assertEquals(0, message.getRepeatedSint32Count());
1167  builder.setRepeatedSint32(0, 0);
1168  assertEquals(1, messageAfterBuild.getRepeatedSint32(0));
1169  assertEquals(0, builder.getRepeatedSint32(0));
1170  builder.clearRepeatedSint32();
1171 
1172  message = builder.build();
1173  builder.addRepeatedSint64(1L);
1174  messageAfterBuild = builder.build();
1175  assertEquals(0L, message.getRepeatedSint64Count());
1176  builder.setRepeatedSint64(0, 0L);
1177  assertEquals(1L, messageAfterBuild.getRepeatedSint64(0));
1178  assertEquals(0L, builder.getRepeatedSint64(0));
1179  builder.clearRepeatedSint64();
1180 
1181  message = builder.build();
1182  builder.addRepeatedString("hi");
1183  messageAfterBuild = builder.build();
1184  assertEquals(0L, message.getRepeatedStringCount());
1185  builder.setRepeatedString(0, "");
1186  assertEquals("hi", messageAfterBuild.getRepeatedString(0));
1187  assertEquals("", builder.getRepeatedString(0));
1188  builder.clearRepeatedString();
1189 
1190  message = builder.build();
1191  builder.addRepeatedStringBytes(ByteString.copyFromUtf8("hi"));
1192  messageAfterBuild = builder.build();
1193  assertEquals(0L, message.getRepeatedStringCount());
1194  builder.setRepeatedString(0, "");
1195  assertEquals(ByteString.copyFromUtf8("hi"), messageAfterBuild.getRepeatedStringBytes(0));
1196  assertEquals(ByteString.EMPTY, builder.getRepeatedStringBytes(0));
1197  builder.clearRepeatedString();
1198 
1199  message = builder.build();
1200  builder.addRepeatedStringPiece("hi");
1201  messageAfterBuild = builder.build();
1202  assertEquals(0L, message.getRepeatedStringPieceCount());
1203  builder.setRepeatedStringPiece(0, "");
1204  assertEquals("hi", messageAfterBuild.getRepeatedStringPiece(0));
1205  assertEquals("", builder.getRepeatedStringPiece(0));
1206  builder.clearRepeatedStringPiece();
1207 
1208  message = builder.build();
1209  builder.addRepeatedStringPieceBytes(ByteString.copyFromUtf8("hi"));
1210  messageAfterBuild = builder.build();
1211  assertEquals(0L, message.getRepeatedStringPieceCount());
1212  builder.setRepeatedStringPiece(0, "");
1213  assertEquals(ByteString.copyFromUtf8("hi"), messageAfterBuild.getRepeatedStringPieceBytes(0));
1214  assertEquals(ByteString.EMPTY, builder.getRepeatedStringPieceBytes(0));
1215  builder.clearRepeatedStringPiece();
1216 
1217  message = builder.build();
1218  builder.addRepeatedUint32(1);
1219  messageAfterBuild = builder.build();
1220  assertEquals(0, message.getRepeatedUint32Count());
1221  builder.setRepeatedUint32(0, 0);
1222  assertEquals(1, messageAfterBuild.getRepeatedUint32(0));
1223  assertEquals(0, builder.getRepeatedUint32(0));
1224  builder.clearRepeatedUint32();
1225 
1226  message = builder.build();
1227  builder.addRepeatedUint64(1L);
1228  messageAfterBuild = builder.build();
1229  assertEquals(0L, message.getRepeatedUint64Count());
1230  builder.setRepeatedUint64(0, 0L);
1231  assertEquals(1L, messageAfterBuild.getRepeatedUint64(0));
1232  assertEquals(0L, builder.getRepeatedUint64(0));
1233  builder.clearRepeatedUint64();
1234 
1235  message = builder.build();
1236  assertEquals(0, message.getSerializedSize());
1237  builder.mergeFrom(TestAllTypesLite.newBuilder().setOptionalBool(true).build());
1238  assertEquals(0, message.getSerializedSize());
1239  assertEquals(true, builder.build().getOptionalBool());
1240  builder.clearOptionalBool();
1241 
1242  message = builder.build();
1243  assertEquals(0, message.getSerializedSize());
1244  builder.mergeFrom(TestAllTypesLite.newBuilder().setOptionalBool(true).build());
1245  assertEquals(0, message.getSerializedSize());
1246  assertEquals(true, builder.build().getOptionalBool());
1247  builder.clear();
1248  assertEquals(0, builder.build().getSerializedSize());
1249 
1250  message = builder.build();
1251  assertEquals(0, message.getSerializedSize());
1252  builder.mergeOptionalForeignMessage(foreignMessage);
1253  assertEquals(0, message.getSerializedSize());
1254  assertEquals(foreignMessage.getC(), builder.build().getOptionalForeignMessage().getC());
1255  builder.clearOptionalForeignMessage();
1256 
1257  message = builder.build();
1258  assertEquals(0, message.getSerializedSize());
1259  builder.mergeOptionalLazyMessage(nestedMessage);
1260  assertEquals(0, message.getSerializedSize());
1261  assertEquals(nestedMessage.getBb(), builder.build().getOptionalLazyMessage().getBb());
1262  builder.clearOptionalLazyMessage();
1263 
1264  message = builder.build();
1265  builder.setOneofString("hi");
1266  assertEquals(OneofFieldCase.ONEOFFIELD_NOT_SET, message.getOneofFieldCase());
1267  assertEquals(OneofFieldCase.ONEOF_STRING, builder.getOneofFieldCase());
1268  assertEquals("hi", builder.getOneofString());
1269  messageAfterBuild = builder.build();
1270  assertEquals(OneofFieldCase.ONEOF_STRING, messageAfterBuild.getOneofFieldCase());
1271  assertEquals("hi", messageAfterBuild.getOneofString());
1272  builder.setOneofUint32(1);
1273  assertEquals(OneofFieldCase.ONEOF_STRING, messageAfterBuild.getOneofFieldCase());
1274  assertEquals("hi", messageAfterBuild.getOneofString());
1275  assertEquals(OneofFieldCase.ONEOF_UINT32, builder.getOneofFieldCase());
1276  assertEquals(1, builder.getOneofUint32());
1277  TestAllTypesLiteOrBuilder messageOrBuilder = builder;
1278  assertEquals(OneofFieldCase.ONEOF_UINT32, messageOrBuilder.getOneofFieldCase());
1279 
1280  TestAllExtensionsLite.Builder extendableMessageBuilder = TestAllExtensionsLite.newBuilder();
1281  TestAllExtensionsLite extendableMessage = extendableMessageBuilder.build();
1282  extendableMessageBuilder.setExtension(UnittestLite.optionalInt32ExtensionLite, 1);
1283  assertFalse(extendableMessage.hasExtension(UnittestLite.optionalInt32ExtensionLite));
1284  extendableMessage = extendableMessageBuilder.build();
1285  assertEquals(
1286  1, (int) extendableMessageBuilder.getExtension(UnittestLite.optionalInt32ExtensionLite));
1287  assertEquals(1, (int) extendableMessage.getExtension(UnittestLite.optionalInt32ExtensionLite));
1288  extendableMessageBuilder.setExtension(UnittestLite.optionalInt32ExtensionLite, 3);
1289  assertEquals(
1290  3, (int) extendableMessageBuilder.getExtension(UnittestLite.optionalInt32ExtensionLite));
1291  assertEquals(1, (int) extendableMessage.getExtension(UnittestLite.optionalInt32ExtensionLite));
1292  extendableMessage = extendableMessageBuilder.build();
1293  assertEquals(
1294  3, (int) extendableMessageBuilder.getExtension(UnittestLite.optionalInt32ExtensionLite));
1295  assertEquals(3, (int) extendableMessage.getExtension(UnittestLite.optionalInt32ExtensionLite));
1296 
1297  // No extension registry, so it should be in unknown fields.
1298  extendableMessage = TestAllExtensionsLite.parseFrom(extendableMessage.toByteArray());
1299  assertFalse(extendableMessage.hasExtension(UnittestLite.optionalInt32ExtensionLite));
1300 
1301  extendableMessageBuilder = extendableMessage.toBuilder();
1302  extendableMessageBuilder.mergeFrom(
1303  TestAllExtensionsLite.newBuilder()
1304  .setExtension(UnittestLite.optionalFixed32ExtensionLite, 11)
1305  .build());
1306 
1307  extendableMessage = extendableMessageBuilder.build();
1308  ExtensionRegistryLite registry = ExtensionRegistryLite.newInstance();
1309  UnittestLite.registerAllExtensions(registry);
1310  extendableMessage = TestAllExtensionsLite.parseFrom(extendableMessage.toByteArray(), registry);
1311 
1312  // The unknown field was preserved.
1313  assertEquals(3, (int) extendableMessage.getExtension(UnittestLite.optionalInt32ExtensionLite));
1314  assertEquals(
1315  11, (int) extendableMessage.getExtension(UnittestLite.optionalFixed32ExtensionLite));
1316  }
1317 
1318  public void testBuilderMergeFromNull() throws Exception {
1319  try {
1320  TestAllTypesLite.newBuilder().mergeFrom((TestAllTypesLite) null);
1321  fail("Expected exception");
1322  } catch (NullPointerException e) {
1323  // Pass.
1324  }
1325  }
1326 
1327  // Builder.mergeFrom() should keep existing extensions.
1328  public void testBuilderMergeFromWithExtensions() throws Exception {
1329  TestAllExtensionsLite message =
1330  TestAllExtensionsLite.newBuilder()
1331  .addExtension(UnittestLite.repeatedInt32ExtensionLite, 12)
1332  .build();
1333 
1334  ExtensionRegistryLite registry = ExtensionRegistryLite.newInstance();
1335  UnittestLite.registerAllExtensions(registry);
1336 
1337  TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.newBuilder();
1338  builder.mergeFrom(message.toByteArray(), registry);
1339  builder.mergeFrom(message.toByteArray(), registry);
1340  TestAllExtensionsLite result = builder.build();
1341  assertEquals(2, result.getExtensionCount(UnittestLite.repeatedInt32ExtensionLite));
1342  assertEquals(12, result.getExtension(UnittestLite.repeatedInt32ExtensionLite, 0).intValue());
1343  assertEquals(12, result.getExtension(UnittestLite.repeatedInt32ExtensionLite, 1).intValue());
1344  }
1345 
1346  // Builder.mergeFrom() should keep existing unknown fields.
1347  public void testBuilderMergeFromWithUnknownFields() throws Exception {
1348  TestAllTypesLite message = TestAllTypesLite.newBuilder().addRepeatedInt32(1).build();
1349 
1350  NestedMessage.Builder builder = NestedMessage.newBuilder();
1351  builder.mergeFrom(message.toByteArray());
1352  builder.mergeFrom(message.toByteArray());
1353  NestedMessage result = builder.build();
1354  assertEquals(message.getSerializedSize() * 2, result.getSerializedSize());
1355  }
1356 
1357  public void testToStringDefaultInstance() throws Exception {
1358  assertToStringEquals("", TestAllTypesLite.getDefaultInstance());
1359  }
1360 
1361  public void testToStringScalarFieldsSuffixedWithList() throws Exception {
1362  assertToStringEquals(
1363  "deceptively_named_list: 7",
1364  TestAllTypesLite.newBuilder().setDeceptivelyNamedList(7).build());
1365  }
1366 
1367  public void testToStringPrimitives() throws Exception {
1368  TestAllTypesLite proto =
1369  TestAllTypesLite.newBuilder()
1370  .setOptionalInt32(1)
1371  .setOptionalInt64(9223372036854775807L)
1372  .build();
1373  assertToStringEquals("optional_int32: 1\noptional_int64: 9223372036854775807", proto);
1374 
1375  proto =
1376  TestAllTypesLite.newBuilder()
1377  .setOptionalBool(true)
1378  .setOptionalNestedEnum(NestedEnum.BAZ)
1379  .build();
1380  assertToStringEquals(
1381  "optional_bool: true\noptional_nested_enum: " + NestedEnum.BAZ.toString(), proto);
1382 
1383  proto = TestAllTypesLite.newBuilder().setOptionalFloat(2.72f).setOptionalDouble(3.14).build();
1384  assertToStringEquals("optional_double: 3.14\noptional_float: 2.72", proto);
1385  }
1386 
1387 
1388  public void testToStringStringFields() throws Exception {
1389  TestAllTypesLite proto =
1390  TestAllTypesLite.newBuilder().setOptionalString("foo\"bar\nbaz\\").build();
1391  assertToStringEquals("optional_string: \"foo\\\"bar\\nbaz\\\\\"", proto);
1392 
1393  proto = TestAllTypesLite.newBuilder().setOptionalString("\u6587").build();
1394  assertToStringEquals("optional_string: \"\\346\\226\\207\"", proto);
1395  }
1396 
1397  public void testToStringNestedMessage() throws Exception {
1398  TestAllTypesLite proto =
1399  TestAllTypesLite.newBuilder()
1400  .setOptionalNestedMessage(NestedMessage.getDefaultInstance())
1401  .build();
1402  assertToStringEquals("optional_nested_message {\n}", proto);
1403 
1404  proto =
1405  TestAllTypesLite.newBuilder()
1406  .setOptionalNestedMessage(NestedMessage.newBuilder().setBb(7))
1407  .build();
1408  assertToStringEquals("optional_nested_message {\n bb: 7\n}", proto);
1409  }
1410 
1411  public void testToStringRepeatedFields() throws Exception {
1412  TestAllTypesLite proto =
1413  TestAllTypesLite.newBuilder()
1414  .addRepeatedInt32(32)
1415  .addRepeatedInt32(32)
1416  .addRepeatedInt64(64)
1417  .build();
1418  assertToStringEquals("repeated_int32: 32\nrepeated_int32: 32\nrepeated_int64: 64", proto);
1419 
1420  proto =
1421  TestAllTypesLite.newBuilder()
1422  .addRepeatedLazyMessage(NestedMessage.newBuilder().setBb(7))
1423  .addRepeatedLazyMessage(NestedMessage.newBuilder().setBb(8))
1424  .build();
1425  assertToStringEquals(
1426  "repeated_lazy_message {\n bb: 7\n}\nrepeated_lazy_message {\n bb: 8\n}", proto);
1427  }
1428 
1429  public void testToStringForeignFields() throws Exception {
1430  TestAllTypesLite proto =
1431  TestAllTypesLite.newBuilder()
1432  .setOptionalForeignEnum(ForeignEnumLite.FOREIGN_LITE_BAR)
1433  .setOptionalForeignMessage(ForeignMessageLite.newBuilder().setC(3))
1434  .build();
1435  assertToStringEquals(
1436  "optional_foreign_enum: "
1437  + ForeignEnumLite.FOREIGN_LITE_BAR
1438  + "\noptional_foreign_message {\n c: 3\n}",
1439  proto);
1440  }
1441 
1442  public void testToStringExtensions() throws Exception {
1443  TestAllExtensionsLite message =
1444  TestAllExtensionsLite.newBuilder()
1445  .setExtension(UnittestLite.optionalInt32ExtensionLite, 123)
1446  .addExtension(UnittestLite.repeatedStringExtensionLite, "spam")
1447  .addExtension(UnittestLite.repeatedStringExtensionLite, "eggs")
1448  .setExtension(UnittestLite.optionalNestedEnumExtensionLite, NestedEnum.BAZ)
1449  .setExtension(
1450  UnittestLite.optionalNestedMessageExtensionLite,
1451  NestedMessage.newBuilder().setBb(7).build())
1452  .build();
1453  assertToStringEquals(
1454  "[1]: 123\n[18] {\n bb: 7\n}\n[21]: 3\n[44]: \"spam\"\n[44]: \"eggs\"", message);
1455  }
1456 
1457  public void testToStringUnknownFields() throws Exception {
1458  TestAllExtensionsLite messageWithExtensions =
1459  TestAllExtensionsLite.newBuilder()
1460  .setExtension(UnittestLite.optionalInt32ExtensionLite, 123)
1461  .addExtension(UnittestLite.repeatedStringExtensionLite, "spam")
1462  .addExtension(UnittestLite.repeatedStringExtensionLite, "eggs")
1463  .setExtension(UnittestLite.optionalNestedEnumExtensionLite, NestedEnum.BAZ)
1464  .setExtension(
1465  UnittestLite.optionalNestedMessageExtensionLite,
1466  NestedMessage.newBuilder().setBb(7).build())
1467  .build();
1468  TestAllExtensionsLite messageWithUnknownFields =
1469  TestAllExtensionsLite.parseFrom(messageWithExtensions.toByteArray());
1470  assertToStringEquals(
1471  "1: 123\n18: \"\\b\\a\"\n21: 3\n44: \"spam\"\n44: \"eggs\"", messageWithUnknownFields);
1472  }
1473 
1474  public void testToStringLazyMessage() throws Exception {
1475  TestAllTypesLite message =
1476  TestAllTypesLite.newBuilder()
1477  .setOptionalLazyMessage(NestedMessage.newBuilder().setBb(1).build())
1478  .build();
1479  assertToStringEquals("optional_lazy_message {\n bb: 1\n}", message);
1480  }
1481 
1482  public void testToStringGroup() throws Exception {
1483  TestAllTypesLite message =
1484  TestAllTypesLite.newBuilder()
1485  .setOptionalGroup(OptionalGroup.newBuilder().setA(1).build())
1486  .build();
1487  assertToStringEquals("optional_group {\n a: 1\n}", message);
1488  }
1489 
1490  public void testToStringOneof() throws Exception {
1491  TestAllTypesLite message = TestAllTypesLite.newBuilder().setOneofString("hello").build();
1492  assertToStringEquals("oneof_string: \"hello\"", message);
1493  }
1494 
1495  public void testToStringMapFields() throws Exception {
1496  TestMap message1 =
1497  TestMap.newBuilder()
1498  .putInt32ToStringField(1, "alpha")
1499  .putInt32ToStringField(2, "beta")
1500  .build();
1501  assertToStringEquals(
1502  "int32_to_string_field {\n"
1503  + " key: 1\n"
1504  + " value: \"alpha\"\n"
1505  + "}\n"
1506  + "int32_to_string_field {\n"
1507  + " key: 2\n"
1508  + " value: \"beta\"\n"
1509  + "}",
1510  message1);
1511 
1512  TestMap message2 =
1513  TestMap.newBuilder()
1514  .putInt32ToMessageField(1, MessageValue.newBuilder().setValue(10).build())
1515  .putInt32ToMessageField(2, MessageValue.newBuilder().setValue(20).build())
1516  .build();
1517  assertToStringEquals(
1518  "int32_to_message_field {\n"
1519  + " key: 1\n"
1520  + " value {\n"
1521  + " value: 10\n"
1522  + " }\n"
1523  + "}\n"
1524  + "int32_to_message_field {\n"
1525  + " key: 2\n"
1526  + " value {\n"
1527  + " value: 20\n"
1528  + " }\n"
1529  + "}",
1530  message2);
1531  }
1532 
1533  // Asserts that the toString() representation of the message matches the expected. This verifies
1534  // the first line starts with a comment; but, does not factor in said comment as part of the
1535  // comparison as it contains unstable addresses.
1536  private static void assertToStringEquals(String expected, MessageLite message) {
1537  String toString = message.toString();
1538  assertEquals('#', toString.charAt(0));
1539  if (toString.contains("\n")) {
1540  toString = toString.substring(toString.indexOf("\n") + 1);
1541  } else {
1542  toString = "";
1543  }
1544  assertEquals(expected, toString);
1545  }
1546 
1547  public void testParseLazy() throws Exception {
1548  ByteString bb =
1549  TestAllTypesLite.newBuilder()
1550  .setOptionalLazyMessage(NestedMessage.newBuilder().setBb(11).build())
1551  .build()
1552  .toByteString();
1553  ByteString cc =
1554  TestAllTypesLite.newBuilder()
1555  .setOptionalLazyMessage(NestedMessage.newBuilder().setCc(22).build())
1556  .build()
1557  .toByteString();
1558 
1559  ByteString concat = bb.concat(cc);
1560  TestAllTypesLite message = TestAllTypesLite.parseFrom(concat);
1561 
1562  assertEquals(11, message.getOptionalLazyMessage().getBb());
1563  assertEquals(22L, message.getOptionalLazyMessage().getCc());
1564  }
1565 
1566  public void testParseLazy_oneOf() throws Exception {
1567  ByteString bb =
1568  TestAllTypesLite.newBuilder()
1569  .setOneofLazyNestedMessage(NestedMessage.newBuilder().setBb(11).build())
1570  .build()
1571  .toByteString();
1572  ByteString cc =
1573  TestAllTypesLite.newBuilder()
1574  .setOneofLazyNestedMessage(NestedMessage.newBuilder().setCc(22).build())
1575  .build()
1576  .toByteString();
1577 
1578  ByteString concat = bb.concat(cc);
1579  TestAllTypesLite message = TestAllTypesLite.parseFrom(concat);
1580 
1581  assertEquals(11, message.getOneofLazyNestedMessage().getBb());
1582  assertEquals(22L, message.getOneofLazyNestedMessage().getCc());
1583  }
1584 
1585  public void testMergeFromStream_repeatedField() throws Exception {
1586  TestAllTypesLite.Builder builder = TestAllTypesLite.newBuilder().addRepeatedString("hello");
1587  builder.mergeFrom(CodedInputStream.newInstance(builder.build().toByteArray()));
1588 
1589  assertEquals(2, builder.getRepeatedStringCount());
1590  }
1591 
1592  public void testMergeFromStream_invalidBytes() throws Exception {
1593  TestAllTypesLite.Builder builder = TestAllTypesLite.newBuilder().setDefaultBool(true);
1594  try {
1595  builder.mergeFrom(CodedInputStream.newInstance("Invalid bytes".getBytes(Internal.UTF_8)));
1596  fail();
1597  } catch (InvalidProtocolBufferException expected) {
1598  }
1599  }
1600 
1601  public void testMergeFrom_sanity() throws Exception {
1602  TestAllTypesLite one = TestUtilLite.getAllLiteSetBuilder().build();
1603  byte[] bytes = one.toByteArray();
1604  TestAllTypesLite two = TestAllTypesLite.parseFrom(bytes);
1605 
1606  one = one.toBuilder().mergeFrom(one).build();
1607  two = two.toBuilder().mergeFrom(bytes).build();
1608  assertEquals(one, two);
1609  assertEquals(two, one);
1610  assertEquals(one.hashCode(), two.hashCode());
1611  }
1612 
1613  public void testMergeFromNoLazyFieldSharing() throws Exception {
1614  TestAllTypesLite.Builder sourceBuilder =
1615  TestAllTypesLite.newBuilder().setOptionalLazyMessage(NestedMessage.newBuilder().setBb(1));
1616  TestAllTypesLite.Builder targetBuilder =
1617  TestAllTypesLite.newBuilder().mergeFrom(sourceBuilder.build());
1618  assertEquals(1, sourceBuilder.getOptionalLazyMessage().getBb());
1619  // now change the sourceBuilder, and target value shouldn't be affected.
1620  sourceBuilder.setOptionalLazyMessage(NestedMessage.newBuilder().setBb(2));
1621  assertEquals(1, targetBuilder.getOptionalLazyMessage().getBb());
1622  }
1623 
1624  public void testEquals_notEqual() throws Exception {
1625  TestAllTypesLite one = TestUtilLite.getAllLiteSetBuilder().build();
1626  byte[] bytes = one.toByteArray();
1627  TestAllTypesLite two = one.toBuilder().mergeFrom(one).mergeFrom(bytes).build();
1628 
1629  assertFalse(one.equals(two));
1630  assertFalse(two.equals(one));
1631 
1632  assertFalse(one.equals(TestAllTypesLite.getDefaultInstance()));
1633  assertFalse(TestAllTypesLite.getDefaultInstance().equals(one));
1634 
1635  TestAllTypesLite oneFieldSet = TestAllTypesLite.newBuilder().setDefaultBool(true).build();
1636  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1637  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1638 
1639  oneFieldSet = TestAllTypesLite.newBuilder().setDefaultBytes(ByteString.EMPTY).build();
1640  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1641  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1642 
1643  oneFieldSet = TestAllTypesLite.newBuilder().setDefaultCord("").build();
1644  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1645  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1646 
1647  oneFieldSet = TestAllTypesLite.newBuilder().setDefaultCordBytes(ByteString.EMPTY).build();
1648  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1649  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1650 
1651  oneFieldSet = TestAllTypesLite.newBuilder().setDefaultDouble(0).build();
1652  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1653  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1654 
1655  oneFieldSet = TestAllTypesLite.newBuilder().setDefaultFixed32(0).build();
1656  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1657  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1658 
1659  oneFieldSet = TestAllTypesLite.newBuilder().setDefaultFixed64(0).build();
1660  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1661  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1662 
1663  oneFieldSet = TestAllTypesLite.newBuilder().setDefaultFloat(0).build();
1664  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1665  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1666 
1667  oneFieldSet =
1668  TestAllTypesLite.newBuilder()
1669  .setDefaultForeignEnum(ForeignEnumLite.FOREIGN_LITE_BAR)
1670  .build();
1671  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1672  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1673 
1674  oneFieldSet =
1675  TestAllTypesLite.newBuilder().setDefaultImportEnum(ImportEnumLite.IMPORT_LITE_BAR).build();
1676  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1677  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1678 
1679  oneFieldSet = TestAllTypesLite.newBuilder().setDefaultInt32(0).build();
1680  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1681  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1682 
1683  oneFieldSet = TestAllTypesLite.newBuilder().setDefaultInt64(0).build();
1684  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1685  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1686 
1687  oneFieldSet = TestAllTypesLite.newBuilder().setDefaultNestedEnum(NestedEnum.BAR).build();
1688  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1689  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1690 
1691  oneFieldSet = TestAllTypesLite.newBuilder().setDefaultSfixed32(0).build();
1692  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1693  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1694 
1695  oneFieldSet = TestAllTypesLite.newBuilder().setDefaultSfixed64(0).build();
1696  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1697  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1698 
1699  oneFieldSet = TestAllTypesLite.newBuilder().setDefaultSint32(0).build();
1700  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1701  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1702 
1703  oneFieldSet = TestAllTypesLite.newBuilder().setDefaultSint64(0).build();
1704  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1705  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1706 
1707  oneFieldSet = TestAllTypesLite.newBuilder().setDefaultString("").build();
1708  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1709  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1710 
1711  oneFieldSet = TestAllTypesLite.newBuilder().setDefaultStringBytes(ByteString.EMPTY).build();
1712  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1713  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1714 
1715  oneFieldSet = TestAllTypesLite.newBuilder().setDefaultStringPiece("").build();
1716  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1717  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1718 
1719  oneFieldSet =
1720  TestAllTypesLite.newBuilder().setDefaultStringPieceBytes(ByteString.EMPTY).build();
1721  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1722  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1723 
1724  oneFieldSet = TestAllTypesLite.newBuilder().setDefaultUint32(0).build();
1725  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1726  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1727 
1728  oneFieldSet = TestAllTypesLite.newBuilder().setDefaultUint64(0).build();
1729  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1730  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1731 
1732  oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedBool(true).build();
1733  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1734  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1735 
1736  oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedBytes(ByteString.EMPTY).build();
1737  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1738  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1739 
1740  oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedCord("").build();
1741  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1742  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1743 
1744  oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedCordBytes(ByteString.EMPTY).build();
1745  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1746  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1747 
1748  oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedDouble(0).build();
1749  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1750  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1751 
1752  oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedFixed32(0).build();
1753  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1754  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1755 
1756  oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedFixed64(0).build();
1757  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1758  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1759 
1760  oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedFloat(0).build();
1761  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1762  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1763 
1764  oneFieldSet =
1765  TestAllTypesLite.newBuilder()
1766  .addRepeatedForeignEnum(ForeignEnumLite.FOREIGN_LITE_BAR)
1767  .build();
1768  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1769  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1770 
1771  oneFieldSet =
1772  TestAllTypesLite.newBuilder().addRepeatedImportEnum(ImportEnumLite.IMPORT_LITE_BAR).build();
1773  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1774  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1775 
1776  oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedInt32(0).build();
1777  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1778  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1779 
1780  oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedInt64(0).build();
1781  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1782  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1783 
1784  oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedNestedEnum(NestedEnum.BAR).build();
1785  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1786  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1787 
1788  oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedSfixed32(0).build();
1789  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1790  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1791 
1792  oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedSfixed64(0).build();
1793  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1794  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1795 
1796  oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedSint32(0).build();
1797  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1798  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1799 
1800  oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedSint64(0).build();
1801  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1802  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1803 
1804  oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedString("").build();
1805  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1806  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1807 
1808  oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedStringBytes(ByteString.EMPTY).build();
1809  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1810  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1811 
1812  oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedStringPiece("").build();
1813  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1814  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1815 
1816  oneFieldSet =
1817  TestAllTypesLite.newBuilder().addRepeatedStringPieceBytes(ByteString.EMPTY).build();
1818  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1819  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1820 
1821  oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedUint32(0).build();
1822  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1823  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1824 
1825  oneFieldSet = TestAllTypesLite.newBuilder().addRepeatedUint64(0).build();
1826  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1827  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1828 
1829  oneFieldSet = TestAllTypesLite.newBuilder().setOptionalBool(true).build();
1830  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1831  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1832 
1833  oneFieldSet = TestAllTypesLite.newBuilder().setOptionalBytes(ByteString.EMPTY).build();
1834  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1835  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1836 
1837  oneFieldSet = TestAllTypesLite.newBuilder().setOptionalCord("").build();
1838  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1839  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1840 
1841  oneFieldSet = TestAllTypesLite.newBuilder().setOptionalCordBytes(ByteString.EMPTY).build();
1842  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1843  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1844 
1845  oneFieldSet = TestAllTypesLite.newBuilder().setOptionalDouble(0).build();
1846  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1847  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1848 
1849  oneFieldSet = TestAllTypesLite.newBuilder().setOptionalFixed32(0).build();
1850  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1851  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1852 
1853  oneFieldSet = TestAllTypesLite.newBuilder().setOptionalFixed64(0).build();
1854  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1855  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1856 
1857  oneFieldSet = TestAllTypesLite.newBuilder().setOptionalFloat(0).build();
1858  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1859  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1860 
1861  oneFieldSet =
1862  TestAllTypesLite.newBuilder()
1863  .setOptionalForeignEnum(ForeignEnumLite.FOREIGN_LITE_BAR)
1864  .build();
1865  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1866  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1867 
1868  oneFieldSet =
1869  TestAllTypesLite.newBuilder().setOptionalImportEnum(ImportEnumLite.IMPORT_LITE_BAR).build();
1870  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1871  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1872 
1873  oneFieldSet = TestAllTypesLite.newBuilder().setOptionalInt32(0).build();
1874  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1875  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1876 
1877  oneFieldSet = TestAllTypesLite.newBuilder().setOptionalInt64(0).build();
1878  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1879  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1880 
1881  oneFieldSet = TestAllTypesLite.newBuilder().setOptionalNestedEnum(NestedEnum.BAR).build();
1882  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1883  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1884 
1885  oneFieldSet = TestAllTypesLite.newBuilder().setOptionalSfixed32(0).build();
1886  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1887  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1888 
1889  oneFieldSet = TestAllTypesLite.newBuilder().setOptionalSfixed64(0).build();
1890  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1891  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1892 
1893  oneFieldSet = TestAllTypesLite.newBuilder().setOptionalSint32(0).build();
1894  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1895  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1896 
1897  oneFieldSet = TestAllTypesLite.newBuilder().setOptionalSint64(0).build();
1898  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1899  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1900 
1901  oneFieldSet = TestAllTypesLite.newBuilder().setOptionalString("").build();
1902  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1903  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1904 
1905  oneFieldSet = TestAllTypesLite.newBuilder().setOptionalStringBytes(ByteString.EMPTY).build();
1906  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1907  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1908 
1909  oneFieldSet = TestAllTypesLite.newBuilder().setOptionalStringPiece("").build();
1910  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1911  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1912 
1913  oneFieldSet =
1914  TestAllTypesLite.newBuilder().setOptionalStringPieceBytes(ByteString.EMPTY).build();
1915  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1916  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1917 
1918  oneFieldSet = TestAllTypesLite.newBuilder().setOptionalUint32(0).build();
1919  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1920  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1921 
1922  oneFieldSet = TestAllTypesLite.newBuilder().setOptionalUint64(0).build();
1923  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1924  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1925 
1926  oneFieldSet = TestAllTypesLite.newBuilder().setOneofBytes(ByteString.EMPTY).build();
1927  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1928  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1929 
1930  oneFieldSet =
1931  TestAllTypesLite.newBuilder()
1932  .setOneofLazyNestedMessage(NestedMessage.getDefaultInstance())
1933  .build();
1934  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1935  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1936 
1937  oneFieldSet =
1938  TestAllTypesLite.newBuilder()
1939  .setOneofNestedMessage(NestedMessage.getDefaultInstance())
1940  .build();
1941  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1942  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1943 
1944  oneFieldSet = TestAllTypesLite.newBuilder().setOneofString("").build();
1945  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1946  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1947 
1948  oneFieldSet = TestAllTypesLite.newBuilder().setOneofStringBytes(ByteString.EMPTY).build();
1949  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1950  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1951 
1952  oneFieldSet = TestAllTypesLite.newBuilder().setOneofUint32(0).build();
1953  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1954  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1955 
1956  oneFieldSet =
1957  TestAllTypesLite.newBuilder()
1958  .setOptionalForeignMessage(ForeignMessageLite.getDefaultInstance())
1959  .build();
1960  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1961  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1962 
1963  oneFieldSet =
1964  TestAllTypesLite.newBuilder().setOptionalGroup(OptionalGroup.getDefaultInstance()).build();
1965  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1966  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1967 
1968  oneFieldSet =
1969  TestAllTypesLite.newBuilder()
1970  .setOptionalPublicImportMessage(PublicImportMessageLite.getDefaultInstance())
1971  .build();
1972  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1973  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1974 
1975  oneFieldSet =
1976  TestAllTypesLite.newBuilder()
1977  .setOptionalLazyMessage(NestedMessage.getDefaultInstance())
1978  .build();
1979  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1980 
1981  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1982  oneFieldSet =
1983  TestAllTypesLite.newBuilder()
1984  .addRepeatedLazyMessage(NestedMessage.getDefaultInstance())
1985  .build();
1986  assertFalse(oneFieldSet.equals(TestAllTypesLite.getDefaultInstance()));
1987  assertFalse(TestAllTypesLite.getDefaultInstance().equals(oneFieldSet));
1988  }
1989 
1990  public void testEquals() throws Exception {
1991  // Check that two identical objs are equal.
1992  Foo foo1a = Foo.newBuilder().setValue(1).addBar(Bar.newBuilder().setName("foo1")).build();
1993  Foo foo1b = Foo.newBuilder().setValue(1).addBar(Bar.newBuilder().setName("foo1")).build();
1994  Foo foo2 = Foo.newBuilder().setValue(1).addBar(Bar.newBuilder().setName("foo2")).build();
1995 
1996  // Check that equals is doing value rather than object equality.
1997  assertEquals(foo1a, foo1b);
1998  assertEquals(foo1a.hashCode(), foo1b.hashCode());
1999 
2000  // Check that a diffeent object is not equal.
2001  assertFalse(foo1a.equals(foo2));
2002 
2003  // Check that two objects which have different types but the same field values are not
2004  // considered to be equal.
2005  Bar bar = Bar.newBuilder().setName("bar").build();
2006  BarPrime barPrime = BarPrime.newBuilder().setName("bar").build();
2007  assertFalse(bar.equals(barPrime));
2008  }
2009 
2010  public void testEqualsAndHashCodeForTrickySchemaTypes() {
2011  Foo foo1 = Foo.getDefaultInstance();
2012  Foo foo2 = Foo.newBuilder().setSint64(1).build();
2013  Foo foo3 = Foo.newBuilder().putMyMap("key", "value2").build();
2014  Foo foo4 = Foo.newBuilder().setMyGroup(Foo.MyGroup.newBuilder().setValue(4).build()).build();
2015 
2016  assertEqualsAndHashCodeAreFalse(foo1, foo2);
2017  assertEqualsAndHashCodeAreFalse(foo1, foo3);
2018  assertEqualsAndHashCodeAreFalse(foo1, foo4);
2019  }
2020 
2021  public void testOneofEquals() throws Exception {
2022  TestOneofEquals.Builder builder = TestOneofEquals.newBuilder();
2023  TestOneofEquals message1 = builder.build();
2024  // Set message2's name field to default value. The two messages should be different when we
2025  // check with the oneof case.
2026  builder.setName("");
2027  TestOneofEquals message2 = builder.build();
2028  assertFalse(message1.equals(message2));
2029  }
2030 
2031  public void testEquals_sanity() throws Exception {
2032  TestAllTypesLite one = TestUtilLite.getAllLiteSetBuilder().build();
2033  TestAllTypesLite two = TestAllTypesLite.parseFrom(one.toByteArray());
2034  assertEquals(one, two);
2035  assertEquals(one.hashCode(), two.hashCode());
2036 
2037  assertEquals(
2038  one.toBuilder().mergeFrom(two).build(),
2039  two.toBuilder().mergeFrom(two.toByteArray()).build());
2040  }
2041 
2042  public void testEqualsAndHashCodeWithUnknownFields() throws InvalidProtocolBufferException {
2043  Foo fooWithOnlyValue = Foo.newBuilder().setValue(1).build();
2044 
2045  Foo fooWithValueAndExtension =
2046  fooWithOnlyValue
2047  .toBuilder()
2048  .setValue(1)
2049  .setExtension(Bar.fooExt, Bar.newBuilder().setName("name").build())
2050  .build();
2051 
2052  Foo fooWithValueAndUnknownFields = Foo.parseFrom(fooWithValueAndExtension.toByteArray());
2053 
2054  assertEqualsAndHashCodeAreFalse(fooWithOnlyValue, fooWithValueAndUnknownFields);
2055  assertEqualsAndHashCodeAreFalse(fooWithValueAndExtension, fooWithValueAndUnknownFields);
2056  }
2057 
2058  public void testEqualsAndHashCodeWithExtensions() throws InvalidProtocolBufferException {
2059  Foo fooWithOnlyValue = Foo.newBuilder().setValue(1).build();
2060 
2061  Foo fooWithValueAndExtension =
2062  fooWithOnlyValue
2063  .toBuilder()
2064  .setValue(1)
2065  .setExtension(Bar.fooExt, Bar.newBuilder().setName("name").build())
2066  .build();
2067 
2068  assertEqualsAndHashCodeAreFalse(fooWithOnlyValue, fooWithValueAndExtension);
2069  }
2070 
2071  // Test to ensure we avoid a class cast exception with oneofs.
2072  public void testEquals_oneOfMessages() {
2073  TestAllTypesLite mine = TestAllTypesLite.newBuilder().setOneofString("Hello").build();
2074 
2075  TestAllTypesLite other =
2076  TestAllTypesLite.newBuilder()
2077  .setOneofNestedMessage(NestedMessage.getDefaultInstance())
2078  .build();
2079 
2080  assertFalse(mine.equals(other));
2081  assertFalse(other.equals(mine));
2082  }
2083 
2084  public void testHugeFieldNumbers() throws InvalidProtocolBufferException {
2085  TestHugeFieldNumbersLite message =
2086  TestHugeFieldNumbersLite.newBuilder()
2087  .setOptionalInt32(1)
2088  .addRepeatedInt32(2)
2089  .setOptionalEnum(ForeignEnumLite.FOREIGN_LITE_FOO)
2090  .setOptionalString("xyz")
2091  .setOptionalMessage(ForeignMessageLite.newBuilder().setC(3).build())
2092  .build();
2093 
2094  TestHugeFieldNumbersLite parsedMessage =
2095  TestHugeFieldNumbersLite.parseFrom(message.toByteArray());
2096  assertEquals(1, parsedMessage.getOptionalInt32());
2097  assertEquals(2, parsedMessage.getRepeatedInt32(0));
2098  assertEquals(ForeignEnumLite.FOREIGN_LITE_FOO, parsedMessage.getOptionalEnum());
2099  assertEquals("xyz", parsedMessage.getOptionalString());
2100  assertEquals(3, parsedMessage.getOptionalMessage().getC());
2101  }
2102 
2103  private void assertEqualsAndHashCodeAreFalse(Object o1, Object o2) {
2104  assertFalse(o1.equals(o2));
2105  assertFalse(o1.hashCode() == o2.hashCode());
2106  }
2107 
2108  public void testRecursiveHashcode() {
2109  // This tests that we don't infinite loop.
2110  TestRecursiveOneof.getDefaultInstance().hashCode();
2111  }
2112 
2113  public void testParseFromByteBuffer() throws Exception {
2114  TestAllTypesLite message =
2115  TestAllTypesLite.newBuilder()
2116  .setOptionalInt32(123)
2117  .addRepeatedString("hello")
2118  .setOptionalNestedMessage(NestedMessage.newBuilder().setBb(7))
2119  .build();
2120 
2121  TestAllTypesLite copy =
2122  TestAllTypesLite.parseFrom(message.toByteString().asReadOnlyByteBuffer());
2123 
2124  assertEquals(message, copy);
2125  }
2126 
2127  public void testParseFromByteBufferThrows() {
2128  try {
2129  TestAllTypesLite.parseFrom(ByteBuffer.wrap(new byte[] {0x5}));
2130  fail();
2131  } catch (InvalidProtocolBufferException expected) {
2132  }
2133 
2134  TestAllTypesLite message =
2135  TestAllTypesLite.newBuilder().setOptionalInt32(123).addRepeatedString("hello").build();
2136 
2137  ByteBuffer buffer = ByteBuffer.wrap(message.toByteArray(), 0, message.getSerializedSize() - 1);
2138  try {
2139  TestAllTypesLite.parseFrom(buffer);
2140  fail();
2141  } catch (InvalidProtocolBufferException expected) {
2142  assertEquals(
2143  TestAllTypesLite.newBuilder().setOptionalInt32(123).build(),
2144  expected.getUnfinishedMessage());
2145  }
2146  }
2147 
2148  public void testParseFromByteBuffer_extensions() throws Exception {
2149  TestAllExtensionsLite message =
2150  TestAllExtensionsLite.newBuilder()
2151  .setExtension(UnittestLite.optionalInt32ExtensionLite, 123)
2152  .addExtension(UnittestLite.repeatedStringExtensionLite, "hello")
2153  .setExtension(UnittestLite.optionalNestedEnumExtensionLite, NestedEnum.BAZ)
2154  .setExtension(
2155  UnittestLite.optionalNestedMessageExtensionLite,
2156  NestedMessage.newBuilder().setBb(7).build())
2157  .build();
2158 
2159  ExtensionRegistryLite registry = ExtensionRegistryLite.newInstance();
2160  UnittestLite.registerAllExtensions(registry);
2161 
2162  TestAllExtensionsLite copy =
2163  TestAllExtensionsLite.parseFrom(message.toByteString().asReadOnlyByteBuffer(), registry);
2164 
2165  assertEquals(message, copy);
2166  }
2167 
2168  public void testParseFromByteBufferThrows_extensions() {
2169  ExtensionRegistryLite registry = ExtensionRegistryLite.newInstance();
2170  UnittestLite.registerAllExtensions(registry);
2171  try {
2172  TestAllExtensionsLite.parseFrom(ByteBuffer.wrap(new byte[] {0x5}), registry);
2173  fail();
2174  } catch (InvalidProtocolBufferException expected) {
2175  }
2176 
2177  TestAllExtensionsLite message =
2178  TestAllExtensionsLite.newBuilder()
2179  .setExtension(UnittestLite.optionalInt32ExtensionLite, 123)
2180  .addExtension(UnittestLite.repeatedStringExtensionLite, "hello")
2181  .build();
2182 
2183  ByteBuffer buffer = ByteBuffer.wrap(message.toByteArray(), 0, message.getSerializedSize() - 1);
2184  try {
2185  TestAllExtensionsLite.parseFrom(buffer, registry);
2186  fail();
2187  } catch (InvalidProtocolBufferException expected) {
2188  assertEquals(
2189  TestAllExtensionsLite.newBuilder()
2190  .setExtension(UnittestLite.optionalInt32ExtensionLite, 123)
2191  .build(),
2192  expected.getUnfinishedMessage());
2193  }
2194  }
2195 
2196  // Make sure we haven't screwed up the code generation for packing fields by default.
2197  public void testPackedSerialization() throws Exception {
2198  TestAllTypes.Builder builder = TestAllTypes.newBuilder();
2199  builder.addRepeatedInt32(4321);
2200  builder.addRepeatedNestedEnum(TestAllTypes.NestedEnum.BAZ);
2201  TestAllTypes message = builder.build();
2202 
2203  CodedInputStream in = CodedInputStream.newInstance(message.toByteArray());
2204 
2205  while (!in.isAtEnd()) {
2206  int tag = in.readTag();
2207  assertEquals(WireFormat.WIRETYPE_LENGTH_DELIMITED, WireFormat.getTagWireType(tag));
2208  in.skipField(tag);
2209  }
2210  }
2211 
2212  public void testAddAllIteratesOnce() {
2213  TestAllTypesLite.newBuilder()
2214  .addAllRepeatedBool(new OneTimeIterableList<>(false))
2215  .addAllRepeatedInt32(new OneTimeIterableList<>(0))
2216  .addAllRepeatedInt64(new OneTimeIterableList<>(0L))
2217  .addAllRepeatedFloat(new OneTimeIterableList<>(0f))
2218  .addAllRepeatedDouble(new OneTimeIterableList<>(0d))
2219  .addAllRepeatedBytes(new OneTimeIterableList<>(ByteString.EMPTY))
2220  .addAllRepeatedString(new OneTimeIterableList<>(""))
2221  .addAllRepeatedNestedMessage(new OneTimeIterableList<>(NestedMessage.getDefaultInstance()))
2222  .addAllRepeatedBool(new OneTimeIterable<>(false))
2223  .addAllRepeatedInt32(new OneTimeIterable<>(0))
2224  .addAllRepeatedInt64(new OneTimeIterable<>(0L))
2225  .addAllRepeatedFloat(new OneTimeIterable<>(0f))
2226  .addAllRepeatedDouble(new OneTimeIterable<>(0d))
2227  .addAllRepeatedBytes(new OneTimeIterable<>(ByteString.EMPTY))
2228  .addAllRepeatedString(new OneTimeIterable<>(""))
2229  .addAllRepeatedNestedMessage(new OneTimeIterable<>(NestedMessage.getDefaultInstance()))
2230  .build();
2231  }
2232 
2233  public void testAddAllIteratesOnce_throwsOnNull() {
2234  TestAllTypesLite.Builder builder = TestAllTypesLite.newBuilder();
2235  try {
2236  builder.addAllRepeatedBool(new OneTimeIterableList<>(true, false, null));
2237  fail();
2238  } catch (NullPointerException expected) {
2239  assertEquals("Element at index 2 is null.", expected.getMessage());
2240  assertEquals(0, builder.getRepeatedBoolCount());
2241  }
2242 
2243  try {
2244  builder.addAllRepeatedBool(new OneTimeIterable<>(true, false, null));
2245  fail();
2246  } catch (NullPointerException expected) {
2247  assertEquals("Element at index 2 is null.", expected.getMessage());
2248  assertEquals(0, builder.getRepeatedBoolCount());
2249  }
2250 
2251  try {
2252  builder = TestAllTypesLite.newBuilder();
2253  builder.addAllRepeatedBool(new OneTimeIterableList<>((Boolean) null));
2254  fail();
2255  } catch (NullPointerException expected) {
2256  assertEquals("Element at index 0 is null.", expected.getMessage());
2257  assertEquals(0, builder.getRepeatedBoolCount());
2258  }
2259 
2260  try {
2261  builder = TestAllTypesLite.newBuilder();
2262  builder.addAllRepeatedInt32(new OneTimeIterableList<>((Integer) null));
2263  fail();
2264  } catch (NullPointerException expected) {
2265  assertEquals("Element at index 0 is null.", expected.getMessage());
2266  assertEquals(0, builder.getRepeatedInt32Count());
2267  }
2268 
2269  try {
2270  builder = TestAllTypesLite.newBuilder();
2271  builder.addAllRepeatedInt64(new OneTimeIterableList<>((Long) null));
2272  fail();
2273  } catch (NullPointerException expected) {
2274  assertEquals("Element at index 0 is null.", expected.getMessage());
2275  assertEquals(0, builder.getRepeatedInt64Count());
2276  }
2277 
2278  try {
2279  builder = TestAllTypesLite.newBuilder();
2280  builder.addAllRepeatedFloat(new OneTimeIterableList<>((Float) null));
2281  fail();
2282  } catch (NullPointerException expected) {
2283  assertEquals("Element at index 0 is null.", expected.getMessage());
2284  assertEquals(0, builder.getRepeatedFloatCount());
2285  }
2286 
2287  try {
2288  builder = TestAllTypesLite.newBuilder();
2289  builder.addAllRepeatedDouble(new OneTimeIterableList<>((Double) null));
2290  fail();
2291  } catch (NullPointerException expected) {
2292  assertEquals("Element at index 0 is null.", expected.getMessage());
2293  assertEquals(0, builder.getRepeatedDoubleCount());
2294  }
2295 
2296  try {
2297  builder = TestAllTypesLite.newBuilder();
2298  builder.addAllRepeatedBytes(new OneTimeIterableList<>((ByteString) null));
2299  fail();
2300  } catch (NullPointerException expected) {
2301  assertEquals("Element at index 0 is null.", expected.getMessage());
2302  assertEquals(0, builder.getRepeatedBytesCount());
2303  }
2304 
2305  try {
2306  builder = TestAllTypesLite.newBuilder();
2307  builder.addAllRepeatedString(new OneTimeIterableList<>("", "", null, ""));
2308  fail();
2309  } catch (NullPointerException expected) {
2310  assertEquals("Element at index 2 is null.", expected.getMessage());
2311  assertEquals(0, builder.getRepeatedStringCount());
2312  }
2313 
2314  try {
2315  builder = TestAllTypesLite.newBuilder();
2316  builder.addAllRepeatedString(new OneTimeIterable<>("", "", null, ""));
2317  fail();
2318  } catch (NullPointerException expected) {
2319  assertEquals("Element at index 2 is null.", expected.getMessage());
2320  assertEquals(0, builder.getRepeatedStringCount());
2321  }
2322 
2323  try {
2324  builder = TestAllTypesLite.newBuilder();
2325  builder.addAllRepeatedString(new OneTimeIterableList<>((String) null));
2326  fail();
2327  } catch (NullPointerException expected) {
2328  assertEquals("Element at index 0 is null.", expected.getMessage());
2329  assertEquals(0, builder.getRepeatedStringCount());
2330  }
2331 
2332  try {
2333  builder = TestAllTypesLite.newBuilder();
2334  builder.addAllRepeatedNestedMessage(new OneTimeIterableList<>((NestedMessage) null));
2335  fail();
2336  } catch (NullPointerException expected) {
2337  assertEquals("Element at index 0 is null.", expected.getMessage());
2338  assertEquals(0, builder.getRepeatedNestedMessageCount());
2339  }
2340  }
2341 
2342  public void testExtensionRenamesKeywords() {
2343  assertTrue(NonNestedExtensionLite.package_ instanceof GeneratedMessageLite.GeneratedExtension);
2344  assertTrue(
2345  NestedExtensionLite.MyNestedExtensionLite.private_
2346  instanceof GeneratedMessageLite.GeneratedExtension);
2347 
2348  NonNestedExtensionLite.MessageLiteToBeExtended msg =
2349  NonNestedExtensionLite.MessageLiteToBeExtended.newBuilder()
2350  .setExtension(NonNestedExtensionLite.package_, true)
2351  .build();
2352  assertTrue(msg.getExtension(NonNestedExtensionLite.package_));
2353 
2354  msg =
2355  NonNestedExtensionLite.MessageLiteToBeExtended.newBuilder()
2356  .setExtension(NestedExtensionLite.MyNestedExtensionLite.private_, 2.4)
2357  .build();
2358  assertEquals(
2359  2.4, msg.getExtension(NestedExtensionLite.MyNestedExtensionLite.private_), 0.001);
2360  }
2361 
2362  private static final class OneTimeIterableList<T> extends ArrayList<T> {
2363  private boolean wasIterated = false;
2364 
2365  OneTimeIterableList(T... contents) {
2366  addAll(Arrays.asList(contents));
2367  }
2368 
2369  @Override
2370  public Iterator<T> iterator() {
2371  if (wasIterated) {
2372  fail();
2373  }
2374  wasIterated = true;
2375  return super.iterator();
2376  }
2377  }
2378 
2379  private static final class OneTimeIterable<T> implements Iterable<T> {
2380  private final List<T> list;
2381  private boolean wasIterated = false;
2382 
2383  OneTimeIterable(T... contents) {
2384  list = Arrays.asList(contents);
2385  }
2386 
2387  @Override
2388  public Iterator<T> iterator() {
2389  if (wasIterated) {
2390  fail();
2391  }
2392  wasIterated = true;
2393  return list.iterator();
2394  }
2395  }
2396 
2397  public void testNullExtensionRegistry() throws Exception {
2398  try {
2399  TestAllTypesLite.parseFrom(new byte[] {}, null);
2400  fail();
2401  } catch (NullPointerException expected) {
2402  }
2403  }
2404 
2405  public void testSerializeToOutputStreamThrowsIOException() {
2406  try {
2407  TestAllTypesLite.newBuilder()
2408  .setOptionalBytes(ByteString.copyFromUtf8("hello"))
2409  .build()
2410  .writeTo(
2411  new OutputStream() {
2412 
2413  @Override
2414  public void write(int b) throws IOException {
2415  throw new IOException();
2416  }
2417  });
2418  fail();
2419  } catch (IOException expected) {
2420  }
2421  }
2422 
2423  public void testUnpairedSurrogatesReplacedByQuestionMark() throws InvalidProtocolBufferException {
2424  String testString = "foo \ud83d bar";
2425  String expectedString = "foo ? bar";
2426 
2427  TestAllTypesLite testMessage =
2428  TestAllTypesLite.newBuilder().setOptionalString(testString).build();
2429  ByteString serializedMessage = testMessage.toByteString();
2430 
2431  // Behavior is compatible with String.getBytes("UTF-8"), which replaces
2432  // unpaired surrogates with a question mark.
2433  TestAllTypesLite parsedMessage = TestAllTypesLite.parseFrom(serializedMessage);
2434  assertEquals(expectedString, parsedMessage.getOptionalString());
2435 
2436  // Conversion happens during serialization.
2437  ByteString expectedBytes = ByteString.copyFromUtf8(expectedString);
2438  assertTrue(
2439  String.format(
2440  "Expected serializedMessage (%s) to contain \"%s\" (%s).",
2441  encodeHex(serializedMessage), expectedString, encodeHex(expectedBytes)),
2442  contains(serializedMessage, expectedBytes));
2443  }
2444 
2445  private String encodeHex(ByteString bytes) {
2446  String hexDigits = "0123456789abcdef";
2447  StringBuilder stringBuilder = new StringBuilder(bytes.size() * 2);
2448  for (byte b : bytes) {
2449  stringBuilder.append(hexDigits.charAt((b & 0xf0) >> 4));
2450  stringBuilder.append(hexDigits.charAt(b & 0x0f));
2451  }
2452  return stringBuilder.toString();
2453  }
2454 
2455  private boolean contains(ByteString a, ByteString b) {
2456  for (int i = 0; i <= a.size() - b.size(); ++i) {
2457  if (a.substring(i, i + b.size()).equals(b)) {
2458  return true;
2459  }
2460  }
2461  return false;
2462  }
2463 }
java::lang
com.google.protobuf.LiteTest.testToStringNestedMessage
void testToStringNestedMessage()
Definition: LiteTest.java:1397
com.google.protobuf.LiteTest.testUnpairedSurrogatesReplacedByQuestionMark
void testUnpairedSurrogatesReplacedByQuestionMark()
Definition: LiteTest.java:2423
com.google.protobuf.LiteTest.testMergeFrom_sanity
void testMergeFrom_sanity()
Definition: LiteTest.java:1601
com.google.protobuf.LiteTest.testLite
void testLite()
Definition: LiteTest.java:89
com.google.protobuf.LiteTest.testLiteExtensions
void testLiteExtensions()
Definition: LiteTest.java:129
com.google.protobuf.InvalidProtocolBufferException.getUnfinishedMessage
MessageLite getUnfinishedMessage()
Definition: InvalidProtocolBufferException.java:71
com.google.protobuf.CodedInputStream.newInstance
static CodedInputStream newInstance(final InputStream input)
Definition: CodedInputStream.java:79
com.google.protobuf.LiteTest.testPackedSerialization
void testPackedSerialization()
Definition: LiteTest.java:2197
com.google.protobuf.LiteTest.testLite_unknownEnumAtListBoundary
void testLite_unknownEnumAtListBoundary()
Definition: LiteTest.java:115
com.google.protobuf.GeneratedMessageLite
Definition: GeneratedMessageLite.java:60
com.google.protobuf.LiteTest.OneTimeIterable.wasIterated
boolean wasIterated
Definition: LiteTest.java:2381
com.google.protobuf.LiteTest.OneTimeIterableList.wasIterated
boolean wasIterated
Definition: LiteTest.java:2363
com.google.protobuf.LiteTest.testAddAllIteratesOnce_throwsOnNull
void testAddAllIteratesOnce_throwsOnNull()
Definition: LiteTest.java:2233
com.google.protobuf.TestUtilLite.getAllLiteSetBuilder
static TestAllTypesLite.Builder getAllLiteSetBuilder()
Definition: TestUtilLite.java:153
bar
Definition: googletest-output-test_.cc:550
com.google.protobuf.LiteTest.encodeHex
String encodeHex(ByteString bytes)
Definition: LiteTest.java:2445
com.google.protobuf.LiteTest.testToStringUnknownFields
void testToStringUnknownFields()
Definition: LiteTest.java:1457
com.google.protobuf.LiteTest.testParseFromByteBuffer
void testParseFromByteBuffer()
Definition: LiteTest.java:2113
com.google.protobuf.LiteTest.testParseFromByteBufferThrows
void testParseFromByteBufferThrows()
Definition: LiteTest.java:2127
com.google.protobuf.LiteTest.testMergeFromStream_repeatedField
void testMergeFromStream_repeatedField()
Definition: LiteTest.java:1585
com.google.protobuf.LiteTest.testMergeFromNoLazyFieldSharing
void testMergeFromNoLazyFieldSharing()
Definition: LiteTest.java:1613
com.google.protobuf.LiteTest.testBuilderMergeFromWithExtensions
void testBuilderMergeFromWithExtensions()
Definition: LiteTest.java:1328
com.google.protobuf
Definition: ProtoCaliperBenchmark.java:2
com.google.protobuf.LiteTest.testToStringExtensions
void testToStringExtensions()
Definition: LiteTest.java:1442
com.google.protobuf.ExtensionRegistryLite.newInstance
static ExtensionRegistryLite newInstance()
Definition: ExtensionRegistryLite.java:113
com.google.protobuf.LiteTest.testToStringPrimitives
void testToStringPrimitives()
Definition: LiteTest.java:1367
com.google.protobuf.ByteString.EMPTY
static final ByteString EMPTY
Definition: ByteString.java:85
java::lang::reflect
com.google.protobuf.WireFormat
Definition: WireFormat.java:45
T
#define T(upbtypeconst, upbtype, ctype, default_value)
com.google.protobuf.LiteTest.testAddAll
void testAddAll()
Definition: LiteTest.java:170
com.google.protobuf.LiteTest.testOneofEquals
void testOneofEquals()
Definition: LiteTest.java:2021
bytes
uint8 bytes[10]
Definition: coded_stream_unittest.cc:153
com.google.protobuf.LiteTest.OneTimeIterable.iterator
Iterator< T > iterator()
Definition: LiteTest.java:2388
com.google.protobuf.LiteTest.testSerializeToOutputStreamThrowsIOException
void testSerializeToOutputStreamThrowsIOException()
Definition: LiteTest.java:2405
com.google.protobuf.CodedInputStream.readTag
abstract int readTag()
testing::internal::Double
FloatingPoint< double > Double
Definition: gtest-internal.h:429
b
GLboolean GLboolean GLboolean b
Definition: glcorearb.h:3228
TestAllTypesLite
TestAllTypes
com.google.protobuf.LiteTest.OneTimeIterable
Definition: LiteTest.java:2379
com.google.protobuf.LiteTest.testEquals_sanity
void testEquals_sanity()
Definition: LiteTest.java:2031
com.google.protobuf.LiteTest.testParseLazy
void testParseLazy()
Definition: LiteTest.java:1547
com.google.protobuf.CodedInputStream
Definition: CodedInputStream.java:61
testing::internal::Float
FloatingPoint< float > Float
Definition: gtest-internal.h:428
com.google.protobuf.LiteTest.testAddAllIteratesOnce
void testAddAllIteratesOnce()
Definition: LiteTest.java:2212
com.google.protobuf.LiteTest.testToStringLazyMessage
void testToStringLazyMessage()
Definition: LiteTest.java:1474
com.google.protobuf.LiteTest.testSanityCopyOnWrite
void testSanityCopyOnWrite()
Definition: LiteTest.java:204
com.google.protobuf.TestUtilLite.getAllLiteExtensionsSet
static TestAllExtensionsLite getAllLiteExtensionsSet()
Definition: TestUtilLite.java:163
com.google.protobuf.LiteTest.testToStringForeignFields
void testToStringForeignFields()
Definition: LiteTest.java:1429
com.google.protobuf.LiteTest.testEqualsAndHashCodeWithUnknownFields
void testEqualsAndHashCodeWithUnknownFields()
Definition: LiteTest.java:2042
benchmark::o1
@ o1
Definition: benchmark.h:375
com.google.protobuf.LiteTest.testToStringRepeatedFields
void testToStringRepeatedFields()
Definition: LiteTest.java:1411
com.google.protobuf.LiteTest.testEqualsAndHashCodeWithExtensions
void testEqualsAndHashCodeWithExtensions()
Definition: LiteTest.java:2058
buffer
Definition: buffer_processor.h:43
d
d
F
#define F(msg, field)
Definition: ruby/ext/google/protobuf_c/upb.c:9347
com.google.protobuf.LiteTest.testParseFromByteBuffer_extensions
void testParseFromByteBuffer_extensions()
Definition: LiteTest.java:2148
com.google.protobuf.ExtensionRegistryLite
Definition: ExtensionRegistryLite.java:70
com.google.protobuf.TestUtilLite
Definition: TestUtilLite.java:141
com.google.protobuf.LiteTest.testParseLazy_oneOf
void testParseLazy_oneOf()
Definition: LiteTest.java:1566
com.google.protobuf.LiteTest.testEquals_notEqual
void testEquals_notEqual()
Definition: LiteTest.java:1624
com.google.protobuf.LiteTest.testExtensionRenamesKeywords
void testExtensionRenamesKeywords()
Definition: LiteTest.java:2342
com.google.protobuf.LiteTest.assertEqualsAndHashCodeAreFalse
void assertEqualsAndHashCodeAreFalse(Object o1, Object o2)
Definition: LiteTest.java:2103
com.google.protobuf.LiteTest.testEquals_oneOfMessages
void testEquals_oneOfMessages()
Definition: LiteTest.java:2072
i
int i
Definition: gmock-matchers_test.cc:764
com.google.protobuf.LiteTest.testEqualsAndHashCodeForTrickySchemaTypes
void testEqualsAndHashCodeForTrickySchemaTypes()
Definition: LiteTest.java:2010
ForeignEnumLite
java
com.google.protobuf.LiteTest.OneTimeIterableList.iterator
Iterator< T > iterator()
Definition: LiteTest.java:2370
Field
struct Field Field
Definition: php/ext/google/protobuf/protobuf.h:638
TestHugeFieldNumbersLite
com.google.protobuf.LiteTest.testMergeFromStream_invalidBytes
void testMergeFromStream_invalidBytes()
Definition: LiteTest.java:1592
com.google.protobuf.LiteTest.setUp
void setUp()
Definition: LiteTest.java:79
ImportEnumLite
com.google.protobuf.LiteTest.testRecursiveHashcode
void testRecursiveHashcode()
Definition: LiteTest.java:2108
com.google.protobuf.WireFormat.WIRETYPE_LENGTH_DELIMITED
static final int WIRETYPE_LENGTH_DELIMITED
Definition: WireFormat.java:57
com.google.protobuf.LiteTest.testToStringGroup
void testToStringGroup()
Definition: LiteTest.java:1482
TestAllTypesLiteOrBuilder
com.google.protobuf.WireFormat.getTagWireType
static int getTagWireType(final int tag)
Definition: WireFormat.java:66
ForeignMessageLite
com.google.protobuf.CodedInputStream.skipField
abstract boolean skipField(final int tag)
protobuf_unittest
Definition: map_test_util_impl.h:39
com.google.protobuf.LiteTest.testToStringDefaultInstance
void testToStringDefaultInstance()
Definition: LiteTest.java:1357
size
GLsizeiptr size
Definition: glcorearb.h:2943
com.google.protobuf.LiteTest.contains
boolean contains(ByteString a, ByteString b)
Definition: LiteTest.java:2455
com.google.protobuf.LiteTest.testBuilderMergeFromNull
void testBuilderMergeFromNull()
Definition: LiteTest.java:1318
TestAllExtensionsLite
com.google
com.google.protobuf.CodedInputStream.isAtEnd
abstract boolean isAtEnd()
com
com.google.protobuf.LiteTest.testEquals
void testEquals()
Definition: LiteTest.java:1990
com.google.protobuf.LiteTest.testBuilderMergeFromWithUnknownFields
void testBuilderMergeFromWithUnknownFields()
Definition: LiteTest.java:1347
com.google.protobuf.CodedOutputStream.newInstance
static CodedOutputStream newInstance(final OutputStream output)
Definition: CodedOutputStream.java:92
com.google.protobuf.LiteTest.testToStringStringFields
void testToStringStringFields()
Definition: LiteTest.java:1388
TestNestedExtensionLite
data
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: glcorearb.h:2879
com.google.protobuf.Internal
Definition: Internal.java:54
com.google.protobuf.GeneratedMessageLite.GeneratedExtension
Definition: GeneratedMessageLite.java:1181
com.google.protobuf.CodedOutputStream
Definition: CodedOutputStream.java:59
com.google.protobuf.InvalidProtocolBufferException
Definition: InvalidProtocolBufferException.java:41
com.google.protobuf.LiteTest.testNullExtensionRegistry
void testNullExtensionRegistry()
Definition: LiteTest.java:2397
f
GLfloat f
Definition: glcorearb.h:3964
com.google.protobuf.LiteTest.testMemoization
void testMemoization()
Definition: LiteTest.java:179
com.google.protobuf.LiteTest.OneTimeIterable.list
final List< T > list
Definition: LiteTest.java:2380
output
const upb_json_parsermethod const upb_symtab upb_sink * output
Definition: ruby/ext/google/protobuf_c/upb.h:10503
gmock_test_utils.TestCase
TestCase
Definition: gmock_test_utils.py:97
com.google.protobuf.LiteTest.assertToStringEquals
static void assertToStringEquals(String expected, MessageLite message)
Definition: LiteTest.java:1536
com.google.protobuf.LiteTest.testParseFromByteBufferThrows_extensions
void testParseFromByteBufferThrows_extensions()
Definition: LiteTest.java:2168
com.google.protobuf.LiteTest.testToStringMapFields
void testToStringMapFields()
Definition: LiteTest.java:1495
com.google.protobuf.LiteTest.testHugeFieldNumbers
void testHugeFieldNumbers()
Definition: LiteTest.java:2084
com.google.protobuf.LiteTest.testToStringScalarFieldsSuffixedWithList
void testToStringScalarFieldsSuffixedWithList()
Definition: LiteTest.java:1361
a
GLboolean GLboolean GLboolean GLboolean a
Definition: glcorearb.h:3228
com.google.protobuf.LiteTest.testToStringOneof
void testToStringOneof()
Definition: LiteTest.java:1490
com.google.protobuf.LiteTest
Definition: LiteTest.java:77
message
GLenum GLuint GLenum GLsizei const GLchar * message
Definition: glcorearb.h:2695
com.google.protobuf.LiteTest.testClone
void testClone()
Definition: LiteTest.java:158
PublicImportMessageLite
com.google.protobuf.LiteTest.OneTimeIterableList
Definition: LiteTest.java:2362
com.google.protobuf.MessageLite
Definition: MessageLite.java:65
com.google.protobuf.ByteString
Definition: ByteString.java:67
testString
void testString()

libaditof
Author(s):
autogenerated on Wed May 21 2025 02:06:55