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

Everywhere: Move everything in namescape Util => ruc

master
Riyyi 2 years ago
parent
0e5f21474b
commit
be73ba335e
61 changed files with 570 additions and 587 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      CMakeLists.txt
  2. 6
      src/ruc/argparser.cpp
  3. 4
      src/ruc/argparser.h
  4. 10
      src/ruc/file.cpp
  5. 4
      src/ruc/file.h
  6. 0
      src/ruc/format/.clang-tidy
  7. 10
      src/ruc/format/builder.cpp
  8. 4
      src/ruc/format/builder.h
  9. 10
      src/ruc/format/color.cpp
  10. 19
      src/ruc/format/color.h
  11. 12
      src/ruc/format/format.cpp
  12. 17
      src/ruc/format/format.h
  13. 10
      src/ruc/format/formatter.cpp
  14. 10
      src/ruc/format/formatter.h
  15. 8
      src/ruc/format/log.cpp
  16. 30
      src/ruc/format/log.h
  17. 16
      src/ruc/format/parser.cpp
  18. 6
      src/ruc/format/parser.h
  19. 6
      src/ruc/format/print.cpp
  20. 17
      src/ruc/format/print.h
  21. 8
      src/ruc/genericlexer.cpp
  22. 4
      src/ruc/genericlexer.h
  23. 8
      src/ruc/json/array.cpp
  24. 9
      src/ruc/json/array.h
  25. 18
      src/ruc/json/fromjson.h
  26. 12
      src/ruc/json/job.cpp
  27. 6
      src/ruc/json/job.h
  28. 15
      src/ruc/json/json.h
  29. 8
      src/ruc/json/lexer.cpp
  30. 8
      src/ruc/json/lexer.h
  31. 8
      src/ruc/json/object.cpp
  32. 6
      src/ruc/json/object.h
  33. 18
      src/ruc/json/parser.cpp
  34. 6
      src/ruc/json/parser.h
  35. 12
      src/ruc/json/serializer.cpp
  36. 6
      src/ruc/json/serializer.h
  37. 16
      src/ruc/json/tojson.h
  38. 20
      src/ruc/json/value.cpp
  39. 38
      src/ruc/json/value.h
  40. 14
      src/ruc/meta/assert.h
  41. 0
      src/ruc/meta/compiler.h
  42. 8
      src/ruc/meta/concepts.h
  43. 8
      src/ruc/meta/odr.h
  44. 6
      src/ruc/shell.cpp
  45. 4
      src/ruc/shell.h
  46. 4
      src/ruc/singleton.h
  47. 6
      src/ruc/system.cpp
  48. 4
      src/ruc/system.h
  49. 6
      src/ruc/timer.cpp
  50. 4
      src/ruc/timer.h
  51. 15
      src/util/json/json.h
  52. 6
      test/macro.h
  53. 2
      test/main.cpp
  54. 6
      test/testcase.h
  55. 14
      test/testsuite.cpp
  56. 8
      test/testsuite.h
  57. 180
      test/unit/testutilargparser.cpp
  58. 232
      test/unit/testutilformat.cpp
  59. 162
      test/unit/testutiljson.cpp
  60. 8
      test/unit/testutilshell.cpp
  61. 27
      test/unit/testutilsystem.cpp

2
CMakeLists.txt
Unescape View File

@ -63,7 +63,7 @@ target_include_directories(${PROJECT} PRIVATE
# Unit test library target # Unit test library target
# Define source files # Define source files
file(GLOB TEST_LIBRARY_SOURCES "test/*.cpp" "src/util/timer.cpp") file(GLOB TEST_LIBRARY_SOURCES "test/*.cpp" "src/ruc/timer.cpp")
add_library(${PROJECT}-test STATIC ${TEST_LIBRARY_SOURCES}) add_library(${PROJECT}-test STATIC ${TEST_LIBRARY_SOURCES})
target_include_directories(${PROJECT}-test PRIVATE target_include_directories(${PROJECT}-test PRIVATE

6
src/util/argparser.cpp → src/ruc/argparser.cpp
Unescape View File

@ -14,9 +14,9 @@
#include <string_view> #include <string_view>
#include <vector> #include <vector>
#include "util/argparser.h" #include "ruc/argparser.h"
namespace Util { namespace ruc {
ArgParser::ArgParser() ArgParser::ArgParser()
{ {
@ -565,4 +565,4 @@ AcceptFunction ArgParser::getAcceptFunction(std::vector<std::string>& value)
}; };
} }
} // namespace Util } // namespace ruc

4
src/util/argparser.h → src/ruc/argparser.h
Unescape View File

@ -13,7 +13,7 @@
#include <string_view> #include <string_view>
#include <vector> #include <vector>
namespace Util { namespace ruc {
using AcceptFunction = std::function<bool(const char*)>; using AcceptFunction = std::function<bool(const char*)>;
@ -117,4 +117,4 @@ private:
std::vector<Argument> m_arguments; std::vector<Argument> m_arguments;
}; };
} // namespace Util } // namespace ruc

10
src/util/file.cpp → src/ruc/file.cpp
Unescape View File

@ -10,10 +10,10 @@
#include <memory> // make_unique #include <memory> // make_unique
#include <string> #include <string>
#include "util/file.h" #include "ruc/file.h"
#include "util/meta/assert.h" #include "ruc/meta/assert.h"
namespace Util { namespace ruc {
File::File(const std::string& path) File::File(const std::string& path)
: m_path(path) : m_path(path)
@ -50,7 +50,7 @@ File File::create(const std::string& path)
std::ofstream { path }; std::ofstream { path };
} }
return Util::File(path); return File(path);
} }
// ----------------------------------------- // -----------------------------------------
@ -86,4 +86,4 @@ File& File::flush()
return *this; return *this;
} }
} // namespace Util } // namespace ruc

4
src/util/file.h → src/ruc/file.h
Unescape View File

@ -8,7 +8,7 @@
#include <string> #include <string>
namespace Util { namespace ruc {
class File { class File {
public: public:
@ -31,4 +31,4 @@ private:
std::string m_data; std::string m_data;
}; };
} // namespace Util } // namespace ruc

0
src/util/format/.clang-tidy → src/ruc/format/.clang-tidy
Unescape View File

10
src/util/format/builder.cpp → src/ruc/format/builder.cpp
Unescape View File

@ -14,11 +14,11 @@
#include <string> #include <string>
#include <string_view> #include <string_view>
#include "util/format/builder.h" #include "ruc/format/builder.h"
#include "util/format/parser.h" #include "ruc/format/parser.h"
#include "util/meta/assert.h" #include "ruc/meta/assert.h"
namespace Util::Format { namespace ruc::format {
void Builder::putLiteral(std::string_view literal) void Builder::putLiteral(std::string_view literal)
{ {
@ -219,4 +219,4 @@ void Builder::putString(std::string_view string, char fill, Align align, size_t
}; };
} }
} // namespace Util::Format } // namespace ruc::format

4
src/util/format/builder.h → src/ruc/format/builder.h
Unescape View File

@ -11,7 +11,7 @@
#include <sstream> // stringstream #include <sstream> // stringstream
#include <string_view> #include <string_view>
namespace Util::Format { namespace ruc::format {
class Builder { class Builder {
public: public:
@ -68,7 +68,7 @@ private:
std::stringstream& m_builder; std::stringstream& m_builder;
}; };
} // namespace Util::Format } // namespace ruc::format
#if 0 #if 0
// Defaults based on type // Defaults based on type

10
src/util/format/color.cpp → src/ruc/format/color.cpp
Unescape View File

@ -10,11 +10,11 @@
#include <string> #include <string>
#include <string_view> #include <string_view>
#include "util/format/color.h" #include "ruc/format/color.h"
#include "util/format/format.h" #include "ruc/format/format.h"
#include "util/meta/assert.h" #include "ruc/meta/assert.h"
namespace Util::Format { namespace ruc::format {
TextStyle::TextStyle(Emphasis emphasis) TextStyle::TextStyle(Emphasis emphasis)
: m_emphasis(emphasis) : m_emphasis(emphasis)
@ -173,4 +173,4 @@ ColorPrintOperatorStyle print(FILE* file, const TextStyle& style)
return ColorPrintOperatorStyle(file, style); return ColorPrintOperatorStyle(file, style);
} }
} // namespace Util::Format } // namespace ruc::format

19
src/util/format/color.h → src/ruc/format/color.h
Unescape View File

@ -12,9 +12,9 @@
#include <sstream> // stringstream #include <sstream> // stringstream
#include <string_view> #include <string_view>
#include "util/format/format.h" #include "ruc/format/format.h"
namespace Util::Format { namespace ruc::format {
enum class TerminalColor : uint8_t { enum class TerminalColor : uint8_t {
None = 0, None = 0,
@ -138,19 +138,16 @@ private:
template<typename T> template<typename T>
const ColorPrintOperatorStyle& operator<<(const ColorPrintOperatorStyle& colorPrintOperatorStyle, const T& value) const ColorPrintOperatorStyle& operator<<(const ColorPrintOperatorStyle& colorPrintOperatorStyle, const T& value)
{ {
_format(const_cast<ColorPrintOperatorStyle&>(colorPrintOperatorStyle).builder(), value); Formatter<T> formatter;
formatter.format(const_cast<ColorPrintOperatorStyle&>(colorPrintOperatorStyle).builder(), value);
return colorPrintOperatorStyle; return colorPrintOperatorStyle;
} }
ColorPrintOperatorStyle print(const TextStyle& style); ColorPrintOperatorStyle print(const TextStyle& style);
ColorPrintOperatorStyle print(FILE* file, const TextStyle& style); ColorPrintOperatorStyle print(FILE* file, const TextStyle& style);
} // namespace Util::Format } // namespace ruc::format
namespace Util { using ruc::format::format;
using ruc::format::formatTo;
using Util::Format::format; using ruc::format::print;
using Util::Format::formatTo;
using Util::Format::print;
} // namespace Util

12
src/util/format/format.cpp → src/ruc/format/format.cpp
Unescape View File

@ -8,12 +8,12 @@
#include <string> #include <string>
#include <string_view> #include <string_view>
#include "util/format/builder.h" #include "ruc/format/builder.h"
#include "util/format/format.h" #include "ruc/format/format.h"
#include "util/format/parser.h" #include "ruc/format/parser.h"
#include "util/meta/assert.h" #include "ruc/meta/assert.h"
namespace Util::Format { namespace ruc::format {
void variadicFormatImpl(Builder& builder, Parser& parser, TypeErasedParameters& parameters) void variadicFormatImpl(Builder& builder, Parser& parser, TypeErasedParameters& parameters)
{ {
@ -73,4 +73,4 @@ FormatOperatorStyle formatTo(std::string& output)
return FormatOperatorStyle(output); return FormatOperatorStyle(output);
} }
} // namespace Util::Format } // namespace ruc::format

17
src/util/format/format.h → src/ruc/format/format.h
Unescape View File

@ -12,9 +12,9 @@
#include <string> #include <string>
#include <string_view> #include <string_view>
#include "util/format/formatter.h" #include "ruc/format/formatter.h"
namespace Util::Format { namespace ruc::format {
class Builder; class Builder;
class Parser; class Parser;
@ -103,17 +103,14 @@ private:
template<typename T> template<typename T>
const FormatOperatorStyle& operator<<(const FormatOperatorStyle& formatOperatorStyle, const T& value) const FormatOperatorStyle& operator<<(const FormatOperatorStyle& formatOperatorStyle, const T& value)
{ {
_format(const_cast<FormatOperatorStyle&>(formatOperatorStyle).builder(), value); Formatter<T> formatter;
formatter.format(const_cast<FormatOperatorStyle&>(formatOperatorStyle).builder(), value);
return formatOperatorStyle; return formatOperatorStyle;
} }
FormatOperatorStyle formatTo(std::string& output); FormatOperatorStyle formatTo(std::string& output);
} // namespace Util::Format } // namespace ruc::format
namespace Util {
using Util::Format::format;
using Util::Format::formatTo;
} // namespace Util using ruc::format::format;
using ruc::format::formatTo;

10
src/util/format/formatter.cpp → src/ruc/format/formatter.cpp
Unescape View File

@ -9,11 +9,11 @@
#include <string> #include <string>
#include <string_view> #include <string_view>
#include "util/format/builder.h" #include "ruc/format/builder.h"
#include "util/format/formatter.h" #include "ruc/format/formatter.h"
#include "util/format/parser.h" #include "ruc/format/parser.h"
namespace Util::Format { namespace ruc::format {
// Char // Char
@ -114,4 +114,4 @@ type: {%c}
builder.putString(std::string_view(result)); builder.putString(std::string_view(result));
} }
} // namespace Util::Format } // namespace ruc::format

10
src/util/format/formatter.h → src/ruc/format/formatter.h
Unescape View File

@ -16,11 +16,11 @@
#include <unordered_map> #include <unordered_map>
#include <vector> #include <vector>
#include "util/format/builder.h" #include "ruc/format/builder.h"
#include "util/format/parser.h" #include "ruc/format/parser.h"
#include "util/meta/concepts.h" #include "ruc/meta/concepts.h"
namespace Util::Format { namespace ruc::format {
enum class PresentationType : uint8_t { enum class PresentationType : uint8_t {
None, None,
@ -312,7 +312,7 @@ struct Formatter<Specifier> : Formatter<std::nullptr_t> {
void format(Builder& builder, Specifier value) const; void format(Builder& builder, Specifier value) const;
}; };
} // namespace Util::Format } // namespace ruc::format
#if 0 #if 0

8
src/util/format/log.cpp → src/ruc/format/log.cpp
Unescape View File

@ -7,10 +7,10 @@
#include <cstdio> // FILE #include <cstdio> // FILE
#include <string> #include <string>
#include "util/format/color.h" #include "ruc/format/color.h"
#include "util/format/log.h" #include "ruc/format/log.h"
namespace Util::Format { namespace ruc::format {
std::string formatTimeElapsed() std::string formatTimeElapsed()
{ {
@ -106,4 +106,4 @@ LogOperatorStyle critical()
return LogOperatorStyle(stderr, LogType::Critical); return LogOperatorStyle(stderr, LogType::Critical);
} }
} // namespace Util::Format } // namespace ruc::format

30
src/util/format/log.h → src/ruc/format/log.h
Unescape View File

@ -10,13 +10,13 @@
#include <string> #include <string>
#include <string_view> #include <string_view>
#include "util/format/format.h" #include "ruc/format/format.h"
#include "util/format/print.h" #include "ruc/format/print.h"
#include "util/timer.h" #include "ruc/timer.h"
namespace Util::Format { namespace ruc::format {
static Util::Timer s_timer; static Timer s_timer;
enum class LogType : uint8_t { enum class LogType : uint8_t {
Trace, // White Trace, // White
@ -82,16 +82,16 @@ LogOperatorStyle warn();
LogOperatorStyle error(); LogOperatorStyle error();
LogOperatorStyle critical(); LogOperatorStyle critical();
} // namespace Util::Format } // namespace ruc::format
namespace Util { namespace ruc {
using Util::Format::critical; using ruc::format::critical;
using Util::Format::debug; using ruc::format::debug;
using Util::Format::error; using ruc::format::error;
using Util::Format::info; using ruc::format::info;
using Util::Format::success; using ruc::format::success;
using Util::Format::trace; using ruc::format::trace;
using Util::Format::warn; using ruc::format::warn;
} // namespace Util } // namespace ruc

16
src/util/format/parser.cpp → src/ruc/format/parser.cpp
Unescape View File

@ -11,13 +11,13 @@
#include <string> #include <string>
#include <string_view> #include <string_view>
#include "util/format/builder.h" #include "ruc/format/builder.h"
#include "util/format/formatter.h" #include "ruc/format/formatter.h"
#include "util/format/parser.h" #include "ruc/format/parser.h"
#include "util/format/print.h" #include "ruc/format/print.h"
#include "util/meta/assert.h" #include "ruc/meta/assert.h"
namespace Util::Format { namespace ruc::format {
Parser::Parser(std::string_view format, size_t parameterCount) Parser::Parser(std::string_view format, size_t parameterCount)
: GenericLexer(format) : GenericLexer(format)
@ -282,7 +282,7 @@ void Parser::parseSpecifier(Specifier& specifier, ParameterType type)
if (!p) { if (!p) {
p++; p++;
Util::Format::print("{}\n", specifier); print("{}\n", specifier);
} }
} }
@ -416,4 +416,4 @@ constexpr void Parser::checkSpecifierType(const Specifier& specifier, ParameterT
} }
} }
} // namespace Util::Format } // namespace ruc::format

6
src/util/format/parser.h → src/ruc/format/parser.h
Unescape View File

@ -10,9 +10,9 @@
#include <optional> #include <optional>
#include <string_view> #include <string_view>
#include "util/genericlexer.h" #include "ruc/genericlexer.h"
namespace Util::Format { namespace ruc::format {
class Builder; class Builder;
struct Specifier; struct Specifier;
@ -58,4 +58,4 @@ private:
size_t m_parameterCount { 0 }; size_t m_parameterCount { 0 };
}; };
} // namespace Util::Format } // namespace ruc::format

6
src/util/format/print.cpp → src/ruc/format/print.cpp
Unescape View File

@ -11,9 +11,9 @@
#include <string> #include <string>
#include <string_view> #include <string_view>
#include "util/format/print.h" #include "ruc/format/print.h"
namespace Util::Format { namespace ruc::format {
void variadicPrint(FILE* file, std::string_view format, TypeErasedParameters& parameters) void variadicPrint(FILE* file, std::string_view format, TypeErasedParameters& parameters)
{ {
@ -49,4 +49,4 @@ PrintOperatorStyle print(FILE* file)
return PrintOperatorStyle(file); return PrintOperatorStyle(file);
} }
} // namespace Util::Format } // namespace ruc::format

17
src/util/format/print.h → src/ruc/format/print.h
Unescape View File

@ -11,10 +11,10 @@
#include <sstream> // stringstream #include <sstream> // stringstream
#include <string_view> #include <string_view>
#include "util/format/format.h" #include "ruc/format/format.h"
#include "util/timer.h" #include "ruc/timer.h"
namespace Util::Format { namespace ruc::format {
void variadicPrint(FILE* file, std::string_view format, TypeErasedParameters& parameters); void variadicPrint(FILE* file, std::string_view format, TypeErasedParameters& parameters);
@ -51,7 +51,8 @@ private:
template<typename T> template<typename T>
const PrintOperatorStyle& operator<<(const PrintOperatorStyle& printOperatorStyle, const T& value) const PrintOperatorStyle& operator<<(const PrintOperatorStyle& printOperatorStyle, const T& value)
{ {
_format(const_cast<PrintOperatorStyle&>(printOperatorStyle).builder(), value); Formatter<T> formatter;
formatter.format(const_cast<PrintOperatorStyle&>(printOperatorStyle).builder(), value);
return printOperatorStyle; return printOperatorStyle;
} }
@ -60,10 +61,6 @@ PrintOperatorStyle print(FILE* file);
// ----------------------------------------- // -----------------------------------------
} // namespace Util::Format } // namespace ruc::format
namespace Util { using ruc::format::print;
using Util::Format::print;
} // namespace Util

8
src/util/genericlexer.cpp → src/ruc/genericlexer.cpp
Unescape View File

@ -6,10 +6,10 @@
#include <algorithm> // max, min #include <algorithm> // max, min
#include "util/genericlexer.h" #include "ruc/genericlexer.h"
#include "util/meta/assert.h" #include "ruc/meta/assert.h"
namespace Util { namespace ruc {
GenericLexer::GenericLexer(std::string_view input) GenericLexer::GenericLexer(std::string_view input)
: m_input(input) : m_input(input)
@ -68,4 +68,4 @@ bool GenericLexer::consumeSpecific(const char& character)
return true; return true;
} }
} // namespace Util } // namespace ruc

4
src/util/genericlexer.h → src/ruc/genericlexer.h
Unescape View File

@ -9,7 +9,7 @@
#include <cstddef> // size_t #include <cstddef> // size_t
#include <string_view> #include <string_view>
namespace Util { namespace ruc {
class GenericLexer { class GenericLexer {
public: public:
@ -38,4 +38,4 @@ protected:
std::string_view m_input; std::string_view m_input;
}; };
} // namespace Util } // namespace ruc

8
src/util/json/array.cpp → src/ruc/json/array.cpp
Unescape View File

@ -4,10 +4,10 @@
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
*/ */
#include "util/json/array.h" #include "ruc/json/array.h"
#include "util/json/value.h" #include "ruc/json/value.h"
namespace Util::JSON { namespace ruc::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 Util::JSON } // namespace ruc::json

9
src/util/json/array.h → src/ruc/json/array.h
Unescape View File

@ -9,9 +9,9 @@
#include <utility> // move #include <utility> // move
#include <vector> #include <vector>
#include "util/json/parser.h" #include "ruc/json/parser.h"
namespace Util::JSON { namespace ruc::json {
class Value; class Value;
@ -22,7 +22,8 @@ public:
Array(const std::vector<Value>& elements) Array(const std::vector<Value>& elements)
: m_elements(elements) : m_elements(elements)
{} {
}
Array(const Array& other) Array(const Array& other)
: m_elements(other.m_elements) : m_elements(other.m_elements)
@ -53,4 +54,4 @@ private:
std::vector<Value> m_elements; std::vector<Value> m_elements;
}; };
} // namespace Util::JSON } // namespace ruc::json

18
src/util/json/fromjson.h → src/ruc/json/fromjson.h
Unescape View File

@ -14,14 +14,14 @@
#include <utility> // forward #include <utility> // forward
#include <vector> #include <vector>
#include "util/json/array.h" #include "ruc/json/array.h"
#include "util/json/object.h" #include "ruc/json/object.h"
#include "util/meta/assert.h" #include "ruc/meta/assert.h"
#include "util/meta/odr.h" #include "ruc/meta/odr.h"
namespace Util::JSON { namespace ruc::json {
namespace Detail { namespace detail {
// Required for containers with Json::Value type // Required for containers with Json::Value type
template<typename Json> template<typename Json>
@ -107,15 +107,15 @@ struct fromJsonFunction {
} }
}; };
} // namespace Detail } // namespace detail
// Anonymous namespace prevents multiple definition of the reference // Anonymous namespace prevents multiple definition of the reference
namespace { namespace {
// Function object // Function object
constexpr const auto& fromJson = Util::Detail::staticConst<Detail::fromJsonFunction>; // NOLINT(misc-definitions-in-headers,clang-diagnostic-unused-variable) constexpr const auto& fromJson = ruc::detail::staticConst<detail::fromJsonFunction>; // NOLINT(misc-definitions-in-headers,clang-diagnostic-unused-variable)
} // namespace } // namespace
} // namespace Util::JSON } // namespace ruc::json
// 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

12
src/util/json/job.cpp → src/ruc/json/job.cpp
Unescape View File

@ -8,12 +8,12 @@
#include <sstream> // istringstream #include <sstream> // istringstream
#include <string> // getline #include <string> // getline
#include "util/json/job.h" #include "ruc/json/job.h"
#include "util/json/lexer.h" #include "ruc/json/lexer.h"
#include "util/json/parser.h" #include "ruc/json/parser.h"
#include "util/json/value.h" #include "ruc/json/value.h"
namespace Util::JSON { namespace ruc::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 Util::JSON } // namespace ruc::json

6
src/util/json/job.h → src/ruc/json/job.h
Unescape View File

@ -10,9 +10,9 @@
#include <string_view> #include <string_view>
#include <vector> #include <vector>
#include "util/json/lexer.h" #include "ruc/json/lexer.h"
namespace Util::JSON { namespace ruc::json {
class Value; class Value;
@ -38,4 +38,4 @@ private:
std::vector<Token> m_tokens; std::vector<Token> m_tokens;
}; };
} // namespace Util::JSON } // namespace ruc::json

15
src/ruc/json/json.h
Unescape View File

@ -0,0 +1,15 @@
/*
* Copyright (C) 2022 Riyyi
*
* SPDX-License-Identifier: MIT
*/
#pragma once
#include "ruc/json/value.h"
namespace ruc {
using Json = ruc::json::Value;
} // namespace ruc

8
src/util/json/lexer.cpp → src/ruc/json/lexer.cpp
Unescape View File

@ -7,10 +7,10 @@
#include <cstddef> #include <cstddef>
#include <string> #include <string>
#include "util/json/job.h" #include "ruc/json/job.h"
#include "util/json/lexer.h" #include "ruc/json/lexer.h"
namespace Util::JSON { namespace ruc::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 Util::JSON } // namespace ruc::json

8
src/util/json/lexer.h → src/ruc/json/lexer.h
Unescape View File

@ -14,9 +14,9 @@
#include <string> #include <string>
#include <vector> #include <vector>
#include "util/genericlexer.h" #include "ruc/genericlexer.h"
namespace Util::JSON { namespace ruc::json {
class Job; class Job;
@ -41,7 +41,7 @@ struct Token {
}; };
// Lexical analyzer // Lexical analyzer
class Lexer final : public Util::GenericLexer { class Lexer final : public GenericLexer {
public: public:
Lexer(Job* job); Lexer(Job* job);
virtual ~Lexer(); virtual ~Lexer();
@ -62,4 +62,4 @@ private:
std::vector<Token>* m_tokens { nullptr }; std::vector<Token>* m_tokens { nullptr };
}; };
} // namespace Util::JSON } // namespace ruc::json

8
src/util/json/object.cpp → src/ruc/json/object.cpp
Unescape View File

@ -4,10 +4,10 @@
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
*/ */
#include "util/json/object.h" #include "ruc/json/object.h"
#include "util/json/value.h" #include "ruc/json/value.h"
namespace Util::JSON { namespace ruc::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 Util::JSON } // namespace ruc::json

6
src/util/json/object.h → src/ruc/json/object.h
Unescape View File

@ -10,9 +10,9 @@
#include <string> #include <string>
#include <utility> // move #include <utility> // move
#include "util/json/parser.h" #include "ruc/json/parser.h"
namespace Util::JSON { namespace ruc::json {
class Value; class Value;
@ -49,4 +49,4 @@ private:
std::map<std::string, Value> m_members; std::map<std::string, Value> m_members;
}; };
} // namespace Util::JSON } // namespace ruc::json

18
src/util/json/parser.cpp → src/ruc/json/parser.cpp
Unescape View File

@ -11,15 +11,15 @@
#include <map> #include <map>
#include <string> // stod #include <string> // stod
#include "util/json/array.h" #include "ruc/json/array.h"
#include "util/json/job.h" #include "ruc/json/job.h"
#include "util/json/lexer.h" #include "ruc/json/lexer.h"
#include "util/json/object.h" #include "ruc/json/object.h"
#include "util/json/parser.h" #include "ruc/json/parser.h"
#include "util/json/value.h" #include "ruc/json/value.h"
#include "util/meta/assert.h" #include "ruc/meta/assert.h"
namespace Util::JSON { namespace ruc::json {
Parser::Parser(Job* job) Parser::Parser(Job* job)
: m_job(job) : m_job(job)
@ -494,4 +494,4 @@ Value Parser::consumeObject()
return object; return object;
} }
} // namespace Util::JSON } // namespace ruc::json

6
src/util/json/parser.h → src/ruc/json/parser.h
Unescape View File

@ -9,9 +9,9 @@
#include <cstddef> // size_t #include <cstddef> // size_t
#include <vector> #include <vector>
#include "util/json/lexer.h" #include "ruc/json/lexer.h"
namespace Util::JSON { namespace ruc::json {
class Job; class Job;
class Value; class Value;
@ -42,4 +42,4 @@ private:
std::vector<Token>* m_tokens { nullptr }; std::vector<Token>* m_tokens { nullptr };
}; };
} // namespace Util::JSON } // namespace ruc::json

12
src/util/json/serializer.cpp → src/ruc/json/serializer.cpp
Unescape View File

@ -9,12 +9,12 @@
#include <sstream> // ostringstream #include <sstream> // ostringstream
#include <string> #include <string>
#include "util/json/array.h" #include "ruc/json/array.h"
#include "util/json/lexer.h" #include "ruc/json/lexer.h"
#include "util/json/object.h" #include "ruc/json/object.h"
#include "util/json/serializer.h" #include "ruc/json/serializer.h"
namespace Util::JSON { namespace ruc::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)
@ -152,4 +152,4 @@ void Serializer::dumpObject(const Value& value, const uint32_t indentLevel)
m_output += '}'; m_output += '}';
} }
} // namespace Util::JSON } // namespace ruc::json

6
src/util/json/serializer.h → src/ruc/json/serializer.h
Unescape View File

@ -9,9 +9,9 @@
#include <cstdint> // uint32_t #include <cstdint> // uint32_t
#include <string> #include <string>
#include "util/json/value.h" #include "ruc/json/value.h"
namespace Util::JSON { namespace ruc::json {
class Serializer { class Serializer {
public: public:
@ -32,4 +32,4 @@ private:
bool m_compact { true }; bool m_compact { true };
}; };
} // namespace Util::JSON } // namespace ruc::json

16
src/util/json/tojson.h → src/ruc/json/tojson.h
Unescape View File

@ -13,13 +13,13 @@
#include <unordered_map> #include <unordered_map>
#include <utility> // forward #include <utility> // forward
#include "util/json/array.h" #include "ruc/json/array.h"
#include "util/json/object.h" #include "ruc/json/object.h"
#include "util/meta/odr.h" #include "ruc/meta/odr.h"
namespace Util::JSON { namespace ruc::json {
namespace Detail { namespace detail {
struct jsonConstructor { struct jsonConstructor {
template<typename Json> template<typename Json>
@ -127,15 +127,15 @@ struct toJsonFunction {
} }
}; };
} // namespace Detail } // namespace detail
// Anonymous namespace prevents multiple definition of the reference // Anonymous namespace prevents multiple definition of the reference
namespace { namespace {
// Function object // Function object
constexpr const auto& toJson = Util::Detail::staticConst<Detail::toJsonFunction>; // NOLINT(misc-definitions-in-headers,clang-diagnostic-unused-variable) constexpr const auto& toJson = ruc::detail::staticConst<detail::toJsonFunction>; // NOLINT(misc-definitions-in-headers,clang-diagnostic-unused-variable)
} // namespace } // namespace
} // namespace Util::JSON } // namespace ruc::json
// 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

20
src/util/json/value.cpp → src/ruc/json/value.cpp
Unescape View File

@ -11,15 +11,15 @@
#include <string> #include <string>
#include <utility> // move, swap #include <utility> // move, swap
#include "util/format/builder.h" #include "ruc/format/builder.h"
#include "util/json/array.h" #include "ruc/meta/assert.h"
#include "util/json/job.h" #include "ruc/json/array.h"
#include "util/json/object.h" #include "ruc/json/job.h"
#include "util/json/serializer.h" #include "ruc/json/object.h"
#include "util/json/value.h" #include "ruc/json/serializer.h"
#include "util/meta/assert.h" #include "ruc/json/value.h"
namespace Util::JSON { namespace ruc::json {
Value::Value(std::nullptr_t) Value::Value(std::nullptr_t)
: Value(Type::Null) : Value(Type::Null)
@ -332,9 +332,9 @@ std::ostream& operator<<(std::ostream& output, const Value& value)
return output << value.dump(4); return output << value.dump(4);
} }
void format(Util::Format::Builder& builder, const Value& value) void format(ruc::format::Builder& builder, const Value& value)
{ {
builder.putString(value.dump(4)); builder.putString(value.dump(4));
} }
} // namespace Util::JSON } // namespace ruc::json

38
src/util/json/value.h → src/ruc/json/value.h
Unescape View File

@ -13,18 +13,18 @@
#include <string> #include <string>
#include <utility> // forward #include <utility> // forward
#include "util/format/builder.h" #include "ruc/format/builder.h"
#include "util/json/fromjson.h" #include "ruc/json/fromjson.h"
#include "util/json/tojson.h" #include "ruc/json/tojson.h"
namespace Util::JSON { namespace ruc::json {
class Array; class Array;
class Object; class Object;
class Value { class Value {
private: private:
friend Detail::jsonConstructor; friend detail::jsonConstructor;
friend class Parser; friend class Parser;
friend class Serializer; friend class Serializer;
@ -134,32 +134,16 @@ private:
std::istream& operator>>(std::istream& input, Value& value); std::istream& operator>>(std::istream& input, Value& value);
std::ostream& operator<<(std::ostream& output, const Value& value); std::ostream& operator<<(std::ostream& output, const Value& value);
void format(Util::Format::Builder& builder, const Value& value); void format(ruc::format::Builder& builder, const Value& value);
} // namespace Util::JSON } // namespace ruc::json
/** /**
* User-defined string literal * User-defined string literal
* *
* Example usage: auto json = "[ 3.14, true, null ]"_json; * Example usage: auto json = "[ 3.14, true, null ]"_json;
*/ */
// inline Util::JSON::Value operator"" _json(const char* input, size_t length) inline ruc::json::Value operator"" _json(const char* input, size_t length)
// { {
// return Util::JSON::Value::parse(std::string(input, length)); return ruc::json::Value::parse(std::string(input, length));
// } }
// TODO:
// - find
// - custom iterator
// - begin
// - end
// v parse function that accepts ifstream > redirect to operator>>
// - dump(-1), 0 inserts only newlines, -1 is full compact(?)
// v add timer pause and unpause functions
// v std::prev -> std::next in serializer
// v serializer: output as member, does this speed it up?
// - add Badge pattern, ex: Serializer constructor isnt needed publically
// v Rename namespace Json -> Util::Json, create easy include json.h
// - look into this for correctness
// https://www.json.org/json-en.html

14
src/util/meta/assert.h → src/ruc/meta/assert.h
Unescape View File

@ -13,13 +13,13 @@
#include <string> #include <string>
#include <string_view> #include <string_view>
#include "util/format/format.h" #include "ruc/format/format.h"
#include "util/meta/compiler.h" #include "ruc/meta/compiler.h"
#define CRASH() asm volatile("int $0x03"); #define CRASH() asm volatile("int $0x03");
#ifndef NDEBUG #ifndef NDEBUG
#define VERIFY(expr, ...) (static_cast<bool>(expr) ? (void)0 : Util::__assertion_failed(#expr, __FILE__, __LINE__, FUNCTION_MACRO __VA_OPT__(, ) __VA_ARGS__)) #define VERIFY(expr, ...) (static_cast<bool>(expr) ? (void)0 : ruc::__assertion_failed(#expr, __FILE__, __LINE__, FUNCTION_MACRO __VA_OPT__(, ) __VA_ARGS__))
#define VERIFY_NOT_REACHED() VERIFY(false) #define VERIFY_NOT_REACHED() VERIFY(false)
#else #else
#define VERIFY(expr, ...) (static_cast<bool>(expr) ? (void)0 : CRASH() #define VERIFY(expr, ...) (static_cast<bool>(expr) ? (void)0 : CRASH()
@ -27,7 +27,7 @@
#endif #endif
#ifndef NDEBUG #ifndef NDEBUG
namespace Util { namespace ruc {
template<typename... Parameters> template<typename... Parameters>
inline void __assertion_failed(const char* assertion, const char* file, uint32_t line, const char* function, const Parameters&... parameters) inline void __assertion_failed(const char* assertion, const char* file, uint32_t line, const char* function, const Parameters&... parameters)
@ -66,8 +66,8 @@ inline void __assertion_failed(const char* assertion, const char* file, uint32_t
fprintf(stderr, ": "); fprintf(stderr, ": ");
// Cant use the formatting library to print asserts caused by the formatting library // Cant use the formatting library to print asserts caused by the formatting library
std::string_view functionString = function; std::string_view functionString = function;
if (functionString.find("Util::Format::") != std::string_view::npos if (functionString.find("ruc::format::") != std::string_view::npos
&& functionString.find("Util::GenericLexer::") != std::string_view::npos) { && functionString.find("ruc::GenericLexer::") != std::string_view::npos) {
std::string message; std::string message;
formatTo(message, parameters...); formatTo(message, parameters...);
fprintf(stderr, "%s", message.c_str()); fprintf(stderr, "%s", message.c_str());
@ -92,5 +92,5 @@ inline void __assertion_failed(const char* assertion, const char* file, uint32_t
CRASH(); CRASH();
} }
} // namespace Util } // namespace ruc
#endif #endif

0
src/util/meta/compiler.h → src/ruc/meta/compiler.h
Unescape View File

8
src/util/meta/concepts.h → src/ruc/meta/concepts.h
Unescape View File

@ -8,7 +8,7 @@
#include <type_traits> // is_integral_v, floating_point_v #include <type_traits> // is_integral_v, floating_point_v
namespace Util::Concepts { namespace ruc::concepts {
template<class T> template<class T>
concept Integral = std::is_integral_v<T>; concept Integral = std::is_integral_v<T>;
@ -16,7 +16,7 @@ concept Integral = std::is_integral_v<T>;
template<typename T> template<typename T>
concept FloatingPoint = std::is_floating_point_v<T>; concept FloatingPoint = std::is_floating_point_v<T>;
} // namespace Util::Concepts } // namespace ruc::concepts
using Util::Concepts::FloatingPoint; using ruc::concepts::FloatingPoint;
using Util::Concepts::Integral; using ruc::concepts::Integral;

8
src/util/meta/odr.h → src/ruc/meta/odr.h
Unescape View File

@ -6,15 +6,15 @@
#pragma once #pragma once
namespace Util { namespace ruc {
namespace Detail { namespace detail {
// Avoid ODR (One Definition Rule) violations, // Avoid ODR (One Definition Rule) violations,
// variable templates are required to have external linkage // variable templates are required to have external linkage
template<typename T> template<typename T>
constexpr T staticConst {}; constexpr T staticConst {};
} // namespace Detail } // namespace detail
} // namespace Util } // namespace ruc

6
src/util/shell.cpp → src/ruc/shell.cpp
Unescape View File

@ -2,9 +2,9 @@
#include <string> #include <string>
#include <string_view> #include <string_view>
#include "util/shell.h" #include "ruc/shell.h"
namespace Util { namespace ruc {
Shell::Shell() Shell::Shell()
{ {
@ -50,4 +50,4 @@ Shell Shell::operator()(std::string_view command)
return operator()(command.data()); return operator()(command.data());
} }
} // namespace Util } // namespace ruc

4
src/util/shell.h → src/ruc/shell.h
Unescape View File

@ -9,7 +9,7 @@
#include <string> #include <string>
#include <string_view> #include <string_view>
namespace Util { namespace ruc {
class Shell { class Shell {
public: public:
@ -30,4 +30,4 @@ private:
int m_status { 0 }; int m_status { 0 };
}; };
} // namespace Util } // namespace ruc

4
src/util/singleton.h → src/ruc/singleton.h
Unescape View File

@ -8,7 +8,7 @@
#include <cassert> #include <cassert>
namespace Util { namespace ruc {
template<typename T> template<typename T>
class Singleton { class Singleton {
@ -50,4 +50,4 @@ private:
template<typename T> template<typename T>
T* Singleton<T>::s_instance = nullptr; T* Singleton<T>::s_instance = nullptr;
} // namespace Util } // namespace ruc

6
src/util/system.cpp → src/ruc/system.cpp
Unescape View File

@ -11,9 +11,9 @@
#include <unistd.h> // close, dup2, execvp, fork, pipe, read #include <unistd.h> // close, dup2, execvp, fork, pipe, read
#include <vector> #include <vector>
#include "util/system.h" #include "ruc/system.h"
namespace Util { namespace ruc {
System::System() System::System()
{ {
@ -325,4 +325,4 @@ void System::readFromFileDescriptor(int fileDescriptor[2], std::string& output)
close(fileDescriptor[ReadFileDescriptor]); close(fileDescriptor[ReadFileDescriptor]);
} }
} // namespace Util } // namespace ruc

4
src/util/system.h → src/ruc/system.h
Unescape View File

@ -12,7 +12,7 @@
#include <string_view> #include <string_view>
#include <vector> #include <vector>
namespace Util { namespace ruc {
using LineCallback = std::function<void(std::vector<std::string>&)>; using LineCallback = std::function<void(std::vector<std::string>&)>;
@ -65,4 +65,4 @@ private:
int m_status { 0 }; int m_status { 0 };
}; };
} // namespace Util } // namespace ruc

6
src/util/timer.cpp → src/ruc/timer.cpp
Unescape View File

@ -2,9 +2,9 @@
#include <cstdint> // uint64_t #include <cstdint> // uint64_t
#include <cstdio> // printf #include <cstdio> // printf
#include "util/timer.h" #include "ruc/timer.h"
namespace Util { namespace ruc {
Timer::Timer() Timer::Timer()
: m_running(true) : m_running(true)
@ -128,4 +128,4 @@ void Timer::fancyPrint(uint64_t nanoseconds)
} }
} }
} // namespace Util } // namespace ruc

4
src/util/timer.h → src/ruc/timer.h
Unescape View File

@ -9,7 +9,7 @@
#include <chrono> // high_resolution_clock #include <chrono> // high_resolution_clock
#include <cstdint> // uint64_t #include <cstdint> // uint64_t
namespace Util { namespace ruc {
using TimePoint = std::chrono::high_resolution_clock::time_point; using TimePoint = std::chrono::high_resolution_clock::time_point;
@ -48,4 +48,4 @@ private:
TimePoint m_start; TimePoint m_start;
}; };
} // namespace Util } // namespace ruc

15
src/util/json/json.h
Unescape View File

@ -1,15 +0,0 @@
/*
* Copyright (C) 2022 Riyyi
*
* SPDX-License-Identifier: MIT
*/
#pragma once
#include "util/json/value.h"
namespace Util {
using Json = Util::JSON::Value;
} // namespace Util

6
test/macro.h
Unescape View File

@ -20,7 +20,7 @@
if (!(x)) { \ if (!(x)) { \
fprintf(stderr, " \033[31;1mFAIL:\033[0m %s:%d: EXPECT(%s) failed\n", \ fprintf(stderr, " \033[31;1mFAIL:\033[0m %s:%d: EXPECT(%s) failed\n", \
__FILE__, __LINE__, #x); \ __FILE__, __LINE__, #x); \
Test::TestSuite::the().currentTestCaseFailed(); \ test::TestSuite::the().currentTestCaseFailed(); \
result; \ result; \
} }
@ -41,7 +41,7 @@
std::cerr << " \033[31;1mFAIL:\033[0m " << __FILE__ << ":" << __LINE__ \ std::cerr << " \033[31;1mFAIL:\033[0m " << __FILE__ << ":" << __LINE__ \
<< ": EXPECT_EQ(" << #a << ", " << #b ") failed with" \ << ": EXPECT_EQ(" << #a << ", " << #b ") failed with" \
<< " lhs='" << a << "' and rhs='" << b << "'" << std::endl; \ << " lhs='" << a << "' and rhs='" << b << "'" << std::endl; \
Test::TestSuite::the().currentTestCaseFailed(); \ test::TestSuite::the().currentTestCaseFailed(); \
result; \ result; \
} }
@ -62,7 +62,7 @@
std::cerr << " \033[31;1mFAIL:\033[0m " << __FILE__ << ":" << __LINE__ \ std::cerr << " \033[31;1mFAIL:\033[0m " << __FILE__ << ":" << __LINE__ \
<< ": EXPECT_NE(" << #a << ", " << #b ") failed with" \ << ": EXPECT_NE(" << #a << ", " << #b ") failed with" \
<< " lhs='" << a << "' and rhs='" << b << "'" << std::endl; \ << " lhs='" << a << "' and rhs='" << b << "'" << std::endl; \
Test::TestSuite::the().currentTestCaseFailed(); \ test::TestSuite::the().currentTestCaseFailed(); \
result; \ result; \
} }

2
test/main.cpp
Unescape View File

@ -2,7 +2,7 @@
int main(int, const char*[]) int main(int, const char*[])
{ {
Test::TestSuite::the().run(); test::TestSuite::the().run();
return 0; return 0;
} }

6
test/testcase.h
Unescape View File

@ -13,14 +13,14 @@
__TEST_CASE_STRUCT(x) \ __TEST_CASE_STRUCT(x) \
() \ () \
{ \ { \
Test::TestSuite::the().addCase( \ test::TestSuite::the().addCase( \
{ #x, __TEST_CASE_FUNCTION(x) }); \ { #x, __TEST_CASE_FUNCTION(x) }); \
} \ } \
}; \ }; \
static struct __TEST_CASE_STRUCT(x) __TEST_CASE_STRUCT(x); \ static struct __TEST_CASE_STRUCT(x) __TEST_CASE_STRUCT(x); \
static void __TEST_CASE_FUNCTION(x)() static void __TEST_CASE_FUNCTION(x)()
namespace Test { namespace test {
using TestFunction = std::function<void()>; using TestFunction = std::function<void()>;
@ -40,6 +40,6 @@ private:
TestFunction m_function; TestFunction m_function;
}; };
} // namespace Test } // namespace test
#endif // TEST_CASE_H #endif // TEST_CASE_H

14
test/testsuite.cpp
Unescape View File

@ -3,10 +3,10 @@
#include <string> #include <string>
#include <vector> #include <vector>
#include "ruc/timer.h"
#include "testsuite.h" #include "testsuite.h"
#include "util/timer.h"
namespace Test { namespace test {
TestSuite::TestSuite(s) TestSuite::TestSuite(s)
{ {
@ -32,7 +32,7 @@ void TestSuite::run()
printf("\n"); printf("\n");
printf("---- Running %zu Test Cases ----\n", m_cases.size()); printf("---- Running %zu Test Cases ----\n", m_cases.size());
Util::Timer totalTimer; ruc::Timer totalTimer;
size_t caseFailedCount = 0; size_t caseFailedCount = 0;
for (size_t i = 0; i < m_cases.size(); ++i) { for (size_t i = 0; i < m_cases.size(); ++i) {
@ -40,7 +40,7 @@ void TestSuite::run()
printf(" START %s (%zu/%zu)\n", m_cases.at(i).name(), i + 1, m_cases.size()); printf(" START %s (%zu/%zu)\n", m_cases.at(i).name(), i + 1, m_cases.size());
m_currentTestCasePassed = true; m_currentTestCasePassed = true;
Util::Timer caseTimer; ruc::Timer caseTimer;
m_cases.at(i).function()(); m_cases.at(i).function()();
double elapsed = caseTimer.elapsedNanoseconds(); double elapsed = caseTimer.elapsedNanoseconds();
@ -58,7 +58,7 @@ void TestSuite::run()
} }
printf("%s %s %s(", state.c_str(), m_cases.at(i).name(), escapeGrey); printf("%s %s %s(", state.c_str(), m_cases.at(i).name(), escapeGrey);
Util::Timer::fancyPrint(elapsed); ruc::Timer::fancyPrint(elapsed);
printf(")%s\n", escapeReset); printf(")%s\n", escapeReset);
} }
@ -69,8 +69,8 @@ void TestSuite::run()
m_cases.size()); m_cases.size());
printf("Time: "); printf("Time: ");
Util::Timer::fancyPrint(totalTimer.elapsedNanoseconds()); ruc::Timer::fancyPrint(totalTimer.elapsedNanoseconds());
printf("\n"); printf("\n");
} }
} // namespace Test } // namespace test

8
test/testsuite.h
Unescape View File

@ -4,12 +4,12 @@
#include <cstdio> // FILE #include <cstdio> // FILE
#include <vector> #include <vector>
#include "ruc/singleton.h"
#include "testcase.h" #include "testcase.h"
#include "util/singleton.h"
namespace Test { namespace test {
class TestSuite final : public Util::Singleton<TestSuite> { class TestSuite final : public ruc::Singleton<TestSuite> {
public: public:
TestSuite(s); TestSuite(s);
virtual ~TestSuite(); virtual ~TestSuite();
@ -31,6 +31,6 @@ private:
std::vector<TestCase> m_cases; std::vector<TestCase> m_cases;
}; };
} // namespace Test } // namespace test
#endif // TEST_SUITE_H #endif // TEST_SUITE_H

180
test/unit/testutilargparser.cpp
Unescape View File

@ -3,15 +3,15 @@
#include <vector> #include <vector>
#include "macro.h" #include "macro.h"
#include "ruc/argparser.h"
#include "testcase.h" #include "testcase.h"
#include "testsuite.h" #include "testsuite.h"
#include "util/argparser.h"
bool runParser(std::vector<const char*> arguments, std::function<void(Util::ArgParser&)> initializer = {}) bool runParser(std::vector<const char*> arguments, std::function<void(ruc::ArgParser&)> initializer = {})
{ {
stdout = Test::TestSuite::the().outputNull(); stdout = test::TestSuite::the().outputNull();
Util::ArgParser parser; ruc::ArgParser parser;
if (initializer) { if (initializer) {
initializer(parser); initializer(parser);
} }
@ -19,7 +19,7 @@ bool runParser(std::vector<const char*> arguments, std::function<void(Util::ArgP
arguments.insert(arguments.begin(), "app"); arguments.insert(arguments.begin(), "app");
auto result = parser.parse(arguments.size(), arguments.data()); auto result = parser.parse(arguments.size(), arguments.data());
stdout = Test::TestSuite::the().outputStd(); stdout = test::TestSuite::the().outputStd();
return result; return result;
} }
@ -55,7 +55,7 @@ TEST_CASE(RequiredStringArguments)
// Single required string argument // Single required string argument
std::string stringArg1 = ""; std::string stringArg1 = "";
auto result = runParser({ "my-required-argument" }, [&](auto& parser) { auto result = runParser({ "my-required-argument" }, [&](auto& parser) {
parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(stringArg1, "my-required-argument"); EXPECT_EQ(stringArg1, "my-required-argument");
@ -63,7 +63,7 @@ TEST_CASE(RequiredStringArguments)
// Single required string argument, not given // Single required string argument, not given
stringArg1 = ""; stringArg1 = "";
result = runParser({}, [&](auto& parser) { result = runParser({}, [&](auto& parser) {
parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
}); });
EXPECT_EQ(result, false); EXPECT_EQ(result, false);
EXPECT_EQ(stringArg1, ""); EXPECT_EQ(stringArg1, "");
@ -73,9 +73,9 @@ TEST_CASE(RequiredStringArguments)
std::string stringArg2 = ""; std::string stringArg2 = "";
std::string stringArg3 = ""; std::string stringArg3 = "";
result = runParser({ "my", "required", "argument" }, [&](auto& parser) { result = runParser({ "my", "required", "argument" }, [&](auto& parser) {
parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
parser.addArgument(stringArg2, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addArgument(stringArg2, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
parser.addArgument(stringArg3, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addArgument(stringArg3, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(stringArg1, "my"); EXPECT_EQ(stringArg1, "my");
@ -87,9 +87,9 @@ TEST_CASE(RequiredStringArguments)
stringArg2 = ""; stringArg2 = "";
stringArg3 = ""; stringArg3 = "";
result = runParser({}, [&](auto& parser) { result = runParser({}, [&](auto& parser) {
parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
parser.addArgument(stringArg2, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addArgument(stringArg2, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
parser.addArgument(stringArg3, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addArgument(stringArg3, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
}); });
EXPECT_EQ(result, false); EXPECT_EQ(result, false);
EXPECT_EQ(stringArg1, ""); EXPECT_EQ(stringArg1, "");
@ -104,7 +104,7 @@ TEST_CASE(OptionalStringArguments)
// Single optional string argument // Single optional string argument
std::string stringArg1 = ""; std::string stringArg1 = "";
auto result = runParser({ "my-optional-argument" }, [&](auto& parser) { auto result = runParser({ "my-optional-argument" }, [&](auto& parser) {
parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional); parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(stringArg1, "my-optional-argument"); EXPECT_EQ(stringArg1, "my-optional-argument");
@ -112,7 +112,7 @@ TEST_CASE(OptionalStringArguments)
// Single optional string argument, not given // Single optional string argument, not given
stringArg1 = ""; stringArg1 = "";
result = runParser({}, [&](auto& parser) { result = runParser({}, [&](auto& parser) {
parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional); parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(stringArg1, ""); EXPECT_EQ(stringArg1, "");
@ -122,9 +122,9 @@ TEST_CASE(OptionalStringArguments)
std::string stringArg2 = ""; std::string stringArg2 = "";
std::string stringArg3 = ""; std::string stringArg3 = "";
result = runParser({ "my", "optional", "argument" }, [&](auto& parser) { result = runParser({ "my", "optional", "argument" }, [&](auto& parser) {
parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional); parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
parser.addArgument(stringArg2, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional); parser.addArgument(stringArg2, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
parser.addArgument(stringArg3, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional); parser.addArgument(stringArg3, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(stringArg1, "my"); EXPECT_EQ(stringArg1, "my");
@ -136,9 +136,9 @@ TEST_CASE(OptionalStringArguments)
stringArg2 = ""; stringArg2 = "";
stringArg3 = ""; stringArg3 = "";
result = runParser({}, [&](auto& parser) { result = runParser({}, [&](auto& parser) {
parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional); parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
parser.addArgument(stringArg2, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional); parser.addArgument(stringArg2, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
parser.addArgument(stringArg3, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional); parser.addArgument(stringArg3, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(stringArg1, ""); EXPECT_EQ(stringArg1, "");
@ -153,7 +153,7 @@ TEST_CASE(NonRequiredStringArguments)
// Single non-required string argument // Single non-required string argument
std::string stringArg1 = ""; std::string stringArg1 = "";
auto result = runParser({ "my-non-required-argument" }, [&](auto& parser) { auto result = runParser({ "my-non-required-argument" }, [&](auto& parser) {
parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::No); parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(stringArg1, "my-non-required-argument"); EXPECT_EQ(stringArg1, "my-non-required-argument");
@ -161,7 +161,7 @@ TEST_CASE(NonRequiredStringArguments)
// Single non-required string argument, not given // Single non-required string argument, not given
stringArg1 = ""; stringArg1 = "";
result = runParser({}, [&](auto& parser) { result = runParser({}, [&](auto& parser) {
parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::No); parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(stringArg1, ""); EXPECT_EQ(stringArg1, "");
@ -171,9 +171,9 @@ TEST_CASE(NonRequiredStringArguments)
std::string stringArg2 = ""; std::string stringArg2 = "";
std::string stringArg3 = ""; std::string stringArg3 = "";
result = runParser({ "my", "non-required", "argument" }, [&](auto& parser) { result = runParser({ "my", "non-required", "argument" }, [&](auto& parser) {
parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::No); parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
parser.addArgument(stringArg2, nullptr, nullptr, nullptr, Util::ArgParser::Required::No); parser.addArgument(stringArg2, nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
parser.addArgument(stringArg3, nullptr, nullptr, nullptr, Util::ArgParser::Required::No); parser.addArgument(stringArg3, nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(stringArg1, "my"); EXPECT_EQ(stringArg1, "my");
@ -185,9 +185,9 @@ TEST_CASE(NonRequiredStringArguments)
stringArg2 = ""; stringArg2 = "";
stringArg3 = ""; stringArg3 = "";
result = runParser({}, [&](auto& parser) { result = runParser({}, [&](auto& parser) {
parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::No); parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
parser.addArgument(stringArg2, nullptr, nullptr, nullptr, Util::ArgParser::Required::No); parser.addArgument(stringArg2, nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
parser.addArgument(stringArg3, nullptr, nullptr, nullptr, Util::ArgParser::Required::No); parser.addArgument(stringArg3, nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(stringArg1, ""); EXPECT_EQ(stringArg1, "");
@ -202,7 +202,7 @@ TEST_CASE(VectorStringArguments)
// Required vector string argument, not given // Required vector string argument, not given
std::vector<std::string> vectorArg1 = {}; std::vector<std::string> vectorArg1 = {};
auto result = runParser({}, [&](auto& parser) { auto result = runParser({}, [&](auto& parser) {
parser.addArgument(vectorArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addArgument(vectorArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
}); });
EXPECT_EQ(result, false); EXPECT_EQ(result, false);
EXPECT_EQ(vectorArg1.size(), 0); EXPECT_EQ(vectorArg1.size(), 0);
@ -210,7 +210,7 @@ TEST_CASE(VectorStringArguments)
// Required vector string argument, one given // Required vector string argument, one given
vectorArg1 = {}; vectorArg1 = {};
result = runParser({ "foo" }, [&](auto& parser) { result = runParser({ "foo" }, [&](auto& parser) {
parser.addArgument(vectorArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addArgument(vectorArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(vectorArg1.size(), 1); EXPECT_EQ(vectorArg1.size(), 1);
@ -221,7 +221,7 @@ TEST_CASE(VectorStringArguments)
// Required vector string argument, two given // Required vector string argument, two given
vectorArg1 = {}; vectorArg1 = {};
result = runParser({ "hello", "world" }, [&](auto& parser) { result = runParser({ "hello", "world" }, [&](auto& parser) {
parser.addArgument(vectorArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addArgument(vectorArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(vectorArg1.size(), 2); EXPECT_EQ(vectorArg1.size(), 2);
@ -240,9 +240,9 @@ TEST_CASE(CombinationOfNonRequiredArguments)
double doubleArg1 = 0; double doubleArg1 = 0;
std::string stringArg1 = ""; std::string stringArg1 = "";
auto result = runParser({ "optional argument" }, [&](auto& parser) { auto result = runParser({ "optional argument" }, [&](auto& parser) {
parser.addArgument(intArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional); parser.addArgument(intArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
parser.addArgument(doubleArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional); parser.addArgument(doubleArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional); parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(intArg1, 0); EXPECT_EQ(intArg1, 0);
@ -254,9 +254,9 @@ TEST_CASE(CombinationOfNonRequiredArguments)
doubleArg1 = 0; doubleArg1 = 0;
stringArg1 = ""; stringArg1 = "";
result = runParser({ "999.999", "optional argument" }, [&](auto& parser) { result = runParser({ "999.999", "optional argument" }, [&](auto& parser) {
parser.addArgument(intArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional); parser.addArgument(intArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
parser.addArgument(doubleArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional); parser.addArgument(doubleArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional); parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(intArg1, 0); EXPECT_EQ(intArg1, 0);
@ -268,9 +268,9 @@ TEST_CASE(CombinationOfNonRequiredArguments)
doubleArg1 = 0; doubleArg1 = 0;
stringArg1 = ""; stringArg1 = "";
result = runParser({ "999,999", "optional argument" }, [&](auto& parser) { result = runParser({ "999,999", "optional argument" }, [&](auto& parser) {
parser.addArgument(intArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional); parser.addArgument(intArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
parser.addArgument(doubleArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional); parser.addArgument(doubleArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional); parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
}); });
EXPECT_EQ(result, false); EXPECT_EQ(result, false);
EXPECT_EQ(intArg1, 0); EXPECT_EQ(intArg1, 0);
@ -282,9 +282,9 @@ TEST_CASE(CombinationOfNonRequiredArguments)
intArg1 = 0; intArg1 = 0;
doubleArg1 = 0; doubleArg1 = 0;
result = runParser({ "999.999", "optional argument" }, [&](auto& parser) { result = runParser({ "999.999", "optional argument" }, [&](auto& parser) {
parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional); parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
parser.addArgument(intArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional); parser.addArgument(intArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
parser.addArgument(doubleArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional); parser.addArgument(doubleArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
}); });
EXPECT_EQ(result, false); EXPECT_EQ(result, false);
EXPECT_EQ(stringArg1, "999.999"); EXPECT_EQ(stringArg1, "999.999");
@ -360,7 +360,7 @@ TEST_CASE(SingleRequiredStringOptions)
// Single required string short option // Single required string short option
std::string stringOpt1 = ""; std::string stringOpt1 = "";
auto result = runParser({ "-s", "my-required-argument" }, [&](auto& parser) { auto result = runParser({ "-s", "my-required-argument" }, [&](auto& parser) {
parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(stringOpt1, "my-required-argument"); EXPECT_EQ(stringOpt1, "my-required-argument");
@ -368,7 +368,7 @@ TEST_CASE(SingleRequiredStringOptions)
// Single required string short option, given directly after // Single required string short option, given directly after
stringOpt1 = ""; stringOpt1 = "";
result = runParser({ "-smy-required-argument" }, [&](auto& parser) { result = runParser({ "-smy-required-argument" }, [&](auto& parser) {
parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(stringOpt1, "my-required-argument"); EXPECT_EQ(stringOpt1, "my-required-argument");
@ -376,7 +376,7 @@ TEST_CASE(SingleRequiredStringOptions)
// Single required string short option, empty given // Single required string short option, empty given
stringOpt1 = ""; stringOpt1 = "";
result = runParser({ "-s" }, [&](auto& parser) { result = runParser({ "-s" }, [&](auto& parser) {
parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
}); });
EXPECT_EQ(result, false); EXPECT_EQ(result, false);
EXPECT_EQ(stringOpt1, ""); EXPECT_EQ(stringOpt1, "");
@ -384,7 +384,7 @@ TEST_CASE(SingleRequiredStringOptions)
// Single required string short option, not given // Single required string short option, not given
stringOpt1 = ""; stringOpt1 = "";
result = runParser({}, [&](auto& parser) { result = runParser({}, [&](auto& parser) {
parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(stringOpt1, ""); EXPECT_EQ(stringOpt1, "");
@ -392,7 +392,7 @@ TEST_CASE(SingleRequiredStringOptions)
// Single required string long option // Single required string long option
stringOpt1 = ""; stringOpt1 = "";
result = runParser({ "--string", "my-required-argument" }, [&](auto& parser) { result = runParser({ "--string", "my-required-argument" }, [&](auto& parser) {
parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(stringOpt1, "my-required-argument"); EXPECT_EQ(stringOpt1, "my-required-argument");
@ -400,7 +400,7 @@ TEST_CASE(SingleRequiredStringOptions)
// Single required string long option, given directly after // Single required string long option, given directly after
stringOpt1 = ""; stringOpt1 = "";
result = runParser({ "--string=my-required-argument" }, [&](auto& parser) { result = runParser({ "--string=my-required-argument" }, [&](auto& parser) {
parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(stringOpt1, "my-required-argument"); EXPECT_EQ(stringOpt1, "my-required-argument");
@ -408,7 +408,7 @@ TEST_CASE(SingleRequiredStringOptions)
// Single required string long option, empty given // Single required string long option, empty given
stringOpt1 = ""; stringOpt1 = "";
result = runParser({ "--string" }, [&](auto& parser) { result = runParser({ "--string" }, [&](auto& parser) {
parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
}); });
EXPECT_EQ(result, false); EXPECT_EQ(result, false);
EXPECT_EQ(stringOpt1, ""); EXPECT_EQ(stringOpt1, "");
@ -416,7 +416,7 @@ TEST_CASE(SingleRequiredStringOptions)
// Single required string long option, not given // Single required string long option, not given
stringOpt1 = ""; stringOpt1 = "";
result = runParser({}, [&](auto& parser) { result = runParser({}, [&](auto& parser) {
parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(stringOpt1, ""); EXPECT_EQ(stringOpt1, "");
@ -430,8 +430,8 @@ TEST_CASE(SingleOptionalStringOptions)
std::string stringOpt1 = ""; std::string stringOpt1 = "";
std::string stringArg1 = ""; std::string stringArg1 = "";
auto result = runParser({ "-s", "my-optional-argument" }, [&](auto& parser) { auto result = runParser({ "-s", "my-optional-argument" }, [&](auto& parser) {
parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional); parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::No); parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(stringOpt1, ""); EXPECT_EQ(stringOpt1, "");
@ -440,7 +440,7 @@ TEST_CASE(SingleOptionalStringOptions)
// Single optional string short option, given directly after // Single optional string short option, given directly after
stringOpt1 = ""; stringOpt1 = "";
result = runParser({ "-smy-optional-argument" }, [&](auto& parser) { result = runParser({ "-smy-optional-argument" }, [&](auto& parser) {
parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional); parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(stringOpt1, "my-optional-argument"); EXPECT_EQ(stringOpt1, "my-optional-argument");
@ -448,7 +448,7 @@ TEST_CASE(SingleOptionalStringOptions)
// Single optional string short option, empty given // Single optional string short option, empty given
stringOpt1 = ""; stringOpt1 = "";
result = runParser({ "-s" }, [&](auto& parser) { result = runParser({ "-s" }, [&](auto& parser) {
parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional); parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(stringOpt1, ""); EXPECT_EQ(stringOpt1, "");
@ -456,7 +456,7 @@ TEST_CASE(SingleOptionalStringOptions)
// Single optional string short option, not given // Single optional string short option, not given
stringOpt1 = ""; stringOpt1 = "";
result = runParser({}, [&](auto& parser) { result = runParser({}, [&](auto& parser) {
parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional); parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(stringOpt1, ""); EXPECT_EQ(stringOpt1, "");
@ -465,8 +465,8 @@ TEST_CASE(SingleOptionalStringOptions)
stringOpt1 = ""; stringOpt1 = "";
stringArg1 = ""; stringArg1 = "";
result = runParser({ "--string", "my-optional-argument" }, [&](auto& parser) { result = runParser({ "--string", "my-optional-argument" }, [&](auto& parser) {
parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional); parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::No); parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(stringOpt1, ""); EXPECT_EQ(stringOpt1, "");
@ -475,7 +475,7 @@ TEST_CASE(SingleOptionalStringOptions)
// Single optional string long option, given directly after // Single optional string long option, given directly after
stringOpt1 = ""; stringOpt1 = "";
result = runParser({ "--string=my-optional-argument" }, [&](auto& parser) { result = runParser({ "--string=my-optional-argument" }, [&](auto& parser) {
parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional); parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(stringOpt1, "my-optional-argument"); EXPECT_EQ(stringOpt1, "my-optional-argument");
@ -483,7 +483,7 @@ TEST_CASE(SingleOptionalStringOptions)
// Single optional string long option, empty given // Single optional string long option, empty given
stringOpt1 = ""; stringOpt1 = "";
result = runParser({ "--string" }, [&](auto& parser) { result = runParser({ "--string" }, [&](auto& parser) {
parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional); parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(stringOpt1, ""); EXPECT_EQ(stringOpt1, "");
@ -491,7 +491,7 @@ TEST_CASE(SingleOptionalStringOptions)
// Single optional string long option, not given // Single optional string long option, not given
stringOpt1 = ""; stringOpt1 = "";
result = runParser({}, [&](auto& parser) { result = runParser({}, [&](auto& parser) {
parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, Util::ArgParser::Required::Optional); parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, ruc::ArgParser::Required::Optional);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(stringOpt1, ""); EXPECT_EQ(stringOpt1, "");
@ -505,8 +505,8 @@ TEST_CASE(SingleNonRequiredStringOptions)
std::string stringOpt1 = ""; std::string stringOpt1 = "";
std::string stringArg1 = ""; std::string stringArg1 = "";
auto result = runParser({ "-s", "my-non-required-argument" }, [&](auto& parser) { auto result = runParser({ "-s", "my-non-required-argument" }, [&](auto& parser) {
parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::No); parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::No); parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(stringOpt1, ""); EXPECT_EQ(stringOpt1, "");
@ -515,7 +515,7 @@ TEST_CASE(SingleNonRequiredStringOptions)
// Single non-required string short option, given directly after // Single non-required string short option, given directly after
stringOpt1 = ""; stringOpt1 = "";
result = runParser({ "-smy-non-required-argument" }, [&](auto& parser) { result = runParser({ "-smy-non-required-argument" }, [&](auto& parser) {
parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::No); parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
}); });
EXPECT_EQ(result, false); EXPECT_EQ(result, false);
EXPECT_EQ(stringOpt1, ""); EXPECT_EQ(stringOpt1, "");
@ -523,7 +523,7 @@ TEST_CASE(SingleNonRequiredStringOptions)
// Single non-required string short option, empty given // Single non-required string short option, empty given
stringOpt1 = ""; stringOpt1 = "";
result = runParser({ "-s" }, [&](auto& parser) { result = runParser({ "-s" }, [&](auto& parser) {
parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::No); parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(stringOpt1, ""); EXPECT_EQ(stringOpt1, "");
@ -531,7 +531,7 @@ TEST_CASE(SingleNonRequiredStringOptions)
// Single non-required string short option, not given // Single non-required string short option, not given
stringOpt1 = ""; stringOpt1 = "";
result = runParser({}, [&](auto& parser) { result = runParser({}, [&](auto& parser) {
parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::No); parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(stringOpt1, ""); EXPECT_EQ(stringOpt1, "");
@ -540,8 +540,8 @@ TEST_CASE(SingleNonRequiredStringOptions)
stringOpt1 = ""; stringOpt1 = "";
stringArg1 = ""; stringArg1 = "";
result = runParser({ "--string", "my-non-required-argument" }, [&](auto& parser) { result = runParser({ "--string", "my-non-required-argument" }, [&](auto& parser) {
parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, Util::ArgParser::Required::No); parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
parser.addArgument(stringArg1, nullptr, nullptr, nullptr, Util::ArgParser::Required::No); parser.addArgument(stringArg1, nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(stringOpt1, ""); EXPECT_EQ(stringOpt1, "");
@ -550,7 +550,7 @@ TEST_CASE(SingleNonRequiredStringOptions)
// Single non-required string long option, given directly after // Single non-required string long option, given directly after
stringOpt1 = ""; stringOpt1 = "";
result = runParser({ "--string=my-non-required-argument" }, [&](auto& parser) { result = runParser({ "--string=my-non-required-argument" }, [&](auto& parser) {
parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, Util::ArgParser::Required::No); parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
}); });
EXPECT_EQ(result, false); EXPECT_EQ(result, false);
EXPECT_EQ(stringOpt1, ""); EXPECT_EQ(stringOpt1, "");
@ -558,7 +558,7 @@ TEST_CASE(SingleNonRequiredStringOptions)
// Single non-required string long option, empty given // Single non-required string long option, empty given
stringOpt1 = ""; stringOpt1 = "";
result = runParser({ "--string" }, [&](auto& parser) { result = runParser({ "--string" }, [&](auto& parser) {
parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, Util::ArgParser::Required::No); parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(stringOpt1, ""); EXPECT_EQ(stringOpt1, "");
@ -566,7 +566,7 @@ TEST_CASE(SingleNonRequiredStringOptions)
// Single non-required string long option, not given // Single non-required string long option, not given
stringOpt1 = ""; stringOpt1 = "";
result = runParser({}, [&](auto& parser) { result = runParser({}, [&](auto& parser) {
parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, Util::ArgParser::Required::No); parser.addOption(stringOpt1, '\0', "string", nullptr, nullptr, nullptr, ruc::ArgParser::Required::No);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(stringOpt1, ""); EXPECT_EQ(stringOpt1, "");
@ -579,7 +579,7 @@ TEST_CASE(NumberOptions)
// Required int short option // Required int short option
int intOpt1 = 0; int intOpt1 = 0;
auto result = runParser({ "-i", "2147483647" }, [&](auto& parser) { auto result = runParser({ "-i", "2147483647" }, [&](auto& parser) {
parser.addOption(intOpt1, 'i', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addOption(intOpt1, 'i', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(intOpt1, 2147483647); EXPECT_EQ(intOpt1, 2147483647);
@ -587,7 +587,7 @@ TEST_CASE(NumberOptions)
// Required int short option, overflown value given // Required int short option, overflown value given
intOpt1 = 0; intOpt1 = 0;
result = runParser({ "-i", "2147483648" }, [&](auto& parser) { result = runParser({ "-i", "2147483648" }, [&](auto& parser) {
parser.addOption(intOpt1, 'i', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addOption(intOpt1, 'i', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
}); });
EXPECT_EQ(result, false); EXPECT_EQ(result, false);
EXPECT_EQ(intOpt1, 0); EXPECT_EQ(intOpt1, 0);
@ -595,7 +595,7 @@ TEST_CASE(NumberOptions)
// Required int short option, empty given // Required int short option, empty given
intOpt1 = 0; intOpt1 = 0;
result = runParser({ "-i" }, [&](auto& parser) { result = runParser({ "-i" }, [&](auto& parser) {
parser.addOption(intOpt1, 'i', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addOption(intOpt1, 'i', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
}); });
EXPECT_EQ(result, false); EXPECT_EQ(result, false);
EXPECT_EQ(intOpt1, 0); EXPECT_EQ(intOpt1, 0);
@ -603,7 +603,7 @@ TEST_CASE(NumberOptions)
// Required unsigned int short option // Required unsigned int short option
unsigned int unsignedIntOpt1 = 0; unsigned int unsignedIntOpt1 = 0;
result = runParser({ "-u", "4294967295" }, [&](auto& parser) { result = runParser({ "-u", "4294967295" }, [&](auto& parser) {
parser.addOption(unsignedIntOpt1, 'u', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addOption(unsignedIntOpt1, 'u', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(unsignedIntOpt1, 4294967295); EXPECT_EQ(unsignedIntOpt1, 4294967295);
@ -611,7 +611,7 @@ TEST_CASE(NumberOptions)
// Required unsigned int short option, overflown value given // Required unsigned int short option, overflown value given
unsignedIntOpt1 = 0; unsignedIntOpt1 = 0;
result = runParser({ "-u", "4294967296" }, [&](auto& parser) { result = runParser({ "-u", "4294967296" }, [&](auto& parser) {
parser.addOption(unsignedIntOpt1, 'u', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addOption(unsignedIntOpt1, 'u', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
}); });
EXPECT_EQ(result, false); EXPECT_EQ(result, false);
EXPECT_EQ(unsignedIntOpt1, 0); EXPECT_EQ(unsignedIntOpt1, 0);
@ -619,7 +619,7 @@ TEST_CASE(NumberOptions)
// Required unsigned int short option, empty given // Required unsigned int short option, empty given
unsignedIntOpt1 = 0; unsignedIntOpt1 = 0;
result = runParser({ "-u" }, [&](auto& parser) { result = runParser({ "-u" }, [&](auto& parser) {
parser.addOption(unsignedIntOpt1, 'u', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addOption(unsignedIntOpt1, 'u', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
}); });
EXPECT_EQ(result, false); EXPECT_EQ(result, false);
EXPECT_EQ(unsignedIntOpt1, 0); EXPECT_EQ(unsignedIntOpt1, 0);
@ -627,7 +627,7 @@ TEST_CASE(NumberOptions)
// Required double short option // Required double short option
double doubleOpt1 = 0; double doubleOpt1 = 0;
result = runParser({ "-d", "999.999" }, [&](auto& parser) { result = runParser({ "-d", "999.999" }, [&](auto& parser) {
parser.addOption(doubleOpt1, 'd', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addOption(doubleOpt1, 'd', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(doubleOpt1, 999.999); EXPECT_EQ(doubleOpt1, 999.999);
@ -635,7 +635,7 @@ TEST_CASE(NumberOptions)
// Required double short option, empty given // Required double short option, empty given
doubleOpt1 = 0; doubleOpt1 = 0;
result = runParser({ "-d" }, [&](auto& parser) { result = runParser({ "-d" }, [&](auto& parser) {
parser.addOption(doubleOpt1, 'd', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addOption(doubleOpt1, 'd', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
}); });
EXPECT_EQ(result, false); EXPECT_EQ(result, false);
EXPECT_EQ(doubleOpt1, 0); EXPECT_EQ(doubleOpt1, 0);
@ -648,7 +648,7 @@ TEST_CASE(VectorStringOptions)
// Required vector string short option, not given // Required vector string short option, not given
std::vector<std::string> vectorOpt1 = {}; std::vector<std::string> vectorOpt1 = {};
auto result = runParser({}, [&](auto& parser) { auto result = runParser({}, [&](auto& parser) {
parser.addOption(vectorOpt1, 'v', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addOption(vectorOpt1, 'v', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(vectorOpt1.size(), 0); EXPECT_EQ(vectorOpt1.size(), 0);
@ -656,7 +656,7 @@ TEST_CASE(VectorStringOptions)
// Required vector string short option, empty given // Required vector string short option, empty given
vectorOpt1 = {}; vectorOpt1 = {};
result = runParser({ "-v" }, [&](auto& parser) { result = runParser({ "-v" }, [&](auto& parser) {
parser.addOption(vectorOpt1, 'v', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addOption(vectorOpt1, 'v', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
}); });
EXPECT_EQ(result, false); EXPECT_EQ(result, false);
EXPECT_EQ(vectorOpt1.size(), 0); EXPECT_EQ(vectorOpt1.size(), 0);
@ -664,7 +664,7 @@ TEST_CASE(VectorStringOptions)
// Required vector string short option, one given // Required vector string short option, one given
vectorOpt1 = {}; vectorOpt1 = {};
result = runParser({ "-v", "a vector argument!" }, [&](auto& parser) { result = runParser({ "-v", "a vector argument!" }, [&](auto& parser) {
parser.addOption(vectorOpt1, 'v', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addOption(vectorOpt1, 'v', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(vectorOpt1.size(), 1); EXPECT_EQ(vectorOpt1.size(), 1);
@ -675,7 +675,7 @@ TEST_CASE(VectorStringOptions)
// Required vector string short option, two given // Required vector string short option, two given
vectorOpt1 = {}; vectorOpt1 = {};
result = runParser({ "-v", "hello", "-v", "world" }, [&](auto& parser) { result = runParser({ "-v", "hello", "-v", "world" }, [&](auto& parser) {
parser.addOption(vectorOpt1, 'v', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addOption(vectorOpt1, 'v', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(vectorOpt1.size(), 2); EXPECT_EQ(vectorOpt1.size(), 2);
@ -687,7 +687,7 @@ TEST_CASE(VectorStringOptions)
// Required vector string short option, two given directly after // Required vector string short option, two given directly after
vectorOpt1 = {}; vectorOpt1 = {};
result = runParser({ "-vhello", "-vworld" }, [&](auto& parser) { result = runParser({ "-vhello", "-vworld" }, [&](auto& parser) {
parser.addOption(vectorOpt1, 'v', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addOption(vectorOpt1, 'v', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(vectorOpt1.size(), 2); EXPECT_EQ(vectorOpt1.size(), 2);
@ -699,7 +699,7 @@ TEST_CASE(VectorStringOptions)
// Required vector string long option, empty given // Required vector string long option, empty given
vectorOpt1 = {}; vectorOpt1 = {};
result = runParser({ "--vector" }, [&](auto& parser) { result = runParser({ "--vector" }, [&](auto& parser) {
parser.addOption(vectorOpt1, '\0', "vector", nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addOption(vectorOpt1, '\0', "vector", nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
}); });
EXPECT_EQ(result, false); EXPECT_EQ(result, false);
EXPECT_EQ(vectorOpt1.size(), 0); EXPECT_EQ(vectorOpt1.size(), 0);
@ -707,7 +707,7 @@ TEST_CASE(VectorStringOptions)
// Required vector string long option, one given // Required vector string long option, one given
vectorOpt1 = {}; vectorOpt1 = {};
result = runParser({ "--vector", "a vector argument!" }, [&](auto& parser) { result = runParser({ "--vector", "a vector argument!" }, [&](auto& parser) {
parser.addOption(vectorOpt1, '\0', "vector", nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addOption(vectorOpt1, '\0', "vector", nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(vectorOpt1.size(), 1); EXPECT_EQ(vectorOpt1.size(), 1);
@ -718,7 +718,7 @@ TEST_CASE(VectorStringOptions)
// Required vector string long option, two given // Required vector string long option, two given
vectorOpt1 = {}; vectorOpt1 = {};
result = runParser({ "--vector", "hello", "--vector", "world" }, [&](auto& parser) { result = runParser({ "--vector", "hello", "--vector", "world" }, [&](auto& parser) {
parser.addOption(vectorOpt1, '\0', "vector", nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addOption(vectorOpt1, '\0', "vector", nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(vectorOpt1.size(), 2); EXPECT_EQ(vectorOpt1.size(), 2);
@ -730,7 +730,7 @@ TEST_CASE(VectorStringOptions)
// Required vector string long option, two given directly after // Required vector string long option, two given directly after
vectorOpt1 = {}; vectorOpt1 = {};
result = runParser({ "--vector=hello", "--vector=world" }, [&](auto& parser) { result = runParser({ "--vector=hello", "--vector=world" }, [&](auto& parser) {
parser.addOption(vectorOpt1, '\0', "vector", nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addOption(vectorOpt1, '\0', "vector", nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(vectorOpt1.size(), 2); EXPECT_EQ(vectorOpt1.size(), 2);
@ -750,7 +750,7 @@ TEST_CASE(MultipleOptions)
std::vector<std::string> vectorArg1 = {}; std::vector<std::string> vectorArg1 = {};
auto result = runParser({ "-b", "something", "-s", "a-string-value" }, [&](auto& parser) { auto result = runParser({ "-b", "something", "-s", "a-string-value" }, [&](auto& parser) {
parser.addOption(boolOpt1, 'b', nullptr, nullptr, nullptr); parser.addOption(boolOpt1, 'b', nullptr, nullptr, nullptr);
parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, Util::ArgParser::Required::Yes); parser.addOption(stringOpt1, 's', nullptr, nullptr, nullptr, nullptr, ruc::ArgParser::Required::Yes);
parser.addArgument(vectorArg1, nullptr, nullptr, nullptr); parser.addArgument(vectorArg1, nullptr, nullptr, nullptr);
}); });
EXPECT_EQ(result, true); EXPECT_EQ(result, true);

232
test/unit/testutilformat.cpp
Unescape View File

@ -13,9 +13,9 @@
#include <vector> #include <vector>
#include "macro.h" #include "macro.h"
#include "ruc/format/format.h"
#include "testcase.h" #include "testcase.h"
#include "testsuite.h" #include "testsuite.h"
#include "util/format/format.h"
// ----------------------------------------- // -----------------------------------------
@ -26,37 +26,37 @@ TEST_CASE(FormatIntegral)
// Signed // Signed
int8_t i8 = 127; // char int8_t i8 = 127; // char
result = Util::format("{}", i8); result = format("{}", i8);
EXPECT_EQ(result, "127"); EXPECT_EQ(result, "127");
int16_t i16 = 32767; int16_t i16 = 32767;
result = Util::format("{}", i16); result = format("{}", i16);
EXPECT_EQ(result, "32767"); EXPECT_EQ(result, "32767");
int32_t i32 = 68766; // int int32_t i32 = 68766; // int
result = Util::format("{}", i32); result = format("{}", i32);
EXPECT_EQ(result, "68766"); EXPECT_EQ(result, "68766");
int64_t i64 = 237942768427; // long int int64_t i64 = 237942768427; // long int
result = Util::format("{}", i64); result = format("{}", i64);
EXPECT_EQ(result, "237942768427"); EXPECT_EQ(result, "237942768427");
// Unsigned // Unsigned
uint8_t u8 = 255; // unsigned char uint8_t u8 = 255; // unsigned char
result = Util::format("{}", u8); result = format("{}", u8);
EXPECT_EQ(result, "255"); EXPECT_EQ(result, "255");
uint16_t u16 = 65535; uint16_t u16 = 65535;
result = Util::format("{}", u16); result = format("{}", u16);
EXPECT_EQ(result, "65535"); EXPECT_EQ(result, "65535");
uint32_t u32 = 4294967295; // unsigned int uint32_t u32 = 4294967295; // unsigned int
result = Util::format("{}", u32); result = format("{}", u32);
EXPECT_EQ(result, "4294967295"); EXPECT_EQ(result, "4294967295");
size_t u64 = 18446744073709551615; // long unsigned int size_t u64 = 18446744073709551615; // long unsigned int
result = Util::format("{}", u64); result = format("{}", u64);
EXPECT_EQ(result, "18446744073709551615"); EXPECT_EQ(result, "18446744073709551615");
} }
@ -65,19 +65,19 @@ TEST_CASE(FormatFloatingPoint)
std::string result; std::string result;
float f32R = 245789.70000; float f32R = 245789.70000;
result = Util::format("{}", f32R); result = format("{}", f32R);
EXPECT_EQ(result, "245789.703125"); EXPECT_EQ(result, "245789.703125");
float f32 = 45645.3233; float f32 = 45645.3233;
result = Util::format("{}", f32); result = format("{}", f32);
EXPECT_EQ(result, "45645.324219"); EXPECT_EQ(result, "45645.324219");
double f64 = 87522.300000000; double f64 = 87522.300000000;
result = Util::format("{}", f64); result = format("{}", f64);
EXPECT_EQ(result, "87522.300000"); EXPECT_EQ(result, "87522.300000");
double pi = 3.14159265359; double pi = 3.14159265359;
result = Util::format("{}", pi); result = format("{}", pi);
EXPECT_EQ(result, "3.141593"); EXPECT_EQ(result, "3.141593");
} }
@ -86,15 +86,15 @@ TEST_CASE(FormatChar)
std::string result; std::string result;
char character = 'A'; char character = 'A';
result = Util::format("{}", character); result = format("{}", character);
EXPECT_EQ(result, "A"); EXPECT_EQ(result, "A");
bool boolean = true; bool boolean = true;
result = Util::format("{}", boolean); result = format("{}", boolean);
EXPECT_EQ(result, "true"); EXPECT_EQ(result, "true");
boolean = false; boolean = false;
result = Util::format("{}", boolean); result = format("{}", boolean);
EXPECT_EQ(result, "false"); EXPECT_EQ(result, "false");
} }
@ -102,28 +102,28 @@ TEST_CASE(FormatString)
{ {
std::string result; std::string result;
result = Util::format(""); result = format("");
EXPECT_EQ(result, ""); EXPECT_EQ(result, "");
const char* cString = "C string"; const char* cString = "C string";
result = Util::format("{}", cString); result = format("{}", cString);
EXPECT_EQ(result, "C string"); EXPECT_EQ(result, "C string");
std::string string = "string"; std::string string = "string";
result = Util::format("{}", string); result = format("{}", string);
EXPECT_EQ(result, "string"); EXPECT_EQ(result, "string");
std::string_view stringView = "string_view"; std::string_view stringView = "string_view";
result = Util::format("{}", stringView); result = format("{}", stringView);
EXPECT_EQ(result, "string_view"); EXPECT_EQ(result, "string_view");
result = Util::format("{} {}", "Hello", "World"); result = format("{} {}", "Hello", "World");
EXPECT_EQ(result, "Hello World"); EXPECT_EQ(result, "Hello World");
result = Util::format("{{escaped braces}}"); result = format("{{escaped braces}}");
EXPECT_EQ(result, "{escaped braces}"); EXPECT_EQ(result, "{escaped braces}");
result = Util::format("{{braces{}}}", "Something"); result = format("{{braces{}}}", "Something");
EXPECT_EQ(result, "{bracesSomething}"); EXPECT_EQ(result, "{bracesSomething}");
} }
@ -131,7 +131,7 @@ TEST_CASE(FormatPointer)
{ {
std::string result; std::string result;
result = Util::format("{}", nullptr); result = format("{}", nullptr);
EXPECT_EQ(result, "0x0"); EXPECT_EQ(result, "0x0");
int integer = 42; int integer = 42;
@ -139,7 +139,7 @@ TEST_CASE(FormatPointer)
stream << &integer; stream << &integer;
std::string pointer = stream.str(); std::string pointer = stream.str();
result = Util::format("{}", &integer); result = format("{}", &integer);
EXPECT_EQ(result, pointer); EXPECT_EQ(result, pointer);
} }
@ -148,80 +148,80 @@ TEST_CASE(FormatSpecifierIntegral)
std::string result; std::string result;
// Fill and Align // Fill and Align
result = Util::format("{:+<}", 12345); result = format("{:+<}", 12345);
EXPECT_EQ(result, "12345"); EXPECT_EQ(result, "12345");
result = Util::format("{:+^}", 12345); result = format("{:+^}", 12345);
EXPECT_EQ(result, "12345"); EXPECT_EQ(result, "12345");
result = Util::format("{:+>}", 12345); result = format("{:+>}", 12345);
EXPECT_EQ(result, "12345"); EXPECT_EQ(result, "12345");
// Sign // Sign
result = Util::format("{:+}", 12345); result = format("{:+}", 12345);
EXPECT_EQ(result, "+12345"); EXPECT_EQ(result, "+12345");
result = Util::format("{:+}", -12345); result = format("{:+}", -12345);
EXPECT_EQ(result, "-12345"); EXPECT_EQ(result, "-12345");
result = Util::format("{:-}", 12345); result = format("{:-}", 12345);
EXPECT_EQ(result, "12345"); EXPECT_EQ(result, "12345");
result = Util::format("{:-}", -12345); result = format("{:-}", -12345);
EXPECT_EQ(result, "-12345"); EXPECT_EQ(result, "-12345");
result = Util::format("{: }", 12345); result = format("{: }", 12345);
EXPECT_EQ(result, " 12345"); EXPECT_EQ(result, " 12345");
result = Util::format("{: }", -12345); result = format("{: }", -12345);
EXPECT_EQ(result, "-12345"); EXPECT_EQ(result, "-12345");
// AlternativeForm // AlternativeForm
result = Util::format("{:#}", 12345); result = format("{:#}", 12345);
EXPECT_EQ(result, "12345"); EXPECT_EQ(result, "12345");
// ZeroPadding // ZeroPadding
result = Util::format("{:0}", 12345); result = format("{:0}", 12345);
EXPECT_EQ(result, "12345"); EXPECT_EQ(result, "12345");
// Width // Width
result = Util::format("{:10}", 12345); result = format("{:10}", 12345);
EXPECT_EQ(result, " 12345"); EXPECT_EQ(result, " 12345");
// Width + Fill and Align // Width + Fill and Align
result = Util::format("{:+<10}", 12345); result = format("{:+<10}", 12345);
EXPECT_EQ(result, "12345+++++"); EXPECT_EQ(result, "12345+++++");
result = Util::format("{:+^10}", 12345); result = format("{:+^10}", 12345);
EXPECT_EQ(result, "++12345+++"); EXPECT_EQ(result, "++12345+++");
result = Util::format("{:+>10}", 12345); result = format("{:+>10}", 12345);
EXPECT_EQ(result, "+++++12345"); EXPECT_EQ(result, "+++++12345");
// Width + ZeroPadding // Width + ZeroPadding
result = Util::format("{:010}", 12345); result = format("{:010}", 12345);
EXPECT_EQ(result, "0000012345"); EXPECT_EQ(result, "0000012345");
// Precision // Precision
// Not possible on integral types // Not possible on integral types
// Type // Type
result = Util::format("{:b}", 12345); result = format("{:b}", 12345);
EXPECT_EQ(result, "11000000111001"); EXPECT_EQ(result, "11000000111001");
result = Util::format("{:B}", 12345); result = format("{:B}", 12345);
EXPECT_EQ(result, "11000000111001"); EXPECT_EQ(result, "11000000111001");
result = Util::format("{:c}", 65); result = format("{:c}", 65);
EXPECT_EQ(result, "A"); EXPECT_EQ(result, "A");
result = Util::format("{:o}", 12345); result = format("{:o}", 12345);
EXPECT_EQ(result, "30071"); EXPECT_EQ(result, "30071");
result = Util::format("{:x}", 62432); result = format("{:x}", 62432);
EXPECT_EQ(result, "f3e0"); EXPECT_EQ(result, "f3e0");
result = Util::format("{:X}", 62432); result = format("{:X}", 62432);
EXPECT_EQ(result, "F3E0"); EXPECT_EQ(result, "F3E0");
// Type + AlternativeForm // Type + AlternativeForm
result = Util::format("{:#b}", 12345); result = format("{:#b}", 12345);
EXPECT_EQ(result, "0b11000000111001"); EXPECT_EQ(result, "0b11000000111001");
result = Util::format("{:#B}", 12345); result = format("{:#B}", 12345);
EXPECT_EQ(result, "0B11000000111001"); EXPECT_EQ(result, "0B11000000111001");
result = Util::format("{:#c}", 65); result = format("{:#c}", 65);
EXPECT_EQ(result, "A"); EXPECT_EQ(result, "A");
result = Util::format("{:#o}", 12345); result = format("{:#o}", 12345);
EXPECT_EQ(result, "030071"); EXPECT_EQ(result, "030071");
result = Util::format("{:#x}", 62432); result = format("{:#x}", 62432);
EXPECT_EQ(result, "0xf3e0"); EXPECT_EQ(result, "0xf3e0");
result = Util::format("{:#X}", 62432); result = format("{:#X}", 62432);
EXPECT_EQ(result, "0XF3E0"); EXPECT_EQ(result, "0XF3E0");
} }
@ -232,78 +232,78 @@ TEST_CASE(FormatSpecifierIntegralCombination)
// AlternativeForm + ZeroPadding + Width + Type // AlternativeForm + ZeroPadding + Width + Type
// ------------------------------ // ------------------------------
result = Util::format("{:-#010d}", 402); result = format("{:-#010d}", 402);
EXPECT_EQ(result, "0000000402"); EXPECT_EQ(result, "0000000402");
// AlternativeForm + Width + Type // AlternativeForm + Width + Type
// ------------------------------ // ------------------------------
result = Util::format("{:#10x}", 402); result = format("{:#10x}", 402);
EXPECT_EQ(result, " 0x192"); EXPECT_EQ(result, " 0x192");
// + Fill and Align // + Fill and Align
result = Util::format("{:^<#10x}", 402); result = format("{:^<#10x}", 402);
EXPECT_EQ(result, "0x192^^^^^"); EXPECT_EQ(result, "0x192^^^^^");
result = Util::format("{:^^#10x}", 402); result = format("{:^^#10x}", 402);
EXPECT_EQ(result, "^^0x192^^^"); EXPECT_EQ(result, "^^0x192^^^");
result = Util::format("{:^>#10x}", 402); result = format("{:^>#10x}", 402);
EXPECT_EQ(result, "^^^^^0x192"); EXPECT_EQ(result, "^^^^^0x192");
// ------------------------------ // ------------------------------
// + Sign // + Sign
result = Util::format("{:+#10x}", 402); result = format("{:+#10x}", 402);
EXPECT_EQ(result, " +0x192"); EXPECT_EQ(result, " +0x192");
// + Fill and Align + Sign // + Fill and Align + Sign
result = Util::format("{:^<+#10x}", 402); result = format("{:^<+#10x}", 402);
EXPECT_EQ(result, "+0x192^^^^"); EXPECT_EQ(result, "+0x192^^^^");
result = Util::format("{:^^+#10x}", 402); result = format("{:^^+#10x}", 402);
EXPECT_EQ(result, "^^+0x192^^"); EXPECT_EQ(result, "^^+0x192^^");
result = Util::format("{:^>+#10x}", 402); result = format("{:^>+#10x}", 402);
EXPECT_EQ(result, "^^^^+0x192"); EXPECT_EQ(result, "^^^^+0x192");
// ------------------------------ // ------------------------------
// + ZeroPadding // + ZeroPadding
result = Util::format("{:#010x}", 402); result = format("{:#010x}", 402);
EXPECT_EQ(result, "0x00000192"); EXPECT_EQ(result, "0x00000192");
// Fill and Align + ZeroPadding // Fill and Align + ZeroPadding
result = Util::format("{:^<#010x}", 402); result = format("{:^<#010x}", 402);
EXPECT_EQ(result, "0x19200000"); EXPECT_EQ(result, "0x19200000");
result = Util::format("{:^^#010x}", 402); result = format("{:^^#010x}", 402);
EXPECT_EQ(result, "000x192000"); EXPECT_EQ(result, "000x192000");
result = Util::format("{:^>#010x}", 402); result = format("{:^>#010x}", 402);
EXPECT_EQ(result, "000000x192"); EXPECT_EQ(result, "000000x192");
// ------------------------------ // ------------------------------
// + Sign + ZeroPadding // + Sign + ZeroPadding
result = Util::format("{:+#010x}", 402); result = format("{:+#010x}", 402);
EXPECT_EQ(result, "+0x0000192"); EXPECT_EQ(result, "+0x0000192");
// + Fill and Align + Sign + ZeroPadding // + Fill and Align + Sign + ZeroPadding
result = Util::format("{:^<+#010x}", 402); result = format("{:^<+#010x}", 402);
EXPECT_EQ(result, "+0x1920000"); EXPECT_EQ(result, "+0x1920000");
result = Util::format("{:^^+#010x}", 402); result = format("{:^^+#010x}", 402);
EXPECT_EQ(result, "00+0x19200"); EXPECT_EQ(result, "00+0x19200");
result = Util::format("{:^>+#010x}", 402); result = format("{:^>+#010x}", 402);
EXPECT_EQ(result, "0000+0x192"); EXPECT_EQ(result, "0000+0x192");
} }
@ -312,14 +312,14 @@ TEST_CASE(FormatSpecifierFloatingPoint)
std::string result; std::string result;
double f64 = 87522.300000000; double f64 = 87522.300000000;
result = Util::format("{:.1}", f64); result = format("{:.1}", f64);
EXPECT_EQ(result, "87522.3"); EXPECT_EQ(result, "87522.3");
double pi = 3.14159265359; double pi = 3.14159265359;
result = Util::format("{}", pi); result = format("{}", pi);
EXPECT_EQ(result, "3.141593"); EXPECT_EQ(result, "3.141593");
result = Util::format("{:.15}", pi); result = format("{:.15}", pi);
EXPECT_EQ(result, "3.141592653590000"); EXPECT_EQ(result, "3.141592653590000");
} }
@ -328,45 +328,45 @@ TEST_CASE(FormatSpecifierChar)
std::string result; std::string result;
char character = 65; char character = 65;
result = Util::format("{:b}", character); result = format("{:b}", character);
EXPECT_EQ(result, "1000001"); EXPECT_EQ(result, "1000001");
result = Util::format("{:B}", character); result = format("{:B}", character);
EXPECT_EQ(result, "1000001"); EXPECT_EQ(result, "1000001");
result = Util::format("{:d}", character); result = format("{:d}", character);
EXPECT_EQ(result, "65"); EXPECT_EQ(result, "65");
result = Util::format("{:o}", character); result = format("{:o}", character);
EXPECT_EQ(result, "101"); EXPECT_EQ(result, "101");
result = Util::format("{:x}", character); result = format("{:x}", character);
EXPECT_EQ(result, "41"); EXPECT_EQ(result, "41");
result = Util::format("{:X}", character); result = format("{:X}", character);
EXPECT_EQ(result, "41"); EXPECT_EQ(result, "41");
bool boolean = true; bool boolean = true;
result = Util::format("{:b}", boolean); result = format("{:b}", boolean);
EXPECT_EQ(result, "1"); EXPECT_EQ(result, "1");
result = Util::format("{:B}", boolean); result = format("{:B}", boolean);
EXPECT_EQ(result, "1"); EXPECT_EQ(result, "1");
result = Util::format("{:d}", boolean); result = format("{:d}", boolean);
EXPECT_EQ(result, "1"); EXPECT_EQ(result, "1");
result = Util::format("{:o}", boolean); result = format("{:o}", boolean);
EXPECT_EQ(result, "1"); EXPECT_EQ(result, "1");
result = Util::format("{:x}", boolean); result = format("{:x}", boolean);
EXPECT_EQ(result, "1"); EXPECT_EQ(result, "1");
result = Util::format("{:X}", boolean); result = format("{:X}", boolean);
EXPECT_EQ(result, "1"); EXPECT_EQ(result, "1");
boolean = false; boolean = false;
result = Util::format("{:b}", boolean); result = format("{:b}", boolean);
EXPECT_EQ(result, "0"); EXPECT_EQ(result, "0");
result = Util::format("{:B}", boolean); result = format("{:B}", boolean);
EXPECT_EQ(result, "0"); EXPECT_EQ(result, "0");
result = Util::format("{:d}", boolean); result = format("{:d}", boolean);
EXPECT_EQ(result, "0"); EXPECT_EQ(result, "0");
result = Util::format("{:o}", boolean); result = format("{:o}", boolean);
EXPECT_EQ(result, "0"); EXPECT_EQ(result, "0");
result = Util::format("{:x}", boolean); result = format("{:x}", boolean);
EXPECT_EQ(result, "0"); EXPECT_EQ(result, "0");
result = Util::format("{:X}", boolean); result = format("{:X}", boolean);
EXPECT_EQ(result, "0"); EXPECT_EQ(result, "0");
} }
@ -377,11 +377,11 @@ TEST_CASE(FormatSpecifierString)
std::string string = "my string"; std::string string = "my string";
// Fill and Align // Fill and Align
result = Util::format("{:+<}", string); result = format("{:+<}", string);
EXPECT_EQ(result, "my string"); EXPECT_EQ(result, "my string");
result = Util::format("{:+^}", string); result = format("{:+^}", string);
EXPECT_EQ(result, "my string"); EXPECT_EQ(result, "my string");
result = Util::format("{:+>}", string); result = format("{:+>}", string);
EXPECT_EQ(result, "my string"); EXPECT_EQ(result, "my string");
// Sign // Sign
@ -394,22 +394,22 @@ TEST_CASE(FormatSpecifierString)
// Not possible on string types // Not possible on string types
// Width // Width
result = Util::format("{:15}", string); result = format("{:15}", string);
EXPECT_EQ(result, "my string "); EXPECT_EQ(result, "my string ");
// Width + Fill and Align // Width + Fill and Align
result = Util::format("{:+<15}", string); result = format("{:+<15}", string);
EXPECT_EQ(result, "my string++++++"); EXPECT_EQ(result, "my string++++++");
result = Util::format("{:+^15}", string); result = format("{:+^15}", string);
EXPECT_EQ(result, "+++my string+++"); EXPECT_EQ(result, "+++my string+++");
result = Util::format("{:+>15}", string); result = format("{:+>15}", string);
EXPECT_EQ(result, "++++++my string"); EXPECT_EQ(result, "++++++my string");
// Precision // Precision
// Not possible on string types // Not possible on string types
// Type // Type
result = Util::format("{:s}", string); result = format("{:s}", string);
EXPECT_EQ(result, "my string"); EXPECT_EQ(result, "my string");
} }
@ -423,11 +423,11 @@ TEST_CASE(FormatSpecifierPointer)
std::string pointer = stream.str(); std::string pointer = stream.str();
// Fill and Align // Fill and Align
result = Util::format("{:+<}", &integer); result = format("{:+<}", &integer);
EXPECT_EQ(result, pointer); EXPECT_EQ(result, pointer);
result = Util::format("{:+^}", &integer); result = format("{:+^}", &integer);
EXPECT_EQ(result, pointer); EXPECT_EQ(result, pointer);
result = Util::format("{:+>}", &integer); result = format("{:+>}", &integer);
EXPECT_EQ(result, pointer); EXPECT_EQ(result, pointer);
// Sign // Sign
@ -440,22 +440,22 @@ TEST_CASE(FormatSpecifierPointer)
// Not possible on string types // Not possible on string types
// Width // Width
result = Util::format("{:24}", &integer); result = format("{:24}", &integer);
EXPECT_EQ(result, std::string(24 - pointer.length(), ' ') + pointer); EXPECT_EQ(result, std::string(24 - pointer.length(), ' ') + pointer);
// Width + Fill and Align // Width + Fill and Align
result = Util::format("{:+<24}", &integer); result = format("{:+<24}", &integer);
EXPECT_EQ(result, pointer + std::string(24 - pointer.length(), '+')); EXPECT_EQ(result, pointer + std::string(24 - pointer.length(), '+'));
result = Util::format("{:+^24}", &integer); result = format("{:+^24}", &integer);
EXPECT_EQ(result, std::string((24 - pointer.length()) / 2, '+') + pointer + std::string((24 - pointer.length()) / 2, '+')); EXPECT_EQ(result, std::string((24 - pointer.length()) / 2, '+') + pointer + std::string((24 - pointer.length()) / 2, '+'));
result = Util::format("{:+>24}", &integer); result = format("{:+>24}", &integer);
EXPECT_EQ(result, std::string(24 - pointer.length(), '+') + pointer); EXPECT_EQ(result, std::string(24 - pointer.length(), '+') + pointer);
// Precision // Precision
// Not possible on string types // Not possible on string types
// Type // Type
result = Util::format("{:p}", &integer); result = format("{:p}", &integer);
EXPECT_EQ(result, pointer); EXPECT_EQ(result, pointer);
} }
@ -464,17 +464,17 @@ TEST_CASE(FormatContainers)
std::string result; std::string result;
std::vector<std::string> vector { "thing1", "thing2", "thing3" }; std::vector<std::string> vector { "thing1", "thing2", "thing3" };
result = Util::format("{}", vector); result = format("{}", vector);
EXPECT_EQ(result, "{thing1,thing2,thing3}"); EXPECT_EQ(result, "{thing1,thing2,thing3}");
result = Util::format("{:1}", vector); result = format("{:1}", vector);
EXPECT_EQ(result, "{ thing1, thing2, thing3 }"); EXPECT_EQ(result, "{ thing1, thing2, thing3 }");
result = Util::format("{:#4}", vector); result = format("{:#4}", vector);
EXPECT_EQ(result, R"({ EXPECT_EQ(result, R"({
thing1, thing1,
thing2, thing2,
thing3 thing3
})"); })");
result = Util::format("{:\t<#1}", vector); result = format("{:\t<#1}", vector);
EXPECT_EQ(result, R"({ EXPECT_EQ(result, R"({
thing1, thing1,
thing2, thing2,
@ -482,17 +482,17 @@ TEST_CASE(FormatContainers)
})"); })");
std::map<std::string, int> map { { "thing3", 3 }, { "thing2", 2 }, { "thing1", 1 } }; std::map<std::string, int> map { { "thing3", 3 }, { "thing2", 2 }, { "thing1", 1 } };
result = Util::format("{}", map); result = format("{}", map);
EXPECT_EQ(result, R"({"thing1":1,"thing2":2,"thing3":3})"); EXPECT_EQ(result, R"({"thing1":1,"thing2":2,"thing3":3})");
result = Util::format("{:1}", map); result = format("{:1}", map);
EXPECT_EQ(result, R"({ "thing1": 1, "thing2": 2, "thing3": 3 })"); EXPECT_EQ(result, R"({ "thing1": 1, "thing2": 2, "thing3": 3 })");
result = Util::format("{:#4}", map); result = format("{:#4}", map);
EXPECT_EQ(result, R"({ EXPECT_EQ(result, R"({
"thing1": 1, "thing1": 1,
"thing2": 2, "thing2": 2,
"thing3": 3 "thing3": 3
})"); })");
result = Util::format("{:\t<#1}", map); result = format("{:\t<#1}", map);
EXPECT_EQ(result, R"({ EXPECT_EQ(result, R"({
"thing1": 1, "thing1": 1,
"thing2": 2, "thing2": 2,
@ -505,7 +505,7 @@ TEST_CASE(FormatContainers)
{ "thing1", "thing2", "thing3" }, { "thing1", "thing2", "thing3" },
{ "thing1", "thing2", "thing3" } { "thing1", "thing2", "thing3" }
}; };
result = Util::format("{:#4}", twoDimensionalVector); result = format("{:#4}", twoDimensionalVector);
EXPECT_EQ(result, R"({ EXPECT_EQ(result, R"({
{thing1,thing2,thing3}, {thing1,thing2,thing3},
{thing1,thing2,thing3} {thing1,thing2,thing3}

162
test/unit/testutiljson.cpp
Unescape View File

@ -13,14 +13,14 @@
#include <vector> #include <vector>
#include "macro.h" #include "macro.h"
#include "ruc/json/array.h"
#include "ruc/json/job.h"
#include "ruc/json/json.h"
#include "ruc/json/lexer.h"
#include "ruc/json/parser.h"
#include "ruc/json/serializer.h"
#include "testcase.h" #include "testcase.h"
#include "testsuite.h" #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"
#define DONT_PRINT_PARSER_ERRORS #define DONT_PRINT_PARSER_ERRORS
@ -28,25 +28,25 @@
#define EXEC(x) x #define EXEC(x) x
#else #else
#define EXEC(x) \ #define EXEC(x) \
stderr = Test::TestSuite::the().outputNull(); \ stderr = test::TestSuite::the().outputNull(); \
x; \ x; \
stderr = Test::TestSuite::the().outputErr(); stderr = test::TestSuite::the().outputErr();
#endif #endif
std::vector<Util::JSON::Token> lex(const std::string& input) std::vector<ruc::json::Token> lex(const std::string& input)
{ {
EXEC( EXEC(
Util::JSON::Job job(input); ruc::json::Job job(input);
Util::JSON::Lexer lexer(&job); ruc::json::Lexer lexer(&job);
lexer.analyze();); lexer.analyze(););
return *job.tokens(); return *job.tokens();
} }
Util::Json parse(const std::string& input) ruc::Json parse(const std::string& input)
{ {
EXEC( EXEC(
Util::JSON::Job job(input); ruc::json::Job job(input);
Util::JSON::Lexer lexer(&job); ruc::json::Lexer lexer(&job);
lexer.analyze();); lexer.analyze(););
if (!job.success()) { if (!job.success()) {
@ -54,8 +54,8 @@ Util::Json parse(const std::string& input)
} }
EXEC( EXEC(
Util::JSON::Parser parser(&job); ruc::json::Parser parser(&job);
Util::Json json = parser.parse();); ruc::Json json = parser.parse(););
if (!job.success()) { if (!job.success()) {
return nullptr; return nullptr;
@ -67,7 +67,7 @@ Util::Json 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 = Util::Json::parse(input);); auto json = ruc::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<Util::JSON::Token> tokens; std::vector<ruc::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 == Util::JSON::Token::Type::Literal); EXPECT(tokens[0].type == ruc::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 == Util::JSON::Token::Type::Literal); EXPECT(tokens[0].type == ruc::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 == Util::JSON::Token::Type::Literal); EXPECT(tokens[0].type == ruc::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 == Util::JSON::Token::Type::Number); EXPECT(tokens[0].type == ruc::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 == Util::JSON::Token::Type::Number); EXPECT(tokens[0].type == ruc::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 == Util::JSON::Token::Type::None); EXPECT(tokens[0].type == ruc::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 == Util::JSON::Token::Type::String); EXPECT(tokens[0].type == ruc::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 == Util::JSON::Token::Type::String); EXPECT(tokens[0].type == ruc::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 == Util::JSON::Token::Type::String); EXPECT(tokens[0].type == ruc::json::Token::Type::String);
// Array // Array
@ -156,186 +156,186 @@ TEST_CASE(JsonLexer)
TEST_CASE(JsonParser) TEST_CASE(JsonParser)
{ {
Util::Json json; ruc::Json json;
json = parse("null"); json = parse("null");
EXPECT_EQ(json.size(), 0); EXPECT_EQ(json.size(), 0);
EXPECT_EQ(json.type(), Util::Json::Type::Null); EXPECT_EQ(json.type(), ruc::Json::Type::Null);
json = parse("true"); json = parse("true");
EXPECT_EQ(json.size(), 1); EXPECT_EQ(json.size(), 1);
EXPECT_EQ(json.type(), Util::Json::Type::Bool); EXPECT_EQ(json.type(), ruc::Json::Type::Bool);
json = parse("false"); json = parse("false");
EXPECT_EQ(json.size(), 1); EXPECT_EQ(json.size(), 1);
EXPECT_EQ(json.type(), Util::Json::Type::Bool); EXPECT_EQ(json.type(), ruc::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(), Util::Json::Type::Number); EXPECT_EQ(json.type(), ruc::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(), Util::Json::Type::String); EXPECT_EQ(json.type(), ruc::Json::Type::String);
// Array // Array
json = parse("["); json = parse("[");
EXPECT_EQ(json.size(), 0); EXPECT_EQ(json.size(), 0);
EXPECT_EQ(json.type(), Util::Json::Type::Null); EXPECT_EQ(json.type(), ruc::Json::Type::Null);
json = parse("[ 123"); json = parse("[ 123");
EXPECT_EQ(json.size(), 0); EXPECT_EQ(json.size(), 0);
EXPECT_EQ(json.type(), Util::Json::Type::Null); EXPECT_EQ(json.type(), ruc::Json::Type::Null);
json = parse("[ 123,"); json = parse("[ 123,");
EXPECT_EQ(json.size(), 0); EXPECT_EQ(json.size(), 0);
EXPECT_EQ(json.type(), Util::Json::Type::Null); EXPECT_EQ(json.type(), ruc::Json::Type::Null);
json = parse("[ 123, ]"); json = parse("[ 123, ]");
EXPECT_EQ(json.size(), 0); EXPECT_EQ(json.size(), 0);
EXPECT_EQ(json.type(), Util::Json::Type::Null); EXPECT_EQ(json.type(), ruc::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(), Util::Json::Type::Null); EXPECT_EQ(json.type(), ruc::Json::Type::Null);
json = parse("[]"); json = parse("[]");
EXPECT_EQ(json.size(), 0); EXPECT_EQ(json.size(), 0);
EXPECT_EQ(json.type(), Util::Json::Type::Array); EXPECT_EQ(json.type(), ruc::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(), Util::Json::Type::Array); EXPECT_EQ(json.type(), ruc::Json::Type::Array);
// Object // Object
json = parse("{"); json = parse("{");
EXPECT_EQ(json.size(), 0); EXPECT_EQ(json.size(), 0);
EXPECT_EQ(json.type(), Util::Json::Type::Null); EXPECT_EQ(json.type(), ruc::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(), Util::Json::Type::Null); EXPECT_EQ(json.type(), ruc::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(), Util::Json::Type::Null); EXPECT_EQ(json.type(), ruc::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(), Util::Json::Type::Null); EXPECT_EQ(json.type(), ruc::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(), Util::Json::Type::Null); EXPECT_EQ(json.type(), ruc::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(), Util::Json::Type::Null); EXPECT_EQ(json.type(), ruc::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(), Util::Json::Type::Null); EXPECT_EQ(json.type(), ruc::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(), Util::Json::Type::Null); EXPECT_EQ(json.type(), ruc::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(), Util::Json::Type::Null); EXPECT_EQ(json.type(), ruc::Json::Type::Null);
json = parse("{}"); json = parse("{}");
EXPECT_EQ(json.size(), 0); EXPECT_EQ(json.size(), 0);
EXPECT_EQ(json.type(), Util::Json::Type::Object); EXPECT_EQ(json.type(), ruc::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(), Util::Json::Type::Object); EXPECT_EQ(json.type(), ruc::Json::Type::Object);
// Multiple root elements // Multiple root elements
json = parse("54 false"); json = parse("54 false");
EXPECT_EQ(json.type(), Util::Json::Type::Null); EXPECT_EQ(json.type(), ruc::Json::Type::Null);
json = parse("3.14, 666"); json = parse("3.14, 666");
EXPECT_EQ(json.type(), Util::Json::Type::Null); EXPECT_EQ(json.type(), ruc::Json::Type::Null);
json = parse("true\nfalse"); json = parse("true\nfalse");
EXPECT_EQ(json.type(), Util::Json::Type::Null); EXPECT_EQ(json.type(), ruc::Json::Type::Null);
} }
TEST_CASE(JsonToJsonValue) TEST_CASE(JsonToJsonValue)
{ {
Util::Json json; ruc::Json json;
json = {}; json = {};
EXPECT_EQ(json.size(), 0); EXPECT_EQ(json.size(), 0);
EXPECT_EQ(json.type(), Util::Json::Type::Null); EXPECT_EQ(json.type(), ruc::Json::Type::Null);
json = nullptr; json = nullptr;
EXPECT_EQ(json.size(), 0); EXPECT_EQ(json.size(), 0);
EXPECT_EQ(json.type(), Util::Json::Type::Null); EXPECT_EQ(json.type(), ruc::Json::Type::Null);
json = true; json = true;
EXPECT_EQ(json.size(), 1); EXPECT_EQ(json.size(), 1);
EXPECT_EQ(json.type(), Util::Json::Type::Bool); EXPECT_EQ(json.type(), ruc::Json::Type::Bool);
json = false; json = false;
EXPECT_EQ(json.size(), 1); EXPECT_EQ(json.size(), 1);
EXPECT_EQ(json.type(), Util::Json::Type::Bool); EXPECT_EQ(json.type(), ruc::Json::Type::Bool);
json = 666; json = 666;
EXPECT_EQ(json.size(), 1); EXPECT_EQ(json.size(), 1);
EXPECT_EQ(json.type(), Util::Json::Type::Number); EXPECT_EQ(json.type(), ruc::Json::Type::Number);
json = 3.14; json = 3.14;
EXPECT_EQ(json.size(), 1); EXPECT_EQ(json.size(), 1);
EXPECT_EQ(json.type(), Util::Json::Type::Number); EXPECT_EQ(json.type(), ruc::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(), Util::Json::Type::String); EXPECT_EQ(json.type(), ruc::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(), Util::Json::Type::String); EXPECT_EQ(json.type(), ruc::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(), Util::Json::Type::Array); EXPECT_EQ(json.type(), ruc::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(), Util::Json::Type::Object); EXPECT_EQ(json.type(), ruc::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(), Util::Json::Type::Array); EXPECT_EQ(json.type(), ruc::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(), Util::Json::Type::Object); EXPECT_EQ(json.type(), ruc::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(), Util::Json::Type::Object); EXPECT_EQ(json.type(), ruc::Json::Type::Object);
} }
TEST_CASE(JsonFromJsonValue) TEST_CASE(JsonFromJsonValue)
{ {
Util::Json json; ruc::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<Util::Json>>(); auto valueArray = json.get<std::vector<ruc::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, Util::Json>>(); auto valueObject = json.get<std::map<std::string, ruc::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)
{ {
Util::Json array; ruc::Json array;
array[0]; array[0];
EXPECT_EQ(array.type(), Util::Json::Type::Array); EXPECT_EQ(array.type(), ruc::Json::Type::Array);
Util::Json arrayEmplace; ruc::Json arrayEmplace;
arrayEmplace.emplace_back("element"); arrayEmplace.emplace_back("element");
arrayEmplace.emplace_back({ "nested element" }); arrayEmplace.emplace_back({ "nested element" });
EXPECT_EQ(arrayEmplace.type(), Util::Json::Type::Array); EXPECT_EQ(arrayEmplace.type(), ruc::Json::Type::Array);
EXPECT_EQ(arrayEmplace[1].type(), Util::Json::Type::Array); EXPECT_EQ(arrayEmplace[1].type(), ruc::Json::Type::Array);
Util::Json object; ruc::Json object;
object[""]; object[""];
EXPECT_EQ(object.type(), Util::Json::Type::Object); EXPECT_EQ(object.type(), ruc::Json::Type::Object);
Util::Json objectEmplace; ruc::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(), Util::Json::Type::Object); EXPECT_EQ(objectEmplace.type(), ruc::Json::Type::Object);
EXPECT_EQ(objectEmplace["name2"].type(), Util::Json::Type::Object); EXPECT_EQ(objectEmplace["name2"].type(), ruc::Json::Type::Object);
} }
TEST_CASE(JsonSerializer) TEST_CASE(JsonSerializer)

8
test/unit/testutilshell.cpp
Unescape View File

@ -1,21 +1,21 @@
#include <string> #include <string>
#include "macro.h" #include "macro.h"
#include "ruc/shell.h"
#include "testcase.h" #include "testcase.h"
#include "testsuite.h" #include "testsuite.h"
#include "util/shell.h"
bool runShell(const char* command, std::string* output = nullptr) bool runShell(const char* command, std::string* output = nullptr)
{ {
stdout = Test::TestSuite::the().outputNull(); stdout = test::TestSuite::the().outputNull();
Util::Shell $; ruc::Shell $;
auto exec = $(command); auto exec = $(command);
if (output) { if (output) {
*output = exec.output(); *output = exec.output();
} }
stdout = Test::TestSuite::the().outputStd(); stdout = test::TestSuite::the().outputStd();
return !exec.status() ? true : false; return !exec.status() ? true : false;
} }

27
test/unit/testutilsystem.cpp
Unescape View File

@ -3,13 +3,13 @@
#include <vector> #include <vector>
#include "macro.h" #include "macro.h"
#include "ruc/system.h"
#include "testcase.h" #include "testcase.h"
#include "testsuite.h" #include "testsuite.h"
#include "util/system.h"
bool runSystem(std::function<Util::System(Util::System&)> commands, std::string* output = nullptr, std::string* error = nullptr) bool runSystem(std::function<ruc::System(ruc::System&)> commands, std::string* output = nullptr, std::string* error = nullptr)
{ {
Util::System system; ruc::System system;
auto exec = commands(system); auto exec = commands(system);
if (output) { if (output) {
*output = exec.output(); *output = exec.output();
@ -30,7 +30,8 @@ TEST_CASE(SystemCommand)
std::string error = ""; std::string error = "";
auto result = runSystem([&](auto& $) { auto result = runSystem([&](auto& $) {
return $("echo Hello World!")(); return $("echo Hello World!")();
}, &output, &error); },
&output, &error);
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(output, "Hello World!\n"); EXPECT_EQ(output, "Hello World!\n");
EXPECT_EQ(error, ""); EXPECT_EQ(error, "");
@ -40,7 +41,8 @@ TEST_CASE(SystemCommand)
error = ""; error = "";
result = runSystem([&](auto& $) { result = runSystem([&](auto& $) {
return $("echo -n Hello ") + $("echo -n World!"); return $("echo -n Hello ") + $("echo -n World!");
}, &output, &error); },
&output, &error);
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(output, "Hello World!"); EXPECT_EQ(output, "Hello World!");
EXPECT_EQ(error, ""); EXPECT_EQ(error, "");
@ -50,7 +52,8 @@ TEST_CASE(SystemCommand)
error = ""; error = "";
result = runSystem([&](auto& $) { result = runSystem([&](auto& $) {
return $("echo Hello World!") | $("grep --only-matching Hello"); return $("echo Hello World!") | $("grep --only-matching Hello");
}, &output, &error); },
&output, &error);
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(output, "Hello\n"); EXPECT_EQ(output, "Hello\n");
EXPECT_EQ(error, ""); EXPECT_EQ(error, "");
@ -60,7 +63,8 @@ TEST_CASE(SystemCommand)
error = ""; error = "";
result = runSystem([&](auto& $) { result = runSystem([&](auto& $) {
return $("echo Hello") && $("echo World!"); return $("echo Hello") && $("echo World!");
}, &output, &error); },
&output, &error);
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(output, "Hello\nWorld!\n"); EXPECT_EQ(output, "Hello\nWorld!\n");
EXPECT_EQ(error, ""); EXPECT_EQ(error, "");
@ -70,7 +74,8 @@ TEST_CASE(SystemCommand)
error = ""; error = "";
result = runSystem([&](auto& $) { result = runSystem([&](auto& $) {
return $("echo Hello") || $("echo World!"); return $("echo Hello") || $("echo World!");
}, &output, &error); },
&output, &error);
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(output, "Hello\n"); EXPECT_EQ(output, "Hello\n");
EXPECT_EQ(error, ""); EXPECT_EQ(error, "");
@ -80,7 +85,8 @@ TEST_CASE(SystemCommand)
error = ""; error = "";
result = runSystem([&](auto& $) { result = runSystem([&](auto& $) {
return ($("echo -n one ") && $("echo -n two ") && $("echo -n three")) | $("grep --only-matching two"); return ($("echo -n one ") && $("echo -n two ") && $("echo -n three")) | $("grep --only-matching two");
}, &output, &error); },
&output, &error);
EXPECT_EQ(result, true); EXPECT_EQ(result, true);
EXPECT_EQ(output, "two\n"); EXPECT_EQ(output, "two\n");
EXPECT_EQ(error, ""); EXPECT_EQ(error, "");
@ -91,7 +97,8 @@ TEST_CASE(SystemCommand)
error = ""; error = "";
result = runSystem([&](auto& $) { result = runSystem([&](auto& $) {
return $("exit 1")(); return $("exit 1")();
}, &output, &error); },
&output, &error);
EXPECT_EQ(result, false); EXPECT_EQ(result, false);
EXPECT_EQ(output, ""); EXPECT_EQ(output, "");
EXPECT_EQ(error, ""); EXPECT_EQ(error, "");

Write Preview
Loading…
Cancel
Save