Browse Source

Util+Test: Change namespace of JSON classes: Json -> Util::JSON

master
Riyyi 2 years ago
parent
commit
deb9f29b47
  1. 12
      src/config.cpp
  2. 6
      src/config.h
  3. 4
      src/util/json/array.cpp
  4. 10
      src/util/json/array.h
  5. 10
      src/util/json/fromjson.h
  6. 4
      src/util/json/job.cpp
  7. 10
      src/util/json/job.h
  8. 4
      src/util/json/lexer.cpp
  9. 10
      src/util/json/lexer.h
  10. 4
      src/util/json/object.cpp
  11. 10
      src/util/json/object.h
  12. 4
      src/util/json/parser.cpp
  13. 10
      src/util/json/parser.h
  14. 4
      src/util/json/serializer.cpp
  15. 10
      src/util/json/serializer.h
  16. 10
      src/util/json/tojson.h
  17. 4
      src/util/json/value.cpp
  18. 10
      src/util/json/value.h
  19. 148
      test/unit/testutiljson.cpp

12
src/config.cpp

@ -13,7 +13,7 @@
#include <vector> #include <vector>
#include "config.h" #include "config.h"
#include "util/json/value.h" #include "util/json/json.h"
Config::Config(s) Config::Config(s)
: m_workingDirectory(std::filesystem::current_path()) : m_workingDirectory(std::filesystem::current_path())
@ -51,7 +51,7 @@ void Config::parseConfigFile()
return; return;
} }
Json::Value json; Util::Json json;
std::ifstream file(m_config); std::ifstream file(m_config);
if (!file.is_open()) { if (!file.is_open()) {
@ -72,17 +72,17 @@ void Config::parseConfigFile()
// ----------------------------------------- // -----------------------------------------
void toJson(Json::Value& json, const Settings& settings) void toJson(Util::Json& json, const Settings& settings)
{ {
json = Json::Value { json = Util::Json {
{ "ignorePatterns", settings.ignorePatterns }, { "ignorePatterns", settings.ignorePatterns },
{ "systemPatterns", settings.systemPatterns } { "systemPatterns", settings.systemPatterns }
}; };
} }
void fromJson(const Json::Value& json, Settings& settings) void fromJson(const Util::Json& json, Settings& settings)
{ {
assert(json.type() == Json::Value::Type::Object); assert(json.type() == Util::Json::Type::Object);
if (json.exists("ignorePatterns")) { if (json.exists("ignorePatterns")) {
json.at("ignorePatterns").getTo(settings.ignorePatterns); json.at("ignorePatterns").getTo(settings.ignorePatterns);

6
src/config.h

@ -13,7 +13,7 @@
#include <vector> #include <vector>
#include "util/singleton.h" #include "util/singleton.h"
#include "util/json/value.h" #include "util/json/json.h"
struct Settings { struct Settings {
std::vector<std::string> ignorePatterns { std::vector<std::string> ignorePatterns {
@ -65,7 +65,7 @@ private:
// Json arbitrary type conversion functions // Json arbitrary type conversion functions
void toJson(Json::Value& object, const Settings& settings); void toJson(Util::Json& object, const Settings& settings);
void fromJson(const Json::Value& object, Settings& settings); void fromJson(const Util::Json& object, Settings& settings);
#endif // CONFIG_H #endif // CONFIG_H

4
src/util/json/array.cpp

@ -7,7 +7,7 @@
#include "util/json/array.h" #include "util/json/array.h"
#include "util/json/value.h" #include "util/json/value.h"
namespace Json { namespace Util::JSON {
void Array::emplace_back(Value element) void Array::emplace_back(Value element)
{ {
@ -23,4 +23,4 @@ Value& Array::operator[](size_t index)
return m_elements[index]; return m_elements[index];
} }
} // namespace Json } // namespace Util::JSON

10
src/util/json/array.h

@ -4,15 +4,15 @@
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
*/ */
#ifndef JSON_ARRAY_H #ifndef UTIL_JSON_ARRAY_H
#define JSON_ARRAY_H #define UTIL_JSON_ARRAY_H
#include <utility> // move #include <utility> // move
#include <vector> #include <vector>
#include "util/json/parser.h" #include "util/json/parser.h"
namespace Json { namespace Util::JSON {
class Value; class Value;
@ -54,6 +54,6 @@ private:
std::vector<Value> m_elements; std::vector<Value> m_elements;
}; };
} // namespace Json } // namespace Util::JSON
#endif // JSON_ARRAY_H #endif // UTIL_JSON_ARRAY_H

10
src/util/json/fromjson.h

@ -4,8 +4,8 @@
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
*/ */
#ifndef JSON_FROM_JSON_H #ifndef UTIL_JSON_FROM_JSON_H
#define JSON_FROM_JSON_H #define UTIL_JSON_FROM_JSON_H
#include <algorithm> // transform #include <algorithm> // transform
#include <cassert> // assert #include <cassert> // assert
@ -20,7 +20,7 @@
#include "util/json/object.h" #include "util/json/object.h"
#include "util/meta/odr.h" #include "util/meta/odr.h"
namespace Json { namespace Util::JSON {
namespace Detail { namespace Detail {
@ -116,9 +116,9 @@ namespace {
constexpr const auto& fromJson = Util::Detail::staticConst<Detail::fromJsonFunction>; // NOLINT(misc-definitions-in-headers,clang-diagnostic-unused-variable) constexpr const auto& fromJson = Util::Detail::staticConst<Detail::fromJsonFunction>; // NOLINT(misc-definitions-in-headers,clang-diagnostic-unused-variable)
} // namespace } // namespace
} // namespace Json } // namespace Util::JSON
#endif // JSON_FROM_JSON_H #endif // UTIL_JSON_FROM_JSON_H
// Customization Points // Customization Points
// https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html // https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html

4
src/util/json/job.cpp

@ -13,7 +13,7 @@
#include "util/json/parser.h" #include "util/json/parser.h"
#include "util/json/value.h" #include "util/json/value.h"
namespace Json { namespace Util::JSON {
Job::Job(std::string_view input) Job::Job(std::string_view input)
: m_input(input) : m_input(input)
@ -111,4 +111,4 @@ void Job::printErrorLine(Token token, const char* message)
std::string(line.length() - token.column, '~').c_str()); std::string(line.length() - token.column, '~').c_str());
} }
} // namespace Json } // namespace Util::JSON

10
src/util/json/job.h

@ -4,8 +4,8 @@
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
*/ */
#ifndef JSON_JOB_H #ifndef UTIL_JSON_JOB_H
#define JSON_JOB_H #define UTIL_JSON_JOB_H
#include <cstddef> // size_t #include <cstddef> // size_t
#include <string_view> #include <string_view>
@ -13,7 +13,7 @@
#include "util/json/lexer.h" #include "util/json/lexer.h"
namespace Json { namespace Util::JSON {
class Value; class Value;
@ -48,6 +48,6 @@ private:
std::vector<Token> m_tokens; std::vector<Token> m_tokens;
}; };
} // namespace Json } // namespace Util::JSON
#endif // JSON_JOB_H #endif // UTIL_JSON_JOB_H

4
src/util/json/lexer.cpp

@ -10,7 +10,7 @@
#include "util/json/job.h" #include "util/json/job.h"
#include "util/json/lexer.h" #include "util/json/lexer.h"
namespace Json { namespace Util::JSON {
Lexer::Lexer(Job* job) Lexer::Lexer(Job* job)
: GenericLexer(job->input()) : GenericLexer(job->input())
@ -214,4 +214,4 @@ bool Lexer::consumeLiteral()
return consumeNumberOrLiteral(Token::Type::Literal); return consumeNumberOrLiteral(Token::Type::Literal);
} }
} // namespace Json } // namespace Util::JSON

10
src/util/json/lexer.h

@ -4,8 +4,8 @@
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
*/ */
#ifndef JSON_LEXER_H #ifndef UTIL_JSON_LEXER_H
#define JSON_LEXER_H #define UTIL_JSON_LEXER_H
// The JavaScript Object Notation (JSON) Data Interchange Format // The JavaScript Object Notation (JSON) Data Interchange Format
// https://www.rfc-editor.org/rfc/pdfrfc/rfc8259.txt.pdf // https://www.rfc-editor.org/rfc/pdfrfc/rfc8259.txt.pdf
@ -16,7 +16,7 @@
#include "util/genericlexer.h" #include "util/genericlexer.h"
namespace Json { namespace Util::JSON {
class Job; class Job;
@ -62,6 +62,6 @@ private:
std::vector<Token>* m_tokens { nullptr }; std::vector<Token>* m_tokens { nullptr };
}; };
} // namespace Json } // namespace Util::JSON
#endif // JSON_LEXER_H #endif // UTIL_JSON_LEXER_H

4
src/util/json/object.cpp

@ -7,7 +7,7 @@
#include "util/json/object.h" #include "util/json/object.h"
#include "util/json/value.h" #include "util/json/value.h"
namespace Json { namespace Util::JSON {
void Object::emplace(const std::string& name, Value value) void Object::emplace(const std::string& name, Value value)
{ {
@ -23,4 +23,4 @@ Value& Object::operator[](const std::string& name)
return m_members.at(name); return m_members.at(name);
} }
} // namespace Json } // namespace Util::JSON

10
src/util/json/object.h

@ -4,8 +4,8 @@
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
*/ */
#ifndef JSON_OBJECT_H #ifndef UTIL_JSON_OBJECT_H
#define JSON_OBJECT_H #define UTIL_JSON_OBJECT_H
#include <map> #include <map>
#include <string> #include <string>
@ -13,7 +13,7 @@
#include "util/json/parser.h" #include "util/json/parser.h"
namespace Json { namespace Util::JSON {
class Value; class Value;
@ -50,6 +50,6 @@ private:
std::map<std::string, Value> m_members; std::map<std::string, Value> m_members;
}; };
} // namespace Json } // namespace Util::JSON
#endif // JSON_OBJECT_H #endif // UTIL_JSON_OBJECT_H

4
src/util/json/parser.cpp

@ -18,7 +18,7 @@
#include "util/json/parser.h" #include "util/json/parser.h"
#include "util/json/value.h" #include "util/json/value.h"
namespace Json { namespace Util::JSON {
Parser::Parser(Job* job) Parser::Parser(Job* job)
: m_job(job) : m_job(job)
@ -493,4 +493,4 @@ Value Parser::consumeObject()
return object; return object;
} }
} // namespace Json } // namespace Util::JSON

10
src/util/json/parser.h

@ -4,15 +4,15 @@
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
*/ */
#ifndef JSON_PARSER_H #ifndef UTIL_JSON_PARSER_H
#define JSON_PARSER_H #define UTIL_JSON_PARSER_H
#include <cstddef> // size_t #include <cstddef> // size_t
#include <vector> #include <vector>
#include "util/json/lexer.h" #include "util/json/lexer.h"
namespace Json { namespace Util::JSON {
class Job; class Job;
class Value; class Value;
@ -43,6 +43,6 @@ private:
std::vector<Token>* m_tokens { nullptr }; std::vector<Token>* m_tokens { nullptr };
}; };
} // namespace Json } // namespace Util::JSON
#endif // JSON_PARSER_H #endif // UTIL_JSON_PARSER_H

4
src/util/json/serializer.cpp

@ -14,7 +14,7 @@
#include "util/json/object.h" #include "util/json/object.h"
#include "util/json/serializer.h" #include "util/json/serializer.h"
namespace Json { namespace Util::JSON {
Serializer::Serializer(const uint32_t indent, const char indentCharacter) Serializer::Serializer(const uint32_t indent, const char indentCharacter)
: m_indent(indent) : m_indent(indent)
@ -151,4 +151,4 @@ void Serializer::dumpObject(const Value& value, const uint32_t indentLevel)
m_output += '}'; m_output += '}';
} }
} // namespace Json } // namespace Util::JSON

10
src/util/json/serializer.h

@ -4,15 +4,15 @@
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
*/ */
#ifndef JSON_SERIALIZER_H #ifndef UTIL_JSON_SERIALIZER_H
#define JSON_SERIALIZER_H #define UTIL_JSON_SERIALIZER_H
#include <cstdint> // uint32_t #include <cstdint> // uint32_t
#include <string> #include <string>
#include "util/json/value.h" #include "util/json/value.h"
namespace Json { namespace Util::JSON {
class Serializer { class Serializer {
public: public:
@ -32,6 +32,6 @@ private:
char m_indentCharacter { ' ' }; char m_indentCharacter { ' ' };
}; };
} // namespace Json } // namespace Util::JSON
#endif // JSON_SERIALIZER_H #endif // UTIL_JSON_SERIALIZER_H

10
src/util/json/tojson.h

@ -4,8 +4,8 @@
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
*/ */
#ifndef JSON_TO_JSON_H #ifndef UTIL_JSON_TO_JSON_H
#define JSON_TO_JSON_H #define UTIL_JSON_TO_JSON_H
#include <cassert> // assert #include <cassert> // assert
#include <cstddef> // nullptr_t #include <cstddef> // nullptr_t
@ -18,7 +18,7 @@
#include "util/json/object.h" #include "util/json/object.h"
#include "util/meta/odr.h" #include "util/meta/odr.h"
namespace Json { namespace Util::JSON {
namespace Detail { namespace Detail {
@ -136,9 +136,9 @@ namespace {
constexpr const auto& toJson = Util::Detail::staticConst<Detail::toJsonFunction>; // NOLINT(misc-definitions-in-headers,clang-diagnostic-unused-variable) constexpr const auto& toJson = Util::Detail::staticConst<Detail::toJsonFunction>; // NOLINT(misc-definitions-in-headers,clang-diagnostic-unused-variable)
} // namespace } // namespace
} // namespace Json } // namespace Util::JSON
#endif // JSON_TO_JSON_H #endif // UTIL_JSON_TO_JSON_H
// Customization Points // Customization Points
// https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html // https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html

4
src/util/json/value.cpp

@ -19,7 +19,7 @@
#include "util/json/serializer.h" #include "util/json/serializer.h"
#include "util/json/value.h" #include "util/json/value.h"
namespace Json { namespace Util::JSON {
Value::Value(std::nullptr_t) Value::Value(std::nullptr_t)
: Value(Type::Null) : Value(Type::Null)
@ -337,4 +337,4 @@ void format(FormatBuilder& builder, const Value& value)
builder.putString(value.dump(4)); builder.putString(value.dump(4));
} }
} // namespace Json } // namespace Util::JSON

10
src/util/json/value.h

@ -4,8 +4,8 @@
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
*/ */
#ifndef JSON_VALUE_H #ifndef UTIL_JSON_VALUE_H
#define JSON_VALUE_H #define UTIL_JSON_VALUE_H
#include <cstddef> // nullptr_t, size_t #include <cstddef> // nullptr_t, size_t
#include <cstdint> // uint32_t #include <cstdint> // uint32_t
@ -18,7 +18,7 @@
#include "util/json/fromjson.h" #include "util/json/fromjson.h"
#include "util/json/tojson.h" #include "util/json/tojson.h"
namespace Json { namespace Util::JSON {
class Array; class Array;
class Object; class Object;
@ -137,7 +137,7 @@ std::ostream& operator<<(std::ostream& output, const Value& value);
void format(FormatBuilder& builder, const Value& value); void format(FormatBuilder& builder, const Value& value);
} // namespace Json } // namespace Util::JSON
/** /**
* User-defined string literal * User-defined string literal
@ -149,4 +149,4 @@ inline Json::Value operator"" _json(const char* input, size_t length)
return Json::Value::parse(std::string(input, length)); return Json::Value::parse(std::string(input, length));
} }
#endif // JSON_VALUE_H #endif // UTIL_JSON_VALUE_H

148
test/unit/testutiljson.cpp

@ -17,10 +17,10 @@
#include "testsuite.h" #include "testsuite.h"
#include "util/json/array.h" #include "util/json/array.h"
#include "util/json/job.h" #include "util/json/job.h"
#include "util/json/json.h"
#include "util/json/lexer.h" #include "util/json/lexer.h"
#include "util/json/parser.h" #include "util/json/parser.h"
#include "util/json/serializer.h" #include "util/json/serializer.h"
#include "util/json/value.h"
#define DONT_PRINT_PARSER_ERRORS #define DONT_PRINT_PARSER_ERRORS
@ -33,20 +33,20 @@
stderr = Test::TestSuite::the().outputErr(); stderr = Test::TestSuite::the().outputErr();
#endif #endif
std::vector<Json::Token> lex(const std::string& input) std::vector<Util::JSON::Token> lex(const std::string& input)
{ {
EXEC( EXEC(
Json::Job job(input); Util::JSON::Job job(input);
Json::Lexer lexer(&job); Util::JSON::Lexer lexer(&job);
lexer.analyze();); lexer.analyze(););
return *job.tokens(); return *job.tokens();
} }
Json::Value parse(const std::string& input) Util::Json parse(const std::string& input)
{ {
EXEC( EXEC(
Json::Job job(input); Util::JSON::Job job(input);
Json::Lexer lexer(&job); Util::JSON::Lexer lexer(&job);
lexer.analyze();); lexer.analyze(););
if (!job.success()) { if (!job.success()) {
@ -54,8 +54,8 @@ Json::Value parse(const std::string& input)
} }
EXEC( EXEC(
Json::Parser parser(&job); Util::JSON::Parser parser(&job);
Json::Value json = parser.parse();); Util::Json json = parser.parse(););
if (!job.success()) { if (!job.success()) {
return nullptr; return nullptr;
@ -67,7 +67,7 @@ Json::Value parse(const std::string& input)
std::string serialize(const std::string& input, uint32_t indent = 0) std::string serialize(const std::string& input, uint32_t indent = 0)
{ {
EXEC( EXEC(
auto json = Json::Value::parse(input);); auto json = Util::Json::parse(input););
return json.dump(indent); return json.dump(indent);
} }
@ -75,59 +75,59 @@ std::string serialize(const std::string& input, uint32_t indent = 0)
TEST_CASE(JsonLexer) TEST_CASE(JsonLexer)
{ {
std::vector<Json::Token> tokens; std::vector<Util::JSON::Token> tokens;
// Literal // Literal
tokens = lex("true"); tokens = lex("true");
EXPECT_EQ(tokens.size(), 1); EXPECT_EQ(tokens.size(), 1);
EXPECT_EQ(tokens[0].symbol, "true"); EXPECT_EQ(tokens[0].symbol, "true");
EXPECT(tokens[0].type == Json::Token::Type::Literal); EXPECT(tokens[0].type == Util::JSON::Token::Type::Literal);
tokens = lex("false"); tokens = lex("false");
EXPECT_EQ(tokens.size(), 1); EXPECT_EQ(tokens.size(), 1);
EXPECT_EQ(tokens[0].symbol, "false"); EXPECT_EQ(tokens[0].symbol, "false");
EXPECT(tokens[0].type == Json::Token::Type::Literal); EXPECT(tokens[0].type == Util::JSON::Token::Type::Literal);
tokens = lex("null"); tokens = lex("null");
EXPECT_EQ(tokens.size(), 1); EXPECT_EQ(tokens.size(), 1);
EXPECT_EQ(tokens[0].symbol, "null"); EXPECT_EQ(tokens[0].symbol, "null");
EXPECT(tokens[0].type == Json::Token::Type::Literal); EXPECT(tokens[0].type == Util::JSON::Token::Type::Literal);
// Number // Number
tokens = lex("3.14"); tokens = lex("3.14");
EXPECT_EQ(tokens.size(), 1); EXPECT_EQ(tokens.size(), 1);
EXPECT_EQ(tokens[0].symbol, "3.14"); EXPECT_EQ(tokens[0].symbol, "3.14");
EXPECT(tokens[0].type == Json::Token::Type::Number); EXPECT(tokens[0].type == Util::JSON::Token::Type::Number);
tokens = lex("-3.14e+2"); tokens = lex("-3.14e+2");
EXPECT_EQ(tokens.size(), 1); EXPECT_EQ(tokens.size(), 1);
EXPECT_EQ(tokens[0].symbol, "-3.14e+2"); EXPECT_EQ(tokens[0].symbol, "-3.14e+2");
EXPECT(tokens[0].type == Json::Token::Type::Number); EXPECT(tokens[0].type == Util::JSON::Token::Type::Number);
tokens = lex("+3.14"); tokens = lex("+3.14");
EXPECT_EQ(tokens.size(), 1); EXPECT_EQ(tokens.size(), 1);
EXPECT_EQ(tokens[0].symbol, "+"); EXPECT_EQ(tokens[0].symbol, "+");
EXPECT(tokens[0].type == Json::Token::Type::None); EXPECT(tokens[0].type == Util::JSON::Token::Type::None);
// String // String
tokens = lex(R"("a string")"); tokens = lex(R"("a string")");
EXPECT_EQ(tokens.size(), 1); EXPECT_EQ(tokens.size(), 1);
EXPECT_EQ(tokens[0].symbol, "a string"); EXPECT_EQ(tokens[0].symbol, "a string");
EXPECT(tokens[0].type == Json::Token::Type::String); EXPECT(tokens[0].type == Util::JSON::Token::Type::String);
tokens = lex(R"("a string""another string")"); tokens = lex(R"("a string""another string")");
EXPECT_EQ(tokens.size(), 2); EXPECT_EQ(tokens.size(), 2);
EXPECT_EQ(tokens[0].symbol, "a string"); EXPECT_EQ(tokens[0].symbol, "a string");
EXPECT_EQ(tokens[1].symbol, "another string"); EXPECT_EQ(tokens[1].symbol, "another string");
EXPECT(tokens[0].type == Json::Token::Type::String); EXPECT(tokens[0].type == Util::JSON::Token::Type::String);
tokens = lex("\"a string\nwill break on the newline symbol\""); tokens = lex("\"a string\nwill break on the newline symbol\"");
EXPECT_EQ(tokens.size(), 1); EXPECT_EQ(tokens.size(), 1);
EXPECT_EQ(tokens[0].symbol, "a string"); EXPECT_EQ(tokens[0].symbol, "a string");
EXPECT(tokens[0].type == Json::Token::Type::String); EXPECT(tokens[0].type == Util::JSON::Token::Type::String);
// Array // Array
@ -156,186 +156,186 @@ TEST_CASE(JsonLexer)
TEST_CASE(JsonParser) TEST_CASE(JsonParser)
{ {
Json::Value json; Util::Json json;
json = parse("null"); json = parse("null");
EXPECT_EQ(json.size(), 0); EXPECT_EQ(json.size(), 0);
EXPECT_EQ(json.type(), Json::Value::Type::Null); EXPECT_EQ(json.type(), Util::Json::Type::Null);
json = parse("true"); json = parse("true");
EXPECT_EQ(json.size(), 1); EXPECT_EQ(json.size(), 1);
EXPECT_EQ(json.type(), Json::Value::Type::Bool); EXPECT_EQ(json.type(), Util::Json::Type::Bool);
json = parse("false"); json = parse("false");
EXPECT_EQ(json.size(), 1); EXPECT_EQ(json.size(), 1);
EXPECT_EQ(json.type(), Json::Value::Type::Bool); EXPECT_EQ(json.type(), Util::Json::Type::Bool);
json = parse("3.14"); json = parse("3.14");
EXPECT_EQ(json.size(), 1); EXPECT_EQ(json.size(), 1);
EXPECT_EQ(json.type(), Json::Value::Type::Number); EXPECT_EQ(json.type(), Util::Json::Type::Number);
json = parse(R"("a string")"); json = parse(R"("a string")");
EXPECT_EQ(json.size(), 1); EXPECT_EQ(json.size(), 1);
EXPECT_EQ(json.type(), Json::Value::Type::String); EXPECT_EQ(json.type(), Util::Json::Type::String);
// Array // Array
json = parse("["); json = parse("[");
EXPECT_EQ(json.size(), 0); EXPECT_EQ(json.size(), 0);
EXPECT_EQ(json.type(), Json::Value::Type::Null); EXPECT_EQ(json.type(), Util::Json::Type::Null);
json = parse("[ 123"); json = parse("[ 123");
EXPECT_EQ(json.size(), 0); EXPECT_EQ(json.size(), 0);
EXPECT_EQ(json.type(), Json::Value::Type::Null); EXPECT_EQ(json.type(), Util::Json::Type::Null);
json = parse("[ 123,"); json = parse("[ 123,");
EXPECT_EQ(json.size(), 0); EXPECT_EQ(json.size(), 0);
EXPECT_EQ(json.type(), Json::Value::Type::Null); EXPECT_EQ(json.type(), Util::Json::Type::Null);
json = parse("[ 123, ]"); json = parse("[ 123, ]");
EXPECT_EQ(json.size(), 0); EXPECT_EQ(json.size(), 0);
EXPECT_EQ(json.type(), Json::Value::Type::Null); EXPECT_EQ(json.type(), Util::Json::Type::Null);
json = parse("[ 123 456 ]"); json = parse("[ 123 456 ]");
EXPECT_EQ(json.size(), 0); EXPECT_EQ(json.size(), 0);
EXPECT_EQ(json.type(), Json::Value::Type::Null); EXPECT_EQ(json.type(), Util::Json::Type::Null);
json = parse("[]"); json = parse("[]");
EXPECT_EQ(json.size(), 0); EXPECT_EQ(json.size(), 0);
EXPECT_EQ(json.type(), Json::Value::Type::Array); EXPECT_EQ(json.type(), Util::Json::Type::Array);
json = parse(R"([ "element", 3.14 ])"); json = parse(R"([ "element", 3.14 ])");
EXPECT_EQ(json.size(), 2); EXPECT_EQ(json.size(), 2);
EXPECT_EQ(json.type(), Json::Value::Type::Array); EXPECT_EQ(json.type(), Util::Json::Type::Array);
// Object // Object
json = parse("{"); json = parse("{");
EXPECT_EQ(json.size(), 0); EXPECT_EQ(json.size(), 0);
EXPECT_EQ(json.type(), Json::Value::Type::Null); EXPECT_EQ(json.type(), Util::Json::Type::Null);
json = parse(R"({ "name")"); json = parse(R"({ "name")");
EXPECT_EQ(json.size(), 0); EXPECT_EQ(json.size(), 0);
EXPECT_EQ(json.type(), Json::Value::Type::Null); EXPECT_EQ(json.type(), Util::Json::Type::Null);
json = parse(R"({ "name":)"); json = parse(R"({ "name":)");
EXPECT_EQ(json.size(), 0); EXPECT_EQ(json.size(), 0);
EXPECT_EQ(json.type(), Json::Value::Type::Null); EXPECT_EQ(json.type(), Util::Json::Type::Null);
json = parse(R"({ "name":,)"); json = parse(R"({ "name":,)");
EXPECT_EQ(json.size(), 0); EXPECT_EQ(json.size(), 0);
EXPECT_EQ(json.type(), Json::Value::Type::Null); EXPECT_EQ(json.type(), Util::Json::Type::Null);
json = parse(R"({ "name":"value")"); json = parse(R"({ "name":"value")");
EXPECT_EQ(json.size(), 0); EXPECT_EQ(json.size(), 0);
EXPECT_EQ(json.type(), Json::Value::Type::Null); EXPECT_EQ(json.type(), Util::Json::Type::Null);
json = parse(R"({ "name":"value",)"); json = parse(R"({ "name":"value",)");
EXPECT_EQ(json.size(), 0); EXPECT_EQ(json.size(), 0);
EXPECT_EQ(json.type(), Json::Value::Type::Null); EXPECT_EQ(json.type(), Util::Json::Type::Null);
json = parse(R"({ "name":"value", })"); json = parse(R"({ "name":"value", })");
EXPECT_EQ(json.size(), 0); EXPECT_EQ(json.size(), 0);
EXPECT_EQ(json.type(), Json::Value::Type::Null); EXPECT_EQ(json.type(), Util::Json::Type::Null);
json = parse(R"({ "name" "value" })"); json = parse(R"({ "name" "value" })");
EXPECT_EQ(json.size(), 0); EXPECT_EQ(json.size(), 0);
EXPECT_EQ(json.type(), Json::Value::Type::Null); EXPECT_EQ(json.type(), Util::Json::Type::Null);
json = parse(R"({ 123 })"); json = parse(R"({ 123 })");
EXPECT_EQ(json.size(), 0); EXPECT_EQ(json.size(), 0);
EXPECT_EQ(json.type(), Json::Value::Type::Null); EXPECT_EQ(json.type(), Util::Json::Type::Null);
json = parse("{}"); json = parse("{}");
EXPECT_EQ(json.size(), 0); EXPECT_EQ(json.size(), 0);
EXPECT_EQ(json.type(), Json::Value::Type::Object); EXPECT_EQ(json.type(), Util::Json::Type::Object);
json = parse(R"({ "name": "value", "name2": 3.14 })"); json = parse(R"({ "name": "value", "name2": 3.14 })");
EXPECT_EQ(json.size(), 2); EXPECT_EQ(json.size(), 2);
EXPECT_EQ(json.type(), Json::Value::Type::Object); EXPECT_EQ(json.type(), Util::Json::Type::Object);
// Multiple root elements // Multiple root elements
json = parse("54 false"); json = parse("54 false");
EXPECT_EQ(json.type(), Json::Value::Type::Null); EXPECT_EQ(json.type(), Util::Json::Type::Null);
json = parse("3.14, 666"); json = parse("3.14, 666");
EXPECT_EQ(json.type(), Json::Value::Type::Null); EXPECT_EQ(json.type(), Util::Json::Type::Null);
json = parse("true\nfalse"); json = parse("true\nfalse");
EXPECT_EQ(json.type(), Json::Value::Type::Null); EXPECT_EQ(json.type(), Util::Json::Type::Null);
} }
TEST_CASE(JsonToJsonValue) TEST_CASE(JsonToJsonValue)
{ {
Json::Value json; Util::Json json;
json = {}; json = {};
EXPECT_EQ(json.size(), 0); EXPECT_EQ(json.size(), 0);
EXPECT_EQ(json.type(), Json::Value::Type::Null); EXPECT_EQ(json.type(), Util::Json::Type::Null);
json = nullptr; json = nullptr;
EXPECT_EQ(json.size(), 0); EXPECT_EQ(json.size(), 0);
EXPECT_EQ(json.type(), Json::Value::Type::Null); EXPECT_EQ(json.type(), Util::Json::Type::Null);
json = true; json = true;
EXPECT_EQ(json.size(), 1); EXPECT_EQ(json.size(), 1);
EXPECT_EQ(json.type(), Json::Value::Type::Bool); EXPECT_EQ(json.type(), Util::Json::Type::Bool);
json = false; json = false;
EXPECT_EQ(json.size(), 1); EXPECT_EQ(json.size(), 1);
EXPECT_EQ(json.type(), Json::Value::Type::Bool); EXPECT_EQ(json.type(), Util::Json::Type::Bool);
json = 666; json = 666;
EXPECT_EQ(json.size(), 1); EXPECT_EQ(json.size(), 1);
EXPECT_EQ(json.type(), Json::Value::Type::Number); EXPECT_EQ(json.type(), Util::Json::Type::Number);
json = 3.14; json = 3.14;
EXPECT_EQ(json.size(), 1); EXPECT_EQ(json.size(), 1);
EXPECT_EQ(json.type(), Json::Value::Type::Number); EXPECT_EQ(json.type(), Util::Json::Type::Number);
const char* characters = "my string"; const char* characters = "my string";
json = characters; json = characters;
EXPECT_EQ(json.size(), 1); EXPECT_EQ(json.size(), 1);
EXPECT_EQ(json.type(), Json::Value::Type::String); EXPECT_EQ(json.type(), Util::Json::Type::String);
std::string string = "my string"; std::string string = "my string";
json = string; json = string;
EXPECT_EQ(json.size(), 1); EXPECT_EQ(json.size(), 1);
EXPECT_EQ(json.type(), Json::Value::Type::String); EXPECT_EQ(json.type(), Util::Json::Type::String);
// Nested Array with multiple types // Nested Array with multiple types
json = { "element", 3.14, true, nullptr, { "nested element", { "more nesting", { 1, 2, 3, "yes" } } } }; json = { "element", 3.14, true, nullptr, { "nested element", { "more nesting", { 1, 2, 3, "yes" } } } };
EXPECT_EQ(json.size(), 5); EXPECT_EQ(json.size(), 5);
EXPECT_EQ(json.type(), Json::Value::Type::Array); EXPECT_EQ(json.type(), Util::Json::Type::Array);
// Nested Object with multiple types // Nested Object with multiple types
json = { { "name", "value" }, { "name2", 3.14 }, { "name3", true }, { "name4", nullptr }, { "name5", { { "nested name", "value" } } } }; json = { { "name", "value" }, { "name2", 3.14 }, { "name3", true }, { "name4", nullptr }, { "name5", { { "nested name", "value" } } } };
EXPECT_EQ(json.size(), 5); EXPECT_EQ(json.size(), 5);
EXPECT_EQ(json.type(), Json::Value::Type::Object); EXPECT_EQ(json.type(), Util::Json::Type::Object);
// Array with singular type // Array with singular type
std::vector<std::string> vector = { "element", "element2", "element3" }; std::vector<std::string> vector = { "element", "element2", "element3" };
json = vector; json = vector;
EXPECT_EQ(json.size(), 3); EXPECT_EQ(json.size(), 3);
EXPECT_EQ(json.type(), Json::Value::Type::Array); EXPECT_EQ(json.type(), Util::Json::Type::Array);
// Object with singular type // Object with singular type
std::map<std::string, std::string> map = { { "name", "value" }, { "name2", "value2" } }; std::map<std::string, std::string> map = { { "name", "value" }, { "name2", "value2" } };
json = map; json = map;
EXPECT_EQ(json.size(), 2); EXPECT_EQ(json.size(), 2);
EXPECT_EQ(json.type(), Json::Value::Type::Object); EXPECT_EQ(json.type(), Util::Json::Type::Object);
// Object with singular type // Object with singular type
std::unordered_map<std::string, std::string> unorderedMap = { { "name", "value" }, { "name2", "value2" } }; std::unordered_map<std::string, std::string> unorderedMap = { { "name", "value" }, { "name2", "value2" } };
json = unorderedMap; json = unorderedMap;
EXPECT_EQ(json.size(), 2); EXPECT_EQ(json.size(), 2);
EXPECT_EQ(json.type(), Json::Value::Type::Object); EXPECT_EQ(json.type(), Util::Json::Type::Object);
} }
TEST_CASE(JsonFromJsonValue) TEST_CASE(JsonFromJsonValue)
{ {
Json::Value json; Util::Json json;
json = nullptr; json = nullptr;
EXPECT_EQ(json.get<std::nullptr_t>(), nullptr); EXPECT_EQ(json.get<std::nullptr_t>(), nullptr);
@ -373,7 +373,7 @@ TEST_CASE(JsonFromJsonValue)
EXPECT_EQ(json.at(1).get<double>(), 3.14); EXPECT_EQ(json.at(1).get<double>(), 3.14);
EXPECT_EQ(json[2].get<bool>(), true); EXPECT_EQ(json[2].get<bool>(), true);
EXPECT_EQ(json[3].get<std::nullptr_t>(), nullptr); EXPECT_EQ(json[3].get<std::nullptr_t>(), nullptr);
auto valueArray = json.get<std::vector<Json::Value>>(); auto valueArray = json.get<std::vector<Util::Json>>();
EXPECT_EQ(valueArray.size(), 4); EXPECT_EQ(valueArray.size(), 4);
EXPECT_EQ(valueArray[0].get<std::string>(), "string"); EXPECT_EQ(valueArray[0].get<std::string>(), "string");
EXPECT_EQ(valueArray[1].get<double>(), 3.14); EXPECT_EQ(valueArray[1].get<double>(), 3.14);
@ -417,7 +417,7 @@ TEST_CASE(JsonFromJsonValue)
EXPECT_EQ(json.at("name2").get<double>(), 3.14); EXPECT_EQ(json.at("name2").get<double>(), 3.14);
EXPECT_EQ(json["name3"].get<bool>(), true); EXPECT_EQ(json["name3"].get<bool>(), true);
EXPECT_EQ(json["name4"].get<std::nullptr_t>(), nullptr); EXPECT_EQ(json["name4"].get<std::nullptr_t>(), nullptr);
auto valueObject = json.get<std::map<std::string, Json::Value>>(); auto valueObject = json.get<std::map<std::string, Util::Json>>();
EXPECT_EQ(valueObject.size(), 4); EXPECT_EQ(valueObject.size(), 4);
EXPECT_EQ(valueObject["name"].get<std::string>(), "value"); EXPECT_EQ(valueObject["name"].get<std::string>(), "value");
EXPECT_EQ(valueObject["name2"].get<double>(), 3.14); EXPECT_EQ(valueObject["name2"].get<double>(), 3.14);
@ -455,25 +455,25 @@ TEST_CASE(JsonFromJsonValue)
TEST_CASE(JsonImplicitConversion) TEST_CASE(JsonImplicitConversion)
{ {
Json::Value array; Util::Json array;
array[0]; array[0];
EXPECT_EQ(array.type(), Json::Value::Type::Array); EXPECT_EQ(array.type(), Util::Json::Type::Array);
Json::Value arrayEmplace; Util::Json arrayEmplace;
arrayEmplace.emplace_back("element"); arrayEmplace.emplace_back("element");
arrayEmplace.emplace_back({ "nested element" }); arrayEmplace.emplace_back({ "nested element" });
EXPECT_EQ(arrayEmplace.type(), Json::Value::Type::Array); EXPECT_EQ(arrayEmplace.type(), Util::Json::Type::Array);
EXPECT_EQ(arrayEmplace[1].type(), Json::Value::Type::Array); EXPECT_EQ(arrayEmplace[1].type(), Util::Json::Type::Array);
Json::Value object; Util::Json object;
object[""]; object[""];
EXPECT_EQ(object.type(), Json::Value::Type::Object); EXPECT_EQ(object.type(), Util::Json::Type::Object);
Json::Value objectEmplace; Util::Json objectEmplace;
objectEmplace.emplace("name", "value"); objectEmplace.emplace("name", "value");
objectEmplace.emplace("name2", { { "nested name", "value" } }); objectEmplace.emplace("name2", { { "nested name", "value" } });
EXPECT_EQ(objectEmplace.type(), Json::Value::Type::Object); EXPECT_EQ(objectEmplace.type(), Util::Json::Type::Object);
EXPECT_EQ(objectEmplace["name2"].type(), Json::Value::Type::Object); EXPECT_EQ(objectEmplace["name2"].type(), Util::Json::Type::Object);
} }
TEST_CASE(JsonSerializer) TEST_CASE(JsonSerializer)

Loading…
Cancel
Save