riyyi
/
manafiles
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

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

master
Riyyi 2 years ago
parent
be74d89fea
commit
deb9f29b47
19 changed files with 142 additions and 142 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  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
Unescape View File

@ -13,7 +13,7 @@
#include <vector>
#include "config.h"
#include "util/json/value.h"
#include "util/json/json.h"
Config::Config(s)
: m_workingDirectory(std::filesystem::current_path())
@ -51,7 +51,7 @@ void Config::parseConfigFile()
return;
}
Json::Value json;
Util::Json json;
std::ifstream file(m_config);
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 },
{ "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")) {
json.at("ignorePatterns").getTo(settings.ignorePatterns);

6
src/config.h
Unescape View File

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

4
src/util/json/array.cpp
Unescape View File

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

10
src/util/json/array.h
Unescape View File

@ -4,15 +4,15 @@
* SPDX-License-Identifier: MIT
*/
#ifndef JSON_ARRAY_H
#define JSON_ARRAY_H
#ifndef UTIL_JSON_ARRAY_H
#define UTIL_JSON_ARRAY_H
#include <utility> // move
#include <vector>
#include "util/json/parser.h"
namespace Json {
namespace Util::JSON {
class Value;
@ -54,6 +54,6 @@ private:
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
Unescape View File

@ -4,8 +4,8 @@
* SPDX-License-Identifier: MIT
*/
#ifndef JSON_FROM_JSON_H
#define JSON_FROM_JSON_H
#ifndef UTIL_JSON_FROM_JSON_H
#define UTIL_JSON_FROM_JSON_H
#include <algorithm> // transform
#include <cassert> // assert
@ -20,7 +20,7 @@
#include "util/json/object.h"
#include "util/meta/odr.h"
namespace Json {
namespace Util::JSON {
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)
} // namespace
} // namespace Json
} // namespace Util::JSON
#endif // JSON_FROM_JSON_H
#endif // UTIL_JSON_FROM_JSON_H
// Customization Points
// https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html

4
src/util/json/job.cpp
Unescape View File

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

10
src/util/json/job.h
Unescape View File

@ -4,8 +4,8 @@
* SPDX-License-Identifier: MIT
*/
#ifndef JSON_JOB_H
#define JSON_JOB_H
#ifndef UTIL_JSON_JOB_H
#define UTIL_JSON_JOB_H
#include <cstddef> // size_t
#include <string_view>
@ -13,7 +13,7 @@
#include "util/json/lexer.h"
namespace Json {
namespace Util::JSON {
class Value;
@ -48,6 +48,6 @@ private:
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
Unescape View File

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

10
src/util/json/lexer.h
Unescape View File

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

@ -7,7 +7,7 @@
#include "util/json/object.h"
#include "util/json/value.h"
namespace Json {
namespace Util::JSON {
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);
}
} // namespace Json
} // namespace Util::JSON

10
src/util/json/object.h
Unescape View File

@ -4,8 +4,8 @@
* SPDX-License-Identifier: MIT
*/
#ifndef JSON_OBJECT_H
#define JSON_OBJECT_H
#ifndef UTIL_JSON_OBJECT_H
#define UTIL_JSON_OBJECT_H
#include <map>
#include <string>
@ -13,7 +13,7 @@
#include "util/json/parser.h"
namespace Json {
namespace Util::JSON {
class Value;
@ -50,6 +50,6 @@ private:
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
Unescape View File

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

10
src/util/json/parser.h
Unescape View File

@ -4,15 +4,15 @@
* SPDX-License-Identifier: MIT
*/
#ifndef JSON_PARSER_H
#define JSON_PARSER_H
#ifndef UTIL_JSON_PARSER_H
#define UTIL_JSON_PARSER_H
#include <cstddef> // size_t
#include <vector>
#include "util/json/lexer.h"
namespace Json {
namespace Util::JSON {
class Job;
class Value;
@ -43,6 +43,6 @@ private:
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
Unescape View File

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

10
src/util/json/serializer.h
Unescape View File

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

10
src/util/json/tojson.h
Unescape View File

@ -4,8 +4,8 @@
* SPDX-License-Identifier: MIT
*/
#ifndef JSON_TO_JSON_H
#define JSON_TO_JSON_H
#ifndef UTIL_JSON_TO_JSON_H
#define UTIL_JSON_TO_JSON_H
#include <cassert> // assert
#include <cstddef> // nullptr_t
@ -18,7 +18,7 @@
#include "util/json/object.h"
#include "util/meta/odr.h"
namespace Json {
namespace Util::JSON {
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)
} // namespace
} // namespace Json
} // namespace Util::JSON
#endif // JSON_TO_JSON_H
#endif // UTIL_JSON_TO_JSON_H
// Customization Points
// https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html

4
src/util/json/value.cpp
Unescape View File

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

10
src/util/json/value.h
Unescape View File

@ -4,8 +4,8 @@
* SPDX-License-Identifier: MIT
*/
#ifndef JSON_VALUE_H
#define JSON_VALUE_H
#ifndef UTIL_JSON_VALUE_H
#define UTIL_JSON_VALUE_H
#include <cstddef> // nullptr_t, size_t
#include <cstdint> // uint32_t
@ -18,7 +18,7 @@
#include "util/json/fromjson.h"
#include "util/json/tojson.h"
namespace Json {
namespace Util::JSON {
class Array;
class Object;
@ -137,7 +137,7 @@ std::ostream& operator<<(std::ostream& output, const Value& value);
void format(FormatBuilder& builder, const Value& value);
} // namespace Json
} // namespace Util::JSON
/**
* 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));
}
#endif // JSON_VALUE_H
#endif // UTIL_JSON_VALUE_H

148
test/unit/testutiljson.cpp
Unescape View File

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

Write Preview
Loading…
Cancel
Save