Lines Matching defs:message
207 const std::string& message) {
246 element_name, location_name, message);
252 const std::string& message) {
292 message);
305 // message FooMessage { extensions 1; }
312 // message BarMessage { extensions 1; }
567 void AddError(int line, int column, const std::string& message) {
568 last_error_ = StringPrintf("%d:%d:", line, column) + message;
620 // message TestForeign {}
623 // message TestMessage {
632 // message TestMessage2 {
639 // message TestMessage3 {
644 // message TestMessage4 {
668 DescriptorProto* message = AddMessage(&foo_file, "TestMessage");
669 AddField(message, "foo", 1, FieldDescriptorProto::LABEL_REQUIRED,
671 AddField(message, "bar", 6, FieldDescriptorProto::LABEL_OPTIONAL,
674 AddField(message, "baz", 500000000, FieldDescriptorProto::LABEL_REPEATED,
677 AddField(message, "qux", 15, FieldDescriptorProto::LABEL_OPTIONAL,
771 void CopyWithJsonName(const Descriptor* message, DescriptorProto* proto) {
772 message->CopyTo(proto);
773 message->CopyJsonNameTo(proto);
828 // of the message, we need to test that it does *not* find the fields of
1062 // message TestOneof {
1155 DescriptorProto* message = AddMessage(&file, "TestMessage");
1156 AddField(message, "foo_foo", 1, FieldDescriptorProto::LABEL_OPTIONAL,
1158 AddField(message, "FooBar", 2, FieldDescriptorProto::LABEL_OPTIONAL,
1160 AddField(message, "fooBaz", 3, FieldDescriptorProto::LABEL_OPTIONAL,
1162 AddField(message, "fooFoo", 4, // Camel-case conflict with foo_foo.
1165 AddField(message, "foobar", 5, // Lower-case conflict with FooBar.
1169 AddNestedExtension(message, "ExtendableMessage", "bar_foo", 1,
1172 AddNestedExtension(message, "ExtendableMessage", "BarBar", 2,
1175 AddNestedExtension(message, "ExtendableMessage", "BarBaz", 3,
1178 AddNestedExtension(message, "ExtendableMessage", "barFoo", 4, // Conflict
1181 AddNestedExtension(message, "ExtendableMessage", "barbar", 5, // Conflict
1472 // message FooRequest {}
1473 // message FooResponse {}
1474 // message BarRequest {}
1475 // message BarResponse {}
1476 // message BazRequest {}
1477 // message BazResponse {}
1634 // message TestMessage {
1635 // message Foo {}
1636 // message Bar {}
1643 // message TestMessage2 {
1644 // message Foo {}
1645 // message Baz {}
1655 // values across a message's scope.
1660 DescriptorProto* message = AddMessage(&foo_file, "TestMessage");
1661 AddNestedMessage(message, "Foo");
1662 AddNestedMessage(message, "Bar");
1663 EnumDescriptorProto* baz = AddNestedEnum(message, "Baz");
1665 EnumDescriptorProto* qux = AddNestedEnum(message, "Qux");
1848 // message Qux {}
1850 // message Foo {
1856 // message Bar {
2075 // message Foo {
2286 DescriptorProto* message = AddMessage(&file_proto, "TestMessage");
2288 message, "foo", 1, FieldDescriptorProto::LABEL_OPTIONAL,
2356 EXPECT_STREQ("message", GetTypeNameForFieldType(FD::TYPE_MESSAGE));
2381 EXPECT_STREQ("message", FD::TypeName(FD::TYPE_MESSAGE));
2430 EXPECT_STREQ("message", GetCppTypeNameForFieldType(FD::TYPE_GROUP));
2431 EXPECT_STREQ("message", GetCppTypeNameForFieldType(FD::TYPE_MESSAGE));
2455 EXPECT_STREQ("message", FD::CppTypeName(FD::CPPTYPE_MESSAGE));
2577 const Descriptor* message = file->message_type(0);
2579 ASSERT_EQ(21, message->field_count());
2582 ASSERT_TRUE(message->field(0)->has_default_value());
2583 ASSERT_TRUE(message->field(1)->has_default_value());
2584 ASSERT_TRUE(message->field(2)->has_default_value());
2585 ASSERT_TRUE(message->field(3)->has_default_value());
2586 ASSERT_TRUE(message->field(4)->has_default_value());
2587 ASSERT_TRUE(message->field(5)->has_default_value());
2588 ASSERT_TRUE(message->field(6)->has_default_value());
2589 ASSERT_TRUE(message->field(7)->has_default_value());
2590 ASSERT_TRUE(message->field(8)->has_default_value());
2591 ASSERT_TRUE(message->field(9)->has_default_value());
2592 ASSERT_TRUE(message->field(10)->has_default_value());
2594 EXPECT_EQ(-1, message->field(0)->default_value_int32());
2595 EXPECT_EQ(int64{-1000000000000}, message->field(1)->default_value_int64());
2596 EXPECT_EQ(42, message->field(2)->default_value_uint32());
2597 EXPECT_EQ(uint64{2000000000000}, message->field(3)->default_value_uint64());
2598 EXPECT_EQ(4.5, message->field(4)->default_value_float());
2599 EXPECT_EQ(10e100, message->field(5)->default_value_double());
2600 EXPECT_TRUE(message->field(6)->default_value_bool());
2601 EXPECT_EQ("hello", message->field(7)->default_value_string());
2602 EXPECT_EQ("\001\002\003", message->field(8)->default_value_string());
2603 EXPECT_EQ(enum_value_b, message->field(9)->default_value_enum());
2604 EXPECT_EQ("", message->field(10)->default_value_string());
2606 ASSERT_FALSE(message->field(11)->has_default_value());
2607 ASSERT_FALSE(message->field(12)->has_default_value());
2608 ASSERT_FALSE(message->field(13)->has_default_value());
2609 ASSERT_FALSE(message->field(14)->has_default_value());
2610 ASSERT_FALSE(message->field(15)->has_default_value());
2611 ASSERT_FALSE(message->field(16)->has_default_value());
2612 ASSERT_FALSE(message->field(17)->has_default_value());
2613 ASSERT_FALSE(message->field(18)->has_default_value());
2614 ASSERT_FALSE(message->field(19)->has_default_value());
2615 ASSERT_FALSE(message->field(20)->has_default_value());
2617 EXPECT_EQ(0, message->field(11)->default_value_int32());
2618 EXPECT_EQ(0, message->field(12)->default_value_int64());
2619 EXPECT_EQ(0, message->field(13)->default_value_uint32());
2620 EXPECT_EQ(0, message->field(14)->default_value_uint64());
2621 EXPECT_EQ(0.0f, message->field(15)->default_value_float());
2622 EXPECT_EQ(0.0, message->field(16)->default_value_double());
2623 EXPECT_FALSE(message->field(17)->default_value_bool());
2624 EXPECT_EQ("", message->field(18)->default_value_string());
2625 EXPECT_EQ("", message->field(19)->default_value_string());
2626 EXPECT_EQ(enum_value_a, message->field(20)->default_value_enum());
2651 const Descriptor* message = file->message_type(0);
2653 ASSERT_EQ(2, message->field_count());
2654 const FieldDescriptor* foo = message->field(0);
2655 const FieldDescriptor* bar = message->field(1);
2999 const Descriptor* message =
3001 const FileDescriptor* file = message->file();
3002 const FieldDescriptor* field = message->FindFieldByName("field1");
3003 const OneofDescriptor* oneof = message->FindOneofByName("AnOneof");
3004 const EnumDescriptor* enm = message->FindEnumTypeByName("AnEnum");
3013 message->options().GetExtension(protobuf_unittest::message_opt1));
3028 EXPECT_TRUE(message->options().has_message_set_wire_format());
3199 // bug occurred when you defined a custom option with message type and then
3217 // message Foo {
3294 // message Foo {
3357 // This test checks repeated message values. Each repeated custom value
3374 // message Foo {
3532 // Add a test message that uses the "required_enum_opt" option.
3544 // test message with an enum value that only exists in NewOptionType.
4036 "message Foo {\n"
4063 "message Foo {\n"
4252 // Same thing, but we don't know that this field has message type until
4552 // Also use the empty enum in a message to make sure there are no crashes
4591 "foo.proto: Foo.foo: EXTENDEE: \"Bar\" is not a message type.\n");
4645 // error message. We want this input to yield a validation error instead,
4692 // message Bar{}
4699 // message Foo {
4727 // message Bar{}
4734 // message Foo {
4762 // message Bar{}
4772 // message Foo {
4804 // message Bar{}
4814 // message Foo {
4849 // message Bar { message Baz {} }
4850 // message Foo {
4851 // message Bar {
4852 // // Placing "message Baz{}" here, or removing Foo.Bar altogether,
4906 // message Bar {}
4910 // message Baz { optional bar.Bar qux = 1; }
5002 "foo.proto: Foo.foo: TYPE: \"Bar\" is not a message type.\n");
5053 "foo.proto: Foo.foo: TYPE: Field with message or enum type missing "
5105 "foo.proto: TestService.A: INPUT_TYPE: \"Bar\" is not a message type.\n"
5132 "foo.proto: TestService.A: OUTPUT_TYPE: \"Bar\" is not a message type.\n"
5200 "atomic type, not a message.\n");
5261 "repeated message. Repeated message options must be initialized "
5271 // message Bar { optional int32 foo = 1; }
5659 "foo.proto: foo.proto: OPTION_VALUE: Option \"foo\" is a message. "
5660 "To set the entire message, use syntax like "
5863 // import "base.proto" // No warning: Base message is used.
5867 // message Forward {
5919 "bytes or message types.\n";
6009 // Move the nested MapEntry message into the top level, which should not pass
6175 "with an existing nested message type.\n");
6521 "enum, but is used in \"Foo\" which is a proto3 message type.\n");
7008 // fileN.proto, which defines a message MessageN, which contains fields of
7010 // (file0.proto exists, but is empty), so every other file and message type
7066 DescriptorProto* message = output->add_message_type();
7067 message->set_name(strings::Substitute("Message$0", file_num));
7070 FieldDescriptorProto* field = message->add_field();
7127 const std::string& element_name, const Message* message,
7161 "message A {\n"
7164 " message B {\n"
7194 "message MessageWithExtensions {\n"
7200 "message C {\n"
7267 // tag number of field "a" in message type "A" in above test file
7405 // Nested message option
7496 // option w/ message type that directly sets field
7743 "message Foo {}\n";
7782 // Get the Foo message location
7786 EXPECT_EQ(0, foo_location.path(1)); // Foo is the first message defined
7883 // build the file where the message is defined, and get a valid descriptor
7951 // Verify calling type() on a field that is a message type will
7961 // Verify calling cpp_type() on a field that is a message type will