mpusz/mp-units
1
0
Fork 1
mirror of https://github.com/mpusz/mp-units.git synced 2025-07-29 18:07:16 +02:00
Code Issues Packages Projects Releases Wiki Activity

fix(unit test): quantity construction switched to a new syntax in unit tests

Browse Source
This commit is contained in:
Mateusz Pusz
2023-02-13 19:05:58 +01:00
parent 7160caa597
commit 6d033d72fe
5 changed files with 83 additions and 83 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
test/unit_test/runtime/fmt_test.cpp
View File

@ -562,8 +562,8 @@ TEST_CASE("fill and align specification", "[text][fmt][ostream]")
TEST_CASE("sign specification", "[text][fmt]")
{
quantity<isq::length[m]> inf(std::numeric_limits<double>::infinity());
quantity<isq::length[m]> nan(std::numeric_limits<double>::quiet_NaN());
auto inf = std::numeric_limits<double>::infinity() * si::metre;
auto nan = std::numeric_limits<double>::quiet_NaN() * si::metre;
SECTION("full format {:%Q %q} on a quantity")
{

26
test/unit_test/runtime/linear_algebra_test.cpp
View File

@ -98,27 +98,27 @@ TEST_CASE("vector quantity", "[la]")
{
SECTION("non-truncating")
{
const quantity<isq::position_vector[km], vector<int>> v{vector<int>{3, 2, 1}};
const auto v = vector<int>{3, 2, 1} * isq::position_vector[km];
CHECK(v[m].number() == vector<int>{3000, 2000, 1000});
}
SECTION("truncating")
{
const quantity<isq::position_vector[m], vector<int>> v{vector<int>{1001, 1002, 1003}};
const auto v = vector<int>{1001, 1002, 1003} * isq::position_vector[m];
CHECK(value_cast<km>(v).number() == vector<int>{1, 1, 1});
}
}
SECTION("to scalar magnitude")
{
const quantity<isq::velocity[km / h], vector<int>> v{vector<int>{2, 3, 6}};
const auto v = vector<int>{2, 3, 6} * isq::velocity[km / h];
const auto speed = get_magnitude(v.number()) * isq::speed[v.unit]; // TODO can we do better here?
CHECK(speed.number() == 7);
}
SECTION("multiply by scalar value")
{
const quantity<isq::position_vector[m], vector<int>> v{vector<int>{1, 2, 3}};
const auto v = vector<int>{1, 2, 3} * isq::position_vector[m];
SECTION("integral")
{
@ -135,7 +135,7 @@ TEST_CASE("vector quantity", "[la]")
SECTION("divide by scalar value")
{
const quantity<isq::position_vector[m], vector<int>> v{vector<int>{2, 4, 6}};
const auto v = vector<int>{2, 4, 6} * isq::position_vector[m];
SECTION("integral") { CHECK((v / 2).number() == vector<int>{1, 2, 3}); }
SECTION("floating-point") { CHECK((v / 0.5).number() == vector<double>{4., 8., 12.}); }
@ -143,39 +143,39 @@ TEST_CASE("vector quantity", "[la]")
SECTION("add")
{
const quantity<isq::position_vector[m], vector<int>> v{vector<int>{1, 2, 3}};
const auto v = vector<int>{1, 2, 3} * isq::position_vector[m];
SECTION("same unit")
{
const quantity<isq::position_vector[m], vector<int>> u{vector<int>{3, 2, 1}};
const auto u = vector<int>{3, 2, 1} * isq::position_vector[m];
CHECK((v + u).number() == vector<int>{4, 4, 4});
}
SECTION("different units")
{
const quantity<isq::position_vector[km], vector<int>> u{vector<int>{3, 2, 1}};
const auto u = vector<int>{3, 2, 1} * isq::position_vector[km];
CHECK((v + u).number() == vector<int>{3001, 2002, 1003});
}
}
SECTION("subtract")
{
const quantity<isq::position_vector[m], vector<int>> v{vector<int>{1, 2, 3}};
const auto v = vector<int>{1, 2, 3} * isq::position_vector[m];
SECTION("same unit")
{
const quantity<isq::position_vector[m], vector<int>> u{vector<int>{3, 2, 1}};
const auto u = vector<int>{3, 2, 1} * isq::position_vector[m];
CHECK((v - u).number() == vector<int>{-2, 0, 2});
}
SECTION("different units")
{
const quantity<isq::position_vector[km], vector<int>> u{vector<int>{3, 2, 1}};
const auto u = vector<int>{3, 2, 1} * isq::position_vector[km];
CHECK((v - u).number() == vector<int>{-2999, -1998, -997});
}
}
SECTION("multiply by scalar quantity")
{
const quantity<isq::velocity[m / s], vector<int>> v{vector<int>{1, 2, 3}};
const auto v = vector<int>{1, 2, 3} * isq::velocity[m / s];
SECTION("integral")
{
@ -244,7 +244,7 @@ TEST_CASE("vector quantity", "[la]")
SECTION("divide by scalar quantity")
{
const quantity<isq::position_vector[km], vector<int>> pos{vector<int>{30, 20, 10}};
const auto pos = vector<int>{30, 20, 10} * isq::position_vector[km];
SECTION("integral")
{

6
test/unit_test/static/hep_test.cpp
View File

@ -36,12 +36,12 @@ using namespace mp_units::hep::unit_symbols;
using namespace mp_units::si::unit_symbols;
// mass
static_assert(isq::mass[eV / c2](1'000) == isq::mass[keV / c2](1));
static_assert(isq::mass(1'000 * (eV / c2)) == isq::mass(1 * (keV / c2)));
// momentum
static_assert(isq::momentum[eV / c](1'000'000) == isq::momentum[MeV / c](1));
static_assert(isq::momentum(1'000'000 * (eV / c)) == isq::momentum(1 * (MeV / c)));
// area
static_assert(isq::area[b](1e28) == isq::area[m2](1.));
static_assert(isq::area(1e28 * b) == isq::area(1. * m2));
} // namespace

4
test/unit_test/static/imperial_test.cpp
View File

@ -48,8 +48,8 @@ static_assert(1 * isq::length[mi] == 8 * isq::length[fur]);
static_assert(1 * isq::length[le] == 3 * isq::length[mi]);
// International Nautical
static_assert(1 * isq::length[cb] == 100 * isq::length[ftm]));
static_assert(1 * isq::length[nmi] == 10 * isq::length[cb]));
static_assert(1 * isq::length[cb] == 100 * isq::length[ftm]);
static_assert(1 * isq::length[nmi] == 10 * isq::length[cb]);
// survey
static_assert(100 * isq::length[li] == 1 * isq::length[ch]);

126
test/unit_test/static/usc_test.cpp
View File

@ -35,87 +35,87 @@ using namespace mp_units::usc::unit_symbols;
// https://en.wikipedia.org/wiki/United_States_customary_units#Length
// International
static_assert(isq::length[twip](20) == isq::length[p](1));
static_assert(isq::length[mil](1000) == isq::length[in](1));
static_assert(isq::length[p](72) == isq::length[in](1));
static_assert(isq::length[P](1) == isq::length[p](12));
static_assert(isq::length[in](1) == isq::length[P](6));
static_assert(isq::length[ft](1) == isq::length[in](12));
static_assert(isq::length[yd](1) == isq::length[ft](3));
static_assert(isq::length[mi](1) == isq::length[ft](5280));
static_assert(isq::length[le](1) == isq::length[yd](5280));
static_assert(isq::length(20 * twip) == isq::length(1 * p));
static_assert(isq::length(1000 * mil) == isq::length(1 * in));
static_assert(isq::length(72 * p) == isq::length(1 * in));
static_assert(isq::length(1 * P) == isq::length(12 * p));
static_assert(isq::length(1 * in) == isq::length(6 * P));
static_assert(isq::length(1 * ft) == isq::length(12 * in));
static_assert(isq::length(1 * yd) == isq::length(3 * ft));
static_assert(isq::length(1 * mi) == isq::length(5280 * ft));
static_assert(isq::length(1 * le) == isq::length(5280 * yd));
// International Nautical
static_assert(isq::length[ftm](1) == isq::length[yd](2));
static_assert(isq::length[cb](1) == isq::length[ftm](120));
static_assert(isq::length[nmi](1) == isq::length[si::metre](1852));
static_assert(isq::length(1 * ftm) == isq::length(2 * yd));
static_assert(isq::length(1 * cb) == isq::length(120 * ftm));
static_assert(isq::length(1 * nmi) == isq::length(1852 * si::metre));
// US survey
UNITS_DIAGNOSTIC_PUSH
UNITS_DIAGNOSTIC_IGNORE_DEPRECATED
static_assert(isq::length[us_ft](3937) == isq::length[si::metre](1200));
static_assert(isq::length[us_mi](3937) == isq::length[si::kilo<si::metre>](6336));
static_assert(isq::length(3937 * us_ft) == isq::length(1200 * si::metre));
static_assert(isq::length(3937 * us_mi) == isq::length(6336 * si::kilo<si::metre>));
UNITS_DIAGNOSTIC_POP
static_assert(isq::length[li](50) == isq::length[ft](33));
static_assert(isq::length[rd](1) == isq::length[li](25));
static_assert(isq::length[ch](1) == isq::length[rd](4));
static_assert(isq::length[fur](1) == isq::length[ch](10));
static_assert(isq::length[lea](1) == isq::length[mi](3));
static_assert(isq::length(50 * li) == isq::length(33 * ft));
static_assert(isq::length(1 * rd) == isq::length(25 * li));
static_assert(isq::length(1 * ch) == isq::length(4 * rd));
static_assert(isq::length(1 * fur) == isq::length(10 * ch));
static_assert(isq::length(1 * lea) == isq::length(3 * mi));
static_assert(isq::length[survey1893::link](50) == isq::length[survey1893::us_survey_foot](33));
static_assert(isq::length[survey1893::us_survey_foot](3937) == isq::length[si::metre](1200));
static_assert(isq::length[survey1893::rod](1) == isq::length[survey1893::link](25));
static_assert(isq::length[survey1893::chain](1) == isq::length[survey1893::rod](4));
static_assert(isq::length[survey1893::furlong](1) == isq::length[survey1893::chain](10));
static_assert(isq::length[survey1893::us_survey_mile](1) == isq::length[survey1893::furlong](8));
static_assert(isq::length[survey1893::league](1) == isq::length[survey1893::us_survey_mile](3));
static_assert(isq::length(50 * survey1893::link) == isq::length(33 * survey1893::us_survey_foot));
static_assert(isq::length(3937 * survey1893::us_survey_foot) == isq::length(1200 * si::metre));
static_assert(isq::length(1 * survey1893::rod) == isq::length(25 * survey1893::link));
static_assert(isq::length(1 * survey1893::chain) == isq::length(4 * survey1893::rod));
static_assert(isq::length(1 * survey1893::furlong) == isq::length(10 * survey1893::chain));
static_assert(isq::length(1 * survey1893::us_survey_mile) == isq::length(8 * survey1893::furlong));
static_assert(isq::length(1 * survey1893::league) == isq::length(3 * survey1893::us_survey_mile));
// Area
// static_assert(isq::area[square<survey1893::us_survey_foot>](1) == isq::area[square<inch>](144));
static_assert(isq::area[square<survey1893::chain>](1) == isq::area[square<survey1893::us_survey_foot>](4356));
static_assert(isq::area[acre](1) == isq::area[square<survey1893::us_survey_foot>](43560));
static_assert(isq::area[section](1) == isq::area[square<survey1893::us_survey_mile>](1));
// static_assert(isq::area(1 * square<survey1893::us_survey_foot>) == isq::area(144 * square<inch>));
static_assert(isq::area(1 * square<survey1893::chain>) == isq::area(4356 * square<survey1893::us_survey_foot>));
static_assert(isq::area(1 * acre) == isq::area(43560 * square<survey1893::us_survey_foot>));
static_assert(isq::area(1 * section) == isq::area(1 * square<survey1893::us_survey_mile>));
// Volume
static_assert(isq::volume[cubic<foot>](1) == isq::volume[cubic<inch>](1'728));
static_assert(isq::volume[cubic<yard>](1) == isq::volume[cubic<foot>](27));
static_assert(isq::volume[acre * survey1893::us_survey_foot](1) ==
isq::volume[cubic<survey1893::us_survey_foot>](43'560));
static_assert(isq::volume(1 * cubic<foot>) == isq::volume(1'728 * cubic<inch>));
static_assert(isq::volume(1 * cubic<yard>) == isq::volume(27 * cubic<foot>));
static_assert(isq::volume(1 * (acre * survey1893::us_survey_foot)) ==
isq::volume(43'560 * cubic<survey1893::us_survey_foot>));
// Fluid volume
static_assert(isq::volume[fl_dr](1) == isq::volume[min](60));
static_assert(isq::volume[tsp](1) == isq::volume[min](80));
static_assert(isq::volume[tbsp](1) == isq::volume[tsp](3));
static_assert(isq::volume[fl_oz](1) == isq::volume[tbsp](2));
static_assert(isq::volume[jig](1) == isq::volume[tbsp](3));
static_assert(isq::volume[gi](1) == isq::volume[fl_oz](4));
static_assert(isq::volume[c](1) == isq::volume[gi](2));
static_assert(isq::volume[pt](1) == isq::volume[c](2));
static_assert(isq::volume[qt](1) == isq::volume[pt](2));
static_assert(isq::volume[pot](1) == isq::volume[qt](2));
static_assert(isq::volume[gal](1) == isq::volume[qt](4));
static_assert(isq::volume[bbl](2) == isq::volume[gal](63));
static_assert(isq::volume[oil_barrel](3) == isq::volume[bbl](4));
static_assert(isq::volume[hogshead](2) == isq::volume[oil_barrel](3));
static_assert(isq::volume(1 * fl_dr) == isq::volume(60 * min));
static_assert(isq::volume(1 * tsp) == isq::volume(80 * min));
static_assert(isq::volume(1 * tbsp) == isq::volume(3 * tsp));
static_assert(isq::volume(1 * fl_oz) == isq::volume(2 * tbsp));
static_assert(isq::volume(1 * jig) == isq::volume(3 * tbsp));
static_assert(isq::volume(1 * gi) == isq::volume(4 * fl_oz));
static_assert(isq::volume(1 * c) == isq::volume(2 * gi));
static_assert(isq::volume(1 * pt) == isq::volume(2 * c));
static_assert(isq::volume(1 * qt) == isq::volume(2 * pt));
static_assert(isq::volume(1 * pot) == isq::volume(2 * qt));
static_assert(isq::volume(1 * gal) == isq::volume(4 * qt));
static_assert(isq::volume(2 * bbl) == isq::volume(63 * gal));
static_assert(isq::volume(3 * oil_barrel) == isq::volume(4 * bbl));
static_assert(isq::volume(2 * hogshead) == isq::volume(3 * oil_barrel));
// Dry volume
static_assert(isq::volume[dry_qt](1) == isq::volume[dry_pt](2));
static_assert(isq::volume[dry_gal](1) == isq::volume[dry_qt](4));
static_assert(isq::volume[pk](1) == isq::volume[dry_gal](2));
static_assert(isq::volume[bu](1) == isq::volume[pk](4));
static_assert(isq::volume[dry_bbl](1) == isq::volume[cubic<inch>](7056));
static_assert(isq::volume(1 * dry_qt) == isq::volume(2 * dry_pt));
static_assert(isq::volume(1 * dry_gal) == isq::volume(4 * dry_qt));
static_assert(isq::volume(1 * pk) == isq::volume(2 * dry_gal));
static_assert(isq::volume(1 * bu) == isq::volume(4 * pk));
static_assert(isq::volume(1 * dry_bbl) == isq::volume(7056 * cubic<inch>));
// Mass
static_assert(isq::mass[gr](7'000) == isq::mass[lb](1));
static_assert(isq::mass[dr](32) == isq::mass[gr](875));
static_assert(isq::mass[oz](1) == isq::mass[dr](16));
static_assert(isq::mass[lb](1) == isq::mass[oz](16));
static_assert(isq::mass[qr](1) == isq::mass[lb](25));
static_assert(isq::mass[cwt](1) == isq::mass[qr](4));
static_assert(isq::mass[t](1) == isq::mass[cwt](20));
static_assert(isq::mass[dwt](1) == isq::mass[gr](24));
static_assert(isq::mass[oz_t](1) == isq::mass[dwt](20));
static_assert(isq::mass[lb_t](1) == isq::mass[oz_t](12));
static_assert(isq::mass(7'000 * gr) == isq::mass(1 * lb));
static_assert(isq::mass(32 * dr) == isq::mass(875 * gr));
static_assert(isq::mass(1 * oz) == isq::mass(16 * dr));
static_assert(isq::mass(1 * lb) == isq::mass(16 * oz));
static_assert(isq::mass(1 * qr) == isq::mass(25 * lb));
static_assert(isq::mass(1 * cwt) == isq::mass(4 * qr));
static_assert(isq::mass(1 * t) == isq::mass(20 * cwt));
static_assert(isq::mass(1 * dwt) == isq::mass(24 * gr));
static_assert(isq::mass(1 * oz_t) == isq::mass(20 * dwt));
static_assert(isq::mass(1 * lb_t) == isq::mass(12 * oz_t));
} // namespace