OLD | NEW |
| (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 } | |
OLD | NEW |