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.
336 lines
10 KiB
336 lines
10 KiB
/* |
|
* |
|
* A set of tests for JSON parsing and serialization. |
|
*/ |
|
|
|
#include <string> |
|
|
|
#include "tests/json/test.upb.h" // Test that it compiles for C++. |
|
#include "tests/json/test.upbdefs.h" |
|
#include "tests/test_util.h" |
|
#include "tests/upb_test.h" |
|
#include "upb/def.hpp" |
|
#include "upb/handlers.h" |
|
#include "upb/json/parser.h" |
|
#include "upb/json/printer.h" |
|
#include "upb/port_def.inc" |
|
#include "upb/upb.h" |
|
|
|
// 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 |
|
}; |
|
|
|
static TestCase kTestSkipUnknown[] = { |
|
{ |
|
TEST("{\"optionalEnum\":\"UNKNOWN_ENUM_VALUE\"}"), |
|
EXPECT("{}"), |
|
}, |
|
TEST_SENTINEL |
|
}; |
|
|
|
static TestCase kTestFailure[] = { |
|
{ |
|
TEST("{\"optionalEnum\":\"UNKNOWN_ENUM_VALUE\"}"), |
|
EXPECT("{}"), /* Actually we expect error, this is checked later. */ |
|
}, |
|
TEST_SENTINEL |
|
}; |
|
|
|
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, |
|
int seam, |
|
bool ignore_unknown) { |
|
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(), ignore_unknown); |
|
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" |
|
"Expected:\n%s\nParsed/Serialized:\n%s\n", |
|
json_expected, data_sink.Data().c_str()); |
|
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, |
|
serialize_handlers, parser_method, (int)i, |
|
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, |
|
serialize_handlers, parser_method, (int)i, |
|
true); |
|
} |
|
} |
|
|
|
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, |
|
serialize_handlers, parser_method, (int)i, |
|
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, |
|
parser_method, (int)i); |
|
} |
|
} |
|
} |
|
|
|
extern "C" { |
|
int run_tests(int argc, char *argv[]) { |
|
UPB_UNUSED(argc); |
|
UPB_UNUSED(argv); |
|
test_json_roundtrip(); |
|
test_json_failure(); |
|
return 0; |
|
} |
|
}
|
|
|