summaryrefslogtreecommitdiffstats
path: root/clang-tools-extra/unittests/clangd/JSONExprTests.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'clang-tools-extra/unittests/clangd/JSONExprTests.cpp')
-rw-r--r--clang-tools-extra/unittests/clangd/JSONExprTests.cpp293
1 files changed, 0 insertions, 293 deletions
diff --git a/clang-tools-extra/unittests/clangd/JSONExprTests.cpp b/clang-tools-extra/unittests/clangd/JSONExprTests.cpp
deleted file mode 100644
index 3a41ac2eeea..00000000000
--- a/clang-tools-extra/unittests/clangd/JSONExprTests.cpp
+++ /dev/null
@@ -1,293 +0,0 @@
-//===-- JSONExprTests.cpp - JSON expression unit tests ----------*- C++ -*-===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "JSONExpr.h"
-
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-
-namespace clang {
-namespace clangd {
-namespace json {
-
-namespace {
-
-std::string s(const Expr &E) { return llvm::formatv("{0}", E).str(); }
-std::string sp(const Expr &E) { return llvm::formatv("{0:2}", E).str(); }
-
-TEST(JSONExprTests, Types) {
- EXPECT_EQ("true", s(true));
- EXPECT_EQ("null", s(nullptr));
- EXPECT_EQ("2.5", s(2.5));
- EXPECT_EQ(R"("foo")", s("foo"));
- EXPECT_EQ("[1,2,3]", s({1, 2, 3}));
- EXPECT_EQ(R"({"x":10,"y":20})", s(obj{{"x", 10}, {"y", 20}}));
-}
-
-TEST(JSONExprTests, Constructors) {
- // Lots of edge cases around empty and singleton init lists.
- EXPECT_EQ("[[[3]]]", s({{{3}}}));
- EXPECT_EQ("[[[]]]", s({{{}}}));
- EXPECT_EQ("[[{}]]", s({{obj{}}}));
- EXPECT_EQ(R"({"A":{"B":{}}})", s(obj{{"A", obj{{"B", obj{}}}}}));
- EXPECT_EQ(R"({"A":{"B":{"X":"Y"}}})",
- s(obj{{"A", obj{{"B", obj{{"X", "Y"}}}}}}));
- EXPECT_EQ("null", s(llvm::Optional<double>()));
- EXPECT_EQ("2.5", s(llvm::Optional<double>(2.5)));
-}
-
-TEST(JSONExprTests, StringOwnership) {
- char X[] = "Hello";
- Expr Alias = static_cast<const char *>(X);
- X[1] = 'a';
- EXPECT_EQ(R"("Hallo")", s(Alias));
-
- std::string Y = "Hello";
- Expr Copy = Y;
- Y[1] = 'a';
- EXPECT_EQ(R"("Hello")", s(Copy));
-}
-
-TEST(JSONExprTests, CanonicalOutput) {
- // Objects are sorted (but arrays aren't)!
- EXPECT_EQ(R"({"a":1,"b":2,"c":3})", s(obj{{"a", 1}, {"c", 3}, {"b", 2}}));
- EXPECT_EQ(R"(["a","c","b"])", s({"a", "c", "b"}));
- EXPECT_EQ("3", s(3.0));
-}
-
-TEST(JSONExprTests, Escaping) {
- std::string test = {
- 0, // Strings may contain nulls.
- '\b', '\f', // Have mnemonics, but we escape numerically.
- '\r', '\n', '\t', // Escaped with mnemonics.
- 'S', '\"', '\\', // Printable ASCII characters.
- '\x7f', // Delete is not escaped.
- '\xce', '\x94', // Non-ASCII UTF-8 is not escaped.
- };
-
- std::string teststring = R"("\u0000\u0008\u000c\r\n\tS\"\\)"
- "\x7f\xCE\x94\"";
-
- EXPECT_EQ(teststring, s(test));
-
- EXPECT_EQ(R"({"object keys are\nescaped":true})",
- s(obj{{"object keys are\nescaped", true}}));
-}
-
-TEST(JSONExprTests, PrettyPrinting) {
- const char str[] = R"({
- "empty_array": [],
- "empty_object": {},
- "full_array": [
- 1,
- null
- ],
- "full_object": {
- "nested_array": [
- {
- "property": "value"
- }
- ]
- }
-})";
-
- EXPECT_EQ(str, sp(obj{
- {"empty_object", obj{}},
- {"empty_array", {}},
- {"full_array", {1, nullptr}},
- {"full_object",
- obj{
- {"nested_array",
- {obj{
- {"property", "value"},
- }}},
- }},
- }));
-}
-
-TEST(JSONTest, Parse) {
- auto Compare = [](llvm::StringRef S, Expr Expected) {
- if (auto E = parse(S)) {
- // Compare both string forms and with operator==, in case we have bugs.
- EXPECT_EQ(*E, Expected);
- EXPECT_EQ(sp(*E), sp(Expected));
- } else {
- handleAllErrors(E.takeError(), [S](const llvm::ErrorInfoBase &E) {
- FAIL() << "Failed to parse JSON >>> " << S << " <<<: " << E.message();
- });
- }
- };
-
- Compare(R"(true)", true);
- Compare(R"(false)", false);
- Compare(R"(null)", nullptr);
-
- Compare(R"(42)", 42);
- Compare(R"(2.5)", 2.5);
- Compare(R"(2e50)", 2e50);
- Compare(R"(1.2e3456789)", std::numeric_limits<double>::infinity());
-
- Compare(R"("foo")", "foo");
- Compare(R"("\"\\\b\f\n\r\t")", "\"\\\b\f\n\r\t");
- Compare(R"("\u0000")", llvm::StringRef("\0", 1));
- Compare("\"\x7f\"", "\x7f");
- Compare(R"("\ud801\udc37")", u8"\U00010437"); // UTF16 surrogate pair escape.
- Compare("\"\xE2\x82\xAC\xF0\x9D\x84\x9E\"", u8"\u20ac\U0001d11e"); // UTF8
- Compare(
- R"("LoneLeading=\ud801, LoneTrailing=\udc01, LeadingLeadingTrailing=\ud801\ud801\udc37")",
- u8"LoneLeading=\ufffd, LoneTrailing=\ufffd, "
- u8"LeadingLeadingTrailing=\ufffd\U00010437"); // Invalid unicode.
-
- Compare(R"({"":0,"":0})", obj{{"", 0}});
- Compare(R"({"obj":{},"arr":[]})", obj{{"obj", obj{}}, {"arr", {}}});
- Compare(R"({"\n":{"\u0000":[[[[]]]]}})",
- obj{{"\n", obj{
- {llvm::StringRef("\0", 1), {{{{}}}}},
- }}});
- Compare("\r[\n\t] ", {});
-}
-
-TEST(JSONTest, ParseErrors) {
- auto ExpectErr = [](llvm::StringRef Msg, llvm::StringRef S) {
- if (auto E = parse(S)) {
- // Compare both string forms and with operator==, in case we have bugs.
- FAIL() << "Parsed JSON >>> " << S << " <<< but wanted error: " << Msg;
- } else {
- handleAllErrors(E.takeError(), [S, Msg](const llvm::ErrorInfoBase &E) {
- EXPECT_THAT(E.message(), testing::HasSubstr(Msg)) << S;
- });
- }
- };
- ExpectErr("Unexpected EOF", "");
- ExpectErr("Unexpected EOF", "[");
- ExpectErr("Text after end of document", "[][]");
- ExpectErr("Invalid bareword", "fuzzy");
- ExpectErr("Expected , or ]", "[2?]");
- ExpectErr("Expected object key", "{a:2}");
- ExpectErr("Expected : after object key", R"({"a",2})");
- ExpectErr("Expected , or } after object property", R"({"a":2 "b":3})");
- ExpectErr("Expected JSON value", R"([&%!])");
- ExpectErr("Invalid number", "1e1.0");
- ExpectErr("Unterminated string", R"("abc\"def)");
- ExpectErr("Control character in string", "\"abc\ndef\"");
- ExpectErr("Invalid escape sequence", R"("\030")");
- ExpectErr("Invalid \\u escape sequence", R"("\usuck")");
- ExpectErr("[3:3, byte=19]", R"({
- "valid": 1,
- invalid: 2
-})");
-}
-
-TEST(JSONTest, Inspection) {
- llvm::Expected<Expr> Doc = parse(R"(
- {
- "null": null,
- "boolean": false,
- "number": 2.78,
- "string": "json",
- "array": [null, true, 3.14, "hello", [1,2,3], {"time": "arrow"}],
- "object": {"fruit": "banana"}
- }
- )");
- EXPECT_TRUE(!!Doc);
-
- obj *O = Doc->asObject();
- ASSERT_TRUE(O);
-
- EXPECT_FALSE(O->getNull("missing"));
- EXPECT_FALSE(O->getNull("boolean"));
- EXPECT_TRUE(O->getNull("null"));
-
- EXPECT_EQ(O->getNumber("number"), llvm::Optional<double>(2.78));
- EXPECT_FALSE(O->getInteger("number"));
- EXPECT_EQ(O->getString("string"), llvm::Optional<llvm::StringRef>("json"));
- ASSERT_FALSE(O->getObject("missing"));
- ASSERT_FALSE(O->getObject("array"));
- ASSERT_TRUE(O->getObject("object"));
- EXPECT_EQ(*O->getObject("object"), (obj{{"fruit", "banana"}}));
-
- ary *A = O->getArray("array");
- ASSERT_TRUE(A);
- EXPECT_EQ(A->getBoolean(1), llvm::Optional<bool>(true));
- ASSERT_TRUE(A->getArray(4));
- EXPECT_EQ(*A->getArray(4), (ary{1, 2, 3}));
- EXPECT_EQ(A->getArray(4)->getInteger(1), llvm::Optional<int64_t>(2));
- int I = 0;
- for (Expr &E : *A) {
- if (I++ == 5) {
- ASSERT_TRUE(E.asObject());
- EXPECT_EQ(E.asObject()->getString("time"),
- llvm::Optional<llvm::StringRef>("arrow"));
- } else
- EXPECT_FALSE(E.asObject());
- }
-}
-
-// Sample struct with typical JSON-mapping rules.
-struct CustomStruct {
- CustomStruct() : B(false) {}
- CustomStruct(std::string S, llvm::Optional<int> I, bool B)
- : S(S), I(I), B(B) {}
- std::string S;
- llvm::Optional<int> I;
- bool B;
-};
-inline bool operator==(const CustomStruct &L, const CustomStruct &R) {
- return L.S == R.S && L.I == R.I && L.B == R.B;
-}
-inline std::ostream &operator<<(std::ostream &OS, const CustomStruct &S) {
- return OS << "(" << S.S << ", " << (S.I ? std::to_string(*S.I) : "None")
- << ", " << S.B << ")";
-}
-bool fromJSON(const json::Expr &E, CustomStruct &R) {
- ObjectMapper O(E);
- if (!O || !O.map("str", R.S) || !O.map("int", R.I))
- return false;
- O.map("bool", R.B);
- return true;
-}
-
-TEST(JSONTest, Deserialize) {
- std::map<std::string, std::vector<CustomStruct>> R;
- CustomStruct ExpectedStruct = {"foo", 42, true};
- std::map<std::string, std::vector<CustomStruct>> Expected;
- Expr J = obj{{"foo", ary{
- obj{
- {"str", "foo"},
- {"int", 42},
- {"bool", true},
- {"unknown", "ignored"},
- },
- obj{{"str", "bar"}},
- obj{
- {"str", "baz"},
- {"bool", "string"}, // OK, deserialize ignores.
- },
- }}};
- Expected["foo"] = {
- CustomStruct("foo", 42, true),
- CustomStruct("bar", llvm::None, false),
- CustomStruct("baz", llvm::None, false),
- };
- ASSERT_TRUE(fromJSON(J, R));
- EXPECT_EQ(R, Expected);
-
- CustomStruct V;
- EXPECT_FALSE(fromJSON(nullptr, V)) << "Not an object " << V;
- EXPECT_FALSE(fromJSON(obj{}, V)) << "Missing required field " << V;
- EXPECT_FALSE(fromJSON(obj{{"str", 1}}, V)) << "Wrong type " << V;
- // Optional<T> must parse as the correct type if present.
- EXPECT_FALSE(fromJSON(obj{{"str", 1}, {"int", "string"}}, V))
- << "Wrong type for Optional<T> " << V;
-}
-
-} // namespace
-} // namespace json
-} // namespace clangd
-} // namespace clang
OpenPOWER on IntegriCloud