• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Protocol Buffers - Google's data interchange format
2 // Copyright 2008 Google Inc.  All rights reserved.
3 //
4 // Use of this source code is governed by a BSD-style
5 // license that can be found in the LICENSE file or at
6 // https://developers.google.com/open-source/licenses/bsd
7 
8 package com.google.protobuf;
9 
10 import static com.google.common.truth.Truth.assertThat;
11 import static com.google.common.truth.Truth.assertWithMessage;
12 
13 import protobuf_unittest.LazyFieldsLite.LazyExtension;
14 import protobuf_unittest.LazyFieldsLite.LazyInnerMessageLite;
15 import protobuf_unittest.LazyFieldsLite.LazyMessageLite;
16 import protobuf_unittest.LazyFieldsLite.LazyNestedInnerMessageLite;
17 import java.util.ArrayList;
18 import org.junit.Test;
19 import org.junit.runner.RunWith;
20 import org.junit.runners.JUnit4;
21 
22 /** Unit test for messages with lazy fields. */
23 @RunWith(JUnit4.class)
24 public class LazyMessageLiteTest {
25 
26   @Test
27   @SuppressWarnings("RedundantSetterCall")
testSetValues()28   public void testSetValues() {
29     LazyNestedInnerMessageLite nested = LazyNestedInnerMessageLite.newBuilder().setNum(3).build();
30     LazyInnerMessageLite inner =
31         LazyInnerMessageLite.newBuilder().setNum(2).setNested(nested).build();
32     LazyMessageLite outer =
33         LazyMessageLite.newBuilder()
34             .setNum(1)
35             .setInner(inner)
36             .setOneofNum(123)
37             .setOneofInner(inner)
38             .build();
39 
40     assertThat(outer.getNum()).isEqualTo(1);
41     assertThat(outer.getNumWithDefault()).isEqualTo(421);
42 
43     assertThat(outer.getInner().getNum()).isEqualTo(2);
44     assertThat(outer.getInner().getNumWithDefault()).isEqualTo(42);
45 
46     assertThat(outer.getInner().getNum()).isEqualTo(2);
47     assertThat(outer.getInner().getNumWithDefault()).isEqualTo(42);
48 
49     assertThat(outer.getInner().getNested().getNum()).isEqualTo(3);
50     assertThat(outer.getInner().getNested().getNumWithDefault()).isEqualTo(4);
51 
52     assertThat(outer.hasOneofNum()).isFalse();
53     assertThat(outer.hasOneofInner()).isTrue();
54 
55     assertThat(outer.getOneofInner().getNum()).isEqualTo(2);
56     assertThat(outer.getOneofInner().getNumWithDefault()).isEqualTo(42);
57     assertThat(outer.getOneofInner().getNested().getNum()).isEqualTo(3);
58     assertThat(outer.getOneofInner().getNested().getNumWithDefault()).isEqualTo(4);
59   }
60 
61   @Test
testSetRepeatedValues()62   public void testSetRepeatedValues() {
63     LazyMessageLite outer =
64         LazyMessageLite.newBuilder()
65             .setNum(1)
66             .addRepeatedInner(LazyInnerMessageLite.newBuilder().setNum(119))
67             .addRepeatedInner(LazyInnerMessageLite.newBuilder().setNum(122))
68             .build();
69 
70     assertThat(outer.getNum()).isEqualTo(1);
71     assertThat(outer.getRepeatedInnerCount()).isEqualTo(2);
72     assertThat(outer.getRepeatedInner(0).getNum()).isEqualTo(119);
73     assertThat(outer.getRepeatedInner(1).getNum()).isEqualTo(122);
74   }
75 
76   @Test
testRepeatedMutability()77   public void testRepeatedMutability() throws Exception {
78     LazyMessageLite outer =
79         LazyMessageLite.newBuilder()
80             .addRepeatedInner(LazyInnerMessageLite.newBuilder().setNum(119))
81             .addRepeatedInner(LazyInnerMessageLite.newBuilder().setNum(122))
82             .build();
83 
84     outer =
85         LazyMessageLite.parseFrom(outer.toByteArray(),
86             ExtensionRegistryLite.getEmptyRegistry());
87     try {
88       outer.getRepeatedInnerList().set(1, null);
89       assertWithMessage("expected exception").fail();
90     } catch (UnsupportedOperationException expected) {
91     }
92   }
93 
94   @Test
testAddAll()95   public void testAddAll() {
96     ArrayList<LazyInnerMessageLite> inners = new ArrayList<>();
97     int count = 4;
98     for (int i = 0; i < count; i++) {
99       LazyInnerMessageLite inner = LazyInnerMessageLite.newBuilder().setNum(i).build();
100       inners.add(inner);
101     }
102 
103     LazyMessageLite outer = LazyMessageLite.newBuilder().addAllRepeatedInner(inners).build();
104     assertThat(outer.getRepeatedInnerCount()).isEqualTo(count);
105     for (int i = 0; i < count; i++) {
106       assertThat(outer.getRepeatedInner(i).getNum()).isEqualTo(i);
107     }
108   }
109 
110   @Test
testGetDefaultValues()111   public void testGetDefaultValues() {
112     LazyMessageLite outer = LazyMessageLite.getDefaultInstance();
113 
114     assertThat(outer.getNum()).isEqualTo(0);
115     assertThat(outer.getNumWithDefault()).isEqualTo(421);
116 
117     assertThat(outer.getInner().getNum()).isEqualTo(0);
118     assertThat(outer.getInner().getNumWithDefault()).isEqualTo(42);
119 
120     assertThat(outer.getInner().getNested().getNum()).isEqualTo(0);
121     assertThat(outer.getInner().getNested().getNumWithDefault()).isEqualTo(4);
122 
123     assertThat(outer.getOneofNum()).isEqualTo(0);
124 
125     assertThat(outer.getOneofInner().getNum()).isEqualTo(0);
126     assertThat(outer.getOneofInner().getNumWithDefault()).isEqualTo(42);
127     assertThat(outer.getOneofInner().getNested().getNum()).isEqualTo(0);
128     assertThat(outer.getOneofInner().getNested().getNumWithDefault()).isEqualTo(4);
129   }
130 
131   @Test
testClearValues()132   public void testClearValues() {
133     LazyInnerMessageLite inner = LazyInnerMessageLite.newBuilder().setNum(115).build();
134 
135     LazyMessageLite.Builder outerBuilder = LazyMessageLite.newBuilder();
136 
137     assertThat(outerBuilder.build().getNum()).isEqualTo(0);
138 
139     // Set/Clear num
140     outerBuilder.setNum(100);
141 
142     assertThat(outerBuilder.build().getNum()).isEqualTo(100);
143     assertThat(outerBuilder.build().getNumWithDefault()).isEqualTo(421);
144     assertThat(outerBuilder.build().hasInner()).isFalse();
145 
146     outerBuilder.clearNum();
147 
148     assertThat(outerBuilder.build().getNum()).isEqualTo(0);
149     assertThat(outerBuilder.build().getNumWithDefault()).isEqualTo(421);
150     assertThat(outerBuilder.build().hasInner()).isFalse();
151 
152     // Set/Clear all
153     outerBuilder
154         .setNum(100)
155         .setInner(inner)
156         .addRepeatedInner(LazyInnerMessageLite.newBuilder().setNum(119))
157         .addRepeatedInner(LazyInnerMessageLite.newBuilder().setNum(122))
158         .setOneofInner(LazyInnerMessageLite.newBuilder().setNum(123));
159 
160     LazyMessageLite outer = outerBuilder.build();
161     assertThat(outer.getNum()).isEqualTo(100);
162     assertThat(outer.getNumWithDefault()).isEqualTo(421);
163     assertThat(outer.hasInner()).isTrue();
164     assertThat(outer.getInner().getNum()).isEqualTo(115);
165     assertThat(outer.getRepeatedInnerCount()).isEqualTo(2);
166     assertThat(outer.getRepeatedInner(0).getNum()).isEqualTo(119);
167     assertThat(outer.getRepeatedInner(1).getNum()).isEqualTo(122);
168     assertThat(outer.hasOneofInner()).isTrue();
169     assertThat(outer.getOneofInner().getNum()).isEqualTo(123);
170 
171     outerBuilder.clear();
172 
173     outer = outerBuilder.build();
174 
175     assertThat(outer.getNum()).isEqualTo(0);
176     assertThat(outer.getNumWithDefault()).isEqualTo(421);
177     assertThat(outer.hasInner()).isFalse();
178     assertThat(outer.getRepeatedInnerCount()).isEqualTo(0);
179     assertThat(outer.hasOneofInner()).isFalse();
180     assertThat(outer.getOneofInner().getNum()).isEqualTo(0);
181   }
182 
183   @Test
testMergeValues()184   public void testMergeValues() {
185     LazyMessageLite outerBase = LazyMessageLite.newBuilder().setNumWithDefault(122).build();
186 
187     LazyInnerMessageLite innerMerging = LazyInnerMessageLite.newBuilder().setNum(115).build();
188     LazyMessageLite outerMerging =
189         LazyMessageLite.newBuilder()
190             .setNum(119)
191             .setInner(innerMerging)
192             .setOneofInner(innerMerging)
193             .build();
194 
195     LazyMessageLite merged = LazyMessageLite.newBuilder(outerBase).mergeFrom(outerMerging).build();
196     assertThat(merged.getNum()).isEqualTo(119);
197     assertThat(merged.getNumWithDefault()).isEqualTo(122);
198     assertThat(merged.getInner().getNum()).isEqualTo(115);
199     assertThat(merged.getInner().getNumWithDefault()).isEqualTo(42);
200     assertThat(merged.getOneofInner().getNum()).isEqualTo(115);
201     assertThat(merged.getOneofInner().getNumWithDefault()).isEqualTo(42);
202   }
203 
204   @Test
testMergeDefaultValues()205   public void testMergeDefaultValues() {
206     LazyInnerMessageLite innerBase = LazyInnerMessageLite.newBuilder().setNum(115).build();
207     LazyMessageLite outerBase =
208         LazyMessageLite.newBuilder()
209             .setNum(119)
210             .setNumWithDefault(122)
211             .setInner(innerBase)
212             .setOneofInner(innerBase)
213             .build();
214 
215     LazyMessageLite outerMerging = LazyMessageLite.getDefaultInstance();
216 
217     LazyMessageLite merged = LazyMessageLite.newBuilder(outerBase).mergeFrom(outerMerging).build();
218     // Merging default-instance shouldn't overwrite values in the base message.
219     assertThat(merged.getNum()).isEqualTo(119);
220     assertThat(merged.getNumWithDefault()).isEqualTo(122);
221     assertThat(merged.getInner().getNum()).isEqualTo(115);
222     assertThat(merged.getInner().getNumWithDefault()).isEqualTo(42);
223     assertThat(merged.getOneofInner().getNum()).isEqualTo(115);
224     assertThat(merged.getOneofInner().getNumWithDefault()).isEqualTo(42);
225   }
226 
227   // Regression test for b/28198805.
228   @Test
testMergeOneofMessages()229   public void testMergeOneofMessages() throws Exception {
230     LazyInnerMessageLite inner = LazyInnerMessageLite.getDefaultInstance();
231     LazyMessageLite outer = LazyMessageLite.newBuilder().setOneofInner(inner).build();
232     ByteString data1 = outer.toByteString();
233 
234     // The following should not alter the content of the 'outer' message.
235     LazyMessageLite.Builder merged = outer.toBuilder();
236     LazyInnerMessageLite anotherInner = LazyInnerMessageLite.newBuilder().setNum(12345).build();
237     merged.setOneofInner(anotherInner);
238 
239     // Check that the 'outer' stays the same.
240     ByteString data2 = outer.toByteString();
241     assertThat(data1).isEqualTo(data2);
242     assertThat(outer.getOneofInner().getNum()).isEqualTo(0);
243   }
244 
245   @Test
testSerialize()246   public void testSerialize() throws InvalidProtocolBufferException {
247     LazyNestedInnerMessageLite nested = LazyNestedInnerMessageLite.newBuilder().setNum(3).build();
248     LazyInnerMessageLite inner =
249         LazyInnerMessageLite.newBuilder().setNum(2).setNested(nested).build();
250     LazyMessageLite outer =
251         LazyMessageLite.newBuilder().setNum(1).setInner(inner).setOneofInner(inner).build();
252 
253     ByteString bytes = outer.toByteString();
254     assertThat(bytes.size()).isEqualTo(outer.getSerializedSize());
255 
256     LazyMessageLite deserialized =
257         LazyMessageLite.parseFrom(bytes, ExtensionRegistryLite.getEmptyRegistry());
258 
259     assertThat(deserialized.getNum()).isEqualTo(1);
260     assertThat(deserialized.getNumWithDefault()).isEqualTo(421);
261 
262     assertThat(deserialized.getInner().getNum()).isEqualTo(2);
263     assertThat(deserialized.getInner().getNumWithDefault()).isEqualTo(42);
264 
265     assertThat(deserialized.getInner().getNested().getNum()).isEqualTo(3);
266     assertThat(deserialized.getInner().getNested().getNumWithDefault()).isEqualTo(4);
267 
268     assertThat(deserialized.getOneofInner().getNum()).isEqualTo(2);
269     assertThat(deserialized.getOneofInner().getNumWithDefault()).isEqualTo(42);
270     assertThat(deserialized.getOneofInner().getNested().getNum()).isEqualTo(3);
271     assertThat(deserialized.getOneofInner().getNested().getNumWithDefault()).isEqualTo(4);
272 
273     assertThat(deserialized.toByteString()).isEqualTo(bytes);
274   }
275 
276   @Test
testExtensions()277   public void testExtensions() throws Exception {
278     LazyInnerMessageLite.Builder innerBuilder = LazyInnerMessageLite.newBuilder();
279     innerBuilder.setExtension(
280         LazyExtension.extension, LazyExtension.newBuilder().setName("name").build());
281     assertThat(innerBuilder.hasExtension(LazyExtension.extension)).isTrue();
282     assertThat(innerBuilder.getExtension(LazyExtension.extension).getName()).isEqualTo("name");
283 
284     LazyInnerMessageLite innerMessage = innerBuilder.build();
285     assertThat(innerMessage.hasExtension(LazyExtension.extension)).isTrue();
286     assertThat(innerMessage.getExtension(LazyExtension.extension).getName()).isEqualTo("name");
287 
288     LazyMessageLite lite = LazyMessageLite.newBuilder().setInner(innerMessage).build();
289     assertThat(lite.getInner().hasExtension(LazyExtension.extension)).isTrue();
290     assertThat(lite.getInner().getExtension(LazyExtension.extension).getName()).isEqualTo("name");
291   }
292 }
293