1// Protocol Buffers - Google's data interchange format 2// Copyright 2008 Google Inc. All rights reserved. 3// https://developers.google.com/protocol-buffers/ 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 google.protobuf. 36 37syntax = "proto2"; 38 39// Some generic_services option(s) added automatically. 40// See: http://go/proto2-generic-services-default 41option cc_generic_services = true; // auto-added 42option java_generic_services = true; // auto-added 43option py_generic_services = true; 44 45// A custom file option (defined below). 46option (file_opt1) = 9876543210; 47 48import "google/protobuf/any.proto"; 49import "google/protobuf/descriptor.proto"; 50 51// We don't put this in a package within proto2 because we need to make sure 52// that the generated code doesn't depend on being in the proto2 namespace. 53package protobuf_unittest; 54 55// Some simple test custom options of various types. 56 57extend google.protobuf.FileOptions { 58 optional uint64 file_opt1 = 7736974; 59} 60 61extend google.protobuf.MessageOptions { 62 optional int32 message_opt1 = 7739036; 63} 64 65extend google.protobuf.FieldOptions { 66 optional fixed64 field_opt1 = 7740936; 67 // This is useful for testing that we correctly register default values for 68 // extension options. 69 optional int32 field_opt2 = 7753913 [default = 42]; 70} 71 72extend google.protobuf.OneofOptions { 73 optional int32 oneof_opt1 = 7740111; 74} 75 76extend google.protobuf.EnumOptions { 77 optional sfixed32 enum_opt1 = 7753576; 78} 79 80extend google.protobuf.EnumValueOptions { 81 optional int32 enum_value_opt1 = 1560678; 82} 83 84extend google.protobuf.ServiceOptions { 85 optional sint64 service_opt1 = 7887650; 86} 87 88enum MethodOpt1 { 89 METHODOPT1_VAL1 = 1; 90 METHODOPT1_VAL2 = 2; 91} 92 93extend google.protobuf.MethodOptions { 94 optional MethodOpt1 method_opt1 = 7890860; 95} 96 97// A test message with custom options at all possible locations (and also some 98// regular options, to make sure they interact nicely). 99message TestMessageWithCustomOptions { 100 option message_set_wire_format = false; 101 option (message_opt1) = -56; 102 103 optional string field1 = 1 [ctype = CORD, (field_opt1) = 8765432109]; 104 105 oneof AnOneof { 106 option (oneof_opt1) = -99; 107 108 int32 oneof_field = 2; 109 } 110 111 enum AnEnum { 112 option (enum_opt1) = -789; 113 114 ANENUM_VAL1 = 1; 115 ANENUM_VAL2 = 2 [(enum_value_opt1) = 123]; 116 } 117} 118 119// A test RPC service with custom options at all possible locations (and also 120// some regular options, to make sure they interact nicely). 121message CustomOptionFooRequest {} 122 123message CustomOptionFooResponse {} 124 125message CustomOptionFooClientMessage {} 126 127message CustomOptionFooServerMessage {} 128 129service TestServiceWithCustomOptions { 130 option (service_opt1) = -9876543210; 131 132 rpc Foo(CustomOptionFooRequest) returns (CustomOptionFooResponse) { 133 option (method_opt1) = METHODOPT1_VAL2; 134 } 135} 136 137// Options of every possible field type, so we can test them all exhaustively. 138 139message DummyMessageContainingEnum { 140 enum TestEnumType { 141 TEST_OPTION_ENUM_TYPE1 = 22; 142 TEST_OPTION_ENUM_TYPE2 = -23; 143 } 144} 145 146message DummyMessageInvalidAsOptionType {} 147 148extend google.protobuf.MessageOptions { 149 optional bool bool_opt = 7706090; 150 optional int32 int32_opt = 7705709; 151 optional int64 int64_opt = 7705542; 152 optional uint32 uint32_opt = 7704880; 153 optional uint64 uint64_opt = 7702367; 154 optional sint32 sint32_opt = 7701568; 155 optional sint64 sint64_opt = 7700863; 156 optional fixed32 fixed32_opt = 7700307; 157 optional fixed64 fixed64_opt = 7700194; 158 optional sfixed32 sfixed32_opt = 7698645; 159 optional sfixed64 sfixed64_opt = 7685475; 160 optional float float_opt = 7675390; 161 optional double double_opt = 7673293; 162 optional string string_opt = 7673285; 163 optional bytes bytes_opt = 7673238; 164 optional DummyMessageContainingEnum.TestEnumType enum_opt = 7673233; 165 optional DummyMessageInvalidAsOptionType message_type_opt = 7665967; 166} 167 168message CustomOptionMinIntegerValues { 169 option (bool_opt) = false; 170 option (int32_opt) = -0x80000000; 171 option (int64_opt) = -0x8000000000000000; 172 option (uint32_opt) = 0; 173 option (uint64_opt) = 0; 174 option (sint32_opt) = -0x80000000; 175 option (sint64_opt) = -0x8000000000000000; 176 option (fixed32_opt) = 0; 177 option (fixed64_opt) = 0; 178 option (sfixed32_opt) = -0x80000000; 179 option (sfixed64_opt) = -0x8000000000000000; 180} 181 182message CustomOptionMaxIntegerValues { 183 option (bool_opt) = true; 184 option (int32_opt) = 0x7FFFFFFF; 185 option (int64_opt) = 0x7FFFFFFFFFFFFFFF; 186 option (uint32_opt) = 0xFFFFFFFF; 187 option (uint64_opt) = 0xFFFFFFFFFFFFFFFF; 188 option (sint32_opt) = 0x7FFFFFFF; 189 option (sint64_opt) = 0x7FFFFFFFFFFFFFFF; 190 option (fixed32_opt) = 0xFFFFFFFF; 191 option (fixed64_opt) = 0xFFFFFFFFFFFFFFFF; 192 option (sfixed32_opt) = 0x7FFFFFFF; 193 option (sfixed64_opt) = 0x7FFFFFFFFFFFFFFF; 194} 195 196message CustomOptionOtherValues { 197 option (int32_opt) = -100; // To test sign-extension. 198 option (float_opt) = 12.3456789; 199 option (double_opt) = 1.234567890123456789; 200 option (string_opt) = "Hello, \"World\""; 201 option (bytes_opt) = "Hello\0World"; 202 option (enum_opt) = TEST_OPTION_ENUM_TYPE2; 203} 204 205message SettingRealsFromPositiveInts { 206 option (float_opt) = 12; 207 option (double_opt) = 154; 208} 209 210message SettingRealsFromNegativeInts { 211 option (float_opt) = -12; 212 option (double_opt) = -154; 213} 214 215// Options of complex message types, themselves combined and extended in 216// various ways. 217 218message ComplexOptionType1 { 219 optional int32 foo = 1; 220 optional int32 foo2 = 2; 221 optional int32 foo3 = 3; 222 repeated int32 foo4 = 4; 223 224 extensions 100 to max; 225} 226 227message ComplexOptionType2 { 228 optional ComplexOptionType1 bar = 1; 229 optional int32 baz = 2; 230 231 message ComplexOptionType4 { 232 optional int32 waldo = 1; 233 234 extend google.protobuf.MessageOptions { 235 optional ComplexOptionType4 complex_opt4 = 7633546; 236 } 237 } 238 239 optional ComplexOptionType4 fred = 3; 240 repeated ComplexOptionType4 barney = 4; 241 242 extensions 100 to max; 243} 244 245message ComplexOptionType3 { 246 optional int32 qux = 1; 247 248 optional group ComplexOptionType5 = 2 { 249 optional int32 plugh = 3; 250 } 251} 252 253extend ComplexOptionType1 { 254 optional int32 quux = 7663707; 255 optional ComplexOptionType3 corge = 7663442; 256} 257 258extend ComplexOptionType2 { 259 optional int32 grault = 7650927; 260 optional ComplexOptionType1 garply = 7649992; 261} 262 263extend google.protobuf.MessageOptions { 264 optional protobuf_unittest.ComplexOptionType1 complex_opt1 = 7646756; 265 optional ComplexOptionType2 complex_opt2 = 7636949; 266 optional ComplexOptionType3 complex_opt3 = 7636463; 267 optional group ComplexOpt6 = 7595468 { 268 optional int32 xyzzy = 7593951; 269 } 270} 271 272// Note that we try various different ways of naming the same extension. 273message VariousComplexOptions { 274 option (.protobuf_unittest.complex_opt1).foo = 42; 275 option (protobuf_unittest.complex_opt1).(.protobuf_unittest.quux) = 324; 276 option (.protobuf_unittest.complex_opt1).(protobuf_unittest.corge).qux = 876; 277 option (protobuf_unittest.complex_opt1).foo4 = 99; 278 option (protobuf_unittest.complex_opt1).foo4 = 88; 279 option (complex_opt2).baz = 987; 280 option (complex_opt2).(grault) = 654; 281 option (complex_opt2).bar.foo = 743; 282 option (complex_opt2).bar.(quux) = 1999; 283 option (complex_opt2).bar.(protobuf_unittest.corge).qux = 2008; 284 option (complex_opt2).(garply).foo = 741; 285 option (complex_opt2).(garply).(.protobuf_unittest.quux) = 1998; 286 option (complex_opt2).(protobuf_unittest.garply).(corge).qux = 2121; 287 option (ComplexOptionType2.ComplexOptionType4.complex_opt4).waldo = 1971; 288 option (complex_opt2).fred.waldo = 321; 289 option (complex_opt2).barney = { 290 waldo: 101 291 }; 292 option (complex_opt2).barney = { 293 waldo: 212 294 }; 295 option (protobuf_unittest.complex_opt3).qux = 9; 296 option (complex_opt3).complexoptiontype5.plugh = 22; 297 option (complexopt6).xyzzy = 24; 298} 299 300// ------------------------------------------------------ 301// Definitions for testing aggregate option parsing. 302// See descriptor_unittest.cc. 303 304message AggregateMessageSet { 305 option message_set_wire_format = true; 306 307 extensions 4 to max; 308} 309 310message AggregateMessageSetElement { 311 extend AggregateMessageSet { 312 optional AggregateMessageSetElement message_set_extension = 15447542; 313 } 314 optional string s = 1; 315} 316 317// A helper type used to test aggregate option parsing 318message Aggregate { 319 optional int32 i = 1; 320 optional string s = 2; 321 322 // A nested object 323 optional Aggregate sub = 3; 324 325 // To test the parsing of extensions inside aggregate values 326 optional google.protobuf.FileOptions file = 4; 327 extend google.protobuf.FileOptions { 328 optional Aggregate nested = 15476903; 329 } 330 331 // An embedded message set 332 optional AggregateMessageSet mset = 5; 333 334 // An any 335 optional google.protobuf.Any any = 6; 336} 337 338// Allow Aggregate to be used as an option at all possible locations 339// in the .proto grammar. 340extend google.protobuf.FileOptions { 341 optional Aggregate fileopt = 15478479; 342} 343extend google.protobuf.MessageOptions { 344 optional Aggregate msgopt = 15480088; 345} 346extend google.protobuf.FieldOptions { 347 optional Aggregate fieldopt = 15481374; 348} 349extend google.protobuf.EnumOptions { 350 optional Aggregate enumopt = 15483218; 351} 352extend google.protobuf.EnumValueOptions { 353 optional Aggregate enumvalopt = 15486921; 354} 355extend google.protobuf.ServiceOptions { 356 optional Aggregate serviceopt = 15497145; 357} 358extend google.protobuf.MethodOptions { 359 optional Aggregate methodopt = 15512713; 360} 361 362// Try using AggregateOption at different points in the proto grammar 363option (fileopt) = { 364 s: 'FileAnnotation' 365 // Also test the handling of comments 366 /* of both types */ 367 i: 100 368 369 sub { s: 'NestedFileAnnotation' } 370 371 // Include a google.protobuf.FileOptions and recursively extend it with 372 // another fileopt. 373 file { 374 [protobuf_unittest.fileopt] { s: 'FileExtensionAnnotation' } 375 } 376 377 // A message set inside an option value 378 mset { 379 [protobuf_unittest.AggregateMessageSetElement.message_set_extension] { 380 s: 'EmbeddedMessageSetElement' 381 } 382 } 383 384 any { 385 [type.googleapis.com/protobuf_unittest.AggregateMessageSetElement] { 386 s: 'EmbeddedMessageSetElement' 387 } 388 } 389}; 390 391message AggregateMessage { 392 option (msgopt) = { 393 i: 101 394 s: 'MessageAnnotation' 395 }; 396 397 optional int32 fieldname = 1 [(fieldopt) = { s: 'FieldAnnotation' }]; 398} 399 400service AggregateService { 401 option (serviceopt) = { 402 s: 'ServiceAnnotation' 403 }; 404 405 rpc Method(AggregateMessage) returns (AggregateMessage) { 406 option (methodopt) = { 407 s: 'MethodAnnotation' 408 }; 409 } 410} 411 412enum AggregateEnum { 413 option (enumopt) = { 414 s: 'EnumAnnotation' 415 }; 416 417 VALUE = 1 [(enumvalopt) = { s: 'EnumValueAnnotation' }]; 418} 419 420// Test custom options for nested type. 421message NestedOptionType { 422 message NestedMessage { 423 option (message_opt1) = 1001; 424 425 optional int32 nested_field = 1 [(field_opt1) = 1002]; 426 } 427 enum NestedEnum { 428 option (enum_opt1) = 1003; 429 430 NESTED_ENUM_VALUE = 1 [(enum_value_opt1) = 1004]; 431 } 432 extend google.protobuf.FileOptions { 433 optional int32 nested_extension = 7912573 [(field_opt2) = 1005]; 434 } 435} 436 437// Custom message option that has a required enum field. 438// WARNING: this is strongly discouraged! 439message OldOptionType { 440 enum TestEnum { OLD_VALUE = 0; } 441 required TestEnum value = 1; 442} 443 444// Updated version of the custom option above. 445message NewOptionType { 446 enum TestEnum { 447 OLD_VALUE = 0; 448 NEW_VALUE = 1; 449 } 450 required TestEnum value = 1; 451} 452 453extend google.protobuf.MessageOptions { 454 optional OldOptionType required_enum_opt = 106161807; 455} 456 457// Test message using the "required_enum_opt" option defined above. 458message TestMessageWithRequiredEnumOption { 459 option (required_enum_opt) = { 460 value: OLD_VALUE 461 }; 462} 463