void UserBasicInfo::SharedCtor() {
_cached_size_ = 0;
uid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
level_ = 1u;
style_ = 0u;
wincount_ = 0u;
losecount_ = 0u;
winrate_ = 0;
effect_ = NULL;
iconid_ = 6000u;
successionwincount_ = 0u;
oncelong_ = 0u;
maximum_ = GOOGLE_ULONGLONG(0);
totaltime_ = GOOGLE_ULONGLONG(0);
roundsplayed_ = 0u;
throwstones_ = 0u;
thrownstones_ = 0u;
colorcats_ = 0u;
consumegolds_ = 0u;
consumeitems1_ = 0u;
consumeitems2_ = 0u;
consumeitems3_ = 0u;
consumeitems4_ = 0u;
golds_ = 0u;
experience_ = 0u;
maxexperience_ = 1u;
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
void MatchesProto::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
imagelseq_ = GOOGLE_ULONGLONG(0);
imagerseq_ = GOOGLE_ULONGLONG(0);
}
matches_.Clear();
::memset(_has_bits_, 0, sizeof(_has_bits_));
mutable_unknown_fields()->Clear();
}
void UserBasicInfo::Clear() {
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
if (has_uid()) {
if (uid_ != &::google::protobuf::internal::kEmptyString) {
uid_->clear();
}
}
if (has_name()) {
if (name_ != &::google::protobuf::internal::kEmptyString) {
name_->clear();
}
}
level_ = 1u;
style_ = 0u;
wincount_ = 0u;
losecount_ = 0u;
winrate_ = 0;
if (has_effect()) {
if (effect_ != NULL) effect_->::message::UserBasicInfo_EffectData::Clear();
}
}
if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
iconid_ = 6000u;
successionwincount_ = 0u;
oncelong_ = 0u;
maximum_ = GOOGLE_ULONGLONG(0);
totaltime_ = GOOGLE_ULONGLONG(0);
roundsplayed_ = 0u;
throwstones_ = 0u;
thrownstones_ = 0u;
}
if (_has_bits_[16 / 32] & (0xffu << (16 % 32))) {
colorcats_ = 0u;
consumegolds_ = 0u;
consumeitems1_ = 0u;
consumeitems2_ = 0u;
consumeitems3_ = 0u;
consumeitems4_ = 0u;
golds_ = 0u;
experience_ = 0u;
}
if (_has_bits_[24 / 32] & (0xffu << (24 % 32))) {
maxexperience_ = 1u;
}
buyequipframe_.Clear();
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
TEST_F(TextFormatTest, PrintExotic) {
unittest::TestAllTypes message;
// Note: In C, a negative integer literal is actually the unary negation
// operator being applied to a positive integer literal, and
// 9223372036854775808 is outside the range of int64. However, it is not
// outside the range of uint64. Confusingly, this means that everything
// works if we make the literal unsigned, even though we are negating it.
message.add_repeated_int64(-GOOGLE_ULONGLONG(9223372036854775808));
message.add_repeated_uint64(GOOGLE_ULONGLONG(18446744073709551615));
message.add_repeated_double(123.456);
message.add_repeated_double(1.23e21);
message.add_repeated_double(1.23e-18);
message.add_repeated_double(std::numeric_limits<double>::infinity());
message.add_repeated_double(-std::numeric_limits<double>::infinity());
message.add_repeated_double(std::numeric_limits<double>::quiet_NaN());
message.add_repeated_string(string("\000\001\a\b\f\n\r\t\v\\\'\"", 12));
// Fun story: We used to use 1.23e22 instead of 1.23e21 above, but this
// seemed to trigger an odd case on MinGW/GCC 3.4.5 where GCC's parsing of
// the value differed from strtod()'s parsing. That is to say, the
// following assertion fails on MinGW:
// assert(1.23e22 == strtod("1.23e22", NULL));
// As a result, SimpleDtoa() would print the value as
// "1.2300000000000001e+22" to make sure strtod() produce the exact same
// result. Our goal is to test runtime parsing, not compile-time parsing,
// so this wasn't our problem. It was found that using 1.23e21 did not
// have this problem, so we switched to that instead.
EXPECT_EQ(
"repeated_int64: -9223372036854775808\n"
"repeated_uint64: 18446744073709551615\n"
"repeated_double: 123.456\n"
"repeated_double: 1.23e+21\n"
"repeated_double: 1.23e-18\n"
"repeated_double: inf\n"
"repeated_double: -inf\n"
"repeated_double: nan\n"
"repeated_string: \"\\000\\001\\007\\010\\014\\n\\r\\t\\013\\\\\\'\\\"\"\n",
RemoveRedundantZeros(message.DebugString()));
}
TEST_F(TextFormatTest, ParseExotic) {
unittest::TestAllTypes message;
ASSERT_TRUE(TextFormat::ParseFromString(
"repeated_int32: -1\n"
"repeated_int32: -2147483648\n"
"repeated_int64: -1\n"
"repeated_int64: -9223372036854775808\n"
"repeated_uint32: 4294967295\n"
"repeated_uint32: 2147483648\n"
"repeated_uint64: 18446744073709551615\n"
"repeated_uint64: 9223372036854775808\n"
"repeated_double: 123.0\n"
"repeated_double: 123.5\n"
"repeated_double: 0.125\n"
"repeated_double: 1.23E17\n"
"repeated_double: 1.235E+22\n"
"repeated_double: 1.235e-18\n"
"repeated_double: 123.456789\n"
"repeated_double: inf\n"
"repeated_double: Infinity\n"
"repeated_double: -inf\n"
"repeated_double: -Infinity\n"
"repeated_double: nan\n"
"repeated_double: NaN\n"
"repeated_string: \"\\000\\001\\a\\b\\f\\n\\r\\t\\v\\\\\\'\\\"\"\n",
&message));
ASSERT_EQ(2, message.repeated_int32_size());
EXPECT_EQ(-1, message.repeated_int32(0));
// Note: In C, a negative integer literal is actually the unary negation
// operator being applied to a positive integer literal, and 2147483648 is
// outside the range of int32. However, it is not outside the range of
// uint32. Confusingly, this means that everything works if we make the
// literal unsigned, even though we are negating it.
EXPECT_EQ(-2147483648u, message.repeated_int32(1));
ASSERT_EQ(2, message.repeated_int64_size());
EXPECT_EQ(-1, message.repeated_int64(0));
// Note: In C, a negative integer literal is actually the unary negation
// operator being applied to a positive integer literal, and
// 9223372036854775808 is outside the range of int64. However, it is not
// outside the range of uint64. Confusingly, this means that everything
// works if we make the literal unsigned, even though we are negating it.
EXPECT_EQ(-GOOGLE_ULONGLONG(9223372036854775808), message.repeated_int64(1));
ASSERT_EQ(2, message.repeated_uint32_size());
EXPECT_EQ(4294967295u, message.repeated_uint32(0));
EXPECT_EQ(2147483648u, message.repeated_uint32(1));
ASSERT_EQ(2, message.repeated_uint64_size());
EXPECT_EQ(GOOGLE_ULONGLONG(18446744073709551615), message.repeated_uint64(0));
EXPECT_EQ(GOOGLE_ULONGLONG(9223372036854775808), message.repeated_uint64(1));
ASSERT_EQ(13, message.repeated_double_size());
EXPECT_EQ(123.0 , message.repeated_double(0));
EXPECT_EQ(123.5 , message.repeated_double(1));
EXPECT_EQ(0.125 , message.repeated_double(2));
EXPECT_EQ(1.23E17 , message.repeated_double(3));
EXPECT_EQ(1.235E22 , message.repeated_double(4));
EXPECT_EQ(1.235E-18 , message.repeated_double(5));
EXPECT_EQ(123.456789, message.repeated_double(6));
EXPECT_EQ(message.repeated_double(7), numeric_limits<double>::infinity());
EXPECT_EQ(message.repeated_double(8), numeric_limits<double>::infinity());
EXPECT_EQ(message.repeated_double(9), -numeric_limits<double>::infinity());
EXPECT_EQ(message.repeated_double(10), -numeric_limits<double>::infinity());
EXPECT_TRUE(IsNaN(message.repeated_double(11)));
EXPECT_TRUE(IsNaN(message.repeated_double(12)));
// Note: Since these string literals have \0's in them, we must explicitly
// pass their sizes to string's constructor.
ASSERT_EQ(1, message.repeated_string_size());
EXPECT_EQ(string("\000\001\a\b\f\n\r\t\v\\\'\"", 12),
message.repeated_string(0));
}
void MatchesProto::SharedCtor() {
_cached_size_ = 0;
imagelseq_ = GOOGLE_ULONGLONG(0);
imagerseq_ = GOOGLE_ULONGLONG(0);
::memset(_has_bits_, 0, sizeof(_has_bits_));
}
