Chiebot-Mirror
/
protobuf
mirror of https://github.com/protocolbuffers/protobuf.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Delete deprecated C++ utf8 validation feature

Browse Source 
PiperOrigin-RevId: 568713868
pull/14225/head
Mike Kruskal 1 year ago committed by Copybara-Service
parent e9fc181ae9
commit caa462715c
5 changed files with 70 additions and 313 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 130
      src/google/protobuf/cpp_features.pb.cc
  2. 111
      src/google/protobuf/cpp_features.pb.h
  3. 21
      src/google/protobuf/cpp_features.proto
  4. 98
      src/google/protobuf/descriptor_unittest.cc
  5. 23
      src/google/protobuf/editions/generated_files_test.cc

130
src/google/protobuf/cpp_features.pb.cc
Unescape View File

@ -25,8 +25,7 @@ namespace pb {
inline constexpr CppFeatures::Impl_::Impl_(
::_pbi::ConstantInitialized) noexcept
: _cached_size_{0},
legacy_closed_enum_{false},
utf8_validation_{static_cast< ::pb::CppFeatures_Utf8Validation >(0)} {}
legacy_closed_enum_{false} {}
template <typename>
PROTOBUF_CONSTEXPR CppFeatures::CppFeatures(::_pbi::ConstantInitialized)
@ -43,7 +42,8 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_EXPORT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CppFeaturesDefaultTypeInternal _CppFeatures_default_instance_;
} // namespace pb
static ::_pb::Metadata file_level_metadata_google_2fprotobuf_2fcpp_5ffeatures_2eproto[1];
static const ::_pb::EnumDescriptor* file_level_enum_descriptors_google_2fprotobuf_2fcpp_5ffeatures_2eproto[1];
static constexpr const ::_pb::EnumDescriptor**
file_level_enum_descriptors_google_2fprotobuf_2fcpp_5ffeatures_2eproto = nullptr;
static constexpr const ::_pb::ServiceDescriptor**
file_level_service_descriptors_google_2fprotobuf_2fcpp_5ffeatures_2eproto = nullptr;
const ::uint32_t TableStruct_google_2fprotobuf_2fcpp_5ffeatures_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(
@ -57,14 +57,12 @@ const ::uint32_t TableStruct_google_2fprotobuf_2fcpp_5ffeatures_2eproto::offsets
~0u, // no _split_
~0u, // no sizeof(Split)
PROTOBUF_FIELD_OFFSET(::pb::CppFeatures, _impl_.legacy_closed_enum_),
PROTOBUF_FIELD_OFFSET(::pb::CppFeatures, _impl_.utf8_validation_),
0,
1,
};
static const ::_pbi::MigrationSchema
schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
{0, 10, -1, sizeof(::pb::CppFeatures)},
{0, 9, -1, sizeof(::pb::CppFeatures)},
};
static const ::_pb::Message* const file_default_instances[] = {
@ -72,15 +70,11 @@ static const ::_pb::Message* const file_default_instances[] = {
};
const char descriptor_table_protodef_google_2fprotobuf_2fcpp_5ffeatures_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
"\n\"google/protobuf/cpp_features.proto\022\002pb"
"\032 google/protobuf/descriptor.proto\"\365\001\n\013C"
"ppFeatures\0222\n\022legacy_closed_enum\030\001 \001(\010B\026"
"\210\001\001\230\001\004\230\001\001\242\001\n\022\005false\030\350\007\022V\n\017utf8_validatio"
"n\030\002 \001(\0162\036.pb.CppFeatures.Utf8ValidationB"
"\035\210\001\001\230\001\004\230\001\001\242\001\021\022\014VERIFY_PARSE\030\350\007\"Z\n\016Utf8Va"
"lidation\022\033\n\027UTF8_VALIDATION_UNKNOWN\020\000\022\020\n"
"\014VERIFY_PARSE\020\001\022\017\n\013VERIFY_DLOG\020\002\022\010\n\004NONE"
"\020\003::\n\003cpp\022\033.google.protobuf.FeatureSet\030\350"
"\007 \001(\0132\017.pb.CppFeatures"
"\032 google/protobuf/descriptor.proto\"A\n\013Cp"
"pFeatures\0222\n\022legacy_closed_enum\030\001 \001(\010B\026\210"
"\001\001\230\001\004\230\001\001\242\001\n\022\005false\030\350\007::\n\003cpp\022\033.google.pr"
"otobuf.FeatureSet\030\350\007 \001(\0132\017.pb.CppFeature"
"s"
};
static const ::_pbi::DescriptorTable* const descriptor_table_google_2fprotobuf_2fcpp_5ffeatures_2eproto_deps[1] =
{
@ -90,7 +84,7 @@ static ::absl::once_flag descriptor_table_google_2fprotobuf_2fcpp_5ffeatures_2ep
const ::_pbi::DescriptorTable descriptor_table_google_2fprotobuf_2fcpp_5ffeatures_2eproto = {
false,
false,
382,
201,
descriptor_table_protodef_google_2fprotobuf_2fcpp_5ffeatures_2eproto,
"google/protobuf/cpp_features.proto",
&descriptor_table_google_2fprotobuf_2fcpp_5ffeatures_2eproto_once,
@ -120,28 +114,6 @@ PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_google_2
return &descriptor_table_google_2fprotobuf_2fcpp_5ffeatures_2eproto;
}
namespace pb {
const ::google::protobuf::EnumDescriptor* CppFeatures_Utf8Validation_descriptor() {
::google::protobuf::internal::AssignDescriptors(&descriptor_table_google_2fprotobuf_2fcpp_5ffeatures_2eproto);
return file_level_enum_descriptors_google_2fprotobuf_2fcpp_5ffeatures_2eproto[0];
}
PROTOBUF_CONSTINIT const uint32_t CppFeatures_Utf8Validation_internal_data_[] = {
262144u, 0u, };
bool CppFeatures_Utf8Validation_IsValid(int value) {
return 0 <= value && value <= 3;
}
#if (__cplusplus < 201703) && \
(!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr CppFeatures_Utf8Validation CppFeatures::UTF8_VALIDATION_UNKNOWN;
constexpr CppFeatures_Utf8Validation CppFeatures::VERIFY_PARSE;
constexpr CppFeatures_Utf8Validation CppFeatures::VERIFY_DLOG;
constexpr CppFeatures_Utf8Validation CppFeatures::NONE;
constexpr CppFeatures_Utf8Validation CppFeatures::Utf8Validation_MIN;
constexpr CppFeatures_Utf8Validation CppFeatures::Utf8Validation_MAX;
constexpr int CppFeatures::Utf8Validation_ARRAYSIZE;
#endif // (__cplusplus < 201703) &&
// (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
// ===================================================================
class CppFeatures::_Internal {
@ -152,9 +124,6 @@ class CppFeatures::_Internal {
static void set_has_legacy_closed_enum(HasBits* has_bits) {
(*has_bits)[0] |= 1u;
}
static void set_has_utf8_validation(HasBits* has_bits) {
(*has_bits)[0] |= 2u;
}
};
CppFeatures::CppFeatures(::google::protobuf::Arena* arena)
@ -174,12 +143,7 @@ inline PROTOBUF_NDEBUG_INLINE CppFeatures::Impl_::Impl_(
inline void CppFeatures::SharedCtor(::_pb::Arena* arena) {
new (&_impl_) Impl_(internal_visibility(), arena);
::memset(reinterpret_cast<char *>(&_impl_) +
offsetof(Impl_, legacy_closed_enum_),
0,
offsetof(Impl_, utf8_validation_) -
offsetof(Impl_, legacy_closed_enum_) +
sizeof(Impl_::utf8_validation_));
_impl_.legacy_closed_enum_ = {};
}
CppFeatures::~CppFeatures() {
// @@protoc_insertion_point(destructor:pb.CppFeatures)
@ -198,12 +162,7 @@ PROTOBUF_NOINLINE void CppFeatures::Clear() {
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
cached_has_bits = _impl_._has_bits_[0];
if (cached_has_bits & 0x00000003u) {
::memset(&_impl_.legacy_closed_enum_, 0, static_cast<::size_t>(
reinterpret_cast<char*>(&_impl_.utf8_validation_) -
reinterpret_cast<char*>(&_impl_.legacy_closed_enum_)) + sizeof(_impl_.utf8_validation_));
}
_impl_.legacy_closed_enum_ = false;
_impl_._has_bits_.Clear();
_internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}
@ -216,23 +175,20 @@ const char* CppFeatures::_InternalParse(
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<1, 2, 1, 0, 2> CppFeatures::_table_ = {
const ::_pbi::TcParseTable<0, 1, 0, 0, 2> CppFeatures::_table_ = {
{
PROTOBUF_FIELD_OFFSET(CppFeatures, _impl_._has_bits_),
0, // no _extensions_
2, 8, // max_field_number, fast_idx_mask
1, 0, // max_field_number, fast_idx_mask
offsetof(decltype(_table_), field_lookup_table),
4294967292, // skipmap
4294967294, // skipmap
offsetof(decltype(_table_), field_entries),
2, // num_field_entries
1, // num_aux_entries
offsetof(decltype(_table_), aux_entries),
1, // num_field_entries
0, // num_aux_entries
offsetof(decltype(_table_), field_names), // no aux_entries
&_CppFeatures_default_instance_._instance,
::_pbi::TcParser::GenericFallback, // fallback
}, {{
// optional .pb.CppFeatures.Utf8Validation utf8_validation = 2 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = {
{::_pbi::TcParser::FastEr0S1,
{16, 1, 3, PROTOBUF_FIELD_OFFSET(CppFeatures, _impl_.utf8_validation_)}},
// optional bool legacy_closed_enum = 1 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = {
{::_pbi::TcParser::SingularVarintNoZag1<bool, offsetof(CppFeatures, _impl_.legacy_closed_enum_), 0>(),
{8, 0, 0, PROTOBUF_FIELD_OFFSET(CppFeatures, _impl_.legacy_closed_enum_)}},
@ -242,12 +198,9 @@ const ::_pbi::TcParseTable<1, 2, 1, 0, 2> CppFeatures::_table_ = {
// optional bool legacy_closed_enum = 1 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = {
{PROTOBUF_FIELD_OFFSET(CppFeatures, _impl_.legacy_closed_enum_), _Internal::kHasBitsOffset + 0, 0,
(0 | ::_fl::kFcOptional | ::_fl::kBool)},
// optional .pb.CppFeatures.Utf8Validation utf8_validation = 2 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = {
{PROTOBUF_FIELD_OFFSET(CppFeatures, _impl_.utf8_validation_), _Internal::kHasBitsOffset + 1, 0,
(0 | ::_fl::kFcOptional | ::_fl::kEnumRange)},
}}, {{
{0, 4},
}}, {{
}},
// no aux_entries
{{
}},
};
@ -266,13 +219,6 @@ const ::_pbi::TcParseTable<1, 2, 1, 0, 2> CppFeatures::_table_ = {
1, this->_internal_legacy_closed_enum(), target);
}
// optional .pb.CppFeatures.Utf8Validation utf8_validation = 2 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = {
if (cached_has_bits & 0x00000002u) {
target = stream->EnsureSpace(target);
target = ::_pbi::WireFormatLite::WriteEnumToArray(
2, this->_internal_utf8_validation(), target);
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
target =
::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
@ -290,20 +236,12 @@ const ::_pbi::TcParseTable<1, 2, 1, 0, 2> CppFeatures::_table_ = {
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
// optional bool legacy_closed_enum = 1 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = {
cached_has_bits = _impl_._has_bits_[0];
if (cached_has_bits & 0x00000003u) {
// optional bool legacy_closed_enum = 1 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = {
if (cached_has_bits & 0x00000001u) {
total_size += 2;
}
// optional .pb.CppFeatures.Utf8Validation utf8_validation = 2 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = {
if (cached_has_bits & 0x00000002u) {
total_size += 1 +
::_pbi::WireFormatLite::EnumSize(this->_internal_utf8_validation());
}
if (cached_has_bits & 0x00000001u) {
total_size += 2;
}
return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}
@ -323,15 +261,8 @@ void CppFeatures::MergeImpl(::google::protobuf::Message& to_msg, const ::google:
::uint32_t cached_has_bits = 0;
(void) cached_has_bits;
cached_has_bits = from._impl_._has_bits_[0];
if (cached_has_bits & 0x00000003u) {
if (cached_has_bits & 0x00000001u) {
_this->_impl_.legacy_closed_enum_ = from._impl_.legacy_closed_enum_;
}
if (cached_has_bits & 0x00000002u) {
_this->_impl_.utf8_validation_ = from._impl_.utf8_validation_;
}
_this->_impl_._has_bits_[0] |= cached_has_bits;
if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
_this->_internal_set_legacy_closed_enum(from._internal_legacy_closed_enum());
}
_this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
}
@ -354,12 +285,7 @@ void CppFeatures::InternalSwap(CppFeatures* PROTOBUF_RESTRICT other) {
using std::swap;
_internal_metadata_.InternalSwap(&other->_internal_metadata_);
swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
::google::protobuf::internal::memswap<
PROTOBUF_FIELD_OFFSET(CppFeatures, _impl_.utf8_validation_)
+ sizeof(CppFeatures::_impl_.utf8_validation_)
- PROTOBUF_FIELD_OFFSET(CppFeatures, _impl_.legacy_closed_enum_)>(
reinterpret_cast<char*>(&_impl_.legacy_closed_enum_),
reinterpret_cast<char*>(&other->_impl_.legacy_closed_enum_));
swap(_impl_.legacy_closed_enum_, other->_impl_.legacy_closed_enum_);
}
::google::protobuf::Metadata CppFeatures::GetMetadata() const {

111
src/google/protobuf/cpp_features.pb.h
Unescape View File

@ -33,7 +33,6 @@
#include "google/protobuf/message.h"
#include "google/protobuf/repeated_field.h" // IWYU pragma: export
#include "google/protobuf/extension_set.h" // IWYU pragma: export
#include "google/protobuf/generated_enum_reflection.h"
#include "google/protobuf/unknown_field_set.h"
#include "google/protobuf/descriptor.pb.h"
// @@protoc_insertion_point(includes)
@ -68,37 +67,6 @@ namespace protobuf {
} // namespace google
namespace pb {
enum CppFeatures_Utf8Validation : int {
CppFeatures_Utf8Validation_UTF8_VALIDATION_UNKNOWN = 0,
CppFeatures_Utf8Validation_VERIFY_PARSE = 1,
CppFeatures_Utf8Validation_VERIFY_DLOG = 2,
CppFeatures_Utf8Validation_NONE = 3,
};
PROTOBUF_EXPORT bool CppFeatures_Utf8Validation_IsValid(int value);
PROTOBUF_EXPORT extern const uint32_t CppFeatures_Utf8Validation_internal_data_[];
constexpr CppFeatures_Utf8Validation CppFeatures_Utf8Validation_Utf8Validation_MIN = static_cast<CppFeatures_Utf8Validation>(0);
constexpr CppFeatures_Utf8Validation CppFeatures_Utf8Validation_Utf8Validation_MAX = static_cast<CppFeatures_Utf8Validation>(3);
constexpr int CppFeatures_Utf8Validation_Utf8Validation_ARRAYSIZE = 3 + 1;
PROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor*
CppFeatures_Utf8Validation_descriptor();
template <typename T>
const std::string& CppFeatures_Utf8Validation_Name(T value) {
static_assert(std::is_same<T, CppFeatures_Utf8Validation>::value ||
std::is_integral<T>::value,
"Incorrect type passed to Utf8Validation_Name().");
return CppFeatures_Utf8Validation_Name(static_cast<CppFeatures_Utf8Validation>(value));
}
template <>
inline const std::string& CppFeatures_Utf8Validation_Name(CppFeatures_Utf8Validation value) {
return ::google::protobuf::internal::NameOfDenseEnum<CppFeatures_Utf8Validation_descriptor,
0, 3>(
static_cast<int>(value));
}
inline bool CppFeatures_Utf8Validation_Parse(absl::string_view name, CppFeatures_Utf8Validation* value) {
return ::google::protobuf::internal::ParseNamedEnum<CppFeatures_Utf8Validation>(
CppFeatures_Utf8Validation_descriptor(), name, value);
}
// ===================================================================
@ -234,33 +202,10 @@ class PROTOBUF_EXPORT CppFeatures final :
// nested types ----------------------------------------------------
using Utf8Validation = CppFeatures_Utf8Validation;
static constexpr Utf8Validation UTF8_VALIDATION_UNKNOWN = CppFeatures_Utf8Validation_UTF8_VALIDATION_UNKNOWN;
static constexpr Utf8Validation VERIFY_PARSE = CppFeatures_Utf8Validation_VERIFY_PARSE;
static constexpr Utf8Validation VERIFY_DLOG = CppFeatures_Utf8Validation_VERIFY_DLOG;
static constexpr Utf8Validation NONE = CppFeatures_Utf8Validation_NONE;
static inline bool Utf8Validation_IsValid(int value) {
return CppFeatures_Utf8Validation_IsValid(value);
}
static constexpr Utf8Validation Utf8Validation_MIN = CppFeatures_Utf8Validation_Utf8Validation_MIN;
static constexpr Utf8Validation Utf8Validation_MAX = CppFeatures_Utf8Validation_Utf8Validation_MAX;
static constexpr int Utf8Validation_ARRAYSIZE = CppFeatures_Utf8Validation_Utf8Validation_ARRAYSIZE;
static inline const ::google::protobuf::EnumDescriptor* Utf8Validation_descriptor() {
return CppFeatures_Utf8Validation_descriptor();
}
template <typename T>
static inline const std::string& Utf8Validation_Name(T value) {
return CppFeatures_Utf8Validation_Name(value);
}
static inline bool Utf8Validation_Parse(absl::string_view name, Utf8Validation* value) {
return CppFeatures_Utf8Validation_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kLegacyClosedEnumFieldNumber = 1,
kUtf8ValidationFieldNumber = 2,
};
// optional bool legacy_closed_enum = 1 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = {
bool has_legacy_closed_enum() const;
@ -272,17 +217,6 @@ class PROTOBUF_EXPORT CppFeatures final :
bool _internal_legacy_closed_enum() const;
void _internal_set_legacy_closed_enum(bool value);
public:
// optional .pb.CppFeatures.Utf8Validation utf8_validation = 2 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = {
bool has_utf8_validation() const;
void clear_utf8_validation() ;
::pb::CppFeatures_Utf8Validation utf8_validation() const;
void set_utf8_validation(::pb::CppFeatures_Utf8Validation value);
private:
::pb::CppFeatures_Utf8Validation _internal_utf8_validation() const;
void _internal_set_utf8_validation(::pb::CppFeatures_Utf8Validation value);
public:
// @@protoc_insertion_point(class_scope:pb.CppFeatures)
private:
@ -290,7 +224,7 @@ class PROTOBUF_EXPORT CppFeatures final :
friend class ::google::protobuf::internal::TcParser;
static const ::google::protobuf::internal::TcParseTable<
1, 2, 1,
0, 1, 0,
0, 2>
_table_;
friend class ::google::protobuf::MessageLite;
@ -310,7 +244,6 @@ class PROTOBUF_EXPORT CppFeatures final :
::google::protobuf::internal::HasBits<1> _has_bits_;
mutable ::google::protobuf::internal::CachedSize _cached_size_;
bool legacy_closed_enum_;
int utf8_validation_;
PROTOBUF_TSAN_DECLARE_MEMBER
};
union { Impl_ _impl_; };
@ -365,35 +298,6 @@ inline void CppFeatures::_internal_set_legacy_closed_enum(bool value) {
_impl_.legacy_closed_enum_ = value;
}
// optional .pb.CppFeatures.Utf8Validation utf8_validation = 2 [retention = RETENTION_RUNTIME, targets = TARGET_TYPE_FIELD, targets = TARGET_TYPE_FILE, edition_defaults = {
inline bool CppFeatures::has_utf8_validation() const {
bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline void CppFeatures::clear_utf8_validation() {
PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
_impl_.utf8_validation_ = 0;
_impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::pb::CppFeatures_Utf8Validation CppFeatures::utf8_validation() const {
// @@protoc_insertion_point(field_get:pb.CppFeatures.utf8_validation)
return _internal_utf8_validation();
}
inline void CppFeatures::set_utf8_validation(::pb::CppFeatures_Utf8Validation value) {
_internal_set_utf8_validation(value);
// @@protoc_insertion_point(field_set:pb.CppFeatures.utf8_validation)
}
inline ::pb::CppFeatures_Utf8Validation CppFeatures::_internal_utf8_validation() const {
PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
return static_cast<::pb::CppFeatures_Utf8Validation>(_impl_.utf8_validation_);
}
inline void CppFeatures::_internal_set_utf8_validation(::pb::CppFeatures_Utf8Validation value) {
PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
assert(::pb::CppFeatures_Utf8Validation_IsValid(value));
_impl_._has_bits_[0] |= 0x00000002u;
_impl_.utf8_validation_ = value;
}
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif // __GNUC__
@ -402,19 +306,6 @@ inline void CppFeatures::_internal_set_utf8_validation(::pb::CppFeatures_Utf8Val
} // namespace pb
namespace google {
namespace protobuf {
template <>
struct is_proto_enum<::pb::CppFeatures_Utf8Validation> : std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor<::pb::CppFeatures_Utf8Validation>() {
return ::pb::CppFeatures_Utf8Validation_descriptor();
}
} // namespace protobuf
} // namespace google
// @@protoc_insertion_point(global_scope)
#include "google/protobuf/port_undef.inc"

21
src/google/protobuf/cpp_features.proto
Unescape View File

@ -26,25 +26,4 @@ message CppFeatures {
targets = TARGET_TYPE_FILE,
edition_defaults = { edition: EDITION_2023, value: "false" }
];
// The UTF8 validation strategy to use. See go/editions-utf8-validation for
// more information on this feature.
enum Utf8Validation {
// Invalid default, which should never be used.
UTF8_VALIDATION_UNKNOWN = 0;
// Default proto3 behavior, which verifies UTF8 validity during parse.
VERIFY_PARSE = 1;
// Default proto2 behavior, which verifies UTF8 validity during both parse
// and serialize in debug builds. On failure an error is logged, but the
// operation continues.
VERIFY_DLOG = 2;
// No UTF8 validation is done ever.
NONE = 3;
}
optional Utf8Validation utf8_validation = 2 [
retention = RETENTION_RUNTIME,
targets = TARGET_TYPE_FIELD,
targets = TARGET_TYPE_FILE,
edition_defaults = { edition: EDITION_2023, value: "VERIFY_PARSE" }
];
}

98
src/google/protobuf/descriptor_unittest.cc
Unescape View File

@ -7529,16 +7529,15 @@ TEST_F(FeaturesTest, Edition2023Defaults) {
BuildDescriptorMessagesInTestPool();
const FileDescriptor* file = ABSL_DIE_IF_NULL(pool_.BuildFile(file_proto));
EXPECT_THAT(file->options(), EqualsProto(""));
EXPECT_THAT(
GetCoreFeatures(file), EqualsProto(R"pb(
field_presence: EXPLICIT
enum_type: OPEN
repeated_field_encoding: PACKED
utf8_validation: VERIFY
message_encoding: LENGTH_PREFIXED
json_format: ALLOW
[pb.cpp] { legacy_closed_enum: false utf8_validation: VERIFY_PARSE }
)pb"));
EXPECT_THAT(GetCoreFeatures(file), EqualsProto(R"pb(
field_presence: EXPLICIT
enum_type: OPEN
repeated_field_encoding: PACKED
utf8_validation: VERIFY
message_encoding: LENGTH_PREFIXED
json_format: ALLOW
[pb.cpp] { legacy_closed_enum: false }
)pb"));
// Since pb::test is registered in the pool, it should end up with defaults in
// our FeatureSet.
@ -7558,16 +7557,15 @@ TEST_F(FeaturesBaseTest, DefaultEdition2023Defaults) {
ASSERT_NE(file, nullptr);
EXPECT_THAT(file->options(), EqualsProto(""));
EXPECT_THAT(
GetFeatures(file), EqualsProto(R"pb(
field_presence: EXPLICIT
enum_type: OPEN
repeated_field_encoding: PACKED
utf8_validation: VERIFY
message_encoding: LENGTH_PREFIXED
json_format: ALLOW
[pb.cpp] { legacy_closed_enum: false utf8_validation: VERIFY_PARSE }
)pb"));
EXPECT_THAT(GetFeatures(file), EqualsProto(R"pb(
field_presence: EXPLICIT
enum_type: OPEN
repeated_field_encoding: PACKED
utf8_validation: VERIFY
message_encoding: LENGTH_PREFIXED
json_format: ALLOW
[pb.cpp] { legacy_closed_enum: false }
)pb"));
EXPECT_FALSE(GetFeatures(file).HasExtension(pb::test));
}
@ -7590,10 +7588,7 @@ TEST_F(FeaturesTest, ClearsOptions) {
utf8_validation: VERIFY
message_encoding: LENGTH_PREFIXED
json_format: ALLOW
[pb.cpp] {
legacy_closed_enum: false
utf8_validation: VERIFY_PARSE
})pb"));
[pb.cpp] { legacy_closed_enum: false })pb"));
}
TEST_F(FeaturesTest, RestoresOptionsRoundTrip) {
@ -7853,10 +7848,7 @@ TEST_F(FeaturesTest, NoOptions) {
utf8_validation: VERIFY
message_encoding: LENGTH_PREFIXED
json_format: ALLOW
[pb.cpp] {
legacy_closed_enum: false
utf8_validation: VERIFY_PARSE
})pb"));
[pb.cpp] { legacy_closed_enum: false })pb"));
}
TEST_F(FeaturesTest, InvalidEdition) {
@ -7885,10 +7877,7 @@ TEST_F(FeaturesTest, FileFeatures) {
utf8_validation: VERIFY
message_encoding: LENGTH_PREFIXED
json_format: ALLOW
[pb.cpp] {
legacy_closed_enum: false
utf8_validation: VERIFY_PARSE
})pb"));
[pb.cpp] { legacy_closed_enum: false })pb"));
}
TEST_F(FeaturesTest, FileFeaturesExtension) {
@ -7963,10 +7952,7 @@ TEST_F(FeaturesTest, MessageFeaturesDefault) {
utf8_validation: VERIFY
message_encoding: LENGTH_PREFIXED
json_format: ALLOW
[pb.cpp] {
legacy_closed_enum: false
utf8_validation: VERIFY_PARSE
})pb"));
[pb.cpp] { legacy_closed_enum: false })pb"));
}
TEST_F(FeaturesTest, MessageFeaturesInherit) {
@ -8071,10 +8057,7 @@ TEST_F(FeaturesTest, FieldFeaturesDefault) {
utf8_validation: VERIFY
message_encoding: LENGTH_PREFIXED
json_format: ALLOW
[pb.cpp] {
legacy_closed_enum: false
utf8_validation: VERIFY_PARSE
})pb"));
[pb.cpp] { legacy_closed_enum: false })pb"));
}
TEST_F(FeaturesTest, FieldFeaturesInherit) {
@ -8462,10 +8445,7 @@ TEST_F(FeaturesTest, EnumFeaturesDefault) {
utf8_validation: VERIFY
message_encoding: LENGTH_PREFIXED
json_format: ALLOW
[pb.cpp] {
legacy_closed_enum: false
utf8_validation: VERIFY_PARSE
})pb"));
[pb.cpp] { legacy_closed_enum: false })pb"));
}
TEST_F(FeaturesTest, EnumFeaturesInherit) {
@ -8572,10 +8552,7 @@ TEST_F(FeaturesTest, EnumValueFeaturesDefault) {
utf8_validation: VERIFY
message_encoding: LENGTH_PREFIXED
json_format: ALLOW
[pb.cpp] {
legacy_closed_enum: false
utf8_validation: VERIFY_PARSE
})pb"));
[pb.cpp] { legacy_closed_enum: false })pb"));
}
TEST_F(FeaturesTest, EnumValueFeaturesInherit) {
@ -8667,10 +8644,7 @@ TEST_F(FeaturesTest, OneofFeaturesDefault) {
utf8_validation: VERIFY
message_encoding: LENGTH_PREFIXED
json_format: ALLOW
[pb.cpp] {
legacy_closed_enum: false
utf8_validation: VERIFY_PARSE
})pb"));
[pb.cpp] { legacy_closed_enum: false })pb"));
}
TEST_F(FeaturesTest, OneofFeaturesInherit) {
@ -8769,10 +8743,7 @@ TEST_F(FeaturesTest, ExtensionRangeFeaturesDefault) {
utf8_validation: VERIFY
message_encoding: LENGTH_PREFIXED
json_format: ALLOW
[pb.cpp] {
legacy_closed_enum: false
utf8_validation: VERIFY_PARSE
})pb"));
[pb.cpp] { legacy_closed_enum: false })pb"));
}
TEST_F(FeaturesTest, ExtensionRangeFeaturesInherit) {
@ -8856,10 +8827,7 @@ TEST_F(FeaturesTest, ServiceFeaturesDefault) {
utf8_validation: VERIFY
message_encoding: LENGTH_PREFIXED
json_format: ALLOW
[pb.cpp] {
legacy_closed_enum: false
utf8_validation: VERIFY_PARSE
})pb"));
[pb.cpp] { legacy_closed_enum: false })pb"));
}
TEST_F(FeaturesTest, ServiceFeaturesInherit) {
@ -8925,10 +8893,7 @@ TEST_F(FeaturesTest, MethodFeaturesDefault) {
utf8_validation: VERIFY
message_encoding: LENGTH_PREFIXED
json_format: ALLOW
[pb.cpp] {
legacy_closed_enum: false
utf8_validation: VERIFY_PARSE
})pb"));
[pb.cpp] { legacy_closed_enum: false })pb"));
}
TEST_F(FeaturesTest, MethodFeaturesInherit) {
@ -9722,10 +9687,7 @@ TEST_F(FeaturesTest, UninterpretedOptions) {
utf8_validation: VERIFY
message_encoding: LENGTH_PREFIXED
json_format: ALLOW
[pb.cpp] {
legacy_closed_enum: false
utf8_validation: VERIFY_PARSE
})pb"));
[pb.cpp] { legacy_closed_enum: false })pb"));
}
TEST_F(FeaturesTest, UninterpretedOptionsMerge) {

23
src/google/protobuf/editions/generated_files_test.cc
Unescape View File

@ -136,18 +136,17 @@ TEST(Generated, EditionDefaults2023) {
}
TEST(Generated, EditionDefaults2023InternalFeatures) {
EXPECT_THAT(
internal::InternalFeatureHelper::GetFeatures(
*EditionsDefaultMessage::descriptor()),
google::protobuf::EqualsProto(R"pb(
field_presence: EXPLICIT
enum_type: OPEN
repeated_field_encoding: PACKED
utf8_validation: VERIFY
message_encoding: LENGTH_PREFIXED
json_format: ALLOW
[pb.cpp] { legacy_closed_enum: false utf8_validation: VERIFY_PARSE }
)pb"));
EXPECT_THAT(internal::InternalFeatureHelper::GetFeatures(
*EditionsDefaultMessage::descriptor()),
google::protobuf::EqualsProto(R"pb(
field_presence: EXPLICIT
enum_type: OPEN
repeated_field_encoding: PACKED
utf8_validation: VERIFY
message_encoding: LENGTH_PREFIXED
json_format: ALLOW
[pb.cpp] { legacy_closed_enum: false }
)pb"));
}
} // namespace

Write Preview
Loading…
Cancel
Save