diff options
Diffstat (limited to 'domain/tests/disposition.cpp')
| -rw-r--r-- | domain/tests/disposition.cpp | 125 |
1 files changed, 125 insertions, 0 deletions
diff --git a/domain/tests/disposition.cpp b/domain/tests/disposition.cpp new file mode 100644 index 0000000..487bc5f --- /dev/null +++ b/domain/tests/disposition.cpp @@ -0,0 +1,125 @@ +#include "turns/domain/disposition.hpp" + +#include <catch2/catch_test_macros.hpp> +#include <catch2/generators/catch_generators.hpp> + +#include <compare> +#include <format> +#include <limits> +#include <utility> + +#include <glibmm/i18n.h> +#include <glibmm/init.h> + +namespace turns::domain::tests +{ + + TEST_CASE("A freshly constructed disposition", "[disposition]") + { + auto constexpr constructed_value = disposition::values::friendly; + auto instance = disposition{constructed_value}; + + SECTION("can be created") + { + REQUIRE(disposition::create(constructed_value)); + } + + SECTION("allows access to its value via the associated accessors") + { + SECTION("allowing to get it") + { + REQUIRE(instance.get_value() == constructed_value); + } + + SECTION("allowing to get it via a constant object") + { + auto const & cref = instance; + REQUIRE(cref.get_value() == constructed_value); + } + + SECTION("allowing to set it") + { + instance.set_value(disposition::values::hostile); + REQUIRE(instance.get_value() == disposition::values::hostile); + } + } + + SECTION("allows access to its value via the associated property") + { + SECTION("allowing to get it") + { + REQUIRE(instance.property_value() == constructed_value); + } + + SECTION("allowing to get it via a constant object") + { + auto const & cref = instance; + REQUIRE(cref.property_value() == constructed_value); + } + + SECTION("allowing to set it") + { + instance.property_value() = disposition::values::hostile; + REQUIRE(instance.get_value() == disposition::values::hostile); + } + } + + SECTION("allows access to its name via the associated accessors") + { + SECTION("allowing to get it") + { + REQUIRE(instance.get_presentation_name() == _("Friendly")); + } + + SECTION("allowing to get it via a constant object") + { + auto const & cref = instance; + REQUIRE(cref.get_presentation_name() == _("Friendly")); + } + } + + SECTION("can be compared with another disposition") + { + auto equal_instance = disposition{disposition::values::friendly}; + auto lesser_instance = disposition{disposition::values::neutral}; + auto greater_instance = disposition{disposition::values::hostile}; + + SECTION("yielding std::partial_ordering::equivalent for itself") + { + REQUIRE((instance <=> instance) == std::strong_ordering::equal); + } + + SECTION("yielding std::partial_ordering::equivalent for an equivalent participant") + { + REQUIRE((instance <=> equal_instance) == std::strong_ordering::equal); + } + + SECTION("yielding std::partial_ordering::greater for a lesser participant") + { + REQUIRE((instance <=> lesser_instance) == std::strong_ordering::greater); + } + + SECTION("yielding std::partial_ordering::less for a greater participant") + { + REQUIRE((instance <=> greater_instance) == std::strong_ordering::less); + } + } + } + + TEST_CASE("disposition::get_presentation_name returns the correct string", "[disposition]") + { + auto [value, name] = + GENERATE(std::pair{disposition::values::neutral, _("Neutral")}, + std::pair{disposition::values::friendly, _("Friendly")}, + std::pair{disposition::values::hostile, _("Hostile")}, + std::pair{disposition::values::secret, _("Secret")}, + std::pair{static_cast<disposition::values>(std::numeric_limits<std::underlying_type_t<disposition::values>>::max()), + _("Unknown disposition value")}); + + SECTION(std::format("the presentation name for '{}' is '{}'", static_cast<std::underlying_type_t<disposition::values>>(value), name)) + { + REQUIRE(disposition{value}.get_presentation_name() == name); + } + } + +} // namespace turns::domain::tests
\ No newline at end of file |