1 // Protocol Buffers - Google's data interchange format
2 // Copyright 2008 Google Inc. All rights reserved.
3 // http://code.google.com/p/protobuf/
5 // Redistribution and use in source and binary forms, with or without
6 // modification, are permitted provided that the following conditions are
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
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.
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.
31 // Author: kenton@google.com (Kenton Varda)
32 // Based on original Protocol Buffers design by
33 // Sanjay Ghemawat, Jeff Dean, and others.
35 // A proto file we will use for unit testing.
37 syntax = "proto2"; // for compatibility with internal Google compiler
39 // Some generic_services option(s) added automatically.
40 // See: http://go/proto2-generic-services-default
41 option cc_generic_services = true; // auto-added
42 option java_generic_services = true; // auto-added
43 option py_generic_services = true; // auto-added
45 //--- import "google/protobuf/unittest_import.proto";
46 import "unittest_import.proto";
48 // We don't put this in a package within proto2 because we need to make sure
49 // that the generated code doesn't depend on being in the proto2 namespace.
50 // In test_util.h we do "using namespace unittest = protobuf_unittest".
51 package protobuf_unittest;
53 // Protos optimized for SPEED use a strict superset of the generated code
54 // of equivalent ones optimized for CODE_SIZE, so we should optimize all our
55 // tests for speed unless explicitly testing code size optimization.
56 //--- option optimize_for = SPEED;
58 option java_outer_classname = "UnittestProto";
60 // This proto includes every type of field in both singular and repeated
62 message TestAllTypes {
63 message NestedMessage {
64 // The field name "b" fails to compile in proto1 because it conflicts with
65 // a local variable named "b" in one of the generated methods. Doh.
66 // This file needs to compile in proto1 to test backwards-compatibility.
67 optional int32 bb = 1;
77 optional int32 optional_int32 = 1;
78 optional int64 optional_int64 = 2;
79 optional uint32 optional_uint32 = 3;
80 optional uint64 optional_uint64 = 4;
81 optional sint32 optional_sint32 = 5;
82 optional sint64 optional_sint64 = 6;
83 optional fixed32 optional_fixed32 = 7;
84 optional fixed64 optional_fixed64 = 8;
85 optional sfixed32 optional_sfixed32 = 9;
86 optional sfixed64 optional_sfixed64 = 10;
87 optional float optional_float = 11;
88 optional double optional_double = 12;
89 optional bool optional_bool = 13;
90 optional string optional_string = 14;
91 optional bytes optional_bytes = 15;
93 optional group OptionalGroup = 16 {
94 optional int32 a = 17;
97 optional NestedMessage optional_nested_message = 18;
98 optional ForeignMessage optional_foreign_message = 19;
99 optional protobuf_unittest_import.ImportMessage optional_import_message = 20;
101 optional NestedEnum optional_nested_enum = 21;
102 optional ForeignEnum optional_foreign_enum = 22;
103 optional protobuf_unittest_import.ImportEnum optional_import_enum = 23;
105 optional string optional_string_piece = 24 [ctype=STRING_PIECE];
106 optional string optional_cord = 25 [ctype=CORD];
109 repeated int32 repeated_int32 = 31;
110 repeated int64 repeated_int64 = 32;
111 repeated uint32 repeated_uint32 = 33;
112 repeated uint64 repeated_uint64 = 34;
113 repeated sint32 repeated_sint32 = 35;
114 repeated sint64 repeated_sint64 = 36;
115 repeated fixed32 repeated_fixed32 = 37;
116 repeated fixed64 repeated_fixed64 = 38;
117 repeated sfixed32 repeated_sfixed32 = 39;
118 repeated sfixed64 repeated_sfixed64 = 40;
119 repeated float repeated_float = 41;
120 repeated double repeated_double = 42;
121 repeated bool repeated_bool = 43;
122 repeated string repeated_string = 44;
123 repeated bytes repeated_bytes = 45;
125 repeated group RepeatedGroup = 46 {
126 optional int32 a = 47;
129 repeated NestedMessage repeated_nested_message = 48;
130 repeated ForeignMessage repeated_foreign_message = 49;
131 repeated protobuf_unittest_import.ImportMessage repeated_import_message = 50;
133 repeated NestedEnum repeated_nested_enum = 51;
134 repeated ForeignEnum repeated_foreign_enum = 52;
135 repeated protobuf_unittest_import.ImportEnum repeated_import_enum = 53;
137 repeated string repeated_string_piece = 54 [ctype=STRING_PIECE];
138 repeated string repeated_cord = 55 [ctype=CORD];
140 // Singular with defaults
141 optional int32 default_int32 = 61 [default = 41 ];
142 optional int64 default_int64 = 62 [default = 42 ];
143 optional uint32 default_uint32 = 63 [default = 43 ];
144 optional uint64 default_uint64 = 64 [default = 44 ];
145 optional sint32 default_sint32 = 65 [default = -45 ];
146 optional sint64 default_sint64 = 66 [default = 46 ];
147 optional fixed32 default_fixed32 = 67 [default = 47 ];
148 optional fixed64 default_fixed64 = 68 [default = 48 ];
149 optional sfixed32 default_sfixed32 = 69 [default = 49 ];
150 optional sfixed64 default_sfixed64 = 70 [default = -50 ];
151 optional float default_float = 71 [default = 51.5 ];
152 optional double default_double = 72 [default = 52e3 ];
153 optional bool default_bool = 73 [default = true ];
154 optional string default_string = 74 [default = "hello"];
155 optional bytes default_bytes = 75 [default = "world"];
157 optional NestedEnum default_nested_enum = 81 [default = BAR ];
158 optional ForeignEnum default_foreign_enum = 82 [default = FOREIGN_BAR];
159 optional protobuf_unittest_import.ImportEnum
160 default_import_enum = 83 [default = IMPORT_BAR];
162 optional string default_string_piece = 84 [ctype=STRING_PIECE,default="abc"];
163 optional string default_cord = 85 [ctype=CORD,default="123"];
166 message TestDeprecatedFields {
167 optional int32 deprecated_int32 = 1 [deprecated=true];
170 // Define these after TestAllTypes to make sure the compiler can handle
172 message ForeignMessage {
173 optional int32 c = 1;
182 message TestAllExtensions {
186 extend TestAllExtensions {
188 optional int32 optional_int32_extension = 1;
189 optional int64 optional_int64_extension = 2;
190 optional uint32 optional_uint32_extension = 3;
191 optional uint64 optional_uint64_extension = 4;
192 optional sint32 optional_sint32_extension = 5;
193 optional sint64 optional_sint64_extension = 6;
194 optional fixed32 optional_fixed32_extension = 7;
195 optional fixed64 optional_fixed64_extension = 8;
196 optional sfixed32 optional_sfixed32_extension = 9;
197 optional sfixed64 optional_sfixed64_extension = 10;
198 optional float optional_float_extension = 11;
199 optional double optional_double_extension = 12;
200 optional bool optional_bool_extension = 13;
201 optional string optional_string_extension = 14;
202 optional bytes optional_bytes_extension = 15;
204 optional group OptionalGroup_extension = 16 {
205 optional int32 a = 17;
208 optional TestAllTypes.NestedMessage optional_nested_message_extension = 18;
209 optional ForeignMessage optional_foreign_message_extension = 19;
210 optional protobuf_unittest_import.ImportMessage
211 optional_import_message_extension = 20;
213 optional TestAllTypes.NestedEnum optional_nested_enum_extension = 21;
214 optional ForeignEnum optional_foreign_enum_extension = 22;
215 optional protobuf_unittest_import.ImportEnum
216 optional_import_enum_extension = 23;
218 optional string optional_string_piece_extension = 24 [ctype=STRING_PIECE];
219 optional string optional_cord_extension = 25 [ctype=CORD];
222 repeated int32 repeated_int32_extension = 31;
223 repeated int64 repeated_int64_extension = 32;
224 repeated uint32 repeated_uint32_extension = 33;
225 repeated uint64 repeated_uint64_extension = 34;
226 repeated sint32 repeated_sint32_extension = 35;
227 repeated sint64 repeated_sint64_extension = 36;
228 repeated fixed32 repeated_fixed32_extension = 37;
229 repeated fixed64 repeated_fixed64_extension = 38;
230 repeated sfixed32 repeated_sfixed32_extension = 39;
231 repeated sfixed64 repeated_sfixed64_extension = 40;
232 repeated float repeated_float_extension = 41;
233 repeated double repeated_double_extension = 42;
234 repeated bool repeated_bool_extension = 43;
235 repeated string repeated_string_extension = 44;
236 repeated bytes repeated_bytes_extension = 45;
238 repeated group RepeatedGroup_extension = 46 {
239 optional int32 a = 47;
242 repeated TestAllTypes.NestedMessage repeated_nested_message_extension = 48;
243 repeated ForeignMessage repeated_foreign_message_extension = 49;
244 repeated protobuf_unittest_import.ImportMessage
245 repeated_import_message_extension = 50;
247 repeated TestAllTypes.NestedEnum repeated_nested_enum_extension = 51;
248 repeated ForeignEnum repeated_foreign_enum_extension = 52;
249 repeated protobuf_unittest_import.ImportEnum
250 repeated_import_enum_extension = 53;
252 repeated string repeated_string_piece_extension = 54 [ctype=STRING_PIECE];
253 repeated string repeated_cord_extension = 55 [ctype=CORD];
255 // Singular with defaults
256 optional int32 default_int32_extension = 61 [default = 41 ];
257 optional int64 default_int64_extension = 62 [default = 42 ];
258 optional uint32 default_uint32_extension = 63 [default = 43 ];
259 optional uint64 default_uint64_extension = 64 [default = 44 ];
260 optional sint32 default_sint32_extension = 65 [default = -45 ];
261 optional sint64 default_sint64_extension = 66 [default = 46 ];
262 optional fixed32 default_fixed32_extension = 67 [default = 47 ];
263 optional fixed64 default_fixed64_extension = 68 [default = 48 ];
264 optional sfixed32 default_sfixed32_extension = 69 [default = 49 ];
265 optional sfixed64 default_sfixed64_extension = 70 [default = -50 ];
266 optional float default_float_extension = 71 [default = 51.5 ];
267 optional double default_double_extension = 72 [default = 52e3 ];
268 optional bool default_bool_extension = 73 [default = true ];
269 optional string default_string_extension = 74 [default = "hello"];
270 optional bytes default_bytes_extension = 75 [default = "world"];
272 optional TestAllTypes.NestedEnum
273 default_nested_enum_extension = 81 [default = BAR];
275 default_foreign_enum_extension = 82 [default = FOREIGN_BAR];
276 optional protobuf_unittest_import.ImportEnum
277 default_import_enum_extension = 83 [default = IMPORT_BAR];
279 optional string default_string_piece_extension = 84 [ctype=STRING_PIECE,
281 optional string default_cord_extension = 85 [ctype=CORD, default="123"];
284 message TestNestedExtension {
285 extend TestAllExtensions {
286 // Check for bug where string extensions declared in tested scope did not
288 optional string test = 1002 [default="test"];
292 // We have separate messages for testing required fields because it's
293 // annoying to have to fill in required fields in TestProto in order to
294 // do anything with it. Note that we don't need to test every type of
295 // required filed because the code output is basically identical to
296 // optional fields for all types.
297 message TestRequired {
298 required int32 a = 1;
299 optional int32 dummy2 = 2;
300 required int32 b = 3;
302 extend TestAllExtensions {
303 optional TestRequired single = 1000;
304 repeated TestRequired multi = 1001;
307 // Pad the field count to 32 so that we can test that IsInitialized()
308 // properly checks multiple elements of has_bits_.
309 optional int32 dummy4 = 4;
310 optional int32 dummy5 = 5;
311 optional int32 dummy6 = 6;
312 optional int32 dummy7 = 7;
313 optional int32 dummy8 = 8;
314 optional int32 dummy9 = 9;
315 optional int32 dummy10 = 10;
316 optional int32 dummy11 = 11;
317 optional int32 dummy12 = 12;
318 optional int32 dummy13 = 13;
319 optional int32 dummy14 = 14;
320 optional int32 dummy15 = 15;
321 optional int32 dummy16 = 16;
322 optional int32 dummy17 = 17;
323 optional int32 dummy18 = 18;
324 optional int32 dummy19 = 19;
325 optional int32 dummy20 = 20;
326 optional int32 dummy21 = 21;
327 optional int32 dummy22 = 22;
328 optional int32 dummy23 = 23;
329 optional int32 dummy24 = 24;
330 optional int32 dummy25 = 25;
331 optional int32 dummy26 = 26;
332 optional int32 dummy27 = 27;
333 optional int32 dummy28 = 28;
334 optional int32 dummy29 = 29;
335 optional int32 dummy30 = 30;
336 optional int32 dummy31 = 31;
337 optional int32 dummy32 = 32;
339 required int32 c = 33;
342 message TestRequiredForeign {
343 optional TestRequired optional_message = 1;
344 repeated TestRequired repeated_message = 2;
345 optional int32 dummy = 3;
348 // Test that we can use NestedMessage from outside TestAllTypes.
349 message TestForeignNested {
350 optional TestAllTypes.NestedMessage foreign_nested = 1;
353 // TestEmptyMessage is used to test unknown field support.
354 message TestEmptyMessage {
357 // Like above, but declare all field numbers as potential extensions. No
358 // actual extensions should ever be defined for this type.
359 message TestEmptyMessageWithExtensions {
363 message TestMultipleExtensionRanges {
365 extensions 4143 to 4243;
366 extensions 65536 to max;
369 // Test that really large tag numbers don't break anything.
370 message TestReallyLargeTagNumber {
371 // The largest possible tag number is 2^28 - 1, since the wire format uses
372 // three bits to communicate wire type.
373 optional int32 a = 1;
374 optional int32 bb = 268435455;
377 message TestRecursiveMessage {
378 optional TestRecursiveMessage a = 1;
379 optional int32 i = 2;
382 // Test that mutual recursion works.
383 message TestMutualRecursionA {
384 optional TestMutualRecursionB bb = 1;
387 message TestMutualRecursionB {
388 optional TestMutualRecursionA a = 1;
389 optional int32 optional_int32 = 2;
392 // Test that groups have disjoint field numbers from their siblings and
393 // parents. This is NOT possible in proto1; only proto2. When attempting
394 // to compile with proto1, this will emit an error; so we only include it
395 // in protobuf_unittest_proto.
396 message TestDupFieldNumber { // NO_PROTO1
397 optional int32 a = 1; // NO_PROTO1
398 optional group Foo = 2 { optional int32 a = 1; } // NO_PROTO1
399 optional group Bar = 3 { optional int32 a = 1; } // NO_PROTO1
403 // Needed for a Python test.
404 message TestNestedMessageHasBits {
405 message NestedMessageHasBits { //--- add 'HasBits' suffix to avoid redefinition warning
406 repeated int32 nestedmessage_repeated_int32 = 1;
407 repeated ForeignMessage nestedmessage_repeated_foreignmessage = 2;
409 optional NestedMessageHasBits optional_nested_message = 1;
413 // Test an enum that has multiple values with the same number.
414 enum TestEnumWithDupValue {
422 // Test an enum with large, unordered values.
423 enum TestSparseEnum {
433 // Test message with CamelCase field names. This violates Protocol Buffer
435 message TestCamelCaseFieldNames {
436 optional int32 PrimitiveField = 1;
437 optional string StringField = 2;
438 optional ForeignEnum EnumField = 3;
439 optional ForeignMessage MessageField = 4;
440 optional string StringPieceField = 5 [ctype=STRING_PIECE];
441 optional string CordField = 6 [ctype=CORD];
443 repeated int32 RepeatedPrimitiveField = 7;
444 repeated string RepeatedStringField = 8;
445 repeated ForeignEnum RepeatedEnumField = 9;
446 repeated ForeignMessage RepeatedMessageField = 10;
447 repeated string RepeatedStringPieceField = 11 [ctype=STRING_PIECE];
448 repeated string RepeatedCordField = 12 [ctype=CORD];
452 // We list fields out of order, to ensure that we're using field number and not
453 // field index to determine serialization order.
454 message TestFieldOrderings {
455 optional string my_string = 11;
457 optional int64 my_int = 1;
458 extensions 12 to 100;
459 optional float my_float = 101;
463 extend TestFieldOrderings {
464 optional string my_extension_string = 50;
465 optional int32 my_extension_int = 5;
469 message TestExtremeDefaultValues {
470 optional bytes escaped_bytes = 1 [default = "\0\001\a\b\f\n\r\t\v\\\'\"\xfe"];
471 optional uint32 large_uint32 = 2 [default = 0xFFFFFFFF];
472 optional uint64 large_uint64 = 3 [default = 0xFFFFFFFFFFFFFFFF];
473 optional int32 small_int32 = 4 [default = -0x7FFFFFFF];
474 optional int64 small_int64 = 5 [default = -0x7FFFFFFFFFFFFFFF];
476 // The default value here is UTF-8 for "\u1234". (We could also just type
477 // the UTF-8 text directly into this text file rather than escape it, but
478 // lots of people use editors that would be confused by this.)
479 optional string utf8_string = 6 [default = "\341\210\264"];
481 // Tests for single-precision floating-point values.
482 optional float zero_float = 7 [default = 0];
483 optional float one_float = 8 [default = 1];
484 optional float small_float = 9 [default = 1.5];
485 optional float negative_one_float = 10 [default = -1];
486 optional float negative_float = 11 [default = -1.5];
488 optional float large_float = 12 [default = 2E8];
489 optional float small_negative_float = 13 [default = -8e-28];
491 // Text for nonfinite floating-point values.
492 // XXXXXXXXXX: Common Lisp does not have standard infinities and NaNs.
493 // optional double inf_double = 14 [default = inf];
494 // optional double neg_inf_double = 15 [default = -inf];
495 // optional double nan_double = 16 [default = nan];
496 // optional float inf_float = 17 [default = inf];
497 // optional float neg_inf_float = 18 [default = -inf];
498 // optional float nan_float = 19 [default = nan];
501 message SparseEnumMessage {
502 optional TestSparseEnum sparse_enum = 1;
505 // Test String and Bytes: string is for valid UTF-8 strings
507 optional string data = 1;
511 optional bytes data = 1;
514 // Test messages for packed fields
516 message TestPackedTypes {
517 repeated int32 packed_int32 = 90 [packed = true];
518 repeated int64 packed_int64 = 91 [packed = true];
519 repeated uint32 packed_uint32 = 92 [packed = true];
520 repeated uint64 packed_uint64 = 93 [packed = true];
521 repeated sint32 packed_sint32 = 94 [packed = true];
522 repeated sint64 packed_sint64 = 95 [packed = true];
523 repeated fixed32 packed_fixed32 = 96 [packed = true];
524 repeated fixed64 packed_fixed64 = 97 [packed = true];
525 repeated sfixed32 packed_sfixed32 = 98 [packed = true];
526 repeated sfixed64 packed_sfixed64 = 99 [packed = true];
527 repeated float packed_float = 100 [packed = true];
528 repeated double packed_double = 101 [packed = true];
529 repeated bool packed_bool = 102 [packed = true];
530 repeated ForeignEnum packed_enum = 103 [packed = true];
533 // A message with the same fields as TestPackedTypes, but without packing. Used
534 // to test packed <-> unpacked wire compatibility.
535 message TestUnpackedTypes {
536 repeated int32 unpacked_int32 = 90 [packed = false];
537 repeated int64 unpacked_int64 = 91 [packed = false];
538 repeated uint32 unpacked_uint32 = 92 [packed = false];
539 repeated uint64 unpacked_uint64 = 93 [packed = false];
540 repeated sint32 unpacked_sint32 = 94 [packed = false];
541 repeated sint64 unpacked_sint64 = 95 [packed = false];
542 repeated fixed32 unpacked_fixed32 = 96 [packed = false];
543 repeated fixed64 unpacked_fixed64 = 97 [packed = false];
544 repeated sfixed32 unpacked_sfixed32 = 98 [packed = false];
545 repeated sfixed64 unpacked_sfixed64 = 99 [packed = false];
546 repeated float unpacked_float = 100 [packed = false];
547 repeated double unpacked_double = 101 [packed = false];
548 repeated bool unpacked_bool = 102 [packed = false];
549 repeated ForeignEnum unpacked_enum = 103 [packed = false];
552 message TestPackedExtensions {
556 extend TestPackedExtensions {
557 repeated int32 packed_int32_extension = 90 [packed = true];
558 repeated int64 packed_int64_extension = 91 [packed = true];
559 repeated uint32 packed_uint32_extension = 92 [packed = true];
560 repeated uint64 packed_uint64_extension = 93 [packed = true];
561 repeated sint32 packed_sint32_extension = 94 [packed = true];
562 repeated sint64 packed_sint64_extension = 95 [packed = true];
563 repeated fixed32 packed_fixed32_extension = 96 [packed = true];
564 repeated fixed64 packed_fixed64_extension = 97 [packed = true];
565 repeated sfixed32 packed_sfixed32_extension = 98 [packed = true];
566 repeated sfixed64 packed_sfixed64_extension = 99 [packed = true];
567 repeated float packed_float_extension = 100 [packed = true];
568 repeated double packed_double_extension = 101 [packed = true];
569 repeated bool packed_bool_extension = 102 [packed = true];
570 repeated ForeignEnum packed_enum_extension = 103 [packed = true];
573 // Used by ExtensionSetTest/DynamicExtensions. The test actually builds
574 // a set of extensions to TestAllExtensions dynamically, based on the fields
575 // of this message type.
576 message TestDynamicExtensions {
577 enum DynamicEnumType {
582 message DynamicMessageType {
583 optional int32 dynamic_field = 2100;
586 optional fixed32 scalar_extension = 2000;
587 optional ForeignEnum enum_extension = 2001;
588 optional DynamicEnumType dynamic_enum_extension = 2002;
590 optional ForeignMessage message_extension = 2003;
591 optional DynamicMessageType dynamic_message_extension = 2004;
593 repeated string repeated_extension = 2005;
594 repeated sint32 packed_extension = 2006 [packed = true];
597 message TestRepeatedScalarDifferentTagSizes {
598 // Parsing repeated fixed size values used to fail. This message needs to be
599 // used in order to get a tag of the right size; all of the repeated fields
600 // in TestAllTypes didn't trigger the check.
601 repeated fixed32 repeated_fixed32 = 12;
602 // Check for a varint type, just for good measure.
603 repeated int32 repeated_int32 = 13;
605 // These have two-byte tags.
606 repeated fixed64 repeated_fixed64 = 2046;
607 repeated int64 repeated_int64 = 2047;
610 repeated float repeated_float = 262142;
611 repeated uint64 repeated_uint64 = 262143;
615 // Test that RPC services work.
616 message FooRequest {}
617 message FooResponse {}
619 service TestService {
620 rpc Foo(FooRequest) returns (FooResponse);
621 rpc Bar(BarRequest) returns (BarResponse);
625 message BarRequest {}
626 message BarResponse {}