diff options
Diffstat (limited to 'subprojects/exess/bindings')
| -rw-r--r-- | subprojects/exess/bindings/cpp/include/exess/exess.hpp | 707 | ||||
| -rw-r--r-- | subprojects/exess/bindings/cpp/meson.build | 54 | ||||
| -rw-r--r-- | subprojects/exess/bindings/cpp/test/.clang-tidy | 17 | ||||
| -rw-r--r-- | subprojects/exess/bindings/cpp/test/meson.build | 8 | ||||
| -rw-r--r-- | subprojects/exess/bindings/cpp/test/test_exess_hpp.cpp | 221 |
5 files changed, 1007 insertions, 0 deletions
diff --git a/subprojects/exess/bindings/cpp/include/exess/exess.hpp b/subprojects/exess/bindings/cpp/include/exess/exess.hpp new file mode 100644 index 00000000..7aa6fc5b --- /dev/null +++ b/subprojects/exess/bindings/cpp/include/exess/exess.hpp @@ -0,0 +1,707 @@ +/* + Copyright 2021 David Robillard <d@drobilla.net> + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted, provided that the above + copyright notice and this permission notice appear in all copies. + + THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef EXESS_EXESS_HPP +#define EXESS_EXESS_HPP + +#include "exess/exess.h" + +#include <cstdint> +#include <exception> +#include <iostream> +#include <string> +#include <type_traits> +#include <typeinfo> +#include <vector> + +namespace exess { + +/** + @defgroup exesspp Exess C++ API + This is the C++ wrapper for the exess API. + @{ +*/ + +constexpr const char* EXESS_NONNULL const xsd_uri = + "http://www.w3.org/2001/XMLSchema#"; + +// FIXME: Reorganize +using Datatype = ExessDatatype; +using Result = ExessResult; + +using Duration = ExessDuration; +using DateTime = ExessDateTime; +using Time = ExessTime; +using Date = ExessDate; + +/** + @defgroup exesspp_status Status + @copydoc exess_status + @{ +*/ + +/// @copydoc ExessStatus +enum class Status { + success, ///< @copydoc EXESS_SUCCESS + expected_end, ///< @copydoc EXESS_EXPECTED_END + expected_boolean, ///< @copydoc EXESS_EXPECTED_BOOLEAN + expected_integer, ///< @copydoc EXESS_EXPECTED_INTEGER + expected_duration, ///< @copydoc EXESS_EXPECTED_DURATION + expected_sign, ///< @copydoc EXESS_EXPECTED_SIGN + expected_digit, ///< @copydoc EXESS_EXPECTED_DIGIT + expected_colon, ///< @copydoc EXESS_EXPECTED_COLON + expected_dash, ///< @copydoc EXESS_EXPECTED_DASH + expected_time_sep, ///< @copydoc EXESS_EXPECTED_TIME_SEP + expected_time_tag, ///< @copydoc EXESS_EXPECTED_TIME_TAG + expected_date_tag, ///< @copydoc EXESS_EXPECTED_DATE_TAG + expected_hex, ///< @copydoc EXESS_EXPECTED_HEX + expected_base64, ///< @copydoc EXESS_EXPECTED_BASE64 + bad_order, ///< @copydoc EXESS_BAD_ORDER + bad_value, ///< @copydoc EXESS_BAD_VALUE + out_of_range, ///< @copydoc EXESS_OUT_OF_RANGE + no_space, ///< @copydoc EXESS_NO_SPACE + would_reduce_precision, ///< @copydoc EXESS_WOULD_REDUCE_PRECISION + would_round, ///< @copydoc EXESS_WOULD_ROUND + would_truncate, ///< @copydoc EXESS_WOULD_TRUNCATE + unsupported, ///< @copydoc EXESS_UNSUPPORTED +}; + +/// @copydoc exess_strerror +inline const char* EXESS_NONNULL +strerror(const Status status) +{ + return exess_strerror(static_cast<ExessStatus>(status)); +} + +inline std::ostream& +operator<<(std::ostream& stream, const Status status) +{ + return stream << strerror(status); +} + +/** + @} + + Datatype Traits +*/ + +namespace detail { + +template<class T> +struct DatatypeTraits {}; + +template<> +struct DatatypeTraits<bool> { + static constexpr auto datatype = EXESS_BOOLEAN; + static constexpr auto read_function = exess_read_boolean; + static constexpr auto write_function = exess_write_boolean; +}; + +template<> +struct DatatypeTraits<double> { + static constexpr auto datatype = EXESS_DOUBLE; + static constexpr auto read_function = exess_read_double; + static constexpr auto write_function = exess_write_double; +}; + +template<> +struct DatatypeTraits<float> { + static constexpr auto datatype = EXESS_FLOAT; + static constexpr auto read_function = exess_read_float; + static constexpr auto write_function = exess_write_float; +}; + +template<> +struct DatatypeTraits<int64_t> { + static constexpr auto datatype = EXESS_LONG; + static constexpr auto read_function = exess_read_long; + static constexpr auto write_function = exess_write_long; +}; + +template<> +struct DatatypeTraits<int32_t> { + static constexpr auto datatype = EXESS_INT; + static constexpr auto read_function = exess_read_int; + static constexpr auto write_function = exess_write_int; +}; + +template<> +struct DatatypeTraits<int16_t> { + static constexpr auto datatype = EXESS_SHORT; + static constexpr auto read_function = exess_read_short; + static constexpr auto write_function = exess_write_short; +}; + +template<> +struct DatatypeTraits<int8_t> { + static constexpr auto datatype = EXESS_BYTE; + static constexpr auto read_function = exess_read_byte; + static constexpr auto write_function = exess_write_byte; +}; + +template<> +struct DatatypeTraits<uint64_t> { + static constexpr auto datatype = EXESS_ULONG; + static constexpr auto read_function = exess_read_ulong; + static constexpr auto write_function = exess_write_ulong; +}; + +template<> +struct DatatypeTraits<uint32_t> { + static constexpr auto datatype = EXESS_UINT; + static constexpr auto read_function = exess_read_uint; + static constexpr auto write_function = exess_write_uint; +}; + +template<> +struct DatatypeTraits<uint16_t> { + static constexpr auto datatype = EXESS_USHORT; + static constexpr auto read_function = exess_read_ushort; + static constexpr auto write_function = exess_write_ushort; +}; + +template<> +struct DatatypeTraits<uint8_t> { + static constexpr auto datatype = EXESS_UBYTE; + static constexpr auto read_function = exess_read_ubyte; + static constexpr auto write_function = exess_write_ubyte; +}; + +template<> +struct DatatypeTraits<Duration> { + static constexpr auto datatype = EXESS_DURATION; + static constexpr auto read_function = exess_read_duration; + static constexpr auto write_function = exess_write_duration; +}; + +template<> +struct DatatypeTraits<DateTime> { + static constexpr auto datatype = EXESS_DATETIME; + static constexpr auto read_function = exess_read_datetime; + static constexpr auto write_function = exess_write_datetime; +}; + +template<> +struct DatatypeTraits<Time> { + static constexpr auto datatype = EXESS_TIME; + static constexpr auto read_function = exess_read_time; + static constexpr auto write_function = exess_write_time; +}; + +template<> +struct DatatypeTraits<Date> { + static constexpr auto datatype = EXESS_DATE; + static constexpr auto read_function = exess_read_date; + static constexpr auto write_function = exess_write_date; +}; + +} // namespace detail + +/** + @defgroup exesspp_read_write Reading and Writing + @{ +*/ + +/** + Read a value from a string. + + @param out Set to the parsed value. + @param str String input. + @return The `count` of characters read, and a `status` code. +*/ +template<class T> +inline Result +read(T* EXESS_NONNULL out, const char* EXESS_NONNULL str) +{ + return detail::DatatypeTraits<T>::read_function(out, str); +} + +/** + Write a value to a canonical string. + + @param value Value to write. + @param buf_size The size of `buf` in bytes. + @param buf Output buffer, or null to only measure. + + @return The `count` of characters in the output, and `status` + #Status::success, or #Status::no_space if the buffer is too small. +*/ +template<class T> +inline Result +write(const T& value, const size_t buf_size, char* EXESS_NONNULL buf) +{ + return detail::DatatypeTraits<T>::write_function(value, buf_size, buf); +} + +/** + Return a value as a string. + + This is a wrapper for write() that allocates a new string of the appropriate + length, writes the value to it, and returns it. + + @param value The value to convert to a string. + @return The value as a string, or the empty string on error. +*/ +template<class T> +inline std::string +to_string(const T& value) +{ + auto r = detail::DatatypeTraits<T>::write_function(value, 0, nullptr); + if (r.status) { + return {}; + } + + // In C++17, std::string::data() allows mutable access +#if __cplusplus >= 201703L + std::string string(r.count, ' '); + r = detail::DatatypeTraits<T>::write_function( + value, r.count + 1, string.data()); + + // Before, we had to allocate somewhere else +#else + std::vector<char> buf(r.count + 1, '\0'); + r = detail::DatatypeTraits<T>::write_function(value, r.count + 1, buf.data()); + + std::string string(buf.data()); +#endif + + return r.status ? "" : string; +} + +/** + @} +*/ + +// TODO: hex, base64 + +struct Variant : ExessVariant { + explicit Variant(const Status status) noexcept + : ExessVariant{} + { + datatype = EXESS_NOTHING; + value.as_status = static_cast<ExessStatus>(status); + } + + explicit Variant(const bool v) noexcept + : ExessVariant{} + { + datatype = EXESS_BOOLEAN; + value.as_bool = v; + } + + explicit Variant(const double v) noexcept + : ExessVariant{} + { + datatype = EXESS_DOUBLE; + value.as_double = v; + } + + explicit Variant(const float v) noexcept + : ExessVariant{} + { + datatype = EXESS_FLOAT; + value.as_float = v; + } + + explicit Variant(const int64_t v) noexcept + : ExessVariant{} + { + datatype = EXESS_LONG; + value.as_long = v; + } + + explicit Variant(const int32_t v) noexcept + : ExessVariant{} + { + datatype = EXESS_INT; + value.as_int = v; + } + + explicit Variant(const int16_t v) noexcept + : ExessVariant{} + { + datatype = EXESS_SHORT; + value.as_short = v; + } + + explicit Variant(const int8_t v) noexcept + : ExessVariant{} + { + datatype = EXESS_BYTE; + value.as_byte = v; + } + + explicit Variant(const uint64_t v) noexcept + : ExessVariant{} + { + datatype = EXESS_ULONG; + value.as_ulong = v; + } + + explicit Variant(const uint32_t v) noexcept + : ExessVariant{} + { + datatype = EXESS_UINT; + value.as_uint = v; + } + + explicit Variant(const uint16_t v) noexcept + : ExessVariant{} + { + datatype = EXESS_USHORT; + value.as_ushort = v; + } + + explicit Variant(const uint8_t v) noexcept + : ExessVariant{} + { + datatype = EXESS_UBYTE; + value.as_ubyte = v; + } + + explicit Variant(const Duration v) noexcept + : ExessVariant{} + { + datatype = EXESS_DURATION; + value.as_duration = v; + } + + explicit Variant(const DateTime v) noexcept + : ExessVariant{} + { + datatype = EXESS_DATETIME; + value.as_datetime = v; + } + + explicit Variant(const Time v) noexcept + : ExessVariant{} + { + datatype = EXESS_TIME; + value.as_time = v; + } + + explicit Variant(const Date v) noexcept + : ExessVariant{} + { + datatype = EXESS_DATE; + value.as_date = v; + } +}; + +inline Variant +make_decimal(const double value) noexcept +{ + Variant result{value}; + result.datatype = EXESS_DECIMAL; + return result; +} + +inline Variant +make_integer(const int64_t value) noexcept +{ + Variant result{value}; + result.datatype = EXESS_INTEGER; + return result; +} + +inline Variant +make_non_positive_integer(const int64_t value) noexcept +{ + if (value > 0) { + return Variant{Status::out_of_range}; + } + + Variant result{value}; + result.datatype = EXESS_NON_POSITIVE_INTEGER; + return result; +} + +inline Variant +make_negative_integer(const int64_t value) noexcept +{ + if (value >= 0) { + return Variant{Status::out_of_range}; + } + + Variant result{value}; + result.datatype = EXESS_NEGATIVE_INTEGER; + return result; +} + +inline Variant +make_non_negative_integer(const uint64_t value) noexcept +{ + Variant result{value}; + result.datatype = EXESS_NON_NEGATIVE_INTEGER; + return result; +} + +inline Variant +make_positive_integer(const uint64_t value) noexcept +{ + if (value == 0) { + return Variant{Status::out_of_range}; + } + + Variant result{value}; + result.datatype = EXESS_POSITIVE_INTEGER; + return result; +} + +// enum class Datatype { +// NOTHING, ///< Sentinel for unknown datatypes or errors +// BOOLEAN, ///< xsd:boolean (see @ref exess_boolean) +// DECIMAL, ///< xsd:decimal (see @ref exess_decimal) +// DOUBLE, ///< xsd:double (see @ref exess_double) +// FLOAT, ///< xsd:float (see @ref exess_float) +// INTEGER, ///< xsd:integer (see @ref exess_long) +// NON_POSITIVE_INTEGER, ///< xsd:nonPositiveInteger (see @ref exess_long) +// NEGATIVE_INTEGER, ///< xsd:negativeInteger (see @ref exess_long) +// LONG, ///< xsd:long (see @ref exess_long) +// INT, ///< xsd:integer (see @ref exess_int) +// SHORT, ///< xsd:short (see @ref exess_short) +// BYTE, ///< xsd:byte (see @ref exess_byte) +// NON_NEGATIVE_INTEGER, ///< xsd:nonNegativeInteger (see @ref exess_ulong) +// ULONG, ///< xsd:unsignedLong (see @ref exess_ulong) +// UINT, ///< xsd:unsignedInt (see @ref exess_uint) +// USHORT, ///< xsd:unsignedShort (see @ref exess_ushort) +// UBYTE, ///< xsd:unsignedByte (see @ref exess_ubyte) +// POSITIVE_INTEGER, ///< xsd:positiveInteger (see @ref exess_ulong) +// DURATION, ///< xsd:duration (see @ref exess_duration) +// DATETIME, ///< xsd:dateTime (see @ref exess_datetime) +// TIME, ///< xsd:time (see @ref exess_time) +// DATE, ///< xsd:date (see @ref exess_date) +// HEX, ///< xsd:hexBinary (see @ref exess_hex) +// BASE64, ///< xsd:base64Binary (see @ref exess_base64) +// } + +// + +/** + Return a pointer to the value of `variant` if it has type `T`. + + This is safe to call on any variant, and will only return a pointer to the + value if the variant has the matching type and the value is valid to read. + + @return A pointer to the value in `variant`, or null. +*/ +template<class T> +constexpr const T* EXESS_NULLABLE +get_if(const Variant& variant) noexcept +{ + return (variant.datatype == detail::DatatypeTraits<T>::datatype) + ? reinterpret_cast<const T*>(&variant.value) + : nullptr; +} + +/** + Return a pointer to the Status value in `variant` if it exists. +*/ +template<> +constexpr const Status* EXESS_NULLABLE +get_if<Status>(const Variant& variant) noexcept +{ + return variant.datatype == EXESS_NOTHING + ? reinterpret_cast<const Status*>(&variant.value.as_status) + : nullptr; +} + +/** + Return a pointer to the value of `variant` if it is a `double`. + + This specialization works for both #EXESS_DECIMAL and #EXESS_DOUBLE values. +*/ +template<> +constexpr const double* EXESS_NULLABLE +get_if<double>(const Variant& variant) noexcept +{ + return (variant.datatype == EXESS_DECIMAL || variant.datatype == EXESS_DOUBLE) + ? &variant.value.as_double + : nullptr; +} + +/** + Return a pointer to the value of `variant` if it is an `int64_t` (long). + + This specialization works for #EXESS_INTEGER, #EXESS_NON_POSITIVE_INTEGER, + #EXESS_NEGATIVE_INTEGER, and #EXESS_LONG values. +*/ +template<> +constexpr const int64_t* EXESS_NULLABLE +get_if<int64_t>(const Variant& variant) noexcept +{ + return (variant.datatype >= EXESS_INTEGER && variant.datatype <= EXESS_LONG) + ? &variant.value.as_long + : nullptr; +} + +/** + Return a pointer to the value of `variant` if it is a `uint64_t` (ulong). + + This specialization works for #EXESS_NON_NEGATIVE_INTEGER, #EXESS_ULONG, and + #EXESS_POSITIVE_INTEGER values. +*/ +template<> +constexpr const uint64_t* EXESS_NULLABLE +get_if<uint64_t>(const Variant& variant) noexcept +{ + return (variant.datatype == EXESS_NON_NEGATIVE_INTEGER || + variant.datatype == EXESS_ULONG || + variant.datatype == EXESS_POSITIVE_INTEGER) + ? &variant.value.as_ulong + : nullptr; +} + +/** + Return the value of a variant with the given type. +*/ +template<class T> +const T& +get(const Variant& variant) +{ + if (const T* const pointer = get_if<T>(variant)) { + return *pointer; + } + + if (variant.datatype == EXESS_NOTHING) { + throw std::runtime_error{"Empty exess::Variant access"}; + } + + throw std::runtime_error{ + std::string("Bad exess::Variant access: ") + + std::string(exess_datatype_uri(variant.datatype) + strlen(xsd_uri)) + + " from " + typeid(T).name()}; +} + +template<class T> +constexpr size_t +max_length() +{ + return 0u; +} + +template<> +constexpr size_t +max_length<bool>() +{ + return EXESS_MAX_BOOLEAN_LENGTH; +} + +template<> +constexpr size_t +max_length<double>() +{ + return EXESS_MAX_DOUBLE_LENGTH; +} + +template<> +constexpr size_t +max_length<float>() +{ + return EXESS_MAX_FLOAT_LENGTH; +} + +template<> +constexpr size_t +max_length<int64_t>() +{ + return EXESS_MAX_LONG_LENGTH; +} + +template<> +constexpr size_t +max_length<int32_t>() +{ + return EXESS_MAX_INT_LENGTH; +} + +template<> +constexpr size_t +max_length<int16_t>() +{ + return EXESS_MAX_SHORT_LENGTH; +} + +template<> +constexpr size_t +max_length<int8_t>() +{ + return EXESS_MAX_BYTE_LENGTH; +} + +template<> +constexpr size_t +max_length<uint64_t>() +{ + return EXESS_MAX_ULONG_LENGTH; +} + +template<> +constexpr size_t +max_length<uint32_t>() +{ + return EXESS_MAX_UINT_LENGTH; +} + +template<> +constexpr size_t +max_length<uint16_t>() +{ + return EXESS_MAX_USHORT_LENGTH; +} + +template<> +constexpr size_t +max_length<uint8_t>() +{ + return EXESS_MAX_UBYTE_LENGTH; +} + +template<> +constexpr size_t +max_length<Duration>() +{ + return EXESS_MAX_DURATION_LENGTH; +} + +template<> +constexpr size_t +max_length<DateTime>() +{ + return EXESS_MAX_DATETIME_LENGTH; +} + +template<> +constexpr size_t +max_length<Time>() +{ + return EXESS_MAX_TIME_LENGTH; +} + +template<> +constexpr size_t +max_length<Date>() +{ + return EXESS_MAX_DATE_LENGTH; +} + +/** + @} +*/ + +} // namespace exess + +#endif // EXESS_EXESS_HPP diff --git a/subprojects/exess/bindings/cpp/meson.build b/subprojects/exess/bindings/cpp/meson.build new file mode 100644 index 00000000..61e3616e --- /dev/null +++ b/subprojects/exess/bindings/cpp/meson.build @@ -0,0 +1,54 @@ +add_languages(['cpp']) +cpp = meson.get_compiler('cpp') + +# Set ultra strict warnings for developers, if requested +if get_option('strict') + if cpp.get_id() == 'clang' + cpp_suppressions = [ + '-Wno-c++14-extensions', + '-Wno-c++98-compat', + '-Wno-c++98-compat-pedantic', + '-Wno-documentation-unknown-command', + '-Wno-nullability-extension', + '-Wno-padded', + ] + + elif cpp.get_id() == 'gcc' + cpp_suppressions = [ + '-Wno-inline', + '-Wno-padded', + '-Wno-switch-default', + '-Wno-unused-const-variable', + '-Wno-useless-cast', + ] + + elif cpp.get_id() == 'msvc' + cpp_suppressions = [ + '/wd4028', # formal parameter different from declaration + '/wd4204', # nonstandard extension: non-constant aggregate initializer + '/wd4706', # assignment within conditional expression + '/wd4710', # function not inlined + '/wd4711', # function selected for automatic inline expansion + '/wd4820', # padding added after data member + '/wd5045', # will insert Spectre mitigation + ] + endif + +else + if cpp.get_id() == 'clang' + cpp_suppressions = [ + '-Wno-nullability-extension', + ] + endif +endif + +exess_cpp_args = cc.get_supported_arguments(cpp_suppressions) + +cpp_headers = ['include/exess/exess.hpp'] +cpp_header_files = files(cpp_headers) + +exess_hpp_dep = declare_dependency( + dependencies: exess_dep, + include_directories: include_directories('include')) + +subdir('test') diff --git a/subprojects/exess/bindings/cpp/test/.clang-tidy b/subprojects/exess/bindings/cpp/test/.clang-tidy new file mode 100644 index 00000000..a0307839 --- /dev/null +++ b/subprojects/exess/bindings/cpp/test/.clang-tidy @@ -0,0 +1,17 @@ +Checks: > + *, + -*-magic-numbers, + -*-uppercase-literal-suffix, + -clang-analyzer-nullability.NullableDereferenced, + -cppcoreguidelines-pro-bounds-array-to-pointer-decay, + -cppcoreguidelines-pro-type-reinterpret-cast, + -fuchsia-default-arguments-calls, + -fuchsia-overloaded-operator, + -hicpp-no-array-decay, + -llvmlibc-*, + -misc-non-private-member-variables-in-classes, + -modernize-unary-static-assert, + -modernize-use-trailing-return-type, +WarningsAsErrors: '*' +HeaderFilterRegex: '.*' +FormatStyle: file diff --git a/subprojects/exess/bindings/cpp/test/meson.build b/subprojects/exess/bindings/cpp/test/meson.build new file mode 100644 index 00000000..e04c21c9 --- /dev/null +++ b/subprojects/exess/bindings/cpp/test/meson.build @@ -0,0 +1,8 @@ +test('exess_hpp', + executable('test_exess_hpp', + 'test_exess_hpp.cpp', + cpp_args: exess_cpp_args + prog_args, + dependencies: [exess_hpp_dep], + include_directories: include_directories('../../../test', + '../../../src')), + suite: 'cpp') diff --git a/subprojects/exess/bindings/cpp/test/test_exess_hpp.cpp b/subprojects/exess/bindings/cpp/test/test_exess_hpp.cpp new file mode 100644 index 00000000..e940f4b1 --- /dev/null +++ b/subprojects/exess/bindings/cpp/test/test_exess_hpp.cpp @@ -0,0 +1,221 @@ +/* + Copyright 2021 David Robillard <d@drobilla.net> + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted, provided that the above + copyright notice and this permission notice appear in all copies. + + THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#undef NDEBUG + +#include "float_test_data.h" + +#include "exess/exess.h" +#include "exess/exess.hpp" + +#include <cassert> +#include <cstdint> +#include <cstdlib> +#include <iostream> +#include <sstream> +#include <stdexcept> +#include <string> + +namespace exess { +namespace { + +void +test_status() +{ + std::ostringstream ss; + ss << Status::no_space; + + std::cerr << ss.str(); + assert(ss.str() == "Insufficient space"); +} + +void +test_read() +{ + bool a_bool = false; + assert(!read(&a_bool, "true").status); + assert(a_bool == true); + + double a_double = 0.0; + assert(!read(&a_double, "4.2E16").status); + assert(double_matches(a_double, 42000000000000000.0)); + + float a_float = 0.0f; + assert(!read(&a_float, "4.2E7").status); + assert(float_matches(a_float, 42000000.0f)); + + int64_t a_long = 0; + assert(!read(&a_long, "-4200000000").status); + assert(a_long == -4200000000); + + int32_t a_int = 0; + assert(!read(&a_int, "-42000").status); + assert(a_int == -42000); + + int16_t a_short = 0; + assert(!read(&a_short, "-420").status); + assert(a_short == -420); + + int8_t a_byte = 0; + assert(!read(&a_byte, "-42").status); + assert(a_byte == -42); + + uint64_t a_ulong = 0u; + assert(!read(&a_ulong, "4200000000").status); + assert(a_ulong == 4200000000); + + uint32_t a_uint = 0u; + assert(!read(&a_uint, "42000").status); + assert(a_uint == 42000); + + uint16_t a_ushort = 0u; + assert(!read(&a_ushort, "420").status); + assert(a_ushort == 420); + + uint8_t a_ubyte = 0u; + assert(!read(&a_ubyte, "42").status); + assert(a_ubyte == 42); +} + +void +test_to_string() +{ + assert(to_string(true) == "true"); + assert(to_string(42000000000000000.0) == "4.2E16"); + assert(to_string(42000000.0f) == "4.2E7"); + assert(to_string(int64_t(-4200000000)) == "-4200000000"); + assert(to_string(int32_t(-42000)) == "-42000"); + assert(to_string(int16_t(-420)) == "-420"); + assert(to_string(int8_t(-42)) == "-42"); + assert(to_string(uint64_t(4200000000u)) == "4200000000"); + assert(to_string(uint32_t(42000u)) == "42000"); + assert(to_string(uint16_t(420u)) == "420"); + assert(to_string(uint8_t(42u)) == "42"); +} + +void +test_max_length() +{ + static_assert(max_length<bool>() == EXESS_MAX_BOOLEAN_LENGTH, ""); + static_assert(max_length<double>() == EXESS_MAX_DOUBLE_LENGTH, ""); + static_assert(max_length<float>() == EXESS_MAX_FLOAT_LENGTH, ""); + static_assert(max_length<int64_t>() == EXESS_MAX_LONG_LENGTH, ""); + static_assert(max_length<int32_t>() == EXESS_MAX_INT_LENGTH, ""); + static_assert(max_length<int16_t>() == EXESS_MAX_SHORT_LENGTH, ""); + static_assert(max_length<int8_t>() == EXESS_MAX_BYTE_LENGTH, ""); + static_assert(max_length<uint64_t>() == EXESS_MAX_ULONG_LENGTH, ""); + static_assert(max_length<uint32_t>() == EXESS_MAX_UINT_LENGTH, ""); + static_assert(max_length<uint16_t>() == EXESS_MAX_USHORT_LENGTH, ""); + static_assert(max_length<uint8_t>() == EXESS_MAX_UBYTE_LENGTH, ""); + static_assert(max_length<Duration>() == EXESS_MAX_DURATION_LENGTH, ""); + static_assert(max_length<DateTime>() == EXESS_MAX_DATETIME_LENGTH, ""); + static_assert(max_length<Date>() == EXESS_MAX_DATE_LENGTH, ""); + static_assert(max_length<Time>() == EXESS_MAX_TIME_LENGTH, ""); +} + +template<class T> +void +check_get_throws(const Variant& variant) +{ + bool caught = false; + + try { + get<T>(variant); + } catch (const std::runtime_error&) { + caught = true; + } + + assert(caught); +} + +void +test_variant() +{ + const auto a_nothing = Variant{Status::success}; + const auto a_bool = Variant{true}; + const auto a_decimal = make_decimal(1.2); + const auto a_double = Variant{3.4}; + const auto a_float = Variant{5.6f}; + const auto a_integer = make_integer(7); + const auto a_non_positive_integer = make_non_positive_integer(-8); + const auto a_negative_integer = make_negative_integer(-9); + const auto a_long = Variant{int64_t(10)}; + const auto a_int = Variant{int32_t(11)}; + const auto a_short = Variant{int16_t(12)}; + const auto a_byte = Variant{int8_t(13)}; + const auto a_non_negative_integer = make_non_negative_integer(14u); + const auto a_ulong = Variant{uint64_t(15u)}; + const auto a_uint = Variant{uint32_t(16u)}; + const auto a_ushort = Variant{uint16_t(17u)}; + const auto a_ubyte = Variant{uint8_t(18u)}; + const auto a_positive_integer = make_positive_integer(19u); + + try { + assert(get<Status>(a_nothing) == Status::success); + assert(get<bool>(a_bool) == true); + assert(double_matches(get<double>(a_decimal), 1.2)); + assert(double_matches(get<double>(a_double), 3.4)); + assert(float_matches(get<float>(a_float), 5.6f)); + assert(get<int64_t>(a_integer) == 7); + assert(get<int64_t>(a_non_positive_integer) == -8); + assert(get<int64_t>(a_negative_integer) == -9); + assert(get<int64_t>(a_long) == 10); + assert(get<int32_t>(a_int) == 11); + assert(get<int16_t>(a_short) == 12); + assert(get<int8_t>(a_byte) == 13); + assert(get<uint64_t>(a_non_negative_integer) == 14u); + assert(get<uint64_t>(a_ulong) == 15u); + assert(get<uint32_t>(a_uint) == 16u); + assert(get<uint16_t>(a_ushort) == 17u); + assert(get<uint8_t>(a_ubyte) == 18u); + assert(get<uint64_t>(a_positive_integer) == 19u); + } catch (const std::runtime_error&) { + abort(); + } + + check_get_throws<int>(a_nothing); + check_get_throws<int>(a_bool); + check_get_throws<int>(a_double); + check_get_throws<int>(a_float); + check_get_throws<int>(a_integer); + check_get_throws<int>(a_non_positive_integer); + check_get_throws<int>(a_negative_integer); + check_get_throws<int>(a_long); + check_get_throws<bool>(a_int); + check_get_throws<int>(a_short); + check_get_throws<int>(a_byte); + check_get_throws<int>(a_non_negative_integer); + check_get_throws<int>(a_ulong); + check_get_throws<int>(a_uint); + check_get_throws<int>(a_ushort); + check_get_throws<int>(a_ubyte); + check_get_throws<int>(a_positive_integer); +} + +} // namespace +} // namespace exess + +int +main() +{ + exess::test_status(); + exess::test_read(); + exess::test_to_string(); + exess::test_max_length(); + exess::test_variant(); + + return 0; +} |