Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(12)

Side by Side Diff: third_party/protobuf/java/compatibility_tests/v2.5.0/tests/src/main/java/com/google/protobuf/test/MessageTest.java

Issue 2600753002: Reverts third_party/protobuf: Update to HEAD (f52e188fe4) (Closed)
Patch Set: Created 3 years, 12 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
(Empty)
1 // Protocol Buffers - Google's data interchange format
2 // Copyright 2008 Google Inc. All rights reserved.
3 // http://code.google.com/p/protobuf/
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.test;
32 import com.google.protobuf.*;
33
34 import protobuf_unittest.UnittestProto.TestAllTypes;
35 import protobuf_unittest.UnittestProto.TestAllExtensions;
36 import protobuf_unittest.UnittestProto.TestRequired;
37 import protobuf_unittest.UnittestProto.TestRequiredForeign;
38 import protobuf_unittest.UnittestProto.ForeignMessage;
39
40 import junit.framework.TestCase;
41
42 import java.util.List;
43
44 /**
45 * Misc. unit tests for message operations that apply to both generated
46 * and dynamic messages.
47 *
48 * @author kenton@google.com Kenton Varda
49 */
50 public class MessageTest extends TestCase {
51 // =================================================================
52 // Message-merging tests.
53
54 static final TestAllTypes MERGE_SOURCE =
55 TestAllTypes.newBuilder()
56 .setOptionalInt32(1)
57 .setOptionalString("foo")
58 .setOptionalForeignMessage(ForeignMessage.getDefaultInstance())
59 .addRepeatedString("bar")
60 .build();
61
62 static final TestAllTypes MERGE_DEST =
63 TestAllTypes.newBuilder()
64 .setOptionalInt64(2)
65 .setOptionalString("baz")
66 .setOptionalForeignMessage(ForeignMessage.newBuilder().setC(3).build())
67 .addRepeatedString("qux")
68 .build();
69
70 static final String MERGE_RESULT_TEXT =
71 "optional_int32: 1\n" +
72 "optional_int64: 2\n" +
73 "optional_string: \"foo\"\n" +
74 "optional_foreign_message {\n" +
75 " c: 3\n" +
76 "}\n" +
77 "repeated_string: \"qux\"\n" +
78 "repeated_string: \"bar\"\n";
79
80 public void testMergeFrom() throws Exception {
81 TestAllTypes result =
82 TestAllTypes.newBuilder(MERGE_DEST)
83 .mergeFrom(MERGE_SOURCE).build();
84
85 assertEquals(MERGE_RESULT_TEXT, result.toString());
86 }
87
88 /**
89 * Test merging a DynamicMessage into a GeneratedMessage. As long as they
90 * have the same descriptor, this should work, but it is an entirely different
91 * code path.
92 */
93 public void testMergeFromDynamic() throws Exception {
94 TestAllTypes result =
95 TestAllTypes.newBuilder(MERGE_DEST)
96 .mergeFrom(DynamicMessage.newBuilder(MERGE_SOURCE).build())
97 .build();
98
99 assertEquals(MERGE_RESULT_TEXT, result.toString());
100 }
101
102 /** Test merging two DynamicMessages. */
103 public void testDynamicMergeFrom() throws Exception {
104 DynamicMessage result =
105 DynamicMessage.newBuilder(MERGE_DEST)
106 .mergeFrom(DynamicMessage.newBuilder(MERGE_SOURCE).build())
107 .build();
108
109 assertEquals(MERGE_RESULT_TEXT, result.toString());
110 }
111
112 // =================================================================
113 // Required-field-related tests.
114
115 private static final TestRequired TEST_REQUIRED_UNINITIALIZED =
116 TestRequired.getDefaultInstance();
117 private static final TestRequired TEST_REQUIRED_INITIALIZED =
118 TestRequired.newBuilder().setA(1).setB(2).setC(3).build();
119
120 public void testRequired() throws Exception {
121 TestRequired.Builder builder = TestRequired.newBuilder();
122
123 assertFalse(builder.isInitialized());
124 builder.setA(1);
125 assertFalse(builder.isInitialized());
126 builder.setB(1);
127 assertFalse(builder.isInitialized());
128 builder.setC(1);
129 assertTrue(builder.isInitialized());
130 }
131
132 public void testRequiredForeign() throws Exception {
133 TestRequiredForeign.Builder builder = TestRequiredForeign.newBuilder();
134
135 assertTrue(builder.isInitialized());
136
137 builder.setOptionalMessage(TEST_REQUIRED_UNINITIALIZED);
138 assertFalse(builder.isInitialized());
139
140 builder.setOptionalMessage(TEST_REQUIRED_INITIALIZED);
141 assertTrue(builder.isInitialized());
142
143 builder.addRepeatedMessage(TEST_REQUIRED_UNINITIALIZED);
144 assertFalse(builder.isInitialized());
145
146 builder.setRepeatedMessage(0, TEST_REQUIRED_INITIALIZED);
147 assertTrue(builder.isInitialized());
148 }
149
150 public void testRequiredExtension() throws Exception {
151 TestAllExtensions.Builder builder = TestAllExtensions.newBuilder();
152
153 assertTrue(builder.isInitialized());
154
155 builder.setExtension(TestRequired.single, TEST_REQUIRED_UNINITIALIZED);
156 assertFalse(builder.isInitialized());
157
158 builder.setExtension(TestRequired.single, TEST_REQUIRED_INITIALIZED);
159 assertTrue(builder.isInitialized());
160
161 builder.addExtension(TestRequired.multi, TEST_REQUIRED_UNINITIALIZED);
162 assertFalse(builder.isInitialized());
163
164 builder.setExtension(TestRequired.multi, 0, TEST_REQUIRED_INITIALIZED);
165 assertTrue(builder.isInitialized());
166 }
167
168 public void testRequiredDynamic() throws Exception {
169 Descriptors.Descriptor descriptor = TestRequired.getDescriptor();
170 DynamicMessage.Builder builder = DynamicMessage.newBuilder(descriptor);
171
172 assertFalse(builder.isInitialized());
173 builder.setField(descriptor.findFieldByName("a"), 1);
174 assertFalse(builder.isInitialized());
175 builder.setField(descriptor.findFieldByName("b"), 1);
176 assertFalse(builder.isInitialized());
177 builder.setField(descriptor.findFieldByName("c"), 1);
178 assertTrue(builder.isInitialized());
179 }
180
181 public void testRequiredDynamicForeign() throws Exception {
182 Descriptors.Descriptor descriptor = TestRequiredForeign.getDescriptor();
183 DynamicMessage.Builder builder = DynamicMessage.newBuilder(descriptor);
184
185 assertTrue(builder.isInitialized());
186
187 builder.setField(descriptor.findFieldByName("optional_message"),
188 TEST_REQUIRED_UNINITIALIZED);
189 assertFalse(builder.isInitialized());
190
191 builder.setField(descriptor.findFieldByName("optional_message"),
192 TEST_REQUIRED_INITIALIZED);
193 assertTrue(builder.isInitialized());
194
195 builder.addRepeatedField(descriptor.findFieldByName("repeated_message"),
196 TEST_REQUIRED_UNINITIALIZED);
197 assertFalse(builder.isInitialized());
198
199 builder.setRepeatedField(descriptor.findFieldByName("repeated_message"), 0,
200 TEST_REQUIRED_INITIALIZED);
201 assertTrue(builder.isInitialized());
202 }
203
204 public void testUninitializedException() throws Exception {
205 try {
206 TestRequired.newBuilder().build();
207 fail("Should have thrown an exception.");
208 } catch (UninitializedMessageException e) {
209 assertEquals("Message missing required fields: a, b, c", e.getMessage());
210 }
211 }
212
213 public void testBuildPartial() throws Exception {
214 // We're mostly testing that no exception is thrown.
215 TestRequired message = TestRequired.newBuilder().buildPartial();
216 assertFalse(message.isInitialized());
217 }
218
219 public void testNestedUninitializedException() throws Exception {
220 try {
221 TestRequiredForeign.newBuilder()
222 .setOptionalMessage(TEST_REQUIRED_UNINITIALIZED)
223 .addRepeatedMessage(TEST_REQUIRED_UNINITIALIZED)
224 .addRepeatedMessage(TEST_REQUIRED_UNINITIALIZED)
225 .build();
226 fail("Should have thrown an exception.");
227 } catch (UninitializedMessageException e) {
228 assertEquals(
229 "Message missing required fields: " +
230 "optional_message.a, " +
231 "optional_message.b, " +
232 "optional_message.c, " +
233 "repeated_message[0].a, " +
234 "repeated_message[0].b, " +
235 "repeated_message[0].c, " +
236 "repeated_message[1].a, " +
237 "repeated_message[1].b, " +
238 "repeated_message[1].c",
239 e.getMessage());
240 }
241 }
242
243 public void testBuildNestedPartial() throws Exception {
244 // We're mostly testing that no exception is thrown.
245 TestRequiredForeign message =
246 TestRequiredForeign.newBuilder()
247 .setOptionalMessage(TEST_REQUIRED_UNINITIALIZED)
248 .addRepeatedMessage(TEST_REQUIRED_UNINITIALIZED)
249 .addRepeatedMessage(TEST_REQUIRED_UNINITIALIZED)
250 .buildPartial();
251 assertFalse(message.isInitialized());
252 }
253
254 public void testParseUnititialized() throws Exception {
255 try {
256 TestRequired.parseFrom(ByteString.EMPTY);
257 fail("Should have thrown an exception.");
258 } catch (InvalidProtocolBufferException e) {
259 assertEquals("Message missing required fields: a, b, c", e.getMessage());
260 }
261 }
262
263 public void testParseNestedUnititialized() throws Exception {
264 ByteString data =
265 TestRequiredForeign.newBuilder()
266 .setOptionalMessage(TEST_REQUIRED_UNINITIALIZED)
267 .addRepeatedMessage(TEST_REQUIRED_UNINITIALIZED)
268 .addRepeatedMessage(TEST_REQUIRED_UNINITIALIZED)
269 .buildPartial().toByteString();
270
271 try {
272 TestRequiredForeign.parseFrom(data);
273 fail("Should have thrown an exception.");
274 } catch (InvalidProtocolBufferException e) {
275 assertEquals(
276 "Message missing required fields: " +
277 "optional_message.a, " +
278 "optional_message.b, " +
279 "optional_message.c, " +
280 "repeated_message[0].a, " +
281 "repeated_message[0].b, " +
282 "repeated_message[0].c, " +
283 "repeated_message[1].a, " +
284 "repeated_message[1].b, " +
285 "repeated_message[1].c",
286 e.getMessage());
287 }
288 }
289
290 public void testDynamicUninitializedException() throws Exception {
291 try {
292 DynamicMessage.newBuilder(TestRequired.getDescriptor()).build();
293 fail("Should have thrown an exception.");
294 } catch (UninitializedMessageException e) {
295 assertEquals("Message missing required fields: a, b, c", e.getMessage());
296 }
297 }
298
299 public void testDynamicBuildPartial() throws Exception {
300 // We're mostly testing that no exception is thrown.
301 DynamicMessage message =
302 DynamicMessage.newBuilder(TestRequired.getDescriptor())
303 .buildPartial();
304 assertFalse(message.isInitialized());
305 }
306
307 public void testDynamicParseUnititialized() throws Exception {
308 try {
309 Descriptors.Descriptor descriptor = TestRequired.getDescriptor();
310 DynamicMessage.parseFrom(descriptor, ByteString.EMPTY);
311 fail("Should have thrown an exception.");
312 } catch (InvalidProtocolBufferException e) {
313 assertEquals("Message missing required fields: a, b, c", e.getMessage());
314 }
315 }
316
317 /** Test reading unset repeated message from DynamicMessage. */
318 public void testDynamicRepeatedMessageNull() throws Exception {
319 Descriptors.Descriptor descriptor = TestRequired.getDescriptor();
320 DynamicMessage result =
321 DynamicMessage.newBuilder(TestAllTypes.getDescriptor())
322 .mergeFrom(DynamicMessage.newBuilder(MERGE_SOURCE).build())
323 .build();
324
325 assertTrue(result.getField(result.getDescriptorForType()
326 .findFieldByName("repeated_foreign_message")) instanceof List<?>);
327 assertEquals(result.getRepeatedFieldCount(result.getDescriptorForType()
328 .findFieldByName("repeated_foreign_message")), 0);
329 }
330
331 /** Test reading repeated message from DynamicMessage. */
332 public void testDynamicRepeatedMessageNotNull() throws Exception {
333
334 TestAllTypes REPEATED_NESTED =
335 TestAllTypes.newBuilder()
336 .setOptionalInt32(1)
337 .setOptionalString("foo")
338 .setOptionalForeignMessage(ForeignMessage.getDefaultInstance())
339 .addRepeatedString("bar")
340 .addRepeatedForeignMessage(ForeignMessage.getDefaultInstance())
341 .addRepeatedForeignMessage(ForeignMessage.getDefaultInstance())
342 .build();
343 Descriptors.Descriptor descriptor = TestRequired.getDescriptor();
344 DynamicMessage result =
345 DynamicMessage.newBuilder(TestAllTypes.getDescriptor())
346 .mergeFrom(DynamicMessage.newBuilder(REPEATED_NESTED).build())
347 .build();
348
349 assertTrue(result.getField(result.getDescriptorForType()
350 .findFieldByName("repeated_foreign_message")) instanceof List<?>);
351 assertEquals(result.getRepeatedFieldCount(result.getDescriptorForType()
352 .findFieldByName("repeated_foreign_message")), 2);
353 }
354 }
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698