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