mpusz/mp-units
1
0
Fork 1
mirror of https://github.com/mpusz/mp-units.git synced 2025-08-05 21:24:27 +02:00
Code Issues Packages Projects Releases Wiki Activity

ci: pre-commit related changes

Browse Source
This commit is contained in:
Mateusz Pusz
2023-05-26 17:05:33 +02:00
parent 1e36d47300
commit 6458cd343c
7 changed files with 266 additions and 280 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
test/unit_test/static/CMakeLists.txt
View File

@@ -30,7 +30,7 @@ add_library(unit_tests_static_truncating quantity_test.cpp)
target_link_libraries(unit_tests_static_truncating PRIVATE mp-units::mp-units)
target_compile_options(
unit_tests_static_truncating PRIVATE $<IF:$<CXX_COMPILER_ID:MSVC>,/wd4242 /wd4244,-Wno-conversion>
unit_tests_static_truncating PRIVATE $<IF:$<CXX_COMPILER_ID:MSVC>,/wd4242 /wd4244,-Wno-conversion>
)
add_library(
unit_tests_static

66
test/unit_test/static/custom_rep_test_min_expl.cpp
View File

@@ -51,7 +51,7 @@ public:
// construction from std::int64_t
constexpr explicit min_expl(std::intmax_t v) noexcept
requires(Mode != 2)
: value_(v)
: value_(v)
{
}
@@ -187,42 +187,42 @@ static_assert(!Representation<min_expl<9>>);
// quantity's operators should mirror the representation type capabilities
template<typename Rep>
concept invalid_member_operations = requires(length<metre, Rep> lhs) {
requires !requires { +lhs; };
requires !requires { -lhs; };
requires !requires { ++lhs; };
requires !requires { lhs++; };
requires !requires { --lhs; };
requires !requires { lhs--; };
requires !requires { +lhs; };
requires !requires { -lhs; };
requires !requires { ++lhs; };
requires !requires { lhs++; };
requires !requires { --lhs; };
requires !requires { lhs--; };
requires !requires(length<metre, Rep> rhs) { lhs += rhs; };
requires !requires(length<metre, Rep> rhs) { lhs -= rhs; };
requires !requires(Rep rhs) { lhs *= rhs; };
requires !requires(Rep rhs) { lhs /= rhs; };
requires !requires(Rep rhs) { lhs %= rhs; };
requires !requires(length<metre, Rep> rhs) { lhs %= rhs; };
requires !requires(length<metre, Rep> rhs) { lhs += rhs; };
requires !requires(length<metre, Rep> rhs) { lhs -= rhs; };
requires !requires(Rep rhs) { lhs *= rhs; };
requires !requires(Rep rhs) { lhs /= rhs; };
requires !requires(Rep rhs) { lhs %= rhs; };
requires !requires(length<metre, Rep> rhs) { lhs %= rhs; };
requires !requires(length<metre, Rep> rhs) { lhs + rhs; };
requires !requires(length<metre, Rep> rhs) { lhs - rhs; };
requires !requires(Rep rhs) { lhs % rhs; };
requires !requires(length<metre, Rep> rhs) { lhs % rhs; };
requires !requires(length<metre, Rep> rhs) { lhs < rhs; };
requires !requires(length<metre, Rep> rhs) { lhs > rhs; };
requires !requires(length<metre, Rep> rhs) { lhs <= rhs; };
requires !requires(length<metre, Rep> rhs) { lhs >= rhs; };
requires !requires(length<metre, Rep> rhs) { lhs + rhs; };
requires !requires(length<metre, Rep> rhs) { lhs - rhs; };
requires !requires(Rep rhs) { lhs % rhs; };
requires !requires(length<metre, Rep> rhs) { lhs % rhs; };
requires !requires(length<metre, Rep> rhs) { lhs < rhs; };
requires !requires(length<metre, Rep> rhs) { lhs > rhs; };
requires !requires(length<metre, Rep> rhs) { lhs <= rhs; };
requires !requires(length<metre, Rep> rhs) { lhs >= rhs; };
requires !requires(length<metre, int> rhs) { lhs + rhs; };
requires !requires(length<metre, int> rhs) { lhs - rhs; };
requires !requires(int rhs) { lhs % rhs; };
requires !requires(length<metre, int> rhs) { lhs % rhs; };
requires !requires(length<metre, int> rhs) { lhs == rhs; };
requires !requires(length<metre, int> rhs) { lhs != rhs; };
requires !requires(length<metre, int> rhs) { lhs < rhs; };
requires !requires(length<metre, int> rhs) { lhs > rhs; };
requires !requires(length<metre, int> rhs) { lhs <= rhs; };
requires !requires(length<metre, int> rhs) { lhs >= rhs; };
requires !requires(length<metre, int> rhs) { lhs + rhs; };
requires !requires(length<metre, int> rhs) { lhs - rhs; };
requires !requires(int rhs) { lhs % rhs; };
requires !requires(length<metre, int> rhs) { lhs % rhs; };
requires !requires(length<metre, int> rhs) { lhs == rhs; };
requires !requires(length<metre, int> rhs) { lhs != rhs; };
requires !requires(length<metre, int> rhs) { lhs < rhs; };
requires !requires(length<metre, int> rhs) { lhs > rhs; };
requires !requires(length<metre, int> rhs) { lhs <= rhs; };
requires !requires(length<metre, int> rhs) { lhs >= rhs; };
requires !requires(std::ostream os) { os << lhs; };
};
requires !requires(std::ostream os) { os << lhs; };
};
static_assert(invalid_member_operations<min_expl<>>);
// equality

3
test/unit_test/static/fps_test.cpp
View File

@@ -100,7 +100,6 @@ static_assert(1_q_ft_pdl_per_s * 10_q_s == 10_q_ft_pdl);
static_assert(10_q_ft_pdl / 1_q_ft_pdl_per_s == 10_q_s);
static_assert(detail::unit_text<dim_power, foot_poundal_per_second>() == basic_symbol_text("ft⋅pdl/s", "ft pdl/s"));
static_assert(detail::unit_text<dim_power, foot_pound_force_per_second>() ==
basic_symbol_text("ft⋅lbf/s", "ft lbf/s"));
static_assert(detail::unit_text<dim_power, foot_pound_force_per_second>() == basic_symbol_text("ft⋅lbf/s", "ft lbf/s"));
} // namespace

16
test/unit_test/static/magnitude_test.cpp
View File

@@ -85,14 +85,14 @@ static_assert(is_named_magnitude<mag_2_>);
// power_v
template<template<auto, int, int...> typename P>
concept invalid_power_v = requires {
requires !requires { typename P<123, 0>; };
requires !requires { typename P<123, 0, 2>; };
requires !requires { typename P<123, 1, 0>; };
requires !requires { typename P<123, 0, 0>; };
requires !requires { typename P<123, 1>; };
requires !requires { typename P<123, 1, 1>; };
requires !requires { typename P<123, 5, 5>; };
};
requires !requires { typename P<123, 0>; };
requires !requires { typename P<123, 0, 2>; };
requires !requires { typename P<123, 1, 0>; };
requires !requires { typename P<123, 0, 0>; };
requires !requires { typename P<123, 1>; };
requires !requires { typename P<123, 1, 1>; };
requires !requires { typename P<123, 5, 5>; };
};
static_assert(invalid_power_v<power_v>);
// get_base

218
test/unit_test/static/quantity_kind_test.cpp
View File

@@ -110,17 +110,16 @@ static_assert(sizeof(width<metre, double>) == sizeof(double));
static_assert(sizeof(height<metre, short>) == sizeof(short));
template<typename Width>
concept invalid_types =
requires {
requires !requires { typename quantity_kind<Width, second, int>; }; // unit of a different dimension
requires !requires { typename quantity_kind<Width, metre, length<metre>>; }; // quantity used as Rep
requires !requires { // quantity point used as Rep
typename quantity_kind<Width, metre, quantity_point<dynamic_origin<dim_length>, metre>>;
};
requires !requires { typename quantity_kind<Width, metre, width<metre>>; }; // quantity kind used as Rep
requires !requires { typename quantity_kind<metre, Width, double>; }; // reordered arguments
requires !requires { typename quantity_kind<metre, double, Width>; }; // reordered arguments
concept invalid_types = requires {
requires !requires { typename quantity_kind<Width, second, int>; }; // unit of a different dimension
requires !requires { typename quantity_kind<Width, metre, length<metre>>; }; // quantity used as Rep
requires !requires { // quantity point used as Rep
typename quantity_kind<Width, metre, quantity_point<dynamic_origin<dim_length>, metre>>;
};
requires !requires { typename quantity_kind<Width, metre, width<metre>>; }; // quantity kind used as Rep
requires !requires { typename quantity_kind<metre, Width, double>; }; // reordered arguments
requires !requires { typename quantity_kind<metre, double, Width>; }; // reordered arguments
};
static_assert(invalid_types<width_kind>);
static_assert(std::is_trivially_default_constructible_v<width<metre>>);
@@ -437,45 +436,44 @@ static_assert(same((-width<metre, short>(short{1} * m)).common(), int{-1} * m));
template<typename K, typename U, typename Qx>
concept invalid_compound_assignments_ = requires(quantity_kind<K, U, int> w, Qx q) {
requires !requires { w += q; };
requires !requires { w -= q; };
requires !requires { w *= q; };
requires !requires { w /= q; };
requires !requires { w %= q; };
};
requires !requires { w += q; };
requires !requires { w -= q; };
requires !requires { w *= q; };
requires !requires { w /= q; };
requires !requires { w %= q; };
};
template<typename Width>
concept invalid_compound_assignments =
requires(quantity_kind<Width, metre, int> w, height<metre, int> h) {
requires !requires { w += 1; };
requires !requires { w -= 1; };
requires !requires { w *= 1 * (km / m); };
requires !requires { w /= 1 * (km / m); };
requires !requires { w %= 1 * (km / m); };
requires !requires { w += m; };
requires !requires { w -= m; };
requires !requires { w *= m; };
requires !requires { w /= m; };
requires !requires { w %= m; };
requires !requires {
w *= quantity_kind<downcast_kind<Width, dimension_one>, scaled_unit<mag<1000>(), one>, int>{1};
};
requires !requires {
w /= quantity_kind<downcast_kind<Width, dimension_one>, scaled_unit<mag<1000>(), one>, int>{1};
};
requires !requires {
w %= quantity_kind<downcast_kind<Width, dimension_one>, scaled_unit<mag<1000>(), one>, int>{1};
};
requires !requires { w %= 1.0; };
requires !requires { w %= quantity(1.0); };
requires !requires { w %= 1.0 * (w / w); };
requires !requires { w %= 1.0 * w; };
requires !requires { w %= h / h; };
requires invalid_compound_assignments_<Width, metre, length<metre, int>>;
requires invalid_compound_assignments_<Width, metre, height<metre, int>>;
requires invalid_compound_assignments_<Width, metre, horizontal_area<square_metre, int>>;
requires invalid_compound_assignments_<Width, metre, quantity_point<dynamic_origin<dim_length>, metre, int>>;
requires invalid_compound_assignments_<Width, metre, std::chrono::seconds>;
concept invalid_compound_assignments = requires(quantity_kind<Width, metre, int> w, height<metre, int> h) {
requires !requires { w += 1; };
requires !requires { w -= 1; };
requires !requires { w *= 1 * (km / m); };
requires !requires { w /= 1 * (km / m); };
requires !requires { w %= 1 * (km / m); };
requires !requires { w += m; };
requires !requires { w -= m; };
requires !requires { w *= m; };
requires !requires { w /= m; };
requires !requires { w %= m; };
requires !requires {
w *= quantity_kind<downcast_kind<Width, dimension_one>, scaled_unit<mag<1000>(), one>, int>{1};
};
requires !requires {
w /= quantity_kind<downcast_kind<Width, dimension_one>, scaled_unit<mag<1000>(), one>, int>{1};
};
requires !requires {
w %= quantity_kind<downcast_kind<Width, dimension_one>, scaled_unit<mag<1000>(), one>, int>{1};
};
requires !requires { w %= 1.0; };
requires !requires { w %= quantity(1.0); };
requires !requires { w %= 1.0 * (w / w); };
requires !requires { w %= 1.0 * w; };
requires !requires { w %= h / h; };
requires invalid_compound_assignments_<Width, metre, length<metre, int>>;
requires invalid_compound_assignments_<Width, metre, height<metre, int>>;
requires invalid_compound_assignments_<Width, metre, horizontal_area<square_metre, int>>;
requires invalid_compound_assignments_<Width, metre, quantity_point<dynamic_origin<dim_length>, metre, int>>;
requires invalid_compound_assignments_<Width, metre, std::chrono::seconds>;
};
static_assert(invalid_compound_assignments<width_kind>);
static_assert(invalid_compound_assignments_<time_kind, second, std::chrono::seconds>);
@@ -728,24 +726,24 @@ static_assert(std::equality_comparable_with<width<cgs::centimetre, int>, width<m
static_assert(std::equality_comparable_with<width<metre>, width<cgs::centimetre>>);
template<typename Width>
concept invalid_equality = requires(quantity_kind<Width, metre, int> w) {
requires !requires { w == 1; };
requires !requires { w != 1.0; };
requires !requires { w == 1 * m; };
requires !requires { w != 1.0 * cgs_cm; };
requires !requires { w == 1 * km; };
requires !requires { w != m; };
requires !requires { w == km; };
requires !requires { w != quantity(1); };
requires !requires { w == dimensionless<percent>(1.0); };
requires !requires { w != height<metre, int>(1 * m); };
requires !requires { w == height<kilometre, double>(1.0 * km); };
requires !requires { w != horizontal_area<square_metre, int>(1 * (m * m)); };
requires !requires { w == rate_of_climb<kilometre_per_hour, double>(1.0 * (km / h)); };
requires !requires { w != quantity_point(1 * m); };
requires !requires { w == quantity_point(1.0 * mm); };
requires !requires { w != quantity_point(quantity(1)); };
requires !requires { w == quantity_point(dimensionless<percent>(1.0)); };
};
requires !requires { w == 1; };
requires !requires { w != 1.0; };
requires !requires { w == 1 * m; };
requires !requires { w != 1.0 * cgs_cm; };
requires !requires { w == 1 * km; };
requires !requires { w != m; };
requires !requires { w == km; };
requires !requires { w != quantity(1); };
requires !requires { w == dimensionless<percent>(1.0); };
requires !requires { w != height<metre, int>(1 * m); };
requires !requires { w == height<kilometre, double>(1.0 * km); };
requires !requires { w != horizontal_area<square_metre, int>(1 * (m * m)); };
requires !requires { w == rate_of_climb<kilometre_per_hour, double>(1.0 * (km / h)); };
requires !requires { w != quantity_point(1 * m); };
requires !requires { w == quantity_point(1.0 * mm); };
requires !requires { w != quantity_point(quantity(1)); };
requires !requires { w == quantity_point(dimensionless<percent>(1.0)); };
};
static_assert(invalid_equality<width_kind>);
static_assert(width<metre, int>(1 * m) < width<metre, int>(2 * m));
@@ -760,22 +758,22 @@ static_assert(std::three_way_comparable_with<width<cgs::centimetre, int>, width<
static_assert(std::three_way_comparable_with<width<metre>, width<cgs::centimetre>>);
template<typename Width>
concept invalid_relational = requires(quantity_kind<Width, metre, int> w) {
requires !requires { w < 1; };
requires !requires { w <= 1.0; };
requires !requires { w >= 1 * m; };
requires !requires { w > 1.0 * cgs_cm; };
requires !requires { w <=> 1 * km; };
requires !requires { w < quantity(1); };
requires !requires { w <= dimensionless<percent>(1.0); };
requires !requires { w >= height<metre, int>(1 * m); };
requires !requires { w > height<kilometre, double>(1.0 * km); };
requires !requires { w <=> horizontal_area<square_metre, int>(1 * (m * m)); };
requires !requires { w < rate_of_climb<kilometre_per_hour, double>(1.0 * (km / h)); };
requires !requires { w <= quantity_point(1 * m); };
requires !requires { w >= quantity_point(1.0 * mm); };
requires !requires { w > quantity_point(quantity(1)); };
requires !requires { w <=> quantity_point(dimensionless<percent>(1.0)); };
};
requires !requires { w < 1; };
requires !requires { w <= 1.0; };
requires !requires { w >= 1 * m; };
requires !requires { w > 1.0 * cgs_cm; };
requires !requires { w <=> 1 * km; };
requires !requires { w < quantity(1); };
requires !requires { w <= dimensionless<percent>(1.0); };
requires !requires { w >= height<metre, int>(1 * m); };
requires !requires { w > height<kilometre, double>(1.0 * km); };
requires !requires { w <=> horizontal_area<square_metre, int>(1 * (m * m)); };
requires !requires { w < rate_of_climb<kilometre_per_hour, double>(1.0 * (km / h)); };
requires !requires { w <= quantity_point(1 * m); };
requires !requires { w >= quantity_point(1.0 * mm); };
requires !requires { w > quantity_point(quantity(1)); };
requires !requires { w <=> quantity_point(dimensionless<percent>(1.0)); };
};
static_assert(invalid_relational<width_kind>);
@@ -814,37 +812,35 @@ static_assert(same(quantity_kind_cast<length<centimetre, int>>(width<metre, doub
static_assert(same(quantity_kind_cast<length<centimetre, int>>(width<cgs::centimetre, int>(1 * cgs_cm)), width<cgs::centimetre, int>(1 * cgs_cm)));
// clang-format on
template<typename Width>
concept invalid_cast =
requires {
requires !requires { quantity_kind_cast<apples<one, int>>(quantity_kind<Width, metre, int>(1 * m)); };
requires !requires {
quantity_kind_cast<horizontal_area<square_metre, int>>(quantity_kind<Width, metre, int>(1 * m));
};
requires !requires {
quantity_kind_cast<rate_of_climb<metre_per_second, int>>(quantity_kind<Width, metre, int>(1 * m));
};
requires !requires { quantity_kind_cast<apple>(quantity_kind<Width, metre, int>(1 * m)); };
requires !requires { quantity_kind_cast<horizontal_area_kind>(quantity_kind<Width, metre, int>(1 * m)); };
requires !requires { quantity_kind_cast<rate_of_climb_kind>(quantity_kind<Width, metre, int>(1 * m)); };
requires !requires { quantity_kind_cast<apple, one>(quantity_kind<Width, metre, int>(1 * m)); };
requires !requires {
quantity_kind_cast<horizontal_area_kind, square_metre>(quantity_kind<Width, metre, int>(1 * m));
};
requires !requires {
quantity_kind_cast<rate_of_climb_kind, metre_per_second>(quantity_kind<Width, metre, int>(1 * m));
};
requires !requires { quantity_kind_cast<dimensionless<one>>(quantity_kind<Width, metre, int>(1 * m)); };
requires !requires { quantity_kind_cast<square_metre>(quantity_kind<Width, metre, int>(1 * m)); };
requires !requires { quantity_kind_cast<second>(quantity_kind<Width, metre, int>(1 * m)); };
requires !requires {
quantity_kind_cast<quantity_point<dynamic_origin<dim_length>, metre, int>>(
quantity_kind<Width, metre, int>(1 * m));
};
requires !requires {
quantity_kind_cast<quantity_point<dynamic_origin<dimension_one>, one, int>>(
quantity_kind<Width, metre, int>(1 * m));
};
concept invalid_cast = requires {
requires !requires { quantity_kind_cast<apples<one, int>>(quantity_kind<Width, metre, int>(1 * m)); };
requires !requires {
quantity_kind_cast<horizontal_area<square_metre, int>>(quantity_kind<Width, metre, int>(1 * m));
};
requires !requires {
quantity_kind_cast<rate_of_climb<metre_per_second, int>>(quantity_kind<Width, metre, int>(1 * m));
};
requires !requires { quantity_kind_cast<apple>(quantity_kind<Width, metre, int>(1 * m)); };
requires !requires { quantity_kind_cast<horizontal_area_kind>(quantity_kind<Width, metre, int>(1 * m)); };
requires !requires { quantity_kind_cast<rate_of_climb_kind>(quantity_kind<Width, metre, int>(1 * m)); };
requires !requires { quantity_kind_cast<apple, one>(quantity_kind<Width, metre, int>(1 * m)); };
requires !requires {
quantity_kind_cast<horizontal_area_kind, square_metre>(quantity_kind<Width, metre, int>(1 * m));
};
requires !requires {
quantity_kind_cast<rate_of_climb_kind, metre_per_second>(quantity_kind<Width, metre, int>(1 * m));
};
requires !requires { quantity_kind_cast<dimensionless<one>>(quantity_kind<Width, metre, int>(1 * m)); };
requires !requires { quantity_kind_cast<square_metre>(quantity_kind<Width, metre, int>(1 * m)); };
requires !requires { quantity_kind_cast<second>(quantity_kind<Width, metre, int>(1 * m)); };
requires !requires {
quantity_kind_cast<quantity_point<dynamic_origin<dim_length>, metre, int>>(quantity_kind<Width, metre, int>(1 * m));
};
requires !requires {
quantity_kind_cast<quantity_point<dynamic_origin<dimension_one>, one, int>>(
quantity_kind<Width, metre, int>(1 * m));
};
};
static_assert(invalid_cast<width_kind>);

190
test/unit_test/static/quantity_point_kind_test.cpp
View File

@@ -150,21 +150,20 @@ static_assert(sizeof(abscissa<metre, double>) == sizeof(double));
static_assert(sizeof(ordinate<metre, short>) == sizeof(short));
template<typename Width, typename Abscissa>
concept invalid_types =
requires {
requires !requires { typename quantity_point_kind<Width, metre, int>; }; // width_kind is not a point kind
requires !requires { typename quantity_point_kind<Abscissa, second, int>; }; // unit of a different dimension
requires !requires { typename quantity_point_kind<Abscissa, metre, length<metre>>; }; // quantity used as Rep
requires !requires {
typename quantity_point_kind<Abscissa, metre, quantity_point<dynamic_origin<dim_length>, metre>>;
}; // quantity point used as Rep
requires !requires { typename quantity_point_kind<Abscissa, metre, width<metre>>; }; // quantity kind used as Rep
requires !requires {
typename quantity_point_kind<Abscissa, metre, abscissa<metre>>;
}; // quantity point kind used as Rep
requires !requires { typename quantity_point_kind<metre, Abscissa, double>; }; // reordered arguments
requires !requires { typename quantity_point_kind<metre, double, Abscissa>; }; // reordered arguments
};
concept invalid_types = requires {
requires !requires { typename quantity_point_kind<Width, metre, int>; }; // width_kind is not a point kind
requires !requires { typename quantity_point_kind<Abscissa, second, int>; }; // unit of a different dimension
requires !requires { typename quantity_point_kind<Abscissa, metre, length<metre>>; }; // quantity used as Rep
requires !requires {
typename quantity_point_kind<Abscissa, metre, quantity_point<dynamic_origin<dim_length>, metre>>;
}; // quantity point used as Rep
requires !requires { typename quantity_point_kind<Abscissa, metre, width<metre>>; }; // quantity kind used as Rep
requires !requires {
typename quantity_point_kind<Abscissa, metre, abscissa<metre>>;
}; // quantity point kind used as Rep
requires !requires { typename quantity_point_kind<metre, Abscissa, double>; }; // reordered arguments
requires !requires { typename quantity_point_kind<metre, double, Abscissa>; }; // reordered arguments
};
static_assert(invalid_types<width_kind, abscissa_kind>);
static_assert(std::is_trivially_default_constructible_v<abscissa<metre>>);
@@ -474,20 +473,19 @@ static_assert([]() {
template<typename PK, typename U, typename Qx>
concept invalid_compound_assignments_ = requires(quantity_point_kind<PK, U, int> x, Qx q) {
requires !requires { x += q; };
requires !requires { x -= q; };
};
requires !requires { x += q; };
requires !requires { x -= q; };
};
template<typename Abscissa>
concept invalid_compound_assignments =
requires(quantity_point_kind<Abscissa, metre, int> x) {
requires !requires { x += 1; };
requires !requires { x -= 1; };
requires invalid_compound_assignments_<Abscissa, metre, length<metre, int>>;
requires invalid_compound_assignments_<Abscissa, metre, height<metre, int>>;
requires invalid_compound_assignments_<Abscissa, metre, rate_of_climb<metre_per_second, int>>;
requires invalid_compound_assignments_<Abscissa, metre, quantity_point<dynamic_origin<dim_length>, metre, int>>;
requires invalid_compound_assignments_<Abscissa, metre, std::chrono::seconds>;
};
concept invalid_compound_assignments = requires(quantity_point_kind<Abscissa, metre, int> x) {
requires !requires { x += 1; };
requires !requires { x -= 1; };
requires invalid_compound_assignments_<Abscissa, metre, length<metre, int>>;
requires invalid_compound_assignments_<Abscissa, metre, height<metre, int>>;
requires invalid_compound_assignments_<Abscissa, metre, rate_of_climb<metre_per_second, int>>;
requires invalid_compound_assignments_<Abscissa, metre, quantity_point<dynamic_origin<dim_length>, metre, int>>;
requires invalid_compound_assignments_<Abscissa, metre, std::chrono::seconds>;
};
static_assert(invalid_compound_assignments<abscissa_kind>);
static_assert(invalid_compound_assignments_<time_point_kind, second, std::chrono::seconds>);
#if __cpp_lib_chrono >= 201907L
@@ -564,26 +562,26 @@ static_assert(std::equality_comparable_with<abscissa<metre>, abscissa<cgs::centi
// clang-format on
template<typename Int>
concept invalid_equality = requires(quantity_point_kind<abscissa_kind, metre, Int> x, Int i) {
requires !requires { x == 1; };
requires !requires { x != 1.0; };
requires !requires { x == 1 * m; };
requires !requires { x != 1.0 * cgs_cm; };
requires !requires { x == 1 * km; };
requires !requires { x != quantity(1); };
requires !requires { x == dimensionless<percent>(1.0); };
requires !requires { x != width<metre, int>(1 * m); };
requires !requires { x == width<kilometre, double>(1.0 * km); };
requires !requires { x != height<metre, int>(1 * m); };
requires !requires { x == height<kilometre, double>(1.0 * km); };
requires !requires { x == rate_of_climb<kilometre_per_hour, double>(1.0 * (km / h)); };
requires !requires { x != quantity_point(1 * m); };
requires !requires { x == quantity_point(1.0 * mm); };
requires !requires { x != quantity_point(quantity(1)); };
requires !requires { x == quantity_point(dimensionless<percent>(1.0)); };
requires !requires { x != quantity_point_kind(cgs_width<metre, int>(1 * m)); };
requires !requires { x == ordinate<metre, int>(1 * m); };
requires !requires { screen_si_width<metre, Int>{} != screen_si_cgs_width<metre, Int>{}; };
};
requires !requires { x == 1; };
requires !requires { x != 1.0; };
requires !requires { x == 1 * m; };
requires !requires { x != 1.0 * cgs_cm; };
requires !requires { x == 1 * km; };
requires !requires { x != quantity(1); };
requires !requires { x == dimensionless<percent>(1.0); };
requires !requires { x != width<metre, int>(1 * m); };
requires !requires { x == width<kilometre, double>(1.0 * km); };
requires !requires { x != height<metre, int>(1 * m); };
requires !requires { x == height<kilometre, double>(1.0 * km); };
requires !requires { x == rate_of_climb<kilometre_per_hour, double>(1.0 * (km / h)); };
requires !requires { x != quantity_point(1 * m); };
requires !requires { x == quantity_point(1.0 * mm); };
requires !requires { x != quantity_point(quantity(1)); };
requires !requires { x == quantity_point(dimensionless<percent>(1.0)); };
requires !requires { x != quantity_point_kind(cgs_width<metre, int>(1 * m)); };
requires !requires { x == ordinate<metre, int>(1 * m); };
requires !requires { screen_si_width<metre, Int>{} != screen_si_cgs_width<metre, Int>{}; };
};
static_assert(invalid_equality<int>);
// clang-format off
@@ -599,28 +597,27 @@ static_assert(std::three_way_comparable_with<abscissa<cgs::centimetre, int>, abs
static_assert(std::three_way_comparable_with<abscissa<metre>, abscissa<cgs::centimetre>>);
// clang-format on
template<typename Int>
concept invalid_relational =
requires(quantity_point_kind<abscissa_kind, metre, Int> x, Int i) {
requires !requires { x < 1; };
requires !requires { x <= 1.0; };
requires !requires { x >= 1 * m; };
requires !requires { x > 1.0 * cgs_cm; };
requires !requires { x <=> 1 * km; };
requires !requires { x < quantity(1); };
requires !requires { x <= dimensionless<percent>(1.0); };
requires !requires { x >= width<metre, int>(1 * m); };
requires !requires { x > width<kilometre, double>(1.0 * km); };
requires !requires { x <=> height<metre, int>(1 * m); };
requires !requires { x < height<kilometre, double>(1.0 * km); };
requires !requires { x <= rate_of_climb<kilometre_per_hour, double>(1.0 * (km / h)); };
requires !requires { x >= quantity_point(1 * m); };
requires !requires { x > quantity_point(1.0 * mm); };
requires !requires { x <=> quantity_point(quantity(1)); };
requires !requires { x < quantity_point(dimensionless<percent>(1.0)); };
requires !requires { x <= quantity_point_kind(cgs_width<metre, int>(1 * m)); };
requires !requires { x >= ordinate<metre, int>(1 * m); };
requires !requires { screen_si_width<metre, Int>{} > screen_si_cgs_width<metre, Int>{}; };
};
concept invalid_relational = requires(quantity_point_kind<abscissa_kind, metre, Int> x, Int i) {
requires !requires { x < 1; };
requires !requires { x <= 1.0; };
requires !requires { x >= 1 * m; };
requires !requires { x > 1.0 * cgs_cm; };
requires !requires { x <=> 1 * km; };
requires !requires { x < quantity(1); };
requires !requires { x <= dimensionless<percent>(1.0); };
requires !requires { x >= width<metre, int>(1 * m); };
requires !requires { x > width<kilometre, double>(1.0 * km); };
requires !requires { x <=> height<metre, int>(1 * m); };
requires !requires { x < height<kilometre, double>(1.0 * km); };
requires !requires { x <= rate_of_climb<kilometre_per_hour, double>(1.0 * (km / h)); };
requires !requires { x >= quantity_point(1 * m); };
requires !requires { x > quantity_point(1.0 * mm); };
requires !requires { x <=> quantity_point(quantity(1)); };
requires !requires { x < quantity_point(dimensionless<percent>(1.0)); };
requires !requires { x <= quantity_point_kind(cgs_width<metre, int>(1 * m)); };
requires !requires { x >= ordinate<metre, int>(1 * m); };
requires !requires { screen_si_width<metre, Int>{} > screen_si_cgs_width<metre, Int>{}; };
};
static_assert(invalid_relational<int>);
@@ -672,35 +669,32 @@ static_assert(comp(quantity_point_kind_cast<length<centimetre, int>>(abscissa<cg
static_assert(same(quantity_point_kind_cast<screen_si_cgs_width<metre, int>>(screen_si_width<metre, int>(1 * m)), screen_si_cgs_width<metre, int>(1 * m)));
// clang-format on
template<typename Int>
concept invalid_cast =
requires(Int i) {
requires !requires { quantity_point_kind_cast<apples<one, Int>>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<rate_of_climb<metre_per_second, Int>>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<apple>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<rate_of_climb_kind>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<apple, one>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<width_kind, metre>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<width_kind, kilometre>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<height_kind, metre>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<height_kind, kilometre>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<cgs_width_kind, cgs::centimetre>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<rate_of_climb_kind, metre_per_second>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<dimensionless<one>>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<square_metre>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<second>(abscissa<metre, Int>(i * m)); };
requires !requires {
quantity_point_kind_cast<quantity_point<dynamic_origin<dim_length>, metre, Int>>(
abscissa<metre, Int>(i * m));
};
requires !requires {
quantity_point_kind_cast<quantity_point<dynamic_origin<dim_one>, one, Int>>(
abscissa<metre, Int>(i * m));
};
requires !requires {
quantity_point_kind_cast<quantity_point<dynamic_origin<dim_length>, metre, Int>>(
screen_si_width<metre, Int>(i * m));
};
concept invalid_cast = requires(Int i) {
requires !requires { quantity_point_kind_cast<apples<one, Int>>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<rate_of_climb<metre_per_second, Int>>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<apple>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<rate_of_climb_kind>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<apple, one>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<width_kind, metre>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<width_kind, kilometre>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<height_kind, metre>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<height_kind, kilometre>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<cgs_width_kind, cgs::centimetre>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<rate_of_climb_kind, metre_per_second>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<dimensionless<one>>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<square_metre>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<second>(abscissa<metre, Int>(i * m)); };
requires !requires {
quantity_point_kind_cast<quantity_point<dynamic_origin<dim_length>, metre, Int>>(abscissa<metre, Int>(i * m));
};
requires !requires {
quantity_point_kind_cast<quantity_point<dynamic_origin<dim_one>, one, Int>>(abscissa<metre, Int>(i * m));
};
requires !requires {
quantity_point_kind_cast<quantity_point<dynamic_origin<dim_length>, metre, Int>>(
screen_si_width<metre, Int>(i * m));
};
};
static_assert(invalid_cast<int>);

51
test/unit_test/static/quantity_point_test.cpp
View File

@@ -46,22 +46,20 @@ struct sea_level_origin : point_origin<dim_length> {};
// class invariants
template<typename DimLength>
concept invalid_types =
requires {
// unit of a different dimension:
requires !requires { typename quantity_point<dynamic_origin<DimLength>, second, int>; };
// quantity used as Rep:
requires !requires { typename quantity_point<dynamic_origin<DimLength>, metre, quantity<DimLength, metre, int>>; };
// quantity point used as Rep:
requires !requires {
typename quantity_point<dynamic_origin<DimLength>, metre,
quantity_point<dynamic_origin<DimLength>, metre, int>>;
};
// reordered arguments:
requires !requires { typename quantity_point<metre, dynamic_origin<DimLength>, double>; };
// dimension used as origin:
requires !requires { typename quantity_point<DimLength, second, int>; };
concept invalid_types = requires {
// unit of a different dimension:
requires !requires { typename quantity_point<dynamic_origin<DimLength>, second, int>; };
// quantity used as Rep:
requires !requires { typename quantity_point<dynamic_origin<DimLength>, metre, quantity<DimLength, metre, int>>; };
// quantity point used as Rep:
requires !requires {
typename quantity_point<dynamic_origin<DimLength>, metre, quantity_point<dynamic_origin<DimLength>, metre, int>>;
};
// reordered arguments:
requires !requires { typename quantity_point<metre, dynamic_origin<DimLength>, double>; };
// dimension used as origin:
requires !requires { typename quantity_point<DimLength, second, int>; };
};
static_assert(invalid_types<dim_length>);
@@ -237,9 +235,9 @@ static_assert(quantity_point(1000_q_m) <= quantity_point(1_q_km));
template<typename Int>
concept invalid_comparisons = requires(quantity_point<dynamic_origin<dim_length>, metre, Int> lhs,
quantity_point<sea_level_origin, metre, Int> rhs) {
requires !requires { lhs == rhs; };
requires !requires { lhs < rhs; };
};
requires !requires { lhs == rhs; };
requires !requires { lhs < rhs; };
};
static_assert(invalid_comparisons<int>);
// alias units
@@ -295,16 +293,15 @@ static_assert(
quantity_point_cast<dim_speed, kilometre_per_hour>(quantity_point(2000.0_q_m / 3600.0_q_s)).relative().number() == 2);
template<typename Int>
concept invalid_cast =
requires(Int i) {
requires !requires {
quantity_point_cast<quantity_point<dynamic_origin<dim_time>, second, Int>>(quantity_point(i * m));
};
requires !requires {
quantity_point_cast<quantity_point<dynamic_origin<dim_length>, metre, Int>>(
quantity_point<sea_level_origin, metre, Int>(i * m));
};
concept invalid_cast = requires(Int i) {
requires !requires {
quantity_point_cast<quantity_point<dynamic_origin<dim_time>, second, Int>>(quantity_point(i * m));
};
requires !requires {
quantity_point_cast<quantity_point<dynamic_origin<dim_length>, metre, Int>>(
quantity_point<sea_level_origin, metre, Int>(i * m));
};
};
static_assert(invalid_cast<int>);
// time