src/third_party/protobuf/src/google/protobuf/unittest.proto

   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 // Author: kenton@google.com (Kenton Varda)
  32 //  Based on original Protocol Buffers design by
  33 //  Sanjay Ghemawat, Jeff Dean, and others.
  34 //
  35 // A proto file we will use for unit testing.
  36
  37
  38 // Some generic_services option(s) added automatically.
  39 // See:  http://go/proto2-generic-services-default
  40 option cc_generic_services = true;     // auto-added
  41 option java_generic_services = true;   // auto-added
  42 option py_generic_services = true;     // auto-added
  43
  44 import "google/protobuf/unittest_import.proto";
  45
  46 // We don't put this in a package within proto2 because we need to make sure
  47 // that the generated code doesn't depend on being in the proto2 namespace.
  48 // In test_util.h we do "using namespace unittest = protobuf_unittest".
  49 package protobuf_unittest;
  50
  51 // Protos optimized for SPEED use a strict superset of the generated code
  52 // of equivalent ones optimized for CODE_SIZE, so we should optimize all our
  53 // tests for speed unless explicitly testing code size optimization.
  54 option optimize_for = SPEED;
  55
  56 option java_outer_classname = "UnittestProto";
  57
  58 // This proto includes every type of field in both singular and repeated
  59 // forms.
  60 message TestAllTypes {
  61   message NestedMessage {
  62     // The field name "b" fails to compile in proto1 because it conflicts with
  63     // a local variable named "b" in one of the generated methods.  Doh.
  64     // This file needs to compile in proto1 to test backwards-compatibility.
  65     optional int32 bb = 1;
  66   }
  67
  68   enum NestedEnum {
  69     FOO = 1;
  70     BAR = 2;
  71     BAZ = 3;
  72   }
  73
  74   // Singular
  75   optional    int32 optional_int32    =  1;
  76   optional    int64 optional_int64    =  2;
  77   optional   uint32 optional_uint32   =  3;
  78   optional   uint64 optional_uint64   =  4;
  79   optional   sint32 optional_sint32   =  5;
  80   optional   sint64 optional_sint64   =  6;
  81   optional  fixed32 optional_fixed32  =  7;
  82   optional  fixed64 optional_fixed64  =  8;
  83   optional sfixed32 optional_sfixed32 =  9;
  84   optional sfixed64 optional_sfixed64 = 10;
  85   optional    float optional_float    = 11;
  86   optional   double optional_double   = 12;
  87   optional     bool optional_bool     = 13;
  88   optional   string optional_string   = 14;
  89   optional    bytes optional_bytes    = 15;
  90
  91   optional group OptionalGroup = 16 {
  92     optional int32 a = 17;
  93   }
  94
  95   optional NestedMessage                        optional_nested_message  = 18;
  96   optional ForeignMessage                       optional_foreign_message = 19;
  97   optional protobuf_unittest_import.ImportMessage optional_import_message  = 20;
  98
  99   optional NestedEnum                           optional_nested_enum     = 21;
 100   optional ForeignEnum                          optional_foreign_enum    = 22;
 101   optional protobuf_unittest_import.ImportEnum    optional_import_enum     = 23;
 102
 103   optional string optional_string_piece = 24 [ctype=STRING_PIECE];
 104   optional string optional_cord = 25 [ctype=CORD];
 105
 106   // Defined in unittest_import_public.proto
 107   optional protobuf_unittest_import.PublicImportMessage
 108       optional_public_import_message = 26;
 109
 110   optional NestedMessage optional_lazy_message = 27 [lazy=true];
 111
 112   // Repeated
 113   repeated    int32 repeated_int32    = 31;
 114   repeated    int64 repeated_int64    = 32;
 115   repeated   uint32 repeated_uint32   = 33;
 116   repeated   uint64 repeated_uint64   = 34;
 117   repeated   sint32 repeated_sint32   = 35;
 118   repeated   sint64 repeated_sint64   = 36;
 119   repeated  fixed32 repeated_fixed32  = 37;
 120   repeated  fixed64 repeated_fixed64  = 38;
 121   repeated sfixed32 repeated_sfixed32 = 39;
 122   repeated sfixed64 repeated_sfixed64 = 40;
 123   repeated    float repeated_float    = 41;
 124   repeated   double repeated_double   = 42;
 125   repeated     bool repeated_bool     = 43;
 126   repeated   string repeated_string   = 44;
 127   repeated    bytes repeated_bytes    = 45;
 128
 129   repeated group RepeatedGroup = 46 {
 130     optional int32 a = 47;
 131   }
 132
 133   repeated NestedMessage                        repeated_nested_message  = 48;
 134   repeated ForeignMessage                       repeated_foreign_message = 49;
 135   repeated protobuf_unittest_import.ImportMessage repeated_import_message  = 50;
 136
 137   repeated NestedEnum                           repeated_nested_enum     = 51;
 138   repeated ForeignEnum                          repeated_foreign_enum    = 52;
 139   repeated protobuf_unittest_import.ImportEnum    repeated_import_enum     = 53;
 140
 141   repeated string repeated_string_piece = 54 [ctype=STRING_PIECE];
 142   repeated string repeated_cord = 55 [ctype=CORD];
 143
 144   repeated NestedMessage repeated_lazy_message = 57 [lazy=true];
 145
 146   // Singular with defaults
 147   optional    int32 default_int32    = 61 [default =  41    ];
 148   optional    int64 default_int64    = 62 [default =  42    ];
 149   optional   uint32 default_uint32   = 63 [default =  43    ];
 150   optional   uint64 default_uint64   = 64 [default =  44    ];
 151   optional   sint32 default_sint32   = 65 [default = -45    ];
 152   optional   sint64 default_sint64   = 66 [default =  46    ];
 153   optional  fixed32 default_fixed32  = 67 [default =  47    ];
 154   optional  fixed64 default_fixed64  = 68 [default =  48    ];
 155   optional sfixed32 default_sfixed32 = 69 [default =  49    ];
 156   optional sfixed64 default_sfixed64 = 70 [default = -50    ];
 157   optional    float default_float    = 71 [default =  51.5  ];
 158   optional   double default_double   = 72 [default =  52e3  ];
 159   optional     bool default_bool     = 73 [default = true   ];
 160   optional   string default_string   = 74 [default = "hello"];
 161   optional    bytes default_bytes    = 75 [default = "world"];
 162
 163   optional NestedEnum  default_nested_enum  = 81 [default = BAR        ];
 164   optional ForeignEnum default_foreign_enum = 82 [default = FOREIGN_BAR];
 165   optional protobuf_unittest_import.ImportEnum
 166       default_import_enum = 83 [default = IMPORT_BAR];
 167
 168   optional string default_string_piece = 84 [ctype=STRING_PIECE,default="abc"];
 169   optional string default_cord = 85 [ctype=CORD,default="123"];
 170 }
 171
 172 message TestDeprecatedFields {
 173   optional int32 deprecated_int32 = 1 [deprecated=true];
 174 }
 175
 176 // Define these after TestAllTypes to make sure the compiler can handle
 177 // that.
 178 message ForeignMessage {
 179   optional int32 c = 1;
 180 }
 181
 182 enum ForeignEnum {
 183   FOREIGN_FOO = 4;
 184   FOREIGN_BAR = 5;
 185   FOREIGN_BAZ = 6;
 186 }
 187
 188 message TestAllExtensions {
 189   extensions 1 to max;
 190 }
 191
 192 extend TestAllExtensions {
 193   // Singular
 194   optional    int32 optional_int32_extension    =  1;
 195   optional    int64 optional_int64_extension    =  2;
 196   optional   uint32 optional_uint32_extension   =  3;
 197   optional   uint64 optional_uint64_extension   =  4;
 198   optional   sint32 optional_sint32_extension   =  5;
 199   optional   sint64 optional_sint64_extension   =  6;
 200   optional  fixed32 optional_fixed32_extension  =  7;
 201   optional  fixed64 optional_fixed64_extension  =  8;
 202   optional sfixed32 optional_sfixed32_extension =  9;
 203   optional sfixed64 optional_sfixed64_extension = 10;
 204   optional    float optional_float_extension    = 11;
 205   optional   double optional_double_extension   = 12;
 206   optional     bool optional_bool_extension     = 13;
 207   optional   string optional_string_extension   = 14;
 208   optional    bytes optional_bytes_extension    = 15;
 209
 210   optional group OptionalGroup_extension = 16 {
 211     optional int32 a = 17;
 212   }
 213
 214   optional TestAllTypes.NestedMessage optional_nested_message_extension = 18;
 215   optional ForeignMessage optional_foreign_message_extension = 19;
 216   optional protobuf_unittest_import.ImportMessage
 217     optional_import_message_extension = 20;
 218
 219   optional TestAllTypes.NestedEnum optional_nested_enum_extension = 21;
 220   optional ForeignEnum optional_foreign_enum_extension = 22;
 221   optional protobuf_unittest_import.ImportEnum
 222     optional_import_enum_extension = 23;
 223
 224   optional string optional_string_piece_extension = 24 [ctype=STRING_PIECE];
 225   optional string optional_cord_extension = 25 [ctype=CORD];
 226
 227   optional protobuf_unittest_import.PublicImportMessage
 228     optional_public_import_message_extension = 26;
 229
 230   optional TestAllTypes.NestedMessage
 231     optional_lazy_message_extension = 27 [lazy=true];
 232
 233   // Repeated
 234   repeated    int32 repeated_int32_extension    = 31;
 235   repeated    int64 repeated_int64_extension    = 32;
 236   repeated   uint32 repeated_uint32_extension   = 33;
 237   repeated   uint64 repeated_uint64_extension   = 34;
 238   repeated   sint32 repeated_sint32_extension   = 35;
 239   repeated   sint64 repeated_sint64_extension   = 36;
 240   repeated  fixed32 repeated_fixed32_extension  = 37;
 241   repeated  fixed64 repeated_fixed64_extension  = 38;
 242   repeated sfixed32 repeated_sfixed32_extension = 39;
 243   repeated sfixed64 repeated_sfixed64_extension = 40;
 244   repeated    float repeated_float_extension    = 41;
 245   repeated   double repeated_double_extension   = 42;
 246   repeated     bool repeated_bool_extension     = 43;
 247   repeated   string repeated_string_extension   = 44;
 248   repeated    bytes repeated_bytes_extension    = 45;
 249
 250   repeated group RepeatedGroup_extension = 46 {
 251     optional int32 a = 47;
 252   }
 253
 254   repeated TestAllTypes.NestedMessage repeated_nested_message_extension = 48;
 255   repeated ForeignMessage repeated_foreign_message_extension = 49;
 256   repeated protobuf_unittest_import.ImportMessage
 257     repeated_import_message_extension = 50;
 258
 259   repeated TestAllTypes.NestedEnum repeated_nested_enum_extension = 51;
 260   repeated ForeignEnum repeated_foreign_enum_extension = 52;
 261   repeated protobuf_unittest_import.ImportEnum
 262     repeated_import_enum_extension = 53;
 263
 264   repeated string repeated_string_piece_extension = 54 [ctype=STRING_PIECE];
 265   repeated string repeated_cord_extension = 55 [ctype=CORD];
 266
 267   repeated TestAllTypes.NestedMessage
 268     repeated_lazy_message_extension = 57 [lazy=true];
 269
 270   // Singular with defaults
 271   optional    int32 default_int32_extension    = 61 [default =  41    ];
 272   optional    int64 default_int64_extension    = 62 [default =  42    ];
 273   optional   uint32 default_uint32_extension   = 63 [default =  43    ];
 274   optional   uint64 default_uint64_extension   = 64 [default =  44    ];
 275   optional   sint32 default_sint32_extension   = 65 [default = -45    ];
 276   optional   sint64 default_sint64_extension   = 66 [default =  46    ];
 277   optional  fixed32 default_fixed32_extension  = 67 [default =  47    ];
 278   optional  fixed64 default_fixed64_extension  = 68 [default =  48    ];
 279   optional sfixed32 default_sfixed32_extension = 69 [default =  49    ];
 280   optional sfixed64 default_sfixed64_extension = 70 [default = -50    ];
 281   optional    float default_float_extension    = 71 [default =  51.5  ];
 282   optional   double default_double_extension   = 72 [default =  52e3  ];
 283   optional     bool default_bool_extension     = 73 [default = true   ];
 284   optional   string default_string_extension   = 74 [default = "hello"];
 285   optional    bytes default_bytes_extension    = 75 [default = "world"];
 286
 287   optional TestAllTypes.NestedEnum
 288     default_nested_enum_extension = 81 [default = BAR];
 289   optional ForeignEnum
 290     default_foreign_enum_extension = 82 [default = FOREIGN_BAR];
 291   optional protobuf_unittest_import.ImportEnum
 292     default_import_enum_extension = 83 [default = IMPORT_BAR];
 293
 294   optional string default_string_piece_extension = 84 [ctype=STRING_PIECE,
 295                                                        default="abc"];
 296   optional string default_cord_extension = 85 [ctype=CORD, default="123"];
 297 }
 298
 299 message TestNestedExtension {
 300   extend TestAllExtensions {
 301     // Check for bug where string extensions declared in tested scope did not
 302     // compile.
 303     optional string test = 1002 [default="test"];
 304   }
 305 }
 306
 307 // We have separate messages for testing required fields because it's
 308 // annoying to have to fill in required fields in TestProto in order to
 309 // do anything with it.  Note that we don't need to test every type of
 310 // required filed because the code output is basically identical to
 311 // optional fields for all types.
 312 message TestRequired {
 313   required int32 a = 1;
 314   optional int32 dummy2 = 2;
 315   required int32 b = 3;
 316
 317   extend TestAllExtensions {
 318     optional TestRequired single = 1000;
 319     repeated TestRequired multi  = 1001;
 320   }
 321
 322   // Pad the field count to 32 so that we can test that IsInitialized()
 323   // properly checks multiple elements of has_bits_.
 324   optional int32 dummy4  =  4;
 325   optional int32 dummy5  =  5;
 326   optional int32 dummy6  =  6;
 327   optional int32 dummy7  =  7;
 328   optional int32 dummy8  =  8;
 329   optional int32 dummy9  =  9;
 330   optional int32 dummy10 = 10;
 331   optional int32 dummy11 = 11;
 332   optional int32 dummy12 = 12;
 333   optional int32 dummy13 = 13;
 334   optional int32 dummy14 = 14;
 335   optional int32 dummy15 = 15;
 336   optional int32 dummy16 = 16;
 337   optional int32 dummy17 = 17;
 338   optional int32 dummy18 = 18;
 339   optional int32 dummy19 = 19;
 340   optional int32 dummy20 = 20;
 341   optional int32 dummy21 = 21;
 342   optional int32 dummy22 = 22;
 343   optional int32 dummy23 = 23;
 344   optional int32 dummy24 = 24;
 345   optional int32 dummy25 = 25;
 346   optional int32 dummy26 = 26;
 347   optional int32 dummy27 = 27;
 348   optional int32 dummy28 = 28;
 349   optional int32 dummy29 = 29;
 350   optional int32 dummy30 = 30;
 351   optional int32 dummy31 = 31;
 352   optional int32 dummy32 = 32;
 353
 354   required int32 c = 33;
 355 }
 356
 357 message TestRequiredForeign {
 358   optional TestRequired optional_message = 1;
 359   repeated TestRequired repeated_message = 2;
 360   optional int32 dummy = 3;
 361 }
 362
 363 // Test that we can use NestedMessage from outside TestAllTypes.
 364 message TestForeignNested {
 365   optional TestAllTypes.NestedMessage foreign_nested = 1;
 366 }
 367
 368 // TestEmptyMessage is used to test unknown field support.
 369 message TestEmptyMessage {
 370 }
 371
 372 // Like above, but declare all field numbers as potential extensions.  No
 373 // actual extensions should ever be defined for this type.
 374 message TestEmptyMessageWithExtensions {
 375   extensions 1 to max;
 376 }
 377
 378 message TestMultipleExtensionRanges {
 379   extensions 42;
 380   extensions 4143 to 4243;
 381   extensions 65536 to max;
 382 }
 383
 384 // Test that really large tag numbers don't break anything.
 385 message TestReallyLargeTagNumber {
 386   // The largest possible tag number is 2^28 - 1, since the wire format uses
 387   // three bits to communicate wire type.
 388   optional int32 a = 1;
 389   optional int32 bb = 268435455;
 390 }
 391
 392 message TestRecursiveMessage {
 393   optional TestRecursiveMessage a = 1;
 394   optional int32 i = 2;
 395 }
 396
 397 // Test that mutual recursion works.
 398 message TestMutualRecursionA {
 399   optional TestMutualRecursionB bb = 1;
 400 }
 401
 402 message TestMutualRecursionB {
 403   optional TestMutualRecursionA a = 1;
 404   optional int32 optional_int32 = 2;
 405 }
 406
 407 // Test that groups have disjoint field numbers from their siblings and
 408 // parents.  This is NOT possible in proto1; only proto2.  When attempting
 409 // to compile with proto1, this will emit an error; so we only include it
 410 // in protobuf_unittest_proto.
 411 message TestDupFieldNumber {                        // NO_PROTO1
 412   optional int32 a = 1;                             // NO_PROTO1
 413   optional group Foo = 2 { optional int32 a = 1; }  // NO_PROTO1
 414   optional group Bar = 3 { optional int32 a = 1; }  // NO_PROTO1
 415 }                                                   // NO_PROTO1
 416
 417 // Additional messages for testing lazy fields.
 418 message TestEagerMessage {
 419   optional TestAllTypes sub_message = 1 [lazy=false];
 420 }
 421 message TestLazyMessage {
 422   optional TestAllTypes sub_message = 1 [lazy=true];
 423 }
 424
 425 // Needed for a Python test.
 426 message TestNestedMessageHasBits {
 427   message NestedMessage {
 428     repeated int32 nestedmessage_repeated_int32 = 1;
 429     repeated ForeignMessage nestedmessage_repeated_foreignmessage = 2;
 430   }
 431   optional NestedMessage optional_nested_message = 1;
 432 }
 433
 434
 435 // Test an enum that has multiple values with the same number.
 436 enum TestEnumWithDupValue {
 437   option allow_alias = true;
 438   FOO1 = 1;
 439   BAR1 = 2;
 440   BAZ = 3;
 441   FOO2 = 1;
 442   BAR2 = 2;
 443 }
 444
 445 // Test an enum with large, unordered values.
 446 enum TestSparseEnum {
 447   SPARSE_A = 123;
 448   SPARSE_B = 62374;
 449   SPARSE_C = 12589234;
 450   SPARSE_D = -15;
 451   SPARSE_E = -53452;
 452   SPARSE_F = 0;
 453   SPARSE_G = 2;
 454 }
 455
 456 // Test message with CamelCase field names.  This violates Protocol Buffer
 457 // standard style.
 458 message TestCamelCaseFieldNames {
 459   optional int32 PrimitiveField = 1;
 460   optional string StringField = 2;
 461   optional ForeignEnum EnumField = 3;
 462   optional ForeignMessage MessageField = 4;
 463   optional string StringPieceField = 5 [ctype=STRING_PIECE];
 464   optional string CordField = 6 [ctype=CORD];
 465
 466   repeated int32 RepeatedPrimitiveField = 7;
 467   repeated string RepeatedStringField = 8;
 468   repeated ForeignEnum RepeatedEnumField = 9;
 469   repeated ForeignMessage RepeatedMessageField = 10;
 470   repeated string RepeatedStringPieceField = 11 [ctype=STRING_PIECE];
 471   repeated string RepeatedCordField = 12 [ctype=CORD];
 472 }
 473
 474
 475 // We list fields out of order, to ensure that we're using field number and not
 476 // field index to determine serialization order.
 477 message TestFieldOrderings {
 478   optional string my_string = 11;
 479   extensions 2 to 10;
 480   optional int64 my_int = 1;
 481   extensions 12 to 100;
 482   optional float my_float = 101;
 483 }
 484
 485
 486 extend TestFieldOrderings {
 487   optional string my_extension_string = 50;
 488   optional int32 my_extension_int = 5;
 489 }
 490
 491
 492 message TestExtremeDefaultValues {
 493   optional bytes escaped_bytes = 1 [default = "\0\001\a\b\f\n\r\t\v\\\'\"\xfe"];
 494   optional uint32 large_uint32 = 2 [default = 0xFFFFFFFF];
 495   optional uint64 large_uint64 = 3 [default = 0xFFFFFFFFFFFFFFFF];
 496   optional  int32 small_int32  = 4 [default = -0x7FFFFFFF];
 497   optional  int64 small_int64  = 5 [default = -0x7FFFFFFFFFFFFFFF];
 498   optional  int32 really_small_int32 = 21 [default = -0x80000000];
 499   optional  int64 really_small_int64 = 22 [default = -0x8000000000000000];
 500
 501   // The default value here is UTF-8 for "\u1234".  (We could also just type
 502   // the UTF-8 text directly into this text file rather than escape it, but
 503   // lots of people use editors that would be confused by this.)
 504   optional string utf8_string = 6 [default = "\341\210\264"];
 505
 506   // Tests for single-precision floating-point values.
 507   optional float zero_float = 7 [default = 0];
 508   optional float one_float = 8 [default = 1];
 509   optional float small_float = 9 [default = 1.5];
 510   optional float negative_one_float = 10 [default = -1];
 511   optional float negative_float = 11 [default = -1.5];
 512   // Using exponents
 513   optional float large_float = 12 [default = 2E8];
 514   optional float small_negative_float = 13 [default = -8e-28];
 515
 516   // Text for nonfinite floating-point values.
 517   optional double inf_double = 14 [default = inf];
 518   optional double neg_inf_double = 15 [default = -inf];
 519   optional double nan_double = 16 [default = nan];
 520   optional float inf_float = 17 [default = inf];
 521   optional float neg_inf_float = 18 [default = -inf];
 522   optional float nan_float = 19 [default = nan];
 523
 524   // Tests for C++ trigraphs.
 525   // Trigraphs should be escaped in C++ generated files, but they should not be
 526   // escaped for other languages.
 527   // Note that in .proto file, "\?" is a valid way to escape ? in string
 528   // literals.
 529   optional string cpp_trigraph = 20 [default = "? \? ?? \?? \??? ??/ ?\?-"];
 530
 531   // String defaults containing the character '\000'
 532   optional string string_with_zero       = 23 [default = "hel\000lo"];
 533   optional  bytes bytes_with_zero        = 24 [default = "wor\000ld"];
 534   optional string string_piece_with_zero = 25 [ctype=STRING_PIECE,
 535                                                default="ab\000c"];
 536   optional string cord_with_zero         = 26 [ctype=CORD,
 537                                                default="12\0003"];
 538 }
 539
 540 message SparseEnumMessage {
 541   optional TestSparseEnum sparse_enum = 1;
 542 }
 543
 544 // Test String and Bytes: string is for valid UTF-8 strings
 545 message OneString {
 546   optional string data = 1;
 547 }
 548
 549 message MoreString {
 550   repeated string data = 1;
 551 }
 552
 553 message OneBytes {
 554   optional bytes data = 1;
 555 }
 556
 557 message MoreBytes {
 558   repeated bytes data = 1;
 559 }
 560
 561
 562 // Test messages for packed fields
 563
 564 message TestPackedTypes {
 565   repeated    int32 packed_int32    =  90 [packed = true];
 566   repeated    int64 packed_int64    =  91 [packed = true];
 567   repeated   uint32 packed_uint32   =  92 [packed = true];
 568   repeated   uint64 packed_uint64   =  93 [packed = true];
 569   repeated   sint32 packed_sint32   =  94 [packed = true];
 570   repeated   sint64 packed_sint64   =  95 [packed = true];
 571   repeated  fixed32 packed_fixed32  =  96 [packed = true];
 572   repeated  fixed64 packed_fixed64  =  97 [packed = true];
 573   repeated sfixed32 packed_sfixed32 =  98 [packed = true];
 574   repeated sfixed64 packed_sfixed64 =  99 [packed = true];
 575   repeated    float packed_float    = 100 [packed = true];
 576   repeated   double packed_double   = 101 [packed = true];
 577   repeated     bool packed_bool     = 102 [packed = true];
 578   repeated ForeignEnum packed_enum  = 103 [packed = true];
 579 }
 580
 581 // A message with the same fields as TestPackedTypes, but without packing. Used
 582 // to test packed <-> unpacked wire compatibility.
 583 message TestUnpackedTypes {
 584   repeated    int32 unpacked_int32    =  90 [packed = false];
 585   repeated    int64 unpacked_int64    =  91 [packed = false];
 586   repeated   uint32 unpacked_uint32   =  92 [packed = false];
 587   repeated   uint64 unpacked_uint64   =  93 [packed = false];
 588   repeated   sint32 unpacked_sint32   =  94 [packed = false];
 589   repeated   sint64 unpacked_sint64   =  95 [packed = false];
 590   repeated  fixed32 unpacked_fixed32  =  96 [packed = false];
 591   repeated  fixed64 unpacked_fixed64  =  97 [packed = false];
 592   repeated sfixed32 unpacked_sfixed32 =  98 [packed = false];
 593   repeated sfixed64 unpacked_sfixed64 =  99 [packed = false];
 594   repeated    float unpacked_float    = 100 [packed = false];
 595   repeated   double unpacked_double   = 101 [packed = false];
 596   repeated     bool unpacked_bool     = 102 [packed = false];
 597   repeated ForeignEnum unpacked_enum  = 103 [packed = false];
 598 }
 599
 600 message TestPackedExtensions {
 601   extensions 1 to max;
 602 }
 603
 604 extend TestPackedExtensions {
 605   repeated    int32 packed_int32_extension    =  90 [packed = true];
 606   repeated    int64 packed_int64_extension    =  91 [packed = true];
 607   repeated   uint32 packed_uint32_extension   =  92 [packed = true];
 608   repeated   uint64 packed_uint64_extension   =  93 [packed = true];
 609   repeated   sint32 packed_sint32_extension   =  94 [packed = true];
 610   repeated   sint64 packed_sint64_extension   =  95 [packed = true];
 611   repeated  fixed32 packed_fixed32_extension  =  96 [packed = true];
 612   repeated  fixed64 packed_fixed64_extension  =  97 [packed = true];
 613   repeated sfixed32 packed_sfixed32_extension =  98 [packed = true];
 614   repeated sfixed64 packed_sfixed64_extension =  99 [packed = true];
 615   repeated    float packed_float_extension    = 100 [packed = true];
 616   repeated   double packed_double_extension   = 101 [packed = true];
 617   repeated     bool packed_bool_extension     = 102 [packed = true];
 618   repeated ForeignEnum packed_enum_extension  = 103 [packed = true];
 619 }
 620
 621 // Used by ExtensionSetTest/DynamicExtensions.  The test actually builds
 622 // a set of extensions to TestAllExtensions dynamically, based on the fields
 623 // of this message type.
 624 message TestDynamicExtensions {
 625   enum DynamicEnumType {
 626     DYNAMIC_FOO = 2200;
 627     DYNAMIC_BAR = 2201;
 628     DYNAMIC_BAZ = 2202;
 629   }
 630   message DynamicMessageType {
 631     optional int32 dynamic_field = 2100;
 632   }
 633
 634   optional fixed32 scalar_extension = 2000;
 635   optional ForeignEnum enum_extension = 2001;
 636   optional DynamicEnumType dynamic_enum_extension = 2002;
 637
 638   optional ForeignMessage message_extension = 2003;
 639   optional DynamicMessageType dynamic_message_extension = 2004;
 640
 641   repeated string repeated_extension = 2005;
 642   repeated sint32 packed_extension = 2006 [packed = true];
 643 }
 644
 645 message TestRepeatedScalarDifferentTagSizes {
 646   // Parsing repeated fixed size values used to fail. This message needs to be
 647   // used in order to get a tag of the right size; all of the repeated fields
 648   // in TestAllTypes didn't trigger the check.
 649   repeated fixed32 repeated_fixed32 = 12;
 650   // Check for a varint type, just for good measure.
 651   repeated int32   repeated_int32   = 13;
 652
 653   // These have two-byte tags.
 654   repeated fixed64 repeated_fixed64 = 2046;
 655   repeated int64   repeated_int64   = 2047;
 656
 657   // Three byte tags.
 658   repeated float   repeated_float   = 262142;
 659   repeated uint64  repeated_uint64  = 262143;
 660 }
 661
 662 // Test that if an optional or required message/group field appears multiple
 663 // times in the input, they need to be merged.
 664 message TestParsingMerge {
 665   // RepeatedFieldsGenerator defines matching field types as TestParsingMerge,
 666   // except that all fields are repeated. In the tests, we will serialize the
 667   // RepeatedFieldsGenerator to bytes, and parse the bytes to TestParsingMerge.
 668   // Repeated fields in RepeatedFieldsGenerator are expected to be merged into
 669   // the corresponding required/optional fields in TestParsingMerge.
 670   message RepeatedFieldsGenerator {
 671     repeated TestAllTypes field1 = 1;
 672     repeated TestAllTypes field2 = 2;
 673     repeated TestAllTypes field3 = 3;
 674     repeated group Group1 = 10 {
 675       optional TestAllTypes field1 = 11;
 676     }
 677     repeated group Group2 = 20 {
 678       optional TestAllTypes field1 = 21;
 679     }
 680     repeated TestAllTypes ext1 = 1000;
 681     repeated TestAllTypes ext2 = 1001;
 682   }
 683   required TestAllTypes required_all_types = 1;
 684   optional TestAllTypes optional_all_types = 2;
 685   repeated TestAllTypes repeated_all_types = 3;
 686   optional group OptionalGroup = 10 {
 687     optional TestAllTypes optional_group_all_types = 11;
 688   }
 689   repeated group RepeatedGroup = 20 {
 690     optional TestAllTypes repeated_group_all_types = 21;
 691   }
 692   extensions 1000 to max;
 693   extend TestParsingMerge {
 694     optional TestAllTypes optional_ext = 1000;
 695     repeated TestAllTypes repeated_ext = 1001;
 696   }
 697 }
 698
 699 message TestCommentInjectionMessage {
 700   // */ <- This should not close the generated doc comment
 701   optional string a = 1 [default="*/ <- Neither should this."];
 702 }
 703
 704
 705 // Test that RPC services work.
 706 message FooRequest  {}
 707 message FooResponse {}
 708
 709 message FooClientMessage {}
 710 message FooServerMessage{}
 711
 712 service TestService {
 713   rpc Foo(FooRequest) returns (FooResponse);
 714   rpc Bar(BarRequest) returns (BarResponse);
 715 }
 716
 717
 718 message BarRequest  {}
 719 message BarResponse {}