| OLD | NEW |
| (Empty) |
| 1 // Protocol Buffers - Google's data interchange format | |
| 2 // Copyright 2008 Google Inc. All rights reserved. | |
| 3 // http://code.google.com/p/protobuf/ | |
| 4 // | |
| 5 // Redistribution and use in source and binary forms, with or without | |
| 6 // modification, are permitted provided that the following conditions are | |
| 7 // met: | |
| 8 // | |
| 9 // * Redistributions of source code must retain the above copyright | |
| 10 // notice, this list of conditions and the following disclaimer. | |
| 11 // * Redistributions in binary form must reproduce the above | |
| 12 // copyright notice, this list of conditions and the following disclaimer | |
| 13 // in the documentation and/or other materials provided with the | |
| 14 // distribution. | |
| 15 // * Neither the name of Google Inc. nor the names of its | |
| 16 // contributors may be used to endorse or promote products derived from | |
| 17 // this software without specific prior written permission. | |
| 18 // | |
| 19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
| 20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
| 21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
| 22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
| 23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
| 24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
| 25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
| 26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
| 27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
| 28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
| 29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| 30 | |
| 31 // Author: benjy@google.com (Benjy Weinberger) | |
| 32 // Based on original Protocol Buffers design by | |
| 33 // Sanjay Ghemawat, Jeff Dean, and others. | |
| 34 // | |
| 35 // A proto file used to test the "custom options" feature of proto2. | |
| 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; | |
| 43 | |
| 44 // A custom file option (defined below). | |
| 45 option (file_opt1) = 9876543210; | |
| 46 | |
| 47 import "google/protobuf/descriptor.proto"; | |
| 48 | |
| 49 // We don't put this in a package within proto2 because we need to make sure | |
| 50 // that the generated code doesn't depend on being in the proto2 namespace. | |
| 51 package protobuf_unittest; | |
| 52 | |
| 53 | |
| 54 // Some simple test custom options of various types. | |
| 55 | |
| 56 extend google.protobuf.FileOptions { | |
| 57 optional uint64 file_opt1 = 7736974; | |
| 58 } | |
| 59 | |
| 60 extend google.protobuf.MessageOptions { | |
| 61 optional int32 message_opt1 = 7739036; | |
| 62 } | |
| 63 | |
| 64 extend google.protobuf.FieldOptions { | |
| 65 optional fixed64 field_opt1 = 7740936; | |
| 66 // This is useful for testing that we correctly register default values for | |
| 67 // extension options. | |
| 68 optional int32 field_opt2 = 7753913 [default=42]; | |
| 69 } | |
| 70 | |
| 71 extend google.protobuf.EnumOptions { | |
| 72 optional sfixed32 enum_opt1 = 7753576; | |
| 73 } | |
| 74 | |
| 75 extend google.protobuf.EnumValueOptions { | |
| 76 optional int32 enum_value_opt1 = 1560678; | |
| 77 } | |
| 78 | |
| 79 extend google.protobuf.ServiceOptions { | |
| 80 optional sint64 service_opt1 = 7887650; | |
| 81 } | |
| 82 | |
| 83 enum MethodOpt1 { | |
| 84 METHODOPT1_VAL1 = 1; | |
| 85 METHODOPT1_VAL2 = 2; | |
| 86 } | |
| 87 | |
| 88 extend google.protobuf.MethodOptions { | |
| 89 optional MethodOpt1 method_opt1 = 7890860; | |
| 90 } | |
| 91 | |
| 92 // A test message with custom options at all possible locations (and also some | |
| 93 // regular options, to make sure they interact nicely). | |
| 94 message TestMessageWithCustomOptions { | |
| 95 option message_set_wire_format = false; | |
| 96 | |
| 97 option (message_opt1) = -56; | |
| 98 | |
| 99 optional string field1 = 1 [ctype=CORD, | |
| 100 (field_opt1)=8765432109]; | |
| 101 | |
| 102 enum AnEnum { | |
| 103 option (enum_opt1) = -789; | |
| 104 | |
| 105 ANENUM_VAL1 = 1; | |
| 106 ANENUM_VAL2 = 2 [(enum_value_opt1) = 123]; | |
| 107 } | |
| 108 } | |
| 109 | |
| 110 | |
| 111 // A test RPC service with custom options at all possible locations (and also | |
| 112 // some regular options, to make sure they interact nicely). | |
| 113 message CustomOptionFooRequest { | |
| 114 } | |
| 115 | |
| 116 message CustomOptionFooResponse { | |
| 117 } | |
| 118 | |
| 119 message CustomOptionFooClientMessage { | |
| 120 } | |
| 121 | |
| 122 message CustomOptionFooServerMessage { | |
| 123 } | |
| 124 | |
| 125 service TestServiceWithCustomOptions { | |
| 126 option (service_opt1) = -9876543210; | |
| 127 | |
| 128 rpc Foo(CustomOptionFooRequest) returns (CustomOptionFooResponse) { | |
| 129 option (method_opt1) = METHODOPT1_VAL2; | |
| 130 } | |
| 131 } | |
| 132 | |
| 133 | |
| 134 | |
| 135 // Options of every possible field type, so we can test them all exhaustively. | |
| 136 | |
| 137 message DummyMessageContainingEnum { | |
| 138 enum TestEnumType { | |
| 139 TEST_OPTION_ENUM_TYPE1 = 22; | |
| 140 TEST_OPTION_ENUM_TYPE2 = -23; | |
| 141 } | |
| 142 } | |
| 143 | |
| 144 message DummyMessageInvalidAsOptionType { | |
| 145 } | |
| 146 | |
| 147 extend google.protobuf.MessageOptions { | |
| 148 optional bool bool_opt = 7706090; | |
| 149 optional int32 int32_opt = 7705709; | |
| 150 optional int64 int64_opt = 7705542; | |
| 151 optional uint32 uint32_opt = 7704880; | |
| 152 optional uint64 uint64_opt = 7702367; | |
| 153 optional sint32 sint32_opt = 7701568; | |
| 154 optional sint64 sint64_opt = 7700863; | |
| 155 optional fixed32 fixed32_opt = 7700307; | |
| 156 optional fixed64 fixed64_opt = 7700194; | |
| 157 optional sfixed32 sfixed32_opt = 7698645; | |
| 158 optional sfixed64 sfixed64_opt = 7685475; | |
| 159 optional float float_opt = 7675390; | |
| 160 optional double double_opt = 7673293; | |
| 161 optional string string_opt = 7673285; | |
| 162 optional bytes bytes_opt = 7673238; | |
| 163 optional DummyMessageContainingEnum.TestEnumType enum_opt = 7673233; | |
| 164 optional DummyMessageInvalidAsOptionType message_type_opt = 7665967; | |
| 165 } | |
| 166 | |
| 167 message CustomOptionMinIntegerValues { | |
| 168 option (bool_opt) = false; | |
| 169 option (int32_opt) = -0x80000000; | |
| 170 option (int64_opt) = -0x8000000000000000; | |
| 171 option (uint32_opt) = 0; | |
| 172 option (uint64_opt) = 0; | |
| 173 option (sint32_opt) = -0x80000000; | |
| 174 option (sint64_opt) = -0x8000000000000000; | |
| 175 option (fixed32_opt) = 0; | |
| 176 option (fixed64_opt) = 0; | |
| 177 option (sfixed32_opt) = -0x80000000; | |
| 178 option (sfixed64_opt) = -0x8000000000000000; | |
| 179 } | |
| 180 | |
| 181 message CustomOptionMaxIntegerValues { | |
| 182 option (bool_opt) = true; | |
| 183 option (int32_opt) = 0x7FFFFFFF; | |
| 184 option (int64_opt) = 0x7FFFFFFFFFFFFFFF; | |
| 185 option (uint32_opt) = 0xFFFFFFFF; | |
| 186 option (uint64_opt) = 0xFFFFFFFFFFFFFFFF; | |
| 187 option (sint32_opt) = 0x7FFFFFFF; | |
| 188 option (sint64_opt) = 0x7FFFFFFFFFFFFFFF; | |
| 189 option (fixed32_opt) = 0xFFFFFFFF; | |
| 190 option (fixed64_opt) = 0xFFFFFFFFFFFFFFFF; | |
| 191 option (sfixed32_opt) = 0x7FFFFFFF; | |
| 192 option (sfixed64_opt) = 0x7FFFFFFFFFFFFFFF; | |
| 193 } | |
| 194 | |
| 195 message CustomOptionOtherValues { | |
| 196 option (int32_opt) = -100; // To test sign-extension. | |
| 197 option (float_opt) = 12.3456789; | |
| 198 option (double_opt) = 1.234567890123456789; | |
| 199 option (string_opt) = "Hello, \"World\""; | |
| 200 option (bytes_opt) = "Hello\0World"; | |
| 201 option (enum_opt) = TEST_OPTION_ENUM_TYPE2; | |
| 202 } | |
| 203 | |
| 204 message SettingRealsFromPositiveInts { | |
| 205 option (float_opt) = 12; | |
| 206 option (double_opt) = 154; | |
| 207 } | |
| 208 | |
| 209 message SettingRealsFromNegativeInts { | |
| 210 option (float_opt) = -12; | |
| 211 option (double_opt) = -154; | |
| 212 } | |
| 213 | |
| 214 // Options of complex message types, themselves combined and extended in | |
| 215 // various ways. | |
| 216 | |
| 217 message ComplexOptionType1 { | |
| 218 optional int32 foo = 1; | |
| 219 optional int32 foo2 = 2; | |
| 220 optional int32 foo3 = 3; | |
| 221 | |
| 222 extensions 100 to max; | |
| 223 } | |
| 224 | |
| 225 message ComplexOptionType2 { | |
| 226 optional ComplexOptionType1 bar = 1; | |
| 227 optional int32 baz = 2; | |
| 228 | |
| 229 message ComplexOptionType4 { | |
| 230 optional int32 waldo = 1; | |
| 231 | |
| 232 extend google.protobuf.MessageOptions { | |
| 233 optional ComplexOptionType4 complex_opt4 = 7633546; | |
| 234 } | |
| 235 } | |
| 236 | |
| 237 optional ComplexOptionType4 fred = 3; | |
| 238 | |
| 239 extensions 100 to max; | |
| 240 } | |
| 241 | |
| 242 message ComplexOptionType3 { | |
| 243 optional int32 qux = 1; | |
| 244 | |
| 245 optional group ComplexOptionType5 = 2 { | |
| 246 optional int32 plugh = 3; | |
| 247 } | |
| 248 } | |
| 249 | |
| 250 extend ComplexOptionType1 { | |
| 251 optional int32 quux = 7663707; | |
| 252 optional ComplexOptionType3 corge = 7663442; | |
| 253 } | |
| 254 | |
| 255 extend ComplexOptionType2 { | |
| 256 optional int32 grault = 7650927; | |
| 257 optional ComplexOptionType1 garply = 7649992; | |
| 258 } | |
| 259 | |
| 260 extend google.protobuf.MessageOptions { | |
| 261 optional protobuf_unittest.ComplexOptionType1 complex_opt1 = 7646756; | |
| 262 optional ComplexOptionType2 complex_opt2 = 7636949; | |
| 263 optional ComplexOptionType3 complex_opt3 = 7636463; | |
| 264 optional group ComplexOpt6 = 7595468 { | |
| 265 optional int32 xyzzy = 7593951; | |
| 266 } | |
| 267 } | |
| 268 | |
| 269 // Note that we try various different ways of naming the same extension. | |
| 270 message VariousComplexOptions { | |
| 271 option (.protobuf_unittest.complex_opt1).foo = 42; | |
| 272 option (protobuf_unittest.complex_opt1).(.protobuf_unittest.quux) = 324; | |
| 273 option (.protobuf_unittest.complex_opt1).(protobuf_unittest.corge).qux = 876; | |
| 274 option (complex_opt2).baz = 987; | |
| 275 option (complex_opt2).(grault) = 654; | |
| 276 option (complex_opt2).bar.foo = 743; | |
| 277 option (complex_opt2).bar.(quux) = 1999; | |
| 278 option (complex_opt2).bar.(protobuf_unittest.corge).qux = 2008; | |
| 279 option (complex_opt2).(garply).foo = 741; | |
| 280 option (complex_opt2).(garply).(.protobuf_unittest.quux) = 1998; | |
| 281 option (complex_opt2).(protobuf_unittest.garply).(corge).qux = 2121; | |
| 282 option (ComplexOptionType2.ComplexOptionType4.complex_opt4).waldo = 1971; | |
| 283 option (complex_opt2).fred.waldo = 321; | |
| 284 option (protobuf_unittest.complex_opt3).qux = 9; | |
| 285 option (complex_opt3).complexoptiontype5.plugh = 22; | |
| 286 option (complexopt6).xyzzy = 24; | |
| 287 } | |
| 288 | |
| 289 // ------------------------------------------------------ | |
| 290 // Definitions for testing aggregate option parsing. | |
| 291 // See descriptor_unittest.cc. | |
| 292 | |
| 293 message AggregateMessageSet { | |
| 294 option message_set_wire_format = true; | |
| 295 extensions 4 to max; | |
| 296 } | |
| 297 | |
| 298 message AggregateMessageSetElement { | |
| 299 extend AggregateMessageSet { | |
| 300 optional AggregateMessageSetElement message_set_extension = 15447542; | |
| 301 } | |
| 302 optional string s = 1; | |
| 303 } | |
| 304 | |
| 305 // A helper type used to test aggregate option parsing | |
| 306 message Aggregate { | |
| 307 optional int32 i = 1; | |
| 308 optional string s = 2; | |
| 309 | |
| 310 // A nested object | |
| 311 optional Aggregate sub = 3; | |
| 312 | |
| 313 // To test the parsing of extensions inside aggregate values | |
| 314 optional google.protobuf.FileOptions file = 4; | |
| 315 extend google.protobuf.FileOptions { | |
| 316 optional Aggregate nested = 15476903; | |
| 317 } | |
| 318 | |
| 319 // An embedded message set | |
| 320 optional AggregateMessageSet mset = 5; | |
| 321 } | |
| 322 | |
| 323 // Allow Aggregate to be used as an option at all possible locations | |
| 324 // in the .proto grammer. | |
| 325 extend google.protobuf.FileOptions { optional Aggregate fileopt = 154784
79; } | |
| 326 extend google.protobuf.MessageOptions { optional Aggregate msgopt = 154800
88; } | |
| 327 extend google.protobuf.FieldOptions { optional Aggregate fieldopt = 154813
74; } | |
| 328 extend google.protobuf.EnumOptions { optional Aggregate enumopt = 154832
18; } | |
| 329 extend google.protobuf.EnumValueOptions { optional Aggregate enumvalopt = 154869
21; } | |
| 330 extend google.protobuf.ServiceOptions { optional Aggregate serviceopt = 154971
45; } | |
| 331 extend google.protobuf.MethodOptions { optional Aggregate methodopt = 155127
13; } | |
| 332 | |
| 333 // Try using AggregateOption at different points in the proto grammar | |
| 334 option (fileopt) = { | |
| 335 s: 'FileAnnotation' | |
| 336 // Also test the handling of comments | |
| 337 /* of both types */ i: 100 | |
| 338 | |
| 339 sub { s: 'NestedFileAnnotation' } | |
| 340 | |
| 341 // Include a google.protobuf.FileOptions and recursively extend it with | |
| 342 // another fileopt. | |
| 343 file { | |
| 344 [protobuf_unittest.fileopt] { | |
| 345 s:'FileExtensionAnnotation' | |
| 346 } | |
| 347 } | |
| 348 | |
| 349 // A message set inside an option value | |
| 350 mset { | |
| 351 [protobuf_unittest.AggregateMessageSetElement.message_set_extension] { | |
| 352 s: 'EmbeddedMessageSetElement' | |
| 353 } | |
| 354 } | |
| 355 }; | |
| 356 | |
| 357 message AggregateMessage { | |
| 358 option (msgopt) = { i:101 s:'MessageAnnotation' }; | |
| 359 optional int32 fieldname = 1 [(fieldopt) = { s:'FieldAnnotation' }]; | |
| 360 } | |
| 361 | |
| 362 service AggregateService { | |
| 363 option (serviceopt) = { s:'ServiceAnnotation' }; | |
| 364 rpc Method (AggregateMessage) returns (AggregateMessage) { | |
| 365 option (methodopt) = { s:'MethodAnnotation' }; | |
| 366 } | |
| 367 } | |
| 368 | |
| 369 enum AggregateEnum { | |
| 370 option (enumopt) = { s:'EnumAnnotation' }; | |
| 371 VALUE = 1 [(enumvalopt) = { s:'EnumValueAnnotation' }]; | |
| 372 } | |
| 373 | |
| 374 // Test custom options for nested type. | |
| 375 message NestedOptionType { | |
| 376 message NestedMessage { | |
| 377 option (message_opt1) = 1001; | |
| 378 optional int32 nested_field = 1 [(field_opt1) = 1002]; | |
| 379 } | |
| 380 enum NestedEnum { | |
| 381 option (enum_opt1) = 1003; | |
| 382 NESTED_ENUM_VALUE = 1 [(enum_value_opt1) = 1004]; | |
| 383 } | |
| 384 extend google.protobuf.FileOptions { | |
| 385 optional int32 nested_extension = 7912573 [(field_opt2) = 1005]; | |
| 386 } | |
| 387 } | |
| OLD | NEW |