mpusz/mp-units
1
0
Fork 1
mirror of https://github.com/mpusz/mp-units.git synced 2025-08-04 20:54:28 +02:00
Code Issues Packages Projects Releases Wiki Activity

refactor: chrono_test refactored to V2

Browse Source
This commit is contained in:
Mateusz Pusz
2023-04-03 19:23:08 +02:00
parent 8da791f8ba
commit 660e62c0a6
5 changed files with 77 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
example/glide_computer/include/glide_computer.h
View File

@@ -66,7 +66,7 @@ using altitude = mp_units::quantity_point<mp_units::isq::altitude[mp_units::si::
// time
using duration = mp_units::quantity<mp_units::isq::duration[mp_units::si::second]>;
using timestamp = mp_units::quantity_point<mp_units::isq::time[mp_units::si::second],
mp_units::chrono_point_origin<std::chrono::system_clock>{}>;
mp_units::chrono_point_origin<std::chrono::system_clock>>;
// speed
using velocity = mp_units::quantity<mp_units::isq::speed[mp_units::si::kilo<mp_units::si::metre> / mp_units::si::hour]>;

6
src/core/include/mp_units/quantity.h
View File

@@ -459,7 +459,8 @@ explicit quantity(Q) -> quantity<quantity_like_traits<Q>::reference, typename qu
// non-member binary operators
template<Quantity Q1, Quantity Q2>
requires(get_kind(Q1::quantity_spec) == get_kind(Q2::quantity_spec)) &&
requires(implicitly_convertible_to(get_kind(Q1::quantity_spec), get_kind(Q2::quantity_spec)) ||
implicitly_convertible_to(get_kind(Q2::quantity_spec), get_kind(Q1::quantity_spec))) &&
detail::InvokeResultOf<common_quantity_spec(Q1::quantity_spec, Q2::quantity_spec).character, std::plus<>,
typename Q1::rep, typename Q2::rep>
[[nodiscard]] constexpr Quantity auto operator+(const Q1& lhs, const Q2& rhs)
@@ -470,7 +471,8 @@ template<Quantity Q1, Quantity Q2>
}
template<Quantity Q1, Quantity Q2>
requires(get_kind(Q1::quantity_spec) == get_kind(Q2::quantity_spec)) &&
requires(implicitly_convertible_to(get_kind(Q1::quantity_spec), get_kind(Q2::quantity_spec)) ||
implicitly_convertible_to(get_kind(Q2::quantity_spec), get_kind(Q1::quantity_spec))) &&
detail::InvokeResultOf<common_quantity_spec(Q1::quantity_spec, Q2::quantity_spec).character, std::minus<>,
typename Q1::rep, typename Q2::rep>
[[nodiscard]] constexpr Quantity auto operator-(const Q1& lhs, const Q2& rhs)

11
src/utility/include/mp_units/chrono.h
View File

@@ -66,14 +66,17 @@ struct quantity_like_traits<std::chrono::duration<Rep, Period>> {
};
template<typename C>
struct chrono_point_origin : absolute_point_origin<isq::time> {
struct chrono_point_origin_ : absolute_point_origin<isq::time> {
using clock = C;
};
template<typename C>
inline constexpr chrono_point_origin_<C> chrono_point_origin;
template<typename C, typename Rep, typename Period>
struct quantity_point_like_traits<std::chrono::time_point<C, std::chrono::duration<Rep, Period>>> {
static constexpr auto reference = isq::time[detail::time_unit_from_chrono_period<Period>()];
static constexpr auto point_origin = chrono_point_origin<C>{};
static constexpr auto point_origin = chrono_point_origin<C>;
using rep = Rep;
[[nodiscard]] static constexpr auto relative(const std::chrono::time_point<C, std::chrono::duration<Rep, Period>>& qp)
{
@@ -90,7 +93,7 @@ template<QuantityOf<isq::time> Q>
}
template<QuantityPointOf<isq::time> QP>
requires is_specialization_of<std::remove_const_t<decltype(QP::absolute_point_origin)>, chrono_point_origin>
requires is_specialization_of<std::remove_const_t<decltype(QP::absolute_point_origin)>, chrono_point_origin_>
[[nodiscard]] constexpr auto to_chrono_time_point(const QP& qp)
{
using clock = TYPENAME decltype(QP::absolute_point_origin)::clock;
@@ -98,7 +101,7 @@ template<QuantityPointOf<isq::time> QP>
constexpr auto canonical = detail::get_canonical_unit(QP::unit);
constexpr ratio r = as_ratio(canonical.mag);
using ret_type = std::chrono::time_point<clock, std::chrono::duration<rep, std::ratio<r.num, r.den>>>;
return ret_type(to_std_duration(qp.absolute()));
return ret_type(to_chrono_duration(qp.absolute()));
}
} // namespace mp_units

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

@@ -37,7 +37,7 @@ add_library(
dimension_test.cpp
# angle_test.cpp
# cgs_test.cpp
# chrono_test.cpp
chrono_test.cpp
# concepts_test.cpp
# custom_rep_test_min_expl.cpp
# custom_unit_test.cpp

127
test/unit_test/static/chrono_test.cpp
View File

@@ -21,95 +21,96 @@
// SOFTWARE.
#include "test_tools.h"
#include <units/bits/external/type_traits.h>
#include <units/chrono.h>
#include <units/isq/si/length.h>
#include <units/isq/si/speed.h>
#include <units/quantity_point.h>
#include <mp_units/bits/external/type_traits.h>
#include <mp_units/chrono.h>
#include <mp_units/quantity_point.h>
#include <mp_units/systems/si/unit_symbols.h>
#include <ratio>
namespace {
using namespace units;
using namespace units::isq;
using namespace units::isq::si::literals;
using namespace mp_units;
using namespace mp_units::si::unit_symbols;
using namespace std::chrono_literals;
using sys_seconds = std::chrono::time_point<std::chrono::system_clock, std::chrono::seconds>;
using sys_days =
std::chrono::time_point<std::chrono::system_clock,
std::chrono::duration<long, std::ratio_multiply<std::ratio<24>, std::chrono::hours::period>>>;
template<typename C, typename U, typename Rep = double>
using time_point = quantity_point<clock_origin<C>, U, Rep>;
template<Unit auto U, typename C, typename Rep = double>
using time_point = quantity_point<isq::time[U], chrono_point_origin<C>, Rep>;
static_assert(QuantityLike<std::chrono::seconds>);
static_assert(QuantityPointLike<sys_seconds>);
// construction - same rep type
static_assert(std::constructible_from<si::time<si::second, std::chrono::seconds::rep>, std::chrono::seconds>);
static_assert(!std::convertible_to<std::chrono::seconds, si::time<si::second, std::chrono::seconds::rep>>);
static_assert(std::constructible_from<si::time<si::hour, std::chrono::hours::rep>, std::chrono::hours>);
static_assert(!std::convertible_to<std::chrono::hours, si::time<si::hour, std::chrono::hours::rep>>);
static_assert(std::constructible_from<si::time<si::second, std::chrono::hours::rep>, std::chrono::hours>);
static_assert(!std::convertible_to<std::chrono::hours, si::time<si::second, std::chrono::hours::rep>>);
static_assert(!std::constructible_from<si::time<si::hour, std::chrono::seconds::rep>, std::chrono::seconds>);
static_assert(!std::convertible_to<std::chrono::seconds, si::time<si::hour, std::chrono::seconds::rep>>);
static_assert(
std::constructible_from<time_point<std::chrono::system_clock, si::second, sys_seconds::rep>, sys_seconds>);
std::constructible_from<quantity<isq::time[si::second], std::chrono::seconds::rep>, std::chrono::seconds>);
static_assert(!std::convertible_to<std::chrono::seconds, quantity<isq::time[si::second], std::chrono::seconds::rep>>);
static_assert(std::constructible_from<quantity<isq::time[si::hour], std::chrono::hours::rep>, std::chrono::hours>);
static_assert(!std::convertible_to<std::chrono::hours, quantity<isq::time[si::hour], std::chrono::hours::rep>>);
static_assert(std::constructible_from<quantity<isq::time[si::second], std::chrono::hours::rep>, std::chrono::hours>);
static_assert(!std::convertible_to<std::chrono::hours, quantity<isq::time[si::second], std::chrono::hours::rep>>);
static_assert(!std::constructible_from<quantity<isq::time[si::hour], std::chrono::seconds::rep>, std::chrono::seconds>);
static_assert(!std::convertible_to<std::chrono::seconds, quantity<isq::time[si::hour], std::chrono::seconds::rep>>);
static_assert(
!std::constructible_from<time_point<std::chrono::steady_clock, si::second, sys_seconds::rep>, sys_seconds>);
static_assert(!std::convertible_to<sys_seconds, time_point<std::chrono::system_clock, si::second, sys_seconds::rep>>);
static_assert(std::constructible_from<time_point<std::chrono::system_clock, si::day, sys_days::rep>, sys_days>);
static_assert(!std::constructible_from<time_point<std::chrono::steady_clock, si::day, sys_days::rep>, sys_days>);
static_assert(!std::convertible_to<sys_days, time_point<std::chrono::system_clock, si::day, sys_days::rep>>);
static_assert(std::constructible_from<time_point<std::chrono::system_clock, si::second, sys_days::rep>, sys_days>);
static_assert(!std::constructible_from<time_point<std::chrono::steady_clock, si::second, sys_days::rep>, sys_days>);
static_assert(!std::convertible_to<sys_days, time_point<std::chrono::system_clock, si::second, sys_days::rep>>);
static_assert(!std::constructible_from<time_point<std::chrono::system_clock, si::day, sys_seconds::rep>, sys_seconds>);
static_assert(!std::convertible_to<sys_seconds, time_point<std::chrono::system_clock, si::day, sys_seconds::rep>>);
std::constructible_from<time_point<si::second, std::chrono::system_clock, sys_seconds::rep>, sys_seconds>);
static_assert(
!std::constructible_from<time_point<si::second, std::chrono::steady_clock, sys_seconds::rep>, sys_seconds>);
static_assert(!std::convertible_to<sys_seconds, time_point<si::second, std::chrono::system_clock, sys_seconds::rep>>);
static_assert(std::constructible_from<time_point<si::day, std::chrono::system_clock, sys_days::rep>, sys_days>);
static_assert(!std::constructible_from<time_point<si::day, std::chrono::steady_clock, sys_days::rep>, sys_days>);
static_assert(!std::convertible_to<sys_days, time_point<si::day, std::chrono::system_clock, sys_days::rep>>);
static_assert(std::constructible_from<time_point<si::second, std::chrono::system_clock, sys_days::rep>, sys_days>);
static_assert(!std::constructible_from<time_point<si::second, std::chrono::steady_clock, sys_days::rep>, sys_days>);
static_assert(!std::convertible_to<sys_days, time_point<si::second, std::chrono::system_clock, sys_days::rep>>);
static_assert(!std::constructible_from<time_point<si::day, std::chrono::system_clock, sys_seconds::rep>, sys_seconds>);
static_assert(!std::convertible_to<sys_seconds, time_point<si::day, std::chrono::system_clock, sys_seconds::rep>>);
// construction - different rep type (integral to a floating-point)
static_assert(std::constructible_from<si::time<si::second>, std::chrono::seconds>);
static_assert(!std::convertible_to<std::chrono::seconds, si::time<si::second>>);
static_assert(std::constructible_from<si::time<si::second>, std::chrono::hours>);
static_assert(!std::convertible_to<std::chrono::hours, si::time<si::second>>);
static_assert(std::constructible_from<si::time<si::hour>, std::chrono::seconds>);
static_assert(!std::convertible_to<std::chrono::seconds, si::time<si::hour>>);
static_assert(std::constructible_from<time_point<std::chrono::system_clock, si::second>, sys_seconds>);
static_assert(!std::convertible_to<sys_seconds, time_point<std::chrono::system_clock, si::second>>);
static_assert(std::constructible_from<time_point<std::chrono::system_clock, si::second>, sys_days>);
static_assert(!std::convertible_to<sys_days, time_point<std::chrono::system_clock, si::second>>);
static_assert(std::constructible_from<time_point<std::chrono::system_clock, si::day>, sys_seconds>);
static_assert(!std::convertible_to<sys_seconds, time_point<std::chrono::system_clock, si::day>>);
static_assert(std::constructible_from<quantity<isq::time[si::second]>, std::chrono::seconds>);
static_assert(!std::convertible_to<std::chrono::seconds, quantity<isq::time[si::second]>>);
static_assert(std::constructible_from<quantity<isq::time[si::second]>, std::chrono::hours>);
static_assert(!std::convertible_to<std::chrono::hours, quantity<isq::time[si::second]>>);
static_assert(std::constructible_from<quantity<isq::time[si::hour]>, std::chrono::seconds>);
static_assert(!std::convertible_to<std::chrono::seconds, quantity<isq::time[si::hour]>>);
static_assert(std::constructible_from<time_point<si::second, std::chrono::system_clock>, sys_seconds>);
static_assert(!std::convertible_to<sys_seconds, time_point<si::second, std::chrono::system_clock>>);
static_assert(std::constructible_from<time_point<si::second, std::chrono::system_clock>, sys_days>);
static_assert(!std::convertible_to<sys_days, time_point<si::second, std::chrono::system_clock>>);
static_assert(std::constructible_from<time_point<si::day, std::chrono::system_clock>, sys_seconds>);
static_assert(!std::convertible_to<sys_seconds, time_point<si::day, std::chrono::system_clock>>);
// CTAD
static_assert(compare<decltype(quantity{1s}), si::time<si::second, std::chrono::seconds::rep>>);
static_assert(compare<decltype(quantity{1h}), si::time<si::hour, std::chrono::hours::rep>>);
static_assert(compare<decltype(quantity_point{sys_seconds{1s}}),
time_point<std::chrono::system_clock, si::second, sys_seconds::rep>>);
static_assert(compare<decltype(quantity_point{sys_days{sys_days::duration{1}}}),
time_point<std::chrono::system_clock, si::day, sys_days::rep>>);
static_assert(is_of_type<quantity{1s}, quantity<isq::time[si::second], std::chrono::seconds::rep>>);
static_assert(is_of_type<quantity{1h}, quantity<isq::time[si::hour], std::chrono::hours::rep>>);
static_assert(
is_of_type<quantity_point{sys_seconds{1s}}, time_point<si::second, std::chrono::system_clock, sys_seconds::rep>>);
static_assert(is_of_type<quantity_point{sys_days{sys_days::duration{1}}},
time_point<si::day, std::chrono::system_clock, sys_days::rep>>);
// operators
static_assert(quantity{1s} + 1_q_s == 2_q_s);
static_assert(quantity{1s} + 1_q_min == 61_q_s);
static_assert(10_q_m / quantity{2s} == 5_q_m_per_s);
static_assert(quantity_point{sys_seconds{1s}} + 1_q_s == time_point<std::chrono::system_clock, si::second>{2_q_s});
static_assert(quantity_point{sys_seconds{1s}} + 1_q_min == time_point<std::chrono::system_clock, si::second>{61_q_s});
static_assert(quantity{1s} + 1 * s == 2 * s);
static_assert(quantity{1s} + 1 * min == 61 * s);
static_assert(10 * m / quantity{2s} == 5 * (m / s));
static_assert(quantity_point{sys_seconds{1s}} + 1 * s ==
time_point<si::second, std::chrono::system_clock, sys_seconds::rep>{2 * s});
static_assert(quantity_point{sys_seconds{1s}} + 1 * min ==
time_point<si::second, std::chrono::system_clock, sys_seconds::rep>{61 * s});
// to_std_duration
static_assert(to_std_duration(1_q_s) == 1s);
static_assert(to_std_duration(2_q_h) == 2h);
static_assert(to_std_duration(3_q_ns) == 3ns);
static_assert(to_std_duration(quantity{1s}) == 1s);
static_assert(to_std_duration(quantity{2h}) == 2h);
static_assert(to_std_duration(quantity{3ns}) == 3ns);
static_assert(is_same_v<decltype(to_std_duration(1_q_s))::period, std::ratio<1>>);
static_assert(is_same_v<decltype(to_std_duration(2_q_h))::period, std::ratio<3600>>);
static_assert(is_same_v<decltype(to_std_duration(3_q_ns))::period, std::nano>);
static_assert(to_chrono_duration(1 * s) == 1s);
static_assert(to_chrono_duration(2 * h) == 2h);
static_assert(to_chrono_duration(3 * ns) == 3ns);
static_assert(to_chrono_duration(quantity{1s}) == 1s);
static_assert(to_chrono_duration(quantity{2h}) == 2h);
static_assert(to_chrono_duration(quantity{3ns}) == 3ns);
static_assert(is_same_v<decltype(to_chrono_duration(1 * s))::period, std::ratio<1>>);
static_assert(is_same_v<decltype(to_chrono_duration(2 * h))::period, std::ratio<3600>>);
static_assert(is_same_v<decltype(to_chrono_duration(3 * ns))::period, std::nano>);
// to_std_time_point
static_assert(to_std_time_point(quantity_point{sys_seconds{1s}}) == sys_seconds{1s});
static_assert(to_std_time_point(quantity_point{sys_days{sys_days::duration{1}}}) == sys_days{sys_days::duration{1}});
static_assert(to_chrono_time_point(quantity_point{sys_seconds{1s}}) == sys_seconds{1s});
static_assert(to_chrono_time_point(quantity_point{sys_days{sys_days::duration{1}}}) == sys_days{sys_days::duration{1}});
} // namespace