// Protocol Buffers - Google's data interchange format

// Copyright 2008 Google Inc. All rights reserved.

//

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file or at

// https://developers.google.com/open-source/licenses/bsd

// Author: kenton@google.com (Kenton Varda)

// Based on original Protocol Buffers design by

// Sanjay Ghemawat, Jeff Dean, and others.

//

// A proto file we will use for unit testing. See comments in

// edition_message_unittest.cc before adding new features.

//

// LINT: ALLOW_GROUPS, LEGACY_NAMES

edition = "2024";

import "google/protobuf/unittest_import.proto";

import option "google/protobuf/cpp_features.proto";

option features.field_presence = EXPLICIT;

option features.enum_type = CLOSED;

// Some generic_services option(s) added automatically.

// See: http://go/proto2-generic-services-default

option cc_generic_services = true; // auto-added

option java_generic_services = true; // auto-added

option py_generic_services = true; // auto-added

option cc_enable_arenas = true;

// We don't put this in a package within proto2 because we need to make sure

// that the generated code doesn't depend on being in the proto2 namespace.

// In test_util.h we do "using namespace unittest = edition_unittest".

package edition_unittest;

// Protos optimized for SPEED use a strict superset of the generated code

// of equivalent ones optimized for CODE_SIZE, so we should optimize all our

// tests for speed unless explicitly testing code size optimization.

option optimize_for = SPEED;

// This proto includes every type of field in both singular and repeated

// forms.

message TestAllTypes {

message NestedMessage {

// The field name "b" fails to compile in proto1 because it conflicts with

// a local variable named "b" in one of the generated methods. Doh.

// This file needs to compile in proto1 to test backwards-compatibility.

int32 bb = 1;

}

enum NestedEnum {

FOO = 1;

BAR = 2;

BAZ = 3;

NEG = -1; // Intentionally negative.

}

// Singular

int32 optional_int32 = 1;

int64 optional_int64 = 2;

uint32 optional_uint32 = 3;

uint64 optional_uint64 = 4;

sint32 optional_sint32 = 5;

sint64 optional_sint64 = 6;

fixed32 optional_fixed32 = 7;

fixed64 optional_fixed64 = 8;

sfixed32 optional_sfixed32 = 9;

sfixed64 optional_sfixed64 = 10;

float optional_float = 11;

double optional_double = 12;

bool optional_bool = 13;

string optional_string = 14;

bytes optional_bytes = 15;

message OptionalGroup {

int32 a = 17;

}

OptionalGroup optionalgroup = 16

[features.message_encoding = DELIMITED];

NestedMessage optional_nested_message = 18;

ForeignMessage optional_foreign_message = 19;

proto2_unittest_import.ImportMessage optional_import_message = 20;

NestedEnum optional_nested_enum = 21;

ForeignEnum optional_foreign_enum = 22;

proto2_unittest_import.ImportEnum optional_import_enum = 23;

string optional_string_piece = 24;

string optional_cord = 25 [features.(pb.cpp).string_type=CORD];

bytes optional_bytes_cord = 86 [features.(pb.cpp).string_type=CORD];

// Defined in unittest_import_public.proto

proto2_unittest_import.PublicImportMessage

optional_public_import_message = 26;

NestedMessage optional_lazy_message = 27 [lazy=true];

NestedMessage optional_unverified_lazy_message = 28 [unverified_lazy=true];

// Repeated

repeated int32 repeated_int32 = 31;

repeated int64 repeated_int64 = 32;

repeated uint32 repeated_uint32 = 33;

repeated uint64 repeated_uint64 = 34;

repeated sint32 repeated_sint32 = 35;

repeated sint64 repeated_sint64 = 36;

repeated fixed32 repeated_fixed32 = 37;

repeated fixed64 repeated_fixed64 = 38;

repeated sfixed32 repeated_sfixed32 = 39;

repeated sfixed64 repeated_sfixed64 = 40;

repeated float repeated_float = 41;

repeated double repeated_double = 42;

repeated bool repeated_bool = 43;

repeated string repeated_string = 44;

repeated bytes repeated_bytes = 45;

message RepeatedGroup {

int32 a = 47;

}

repeated RepeatedGroup repeatedgroup = 46

[features.message_encoding = DELIMITED];

repeated NestedMessage repeated_nested_message = 48;

repeated ForeignMessage repeated_foreign_message = 49;

repeated proto2_unittest_import.ImportMessage repeated_import_message = 50;

repeated NestedEnum repeated_nested_enum = 51;

repeated ForeignEnum repeated_foreign_enum = 52;

repeated proto2_unittest_import.ImportEnum repeated_import_enum = 53;

repeated string repeated_string_piece = 54;

repeated string repeated_cord = 55 [features.(pb.cpp).string_type=CORD];

repeated NestedMessage repeated_lazy_message = 57 ;

// Singular with defaults

int32 default_int32 = 61 [default = 41 ];

int64 default_int64 = 62 [default = 42 ];

uint32 default_uint32 = 63 [default = 43 ];

uint64 default_uint64 = 64 [default = 44 ];

sint32 default_sint32 = 65 [default = -45 ];

sint64 default_sint64 = 66 [default = 46 ];

fixed32 default_fixed32 = 67 [default = 47 ];

fixed64 default_fixed64 = 68 [default = 48 ];

sfixed32 default_sfixed32 = 69 [default = 49 ];

sfixed64 default_sfixed64 = 70 [default = -50 ];

float default_float = 71 [default = 51.5 ];

double default_double = 72 [default = 52e3 ];

bool default_bool = 73 [default = true ];

string default_string = 74 [default = "hello"];

bytes default_bytes = 75 [default = "world"];

NestedEnum default_nested_enum = 81 [default = BAR ];

ForeignEnum default_foreign_enum = 82 [default = FOREIGN_BAR];

proto2_unittest_import.ImportEnum

default_import_enum = 83 [default = IMPORT_BAR];

string default_string_piece = 84 [default="abc"];

string default_cord = 85 [features.(pb.cpp).string_type=CORD,default="123"];

// For oneof test

oneof oneof_field {

uint32 oneof_uint32 = 111;

NestedMessage oneof_nested_message = 112;

string oneof_string = 113;

bytes oneof_bytes = 114;

string oneof_cord = 115 [features.(pb.cpp).string_type=CORD];

string oneof_string_piece = 116;

NestedMessage oneof_lazy_nested_message = 117 [lazy=true];

}

}

// This proto includes a recursively nested message.

message NestedTestAllTypes {

NestedTestAllTypes child = 1;

TestAllTypes payload = 2;

repeated NestedTestAllTypes repeated_child = 3;

NestedTestAllTypes lazy_child = 4 [lazy=true];

TestAllTypes eager_child = 5 [lazy=false];

}

message TestDeprecatedFields {

int32 deprecated_int32 = 1 [deprecated=true];

repeated string deprecated_repeated_string = 4 [deprecated=true];

TestAllTypes.NestedMessage deprecated_message = 3 [deprecated=true];

oneof oneof_fields {

int32 deprecated_int32_in_oneof = 2 [deprecated=true];

}

TestDeprecatedFields nested = 5;

}

message TestDeprecatedMessage {

option deprecated = true;

}

// Define these after TestAllTypes to make sure the compiler can handle that.

message ForeignMessage {

int32 c = 1;

int32 d = 2;

}

enum ForeignEnum {

FOREIGN_FOO = 4;

FOREIGN_BAR = 5;

FOREIGN_BAZ = 6;

FOREIGN_BAX = 32; // (1 << 32) to generate a 64b bitmask would be incorrect.

}

message TestReservedFields {

reserved 2, 15, 9 to 11;

reserved bar, baz;

}

enum TestReservedEnumFields {

UNKNOWN = 0;

reserved 2, 15, 9 to 11;

reserved bar, baz;

}

message TestAllExtensions {

extensions 1 to max;

}

message OptionalGroup_extension {

option features.enforce_naming_style = STYLE_LEGACY;

int32 a = 17;

}

message RepeatedGroup_extension {

option features.enforce_naming_style = STYLE_LEGACY;

int32 a = 47;

}

extend TestAllExtensions {

// Singular

int32 optional_int32_extension = 1;

int64 optional_int64_extension = 2;

uint32 optional_uint32_extension = 3;

uint64 optional_uint64_extension = 4;

sint32 optional_sint32_extension = 5;

sint64 optional_sint64_extension = 6;

fixed32 optional_fixed32_extension = 7;

fixed64 optional_fixed64_extension = 8;

sfixed32 optional_sfixed32_extension = 9;

sfixed64 optional_sfixed64_extension = 10;

float optional_float_extension = 11;

double optional_double_extension = 12;

bool optional_bool_extension = 13;

string optional_string_extension = 14;

bytes optional_bytes_extension = 15;

OptionalGroup_extension optionalgroup_extension = 16

[features.message_encoding = DELIMITED];

TestAllTypes.NestedMessage optional_nested_message_extension = 18;

ForeignMessage optional_foreign_message_extension = 19;

proto2_unittest_import.ImportMessage

optional_import_message_extension = 20;

TestAllTypes.NestedEnum optional_nested_enum_extension = 21;

ForeignEnum optional_foreign_enum_extension = 22;

proto2_unittest_import.ImportEnum

optional_import_enum_extension = 23;

string optional_string_piece_extension = 24;

// TODO: ctype=CORD is not supported for extension. Add

// ctype=CORD option back after it is supported.

string optional_cord_extension = 25;

bytes optional_bytes_cord_extension = 86;

proto2_unittest_import.PublicImportMessage

optional_public_import_message_extension = 26;

TestAllTypes.NestedMessage

optional_lazy_message_extension = 27 [lazy=true];

// "unverified_lazy" is copied from the counterpart field in TestAllTypes.

// An extension can't be labeled as "unverified_lazy".

TestAllTypes.NestedMessage

optional_unverified_lazy_message_extension = 28;

// Repeated

repeated int32 repeated_int32_extension = 31;

repeated int64 repeated_int64_extension = 32;

repeated uint32 repeated_uint32_extension = 33;

repeated uint64 repeated_uint64_extension = 34;

repeated sint32 repeated_sint32_extension = 35;

repeated sint64 repeated_sint64_extension = 36;

repeated fixed32 repeated_fixed32_extension = 37;

repeated fixed64 repeated_fixed64_extension = 38;

repeated sfixed32 repeated_sfixed32_extension = 39;

repeated sfixed64 repeated_sfixed64_extension = 40;

repeated float repeated_float_extension = 41;

repeated double repeated_double_extension = 42;

repeated bool repeated_bool_extension = 43;

repeated string repeated_string_extension = 44;

repeated bytes repeated_bytes_extension = 45;

repeated RepeatedGroup_extension repeatedgroup_extension = 46

[features.message_encoding = DELIMITED];

repeated TestAllTypes.NestedMessage repeated_nested_message_extension = 48;

repeated ForeignMessage repeated_foreign_message_extension = 49;

repeated proto2_unittest_import.ImportMessage

repeated_import_message_extension = 50;

repeated TestAllTypes.NestedEnum repeated_nested_enum_extension = 51;

repeated ForeignEnum repeated_foreign_enum_extension = 52;

repeated proto2_unittest_import.ImportEnum

repeated_import_enum_extension = 53;

repeated string repeated_string_piece_extension = 54;

// TODO: ctype=CORD is not supported for extension. Add

// ctype=CORD option back after it is supported.

repeated string repeated_cord_extension = 55;

repeated TestAllTypes.NestedMessage

repeated_lazy_message_extension = 57 [lazy=true];

// Singular with defaults

int32 default_int32_extension = 61 [default = 41 ];

int64 default_int64_extension = 62 [default = 42 ];

uint32 default_uint32_extension = 63 [default = 43 ];

uint64 default_uint64_extension = 64 [default = 44 ];

sint32 default_sint32_extension = 65 [default = -45 ];

sint64 default_sint64_extension = 66 [default = 46 ];

fixed32 default_fixed32_extension = 67 [default = 47 ];

fixed64 default_fixed64_extension = 68 [default = 48 ];

sfixed32 default_sfixed32_extension = 69 [default = 49 ];

sfixed64 default_sfixed64_extension = 70 [default = -50 ];

float default_float_extension = 71 [default = 51.5 ];

double default_double_extension = 72 [default = 52e3 ];

bool default_bool_extension = 73 [default = true ];

string default_string_extension = 74 [default = "hello"];

bytes default_bytes_extension = 75 [default = "world"];

TestAllTypes.NestedEnum

default_nested_enum_extension = 81 [default = BAR];

ForeignEnum

default_foreign_enum_extension = 82 [default = FOREIGN_BAR];

proto2_unittest_import.ImportEnum

default_import_enum_extension = 83 [default = IMPORT_BAR];

string default_string_piece_extension = 84 [default="abc"];

// TODO: ctype=CORD is not supported for extension. Add

// ctype=CORD option back after it is supported.

string default_cord_extension = 85 [default="123"];

// For oneof test

uint32 oneof_uint32_extension = 111;

TestAllTypes.NestedMessage oneof_nested_message_extension = 112;

string oneof_string_extension = 113;

bytes oneof_bytes_extension = 114;

}

message TestMixedFieldsAndExtensions {

int32 a = 1;

repeated fixed32 b = 3;

extensions 2, 4;

extend TestMixedFieldsAndExtensions {

int32 c = 2;

repeated fixed32 d = 4;

}

}

message TestGroup {

message OptionalGroup {

int32 a = 17;

int32 zz = 89; // fast table size must be at least 16, for this

// field to be parsed by the fast parser, since

// 89 - 17 = 72 is a multiple of 8.

}

OptionalGroup optionalgroup = 16 [features.message_encoding = DELIMITED];

ForeignEnum optional_foreign_enum = 22;

}

message TestGroupExtension {

extensions 1 to max;

}

message TestNestedExtension {

extend TestAllExtensions {

// Check for bug where string extensions declared in tested scope did not

// compile.

string test = 1002 [default="test"];

// Used to test if generated extension name is correct when there are

// underscores.

string nested_string_extension = 1003;

}

message OptionalGroup_extension {

option features.enforce_naming_style = STYLE_LEGACY;

int32 a = 17;

}

extend TestGroupExtension {

OptionalGroup_extension optionalgroup_extension = 16

[features.message_encoding = DELIMITED];

ForeignEnum optional_foreign_enum_extension = 22;

}

}

message TestChildExtension {

string a = 1;

string b = 2;

TestAllExtensions optional_extension = 3;

}

// Emulates wireformat data of TestChildExtension with dynamic extension

// (DynamicExtension).

message TestChildExtensionData {

message NestedTestAllExtensionsData {

message NestedDynamicExtensions {

int32 a = 1;

int32 b = 2;

}

NestedDynamicExtensions dynamic = 409707008;

}

string a = 1;

string b = 2;

NestedTestAllExtensionsData optional_extension = 3;

}

message TestNestedChildExtension {

int32 a = 1;

TestChildExtension child = 2;

}

// Emulates wireformat data of TestNestedChildExtension with dynamic extension

// (DynamicExtension).

message TestNestedChildExtensionData {

int32 a = 1;

TestChildExtensionData child = 2;

}

// Required and closed enum fields are considered unknown fields if the value is

// not valid. We need to make sure it functions as expected.

message TestRequiredEnum {

ForeignEnum required_enum = 1 [features.field_presence = LEGACY_REQUIRED];

// A dummy optional field.

int32 a = 2;

}

// TestRequiredEnum + using enum values that won't fit to 64 bitmask.

message TestRequiredEnumNoMask {

enum NestedEnum {

UNSPECIFIED = 0;

FOO = 2;

BAR = 100;

BAZ = -1; // Intentionally negative.

}

NestedEnum required_enum = 1 [features.field_presence = LEGACY_REQUIRED];

// A dummy optional field.

int32 a = 2;

}

message TestRequiredEnumMulti {

enum NestedEnum {

UNSPECIFIED = 0;

FOO = 1;

BAR = 2;

BAZ = 100;

}

option features.enforce_naming_style = STYLE_LEGACY;

// Intentionally placed in descending field number to force sorting in closed

// enum verification.

NestedEnum required_enum_4 = 4 [features.field_presence = LEGACY_REQUIRED];

int32 a_3 = 3;

NestedEnum required_enum_2 = 2 [features.field_presence = LEGACY_REQUIRED];

ForeignEnum required_enum_1 = 1 [features.field_presence = LEGACY_REQUIRED];

}

message TestRequiredNoMaskMulti {

enum NestedEnum {

UNSPECIFIED = 0;

FOO = 1;

BAR = 2;

BAZ = 100;

}

option features.enforce_naming_style = STYLE_LEGACY;

// Intentionally placed in descending field number to force sorting in closed

// enum verification. Also, using large field numbers to use tag only

// matching for fields.

fixed32 required_fixed32_80 = 80 [features.field_presence = LEGACY_REQUIRED];

fixed32 required_fixed32_70 = 70 [features.field_presence = LEGACY_REQUIRED];

NestedEnum required_enum_64 = 64 [features.field_presence = LEGACY_REQUIRED];

NestedEnum required_enum_4 = 4 [features.field_presence = LEGACY_REQUIRED];

int32 a_3 = 3;

NestedEnum required_enum_2 = 2 [features.field_presence = LEGACY_REQUIRED];

ForeignEnum required_enum_1 = 1 [features.field_presence = LEGACY_REQUIRED];

}

// We have separate messages for testing fields because it's

// annoying to have to fill in fields in TestProto in order to

// do anything with it. Note that we don't need to test every type of

// filed because the code output is basically identical to

// optional fields for all types.

message TestRequired {

int32 a = 1 [features.field_presence = LEGACY_REQUIRED];

int32 dummy2 = 2;

int32 b = 3 [features.field_presence = LEGACY_REQUIRED];

extend TestAllExtensions {

TestRequired single = 1000;

repeated TestRequired multi = 1001;

}

// Pad the field count to 32 so that we can test that IsInitialized()

// properly checks multiple elements of has_bits_.

int32 dummy4 = 4;

int32 dummy5 = 5;

int32 dummy6 = 6;

int32 dummy7 = 7;

int32 dummy8 = 8;

int32 dummy9 = 9;

int32 dummy10 = 10;

int32 dummy11 = 11;

int32 dummy12 = 12;

int32 dummy13 = 13;

int32 dummy14 = 14;

int32 dummy15 = 15;

int32 dummy16 = 16;

int32 dummy17 = 17;

int32 dummy18 = 18;

int32 dummy19 = 19;

int32 dummy20 = 20;

int32 dummy21 = 21;

int32 dummy22 = 22;

int32 dummy23 = 23;

int32 dummy24 = 24;

int32 dummy25 = 25;

int32 dummy26 = 26;

int32 dummy27 = 27;

int32 dummy28 = 28;

int32 dummy29 = 29;

int32 dummy30 = 30;

int32 dummy31 = 31;

int32 dummy32 = 32;

int32 c = 33 [features.field_presence = LEGACY_REQUIRED];

// Add an optional child message to make this non-trivial for go/pdlazy.

ForeignMessage optional_foreign = 34;

}

message TestRequiredForeign {

TestRequired optional_message = 1;

repeated TestRequired repeated_message = 2;

int32 dummy = 3;

// Missing fields must not affect verification of child messages.

NestedTestAllTypes optional_lazy_message = 4 [lazy = true];

}

message TestRequiredMessage {

TestRequired optional_message = 1;

repeated TestRequired repeated_message = 2;

TestRequired required_message = 3 [features.field_presence = LEGACY_REQUIRED];

}

message TestNestedRequiredForeign {

TestNestedRequiredForeign child = 1;

TestRequiredForeign payload = 2;

int32 dummy = 3;

// optional message to test closed enum.

TestRequiredEnum required_enum = 5;

TestRequiredEnumNoMask required_enum_no_mask = 6;

TestRequiredEnumMulti required_enum_multi = 7;

TestRequiredNoMaskMulti required_no_mask = 9;

}

// Test that we can use NestedMessage from outside TestAllTypes.

message TestForeignNested {

TestAllTypes.NestedMessage foreign_nested = 1;

}

// TestEmptyMessage is used to test unknown field support.

message TestEmptyMessage {

}

// Like above, but declare all field numbers as potential extensions. No

// actual extensions should ever be defined for this type.

message TestEmptyMessageWithExtensions {

extensions 1 to max;

}

// Needed for a Python test.

message TestPickleNestedMessage {

message NestedMessage {

int32 bb = 1;

message NestedNestedMessage {

int32 cc = 1;

}

}

}

message TestMultipleExtensionRanges {

extensions 42;

extensions 4143 to 4243;

extensions 65536 to max;

}

// Test that really large tag numbers don't break anything.

message TestReallyLargeTagNumber {

// The largest possible tag number is 2^28 - 1, since the wire format uses

// three bits to communicate wire type.

int32 a = 1;

int32 bb = 268435455;

}

message TestRecursiveMessage {

TestRecursiveMessage a = 1;

int32 i = 2;

}

// Test that mutual recursion works.

message TestMutualRecursionA {

message SubMessage {

TestMutualRecursionB b = 1;

}

TestMutualRecursionB bb = 1;

message SubGroup {

SubMessage sub_message = 3; // Needed because of bug in javatest

TestAllTypes not_in_this_scc = 4;

}

SubGroup subgroup = 2 [features.message_encoding = DELIMITED];

message SubGroupR {

TestAllTypes payload = 6;

}

repeated SubGroupR subgroupr = 5 [features.message_encoding = DELIMITED];

}

message TestMutualRecursionB {

TestMutualRecursionA a = 1;

int32 optional_int32 = 2;

}

message TestIsInitialized {

message SubMessage {

message SubGroup {

int32 i = 2 [features.field_presence = LEGACY_REQUIRED];

}

SubGroup subgroup = 1 [features.message_encoding = DELIMITED];

}

SubMessage sub_message = 1;

}

// Test that groups have disjoint field numbers from their siblings and

// parents. This is NOT possible in proto1; only google.protobuf. When attempting

// to compile with proto1, this will emit an error; so we only include it

// in proto2_unittest_proto.

message TestDupFieldNumber { // NO_PROTO1

int32 a = 1; // NO_PROTO1

message Foo { int32 a = 1; } // NO_PROTO1

message Bar { int32 a = 1; } // NO_PROTO1

Foo foo = 2 [features.message_encoding = DELIMITED];

Bar bar = 3 [features.message_encoding = DELIMITED];

} // NO_PROTO1

// Additional messages for testing lazy fields.

message TestEagerMessage {

TestAllTypes sub_message = 1 [lazy=false];

}

message TestLazyMessage {

TestAllTypes sub_message = 1 [lazy=true];

}

message TestLazyMessageRepeated {

repeated TestLazyMessage repeated_message = 1;

}

message TestEagerMaybeLazy {

message NestedMessage {

TestPackedTypes packed = 1;

}

TestAllTypes message_foo = 1;

TestAllTypes message_bar = 2;

NestedMessage message_baz = 3;

}

// Needed for a Python test.

message TestNestedMessageHasBits {

message NestedMessage {

repeated int32 nestedmessage_repeated_int32 = 1;

repeated ForeignMessage nestedmessage_repeated_foreignmessage = 2;

}

NestedMessage optional_nested_message = 1;

}

// Test an enum that has multiple values with the same number.

enum TestEnumWithDupValue {

option allow_alias = true;

DUP_UNKNOWN1 = 0;

DUP_FOO1 = 1;

DUP_BAR1 = 2;

DUP_BAZ = 3;

DUP_UNKNOWN2 = 0;

DUP_FOO2 = 1;

DUP_BAR2 = 2;

}

// Test an enum with large, unordered values.

enum TestSparseEnum {

SPARSE_A = 123;

SPARSE_B = 62374;

SPARSE_C = 12589234;

SPARSE_D = -15;

SPARSE_E = -53452;

SPARSE_F = 0;

SPARSE_G = 2;

}

// Test message with CamelCase field names. This violates Protocol Buffer

// standard style.

message TestCamelCaseFieldNames {

option features.enforce_naming_style = STYLE_LEGACY;

int32 PrimitiveField = 1;

string StringField = 2;

ForeignEnum EnumField = 3;

ForeignMessage MessageField = 4;

string StringPieceField = 5;

string CordField = 6 [features.(pb.cpp).string_type=CORD];

repeated int32 RepeatedPrimitiveField = 7;

repeated string RepeatedStringField = 8;

repeated ForeignEnum RepeatedEnumField = 9;

repeated ForeignMessage RepeatedMessageField = 10;

repeated string RepeatedStringPieceField = 11;

repeated string RepeatedCordField = 12 [features.(pb.cpp).string_type=CORD];

}

// We list fields out of order, to ensure that we're using field number and not

// field index to determine serialization order.

message TestFieldOrderings {

string my_string = 11;

extensions 2 to 10;

int64 my_int = 1;

extensions 12 to 100;

float my_float = 101;

message NestedMessage {

int64 oo = 2;

// The field name "b" fails to compile in proto1 because it conflicts with

// a local variable named "b" in one of the generated methods. Doh.

// This file needs to compile in proto1 to test backwards-compatibility.

int32 bb = 1;

}

NestedMessage optional_nested_message = 200;

}

extend TestFieldOrderings {

string my_extension_string = 50;

int32 my_extension_int = 5;

}

message TestExtensionOrderings1 {

extend TestFieldOrderings {

TestExtensionOrderings1 test_ext_orderings1 = 13;

}

string my_string = 1;

}

message TestExtensionOrderings2 {

extend TestFieldOrderings {

TestExtensionOrderings2 test_ext_orderings2 = 12;

}

message TestExtensionOrderings3 {

extend TestFieldOrderings {

TestExtensionOrderings3 test_ext_orderings3 = 14;

}

string my_string = 1;

}

string my_string = 1;

}

message TestExtremeDefaultValues {

bytes escaped_bytes = 1 [default = "\0\001\a\b\f\n\r\t\v\\\'\"\xfe"];

uint32 large_uint32 = 2 [default = 0xFFFFFFFF];

uint64 large_uint64 = 3 [default = 0xFFFFFFFFFFFFFFFF];

int32 small_int32 = 4 [default = -0x7FFFFFFF];

int64 small_int64 = 5 [default = -0x7FFFFFFFFFFFFFFF];

int32 really_small_int32 = 21 [default = -0x80000000];

int64 really_small_int64 = 22 [default = -0x8000000000000000];

// The default value here is UTF-8 for "\u1234". (We could also just type

// the UTF-8 text directly into this text file rather than escape it, but

// lots of people use editors that would be confused by this.)

string utf8_string = 6 [default = "\341\210\264"];

// Tests for single-precision floating-point values.

float zero_float = 7 [default = 0];

float one_float = 8 [default = 1];

float small_float = 9 [default = 1.5];

float negative_one_float = 10 [default = -1];

float negative_float = 11 [default = -1.5];

// Using exponents

float large_float = 12 [default = 2E8];

float small_negative_float = 13 [default = -8e-28];

// Text for nonfinite floating-point values.

double inf_double = 14 [default = inf];

double neg_inf_double = 15 [default = -inf];

double nan_double = 16 [default = nan];

float inf_float = 17 [default = inf];

float neg_inf_float = 18 [default = -inf];

float nan_float = 19 [default = nan];

// Tests for C++ trigraphs.

// Trigraphs should be escaped in C++ generated files, but they should not be

// escaped for other languages.

// Note that in .proto file, "\?" is a valid way to escape ? in string

// literals.

string cpp_trigraph = 20 [default = "? \? ?? \?? \??? ??/ ?\?-"];

// String defaults containing the character '\000'

string string_with_zero = 23 [default = "hel\000lo"];

bytes bytes_with_zero = 24 [default = "wor\000ld"];

string string_piece_with_zero = 25 [default="ab\000c"];

string cord_with_zero = 26 [features.(pb.cpp).string_type=CORD,

default="12\0003"];

string replacement_string = 27 [default="${unknown}"];

}

message SparseEnumMessage {

TestSparseEnum sparse_enum = 1;

}

// Test String and Bytes: string is for valid UTF-8 strings

message OneString {

string data = 1;

}

message MoreString {

repeated string data = 1;

}

message OneBytes {

bytes data = 1;

}

message MoreBytes {

repeated bytes data = 1;

}

message ManyOptionalString {

string str1 = 1;

string str2 = 2;

string str3 = 3;

string str4 = 4;

string str5 = 5;

string str6 = 6;

string str7 = 7;

string str8 = 8;

string str9 = 9;

string str10 = 10;

string str11 = 11;

string str12 = 12;

string str13 = 13;

string str14 = 14;

string str15 = 15;

string str16 = 16;

string str17 = 17;

string str18 = 18;

string str19 = 19;

string str20 = 20;

string str21 = 21;

string str22 = 22;

string str23 = 23;

string str24 = 24;

string str25 = 25;

string str26 = 26;

string str27 = 27;

string str28 = 28;

string str29 = 29;

string str30 = 30;

string str31 = 31;

string str32 = 32;

}

// Test int32, uint32, int64, uint64, and bool are all compatible

message Int32Message {

int32 data = 1;

}

message Uint32Message {

uint32 data = 1;

}

message Int64Message {

int64 data = 1;

}

message Uint64Message {

uint64 data = 1;

}

message BoolMessage {

bool data = 1;

}

// Test oneofs.

message TestOneof {

message FooGroup {

int32 a = 5;

string b = 6;

}

oneof foo {

int32 foo_int = 1;

string foo_string = 2;

TestAllTypes foo_message = 3;

FooGroup foogroup= 4 [features.message_encoding = DELIMITED];

}

}

message TestOneofBackwardsCompatible {

int32 foo_int = 1;

string foo_string = 2;

TestAllTypes foo_message = 3;

message FooGroup {

int32 a = 5;

string b = 6;

}

FooGroup foogroup= 4 [features.message_encoding = DELIMITED];

}

message TestOneof2 {

message FooGroup {

int32 a = 9;

string b = 10;

}

oneof foo {

int32 foo_int = 1;

string foo_string = 2;

string foo_cord = 3 [features.(pb.cpp).string_type=CORD];

string foo_string_piece = 4;

bytes foo_bytes = 5;

NestedEnum foo_enum = 6;

NestedMessage foo_message = 7;

FooGroup foogroup = 8 [features.message_encoding = DELIMITED];

NestedMessage foo_lazy_message = 11 [lazy=true];

bytes foo_bytes_cord = 30 [features.(pb.cpp).string_type=CORD];

}

oneof bar {

int32 bar_int = 12 [default = 5];

string bar_string = 13 [default = "STRING"];

string bar_cord = 14 [features.(pb.cpp).string_type=CORD, default = "CORD"];

string bar_string_piece = 15 [default = "SPIECE"];

bytes bar_bytes = 16 [default = "BYTES"];

NestedEnum bar_enum = 17 [default = BAR];

string bar_string_with_empty_default = 20 [default = ""];

string bar_cord_with_empty_default = 21 [features.(pb.cpp).string_type=CORD, default = ""];

string bar_string_piece_with_empty_default = 22 [default = ""];

bytes bar_bytes_with_empty_default = 23 [default = ""];

}

int32 baz_int = 18;

string baz_string = 19 [default = "BAZ"];

message NestedMessage {

int64 moo_int = 1;

repeated int32 corge_int = 2;

}

enum NestedEnum {

UNKNOWN = 0;

FOO = 1;

BAR = 2;

BAZ = 3;

}

}

message TestRequiredOneof {

oneof foo {

int32 foo_int = 1;

string foo_string = 2;

NestedMessage foo_message = 3;

NestedMessage foo_lazy_message = 4 [lazy = true];

}

message NestedMessage {

double required_double = 1 [features.field_presence = LEGACY_REQUIRED];

}

}

// Test messages for packed fields

message TestPackedTypes {

repeated int32 packed_int32 = 90 [features.repeated_field_encoding = PACKED];

repeated int64 packed_int64 = 91 [features.repeated_field_encoding = PACKED];