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: kenton (at) google.com (Kenton Varda) 32 // Based on original Protocol Buffers design by 33 // Sanjay Ghemawat, Jeff Dean, and others. 34 // 35 // This file makes extensive use of RFC 3092. :) 36 37 #include <vector> 38 39 #include <google/protobuf/compiler/importer.h> 40 #include <google/protobuf/unittest.pb.h> 41 #include <google/protobuf/unittest_custom_options.pb.h> 42 #include <google/protobuf/io/zero_copy_stream_impl.h> 43 #include <google/protobuf/descriptor.pb.h> 44 #include <google/protobuf/descriptor.h> 45 #include <google/protobuf/descriptor_database.h> 46 #include <google/protobuf/dynamic_message.h> 47 #include <google/protobuf/text_format.h> 48 #include <google/protobuf/stubs/strutil.h> 49 #include <google/protobuf/stubs/substitute.h> 50 51 #include <google/protobuf/stubs/common.h> 52 #include <google/protobuf/testing/googletest.h> 53 #include <gtest/gtest.h> 54 55 namespace google { 56 namespace protobuf { 57 58 // Can't use an anonymous namespace here due to brokenness of Tru64 compiler. 59 namespace descriptor_unittest { 60 61 // Some helpers to make assembling descriptors faster. 62 DescriptorProto* AddMessage(FileDescriptorProto* file, const string& name) { 63 DescriptorProto* result = file->add_message_type(); 64 result->set_name(name); 65 return result; 66 } 67 68 DescriptorProto* AddNestedMessage(DescriptorProto* parent, const string& name) { 69 DescriptorProto* result = parent->add_nested_type(); 70 result->set_name(name); 71 return result; 72 } 73 74 EnumDescriptorProto* AddEnum(FileDescriptorProto* file, const string& name) { 75 EnumDescriptorProto* result = file->add_enum_type(); 76 result->set_name(name); 77 return result; 78 } 79 80 EnumDescriptorProto* AddNestedEnum(DescriptorProto* parent, 81 const string& name) { 82 EnumDescriptorProto* result = parent->add_enum_type(); 83 result->set_name(name); 84 return result; 85 } 86 87 ServiceDescriptorProto* AddService(FileDescriptorProto* file, 88 const string& name) { 89 ServiceDescriptorProto* result = file->add_service(); 90 result->set_name(name); 91 return result; 92 } 93 94 FieldDescriptorProto* AddField(DescriptorProto* parent, 95 const string& name, int number, 96 FieldDescriptorProto::Label label, 97 FieldDescriptorProto::Type type) { 98 FieldDescriptorProto* result = parent->add_field(); 99 result->set_name(name); 100 result->set_number(number); 101 result->set_label(label); 102 result->set_type(type); 103 return result; 104 } 105 106 FieldDescriptorProto* AddExtension(FileDescriptorProto* file, 107 const string& extendee, 108 const string& name, int number, 109 FieldDescriptorProto::Label label, 110 FieldDescriptorProto::Type type) { 111 FieldDescriptorProto* result = file->add_extension(); 112 result->set_name(name); 113 result->set_number(number); 114 result->set_label(label); 115 result->set_type(type); 116 result->set_extendee(extendee); 117 return result; 118 } 119 120 FieldDescriptorProto* AddNestedExtension(DescriptorProto* parent, 121 const string& extendee, 122 const string& name, int number, 123 FieldDescriptorProto::Label label, 124 FieldDescriptorProto::Type type) { 125 FieldDescriptorProto* result = parent->add_extension(); 126 result->set_name(name); 127 result->set_number(number); 128 result->set_label(label); 129 result->set_type(type); 130 result->set_extendee(extendee); 131 return result; 132 } 133 134 DescriptorProto::ExtensionRange* AddExtensionRange(DescriptorProto* parent, 135 int start, int end) { 136 DescriptorProto::ExtensionRange* result = parent->add_extension_range(); 137 result->set_start(start); 138 result->set_end(end); 139 return result; 140 } 141 142 EnumValueDescriptorProto* AddEnumValue(EnumDescriptorProto* enum_proto, 143 const string& name, int number) { 144 EnumValueDescriptorProto* result = enum_proto->add_value(); 145 result->set_name(name); 146 result->set_number(number); 147 return result; 148 } 149 150 MethodDescriptorProto* AddMethod(ServiceDescriptorProto* service, 151 const string& name, 152 const string& input_type, 153 const string& output_type) { 154 MethodDescriptorProto* result = service->add_method(); 155 result->set_name(name); 156 result->set_input_type(input_type); 157 result->set_output_type(output_type); 158 return result; 159 } 160 161 // Empty enums technically aren't allowed. We need to insert a dummy value 162 // into them. 163 void AddEmptyEnum(FileDescriptorProto* file, const string& name) { 164 AddEnumValue(AddEnum(file, name), name + "_DUMMY", 1); 165 } 166 167 // =================================================================== 168 169 // Test simple files. 170 class FileDescriptorTest : public testing::Test { 171 protected: 172 virtual void SetUp() { 173 // Build descriptors for the following definitions: 174 // 175 // // in "foo.proto" 176 // message FooMessage { extensions 1; } 177 // enum FooEnum {FOO_ENUM_VALUE = 1;} 178 // service FooService {} 179 // extend FooMessage { optional int32 foo_extension = 1; } 180 // 181 // // in "bar.proto" 182 // package bar_package; 183 // message BarMessage { extensions 1; } 184 // enum BarEnum {BAR_ENUM_VALUE = 1;} 185 // service BarService {} 186 // extend BarMessage { optional int32 bar_extension = 1; } 187 // 188 // Also, we have an empty file "baz.proto". This file's purpose is to 189 // make sure that even though it has the same package as foo.proto, 190 // searching it for members of foo.proto won't work. 191 192 FileDescriptorProto foo_file; 193 foo_file.set_name("foo.proto"); 194 AddExtensionRange(AddMessage(&foo_file, "FooMessage"), 1, 2); 195 AddEnumValue(AddEnum(&foo_file, "FooEnum"), "FOO_ENUM_VALUE", 1); 196 AddService(&foo_file, "FooService"); 197 AddExtension(&foo_file, "FooMessage", "foo_extension", 1, 198 FieldDescriptorProto::LABEL_OPTIONAL, 199 FieldDescriptorProto::TYPE_INT32); 200 201 FileDescriptorProto bar_file; 202 bar_file.set_name("bar.proto"); 203 bar_file.set_package("bar_package"); 204 bar_file.add_dependency("foo.proto"); 205 AddExtensionRange(AddMessage(&bar_file, "BarMessage"), 1, 2); 206 AddEnumValue(AddEnum(&bar_file, "BarEnum"), "BAR_ENUM_VALUE", 1); 207 AddService(&bar_file, "BarService"); 208 AddExtension(&bar_file, "bar_package.BarMessage", "bar_extension", 1, 209 FieldDescriptorProto::LABEL_OPTIONAL, 210 FieldDescriptorProto::TYPE_INT32); 211 212 FileDescriptorProto baz_file; 213 baz_file.set_name("baz.proto"); 214 215 // Build the descriptors and get the pointers. 216 foo_file_ = pool_.BuildFile(foo_file); 217 ASSERT_TRUE(foo_file_ != NULL); 218 219 bar_file_ = pool_.BuildFile(bar_file); 220 ASSERT_TRUE(bar_file_ != NULL); 221 222 baz_file_ = pool_.BuildFile(baz_file); 223 ASSERT_TRUE(baz_file_ != NULL); 224 225 ASSERT_EQ(1, foo_file_->message_type_count()); 226 foo_message_ = foo_file_->message_type(0); 227 ASSERT_EQ(1, foo_file_->enum_type_count()); 228 foo_enum_ = foo_file_->enum_type(0); 229 ASSERT_EQ(1, foo_enum_->value_count()); 230 foo_enum_value_ = foo_enum_->value(0); 231 ASSERT_EQ(1, foo_file_->service_count()); 232 foo_service_ = foo_file_->service(0); 233 ASSERT_EQ(1, foo_file_->extension_count()); 234 foo_extension_ = foo_file_->extension(0); 235 236 ASSERT_EQ(1, bar_file_->message_type_count()); 237 bar_message_ = bar_file_->message_type(0); 238 ASSERT_EQ(1, bar_file_->enum_type_count()); 239 bar_enum_ = bar_file_->enum_type(0); 240 ASSERT_EQ(1, bar_enum_->value_count()); 241 bar_enum_value_ = bar_enum_->value(0); 242 ASSERT_EQ(1, bar_file_->service_count()); 243 bar_service_ = bar_file_->service(0); 244 ASSERT_EQ(1, bar_file_->extension_count()); 245 bar_extension_ = bar_file_->extension(0); 246 } 247 248 DescriptorPool pool_; 249 250 const FileDescriptor* foo_file_; 251 const FileDescriptor* bar_file_; 252 const FileDescriptor* baz_file_; 253 254 const Descriptor* foo_message_; 255 const EnumDescriptor* foo_enum_; 256 const EnumValueDescriptor* foo_enum_value_; 257 const ServiceDescriptor* foo_service_; 258 const FieldDescriptor* foo_extension_; 259 260 const Descriptor* bar_message_; 261 const EnumDescriptor* bar_enum_; 262 const EnumValueDescriptor* bar_enum_value_; 263 const ServiceDescriptor* bar_service_; 264 const FieldDescriptor* bar_extension_; 265 }; 266 267 TEST_F(FileDescriptorTest, Name) { 268 EXPECT_EQ("foo.proto", foo_file_->name()); 269 EXPECT_EQ("bar.proto", bar_file_->name()); 270 EXPECT_EQ("baz.proto", baz_file_->name()); 271 } 272 273 TEST_F(FileDescriptorTest, Package) { 274 EXPECT_EQ("", foo_file_->package()); 275 EXPECT_EQ("bar_package", bar_file_->package()); 276 } 277 278 TEST_F(FileDescriptorTest, Dependencies) { 279 EXPECT_EQ(0, foo_file_->dependency_count()); 280 EXPECT_EQ(1, bar_file_->dependency_count()); 281 EXPECT_EQ(foo_file_, bar_file_->dependency(0)); 282 } 283 284 TEST_F(FileDescriptorTest, FindMessageTypeByName) { 285 EXPECT_EQ(foo_message_, foo_file_->FindMessageTypeByName("FooMessage")); 286 EXPECT_EQ(bar_message_, bar_file_->FindMessageTypeByName("BarMessage")); 287 288 EXPECT_TRUE(foo_file_->FindMessageTypeByName("BarMessage") == NULL); 289 EXPECT_TRUE(bar_file_->FindMessageTypeByName("FooMessage") == NULL); 290 EXPECT_TRUE(baz_file_->FindMessageTypeByName("FooMessage") == NULL); 291 292 EXPECT_TRUE(foo_file_->FindMessageTypeByName("NoSuchMessage") == NULL); 293 EXPECT_TRUE(foo_file_->FindMessageTypeByName("FooEnum") == NULL); 294 } 295 296 TEST_F(FileDescriptorTest, FindEnumTypeByName) { 297 EXPECT_EQ(foo_enum_, foo_file_->FindEnumTypeByName("FooEnum")); 298 EXPECT_EQ(bar_enum_, bar_file_->FindEnumTypeByName("BarEnum")); 299 300 EXPECT_TRUE(foo_file_->FindEnumTypeByName("BarEnum") == NULL); 301 EXPECT_TRUE(bar_file_->FindEnumTypeByName("FooEnum") == NULL); 302 EXPECT_TRUE(baz_file_->FindEnumTypeByName("FooEnum") == NULL); 303 304 EXPECT_TRUE(foo_file_->FindEnumTypeByName("NoSuchEnum") == NULL); 305 EXPECT_TRUE(foo_file_->FindEnumTypeByName("FooMessage") == NULL); 306 } 307 308 TEST_F(FileDescriptorTest, FindEnumValueByName) { 309 EXPECT_EQ(foo_enum_value_, foo_file_->FindEnumValueByName("FOO_ENUM_VALUE")); 310 EXPECT_EQ(bar_enum_value_, bar_file_->FindEnumValueByName("BAR_ENUM_VALUE")); 311 312 EXPECT_TRUE(foo_file_->FindEnumValueByName("BAR_ENUM_VALUE") == NULL); 313 EXPECT_TRUE(bar_file_->FindEnumValueByName("FOO_ENUM_VALUE") == NULL); 314 EXPECT_TRUE(baz_file_->FindEnumValueByName("FOO_ENUM_VALUE") == NULL); 315 316 EXPECT_TRUE(foo_file_->FindEnumValueByName("NO_SUCH_VALUE") == NULL); 317 EXPECT_TRUE(foo_file_->FindEnumValueByName("FooMessage") == NULL); 318 } 319 320 TEST_F(FileDescriptorTest, FindServiceByName) { 321 EXPECT_EQ(foo_service_, foo_file_->FindServiceByName("FooService")); 322 EXPECT_EQ(bar_service_, bar_file_->FindServiceByName("BarService")); 323 324 EXPECT_TRUE(foo_file_->FindServiceByName("BarService") == NULL); 325 EXPECT_TRUE(bar_file_->FindServiceByName("FooService") == NULL); 326 EXPECT_TRUE(baz_file_->FindServiceByName("FooService") == NULL); 327 328 EXPECT_TRUE(foo_file_->FindServiceByName("NoSuchService") == NULL); 329 EXPECT_TRUE(foo_file_->FindServiceByName("FooMessage") == NULL); 330 } 331 332 TEST_F(FileDescriptorTest, FindExtensionByName) { 333 EXPECT_EQ(foo_extension_, foo_file_->FindExtensionByName("foo_extension")); 334 EXPECT_EQ(bar_extension_, bar_file_->FindExtensionByName("bar_extension")); 335 336 EXPECT_TRUE(foo_file_->FindExtensionByName("bar_extension") == NULL); 337 EXPECT_TRUE(bar_file_->FindExtensionByName("foo_extension") == NULL); 338 EXPECT_TRUE(baz_file_->FindExtensionByName("foo_extension") == NULL); 339 340 EXPECT_TRUE(foo_file_->FindExtensionByName("no_such_extension") == NULL); 341 EXPECT_TRUE(foo_file_->FindExtensionByName("FooMessage") == NULL); 342 } 343 344 TEST_F(FileDescriptorTest, FindExtensionByNumber) { 345 EXPECT_EQ(foo_extension_, pool_.FindExtensionByNumber(foo_message_, 1)); 346 EXPECT_EQ(bar_extension_, pool_.FindExtensionByNumber(bar_message_, 1)); 347 348 EXPECT_TRUE(pool_.FindExtensionByNumber(foo_message_, 2) == NULL); 349 } 350 351 TEST_F(FileDescriptorTest, BuildAgain) { 352 // Test that if te call BuildFile again on the same input we get the same 353 // FileDescriptor back. 354 FileDescriptorProto file; 355 foo_file_->CopyTo(&file); 356 EXPECT_EQ(foo_file_, pool_.BuildFile(file)); 357 358 // But if we change the file then it won't work. 359 file.set_package("some.other.package"); 360 EXPECT_TRUE(pool_.BuildFile(file) == NULL); 361 } 362 363 // =================================================================== 364 365 // Test simple flat messages and fields. 366 class DescriptorTest : public testing::Test { 367 protected: 368 virtual void SetUp() { 369 // Build descriptors for the following definitions: 370 // 371 // // in "foo.proto" 372 // message TestForeign {} 373 // enum TestEnum {} 374 // 375 // message TestMessage { 376 // required string foo = 1; 377 // optional TestEnum bar = 6; 378 // repeated TestForeign baz = 500000000; 379 // optional group qux = 15 {} 380 // } 381 // 382 // // in "bar.proto" 383 // package corge.grault; 384 // message TestMessage2 { 385 // required string foo = 1; 386 // required string bar = 2; 387 // required string quux = 6; 388 // } 389 // 390 // We cheat and use TestForeign as the type for qux rather than create 391 // an actual nested type. 392 // 393 // Since all primitive types (including string) use the same building 394 // code, there's no need to test each one individually. 395 // 396 // TestMessage2 is primarily here to test FindFieldByName and friends. 397 // All messages created from the same DescriptorPool share the same lookup 398 // table, so we need to insure that they don't interfere. 399 400 FileDescriptorProto foo_file; 401 foo_file.set_name("foo.proto"); 402 AddMessage(&foo_file, "TestForeign"); 403 AddEmptyEnum(&foo_file, "TestEnum"); 404 405 DescriptorProto* message = AddMessage(&foo_file, "TestMessage"); 406 AddField(message, "foo", 1, 407 FieldDescriptorProto::LABEL_REQUIRED, 408 FieldDescriptorProto::TYPE_STRING); 409 AddField(message, "bar", 6, 410 FieldDescriptorProto::LABEL_OPTIONAL, 411 FieldDescriptorProto::TYPE_ENUM) 412 ->set_type_name("TestEnum"); 413 AddField(message, "baz", 500000000, 414 FieldDescriptorProto::LABEL_REPEATED, 415 FieldDescriptorProto::TYPE_MESSAGE) 416 ->set_type_name("TestForeign"); 417 AddField(message, "qux", 15, 418 FieldDescriptorProto::LABEL_OPTIONAL, 419 FieldDescriptorProto::TYPE_GROUP) 420 ->set_type_name("TestForeign"); 421 422 FileDescriptorProto bar_file; 423 bar_file.set_name("bar.proto"); 424 bar_file.set_package("corge.grault"); 425 426 DescriptorProto* message2 = AddMessage(&bar_file, "TestMessage2"); 427 AddField(message2, "foo", 1, 428 FieldDescriptorProto::LABEL_REQUIRED, 429 FieldDescriptorProto::TYPE_STRING); 430 AddField(message2, "bar", 2, 431 FieldDescriptorProto::LABEL_REQUIRED, 432 FieldDescriptorProto::TYPE_STRING); 433 AddField(message2, "quux", 6, 434 FieldDescriptorProto::LABEL_REQUIRED, 435 FieldDescriptorProto::TYPE_STRING); 436 437 // Build the descriptors and get the pointers. 438 foo_file_ = pool_.BuildFile(foo_file); 439 ASSERT_TRUE(foo_file_ != NULL); 440 441 bar_file_ = pool_.BuildFile(bar_file); 442 ASSERT_TRUE(bar_file_ != NULL); 443 444 ASSERT_EQ(1, foo_file_->enum_type_count()); 445 enum_ = foo_file_->enum_type(0); 446 447 ASSERT_EQ(2, foo_file_->message_type_count()); 448 foreign_ = foo_file_->message_type(0); 449 message_ = foo_file_->message_type(1); 450 451 ASSERT_EQ(4, message_->field_count()); 452 foo_ = message_->field(0); 453 bar_ = message_->field(1); 454 baz_ = message_->field(2); 455 qux_ = message_->field(3); 456 457 ASSERT_EQ(1, bar_file_->message_type_count()); 458 message2_ = bar_file_->message_type(0); 459 460 ASSERT_EQ(3, message2_->field_count()); 461 foo2_ = message2_->field(0); 462 bar2_ = message2_->field(1); 463 quux2_ = message2_->field(2); 464 } 465 466 DescriptorPool pool_; 467 468 const FileDescriptor* foo_file_; 469 const FileDescriptor* bar_file_; 470 471 const Descriptor* message_; 472 const Descriptor* message2_; 473 const Descriptor* foreign_; 474 const EnumDescriptor* enum_; 475 476 const FieldDescriptor* foo_; 477 const FieldDescriptor* bar_; 478 const FieldDescriptor* baz_; 479 const FieldDescriptor* qux_; 480 481 const FieldDescriptor* foo2_; 482 const FieldDescriptor* bar2_; 483 const FieldDescriptor* quux2_; 484 }; 485 486 TEST_F(DescriptorTest, Name) { 487 EXPECT_EQ("TestMessage", message_->name()); 488 EXPECT_EQ("TestMessage", message_->full_name()); 489 EXPECT_EQ(foo_file_, message_->file()); 490 491 EXPECT_EQ("TestMessage2", message2_->name()); 492 EXPECT_EQ("corge.grault.TestMessage2", message2_->full_name()); 493 EXPECT_EQ(bar_file_, message2_->file()); 494 } 495 496 TEST_F(DescriptorTest, ContainingType) { 497 EXPECT_TRUE(message_->containing_type() == NULL); 498 EXPECT_TRUE(message2_->containing_type() == NULL); 499 } 500 501 TEST_F(DescriptorTest, FieldsByIndex) { 502 ASSERT_EQ(4, message_->field_count()); 503 EXPECT_EQ(foo_, message_->field(0)); 504 EXPECT_EQ(bar_, message_->field(1)); 505 EXPECT_EQ(baz_, message_->field(2)); 506 EXPECT_EQ(qux_, message_->field(3)); 507 } 508 509 TEST_F(DescriptorTest, FindFieldByName) { 510 // All messages in the same DescriptorPool share a single lookup table for 511 // fields. So, in addition to testing that FindFieldByName finds the fields 512 // of the message, we need to test that it does *not* find the fields of 513 // *other* messages. 514 515 EXPECT_EQ(foo_, message_->FindFieldByName("foo")); 516 EXPECT_EQ(bar_, message_->FindFieldByName("bar")); 517 EXPECT_EQ(baz_, message_->FindFieldByName("baz")); 518 EXPECT_EQ(qux_, message_->FindFieldByName("qux")); 519 EXPECT_TRUE(message_->FindFieldByName("no_such_field") == NULL); 520 EXPECT_TRUE(message_->FindFieldByName("quux") == NULL); 521 522 EXPECT_EQ(foo2_ , message2_->FindFieldByName("foo" )); 523 EXPECT_EQ(bar2_ , message2_->FindFieldByName("bar" )); 524 EXPECT_EQ(quux2_, message2_->FindFieldByName("quux")); 525 EXPECT_TRUE(message2_->FindFieldByName("baz") == NULL); 526 EXPECT_TRUE(message2_->FindFieldByName("qux") == NULL); 527 } 528 529 TEST_F(DescriptorTest, FindFieldByNumber) { 530 EXPECT_EQ(foo_, message_->FindFieldByNumber(1)); 531 EXPECT_EQ(bar_, message_->FindFieldByNumber(6)); 532 EXPECT_EQ(baz_, message_->FindFieldByNumber(500000000)); 533 EXPECT_EQ(qux_, message_->FindFieldByNumber(15)); 534 EXPECT_TRUE(message_->FindFieldByNumber(837592) == NULL); 535 EXPECT_TRUE(message_->FindFieldByNumber(2) == NULL); 536 537 EXPECT_EQ(foo2_ , message2_->FindFieldByNumber(1)); 538 EXPECT_EQ(bar2_ , message2_->FindFieldByNumber(2)); 539 EXPECT_EQ(quux2_, message2_->FindFieldByNumber(6)); 540 EXPECT_TRUE(message2_->FindFieldByNumber(15) == NULL); 541 EXPECT_TRUE(message2_->FindFieldByNumber(500000000) == NULL); 542 } 543 544 TEST_F(DescriptorTest, FieldName) { 545 EXPECT_EQ("foo", foo_->name()); 546 EXPECT_EQ("bar", bar_->name()); 547 EXPECT_EQ("baz", baz_->name()); 548 EXPECT_EQ("qux", qux_->name()); 549 } 550 551 TEST_F(DescriptorTest, FieldFullName) { 552 EXPECT_EQ("TestMessage.foo", foo_->full_name()); 553 EXPECT_EQ("TestMessage.bar", bar_->full_name()); 554 EXPECT_EQ("TestMessage.baz", baz_->full_name()); 555 EXPECT_EQ("TestMessage.qux", qux_->full_name()); 556 557 EXPECT_EQ("corge.grault.TestMessage2.foo", foo2_->full_name()); 558 EXPECT_EQ("corge.grault.TestMessage2.bar", bar2_->full_name()); 559 EXPECT_EQ("corge.grault.TestMessage2.quux", quux2_->full_name()); 560 } 561 562 TEST_F(DescriptorTest, FieldFile) { 563 EXPECT_EQ(foo_file_, foo_->file()); 564 EXPECT_EQ(foo_file_, bar_->file()); 565 EXPECT_EQ(foo_file_, baz_->file()); 566 EXPECT_EQ(foo_file_, qux_->file()); 567 568 EXPECT_EQ(bar_file_, foo2_->file()); 569 EXPECT_EQ(bar_file_, bar2_->file()); 570 EXPECT_EQ(bar_file_, quux2_->file()); 571 } 572 573 TEST_F(DescriptorTest, FieldIndex) { 574 EXPECT_EQ(0, foo_->index()); 575 EXPECT_EQ(1, bar_->index()); 576 EXPECT_EQ(2, baz_->index()); 577 EXPECT_EQ(3, qux_->index()); 578 } 579 580 TEST_F(DescriptorTest, FieldNumber) { 581 EXPECT_EQ( 1, foo_->number()); 582 EXPECT_EQ( 6, bar_->number()); 583 EXPECT_EQ(500000000, baz_->number()); 584 EXPECT_EQ( 15, qux_->number()); 585 } 586 587 TEST_F(DescriptorTest, FieldType) { 588 EXPECT_EQ(FieldDescriptor::TYPE_STRING , foo_->type()); 589 EXPECT_EQ(FieldDescriptor::TYPE_ENUM , bar_->type()); 590 EXPECT_EQ(FieldDescriptor::TYPE_MESSAGE, baz_->type()); 591 EXPECT_EQ(FieldDescriptor::TYPE_GROUP , qux_->type()); 592 } 593 594 TEST_F(DescriptorTest, FieldLabel) { 595 EXPECT_EQ(FieldDescriptor::LABEL_REQUIRED, foo_->label()); 596 EXPECT_EQ(FieldDescriptor::LABEL_OPTIONAL, bar_->label()); 597 EXPECT_EQ(FieldDescriptor::LABEL_REPEATED, baz_->label()); 598 EXPECT_EQ(FieldDescriptor::LABEL_OPTIONAL, qux_->label()); 599 600 EXPECT_TRUE (foo_->is_required()); 601 EXPECT_FALSE(foo_->is_optional()); 602 EXPECT_FALSE(foo_->is_repeated()); 603 604 EXPECT_FALSE(bar_->is_required()); 605 EXPECT_TRUE (bar_->is_optional()); 606 EXPECT_FALSE(bar_->is_repeated()); 607 608 EXPECT_FALSE(baz_->is_required()); 609 EXPECT_FALSE(baz_->is_optional()); 610 EXPECT_TRUE (baz_->is_repeated()); 611 } 612 613 TEST_F(DescriptorTest, FieldHasDefault) { 614 EXPECT_FALSE(foo_->has_default_value()); 615 EXPECT_FALSE(bar_->has_default_value()); 616 EXPECT_FALSE(baz_->has_default_value()); 617 EXPECT_FALSE(qux_->has_default_value()); 618 } 619 620 TEST_F(DescriptorTest, FieldContainingType) { 621 EXPECT_EQ(message_, foo_->containing_type()); 622 EXPECT_EQ(message_, bar_->containing_type()); 623 EXPECT_EQ(message_, baz_->containing_type()); 624 EXPECT_EQ(message_, qux_->containing_type()); 625 626 EXPECT_EQ(message2_, foo2_ ->containing_type()); 627 EXPECT_EQ(message2_, bar2_ ->containing_type()); 628 EXPECT_EQ(message2_, quux2_->containing_type()); 629 } 630 631 TEST_F(DescriptorTest, FieldMessageType) { 632 EXPECT_TRUE(foo_->message_type() == NULL); 633 EXPECT_TRUE(bar_->message_type() == NULL); 634 635 EXPECT_EQ(foreign_, baz_->message_type()); 636 EXPECT_EQ(foreign_, qux_->message_type()); 637 } 638 639 TEST_F(DescriptorTest, FieldEnumType) { 640 EXPECT_TRUE(foo_->enum_type() == NULL); 641 EXPECT_TRUE(baz_->enum_type() == NULL); 642 EXPECT_TRUE(qux_->enum_type() == NULL); 643 644 EXPECT_EQ(enum_, bar_->enum_type()); 645 } 646 647 // =================================================================== 648 649 // Test simple flat messages and fields. 650 class OneofDescriptorTest : public testing::Test { 651 protected: 652 virtual void SetUp() { 653 // Build descriptors for the following definitions: 654 // 655 // package garply; 656 // message TestOneof { 657 // optional int32 a = 1; 658 // oneof foo { 659 // string b = 2; 660 // TestOneof c = 3; 661 // } 662 // oneof bar { 663 // float d = 4; 664 // } 665 // } 666 667 FileDescriptorProto baz_file; 668 baz_file.set_name("baz.proto"); 669 baz_file.set_package("garply"); 670 671 DescriptorProto* oneof_message = AddMessage(&baz_file, "TestOneof"); 672 oneof_message->add_oneof_decl()->set_name("foo"); 673 oneof_message->add_oneof_decl()->set_name("bar"); 674 675 AddField(oneof_message, "a", 1, 676 FieldDescriptorProto::LABEL_OPTIONAL, 677 FieldDescriptorProto::TYPE_INT32); 678 AddField(oneof_message, "b", 2, 679 FieldDescriptorProto::LABEL_OPTIONAL, 680 FieldDescriptorProto::TYPE_STRING); 681 oneof_message->mutable_field(1)->set_oneof_index(0); 682 AddField(oneof_message, "c", 3, 683 FieldDescriptorProto::LABEL_OPTIONAL, 684 FieldDescriptorProto::TYPE_MESSAGE); 685 oneof_message->mutable_field(2)->set_oneof_index(0); 686 oneof_message->mutable_field(2)->set_type_name("TestOneof"); 687 688 AddField(oneof_message, "d", 4, 689 FieldDescriptorProto::LABEL_OPTIONAL, 690 FieldDescriptorProto::TYPE_FLOAT); 691 oneof_message->mutable_field(3)->set_oneof_index(1); 692 693 // Build the descriptors and get the pointers. 694 baz_file_ = pool_.BuildFile(baz_file); 695 ASSERT_TRUE(baz_file_ != NULL); 696 697 ASSERT_EQ(1, baz_file_->message_type_count()); 698 oneof_message_ = baz_file_->message_type(0); 699 700 ASSERT_EQ(2, oneof_message_->oneof_decl_count()); 701 oneof_ = oneof_message_->oneof_decl(0); 702 oneof2_ = oneof_message_->oneof_decl(1); 703 704 ASSERT_EQ(4, oneof_message_->field_count()); 705 a_ = oneof_message_->field(0); 706 b_ = oneof_message_->field(1); 707 c_ = oneof_message_->field(2); 708 d_ = oneof_message_->field(3); 709 } 710 711 DescriptorPool pool_; 712 713 const FileDescriptor* baz_file_; 714 715 const Descriptor* oneof_message_; 716 717 const OneofDescriptor* oneof_; 718 const OneofDescriptor* oneof2_; 719 const FieldDescriptor* a_; 720 const FieldDescriptor* b_; 721 const FieldDescriptor* c_; 722 const FieldDescriptor* d_; 723 const FieldDescriptor* e_; 724 const FieldDescriptor* f_; 725 }; 726 727 TEST_F(OneofDescriptorTest, Normal) { 728 EXPECT_EQ("foo", oneof_->name()); 729 EXPECT_EQ("garply.TestOneof.foo", oneof_->full_name()); 730 EXPECT_EQ(0, oneof_->index()); 731 ASSERT_EQ(2, oneof_->field_count()); 732 EXPECT_EQ(b_, oneof_->field(0)); 733 EXPECT_EQ(c_, oneof_->field(1)); 734 EXPECT_TRUE(a_->containing_oneof() == NULL); 735 EXPECT_EQ(oneof_, b_->containing_oneof()); 736 EXPECT_EQ(oneof_, c_->containing_oneof()); 737 } 738 739 TEST_F(OneofDescriptorTest, FindByName) { 740 EXPECT_EQ(oneof_, oneof_message_->FindOneofByName("foo")); 741 EXPECT_EQ(oneof2_, oneof_message_->FindOneofByName("bar")); 742 EXPECT_TRUE(oneof_message_->FindOneofByName("no_such_oneof") == NULL); 743 } 744 745 // =================================================================== 746 747 class StylizedFieldNamesTest : public testing::Test { 748 protected: 749 void SetUp() { 750 FileDescriptorProto file; 751 file.set_name("foo.proto"); 752 753 AddExtensionRange(AddMessage(&file, "ExtendableMessage"), 1, 1000); 754 755 DescriptorProto* message = AddMessage(&file, "TestMessage"); 756 AddField(message, "foo_foo", 1, 757 FieldDescriptorProto::LABEL_OPTIONAL, 758 FieldDescriptorProto::TYPE_INT32); 759 AddField(message, "FooBar", 2, 760 FieldDescriptorProto::LABEL_OPTIONAL, 761 FieldDescriptorProto::TYPE_INT32); 762 AddField(message, "fooBaz", 3, 763 FieldDescriptorProto::LABEL_OPTIONAL, 764 FieldDescriptorProto::TYPE_INT32); 765 AddField(message, "fooFoo", 4, // Camel-case conflict with foo_foo. 766 FieldDescriptorProto::LABEL_OPTIONAL, 767 FieldDescriptorProto::TYPE_INT32); 768 AddField(message, "foobar", 5, // Lower-case conflict with FooBar. 769 FieldDescriptorProto::LABEL_OPTIONAL, 770 FieldDescriptorProto::TYPE_INT32); 771 772 AddNestedExtension(message, "ExtendableMessage", "bar_foo", 1, 773 FieldDescriptorProto::LABEL_OPTIONAL, 774 FieldDescriptorProto::TYPE_INT32); 775 AddNestedExtension(message, "ExtendableMessage", "BarBar", 2, 776 FieldDescriptorProto::LABEL_OPTIONAL, 777 FieldDescriptorProto::TYPE_INT32); 778 AddNestedExtension(message, "ExtendableMessage", "BarBaz", 3, 779 FieldDescriptorProto::LABEL_OPTIONAL, 780 FieldDescriptorProto::TYPE_INT32); 781 AddNestedExtension(message, "ExtendableMessage", "barFoo", 4, // Conflict 782 FieldDescriptorProto::LABEL_OPTIONAL, 783 FieldDescriptorProto::TYPE_INT32); 784 AddNestedExtension(message, "ExtendableMessage", "barbar", 5, // Conflict 785 FieldDescriptorProto::LABEL_OPTIONAL, 786 FieldDescriptorProto::TYPE_INT32); 787 788 AddExtension(&file, "ExtendableMessage", "baz_foo", 11, 789 FieldDescriptorProto::LABEL_OPTIONAL, 790 FieldDescriptorProto::TYPE_INT32); 791 AddExtension(&file, "ExtendableMessage", "BazBar", 12, 792 FieldDescriptorProto::LABEL_OPTIONAL, 793 FieldDescriptorProto::TYPE_INT32); 794 AddExtension(&file, "ExtendableMessage", "BazBaz", 13, 795 FieldDescriptorProto::LABEL_OPTIONAL, 796 FieldDescriptorProto::TYPE_INT32); 797 AddExtension(&file, "ExtendableMessage", "bazFoo", 14, // Conflict 798 FieldDescriptorProto::LABEL_OPTIONAL, 799 FieldDescriptorProto::TYPE_INT32); 800 AddExtension(&file, "ExtendableMessage", "bazbar", 15, // Conflict 801 FieldDescriptorProto::LABEL_OPTIONAL, 802 FieldDescriptorProto::TYPE_INT32); 803 804 file_ = pool_.BuildFile(file); 805 ASSERT_TRUE(file_ != NULL); 806 ASSERT_EQ(2, file_->message_type_count()); 807 message_ = file_->message_type(1); 808 ASSERT_EQ("TestMessage", message_->name()); 809 ASSERT_EQ(5, message_->field_count()); 810 ASSERT_EQ(5, message_->extension_count()); 811 ASSERT_EQ(5, file_->extension_count()); 812 } 813 814 DescriptorPool pool_; 815 const FileDescriptor* file_; 816 const Descriptor* message_; 817 }; 818 819 TEST_F(StylizedFieldNamesTest, LowercaseName) { 820 EXPECT_EQ("foo_foo", message_->field(0)->lowercase_name()); 821 EXPECT_EQ("foobar" , message_->field(1)->lowercase_name()); 822 EXPECT_EQ("foobaz" , message_->field(2)->lowercase_name()); 823 EXPECT_EQ("foofoo" , message_->field(3)->lowercase_name()); 824 EXPECT_EQ("foobar" , message_->field(4)->lowercase_name()); 825 826 EXPECT_EQ("bar_foo", message_->extension(0)->lowercase_name()); 827 EXPECT_EQ("barbar" , message_->extension(1)->lowercase_name()); 828 EXPECT_EQ("barbaz" , message_->extension(2)->lowercase_name()); 829 EXPECT_EQ("barfoo" , message_->extension(3)->lowercase_name()); 830 EXPECT_EQ("barbar" , message_->extension(4)->lowercase_name()); 831 832 EXPECT_EQ("baz_foo", file_->extension(0)->lowercase_name()); 833 EXPECT_EQ("bazbar" , file_->extension(1)->lowercase_name()); 834 EXPECT_EQ("bazbaz" , file_->extension(2)->lowercase_name()); 835 EXPECT_EQ("bazfoo" , file_->extension(3)->lowercase_name()); 836 EXPECT_EQ("bazbar" , file_->extension(4)->lowercase_name()); 837 } 838 839 TEST_F(StylizedFieldNamesTest, CamelcaseName) { 840 EXPECT_EQ("fooFoo", message_->field(0)->camelcase_name()); 841 EXPECT_EQ("fooBar", message_->field(1)->camelcase_name()); 842 EXPECT_EQ("fooBaz", message_->field(2)->camelcase_name()); 843 EXPECT_EQ("fooFoo", message_->field(3)->camelcase_name()); 844 EXPECT_EQ("foobar", message_->field(4)->camelcase_name()); 845 846 EXPECT_EQ("barFoo", message_->extension(0)->camelcase_name()); 847 EXPECT_EQ("barBar", message_->extension(1)->camelcase_name()); 848 EXPECT_EQ("barBaz", message_->extension(2)->camelcase_name()); 849 EXPECT_EQ("barFoo", message_->extension(3)->camelcase_name()); 850 EXPECT_EQ("barbar", message_->extension(4)->camelcase_name()); 851 852 EXPECT_EQ("bazFoo", file_->extension(0)->camelcase_name()); 853 EXPECT_EQ("bazBar", file_->extension(1)->camelcase_name()); 854 EXPECT_EQ("bazBaz", file_->extension(2)->camelcase_name()); 855 EXPECT_EQ("bazFoo", file_->extension(3)->camelcase_name()); 856 EXPECT_EQ("bazbar", file_->extension(4)->camelcase_name()); 857 } 858 859 TEST_F(StylizedFieldNamesTest, FindByLowercaseName) { 860 EXPECT_EQ(message_->field(0), 861 message_->FindFieldByLowercaseName("foo_foo")); 862 EXPECT_EQ(message_->field(1), 863 message_->FindFieldByLowercaseName("foobar")); 864 EXPECT_EQ(message_->field(2), 865 message_->FindFieldByLowercaseName("foobaz")); 866 EXPECT_TRUE(message_->FindFieldByLowercaseName("FooBar") == NULL); 867 EXPECT_TRUE(message_->FindFieldByLowercaseName("fooBaz") == NULL); 868 EXPECT_TRUE(message_->FindFieldByLowercaseName("bar_foo") == NULL); 869 EXPECT_TRUE(message_->FindFieldByLowercaseName("nosuchfield") == NULL); 870 871 EXPECT_EQ(message_->extension(0), 872 message_->FindExtensionByLowercaseName("bar_foo")); 873 EXPECT_EQ(message_->extension(1), 874 message_->FindExtensionByLowercaseName("barbar")); 875 EXPECT_EQ(message_->extension(2), 876 message_->FindExtensionByLowercaseName("barbaz")); 877 EXPECT_TRUE(message_->FindExtensionByLowercaseName("BarBar") == NULL); 878 EXPECT_TRUE(message_->FindExtensionByLowercaseName("barBaz") == NULL); 879 EXPECT_TRUE(message_->FindExtensionByLowercaseName("foo_foo") == NULL); 880 EXPECT_TRUE(message_->FindExtensionByLowercaseName("nosuchfield") == NULL); 881 882 EXPECT_EQ(file_->extension(0), 883 file_->FindExtensionByLowercaseName("baz_foo")); 884 EXPECT_EQ(file_->extension(1), 885 file_->FindExtensionByLowercaseName("bazbar")); 886 EXPECT_EQ(file_->extension(2), 887 file_->FindExtensionByLowercaseName("bazbaz")); 888 EXPECT_TRUE(file_->FindExtensionByLowercaseName("BazBar") == NULL); 889 EXPECT_TRUE(file_->FindExtensionByLowercaseName("bazBaz") == NULL); 890 EXPECT_TRUE(file_->FindExtensionByLowercaseName("nosuchfield") == NULL); 891 } 892 893 TEST_F(StylizedFieldNamesTest, FindByCamelcaseName) { 894 EXPECT_EQ(message_->field(0), 895 message_->FindFieldByCamelcaseName("fooFoo")); 896 EXPECT_EQ(message_->field(1), 897 message_->FindFieldByCamelcaseName("fooBar")); 898 EXPECT_EQ(message_->field(2), 899 message_->FindFieldByCamelcaseName("fooBaz")); 900 EXPECT_TRUE(message_->FindFieldByCamelcaseName("foo_foo") == NULL); 901 EXPECT_TRUE(message_->FindFieldByCamelcaseName("FooBar") == NULL); 902 EXPECT_TRUE(message_->FindFieldByCamelcaseName("barFoo") == NULL); 903 EXPECT_TRUE(message_->FindFieldByCamelcaseName("nosuchfield") == NULL); 904 905 EXPECT_EQ(message_->extension(0), 906 message_->FindExtensionByCamelcaseName("barFoo")); 907 EXPECT_EQ(message_->extension(1), 908 message_->FindExtensionByCamelcaseName("barBar")); 909 EXPECT_EQ(message_->extension(2), 910 message_->FindExtensionByCamelcaseName("barBaz")); 911 EXPECT_TRUE(message_->FindExtensionByCamelcaseName("bar_foo") == NULL); 912 EXPECT_TRUE(message_->FindExtensionByCamelcaseName("BarBar") == NULL); 913 EXPECT_TRUE(message_->FindExtensionByCamelcaseName("fooFoo") == NULL); 914 EXPECT_TRUE(message_->FindExtensionByCamelcaseName("nosuchfield") == NULL); 915 916 EXPECT_EQ(file_->extension(0), 917 file_->FindExtensionByCamelcaseName("bazFoo")); 918 EXPECT_EQ(file_->extension(1), 919 file_->FindExtensionByCamelcaseName("bazBar")); 920 EXPECT_EQ(file_->extension(2), 921 file_->FindExtensionByCamelcaseName("bazBaz")); 922 EXPECT_TRUE(file_->FindExtensionByCamelcaseName("baz_foo") == NULL); 923 EXPECT_TRUE(file_->FindExtensionByCamelcaseName("BazBar") == NULL); 924 EXPECT_TRUE(file_->FindExtensionByCamelcaseName("nosuchfield") == NULL); 925 } 926 927 // =================================================================== 928 929 // Test enum descriptors. 930 class EnumDescriptorTest : public testing::Test { 931 protected: 932 virtual void SetUp() { 933 // Build descriptors for the following definitions: 934 // 935 // // in "foo.proto" 936 // enum TestEnum { 937 // FOO = 1; 938 // BAR = 2; 939 // } 940 // 941 // // in "bar.proto" 942 // package corge.grault; 943 // enum TestEnum2 { 944 // FOO = 1; 945 // BAZ = 3; 946 // } 947 // 948 // TestEnum2 is primarily here to test FindValueByName and friends. 949 // All enums created from the same DescriptorPool share the same lookup 950 // table, so we need to insure that they don't interfere. 951 952 // TestEnum 953 FileDescriptorProto foo_file; 954 foo_file.set_name("foo.proto"); 955 956 EnumDescriptorProto* enum_proto = AddEnum(&foo_file, "TestEnum"); 957 AddEnumValue(enum_proto, "FOO", 1); 958 AddEnumValue(enum_proto, "BAR", 2); 959 960 // TestEnum2 961 FileDescriptorProto bar_file; 962 bar_file.set_name("bar.proto"); 963 bar_file.set_package("corge.grault"); 964 965 EnumDescriptorProto* enum2_proto = AddEnum(&bar_file, "TestEnum2"); 966 AddEnumValue(enum2_proto, "FOO", 1); 967 AddEnumValue(enum2_proto, "BAZ", 3); 968 969 // Build the descriptors and get the pointers. 970 foo_file_ = pool_.BuildFile(foo_file); 971 ASSERT_TRUE(foo_file_ != NULL); 972 973 bar_file_ = pool_.BuildFile(bar_file); 974 ASSERT_TRUE(bar_file_ != NULL); 975 976 ASSERT_EQ(1, foo_file_->enum_type_count()); 977 enum_ = foo_file_->enum_type(0); 978 979 ASSERT_EQ(2, enum_->value_count()); 980 foo_ = enum_->value(0); 981 bar_ = enum_->value(1); 982 983 ASSERT_EQ(1, bar_file_->enum_type_count()); 984 enum2_ = bar_file_->enum_type(0); 985 986 ASSERT_EQ(2, enum2_->value_count()); 987 foo2_ = enum2_->value(0); 988 baz2_ = enum2_->value(1); 989 } 990 991 DescriptorPool pool_; 992 993 const FileDescriptor* foo_file_; 994 const FileDescriptor* bar_file_; 995 996 const EnumDescriptor* enum_; 997 const EnumDescriptor* enum2_; 998 999 const EnumValueDescriptor* foo_; 1000 const EnumValueDescriptor* bar_; 1001 1002 const EnumValueDescriptor* foo2_; 1003 const EnumValueDescriptor* baz2_; 1004 }; 1005 1006 TEST_F(EnumDescriptorTest, Name) { 1007 EXPECT_EQ("TestEnum", enum_->name()); 1008 EXPECT_EQ("TestEnum", enum_->full_name()); 1009 EXPECT_EQ(foo_file_, enum_->file()); 1010 1011 EXPECT_EQ("TestEnum2", enum2_->name()); 1012 EXPECT_EQ("corge.grault.TestEnum2", enum2_->full_name()); 1013 EXPECT_EQ(bar_file_, enum2_->file()); 1014 } 1015 1016 TEST_F(EnumDescriptorTest, ContainingType) { 1017 EXPECT_TRUE(enum_->containing_type() == NULL); 1018 EXPECT_TRUE(enum2_->containing_type() == NULL); 1019 } 1020 1021 TEST_F(EnumDescriptorTest, ValuesByIndex) { 1022 ASSERT_EQ(2, enum_->value_count()); 1023 EXPECT_EQ(foo_, enum_->value(0)); 1024 EXPECT_EQ(bar_, enum_->value(1)); 1025 } 1026 1027 TEST_F(EnumDescriptorTest, FindValueByName) { 1028 EXPECT_EQ(foo_ , enum_ ->FindValueByName("FOO")); 1029 EXPECT_EQ(bar_ , enum_ ->FindValueByName("BAR")); 1030 EXPECT_EQ(foo2_, enum2_->FindValueByName("FOO")); 1031 EXPECT_EQ(baz2_, enum2_->FindValueByName("BAZ")); 1032 1033 EXPECT_TRUE(enum_ ->FindValueByName("NO_SUCH_VALUE") == NULL); 1034 EXPECT_TRUE(enum_ ->FindValueByName("BAZ" ) == NULL); 1035 EXPECT_TRUE(enum2_->FindValueByName("BAR" ) == NULL); 1036 } 1037 1038 TEST_F(EnumDescriptorTest, FindValueByNumber) { 1039 EXPECT_EQ(foo_ , enum_ ->FindValueByNumber(1)); 1040 EXPECT_EQ(bar_ , enum_ ->FindValueByNumber(2)); 1041 EXPECT_EQ(foo2_, enum2_->FindValueByNumber(1)); 1042 EXPECT_EQ(baz2_, enum2_->FindValueByNumber(3)); 1043 1044 EXPECT_TRUE(enum_ ->FindValueByNumber(416) == NULL); 1045 EXPECT_TRUE(enum_ ->FindValueByNumber(3) == NULL); 1046 EXPECT_TRUE(enum2_->FindValueByNumber(2) == NULL); 1047 } 1048 1049 TEST_F(EnumDescriptorTest, ValueName) { 1050 EXPECT_EQ("FOO", foo_->name()); 1051 EXPECT_EQ("BAR", bar_->name()); 1052 } 1053 1054 TEST_F(EnumDescriptorTest, ValueFullName) { 1055 EXPECT_EQ("FOO", foo_->full_name()); 1056 EXPECT_EQ("BAR", bar_->full_name()); 1057 EXPECT_EQ("corge.grault.FOO", foo2_->full_name()); 1058 EXPECT_EQ("corge.grault.BAZ", baz2_->full_name()); 1059 } 1060 1061 TEST_F(EnumDescriptorTest, ValueIndex) { 1062 EXPECT_EQ(0, foo_->index()); 1063 EXPECT_EQ(1, bar_->index()); 1064 } 1065 1066 TEST_F(EnumDescriptorTest, ValueNumber) { 1067 EXPECT_EQ(1, foo_->number()); 1068 EXPECT_EQ(2, bar_->number()); 1069 } 1070 1071 TEST_F(EnumDescriptorTest, ValueType) { 1072 EXPECT_EQ(enum_ , foo_ ->type()); 1073 EXPECT_EQ(enum_ , bar_ ->type()); 1074 EXPECT_EQ(enum2_, foo2_->type()); 1075 EXPECT_EQ(enum2_, baz2_->type()); 1076 } 1077 1078 // =================================================================== 1079 1080 // Test service descriptors. 1081 class ServiceDescriptorTest : public testing::Test { 1082 protected: 1083 virtual void SetUp() { 1084 // Build descriptors for the following messages and service: 1085 // // in "foo.proto" 1086 // message FooRequest {} 1087 // message FooResponse {} 1088 // message BarRequest {} 1089 // message BarResponse {} 1090 // message BazRequest {} 1091 // message BazResponse {} 1092 // 1093 // service TestService { 1094 // rpc Foo(FooRequest) returns (FooResponse); 1095 // rpc Bar(BarRequest) returns (BarResponse); 1096 // } 1097 // 1098 // // in "bar.proto" 1099 // package corge.grault 1100 // service TestService2 { 1101 // rpc Foo(FooRequest) returns (FooResponse); 1102 // rpc Baz(BazRequest) returns (BazResponse); 1103 // } 1104 1105 FileDescriptorProto foo_file; 1106 foo_file.set_name("foo.proto"); 1107 1108 AddMessage(&foo_file, "FooRequest"); 1109 AddMessage(&foo_file, "FooResponse"); 1110 AddMessage(&foo_file, "BarRequest"); 1111 AddMessage(&foo_file, "BarResponse"); 1112 AddMessage(&foo_file, "BazRequest"); 1113 AddMessage(&foo_file, "BazResponse"); 1114 1115 ServiceDescriptorProto* service = AddService(&foo_file, "TestService"); 1116 AddMethod(service, "Foo", "FooRequest", "FooResponse"); 1117 AddMethod(service, "Bar", "BarRequest", "BarResponse"); 1118 1119 FileDescriptorProto bar_file; 1120 bar_file.set_name("bar.proto"); 1121 bar_file.set_package("corge.grault"); 1122 bar_file.add_dependency("foo.proto"); 1123 1124 ServiceDescriptorProto* service2 = AddService(&bar_file, "TestService2"); 1125 AddMethod(service2, "Foo", "FooRequest", "FooResponse"); 1126 AddMethod(service2, "Baz", "BazRequest", "BazResponse"); 1127 1128 // Build the descriptors and get the pointers. 1129 foo_file_ = pool_.BuildFile(foo_file); 1130 ASSERT_TRUE(foo_file_ != NULL); 1131 1132 bar_file_ = pool_.BuildFile(bar_file); 1133 ASSERT_TRUE(bar_file_ != NULL); 1134 1135 ASSERT_EQ(6, foo_file_->message_type_count()); 1136 foo_request_ = foo_file_->message_type(0); 1137 foo_response_ = foo_file_->message_type(1); 1138 bar_request_ = foo_file_->message_type(2); 1139 bar_response_ = foo_file_->message_type(3); 1140 baz_request_ = foo_file_->message_type(4); 1141 baz_response_ = foo_file_->message_type(5); 1142 1143 ASSERT_EQ(1, foo_file_->service_count()); 1144 service_ = foo_file_->service(0); 1145 1146 ASSERT_EQ(2, service_->method_count()); 1147 foo_ = service_->method(0); 1148 bar_ = service_->method(1); 1149 1150 ASSERT_EQ(1, bar_file_->service_count()); 1151 service2_ = bar_file_->service(0); 1152 1153 ASSERT_EQ(2, service2_->method_count()); 1154 foo2_ = service2_->method(0); 1155 baz2_ = service2_->method(1); 1156 } 1157 1158 DescriptorPool pool_; 1159 1160 const FileDescriptor* foo_file_; 1161 const FileDescriptor* bar_file_; 1162 1163 const Descriptor* foo_request_; 1164 const Descriptor* foo_response_; 1165 const Descriptor* bar_request_; 1166 const Descriptor* bar_response_; 1167 const Descriptor* baz_request_; 1168 const Descriptor* baz_response_; 1169 1170 const ServiceDescriptor* service_; 1171 const ServiceDescriptor* service2_; 1172 1173 const MethodDescriptor* foo_; 1174 const MethodDescriptor* bar_; 1175 1176 const MethodDescriptor* foo2_; 1177 const MethodDescriptor* baz2_; 1178 }; 1179 1180 TEST_F(ServiceDescriptorTest, Name) { 1181 EXPECT_EQ("TestService", service_->name()); 1182 EXPECT_EQ("TestService", service_->full_name()); 1183 EXPECT_EQ(foo_file_, service_->file()); 1184 1185 EXPECT_EQ("TestService2", service2_->name()); 1186 EXPECT_EQ("corge.grault.TestService2", service2_->full_name()); 1187 EXPECT_EQ(bar_file_, service2_->file()); 1188 } 1189 1190 TEST_F(ServiceDescriptorTest, MethodsByIndex) { 1191 ASSERT_EQ(2, service_->method_count()); 1192 EXPECT_EQ(foo_, service_->method(0)); 1193 EXPECT_EQ(bar_, service_->method(1)); 1194 } 1195 1196 TEST_F(ServiceDescriptorTest, FindMethodByName) { 1197 EXPECT_EQ(foo_ , service_ ->FindMethodByName("Foo")); 1198 EXPECT_EQ(bar_ , service_ ->FindMethodByName("Bar")); 1199 EXPECT_EQ(foo2_, service2_->FindMethodByName("Foo")); 1200 EXPECT_EQ(baz2_, service2_->FindMethodByName("Baz")); 1201 1202 EXPECT_TRUE(service_ ->FindMethodByName("NoSuchMethod") == NULL); 1203 EXPECT_TRUE(service_ ->FindMethodByName("Baz" ) == NULL); 1204 EXPECT_TRUE(service2_->FindMethodByName("Bar" ) == NULL); 1205 } 1206 1207 TEST_F(ServiceDescriptorTest, MethodName) { 1208 EXPECT_EQ("Foo", foo_->name()); 1209 EXPECT_EQ("Bar", bar_->name()); 1210 } 1211 1212 TEST_F(ServiceDescriptorTest, MethodFullName) { 1213 EXPECT_EQ("TestService.Foo", foo_->full_name()); 1214 EXPECT_EQ("TestService.Bar", bar_->full_name()); 1215 EXPECT_EQ("corge.grault.TestService2.Foo", foo2_->full_name()); 1216 EXPECT_EQ("corge.grault.TestService2.Baz", baz2_->full_name()); 1217 } 1218 1219 TEST_F(ServiceDescriptorTest, MethodIndex) { 1220 EXPECT_EQ(0, foo_->index()); 1221 EXPECT_EQ(1, bar_->index()); 1222 } 1223 1224 TEST_F(ServiceDescriptorTest, MethodParent) { 1225 EXPECT_EQ(service_, foo_->service()); 1226 EXPECT_EQ(service_, bar_->service()); 1227 } 1228 1229 TEST_F(ServiceDescriptorTest, MethodInputType) { 1230 EXPECT_EQ(foo_request_, foo_->input_type()); 1231 EXPECT_EQ(bar_request_, bar_->input_type()); 1232 } 1233 1234 TEST_F(ServiceDescriptorTest, MethodOutputType) { 1235 EXPECT_EQ(foo_response_, foo_->output_type()); 1236 EXPECT_EQ(bar_response_, bar_->output_type()); 1237 } 1238 1239 // =================================================================== 1240 1241 // Test nested types. 1242 class NestedDescriptorTest : public testing::Test { 1243 protected: 1244 virtual void SetUp() { 1245 // Build descriptors for the following definitions: 1246 // 1247 // // in "foo.proto" 1248 // message TestMessage { 1249 // message Foo {} 1250 // message Bar {} 1251 // enum Baz { A = 1; } 1252 // enum Qux { B = 1; } 1253 // } 1254 // 1255 // // in "bar.proto" 1256 // package corge.grault; 1257 // message TestMessage2 { 1258 // message Foo {} 1259 // message Baz {} 1260 // enum Qux { A = 1; } 1261 // enum Quux { C = 1; } 1262 // } 1263 // 1264 // TestMessage2 is primarily here to test FindNestedTypeByName and friends. 1265 // All messages created from the same DescriptorPool share the same lookup 1266 // table, so we need to insure that they don't interfere. 1267 // 1268 // We add enum values to the enums in order to test searching for enum 1269 // values across a message's scope. 1270 1271 FileDescriptorProto foo_file; 1272 foo_file.set_name("foo.proto"); 1273 1274 DescriptorProto* message = AddMessage(&foo_file, "TestMessage"); 1275 AddNestedMessage(message, "Foo"); 1276 AddNestedMessage(message, "Bar"); 1277 EnumDescriptorProto* baz = AddNestedEnum(message, "Baz"); 1278 AddEnumValue(baz, "A", 1); 1279 EnumDescriptorProto* qux = AddNestedEnum(message, "Qux"); 1280 AddEnumValue(qux, "B", 1); 1281 1282 FileDescriptorProto bar_file; 1283 bar_file.set_name("bar.proto"); 1284 bar_file.set_package("corge.grault"); 1285 1286 DescriptorProto* message2 = AddMessage(&bar_file, "TestMessage2"); 1287 AddNestedMessage(message2, "Foo"); 1288 AddNestedMessage(message2, "Baz"); 1289 EnumDescriptorProto* qux2 = AddNestedEnum(message2, "Qux"); 1290 AddEnumValue(qux2, "A", 1); 1291 EnumDescriptorProto* quux2 = AddNestedEnum(message2, "Quux"); 1292 AddEnumValue(quux2, "C", 1); 1293 1294 // Build the descriptors and get the pointers. 1295 foo_file_ = pool_.BuildFile(foo_file); 1296 ASSERT_TRUE(foo_file_ != NULL); 1297 1298 bar_file_ = pool_.BuildFile(bar_file); 1299 ASSERT_TRUE(bar_file_ != NULL); 1300 1301 ASSERT_EQ(1, foo_file_->message_type_count()); 1302 message_ = foo_file_->message_type(0); 1303 1304 ASSERT_EQ(2, message_->nested_type_count()); 1305 foo_ = message_->nested_type(0); 1306 bar_ = message_->nested_type(1); 1307 1308 ASSERT_EQ(2, message_->enum_type_count()); 1309 baz_ = message_->enum_type(0); 1310 qux_ = message_->enum_type(1); 1311 1312 ASSERT_EQ(1, baz_->value_count()); 1313 a_ = baz_->value(0); 1314 ASSERT_EQ(1, qux_->value_count()); 1315 b_ = qux_->value(0); 1316 1317 ASSERT_EQ(1, bar_file_->message_type_count()); 1318 message2_ = bar_file_->message_type(0); 1319 1320 ASSERT_EQ(2, message2_->nested_type_count()); 1321 foo2_ = message2_->nested_type(0); 1322 baz2_ = message2_->nested_type(1); 1323 1324 ASSERT_EQ(2, message2_->enum_type_count()); 1325 qux2_ = message2_->enum_type(0); 1326 quux2_ = message2_->enum_type(1); 1327 1328 ASSERT_EQ(1, qux2_->value_count()); 1329 a2_ = qux2_->value(0); 1330 ASSERT_EQ(1, quux2_->value_count()); 1331 c2_ = quux2_->value(0); 1332 } 1333 1334 DescriptorPool pool_; 1335 1336 const FileDescriptor* foo_file_; 1337 const FileDescriptor* bar_file_; 1338 1339 const Descriptor* message_; 1340 const Descriptor* message2_; 1341 1342 const Descriptor* foo_; 1343 const Descriptor* bar_; 1344 const EnumDescriptor* baz_; 1345 const EnumDescriptor* qux_; 1346 const EnumValueDescriptor* a_; 1347 const EnumValueDescriptor* b_; 1348 1349 const Descriptor* foo2_; 1350 const Descriptor* baz2_; 1351 const EnumDescriptor* qux2_; 1352 const EnumDescriptor* quux2_; 1353 const EnumValueDescriptor* a2_; 1354 const EnumValueDescriptor* c2_; 1355 }; 1356 1357 TEST_F(NestedDescriptorTest, MessageName) { 1358 EXPECT_EQ("Foo", foo_ ->name()); 1359 EXPECT_EQ("Bar", bar_ ->name()); 1360 EXPECT_EQ("Foo", foo2_->name()); 1361 EXPECT_EQ("Baz", baz2_->name()); 1362 1363 EXPECT_EQ("TestMessage.Foo", foo_->full_name()); 1364 EXPECT_EQ("TestMessage.Bar", bar_->full_name()); 1365 EXPECT_EQ("corge.grault.TestMessage2.Foo", foo2_->full_name()); 1366 EXPECT_EQ("corge.grault.TestMessage2.Baz", baz2_->full_name()); 1367 } 1368 1369 TEST_F(NestedDescriptorTest, MessageContainingType) { 1370 EXPECT_EQ(message_ , foo_ ->containing_type()); 1371 EXPECT_EQ(message_ , bar_ ->containing_type()); 1372 EXPECT_EQ(message2_, foo2_->containing_type()); 1373 EXPECT_EQ(message2_, baz2_->containing_type()); 1374 } 1375 1376 TEST_F(NestedDescriptorTest, NestedMessagesByIndex) { 1377 ASSERT_EQ(2, message_->nested_type_count()); 1378 EXPECT_EQ(foo_, message_->nested_type(0)); 1379 EXPECT_EQ(bar_, message_->nested_type(1)); 1380 } 1381 1382 TEST_F(NestedDescriptorTest, FindFieldByNameDoesntFindNestedTypes) { 1383 EXPECT_TRUE(message_->FindFieldByName("Foo") == NULL); 1384 EXPECT_TRUE(message_->FindFieldByName("Qux") == NULL); 1385 EXPECT_TRUE(message_->FindExtensionByName("Foo") == NULL); 1386 EXPECT_TRUE(message_->FindExtensionByName("Qux") == NULL); 1387 } 1388 1389 TEST_F(NestedDescriptorTest, FindNestedTypeByName) { 1390 EXPECT_EQ(foo_ , message_ ->FindNestedTypeByName("Foo")); 1391 EXPECT_EQ(bar_ , message_ ->FindNestedTypeByName("Bar")); 1392 EXPECT_EQ(foo2_, message2_->FindNestedTypeByName("Foo")); 1393 EXPECT_EQ(baz2_, message2_->FindNestedTypeByName("Baz")); 1394 1395 EXPECT_TRUE(message_ ->FindNestedTypeByName("NoSuchType") == NULL); 1396 EXPECT_TRUE(message_ ->FindNestedTypeByName("Baz" ) == NULL); 1397 EXPECT_TRUE(message2_->FindNestedTypeByName("Bar" ) == NULL); 1398 1399 EXPECT_TRUE(message_->FindNestedTypeByName("Qux") == NULL); 1400 } 1401 1402 TEST_F(NestedDescriptorTest, EnumName) { 1403 EXPECT_EQ("Baz" , baz_ ->name()); 1404 EXPECT_EQ("Qux" , qux_ ->name()); 1405 EXPECT_EQ("Qux" , qux2_->name()); 1406 EXPECT_EQ("Quux", quux2_->name()); 1407 1408 EXPECT_EQ("TestMessage.Baz", baz_->full_name()); 1409 EXPECT_EQ("TestMessage.Qux", qux_->full_name()); 1410 EXPECT_EQ("corge.grault.TestMessage2.Qux" , qux2_ ->full_name()); 1411 EXPECT_EQ("corge.grault.TestMessage2.Quux", quux2_->full_name()); 1412 } 1413 1414 TEST_F(NestedDescriptorTest, EnumContainingType) { 1415 EXPECT_EQ(message_ , baz_ ->containing_type()); 1416 EXPECT_EQ(message_ , qux_ ->containing_type()); 1417 EXPECT_EQ(message2_, qux2_ ->containing_type()); 1418 EXPECT_EQ(message2_, quux2_->containing_type()); 1419 } 1420 1421 TEST_F(NestedDescriptorTest, NestedEnumsByIndex) { 1422 ASSERT_EQ(2, message_->nested_type_count()); 1423 EXPECT_EQ(foo_, message_->nested_type(0)); 1424 EXPECT_EQ(bar_, message_->nested_type(1)); 1425 } 1426 1427 TEST_F(NestedDescriptorTest, FindEnumTypeByName) { 1428 EXPECT_EQ(baz_ , message_ ->FindEnumTypeByName("Baz" )); 1429 EXPECT_EQ(qux_ , message_ ->FindEnumTypeByName("Qux" )); 1430 EXPECT_EQ(qux2_ , message2_->FindEnumTypeByName("Qux" )); 1431 EXPECT_EQ(quux2_, message2_->FindEnumTypeByName("Quux")); 1432 1433 EXPECT_TRUE(message_ ->FindEnumTypeByName("NoSuchType") == NULL); 1434 EXPECT_TRUE(message_ ->FindEnumTypeByName("Quux" ) == NULL); 1435 EXPECT_TRUE(message2_->FindEnumTypeByName("Baz" ) == NULL); 1436 1437 EXPECT_TRUE(message_->FindEnumTypeByName("Foo") == NULL); 1438 } 1439 1440 TEST_F(NestedDescriptorTest, FindEnumValueByName) { 1441 EXPECT_EQ(a_ , message_ ->FindEnumValueByName("A")); 1442 EXPECT_EQ(b_ , message_ ->FindEnumValueByName("B")); 1443 EXPECT_EQ(a2_, message2_->FindEnumValueByName("A")); 1444 EXPECT_EQ(c2_, message2_->FindEnumValueByName("C")); 1445 1446 EXPECT_TRUE(message_ ->FindEnumValueByName("NO_SUCH_VALUE") == NULL); 1447 EXPECT_TRUE(message_ ->FindEnumValueByName("C" ) == NULL); 1448 EXPECT_TRUE(message2_->FindEnumValueByName("B" ) == NULL); 1449 1450 EXPECT_TRUE(message_->FindEnumValueByName("Foo") == NULL); 1451 } 1452 1453 // =================================================================== 1454 1455 // Test extensions. 1456 class ExtensionDescriptorTest : public testing::Test { 1457 protected: 1458 virtual void SetUp() { 1459 // Build descriptors for the following definitions: 1460 // 1461 // enum Baz {} 1462 // message Qux {} 1463 // 1464 // message Foo { 1465 // extensions 10 to 19; 1466 // extensions 30 to 39; 1467 // } 1468 // extends Foo with optional int32 foo_int32 = 10; 1469 // extends Foo with repeated TestEnum foo_enum = 19; 1470 // message Bar { 1471 // extends Foo with optional Qux foo_message = 30; 1472 // // (using Qux as the group type) 1473 // extends Foo with repeated group foo_group = 39; 1474 // } 1475 1476 FileDescriptorProto foo_file; 1477 foo_file.set_name("foo.proto"); 1478 1479 AddEmptyEnum(&foo_file, "Baz"); 1480 AddMessage(&foo_file, "Qux"); 1481 1482 DescriptorProto* foo = AddMessage(&foo_file, "Foo"); 1483 AddExtensionRange(foo, 10, 20); 1484 AddExtensionRange(foo, 30, 40); 1485 1486 AddExtension(&foo_file, "Foo", "foo_int32", 10, 1487 FieldDescriptorProto::LABEL_OPTIONAL, 1488 FieldDescriptorProto::TYPE_INT32); 1489 AddExtension(&foo_file, "Foo", "foo_enum", 19, 1490 FieldDescriptorProto::LABEL_REPEATED, 1491 FieldDescriptorProto::TYPE_ENUM) 1492 ->set_type_name("Baz"); 1493 1494 DescriptorProto* bar = AddMessage(&foo_file, "Bar"); 1495 AddNestedExtension(bar, "Foo", "foo_message", 30, 1496 FieldDescriptorProto::LABEL_OPTIONAL, 1497 FieldDescriptorProto::TYPE_MESSAGE) 1498 ->set_type_name("Qux"); 1499 AddNestedExtension(bar, "Foo", "foo_group", 39, 1500 FieldDescriptorProto::LABEL_REPEATED, 1501 FieldDescriptorProto::TYPE_GROUP) 1502 ->set_type_name("Qux"); 1503 1504 // Build the descriptors and get the pointers. 1505 foo_file_ = pool_.BuildFile(foo_file); 1506 ASSERT_TRUE(foo_file_ != NULL); 1507 1508 ASSERT_EQ(1, foo_file_->enum_type_count()); 1509 baz_ = foo_file_->enum_type(0); 1510 1511 ASSERT_EQ(3, foo_file_->message_type_count()); 1512 qux_ = foo_file_->message_type(0); 1513 foo_ = foo_file_->message_type(1); 1514 bar_ = foo_file_->message_type(2); 1515 } 1516 1517 DescriptorPool pool_; 1518 1519 const FileDescriptor* foo_file_; 1520 1521 const Descriptor* foo_; 1522 const Descriptor* bar_; 1523 const EnumDescriptor* baz_; 1524 const Descriptor* qux_; 1525 }; 1526 1527 TEST_F(ExtensionDescriptorTest, ExtensionRanges) { 1528 EXPECT_EQ(0, bar_->extension_range_count()); 1529 ASSERT_EQ(2, foo_->extension_range_count()); 1530 1531 EXPECT_EQ(10, foo_->extension_range(0)->start); 1532 EXPECT_EQ(30, foo_->extension_range(1)->start); 1533 1534 EXPECT_EQ(20, foo_->extension_range(0)->end); 1535 EXPECT_EQ(40, foo_->extension_range(1)->end); 1536 }; 1537 1538 TEST_F(ExtensionDescriptorTest, Extensions) { 1539 EXPECT_EQ(0, foo_->extension_count()); 1540 ASSERT_EQ(2, foo_file_->extension_count()); 1541 ASSERT_EQ(2, bar_->extension_count()); 1542 1543 EXPECT_TRUE(foo_file_->extension(0)->is_extension()); 1544 EXPECT_TRUE(foo_file_->extension(1)->is_extension()); 1545 EXPECT_TRUE(bar_->extension(0)->is_extension()); 1546 EXPECT_TRUE(bar_->extension(1)->is_extension()); 1547 1548 EXPECT_EQ("foo_int32" , foo_file_->extension(0)->name()); 1549 EXPECT_EQ("foo_enum" , foo_file_->extension(1)->name()); 1550 EXPECT_EQ("foo_message", bar_->extension(0)->name()); 1551 EXPECT_EQ("foo_group" , bar_->extension(1)->name()); 1552 1553 EXPECT_EQ(10, foo_file_->extension(0)->number()); 1554 EXPECT_EQ(19, foo_file_->extension(1)->number()); 1555 EXPECT_EQ(30, bar_->extension(0)->number()); 1556 EXPECT_EQ(39, bar_->extension(1)->number()); 1557 1558 EXPECT_EQ(FieldDescriptor::TYPE_INT32 , foo_file_->extension(0)->type()); 1559 EXPECT_EQ(FieldDescriptor::TYPE_ENUM , foo_file_->extension(1)->type()); 1560 EXPECT_EQ(FieldDescriptor::TYPE_MESSAGE, bar_->extension(0)->type()); 1561 EXPECT_EQ(FieldDescriptor::TYPE_GROUP , bar_->extension(1)->type()); 1562 1563 EXPECT_EQ(baz_, foo_file_->extension(1)->enum_type()); 1564 EXPECT_EQ(qux_, bar_->extension(0)->message_type()); 1565 EXPECT_EQ(qux_, bar_->extension(1)->message_type()); 1566 1567 EXPECT_EQ(FieldDescriptor::LABEL_OPTIONAL, foo_file_->extension(0)->label()); 1568 EXPECT_EQ(FieldDescriptor::LABEL_REPEATED, foo_file_->extension(1)->label()); 1569 EXPECT_EQ(FieldDescriptor::LABEL_OPTIONAL, bar_->extension(0)->label()); 1570 EXPECT_EQ(FieldDescriptor::LABEL_REPEATED, bar_->extension(1)->label()); 1571 1572 EXPECT_EQ(foo_, foo_file_->extension(0)->containing_type()); 1573 EXPECT_EQ(foo_, foo_file_->extension(1)->containing_type()); 1574 EXPECT_EQ(foo_, bar_->extension(0)->containing_type()); 1575 EXPECT_EQ(foo_, bar_->extension(1)->containing_type()); 1576 1577 EXPECT_TRUE(foo_file_->extension(0)->extension_scope() == NULL); 1578 EXPECT_TRUE(foo_file_->extension(1)->extension_scope() == NULL); 1579 EXPECT_EQ(bar_, bar_->extension(0)->extension_scope()); 1580 EXPECT_EQ(bar_, bar_->extension(1)->extension_scope()); 1581 }; 1582 1583 TEST_F(ExtensionDescriptorTest, IsExtensionNumber) { 1584 EXPECT_FALSE(foo_->IsExtensionNumber( 9)); 1585 EXPECT_TRUE (foo_->IsExtensionNumber(10)); 1586 EXPECT_TRUE (foo_->IsExtensionNumber(19)); 1587 EXPECT_FALSE(foo_->IsExtensionNumber(20)); 1588 EXPECT_FALSE(foo_->IsExtensionNumber(29)); 1589 EXPECT_TRUE (foo_->IsExtensionNumber(30)); 1590 EXPECT_TRUE (foo_->IsExtensionNumber(39)); 1591 EXPECT_FALSE(foo_->IsExtensionNumber(40)); 1592 } 1593 1594 TEST_F(ExtensionDescriptorTest, FindExtensionByName) { 1595 // Note that FileDescriptor::FindExtensionByName() is tested by 1596 // FileDescriptorTest. 1597 ASSERT_EQ(2, bar_->extension_count()); 1598 1599 EXPECT_EQ(bar_->extension(0), bar_->FindExtensionByName("foo_message")); 1600 EXPECT_EQ(bar_->extension(1), bar_->FindExtensionByName("foo_group" )); 1601 1602 EXPECT_TRUE(bar_->FindExtensionByName("no_such_extension") == NULL); 1603 EXPECT_TRUE(foo_->FindExtensionByName("foo_int32") == NULL); 1604 EXPECT_TRUE(foo_->FindExtensionByName("foo_message") == NULL); 1605 } 1606 1607 TEST_F(ExtensionDescriptorTest, FindAllExtensions) { 1608 vector<const FieldDescriptor*> extensions; 1609 pool_.FindAllExtensions(foo_, &extensions); 1610 ASSERT_EQ(4, extensions.size()); 1611 EXPECT_EQ(10, extensions[0]->number()); 1612 EXPECT_EQ(19, extensions[1]->number()); 1613 EXPECT_EQ(30, extensions[2]->number()); 1614 EXPECT_EQ(39, extensions[3]->number()); 1615 } 1616 1617 TEST_F(ExtensionDescriptorTest, DuplicateFieldNumber) { 1618 DescriptorPool pool; 1619 FileDescriptorProto file_proto; 1620 // Add "google/protobuf/descriptor.proto". 1621 FileDescriptorProto::descriptor()->file()->CopyTo(&file_proto); 1622 ASSERT_TRUE(pool.BuildFile(file_proto) != NULL); 1623 // Add "foo.proto": 1624 // import "google/protobuf/descriptor.proto"; 1625 // extend google.protobuf.FieldOptions { 1626 // optional int32 option1 = 1000; 1627 // } 1628 file_proto.Clear(); 1629 file_proto.set_name("foo.proto"); 1630 file_proto.add_dependency("google/protobuf/descriptor.proto"); 1631 AddExtension(&file_proto, "google.protobuf.FieldOptions", "option1", 1000, 1632 FieldDescriptorProto::LABEL_OPTIONAL, 1633 FieldDescriptorProto::TYPE_INT32); 1634 ASSERT_TRUE(pool.BuildFile(file_proto) != NULL); 1635 // Add "bar.proto": 1636 // import "google/protobuf/descriptor.proto"; 1637 // extend google.protobuf.FieldOptions { 1638 // optional int32 option2 = 1000; 1639 // } 1640 file_proto.Clear(); 1641 file_proto.set_name("bar.proto"); 1642 file_proto.add_dependency("google/protobuf/descriptor.proto"); 1643 AddExtension(&file_proto, "google.protobuf.FieldOptions", "option2", 1000, 1644 FieldDescriptorProto::LABEL_OPTIONAL, 1645 FieldDescriptorProto::TYPE_INT32); 1646 // Currently we only generate a warning for conflicting extension numbers. 1647 // TODO(xiaofeng): Change it to an error. 1648 ASSERT_TRUE(pool.BuildFile(file_proto) != NULL); 1649 } 1650 1651 // =================================================================== 1652 1653 class MiscTest : public testing::Test { 1654 protected: 1655 // Function which makes a field descriptor of the given type. 1656 const FieldDescriptor* GetFieldDescriptorOfType(FieldDescriptor::Type type) { 1657 FileDescriptorProto file_proto; 1658 file_proto.set_name("foo.proto"); 1659 AddEmptyEnum(&file_proto, "DummyEnum"); 1660 1661 DescriptorProto* message = AddMessage(&file_proto, "TestMessage"); 1662 FieldDescriptorProto* field = 1663 AddField(message, "foo", 1, FieldDescriptorProto::LABEL_OPTIONAL, 1664 static_cast<FieldDescriptorProto::Type>(static_cast<int>(type))); 1665 1666 if (type == FieldDescriptor::TYPE_MESSAGE || 1667 type == FieldDescriptor::TYPE_GROUP) { 1668 field->set_type_name("TestMessage"); 1669 } else if (type == FieldDescriptor::TYPE_ENUM) { 1670 field->set_type_name("DummyEnum"); 1671 } 1672 1673 // Build the descriptors and get the pointers. 1674 pool_.reset(new DescriptorPool()); 1675 const FileDescriptor* file = pool_->BuildFile(file_proto); 1676 1677 if (file != NULL && 1678 file->message_type_count() == 1 && 1679 file->message_type(0)->field_count() == 1) { 1680 return file->message_type(0)->field(0); 1681 } else { 1682 return NULL; 1683 } 1684 } 1685 1686 const char* GetTypeNameForFieldType(FieldDescriptor::Type type) { 1687 const FieldDescriptor* field = GetFieldDescriptorOfType(type); 1688 return field != NULL ? field->type_name() : ""; 1689 } 1690 1691 FieldDescriptor::CppType GetCppTypeForFieldType(FieldDescriptor::Type type) { 1692 const FieldDescriptor* field = GetFieldDescriptorOfType(type); 1693 return field != NULL ? field->cpp_type() : 1694 static_cast<FieldDescriptor::CppType>(0); 1695 } 1696 1697 const char* GetCppTypeNameForFieldType(FieldDescriptor::Type type) { 1698 const FieldDescriptor* field = GetFieldDescriptorOfType(type); 1699 return field != NULL ? field->cpp_type_name() : ""; 1700 } 1701 1702 const Descriptor* GetMessageDescriptorForFieldType( 1703 FieldDescriptor::Type type) { 1704 const FieldDescriptor* field = GetFieldDescriptorOfType(type); 1705 return field != NULL ? field->message_type() : NULL; 1706 } 1707 1708 const EnumDescriptor* GetEnumDescriptorForFieldType( 1709 FieldDescriptor::Type type) { 1710 const FieldDescriptor* field = GetFieldDescriptorOfType(type); 1711 return field != NULL ? field->enum_type() : NULL; 1712 } 1713 1714 scoped_ptr<DescriptorPool> pool_; 1715 }; 1716 1717 TEST_F(MiscTest, TypeNames) { 1718 // Test that correct type names are returned. 1719 1720 typedef FieldDescriptor FD; // avoid ugly line wrapping 1721 1722 EXPECT_STREQ("double" , GetTypeNameForFieldType(FD::TYPE_DOUBLE )); 1723 EXPECT_STREQ("float" , GetTypeNameForFieldType(FD::TYPE_FLOAT )); 1724 EXPECT_STREQ("int64" , GetTypeNameForFieldType(FD::TYPE_INT64 )); 1725 EXPECT_STREQ("uint64" , GetTypeNameForFieldType(FD::TYPE_UINT64 )); 1726 EXPECT_STREQ("int32" , GetTypeNameForFieldType(FD::TYPE_INT32 )); 1727 EXPECT_STREQ("fixed64" , GetTypeNameForFieldType(FD::TYPE_FIXED64 )); 1728 EXPECT_STREQ("fixed32" , GetTypeNameForFieldType(FD::TYPE_FIXED32 )); 1729 EXPECT_STREQ("bool" , GetTypeNameForFieldType(FD::TYPE_BOOL )); 1730 EXPECT_STREQ("string" , GetTypeNameForFieldType(FD::TYPE_STRING )); 1731 EXPECT_STREQ("group" , GetTypeNameForFieldType(FD::TYPE_GROUP )); 1732 EXPECT_STREQ("message" , GetTypeNameForFieldType(FD::TYPE_MESSAGE )); 1733 EXPECT_STREQ("bytes" , GetTypeNameForFieldType(FD::TYPE_BYTES )); 1734 EXPECT_STREQ("uint32" , GetTypeNameForFieldType(FD::TYPE_UINT32 )); 1735 EXPECT_STREQ("enum" , GetTypeNameForFieldType(FD::TYPE_ENUM )); 1736 EXPECT_STREQ("sfixed32", GetTypeNameForFieldType(FD::TYPE_SFIXED32)); 1737 EXPECT_STREQ("sfixed64", GetTypeNameForFieldType(FD::TYPE_SFIXED64)); 1738 EXPECT_STREQ("sint32" , GetTypeNameForFieldType(FD::TYPE_SINT32 )); 1739 EXPECT_STREQ("sint64" , GetTypeNameForFieldType(FD::TYPE_SINT64 )); 1740 } 1741 1742 TEST_F(MiscTest, StaticTypeNames) { 1743 // Test that correct type names are returned. 1744 1745 typedef FieldDescriptor FD; // avoid ugly line wrapping 1746 1747 EXPECT_STREQ("double" , FD::TypeName(FD::TYPE_DOUBLE )); 1748 EXPECT_STREQ("float" , FD::TypeName(FD::TYPE_FLOAT )); 1749 EXPECT_STREQ("int64" , FD::TypeName(FD::TYPE_INT64 )); 1750 EXPECT_STREQ("uint64" , FD::TypeName(FD::TYPE_UINT64 )); 1751 EXPECT_STREQ("int32" , FD::TypeName(FD::TYPE_INT32 )); 1752 EXPECT_STREQ("fixed64" , FD::TypeName(FD::TYPE_FIXED64 )); 1753 EXPECT_STREQ("fixed32" , FD::TypeName(FD::TYPE_FIXED32 )); 1754 EXPECT_STREQ("bool" , FD::TypeName(FD::TYPE_BOOL )); 1755 EXPECT_STREQ("string" , FD::TypeName(FD::TYPE_STRING )); 1756 EXPECT_STREQ("group" , FD::TypeName(FD::TYPE_GROUP )); 1757 EXPECT_STREQ("message" , FD::TypeName(FD::TYPE_MESSAGE )); 1758 EXPECT_STREQ("bytes" , FD::TypeName(FD::TYPE_BYTES )); 1759 EXPECT_STREQ("uint32" , FD::TypeName(FD::TYPE_UINT32 )); 1760 EXPECT_STREQ("enum" , FD::TypeName(FD::TYPE_ENUM )); 1761 EXPECT_STREQ("sfixed32", FD::TypeName(FD::TYPE_SFIXED32)); 1762 EXPECT_STREQ("sfixed64", FD::TypeName(FD::TYPE_SFIXED64)); 1763 EXPECT_STREQ("sint32" , FD::TypeName(FD::TYPE_SINT32 )); 1764 EXPECT_STREQ("sint64" , FD::TypeName(FD::TYPE_SINT64 )); 1765 } 1766 1767 TEST_F(MiscTest, CppTypes) { 1768 // Test that CPP types are assigned correctly. 1769 1770 typedef FieldDescriptor FD; // avoid ugly line wrapping 1771 1772 EXPECT_EQ(FD::CPPTYPE_DOUBLE , GetCppTypeForFieldType(FD::TYPE_DOUBLE )); 1773 EXPECT_EQ(FD::CPPTYPE_FLOAT , GetCppTypeForFieldType(FD::TYPE_FLOAT )); 1774 EXPECT_EQ(FD::CPPTYPE_INT64 , GetCppTypeForFieldType(FD::TYPE_INT64 )); 1775 EXPECT_EQ(FD::CPPTYPE_UINT64 , GetCppTypeForFieldType(FD::TYPE_UINT64 )); 1776 EXPECT_EQ(FD::CPPTYPE_INT32 , GetCppTypeForFieldType(FD::TYPE_INT32 )); 1777 EXPECT_EQ(FD::CPPTYPE_UINT64 , GetCppTypeForFieldType(FD::TYPE_FIXED64 )); 1778 EXPECT_EQ(FD::CPPTYPE_UINT32 , GetCppTypeForFieldType(FD::TYPE_FIXED32 )); 1779 EXPECT_EQ(FD::CPPTYPE_BOOL , GetCppTypeForFieldType(FD::TYPE_BOOL )); 1780 EXPECT_EQ(FD::CPPTYPE_STRING , GetCppTypeForFieldType(FD::TYPE_STRING )); 1781 EXPECT_EQ(FD::CPPTYPE_MESSAGE, GetCppTypeForFieldType(FD::TYPE_GROUP )); 1782 EXPECT_EQ(FD::CPPTYPE_MESSAGE, GetCppTypeForFieldType(FD::TYPE_MESSAGE )); 1783 EXPECT_EQ(FD::CPPTYPE_STRING , GetCppTypeForFieldType(FD::TYPE_BYTES )); 1784 EXPECT_EQ(FD::CPPTYPE_UINT32 , GetCppTypeForFieldType(FD::TYPE_UINT32 )); 1785 EXPECT_EQ(FD::CPPTYPE_ENUM , GetCppTypeForFieldType(FD::TYPE_ENUM )); 1786 EXPECT_EQ(FD::CPPTYPE_INT32 , GetCppTypeForFieldType(FD::TYPE_SFIXED32)); 1787 EXPECT_EQ(FD::CPPTYPE_INT64 , GetCppTypeForFieldType(FD::TYPE_SFIXED64)); 1788 EXPECT_EQ(FD::CPPTYPE_INT32 , GetCppTypeForFieldType(FD::TYPE_SINT32 )); 1789 EXPECT_EQ(FD::CPPTYPE_INT64 , GetCppTypeForFieldType(FD::TYPE_SINT64 )); 1790 } 1791 1792 TEST_F(MiscTest, CppTypeNames) { 1793 // Test that correct CPP type names are returned. 1794 1795 typedef FieldDescriptor FD; // avoid ugly line wrapping 1796 1797 EXPECT_STREQ("double" , GetCppTypeNameForFieldType(FD::TYPE_DOUBLE )); 1798 EXPECT_STREQ("float" , GetCppTypeNameForFieldType(FD::TYPE_FLOAT )); 1799 EXPECT_STREQ("int64" , GetCppTypeNameForFieldType(FD::TYPE_INT64 )); 1800 EXPECT_STREQ("uint64" , GetCppTypeNameForFieldType(FD::TYPE_UINT64 )); 1801 EXPECT_STREQ("int32" , GetCppTypeNameForFieldType(FD::TYPE_INT32 )); 1802 EXPECT_STREQ("uint64" , GetCppTypeNameForFieldType(FD::TYPE_FIXED64 )); 1803 EXPECT_STREQ("uint32" , GetCppTypeNameForFieldType(FD::TYPE_FIXED32 )); 1804 EXPECT_STREQ("bool" , GetCppTypeNameForFieldType(FD::TYPE_BOOL )); 1805 EXPECT_STREQ("string" , GetCppTypeNameForFieldType(FD::TYPE_STRING )); 1806 EXPECT_STREQ("message", GetCppTypeNameForFieldType(FD::TYPE_GROUP )); 1807 EXPECT_STREQ("message", GetCppTypeNameForFieldType(FD::TYPE_MESSAGE )); 1808 EXPECT_STREQ("string" , GetCppTypeNameForFieldType(FD::TYPE_BYTES )); 1809 EXPECT_STREQ("uint32" , GetCppTypeNameForFieldType(FD::TYPE_UINT32 )); 1810 EXPECT_STREQ("enum" , GetCppTypeNameForFieldType(FD::TYPE_ENUM )); 1811 EXPECT_STREQ("int32" , GetCppTypeNameForFieldType(FD::TYPE_SFIXED32)); 1812 EXPECT_STREQ("int64" , GetCppTypeNameForFieldType(FD::TYPE_SFIXED64)); 1813 EXPECT_STREQ("int32" , GetCppTypeNameForFieldType(FD::TYPE_SINT32 )); 1814 EXPECT_STREQ("int64" , GetCppTypeNameForFieldType(FD::TYPE_SINT64 )); 1815 } 1816 1817 TEST_F(MiscTest, StaticCppTypeNames) { 1818 // Test that correct CPP type names are returned. 1819 1820 typedef FieldDescriptor FD; // avoid ugly line wrapping 1821 1822 EXPECT_STREQ("int32" , FD::CppTypeName(FD::CPPTYPE_INT32 )); 1823 EXPECT_STREQ("int64" , FD::CppTypeName(FD::CPPTYPE_INT64 )); 1824 EXPECT_STREQ("uint32" , FD::CppTypeName(FD::CPPTYPE_UINT32 )); 1825 EXPECT_STREQ("uint64" , FD::CppTypeName(FD::CPPTYPE_UINT64 )); 1826 EXPECT_STREQ("double" , FD::CppTypeName(FD::CPPTYPE_DOUBLE )); 1827 EXPECT_STREQ("float" , FD::CppTypeName(FD::CPPTYPE_FLOAT )); 1828 EXPECT_STREQ("bool" , FD::CppTypeName(FD::CPPTYPE_BOOL )); 1829 EXPECT_STREQ("enum" , FD::CppTypeName(FD::CPPTYPE_ENUM )); 1830 EXPECT_STREQ("string" , FD::CppTypeName(FD::CPPTYPE_STRING )); 1831 EXPECT_STREQ("message", FD::CppTypeName(FD::CPPTYPE_MESSAGE)); 1832 } 1833 1834 TEST_F(MiscTest, MessageType) { 1835 // Test that message_type() is NULL for non-aggregate fields 1836 1837 typedef FieldDescriptor FD; // avoid ugly line wrapping 1838 1839 EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_DOUBLE )); 1840 EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_FLOAT )); 1841 EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_INT64 )); 1842 EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_UINT64 )); 1843 EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_INT32 )); 1844 EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_FIXED64 )); 1845 EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_FIXED32 )); 1846 EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_BOOL )); 1847 EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_STRING )); 1848 EXPECT_TRUE(NULL != GetMessageDescriptorForFieldType(FD::TYPE_GROUP )); 1849 EXPECT_TRUE(NULL != GetMessageDescriptorForFieldType(FD::TYPE_MESSAGE )); 1850 EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_BYTES )); 1851 EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_UINT32 )); 1852 EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_ENUM )); 1853 EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_SFIXED32)); 1854 EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_SFIXED64)); 1855 EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_SINT32 )); 1856 EXPECT_TRUE(NULL == GetMessageDescriptorForFieldType(FD::TYPE_SINT64 )); 1857 } 1858 1859 TEST_F(MiscTest, EnumType) { 1860 // Test that enum_type() is NULL for non-enum fields 1861 1862 typedef FieldDescriptor FD; // avoid ugly line wrapping 1863 1864 EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_DOUBLE )); 1865 EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_FLOAT )); 1866 EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_INT64 )); 1867 EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_UINT64 )); 1868 EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_INT32 )); 1869 EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_FIXED64 )); 1870 EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_FIXED32 )); 1871 EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_BOOL )); 1872 EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_STRING )); 1873 EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_GROUP )); 1874 EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_MESSAGE )); 1875 EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_BYTES )); 1876 EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_UINT32 )); 1877 EXPECT_TRUE(NULL != GetEnumDescriptorForFieldType(FD::TYPE_ENUM )); 1878 EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_SFIXED32)); 1879 EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_SFIXED64)); 1880 EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_SINT32 )); 1881 EXPECT_TRUE(NULL == GetEnumDescriptorForFieldType(FD::TYPE_SINT64 )); 1882 } 1883 1884 1885 TEST_F(MiscTest, DefaultValues) { 1886 // Test that setting default values works. 1887 FileDescriptorProto file_proto; 1888 file_proto.set_name("foo.proto"); 1889 1890 EnumDescriptorProto* enum_type_proto = AddEnum(&file_proto, "DummyEnum"); 1891 AddEnumValue(enum_type_proto, "A", 1); 1892 AddEnumValue(enum_type_proto, "B", 2); 1893 1894 DescriptorProto* message_proto = AddMessage(&file_proto, "TestMessage"); 1895 1896 typedef FieldDescriptorProto FD; // avoid ugly line wrapping 1897 const FD::Label label = FD::LABEL_OPTIONAL; 1898 1899 // Create fields of every CPP type with default values. 1900 AddField(message_proto, "int32" , 1, label, FD::TYPE_INT32 ) 1901 ->set_default_value("-1"); 1902 AddField(message_proto, "int64" , 2, label, FD::TYPE_INT64 ) 1903 ->set_default_value("-1000000000000"); 1904 AddField(message_proto, "uint32", 3, label, FD::TYPE_UINT32) 1905 ->set_default_value("42"); 1906 AddField(message_proto, "uint64", 4, label, FD::TYPE_UINT64) 1907 ->set_default_value("2000000000000"); 1908 AddField(message_proto, "float" , 5, label, FD::TYPE_FLOAT ) 1909 ->set_default_value("4.5"); 1910 AddField(message_proto, "double", 6, label, FD::TYPE_DOUBLE) 1911 ->set_default_value("10e100"); 1912 AddField(message_proto, "bool" , 7, label, FD::TYPE_BOOL ) 1913 ->set_default_value("true"); 1914 AddField(message_proto, "string", 8, label, FD::TYPE_STRING) 1915 ->set_default_value("hello"); 1916 AddField(message_proto, "data" , 9, label, FD::TYPE_BYTES ) 1917 ->set_default_value("\\001\\002\\003"); 1918 1919 FieldDescriptorProto* enum_field = 1920 AddField(message_proto, "enum", 10, label, FD::TYPE_ENUM); 1921 enum_field->set_type_name("DummyEnum"); 1922 enum_field->set_default_value("B"); 1923 1924 // Strings are allowed to have empty defaults. (At one point, due to 1925 // a bug, empty defaults for strings were rejected. Oops.) 1926 AddField(message_proto, "empty_string", 11, label, FD::TYPE_STRING) 1927 ->set_default_value(""); 1928 1929 // Add a second set of fields with implicit defalut values. 1930 AddField(message_proto, "implicit_int32" , 21, label, FD::TYPE_INT32 ); 1931 AddField(message_proto, "implicit_int64" , 22, label, FD::TYPE_INT64 ); 1932 AddField(message_proto, "implicit_uint32", 23, label, FD::TYPE_UINT32); 1933 AddField(message_proto, "implicit_uint64", 24, label, FD::TYPE_UINT64); 1934 AddField(message_proto, "implicit_float" , 25, label, FD::TYPE_FLOAT ); 1935 AddField(message_proto, "implicit_double", 26, label, FD::TYPE_DOUBLE); 1936 AddField(message_proto, "implicit_bool" , 27, label, FD::TYPE_BOOL ); 1937 AddField(message_proto, "implicit_string", 28, label, FD::TYPE_STRING); 1938 AddField(message_proto, "implicit_data" , 29, label, FD::TYPE_BYTES ); 1939 AddField(message_proto, "implicit_enum" , 30, label, FD::TYPE_ENUM) 1940 ->set_type_name("DummyEnum"); 1941 1942 // Build it. 1943 DescriptorPool pool; 1944 const FileDescriptor* file = pool.BuildFile(file_proto); 1945 ASSERT_TRUE(file != NULL); 1946 1947 ASSERT_EQ(1, file->enum_type_count()); 1948 const EnumDescriptor* enum_type = file->enum_type(0); 1949 ASSERT_EQ(2, enum_type->value_count()); 1950 const EnumValueDescriptor* enum_value_a = enum_type->value(0); 1951 const EnumValueDescriptor* enum_value_b = enum_type->value(1); 1952 1953 ASSERT_EQ(1, file->message_type_count()); 1954 const Descriptor* message = file->message_type(0); 1955 1956 ASSERT_EQ(21, message->field_count()); 1957 1958 // Check the default values. 1959 ASSERT_TRUE(message->field(0)->has_default_value()); 1960 ASSERT_TRUE(message->field(1)->has_default_value()); 1961 ASSERT_TRUE(message->field(2)->has_default_value()); 1962 ASSERT_TRUE(message->field(3)->has_default_value()); 1963 ASSERT_TRUE(message->field(4)->has_default_value()); 1964 ASSERT_TRUE(message->field(5)->has_default_value()); 1965 ASSERT_TRUE(message->field(6)->has_default_value()); 1966 ASSERT_TRUE(message->field(7)->has_default_value()); 1967 ASSERT_TRUE(message->field(8)->has_default_value()); 1968 ASSERT_TRUE(message->field(9)->has_default_value()); 1969 ASSERT_TRUE(message->field(10)->has_default_value()); 1970 1971 EXPECT_EQ(-1 , message->field(0)->default_value_int32 ()); 1972 EXPECT_EQ(-GOOGLE_ULONGLONG(1000000000000), 1973 message->field(1)->default_value_int64 ()); 1974 EXPECT_EQ(42 , message->field(2)->default_value_uint32()); 1975 EXPECT_EQ(GOOGLE_ULONGLONG(2000000000000), 1976 message->field(3)->default_value_uint64()); 1977 EXPECT_EQ(4.5 , message->field(4)->default_value_float ()); 1978 EXPECT_EQ(10e100 , message->field(5)->default_value_double()); 1979 EXPECT_TRUE( message->field(6)->default_value_bool ()); 1980 EXPECT_EQ("hello" , message->field(7)->default_value_string()); 1981 EXPECT_EQ("\001\002\003" , message->field(8)->default_value_string()); 1982 EXPECT_EQ(enum_value_b , message->field(9)->default_value_enum ()); 1983 EXPECT_EQ("" , message->field(10)->default_value_string()); 1984 1985 ASSERT_FALSE(message->field(11)->has_default_value()); 1986 ASSERT_FALSE(message->field(12)->has_default_value()); 1987 ASSERT_FALSE(message->field(13)->has_default_value()); 1988 ASSERT_FALSE(message->field(14)->has_default_value()); 1989 ASSERT_FALSE(message->field(15)->has_default_value()); 1990 ASSERT_FALSE(message->field(16)->has_default_value()); 1991 ASSERT_FALSE(message->field(17)->has_default_value()); 1992 ASSERT_FALSE(message->field(18)->has_default_value()); 1993 ASSERT_FALSE(message->field(19)->has_default_value()); 1994 ASSERT_FALSE(message->field(20)->has_default_value()); 1995 1996 EXPECT_EQ(0 , message->field(11)->default_value_int32 ()); 1997 EXPECT_EQ(0 , message->field(12)->default_value_int64 ()); 1998 EXPECT_EQ(0 , message->field(13)->default_value_uint32()); 1999 EXPECT_EQ(0 , message->field(14)->default_value_uint64()); 2000 EXPECT_EQ(0.0f , message->field(15)->default_value_float ()); 2001 EXPECT_EQ(0.0 , message->field(16)->default_value_double()); 2002 EXPECT_FALSE( message->field(17)->default_value_bool ()); 2003 EXPECT_EQ("" , message->field(18)->default_value_string()); 2004 EXPECT_EQ("" , message->field(19)->default_value_string()); 2005 EXPECT_EQ(enum_value_a, message->field(20)->default_value_enum()); 2006 } 2007 2008 TEST_F(MiscTest, FieldOptions) { 2009 // Try setting field options. 2010 2011 FileDescriptorProto file_proto; 2012 file_proto.set_name("foo.proto"); 2013 2014 DescriptorProto* message_proto = AddMessage(&file_proto, "TestMessage"); 2015 AddField(message_proto, "foo", 1, 2016 FieldDescriptorProto::LABEL_OPTIONAL, 2017 FieldDescriptorProto::TYPE_INT32); 2018 FieldDescriptorProto* bar_proto = 2019 AddField(message_proto, "bar", 2, 2020 FieldDescriptorProto::LABEL_OPTIONAL, 2021 FieldDescriptorProto::TYPE_INT32); 2022 2023 FieldOptions* options = bar_proto->mutable_options(); 2024 options->set_ctype(FieldOptions::CORD); 2025 2026 // Build the descriptors and get the pointers. 2027 DescriptorPool pool; 2028 const FileDescriptor* file = pool.BuildFile(file_proto); 2029 ASSERT_TRUE(file != NULL); 2030 2031 ASSERT_EQ(1, file->message_type_count()); 2032 const Descriptor* message = file->message_type(0); 2033 2034 ASSERT_EQ(2, message->field_count()); 2035 const FieldDescriptor* foo = message->field(0); 2036 const FieldDescriptor* bar = message->field(1); 2037 2038 // "foo" had no options set, so it should return the default options. 2039 EXPECT_EQ(&FieldOptions::default_instance(), &foo->options()); 2040 2041 // "bar" had options set. 2042 EXPECT_NE(&FieldOptions::default_instance(), options); 2043 EXPECT_TRUE(bar->options().has_ctype()); 2044 EXPECT_EQ(FieldOptions::CORD, bar->options().ctype()); 2045 } 2046 2047 // =================================================================== 2048 enum DescriptorPoolMode { 2049 NO_DATABASE, 2050 FALLBACK_DATABASE 2051 }; 2052 2053 class AllowUnknownDependenciesTest 2054 : public testing::TestWithParam<DescriptorPoolMode> { 2055 protected: 2056 DescriptorPoolMode mode() { 2057 return GetParam(); 2058 } 2059 2060 virtual void SetUp() { 2061 FileDescriptorProto foo_proto, bar_proto; 2062 2063 switch (mode()) { 2064 case NO_DATABASE: 2065 pool_.reset(new DescriptorPool); 2066 break; 2067 case FALLBACK_DATABASE: 2068 pool_.reset(new DescriptorPool(&db_)); 2069 break; 2070 } 2071 2072 pool_->AllowUnknownDependencies(); 2073 2074 ASSERT_TRUE(TextFormat::ParseFromString( 2075 "name: 'foo.proto'" 2076 "dependency: 'bar.proto'" 2077 "dependency: 'baz.proto'" 2078 "message_type {" 2079 " name: 'Foo'" 2080 " field { name:'bar' number:1 label:LABEL_OPTIONAL type_name:'Bar' }" 2081 " field { name:'baz' number:2 label:LABEL_OPTIONAL type_name:'Baz' }" 2082 " field { name:'qux' number:3 label:LABEL_OPTIONAL" 2083 " type_name: '.corge.Qux'" 2084 " type: TYPE_ENUM" 2085 " options {" 2086 " uninterpreted_option {" 2087 " name {" 2088 " name_part: 'grault'" 2089 " is_extension: true" 2090 " }" 2091 " positive_int_value: 1234" 2092 " }" 2093 " }" 2094 " }" 2095 "}", 2096 &foo_proto)); 2097 ASSERT_TRUE(TextFormat::ParseFromString( 2098 "name: 'bar.proto'" 2099 "message_type { name: 'Bar' }", 2100 &bar_proto)); 2101 2102 // Collect pointers to stuff. 2103 bar_file_ = BuildFile(bar_proto); 2104 ASSERT_TRUE(bar_file_ != NULL); 2105 2106 ASSERT_EQ(1, bar_file_->message_type_count()); 2107 bar_type_ = bar_file_->message_type(0); 2108 2109 foo_file_ = BuildFile(foo_proto); 2110 ASSERT_TRUE(foo_file_ != NULL); 2111 2112 ASSERT_EQ(1, foo_file_->message_type_count()); 2113 foo_type_ = foo_file_->message_type(0); 2114 2115 ASSERT_EQ(3, foo_type_->field_count()); 2116 bar_field_ = foo_type_->field(0); 2117 baz_field_ = foo_type_->field(1); 2118 qux_field_ = foo_type_->field(2); 2119 } 2120 2121 const FileDescriptor* BuildFile(const FileDescriptorProto& proto) { 2122 switch (mode()) { 2123 case NO_DATABASE: 2124 return pool_->BuildFile(proto); 2125 break; 2126 case FALLBACK_DATABASE: { 2127 EXPECT_TRUE(db_.Add(proto)); 2128 return pool_->FindFileByName(proto.name()); 2129 } 2130 } 2131 GOOGLE_LOG(FATAL) << "Can't get here."; 2132 return NULL; 2133 } 2134 2135 const FileDescriptor* bar_file_; 2136 const Descriptor* bar_type_; 2137 const FileDescriptor* foo_file_; 2138 const Descriptor* foo_type_; 2139 const FieldDescriptor* bar_field_; 2140 const FieldDescriptor* baz_field_; 2141 const FieldDescriptor* qux_field_; 2142 2143 SimpleDescriptorDatabase db_; // used if in FALLBACK_DATABASE mode. 2144 scoped_ptr<DescriptorPool> pool_; 2145 }; 2146 2147 TEST_P(AllowUnknownDependenciesTest, PlaceholderFile) { 2148 ASSERT_EQ(2, foo_file_->dependency_count()); 2149 EXPECT_EQ(bar_file_, foo_file_->dependency(0)); 2150 EXPECT_FALSE(bar_file_->is_placeholder()); 2151 2152 const FileDescriptor* baz_file = foo_file_->dependency(1); 2153 EXPECT_EQ("baz.proto", baz_file->name()); 2154 EXPECT_EQ(0, baz_file->message_type_count()); 2155 EXPECT_TRUE(baz_file->is_placeholder()); 2156 2157 // Placeholder files should not be findable. 2158 EXPECT_EQ(bar_file_, pool_->FindFileByName(bar_file_->name())); 2159 EXPECT_TRUE(pool_->FindFileByName(baz_file->name()) == NULL); 2160 } 2161 2162 TEST_P(AllowUnknownDependenciesTest, PlaceholderTypes) { 2163 ASSERT_EQ(FieldDescriptor::TYPE_MESSAGE, bar_field_->type()); 2164 EXPECT_EQ(bar_type_, bar_field_->message_type()); 2165 EXPECT_FALSE(bar_type_->is_placeholder()); 2166 2167 ASSERT_EQ(FieldDescriptor::TYPE_MESSAGE, baz_field_->type()); 2168 const Descriptor* baz_type = baz_field_->message_type(); 2169 EXPECT_EQ("Baz", baz_type->name()); 2170 EXPECT_EQ("Baz", baz_type->full_name()); 2171 EXPECT_EQ(0, baz_type->extension_range_count()); 2172 EXPECT_TRUE(baz_type->is_placeholder()); 2173 2174 ASSERT_EQ(FieldDescriptor::TYPE_ENUM, qux_field_->type()); 2175 const EnumDescriptor* qux_type = qux_field_->enum_type(); 2176 EXPECT_EQ("Qux", qux_type->name()); 2177 EXPECT_EQ("corge.Qux", qux_type->full_name()); 2178 EXPECT_TRUE(qux_type->is_placeholder()); 2179 2180 // Placeholder types should not be findable. 2181 EXPECT_EQ(bar_type_, pool_->FindMessageTypeByName(bar_type_->full_name())); 2182 EXPECT_TRUE(pool_->FindMessageTypeByName(baz_type->full_name()) == NULL); 2183 EXPECT_TRUE(pool_->FindEnumTypeByName(qux_type->full_name()) == NULL); 2184 } 2185 2186 TEST_P(AllowUnknownDependenciesTest, CopyTo) { 2187 // FieldDescriptor::CopyTo() should write non-fully-qualified type names 2188 // for placeholder types which were not originally fully-qualified. 2189 FieldDescriptorProto proto; 2190 2191 // Bar is not a placeholder, so it is fully-qualified. 2192 bar_field_->CopyTo(&proto); 2193 EXPECT_EQ(".Bar", proto.type_name()); 2194 EXPECT_EQ(FieldDescriptorProto::TYPE_MESSAGE, proto.type()); 2195 2196 // Baz is an unqualified placeholder. 2197 proto.Clear(); 2198 baz_field_->CopyTo(&proto); 2199 EXPECT_EQ("Baz", proto.type_name()); 2200 EXPECT_FALSE(proto.has_type()); 2201 2202 // Qux is a fully-qualified placeholder. 2203 proto.Clear(); 2204 qux_field_->CopyTo(&proto); 2205 EXPECT_EQ(".corge.Qux", proto.type_name()); 2206 EXPECT_EQ(FieldDescriptorProto::TYPE_ENUM, proto.type()); 2207 } 2208 2209 TEST_P(AllowUnknownDependenciesTest, CustomOptions) { 2210 // Qux should still have the uninterpreted option attached. 2211 ASSERT_EQ(1, qux_field_->options().uninterpreted_option_size()); 2212 const UninterpretedOption& option = 2213 qux_field_->options().uninterpreted_option(0); 2214 ASSERT_EQ(1, option.name_size()); 2215 EXPECT_EQ("grault", option.name(0).name_part()); 2216 } 2217 2218 TEST_P(AllowUnknownDependenciesTest, UnknownExtendee) { 2219 // Test that we can extend an unknown type. This is slightly tricky because 2220 // it means that the placeholder type must have an extension range. 2221 2222 FileDescriptorProto extension_proto; 2223 2224 ASSERT_TRUE(TextFormat::ParseFromString( 2225 "name: 'extension.proto'" 2226 "extension { extendee: 'UnknownType' name:'some_extension' number:123" 2227 " label:LABEL_OPTIONAL type:TYPE_INT32 }", 2228 &extension_proto)); 2229 const FileDescriptor* file = BuildFile(extension_proto); 2230 2231 ASSERT_TRUE(file != NULL); 2232 2233 ASSERT_EQ(1, file->extension_count()); 2234 const Descriptor* extendee = file->extension(0)->containing_type(); 2235 EXPECT_EQ("UnknownType", extendee->name()); 2236 EXPECT_TRUE(extendee->is_placeholder()); 2237 ASSERT_EQ(1, extendee->extension_range_count()); 2238 EXPECT_EQ(1, extendee->extension_range(0)->start); 2239 EXPECT_EQ(FieldDescriptor::kMaxNumber + 1, extendee->extension_range(0)->end); 2240 } 2241 2242 TEST_P(AllowUnknownDependenciesTest, CustomOption) { 2243 // Test that we can use a custom option without having parsed 2244 // descriptor.proto. 2245 2246 FileDescriptorProto option_proto; 2247 2248 ASSERT_TRUE(TextFormat::ParseFromString( 2249 "name: \"unknown_custom_options.proto\" " 2250 "dependency: \"google/protobuf/descriptor.proto\" " 2251 "extension { " 2252 " extendee: \"google.protobuf.FileOptions\" " 2253 " name: \"some_option\" " 2254 " number: 123456 " 2255 " label: LABEL_OPTIONAL " 2256 " type: TYPE_INT32 " 2257 "} " 2258 "options { " 2259 " uninterpreted_option { " 2260 " name { " 2261 " name_part: \"some_option\" " 2262 " is_extension: true " 2263 " } " 2264 " positive_int_value: 1234 " 2265 " } " 2266 " uninterpreted_option { " 2267 " name { " 2268 " name_part: \"unknown_option\" " 2269 " is_extension: true " 2270 " } " 2271 " positive_int_value: 1234 " 2272 " } " 2273 " uninterpreted_option { " 2274 " name { " 2275 " name_part: \"optimize_for\" " 2276 " is_extension: false " 2277 " } " 2278 " identifier_value: \"SPEED\" " 2279 " } " 2280 "}", 2281 &option_proto)); 2282 2283 const FileDescriptor* file = BuildFile(option_proto); 2284 ASSERT_TRUE(file != NULL); 2285 2286 // Verify that no extension options were set, but they were left as 2287 // uninterpreted_options. 2288 vector<const FieldDescriptor*> fields; 2289 file->options().GetReflection()->ListFields(file->options(), &fields); 2290 ASSERT_EQ(2, fields.size()); 2291 EXPECT_TRUE(file->options().has_optimize_for()); 2292 EXPECT_EQ(2, file->options().uninterpreted_option_size()); 2293 } 2294 2295 TEST_P(AllowUnknownDependenciesTest, 2296 UndeclaredDependencyTriggersBuildOfDependency) { 2297 // Crazy case: suppose foo.proto refers to a symbol without declaring the 2298 // dependency that finds it. In the event that the pool is backed by a 2299 // DescriptorDatabase, the pool will attempt to find the symbol in the 2300 // database. If successful, it will build the undeclared dependency to verify 2301 // that the file does indeed contain the symbol. If that file fails to build, 2302 // then its descriptors must be rolled back. However, we still want foo.proto 2303 // to build successfully, since we are allowing unknown dependencies. 2304 2305 FileDescriptorProto undeclared_dep_proto; 2306 // We make this file fail to build by giving it two fields with tag 1. 2307 ASSERT_TRUE(TextFormat::ParseFromString( 2308 "name: \"invalid_file_as_undeclared_dep.proto\" " 2309 "package: \"undeclared\" " 2310 "message_type: { " 2311 " name: \"Quux\" " 2312 " field { " 2313 " name:'qux' number:1 label:LABEL_OPTIONAL type: TYPE_INT32 " 2314 " }" 2315 " field { " 2316 " name:'quux' number:1 label:LABEL_OPTIONAL type: TYPE_INT64 " 2317 " }" 2318 "}", 2319 &undeclared_dep_proto)); 2320 // We can't use the BuildFile() helper because we don't actually want to build 2321 // it into the descriptor pool in the fallback database case: it just needs to 2322 // be sitting in the database so that it gets built during the building of 2323 // test.proto below. 2324 switch (mode()) { 2325 case NO_DATABASE: { 2326 ASSERT_TRUE(pool_->BuildFile(undeclared_dep_proto) == NULL); 2327 break; 2328 } 2329 case FALLBACK_DATABASE: { 2330 ASSERT_TRUE(db_.Add(undeclared_dep_proto)); 2331 } 2332 } 2333 2334 FileDescriptorProto test_proto; 2335 ASSERT_TRUE(TextFormat::ParseFromString( 2336 "name: \"test.proto\" " 2337 "message_type: { " 2338 " name: \"Corge\" " 2339 " field { " 2340 " name:'quux' number:1 label: LABEL_OPTIONAL " 2341 " type_name:'undeclared.Quux' type: TYPE_MESSAGE " 2342 " }" 2343 "}", 2344 &test_proto)); 2345 2346 const FileDescriptor* file = BuildFile(test_proto); 2347 ASSERT_TRUE(file != NULL); 2348 GOOGLE_LOG(INFO) << file->DebugString(); 2349 2350 EXPECT_EQ(0, file->dependency_count()); 2351 ASSERT_EQ(1, file->message_type_count()); 2352 const Descriptor* corge_desc = file->message_type(0); 2353 ASSERT_EQ("Corge", corge_desc->name()); 2354 ASSERT_EQ(1, corge_desc->field_count()); 2355 EXPECT_FALSE(corge_desc->is_placeholder()); 2356 2357 const FieldDescriptor* quux_field = corge_desc->field(0); 2358 ASSERT_EQ(FieldDescriptor::TYPE_MESSAGE, quux_field->type()); 2359 ASSERT_EQ("Quux", quux_field->message_type()->name()); 2360 ASSERT_EQ("undeclared.Quux", quux_field->message_type()->full_name()); 2361 EXPECT_TRUE(quux_field->message_type()->is_placeholder()); 2362 // The place holder type should not be findable. 2363 ASSERT_TRUE(pool_->FindMessageTypeByName("undeclared.Quux") == NULL); 2364 } 2365 2366 INSTANTIATE_TEST_CASE_P(DatabaseSource, 2367 AllowUnknownDependenciesTest, 2368 testing::Values(NO_DATABASE, FALLBACK_DATABASE)); 2369 2370 // =================================================================== 2371 2372 TEST(CustomOptions, OptionLocations) { 2373 const Descriptor* message = 2374 protobuf_unittest::TestMessageWithCustomOptions::descriptor(); 2375 const FileDescriptor* file = message->file(); 2376 const FieldDescriptor* field = message->FindFieldByName("field1"); 2377 const EnumDescriptor* enm = message->FindEnumTypeByName("AnEnum"); 2378 // TODO(benjy): Support EnumValue options, once the compiler does. 2379 const ServiceDescriptor* service = 2380 file->FindServiceByName("TestServiceWithCustomOptions"); 2381 const MethodDescriptor* method = service->FindMethodByName("Foo"); 2382 2383 EXPECT_EQ(GOOGLE_LONGLONG(9876543210), 2384 file->options().GetExtension(protobuf_unittest::file_opt1)); 2385 EXPECT_EQ(-56, 2386 message->options().GetExtension(protobuf_unittest::message_opt1)); 2387 EXPECT_EQ(GOOGLE_LONGLONG(8765432109), 2388 field->options().GetExtension(protobuf_unittest::field_opt1)); 2389 EXPECT_EQ(42, // Check that we get the default for an option we don't set. 2390 field->options().GetExtension(protobuf_unittest::field_opt2)); 2391 EXPECT_EQ(-789, 2392 enm->options().GetExtension(protobuf_unittest::enum_opt1)); 2393 EXPECT_EQ(123, 2394 enm->value(1)->options().GetExtension( 2395 protobuf_unittest::enum_value_opt1)); 2396 EXPECT_EQ(GOOGLE_LONGLONG(-9876543210), 2397 service->options().GetExtension(protobuf_unittest::service_opt1)); 2398 EXPECT_EQ(protobuf_unittest::METHODOPT1_VAL2, 2399 method->options().GetExtension(protobuf_unittest::method_opt1)); 2400 2401 // See that the regular options went through unscathed. 2402 EXPECT_TRUE(message->options().has_message_set_wire_format()); 2403 EXPECT_EQ(FieldOptions::CORD, field->options().ctype()); 2404 } 2405 2406 TEST(CustomOptions, OptionTypes) { 2407 const MessageOptions* options = NULL; 2408 2409 options = 2410 &protobuf_unittest::CustomOptionMinIntegerValues::descriptor()->options(); 2411 EXPECT_EQ(false , options->GetExtension(protobuf_unittest::bool_opt)); 2412 EXPECT_EQ(kint32min, options->GetExtension(protobuf_unittest::int32_opt)); 2413 EXPECT_EQ(kint64min, options->GetExtension(protobuf_unittest::int64_opt)); 2414 EXPECT_EQ(0 , options->GetExtension(protobuf_unittest::uint32_opt)); 2415 EXPECT_EQ(0 , options->GetExtension(protobuf_unittest::uint64_opt)); 2416 EXPECT_EQ(kint32min, options->GetExtension(protobuf_unittest::sint32_opt)); 2417 EXPECT_EQ(kint64min, options->GetExtension(protobuf_unittest::sint64_opt)); 2418 EXPECT_EQ(0 , options->GetExtension(protobuf_unittest::fixed32_opt)); 2419 EXPECT_EQ(0 , options->GetExtension(protobuf_unittest::fixed64_opt)); 2420 EXPECT_EQ(kint32min, options->GetExtension(protobuf_unittest::sfixed32_opt)); 2421 EXPECT_EQ(kint64min, options->GetExtension(protobuf_unittest::sfixed64_opt)); 2422 2423 options = 2424 &protobuf_unittest::CustomOptionMaxIntegerValues::descriptor()->options(); 2425 EXPECT_EQ(true , options->GetExtension(protobuf_unittest::bool_opt)); 2426 EXPECT_EQ(kint32max , options->GetExtension(protobuf_unittest::int32_opt)); 2427 EXPECT_EQ(kint64max , options->GetExtension(protobuf_unittest::int64_opt)); 2428 EXPECT_EQ(kuint32max, options->GetExtension(protobuf_unittest::uint32_opt)); 2429 EXPECT_EQ(kuint64max, options->GetExtension(protobuf_unittest::uint64_opt)); 2430 EXPECT_EQ(kint32max , options->GetExtension(protobuf_unittest::sint32_opt)); 2431 EXPECT_EQ(kint64max , options->GetExtension(protobuf_unittest::sint64_opt)); 2432 EXPECT_EQ(kuint32max, options->GetExtension(protobuf_unittest::fixed32_opt)); 2433 EXPECT_EQ(kuint64max, options->GetExtension(protobuf_unittest::fixed64_opt)); 2434 EXPECT_EQ(kint32max , options->GetExtension(protobuf_unittest::sfixed32_opt)); 2435 EXPECT_EQ(kint64max , options->GetExtension(protobuf_unittest::sfixed64_opt)); 2436 2437 options = 2438 &protobuf_unittest::CustomOptionOtherValues::descriptor()->options(); 2439 EXPECT_EQ(-100, options->GetExtension(protobuf_unittest::int32_opt)); 2440 EXPECT_FLOAT_EQ(12.3456789, 2441 options->GetExtension(protobuf_unittest::float_opt)); 2442 EXPECT_DOUBLE_EQ(1.234567890123456789, 2443 options->GetExtension(protobuf_unittest::double_opt)); 2444 EXPECT_EQ("Hello, \"World\"", 2445 options->GetExtension(protobuf_unittest::string_opt)); 2446 2447 EXPECT_EQ(string("Hello\0World", 11), 2448 options->GetExtension(protobuf_unittest::bytes_opt)); 2449 2450 EXPECT_EQ(protobuf_unittest::DummyMessageContainingEnum::TEST_OPTION_ENUM_TYPE2, 2451 options->GetExtension(protobuf_unittest::enum_opt)); 2452 2453 options = 2454 &protobuf_unittest::SettingRealsFromPositiveInts::descriptor()->options(); 2455 EXPECT_FLOAT_EQ(12, options->GetExtension(protobuf_unittest::float_opt)); 2456 EXPECT_DOUBLE_EQ(154, options->GetExtension(protobuf_unittest::double_opt)); 2457 2458 options = 2459 &protobuf_unittest::SettingRealsFromNegativeInts::descriptor()->options(); 2460 EXPECT_FLOAT_EQ(-12, options->GetExtension(protobuf_unittest::float_opt)); 2461 EXPECT_DOUBLE_EQ(-154, options->GetExtension(protobuf_unittest::double_opt)); 2462 } 2463 2464 TEST(CustomOptions, ComplexExtensionOptions) { 2465 const MessageOptions* options = 2466 &protobuf_unittest::VariousComplexOptions::descriptor()->options(); 2467 EXPECT_EQ(options->GetExtension(protobuf_unittest::complex_opt1).foo(), 42); 2468 EXPECT_EQ(options->GetExtension(protobuf_unittest::complex_opt1). 2469 GetExtension(protobuf_unittest::quux), 324); 2470 EXPECT_EQ(options->GetExtension(protobuf_unittest::complex_opt1). 2471 GetExtension(protobuf_unittest::corge).qux(), 876); 2472 EXPECT_EQ(options->GetExtension(protobuf_unittest::complex_opt2).baz(), 987); 2473 EXPECT_EQ(options->GetExtension(protobuf_unittest::complex_opt2). 2474 GetExtension(protobuf_unittest::grault), 654); 2475 EXPECT_EQ(options->GetExtension(protobuf_unittest::complex_opt2).bar().foo(), 2476 743); 2477 EXPECT_EQ(options->GetExtension(protobuf_unittest::complex_opt2).bar(). 2478 GetExtension(protobuf_unittest::quux), 1999); 2479 EXPECT_EQ(options->GetExtension(protobuf_unittest::complex_opt2).bar(). 2480 GetExtension(protobuf_unittest::corge).qux(), 2008); 2481 EXPECT_EQ(options->GetExtension(protobuf_unittest::complex_opt2). 2482 GetExtension(protobuf_unittest::garply).foo(), 741); 2483 EXPECT_EQ(options->GetExtension(protobuf_unittest::complex_opt2). 2484 GetExtension(protobuf_unittest::garply). 2485 GetExtension(protobuf_unittest::quux), 1998); 2486 EXPECT_EQ(options->GetExtension(protobuf_unittest::complex_opt2). 2487 GetExtension(protobuf_unittest::garply). 2488 GetExtension(protobuf_unittest::corge).qux(), 2121); 2489 EXPECT_EQ(options->GetExtension( 2490 protobuf_unittest::ComplexOptionType2::ComplexOptionType4::complex_opt4). 2491 waldo(), 1971); 2492 EXPECT_EQ(options->GetExtension(protobuf_unittest::complex_opt2). 2493 fred().waldo(), 321); 2494 EXPECT_EQ(9, options->GetExtension(protobuf_unittest::complex_opt3).qux()); 2495 EXPECT_EQ(22, options->GetExtension(protobuf_unittest::complex_opt3). 2496 complexoptiontype5().plugh()); 2497 EXPECT_EQ(24, options->GetExtension(protobuf_unittest::complexopt6).xyzzy()); 2498 } 2499 2500 TEST(CustomOptions, OptionsFromOtherFile) { 2501 // Test that to use a custom option, we only need to import the file 2502 // defining the option; we do not also have to import descriptor.proto. 2503 DescriptorPool pool; 2504 2505 FileDescriptorProto file_proto; 2506 FileDescriptorProto::descriptor()->file()->CopyTo(&file_proto); 2507 ASSERT_TRUE(pool.BuildFile(file_proto) != NULL); 2508 2509 protobuf_unittest::TestMessageWithCustomOptions::descriptor() 2510 ->file()->CopyTo(&file_proto); 2511 ASSERT_TRUE(pool.BuildFile(file_proto) != NULL); 2512 2513 ASSERT_TRUE(TextFormat::ParseFromString( 2514 "name: \"custom_options_import.proto\" " 2515 "package: \"protobuf_unittest\" " 2516 "dependency: \"google/protobuf/unittest_custom_options.proto\" " 2517 "options { " 2518 " uninterpreted_option { " 2519 " name { " 2520 " name_part: \"file_opt1\" " 2521 " is_extension: true " 2522 " } " 2523 " positive_int_value: 1234 " 2524 " } " 2525 // Test a non-extension option too. (At one point this failed due to a 2526 // bug.) 2527 " uninterpreted_option { " 2528 " name { " 2529 " name_part: \"java_package\" " 2530 " is_extension: false " 2531 " } " 2532 " string_value: \"foo\" " 2533 " } " 2534 // Test that enum-typed options still work too. (At one point this also 2535 // failed due to a bug.) 2536 " uninterpreted_option { " 2537 " name { " 2538 " name_part: \"optimize_for\" " 2539 " is_extension: false " 2540 " } " 2541 " identifier_value: \"SPEED\" " 2542 " } " 2543 "}" 2544 , 2545 &file_proto)); 2546 2547 const FileDescriptor* file = pool.BuildFile(file_proto); 2548 ASSERT_TRUE(file != NULL); 2549 EXPECT_EQ(1234, file->options().GetExtension(protobuf_unittest::file_opt1)); 2550 EXPECT_TRUE(file->options().has_java_package()); 2551 EXPECT_EQ("foo", file->options().java_package()); 2552 EXPECT_TRUE(file->options().has_optimize_for()); 2553 EXPECT_EQ(FileOptions::SPEED, file->options().optimize_for()); 2554 } 2555 2556 TEST(CustomOptions, MessageOptionThreeFieldsSet) { 2557 // This tests a bug which previously existed in custom options parsing. The 2558 // bug occurred when you defined a custom option with message type and then 2559 // set three fields of that option on a single definition (see the example 2560 // below). The bug is a bit hard to explain, so check the change history if 2561 // you want to know more. 2562 DescriptorPool pool; 2563 2564 FileDescriptorProto file_proto; 2565 FileDescriptorProto::descriptor()->file()->CopyTo(&file_proto); 2566 ASSERT_TRUE(pool.BuildFile(file_proto) != NULL); 2567 2568 protobuf_unittest::TestMessageWithCustomOptions::descriptor() 2569 ->file()->CopyTo(&file_proto); 2570 ASSERT_TRUE(pool.BuildFile(file_proto) != NULL); 2571 2572 // The following represents the definition: 2573 // 2574 // import "google/protobuf/unittest_custom_options.proto" 2575 // package protobuf_unittest; 2576 // message Foo { 2577 // option (complex_opt1).foo = 1234; 2578 // option (complex_opt1).foo2 = 1234; 2579 // option (complex_opt1).foo3 = 1234; 2580 // } 2581 ASSERT_TRUE(TextFormat::ParseFromString( 2582 "name: \"custom_options_import.proto\" " 2583 "package: \"protobuf_unittest\" " 2584 "dependency: \"google/protobuf/unittest_custom_options.proto\" " 2585 "message_type { " 2586 " name: \"Foo\" " 2587 " options { " 2588 " uninterpreted_option { " 2589 " name { " 2590 " name_part: \"complex_opt1\" " 2591 " is_extension: true " 2592 " } " 2593 " name { " 2594 " name_part: \"foo\" " 2595 " is_extension: false " 2596 " } " 2597 " positive_int_value: 1234 " 2598 " } " 2599 " uninterpreted_option { " 2600 " name { " 2601 " name_part: \"complex_opt1\" " 2602 " is_extension: true " 2603 " } " 2604 " name { " 2605 " name_part: \"foo2\" " 2606 " is_extension: false " 2607 " } " 2608 " positive_int_value: 1234 " 2609 " } " 2610 " uninterpreted_option { " 2611 " name { " 2612 " name_part: \"complex_opt1\" " 2613 " is_extension: true " 2614 " } " 2615 " name { " 2616 " name_part: \"foo3\" " 2617 " is_extension: false " 2618 " } " 2619 " positive_int_value: 1234 " 2620 " } " 2621 " } " 2622 "}", 2623 &file_proto)); 2624 2625 const FileDescriptor* file = pool.BuildFile(file_proto); 2626 ASSERT_TRUE(file != NULL); 2627 ASSERT_EQ(1, file->message_type_count()); 2628 2629 const MessageOptions& options = file->message_type(0)->options(); 2630 EXPECT_EQ(1234, options.GetExtension(protobuf_unittest::complex_opt1).foo()); 2631 } 2632 2633 TEST(CustomOptions, MessageOptionRepeatedLeafFieldSet) { 2634 // This test verifies that repeated fields in custom options can be 2635 // given multiple values by repeating the option with a different value. 2636 // This test checks repeated leaf values. Each repeated custom value 2637 // appears in a different uninterpreted_option, which will be concatenated 2638 // when they are merged into the final option value. 2639 DescriptorPool pool; 2640 2641 FileDescriptorProto file_proto; 2642 FileDescriptorProto::descriptor()->file()->CopyTo(&file_proto); 2643 ASSERT_TRUE(pool.BuildFile(file_proto) != NULL); 2644 2645 protobuf_unittest::TestMessageWithCustomOptions::descriptor() 2646 ->file()->CopyTo(&file_proto); 2647 ASSERT_TRUE(pool.BuildFile(file_proto) != NULL); 2648 2649 // The following represents the definition: 2650 // 2651 // import "google/protobuf/unittest_custom_options.proto" 2652 // package protobuf_unittest; 2653 // message Foo { 2654 // option (complex_opt1).foo4 = 12; 2655 // option (complex_opt1).foo4 = 34; 2656 // option (complex_opt1).foo4 = 56; 2657 // } 2658 ASSERT_TRUE(TextFormat::ParseFromString( 2659 "name: \"custom_options_import.proto\" " 2660 "package: \"protobuf_unittest\" " 2661 "dependency: \"google/protobuf/unittest_custom_options.proto\" " 2662 "message_type { " 2663 " name: \"Foo\" " 2664 " options { " 2665 " uninterpreted_option { " 2666 " name { " 2667 " name_part: \"complex_opt1\" " 2668 " is_extension: true " 2669 " } " 2670 " name { " 2671 " name_part: \"foo4\" " 2672 " is_extension: false " 2673 " } " 2674 " positive_int_value: 12 " 2675 " } " 2676 " uninterpreted_option { " 2677 " name { " 2678 " name_part: \"complex_opt1\" " 2679 " is_extension: true " 2680 " } " 2681 " name { " 2682 " name_part: \"foo4\" " 2683 " is_extension: false " 2684 " } " 2685 " positive_int_value: 34 " 2686 " } " 2687 " uninterpreted_option { " 2688 " name { " 2689 " name_part: \"complex_opt1\" " 2690 " is_extension: true " 2691 " } " 2692 " name { " 2693 " name_part: \"foo4\" " 2694 " is_extension: false " 2695 " } " 2696 " positive_int_value: 56 " 2697 " } " 2698 " } " 2699 "}", 2700 &file_proto)); 2701 2702 const FileDescriptor* file = pool.BuildFile(file_proto); 2703 ASSERT_TRUE(file != NULL); 2704 ASSERT_EQ(1, file->message_type_count()); 2705 2706 const MessageOptions& options = file->message_type(0)->options(); 2707 EXPECT_EQ(3, options.GetExtension(protobuf_unittest::complex_opt1).foo4_size()); 2708 EXPECT_EQ(12, options.GetExtension(protobuf_unittest::complex_opt1).foo4(0)); 2709 EXPECT_EQ(34, options.GetExtension(protobuf_unittest::complex_opt1).foo4(1)); 2710 EXPECT_EQ(56, options.GetExtension(protobuf_unittest::complex_opt1).foo4(2)); 2711 } 2712 2713 TEST(CustomOptions, MessageOptionRepeatedMsgFieldSet) { 2714 // This test verifies that repeated fields in custom options can be 2715 // given multiple values by repeating the option with a different value. 2716 // This test checks repeated message values. Each repeated custom value 2717 // appears in a different uninterpreted_option, which will be concatenated 2718 // when they are merged into the final option value. 2719 DescriptorPool pool; 2720 2721 FileDescriptorProto file_proto; 2722 FileDescriptorProto::descriptor()->file()->CopyTo(&file_proto); 2723 ASSERT_TRUE(pool.BuildFile(file_proto) != NULL); 2724 2725 protobuf_unittest::TestMessageWithCustomOptions::descriptor() 2726 ->file()->CopyTo(&file_proto); 2727 ASSERT_TRUE(pool.BuildFile(file_proto) != NULL); 2728 2729 // The following represents the definition: 2730 // 2731 // import "google/protobuf/unittest_custom_options.proto" 2732 // package protobuf_unittest; 2733 // message Foo { 2734 // option (complex_opt2).barney = {waldo: 1}; 2735 // option (complex_opt2).barney = {waldo: 10}; 2736 // option (complex_opt2).barney = {waldo: 100}; 2737 // } 2738 ASSERT_TRUE(TextFormat::ParseFromString( 2739 "name: \"custom_options_import.proto\" " 2740 "package: \"protobuf_unittest\" " 2741 "dependency: \"google/protobuf/unittest_custom_options.proto\" " 2742 "message_type { " 2743 " name: \"Foo\" " 2744 " options { " 2745 " uninterpreted_option { " 2746 " name { " 2747 " name_part: \"complex_opt2\" " 2748 " is_extension: true " 2749 " } " 2750 " name { " 2751 " name_part: \"barney\" " 2752 " is_extension: false " 2753 " } " 2754 " aggregate_value: \"waldo: 1\" " 2755 " } " 2756 " uninterpreted_option { " 2757 " name { " 2758 " name_part: \"complex_opt2\" " 2759 " is_extension: true " 2760 " } " 2761 " name { " 2762 " name_part: \"barney\" " 2763 " is_extension: false " 2764 " } " 2765 " aggregate_value: \"waldo: 10\" " 2766 " } " 2767 " uninterpreted_option { " 2768 " name { " 2769 " name_part: \"complex_opt2\" " 2770 " is_extension: true " 2771 " } " 2772 " name { " 2773 " name_part: \"barney\" " 2774 " is_extension: false " 2775 " } " 2776 " aggregate_value: \"waldo: 100\" " 2777 " } " 2778 " } " 2779 "}", 2780 &file_proto)); 2781 2782 const FileDescriptor* file = pool.BuildFile(file_proto); 2783 ASSERT_TRUE(file != NULL); 2784 ASSERT_EQ(1, file->message_type_count()); 2785 2786 const MessageOptions& options = file->message_type(0)->options(); 2787 EXPECT_EQ(3, options.GetExtension( 2788 protobuf_unittest::complex_opt2).barney_size()); 2789 EXPECT_EQ(1,options.GetExtension( 2790 protobuf_unittest::complex_opt2).barney(0).waldo()); 2791 EXPECT_EQ(10, options.GetExtension( 2792 protobuf_unittest::complex_opt2).barney(1).waldo()); 2793 EXPECT_EQ(100, options.GetExtension( 2794 protobuf_unittest::complex_opt2).barney(2).waldo()); 2795 } 2796 2797 // Check that aggregate options were parsed and saved correctly in 2798 // the appropriate descriptors. 2799 TEST(CustomOptions, AggregateOptions) { 2800 const Descriptor* msg = protobuf_unittest::AggregateMessage::descriptor(); 2801 const FileDescriptor* file = msg->file(); 2802 const FieldDescriptor* field = msg->FindFieldByName("fieldname"); 2803 const EnumDescriptor* enumd = file->FindEnumTypeByName("AggregateEnum"); 2804 const EnumValueDescriptor* enumv = enumd->FindValueByName("VALUE"); 2805 const ServiceDescriptor* service = file->FindServiceByName( 2806 "AggregateService"); 2807 const MethodDescriptor* method = service->FindMethodByName("Method"); 2808 2809 // Tests for the different types of data embedded in fileopt 2810 const protobuf_unittest::Aggregate& file_options = 2811 file->options().GetExtension(protobuf_unittest::fileopt); 2812 EXPECT_EQ(100, file_options.i()); 2813 EXPECT_EQ("FileAnnotation", file_options.s()); 2814 EXPECT_EQ("NestedFileAnnotation", file_options.sub().s()); 2815 EXPECT_EQ("FileExtensionAnnotation", 2816 file_options.file().GetExtension(protobuf_unittest::fileopt).s()); 2817 EXPECT_EQ("EmbeddedMessageSetElement", 2818 file_options.mset().GetExtension( 2819 protobuf_unittest::AggregateMessageSetElement 2820 ::message_set_extension).s()); 2821 2822 // Simple tests for all the other types of annotations 2823 EXPECT_EQ("MessageAnnotation", 2824 msg->options().GetExtension(protobuf_unittest::msgopt).s()); 2825 EXPECT_EQ("FieldAnnotation", 2826 field->options().GetExtension(protobuf_unittest::fieldopt).s()); 2827 EXPECT_EQ("EnumAnnotation", 2828 enumd->options().GetExtension(protobuf_unittest::enumopt).s()); 2829 EXPECT_EQ("EnumValueAnnotation", 2830 enumv->options().GetExtension(protobuf_unittest::enumvalopt).s()); 2831 EXPECT_EQ("ServiceAnnotation", 2832 service->options().GetExtension(protobuf_unittest::serviceopt).s()); 2833 EXPECT_EQ("MethodAnnotation", 2834 method->options().GetExtension(protobuf_unittest::methodopt).s()); 2835 } 2836 2837 TEST(CustomOptions, UnusedImportWarning) { 2838 DescriptorPool pool; 2839 2840 FileDescriptorProto file_proto; 2841 FileDescriptorProto::descriptor()->file()->CopyTo(&file_proto); 2842 ASSERT_TRUE(pool.BuildFile(file_proto) != NULL); 2843 2844 protobuf_unittest::TestMessageWithCustomOptions::descriptor() 2845 ->file()->CopyTo(&file_proto); 2846 ASSERT_TRUE(pool.BuildFile(file_proto) != NULL); 2847 2848 2849 pool.AddUnusedImportTrackFile("custom_options_import.proto"); 2850 ASSERT_TRUE(TextFormat::ParseFromString( 2851 "name: \"custom_options_import.proto\" " 2852 "package: \"protobuf_unittest\" " 2853 "dependency: \"google/protobuf/unittest_custom_options.proto\" ", 2854 &file_proto)); 2855 pool.BuildFile(file_proto); 2856 } 2857 2858 // =================================================================== 2859 2860 // The tests below trigger every unique call to AddError() in descriptor.cc, 2861 // in the order in which they appear in that file. I'm using TextFormat here 2862 // to specify the input descriptors because building them using code would 2863 // be too bulky. 2864 2865 class MockErrorCollector : public DescriptorPool::ErrorCollector { 2866 public: 2867 MockErrorCollector() {} 2868 ~MockErrorCollector() {} 2869 2870 string text_; 2871 string warning_text_; 2872 2873 // implements ErrorCollector --------------------------------------- 2874 void AddError(const string& filename, 2875 const string& element_name, const Message* descriptor, 2876 ErrorLocation location, const string& message) { 2877 const char* location_name = NULL; 2878 switch (location) { 2879 case NAME : location_name = "NAME" ; break; 2880 case NUMBER : location_name = "NUMBER" ; break; 2881 case TYPE : location_name = "TYPE" ; break; 2882 case EXTENDEE : location_name = "EXTENDEE" ; break; 2883 case DEFAULT_VALUE: location_name = "DEFAULT_VALUE"; break; 2884 case OPTION_NAME : location_name = "OPTION_NAME" ; break; 2885 case OPTION_VALUE : location_name = "OPTION_VALUE" ; break; 2886 case INPUT_TYPE : location_name = "INPUT_TYPE" ; break; 2887 case OUTPUT_TYPE : location_name = "OUTPUT_TYPE" ; break; 2888 case OTHER : location_name = "OTHER" ; break; 2889 } 2890 2891 strings::SubstituteAndAppend( 2892 &text_, "$0: $1: $2: $3\n", 2893 filename, element_name, location_name, message); 2894 } 2895 2896 // implements ErrorCollector --------------------------------------- 2897 void AddWarning(const string& filename, const string& element_name, 2898 const Message* descriptor, ErrorLocation location, 2899 const string& message) { 2900 const char* location_name = NULL; 2901 switch (location) { 2902 case NAME : location_name = "NAME" ; break; 2903 case NUMBER : location_name = "NUMBER" ; break; 2904 case TYPE : location_name = "TYPE" ; break; 2905 case EXTENDEE : location_name = "EXTENDEE" ; break; 2906 case DEFAULT_VALUE: location_name = "DEFAULT_VALUE"; break; 2907 case OPTION_NAME : location_name = "OPTION_NAME" ; break; 2908 case OPTION_VALUE : location_name = "OPTION_VALUE" ; break; 2909 case INPUT_TYPE : location_name = "INPUT_TYPE" ; break; 2910 case OUTPUT_TYPE : location_name = "OUTPUT_TYPE" ; break; 2911 case OTHER : location_name = "OTHER" ; break; 2912 } 2913 2914 strings::SubstituteAndAppend( 2915 &warning_text_, "$0: $1: $2: $3\n", 2916 filename, element_name, location_name, message); 2917 } 2918 }; 2919 2920 class ValidationErrorTest : public testing::Test { 2921 protected: 2922 // Parse file_text as a FileDescriptorProto in text format and add it 2923 // to the DescriptorPool. Expect no errors. 2924 void BuildFile(const string& file_text) { 2925 FileDescriptorProto file_proto; 2926 ASSERT_TRUE(TextFormat::ParseFromString(file_text, &file_proto)); 2927 ASSERT_TRUE(pool_.BuildFile(file_proto) != NULL); 2928 } 2929 2930 // Parse file_text as a FileDescriptorProto in text format and add it 2931 // to the DescriptorPool. Expect errors to be produced which match the 2932 // given error text. 2933 void BuildFileWithErrors(const string& file_text, 2934 const string& expected_errors) { 2935 FileDescriptorProto file_proto; 2936 ASSERT_TRUE(TextFormat::ParseFromString(file_text, &file_proto)); 2937 2938 MockErrorCollector error_collector; 2939 EXPECT_TRUE( 2940 pool_.BuildFileCollectingErrors(file_proto, &error_collector) == NULL); 2941 EXPECT_EQ(expected_errors, error_collector.text_); 2942 } 2943 2944 // Parse file_text as a FileDescriptorProto in text format and add it 2945 // to the DescriptorPool. Expect errors to be produced which match the 2946 // given warning text. 2947 void BuildFileWithWarnings(const string& file_text, 2948 const string& expected_warnings) { 2949 FileDescriptorProto file_proto; 2950 ASSERT_TRUE(TextFormat::ParseFromString(file_text, &file_proto)); 2951 2952 MockErrorCollector error_collector; 2953 EXPECT_TRUE(pool_.BuildFileCollectingErrors(file_proto, &error_collector)); 2954 EXPECT_EQ(expected_warnings, error_collector.warning_text_); 2955 } 2956 2957 // Builds some already-parsed file in our test pool. 2958 void BuildFileInTestPool(const FileDescriptor* file) { 2959 FileDescriptorProto file_proto; 2960 file->CopyTo(&file_proto); 2961 ASSERT_TRUE(pool_.BuildFile(file_proto) != NULL); 2962 } 2963 2964 // Build descriptor.proto in our test pool. This allows us to extend it in 2965 // the test pool, so we can test custom options. 2966 void BuildDescriptorMessagesInTestPool() { 2967 BuildFileInTestPool(DescriptorProto::descriptor()->file()); 2968 } 2969 2970 DescriptorPool pool_; 2971 }; 2972 2973 TEST_F(ValidationErrorTest, AlreadyDefined) { 2974 BuildFileWithErrors( 2975 "name: \"foo.proto\" " 2976 "message_type { name: \"Foo\" }" 2977 "message_type { name: \"Foo\" }", 2978 2979 "foo.proto: Foo: NAME: \"Foo\" is already defined.\n"); 2980 } 2981 2982 TEST_F(ValidationErrorTest, AlreadyDefinedInPackage) { 2983 BuildFileWithErrors( 2984 "name: \"foo.proto\" " 2985 "package: \"foo.bar\" " 2986 "message_type { name: \"Foo\" }" 2987 "message_type { name: \"Foo\" }", 2988 2989 "foo.proto: foo.bar.Foo: NAME: \"Foo\" is already defined in " 2990 "\"foo.bar\".\n"); 2991 } 2992 2993 TEST_F(ValidationErrorTest, AlreadyDefinedInOtherFile) { 2994 BuildFile( 2995 "name: \"foo.proto\" " 2996 "message_type { name: \"Foo\" }"); 2997 2998 BuildFileWithErrors( 2999 "name: \"bar.proto\" " 3000 "message_type { name: \"Foo\" }", 3001 3002 "bar.proto: Foo: NAME: \"Foo\" is already defined in file " 3003 "\"foo.proto\".\n"); 3004 } 3005 3006 TEST_F(ValidationErrorTest, PackageAlreadyDefined) { 3007 BuildFile( 3008 "name: \"foo.proto\" " 3009 "message_type { name: \"foo\" }"); 3010 BuildFileWithErrors( 3011 "name: \"bar.proto\" " 3012 "package: \"foo.bar\"", 3013 3014 "bar.proto: foo: NAME: \"foo\" is already defined (as something other " 3015 "than a package) in file \"foo.proto\".\n"); 3016 } 3017 3018 TEST_F(ValidationErrorTest, EnumValueAlreadyDefinedInParent) { 3019 BuildFileWithErrors( 3020 "name: \"foo.proto\" " 3021 "enum_type { name: \"Foo\" value { name: \"FOO\" number: 1 } } " 3022 "enum_type { name: \"Bar\" value { name: \"FOO\" number: 1 } } ", 3023 3024 "foo.proto: FOO: NAME: \"FOO\" is already defined.\n" 3025 "foo.proto: FOO: NAME: Note that enum values use C++ scoping rules, " 3026 "meaning that enum values are siblings of their type, not children of " 3027 "it. Therefore, \"FOO\" must be unique within the global scope, not " 3028 "just within \"Bar\".\n"); 3029 } 3030 3031 TEST_F(ValidationErrorTest, EnumValueAlreadyDefinedInParentNonGlobal) { 3032 BuildFileWithErrors( 3033 "name: \"foo.proto\" " 3034 "package: \"pkg\" " 3035 "enum_type { name: \"Foo\" value { name: \"FOO\" number: 1 } } " 3036 "enum_type { name: \"Bar\" value { name: \"FOO\" number: 1 } } ", 3037 3038 "foo.proto: pkg.FOO: NAME: \"FOO\" is already defined in \"pkg\".\n" 3039 "foo.proto: pkg.FOO: NAME: Note that enum values use C++ scoping rules, " 3040 "meaning that enum values are siblings of their type, not children of " 3041 "it. Therefore, \"FOO\" must be unique within \"pkg\", not just within " 3042 "\"Bar\".\n"); 3043 } 3044 3045 TEST_F(ValidationErrorTest, MissingName) { 3046 BuildFileWithErrors( 3047 "name: \"foo.proto\" " 3048 "message_type { }", 3049 3050 "foo.proto: : NAME: Missing name.\n"); 3051 } 3052 3053 TEST_F(ValidationErrorTest, InvalidName) { 3054 BuildFileWithErrors( 3055 "name: \"foo.proto\" " 3056 "message_type { name: \"$\" }", 3057 3058 "foo.proto: $: NAME: \"$\" is not a valid identifier.\n"); 3059 } 3060 3061 TEST_F(ValidationErrorTest, InvalidPackageName) { 3062 BuildFileWithErrors( 3063 "name: \"foo.proto\" " 3064 "package: \"foo.$\"", 3065 3066 "foo.proto: foo.$: NAME: \"$\" is not a valid identifier.\n"); 3067 } 3068 3069 TEST_F(ValidationErrorTest, MissingFileName) { 3070 BuildFileWithErrors( 3071 "", 3072 3073 ": : OTHER: Missing field: FileDescriptorProto.name.\n"); 3074 } 3075 3076 TEST_F(ValidationErrorTest, DupeDependency) { 3077 BuildFile("name: \"foo.proto\""); 3078 BuildFileWithErrors( 3079 "name: \"bar.proto\" " 3080 "dependency: \"foo.proto\" " 3081 "dependency: \"foo.proto\" ", 3082 3083 "bar.proto: bar.proto: OTHER: Import \"foo.proto\" was listed twice.\n"); 3084 } 3085 3086 TEST_F(ValidationErrorTest, UnknownDependency) { 3087 BuildFileWithErrors( 3088 "name: \"bar.proto\" " 3089 "dependency: \"foo.proto\" ", 3090 3091 "bar.proto: bar.proto: OTHER: Import \"foo.proto\" has not been loaded.\n"); 3092 } 3093 3094 TEST_F(ValidationErrorTest, InvalidPublicDependencyIndex) { 3095 BuildFile("name: \"foo.proto\""); 3096 BuildFileWithErrors( 3097 "name: \"bar.proto\" " 3098 "dependency: \"foo.proto\" " 3099 "public_dependency: 1", 3100 "bar.proto: bar.proto: OTHER: Invalid public dependency index.\n"); 3101 } 3102 3103 TEST_F(ValidationErrorTest, ForeignUnimportedPackageNoCrash) { 3104 // Used to crash: If we depend on a non-existent file and then refer to a 3105 // package defined in a file that we didn't import, and that package is 3106 // nested within a parent package which this file is also in, and we don't 3107 // include that parent package in the name (i.e. we do a relative lookup)... 3108 // Yes, really. 3109 BuildFile( 3110 "name: 'foo.proto' " 3111 "package: 'outer.foo' "); 3112 BuildFileWithErrors( 3113 "name: 'bar.proto' " 3114 "dependency: 'baz.proto' " 3115 "package: 'outer.bar' " 3116 "message_type { " 3117 " name: 'Bar' " 3118 " field { name:'bar' number:1 label:LABEL_OPTIONAL type_name:'foo.Foo' }" 3119 "}", 3120 3121 "bar.proto: bar.proto: OTHER: Import \"baz.proto\" has not been loaded.\n" 3122 "bar.proto: outer.bar.Bar.bar: TYPE: \"outer.foo\" seems to be defined in " 3123 "\"foo.proto\", which is not imported by \"bar.proto\". To use it here, " 3124 "please add the necessary import.\n"); 3125 } 3126 3127 TEST_F(ValidationErrorTest, DupeFile) { 3128 BuildFile( 3129 "name: \"foo.proto\" " 3130 "message_type { name: \"Foo\" }"); 3131 // Note: We should *not* get redundant errors about "Foo" already being 3132 // defined. 3133 BuildFileWithErrors( 3134 "name: \"foo.proto\" " 3135 "message_type { name: \"Foo\" } " 3136 // Add another type so that the files aren't identical (in which case there 3137 // would be no error). 3138 "enum_type { name: \"Bar\" }", 3139 3140 "foo.proto: foo.proto: OTHER: A file with this name is already in the " 3141 "pool.\n"); 3142 } 3143 3144 TEST_F(ValidationErrorTest, FieldInExtensionRange) { 3145 BuildFileWithErrors( 3146 "name: \"foo.proto\" " 3147 "message_type {" 3148 " name: \"Foo\"" 3149 " field { name: \"foo\" number: 9 label:LABEL_OPTIONAL type:TYPE_INT32 }" 3150 " field { name: \"bar\" number: 10 label:LABEL_OPTIONAL type:TYPE_INT32 }" 3151 " field { name: \"baz\" number: 19 label:LABEL_OPTIONAL type:TYPE_INT32 }" 3152 " field { name: \"qux\" number: 20 label:LABEL_OPTIONAL type:TYPE_INT32 }" 3153 " extension_range { start: 10 end: 20 }" 3154 "}", 3155 3156 "foo.proto: Foo.bar: NUMBER: Extension range 10 to 19 includes field " 3157 "\"bar\" (10).\n" 3158 "foo.proto: Foo.baz: NUMBER: Extension range 10 to 19 includes field " 3159 "\"baz\" (19).\n"); 3160 } 3161 3162 TEST_F(ValidationErrorTest, OverlappingExtensionRanges) { 3163 BuildFileWithErrors( 3164 "name: \"foo.proto\" " 3165 "message_type {" 3166 " name: \"Foo\"" 3167 " extension_range { start: 10 end: 20 }" 3168 " extension_range { start: 20 end: 30 }" 3169 " extension_range { start: 19 end: 21 }" 3170 "}", 3171 3172 "foo.proto: Foo: NUMBER: Extension range 19 to 20 overlaps with " 3173 "already-defined range 10 to 19.\n" 3174 "foo.proto: Foo: NUMBER: Extension range 19 to 20 overlaps with " 3175 "already-defined range 20 to 29.\n"); 3176 } 3177 3178 TEST_F(ValidationErrorTest, InvalidDefaults) { 3179 BuildFileWithErrors( 3180 "name: \"foo.proto\" " 3181 "message_type {" 3182 " name: \"Foo\"" 3183 3184 // Invalid number. 3185 " field { name: \"foo\" number: 1 label: LABEL_OPTIONAL type: TYPE_INT32" 3186 " default_value: \"abc\" }" 3187 3188 // Empty default value. 3189 " field { name: \"bar\" number: 2 label: LABEL_OPTIONAL type: TYPE_INT32" 3190 " default_value: \"\" }" 3191 3192 // Invalid boolean. 3193 " field { name: \"baz\" number: 3 label: LABEL_OPTIONAL type: TYPE_BOOL" 3194 " default_value: \"abc\" }" 3195 3196 // Messages can't have defaults. 3197 " field { name: \"qux\" number: 4 label: LABEL_OPTIONAL type: TYPE_MESSAGE" 3198 " default_value: \"abc\" type_name: \"Foo\" }" 3199 3200 // Same thing, but we don't know that this field has message type until 3201 // we look up the type name. 3202 " field { name: \"quux\" number: 5 label: LABEL_OPTIONAL" 3203 " default_value: \"abc\" type_name: \"Foo\" }" 3204 3205 // Repeateds can't have defaults. 3206 " field { name: \"corge\" number: 6 label: LABEL_REPEATED type: TYPE_INT32" 3207 " default_value: \"1\" }" 3208 "}", 3209 3210 "foo.proto: Foo.foo: DEFAULT_VALUE: Couldn't parse default value \"abc\".\n" 3211 "foo.proto: Foo.bar: DEFAULT_VALUE: Couldn't parse default value \"\".\n" 3212 "foo.proto: Foo.baz: DEFAULT_VALUE: Boolean default must be true or " 3213 "false.\n" 3214 "foo.proto: Foo.qux: DEFAULT_VALUE: Messages can't have default values.\n" 3215 "foo.proto: Foo.corge: DEFAULT_VALUE: Repeated fields can't have default " 3216 "values.\n" 3217 // This ends up being reported later because the error is detected at 3218 // cross-linking time. 3219 "foo.proto: Foo.quux: DEFAULT_VALUE: Messages can't have default " 3220 "values.\n"); 3221 } 3222 3223 TEST_F(ValidationErrorTest, NegativeFieldNumber) { 3224 BuildFileWithErrors( 3225 "name: \"foo.proto\" " 3226 "message_type {" 3227 " name: \"Foo\"" 3228 " field { name: \"foo\" number: -1 label:LABEL_OPTIONAL type:TYPE_INT32 }" 3229 "}", 3230 3231 "foo.proto: Foo.foo: NUMBER: Field numbers must be positive integers.\n"); 3232 } 3233 3234 TEST_F(ValidationErrorTest, HugeFieldNumber) { 3235 BuildFileWithErrors( 3236 "name: \"foo.proto\" " 3237 "message_type {" 3238 " name: \"Foo\"" 3239 " field { name: \"foo\" number: 0x70000000 " 3240 " label:LABEL_OPTIONAL type:TYPE_INT32 }" 3241 "}", 3242 3243 "foo.proto: Foo.foo: NUMBER: Field numbers cannot be greater than " 3244 "536870911.\n"); 3245 } 3246 3247 TEST_F(ValidationErrorTest, ReservedFieldNumber) { 3248 BuildFileWithErrors( 3249 "name: \"foo.proto\" " 3250 "message_type {" 3251 " name: \"Foo\"" 3252 " field {name:\"foo\" number: 18999 label:LABEL_OPTIONAL type:TYPE_INT32 }" 3253 " field {name:\"bar\" number: 19000 label:LABEL_OPTIONAL type:TYPE_INT32 }" 3254 " field {name:\"baz\" number: 19999 label:LABEL_OPTIONAL type:TYPE_INT32 }" 3255 " field {name:\"qux\" number: 20000 label:LABEL_OPTIONAL type:TYPE_INT32 }" 3256 "}", 3257 3258 "foo.proto: Foo.bar: NUMBER: Field numbers 19000 through 19999 are " 3259 "reserved for the protocol buffer library implementation.\n" 3260 "foo.proto: Foo.baz: NUMBER: Field numbers 19000 through 19999 are " 3261 "reserved for the protocol buffer library implementation.\n"); 3262 } 3263 3264 TEST_F(ValidationErrorTest, ExtensionMissingExtendee) { 3265 BuildFileWithErrors( 3266 "name: \"foo.proto\" " 3267 "message_type {" 3268 " name: \"Foo\"" 3269 " extension { name: \"foo\" number: 1 label: LABEL_OPTIONAL" 3270 " type_name: \"Foo\" }" 3271 "}", 3272 3273 "foo.proto: Foo.foo: EXTENDEE: FieldDescriptorProto.extendee not set for " 3274 "extension field.\n"); 3275 } 3276 3277 TEST_F(ValidationErrorTest, NonExtensionWithExtendee) { 3278 BuildFileWithErrors( 3279 "name: \"foo.proto\" " 3280 "message_type {" 3281 " name: \"Bar\"" 3282 " extension_range { start: 1 end: 2 }" 3283 "}" 3284 "message_type {" 3285 " name: \"Foo\"" 3286 " field { name: \"foo\" number: 1 label: LABEL_OPTIONAL" 3287 " type_name: \"Foo\" extendee: \"Bar\" }" 3288 "}", 3289 3290 "foo.proto: Foo.foo: EXTENDEE: FieldDescriptorProto.extendee set for " 3291 "non-extension field.\n"); 3292 } 3293 3294 TEST_F(ValidationErrorTest, FieldOneofIndexTooLarge) { 3295 BuildFileWithErrors( 3296 "name: \"foo.proto\" " 3297 "message_type {" 3298 " name: \"Foo\"" 3299 " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_INT32 " 3300 " oneof_index: 1 }" 3301 " field { name:\"dummy\" number:2 label:LABEL_OPTIONAL type:TYPE_INT32 " 3302 " oneof_index: 0 }" 3303 " oneof_decl { name:\"bar\" }" 3304 "}", 3305 3306 "foo.proto: Foo.foo: OTHER: FieldDescriptorProto.oneof_index 1 is out of " 3307 "range for type \"Foo\".\n"); 3308 } 3309 3310 TEST_F(ValidationErrorTest, FieldOneofIndexNegative) { 3311 BuildFileWithErrors( 3312 "name: \"foo.proto\" " 3313 "message_type {" 3314 " name: \"Foo\"" 3315 " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_INT32 " 3316 " oneof_index: -1 }" 3317 " field { name:\"dummy\" number:2 label:LABEL_OPTIONAL type:TYPE_INT32 " 3318 " oneof_index: 0 }" 3319 " oneof_decl { name:\"bar\" }" 3320 "}", 3321 3322 "foo.proto: Foo.foo: OTHER: FieldDescriptorProto.oneof_index -1 is out of " 3323 "range for type \"Foo\".\n"); 3324 } 3325 3326 TEST_F(ValidationErrorTest, FieldNumberConflict) { 3327 BuildFileWithErrors( 3328 "name: \"foo.proto\" " 3329 "message_type {" 3330 " name: \"Foo\"" 3331 " field { name: \"foo\" number: 1 label:LABEL_OPTIONAL type:TYPE_INT32 }" 3332 " field { name: \"bar\" number: 1 label:LABEL_OPTIONAL type:TYPE_INT32 }" 3333 "}", 3334 3335 "foo.proto: Foo.bar: NUMBER: Field number 1 has already been used in " 3336 "\"Foo\" by field \"foo\".\n"); 3337 } 3338 3339 TEST_F(ValidationErrorTest, BadMessageSetExtensionType) { 3340 BuildFileWithErrors( 3341 "name: \"foo.proto\" " 3342 "message_type {" 3343 " name: \"MessageSet\"" 3344 " options { message_set_wire_format: true }" 3345 " extension_range { start: 4 end: 5 }" 3346 "}" 3347 "message_type {" 3348 " name: \"Foo\"" 3349 " extension { name:\"foo\" number:4 label:LABEL_OPTIONAL type:TYPE_INT32" 3350 " extendee: \"MessageSet\" }" 3351 "}", 3352 3353 "foo.proto: Foo.foo: TYPE: Extensions of MessageSets must be optional " 3354 "messages.\n"); 3355 } 3356 3357 TEST_F(ValidationErrorTest, BadMessageSetExtensionLabel) { 3358 BuildFileWithErrors( 3359 "name: \"foo.proto\" " 3360 "message_type {" 3361 " name: \"MessageSet\"" 3362 " options { message_set_wire_format: true }" 3363 " extension_range { start: 4 end: 5 }" 3364 "}" 3365 "message_type {" 3366 " name: \"Foo\"" 3367 " extension { name:\"foo\" number:4 label:LABEL_REPEATED type:TYPE_MESSAGE" 3368 " type_name: \"Foo\" extendee: \"MessageSet\" }" 3369 "}", 3370 3371 "foo.proto: Foo.foo: TYPE: Extensions of MessageSets must be optional " 3372 "messages.\n"); 3373 } 3374 3375 TEST_F(ValidationErrorTest, FieldInMessageSet) { 3376 BuildFileWithErrors( 3377 "name: \"foo.proto\" " 3378 "message_type {" 3379 " name: \"Foo\"" 3380 " options { message_set_wire_format: true }" 3381 " field { name: \"foo\" number: 1 label:LABEL_OPTIONAL type:TYPE_INT32 }" 3382 "}", 3383 3384 "foo.proto: Foo.foo: NAME: MessageSets cannot have fields, only " 3385 "extensions.\n"); 3386 } 3387 3388 TEST_F(ValidationErrorTest, NegativeExtensionRangeNumber) { 3389 BuildFileWithErrors( 3390 "name: \"foo.proto\" " 3391 "message_type {" 3392 " name: \"Foo\"" 3393 " extension_range { start: -10 end: -1 }" 3394 "}", 3395 3396 "foo.proto: Foo: NUMBER: Extension numbers must be positive integers.\n"); 3397 } 3398 3399 TEST_F(ValidationErrorTest, HugeExtensionRangeNumber) { 3400 BuildFileWithErrors( 3401 "name: \"foo.proto\" " 3402 "message_type {" 3403 " name: \"Foo\"" 3404 " extension_range { start: 1 end: 0x70000000 }" 3405 "}", 3406 3407 "foo.proto: Foo: NUMBER: Extension numbers cannot be greater than " 3408 "536870911.\n"); 3409 } 3410 3411 TEST_F(ValidationErrorTest, ExtensionRangeEndBeforeStart) { 3412 BuildFileWithErrors( 3413 "name: \"foo.proto\" " 3414 "message_type {" 3415 " name: \"Foo\"" 3416 " extension_range { start: 10 end: 10 }" 3417 " extension_range { start: 10 end: 5 }" 3418 "}", 3419 3420 "foo.proto: Foo: NUMBER: Extension range end number must be greater than " 3421 "start number.\n" 3422 "foo.proto: Foo: NUMBER: Extension range end number must be greater than " 3423 "start number.\n"); 3424 } 3425 3426 TEST_F(ValidationErrorTest, EmptyEnum) { 3427 BuildFileWithErrors( 3428 "name: \"foo.proto\" " 3429 "enum_type { name: \"Foo\" }" 3430 // Also use the empty enum in a message to make sure there are no crashes 3431 // during validation (possible if the code attempts to derive a default 3432 // value for the field). 3433 "message_type {" 3434 " name: \"Bar\"" 3435 " field { name: \"foo\" number: 1 label:LABEL_OPTIONAL type_name:\"Foo\" }" 3436 " field { name: \"bar\" number: 2 label:LABEL_OPTIONAL type_name:\"Foo\" " 3437 " default_value: \"NO_SUCH_VALUE\" }" 3438 "}", 3439 3440 "foo.proto: Foo: NAME: Enums must contain at least one value.\n" 3441 "foo.proto: Bar.bar: DEFAULT_VALUE: Enum type \"Foo\" has no value named " 3442 "\"NO_SUCH_VALUE\".\n"); 3443 } 3444 3445 TEST_F(ValidationErrorTest, UndefinedExtendee) { 3446 BuildFileWithErrors( 3447 "name: \"foo.proto\" " 3448 "message_type {" 3449 " name: \"Foo\"" 3450 " extension { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_INT32" 3451 " extendee: \"Bar\" }" 3452 "}", 3453 3454 "foo.proto: Foo.foo: EXTENDEE: \"Bar\" is not defined.\n"); 3455 } 3456 3457 TEST_F(ValidationErrorTest, NonMessageExtendee) { 3458 BuildFileWithErrors( 3459 "name: \"foo.proto\" " 3460 "enum_type { name: \"Bar\" value { name:\"DUMMY\" number:0 } }" 3461 "message_type {" 3462 " name: \"Foo\"" 3463 " extension { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_INT32" 3464 " extendee: \"Bar\" }" 3465 "}", 3466 3467 "foo.proto: Foo.foo: EXTENDEE: \"Bar\" is not a message type.\n"); 3468 } 3469 3470 TEST_F(ValidationErrorTest, NotAnExtensionNumber) { 3471 BuildFileWithErrors( 3472 "name: \"foo.proto\" " 3473 "message_type {" 3474 " name: \"Bar\"" 3475 "}" 3476 "message_type {" 3477 " name: \"Foo\"" 3478 " extension { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_INT32" 3479 " extendee: \"Bar\" }" 3480 "}", 3481 3482 "foo.proto: Foo.foo: NUMBER: \"Bar\" does not declare 1 as an extension " 3483 "number.\n"); 3484 } 3485 3486 TEST_F(ValidationErrorTest, RequiredExtension) { 3487 BuildFileWithErrors( 3488 "name: \"foo.proto\" " 3489 "message_type {" 3490 " name: \"Bar\"" 3491 " extension_range { start: 1000 end: 10000 }" 3492 "}" 3493 "message_type {" 3494 " name: \"Foo\"" 3495 " extension {" 3496 " name:\"foo\"" 3497 " number:1000" 3498 " label:LABEL_REQUIRED" 3499 " type:TYPE_INT32" 3500 " extendee: \"Bar\"" 3501 " }" 3502 "}", 3503 3504 "foo.proto: Foo.foo: TYPE: Message extensions cannot have required " 3505 "fields.\n"); 3506 } 3507 3508 TEST_F(ValidationErrorTest, UndefinedFieldType) { 3509 BuildFileWithErrors( 3510 "name: \"foo.proto\" " 3511 "message_type {" 3512 " name: \"Foo\"" 3513 " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type_name:\"Bar\" }" 3514 "}", 3515 3516 "foo.proto: Foo.foo: TYPE: \"Bar\" is not defined.\n"); 3517 } 3518 3519 TEST_F(ValidationErrorTest, UndefinedFieldTypeWithDefault) { 3520 // See b/12533582. Previously this failed because the default value was not 3521 // accepted by the parser, which assumed an enum type, leading to an unclear 3522 // error message. We want this input to yield a validation error instead, 3523 // since the unknown type is the primary problem. 3524 BuildFileWithErrors( 3525 "name: \"foo.proto\" " 3526 "message_type {" 3527 " name: \"Foo\"" 3528 " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type_name:\"int\" " 3529 " default_value:\"1\" }" 3530 "}", 3531 3532 "foo.proto: Foo.foo: TYPE: \"int\" is not defined.\n"); 3533 } 3534 3535 TEST_F(ValidationErrorTest, UndefinedNestedFieldType) { 3536 BuildFileWithErrors( 3537 "name: \"foo.proto\" " 3538 "message_type {" 3539 " name: \"Foo\"" 3540 " nested_type { name:\"Baz\" }" 3541 " field { name:\"foo\" number:1" 3542 " label:LABEL_OPTIONAL" 3543 " type_name:\"Foo.Baz.Bar\" }" 3544 "}", 3545 3546 "foo.proto: Foo.foo: TYPE: \"Foo.Baz.Bar\" is not defined.\n"); 3547 } 3548 3549 TEST_F(ValidationErrorTest, FieldTypeDefinedInUndeclaredDependency) { 3550 BuildFile( 3551 "name: \"bar.proto\" " 3552 "message_type { name: \"Bar\" } "); 3553 3554 BuildFileWithErrors( 3555 "name: \"foo.proto\" " 3556 "message_type {" 3557 " name: \"Foo\"" 3558 " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type_name:\"Bar\" }" 3559 "}", 3560 "foo.proto: Foo.foo: TYPE: \"Bar\" seems to be defined in \"bar.proto\", " 3561 "which is not imported by \"foo.proto\". To use it here, please add the " 3562 "necessary import.\n"); 3563 } 3564 3565 TEST_F(ValidationErrorTest, FieldTypeDefinedInIndirectDependency) { 3566 // Test for hidden dependencies. 3567 // 3568 // // bar.proto 3569 // message Bar{} 3570 // 3571 // // forward.proto 3572 // import "bar.proto" 3573 // 3574 // // foo.proto 3575 // import "forward.proto" 3576 // message Foo { 3577 // optional Bar foo = 1; // Error, needs to import bar.proto explicitly. 3578 // } 3579 // 3580 BuildFile( 3581 "name: \"bar.proto\" " 3582 "message_type { name: \"Bar\" }"); 3583 3584 BuildFile( 3585 "name: \"forward.proto\"" 3586 "dependency: \"bar.proto\""); 3587 3588 BuildFileWithErrors( 3589 "name: \"foo.proto\" " 3590 "dependency: \"forward.proto\" " 3591 "message_type {" 3592 " name: \"Foo\"" 3593 " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type_name:\"Bar\" }" 3594 "}", 3595 "foo.proto: Foo.foo: TYPE: \"Bar\" seems to be defined in \"bar.proto\", " 3596 "which is not imported by \"foo.proto\". To use it here, please add the " 3597 "necessary import.\n"); 3598 } 3599 3600 TEST_F(ValidationErrorTest, FieldTypeDefinedInPublicDependency) { 3601 // Test for public dependencies. 3602 // 3603 // // bar.proto 3604 // message Bar{} 3605 // 3606 // // forward.proto 3607 // import public "bar.proto" 3608 // 3609 // // foo.proto 3610 // import "forward.proto" 3611 // message Foo { 3612 // optional Bar foo = 1; // Correct. "bar.proto" is public imported into 3613 // // forward.proto, so when "foo.proto" imports 3614 // // "forward.proto", it imports "bar.proto" too. 3615 // } 3616 // 3617 BuildFile( 3618 "name: \"bar.proto\" " 3619 "message_type { name: \"Bar\" }"); 3620 3621 BuildFile( 3622 "name: \"forward.proto\"" 3623 "dependency: \"bar.proto\" " 3624 "public_dependency: 0"); 3625 3626 BuildFile( 3627 "name: \"foo.proto\" " 3628 "dependency: \"forward.proto\" " 3629 "message_type {" 3630 " name: \"Foo\"" 3631 " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type_name:\"Bar\" }" 3632 "}"); 3633 } 3634 3635 TEST_F(ValidationErrorTest, FieldTypeDefinedInTransitivePublicDependency) { 3636 // Test for public dependencies. 3637 // 3638 // // bar.proto 3639 // message Bar{} 3640 // 3641 // // forward.proto 3642 // import public "bar.proto" 3643 // 3644 // // forward2.proto 3645 // import public "forward.proto" 3646 // 3647 // // foo.proto 3648 // import "forward2.proto" 3649 // message Foo { 3650 // optional Bar foo = 1; // Correct, public imports are transitive. 3651 // } 3652 // 3653 BuildFile( 3654 "name: \"bar.proto\" " 3655 "message_type { name: \"Bar\" }"); 3656 3657 BuildFile( 3658 "name: \"forward.proto\"" 3659 "dependency: \"bar.proto\" " 3660 "public_dependency: 0"); 3661 3662 BuildFile( 3663 "name: \"forward2.proto\"" 3664 "dependency: \"forward.proto\" " 3665 "public_dependency: 0"); 3666 3667 BuildFile( 3668 "name: \"foo.proto\" " 3669 "dependency: \"forward2.proto\" " 3670 "message_type {" 3671 " name: \"Foo\"" 3672 " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type_name:\"Bar\" }" 3673 "}"); 3674 } 3675 3676 TEST_F(ValidationErrorTest, 3677 FieldTypeDefinedInPrivateDependencyOfPublicDependency) { 3678 // Test for public dependencies. 3679 // 3680 // // bar.proto 3681 // message Bar{} 3682 // 3683 // // forward.proto 3684 // import "bar.proto" 3685 // 3686 // // forward2.proto 3687 // import public "forward.proto" 3688 // 3689 // // foo.proto 3690 // import "forward2.proto" 3691 // message Foo { 3692 // optional Bar foo = 1; // Error, the "bar.proto" is not public imported 3693 // // into "forward.proto", so will not be imported 3694 // // into either "forward2.proto" or "foo.proto". 3695 // } 3696 // 3697 BuildFile( 3698 "name: \"bar.proto\" " 3699 "message_type { name: \"Bar\" }"); 3700 3701 BuildFile( 3702 "name: \"forward.proto\"" 3703 "dependency: \"bar.proto\""); 3704 3705 BuildFile( 3706 "name: \"forward2.proto\"" 3707 "dependency: \"forward.proto\" " 3708 "public_dependency: 0"); 3709 3710 BuildFileWithErrors( 3711 "name: \"foo.proto\" " 3712 "dependency: \"forward2.proto\" " 3713 "message_type {" 3714 " name: \"Foo\"" 3715 " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type_name:\"Bar\" }" 3716 "}", 3717 "foo.proto: Foo.foo: TYPE: \"Bar\" seems to be defined in \"bar.proto\", " 3718 "which is not imported by \"foo.proto\". To use it here, please add the " 3719 "necessary import.\n"); 3720 } 3721 3722 3723 TEST_F(ValidationErrorTest, SearchMostLocalFirst) { 3724 // The following should produce an error that Bar.Baz is resolved but 3725 // not defined: 3726 // message Bar { message Baz {} } 3727 // message Foo { 3728 // message Bar { 3729 // // Placing "message Baz{}" here, or removing Foo.Bar altogether, 3730 // // would fix the error. 3731 // } 3732 // optional Bar.Baz baz = 1; 3733 // } 3734 // An one point the lookup code incorrectly did not produce an error in this 3735 // case, because when looking for Bar.Baz, it would try "Foo.Bar.Baz" first, 3736 // fail, and ten try "Bar.Baz" and succeed, even though "Bar" should actually 3737 // refer to the inner Bar, not the outer one. 3738 BuildFileWithErrors( 3739 "name: \"foo.proto\" " 3740 "message_type {" 3741 " name: \"Bar\"" 3742 " nested_type { name: \"Baz\" }" 3743 "}" 3744 "message_type {" 3745 " name: \"Foo\"" 3746 " nested_type { name: \"Bar\" }" 3747 " field { name:\"baz\" number:1 label:LABEL_OPTIONAL" 3748 " type_name:\"Bar.Baz\" }" 3749 "}", 3750 3751 "foo.proto: Foo.baz: TYPE: \"Bar.Baz\" is resolved to \"Foo.Bar.Baz\"," 3752 " which is not defined. The innermost scope is searched first in name " 3753 "resolution. Consider using a leading '.'(i.e., \".Bar.Baz\") to start " 3754 "from the outermost scope.\n"); 3755 } 3756 3757 TEST_F(ValidationErrorTest, SearchMostLocalFirst2) { 3758 // This test would find the most local "Bar" first, and does, but 3759 // proceeds to find the outer one because the inner one's not an 3760 // aggregate. 3761 BuildFile( 3762 "name: \"foo.proto\" " 3763 "message_type {" 3764 " name: \"Bar\"" 3765 " nested_type { name: \"Baz\" }" 3766 "}" 3767 "message_type {" 3768 " name: \"Foo\"" 3769 " field { name: \"Bar\" number:1 type:TYPE_BYTES } " 3770 " field { name:\"baz\" number:2 label:LABEL_OPTIONAL" 3771 " type_name:\"Bar.Baz\" }" 3772 "}"); 3773 } 3774 3775 TEST_F(ValidationErrorTest, PackageOriginallyDeclaredInTransitiveDependent) { 3776 // Imagine we have the following: 3777 // 3778 // foo.proto: 3779 // package foo.bar; 3780 // bar.proto: 3781 // package foo.bar; 3782 // import "foo.proto"; 3783 // message Bar {} 3784 // baz.proto: 3785 // package foo; 3786 // import "bar.proto" 3787 // message Baz { optional bar.Bar qux = 1; } 3788 // 3789 // When validating baz.proto, we will look up "bar.Bar". As part of this 3790 // lookup, we first lookup "bar" then try to find "Bar" within it. "bar" 3791 // should resolve to "foo.bar". Note, though, that "foo.bar" was originally 3792 // defined in foo.proto, which is not a direct dependency of baz.proto. The 3793 // implementation of FindSymbol() normally only returns symbols in direct 3794 // dependencies, not indirect ones. This test insures that this does not 3795 // prevent it from finding "foo.bar". 3796 3797 BuildFile( 3798 "name: \"foo.proto\" " 3799 "package: \"foo.bar\" "); 3800 BuildFile( 3801 "name: \"bar.proto\" " 3802 "package: \"foo.bar\" " 3803 "dependency: \"foo.proto\" " 3804 "message_type { name: \"Bar\" }"); 3805 BuildFile( 3806 "name: \"baz.proto\" " 3807 "package: \"foo\" " 3808 "dependency: \"bar.proto\" " 3809 "message_type { " 3810 " name: \"Baz\" " 3811 " field { name:\"qux\" number:1 label:LABEL_OPTIONAL " 3812 " type_name:\"bar.Bar\" }" 3813 "}"); 3814 } 3815 3816 TEST_F(ValidationErrorTest, FieldTypeNotAType) { 3817 BuildFileWithErrors( 3818 "name: \"foo.proto\" " 3819 "message_type {" 3820 " name: \"Foo\"" 3821 " field { name:\"foo\" number:1 label:LABEL_OPTIONAL " 3822 " type_name:\".Foo.bar\" }" 3823 " field { name:\"bar\" number:2 label:LABEL_OPTIONAL type:TYPE_INT32 }" 3824 "}", 3825 3826 "foo.proto: Foo.foo: TYPE: \".Foo.bar\" is not a type.\n"); 3827 } 3828 3829 TEST_F(ValidationErrorTest, RelativeFieldTypeNotAType) { 3830 BuildFileWithErrors( 3831 "name: \"foo.proto\" " 3832 "message_type {" 3833 " nested_type {" 3834 " name: \"Bar\"" 3835 " field { name:\"Baz\" number:2 label:LABEL_OPTIONAL type:TYPE_INT32 }" 3836 " }" 3837 " name: \"Foo\"" 3838 " field { name:\"foo\" number:1 label:LABEL_OPTIONAL " 3839 " type_name:\"Bar.Baz\" }" 3840 "}", 3841 "foo.proto: Foo.foo: TYPE: \"Bar.Baz\" is not a type.\n"); 3842 } 3843 3844 TEST_F(ValidationErrorTest, FieldTypeMayBeItsName) { 3845 BuildFile( 3846 "name: \"foo.proto\" " 3847 "message_type {" 3848 " name: \"Bar\"" 3849 "}" 3850 "message_type {" 3851 " name: \"Foo\"" 3852 " field { name:\"Bar\" number:1 label:LABEL_OPTIONAL type_name:\"Bar\" }" 3853 "}"); 3854 } 3855 3856 TEST_F(ValidationErrorTest, EnumFieldTypeIsMessage) { 3857 BuildFileWithErrors( 3858 "name: \"foo.proto\" " 3859 "message_type { name: \"Bar\" } " 3860 "message_type {" 3861 " name: \"Foo\"" 3862 " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_ENUM" 3863 " type_name:\"Bar\" }" 3864 "}", 3865 3866 "foo.proto: Foo.foo: TYPE: \"Bar\" is not an enum type.\n"); 3867 } 3868 3869 TEST_F(ValidationErrorTest, MessageFieldTypeIsEnum) { 3870 BuildFileWithErrors( 3871 "name: \"foo.proto\" " 3872 "enum_type { name: \"Bar\" value { name:\"DUMMY\" number:0 } } " 3873 "message_type {" 3874 " name: \"Foo\"" 3875 " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_MESSAGE" 3876 " type_name:\"Bar\" }" 3877 "}", 3878 3879 "foo.proto: Foo.foo: TYPE: \"Bar\" is not a message type.\n"); 3880 } 3881 3882 TEST_F(ValidationErrorTest, BadEnumDefaultValue) { 3883 BuildFileWithErrors( 3884 "name: \"foo.proto\" " 3885 "enum_type { name: \"Bar\" value { name:\"DUMMY\" number:0 } } " 3886 "message_type {" 3887 " name: \"Foo\"" 3888 " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type_name:\"Bar\"" 3889 " default_value:\"NO_SUCH_VALUE\" }" 3890 "}", 3891 3892 "foo.proto: Foo.foo: DEFAULT_VALUE: Enum type \"Bar\" has no value named " 3893 "\"NO_SUCH_VALUE\".\n"); 3894 } 3895 3896 TEST_F(ValidationErrorTest, EnumDefaultValueIsInteger) { 3897 BuildFileWithErrors( 3898 "name: \"foo.proto\" " 3899 "enum_type { name: \"Bar\" value { name:\"DUMMY\" number:0 } } " 3900 "message_type {" 3901 " name: \"Foo\"" 3902 " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type_name:\"Bar\"" 3903 " default_value:\"0\" }" 3904 "}", 3905 3906 "foo.proto: Foo.foo: DEFAULT_VALUE: Default value for an enum field must " 3907 "be an identifier.\n"); 3908 } 3909 3910 TEST_F(ValidationErrorTest, PrimitiveWithTypeName) { 3911 BuildFileWithErrors( 3912 "name: \"foo.proto\" " 3913 "message_type {" 3914 " name: \"Foo\"" 3915 " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_INT32" 3916 " type_name:\"Foo\" }" 3917 "}", 3918 3919 "foo.proto: Foo.foo: TYPE: Field with primitive type has type_name.\n"); 3920 } 3921 3922 TEST_F(ValidationErrorTest, NonPrimitiveWithoutTypeName) { 3923 BuildFileWithErrors( 3924 "name: \"foo.proto\" " 3925 "message_type {" 3926 " name: \"Foo\"" 3927 " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_MESSAGE }" 3928 "}", 3929 3930 "foo.proto: Foo.foo: TYPE: Field with message or enum type missing " 3931 "type_name.\n"); 3932 } 3933 3934 TEST_F(ValidationErrorTest, OneofWithNoFields) { 3935 BuildFileWithErrors( 3936 "name: \"foo.proto\" " 3937 "message_type {" 3938 " name: \"Foo\"" 3939 " oneof_decl { name:\"bar\" }" 3940 "}", 3941 3942 "foo.proto: Foo.bar: NAME: Oneof must have at least one field.\n"); 3943 } 3944 3945 TEST_F(ValidationErrorTest, OneofLabelMismatch) { 3946 BuildFileWithErrors( 3947 "name: \"foo.proto\" " 3948 "message_type {" 3949 " name: \"Foo\"" 3950 " field { name:\"foo\" number:1 label:LABEL_REPEATED type:TYPE_INT32 " 3951 " oneof_index:0 }" 3952 " oneof_decl { name:\"bar\" }" 3953 "}", 3954 3955 "foo.proto: Foo.foo: NAME: Fields of oneofs must themselves have label " 3956 "LABEL_OPTIONAL.\n"); 3957 } 3958 3959 TEST_F(ValidationErrorTest, InputTypeNotDefined) { 3960 BuildFileWithErrors( 3961 "name: \"foo.proto\" " 3962 "message_type { name: \"Foo\" } " 3963 "service {" 3964 " name: \"TestService\"" 3965 " method { name: \"A\" input_type: \"Bar\" output_type: \"Foo\" }" 3966 "}", 3967 3968 "foo.proto: TestService.A: INPUT_TYPE: \"Bar\" is not defined.\n" 3969 ); 3970 } 3971 3972 TEST_F(ValidationErrorTest, InputTypeNotAMessage) { 3973 BuildFileWithErrors( 3974 "name: \"foo.proto\" " 3975 "message_type { name: \"Foo\" } " 3976 "enum_type { name: \"Bar\" value { name:\"DUMMY\" number:0 } } " 3977 "service {" 3978 " name: \"TestService\"" 3979 " method { name: \"A\" input_type: \"Bar\" output_type: \"Foo\" }" 3980 "}", 3981 3982 "foo.proto: TestService.A: INPUT_TYPE: \"Bar\" is not a message type.\n" 3983 ); 3984 } 3985 3986 TEST_F(ValidationErrorTest, OutputTypeNotDefined) { 3987 BuildFileWithErrors( 3988 "name: \"foo.proto\" " 3989 "message_type { name: \"Foo\" } " 3990 "service {" 3991 " name: \"TestService\"" 3992 " method { name: \"A\" input_type: \"Foo\" output_type: \"Bar\" }" 3993 "}", 3994 3995 "foo.proto: TestService.A: OUTPUT_TYPE: \"Bar\" is not defined.\n" 3996 ); 3997 } 3998 3999 TEST_F(ValidationErrorTest, OutputTypeNotAMessage) { 4000 BuildFileWithErrors( 4001 "name: \"foo.proto\" " 4002 "message_type { name: \"Foo\" } " 4003 "enum_type { name: \"Bar\" value { name:\"DUMMY\" number:0 } } " 4004 "service {" 4005 " name: \"TestService\"" 4006 " method { name: \"A\" input_type: \"Foo\" output_type: \"Bar\" }" 4007 "}", 4008 4009 "foo.proto: TestService.A: OUTPUT_TYPE: \"Bar\" is not a message type.\n" 4010 ); 4011 } 4012 4013 4014 TEST_F(ValidationErrorTest, IllegalPackedField) { 4015 BuildFileWithErrors( 4016 "name: \"foo.proto\" " 4017 "message_type {\n" 4018 " name: \"Foo\"" 4019 " field { name:\"packed_string\" number:1 label:LABEL_REPEATED " 4020 " type:TYPE_STRING " 4021 " options { uninterpreted_option {" 4022 " name { name_part: \"packed\" is_extension: false }" 4023 " identifier_value: \"true\" }}}\n" 4024 " field { name:\"packed_message\" number:3 label:LABEL_REPEATED " 4025 " type_name: \"Foo\"" 4026 " options { uninterpreted_option {" 4027 " name { name_part: \"packed\" is_extension: false }" 4028 " identifier_value: \"true\" }}}\n" 4029 " field { name:\"optional_int32\" number: 4 label: LABEL_OPTIONAL " 4030 " type:TYPE_INT32 " 4031 " options { uninterpreted_option {" 4032 " name { name_part: \"packed\" is_extension: false }" 4033 " identifier_value: \"true\" }}}\n" 4034 "}", 4035 4036 "foo.proto: Foo.packed_string: TYPE: [packed = true] can only be " 4037 "specified for repeated primitive fields.\n" 4038 "foo.proto: Foo.packed_message: TYPE: [packed = true] can only be " 4039 "specified for repeated primitive fields.\n" 4040 "foo.proto: Foo.optional_int32: TYPE: [packed = true] can only be " 4041 "specified for repeated primitive fields.\n" 4042 ); 4043 } 4044 4045 TEST_F(ValidationErrorTest, OptionWrongType) { 4046 BuildFileWithErrors( 4047 "name: \"foo.proto\" " 4048 "message_type { " 4049 " name: \"TestMessage\" " 4050 " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_STRING " 4051 " options { uninterpreted_option { name { name_part: \"ctype\" " 4052 " is_extension: false }" 4053 " positive_int_value: 1 }" 4054 " }" 4055 " }" 4056 "}\n", 4057 4058 "foo.proto: TestMessage.foo: OPTION_VALUE: Value must be identifier for " 4059 "enum-valued option \"google.protobuf.FieldOptions.ctype\".\n"); 4060 } 4061 4062 TEST_F(ValidationErrorTest, OptionExtendsAtomicType) { 4063 BuildFileWithErrors( 4064 "name: \"foo.proto\" " 4065 "message_type { " 4066 " name: \"TestMessage\" " 4067 " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_STRING " 4068 " options { uninterpreted_option { name { name_part: \"ctype\" " 4069 " is_extension: false }" 4070 " name { name_part: \"foo\" " 4071 " is_extension: true }" 4072 " positive_int_value: 1 }" 4073 " }" 4074 " }" 4075 "}\n", 4076 4077 "foo.proto: TestMessage.foo: OPTION_NAME: Option \"ctype\" is an " 4078 "atomic type, not a message.\n"); 4079 } 4080 4081 TEST_F(ValidationErrorTest, DupOption) { 4082 BuildFileWithErrors( 4083 "name: \"foo.proto\" " 4084 "message_type { " 4085 " name: \"TestMessage\" " 4086 " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_UINT32 " 4087 " options { uninterpreted_option { name { name_part: \"ctype\" " 4088 " is_extension: false }" 4089 " identifier_value: \"CORD\" }" 4090 " uninterpreted_option { name { name_part: \"ctype\" " 4091 " is_extension: false }" 4092 " identifier_value: \"CORD\" }" 4093 " }" 4094 " }" 4095 "}\n", 4096 4097 "foo.proto: TestMessage.foo: OPTION_NAME: Option \"ctype\" was " 4098 "already set.\n"); 4099 } 4100 4101 TEST_F(ValidationErrorTest, InvalidOptionName) { 4102 BuildFileWithErrors( 4103 "name: \"foo.proto\" " 4104 "message_type { " 4105 " name: \"TestMessage\" " 4106 " field { name:\"foo\" number:1 label:LABEL_OPTIONAL type:TYPE_BOOL " 4107 " options { uninterpreted_option { " 4108 " name { name_part: \"uninterpreted_option\" " 4109 " is_extension: false }" 4110 " positive_int_value: 1 " 4111 " }" 4112 " }" 4113 " }" 4114 "}\n", 4115 4116 "foo.proto: TestMessage.foo: OPTION_NAME: Option must not use " 4117 "reserved name \"uninterpreted_option\".\n"); 4118 } 4119 4120 TEST_F(ValidationErrorTest, RepeatedMessageOption) { 4121 BuildDescriptorMessagesInTestPool(); 4122 4123 BuildFileWithErrors( 4124 "name: \"foo.proto\" " 4125 "dependency: \"google/protobuf/descriptor.proto\" " 4126 "message_type: { name: \"Bar\" field: { " 4127 " name: \"foo\" number: 1 label: LABEL_OPTIONAL type: TYPE_INT32 } " 4128 "} " 4129 "extension { name: \"bar\" number: 7672757 label: LABEL_REPEATED " 4130 " type: TYPE_MESSAGE type_name: \"Bar\" " 4131 " extendee: \"google.protobuf.FileOptions\" }" 4132 "options { uninterpreted_option { name { name_part: \"bar\" " 4133 " is_extension: true } " 4134 " name { name_part: \"foo\" " 4135 " is_extension: false } " 4136 " positive_int_value: 1 } }", 4137 4138 "foo.proto: foo.proto: OPTION_NAME: Option field \"(bar)\" is a " 4139 "repeated message. Repeated message options must be initialized " 4140 "using an aggregate value.\n"); 4141 } 4142 4143 TEST_F(ValidationErrorTest, ResolveUndefinedOption) { 4144 // The following should produce an eror that baz.bar is resolved but not 4145 // defined. 4146 // foo.proto: 4147 // package baz 4148 // import google/protobuf/descriptor.proto 4149 // message Bar { optional int32 foo = 1; } 4150 // extend FileOptions { optional Bar bar = 7672757; } 4151 // 4152 // qux.proto: 4153 // package qux.baz 4154 // option (baz.bar).foo = 1; 4155 // 4156 // Although "baz.bar" is already defined, the lookup code will try 4157 // "qux.baz.bar", since it's the match from the innermost scope, which will 4158 // cause a symbol not defined error. 4159 BuildDescriptorMessagesInTestPool(); 4160 4161 BuildFile( 4162 "name: \"foo.proto\" " 4163 "package: \"baz\" " 4164 "dependency: \"google/protobuf/descriptor.proto\" " 4165 "message_type: { name: \"Bar\" field: { " 4166 " name: \"foo\" number: 1 label: LABEL_OPTIONAL type: TYPE_INT32 } " 4167 "} " 4168 "extension { name: \"bar\" number: 7672757 label: LABEL_OPTIONAL " 4169 " type: TYPE_MESSAGE type_name: \"Bar\" " 4170 " extendee: \"google.protobuf.FileOptions\" }"); 4171 4172 BuildFileWithErrors( 4173 "name: \"qux.proto\" " 4174 "package: \"qux.baz\" " 4175 "options { uninterpreted_option { name { name_part: \"baz.bar\" " 4176 " is_extension: true } " 4177 " name { name_part: \"foo\" " 4178 " is_extension: false } " 4179 " positive_int_value: 1 } }", 4180 4181 "qux.proto: qux.proto: OPTION_NAME: Option \"(baz.bar)\" is resolved to " 4182 "\"(qux.baz.bar)\"," 4183 " which is not defined. The innermost scope is searched first in name " 4184 "resolution. Consider using a leading '.'(i.e., \"(.baz.bar)\") to start " 4185 "from the outermost scope.\n"); 4186 } 4187 4188 TEST_F(ValidationErrorTest, UnknownOption) { 4189 BuildFileWithErrors( 4190 "name: \"qux.proto\" " 4191 "package: \"qux.baz\" " 4192 "options { uninterpreted_option { name { name_part: \"baaz.bar\" " 4193 " is_extension: true } " 4194 " name { name_part: \"foo\" " 4195 " is_extension: false } " 4196 " positive_int_value: 1 } }", 4197 4198 "qux.proto: qux.proto: OPTION_NAME: Option \"(baaz.bar)\" unknown.\n"); 4199 } 4200 4201 TEST_F(ValidationErrorTest, CustomOptionConflictingFieldNumber) { 4202 BuildDescriptorMessagesInTestPool(); 4203 4204 BuildFileWithErrors( 4205 "name: \"foo.proto\" " 4206 "dependency: \"google/protobuf/descriptor.proto\" " 4207 "extension { name: \"foo1\" number: 7672757 label: LABEL_OPTIONAL " 4208 " type: TYPE_INT32 extendee: \"google.protobuf.FieldOptions\" }" 4209 "extension { name: \"foo2\" number: 7672757 label: LABEL_OPTIONAL " 4210 " type: TYPE_INT32 extendee: \"google.protobuf.FieldOptions\" }", 4211 4212 "foo.proto: foo2: NUMBER: Extension number 7672757 has already been used " 4213 "in \"google.protobuf.FieldOptions\" by extension \"foo1\".\n"); 4214 } 4215 4216 TEST_F(ValidationErrorTest, Int32OptionValueOutOfPositiveRange) { 4217 BuildDescriptorMessagesInTestPool(); 4218 4219 BuildFileWithErrors( 4220 "name: \"foo.proto\" " 4221 "dependency: \"google/protobuf/descriptor.proto\" " 4222 "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL " 4223 " type: TYPE_INT32 extendee: \"google.protobuf.FileOptions\" }" 4224 "options { uninterpreted_option { name { name_part: \"foo\" " 4225 " is_extension: true } " 4226 " positive_int_value: 0x80000000 } " 4227 "}", 4228 4229 "foo.proto: foo.proto: OPTION_VALUE: Value out of range " 4230 "for int32 option \"foo\".\n"); 4231 } 4232 4233 TEST_F(ValidationErrorTest, Int32OptionValueOutOfNegativeRange) { 4234 BuildDescriptorMessagesInTestPool(); 4235 4236 BuildFileWithErrors( 4237 "name: \"foo.proto\" " 4238 "dependency: \"google/protobuf/descriptor.proto\" " 4239 "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL " 4240 " type: TYPE_INT32 extendee: \"google.protobuf.FileOptions\" }" 4241 "options { uninterpreted_option { name { name_part: \"foo\" " 4242 " is_extension: true } " 4243 " negative_int_value: -0x80000001 } " 4244 "}", 4245 4246 "foo.proto: foo.proto: OPTION_VALUE: Value out of range " 4247 "for int32 option \"foo\".\n"); 4248 } 4249 4250 TEST_F(ValidationErrorTest, Int32OptionValueIsNotPositiveInt) { 4251 BuildDescriptorMessagesInTestPool(); 4252 4253 BuildFileWithErrors( 4254 "name: \"foo.proto\" " 4255 "dependency: \"google/protobuf/descriptor.proto\" " 4256 "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL " 4257 " type: TYPE_INT32 extendee: \"google.protobuf.FileOptions\" }" 4258 "options { uninterpreted_option { name { name_part: \"foo\" " 4259 " is_extension: true } " 4260 " string_value: \"5\" } }", 4261 4262 "foo.proto: foo.proto: OPTION_VALUE: Value must be integer " 4263 "for int32 option \"foo\".\n"); 4264 } 4265 4266 TEST_F(ValidationErrorTest, Int64OptionValueOutOfRange) { 4267 BuildDescriptorMessagesInTestPool(); 4268 4269 BuildFileWithErrors( 4270 "name: \"foo.proto\" " 4271 "dependency: \"google/protobuf/descriptor.proto\" " 4272 "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL " 4273 " type: TYPE_INT64 extendee: \"google.protobuf.FileOptions\" }" 4274 "options { uninterpreted_option { name { name_part: \"foo\" " 4275 " is_extension: true } " 4276 " positive_int_value: 0x8000000000000000 } " 4277 "}", 4278 4279 "foo.proto: foo.proto: OPTION_VALUE: Value out of range " 4280 "for int64 option \"foo\".\n"); 4281 } 4282 4283 TEST_F(ValidationErrorTest, Int64OptionValueIsNotPositiveInt) { 4284 BuildDescriptorMessagesInTestPool(); 4285 4286 BuildFileWithErrors( 4287 "name: \"foo.proto\" " 4288 "dependency: \"google/protobuf/descriptor.proto\" " 4289 "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL " 4290 " type: TYPE_INT64 extendee: \"google.protobuf.FileOptions\" }" 4291 "options { uninterpreted_option { name { name_part: \"foo\" " 4292 " is_extension: true } " 4293 " identifier_value: \"5\" } }", 4294 4295 "foo.proto: foo.proto: OPTION_VALUE: Value must be integer " 4296 "for int64 option \"foo\".\n"); 4297 } 4298 4299 TEST_F(ValidationErrorTest, UInt32OptionValueOutOfRange) { 4300 BuildDescriptorMessagesInTestPool(); 4301 4302 BuildFileWithErrors( 4303 "name: \"foo.proto\" " 4304 "dependency: \"google/protobuf/descriptor.proto\" " 4305 "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL " 4306 " type: TYPE_UINT32 extendee: \"google.protobuf.FileOptions\" }" 4307 "options { uninterpreted_option { name { name_part: \"foo\" " 4308 " is_extension: true } " 4309 " positive_int_value: 0x100000000 } }", 4310 4311 "foo.proto: foo.proto: OPTION_VALUE: Value out of range " 4312 "for uint32 option \"foo\".\n"); 4313 } 4314 4315 TEST_F(ValidationErrorTest, UInt32OptionValueIsNotPositiveInt) { 4316 BuildDescriptorMessagesInTestPool(); 4317 4318 BuildFileWithErrors( 4319 "name: \"foo.proto\" " 4320 "dependency: \"google/protobuf/descriptor.proto\" " 4321 "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL " 4322 " type: TYPE_UINT32 extendee: \"google.protobuf.FileOptions\" }" 4323 "options { uninterpreted_option { name { name_part: \"foo\" " 4324 " is_extension: true } " 4325 " double_value: -5.6 } }", 4326 4327 "foo.proto: foo.proto: OPTION_VALUE: Value must be non-negative integer " 4328 "for uint32 option \"foo\".\n"); 4329 } 4330 4331 TEST_F(ValidationErrorTest, UInt64OptionValueIsNotPositiveInt) { 4332 BuildDescriptorMessagesInTestPool(); 4333 4334 BuildFileWithErrors( 4335 "name: \"foo.proto\" " 4336 "dependency: \"google/protobuf/descriptor.proto\" " 4337 "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL " 4338 " type: TYPE_UINT64 extendee: \"google.protobuf.FileOptions\" }" 4339 "options { uninterpreted_option { name { name_part: \"foo\" " 4340 " is_extension: true } " 4341 " negative_int_value: -5 } }", 4342 4343 "foo.proto: foo.proto: OPTION_VALUE: Value must be non-negative integer " 4344 "for uint64 option \"foo\".\n"); 4345 } 4346 4347 TEST_F(ValidationErrorTest, FloatOptionValueIsNotNumber) { 4348 BuildDescriptorMessagesInTestPool(); 4349 4350 BuildFileWithErrors( 4351 "name: \"foo.proto\" " 4352 "dependency: \"google/protobuf/descriptor.proto\" " 4353 "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL " 4354 " type: TYPE_FLOAT extendee: \"google.protobuf.FileOptions\" }" 4355 "options { uninterpreted_option { name { name_part: \"foo\" " 4356 " is_extension: true } " 4357 " string_value: \"bar\" } }", 4358 4359 "foo.proto: foo.proto: OPTION_VALUE: Value must be number " 4360 "for float option \"foo\".\n"); 4361 } 4362 4363 TEST_F(ValidationErrorTest, DoubleOptionValueIsNotNumber) { 4364 BuildDescriptorMessagesInTestPool(); 4365 4366 BuildFileWithErrors( 4367 "name: \"foo.proto\" " 4368 "dependency: \"google/protobuf/descriptor.proto\" " 4369 "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL " 4370 " type: TYPE_DOUBLE extendee: \"google.protobuf.FileOptions\" }" 4371 "options { uninterpreted_option { name { name_part: \"foo\" " 4372 " is_extension: true } " 4373 " string_value: \"bar\" } }", 4374 4375 "foo.proto: foo.proto: OPTION_VALUE: Value must be number " 4376 "for double option \"foo\".\n"); 4377 } 4378 4379 TEST_F(ValidationErrorTest, BoolOptionValueIsNotTrueOrFalse) { 4380 BuildDescriptorMessagesInTestPool(); 4381 4382 BuildFileWithErrors( 4383 "name: \"foo.proto\" " 4384 "dependency: \"google/protobuf/descriptor.proto\" " 4385 "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL " 4386 " type: TYPE_BOOL extendee: \"google.protobuf.FileOptions\" }" 4387 "options { uninterpreted_option { name { name_part: \"foo\" " 4388 " is_extension: true } " 4389 " identifier_value: \"bar\" } }", 4390 4391 "foo.proto: foo.proto: OPTION_VALUE: Value must be \"true\" or \"false\" " 4392 "for boolean option \"foo\".\n"); 4393 } 4394 4395 TEST_F(ValidationErrorTest, EnumOptionValueIsNotIdentifier) { 4396 BuildDescriptorMessagesInTestPool(); 4397 4398 BuildFileWithErrors( 4399 "name: \"foo.proto\" " 4400 "dependency: \"google/protobuf/descriptor.proto\" " 4401 "enum_type { name: \"FooEnum\" value { name: \"BAR\" number: 1 } " 4402 " value { name: \"BAZ\" number: 2 } }" 4403 "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL " 4404 " type: TYPE_ENUM type_name: \"FooEnum\" " 4405 " extendee: \"google.protobuf.FileOptions\" }" 4406 "options { uninterpreted_option { name { name_part: \"foo\" " 4407 " is_extension: true } " 4408 " string_value: \"QUUX\" } }", 4409 4410 "foo.proto: foo.proto: OPTION_VALUE: Value must be identifier for " 4411 "enum-valued option \"foo\".\n"); 4412 } 4413 4414 TEST_F(ValidationErrorTest, EnumOptionValueIsNotEnumValueName) { 4415 BuildDescriptorMessagesInTestPool(); 4416 4417 BuildFileWithErrors( 4418 "name: \"foo.proto\" " 4419 "dependency: \"google/protobuf/descriptor.proto\" " 4420 "enum_type { name: \"FooEnum\" value { name: \"BAR\" number: 1 } " 4421 " value { name: \"BAZ\" number: 2 } }" 4422 "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL " 4423 " type: TYPE_ENUM type_name: \"FooEnum\" " 4424 " extendee: \"google.protobuf.FileOptions\" }" 4425 "options { uninterpreted_option { name { name_part: \"foo\" " 4426 " is_extension: true } " 4427 " identifier_value: \"QUUX\" } }", 4428 4429 "foo.proto: foo.proto: OPTION_VALUE: Enum type \"FooEnum\" has no value " 4430 "named \"QUUX\" for option \"foo\".\n"); 4431 } 4432 4433 TEST_F(ValidationErrorTest, EnumOptionValueIsSiblingEnumValueName) { 4434 BuildDescriptorMessagesInTestPool(); 4435 4436 BuildFileWithErrors( 4437 "name: \"foo.proto\" " 4438 "dependency: \"google/protobuf/descriptor.proto\" " 4439 "enum_type { name: \"FooEnum1\" value { name: \"BAR\" number: 1 } " 4440 " value { name: \"BAZ\" number: 2 } }" 4441 "enum_type { name: \"FooEnum2\" value { name: \"QUX\" number: 1 } " 4442 " value { name: \"QUUX\" number: 2 } }" 4443 "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL " 4444 " type: TYPE_ENUM type_name: \"FooEnum1\" " 4445 " extendee: \"google.protobuf.FileOptions\" }" 4446 "options { uninterpreted_option { name { name_part: \"foo\" " 4447 " is_extension: true } " 4448 " identifier_value: \"QUUX\" } }", 4449 4450 "foo.proto: foo.proto: OPTION_VALUE: Enum type \"FooEnum1\" has no value " 4451 "named \"QUUX\" for option \"foo\". This appears to be a value from a " 4452 "sibling type.\n"); 4453 } 4454 4455 TEST_F(ValidationErrorTest, StringOptionValueIsNotString) { 4456 BuildDescriptorMessagesInTestPool(); 4457 4458 BuildFileWithErrors( 4459 "name: \"foo.proto\" " 4460 "dependency: \"google/protobuf/descriptor.proto\" " 4461 "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL " 4462 " type: TYPE_STRING extendee: \"google.protobuf.FileOptions\" }" 4463 "options { uninterpreted_option { name { name_part: \"foo\" " 4464 " is_extension: true } " 4465 " identifier_value: \"QUUX\" } }", 4466 4467 "foo.proto: foo.proto: OPTION_VALUE: Value must be quoted string for " 4468 "string option \"foo\".\n"); 4469 } 4470 4471 TEST_F(ValidationErrorTest, DuplicateExtensionFieldNumber) { 4472 BuildDescriptorMessagesInTestPool(); 4473 4474 BuildFile( 4475 "name: \"foo.proto\" " 4476 "dependency: \"google/protobuf/descriptor.proto\" " 4477 "extension { name: \"option1\" number: 1000 label: LABEL_OPTIONAL " 4478 " type: TYPE_INT32 extendee: \"google.protobuf.FileOptions\" }"); 4479 4480 BuildFileWithWarnings( 4481 "name: \"bar.proto\" " 4482 "dependency: \"google/protobuf/descriptor.proto\" " 4483 "extension { name: \"option2\" number: 1000 label: LABEL_OPTIONAL " 4484 " type: TYPE_INT32 extendee: \"google.protobuf.FileOptions\" }", 4485 "bar.proto: option2: NUMBER: Extension number 1000 has already been used " 4486 "in \"google.protobuf.FileOptions\" by extension \"option1\" defined in " 4487 "foo.proto.\n"); 4488 } 4489 4490 // Helper function for tests that check for aggregate value parsing 4491 // errors. The "value" argument is embedded inside the 4492 // "uninterpreted_option" portion of the result. 4493 static string EmbedAggregateValue(const char* value) { 4494 return strings::Substitute( 4495 "name: \"foo.proto\" " 4496 "dependency: \"google/protobuf/descriptor.proto\" " 4497 "message_type { name: \"Foo\" } " 4498 "extension { name: \"foo\" number: 7672757 label: LABEL_OPTIONAL " 4499 " type: TYPE_MESSAGE type_name: \"Foo\" " 4500 " extendee: \"google.protobuf.FileOptions\" }" 4501 "options { uninterpreted_option { name { name_part: \"foo\" " 4502 " is_extension: true } " 4503 " $0 } }", 4504 value); 4505 } 4506 4507 TEST_F(ValidationErrorTest, AggregateValueNotFound) { 4508 BuildDescriptorMessagesInTestPool(); 4509 4510 BuildFileWithErrors( 4511 EmbedAggregateValue("string_value: \"\""), 4512 "foo.proto: foo.proto: OPTION_VALUE: Option \"foo\" is a message. " 4513 "To set the entire message, use syntax like " 4514 "\"foo = { <proto text format> }\". To set fields within it, use " 4515 "syntax like \"foo.foo = value\".\n"); 4516 } 4517 4518 TEST_F(ValidationErrorTest, AggregateValueParseError) { 4519 BuildDescriptorMessagesInTestPool(); 4520 4521 BuildFileWithErrors( 4522 EmbedAggregateValue("aggregate_value: \"1+2\""), 4523 "foo.proto: foo.proto: OPTION_VALUE: Error while parsing option " 4524 "value for \"foo\": Expected identifier.\n"); 4525 } 4526 4527 TEST_F(ValidationErrorTest, AggregateValueUnknownFields) { 4528 BuildDescriptorMessagesInTestPool(); 4529 4530 BuildFileWithErrors( 4531 EmbedAggregateValue("aggregate_value: \"x:100\""), 4532 "foo.proto: foo.proto: OPTION_VALUE: Error while parsing option " 4533 "value for \"foo\": Message type \"Foo\" has no field named \"x\".\n"); 4534 } 4535 4536 TEST_F(ValidationErrorTest, NotLiteImportsLite) { 4537 BuildFile( 4538 "name: \"bar.proto\" " 4539 "options { optimize_for: LITE_RUNTIME } "); 4540 4541 BuildFileWithErrors( 4542 "name: \"foo.proto\" " 4543 "dependency: \"bar.proto\" ", 4544 4545 "foo.proto: foo.proto: OTHER: Files that do not use optimize_for = " 4546 "LITE_RUNTIME cannot import files which do use this option. This file " 4547 "is not lite, but it imports \"bar.proto\" which is.\n"); 4548 } 4549 4550 TEST_F(ValidationErrorTest, LiteExtendsNotLite) { 4551 BuildFile( 4552 "name: \"bar.proto\" " 4553 "message_type: {" 4554 " name: \"Bar\"" 4555 " extension_range { start: 1 end: 1000 }" 4556 "}"); 4557 4558 BuildFileWithErrors( 4559 "name: \"foo.proto\" " 4560 "dependency: \"bar.proto\" " 4561 "options { optimize_for: LITE_RUNTIME } " 4562 "extension { name: \"ext\" number: 123 label: LABEL_OPTIONAL " 4563 " type: TYPE_INT32 extendee: \"Bar\" }", 4564 4565 "foo.proto: ext: EXTENDEE: Extensions to non-lite types can only be " 4566 "declared in non-lite files. Note that you cannot extend a non-lite " 4567 "type to contain a lite type, but the reverse is allowed.\n"); 4568 } 4569 4570 TEST_F(ValidationErrorTest, NoLiteServices) { 4571 BuildFileWithErrors( 4572 "name: \"foo.proto\" " 4573 "options {" 4574 " optimize_for: LITE_RUNTIME" 4575 " cc_generic_services: true" 4576 " java_generic_services: true" 4577 "} " 4578 "service { name: \"Foo\" }", 4579 4580 "foo.proto: Foo: NAME: Files with optimize_for = LITE_RUNTIME cannot " 4581 "define services unless you set both options cc_generic_services and " 4582 "java_generic_sevices to false.\n"); 4583 4584 BuildFile( 4585 "name: \"bar.proto\" " 4586 "options {" 4587 " optimize_for: LITE_RUNTIME" 4588 " cc_generic_services: false" 4589 " java_generic_services: false" 4590 "} " 4591 "service { name: \"Bar\" }"); 4592 } 4593 4594 TEST_F(ValidationErrorTest, RollbackAfterError) { 4595 // Build a file which contains every kind of construct but references an 4596 // undefined type. All these constructs will be added to the symbol table 4597 // before the undefined type error is noticed. The DescriptorPool will then 4598 // have to roll everything back. 4599 BuildFileWithErrors( 4600 "name: \"foo.proto\" " 4601 "message_type {" 4602 " name: \"TestMessage\"" 4603 " field { name:\"foo\" label:LABEL_OPTIONAL type:TYPE_INT32 number:1 }" 4604 "} " 4605 "enum_type {" 4606 " name: \"TestEnum\"" 4607 " value { name:\"BAR\" number:1 }" 4608 "} " 4609 "service {" 4610 " name: \"TestService\"" 4611 " method {" 4612 " name: \"Baz\"" 4613 " input_type: \"NoSuchType\"" // error 4614 " output_type: \"TestMessage\"" 4615 " }" 4616 "}", 4617 4618 "foo.proto: TestService.Baz: INPUT_TYPE: \"NoSuchType\" is not defined.\n" 4619 ); 4620 4621 // Make sure that if we build the same file again with the error fixed, 4622 // it works. If the above rollback was incomplete, then some symbols will 4623 // be left defined, and this second attempt will fail since it tries to 4624 // re-define the same symbols. 4625 BuildFile( 4626 "name: \"foo.proto\" " 4627 "message_type {" 4628 " name: \"TestMessage\"" 4629 " field { name:\"foo\" label:LABEL_OPTIONAL type:TYPE_INT32 number:1 }" 4630 "} " 4631 "enum_type {" 4632 " name: \"TestEnum\"" 4633 " value { name:\"BAR\" number:1 }" 4634 "} " 4635 "service {" 4636 " name: \"TestService\"" 4637 " method { name:\"Baz\"" 4638 " input_type:\"TestMessage\"" 4639 " output_type:\"TestMessage\" }" 4640 "}"); 4641 } 4642 4643 TEST_F(ValidationErrorTest, ErrorsReportedToLogError) { 4644 // Test that errors are reported to GOOGLE_LOG(ERROR) if no error collector is 4645 // provided. 4646 4647 FileDescriptorProto file_proto; 4648 ASSERT_TRUE(TextFormat::ParseFromString( 4649 "name: \"foo.proto\" " 4650 "message_type { name: \"Foo\" } " 4651 "message_type { name: \"Foo\" } ", 4652 &file_proto)); 4653 4654 vector<string> errors; 4655 4656 { 4657 ScopedMemoryLog log; 4658 EXPECT_TRUE(pool_.BuildFile(file_proto) == NULL); 4659 errors = log.GetMessages(ERROR); 4660 } 4661 4662 ASSERT_EQ(2, errors.size()); 4663 4664 EXPECT_EQ("Invalid proto descriptor for file \"foo.proto\":", errors[0]); 4665 EXPECT_EQ(" Foo: \"Foo\" is already defined.", errors[1]); 4666 } 4667 4668 TEST_F(ValidationErrorTest, DisallowEnumAlias) { 4669 BuildFileWithErrors( 4670 "name: \"foo.proto\" " 4671 "enum_type {" 4672 " name: \"Bar\"" 4673 " value { name:\"ENUM_A\" number:0 }" 4674 " value { name:\"ENUM_B\" number:0 }" 4675 "}", 4676 "foo.proto: Bar: NUMBER: " 4677 "\"ENUM_B\" uses the same enum value as \"ENUM_A\". " 4678 "If this is intended, set 'option allow_alias = true;' to the enum " 4679 "definition.\n"); 4680 } 4681 4682 TEST_F(ValidationErrorTest, AllowEnumAlias) { 4683 BuildFile( 4684 "name: \"foo.proto\" " 4685 "enum_type {" 4686 " name: \"Bar\"" 4687 " value { name:\"ENUM_A\" number:0 }" 4688 " value { name:\"ENUM_B\" number:0 }" 4689 " options { allow_alias: true }" 4690 "}"); 4691 } 4692 4693 TEST_F(ValidationErrorTest, UnusedImportWarning) { 4694 4695 pool_.AddUnusedImportTrackFile("bar.proto"); 4696 BuildFile( 4697 "name: \"bar.proto\" " 4698 "message_type { name: \"Bar\" }"); 4699 4700 pool_.AddUnusedImportTrackFile("base.proto"); 4701 BuildFile( 4702 "name: \"base.proto\" " 4703 "message_type { name: \"Base\" }"); 4704 4705 pool_.AddUnusedImportTrackFile("baz.proto"); 4706 BuildFile( 4707 "name: \"baz.proto\" " 4708 "message_type { name: \"Baz\" }"); 4709 4710 pool_.AddUnusedImportTrackFile("public.proto"); 4711 BuildFile( 4712 "name: \"public.proto\" " 4713 "dependency: \"bar.proto\"" 4714 "public_dependency: 0"); 4715 4716 // // forward.proto 4717 // import "base.proto" // No warning: Base message is used. 4718 // import "bar.proto" // Will log a warning. 4719 // import public "baz.proto" // No warning: Do not track import public. 4720 // import "public.proto" // No warning: public.proto has import public. 4721 // message Forward { 4722 // optional Base base = 1; 4723 // } 4724 // 4725 pool_.AddUnusedImportTrackFile("forward.proto"); 4726 BuildFile( 4727 "name: \"forward.proto\"" 4728 "dependency: \"base.proto\"" 4729 "dependency: \"bar.proto\"" 4730 "dependency: \"baz.proto\"" 4731 "dependency: \"public.proto\"" 4732 "public_dependency: 2 " 4733 "message_type {" 4734 " name: \"Forward\"" 4735 " field { name:\"base\" number:1 label:LABEL_OPTIONAL type_name:\"Base\" }" 4736 "}"); 4737 } 4738 4739 4740 // =================================================================== 4741 // DescriptorDatabase 4742 4743 static void AddToDatabase(SimpleDescriptorDatabase* database, 4744 const char* file_text) { 4745 FileDescriptorProto file_proto; 4746 EXPECT_TRUE(TextFormat::ParseFromString(file_text, &file_proto)); 4747 database->Add(file_proto); 4748 } 4749 4750 class DatabaseBackedPoolTest : public testing::Test { 4751 protected: 4752 DatabaseBackedPoolTest() {} 4753 4754 SimpleDescriptorDatabase database_; 4755 4756 virtual void SetUp() { 4757 AddToDatabase(&database_, 4758 "name: 'foo.proto' " 4759 "message_type { name:'Foo' extension_range { start: 1 end: 100 } } " 4760 "enum_type { name:'TestEnum' value { name:'DUMMY' number:0 } } " 4761 "service { name:'TestService' } "); 4762 AddToDatabase(&database_, 4763 "name: 'bar.proto' " 4764 "dependency: 'foo.proto' " 4765 "message_type { name:'Bar' } " 4766 "extension { name:'foo_ext' extendee: '.Foo' number:5 " 4767 " label:LABEL_OPTIONAL type:TYPE_INT32 } "); 4768 // Baz has an undeclared dependency on Foo. 4769 AddToDatabase(&database_, 4770 "name: 'baz.proto' " 4771 "message_type { " 4772 " name:'Baz' " 4773 " field { name:'foo' number:1 label:LABEL_OPTIONAL type_name:'Foo' } " 4774 "}"); 4775 } 4776 4777 // We can't inject a file containing errors into a DescriptorPool, so we 4778 // need an actual mock DescriptorDatabase to test errors. 4779 class ErrorDescriptorDatabase : public DescriptorDatabase { 4780 public: 4781 ErrorDescriptorDatabase() {} 4782 ~ErrorDescriptorDatabase() {} 4783 4784 // implements DescriptorDatabase --------------------------------- 4785 bool FindFileByName(const string& filename, 4786 FileDescriptorProto* output) { 4787 // error.proto and error2.proto cyclically import each other. 4788 if (filename == "error.proto") { 4789 output->Clear(); 4790 output->set_name("error.proto"); 4791 output->add_dependency("error2.proto"); 4792 return true; 4793 } else if (filename == "error2.proto") { 4794 output->Clear(); 4795 output->set_name("error2.proto"); 4796 output->add_dependency("error.proto"); 4797 return true; 4798 } else { 4799 return false; 4800 } 4801 } 4802 bool FindFileContainingSymbol(const string& symbol_name, 4803 FileDescriptorProto* output) { 4804 return false; 4805 } 4806 bool FindFileContainingExtension(const string& containing_type, 4807 int field_number, 4808 FileDescriptorProto* output) { 4809 return false; 4810 } 4811 }; 4812 4813 // A DescriptorDatabase that counts how many times each method has been 4814 // called and forwards to some other DescriptorDatabase. 4815 class CallCountingDatabase : public DescriptorDatabase { 4816 public: 4817 CallCountingDatabase(DescriptorDatabase* wrapped_db) 4818 : wrapped_db_(wrapped_db) { 4819 Clear(); 4820 } 4821 ~CallCountingDatabase() {} 4822 4823 DescriptorDatabase* wrapped_db_; 4824 4825 int call_count_; 4826 4827 void Clear() { 4828 call_count_ = 0; 4829 } 4830 4831 // implements DescriptorDatabase --------------------------------- 4832 bool FindFileByName(const string& filename, 4833 FileDescriptorProto* output) { 4834 ++call_count_; 4835 return wrapped_db_->FindFileByName(filename, output); 4836 } 4837 bool FindFileContainingSymbol(const string& symbol_name, 4838 FileDescriptorProto* output) { 4839 ++call_count_; 4840 return wrapped_db_->FindFileContainingSymbol(symbol_name, output); 4841 } 4842 bool FindFileContainingExtension(const string& containing_type, 4843 int field_number, 4844 FileDescriptorProto* output) { 4845 ++call_count_; 4846 return wrapped_db_->FindFileContainingExtension( 4847 containing_type, field_number, output); 4848 } 4849 }; 4850 4851 // A DescriptorDatabase which falsely always returns foo.proto when searching 4852 // for any symbol or extension number. This shouldn't cause the 4853 // DescriptorPool to reload foo.proto if it is already loaded. 4854 class FalsePositiveDatabase : public DescriptorDatabase { 4855 public: 4856 FalsePositiveDatabase(DescriptorDatabase* wrapped_db) 4857 : wrapped_db_(wrapped_db) {} 4858 ~FalsePositiveDatabase() {} 4859 4860 DescriptorDatabase* wrapped_db_; 4861 4862 // implements DescriptorDatabase --------------------------------- 4863 bool FindFileByName(const string& filename, 4864 FileDescriptorProto* output) { 4865 return wrapped_db_->FindFileByName(filename, output); 4866 } 4867 bool FindFileContainingSymbol(const string& symbol_name, 4868 FileDescriptorProto* output) { 4869 return FindFileByName("foo.proto", output); 4870 } 4871 bool FindFileContainingExtension(const string& containing_type, 4872 int field_number, 4873 FileDescriptorProto* output) { 4874 return FindFileByName("foo.proto", output); 4875 } 4876 }; 4877 }; 4878 4879 TEST_F(DatabaseBackedPoolTest, FindFileByName) { 4880 DescriptorPool pool(&database_); 4881 4882 const FileDescriptor* foo = pool.FindFileByName("foo.proto"); 4883 ASSERT_TRUE(foo != NULL); 4884 EXPECT_EQ("foo.proto", foo->name()); 4885 ASSERT_EQ(1, foo->message_type_count()); 4886 EXPECT_EQ("Foo", foo->message_type(0)->name()); 4887 4888 EXPECT_EQ(foo, pool.FindFileByName("foo.proto")); 4889 4890 EXPECT_TRUE(pool.FindFileByName("no_such_file.proto") == NULL); 4891 } 4892 4893 TEST_F(DatabaseBackedPoolTest, FindDependencyBeforeDependent) { 4894 DescriptorPool pool(&database_); 4895 4896 const FileDescriptor* foo = pool.FindFileByName("foo.proto"); 4897 ASSERT_TRUE(foo != NULL); 4898 EXPECT_EQ("foo.proto", foo->name()); 4899 ASSERT_EQ(1, foo->message_type_count()); 4900 EXPECT_EQ("Foo", foo->message_type(0)->name()); 4901 4902 const FileDescriptor* bar = pool.FindFileByName("bar.proto"); 4903 ASSERT_TRUE(bar != NULL); 4904 EXPECT_EQ("bar.proto", bar->name()); 4905 ASSERT_EQ(1, bar->message_type_count()); 4906 EXPECT_EQ("Bar", bar->message_type(0)->name()); 4907 4908 ASSERT_EQ(1, bar->dependency_count()); 4909 EXPECT_EQ(foo, bar->dependency(0)); 4910 } 4911 4912 TEST_F(DatabaseBackedPoolTest, FindDependentBeforeDependency) { 4913 DescriptorPool pool(&database_); 4914 4915 const FileDescriptor* bar = pool.FindFileByName("bar.proto"); 4916 ASSERT_TRUE(bar != NULL); 4917 EXPECT_EQ("bar.proto", bar->name()); 4918 ASSERT_EQ(1, bar->message_type_count()); 4919 ASSERT_EQ("Bar", bar->message_type(0)->name()); 4920 4921 const FileDescriptor* foo = pool.FindFileByName("foo.proto"); 4922 ASSERT_TRUE(foo != NULL); 4923 EXPECT_EQ("foo.proto", foo->name()); 4924 ASSERT_EQ(1, foo->message_type_count()); 4925 ASSERT_EQ("Foo", foo->message_type(0)->name()); 4926 4927 ASSERT_EQ(1, bar->dependency_count()); 4928 EXPECT_EQ(foo, bar->dependency(0)); 4929 } 4930 4931 TEST_F(DatabaseBackedPoolTest, FindFileContainingSymbol) { 4932 DescriptorPool pool(&database_); 4933 4934 const FileDescriptor* file = pool.FindFileContainingSymbol("Foo"); 4935 ASSERT_TRUE(file != NULL); 4936 EXPECT_EQ("foo.proto", file->name()); 4937 EXPECT_EQ(file, pool.FindFileByName("foo.proto")); 4938 4939 EXPECT_TRUE(pool.FindFileContainingSymbol("NoSuchSymbol") == NULL); 4940 } 4941 4942 TEST_F(DatabaseBackedPoolTest, FindMessageTypeByName) { 4943 DescriptorPool pool(&database_); 4944 4945 const Descriptor* type = pool.FindMessageTypeByName("Foo"); 4946 ASSERT_TRUE(type != NULL); 4947 EXPECT_EQ("Foo", type->name()); 4948 EXPECT_EQ(type->file(), pool.FindFileByName("foo.proto")); 4949 4950 EXPECT_TRUE(pool.FindMessageTypeByName("NoSuchType") == NULL); 4951 } 4952 4953 TEST_F(DatabaseBackedPoolTest, FindExtensionByNumber) { 4954 DescriptorPool pool(&database_); 4955 4956 const Descriptor* foo = pool.FindMessageTypeByName("Foo"); 4957 ASSERT_TRUE(foo != NULL); 4958 4959 const FieldDescriptor* extension = pool.FindExtensionByNumber(foo, 5); 4960 ASSERT_TRUE(extension != NULL); 4961 EXPECT_EQ("foo_ext", extension->name()); 4962 EXPECT_EQ(extension->file(), pool.FindFileByName("bar.proto")); 4963 4964 EXPECT_TRUE(pool.FindExtensionByNumber(foo, 12) == NULL); 4965 } 4966 4967 TEST_F(DatabaseBackedPoolTest, FindAllExtensions) { 4968 DescriptorPool pool(&database_); 4969 4970 const Descriptor* foo = pool.FindMessageTypeByName("Foo"); 4971 4972 for (int i = 0; i < 2; ++i) { 4973 // Repeat the lookup twice, to check that we get consistent 4974 // results despite the fallback database lookup mutating the pool. 4975 vector<const FieldDescriptor*> extensions; 4976 pool.FindAllExtensions(foo, &extensions); 4977 ASSERT_EQ(1, extensions.size()); 4978 EXPECT_EQ(5, extensions[0]->number()); 4979 } 4980 } 4981 4982 TEST_F(DatabaseBackedPoolTest, ErrorWithoutErrorCollector) { 4983 ErrorDescriptorDatabase error_database; 4984 DescriptorPool pool(&error_database); 4985 4986 vector<string> errors; 4987 4988 { 4989 ScopedMemoryLog log; 4990 EXPECT_TRUE(pool.FindFileByName("error.proto") == NULL); 4991 errors = log.GetMessages(ERROR); 4992 } 4993 4994 EXPECT_FALSE(errors.empty()); 4995 } 4996 4997 TEST_F(DatabaseBackedPoolTest, ErrorWithErrorCollector) { 4998 ErrorDescriptorDatabase error_database; 4999 MockErrorCollector error_collector; 5000 DescriptorPool pool(&error_database, &error_collector); 5001 5002 EXPECT_TRUE(pool.FindFileByName("error.proto") == NULL); 5003 EXPECT_EQ( 5004 "error.proto: error.proto: OTHER: File recursively imports itself: " 5005 "error.proto -> error2.proto -> error.proto\n" 5006 "error2.proto: error2.proto: OTHER: Import \"error.proto\" was not " 5007 "found or had errors.\n" 5008 "error.proto: error.proto: OTHER: Import \"error2.proto\" was not " 5009 "found or had errors.\n", 5010 error_collector.text_); 5011 } 5012 5013 TEST_F(DatabaseBackedPoolTest, UndeclaredDependencyOnUnbuiltType) { 5014 // Check that we find and report undeclared dependencies on types that exist 5015 // in the descriptor database but that have not not been built yet. 5016 MockErrorCollector error_collector; 5017 DescriptorPool pool(&database_, &error_collector); 5018 EXPECT_TRUE(pool.FindMessageTypeByName("Baz") == NULL); 5019 EXPECT_EQ( 5020 "baz.proto: Baz.foo: TYPE: \"Foo\" seems to be defined in \"foo.proto\", " 5021 "which is not imported by \"baz.proto\". To use it here, please add " 5022 "the necessary import.\n", 5023 error_collector.text_); 5024 } 5025 5026 TEST_F(DatabaseBackedPoolTest, RollbackAfterError) { 5027 // Make sure that all traces of bad types are removed from the pool. This used 5028 // to be b/4529436, due to the fact that a symbol resolution failure could 5029 // potentially cause another file to be recursively built, which would trigger 5030 // a checkpoint _past_ possibly invalid symbols. 5031 // Baz is defined in the database, but the file is invalid because it is 5032 // missing a necessary import. 5033 DescriptorPool pool(&database_); 5034 EXPECT_TRUE(pool.FindMessageTypeByName("Baz") == NULL); 5035 // Make sure that searching again for the file or the type fails. 5036 EXPECT_TRUE(pool.FindFileByName("baz.proto") == NULL); 5037 EXPECT_TRUE(pool.FindMessageTypeByName("Baz") == NULL); 5038 } 5039 5040 TEST_F(DatabaseBackedPoolTest, UnittestProto) { 5041 // Try to load all of unittest.proto from a DescriptorDatabase. This should 5042 // thoroughly test all paths through DescriptorBuilder to insure that there 5043 // are no deadlocking problems when pool_->mutex_ is non-NULL. 5044 const FileDescriptor* original_file = 5045 protobuf_unittest::TestAllTypes::descriptor()->file(); 5046 5047 DescriptorPoolDatabase database(*DescriptorPool::generated_pool()); 5048 DescriptorPool pool(&database); 5049 const FileDescriptor* file_from_database = 5050 pool.FindFileByName(original_file->name()); 5051 5052 ASSERT_TRUE(file_from_database != NULL); 5053 5054 FileDescriptorProto original_file_proto; 5055 original_file->CopyTo(&original_file_proto); 5056 5057 FileDescriptorProto file_from_database_proto; 5058 file_from_database->CopyTo(&file_from_database_proto); 5059 5060 EXPECT_EQ(original_file_proto.DebugString(), 5061 file_from_database_proto.DebugString()); 5062 5063 // Also verify that CopyTo() did not omit any information. 5064 EXPECT_EQ(original_file->DebugString(), 5065 file_from_database->DebugString()); 5066 } 5067 5068 TEST_F(DatabaseBackedPoolTest, DoesntRetryDbUnnecessarily) { 5069 // Searching for a child of an existing descriptor should never fall back 5070 // to the DescriptorDatabase even if it isn't found, because we know all 5071 // children are already loaded. 5072 CallCountingDatabase call_counter(&database_); 5073 DescriptorPool pool(&call_counter); 5074 5075 const FileDescriptor* file = pool.FindFileByName("foo.proto"); 5076 ASSERT_TRUE(file != NULL); 5077 const Descriptor* foo = pool.FindMessageTypeByName("Foo"); 5078 ASSERT_TRUE(foo != NULL); 5079 const EnumDescriptor* test_enum = pool.FindEnumTypeByName("TestEnum"); 5080 ASSERT_TRUE(test_enum != NULL); 5081 const ServiceDescriptor* test_service = pool.FindServiceByName("TestService"); 5082 ASSERT_TRUE(test_service != NULL); 5083 5084 EXPECT_NE(0, call_counter.call_count_); 5085 call_counter.Clear(); 5086 5087 EXPECT_TRUE(foo->FindFieldByName("no_such_field") == NULL); 5088 EXPECT_TRUE(foo->FindExtensionByName("no_such_extension") == NULL); 5089 EXPECT_TRUE(foo->FindNestedTypeByName("NoSuchMessageType") == NULL); 5090 EXPECT_TRUE(foo->FindEnumTypeByName("NoSuchEnumType") == NULL); 5091 EXPECT_TRUE(foo->FindEnumValueByName("NO_SUCH_VALUE") == NULL); 5092 EXPECT_TRUE(test_enum->FindValueByName("NO_SUCH_VALUE") == NULL); 5093 EXPECT_TRUE(test_service->FindMethodByName("NoSuchMethod") == NULL); 5094 5095 EXPECT_TRUE(file->FindMessageTypeByName("NoSuchMessageType") == NULL); 5096 EXPECT_TRUE(file->FindEnumTypeByName("NoSuchEnumType") == NULL); 5097 EXPECT_TRUE(file->FindEnumValueByName("NO_SUCH_VALUE") == NULL); 5098 EXPECT_TRUE(file->FindServiceByName("NO_SUCH_VALUE") == NULL); 5099 EXPECT_TRUE(file->FindExtensionByName("no_such_extension") == NULL); 5100 5101 EXPECT_TRUE(pool.FindFileContainingSymbol("Foo.no.such.field") == NULL); 5102 EXPECT_TRUE(pool.FindFileContainingSymbol("Foo.no_such_field") == NULL); 5103 EXPECT_TRUE(pool.FindMessageTypeByName("Foo.NoSuchMessageType") == NULL); 5104 EXPECT_TRUE(pool.FindFieldByName("Foo.no_such_field") == NULL); 5105 EXPECT_TRUE(pool.FindExtensionByName("Foo.no_such_extension") == NULL); 5106 EXPECT_TRUE(pool.FindEnumTypeByName("Foo.NoSuchEnumType") == NULL); 5107 EXPECT_TRUE(pool.FindEnumValueByName("Foo.NO_SUCH_VALUE") == NULL); 5108 EXPECT_TRUE(pool.FindMethodByName("TestService.NoSuchMethod") == NULL); 5109 5110 EXPECT_EQ(0, call_counter.call_count_); 5111 } 5112 5113 TEST_F(DatabaseBackedPoolTest, DoesntReloadFilesUncesessarily) { 5114 // If FindFileContainingSymbol() or FindFileContainingExtension() return a 5115 // file that is already in the DescriptorPool, it should not attempt to 5116 // reload the file. 5117 FalsePositiveDatabase false_positive_database(&database_); 5118 MockErrorCollector error_collector; 5119 DescriptorPool pool(&false_positive_database, &error_collector); 5120 5121 // First make sure foo.proto is loaded. 5122 const Descriptor* foo = pool.FindMessageTypeByName("Foo"); 5123 ASSERT_TRUE(foo != NULL); 5124 5125 // Try inducing false positives. 5126 EXPECT_TRUE(pool.FindMessageTypeByName("NoSuchSymbol") == NULL); 5127 EXPECT_TRUE(pool.FindExtensionByNumber(foo, 22) == NULL); 5128 5129 // No errors should have been reported. (If foo.proto was incorrectly 5130 // loaded multiple times, errors would have been reported.) 5131 EXPECT_EQ("", error_collector.text_); 5132 } 5133 5134 // DescriptorDatabase that attempts to induce exponentially-bad performance 5135 // in DescriptorPool. For every positive N, the database contains a file 5136 // fileN.proto, which defines a message MessageN, which contains fields of 5137 // type MessageK for all K in [0,N). Message0 is not defined anywhere 5138 // (file0.proto exists, but is empty), so every other file and message type 5139 // will fail to build. 5140 // 5141 // If the DescriptorPool is not careful to memoize errors, an attempt to 5142 // build a descriptor for MessageN can require O(2^N) time. 5143 class ExponentialErrorDatabase : public DescriptorDatabase { 5144 public: 5145 ExponentialErrorDatabase() {} 5146 ~ExponentialErrorDatabase() {} 5147 5148 // implements DescriptorDatabase --------------------------------- 5149 bool FindFileByName(const string& filename, 5150 FileDescriptorProto* output) { 5151 int file_num = -1; 5152 FullMatch(filename, "file", ".proto", &file_num); 5153 if (file_num > -1) { 5154 return PopulateFile(file_num, output); 5155 } else { 5156 return false; 5157 } 5158 } 5159 bool FindFileContainingSymbol(const string& symbol_name, 5160 FileDescriptorProto* output) { 5161 int file_num = -1; 5162 FullMatch(symbol_name, "Message", "", &file_num); 5163 if (file_num > 0) { 5164 return PopulateFile(file_num, output); 5165 } else { 5166 return false; 5167 } 5168 } 5169 bool FindFileContainingExtension(const string& containing_type, 5170 int field_number, 5171 FileDescriptorProto* output) { 5172 return false; 5173 } 5174 5175 private: 5176 void FullMatch(const string& name, 5177 const string& begin_with, 5178 const string& end_with, 5179 int* file_num) { 5180 int begin_size = begin_with.size(); 5181 int end_size = end_with.size(); 5182 if (name.substr(0, begin_size) != begin_with || 5183 name.substr(name.size()- end_size, end_size) != end_with) { 5184 return; 5185 } 5186 safe_strto32(name.substr(begin_size, name.size() - end_size - begin_size), 5187 file_num); 5188 } 5189 5190 bool PopulateFile(int file_num, FileDescriptorProto* output) { 5191 using strings::Substitute; 5192 GOOGLE_CHECK_GE(file_num, 0); 5193 output->Clear(); 5194 output->set_name(Substitute("file$0.proto", file_num)); 5195 // file0.proto doesn't define Message0 5196 if (file_num > 0) { 5197 DescriptorProto* message = output->add_message_type(); 5198 message->set_name(Substitute("Message$0", file_num)); 5199 for (int i = 0; i < file_num; ++i) { 5200 output->add_dependency(Substitute("file$0.proto", i)); 5201 FieldDescriptorProto* field = message->add_field(); 5202 field->set_name(Substitute("field$0", i)); 5203 field->set_number(i); 5204 field->set_label(FieldDescriptorProto::LABEL_OPTIONAL); 5205 field->set_type(FieldDescriptorProto::TYPE_MESSAGE); 5206 field->set_type_name(Substitute("Message$0", i)); 5207 } 5208 } 5209 return true; 5210 } 5211 }; 5212 5213 TEST_F(DatabaseBackedPoolTest, DoesntReloadKnownBadFiles) { 5214 ExponentialErrorDatabase error_database; 5215 DescriptorPool pool(&error_database); 5216 5217 GOOGLE_LOG(INFO) << "A timeout in this test probably indicates a real bug."; 5218 5219 EXPECT_TRUE(pool.FindFileByName("file40.proto") == NULL); 5220 EXPECT_TRUE(pool.FindMessageTypeByName("Message40") == NULL); 5221 } 5222 5223 TEST_F(DatabaseBackedPoolTest, DoesntFallbackOnWrongType) { 5224 // If a lookup finds a symbol of the wrong type (e.g. we pass a type name 5225 // to FindFieldByName()), we should fail fast, without checking the fallback 5226 // database. 5227 CallCountingDatabase call_counter(&database_); 5228 DescriptorPool pool(&call_counter); 5229 5230 const FileDescriptor* file = pool.FindFileByName("foo.proto"); 5231 ASSERT_TRUE(file != NULL); 5232 const Descriptor* foo = pool.FindMessageTypeByName("Foo"); 5233 ASSERT_TRUE(foo != NULL); 5234 const EnumDescriptor* test_enum = pool.FindEnumTypeByName("TestEnum"); 5235 ASSERT_TRUE(test_enum != NULL); 5236 5237 EXPECT_NE(0, call_counter.call_count_); 5238 call_counter.Clear(); 5239 5240 EXPECT_TRUE(pool.FindMessageTypeByName("TestEnum") == NULL); 5241 EXPECT_TRUE(pool.FindFieldByName("Foo") == NULL); 5242 EXPECT_TRUE(pool.FindExtensionByName("Foo") == NULL); 5243 EXPECT_TRUE(pool.FindEnumTypeByName("Foo") == NULL); 5244 EXPECT_TRUE(pool.FindEnumValueByName("Foo") == NULL); 5245 EXPECT_TRUE(pool.FindServiceByName("Foo") == NULL); 5246 EXPECT_TRUE(pool.FindMethodByName("Foo") == NULL); 5247 5248 EXPECT_EQ(0, call_counter.call_count_); 5249 } 5250 5251 // =================================================================== 5252 5253 class AbortingErrorCollector : public DescriptorPool::ErrorCollector { 5254 public: 5255 AbortingErrorCollector() {} 5256 5257 virtual void AddError( 5258 const string &filename, 5259 const string &element_name, 5260 const Message *message, 5261 ErrorLocation location, 5262 const string &error_message) { 5263 GOOGLE_LOG(FATAL) << "AddError() called unexpectedly: " << filename << ": " 5264 << error_message; 5265 } 5266 private: 5267 GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(AbortingErrorCollector); 5268 }; 5269 5270 // A source tree containing only one file. 5271 class SingletonSourceTree : public compiler::SourceTree { 5272 public: 5273 SingletonSourceTree(const string& filename, const string& contents) 5274 : filename_(filename), contents_(contents) {} 5275 5276 virtual io::ZeroCopyInputStream* Open(const string& filename) { 5277 return filename == filename_ ? 5278 new io::ArrayInputStream(contents_.data(), contents_.size()) : NULL; 5279 } 5280 5281 private: 5282 const string filename_; 5283 const string contents_; 5284 5285 GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(SingletonSourceTree); 5286 }; 5287 5288 const char *const kSourceLocationTestInput = 5289 "syntax = \"proto2\";\n" 5290 "message A {\n" 5291 " optional int32 a = 1;\n" 5292 " message B {\n" 5293 " required double b = 1;\n" 5294 " }\n" 5295 "}\n" 5296 "enum Indecision {\n" 5297 " YES = 1;\n" 5298 " NO = 2;\n" 5299 " MAYBE = 3;\n" 5300 "}\n" 5301 "service S {\n" 5302 " rpc Method(A) returns (A.B);\n" 5303 // Put an empty line here to make the source location range match. 5304 "\n" 5305 "}\n" 5306 "message MessageWithExtensions {\n" 5307 " extensions 1000 to max;\n" 5308 "}\n" 5309 "extend MessageWithExtensions {\n" 5310 " optional int32 int32_extension = 1001;\n" 5311 "}\n" 5312 "message C {\n" 5313 " extend MessageWithExtensions {\n" 5314 " optional C message_extension = 1002;\n" 5315 " }\n" 5316 "}\n"; 5317 5318 class SourceLocationTest : public testing::Test { 5319 public: 5320 SourceLocationTest() 5321 : source_tree_("/test/test.proto", kSourceLocationTestInput), 5322 db_(&source_tree_), 5323 pool_(&db_, &collector_) {} 5324 5325 static string PrintSourceLocation(const SourceLocation &loc) { 5326 return strings::Substitute("$0:$1-$2:$3", 5327 1 + loc.start_line, 5328 1 + loc.start_column, 5329 1 + loc.end_line, 5330 1 + loc.end_column); 5331 } 5332 5333 private: 5334 AbortingErrorCollector collector_; 5335 SingletonSourceTree source_tree_; 5336 compiler::SourceTreeDescriptorDatabase db_; 5337 5338 protected: 5339 DescriptorPool pool_; 5340 }; 5341 5342 // TODO(adonovan): implement support for option fields and for 5343 // subparts of declarations. 5344 5345 TEST_F(SourceLocationTest, GetSourceLocation) { 5346 SourceLocation loc; 5347 5348 const FileDescriptor *file_desc = 5349 GOOGLE_CHECK_NOTNULL(pool_.FindFileByName("/test/test.proto")); 5350 5351 const Descriptor *a_desc = file_desc->FindMessageTypeByName("A"); 5352 EXPECT_TRUE(a_desc->GetSourceLocation(&loc)); 5353 EXPECT_EQ("2:1-7:2", PrintSourceLocation(loc)); 5354 5355 const Descriptor *a_b_desc = a_desc->FindNestedTypeByName("B"); 5356 EXPECT_TRUE(a_b_desc->GetSourceLocation(&loc)); 5357 EXPECT_EQ("4:3-6:4", PrintSourceLocation(loc)); 5358 5359 const EnumDescriptor *e_desc = file_desc->FindEnumTypeByName("Indecision"); 5360 EXPECT_TRUE(e_desc->GetSourceLocation(&loc)); 5361 EXPECT_EQ("8:1-12:2", PrintSourceLocation(loc)); 5362 5363 const EnumValueDescriptor *yes_desc = e_desc->FindValueByName("YES"); 5364 EXPECT_TRUE(yes_desc->GetSourceLocation(&loc)); 5365 EXPECT_EQ("9:3-9:13", PrintSourceLocation(loc)); 5366 5367 const ServiceDescriptor *s_desc = file_desc->FindServiceByName("S"); 5368 EXPECT_TRUE(s_desc->GetSourceLocation(&loc)); 5369 EXPECT_EQ("13:1-16:2", PrintSourceLocation(loc)); 5370 5371 const MethodDescriptor *m_desc = s_desc->FindMethodByName("Method"); 5372 EXPECT_TRUE(m_desc->GetSourceLocation(&loc)); 5373 EXPECT_EQ("14:3-14:31", PrintSourceLocation(loc)); 5374 5375 } 5376 5377 TEST_F(SourceLocationTest, ExtensionSourceLocation) { 5378 SourceLocation loc; 5379 5380 const FileDescriptor *file_desc = 5381 GOOGLE_CHECK_NOTNULL(pool_.FindFileByName("/test/test.proto")); 5382 5383 const FieldDescriptor *int32_extension_desc = 5384 file_desc->FindExtensionByName("int32_extension"); 5385 EXPECT_TRUE(int32_extension_desc->GetSourceLocation(&loc)); 5386 EXPECT_EQ("21:3-21:41", PrintSourceLocation(loc)); 5387 5388 const Descriptor *c_desc = file_desc->FindMessageTypeByName("C"); 5389 EXPECT_TRUE(c_desc->GetSourceLocation(&loc)); 5390 EXPECT_EQ("23:1-27:2", PrintSourceLocation(loc)); 5391 5392 const FieldDescriptor *message_extension_desc = 5393 c_desc->FindExtensionByName("message_extension"); 5394 EXPECT_TRUE(message_extension_desc->GetSourceLocation(&loc)); 5395 EXPECT_EQ("25:5-25:41", PrintSourceLocation(loc)); 5396 } 5397 5398 // Missing SourceCodeInfo doesn't cause crash: 5399 TEST_F(SourceLocationTest, GetSourceLocation_MissingSourceCodeInfo) { 5400 SourceLocation loc; 5401 5402 const FileDescriptor *file_desc = 5403 GOOGLE_CHECK_NOTNULL(pool_.FindFileByName("/test/test.proto")); 5404 5405 FileDescriptorProto proto; 5406 file_desc->CopyTo(&proto); // Note, this discards the SourceCodeInfo. 5407 EXPECT_FALSE(proto.has_source_code_info()); 5408 5409 DescriptorPool bad1_pool(&pool_); 5410 const FileDescriptor* bad1_file_desc = 5411 GOOGLE_CHECK_NOTNULL(bad1_pool.BuildFile(proto)); 5412 const Descriptor *bad1_a_desc = bad1_file_desc->FindMessageTypeByName("A"); 5413 EXPECT_FALSE(bad1_a_desc->GetSourceLocation(&loc)); 5414 } 5415 5416 // Corrupt SourceCodeInfo doesn't cause crash: 5417 TEST_F(SourceLocationTest, GetSourceLocation_BogusSourceCodeInfo) { 5418 SourceLocation loc; 5419 5420 const FileDescriptor *file_desc = 5421 GOOGLE_CHECK_NOTNULL(pool_.FindFileByName("/test/test.proto")); 5422 5423 FileDescriptorProto proto; 5424 file_desc->CopyTo(&proto); // Note, this discards the SourceCodeInfo. 5425 EXPECT_FALSE(proto.has_source_code_info()); 5426 SourceCodeInfo_Location *loc_msg = 5427 proto.mutable_source_code_info()->add_location(); 5428 loc_msg->add_path(1); 5429 loc_msg->add_path(2); 5430 loc_msg->add_path(3); 5431 loc_msg->add_span(4); 5432 loc_msg->add_span(5); 5433 loc_msg->add_span(6); 5434 5435 DescriptorPool bad2_pool(&pool_); 5436 const FileDescriptor* bad2_file_desc = 5437 GOOGLE_CHECK_NOTNULL(bad2_pool.BuildFile(proto)); 5438 const Descriptor *bad2_a_desc = bad2_file_desc->FindMessageTypeByName("A"); 5439 EXPECT_FALSE(bad2_a_desc->GetSourceLocation(&loc)); 5440 } 5441 5442 // =================================================================== 5443 5444 const char* const kCopySourceCodeInfoToTestInput = 5445 "syntax = \"proto2\";\n" 5446 "message Foo {}\n"; 5447 5448 // Required since source code information is not preserved by 5449 // FileDescriptorTest. 5450 class CopySourceCodeInfoToTest : public testing::Test { 5451 public: 5452 CopySourceCodeInfoToTest() 5453 : source_tree_("/test/test.proto", kCopySourceCodeInfoToTestInput), 5454 db_(&source_tree_), 5455 pool_(&db_, &collector_) {} 5456 5457 private: 5458 AbortingErrorCollector collector_; 5459 SingletonSourceTree source_tree_; 5460 compiler::SourceTreeDescriptorDatabase db_; 5461 5462 protected: 5463 DescriptorPool pool_; 5464 }; 5465 5466 TEST_F(CopySourceCodeInfoToTest, CopyTo_DoesNotCopySourceCodeInfo) { 5467 const FileDescriptor* file_desc = 5468 GOOGLE_CHECK_NOTNULL(pool_.FindFileByName("/test/test.proto")); 5469 FileDescriptorProto file_desc_proto; 5470 ASSERT_FALSE(file_desc_proto.has_source_code_info()); 5471 5472 file_desc->CopyTo(&file_desc_proto); 5473 EXPECT_FALSE(file_desc_proto.has_source_code_info()); 5474 } 5475 5476 TEST_F(CopySourceCodeInfoToTest, CopySourceCodeInfoTo) { 5477 const FileDescriptor* file_desc = 5478 GOOGLE_CHECK_NOTNULL(pool_.FindFileByName("/test/test.proto")); 5479 FileDescriptorProto file_desc_proto; 5480 ASSERT_FALSE(file_desc_proto.has_source_code_info()); 5481 5482 file_desc->CopySourceCodeInfoTo(&file_desc_proto); 5483 const SourceCodeInfo& info = file_desc_proto.source_code_info(); 5484 ASSERT_EQ(3, info.location_size()); 5485 // Get the Foo message location 5486 const SourceCodeInfo_Location& foo_location = info.location(1); 5487 ASSERT_EQ(2, foo_location.path_size()); 5488 EXPECT_EQ(FileDescriptorProto::kMessageTypeFieldNumber, foo_location.path(0)); 5489 EXPECT_EQ(0, foo_location.path(1)); // Foo is the first message defined 5490 ASSERT_EQ(3, foo_location.span_size()); // Foo spans one line 5491 EXPECT_EQ(1, foo_location.span(0)); // Foo is declared on line 1 5492 EXPECT_EQ(0, foo_location.span(1)); // Foo starts at column 0 5493 EXPECT_EQ(14, foo_location.span(2)); // Foo ends on column 14 5494 } 5495 5496 // =================================================================== 5497 5498 5499 } // namespace descriptor_unittest 5500 } // namespace protobuf 5501 } // namespace google 5502
