From 91f26759d6bd24cab85176d56d7422c7ef7b5a78 Mon Sep 17 00:00:00 2001 From: Mateusz Pusz Date: Thu, 1 Dec 2022 20:59:16 +0100 Subject: [PATCH] refactor: more unit tests refactored --- test/unit_test/runtime/CMakeLists.txt | 7 +- test/unit_test/runtime/almost_equals.h | 2 +- test/unit_test/runtime/math_test.cpp | 249 ++++++++--------------- test/unit_test/static/dimension_test.cpp | 100 ++++----- test/unit_test/static/reference_test.cpp | 47 +++-- test/unit_test/static/unit_test.cpp | 122 +++++------ 6 files changed, 224 insertions(+), 303 deletions(-) diff --git a/test/unit_test/runtime/CMakeLists.txt b/test/unit_test/runtime/CMakeLists.txt index 16cc33be..9d8d4156 100644 --- a/test/unit_test/runtime/CMakeLists.txt +++ b/test/unit_test/runtime/CMakeLists.txt @@ -26,8 +26,11 @@ find_package(Catch2 3 CONFIG REQUIRED) add_executable( unit_tests_runtime - # math_test.cpp - magnitude_test.cpp # fmt_test.cpp fmt_units_test.cpp distribution_test.cpp + distribution_test.cpp + fmt_test.cpp + + # fmt_units_test.cpp + math_test.cpp ) target_link_libraries(unit_tests_runtime PRIVATE mp-units::mp-units Catch2::Catch2WithMain) diff --git a/test/unit_test/runtime/almost_equals.h b/test/unit_test/runtime/almost_equals.h index 955edfd8..af0469ab 100644 --- a/test/unit_test/runtime/almost_equals.h +++ b/test/unit_test/runtime/almost_equals.h @@ -30,7 +30,7 @@ template struct AlmostEqualsMatcher : Catch::Matchers::MatcherGenericBase { AlmostEqualsMatcher(const T& target) : target_{target} {} - template U> + template U> requires std::same_as && treat_as_floating_point bool match(const U& other) const { diff --git a/test/unit_test/runtime/math_test.cpp b/test/unit_test/runtime/math_test.cpp index cf2e4c3d..06b18525 100644 --- a/test/unit_test/runtime/math_test.cpp +++ b/test/unit_test/runtime/math_test.cpp @@ -22,61 +22,64 @@ #include "almost_equals.h" #include -#include -#include -#include -#include -#include +#include #include #include +#include +#include #include using namespace units; -using namespace units::isq; -using namespace units::isq::si::literals; +using namespace units::si::unit_symbols; // classical TEST_CASE("'pow()' on quantity changes the value and the dimension accordingly", "[math][pow]") { - SECTION("'pow<0>(q)' returns '1'") { CHECK(pow<0>(2_q_m) == 1); } + SECTION("'pow<0>(q)' returns '1'") { CHECK(pow<0>(2 * isq::length[m]) == 1); } - SECTION("'pow<1>(q)' returns 'q'") { CHECK(pow<1>(2_q_m) == 2_q_m); } + SECTION("'pow<1>(q)' returns 'q'") { CHECK(pow<1>(2 * isq::length[m]) == 2 * isq::length[m]); } - SECTION("'pow<2>(q)' squares both the value and a dimension") { CHECK(pow<2>(2_q_m) == 4_q_m2); } + SECTION("'pow<2>(q)' squares both the value and a dimension") + { + CHECK(pow<2>(2 * isq::length[m]) == 4 * isq::area[m2]); + } - SECTION("'pow<3>(q)' cubes both the value and a dimension") { CHECK(pow<3>(2_q_m) == 8_q_m3); } + SECTION("'pow<3>(q)' cubes both the value and a dimension") + { + CHECK(pow<3>(2 * isq::length[m]) == 8 * isq::volume[m3]); + } } TEST_CASE("'sqrt()' on quantity changes the value and the dimension accordingly", "[math][sqrt]") { - REQUIRE(sqrt(4_q_m2) == 2_q_m); + REQUIRE(sqrt(4 * isq::area[m2]) == 2 * isq::length[m]); } TEST_CASE("'cbrt()' on quantity changes the value and the dimension accordingly", "[math][cbrt]") { - REQUIRE(cbrt(8_q_m3) == 2_q_m); + REQUIRE(cbrt(8 * isq::volume[m3]) == 2 * isq::length[m]); } TEST_CASE("'pow()' on quantity changes the value and the dimension accordingly", "[math][pow]") { - REQUIRE(pow<1, 4>(16_q_m2) == sqrt(4_q_m)); + REQUIRE(pow<1, 4>(16 * isq::area[m2]) == sqrt(4 * isq::length[m])); } TEST_CASE("absolute functions on quantity returns the absolute value", "[math][abs][fabs]") { SECTION("'abs()' on a negative quantity returns the abs") { - SECTION("integral representation") { REQUIRE(abs(-1_q_m) == 1_q_m); } + SECTION("integral representation") { REQUIRE(abs(-1 * isq::length[m]) == 1 * isq::length[m]); } - SECTION("floating-point representation") { REQUIRE(abs(-1._q_m) == 1_q_m); } + SECTION("floating-point representation") { REQUIRE(abs(-1. * isq::length[m]) == 1 * isq::length[m]); } } SECTION("'abs()' on a positive quantity returns the abs") { - SECTION("integral representation") { REQUIRE(abs(1_q_m) == 1_q_m); } + SECTION("integral representation") { REQUIRE(abs(1 * isq::length[m]) == 1 * isq::length[m]); } - SECTION("floating-point representation") { REQUIRE(abs(1._q_m) == 1_q_m); } + SECTION("floating-point representation") { REQUIRE(abs(1. * isq::length[m]) == 1 * isq::length[m]); } } } @@ -84,303 +87,219 @@ TEST_CASE("numeric_limits functions", "[limits]") { SECTION("'epsilon' works as expected using default floating type") { - REQUIRE(epsilon().number() == std::numeric_limits::epsilon()); + REQUIRE(epsilon(isq::length[m]).number() == + std::numeric_limits::epsilon()); } SECTION("'epsilon' works as expected using integers") { - REQUIRE(epsilon().number() == std::numeric_limits::epsilon()); - } - SECTION("'epsilon' works as expected using mixed Rep types") - { - REQUIRE(epsilon().number() != std::numeric_limits::epsilon()); + REQUIRE(epsilon(isq::length[m]).number() == std::numeric_limits::epsilon()); } } TEST_CASE("floor functions", "[floor]") { - SECTION("floor 1 second with target unit second should be 1 second") { REQUIRE(floor(1_q_s) == 1_q_s); } + SECTION("floor 1 second with target unit second should be 1 second") + { + REQUIRE(floor(1 * isq::time[s]) == 1 * isq::time[s]); + } SECTION("floor 1000 milliseconds with target unit second should be 1 second") { - REQUIRE(floor(1000_q_ms) == 1_q_s); + REQUIRE(floor(1000 * isq::time[ms]) == 1 * isq::time[s]); } SECTION("floor 1001 milliseconds with target unit second should be 1 second") { - REQUIRE(floor(1001_q_ms) == 1_q_s); + REQUIRE(floor(1001 * isq::time[ms]) == 1 * isq::time[s]); } SECTION("floor 1999 milliseconds with target unit second should be 1 second") { - REQUIRE(floor(1999_q_ms) == 1_q_s); + REQUIRE(floor(1999 * isq::time[ms]) == 1 * isq::time[s]); } SECTION("floor -1000 milliseconds with target unit second should be -1 second") { - REQUIRE(floor(-1000_q_ms) == -1_q_s); + REQUIRE(floor(-1000 * isq::time[ms]) == -1 * isq::time[s]); } SECTION("floor -999 milliseconds with target unit second should be -1 second") { - REQUIRE(floor(-999_q_ms) == -1_q_s); + REQUIRE(floor(-999 * isq::time[ms]) == -1 * isq::time[s]); } SECTION("floor 1.3 seconds with target unit second should be 1 second") { - REQUIRE(floor(1.3_q_s) == 1_q_s); + REQUIRE(floor(1.3 * isq::time[s]) == 1 * isq::time[s]); } SECTION("floor -1.3 seconds with target unit second should be -2 seconds") { - REQUIRE(floor(-1.3_q_s) == -2_q_s); + REQUIRE(floor(-1.3 * isq::time[s]) == -2 * isq::time[s]); } SECTION("floor 1001. milliseconds with target unit second should be 1 second") { - REQUIRE(floor(1001._q_ms) == 1_q_s); + REQUIRE(floor(1001. * isq::time[ms]) == 1 * isq::time[s]); } SECTION("floor 1999. milliseconds with target unit second should be 1 second") { - REQUIRE(floor(1999._q_ms) == 1_q_s); + REQUIRE(floor(1999. * isq::time[ms]) == 1 * isq::time[s]); } SECTION("floor -1000. milliseconds with target unit second should be -1 second") { - REQUIRE(floor(-1000._q_ms) == -1_q_s); + REQUIRE(floor(-1000. * isq::time[ms]) == -1 * isq::time[s]); } SECTION("floor -999. milliseconds with target unit second should be -1 second") { - REQUIRE(floor(-999._q_ms) == -1_q_s); - } - SECTION("floor 1 second with target quantity with unit type second should be 1 second") - { - using showtime = si::time; - REQUIRE(floor(showtime::one()) == showtime::one()); + REQUIRE(floor(-999. * isq::time[ms]) == -1 * isq::time[s]); } + + // TODO Add tests for `N`, `kN` and `kg * m / s2` i `kg * km / s2` } TEST_CASE("ceil functions", "[ceil]") { - SECTION("ceil 1 second with target unit second should be 1 second") { REQUIRE(ceil(1_q_s) == 1_q_s); } + SECTION("ceil 1 second with target unit second should be 1 second") + { + REQUIRE(ceil(1 * isq::time[s]) == 1 * isq::time[s]); + } SECTION("ceil 1000 milliseconds with target unit second should be 1 second") { - REQUIRE(ceil(1000_q_ms) == 1_q_s); + REQUIRE(ceil(1000 * isq::time[ms]) == 1 * isq::time[s]); } SECTION("ceil 1001 milliseconds with target unit second should be 2 seconds") { - REQUIRE(ceil(1001_q_ms) == 2_q_s); + REQUIRE(ceil(1001 * isq::time[ms]) == 2 * isq::time[s]); } SECTION("ceil 1999 milliseconds with target unit second should be 2 seconds") { - REQUIRE(ceil(1999_q_ms) == 2_q_s); + REQUIRE(ceil(1999 * isq::time[ms]) == 2 * isq::time[s]); } SECTION("ceil -1000 milliseconds with target unit second should be -1 second") { - REQUIRE(ceil(-1000_q_ms) == -1_q_s); + REQUIRE(ceil(-1000 * isq::time[ms]) == -1 * isq::time[s]); } SECTION("ceil -999 milliseconds with target unit second should be 0 seconds") { - REQUIRE(ceil(-999_q_ms) == 0_q_s); + REQUIRE(ceil(-999 * isq::time[ms]) == 0 * isq::time[s]); } SECTION("ceil 1.3 seconds with target unit second should be 2 seconds") { - REQUIRE(ceil(1.3_q_s) == 2_q_s); + REQUIRE(ceil(1.3 * isq::time[s]) == 2 * isq::time[s]); } SECTION("ceil -1.3 seconds with target unit second should be -1 second") { - REQUIRE(ceil(-1.3_q_s) == -1_q_s); + REQUIRE(ceil(-1.3 * isq::time[s]) == -1 * isq::time[s]); } SECTION("ceil 1001. milliseconds with target unit second should be 2 seconds") { - REQUIRE(ceil(1001._q_ms) == 2_q_s); + REQUIRE(ceil(1001. * isq::time[ms]) == 2 * isq::time[s]); } SECTION("ceil 1999. milliseconds with target unit second should be 2 seconds") { - REQUIRE(ceil(1999._q_ms) == 2_q_s); + REQUIRE(ceil(1999. * isq::time[ms]) == 2 * isq::time[s]); } SECTION("ceil -1000. milliseconds with target unit second should be -1 second") { - REQUIRE(ceil(-1000._q_ms) == -1_q_s); + REQUIRE(ceil(-1000. * isq::time[ms]) == -1 * isq::time[s]); } SECTION("ceil -999. milliseconds with target unit second should be 0 seconds") { - REQUIRE(ceil(-999._q_ms) == 0_q_s); - } - SECTION("ceil 1 second with target quantity with unit type second should be 1 second") - { - using showtime = si::time; - REQUIRE(ceil(showtime::one()) == showtime::one()); + REQUIRE(ceil(-999. * isq::time[ms]) == 0 * isq::time[s]); } } TEST_CASE("round functions", "[round]") { - SECTION("round 1 second with target unit second should be 1 second") { REQUIRE(round(1_q_s) == 1_q_s); } + SECTION("round 1 second with target unit second should be 1 second") + { + REQUIRE(round(1 * isq::time[s]) == 1 * isq::time[s]); + } SECTION("round 1000 milliseconds with target unit second should be 1 second") { - REQUIRE(round(1000_q_ms) == 1_q_s); + REQUIRE(round(1000 * isq::time[ms]) == 1 * isq::time[s]); } SECTION("round 1001 milliseconds with target unit second should be 1 second") { - REQUIRE(round(1001_q_ms) == 1_q_s); + REQUIRE(round(1001 * isq::time[ms]) == 1 * isq::time[s]); } SECTION("round 1499 milliseconds with target unit second should be 1 second") { - REQUIRE(round(1499_q_ms) == 1_q_s); + REQUIRE(round(1499 * isq::time[ms]) == 1 * isq::time[s]); } SECTION("round 1500 milliseconds with target unit second should be 2 seconds") { - REQUIRE(round(1500_q_ms) == 2_q_s); + REQUIRE(round(1500 * isq::time[ms]) == 2 * isq::time[s]); } SECTION("round 1999 milliseconds with target unit second should be 2 seconds") { - REQUIRE(round(1999_q_ms) == 2_q_s); + REQUIRE(round(1999 * isq::time[ms]) == 2 * isq::time[s]); } SECTION("round -1000 milliseconds with target unit second should be -1 second") { - REQUIRE(round(-1000_q_ms) == -1_q_s); + REQUIRE(round(-1000 * isq::time[ms]) == -1 * isq::time[s]); } SECTION("round -1001 milliseconds with target unit second should be -1 second") { - REQUIRE(round(-1001_q_ms) == -1_q_s); + REQUIRE(round(-1001 * isq::time[ms]) == -1 * isq::time[s]); } SECTION("round -1499 milliseconds with target unit second should be -1 second") { - REQUIRE(round(-1499_q_ms) == -1_q_s); + REQUIRE(round(-1499 * isq::time[ms]) == -1 * isq::time[s]); } SECTION("round -1500 milliseconds with target unit second should be -2 seconds") { - REQUIRE(round(-1500_q_ms) == -2_q_s); + REQUIRE(round(-1500 * isq::time[ms]) == -2 * isq::time[s]); } SECTION("round -1999 milliseconds with target unit second should be -2 seconds") { - REQUIRE(round(-1999_q_ms) == -2_q_s); + REQUIRE(round(-1999 * isq::time[ms]) == -2 * isq::time[s]); } SECTION("round 1000. milliseconds with target unit second should be 1 second") { - REQUIRE(round(1000._q_ms) == 1_q_s); + REQUIRE(round(1000. * isq::time[ms]) == 1 * isq::time[s]); } SECTION("round 1001. milliseconds with target unit second should be 1 second") { - REQUIRE(round(1001._q_ms) == 1_q_s); + REQUIRE(round(1001. * isq::time[ms]) == 1 * isq::time[s]); } SECTION("round 1499. milliseconds with target unit second should be 1 second") { - REQUIRE(round(1499._q_ms) == 1_q_s); + REQUIRE(round(1499. * isq::time[ms]) == 1 * isq::time[s]); } SECTION("round 1500. milliseconds with target unit second should be 2 seconds") { - REQUIRE(round(1500._q_ms) == 2_q_s); + REQUIRE(round(1500. * isq::time[ms]) == 2 * isq::time[s]); } SECTION("round 1999. milliseconds with target unit second should be 2 seconds") { - REQUIRE(round(1999._q_ms) == 2_q_s); + REQUIRE(round(1999. * isq::time[ms]) == 2 * isq::time[s]); } SECTION("round -1000. milliseconds with target unit second should be -1 second") { - REQUIRE(round(-1000._q_ms) == -1_q_s); + REQUIRE(round(-1000. * isq::time[ms]) == -1 * isq::time[s]); } SECTION("round -1001. milliseconds with target unit second should be -1 second") { - REQUIRE(round(-1001._q_ms) == -1_q_s); + REQUIRE(round(-1001. * isq::time[ms]) == -1 * isq::time[s]); } SECTION("round -1499. milliseconds with target unit second should be -1 second") { - REQUIRE(round(-1499._q_ms) == -1_q_s); + REQUIRE(round(-1499. * isq::time[ms]) == -1 * isq::time[s]); } SECTION("round -1500. milliseconds with target unit second should be -2 seconds") { - REQUIRE(round(-1500._q_ms) == -2_q_s); + REQUIRE(round(-1500. * isq::time[ms]) == -2 * isq::time[s]); } SECTION("round -1999. milliseconds with target unit second should be -2 seconds") { - REQUIRE(round(-1999._q_ms) == -2_q_s); - } - SECTION("round 1 second with target quantity with unit type second should be 1 second") - { - using showtime = si::time; - REQUIRE(round(showtime::one()) == showtime::one()); + REQUIRE(round(-1999. * isq::time[ms]) == -2 * isq::time[s]); } } TEST_CASE("hypot functions", "[hypot]") { - using namespace units::aliases::isq::si; - SECTION("hypot should work on the same quantities") { - REQUIRE(hypot(km<>(3.), km<>(4.)) == km<>(5.)); - REQUIRE(hypot(km<>(2.), km<>(3.), km<>(6.)) == km<>(7.)); + REQUIRE(hypot(3. * isq::length[km], 4. * isq::length[km]) == 5. * isq::length[km]); + REQUIRE(hypot(2. * isq::length[km], 3. * isq::length[km], 6. * isq::length[km]) == 7. * isq::length[km]); } SECTION("hypot should work with different units of the same dimension") { - REQUIRE(hypot(km<>(3.), m<>(4000.)) == km<>(5.)); - REQUIRE(hypot(km<>(2.), m<>(3000.), km<>(6.)) == km<>(7.)); - } - SECTION("hypot should work with different but equivalent dimensions") - { - REQUIRE(hypot(km<>(3.), cgs::length::cm<>(400'000.)) == km<>(5.)); - REQUIRE(hypot(km<>(2.), cgs::length::cm<>(300'000.), km<>(6.)) == km<>(7.)); - } -} - -TEST_CASE("trigonometric functions", "[trig]") -{ - using namespace units::aliases; - - SECTION("sin") - { - REQUIRE_THAT(sin(deg<>(0.)), AlmostEquals(quantity{0.})); - REQUIRE_THAT(sin(deg<>(90.)), AlmostEquals(quantity{1.})); - REQUIRE_THAT(sin(deg<>(180.)), AlmostEquals(quantity{0.})); - REQUIRE_THAT(sin(deg<>(270.)), AlmostEquals(quantity{-1.})); - - REQUIRE_THAT(sin(grad<>(0.)), AlmostEquals(quantity{0.})); - REQUIRE_THAT(sin(grad<>(100.)), AlmostEquals(quantity{1.})); - REQUIRE_THAT(sin(grad<>(200.)), AlmostEquals(quantity{0.})); - REQUIRE_THAT(sin(grad<>(300.)), AlmostEquals(quantity{-1.})); - } - - SECTION("cos") - { - REQUIRE_THAT(cos(deg<>(0.)), AlmostEquals(quantity{1.})); - REQUIRE_THAT(cos(deg<>(90.)), AlmostEquals(quantity{0.})); - REQUIRE_THAT(cos(deg<>(180.)), AlmostEquals(quantity{-1.})); - REQUIRE_THAT(cos(deg<>(270.)), AlmostEquals(quantity{0.})); - - REQUIRE_THAT(cos(grad<>(0.)), AlmostEquals(quantity{1.})); - REQUIRE_THAT(cos(grad<>(100.)), AlmostEquals(quantity{0.})); - REQUIRE_THAT(cos(grad<>(200.)), AlmostEquals(quantity{-1.})); - REQUIRE_THAT(cos(grad<>(300.)), AlmostEquals(quantity{0.})); - } - - SECTION("tan") - { - REQUIRE_THAT(tan(deg<>(0.)), AlmostEquals(quantity{0.})); - REQUIRE_THAT(tan(deg<>(45.)), AlmostEquals(quantity{1.})); - REQUIRE_THAT(tan(deg<>(135.)), AlmostEquals(quantity{-1.})); - REQUIRE_THAT(tan(deg<>(180.)), AlmostEquals(quantity{0.})); - - REQUIRE_THAT(tan(grad<>(0.)), AlmostEquals(quantity{0.})); - REQUIRE_THAT(tan(grad<>(50.)), AlmostEquals(quantity{1.})); - REQUIRE_THAT(tan(grad<>(150.)), AlmostEquals(quantity{-1.})); - REQUIRE_THAT(tan(grad<>(200.)), AlmostEquals(quantity{0.})); - } -} - -TEST_CASE("inverse trigonometric functions", "[inv trig]") -{ - using namespace units::aliases; - - SECTION("asin") - { - REQUIRE_THAT(asin(quantity{-1.}), AlmostEquals(deg<>(-90.))); - REQUIRE_THAT(asin(quantity{0.}), AlmostEquals(deg<>(0.))); - REQUIRE_THAT(asin(quantity{1.}), AlmostEquals(deg<>(90.))); - } - - SECTION("acos") - { - REQUIRE_THAT(asin(quantity{-1.}), AlmostEquals(deg<>(-90.))); - REQUIRE_THAT(asin(quantity{0.}), AlmostEquals(deg<>(0.))); - REQUIRE_THAT(asin(quantity{1.}), AlmostEquals(deg<>(90.))); - } - - SECTION("atan") - { - REQUIRE_THAT(atan(quantity{-1.}), AlmostEquals(deg<>(-45.))); - REQUIRE_THAT(atan(quantity{0.}), AlmostEquals(deg<>(0.))); - REQUIRE_THAT(atan(quantity{1.}), AlmostEquals(deg<>(45.))); + REQUIRE(hypot(3. * isq::length[km], 4000. * isq::length[m]) == 5. * isq::length[km]); + REQUIRE(hypot(2. * isq::length[km], 3000. * isq::length[m], 6. * isq::length[km]) == 7. * isq::length[km]); } } diff --git a/test/unit_test/static/dimension_test.cpp b/test/unit_test/static/dimension_test.cpp index 62e3be17..21bd2926 100644 --- a/test/unit_test/static/dimension_test.cpp +++ b/test/unit_test/static/dimension_test.cpp @@ -123,44 +123,44 @@ static_assert(is_of_type concept invalid_operations = requires { - requires !requires { t < t; }; - requires !requires { t / 2; }; - requires !requires { 2 * t; }; - requires !requires { t * 2; }; - requires !requires { t + 2; }; - requires !requires { 2 + t; }; - requires !requires { t + t; }; - requires !requires { t - 2; }; - requires !requires { 2 - t; }; - requires !requires { t - t; }; - requires !requires { t == 2; }; - requires !requires { 2 == t; }; - requires !requires { t < 2; }; - requires !requires { 2 < t; }; - requires !requires { t + time[second]; }; - requires !requires { t - time[second]; }; - requires !requires { t* time[second]; }; - requires !requires { t / time[second]; }; - requires !requires { t == time[second]; }; - requires !requires { t < time[second]; }; - requires !requires { time[second] + t; }; - requires !requires { time[second] - t; }; - requires !requires { time[second] * t; }; - requires !requires { time[second] / t; }; - requires !requires { time[second] == t; }; - requires !requires { time[second] < t; }; - requires !requires { t + 1 * time[second]; }; - requires !requires { t - 1 * time[second]; }; - requires !requires { t * 1 * time[second]; }; - requires !requires { t / 1 * time[second]; }; - requires !requires { t == 1 * time[second]; }; - requires !requires { t == 1 * time[second]; }; - requires !requires { 1 * time[second] + t; }; - requires !requires { 1 * time[second] - t; }; - requires !requires { 1 * time[second] * t; }; - requires !requires { 1 * time[second] == t; }; - requires !requires { 1 * time[second] < t; }; - }; + requires !requires { t < t; }; + requires !requires { t / 2; }; + requires !requires { 2 * t; }; + requires !requires { t * 2; }; + requires !requires { t + 2; }; + requires !requires { 2 + t; }; + requires !requires { t + t; }; + requires !requires { t - 2; }; + requires !requires { 2 - t; }; + requires !requires { t - t; }; + requires !requires { t == 2; }; + requires !requires { 2 == t; }; + requires !requires { t < 2; }; + requires !requires { 2 < t; }; + requires !requires { t + time[second]; }; + requires !requires { t - time[second]; }; + requires !requires { t* time[second]; }; + requires !requires { t / time[second]; }; + requires !requires { t == time[second]; }; + requires !requires { t < time[second]; }; + requires !requires { time[second] + t; }; + requires !requires { time[second] - t; }; + requires !requires { time[second] * t; }; + requires !requires { time[second] / t; }; + requires !requires { time[second] == t; }; + requires !requires { time[second] < t; }; + requires !requires { t + 1 * time[second]; }; + requires !requires { t - 1 * time[second]; }; + requires !requires { t * 1 * time[second]; }; + requires !requires { t / 1 * time[second]; }; + requires !requires { t == 1 * time[second]; }; + requires !requires { t == 1 * time[second]; }; + requires !requires { 1 * time[second] + t; }; + requires !requires { 1 * time[second] - t; }; + requires !requires { 1 * time[second] * t; }; + requires !requires { 1 * time[second] == t; }; + requires !requires { 1 * time[second] < t; }; +}; static_assert(invalid_operations