mirror of https://github.com/grpc/grpc.git
Mark D. Roth
5 years ago
committed by
GitHub
commit
3003fc0b21
19 changed files with 1840 additions and 1 deletions
@ -0,0 +1,808 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016 gRPC authors. |
||||
* |
||||
* Licensed under the Apache License, Version 2.0 (the "License"); |
||||
* you may not use this file except in compliance with the License. |
||||
* You may obtain a copy of the License at |
||||
* |
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
* |
||||
* Unless required by applicable law or agreed to in writing, software |
||||
* distributed under the License is distributed on an "AS IS" BASIS, |
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
* See the License for the specific language governing permissions and |
||||
* limitations under the License. |
||||
* |
||||
*/ |
||||
|
||||
#include <grpc/support/port_platform.h> |
||||
|
||||
#include <string.h> |
||||
|
||||
#include <grpc/support/log.h> |
||||
|
||||
#include "src/core/lib/json/json.h" |
||||
|
||||
namespace grpc_core { |
||||
|
||||
namespace { |
||||
|
||||
class JsonReader { |
||||
public: |
||||
enum class Status { |
||||
GRPC_JSON_DONE, /* The parser finished successfully. */ |
||||
GRPC_JSON_PARSE_ERROR, /* The parser found an error in the json stream. */ |
||||
GRPC_JSON_INTERNAL_ERROR /* The parser got an internal error. */ |
||||
}; |
||||
|
||||
static Status Parse(StringView input, Json* output); |
||||
|
||||
private: |
||||
enum class State { |
||||
GRPC_JSON_STATE_OBJECT_KEY_BEGIN, |
||||
GRPC_JSON_STATE_OBJECT_KEY_STRING, |
||||
GRPC_JSON_STATE_OBJECT_KEY_END, |
||||
GRPC_JSON_STATE_VALUE_BEGIN, |
||||
GRPC_JSON_STATE_VALUE_STRING, |
||||
GRPC_JSON_STATE_STRING_ESCAPE, |
||||
GRPC_JSON_STATE_STRING_ESCAPE_U1, |
||||
GRPC_JSON_STATE_STRING_ESCAPE_U2, |
||||
GRPC_JSON_STATE_STRING_ESCAPE_U3, |
||||
GRPC_JSON_STATE_STRING_ESCAPE_U4, |
||||
GRPC_JSON_STATE_VALUE_NUMBER, |
||||
GRPC_JSON_STATE_VALUE_NUMBER_WITH_DECIMAL, |
||||
GRPC_JSON_STATE_VALUE_NUMBER_ZERO, |
||||
GRPC_JSON_STATE_VALUE_NUMBER_DOT, |
||||
GRPC_JSON_STATE_VALUE_NUMBER_E, |
||||
GRPC_JSON_STATE_VALUE_NUMBER_EPM, |
||||
GRPC_JSON_STATE_VALUE_TRUE_R, |
||||
GRPC_JSON_STATE_VALUE_TRUE_U, |
||||
GRPC_JSON_STATE_VALUE_TRUE_E, |
||||
GRPC_JSON_STATE_VALUE_FALSE_A, |
||||
GRPC_JSON_STATE_VALUE_FALSE_L, |
||||
GRPC_JSON_STATE_VALUE_FALSE_S, |
||||
GRPC_JSON_STATE_VALUE_FALSE_E, |
||||
GRPC_JSON_STATE_VALUE_NULL_U, |
||||
GRPC_JSON_STATE_VALUE_NULL_L1, |
||||
GRPC_JSON_STATE_VALUE_NULL_L2, |
||||
GRPC_JSON_STATE_VALUE_END, |
||||
GRPC_JSON_STATE_END |
||||
}; |
||||
|
||||
/* The first non-unicode value is 0x110000. But let's pick
|
||||
* a value high enough to start our error codes from. These |
||||
* values are safe to return from the read_char function. |
||||
*/ |
||||
static constexpr uint32_t GRPC_JSON_READ_CHAR_EOF = 0x7ffffff0; |
||||
|
||||
explicit JsonReader(StringView input) |
||||
: input_(reinterpret_cast<const uint8_t*>(input.data())), |
||||
remaining_input_(input.size()) {} |
||||
|
||||
Status Run(); |
||||
uint32_t ReadChar(); |
||||
bool IsComplete(); |
||||
|
||||
void StringAddChar(uint32_t c); |
||||
void StringAddUtf32(uint32_t c); |
||||
|
||||
Json* CreateAndLinkValue(); |
||||
void StartContainer(Json::Type type); |
||||
void EndContainer(); |
||||
void SetKey(); |
||||
void SetString(); |
||||
bool SetNumber(); |
||||
void SetTrue(); |
||||
void SetFalse(); |
||||
void SetNull(); |
||||
|
||||
const uint8_t* input_; |
||||
size_t remaining_input_; |
||||
|
||||
State state_ = State::GRPC_JSON_STATE_VALUE_BEGIN; |
||||
bool escaped_string_was_key_ = false; |
||||
bool container_just_begun_ = false; |
||||
uint16_t unicode_char_ = 0; |
||||
uint16_t unicode_high_surrogate_ = 0; |
||||
bool duplicate_key_found_ = false; |
||||
|
||||
Json root_value_; |
||||
std::vector<Json*> stack_; |
||||
|
||||
std::string key_; |
||||
std::string string_; |
||||
}; |
||||
|
||||
void JsonReader::StringAddChar(uint32_t c) { |
||||
string_.push_back(static_cast<uint8_t>(c)); |
||||
} |
||||
|
||||
void JsonReader::StringAddUtf32(uint32_t c) { |
||||
if (c <= 0x7f) { |
||||
StringAddChar(c); |
||||
} else if (c <= 0x7ff) { |
||||
uint32_t b1 = 0xc0 | ((c >> 6) & 0x1f); |
||||
uint32_t b2 = 0x80 | (c & 0x3f); |
||||
StringAddChar(b1); |
||||
StringAddChar(b2); |
||||
} else if (c <= 0xffff) { |
||||
uint32_t b1 = 0xe0 | ((c >> 12) & 0x0f); |
||||
uint32_t b2 = 0x80 | ((c >> 6) & 0x3f); |
||||
uint32_t b3 = 0x80 | (c & 0x3f); |
||||
StringAddChar(b1); |
||||
StringAddChar(b2); |
||||
StringAddChar(b3); |
||||
} else if (c <= 0x1fffff) { |
||||
uint32_t b1 = 0xf0 | ((c >> 18) & 0x07); |
||||
uint32_t b2 = 0x80 | ((c >> 12) & 0x3f); |
||||
uint32_t b3 = 0x80 | ((c >> 6) & 0x3f); |
||||
uint32_t b4 = 0x80 | (c & 0x3f); |
||||
StringAddChar(b1); |
||||
StringAddChar(b2); |
||||
StringAddChar(b3); |
||||
StringAddChar(b4); |
||||
} |
||||
} |
||||
|
||||
uint32_t JsonReader::ReadChar() { |
||||
if (remaining_input_ == 0) return GRPC_JSON_READ_CHAR_EOF; |
||||
const uint32_t r = *input_++; |
||||
--remaining_input_; |
||||
if (r == 0) { |
||||
remaining_input_ = 0; |
||||
return GRPC_JSON_READ_CHAR_EOF; |
||||
} |
||||
return r; |
||||
} |
||||
|
||||
Json* JsonReader::CreateAndLinkValue() { |
||||
Json* value; |
||||
if (stack_.empty()) { |
||||
value = &root_value_; |
||||
} else { |
||||
Json* parent = stack_.back(); |
||||
if (parent->type() == Json::Type::OBJECT) { |
||||
if (parent->object_value().find(key_) != parent->object_value().end()) { |
||||
duplicate_key_found_ = true; |
||||
} |
||||
value = &(*parent->mutable_object())[std::move(key_)]; |
||||
} else { |
||||
GPR_ASSERT(parent->type() == Json::Type::ARRAY); |
||||
parent->mutable_array()->emplace_back(); |
||||
value = &parent->mutable_array()->back(); |
||||
} |
||||
} |
||||
return value; |
||||
} |
||||
|
||||
void JsonReader::StartContainer(Json::Type type) { |
||||
Json* value = CreateAndLinkValue(); |
||||
if (type == Json::Type::OBJECT) { |
||||
*value = Json::Object(); |
||||
} else { |
||||
GPR_ASSERT(type == Json::Type::ARRAY); |
||||
*value = Json::Array(); |
||||
} |
||||
stack_.push_back(value); |
||||
} |
||||
|
||||
void JsonReader::EndContainer() { |
||||
GPR_ASSERT(!stack_.empty()); |
||||
stack_.pop_back(); |
||||
} |
||||
|
||||
void JsonReader::SetKey() { |
||||
key_ = std::move(string_); |
||||
string_.clear(); |
||||
} |
||||
|
||||
void JsonReader::SetString() { |
||||
Json* value = CreateAndLinkValue(); |
||||
*value = std::move(string_); |
||||
string_.clear(); |
||||
} |
||||
|
||||
bool JsonReader::SetNumber() { |
||||
Json* value = CreateAndLinkValue(); |
||||
*value = Json(std::move(string_), /*is_number=*/true); |
||||
string_.clear(); |
||||
return true; |
||||
} |
||||
|
||||
void JsonReader::SetTrue() { |
||||
Json* value = CreateAndLinkValue(); |
||||
*value = true; |
||||
string_.clear(); |
||||
} |
||||
|
||||
void JsonReader::SetFalse() { |
||||
Json* value = CreateAndLinkValue(); |
||||
*value = false; |
||||
string_.clear(); |
||||
} |
||||
|
||||
void JsonReader::SetNull() { CreateAndLinkValue(); } |
||||
|
||||
bool JsonReader::IsComplete() { |
||||
return (stack_.empty() && (state_ == State::GRPC_JSON_STATE_END || |
||||
state_ == State::GRPC_JSON_STATE_VALUE_END)); |
||||
} |
||||
|
||||
/* Call this function to start parsing the input. It will return the following:
|
||||
* . GRPC_JSON_DONE if the input got eof, and the parsing finished |
||||
* successfully. |
||||
* . GRPC_JSON_PARSE_ERROR if the input was somehow invalid. |
||||
* . GRPC_JSON_INTERNAL_ERROR if the parser somehow ended into an invalid |
||||
* internal state. |
||||
*/ |
||||
JsonReader::Status JsonReader::Run() { |
||||
uint32_t c; |
||||
|
||||
/* This state-machine is a strict implementation of ECMA-404 */ |
||||
while (true) { |
||||
c = ReadChar(); |
||||
switch (c) { |
||||
/* Let's process the error case first. */ |
||||
case GRPC_JSON_READ_CHAR_EOF: |
||||
if (IsComplete()) { |
||||
return Status::GRPC_JSON_DONE; |
||||
} else { |
||||
return Status::GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
break; |
||||
|
||||
/* Processing whitespaces. */ |
||||
case ' ': |
||||
case '\t': |
||||
case '\n': |
||||
case '\r': |
||||
switch (state_) { |
||||
case State::GRPC_JSON_STATE_OBJECT_KEY_BEGIN: |
||||
case State::GRPC_JSON_STATE_OBJECT_KEY_END: |
||||
case State::GRPC_JSON_STATE_VALUE_BEGIN: |
||||
case State::GRPC_JSON_STATE_VALUE_END: |
||||
case State::GRPC_JSON_STATE_END: |
||||
break; |
||||
|
||||
case State::GRPC_JSON_STATE_OBJECT_KEY_STRING: |
||||
case State::GRPC_JSON_STATE_VALUE_STRING: |
||||
if (c != ' ') return Status::GRPC_JSON_PARSE_ERROR; |
||||
if (unicode_high_surrogate_ != 0) { |
||||
return Status::GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
StringAddChar(c); |
||||
break; |
||||
|
||||
case State::GRPC_JSON_STATE_VALUE_NUMBER: |
||||
case State::GRPC_JSON_STATE_VALUE_NUMBER_WITH_DECIMAL: |
||||
case State::GRPC_JSON_STATE_VALUE_NUMBER_ZERO: |
||||
case State::GRPC_JSON_STATE_VALUE_NUMBER_EPM: |
||||
if (!SetNumber()) return Status::GRPC_JSON_PARSE_ERROR; |
||||
state_ = State::GRPC_JSON_STATE_VALUE_END; |
||||
break; |
||||
|
||||
default: |
||||
return Status::GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
break; |
||||
|
||||
/* Value, object or array terminations. */ |
||||
case ',': |
||||
case '}': |
||||
case ']': |
||||
switch (state_) { |
||||
case State::GRPC_JSON_STATE_OBJECT_KEY_STRING: |
||||
case State::GRPC_JSON_STATE_VALUE_STRING: |
||||
if (unicode_high_surrogate_ != 0) { |
||||
return Status::GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
StringAddChar(c); |
||||
break; |
||||
|
||||
case State::GRPC_JSON_STATE_VALUE_NUMBER: |
||||
case State::GRPC_JSON_STATE_VALUE_NUMBER_WITH_DECIMAL: |
||||
case State::GRPC_JSON_STATE_VALUE_NUMBER_ZERO: |
||||
case State::GRPC_JSON_STATE_VALUE_NUMBER_EPM: |
||||
if (stack_.empty()) { |
||||
return Status::GRPC_JSON_PARSE_ERROR; |
||||
} else if (c == '}' && |
||||
stack_.back()->type() != Json::Type::OBJECT) { |
||||
return Status::GRPC_JSON_PARSE_ERROR; |
||||
return Status::GRPC_JSON_PARSE_ERROR; |
||||
} else if (c == ']' && stack_.back()->type() != Json::Type::ARRAY) { |
||||
return Status::GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
if (!SetNumber()) return Status::GRPC_JSON_PARSE_ERROR; |
||||
state_ = State::GRPC_JSON_STATE_VALUE_END; |
||||
/* The missing break here is intentional. */ |
||||
/* fallthrough */ |
||||
|
||||
case State::GRPC_JSON_STATE_VALUE_END: |
||||
case State::GRPC_JSON_STATE_OBJECT_KEY_BEGIN: |
||||
case State::GRPC_JSON_STATE_VALUE_BEGIN: |
||||
if (c == ',') { |
||||
if (state_ != State::GRPC_JSON_STATE_VALUE_END) { |
||||
return Status::GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
if (!stack_.empty() && |
||||
stack_.back()->type() == Json::Type::OBJECT) { |
||||
state_ = State::GRPC_JSON_STATE_OBJECT_KEY_BEGIN; |
||||
} else if (!stack_.empty() && |
||||
stack_.back()->type() == Json::Type::ARRAY) { |
||||
state_ = State::GRPC_JSON_STATE_VALUE_BEGIN; |
||||
} else { |
||||
return Status::GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
} else { |
||||
if (stack_.empty()) { |
||||
return Status::GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
if (c == '}' && stack_.back()->type() != Json::Type::OBJECT) { |
||||
return Status::GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
if (c == '}' && |
||||
state_ == State::GRPC_JSON_STATE_OBJECT_KEY_BEGIN && |
||||
!container_just_begun_) { |
||||
return Status::GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
if (c == ']' && stack_.back()->type() != Json::Type::ARRAY) { |
||||
return Status::GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
if (c == ']' && state_ == State::GRPC_JSON_STATE_VALUE_BEGIN && |
||||
!container_just_begun_) { |
||||
return Status::GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
state_ = State::GRPC_JSON_STATE_VALUE_END; |
||||
EndContainer(); |
||||
if (stack_.empty()) { |
||||
state_ = State::GRPC_JSON_STATE_END; |
||||
} |
||||
} |
||||
break; |
||||
|
||||
default: |
||||
return Status::GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
break; |
||||
|
||||
/* In-string escaping. */ |
||||
case '\\': |
||||
switch (state_) { |
||||
case State::GRPC_JSON_STATE_OBJECT_KEY_STRING: |
||||
escaped_string_was_key_ = true; |
||||
state_ = State::GRPC_JSON_STATE_STRING_ESCAPE; |
||||
break; |
||||
|
||||
case State::GRPC_JSON_STATE_VALUE_STRING: |
||||
escaped_string_was_key_ = false; |
||||
state_ = State::GRPC_JSON_STATE_STRING_ESCAPE; |
||||
break; |
||||
|
||||
/* This is the \\ case. */ |
||||
case State::GRPC_JSON_STATE_STRING_ESCAPE: |
||||
if (unicode_high_surrogate_ != 0) |
||||
return Status::GRPC_JSON_PARSE_ERROR; |
||||
StringAddChar('\\'); |
||||
if (escaped_string_was_key_) { |
||||
state_ = State::GRPC_JSON_STATE_OBJECT_KEY_STRING; |
||||
} else { |
||||
state_ = State::GRPC_JSON_STATE_VALUE_STRING; |
||||
} |
||||
break; |
||||
|
||||
default: |
||||
return Status::GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
break; |
||||
|
||||
default: |
||||
container_just_begun_ = false; |
||||
switch (state_) { |
||||
case State::GRPC_JSON_STATE_OBJECT_KEY_BEGIN: |
||||
if (c != '"') return Status::GRPC_JSON_PARSE_ERROR; |
||||
state_ = State::GRPC_JSON_STATE_OBJECT_KEY_STRING; |
||||
break; |
||||
|
||||
case State::GRPC_JSON_STATE_OBJECT_KEY_STRING: |
||||
if (unicode_high_surrogate_ != 0) { |
||||
return Status::GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
if (c == '"') { |
||||
state_ = State::GRPC_JSON_STATE_OBJECT_KEY_END; |
||||
SetKey(); |
||||
} else { |
||||
if (c < 32) return Status::GRPC_JSON_PARSE_ERROR; |
||||
StringAddChar(c); |
||||
} |
||||
break; |
||||
|
||||
case State::GRPC_JSON_STATE_VALUE_STRING: |
||||
if (unicode_high_surrogate_ != 0) { |
||||
return Status::GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
if (c == '"') { |
||||
state_ = State::GRPC_JSON_STATE_VALUE_END; |
||||
SetString(); |
||||
} else { |
||||
if (c < 32) return Status::GRPC_JSON_PARSE_ERROR; |
||||
StringAddChar(c); |
||||
} |
||||
break; |
||||
|
||||
case State::GRPC_JSON_STATE_OBJECT_KEY_END: |
||||
if (c != ':') return Status::GRPC_JSON_PARSE_ERROR; |
||||
state_ = State::GRPC_JSON_STATE_VALUE_BEGIN; |
||||
break; |
||||
|
||||
case State::GRPC_JSON_STATE_VALUE_BEGIN: |
||||
switch (c) { |
||||
case 't': |
||||
state_ = State::GRPC_JSON_STATE_VALUE_TRUE_R; |
||||
break; |
||||
|
||||
case 'f': |
||||
state_ = State::GRPC_JSON_STATE_VALUE_FALSE_A; |
||||
break; |
||||
|
||||
case 'n': |
||||
state_ = State::GRPC_JSON_STATE_VALUE_NULL_U; |
||||
break; |
||||
|
||||
case '"': |
||||
state_ = State::GRPC_JSON_STATE_VALUE_STRING; |
||||
break; |
||||
|
||||
case '0': |
||||
StringAddChar(c); |
||||
state_ = State::GRPC_JSON_STATE_VALUE_NUMBER_ZERO; |
||||
break; |
||||
|
||||
case '1': |
||||
case '2': |
||||
case '3': |
||||
case '4': |
||||
case '5': |
||||
case '6': |
||||
case '7': |
||||
case '8': |
||||
case '9': |
||||
case '-': |
||||
StringAddChar(c); |
||||
state_ = State::GRPC_JSON_STATE_VALUE_NUMBER; |
||||
break; |
||||
|
||||
case '{': |
||||
container_just_begun_ = true; |
||||
StartContainer(Json::Type::OBJECT); |
||||
state_ = State::GRPC_JSON_STATE_OBJECT_KEY_BEGIN; |
||||
break; |
||||
|
||||
case '[': |
||||
container_just_begun_ = true; |
||||
StartContainer(Json::Type::ARRAY); |
||||
break; |
||||
default: |
||||
return Status::GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
break; |
||||
|
||||
case State::GRPC_JSON_STATE_STRING_ESCAPE: |
||||
if (escaped_string_was_key_) { |
||||
state_ = State::GRPC_JSON_STATE_OBJECT_KEY_STRING; |
||||
} else { |
||||
state_ = State::GRPC_JSON_STATE_VALUE_STRING; |
||||
} |
||||
if (unicode_high_surrogate_ && c != 'u') { |
||||
return Status::GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
switch (c) { |
||||
case '"': |
||||
case '/': |
||||
StringAddChar(c); |
||||
break; |
||||
case 'b': |
||||
StringAddChar('\b'); |
||||
break; |
||||
case 'f': |
||||
StringAddChar('\f'); |
||||
break; |
||||
case 'n': |
||||
StringAddChar('\n'); |
||||
break; |
||||
case 'r': |
||||
StringAddChar('\r'); |
||||
break; |
||||
case 't': |
||||
StringAddChar('\t'); |
||||
break; |
||||
case 'u': |
||||
state_ = State::GRPC_JSON_STATE_STRING_ESCAPE_U1; |
||||
unicode_char_ = 0; |
||||
break; |
||||
default: |
||||
return Status::GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
break; |
||||
|
||||
case State::GRPC_JSON_STATE_STRING_ESCAPE_U1: |
||||
case State::GRPC_JSON_STATE_STRING_ESCAPE_U2: |
||||
case State::GRPC_JSON_STATE_STRING_ESCAPE_U3: |
||||
case State::GRPC_JSON_STATE_STRING_ESCAPE_U4: |
||||
if ((c >= '0') && (c <= '9')) { |
||||
c -= '0'; |
||||
} else if ((c >= 'A') && (c <= 'F')) { |
||||
c -= 'A' - 10; |
||||
} else if ((c >= 'a') && (c <= 'f')) { |
||||
c -= 'a' - 10; |
||||
} else { |
||||
return Status::GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
unicode_char_ = static_cast<uint16_t>(unicode_char_ << 4); |
||||
unicode_char_ = static_cast<uint16_t>(unicode_char_ | c); |
||||
|
||||
switch (state_) { |
||||
case State::GRPC_JSON_STATE_STRING_ESCAPE_U1: |
||||
state_ = State::GRPC_JSON_STATE_STRING_ESCAPE_U2; |
||||
break; |
||||
case State::GRPC_JSON_STATE_STRING_ESCAPE_U2: |
||||
state_ = State::GRPC_JSON_STATE_STRING_ESCAPE_U3; |
||||
break; |
||||
case State::GRPC_JSON_STATE_STRING_ESCAPE_U3: |
||||
state_ = State::GRPC_JSON_STATE_STRING_ESCAPE_U4; |
||||
break; |
||||
case State::GRPC_JSON_STATE_STRING_ESCAPE_U4: |
||||
/* See grpc_json_writer_escape_string to have a description
|
||||
* of what's going on here. |
||||
*/ |
||||
if ((unicode_char_ & 0xfc00) == 0xd800) { |
||||
/* high surrogate utf-16 */ |
||||
if (unicode_high_surrogate_ != 0) |
||||
return Status::GRPC_JSON_PARSE_ERROR; |
||||
unicode_high_surrogate_ = unicode_char_; |
||||
} else if ((unicode_char_ & 0xfc00) == 0xdc00) { |
||||
/* low surrogate utf-16 */ |
||||
uint32_t utf32; |
||||
if (unicode_high_surrogate_ == 0) |
||||
return Status::GRPC_JSON_PARSE_ERROR; |
||||
utf32 = 0x10000; |
||||
utf32 += static_cast<uint32_t>( |
||||
(unicode_high_surrogate_ - 0xd800) * 0x400); |
||||
utf32 += static_cast<uint32_t>(unicode_char_ - 0xdc00); |
||||
StringAddUtf32(utf32); |
||||
unicode_high_surrogate_ = 0; |
||||
} else { |
||||
/* anything else */ |
||||
if (unicode_high_surrogate_ != 0) |
||||
return Status::GRPC_JSON_PARSE_ERROR; |
||||
StringAddUtf32(unicode_char_); |
||||
} |
||||
if (escaped_string_was_key_) { |
||||
state_ = State::GRPC_JSON_STATE_OBJECT_KEY_STRING; |
||||
} else { |
||||
state_ = State::GRPC_JSON_STATE_VALUE_STRING; |
||||
} |
||||
break; |
||||
default: |
||||
GPR_UNREACHABLE_CODE(return Status::GRPC_JSON_INTERNAL_ERROR); |
||||
} |
||||
break; |
||||
|
||||
case State::GRPC_JSON_STATE_VALUE_NUMBER: |
||||
StringAddChar(c); |
||||
switch (c) { |
||||
case '0': |
||||
case '1': |
||||
case '2': |
||||
case '3': |
||||
case '4': |
||||
case '5': |
||||
case '6': |
||||
case '7': |
||||
case '8': |
||||
case '9': |
||||
break; |
||||
case 'e': |
||||
case 'E': |
||||
state_ = State::GRPC_JSON_STATE_VALUE_NUMBER_E; |
||||
break; |
||||
case '.': |
||||
state_ = State::GRPC_JSON_STATE_VALUE_NUMBER_DOT; |
||||
break; |
||||
default: |
||||
return Status::GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
break; |
||||
|
||||
case State::GRPC_JSON_STATE_VALUE_NUMBER_WITH_DECIMAL: |
||||
StringAddChar(c); |
||||
switch (c) { |
||||
case '0': |
||||
case '1': |
||||
case '2': |
||||
case '3': |
||||
case '4': |
||||
case '5': |
||||
case '6': |
||||
case '7': |
||||
case '8': |
||||
case '9': |
||||
break; |
||||
case 'e': |
||||
case 'E': |
||||
state_ = State::GRPC_JSON_STATE_VALUE_NUMBER_E; |
||||
break; |
||||
default: |
||||
return Status::GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
break; |
||||
|
||||
case State::GRPC_JSON_STATE_VALUE_NUMBER_ZERO: |
||||
if (c != '.') return Status::GRPC_JSON_PARSE_ERROR; |
||||
StringAddChar(c); |
||||
state_ = State::GRPC_JSON_STATE_VALUE_NUMBER_DOT; |
||||
break; |
||||
|
||||
case State::GRPC_JSON_STATE_VALUE_NUMBER_DOT: |
||||
StringAddChar(c); |
||||
switch (c) { |
||||
case '0': |
||||
case '1': |
||||
case '2': |
||||
case '3': |
||||
case '4': |
||||
case '5': |
||||
case '6': |
||||
case '7': |
||||
case '8': |
||||
case '9': |
||||
state_ = State::GRPC_JSON_STATE_VALUE_NUMBER_WITH_DECIMAL; |
||||
break; |
||||
default: |
||||
return Status::GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
break; |
||||
|
||||
case State::GRPC_JSON_STATE_VALUE_NUMBER_E: |
||||
StringAddChar(c); |
||||
switch (c) { |
||||
case '0': |
||||
case '1': |
||||
case '2': |
||||
case '3': |
||||
case '4': |
||||
case '5': |
||||
case '6': |
||||
case '7': |
||||
case '8': |
||||
case '9': |
||||
case '+': |
||||
case '-': |
||||
state_ = State::GRPC_JSON_STATE_VALUE_NUMBER_EPM; |
||||
break; |
||||
default: |
||||
return Status::GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
break; |
||||
|
||||
case State::GRPC_JSON_STATE_VALUE_NUMBER_EPM: |
||||
StringAddChar(c); |
||||
switch (c) { |
||||
case '0': |
||||
case '1': |
||||
case '2': |
||||
case '3': |
||||
case '4': |
||||
case '5': |
||||
case '6': |
||||
case '7': |
||||
case '8': |
||||
case '9': |
||||
break; |
||||
default: |
||||
return Status::GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
break; |
||||
|
||||
case State::GRPC_JSON_STATE_VALUE_TRUE_R: |
||||
if (c != 'r') return Status::GRPC_JSON_PARSE_ERROR; |
||||
state_ = State::GRPC_JSON_STATE_VALUE_TRUE_U; |
||||
break; |
||||
|
||||
case State::GRPC_JSON_STATE_VALUE_TRUE_U: |
||||
if (c != 'u') return Status::GRPC_JSON_PARSE_ERROR; |
||||
state_ = State::GRPC_JSON_STATE_VALUE_TRUE_E; |
||||
break; |
||||
|
||||
case State::GRPC_JSON_STATE_VALUE_TRUE_E: |
||||
if (c != 'e') return Status::GRPC_JSON_PARSE_ERROR; |
||||
SetTrue(); |
||||
state_ = State::GRPC_JSON_STATE_VALUE_END; |
||||
break; |
||||
|
||||
case State::GRPC_JSON_STATE_VALUE_FALSE_A: |
||||
if (c != 'a') return Status::GRPC_JSON_PARSE_ERROR; |
||||
state_ = State::GRPC_JSON_STATE_VALUE_FALSE_L; |
||||
break; |
||||
|
||||
case State::GRPC_JSON_STATE_VALUE_FALSE_L: |
||||
if (c != 'l') return Status::GRPC_JSON_PARSE_ERROR; |
||||
state_ = State::GRPC_JSON_STATE_VALUE_FALSE_S; |
||||
break; |
||||
|
||||
case State::GRPC_JSON_STATE_VALUE_FALSE_S: |
||||
if (c != 's') return Status::GRPC_JSON_PARSE_ERROR; |
||||
state_ = State::GRPC_JSON_STATE_VALUE_FALSE_E; |
||||
break; |
||||
|
||||
case State::GRPC_JSON_STATE_VALUE_FALSE_E: |
||||
if (c != 'e') return Status::GRPC_JSON_PARSE_ERROR; |
||||
SetFalse(); |
||||
state_ = State::GRPC_JSON_STATE_VALUE_END; |
||||
break; |
||||
|
||||
case State::GRPC_JSON_STATE_VALUE_NULL_U: |
||||
if (c != 'u') return Status::GRPC_JSON_PARSE_ERROR; |
||||
state_ = State::GRPC_JSON_STATE_VALUE_NULL_L1; |
||||
break; |
||||
|
||||
case State::GRPC_JSON_STATE_VALUE_NULL_L1: |
||||
if (c != 'l') return Status::GRPC_JSON_PARSE_ERROR; |
||||
state_ = State::GRPC_JSON_STATE_VALUE_NULL_L2; |
||||
break; |
||||
|
||||
case State::GRPC_JSON_STATE_VALUE_NULL_L2: |
||||
if (c != 'l') return Status::GRPC_JSON_PARSE_ERROR; |
||||
SetNull(); |
||||
state_ = State::GRPC_JSON_STATE_VALUE_END; |
||||
break; |
||||
|
||||
/* All of the VALUE_END cases are handled in the specialized case
|
||||
* above. */ |
||||
case State::GRPC_JSON_STATE_VALUE_END: |
||||
switch (c) { |
||||
case ',': |
||||
case '}': |
||||
case ']': |
||||
GPR_UNREACHABLE_CODE(return Status::GRPC_JSON_INTERNAL_ERROR); |
||||
break; |
||||
|
||||
default: |
||||
return Status::GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
break; |
||||
|
||||
case State::GRPC_JSON_STATE_END: |
||||
return Status::GRPC_JSON_PARSE_ERROR; |
||||
} |
||||
} |
||||
} |
||||
|
||||
GPR_UNREACHABLE_CODE(return Status::GRPC_JSON_INTERNAL_ERROR); |
||||
} |
||||
|
||||
JsonReader::Status JsonReader::Parse(StringView input, Json* output) { |
||||
JsonReader reader(input); |
||||
Status status = reader.Run(); |
||||
if (reader.duplicate_key_found_) status = Status::GRPC_JSON_PARSE_ERROR; |
||||
if (status == Status::GRPC_JSON_DONE) { |
||||
*output = std::move(reader.root_value_); |
||||
} |
||||
return status; |
||||
} |
||||
|
||||
} // namespace
|
||||
|
||||
Json Json::Parse(StringView json_str, grpc_error** error) { |
||||
Json value; |
||||
JsonReader::Status status = JsonReader::Parse(json_str, &value); |
||||
if (status == JsonReader::Status::GRPC_JSON_PARSE_ERROR) { |
||||
*error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("JSON parse error"); |
||||
} else if (status == JsonReader::Status::GRPC_JSON_INTERNAL_ERROR) { |
||||
*error = |
||||
GRPC_ERROR_CREATE_FROM_STATIC_STRING("internal error in JSON parser"); |
||||
} |
||||
return value; |
||||
} |
||||
|
||||
} // namespace grpc_core
|
||||
@ -0,0 +1,336 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015 gRPC authors. |
||||
* |
||||
* Licensed under the Apache License, Version 2.0 (the "License"); |
||||
* you may not use this file except in compliance with the License. |
||||
* You may obtain a copy of the License at |
||||
* |
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
* |
||||
* Unless required by applicable law or agreed to in writing, software |
||||
* distributed under the License is distributed on an "AS IS" BASIS, |
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
* See the License for the specific language governing permissions and |
||||
* limitations under the License. |
||||
* |
||||
*/ |
||||
|
||||
#include <grpc/support/port_platform.h> |
||||
|
||||
#include <stdlib.h> |
||||
#include <string.h> |
||||
|
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/log.h> |
||||
|
||||
#include "src/core/lib/json/json.h" |
||||
|
||||
#include "src/core/lib/gprpp/string_view.h" |
||||
|
||||
namespace grpc_core { |
||||
|
||||
namespace { |
||||
|
||||
/* The idea of the writer is basically symmetrical of the reader. While the
|
||||
* reader emits various calls to your code, the writer takes basically the |
||||
* same calls and emit json out of it. It doesn't try to make any check on |
||||
* the order of the calls you do on it. Meaning you can theorically force |
||||
* it to generate invalid json. |
||||
* |
||||
* Also, unlike the reader, the writer expects UTF-8 encoded input strings. |
||||
* These strings will be UTF-8 validated, and any invalid character will |
||||
* cut the conversion short, before any invalid UTF-8 sequence, thus forming |
||||
* a valid UTF-8 string overall. |
||||
*/ |
||||
class JsonWriter { |
||||
public: |
||||
static std::string Dump(const Json& value, int indent); |
||||
|
||||
private: |
||||
explicit JsonWriter(int indent) : indent_(indent) {} |
||||
|
||||
void OutputCheck(size_t needed); |
||||
void OutputChar(char c); |
||||
void OutputString(const StringView str); |
||||
void OutputIndent(); |
||||
void ValueEnd(); |
||||
void EscapeUtf16(uint16_t utf16); |
||||
void EscapeString(const std::string& string); |
||||
void ContainerBegins(Json::Type type); |
||||
void ContainerEnds(Json::Type type); |
||||
void ObjectKey(const std::string& string); |
||||
void ValueRaw(const std::string& string); |
||||
void ValueString(const std::string& string); |
||||
|
||||
void DumpObject(const Json::Object& object); |
||||
void DumpArray(const Json::Array& array); |
||||
void DumpValue(const Json& value); |
||||
|
||||
int indent_; |
||||
int depth_ = 0; |
||||
bool container_empty_ = true; |
||||
bool got_key_ = false; |
||||
std::string output_; |
||||
}; |
||||
|
||||
/* This function checks if there's enough space left in the output buffer,
|
||||
* and will enlarge it if necessary. We're only allocating chunks of 256 |
||||
* bytes at a time (or multiples thereof). |
||||
*/ |
||||
void JsonWriter::OutputCheck(size_t needed) { |
||||
size_t free_space = output_.capacity() - output_.size(); |
||||
if (free_space >= needed) return; |
||||
needed -= free_space; |
||||
/* Round up by 256 bytes. */ |
||||
needed = (needed + 0xff) & ~0xffU; |
||||
output_.reserve(output_.capacity() + needed); |
||||
} |
||||
|
||||
void JsonWriter::OutputChar(char c) { |
||||
OutputCheck(1); |
||||
output_.push_back(c); |
||||
} |
||||
|
||||
void JsonWriter::OutputString(const StringView str) { |
||||
OutputCheck(str.size()); |
||||
output_.append(str.data(), str.size()); |
||||
} |
||||
|
||||
void JsonWriter::OutputIndent() { |
||||
static const char spacesstr[] = |
||||
" " |
||||
" " |
||||
" " |
||||
" "; |
||||
unsigned spaces = static_cast<unsigned>(depth_ * indent_); |
||||
if (indent_ == 0) return; |
||||
if (got_key_) { |
||||
OutputChar(' '); |
||||
return; |
||||
} |
||||
while (spaces >= (sizeof(spacesstr) - 1)) { |
||||
OutputString(StringView(spacesstr, sizeof(spacesstr) - 1)); |
||||
spaces -= static_cast<unsigned>(sizeof(spacesstr) - 1); |
||||
} |
||||
if (spaces == 0) return; |
||||
OutputString(StringView(spacesstr + sizeof(spacesstr) - 1 - spaces, spaces)); |
||||
} |
||||
|
||||
void JsonWriter::ValueEnd() { |
||||
if (container_empty_) { |
||||
container_empty_ = false; |
||||
if (indent_ == 0 || depth_ == 0) return; |
||||
OutputChar('\n'); |
||||
} else { |
||||
OutputChar(','); |
||||
if (indent_ == 0) return; |
||||
OutputChar('\n'); |
||||
} |
||||
} |
||||
|
||||
void JsonWriter::EscapeUtf16(uint16_t utf16) { |
||||
static const char hex[] = "0123456789abcdef"; |
||||
OutputString(StringView("\\u", 2)); |
||||
OutputChar(hex[(utf16 >> 12) & 0x0f]); |
||||
OutputChar(hex[(utf16 >> 8) & 0x0f]); |
||||
OutputChar(hex[(utf16 >> 4) & 0x0f]); |
||||
OutputChar(hex[(utf16)&0x0f]); |
||||
} |
||||
|
||||
void JsonWriter::EscapeString(const std::string& string) { |
||||
OutputChar('"'); |
||||
for (size_t idx = 0; idx < string.size(); ++idx) { |
||||
uint8_t c = static_cast<uint8_t>(string[idx]); |
||||
if (c == 0) { |
||||
break; |
||||
} else if (c >= 32 && c <= 126) { |
||||
if (c == '\\' || c == '"') OutputChar('\\'); |
||||
OutputChar(static_cast<char>(c)); |
||||
} else if (c < 32 || c == 127) { |
||||
switch (c) { |
||||
case '\b': |
||||
OutputString(StringView("\\b", 2)); |
||||
break; |
||||
case '\f': |
||||
OutputString(StringView("\\f", 2)); |
||||
break; |
||||
case '\n': |
||||
OutputString(StringView("\\n", 2)); |
||||
break; |
||||
case '\r': |
||||
OutputString(StringView("\\r", 2)); |
||||
break; |
||||
case '\t': |
||||
OutputString(StringView("\\t", 2)); |
||||
break; |
||||
default: |
||||
EscapeUtf16(c); |
||||
break; |
||||
} |
||||
} else { |
||||
uint32_t utf32 = 0; |
||||
int extra = 0; |
||||
int i; |
||||
int valid = 1; |
||||
if ((c & 0xe0) == 0xc0) { |
||||
utf32 = c & 0x1f; |
||||
extra = 1; |
||||
} else if ((c & 0xf0) == 0xe0) { |
||||
utf32 = c & 0x0f; |
||||
extra = 2; |
||||
} else if ((c & 0xf8) == 0xf0) { |
||||
utf32 = c & 0x07; |
||||
extra = 3; |
||||
} else { |
||||
break; |
||||
} |
||||
for (i = 0; i < extra; i++) { |
||||
utf32 <<= 6; |
||||
++idx; |
||||
/* Breaks out and bail if we hit the end of the string. */ |
||||
if (idx == string.size()) { |
||||
valid = 0; |
||||
break; |
||||
} |
||||
c = static_cast<uint8_t>(string[idx]); |
||||
/* Breaks out and bail on any invalid UTF-8 sequence, including \0. */ |
||||
if ((c & 0xc0) != 0x80) { |
||||
valid = 0; |
||||
break; |
||||
} |
||||
utf32 |= c & 0x3f; |
||||
} |
||||
if (!valid) break; |
||||
/* The range 0xd800 - 0xdfff is reserved by the surrogates ad vitam.
|
||||
* Any other range is technically reserved for future usage, so if we |
||||
* don't want the software to break in the future, we have to allow |
||||
* anything else. The first non-unicode character is 0x110000. */ |
||||
if (((utf32 >= 0xd800) && (utf32 <= 0xdfff)) || (utf32 >= 0x110000)) |
||||
break; |
||||
if (utf32 >= 0x10000) { |
||||
/* If utf32 contains a character that is above 0xffff, it needs to be
|
||||
* broken down into a utf-16 surrogate pair. A surrogate pair is first |
||||
* a high surrogate, followed by a low surrogate. Each surrogate holds |
||||
* 10 bits of usable data, thus allowing a total of 20 bits of data. |
||||
* The high surrogate marker is 0xd800, while the low surrogate marker |
||||
* is 0xdc00. The low 10 bits of each will be the usable data. |
||||
* |
||||
* After re-combining the 20 bits of data, one has to add 0x10000 to |
||||
* the resulting value, in order to obtain the original character. |
||||
* This is obviously because the range 0x0000 - 0xffff can be written |
||||
* without any special trick. |
||||
* |
||||
* Since 0x10ffff is the highest allowed character, we're working in |
||||
* the range 0x00000 - 0xfffff after we decrement it by 0x10000. |
||||
* That range is exactly 20 bits. |
||||
*/ |
||||
utf32 -= 0x10000; |
||||
EscapeUtf16(static_cast<uint16_t>(0xd800 | (utf32 >> 10))); |
||||
EscapeUtf16(static_cast<uint16_t>(0xdc00 | (utf32 & 0x3ff))); |
||||
} else { |
||||
EscapeUtf16(static_cast<uint16_t>(utf32)); |
||||
} |
||||
} |
||||
} |
||||
OutputChar('"'); |
||||
} |
||||
|
||||
void JsonWriter::ContainerBegins(Json::Type type) { |
||||
if (!got_key_) ValueEnd(); |
||||
OutputIndent(); |
||||
OutputChar(type == Json::Type::OBJECT ? '{' : '['); |
||||
container_empty_ = true; |
||||
got_key_ = false; |
||||
depth_++; |
||||
} |
||||
|
||||
void JsonWriter::ContainerEnds(Json::Type type) { |
||||
if (indent_ && !container_empty_) OutputChar('\n'); |
||||
depth_--; |
||||
if (!container_empty_) OutputIndent(); |
||||
OutputChar(type == Json::Type::OBJECT ? '}' : ']'); |
||||
container_empty_ = false; |
||||
got_key_ = false; |
||||
} |
||||
|
||||
void JsonWriter::ObjectKey(const std::string& string) { |
||||
ValueEnd(); |
||||
OutputIndent(); |
||||
EscapeString(string); |
||||
OutputChar(':'); |
||||
got_key_ = true; |
||||
} |
||||
|
||||
void JsonWriter::ValueRaw(const std::string& string) { |
||||
if (!got_key_) ValueEnd(); |
||||
OutputIndent(); |
||||
OutputString(string); |
||||
got_key_ = false; |
||||
} |
||||
|
||||
void JsonWriter::ValueString(const std::string& string) { |
||||
if (!got_key_) ValueEnd(); |
||||
OutputIndent(); |
||||
EscapeString(string); |
||||
got_key_ = false; |
||||
} |
||||
|
||||
void JsonWriter::DumpObject(const Json::Object& object) { |
||||
ContainerBegins(Json::Type::OBJECT); |
||||
for (const auto& p : object) { |
||||
ObjectKey(p.first.data()); |
||||
DumpValue(p.second); |
||||
} |
||||
ContainerEnds(Json::Type::OBJECT); |
||||
} |
||||
|
||||
void JsonWriter::DumpArray(const Json::Array& array) { |
||||
ContainerBegins(Json::Type::ARRAY); |
||||
for (const auto& v : array) { |
||||
DumpValue(v); |
||||
} |
||||
ContainerEnds(Json::Type::ARRAY); |
||||
} |
||||
|
||||
void JsonWriter::DumpValue(const Json& value) { |
||||
switch (value.type()) { |
||||
case Json::Type::OBJECT: |
||||
DumpObject(value.object_value()); |
||||
break; |
||||
case Json::Type::ARRAY: |
||||
DumpArray(value.array_value()); |
||||
break; |
||||
case Json::Type::STRING: |
||||
ValueString(value.string_value()); |
||||
break; |
||||
case Json::Type::NUMBER: |
||||
ValueRaw(value.string_value()); |
||||
break; |
||||
case Json::Type::JSON_TRUE: |
||||
ValueRaw(std::string("true", 4)); |
||||
break; |
||||
case Json::Type::JSON_FALSE: |
||||
ValueRaw(std::string("false", 5)); |
||||
break; |
||||
case Json::Type::JSON_NULL: |
||||
ValueRaw(std::string("null", 4)); |
||||
break; |
||||
default: |
||||
GPR_UNREACHABLE_CODE(abort()); |
||||
} |
||||
} |
||||
|
||||
std::string JsonWriter::Dump(const Json& value, int indent) { |
||||
JsonWriter writer(indent); |
||||
writer.DumpValue(value); |
||||
return std::move(writer.output_); |
||||
} |
||||
|
||||
} // namespace
|
||||
|
||||
std::string Json::Dump(int indent) const { |
||||
return JsonWriter::Dump(*this, indent); |
||||
} |
||||
|
||||
} // namespace grpc_core
|
||||
@ -0,0 +1,295 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015-2016 gRPC authors. |
||||
* |
||||
* Licensed under the Apache License, Version 2.0 (the "License"); |
||||
* you may not use this file except in compliance with the License. |
||||
* You may obtain a copy of the License at |
||||
* |
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
* |
||||
* Unless required by applicable law or agreed to in writing, software |
||||
* distributed under the License is distributed on an "AS IS" BASIS, |
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
* See the License for the specific language governing permissions and |
||||
* limitations under the License. |
||||
* |
||||
*/ |
||||
|
||||
#include <string.h> |
||||
|
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/log.h> |
||||
#include <grpc/support/string_util.h> |
||||
|
||||
#include <gmock/gmock.h> |
||||
#include <gtest/gtest.h> |
||||
|
||||
#include "src/core/lib/gpr/string.h" |
||||
#include "src/core/lib/gpr/useful.h" |
||||
#include "src/core/lib/json/json.h" |
||||
|
||||
#include "test/core/util/test_config.h" |
||||
|
||||
namespace grpc_core { |
||||
|
||||
void ValidateValue(const Json& actual, const Json& expected); |
||||
|
||||
void ValidateObject(const Json::Object& actual, const Json::Object& expected) { |
||||
ASSERT_EQ(actual.size(), expected.size()); |
||||
auto actual_it = actual.begin(); |
||||
for (const auto& p : expected) { |
||||
EXPECT_EQ(actual_it->first, p.first); |
||||
ValidateValue(actual_it->second, p.second); |
||||
++actual_it; |
||||
} |
||||
} |
||||
|
||||
void ValidateArray(const Json::Array& actual, const Json::Array& expected) { |
||||
ASSERT_EQ(actual.size(), expected.size()); |
||||
for (size_t i = 0; i < expected.size(); ++i) { |
||||
ValidateValue(actual[i], expected[i]); |
||||
} |
||||
} |
||||
|
||||
void ValidateValue(const Json& actual, const Json& expected) { |
||||
ASSERT_EQ(actual.type(), expected.type()); |
||||
switch (expected.type()) { |
||||
case Json::Type::JSON_NULL: |
||||
case Json::Type::JSON_TRUE: |
||||
case Json::Type::JSON_FALSE: |
||||
break; |
||||
case Json::Type::STRING: |
||||
case Json::Type::NUMBER: |
||||
EXPECT_EQ(actual.string_value(), expected.string_value()); |
||||
break; |
||||
case Json::Type::OBJECT: |
||||
ValidateObject(actual.object_value(), expected.object_value()); |
||||
break; |
||||
case Json::Type::ARRAY: |
||||
ValidateArray(actual.array_value(), expected.array_value()); |
||||
break; |
||||
} |
||||
} |
||||
|
||||
void RunSuccessTest(const char* input, const Json& expected, |
||||
const char* expected_output) { |
||||
gpr_log(GPR_INFO, "parsing string \"%s\" - should succeed", input); |
||||
grpc_error* error = GRPC_ERROR_NONE; |
||||
Json json = Json::Parse(input, &error); |
||||
ASSERT_EQ(error, GRPC_ERROR_NONE) << grpc_error_string(error); |
||||
ValidateValue(json, expected); |
||||
std::string output = json.Dump(); |
||||
EXPECT_EQ(output, expected_output); |
||||
} |
||||
|
||||
TEST(Json, Whitespace) { |
||||
RunSuccessTest(" 0 ", 0, "0"); |
||||
RunSuccessTest(" 1 ", 1, "1"); |
||||
RunSuccessTest(" \" \" ", " ", "\" \""); |
||||
RunSuccessTest(" \"a\" ", "a", "\"a\""); |
||||
RunSuccessTest(" true ", true, "true"); |
||||
} |
||||
|
||||
TEST(Json, Utf16) { |
||||
RunSuccessTest("\"\\u0020\\\\\\u0010\\u000a\\u000D\"", " \\\u0010\n\r", |
||||
"\" \\\\\\u0010\\n\\r\""); |
||||
} |
||||
|
||||
TEST(Json, Utf8) { |
||||
RunSuccessTest("\"ßâñć௵⇒\"", "ßâñć௵⇒", |
||||
"\"\\u00df\\u00e2\\u00f1\\u0107\\u0bf5\\u21d2\""); |
||||
RunSuccessTest("\"\\u00df\\u00e2\\u00f1\\u0107\\u0bf5\\u21d2\"", "ßâñć௵⇒", |
||||
"\"\\u00df\\u00e2\\u00f1\\u0107\\u0bf5\\u21d2\""); |
||||
// Testing UTF-8 character "𝄞", U+11D1E.
|
||||
RunSuccessTest("\"\xf0\x9d\x84\x9e\"", "\xf0\x9d\x84\x9e", |
||||
"\"\\ud834\\udd1e\""); |
||||
RunSuccessTest("\"\\ud834\\udd1e\"", "\xf0\x9d\x84\x9e", |
||||
"\"\\ud834\\udd1e\""); |
||||
RunSuccessTest("{\"\\ud834\\udd1e\":0}", |
||||
Json::Object{{"\xf0\x9d\x84\x9e", 0}}, |
||||
"{\"\\ud834\\udd1e\":0}"); |
||||
} |
||||
|
||||
TEST(Json, NestedEmptyContainers) { |
||||
RunSuccessTest(" [ [ ] , { } , [ ] ] ", |
||||
Json::Array{ |
||||
Json::Array(), |
||||
Json::Object(), |
||||
Json::Array(), |
||||
}, |
||||
"[[],{},[]]"); |
||||
} |
||||
|
||||
TEST(Json, EscapesAndControlCharactersInKeyStrings) { |
||||
RunSuccessTest(" { \"\\u007f\x7f\\n\\r\\\"\\f\\b\\\\a , b\": 1, \"\": 0 } ", |
||||
Json::Object{ |
||||
{"\u007f\u007f\n\r\"\f\b\\a , b", 1}, |
||||
{"", 0}, |
||||
}, |
||||
"{\"\":0,\"\\u007f\\u007f\\n\\r\\\"\\f\\b\\\\a , b\":1}"); |
||||
} |
||||
|
||||
TEST(Json, WriterCutsOffInvalidUtf8) { |
||||
RunSuccessTest("\"abc\xf0\x9d\x24\"", "abc\xf0\x9d\x24", "\"abc\""); |
||||
RunSuccessTest("\"\xff\"", "\xff", "\"\""); |
||||
} |
||||
|
||||
TEST(Json, ValidNumbers) { |
||||
RunSuccessTest("[0, 42 , 0.0123, 123.456]", |
||||
Json::Array{ |
||||
0, |
||||
42, |
||||
Json("0.0123", /*is_number=*/true), |
||||
Json("123.456", /*is_number=*/true), |
||||
}, |
||||
"[0,42,0.0123,123.456]"); |
||||
RunSuccessTest("[1e4,-53.235e-31, 0.3e+3]", |
||||
Json::Array{ |
||||
Json("1e4", /*is_number=*/true), |
||||
Json("-53.235e-31", /*is_number=*/true), |
||||
Json("0.3e+3", /*is_number=*/true), |
||||
}, |
||||
"[1e4,-53.235e-31,0.3e+3]"); |
||||
} |
||||
|
||||
TEST(Json, Keywords) { |
||||
RunSuccessTest("[true, false, null]", |
||||
Json::Array{ |
||||
Json(true), |
||||
Json(false), |
||||
Json(), |
||||
}, |
||||
"[true,false,null]"); |
||||
} |
||||
|
||||
void RunParseFailureTest(const char* input) { |
||||
gpr_log(GPR_INFO, "parsing string \"%s\" - should fail", input); |
||||
grpc_error* error = GRPC_ERROR_NONE; |
||||
Json json = Json::Parse(input, &error); |
||||
gpr_log(GPR_INFO, "error: %s", grpc_error_string(error)); |
||||
EXPECT_NE(error, GRPC_ERROR_NONE); |
||||
GRPC_ERROR_UNREF(error); |
||||
} |
||||
|
||||
TEST(Json, InvalidInput) { |
||||
RunParseFailureTest("\\"); |
||||
RunParseFailureTest("nu ll"); |
||||
RunParseFailureTest("{\"foo\": bar}"); |
||||
RunParseFailureTest("{\"foo\": bar\"x\"}"); |
||||
RunParseFailureTest("fals"); |
||||
RunParseFailureTest("0,0 "); |
||||
RunParseFailureTest("\"foo\",[]"); |
||||
} |
||||
|
||||
TEST(Json, UnterminatedString) { RunParseFailureTest("\"\\x"); } |
||||
|
||||
TEST(Json, InvalidUtf16) { |
||||
RunParseFailureTest("\"\\u123x"); |
||||
RunParseFailureTest("{\"\\u123x"); |
||||
} |
||||
|
||||
TEST(Json, ImbalancedSurrogatePairs) { |
||||
RunParseFailureTest("\"\\ud834f"); |
||||
RunParseFailureTest("{\"\\ud834f\":0}"); |
||||
RunParseFailureTest("\"\\ud834\\n"); |
||||
RunParseFailureTest("{\"\\ud834\\n\":0}"); |
||||
RunParseFailureTest("\"\\udd1ef"); |
||||
RunParseFailureTest("{\"\\udd1ef\":0}"); |
||||
RunParseFailureTest("\"\\ud834\\ud834\""); |
||||
RunParseFailureTest("{\"\\ud834\\ud834\"\":0}"); |
||||
RunParseFailureTest("\"\\ud834\\u1234\""); |
||||
RunParseFailureTest("{\"\\ud834\\u1234\"\":0}"); |
||||
RunParseFailureTest("\"\\ud834]\""); |
||||
RunParseFailureTest("{\"\\ud834]\"\":0}"); |
||||
RunParseFailureTest("\"\\ud834 \""); |
||||
RunParseFailureTest("{\"\\ud834 \"\":0}"); |
||||
RunParseFailureTest("\"\\ud834\\\\\""); |
||||
RunParseFailureTest("{\"\\ud834\\\\\"\":0}"); |
||||
} |
||||
|
||||
TEST(Json, EmbeddedInvalidWhitechars) { |
||||
RunParseFailureTest("\"\n\""); |
||||
RunParseFailureTest("\"\t\""); |
||||
} |
||||
|
||||
TEST(Json, EmptyString) { RunParseFailureTest(""); } |
||||
|
||||
TEST(Json, ExtraCharsAtEndOfParsing) { |
||||
RunParseFailureTest("{},"); |
||||
RunParseFailureTest("{}x"); |
||||
} |
||||
|
||||
TEST(Json, ImbalancedContainers) { |
||||
RunParseFailureTest("{}}"); |
||||
RunParseFailureTest("[]]"); |
||||
RunParseFailureTest("{{}"); |
||||
RunParseFailureTest("[[]"); |
||||
RunParseFailureTest("[}"); |
||||
RunParseFailureTest("{]"); |
||||
} |
||||
|
||||
TEST(Json, BadContainers) { |
||||
RunParseFailureTest("{x}"); |
||||
RunParseFailureTest("{x=0,y}"); |
||||
} |
||||
|
||||
TEST(Json, DuplicateObjectKeys) { RunParseFailureTest("{\"x\": 1, \"x\": 1}"); } |
||||
|
||||
TEST(Json, TrailingComma) { |
||||
RunParseFailureTest("{,}"); |
||||
RunParseFailureTest("[1,2,3,4,]"); |
||||
RunParseFailureTest("{\"a\": 1, }"); |
||||
} |
||||
|
||||
TEST(Json, KeySyntaxInArray) { RunParseFailureTest("[\"x\":0]"); } |
||||
|
||||
TEST(Json, InvalidNumbers) { |
||||
RunParseFailureTest("1."); |
||||
RunParseFailureTest("1e"); |
||||
RunParseFailureTest(".12"); |
||||
RunParseFailureTest("1.x"); |
||||
RunParseFailureTest("1.12x"); |
||||
RunParseFailureTest("1ex"); |
||||
RunParseFailureTest("1e12x"); |
||||
RunParseFailureTest(".12x"); |
||||
RunParseFailureTest("000"); |
||||
}; |
||||
|
||||
TEST(Json, Equality) { |
||||
// Null.
|
||||
EXPECT_EQ(Json(), Json()); |
||||
// Numbers.
|
||||
EXPECT_EQ(Json(1), Json(1)); |
||||
EXPECT_NE(Json(1), Json(2)); |
||||
EXPECT_EQ(Json(1), Json("1", /*is_number=*/true)); |
||||
EXPECT_EQ(Json("-5e5", /*is_number=*/true), Json("-5e5", /*is_number=*/true)); |
||||
// Booleans.
|
||||
EXPECT_EQ(Json(true), Json(true)); |
||||
EXPECT_EQ(Json(false), Json(false)); |
||||
EXPECT_NE(Json(true), Json(false)); |
||||
// Strings.
|
||||
EXPECT_EQ(Json("foo"), Json("foo")); |
||||
EXPECT_NE(Json("foo"), Json("bar")); |
||||
// Arrays.
|
||||
EXPECT_EQ(Json(Json::Array{"foo"}), Json(Json::Array{"foo"})); |
||||
EXPECT_NE(Json(Json::Array{"foo"}), Json(Json::Array{"bar"})); |
||||
// Objects.
|
||||
EXPECT_EQ(Json(Json::Object{{"foo", 1}}), Json(Json::Object{{"foo", 1}})); |
||||
EXPECT_NE(Json(Json::Object{{"foo", 1}}), Json(Json::Object{{"foo", 2}})); |
||||
EXPECT_NE(Json(Json::Object{{"foo", 1}}), Json(Json::Object{{"bar", 1}})); |
||||
// Differing types.
|
||||
EXPECT_NE(Json(1), Json("foo")); |
||||
EXPECT_NE(Json(1), Json(true)); |
||||
EXPECT_NE(Json(1), Json(Json::Array{})); |
||||
EXPECT_NE(Json(1), Json(Json::Object{})); |
||||
EXPECT_NE(Json(1), Json()); |
||||
} |
||||
|
||||
} // namespace grpc_core
|
||||
|
||||
int main(int argc, char** argv) { |
||||
grpc::testing::TestEnvironment env(argc, argv); |
||||
::testing::InitGoogleTest(&argc, argv); |
||||
return RUN_ALL_TESTS(); |
||||
} |
||||
Loading…
Reference in new issue