void ExpectMessage(const string& input, const string& message, int line,
int col, Message* proto, bool expected_result) {
TextFormat::Parser parser;
MockErrorCollector error_collector;
parser.RecordErrorsTo(&error_collector);
EXPECT_EQ(parser.ParseFromString(input, proto), expected_result);
EXPECT_EQ(SimpleItoa(line) + ":" + SimpleItoa(col) + ": " + message + "\n",
error_collector.text_);
}
void EnumGenerator::GenerateDescriptorInitializer(
io::Printer* printer, int index) {
map<string, string> vars;
vars["classname"] = classname_;
vars["index"] = SimpleItoa(index);
if (descriptor_->containing_type() == NULL) {
printer->Print(vars,
"$classname$_descriptor_ = file->enum_type($index$);\n");
} else {
vars["parent"] = ClassName(descriptor_->containing_type(), false);
printer->Print(vars,
"$classname$_descriptor_ = $parent$_descriptor_->enum_type($index$);\n");
}
}
TEST_F(TextFormatParserTest, ParseFieldValueFromString) {
scoped_ptr<unittest::TestAllTypes> message(new unittest::TestAllTypes);
const Descriptor* d = message->GetDescriptor();
#define EXPECT_FIELD(name, value, valuestring) \
EXPECT_TRUE(TextFormat::ParseFieldValueFromString( \
valuestring, d->FindFieldByName("optional_" #name), message.get())); \
EXPECT_EQ(value, message->optional_##name()); \
EXPECT_TRUE(message->has_optional_##name());
#define EXPECT_FLOAT_FIELD(name, value, valuestring) \
EXPECT_TRUE(TextFormat::ParseFieldValueFromString( \
valuestring, d->FindFieldByName("optional_" #name), message.get())); \
EXPECT_FLOAT_EQ(value, message->optional_##name()); \
EXPECT_TRUE(message->has_optional_##name());
#define EXPECT_DOUBLE_FIELD(name, value, valuestring) \
EXPECT_TRUE(TextFormat::ParseFieldValueFromString( \
valuestring, d->FindFieldByName("optional_" #name), message.get())); \
EXPECT_DOUBLE_EQ(value, message->optional_##name()); \
EXPECT_TRUE(message->has_optional_##name());
#define EXPECT_INVALID(name, valuestring) \
EXPECT_FALSE(TextFormat::ParseFieldValueFromString( \
valuestring, d->FindFieldByName("optional_" #name), message.get()));
// int32
EXPECT_FIELD(int32, 1, "1");
EXPECT_FIELD(int32, -1, "-1");
EXPECT_FIELD(int32, 0x1234, "0x1234");
EXPECT_INVALID(int32, "a");
EXPECT_INVALID(int32, "999999999999999999999999999999999999");
EXPECT_INVALID(int32, "1,2");
// int64
EXPECT_FIELD(int64, 1, "1");
EXPECT_FIELD(int64, -1, "-1");
EXPECT_FIELD(int64, 0x1234567812345678LL, "0x1234567812345678");
EXPECT_INVALID(int64, "a");
EXPECT_INVALID(int64, "999999999999999999999999999999999999");
EXPECT_INVALID(int64, "1,2");
// uint64
EXPECT_FIELD(uint64, 1, "1");
EXPECT_FIELD(uint64, 0xf234567812345678ULL, "0xf234567812345678");
EXPECT_INVALID(uint64, "-1");
EXPECT_INVALID(uint64, "a");
EXPECT_INVALID(uint64, "999999999999999999999999999999999999");
EXPECT_INVALID(uint64, "1,2");
// fixed32
EXPECT_FIELD(fixed32, 1, "1");
EXPECT_FIELD(fixed32, 0x12345678, "0x12345678");
EXPECT_INVALID(fixed32, "-1");
EXPECT_INVALID(fixed32, "a");
EXPECT_INVALID(fixed32, "999999999999999999999999999999999999");
EXPECT_INVALID(fixed32, "1,2");
// fixed64
EXPECT_FIELD(fixed64, 1, "1");
EXPECT_FIELD(fixed64, 0x1234567812345678ULL, "0x1234567812345678");
EXPECT_INVALID(fixed64, "-1");
EXPECT_INVALID(fixed64, "a");
EXPECT_INVALID(fixed64, "999999999999999999999999999999999999");
EXPECT_INVALID(fixed64, "1,2");
// bool
EXPECT_FIELD(bool, true, "true");
EXPECT_FIELD(bool, false, "false");
EXPECT_FIELD(bool, true, "1");
EXPECT_FIELD(bool, true, "t");
EXPECT_FIELD(bool, false, "0");
EXPECT_FIELD(bool, false, "f");
EXPECT_INVALID(bool, "2");
EXPECT_INVALID(bool, "-0");
EXPECT_INVALID(bool, "on");
EXPECT_INVALID(bool, "a");
EXPECT_INVALID(bool, "True");
// float
EXPECT_FIELD(float, 1, "1");
EXPECT_FLOAT_FIELD(float, 1.5, "1.5");
EXPECT_FLOAT_FIELD(float, 1.5e3, "1.5e3");
EXPECT_FLOAT_FIELD(float, -4.55, "-4.55");
EXPECT_INVALID(float, "a");
EXPECT_INVALID(float, "1,2");
// double
EXPECT_FIELD(double, 1, "1");
EXPECT_FIELD(double, -1, "-1");
EXPECT_DOUBLE_FIELD(double, 2.3, "2.3");
EXPECT_DOUBLE_FIELD(double, 3e5, "3e5");
EXPECT_INVALID(double, "a");
EXPECT_INVALID(double, "1,2");
// string
EXPECT_FIELD(string, "hello", "\"hello\"");
EXPECT_FIELD(string, "-1.87", "'-1.87'");
EXPECT_INVALID(string, "hello"); // without quote for value
// enum
EXPECT_FIELD(nested_enum, unittest::TestAllTypes::BAR, "BAR");
EXPECT_FIELD(nested_enum, unittest::TestAllTypes::BAZ,
SimpleItoa(unittest::TestAllTypes::BAZ));
EXPECT_INVALID(nested_enum, "FOOBAR");
// message
EXPECT_TRUE(TextFormat::ParseFieldValueFromString(
"<bb:12>", d->FindFieldByName("optional_nested_message"), message.get()));
EXPECT_EQ(12, message->optional_nested_message().bb()); \
EXPECT_TRUE(message->has_optional_nested_message());
EXPECT_INVALID(nested_message, "any");
#undef EXPECT_FIELD
#undef EXPECT_FLOAT_FIELD
#undef EXPECT_DOUBLE_FIELD
#undef EXPECT_INVALID
}
void EnumGenerator::GenerateDefinition(io::Printer* printer) {
map<string, string> vars;
vars["classname"] = classname_;
vars["short_name"] = descriptor_->name();
//printer->Print(vars, "enum $classname$ {\n");
printer->Print(vars, "$classname$ = {\n");
printer->Indent();
const EnumValueDescriptor* min_value = descriptor_->value(0);
const EnumValueDescriptor* max_value = descriptor_->value(0);
for (int i = 0; i < descriptor_->value_count(); i++) {
vars["name"] = descriptor_->value(i)->name();
vars["number"] = SimpleItoa(descriptor_->value(i)->number());
vars["prefix"] = (descriptor_->containing_type() == NULL) ?
"" : classname_ + "_";
if (i > 0) printer->Print(",\n");
printer->Print(vars, "$prefix$$name$ = $number$");
if (descriptor_->value(i)->number() < min_value->number()) {
min_value = descriptor_->value(i);
}
if (descriptor_->value(i)->number() > max_value->number()) {
max_value = descriptor_->value(i);
}
}
printer->Outdent();
printer->Print("\n};\n\n\n");
vars["min_name"] = min_value->name();
vars["max_name"] = max_value->name();
// if (options_.dllexport_decl.empty()) {
// vars["dllexport"] = "";
// } else {
// vars["dllexport"] = options_.dllexport_decl + " ";
// }
//
// printer->Print(vars,
// "$dllexport$bool $classname$_IsValid(int value);\n"
// "const $classname$ $prefix$$short_name$_MIN = $prefix$$min_name$;\n"
// "const $classname$ $prefix$$short_name$_MAX = $prefix$$max_name$;\n"
// "const int $prefix$$short_name$_ARRAYSIZE = $prefix$$short_name$_MAX + 1;\n"
// "\n");
//
// if (HasDescriptorMethods(descriptor_->file())) {
// printer->Print(vars,
// "$dllexport$const ::google::protobuf::EnumDescriptor* $classname$_descriptor();\n");
// // The _Name and _Parse methods
// printer->Print(vars,
// "inline const ::std::string& $classname$_Name($classname$ value) {\n"
// " return ::google::protobuf::internal::NameOfEnum(\n"
// " $classname$_descriptor(), value);\n"
// "}\n");
// printer->Print(vars,
// "inline bool $classname$_Parse(\n"
// " const ::std::string& name, $classname$* value) {\n"
// " return ::google::protobuf::internal::ParseNamedEnum<$classname$>(\n"
// " $classname$_descriptor(), name, value);\n"
// "}\n");
// }
}
