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

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