mirror of https://github.com/grpc/grpc.git
The C based gRPC (C++, Python, Ruby, Objective-C, PHP, C#)
https://grpc.io/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
337 lines
10 KiB
337 lines
10 KiB
5 years ago
|
/*
|
||
|
*
|
||
|
* A set of tests for JSON parsing and serialization.
|
||
|
*/
|
||
|
|
||
5 years ago
|
#include <string>
|
||
|
|
||
|
#include "tests/json/test.upb.h" // Test that it compiles for C++.
|
||
5 years ago
|
#include "tests/json/test.upbdefs.h"
|
||
|
#include "tests/test_util.h"
|
||
|
#include "tests/upb_test.h"
|
||
5 years ago
|
#include "upb/def.hpp"
|
||
5 years ago
|
#include "upb/handlers.h"
|
||
|
#include "upb/json/parser.h"
|
||
|
#include "upb/json/printer.h"
|
||
|
#include "upb/port_def.inc"
|
||
5 years ago
|
#include "upb/upb.h"
|
||
5 years ago
|
|
||
|
// Macros for readability in test case list: allows us to give TEST("...") /
|
||
|
// EXPECT("...") pairs.
|
||
|
#define TEST(x) x
|
||
|
#define EXPECT_SAME NULL
|
||
|
#define EXPECT(x) x
|
||
|
#define TEST_SENTINEL { NULL, NULL }
|
||
|
|
||
|
struct TestCase {
|
||
|
const char* input;
|
||
|
const char* expected;
|
||
|
};
|
||
|
|
||
|
bool verbose = false;
|
||
|
|
||
|
static TestCase kTestRoundtripMessages[] = {
|
||
|
// Test most fields here.
|
||
|
{
|
||
|
TEST("{\"optionalInt32\":-42,\"optionalString\":\"Test\\u0001Message\","
|
||
|
"\"optionalMsg\":{\"foo\":42},"
|
||
|
"\"optionalBool\":true,\"repeatedMsg\":[{\"foo\":1},"
|
||
|
"{\"foo\":2}]}"),
|
||
|
EXPECT_SAME
|
||
|
},
|
||
|
// We must also recognize raw proto names.
|
||
|
{
|
||
|
TEST("{\"optional_int32\":-42,\"optional_string\":\"Test\\u0001Message\","
|
||
|
"\"optional_msg\":{\"foo\":42},"
|
||
|
"\"optional_bool\":true,\"repeated_msg\":[{\"foo\":1},"
|
||
|
"{\"foo\":2}]}"),
|
||
|
EXPECT("{\"optionalInt32\":-42,\"optionalString\":\"Test\\u0001Message\","
|
||
|
"\"optionalMsg\":{\"foo\":42},"
|
||
|
"\"optionalBool\":true,\"repeatedMsg\":[{\"foo\":1},"
|
||
|
"{\"foo\":2}]}")
|
||
|
},
|
||
|
// Test special escapes in strings.
|
||
|
{
|
||
|
TEST("{\"repeatedString\":[\"\\b\",\"\\r\",\"\\n\",\"\\f\",\"\\t\","
|
||
|
"\"\uFFFF\"]}"),
|
||
|
EXPECT_SAME
|
||
|
},
|
||
|
// Test enum symbolic names.
|
||
|
{
|
||
|
// The common case: parse and print the symbolic name.
|
||
|
TEST("{\"optionalEnum\":\"A\"}"),
|
||
|
EXPECT_SAME
|
||
|
},
|
||
|
{
|
||
|
// Unknown enum value: will be printed as an integer.
|
||
|
TEST("{\"optionalEnum\":42}"),
|
||
|
EXPECT_SAME
|
||
|
},
|
||
|
{
|
||
|
// Known enum value: we're happy to parse an integer but we will re-emit the
|
||
|
// symbolic name.
|
||
|
TEST("{\"optionalEnum\":1}"),
|
||
|
EXPECT("{\"optionalEnum\":\"B\"}")
|
||
|
},
|
||
|
// UTF-8 tests: escapes -> literal UTF8 in output.
|
||
|
{
|
||
|
// Note double escape on \uXXXX: we want the escape to be processed by the
|
||
|
// JSON parser, not by the C++ compiler!
|
||
|
TEST("{\"optionalString\":\"\\u007F\"}"),
|
||
|
EXPECT("{\"optionalString\":\"\x7F\"}")
|
||
|
},
|
||
|
{
|
||
|
TEST("{\"optionalString\":\"\\u0080\"}"),
|
||
|
EXPECT("{\"optionalString\":\"\xC2\x80\"}")
|
||
|
},
|
||
|
{
|
||
|
TEST("{\"optionalString\":\"\\u07FF\"}"),
|
||
|
EXPECT("{\"optionalString\":\"\xDF\xBF\"}")
|
||
|
},
|
||
|
{
|
||
|
TEST("{\"optionalString\":\"\\u0800\"}"),
|
||
|
EXPECT("{\"optionalString\":\"\xE0\xA0\x80\"}")
|
||
|
},
|
||
|
{
|
||
|
TEST("{\"optionalString\":\"\\uFFFF\"}"),
|
||
|
EXPECT("{\"optionalString\":\"\xEF\xBF\xBF\"}")
|
||
|
},
|
||
|
// map-field tests
|
||
|
{
|
||
|
TEST("{\"mapStringString\":{\"a\":\"value1\",\"b\":\"value2\","
|
||
|
"\"c\":\"value3\"}}"),
|
||
|
EXPECT_SAME
|
||
|
},
|
||
|
{
|
||
|
TEST("{\"mapInt32String\":{\"1\":\"value1\",\"-1\":\"value2\","
|
||
|
"\"1234\":\"value3\"}}"),
|
||
|
EXPECT_SAME
|
||
|
},
|
||
|
{
|
||
|
TEST("{\"mapBoolString\":{\"false\":\"value1\",\"true\":\"value2\"}}"),
|
||
|
EXPECT_SAME
|
||
|
},
|
||
|
{
|
||
|
TEST("{\"mapStringInt32\":{\"asdf\":1234,\"jkl;\":-1}}"),
|
||
|
EXPECT_SAME
|
||
|
},
|
||
|
{
|
||
|
TEST("{\"mapStringBool\":{\"asdf\":true,\"jkl;\":false}}"),
|
||
|
EXPECT_SAME
|
||
|
},
|
||
|
{
|
||
|
TEST("{\"mapStringMsg\":{\"asdf\":{\"foo\":42},\"jkl;\":{\"foo\":84}}}"),
|
||
|
EXPECT_SAME
|
||
|
},
|
||
|
TEST_SENTINEL
|
||
|
};
|
||
|
|
||
|
static TestCase kTestRoundtripMessagesPreserve[] = {
|
||
|
// Test most fields here.
|
||
|
{
|
||
|
TEST("{\"optional_int32\":-42,\"optional_string\":\"Test\\u0001Message\","
|
||
|
"\"optional_msg\":{\"foo\":42},"
|
||
|
"\"optional_bool\":true,\"repeated_msg\":[{\"foo\":1},"
|
||
|
"{\"foo\":2}]}"),
|
||
|
EXPECT_SAME
|
||
|
},
|
||
|
TEST_SENTINEL
|
||
|
};
|
||
|
|
||
5 years ago
|
static TestCase kTestSkipUnknown[] = {
|
||
|
{
|
||
|
TEST("{\"optionalEnum\":\"UNKNOWN_ENUM_VALUE\"}"),
|
||
|
EXPECT("{}"),
|
||
|
},
|
||
|
TEST_SENTINEL
|
||
|
};
|
||
|
|
||
|
static TestCase kTestFailure[] = {
|
||
|
{
|
||
|
TEST("{\"optionalEnum\":\"UNKNOWN_ENUM_VALUE\"}"),
|
||
5 years ago
|
EXPECT("{}"), /* Actually we expect error, this is checked later. */
|
||
5 years ago
|
},
|
||
|
TEST_SENTINEL
|
||
|
};
|
||
|
|
||
5 years ago
|
class StringSink {
|
||
|
public:
|
||
|
StringSink() {
|
||
|
upb_byteshandler_init(&byteshandler_);
|
||
|
upb_byteshandler_setstring(&byteshandler_, &str_handler, NULL);
|
||
|
upb_bytessink_reset(&bytessink_, &byteshandler_, &s_);
|
||
|
}
|
||
|
~StringSink() { }
|
||
|
|
||
|
upb_bytessink Sink() { return bytessink_; }
|
||
|
|
||
|
const std::string& Data() { return s_; }
|
||
|
|
||
|
private:
|
||
|
|
||
|
static size_t str_handler(void* _closure, const void* hd,
|
||
|
const char* data, size_t len,
|
||
|
const upb_bufhandle* handle) {
|
||
|
UPB_UNUSED(hd);
|
||
|
UPB_UNUSED(handle);
|
||
|
std::string* s = static_cast<std::string*>(_closure);
|
||
|
std::string appended(data, len);
|
||
|
s->append(data, len);
|
||
|
return len;
|
||
|
}
|
||
|
|
||
|
upb_byteshandler byteshandler_;
|
||
|
upb_bytessink bytessink_;
|
||
|
std::string s_;
|
||
|
};
|
||
|
|
||
|
void test_json_roundtrip_message(const char* json_src,
|
||
|
const char* json_expected,
|
||
|
const upb::Handlers* serialize_handlers,
|
||
|
const upb::json::ParserMethodPtr parser_method,
|
||
5 years ago
|
int seam,
|
||
|
bool ignore_unknown) {
|
||
5 years ago
|
VerboseParserEnvironment env(verbose);
|
||
|
StringSink data_sink;
|
||
|
upb::json::PrinterPtr printer = upb::json::PrinterPtr::Create(
|
||
|
env.arena(), serialize_handlers, data_sink.Sink());
|
||
|
upb::json::ParserPtr parser = upb::json::ParserPtr::Create(
|
||
5 years ago
|
env.arena(), parser_method, NULL, printer.input(),
|
||
|
env.status(), ignore_unknown);
|
||
5 years ago
|
env.ResetBytesSink(parser.input());
|
||
|
env.Reset(json_src, strlen(json_src), false, false);
|
||
|
|
||
|
bool ok = env.Start() &&
|
||
|
env.ParseBuffer(seam) &&
|
||
|
env.ParseBuffer(-1) &&
|
||
|
env.End();
|
||
|
|
||
|
ASSERT(ok);
|
||
|
ASSERT(env.CheckConsistency());
|
||
|
|
||
|
if (memcmp(json_expected,
|
||
|
data_sink.Data().data(),
|
||
|
data_sink.Data().size())) {
|
||
|
fprintf(stderr,
|
||
|
"JSON parse/serialize roundtrip result differs:\n"
|
||
5 years ago
|
"Expected:\n%s\nParsed/Serialized:\n%s\n",
|
||
|
json_expected, data_sink.Data().c_str());
|
||
5 years ago
|
abort();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Starts with a message in JSON format, parses and directly serializes again,
|
||
|
// and compares the result.
|
||
|
void test_json_roundtrip() {
|
||
|
upb::SymbolTable symtab;
|
||
|
upb::HandlerCache serialize_handlercache(
|
||
|
upb::json::PrinterPtr::NewCache(false));
|
||
|
upb::json::CodeCache parse_codecache;
|
||
|
|
||
|
upb::MessageDefPtr md(upb_test_json_TestMessage_getmsgdef(symtab.ptr()));
|
||
|
ASSERT(md);
|
||
|
const upb::Handlers* serialize_handlers = serialize_handlercache.Get(md);
|
||
|
const upb::json::ParserMethodPtr parser_method = parse_codecache.Get(md);
|
||
|
ASSERT(serialize_handlers);
|
||
|
|
||
|
for (const TestCase* test_case = kTestRoundtripMessages;
|
||
|
test_case->input != NULL; test_case++) {
|
||
|
const char *expected =
|
||
|
(test_case->expected == EXPECT_SAME) ?
|
||
|
test_case->input :
|
||
|
test_case->expected;
|
||
|
|
||
|
for (size_t i = 0; i < strlen(test_case->input); i++) {
|
||
|
test_json_roundtrip_message(test_case->input, expected,
|
||
5 years ago
|
serialize_handlers, parser_method, (int)i,
|
||
5 years ago
|
false);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Tests ignore unknown.
|
||
|
for (const TestCase* test_case = kTestSkipUnknown;
|
||
|
test_case->input != NULL; test_case++) {
|
||
|
const char *expected =
|
||
|
(test_case->expected == EXPECT_SAME) ?
|
||
|
test_case->input :
|
||
|
test_case->expected;
|
||
|
|
||
|
for (size_t i = 0; i < strlen(test_case->input); i++) {
|
||
|
test_json_roundtrip_message(test_case->input, expected,
|
||
5 years ago
|
serialize_handlers, parser_method, (int)i,
|
||
5 years ago
|
true);
|
||
5 years ago
|
}
|
||
|
}
|
||
|
|
||
|
serialize_handlercache = upb::json::PrinterPtr::NewCache(true);
|
||
|
serialize_handlers = serialize_handlercache.Get(md);
|
||
|
|
||
|
for (const TestCase* test_case = kTestRoundtripMessagesPreserve;
|
||
|
test_case->input != NULL; test_case++) {
|
||
|
const char *expected =
|
||
|
(test_case->expected == EXPECT_SAME) ?
|
||
|
test_case->input :
|
||
|
test_case->expected;
|
||
|
|
||
|
for (size_t i = 0; i < strlen(test_case->input); i++) {
|
||
|
test_json_roundtrip_message(test_case->input, expected,
|
||
5 years ago
|
serialize_handlers, parser_method, (int)i,
|
||
5 years ago
|
false);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void test_json_parse_failure(const char* json_src,
|
||
|
const upb::Handlers* serialize_handlers,
|
||
|
const upb::json::ParserMethodPtr parser_method,
|
||
|
int seam) {
|
||
|
VerboseParserEnvironment env(verbose);
|
||
|
StringSink data_sink;
|
||
|
upb::json::PrinterPtr printer = upb::json::PrinterPtr::Create(
|
||
|
env.arena(), serialize_handlers, data_sink.Sink());
|
||
|
upb::json::ParserPtr parser = upb::json::ParserPtr::Create(
|
||
|
env.arena(), parser_method, NULL, printer.input(), env.status(), false);
|
||
|
env.ResetBytesSink(parser.input());
|
||
|
env.Reset(json_src, strlen(json_src), false, true);
|
||
|
|
||
|
bool ok = env.Start() &&
|
||
|
env.ParseBuffer(seam) &&
|
||
|
env.ParseBuffer(-1) &&
|
||
|
env.End();
|
||
|
|
||
|
ASSERT(!ok);
|
||
|
ASSERT(env.CheckConsistency());
|
||
|
}
|
||
|
|
||
|
// Starts with a proto message in JSON format, parses and expects failre.
|
||
|
void test_json_failure() {
|
||
|
upb::SymbolTable symtab;
|
||
|
upb::HandlerCache serialize_handlercache(
|
||
|
upb::json::PrinterPtr::NewCache(false));
|
||
|
upb::json::CodeCache parse_codecache;
|
||
|
|
||
|
upb::MessageDefPtr md(upb_test_json_TestMessage_getmsgdef(symtab.ptr()));
|
||
|
ASSERT(md);
|
||
|
const upb::Handlers* serialize_handlers = serialize_handlercache.Get(md);
|
||
|
const upb::json::ParserMethodPtr parser_method = parse_codecache.Get(md);
|
||
|
ASSERT(serialize_handlers);
|
||
|
|
||
|
for (const TestCase* test_case = kTestFailure;
|
||
|
test_case->input != NULL; test_case++) {
|
||
|
for (size_t i = 0; i < strlen(test_case->input); i++) {
|
||
|
test_json_parse_failure(test_case->input, serialize_handlers,
|
||
5 years ago
|
parser_method, (int)i);
|
||
5 years ago
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
extern "C" {
|
||
|
int run_tests(int argc, char *argv[]) {
|
||
|
UPB_UNUSED(argc);
|
||
|
UPB_UNUSED(argv);
|
||
|
test_json_roundtrip();
|
||
5 years ago
|
test_json_failure();
|
||
5 years ago
|
return 0;
|
||
|
}
|
||
|
}
|