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
11 KiB
336 lines
11 KiB
// |
|
// 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 "src/core/util/json/json.h" |
|
|
|
#include <string.h> |
|
|
|
#include <map> |
|
#include <string> |
|
#include <utility> |
|
|
|
#include "absl/log/log.h" |
|
#include "absl/status/status.h" |
|
#include "absl/status/statusor.h" |
|
#include "absl/strings/match.h" |
|
#include "absl/strings/str_cat.h" |
|
#include "gmock/gmock.h" |
|
#include "gtest/gtest.h" |
|
|
|
#include "src/core/util/json/json_reader.h" |
|
#include "src/core/util/json/json_writer.h" |
|
#include "test/core/test_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::kNull: |
|
break; |
|
case Json::Type::kBoolean: |
|
EXPECT_EQ(actual.boolean(), expected.boolean()); |
|
break; |
|
case Json::Type::kString: |
|
case Json::Type::kNumber: |
|
EXPECT_EQ(actual.string(), expected.string()); |
|
break; |
|
case Json::Type::kObject: |
|
ValidateObject(actual.object(), expected.object()); |
|
break; |
|
case Json::Type::kArray: |
|
ValidateArray(actual.array(), expected.array()); |
|
break; |
|
} |
|
} |
|
|
|
void RunSuccessTest(const char* input, const Json& expected, |
|
const char* expected_output) { |
|
LOG(INFO) << "parsing string \"" << input << "\" - should succeed"; |
|
auto json = JsonParse(input); |
|
ASSERT_TRUE(json.ok()) << json.status(); |
|
ValidateValue(*json, expected); |
|
std::string output = JsonDump(*json); |
|
EXPECT_EQ(output, expected_output); |
|
} |
|
|
|
TEST(Json, Whitespace) { |
|
RunSuccessTest(" 0 ", Json::FromNumber(0), "0"); |
|
RunSuccessTest(" 1 ", Json::FromNumber(1), "1"); |
|
RunSuccessTest(" \" \" ", Json::FromString(" "), "\" \""); |
|
RunSuccessTest(" \"a\" ", Json::FromString("a"), "\"a\""); |
|
RunSuccessTest(" true ", Json::FromBool(true), "true"); |
|
} |
|
|
|
TEST(Json, Utf16) { |
|
RunSuccessTest("\"\\u0020\\\\\\u0010\\u000a\\u000D\"", |
|
Json::FromString(" \\\u0010\n\r"), "\" \\\\\\u0010\\n\\r\""); |
|
} |
|
|
|
MATCHER(ContainsInvalidUtf8, |
|
absl::StrCat(negation ? "Contains" : "Does not contain", |
|
" invalid UTF-8 characters.")) { |
|
auto json = JsonParse(arg); |
|
return json.status().code() == absl::StatusCode::kInvalidArgument && |
|
absl::StrContains(json.status().message(), "JSON parsing failed"); |
|
} |
|
|
|
TEST(Json, Utf8) { |
|
RunSuccessTest("\"ßâñć௵⇒\"", Json::FromString("ßâñć௵⇒"), |
|
"\"\\u00df\\u00e2\\u00f1\\u0107\\u0bf5\\u21d2\""); |
|
RunSuccessTest("\"\\u00df\\u00e2\\u00f1\\u0107\\u0bf5\\u21d2\"", |
|
Json::FromString("ßâñć௵⇒"), |
|
"\"\\u00df\\u00e2\\u00f1\\u0107\\u0bf5\\u21d2\""); |
|
// Testing UTF-8 character "𝄞", U+11D1E. |
|
RunSuccessTest("\"\xf0\x9d\x84\x9e\"", Json::FromString("\xf0\x9d\x84\x9e"), |
|
"\"\\ud834\\udd1e\""); |
|
RunSuccessTest("\"\\ud834\\udd1e\"", Json::FromString("\xf0\x9d\x84\x9e"), |
|
"\"\\ud834\\udd1e\""); |
|
RunSuccessTest("{\"\\ud834\\udd1e\":0}", |
|
Json::FromObject({{"\xf0\x9d\x84\x9e", Json::FromNumber(0)}}), |
|
"{\"\\ud834\\udd1e\":0}"); |
|
|
|
/// For UTF-8 characters with length of 1 byte, the range of it is [0x00, |
|
/// 0x7f]. |
|
EXPECT_THAT("\"\xa0\"", ContainsInvalidUtf8()); |
|
|
|
/// For UTF-8 characters with length of 2 bytes, the range of the first byte |
|
/// is [0xc2, 0xdf], and the range of the second byte is [0x80, 0xbf]. |
|
EXPECT_THAT("\"\xc0\xbc\"", ContainsInvalidUtf8()); |
|
EXPECT_THAT("\"\xbc\xc0\"", ContainsInvalidUtf8()); |
|
|
|
/// Corner cases for UTF-8 characters with length of 3 bytes. |
|
/// If the first byte is 0xe0, the range of second byte is [0xa0, 0xbf]. |
|
EXPECT_THAT("\"\xe0\x80\x80\"", ContainsInvalidUtf8()); |
|
/// If the first byte is 0xed, the range of second byte is [0x80, 0x9f]. |
|
EXPECT_THAT("\"\xed\xa0\x80\"", ContainsInvalidUtf8()); |
|
|
|
/// Corner cases for UTF-8 characters with length of 4 bytes. |
|
/// If the first byte is 0xf0, the range of second byte is [0x90, 0xbf]. |
|
EXPECT_THAT("\"\xf0\x80\x80\x80\"", ContainsInvalidUtf8()); |
|
/// If the first byte is 0xf4, the range of second byte is [0x80, 0x8f]. |
|
EXPECT_THAT("\"\xf4\x90\x80\x80\"", ContainsInvalidUtf8()); |
|
/// The range of the first bytes is [0xf0, 0xf4]. |
|
EXPECT_THAT("\"\xf5\x80\x80\x80\"", ContainsInvalidUtf8()); |
|
} |
|
|
|
TEST(Json, NestedEmptyContainers) { |
|
RunSuccessTest(" [ [ ] , { } , [ ] ] ", |
|
Json::FromArray({ |
|
Json::FromArray({}), |
|
Json::FromObject({}), |
|
Json::FromArray({}), |
|
}), |
|
"[[],{},[]]"); |
|
} |
|
|
|
TEST(Json, EscapesAndControlCharactersInKeyStrings) { |
|
RunSuccessTest(" { \"\\u007f\x7f\\n\\r\\\"\\f\\b\\\\a , b\": 1, \"\": 0 } ", |
|
Json::FromObject({ |
|
{"\u007f\u007f\n\r\"\f\b\\a , b", Json::FromNumber(1)}, |
|
{"", Json::FromNumber(0)}, |
|
}), |
|
"{\"\":0,\"\\u007f\\u007f\\n\\r\\\"\\f\\b\\\\a , b\":1}"); |
|
} |
|
|
|
TEST(Json, WriterCutsOffInvalidUtf8) { |
|
EXPECT_EQ(JsonDump(Json::FromString("abc\xf0\x9d\x24")), "\"abc\""); |
|
EXPECT_EQ(JsonDump(Json::FromString("\xff")), "\"\""); |
|
} |
|
|
|
TEST(Json, ValidNumbers) { |
|
RunSuccessTest("[0, 42 , 0.0123, 123.456]", |
|
Json::FromArray({ |
|
Json::FromNumber(0), |
|
Json::FromNumber(42), |
|
Json::FromNumber("0.0123"), |
|
Json::FromNumber("123.456"), |
|
}), |
|
"[0,42,0.0123,123.456]"); |
|
RunSuccessTest("[1e4,-53.235e-31, 0.3e+3]", |
|
Json::FromArray({ |
|
Json::FromNumber("1e4"), |
|
Json::FromNumber("-53.235e-31"), |
|
Json::FromNumber("0.3e+3"), |
|
}), |
|
"[1e4,-53.235e-31,0.3e+3]"); |
|
} |
|
|
|
TEST(Json, Keywords) { |
|
RunSuccessTest("[true, false, null]", |
|
Json::FromArray({ |
|
Json::FromBool(true), |
|
Json::FromBool(false), |
|
Json(), |
|
}), |
|
"[true,false,null]"); |
|
} |
|
|
|
void RunParseFailureTest(const char* input) { |
|
LOG(INFO) << "parsing string \"" << input << "\" - should fail"; |
|
auto json = JsonParse(input); |
|
EXPECT_FALSE(json.ok()) << "input: \"" << input << "\""; |
|
} |
|
|
|
TEST(Json, InvalidInput) { |
|
RunParseFailureTest("\\"); |
|
RunParseFailureTest("nu ll"); |
|
RunParseFailureTest("{\"foo\": bar}"); |
|
RunParseFailureTest("{\"foo\": bar\"x\"}"); |
|
RunParseFailureTest("fals"); |
|
RunParseFailureTest("0,0 "); |
|
RunParseFailureTest("\"foo\",[]"); |
|
RunParseFailureTest("{\"field\": {},}"); |
|
RunParseFailureTest("[{},]"); |
|
RunParseFailureTest("{\"field\": [],}"); |
|
RunParseFailureTest("[[],]"); |
|
} |
|
|
|
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::FromNumber(1), Json::FromNumber(1)); |
|
EXPECT_NE(Json::FromNumber(1), Json::FromNumber(2)); |
|
EXPECT_EQ(Json::FromNumber(1), Json::FromNumber("1")); |
|
EXPECT_EQ(Json::FromNumber("-5e5"), Json::FromNumber("-5e5")); |
|
// Booleans. |
|
EXPECT_EQ(Json::FromBool(true), Json::FromBool(true)); |
|
EXPECT_EQ(Json::FromBool(false), Json::FromBool(false)); |
|
EXPECT_NE(Json::FromBool(true), Json::FromBool(false)); |
|
// Strings. |
|
EXPECT_EQ(Json::FromString("foo"), Json::FromString("foo")); |
|
EXPECT_NE(Json::FromString("foo"), Json::FromString("bar")); |
|
// Arrays. |
|
EXPECT_EQ(Json::FromArray({Json::FromString("foo")}), |
|
Json::FromArray({Json::FromString("foo")})); |
|
EXPECT_NE(Json::FromArray({Json::FromString("foo")}), |
|
Json::FromArray({Json::FromString("bar")})); |
|
// Objects. |
|
EXPECT_EQ(Json::FromObject({{"foo", Json::FromNumber(1)}}), |
|
Json::FromObject({{"foo", Json::FromNumber(1)}})); |
|
EXPECT_NE(Json::FromObject({{"foo", Json::FromNumber(1)}}), |
|
Json::FromObject({{"foo", Json::FromNumber(2)}})); |
|
EXPECT_NE(Json::FromObject({{"foo", Json::FromNumber(1)}}), |
|
Json::FromObject({{"bar", Json::FromNumber(1)}})); |
|
// Differing types. |
|
EXPECT_NE(Json::FromNumber(1), Json::FromString("foo")); |
|
EXPECT_NE(Json::FromNumber(1), Json::FromBool(true)); |
|
EXPECT_NE(Json::FromNumber(1), Json::FromArray({})); |
|
EXPECT_NE(Json::FromNumber(1), Json::FromObject({})); |
|
EXPECT_NE(Json::FromNumber(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(); |
|
}
|
|
|