feedc0de/mp-units
1
0
Fork 0
forked from mpusz/mp-units
Code Pull Requests Activity

refactor: 💥 q_* UDL renamed to _q_*

Browse Source 
We had some fun exploring the STD UDLs for potential collisions,
we have learnt our lesson and know how to proceed.
Now is high time to start behaving and obeying C++ rules.
This commit is contained in:
Mateusz Pusz
2020-09-09 19:20:35 +02:00
parent 2b408f19c0
commit 9527b39005
130 changed files with 2221 additions and 2235 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/unit_test/runtime/digital_info_test.cpp
+4 -4
View File
@@ -34,25 +34,25 @@ TEST_CASE("operator<< on a data quantity", "[text][ostream]")
{
SECTION("named unit")
{
stream << 64q_B;
stream << 64_q_B;
REQUIRE(stream.str() == "64 B");
}
SECTION("prefixed coherent unit")
{
stream << 256q_Kib;
stream << 256_q_Kib;
REQUIRE(stream.str() == "256 Kib");
}
SECTION("prefixed non-coherent unit")
{
stream << 1024q_KiB;
stream << 1024_q_KiB;
REQUIRE(stream.str() == "1024 KiB");
}
SECTION("other unit matching prefix")
{
stream << 8q_Kib * 8q_Kib / 2q_b;
stream << 8_q_Kib * 8_q_Kib / 2_q_b;
REQUIRE(stream.str() == "32 Mib");
}
}
test/unit_test/runtime/distribution_test.cpp
+8 -8
View File
@@ -498,7 +498,7 @@ TEST_CASE("piecewise_constant_distribution")
using q = length<metre, rep>;
std::vector<rep> intervals_rep_vec = {1.0, 2.0, 3.0};
std::vector<q> intervals_qty_vec = {1.0q_m, 2.0q_m, 3.0q_m};
std::vector<q> intervals_qty_vec = {1.0_q_m, 2.0_q_m, 3.0_q_m};
SECTION("default")
{
@@ -515,7 +515,7 @@ TEST_CASE("piecewise_constant_distribution")
SECTION ("parametrized_input_it") {
constexpr std::array<rep, 3> intervals_rep = {1.0, 2.0, 3.0};
constexpr std::array<q, 3> intervals_qty = {1.0q_m, 2.0q_m, 3.0q_m};
constexpr std::array<q, 3> intervals_qty = {1.0_q_m, 2.0_q_m, 3.0_q_m};
constexpr std::array<rep, 3> weights = {1.0, 2.0, 3.0};
auto stl_dist = std::piecewise_constant_distribution<rep>(intervals_rep.cbegin(), intervals_rep.cend(), weights.cbegin());
@@ -528,7 +528,7 @@ TEST_CASE("piecewise_constant_distribution")
SECTION ("parametrized_initializer_list") {
std::initializer_list<rep> intervals_rep = {1.0, 2.0, 3.0};
std::initializer_list<q> intervals_qty = {1.0q_m, 2.0q_m, 3.0q_m};
std::initializer_list<q> intervals_qty = {1.0_q_m, 2.0_q_m, 3.0_q_m};
auto stl_dist = std::piecewise_constant_distribution<rep>(intervals_rep, [](rep val) { return val; });
auto units_dist = units::piecewise_constant_distribution<q>(intervals_qty, [](q qty) { return qty.count(); });
@@ -540,7 +540,7 @@ TEST_CASE("piecewise_constant_distribution")
SECTION ("parametrized_range") {
constexpr std::size_t nw = 2;
constexpr rep xmin_rep = 1.0, xmax_rep = 3.0;
constexpr q xmin_qty = 1.0q_m, xmax_qty = 3.0q_m;
constexpr q xmin_qty = 1.0_q_m, xmax_qty = 3.0_q_m;
auto stl_dist = std::piecewise_constant_distribution<rep>(nw, xmin_rep, xmax_rep, [](rep val) { return val; });
auto units_dist = units::piecewise_constant_distribution<q>(nw, xmin_qty, xmax_qty, [](q qty) { return qty.count(); });
@@ -556,7 +556,7 @@ TEST_CASE("piecewise_linear_distribution")
using q = length<metre, rep>;
std::vector<rep> intervals_rep_vec = {1.0, 2.0, 3.0};
std::vector<q> intervals_qty_vec = {1.0q_m, 2.0q_m, 3.0q_m};
std::vector<q> intervals_qty_vec = {1.0_q_m, 2.0_q_m, 3.0_q_m};
SECTION("default")
{
@@ -573,7 +573,7 @@ TEST_CASE("piecewise_linear_distribution")
SECTION ("parametrized_input_it") {
constexpr std::array<rep, 3> intervals_rep = {1.0, 2.0, 3.0};
constexpr std::array<q, 3> intervals_qty = {1.0q_m, 2.0q_m, 3.0q_m};
constexpr std::array<q, 3> intervals_qty = {1.0_q_m, 2.0_q_m, 3.0_q_m};
constexpr std::array<rep, 3> weights = {1.0, 2.0, 3.0};
auto stl_dist = std::piecewise_linear_distribution<rep>(intervals_rep.cbegin(), intervals_rep.cend(), weights.cbegin());
@@ -586,7 +586,7 @@ TEST_CASE("piecewise_linear_distribution")
SECTION ("parametrized_initializer_list") {
std::initializer_list<rep> intervals_rep = {1.0, 2.0, 3.0};
std::initializer_list<q> intervals_qty = {1.0q_m, 2.0q_m, 3.0q_m};
std::initializer_list<q> intervals_qty = {1.0_q_m, 2.0_q_m, 3.0_q_m};
auto stl_dist = std::piecewise_linear_distribution<rep>(intervals_rep, [](rep val) { return val; });
auto units_dist = units::piecewise_linear_distribution<q>(intervals_qty, [](q qty) { return qty.count(); });
@@ -598,7 +598,7 @@ TEST_CASE("piecewise_linear_distribution")
SECTION ("parametrized_range") {
constexpr std::size_t nw = 2;
constexpr rep xmin_rep = 1.0, xmax_rep = 3.0;
constexpr q xmin_qty = 1.0q_m, xmax_qty = 3.0q_m;
constexpr q xmin_qty = 1.0_q_m, xmax_qty = 3.0_q_m;
auto stl_dist = std::piecewise_linear_distribution<rep>(nw, xmin_rep, xmax_rep, [](rep val) { return val; });
auto units_dist = units::piecewise_linear_distribution<q>(nw, xmin_qty, xmax_qty, [](q qty) { return qty.count(); });
test/unit_test/runtime/fmt_test.cpp
+170 -170
View File
@@ -49,7 +49,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
{
SECTION("integral representation")
{
const auto q = 60q_W;
const auto q = 60_q_W;
os << q;
SECTION("iostream")
@@ -70,7 +70,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("floating-point representation")
{
const auto q = 1023.5q_Pa;
const auto q = 1023.5_q_Pa;
os << q;
SECTION("iostream")
@@ -92,7 +92,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("quantity with a predefined prefixed unit")
{
const auto q = 125q_us;
const auto q = 125_q_us;
os << q;
SECTION("iostream")
@@ -158,7 +158,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("quantity with an alias unit")
{
const auto q = 2q_l;
const auto q = 2_q_l;
os << q;
SECTION("iostream")
@@ -179,7 +179,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("quantity with a prefixed alias unit")
{
const auto q = 2q_ml;
const auto q = 2_q_ml;
os << q;
SECTION("iostream")
@@ -204,7 +204,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
{
SECTION("acceleration")
{
const auto q = 20q_m / 2q_s / 1q_s;
const auto q = 20_q_m / 2_q_s / 1_q_s;
os << q;
SECTION("iostream")
@@ -225,7 +225,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("volume")
{
const auto q = 2q_m * 1q_m * 1q_m;
const auto q = 2_q_m * 1_q_m * 1_q_m;
os << q;
SECTION("iostream")
@@ -246,7 +246,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("surface tension")
{
const auto q = 20q_N / 2q_m;
const auto q = 20_q_N / 2_q_m;
os << q;
SECTION("iostream")
@@ -270,7 +270,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
{
SECTION("speed")
{
const auto q = 20q_km / 2q_h;
const auto q = 20_q_km / 2_q_h;
os << q;
SECTION("iostream")
@@ -317,7 +317,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
{
SECTION("unit::ratio as an SI prefix for a dimension with a special symbol")
{
const auto q = 4q_N * 2q_cm;
const auto q = 4_q_N * 2_q_cm;
os << q;
SECTION("iostream")
@@ -338,7 +338,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("unit::ratio for a dimension without a special symbol")
{
const auto q = 2q_um * 2q_cm * 2q_cm;
const auto q = 2_q_um * 2_q_cm * 2_q_cm;
os << q;
SECTION("iostream")
@@ -359,7 +359,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("unit::ratio::num != 1 && unit::ratio::den == 1")
{
const auto q = 4 * 2q_min / (2q_s * 2q_s);
const auto q = 4 * 2_q_min / (2_q_s * 2_q_s);
os << q;
SECTION("iostream")
@@ -380,7 +380,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("unit::ratio::num == 1 && unit::ratio::den != 1")
{
const auto q = 20q_J / 2q_min;
const auto q = 20_q_J / 2_q_min;
os << q;
SECTION("iostream")
@@ -401,7 +401,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("unit::ratio::num != 1 && unit::ratio::den != 1")
{
const auto q = 60q_kJ / 2q_min;
const auto q = 60_q_kJ / 2_q_min;
os << q;
SECTION("iostream")
@@ -425,7 +425,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
{
SECTION("one with ratio == 1")
{
const auto q = 4q_m / 2q_m;
const auto q = 4_q_m / 2_q_m;
os << q;
SECTION("iostream")
@@ -446,7 +446,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("one with ratio.exp != 0")
{
const auto q = 4q_km / 2q_m;
const auto q = 4_q_km / 2_q_m;
os << q;
SECTION("iostream")
@@ -467,7 +467,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("percents")
{
const auto q = quantity_cast<percent>(15.q_m / 100.q_m);
const auto q = quantity_cast<percent>(15._q_m / 100._q_m);
os << q;
SECTION("iostream")
@@ -493,7 +493,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
{
SECTION("SI base units")
{
const auto q = 2q_s * 2q_m * 2q_kg;
const auto q = 2_q_s * 2_q_m * 2_q_kg;
os << q;
SECTION("iostream")
@@ -514,7 +514,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("CGS base units")
{
const auto q = 2.q_s * cgs::length<cgs::centimetre>(2) * cgs::mass<cgs::gram>(2);
const auto q = 2._q_s * cgs::length<cgs::centimetre>(2) * cgs::mass<cgs::gram>(2);
os << q;
SECTION("iostream")
@@ -536,7 +536,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("unit::ratio as an SI prefix")
{
const auto q = 4q_km * 2q_s;
const auto q = 4_q_km * 2_q_s;
os << q;
SECTION("iostream")
@@ -557,7 +557,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("unit::ratio::num != 1 && unit::ratio::den == 1")
{
const auto q = 4q_kg * 2q_min / (2q_s * 2q_s);
const auto q = 4_q_kg * 2_q_min / (2_q_s * 2_q_s);
os << q;
SECTION("iostream")
@@ -578,7 +578,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("unit::ratio::num == 1 && unit::ratio::den != 1")
{
const auto q = 20q_kg / 2q_min;
const auto q = 20_q_kg / 2_q_min;
os << q;
SECTION("iostream")
@@ -599,7 +599,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("CGS base units")
{
const auto q = 2.q_s * cgs::length<si::metre>(2) * cgs::mass<si::kilogram>(2);
const auto q = 2._q_s * cgs::length<si::metre>(2) * cgs::mass<si::kilogram>(2);
os << q;
SECTION("iostream")
@@ -620,7 +620,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("unit::ratio::num != 1 && unit::ratio::den != 1")
{
const auto q = 60q_min / 2q_km;
const auto q = 60_q_min / 2_q_km;
os << q;
SECTION("iostream")
@@ -641,7 +641,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("exponent::num == 1 && exponent::den == 1")
{
const auto q = 4q_m * 2q_s;
const auto q = 4_q_m * 2_q_s;
os << q;
SECTION("iostream")
@@ -662,7 +662,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("exponent::num == 2 && exponent::den == 1 for positive exponent")
{
const auto q = 4q_m * 2q_s * 2q_s;
const auto q = 4_q_m * 2_q_s * 2_q_s;
os << q;
SECTION("iostream")
@@ -683,7 +683,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("exponent::num == 2 && exponent::den == 1 for negative exponent (first dimension)")
{
const auto q = 8q_s / 2q_m / 2q_m;
const auto q = 8_q_s / 2_q_m / 2_q_m;
os << q;
SECTION("iostream")
@@ -704,7 +704,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("exponent::num == 2 && exponent::den == 1 for negative exponent (not first dimension)")
{
const auto q = 8q_m / 2q_kg / 2q_kg;
const auto q = 8_q_m / 2_q_kg / 2_q_kg;
os << q;
SECTION("iostream")
@@ -725,7 +725,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("fractional positive exponent")
{
const auto q = sqrt(9q_m);
const auto q = sqrt(9_q_m);
os << q;
SECTION("iostream")
@@ -746,7 +746,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("fractional negative exponent")
{
const auto q = sqrt(9 / 1q_m);
const auto q = sqrt(9 / 1_q_m);
os << q;
SECTION("iostream")
@@ -773,12 +773,12 @@ TEST_CASE("format string with only %Q should print quantity value only", "[text]
{
SECTION("positive value")
{
CHECK(fmt::format("{:%Q}", 123q_km_per_h) == "123");
CHECK(fmt::format("{:%Q}", 123_q_km_per_h) == "123");
}
SECTION("negative value")
{
CHECK(fmt::format("{:%Q}", 5q_m - 10q_m) == "-5");
CHECK(fmt::format("{:%Q}", 5_q_m - 10_q_m) == "-5");
}
}
@@ -786,12 +786,12 @@ TEST_CASE("format string with only %Q should print quantity value only", "[text]
{
SECTION("positive value")
{
CHECK(fmt::format("{:%Q}", 221.q_km / 2q_h) == "110.5");
CHECK(fmt::format("{:%Q}", 221._q_km / 2_q_h) == "110.5");
}
SECTION("negative value")
{
CHECK(fmt::format("{:%Q}", 3.14q_m - 10q_m) == "-6.86");
CHECK(fmt::format("{:%Q}", 3.14_q_m - 10_q_m) == "-6.86");
}
SECTION("nan")
@@ -815,24 +815,24 @@ TEST_CASE("format string with only %q should print quantity unit symbol only", "
{
SECTION("standard format for a unit without Unicode symbols")
{
CHECK(fmt::format("{:%q}", 123q_km_per_h) == "km/h");
CHECK(fmt::format("{:%q}", 123_q_km_per_h) == "km/h");
}
SECTION("ASCII format for a unit without Unicode symbols")
{
CHECK(fmt::format("{:%Aq}", 123q_km_per_h) == "km/h");
CHECK(fmt::format("{:%Aq}", 123_q_km_per_h) == "km/h");
}
SECTION("standard format for a unit with Unicode symbols")
{
SECTION("Unicode signs in a unit symbol")
{
CHECK(fmt::format("{:%q}", 123q_kR) == "kΩ");
CHECK(fmt::format("{:%q}", 123_q_kR) == "kΩ");
}
SECTION("Unicode signs in a unit symbol prefix")
{
CHECK(fmt::format("{:%q}", 123q_uV) == "µV");
CHECK(fmt::format("{:%q}", 123_q_uV) == "µV");
}
}
@@ -840,12 +840,12 @@ TEST_CASE("format string with only %q should print quantity unit symbol only", "
{
SECTION("Unicode signs in a unit symbol")
{
CHECK(fmt::format("{:%Aq}", 123q_kR) == "kohm");
CHECK(fmt::format("{:%Aq}", 123_q_kR) == "kohm");
}
SECTION("Unicode signs in a unit symbol prefix")
{
CHECK(fmt::format("{:%Aq}", 123q_uV) == "uV");
CHECK(fmt::format("{:%Aq}", 123_q_uV) == "uV");
}
}
}
@@ -854,32 +854,32 @@ TEST_CASE("%q and %Q can be put anywhere in a format string", "[text][fmt]")
{
SECTION("no space")
{
CHECK(fmt::format("{:%Q%q}", 123q_km_per_h) == "123km/h");
CHECK(fmt::format("{:%Q%q}", 123_q_km_per_h) == "123km/h");
}
SECTION("separator")
{
CHECK(fmt::format("{:%Q###%q}", 123q_km_per_h) == "123###km/h");
CHECK(fmt::format("{:%Q###%q}", 123_q_km_per_h) == "123###km/h");
}
SECTION("opposite order")
{
CHECK(fmt::format("{:%q %Q}", 123q_km_per_h) == "km/h 123");
CHECK(fmt::format("{:%q %Q}", 123_q_km_per_h) == "km/h 123");
}
SECTION("tabulator")
{
CHECK(fmt::format("{:%Q%t%q}", 123q_km_per_h) == "123\tkm/h");
CHECK(fmt::format("{:%Q%t%q}", 123_q_km_per_h) == "123\tkm/h");
}
SECTION("new line")
{
CHECK(fmt::format("{:%Q%n%q}", 123q_km_per_h) == "123\nkm/h");
CHECK(fmt::format("{:%Q%n%q}", 123_q_km_per_h) == "123\nkm/h");
}
SECTION("% sign")
{
CHECK(fmt::format("{:%Q%% %q}", 123q_km_per_h) == "123% km/h");
CHECK(fmt::format("{:%Q%% %q}", 123_q_km_per_h) == "123% km/h");
}
}
@@ -891,87 +891,87 @@ TEST_CASE("fill and align specification", "[text][fmt][ostream]")
SECTION("width = 10")
{
os << "|" << std::setw(10) << 123q_m << "|";
os << "|" << std::setw(10) << 123_q_m << "|";
CHECK(os.str() == "| 123 m|");
}
SECTION("width = 10, align = right")
{
os << "|" << std::setw(10) << std::right << 123q_m << "|";
os << "|" << std::setw(10) << std::right << 123_q_m << "|";
CHECK(os.str() == "| 123 m|");
}
SECTION("width = 10, align = left")
{
os << "|" << std::setw(10) << std::left << 123q_m << "|";
os << "|" << std::setw(10) << std::left << 123_q_m << "|";
CHECK(os.str() == "|123 m |");
}
SECTION("width = 10, fill = *")
{
os << "|" << std::setw(10) << std::setfill('*') << 123q_m << "|";
os << "|" << std::setw(10) << std::setfill('*') << 123_q_m << "|";
CHECK(os.str() == "|*****123 m|");
}
SECTION("width = 10, fill = *, align = right")
{
os << "|" << std::setw(10) << std::setfill('*') << std::right << 123q_m << "|";
os << "|" << std::setw(10) << std::setfill('*') << std::right << 123_q_m << "|";
CHECK(os.str() == "|*****123 m|");
}
SECTION("width = 10, fill = *, align = left")
{
os << "|" << std::setw(10) << std::setfill('*') << std::left << 123q_m << "|";
os << "|" << std::setw(10) << std::setfill('*') << std::left << 123_q_m << "|";
CHECK(os.str() == "|123 m*****|");
}
}
SECTION("default format {} on a quantity")
{
CHECK(fmt::format("|{:0}|", 123q_m) == "|123 m|");
CHECK(fmt::format("|{:10}|", 123q_m) == "| 123 m|");
CHECK(fmt::format("|{:<10}|", 123q_m) == "|123 m |");
CHECK(fmt::format("|{:>10}|", 123q_m) == "| 123 m|");
CHECK(fmt::format("|{:^10}|", 123q_m) == "| 123 m |");
CHECK(fmt::format("|{:*<10}|", 123q_m) == "|123 m*****|");
CHECK(fmt::format("|{:*>10}|", 123q_m) == "|*****123 m|");
CHECK(fmt::format("|{:*^10}|", 123q_m) == "|**123 m***|");
CHECK(fmt::format("|{:0}|", 123_q_m) == "|123 m|");
CHECK(fmt::format("|{:10}|", 123_q_m) == "| 123 m|");
CHECK(fmt::format("|{:<10}|", 123_q_m) == "|123 m |");
CHECK(fmt::format("|{:>10}|", 123_q_m) == "| 123 m|");
CHECK(fmt::format("|{:^10}|", 123_q_m) == "| 123 m |");
CHECK(fmt::format("|{:*<10}|", 123_q_m) == "|123 m*****|");
CHECK(fmt::format("|{:*>10}|", 123_q_m) == "|*****123 m|");
CHECK(fmt::format("|{:*^10}|", 123_q_m) == "|**123 m***|");
}
SECTION("full format {:%Q %q} on a quantity")
{
CHECK(fmt::format("|{:0%Q%q}|", 123q_m) == "|123m|");
CHECK(fmt::format("|{:10%Q%q}|", 123q_m) == "| 123m|");
CHECK(fmt::format("|{:<10%Q%q}|", 123q_m) == "|123m |");
CHECK(fmt::format("|{:>10%Q%q}|", 123q_m) == "| 123m|");
CHECK(fmt::format("|{:^10%Q%q}|", 123q_m) == "| 123m |");
CHECK(fmt::format("|{:*<10%Q%q}|", 123q_m) == "|123m******|");
CHECK(fmt::format("|{:*>10%Q%q}|", 123q_m) == "|******123m|");
CHECK(fmt::format("|{:*^10%Q%q}|", 123q_m) == "|***123m***|");
CHECK(fmt::format("|{:0%Q%q}|", 123_q_m) == "|123m|");
CHECK(fmt::format("|{:10%Q%q}|", 123_q_m) == "| 123m|");
CHECK(fmt::format("|{:<10%Q%q}|", 123_q_m) == "|123m |");
CHECK(fmt::format("|{:>10%Q%q}|", 123_q_m) == "| 123m|");
CHECK(fmt::format("|{:^10%Q%q}|", 123_q_m) == "| 123m |");
CHECK(fmt::format("|{:*<10%Q%q}|", 123_q_m) == "|123m******|");
CHECK(fmt::format("|{:*>10%Q%q}|", 123_q_m) == "|******123m|");
CHECK(fmt::format("|{:*^10%Q%q}|", 123_q_m) == "|***123m***|");
}
SECTION("value only format {:%Q} on a quantity")
{
CHECK(fmt::format("|{:0%Q}|", 123q_m) == "|123|");
CHECK(fmt::format("|{:10%Q}|", 123q_m) == "| 123|");
CHECK(fmt::format("|{:<10%Q}|", 123q_m) == "|123 |");
CHECK(fmt::format("|{:>10%Q}|", 123q_m) == "| 123|");
CHECK(fmt::format("|{:^10%Q}|", 123q_m) == "| 123 |");
CHECK(fmt::format("|{:*<10%Q}|", 123q_m) == "|123*******|");
CHECK(fmt::format("|{:*>10%Q}|", 123q_m) == "|*******123|");
CHECK(fmt::format("|{:*^10%Q}|", 123q_m) == "|***123****|");
CHECK(fmt::format("|{:0%Q}|", 123_q_m) == "|123|");
CHECK(fmt::format("|{:10%Q}|", 123_q_m) == "| 123|");
CHECK(fmt::format("|{:<10%Q}|", 123_q_m) == "|123 |");
CHECK(fmt::format("|{:>10%Q}|", 123_q_m) == "| 123|");
CHECK(fmt::format("|{:^10%Q}|", 123_q_m) == "| 123 |");
CHECK(fmt::format("|{:*<10%Q}|", 123_q_m) == "|123*******|");
CHECK(fmt::format("|{:*>10%Q}|", 123_q_m) == "|*******123|");
CHECK(fmt::format("|{:*^10%Q}|", 123_q_m) == "|***123****|");
}
SECTION("symbol only format {:%q} on a quantity")
{
CHECK(fmt::format("|{:0%q}|", 123q_m) == "|m|");
CHECK(fmt::format("|{:10%q}|", 123q_m) == "|m |");
CHECK(fmt::format("|{:<10%q}|", 123q_m) == "|m |");
CHECK(fmt::format("|{:>10%q}|", 123q_m) == "| m|");
CHECK(fmt::format("|{:^10%q}|", 123q_m) == "| m |");
CHECK(fmt::format("|{:*<10%q}|", 123q_m) == "|m*********|");
CHECK(fmt::format("|{:*>10%q}|", 123q_m) == "|*********m|");
CHECK(fmt::format("|{:*^10%q}|", 123q_m) == "|****m*****|");
CHECK(fmt::format("|{:0%q}|", 123_q_m) == "|m|");
CHECK(fmt::format("|{:10%q}|", 123_q_m) == "|m |");
CHECK(fmt::format("|{:<10%q}|", 123_q_m) == "|m |");
CHECK(fmt::format("|{:>10%q}|", 123_q_m) == "| m|");
CHECK(fmt::format("|{:^10%q}|", 123_q_m) == "| m |");
CHECK(fmt::format("|{:*<10%q}|", 123_q_m) == "|m*********|");
CHECK(fmt::format("|{:*>10%q}|", 123_q_m) == "|*********m|");
CHECK(fmt::format("|{:*^10%q}|", 123_q_m) == "|****m*****|");
}
}
@@ -982,16 +982,16 @@ TEST_CASE("sign specification", "[text][fmt]")
SECTION("full format {:%Q %q} on a quantity")
{
CHECK(fmt::format("{0:%Q%q},{0:%+Q%q},{0:%-Q%q},{0:% Q%q}", 1q_m) == "1m,+1m,1m, 1m");
CHECK(fmt::format("{0:%Q%q},{0:%+Q%q},{0:%-Q%q},{0:% Q%q}", -1q_m) == "-1m,-1m,-1m,-1m");
CHECK(fmt::format("{0:%Q%q},{0:%+Q%q},{0:%-Q%q},{0:% Q%q}", 1_q_m) == "1m,+1m,1m, 1m");
CHECK(fmt::format("{0:%Q%q},{0:%+Q%q},{0:%-Q%q},{0:% Q%q}", -1_q_m) == "-1m,-1m,-1m,-1m");
CHECK(fmt::format("{0:%Q%q},{0:%+Q%q},{0:%-Q%q},{0:% Q%q}", inf) == "infm,+infm,infm, infm");
CHECK(fmt::format("{0:%Q%q},{0:%+Q%q},{0:%-Q%q},{0:% Q%q}", nan) == "nanm,+nanm,nanm, nanm");
}
SECTION("value only format {:%Q} on a quantity")
{
CHECK(fmt::format("{0:%Q},{0:%+Q},{0:%-Q},{0:% Q}", 1q_m) == "1,+1,1, 1");
CHECK(fmt::format("{0:%Q},{0:%+Q},{0:%-Q},{0:% Q}", -1q_m) == "-1,-1,-1,-1");
CHECK(fmt::format("{0:%Q},{0:%+Q},{0:%-Q},{0:% Q}", 1_q_m) == "1,+1,1, 1");
CHECK(fmt::format("{0:%Q},{0:%+Q},{0:%-Q},{0:% Q}", -1_q_m) == "-1,-1,-1,-1");
CHECK(fmt::format("{0:%Q},{0:%+Q},{0:%-Q},{0:% Q}", inf) == "inf,+inf,inf, inf");
CHECK(fmt::format("{0:%Q},{0:%+Q},{0:%-Q},{0:% Q}", nan) == "nan,+nan,nan, nan");
}
@@ -1001,32 +1001,32 @@ TEST_CASE("precision specification", "[text][fmt]")
{
SECTION("full format {:%Q %q} on a quantity")
{
CHECK(fmt::format("{:%.0Q %q}", 1.2345q_m) == "1 m");
CHECK(fmt::format("{:%.1Q %q}", 1.2345q_m) == "1.2 m");
CHECK(fmt::format("{:%.2Q %q}", 1.2345q_m) == "1.23 m");
CHECK(fmt::format("{:%.0Q %q}", 1.2345_q_m) == "1 m");
CHECK(fmt::format("{:%.1Q %q}", 1.2345_q_m) == "1.2 m");
CHECK(fmt::format("{:%.2Q %q}", 1.2345_q_m) == "1.23 m");
#ifdef COMP_MSVC
CHECK(fmt::format("{:%.3Q %q}", 1.2345q_m) == "1.234 m");
CHECK(fmt::format("{:%.3Q %q}", 1.2345_q_m) == "1.234 m");
#else
CHECK(fmt::format("{:%.3Q %q}", 1.2345q_m) == "1.235 m");
CHECK(fmt::format("{:%.3Q %q}", 1.2345_q_m) == "1.235 m");
#endif
CHECK(fmt::format("{:%.4Q %q}", 1.2345q_m) == "1.2345 m");
CHECK(fmt::format("{:%.5Q %q}", 1.2345q_m) == "1.23450 m");
CHECK(fmt::format("{:%.10Q %q}", 1.2345q_m) == "1.2345000000 m");
CHECK(fmt::format("{:%.4Q %q}", 1.2345_q_m) == "1.2345 m");
CHECK(fmt::format("{:%.5Q %q}", 1.2345_q_m) == "1.23450 m");
CHECK(fmt::format("{:%.10Q %q}", 1.2345_q_m) == "1.2345000000 m");
}
SECTION("value only format {:%Q} on a quantity")
{
CHECK(fmt::format("{:%.0Q}", 1.2345q_m) == "1");
CHECK(fmt::format("{:%.1Q}", 1.2345q_m) == "1.2");
CHECK(fmt::format("{:%.2Q}", 1.2345q_m) == "1.23");
CHECK(fmt::format("{:%.0Q}", 1.2345_q_m) == "1");
CHECK(fmt::format("{:%.1Q}", 1.2345_q_m) == "1.2");
CHECK(fmt::format("{:%.2Q}", 1.2345_q_m) == "1.23");
#ifdef COMP_MSVC
CHECK(fmt::format("{:%.3Q}", 1.2345q_m) == "1.234");
CHECK(fmt::format("{:%.3Q}", 1.2345_q_m) == "1.234");
#else
CHECK(fmt::format("{:%.3Q}", 1.2345q_m) == "1.235");
CHECK(fmt::format("{:%.3Q}", 1.2345_q_m) == "1.235");
#endif
CHECK(fmt::format("{:%.4Q}", 1.2345q_m) == "1.2345");
CHECK(fmt::format("{:%.5Q}", 1.2345q_m) == "1.23450");
CHECK(fmt::format("{:%.10Q}", 1.2345q_m) == "1.2345000000");
CHECK(fmt::format("{:%.4Q}", 1.2345_q_m) == "1.2345");
CHECK(fmt::format("{:%.5Q}", 1.2345_q_m) == "1.23450");
CHECK(fmt::format("{:%.10Q}", 1.2345_q_m) == "1.2345000000");
}
}
@@ -1034,12 +1034,12 @@ TEST_CASE("precision specification for integral representation should throw", "[
{
SECTION("full format {:%Q %q} on a quantity")
{
REQUIRE_THROWS_MATCHES(fmt::format("{:%.1Q %q}", 1q_m), fmt::format_error, Message("precision not allowed for integral quantity representation"));
REQUIRE_THROWS_MATCHES(fmt::format("{:%.1Q %q}", 1_q_m), fmt::format_error, Message("precision not allowed for integral quantity representation"));
}
SECTION("value only format {:%Q} on a quantity")
{
REQUIRE_THROWS_MATCHES(fmt::format("{:%.1Q}", 1q_m), fmt::format_error, Message("precision not allowed for integral quantity representation"));
REQUIRE_THROWS_MATCHES(fmt::format("{:%.1Q}", 1_q_m), fmt::format_error, Message("precision not allowed for integral quantity representation"));
}
}
@@ -1047,70 +1047,70 @@ TEST_CASE("type specification", "[text][fmt]")
{
SECTION("full format {:%Q %q} on a quantity")
{
CHECK(fmt::format("{:%bQ %q}", 42q_m) == "101010 m");
CHECK(fmt::format("{:%BQ %q}", 42q_m) == "101010 m");
CHECK(fmt::format("{:%dQ %q}", 42q_m) == "42 m");
CHECK(fmt::format("{:%oQ %q}", 42q_m) == "52 m");
CHECK(fmt::format("{:%xQ %q}", 42q_m) == "2a m");
CHECK(fmt::format("{:%XQ %q}", 42q_m) == "2A m");
CHECK(fmt::format("{:%bQ %q}", 42_q_m) == "101010 m");
CHECK(fmt::format("{:%BQ %q}", 42_q_m) == "101010 m");
CHECK(fmt::format("{:%dQ %q}", 42_q_m) == "42 m");
CHECK(fmt::format("{:%oQ %q}", 42_q_m) == "52 m");
CHECK(fmt::format("{:%xQ %q}", 42_q_m) == "2a m");
CHECK(fmt::format("{:%XQ %q}", 42_q_m) == "2A m");
#ifdef COMP_MSVC
CHECK(fmt::format("{:%aQ %q}", 1.2345678q_m) == "0x1.3c0ca2a5b1d5dp+0 m");
CHECK(fmt::format("{:%.3aQ %q}", 1.2345678q_m) == "0x1.3c1p+0 m");
CHECK(fmt::format("{:%AQ %q}", 1.2345678q_m) == "0X1.3C0CA2A5B1D5DP+0 m");
CHECK(fmt::format("{:%.3AQ %q}", 1.2345678q_m) == "0X1.3C1P+0 m");
CHECK(fmt::format("{:%aQ %q}", 1.2345678_q_m) == "0x1.3c0ca2a5b1d5dp+0 m");
CHECK(fmt::format("{:%.3aQ %q}", 1.2345678_q_m) == "0x1.3c1p+0 m");
CHECK(fmt::format("{:%AQ %q}", 1.2345678_q_m) == "0X1.3C0CA2A5B1D5DP+0 m");
CHECK(fmt::format("{:%.3AQ %q}", 1.2345678_q_m) == "0X1.3C1P+0 m");
#else
CHECK(fmt::format("{:%aQ %q}", 1.2345678q_m) == "0x9.e065152d8eae841p-3 m");
CHECK(fmt::format("{:%.3aQ %q}", 1.2345678q_m) == "0x9.e06p-3 m");
CHECK(fmt::format("{:%AQ %q}", 1.2345678q_m) == "0X9.E065152D8EAE841P-3 m");
CHECK(fmt::format("{:%.3AQ %q}", 1.2345678q_m) == "0X9.E06P-3 m");
CHECK(fmt::format("{:%aQ %q}", 1.2345678_q_m) == "0x9.e065152d8eae841p-3 m");
CHECK(fmt::format("{:%.3aQ %q}", 1.2345678_q_m) == "0x9.e06p-3 m");
CHECK(fmt::format("{:%AQ %q}", 1.2345678_q_m) == "0X9.E065152D8EAE841P-3 m");
CHECK(fmt::format("{:%.3AQ %q}", 1.2345678_q_m) == "0X9.E06P-3 m");
#endif
CHECK(fmt::format("{:%eQ %q}", 1.2345678q_m) == "1.234568e+00 m");
CHECK(fmt::format("{:%.3eQ %q}", 1.2345678q_m) == "1.235e+00 m");
CHECK(fmt::format("{:%EQ %q}", 1.2345678q_m) == "1.234568E+00 m");
CHECK(fmt::format("{:%.3EQ %q}", 1.2345678q_m) == "1.235E+00 m");
CHECK(fmt::format("{:%gQ %q}", 1.2345678q_m) == "1.23457 m");
CHECK(fmt::format("{:%gQ %q}", 1.2345678e8q_m) == "1.23457e+08 m");
CHECK(fmt::format("{:%.3gQ %q}", 1.2345678q_m) == "1.23 m");
CHECK(fmt::format("{:%.3gQ %q}", 1.2345678e8q_m) == "1.23e+08 m");
CHECK(fmt::format("{:%GQ %q}", 1.2345678q_m) == "1.23457 m");
CHECK(fmt::format("{:%GQ %q}", 1.2345678e8q_m) == "1.23457E+08 m");
CHECK(fmt::format("{:%.3GQ %q}", 1.2345678q_m) == "1.23 m");
CHECK(fmt::format("{:%.3GQ %q}", 1.2345678e8q_m) == "1.23E+08 m");
CHECK(fmt::format("{:%eQ %q}", 1.2345678_q_m) == "1.234568e+00 m");
CHECK(fmt::format("{:%.3eQ %q}", 1.2345678_q_m) == "1.235e+00 m");
CHECK(fmt::format("{:%EQ %q}", 1.2345678_q_m) == "1.234568E+00 m");
CHECK(fmt::format("{:%.3EQ %q}", 1.2345678_q_m) == "1.235E+00 m");
CHECK(fmt::format("{:%gQ %q}", 1.2345678_q_m) == "1.23457 m");
CHECK(fmt::format("{:%gQ %q}", 1.2345678e8_q_m) == "1.23457e+08 m");
CHECK(fmt::format("{:%.3gQ %q}", 1.2345678_q_m) == "1.23 m");
CHECK(fmt::format("{:%.3gQ %q}", 1.2345678e8_q_m) == "1.23e+08 m");
CHECK(fmt::format("{:%GQ %q}", 1.2345678_q_m) == "1.23457 m");
CHECK(fmt::format("{:%GQ %q}", 1.2345678e8_q_m) == "1.23457E+08 m");
CHECK(fmt::format("{:%.3GQ %q}", 1.2345678_q_m) == "1.23 m");
CHECK(fmt::format("{:%.3GQ %q}", 1.2345678e8_q_m) == "1.23E+08 m");
}
SECTION("value only format {:%Q} on a quantity")
{
CHECK(fmt::format("{:%bQ}", 42q_m) == "101010");
CHECK(fmt::format("{:%BQ}", 42q_m) == "101010");
CHECK(fmt::format("{:%dQ}", 42q_m) == "42");
CHECK(fmt::format("{:%oQ}", 42q_m) == "52");
CHECK(fmt::format("{:%xQ}", 42q_m) == "2a");
CHECK(fmt::format("{:%XQ}", 42q_m) == "2A");
CHECK(fmt::format("{:%bQ}", 42_q_m) == "101010");
CHECK(fmt::format("{:%BQ}", 42_q_m) == "101010");
CHECK(fmt::format("{:%dQ}", 42_q_m) == "42");
CHECK(fmt::format("{:%oQ}", 42_q_m) == "52");
CHECK(fmt::format("{:%xQ}", 42_q_m) == "2a");
CHECK(fmt::format("{:%XQ}", 42_q_m) == "2A");
#ifdef COMP_MSVC
CHECK(fmt::format("{:%aQ}", 1.2345678q_m) == "0x1.3c0ca2a5b1d5dp+0");
CHECK(fmt::format("{:%.3aQ}", 1.2345678q_m) == "0x1.3c1p+0");
CHECK(fmt::format("{:%AQ}", 1.2345678q_m) == "0X1.3C0CA2A5B1D5DP+0");
CHECK(fmt::format("{:%.3AQ}", 1.2345678q_m) == "0X1.3C1P+0");
CHECK(fmt::format("{:%aQ}", 1.2345678_q_m) == "0x1.3c0ca2a5b1d5dp+0");
CHECK(fmt::format("{:%.3aQ}", 1.2345678_q_m) == "0x1.3c1p+0");
CHECK(fmt::format("{:%AQ}", 1.2345678_q_m) == "0X1.3C0CA2A5B1D5DP+0");
CHECK(fmt::format("{:%.3AQ}", 1.2345678_q_m) == "0X1.3C1P+0");
#else
CHECK(fmt::format("{:%aQ}", 1.2345678q_m) == "0x9.e065152d8eae841p-3");
CHECK(fmt::format("{:%.3aQ}", 1.2345678q_m) == "0x9.e06p-3");
CHECK(fmt::format("{:%AQ}", 1.2345678q_m) == "0X9.E065152D8EAE841P-3");
CHECK(fmt::format("{:%.3AQ}", 1.2345678q_m) == "0X9.E06P-3");
CHECK(fmt::format("{:%aQ}", 1.2345678_q_m) == "0x9.e065152d8eae841p-3");
CHECK(fmt::format("{:%.3aQ}", 1.2345678_q_m) == "0x9.e06p-3");
CHECK(fmt::format("{:%AQ}", 1.2345678_q_m) == "0X9.E065152D8EAE841P-3");
CHECK(fmt::format("{:%.3AQ}", 1.2345678_q_m) == "0X9.E06P-3");
#endif
CHECK(fmt::format("{:%eQ}", 1.2345678q_m) == "1.234568e+00");
CHECK(fmt::format("{:%.3eQ}", 1.2345678q_m) == "1.235e+00");
CHECK(fmt::format("{:%EQ}", 1.2345678q_m) == "1.234568E+00");
CHECK(fmt::format("{:%.3EQ}", 1.2345678q_m) == "1.235E+00");
CHECK(fmt::format("{:%gQ}", 1.2345678q_m) == "1.23457");
CHECK(fmt::format("{:%gQ}", 1.2345678e8q_m) == "1.23457e+08");
CHECK(fmt::format("{:%.3gQ}", 1.2345678q_m) == "1.23");
CHECK(fmt::format("{:%.3gQ}", 1.2345678e8q_m) == "1.23e+08");
CHECK(fmt::format("{:%GQ}", 1.2345678q_m) == "1.23457");
CHECK(fmt::format("{:%GQ}", 1.2345678e8q_m) == "1.23457E+08");
CHECK(fmt::format("{:%.3GQ}", 1.2345678q_m) == "1.23");
CHECK(fmt::format("{:%.3GQ}", 1.2345678e8q_m) == "1.23E+08");
CHECK(fmt::format("{:%eQ}", 1.2345678_q_m) == "1.234568e+00");
CHECK(fmt::format("{:%.3eQ}", 1.2345678_q_m) == "1.235e+00");
CHECK(fmt::format("{:%EQ}", 1.2345678_q_m) == "1.234568E+00");
CHECK(fmt::format("{:%.3EQ}", 1.2345678_q_m) == "1.235E+00");
CHECK(fmt::format("{:%gQ}", 1.2345678_q_m) == "1.23457");
CHECK(fmt::format("{:%gQ}", 1.2345678e8_q_m) == "1.23457e+08");
CHECK(fmt::format("{:%.3gQ}", 1.2345678_q_m) == "1.23");
CHECK(fmt::format("{:%.3gQ}", 1.2345678e8_q_m) == "1.23e+08");
CHECK(fmt::format("{:%GQ}", 1.2345678_q_m) == "1.23457");
CHECK(fmt::format("{:%GQ}", 1.2345678e8_q_m) == "1.23457E+08");
CHECK(fmt::format("{:%.3GQ}", 1.2345678_q_m) == "1.23");
CHECK(fmt::format("{:%.3GQ}", 1.2345678e8_q_m) == "1.23E+08");
}
}
@@ -1118,20 +1118,20 @@ TEST_CASE("different base types with the # specifier")
{
SECTION("full format {:%Q %q} on a quantity")
{
CHECK(fmt::format("{:%#bQ %q}", 42q_m) == "0b101010 m");
CHECK(fmt::format("{:%#BQ %q}", 42q_m) == "0B101010 m");
CHECK(fmt::format("{:%#oQ %q}", 42q_m) == "052 m");
CHECK(fmt::format("{:%#xQ %q}", 42q_m) == "0x2a m");
CHECK(fmt::format("{:%#XQ %q}", 42q_m) == "0X2A m");
CHECK(fmt::format("{:%#bQ %q}", 42_q_m) == "0b101010 m");
CHECK(fmt::format("{:%#BQ %q}", 42_q_m) == "0B101010 m");
CHECK(fmt::format("{:%#oQ %q}", 42_q_m) == "052 m");
CHECK(fmt::format("{:%#xQ %q}", 42_q_m) == "0x2a m");
CHECK(fmt::format("{:%#XQ %q}", 42_q_m) == "0X2A m");
}
SECTION("value only format {:%Q} on a quantity")
{
CHECK(fmt::format("{:%#bQ}", 42q_m) == "0b101010");
CHECK(fmt::format("{:%#BQ}", 42q_m) == "0B101010");
CHECK(fmt::format("{:%#oQ}", 42q_m) == "052");
CHECK(fmt::format("{:%#xQ}", 42q_m) == "0x2a");
CHECK(fmt::format("{:%#XQ}", 42q_m) == "0X2A");
CHECK(fmt::format("{:%#bQ}", 42_q_m) == "0b101010");
CHECK(fmt::format("{:%#BQ}", 42_q_m) == "0B101010");
CHECK(fmt::format("{:%#oQ}", 42_q_m) == "052");
CHECK(fmt::format("{:%#xQ}", 42_q_m) == "0x2a");
CHECK(fmt::format("{:%#XQ}", 42_q_m) == "0X2A");
}
}
@@ -1141,7 +1141,7 @@ TEST_CASE("quantity_cast", "[text][ostream]")
SECTION("int to double representation")
{
const auto q = 121q_km / 2q_h;
const auto q = 121_q_km / 2_q_h;
SECTION("original")
{
@@ -1164,7 +1164,7 @@ TEST_CASE("quantity_cast", "[text][ostream]")
SECTION("double to int representation")
{
const auto q = 121.q_km / 2q_h;
const auto q = 121._q_km / 2_q_h;
SECTION("original")
{
test/unit_test/runtime/fmt_units_test.cpp
+126 -126
View File
@@ -43,278 +43,278 @@ TEST_CASE("fmt::format on synthesized unit symbols", "[text][fmt]")
{
SECTION("time")
{
CHECK(fmt::format("{}", 1q_ns) == "1 ns");
CHECK(fmt::format("{}", 1q_us) == "1 µs");
CHECK(fmt::format("{}", 1q_ms) == "1 ms");
CHECK(fmt::format("{}", 1_q_ns) == "1 ns");
CHECK(fmt::format("{}", 1_q_us) == "1 µs");
CHECK(fmt::format("{}", 1_q_ms) == "1 ms");
CHECK(fmt::format("{:%Q %Aq}", 1q_us) == "1 us");
CHECK(fmt::format("{:%Q %Aq}", 1_q_us) == "1 us");
}
SECTION("length")
{
CHECK(fmt::format("{}", 1q_mm) == "1 mm");
CHECK(fmt::format("{}", 1q_cm) == "1 cm");
CHECK(fmt::format("{}", 1q_km) == "1 km");
CHECK(fmt::format("{}", 1q_ft) == "1 ft");
CHECK(fmt::format("{}", 1q_ft_us) == "1 ft(us)");
CHECK(fmt::format("{}", 1q_yd) == "1 yd");
CHECK(fmt::format("{}", 1q_in) == "1 in");
CHECK(fmt::format("{}", 1q_fathom) == "1 fathom");
CHECK(fmt::format("{}", 1q_fathom_us) == "1 fathom(us)");
CHECK(fmt::format("{}", 1q_mi) == "1 mi");
CHECK(fmt::format("{}", 1q_mi_us) == "1 mi(us)");
CHECK(fmt::format("{}", 1q_naut_mi) == "1 mi(naut)");
CHECK(fmt::format("{}", 1q_ch) == "1 ch");
CHECK(fmt::format("{}", 1q_rd) == "1 rd");
CHECK(fmt::format("{}", 1q_thou) == "1 thou");
CHECK(fmt::format("{}", 1q_pc) == "1 pc");
CHECK(fmt::format("{}", 1q_ly) == "1 ly");
CHECK(fmt::format("{}", 1q_pc) == "1 pc");
CHECK(fmt::format("{}", 1q_angstrom) == "1 angstrom");
CHECK(fmt::format("{}", 1q_au) == "1 au");
CHECK(fmt::format("{}", 1q_pica_comp) == "1 pica(comp)");
CHECK(fmt::format("{}", 1q_pica_prn) == "1 pica(prn)");
CHECK(fmt::format("{}", 1q_point_comp) == "1 point(comp)");
CHECK(fmt::format("{}", 1q_point_prn) == "1 point(prn)");
CHECK(fmt::format("{}", 1_q_mm) == "1 mm");
CHECK(fmt::format("{}", 1_q_cm) == "1 cm");
CHECK(fmt::format("{}", 1_q_km) == "1 km");
CHECK(fmt::format("{}", 1_q_ft) == "1 ft");
CHECK(fmt::format("{}", 1_q_ft_us) == "1 ft(us)");
CHECK(fmt::format("{}", 1_q_yd) == "1 yd");
CHECK(fmt::format("{}", 1_q_in) == "1 in");
CHECK(fmt::format("{}", 1_q_fathom) == "1 fathom");
CHECK(fmt::format("{}", 1_q_fathom_us) == "1 fathom(us)");
CHECK(fmt::format("{}", 1_q_mi) == "1 mi");
CHECK(fmt::format("{}", 1_q_mi_us) == "1 mi(us)");
CHECK(fmt::format("{}", 1_q_naut_mi) == "1 mi(naut)");
CHECK(fmt::format("{}", 1_q_ch) == "1 ch");
CHECK(fmt::format("{}", 1_q_rd) == "1 rd");
CHECK(fmt::format("{}", 1_q_thou) == "1 thou");
CHECK(fmt::format("{}", 1_q_pc) == "1 pc");
CHECK(fmt::format("{}", 1_q_ly) == "1 ly");
CHECK(fmt::format("{}", 1_q_pc) == "1 pc");
CHECK(fmt::format("{}", 1_q_angstrom) == "1 angstrom");
CHECK(fmt::format("{}", 1_q_au) == "1 au");
CHECK(fmt::format("{}", 1_q_pica_comp) == "1 pica(comp)");
CHECK(fmt::format("{}", 1_q_pica_prn) == "1 pica(prn)");
CHECK(fmt::format("{}", 1_q_point_comp) == "1 point(comp)");
CHECK(fmt::format("{}", 1_q_point_prn) == "1 point(prn)");
}
SECTION("mass")
{
CHECK(fmt::format("{}", 1q_kg) == "1 kg");
CHECK(fmt::format("{}", 1_q_kg) == "1 kg");
}
SECTION("area")
{
CHECK(fmt::format("{}", 1q_m2) == "1 m²");
CHECK(fmt::format("{}", 1q_mm2) == "1 mm²");
CHECK(fmt::format("{}", 1q_cm2) == "1 cm²");
CHECK(fmt::format("{}", 1q_km2) == "1 km²");
CHECK(fmt::format("{}", 1q_ft2) == "1 ft²");
CHECK(fmt::format("{}", 1_q_m2) == "1 m²");
CHECK(fmt::format("{}", 1_q_mm2) == "1 mm²");
CHECK(fmt::format("{}", 1_q_cm2) == "1 cm²");
CHECK(fmt::format("{}", 1_q_km2) == "1 km²");
CHECK(fmt::format("{}", 1_q_ft2) == "1 ft²");
CHECK(fmt::format("{:%Q %Aq}", 1q_m2) == "1 m^2");
CHECK(fmt::format("{:%Q %Aq}", 1q_mm2) == "1 mm^2");
CHECK(fmt::format("{:%Q %Aq}", 1q_cm2) == "1 cm^2");
CHECK(fmt::format("{:%Q %Aq}", 1q_km2) == "1 km^2");
CHECK(fmt::format("{:%Q %Aq}", 1q_ft2) == "1 ft^2");
CHECK(fmt::format("{:%Q %Aq}", 1_q_m2) == "1 m^2");
CHECK(fmt::format("{:%Q %Aq}", 1_q_mm2) == "1 mm^2");
CHECK(fmt::format("{:%Q %Aq}", 1_q_cm2) == "1 cm^2");
CHECK(fmt::format("{:%Q %Aq}", 1_q_km2) == "1 km^2");
CHECK(fmt::format("{:%Q %Aq}", 1_q_ft2) == "1 ft^2");
}
SECTION("density")
{
CHECK(fmt::format("{}", 1q_kg_per_m3) == "1 kg/m³");
CHECK(fmt::format("{:%Q %Aq}", 1q_kg_per_m3) == "1 kg/m^3");
CHECK(fmt::format("{}", 1_q_kg_per_m3) == "1 kg/m³");
CHECK(fmt::format("{:%Q %Aq}", 1_q_kg_per_m3) == "1 kg/m^3");
}
SECTION("resistance")
{
CHECK(fmt::format("{}", 1q_R) == "1 Ω");
CHECK(fmt::format("{}", 1q_kR) == "1 kΩ");
CHECK(fmt::format("{}", 1q_mR) == "1 mΩ");
CHECK(fmt::format("{}", 1q_MR) == "1 MΩ");
CHECK(fmt::format("{}", 1_q_R) == "1 Ω");
CHECK(fmt::format("{}", 1_q_kR) == "1 kΩ");
CHECK(fmt::format("{}", 1_q_mR) == "1 mΩ");
CHECK(fmt::format("{}", 1_q_MR) == "1 MΩ");
CHECK(fmt::format("{:%Q %Aq}", 1q_R) == "1 ohm");
CHECK(fmt::format("{:%Q %Aq}", 1q_kR) == "1 kohm");
CHECK(fmt::format("{:%Q %Aq}", 1q_mR) == "1 mohm");
CHECK(fmt::format("{:%Q %Aq}", 1q_MR) == "1 Mohm");
CHECK(fmt::format("{:%Q %Aq}", 1_q_R) == "1 ohm");
CHECK(fmt::format("{:%Q %Aq}", 1_q_kR) == "1 kohm");
CHECK(fmt::format("{:%Q %Aq}", 1_q_mR) == "1 mohm");
CHECK(fmt::format("{:%Q %Aq}", 1_q_MR) == "1 Mohm");
}
SECTION("voltage")
{
CHECK(fmt::format("{}", 1q_V) == "1 V");
CHECK(fmt::format("{}", 1q_mV) == "1 mV");
CHECK(fmt::format("{}", 1q_uV) == "1 µV");
CHECK(fmt::format("{}", 1q_nV) == "1 nV");
CHECK(fmt::format("{}", 1q_pV) == "1 pV");
CHECK(fmt::format("{}", 1_q_V) == "1 V");
CHECK(fmt::format("{}", 1_q_mV) == "1 mV");
CHECK(fmt::format("{}", 1_q_uV) == "1 µV");
CHECK(fmt::format("{}", 1_q_nV) == "1 nV");
CHECK(fmt::format("{}", 1_q_pV) == "1 pV");
CHECK(fmt::format("{:%Q %Aq}", 1q_uV) == "1 uV");
CHECK(fmt::format("{:%Q %Aq}", 1_q_uV) == "1 uV");
}
SECTION("volume")
{
CHECK(fmt::format("{}", 1q_m3) == "1 m³");
CHECK(fmt::format("{}", 1q_mm3) == "1 mm³");
CHECK(fmt::format("{}", 1q_cm3) == "1 cm³");
CHECK(fmt::format("{}", 1q_km3) == "1 km³");
CHECK(fmt::format("{}", 1q_ft3) == "1 ft³");
CHECK(fmt::format("{}", 1_q_m3) == "1 m³");
CHECK(fmt::format("{}", 1_q_mm3) == "1 mm³");
CHECK(fmt::format("{}", 1_q_cm3) == "1 cm³");
CHECK(fmt::format("{}", 1_q_km3) == "1 km³");
CHECK(fmt::format("{}", 1_q_ft3) == "1 ft³");
CHECK(fmt::format("{:%Q %Aq}", 1q_m3) == "1 m^3");
CHECK(fmt::format("{:%Q %Aq}", 1q_mm3) == "1 mm^3");
CHECK(fmt::format("{:%Q %Aq}", 1q_cm3) == "1 cm^3");
CHECK(fmt::format("{:%Q %Aq}", 1q_km3) == "1 km^3");
CHECK(fmt::format("{:%Q %Aq}", 1q_ft3) == "1 ft^3");
CHECK(fmt::format("{:%Q %Aq}", 1_q_m3) == "1 m^3");
CHECK(fmt::format("{:%Q %Aq}", 1_q_mm3) == "1 mm^3");
CHECK(fmt::format("{:%Q %Aq}", 1_q_cm3) == "1 cm^3");
CHECK(fmt::format("{:%Q %Aq}", 1_q_km3) == "1 km^3");
CHECK(fmt::format("{:%Q %Aq}", 1_q_ft3) == "1 ft^3");
}
SECTION("frequency")
{
CHECK(fmt::format("{}", 1q_mHz) == "1 mHz");
CHECK(fmt::format("{}", 1q_kHz) == "1 kHz");
CHECK(fmt::format("{}", 1q_MHz) == "1 MHz");
CHECK(fmt::format("{}", 1q_GHz) == "1 GHz");
CHECK(fmt::format("{}", 1q_THz) == "1 THz");
CHECK(fmt::format("{}", 1_q_mHz) == "1 mHz");
CHECK(fmt::format("{}", 1_q_kHz) == "1 kHz");
CHECK(fmt::format("{}", 1_q_MHz) == "1 MHz");
CHECK(fmt::format("{}", 1_q_GHz) == "1 GHz");
CHECK(fmt::format("{}", 1_q_THz) == "1 THz");
}
SECTION("speed")
{
CHECK(fmt::format("{}", 1q_m_per_s) == "1 m/s");
CHECK(fmt::format("{}", 1q_km_per_h) == "1 km/h");
CHECK(fmt::format("{}", 1q_mi_per_h) == "1 mi/h");
CHECK(fmt::format("{}", 1_q_m_per_s) == "1 m/s");
CHECK(fmt::format("{}", 1_q_km_per_h) == "1 km/h");
CHECK(fmt::format("{}", 1_q_mi_per_h) == "1 mi/h");
}
SECTION("acceleration")
{
CHECK(fmt::format("{}", 1q_m_per_s2) == "1 m/s²");
CHECK(fmt::format("{:%Q %Aq}", 1q_m_per_s2) == "1 m/s^2");
CHECK(fmt::format("{}", 1_q_m_per_s2) == "1 m/s²");
CHECK(fmt::format("{:%Q %Aq}", 1_q_m_per_s2) == "1 m/s^2");
}
SECTION("momentum")
{
CHECK(fmt::format("{}", 1q_kg_m_per_s) == "1 kg ⋅ m/s");
CHECK(fmt::format("{:%Q %Aq}", 1q_kg_m_per_s) == "1 kg m/s");
CHECK(fmt::format("{}", 1_q_kg_m_per_s) == "1 kg ⋅ m/s");
CHECK(fmt::format("{:%Q %Aq}", 1_q_kg_m_per_s) == "1 kg m/s");
}
SECTION("energy")
{
CHECK(fmt::format("{}", 1q_mJ) == "1 mJ");
CHECK(fmt::format("{}", 1q_kJ) == "1 kJ");
CHECK(fmt::format("{}", 1q_MJ) == "1 MJ");
CHECK(fmt::format("{}", 1q_GJ) == "1 GJ");
CHECK(fmt::format("{}", 1_q_mJ) == "1 mJ");
CHECK(fmt::format("{}", 1_q_kJ) == "1 kJ");
CHECK(fmt::format("{}", 1_q_MJ) == "1 MJ");
CHECK(fmt::format("{}", 1_q_GJ) == "1 GJ");
}
SECTION("power")
{
CHECK(fmt::format("{}", 1q_mW) == "1 mW");
CHECK(fmt::format("{}", 1q_kW) == "1 kW");
CHECK(fmt::format("{}", 1q_MW) == "1 MW");
CHECK(fmt::format("{}", 1q_GW) == "1 GW");
CHECK(fmt::format("{}", 1_q_mW) == "1 mW");
CHECK(fmt::format("{}", 1_q_kW) == "1 kW");
CHECK(fmt::format("{}", 1_q_MW) == "1 MW");
CHECK(fmt::format("{}", 1_q_GW) == "1 GW");
}
SECTION("surface tension")
{
CHECK(fmt::format("{}", 1q_N_per_m) == "1 N/m");
CHECK(fmt::format("{}", 1_q_N_per_m) == "1 N/m");
}
SECTION("magnetic induction")
{
CHECK(fmt::format("{}", 1q_T) == "1 T");
CHECK(fmt::format("{}", 1_q_T) == "1 T");
}
SECTION("magnetic flux")
{
CHECK(fmt::format("{}", 1q_Wb) == "1 Wb");
CHECK(fmt::format("{}", 1q_G) == "1 G");
CHECK(fmt::format("{}", 1_q_Wb) == "1 Wb");
CHECK(fmt::format("{}", 1_q_G) == "1 G");
}
SECTION("inductance")
{
CHECK(fmt::format("{}", 1q_H) == "1 H");
CHECK(fmt::format("{}", 1q_mH) == "1 mH");
CHECK(fmt::format("{}", 1_q_H) == "1 H");
CHECK(fmt::format("{}", 1_q_mH) == "1 mH");
}
SECTION("conductance")
{
CHECK(fmt::format("{}", 1q_S) == "1 S");
CHECK(fmt::format("{}", 1q_nS) == "1 nS");
CHECK(fmt::format("{}", 1_q_S) == "1 S");
CHECK(fmt::format("{}", 1_q_nS) == "1 nS");
}
SECTION("catalytic activity")
{
CHECK(fmt::format("{}", 1q_kat) == "1 kat");
CHECK(fmt::format("{}", 1q_U) == "1 U");
CHECK(fmt::format("{}", 1_q_kat) == "1 kat");
CHECK(fmt::format("{}", 1_q_U) == "1 U");
}
SECTION("absorbed dose")
{
CHECK(fmt::format("{}", 1q_Gy) == "1 Gy");
CHECK(fmt::format("{}", 1q_kGy) == "1 kGy");
CHECK(fmt::format("{}", 1q_mGy) == "1 mGy");
CHECK(fmt::format("{}", 1_q_Gy) == "1 Gy");
CHECK(fmt::format("{}", 1_q_kGy) == "1 kGy");
CHECK(fmt::format("{}", 1_q_mGy) == "1 mGy");
}
SECTION("addition with common ratio")
{
CHECK(fmt::format("{}", 1q_in + 1q_yd) == "37 in");
CHECK(fmt::format("{}", 1_q_in + 1_q_yd) == "37 in");
}
SECTION("current density")
{
CHECK(fmt::format("{}", 1q_A_per_m2) == "1 A/m²");
CHECK(fmt::format("{:%Q %Aq}", 1q_A_per_m2) == "1 A/m^2");
CHECK(fmt::format("{}", 1_q_A_per_m2) == "1 A/m²");
CHECK(fmt::format("{:%Q %Aq}", 1_q_A_per_m2) == "1 A/m^2");
}
SECTION("concentration")
{
CHECK(fmt::format("{}", 1q_mol_per_m3) == "1 mol/m³");
CHECK(fmt::format("{:%Q %Aq}", 1q_mol_per_m3) == "1 mol/m^3");
CHECK(fmt::format("{}", 1_q_mol_per_m3) == "1 mol/m³");
CHECK(fmt::format("{:%Q %Aq}", 1_q_mol_per_m3) == "1 mol/m^3");
}
SECTION("luminance")
{
CHECK(fmt::format("{}", 1q_cd_per_m2) == "1 cd/m²");
CHECK(fmt::format("{:%Q %Aq}", 1q_cd_per_m2) == "1 cd/m^2");
CHECK(fmt::format("{}", 1_q_cd_per_m2) == "1 cd/m²");
CHECK(fmt::format("{:%Q %Aq}", 1_q_cd_per_m2) == "1 cd/m^2");
}
SECTION("dynamic viscosity")
{
CHECK(fmt::format("{}", 1q_Pa_s) == "1 Pa ⋅ s");
CHECK(fmt::format("{:%Q %Aq}", 1q_Pa_s) == "1 Pa s");
CHECK(fmt::format("{}", 1_q_Pa_s) == "1 Pa ⋅ s");
CHECK(fmt::format("{:%Q %Aq}", 1_q_Pa_s) == "1 Pa s");
}
SECTION("heat capacity")
{
CHECK(fmt::format("{}", 1q_J_per_K) == "1 J/K");
CHECK(fmt::format("{}", 1_q_J_per_K) == "1 J/K");
}
SECTION("specific heat capacity")
{
CHECK(fmt::format("{}", 1q_J_per_kg_K) == "1 J ⋅ K⁻¹ ⋅ kg⁻¹");
CHECK(fmt::format("{:%Q %Aq}", 1q_J_per_kg_K) == "1 J K^-1 kg^-1");
CHECK(fmt::format("{}", 1_q_J_per_kg_K) == "1 J ⋅ K⁻¹ ⋅ kg⁻¹");
CHECK(fmt::format("{:%Q %Aq}", 1_q_J_per_kg_K) == "1 J K^-1 kg^-1");
}
SECTION("molar heath capacity")
{
CHECK(fmt::format("{}", 1q_J_per_mol_K) == "1 J ⋅ K⁻¹ ⋅ mol⁻¹");
CHECK(fmt::format("{:%Q %Aq}", 1q_J_per_mol_K) == "1 J K^-1 mol^-1");
CHECK(fmt::format("{}", 1_q_J_per_mol_K) == "1 J ⋅ K⁻¹ ⋅ mol⁻¹");
CHECK(fmt::format("{:%Q %Aq}", 1_q_J_per_mol_K) == "1 J K^-1 mol^-1");
}
SECTION("thermal conductivity")
{
CHECK(fmt::format("{}", 1q_W_per_m_K) == "1 W ⋅ m⁻¹ ⋅ K⁻¹");
CHECK(fmt::format("{:%Q %Aq}", 1q_W_per_m_K) == "1 W m^-1 K^-1");
CHECK(fmt::format("{}", 1_q_W_per_m_K) == "1 W ⋅ m⁻¹ ⋅ K⁻¹");
CHECK(fmt::format("{:%Q %Aq}", 1_q_W_per_m_K) == "1 W m^-1 K^-1");
}
SECTION("electric field strength")
{
CHECK(fmt::format("{}", 1q_V_per_m) == "1 V/m");
CHECK(fmt::format("{}", 1_q_V_per_m) == "1 V/m");
}
SECTION("charge density")
{
CHECK(fmt::format("{}", 1q_C_per_m3) == "1 C/m³");
CHECK(fmt::format("{:%Q %Aq}", 1q_C_per_m3) == "1 C/m^3");
CHECK(fmt::format("{}", 1q_C_per_m2) == "1 C/m²");
CHECK(fmt::format("{:%Q %Aq}", 1q_C_per_m2) == "1 C/m^2");
CHECK(fmt::format("{}", 1_q_C_per_m3) == "1 C/m³");
CHECK(fmt::format("{:%Q %Aq}", 1_q_C_per_m3) == "1 C/m^3");
CHECK(fmt::format("{}", 1_q_C_per_m2) == "1 C/m²");
CHECK(fmt::format("{:%Q %Aq}", 1_q_C_per_m2) == "1 C/m^2");
}
SECTION("permittivity")
{
CHECK(fmt::format("{}", 1q_F_per_m) == "1 F/m");
CHECK(fmt::format("{}", 1_q_F_per_m) == "1 F/m");
}
SECTION("permeability")
{
CHECK(fmt::format("{}", 1q_H_per_m) == "1 H/m");
CHECK(fmt::format("{}", 1_q_H_per_m) == "1 H/m");
}
SECTION("molar energy")
{
CHECK(fmt::format("{}", 1q_J_per_mol) == "1 J/mol");
CHECK(fmt::format("{}", 1_q_J_per_mol) == "1 J/mol");
}
SECTION("incoherent units with powers")
{
CHECK(fmt::format("{}", 1q_mi * 1q_mi * 1q_mi) == "1 [15900351812136/3814697265625 × 10⁹] m³");
CHECK(fmt::format("{}", 1q_au * 1q_au) == "1 [2237952291797391849 × 10⁴] m²");
CHECK(fmt::format("{}", 1_q_mi * 1_q_mi * 1_q_mi) == "1 [15900351812136/3814697265625 × 10⁹] m³");
CHECK(fmt::format("{}", 1_q_au * 1_q_au) == "1 [2237952291797391849 × 10⁴] m²");
CHECK(fmt::format("{:%Q %Aq}", 1q_mi * 1q_mi * 1q_mi) == "1 [15900351812136/3814697265625 x 10^9] m^3");
CHECK(fmt::format("{:%Q %Aq}", 1q_au * 1q_au) == "1 [2237952291797391849 x 10^4] m^2");
CHECK(fmt::format("{:%Q %Aq}", 1_q_mi * 1_q_mi * 1_q_mi) == "1 [15900351812136/3814697265625 x 10^9] m^3");
CHECK(fmt::format("{:%Q %Aq}", 1_q_au * 1_q_au) == "1 [2237952291797391849 x 10^4] m^2");
}
SECTION("unknown scaled unit with reference different than the dimension's coherent unit")
test/unit_test/runtime/math_test.cpp
+12 -12
View File
@@ -33,25 +33,25 @@ using namespace units::physical::si;
TEST_CASE("'pow<N>()' on quantity changes the value and the dimension accordingly", "[math][pow]")
{
SECTION ("'pow<0>(q)' returns '1'") {
CHECK(pow<0>(2q_m) == 1);
CHECK(pow<0>(2_q_m) == 1);
}
SECTION ("'pow<1>(q)' returns 'q'") {
CHECK(pow<1>(2q_m) == 2q_m);
CHECK(pow<1>(2_q_m) == 2_q_m);
}
SECTION ("'pow<2>(q)' squares both the value and a dimension") {
CHECK(pow<2>(2q_m) == 4q_m2);
CHECK(pow<2>(2_q_m) == 4_q_m2);
}
SECTION ("'pow<3>(q)' cubes both the value and a dimension") {
CHECK(pow<3>(2q_m) == 8q_m3);
CHECK(pow<3>(2_q_m) == 8_q_m3);
}
}
TEST_CASE("'sqrt()' on quantity changes the value and the dimension accordingly", "[math][sqrt]")
{
REQUIRE(sqrt(4q_m2) == 2q_m);
REQUIRE(sqrt(4_q_m2) == 2_q_m);
}
TEST_CASE("absolute functions on quantity returns the absolute value", "[math][abs][fabs]")
@@ -60,13 +60,13 @@ TEST_CASE("absolute functions on quantity returns the absolute value", "[math][a
{
SECTION ("integral representation")
{
REQUIRE(abs(-1q_m) == 1q_m);
REQUIRE(abs(-1_q_m) == 1_q_m);
}
#ifndef COMP_MSVC
SECTION ("floating-point representation")
{
REQUIRE(abs(-1.q_m) == 1q_m);
REQUIRE(abs(-1._q_m) == 1_q_m);
}
#endif
}
@@ -75,13 +75,13 @@ TEST_CASE("absolute functions on quantity returns the absolute value", "[math][a
{
SECTION ("integral representation")
{
REQUIRE(abs(1q_m) == 1q_m);
REQUIRE(abs(1_q_m) == 1_q_m);
}
#ifndef COMP_MSVC
SECTION ("floating-point representation")
{
REQUIRE(abs(1.q_m) == 1q_m);
REQUIRE(abs(1._q_m) == 1_q_m);
}
#endif
}
@@ -90,12 +90,12 @@ TEST_CASE("absolute functions on quantity returns the absolute value", "[math][a
TEST_CASE("numeric_limits functions", "[limits]")
{
SECTION ("'epsilon' works as expected using default floating type") {
REQUIRE(epsilon<decltype(1.q_m)>().count() == std::numeric_limits<decltype(1.q_m)::rep>::epsilon());
REQUIRE(epsilon<decltype(1._q_m)>().count() == std::numeric_limits<decltype(1._q_m)::rep>::epsilon());
}
SECTION ("'epsilon' works as expected using integers") {
REQUIRE(epsilon<decltype(1q_m)>().count() == std::numeric_limits<decltype(1q_m)::rep>::epsilon());
REQUIRE(epsilon<decltype(1_q_m)>().count() == std::numeric_limits<decltype(1_q_m)::rep>::epsilon());
}
SECTION ("'epsilon' works as expected using mixed Rep types") {
REQUIRE(epsilon<decltype(1q_m)>().count() != std::numeric_limits<decltype(1.q_m)::rep>::epsilon());
REQUIRE(epsilon<decltype(1_q_m)>().count() != std::numeric_limits<decltype(1._q_m)::rep>::epsilon());
}
}
test/unit_test/static/cgs_test.cpp
+20 -20
View File
@@ -50,17 +50,17 @@ static_assert(centimetre::symbol == "cm");
// speed
static_assert(10q_cm / 5q_s == 2q_cm_per_s);
static_assert(10q_cm / 2q_cm_per_s == 5q_s);
static_assert(10q_cm == 2q_cm_per_s * 5q_s);
static_assert(10_q_cm / 5_q_s == 2_q_cm_per_s);
static_assert(10_q_cm / 2_q_cm_per_s == 5_q_s);
static_assert(10_q_cm == 2_q_cm_per_s * 5_q_s);
static_assert(detail::unit_text<dim_speed, centimetre_per_second>() == "cm/s");
// area
static_assert(centimetre::ratio / dimension_unit<dim_length>::ratio == ratio(1));
static_assert(1q_cm * 1q_cm == 1q_cm2);
static_assert(100q_cm2 / 10q_cm == 10q_cm);
static_assert(1_q_cm * 1_q_cm == 1_q_cm2);
static_assert(100_q_cm2 / 10_q_cm == 10_q_cm);
static_assert(detail::unit_text<dim_area, square_centimetre>() == basic_symbol_text("cm²", "cm^2"));
@@ -68,35 +68,35 @@ static_assert(detail::unit_text<dim_area, square_centimetre>() == basic_symbol_t
// acceleration
static_assert(10q_cm_per_s / 10q_s == 1q_Gal);
static_assert(10q_cm_per_s / 1q_Gal == 10q_s);
static_assert(1q_Gal * 10q_s == 10q_cm_per_s);
static_assert(10_q_cm_per_s / 10_q_s == 1_q_Gal);
static_assert(10_q_cm_per_s / 1_q_Gal == 10_q_s);
static_assert(1_q_Gal * 10_q_s == 10_q_cm_per_s);
// force
static_assert(10q_g * 10q_Gal == 100q_dyn);
static_assert(100q_dyn / 10q_g == 10q_Gal);
static_assert(100q_dyn / 10q_Gal == 10q_g);
static_assert(10_q_g * 10_q_Gal == 100_q_dyn);
static_assert(100_q_dyn / 10_q_g == 10_q_Gal);
static_assert(100_q_dyn / 10_q_Gal == 10_q_g);
// pressure
static_assert(10q_dyn / 10q_cm2 == 1q_Ba);
static_assert(10q_dyn / 1q_Ba == 10q_cm2);
static_assert(1q_Ba * 10q_cm2 == 10q_dyn);
static_assert(10_q_dyn / 10_q_cm2 == 1_q_Ba);
static_assert(10_q_dyn / 1_q_Ba == 10_q_cm2);
static_assert(1_q_Ba * 10_q_cm2 == 10_q_dyn);
// energy
static_assert(10q_dyn * 10q_cm == 100q_erg);
static_assert(100q_erg / 10q_cm == 10q_dyn);
static_assert(100q_erg / 10q_dyn == 10q_cm);
static_assert(10_q_dyn * 10_q_cm == 100_q_erg);
static_assert(100_q_erg / 10_q_cm == 10_q_dyn);
static_assert(100_q_erg / 10_q_dyn == 10_q_cm);
/* ************** DERIVED DIMENSIONS IN TERMS OF OTHER UNITS **************** */
// power
static_assert(10q_erg / 10q_s == 1q_erg_per_s);
static_assert(1q_erg_per_s * 10q_s == 10q_erg);
static_assert(10q_erg / 1q_erg_per_s == 10q_s);
static_assert(10_q_erg / 10_q_s == 1_q_erg_per_s);
static_assert(1_q_erg_per_s * 10_q_s == 10_q_erg);
static_assert(10_q_erg / 1_q_erg_per_s == 10_q_s);
static_assert(detail::unit_text<dim_power, erg_per_second>() == "erg/s");
test/unit_test/static/custom_unit_test.cpp
+1 -1
View File
@@ -62,7 +62,7 @@ namespace {
struct kilogram_per_second : unit<kilogram_per_second> {};
struct dim_mass_rate : derived_dimension<dim_mass_rate, kilogram_per_second, units::exponent<dim_mass, 1>, units::exponent<dim_time, -1>> {};
struct kilogram_per_hour : deduced_unit<kilogram_per_hour, dim_mass_rate, kilogram, hour> {};
constexpr auto a = 1q_kg / 1q_h;
constexpr auto a = 1_q_kg / 1_q_h;
static_assert(is_same_v<decltype(a)::unit, kilogram_per_hour>);
}
test/unit_test/static/data_test.cpp
+10 -10
View File
@@ -31,17 +31,17 @@ using namespace units::data;
// information
static_assert(1q_B == 8q_b);
static_assert(1024q_b == 1q_Kib);
static_assert(1024q_B == 1q_KiB);
static_assert(8 * 1024q_b == 1q_KiB);
static_assert(8 * 1q_Kib == 1q_KiB);
static_assert(1_q_B == 8_q_b);
static_assert(1024_q_b == 1_q_Kib);
static_assert(1024_q_B == 1_q_KiB);
static_assert(8 * 1024_q_b == 1_q_KiB);
static_assert(8 * 1_q_Kib == 1_q_KiB);
static_assert(1q_Kib == 1024q_b);
static_assert(1q_Mib == 1024q_Kib);
static_assert(1q_Gib == 1024q_Mib);
static_assert(1q_Tib == 1024q_Gib);
static_assert(1q_Pib == 1024q_Tib);
static_assert(1_q_Kib == 1024_q_b);
static_assert(1_q_Mib == 1024_q_Kib);
static_assert(1_q_Gib == 1024_q_Mib);
static_assert(1_q_Tib == 1024_q_Gib);
static_assert(1_q_Pib == 1024_q_Tib);
// bitrate
test/unit_test/static/fps_test.cpp
+20 -20
View File
@@ -50,17 +50,17 @@ static_assert(foot::symbol == "ft");
// speed
static_assert(10q_ft / 5q_s == 2q_ft_per_s);
static_assert(10q_ft / 2q_ft_per_s == 5q_s);
static_assert(10q_ft == 2q_ft_per_s * 5q_s);
static_assert(10_q_ft / 5_q_s == 2_q_ft_per_s);
static_assert(10_q_ft / 2_q_ft_per_s == 5_q_s);
static_assert(10_q_ft == 2_q_ft_per_s * 5_q_s);
static_assert(detail::unit_text<dim_speed, foot_per_second>() == "ft/s");
// area
static_assert(foot::ratio / dimension_unit<dim_length>::ratio == ratio(1));
static_assert(1q_ft * 1q_ft == 1q_ft2);
static_assert(100q_ft2 / 10q_ft == 10q_ft);
static_assert(1_q_ft * 1_q_ft == 1_q_ft2);
static_assert(100_q_ft2 / 10_q_ft == 10_q_ft);
static_assert(detail::unit_text<dim_area, square_foot>() == basic_symbol_text("ft²", "ft^2"));
@@ -68,34 +68,34 @@ static_assert(detail::unit_text<dim_area, square_foot>() == basic_symbol_text("f
// acceleration
static_assert(10q_ft_per_s / 10q_s == 1q_ft_per_s2);
static_assert(10q_ft_per_s / 1q_ft_per_s2 == 10q_s);
static_assert(1q_ft_per_s2 * 10q_s == 10q_ft_per_s);
static_assert(10_q_ft_per_s / 10_q_s == 1_q_ft_per_s2);
static_assert(10_q_ft_per_s / 1_q_ft_per_s2 == 10_q_s);
static_assert(1_q_ft_per_s2 * 10_q_s == 10_q_ft_per_s);
// force
static_assert(10q_lb * 10q_ft_per_s2 == 100q_pdl);
static_assert(100q_pdl / 10q_lb == 10q_ft_per_s2);
static_assert(100q_pdl / 10q_ft_per_s2 == 10q_lb);
static_assert(10_q_lb * 10_q_ft_per_s2 == 100_q_pdl);
static_assert(100_q_pdl / 10_q_lb == 10_q_ft_per_s2);
static_assert(100_q_pdl / 10_q_ft_per_s2 == 10_q_lb);
// pressure
static_assert(10q_pdl / 10q_ft2 == 1q_pdl_per_ft2);
static_assert(10q_pdl / 1q_pdl_per_ft2 == 10q_ft2);
static_assert(1q_pdl_per_ft2 * 10q_ft2 == 10q_pdl);
static_assert(10_q_pdl / 10_q_ft2 == 1_q_pdl_per_ft2);
static_assert(10_q_pdl / 1_q_pdl_per_ft2 == 10_q_ft2);
static_assert(1_q_pdl_per_ft2 * 10_q_ft2 == 10_q_pdl);
// energy
static_assert(10q_pdl * 10q_ft == 100q_ft_pdl);
static_assert(100q_ft_pdl / 10q_ft == 10q_pdl);
static_assert(100q_ft_pdl / 10q_pdl == 10q_ft);
static_assert(10_q_pdl * 10_q_ft == 100_q_ft_pdl);
static_assert(100_q_ft_pdl / 10_q_ft == 10_q_pdl);
static_assert(100_q_ft_pdl / 10_q_pdl == 10_q_ft);
/* ************** DERIVED DIMENSIONS IN TERMS OF OTHER UNITS **************** */
// power
static_assert(10q_ft_pdl / 10q_s == 1q_ft_pdl_per_s);
static_assert(1q_ft_pdl_per_s * 10q_s == 10q_ft_pdl);
static_assert(10q_ft_pdl / 1q_ft_pdl_per_s == 10q_s);
static_assert(10_q_ft_pdl / 10_q_s == 1_q_ft_pdl_per_s);
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_pound_force_per_second>() == "ft_lbf/s");
test/unit_test/static/math_test.cpp
+8 -8
View File
@@ -31,14 +31,14 @@ namespace {
using namespace units::physical::si::literals;
using namespace units::physical::international::literals;
static_assert(is_same_v<decltype(pow<0>(2q_m)), std::int64_t>);
static_assert(is_same_v<decltype(pow<1>(2q_m)), decltype(2q_m)>);
static_assert(is_same_v<decltype(pow<2>(2q_m)), decltype(4q_m2)>);
static_assert(is_same_v<decltype(pow<2>(2q_km)), decltype(4q_km2)>);
static_assert(is_same_v<decltype(pow<2>(2q_ft)), decltype(4q_ft2)>);
static_assert(is_same_v<decltype(sqrt(4q_m2)), decltype(2q_m)>);
static_assert(is_same_v<decltype(sqrt(4q_km2)), decltype(2q_km)>);
static_assert(is_same_v<decltype(sqrt(4q_ft2)), decltype(2q_ft)>);
static_assert(is_same_v<decltype(pow<0>(2_q_m)), std::int64_t>);
static_assert(is_same_v<decltype(pow<1>(2_q_m)), decltype(2_q_m)>);
static_assert(is_same_v<decltype(pow<2>(2_q_m)), decltype(4_q_m2)>);
static_assert(is_same_v<decltype(pow<2>(2_q_km)), decltype(4_q_km2)>);
static_assert(is_same_v<decltype(pow<2>(2_q_ft)), decltype(4_q_ft2)>);
static_assert(is_same_v<decltype(sqrt(4_q_m2)), decltype(2_q_m)>);
static_assert(is_same_v<decltype(sqrt(4_q_km2)), decltype(2_q_km)>);
static_assert(is_same_v<decltype(sqrt(4_q_ft2)), decltype(2_q_ft)>);
} // namespace
test/unit_test/static/quantity_point_test.cpp
+72 -72
View File
@@ -58,23 +58,23 @@ static_assert(is_same_v<quantity_point<dim_length, kilometre, int>::unit, kilome
// constructors
static_assert(quantity_point<dim_length, metre, int>().relative() == 0q_m);
constexpr quantity_point<dim_length, metre, int> km{1000q_m};
static_assert(km.relative() == 1000q_m);
static_assert(quantity_point<dim_length, metre, int>().relative() == 0_q_m);
constexpr quantity_point<dim_length, metre, int> km{1000_q_m};
static_assert(km.relative() == 1000_q_m);
static_assert(quantity_point<dim_length, metre, int>(km).relative() == km.relative());
static_assert(quantity_point<dim_length, metre, int>(1q_m).relative() == 1q_m);
static_assert(quantity_point<dim_length, metre, int>(1_q_m).relative() == 1_q_m);
static_assert(!std::is_constructible_v<quantity_point<dim_length, metre, int>, double>); // truncating conversion
static_assert(quantity_point<dim_length, metre, double>(1.0q_m).relative() == 1.0q_m);
static_assert(quantity_point<dim_length, metre, double>(1q_m).relative() == 1q_m);
static_assert(quantity_point<dim_length, metre, long double>(3.14q_m).relative() == 3.14q_m);
static_assert(quantity_point<dim_length, metre, double>(1.0_q_m).relative() == 1.0_q_m);
static_assert(quantity_point<dim_length, metre, double>(1_q_m).relative() == 1_q_m);
static_assert(quantity_point<dim_length, metre, long double>(3.14_q_m).relative() == 3.14_q_m);
static_assert(quantity_point<dim_length, metre, int>(km).relative() == 1000q_m);
static_assert(quantity_point<dim_length, metre, int>(km).relative() == 1000_q_m);
static_assert(!std::is_constructible_v<quantity_point<dim_length, metre, int>,
quantity_point<dim_length, metre, double>>); // truncating conversion
static_assert(quantity_point<dim_length, metre, double>(quantity_point(1000.0q_m)).relative() == 1000.0q_m);
static_assert(quantity_point<dim_length, metre, double>(km).relative() == 1000.0q_m);
static_assert(quantity_point<dim_length, metre, int>(quantity_point(1q_km)).relative() == 1000q_m);
static_assert(quantity_point<dim_length, metre, double>(quantity_point(1000.0_q_m)).relative() == 1000.0_q_m);
static_assert(quantity_point<dim_length, metre, double>(km).relative() == 1000.0_q_m);
static_assert(quantity_point<dim_length, metre, int>(quantity_point(1_q_km)).relative() == 1000_q_m);
static_assert(!std::is_constructible_v<quantity_point<dim_length, metre, int>,
quantity_point<dim_time, second, int>>); // different dimensions
static_assert(!std::is_constructible_v<quantity_point<dim_length, kilometre, int>,
@@ -82,7 +82,7 @@ static_assert(!std::is_constructible_v<quantity_point<dim_length, kilometre, int
// assignment operator
static_assert([]() { quantity_point<dim_length, metre, int> l1(1q_m), l2{}; return l2 = l1; }().relative() == 1q_m);
static_assert([]() { quantity_point<dim_length, metre, int> l1(1_q_m), l2{}; return l2 = l1; }().relative() == 1_q_m);
// static member functions
@@ -98,24 +98,24 @@ static_assert(quantity_point<dim_length, metre, double>::max().relative().count(
static_assert([](auto v) {
auto vv = v++;
return std::pair(v, vv);
}(km) == std::pair(quantity_point<dim_length, metre, int>(1001q_m), quantity_point<dim_length, metre, int>(1000q_m)));
}(km) == std::pair(quantity_point<dim_length, metre, int>(1001_q_m), quantity_point<dim_length, metre, int>(1000_q_m)));
static_assert([](auto v) {
auto vv = ++v;
return std::pair(v, vv);
}(km) == std::pair(quantity_point<dim_length, metre, int>(1001q_m), quantity_point<dim_length, metre, int>(1001q_m)));
}(km) == std::pair(quantity_point<dim_length, metre, int>(1001_q_m), quantity_point<dim_length, metre, int>(1001_q_m)));
static_assert([](auto v) {
auto vv = v--;
return std::pair(v, vv);
}(km) == std::pair(quantity_point<dim_length, metre, int>(999q_m), quantity_point<dim_length, metre, int>(1000q_m)));
}(km) == std::pair(quantity_point<dim_length, metre, int>(999_q_m), quantity_point<dim_length, metre, int>(1000_q_m)));
static_assert([](auto v) {
auto vv = --v;
return std::pair(v, vv);
}(km) == std::pair(quantity_point<dim_length, metre, int>(999q_m), quantity_point<dim_length, metre, int>(999q_m)));
}(km) == std::pair(quantity_point<dim_length, metre, int>(999_q_m), quantity_point<dim_length, metre, int>(999_q_m)));
// compound assignment
static_assert((quantity_point(1q_m) += 1q_m).relative().count() == 2);
static_assert((quantity_point(2q_m) -= 1q_m).relative().count() == 1);
static_assert((quantity_point(1_q_m) += 1_q_m).relative().count() == 2);
static_assert((quantity_point(2_q_m) -= 1_q_m).relative().count() == 1);
// non-member arithmetic operators
@@ -138,48 +138,48 @@ static_assert(
is_same_v<decltype(quantity_point<dim_length, kilometre, double>() - quantity_point<dim_length, metre, int>()),
length<metre, double>>);
static_assert((1q_m + km).relative().count() == 1001);
static_assert((quantity_point(1q_m) + 1q_km).relative().count() == 1001);
static_assert((km - 1q_m).relative().count() == 999);
static_assert((quantity_point(1q_km) - quantity_point(1q_m)).count() == 999);
static_assert((1_q_m + km).relative().count() == 1001);
static_assert((quantity_point(1_q_m) + 1_q_km).relative().count() == 1001);
static_assert((km - 1_q_m).relative().count() == 999);
static_assert((quantity_point(1_q_km) - quantity_point(1_q_m)).count() == 999);
// comparators
static_assert(quantity_point(2q_m) + 1q_m == quantity_point(3q_m));
static_assert(!(2q_m + quantity_point(2q_m) == quantity_point(3q_m)));
static_assert(quantity_point(2q_m) + 2q_m != quantity_point(3q_m));
static_assert(!(2q_m + quantity_point(2q_m) != quantity_point(4q_m)));
static_assert(quantity_point(2q_m) > quantity_point(1q_m));
static_assert(!(quantity_point(1q_m) > quantity_point(1q_m)));
static_assert(quantity_point(1q_m) < quantity_point(2q_m));
static_assert(!(quantity_point(2q_m) < quantity_point(2q_m)));
static_assert(quantity_point(2q_m) >= quantity_point(1q_m));
static_assert(quantity_point(2q_m) >= quantity_point(2q_m));
static_assert(!(quantity_point(2q_m) >= quantity_point(3q_m)));
static_assert(quantity_point(1q_m) <= quantity_point(2q_m));
static_assert(quantity_point(2q_m) <= quantity_point(2q_m));
static_assert(!(quantity_point(3q_m) <= quantity_point(2q_m)));
static_assert(quantity_point(2_q_m) + 1_q_m == quantity_point(3_q_m));
static_assert(!(2_q_m + quantity_point(2_q_m) == quantity_point(3_q_m)));
static_assert(quantity_point(2_q_m) + 2_q_m != quantity_point(3_q_m));
static_assert(!(2_q_m + quantity_point(2_q_m) != quantity_point(4_q_m)));
static_assert(quantity_point(2_q_m) > quantity_point(1_q_m));
static_assert(!(quantity_point(1_q_m) > quantity_point(1_q_m)));
static_assert(quantity_point(1_q_m) < quantity_point(2_q_m));
static_assert(!(quantity_point(2_q_m) < quantity_point(2_q_m)));
static_assert(quantity_point(2_q_m) >= quantity_point(1_q_m));
static_assert(quantity_point(2_q_m) >= quantity_point(2_q_m));
static_assert(!(quantity_point(2_q_m) >= quantity_point(3_q_m)));
static_assert(quantity_point(1_q_m) <= quantity_point(2_q_m));
static_assert(quantity_point(2_q_m) <= quantity_point(2_q_m));
static_assert(!(quantity_point(3_q_m) <= quantity_point(2_q_m)));
static_assert(quantity_point(3q_m) == quantity_point(3.0q_m));
static_assert(quantity_point(3q_m) != quantity_point(3.14q_m));
static_assert(quantity_point(2q_m) > quantity_point(1.0q_m));
static_assert(quantity_point(1.0q_m) < quantity_point(2q_m));
static_assert(quantity_point(2.0q_m) >= quantity_point(1q_m));
static_assert(quantity_point(1q_m) <= quantity_point(2.0q_m));
static_assert(quantity_point(3_q_m) == quantity_point(3.0_q_m));
static_assert(quantity_point(3_q_m) != quantity_point(3.14_q_m));
static_assert(quantity_point(2_q_m) > quantity_point(1.0_q_m));
static_assert(quantity_point(1.0_q_m) < quantity_point(2_q_m));
static_assert(quantity_point(2.0_q_m) >= quantity_point(1_q_m));
static_assert(quantity_point(1_q_m) <= quantity_point(2.0_q_m));
static_assert(quantity_point(1000q_m) == quantity_point(1q_km));
static_assert(quantity_point(1001q_m) != quantity_point(1q_km));
static_assert(quantity_point(1001q_m) > quantity_point(1q_km));
static_assert(quantity_point(999q_m) < quantity_point(1q_km));
static_assert(quantity_point(1000q_m) >= quantity_point(1q_km));
static_assert(quantity_point(1000q_m) <= quantity_point(1q_km));
static_assert(quantity_point(1000_q_m) == quantity_point(1_q_km));
static_assert(quantity_point(1001_q_m) != quantity_point(1_q_km));
static_assert(quantity_point(1001_q_m) > quantity_point(1_q_km));
static_assert(quantity_point(999_q_m) < quantity_point(1_q_km));
static_assert(quantity_point(1000_q_m) >= quantity_point(1_q_km));
static_assert(quantity_point(1000_q_m) <= quantity_point(1_q_km));
// alias units
static_assert(quantity_point(2q_l) + 2q_ml == quantity_point(2002q_ml));
static_assert(2q_l + quantity_point(2q_ml) == quantity_point(2002q_cm3));
static_assert(quantity_point(2q_l) + 2q_cm3 == quantity_point(2002q_ml));
static_assert(2q_dm3 + quantity_point(2q_cm3) == quantity_point(2002q_ml));
static_assert(quantity_point(2_q_l) + 2_q_ml == quantity_point(2002_q_ml));
static_assert(2_q_l + quantity_point(2_q_ml) == quantity_point(2002_q_cm3));
static_assert(quantity_point(2_q_l) + 2_q_cm3 == quantity_point(2002_q_ml));
static_assert(2_q_dm3 + quantity_point(2_q_cm3) == quantity_point(2002_q_ml));
// is_quantity_point
@@ -201,47 +201,47 @@ static_assert(is_same_v<common_quantity_point<quantity_point<dim_length, kilomet
using namespace units::physical::us::literals;
static_assert(std::equality_comparable<decltype(quantity_point(1q_m))>);
static_assert(std::equality_comparable_with<decltype(quantity_point(1q_m)), decltype(quantity_point(1q_km))>);
static_assert(quantity_point(0q_m) == quantity_point(0q_ft_us));
static_assert(std::equality_comparable_with<decltype(quantity_point(1q_m)), decltype(quantity_point(1q_ft_us))>);
static_assert(std::equality_comparable<decltype(quantity_point(1_q_m))>);
static_assert(std::equality_comparable_with<decltype(quantity_point(1_q_m)), decltype(quantity_point(1_q_km))>);
static_assert(quantity_point(0_q_m) == quantity_point(0_q_ft_us));
static_assert(std::equality_comparable_with<decltype(quantity_point(1_q_m)), decltype(quantity_point(1_q_ft_us))>);
// quantity_cast
static_assert(
is_same_v<decltype(quantity_point_cast<scaled_unit<ratio(1), metre>>(quantity_point(2q_km)))::unit, metre>);
is_same_v<decltype(quantity_point_cast<scaled_unit<ratio(1), metre>>(quantity_point(2_q_km)))::unit, metre>);
static_assert(quantity_point_cast<quantity_point<dim_length, metre, int>>(quantity_point(2q_km)).relative().count() ==
static_assert(quantity_point_cast<quantity_point<dim_length, metre, int>>(quantity_point(2_q_km)).relative().count() ==
2000);
static_assert(
quantity_point_cast<quantity_point<dim_length, kilometre, int>>(quantity_point(2000q_m)).relative().count() == 2);
static_assert(quantity_point_cast<quantity_point<dim_length, metre, int>>(quantity_point(1.23q_m)).relative().count() ==
quantity_point_cast<quantity_point<dim_length, kilometre, int>>(quantity_point(2000_q_m)).relative().count() == 2);
static_assert(quantity_point_cast<quantity_point<dim_length, metre, int>>(quantity_point(1.23_q_m)).relative().count() ==
1);
static_assert(quantity_point_cast<length<metre, int>>(quantity_point(2q_km)).relative().count() == 2000);
static_assert(quantity_point_cast<length<kilometre, int>>(quantity_point(2000q_m)).relative().count() == 2);
static_assert(quantity_point_cast<length<metre, int>>(quantity_point(1.23q_m)).relative().count() == 1);
static_assert(quantity_point_cast<metre>(quantity_point(2q_km)).relative().count() == 2000);
static_assert(quantity_point_cast<kilometre>(quantity_point(2000q_m)).relative().count() == 2);
static_assert(quantity_point_cast<int>(quantity_point(1.23q_m)).relative().count() == 1);
static_assert(quantity_point_cast<length<metre, int>>(quantity_point(2_q_km)).relative().count() == 2000);
static_assert(quantity_point_cast<length<kilometre, int>>(quantity_point(2000_q_m)).relative().count() == 2);
static_assert(quantity_point_cast<length<metre, int>>(quantity_point(1.23_q_m)).relative().count() == 1);
static_assert(quantity_point_cast<metre>(quantity_point(2_q_km)).relative().count() == 2000);
static_assert(quantity_point_cast<kilometre>(quantity_point(2000_q_m)).relative().count() == 2);
static_assert(quantity_point_cast<int>(quantity_point(1.23_q_m)).relative().count() == 1);
// time
static_assert(quantity_point{1q_h} == quantity_point{3600q_s});
static_assert(quantity_point{1_q_h} == quantity_point{3600_q_s});
template<typename Metre>
concept no_crossdimensional_equality = !requires
{
quantity_point(1q_s) == quantity_point(length<Metre, int>(1));
quantity_point(1_q_s) == quantity_point(length<Metre, int>(1));
};
static_assert(no_crossdimensional_equality<metre>);
// length
static_assert(quantity_point(1q_km) != quantity_point(1q_m));
static_assert(quantity_point(1q_km) == quantity_point(1000q_m));
static_assert(quantity_point(1q_km) + 1q_m == quantity_point(1001q_m));
static_assert(1q_km + quantity_point(1q_m) == quantity_point(1001q_m));
static_assert(quantity_point(1_q_km) != quantity_point(1_q_m));
static_assert(quantity_point(1_q_km) == quantity_point(1000_q_m));
static_assert(quantity_point(1_q_km) + 1_q_m == quantity_point(1001_q_m));
static_assert(1_q_km + quantity_point(1_q_m) == quantity_point(1001_q_m));
template<class T>
concept dimensional_analysis = requires(T t)
test/unit_test/static/quantity_test.cpp
+88 -88
View File
@@ -69,9 +69,9 @@ static_assert(length<metre, double>(3.14).count() == 3.14);
static_assert(length<metre, int>(km).count() == 1000);
static_assert(!std::is_constructible_v<length<metre, int>,
length<metre, double>>); // truncating conversion
static_assert(length<metre, double>(1000.0q_m).count() == 1000.0);
static_assert(length<metre, double>(1000.0_q_m).count() == 1000.0);
static_assert(length<metre, double>(km).count() == 1000.0);
static_assert(length<metre, int>(1q_km).count() == 1000);
static_assert(length<metre, int>(1_q_km).count() == 1000);
static_assert(!std::is_constructible_v<length<metre, int>,
physical::si::time<second, int>>); // different dimensions
static_assert(!std::is_constructible_v<length<kilometre, int>,
@@ -116,18 +116,18 @@ static_assert([](auto v) {
// compound assignment
static_assert((1q_m += 1q_m).count() == 2);
static_assert((2q_m -= 1q_m).count() == 1);
static_assert((1q_m *= 2).count() == 2);
static_assert((2q_m /= 2).count() == 1);
static_assert((7q_m %= 2).count() == 1);
static_assert((7q_m %= 2q_m).count() == 1);
static_assert((1_q_m += 1_q_m).count() == 2);
static_assert((2_q_m -= 1_q_m).count() == 1);
static_assert((1_q_m *= 2).count() == 2);
static_assert((2_q_m /= 2).count() == 1);
static_assert((7_q_m %= 2).count() == 1);
static_assert((7_q_m %= 2_q_m).count() == 1);
static_assert((2.5q_m += 3q_m).count() == 5.5);
static_assert((2.5q_m += 3.5q_m).count() == 6);
static_assert((2.5_q_m += 3_q_m).count() == 5.5);
static_assert((2.5_q_m += 3.5_q_m).count() == 6);
static_assert((2.5q_m *= 3).count() == 7.5);
static_assert((2.5q_m *= 3.5).count() == 8.75);
static_assert((2.5_q_m *= 3).count() == 7.5);
static_assert((2.5_q_m *= 3.5).count() == 8.75);
// operations not allowed for the respective quantities
template<typename Metre>
@@ -136,11 +136,11 @@ concept invalid_compound_assignments = requires()
!requires(length<Metre, double> l) { l %= 2.; };
!requires(length<Metre, double> l) { l %= 2; };
!requires(length<Metre, int> l) { l %= 2.; };
!requires(length<Metre, double> l) { l %= 2.q_m; };
!requires(length<Metre, double> l) { l %= 2q_m; };
!requires(length<Metre, int> l) { l %= 2.q_m; };
!requires(length<Metre, int> l) { l += 3.5q_m; };
!requires(length<Metre, int> l) { l *= 3.5q_m; };
!requires(length<Metre, double> l) { l %= 2._q_m; };
!requires(length<Metre, double> l) { l %= 2_q_m; };
!requires(length<Metre, int> l) { l %= 2._q_m; };
!requires(length<Metre, int> l) { l += 3.5_q_m; };
!requires(length<Metre, int> l) { l *= 3.5_q_m; };
};
static_assert(invalid_compound_assignments<metre>);
@@ -179,22 +179,22 @@ static_assert(is_same_v<decltype(physical::si::time<minute>() / length<metre>())
static_assert(is_same_v<decltype(length<metre, int>() % short(1)), length<metre, int>>);
static_assert(is_same_v<decltype(length<metre, int>() % length<metre, short>(1)), length<metre, int>>);
static_assert((1q_m + km).count() == 1001);
static_assert((1q_m + 1q_km).count() == 1001);
static_assert((km - 1q_m).count() == 999);
static_assert((1q_km - 1q_m).count() == 999);
static_assert((2q_m * 2).count() == 4);
static_assert((3 * 3q_m).count() == 9);
static_assert((4q_m / 2).count() == 2);
static_assert((4q_km / 2q_m).count() == 2);
static_assert((4000q_m / 2q_m).count() == 2000);
static_assert((7q_m % 2).count() == 1);
static_assert((7q_m % 2q_m).count() == 1);
static_assert((7q_km % 2000q_m).count() == 1000);
static_assert((1_q_m + km).count() == 1001);
static_assert((1_q_m + 1_q_km).count() == 1001);
static_assert((km - 1_q_m).count() == 999);
static_assert((1_q_km - 1_q_m).count() == 999);
static_assert((2_q_m * 2).count() == 4);
static_assert((3 * 3_q_m).count() == 9);
static_assert((4_q_m / 2).count() == 2);
static_assert((4_q_km / 2_q_m).count() == 2);
static_assert((4000_q_m / 2_q_m).count() == 2000);
static_assert((7_q_m % 2).count() == 1);
static_assert((7_q_m % 2_q_m).count() == 1);
static_assert((7_q_km % 2000_q_m).count() == 1000);
static_assert((10q_km2 * 10q_km2) / 50q_km2 == 2q_km2);
static_assert((10_q_km2 * 10_q_km2) / 50_q_km2 == 2_q_km2);
constexpr auto q1 = 10q_km / 5q_m;
constexpr auto q1 = 10_q_km / 5_q_m;
static_assert(std::is_same_v<decltype(q1), const dimensionless<scaled_unit<ratio(1, 1, 3), one>, std::int64_t>>);
static_assert(q1.count() == 2);
@@ -203,47 +203,47 @@ static_assert(q2.count() == 2000);
static_assert(quantity_cast<one>(q1).count() == 2000);
constexpr auto q3 = 10q_s * 2q_kHz;
constexpr auto q3 = 10_q_s * 2_q_kHz;
static_assert(std::is_same_v<decltype(q3), const dimensionless<scaled_unit<ratio(1, 1, 3), one>, std::int64_t>>);
static_assert(q3.count() == 20);
// comparators
static_assert(2q_m + 1q_m == 3q_m);
static_assert(!(2q_m + 2q_m == 3q_m));
static_assert(2q_m + 2q_m != 3q_m);
static_assert(!(2q_m + 2q_m != 4q_m));
static_assert(2q_m > 1q_m);
static_assert(!(1q_m > 1q_m));
static_assert(1q_m < 2q_m);
static_assert(!(2q_m < 2q_m));
static_assert(2q_m >= 1q_m);
static_assert(2q_m >= 2q_m);
static_assert(!(2q_m >= 3q_m));
static_assert(1q_m <= 2q_m);
static_assert(2q_m <= 2q_m);
static_assert(!(3q_m <= 2q_m));
static_assert(2_q_m + 1_q_m == 3_q_m);
static_assert(!(2_q_m + 2_q_m == 3_q_m));
static_assert(2_q_m + 2_q_m != 3_q_m);
static_assert(!(2_q_m + 2_q_m != 4_q_m));
static_assert(2_q_m > 1_q_m);
static_assert(!(1_q_m > 1_q_m));
static_assert(1_q_m < 2_q_m);
static_assert(!(2_q_m < 2_q_m));
static_assert(2_q_m >= 1_q_m);
static_assert(2_q_m >= 2_q_m);
static_assert(!(2_q_m >= 3_q_m));
static_assert(1_q_m <= 2_q_m);
static_assert(2_q_m <= 2_q_m);
static_assert(!(3_q_m <= 2_q_m));
static_assert(3q_m == 3.0q_m);
static_assert(3q_m != 3.14q_m);
static_assert(2q_m > 1.0q_m);
static_assert(1.0q_m < 2q_m);
static_assert(2.0q_m >= 1q_m);
static_assert(1q_m <= 2.0q_m);
static_assert(3_q_m == 3.0_q_m);
static_assert(3_q_m != 3.14_q_m);
static_assert(2_q_m > 1.0_q_m);
static_assert(1.0_q_m < 2_q_m);
static_assert(2.0_q_m >= 1_q_m);
static_assert(1_q_m <= 2.0_q_m);
static_assert(1000q_m == 1q_km);
static_assert(1001q_m != 1q_km);
static_assert(1001q_m > 1q_km);
static_assert(999q_m < 1q_km);
static_assert(1000q_m >= 1q_km);
static_assert(1000q_m <= 1q_km);
static_assert(1000_q_m == 1_q_km);
static_assert(1001_q_m != 1_q_km);
static_assert(1001_q_m > 1_q_km);
static_assert(999_q_m < 1_q_km);
static_assert(1000_q_m >= 1_q_km);
static_assert(1000_q_m <= 1_q_km);
// alias units
static_assert(2q_l + 2q_ml == 2002q_ml);
static_assert(2q_l + 2q_ml == 2002q_cm3);
static_assert(2q_l + 2q_cm3 == 2002q_ml);
static_assert(2q_dm3 + 2q_cm3 == 2002q_ml);
static_assert(2_q_l + 2_q_ml == 2002_q_ml);
static_assert(2_q_l + 2_q_ml == 2002_q_cm3);
static_assert(2_q_l + 2_q_cm3 == 2002_q_ml);
static_assert(2_q_dm3 + 2_q_cm3 == 2002_q_ml);
// is_quantity
@@ -261,10 +261,10 @@ static_assert(is_same_v<common_quantity<length<kilometre, long long>, length<mil
using namespace units::physical::us::literals;
static_assert(std::equality_comparable<decltype(1q_m)>);
static_assert(std::equality_comparable_with<decltype(1q_m), decltype(1q_cm)>);
static_assert(0q_m == 0q_ft_us);
static_assert(std::equality_comparable_with<decltype(1q_m), decltype(1q_ft_us)>);
static_assert(std::equality_comparable<decltype(1_q_m)>);
static_assert(std::equality_comparable_with<decltype(1_q_m), decltype(1_q_cm)>);
static_assert(0_q_m == 0_q_ft_us);
static_assert(std::equality_comparable_with<decltype(1_q_m), decltype(1_q_ft_us)>);
static_assert(std::equality_comparable_with<dimensionless<one>, int>);
static_assert(std::equality_comparable_with<dimensionless<one>, double>);
static_assert(std::equality_comparable_with<dimensionless<one, int>, int>);
@@ -272,14 +272,14 @@ static_assert(!std::equality_comparable_with<dimensionless<one, int>, double>);
// quantity_cast
static_assert(is_same_v<decltype(quantity_cast<scaled_unit<ratio(1), metre>>(2q_km))::unit, metre>);
static_assert(is_same_v<decltype(quantity_cast<scaled_unit<ratio(1), metre>>(2_q_km))::unit, metre>);
static_assert(quantity_cast<length<metre, int>>(2q_km).count() == 2000);
static_assert(quantity_cast<length<kilometre, int>>(2000q_m).count() == 2);
static_assert(quantity_cast<length<metre, int>>(1.23q_m).count() == 1);
static_assert(quantity_cast<metre>(2q_km).count() == 2000);
static_assert(quantity_cast<kilometre>(2000q_m).count() == 2);
static_assert(quantity_cast<int>(1.23q_m).count() == 1);
static_assert(quantity_cast<length<metre, int>>(2_q_km).count() == 2000);
static_assert(quantity_cast<length<kilometre, int>>(2000_q_m).count() == 2);
static_assert(quantity_cast<length<metre, int>>(1.23_q_m).count() == 1);
static_assert(quantity_cast<metre>(2_q_km).count() == 2000);
static_assert(quantity_cast<kilometre>(2000_q_m).count() == 2);
static_assert(quantity_cast<int>(1.23_q_m).count() == 1);
// dimensionless
@@ -308,37 +308,37 @@ concept invalid_dimensionless_operations = requires
};
static_assert(invalid_dimensionless_operations<int>);
static_assert(std::is_same_v<decltype(10q_km / 5q_km), quantity<dim_one, one, std::int64_t>>);
static_assert(std::is_same_v<decltype(10_q_km / 5_q_km), quantity<dim_one, one, std::int64_t>>);
static_assert(quantity_cast<percent>(50.q_m / 100.q_m).count() == 50);
static_assert(50.q_m / 100.q_m == dimensionless<percent>(50));
static_assert(quantity_cast<percent>(50._q_m / 100._q_m).count() == 50);
static_assert(50._q_m / 100._q_m == dimensionless<percent>(50));
static_assert(dimensionless<one>(dimensionless<percent>(50)).count() == 0.5);
// time
static_assert(1q_h == 3600q_s);
static_assert(1_q_h == 3600_q_s);
template<typename Metre>
concept no_crossdimensional_equality = !requires { 1q_s == length<Metre, int>(1); };
concept no_crossdimensional_equality = !requires { 1_q_s == length<Metre, int>(1); };
static_assert(no_crossdimensional_equality<metre>);
// length
static_assert(1q_km == 1000q_m);
static_assert(1q_km + 1q_m == 1001q_m);
static_assert(10q_km / 5q_km == 2);
static_assert(10q_km / 2 == 5q_km);
static_assert(1_q_km == 1000_q_m);
static_assert(1_q_km + 1_q_m == 1001_q_m);
static_assert(10_q_km / 5_q_km == 2);
static_assert(10_q_km / 2 == 5_q_km);
// speed
static_assert(10q_m / 5q_s == 2q_m_per_s);
static_assert(10 / 5q_s * 1q_m == 2q_m_per_s);
static_assert(1q_km / 1q_s == 1000q_m_per_s);
static_assert(2q_km_per_h * 2q_h == 4q_km);
static_assert(2q_km / 2q_km_per_h == 1q_h);
static_assert(10_q_m / 5_q_s == 2_q_m_per_s);
static_assert(10 / 5_q_s * 1_q_m == 2_q_m_per_s);
static_assert(1_q_km / 1_q_s == 1000_q_m_per_s);
static_assert(2_q_km_per_h * 2_q_h == 4_q_km);
static_assert(2_q_km / 2_q_km_per_h == 1_q_h);
static_assert(is_same_v<decltype(pow<2>(2q_m)), decltype(4q_m2)>);
static_assert(is_same_v<decltype(pow<2>(2_q_m)), decltype(4_q_m2)>);
} // namespace
test/unit_test/static/si_cgs_test.cpp
+49 -49
View File
@@ -61,15 +61,15 @@ namespace si_test {
using namespace units::physical::si::literals;
static_assert(cgs::length<cgs::centimetre>(100) == 1q_m);
static_assert(cgs::mass<cgs::gram>(1'000) == 1q_kg);
static_assert(cgs::time<cgs::second>(1) == 1q_s);
static_assert(cgs::speed<cgs::centimetre_per_second>(100) == 1q_m_per_s);
static_assert(cgs::acceleration<cgs::gal>(100) == 1q_m_per_s2);
static_assert(cgs::force<cgs::dyne>(100'000) == 1q_N);
static_assert(cgs::energy<cgs::erg>(10'000'000) == 1q_J);
static_assert(cgs::power<cgs::erg_per_second>(10'000'000) == 1q_W);
static_assert(cgs::pressure<cgs::barye>(10) == 1q_Pa);
static_assert(cgs::length<cgs::centimetre>(100) == 1_q_m);
static_assert(cgs::mass<cgs::gram>(1'000) == 1_q_kg);
static_assert(cgs::time<cgs::second>(1) == 1_q_s);
static_assert(cgs::speed<cgs::centimetre_per_second>(100) == 1_q_m_per_s);
static_assert(cgs::acceleration<cgs::gal>(100) == 1_q_m_per_s2);
static_assert(cgs::force<cgs::dyne>(100'000) == 1_q_N);
static_assert(cgs::energy<cgs::erg>(10'000'000) == 1_q_J);
static_assert(cgs::power<cgs::erg_per_second>(10'000'000) == 1_q_W);
static_assert(cgs::pressure<cgs::barye>(10) == 1_q_Pa);
}
@@ -77,15 +77,15 @@ namespace cgs_test {
using namespace units::physical::cgs::literals;
static_assert(100q_cm == si::length<si::metre>(1));
static_assert(1'000q_g == si::mass<si::kilogram>(1));
static_assert(1q_s == si::time<si::second>(1));
static_assert(100q_cm_per_s == si::speed<si::metre_per_second>(1));
static_assert(100q_Gal == si::acceleration<si::metre_per_second_sq>(1));
static_assert(100'000q_dyn == si::force<si::newton>(1));
static_assert(10'000'000q_erg == si::energy<si::joule>(1));
static_assert(10'000'000q_erg_per_s == si::power<si::watt>(1));
static_assert(10q_Ba == si::pressure<si::pascal>(1));
static_assert(100_q_cm == si::length<si::metre>(1));
static_assert(1'000_q_g == si::mass<si::kilogram>(1));
static_assert(1_q_s == si::time<si::second>(1));
static_assert(100_q_cm_per_s == si::speed<si::metre_per_second>(1));
static_assert(100_q_Gal == si::acceleration<si::metre_per_second_sq>(1));
static_assert(100'000_q_dyn == si::force<si::newton>(1));
static_assert(10'000'000_q_erg == si::energy<si::joule>(1));
static_assert(10'000'000_q_erg_per_s == si::power<si::watt>(1));
static_assert(10_q_Ba == si::pressure<si::pascal>(1));
}
@@ -94,15 +94,15 @@ namespace both_test {
using namespace units::physical::si::literals;
using namespace units::physical::cgs::literals;
// static_assert(100q_cm == 1q_m); // ambiguous
// static_assert(1'000q_g == 1q_kg); // ambiguous
static_assert(1q_s == 1q_s);
static_assert(100q_cm_per_s == 1q_m_per_s);
static_assert(100q_Gal == 1q_m_per_s2);
static_assert(100'000q_dyn == 1q_N);
static_assert(10'000'000q_erg == 1q_J);
static_assert(10'000'000q_erg_per_s == 1q_W);
static_assert(10q_Ba == quantity_cast<double>(1q_Pa));
// static_assert(100_q_cm == 1_q_m); // ambiguous
// static_assert(1'000_q_g == 1_q_kg); // ambiguous
static_assert(1_q_s == 1_q_s);
static_assert(100_q_cm_per_s == 1_q_m_per_s);
static_assert(100_q_Gal == 1_q_m_per_s2);
static_assert(100'000_q_dyn == 1_q_N);
static_assert(10'000'000_q_erg == 1_q_J);
static_assert(10'000'000_q_erg_per_s == 1_q_W);
static_assert(10_q_Ba == quantity_cast<double>(1_q_Pa));
}
@@ -110,41 +110,41 @@ namespace cgs_test {
// addition
// static_assert(100q_cm + si::length<si::metre>(1) == si::length<si::metre>(2)); // should not compile (different dimensions)
// static_assert(si::length<si::metre>(1) + 100q_cm == si::length<si::metre>(2)); // should not compile (different dimensions)
static_assert(quantity_cast<si::length<si::metre>>(100q_cm) + si::length<si::metre>(1) == si::length<si::metre>(2));
static_assert(si::length<si::metre>(1) + quantity_cast<si::length<si::metre>>(100q_cm) == si::length<si::metre>(2));
static_assert(100q_cm + quantity_cast<cgs::length<cgs::centimetre>>(si::length<si::metre>(1)) == 200q_cm);
static_assert(quantity_cast<cgs::length<cgs::centimetre>>(si::length<si::metre>(1)) + 100q_cm == 200q_cm);
// static_assert(100_q_cm + si::length<si::metre>(1) == si::length<si::metre>(2)); // should not compile (different dimensions)
// static_assert(si::length<si::metre>(1) + 100_q_cm == si::length<si::metre>(2)); // should not compile (different dimensions)
static_assert(quantity_cast<si::length<si::metre>>(100_q_cm) + si::length<si::metre>(1) == si::length<si::metre>(2));
static_assert(si::length<si::metre>(1) + quantity_cast<si::length<si::metre>>(100_q_cm) == si::length<si::metre>(2));
static_assert(100_q_cm + quantity_cast<cgs::length<cgs::centimetre>>(si::length<si::metre>(1)) == 200_q_cm);
static_assert(quantity_cast<cgs::length<cgs::centimetre>>(si::length<si::metre>(1)) + 100_q_cm == 200_q_cm);
// substraction
// static_assert(500q_cm - si::length<si::metre>(1) == si::length<si::metre>(4)); // should not compile (different dimensions)
// static_assert(si::length<si::metre>(5) - 100q_cm == si::length<si::metre>(4)); // should not compile (different dimensions)
static_assert(quantity_cast<si::length<si::metre>>(500q_cm) - si::length<si::metre>(1) == si::length<si::metre>(4));
static_assert(si::length<si::metre>(5) - quantity_cast<si::length<si::metre>>(100q_cm) == si::length<si::metre>(4));
static_assert(500q_cm - quantity_cast<cgs::length<cgs::centimetre>>(si::length<si::metre>(1)) == 400q_cm);
static_assert(quantity_cast<cgs::length<cgs::centimetre>>(si::length<si::metre>(5)) - 100q_cm == 400q_cm);
// static_assert(500_q_cm - si::length<si::metre>(1) == si::length<si::metre>(4)); // should not compile (different dimensions)
// static_assert(si::length<si::metre>(5) - 100_q_cm == si::length<si::metre>(4)); // should not compile (different dimensions)
static_assert(quantity_cast<si::length<si::metre>>(500_q_cm) - si::length<si::metre>(1) == si::length<si::metre>(4));
static_assert(si::length<si::metre>(5) - quantity_cast<si::length<si::metre>>(100_q_cm) == si::length<si::metre>(4));
static_assert(500_q_cm - quantity_cast<cgs::length<cgs::centimetre>>(si::length<si::metre>(1)) == 400_q_cm);
static_assert(quantity_cast<cgs::length<cgs::centimetre>>(si::length<si::metre>(5)) - 100_q_cm == 400_q_cm);
// multiplication
// static_assert(200q_cm * si::length<si::metre>(2) == si::area<si::square_metre>(4)); // should not compile (unknown dimension)
// static_assert(200_q_cm * si::length<si::metre>(2) == si::area<si::square_metre>(4)); // should not compile (unknown dimension)
static_assert(quantity_cast<si::dim_length>(200.q_cm) * si::length<si::metre>(2) == si::area<si::square_metre>(4));
static_assert(200.q_cm * quantity_cast<cgs::dim_length>(si::length<si::metre>(2)) == 40'000q_cm2);
static_assert(quantity_cast<si::dim_length>(200._q_cm) * si::length<si::metre>(2) == si::area<si::square_metre>(4));
static_assert(200._q_cm * quantity_cast<cgs::dim_length>(si::length<si::metre>(2)) == 40'000_q_cm2);
// TODO Add support for quantity_cast on an unknown_dimension?
// static_assert(quantity_cast<si::area<si::square_metre>>(200q_cm * si::length<si::metre>(2)) == si::area<si::square_metre>(4));
// static_assert(quantity_cast<si::dim_area>(200q_cm * si::length<si::metre>(2)) == si::area<si::square_metre>(4));
// static_assert(quantity_cast<cgs::area<cgs::square_centimeters>>(200q_cm * si::length<si::metre>(2)) == 40'000q_sq_cm);
// static_assert(quantity_cast<cgs::dim_area>(200q_cm * si::length<si::metre>(2)) == 40'000q_sq_cm);
// static_assert(quantity_cast<si::area<si::square_metre>>(200_q_cm * si::length<si::metre>(2)) == si::area<si::square_metre>(4));
// static_assert(quantity_cast<si::dim_area>(200_q_cm * si::length<si::metre>(2)) == si::area<si::square_metre>(4));
// static_assert(quantity_cast<cgs::area<cgs::square_centimeters>>(200_q_cm * si::length<si::metre>(2)) == 40'000_q_sq_cm);
// static_assert(quantity_cast<cgs::dim_area>(200_q_cm * si::length<si::metre>(2)) == 40'000_q_sq_cm);
// division
// static_assert(si::area<si::square_metre>(4) / 200q_cm == si::length<si::metre>(2)); // should not compile (unknown dimension)
// static_assert(si::area<si::square_metre>(4) / 200_q_cm == si::length<si::metre>(2)); // should not compile (unknown dimension)
static_assert(si::area<si::square_metre>(4) / quantity_cast<si::length<si::metre>>(200q_cm) == si::length<si::metre>(2));
static_assert(quantity_cast<cgs::area<cgs::square_centimetre>>(si::area<si::square_metre>(4)) / 200.q_cm == 200q_cm);
static_assert(si::area<si::square_metre>(4) / quantity_cast<si::length<si::metre>>(200_q_cm) == si::length<si::metre>(2));
static_assert(quantity_cast<cgs::area<cgs::square_centimetre>>(si::area<si::square_metre>(4)) / 200._q_cm == 200_q_cm);
}
test/unit_test/static/si_fps_test.cpp
+64 -64
View File
@@ -65,40 +65,40 @@ namespace si_literals {
using namespace units::physical::si::literals;
static_assert(fps::length<fps::foot>(1) == 0.3048q_m);
static_assert(fps::mass<fps::pound>(1) == 0.45359237q_kg);
static_assert(fps::time<fps::second>(1) == 1q_s);
static_assert(fps::speed<fps::foot_per_second>(1) == 0.3048q_m_per_s);
static_assert(fps::area<fps::square_foot>(1) == 0.09290304q_m2);
static_assert(fps::acceleration<fps::foot_per_second_sq>(1) == 0.3048q_m_per_s2);
static_assert(fps::force<fps::poundal>(1) > 0.138254q_N &&
fps::force<fps::poundal>(1) < 0.138256q_N);
static_assert(fps::energy<fps::foot_poundal>(1) > 0.042140110093804q_J &&
fps::energy<fps::foot_poundal>(1) < 0.042140110093806q_J);
static_assert(fps::power<fps::foot_poundal_per_second>(1) > 0.042140110093804q_W &&
fps::power<fps::foot_poundal_per_second>(1) < 0.042140110093806q_W);
static_assert(fps::pressure<fps::poundal_per_foot_sq>(1) > 1.4881639435q_Pa &&
fps::pressure<fps::poundal_per_foot_sq>(1) < 1.4881639437q_Pa);
static_assert(fps::length<fps::foot>(1) == 0.3048_q_m);
static_assert(fps::mass<fps::pound>(1) == 0.45359237_q_kg);
static_assert(fps::time<fps::second>(1) == 1_q_s);
static_assert(fps::speed<fps::foot_per_second>(1) == 0.3048_q_m_per_s);
static_assert(fps::area<fps::square_foot>(1) == 0.09290304_q_m2);
static_assert(fps::acceleration<fps::foot_per_second_sq>(1) == 0.3048_q_m_per_s2);
static_assert(fps::force<fps::poundal>(1) > 0.138254_q_N &&
fps::force<fps::poundal>(1) < 0.138256_q_N);
static_assert(fps::energy<fps::foot_poundal>(1) > 0.042140110093804_q_J &&
fps::energy<fps::foot_poundal>(1) < 0.042140110093806_q_J);
static_assert(fps::power<fps::foot_poundal_per_second>(1) > 0.042140110093804_q_W &&
fps::power<fps::foot_poundal_per_second>(1) < 0.042140110093806_q_W);
static_assert(fps::pressure<fps::poundal_per_foot_sq>(1) > 1.4881639435_q_Pa &&
fps::pressure<fps::poundal_per_foot_sq>(1) < 1.4881639437_q_Pa);
}
namespace fps_literals {
using namespace units::physical::fps::literals;
static_assert(1q_ft == si::length<si::metre>(0.3048));
static_assert(1q_lb == si::mass<si::kilogram>(0.45359237));
static_assert(1q_s == si::time<si::second>(1));
static_assert(1q_ft_per_s == si::speed<si::metre_per_second>(0.3048));
static_assert(1q_ft2 == si::area<si::square_metre>(0.09290304));
static_assert(1q_ft_per_s2 == si::acceleration<si::metre_per_second_sq>(0.3048));
static_assert(1q_pdl > si::force<si::newton>(0.138254) &&
1q_pdl < si::force<si::newton>(0.138256));
static_assert(1q_ft_pdl > si::energy<si::joule>(0.042140110093804) &&
1q_ft_pdl < si::energy<si::joule>(0.042140110093806));
static_assert(1q_ft_pdl_per_s > si::power<si::watt>(0.042140110093804) &&
1q_ft_pdl_per_s < si::power<si::watt>(0.042140110093806));
static_assert(1q_pdl_per_ft2> si::pressure<si::pascal>(1.4881639435) &&
1q_pdl_per_ft2 < si::pressure<si::pascal>(1.4881639437));
static_assert(1_q_ft == si::length<si::metre>(0.3048));
static_assert(1_q_lb == si::mass<si::kilogram>(0.45359237));
static_assert(1_q_s == si::time<si::second>(1));
static_assert(1_q_ft_per_s == si::speed<si::metre_per_second>(0.3048));
static_assert(1_q_ft2 == si::area<si::square_metre>(0.09290304));
static_assert(1_q_ft_per_s2 == si::acceleration<si::metre_per_second_sq>(0.3048));
static_assert(1_q_pdl > si::force<si::newton>(0.138254) &&
1_q_pdl < si::force<si::newton>(0.138256));
static_assert(1_q_ft_pdl > si::energy<si::joule>(0.042140110093804) &&
1_q_ft_pdl < si::energy<si::joule>(0.042140110093806));
static_assert(1_q_ft_pdl_per_s > si::power<si::watt>(0.042140110093804) &&
1_q_ft_pdl_per_s < si::power<si::watt>(0.042140110093806));
static_assert(1_q_pdl_per_ft2> si::pressure<si::pascal>(1.4881639435) &&
1_q_pdl_per_ft2 < si::pressure<si::pascal>(1.4881639437));
}
namespace fps_plus_si_literals {
@@ -106,22 +106,22 @@ namespace fps_plus_si_literals {
using namespace units::physical::si::literals;
using namespace units::physical::fps::literals;
// static_assert(100q_cm == 1q_m); // ambiguous
// static_assert(1'000q_g == 1q_kg); // ambiguous
static_assert(1q_ft == 0.3048q_m);
static_assert(1q_lb == 0.45359237q_kg);
static_assert(1q_s == 1q_s);
static_assert(1q_ft_per_s == 0.3048q_m_per_s);
static_assert(1q_ft2 == 0.09290304q_m2);
static_assert(1q_ft_per_s2 == 0.3048q_m_per_s2);
static_assert(1q_pdl > 0.138254q_N &&
1q_pdl < 0.138256q_N);
static_assert(1q_ft_pdl > 0.042140110093804q_J &&
1q_ft_pdl < 0.042140110093806q_J);
static_assert(1q_ft_pdl_per_s > 0.042140110093804q_W &&
1q_ft_pdl_per_s < 0.042140110093806q_W);
static_assert(1q_pdl_per_ft2> 1.4881639435q_Pa &&
1q_pdl_per_ft2 <1.4881639437q_Pa);
// static_assert(100_q_cm == 1_q_m); // ambiguous
// static_assert(1'000_q_g == 1_q_kg); // ambiguous
static_assert(1_q_ft == 0.3048_q_m);
static_assert(1_q_lb == 0.45359237_q_kg);
static_assert(1_q_s == 1_q_s);
static_assert(1_q_ft_per_s == 0.3048_q_m_per_s);
static_assert(1_q_ft2 == 0.09290304_q_m2);
static_assert(1_q_ft_per_s2 == 0.3048_q_m_per_s2);
static_assert(1_q_pdl > 0.138254_q_N &&
1_q_pdl < 0.138256_q_N);
static_assert(1_q_ft_pdl > 0.042140110093804_q_J &&
1_q_ft_pdl < 0.042140110093806_q_J);
static_assert(1_q_ft_pdl_per_s > 0.042140110093804_q_W &&
1_q_ft_pdl_per_s < 0.042140110093806_q_W);
static_assert(1_q_pdl_per_ft2> 1.4881639435_q_Pa &&
1_q_pdl_per_ft2 <1.4881639437_q_Pa);
}
@@ -131,35 +131,35 @@ using namespace units::physical::fps::literals;
// addition
// static_assert(si::length<si::metre>(1) + 1q_ft == si::length<si::metre>(1.3048)); // should not compile (different dimensions)
// static_assert(1q_ft / 0.3048 + si::length<si::metre>(1) == si::length<si::metre>(1.3048)); // should not compile (different dimensions)
static_assert(quantity_cast<si::length<si::metre>>(1.q_ft / 0.3048) + si::length<si::metre>(1) == si::length<si::metre>(2)); // 1 m in ft + 1 m
static_assert(si::length<si::metre>(1) + quantity_cast<si::length<si::metre>>(1.q_ft / 0.3048) == si::length<si::metre>(2)); // 1 m + 1 m in ft
static_assert(1q_ft + quantity_cast<fps::length<fps::foot>>(si::length<si::metre>(0.3048)) == 2q_ft); // 1 ft + 1 ft in m
static_assert(quantity_cast<fps::length<fps::foot>>(si::length<si::metre>(0.3048)) + 1q_ft == 2q_ft); // 1 ft in m + 1 ft
// static_assert(si::length<si::metre>(1) + 1_q_ft == si::length<si::metre>(1.3048)); // should not compile (different dimensions)
// static_assert(1_q_ft / 0.3048 + si::length<si::metre>(1) == si::length<si::metre>(1.3048)); // should not compile (different dimensions)
static_assert(quantity_cast<si::length<si::metre>>(1._q_ft / 0.3048) + si::length<si::metre>(1) == si::length<si::metre>(2)); // 1 m in ft + 1 m
static_assert(si::length<si::metre>(1) + quantity_cast<si::length<si::metre>>(1._q_ft / 0.3048) == si::length<si::metre>(2)); // 1 m + 1 m in ft
static_assert(1_q_ft + quantity_cast<fps::length<fps::foot>>(si::length<si::metre>(0.3048)) == 2_q_ft); // 1 ft + 1 ft in m
static_assert(quantity_cast<fps::length<fps::foot>>(si::length<si::metre>(0.3048)) + 1_q_ft == 2_q_ft); // 1 ft in m + 1 ft
// substraction
// static_assert(1q_ft - si::length<si::metre>(1) == -si::length<si::metre>(0.6952)); // should not compile (different dimensions)
// static_assert(si::length<si::metre>(1) - 1q_ft == si::length<si::metre>(0.6952)); // should not compile (different dimensions)
static_assert(quantity_cast<si::length<si::metre>>(6.q_ft) - si::length<si::metre>(1) > si::length<si::metre>(0.8287) &&
quantity_cast<si::length<si::metre>>(6.q_ft) - si::length<si::metre>(1) < si::length<si::metre>(0.8289)); // 6 ft in m - 1 m = ... m
static_assert(si::length<si::metre>(5) - quantity_cast<si::length<si::metre>>(6q_ft) == si::length<si::metre>(3.1712)); // 5 m - 6 ft in m = ...
static_assert(6.q_ft - quantity_cast<fps::length<fps::foot>>(si::length<si::metre>(0.3048)) == 5.q_ft); // 6 ft - 1 ft in m = 5 ft
static_assert(quantity_cast<fps::length<fps::foot>>(si::length<si::metre>(1.8288)) - 1.q_ft == 5.q_ft); // 6 ft in m - 1 ft = 5 ft
// static_assert(1_q_ft - si::length<si::metre>(1) == -si::length<si::metre>(0.6952)); // should not compile (different dimensions)
// static_assert(si::length<si::metre>(1) - 1_q_ft == si::length<si::metre>(0.6952)); // should not compile (different dimensions)
static_assert(quantity_cast<si::length<si::metre>>(6._q_ft) - si::length<si::metre>(1) > si::length<si::metre>(0.8287) &&
quantity_cast<si::length<si::metre>>(6._q_ft) - si::length<si::metre>(1) < si::length<si::metre>(0.8289)); // 6 ft in m - 1 m = ... m
static_assert(si::length<si::metre>(5) - quantity_cast<si::length<si::metre>>(6_q_ft) == si::length<si::metre>(3.1712)); // 5 m - 6 ft in m = ...
static_assert(6._q_ft - quantity_cast<fps::length<fps::foot>>(si::length<si::metre>(0.3048)) == 5._q_ft); // 6 ft - 1 ft in m = 5 ft
static_assert(quantity_cast<fps::length<fps::foot>>(si::length<si::metre>(1.8288)) - 1._q_ft == 5._q_ft); // 6 ft in m - 1 ft = 5 ft
// multiplication
// static_assert(2q_ft * si::length<si::metre>(2) == si::area<si::square_metre>(1.2192)); // should not compile (unknown dimension)
// static_assert(quantity_cast<si::length<si::metre>>(2.q_ft) * si::length<si::metre>(2) == si::area<si::square_metre>(1.2192));
static_assert(quantity_cast<si::length<si::metre>>(2.q_ft) * si::length<si::metre>(0.6096) == si::area<si::square_metre>(0.371612160)); // 2 ft * 2 ft == 4 sq ft
static_assert(2.q_ft * quantity_cast<fps::length<fps::foot>>(si::length<si::metre>(0.6096)) == 4.q_ft2);
// static_assert(2_q_ft * si::length<si::metre>(2) == si::area<si::square_metre>(1.2192)); // should not compile (unknown dimension)
// static_assert(quantity_cast<si::length<si::metre>>(2._q_ft) * si::length<si::metre>(2) == si::area<si::square_metre>(1.2192));
static_assert(quantity_cast<si::length<si::metre>>(2._q_ft) * si::length<si::metre>(0.6096) == si::area<si::square_metre>(0.371612160)); // 2 ft * 2 ft == 4 sq ft
static_assert(2._q_ft * quantity_cast<fps::length<fps::foot>>(si::length<si::metre>(0.6096)) == 4._q_ft2);
// division
// static_assert(si::area<si::square_metre>(4) / 200q_cm == si::length<si::metre>(2)); // should not compile (unknown dimension)
static_assert(si::area<si::square_metre>(1.48644864) / quantity_cast<si::length<si::metre>>(4q_ft) == si::length<si::metre>(1.2192)); // 16 ft2 / 4 ft = 4 ft
static_assert(quantity_cast<fps::area<fps::square_foot>>(si::area<si::square_metre>(1.48644864)) / 4.q_ft == 4.q_ft); // 16 ft2 / 4 ft = 4 ft
// static_assert(si::area<si::square_metre>(4) / 200_q_cm == si::length<si::metre>(2)); // should not compile (unknown dimension)
static_assert(si::area<si::square_metre>(1.48644864) / quantity_cast<si::length<si::metre>>(4_q_ft) == si::length<si::metre>(1.2192)); // 16 ft2 / 4 ft = 4 ft
static_assert(quantity_cast<fps::area<fps::square_foot>>(si::area<si::square_metre>(1.48644864)) / 4._q_ft == 4._q_ft); // 16 ft2 / 4 ft = 4 ft
}
test/unit_test/static/si_test.cpp
+145 -145
View File
@@ -32,18 +32,18 @@ using namespace units::physical::si;
// length
static_assert(1q_km == 1000q_m);
static_assert(1q_m == 100q_cm);
static_assert(1q_m == 10q_dm);
static_assert(1q_m == 1000q_mm);
static_assert(1q_hm == 100q_m);
static_assert(1q_au == 149'597'870'700q_m);
static_assert(1q_km + 1q_m == 1001q_m);
static_assert(10q_km / 5q_km == 2);
static_assert(10q_km / 5q_km < 3);
static_assert(100q_mm / 5q_cm == dimensionless<scaled_unit<ratio(1, 1, -1), one>>(20));
static_assert(100q_mm / 5q_cm == dimensionless<one>(2));
static_assert(10q_km / 2 == 5q_km);
static_assert(1_q_km == 1000_q_m);
static_assert(1_q_m == 100_q_cm);
static_assert(1_q_m == 10_q_dm);
static_assert(1_q_m == 1000_q_mm);
static_assert(1_q_hm == 100_q_m);
static_assert(1_q_au == 149'597'870'700_q_m);
static_assert(1_q_km + 1_q_m == 1001_q_m);
static_assert(10_q_km / 5_q_km == 2);
static_assert(10_q_km / 5_q_km < 3);
static_assert(100_q_mm / 5_q_cm == dimensionless<scaled_unit<ratio(1, 1, -1), one>>(20));
static_assert(100_q_mm / 5_q_cm == dimensionless<one>(2));
static_assert(10_q_km / 2 == 5_q_km);
static_assert(millimetre::symbol == "mm");
static_assert(centimetre::symbol == "cm");
@@ -52,9 +52,9 @@ static_assert(kilometre::symbol == "km");
// mass
static_assert(1q_kg == 1000q_g);
static_assert(1q_t == 1000q_kg);
static_assert(1q_kt == 1000000q_kg);
static_assert(1_q_kg == 1000_q_g);
static_assert(1_q_t == 1000_q_kg);
static_assert(1_q_kt == 1000000_q_kg);
static_assert(kilogram::symbol == "kg");
static_assert(tonne::symbol == "t");
@@ -62,14 +62,14 @@ static_assert(kilotonne::symbol == "kt");
// time
static_assert(1q_us == 1000q_ns);
static_assert(1q_ms == 1000q_us);
static_assert(1q_s == 1000q_ms);
static_assert(1q_min == 60q_s);
static_assert(1q_h == 60q_min);
static_assert(1q_h == 3600q_s);
static_assert(1q_d == 24q_h);
static_assert(1q_d == 86'400q_s);
static_assert(1_q_us == 1000_q_ns);
static_assert(1_q_ms == 1000_q_us);
static_assert(1_q_s == 1000_q_ms);
static_assert(1_q_min == 60_q_s);
static_assert(1_q_h == 60_q_min);
static_assert(1_q_h == 3600_q_s);
static_assert(1_q_d == 24_q_h);
static_assert(1_q_d == 86'400_q_s);
static_assert(nanosecond::symbol == "ns");
static_assert(microsecond::symbol == basic_symbol_text("µs", "us"));
@@ -87,11 +87,11 @@ static_assert(millisecond::symbol == "ms");
// frequency
static_assert(1000q_mHz == 1q_Hz);
static_assert(1000q_Hz == 1q_kHz);
static_assert(1000q_kHz == 1q_MHz);
static_assert(1000q_MHz == 1q_GHz);
static_assert(1000q_GHz == 1q_THz);
static_assert(1000_q_mHz == 1_q_Hz);
static_assert(1000_q_Hz == 1_q_kHz);
static_assert(1000_q_kHz == 1_q_MHz);
static_assert(1000_q_MHz == 1_q_GHz);
static_assert(1000_q_GHz == 1_q_THz);
static_assert(millihertz::symbol == "mHz");
static_assert(kilohertz::symbol == "kHz");
@@ -99,89 +99,89 @@ static_assert(megahertz::symbol == "MHz");
static_assert(gigahertz::symbol == "GHz");
static_assert(terahertz::symbol == "THz");
static_assert(2 / 1q_s == 2q_Hz);
static_assert(120 / 1q_min == 2q_Hz);
static_assert(1000 / 1q_s == 1q_kHz);
static_assert(1 / 1q_ms == 1q_kHz);
static_assert(3.2q_GHz == 3'200'000'000q_Hz);
static_assert((10q_Hz * 1q_min).count() == 10);
static_assert(10q_Hz * 1q_min == dimensionless<scaled_unit<ratio(60), one>>(10));
static_assert(10q_Hz * 1q_min == dimensionless<one>(600));
static_assert(2 / 1q_Hz == 2q_s);
static_assert(2 / 1_q_s == 2_q_Hz);
static_assert(120 / 1_q_min == 2_q_Hz);
static_assert(1000 / 1_q_s == 1_q_kHz);
static_assert(1 / 1_q_ms == 1_q_kHz);
static_assert(3.2_q_GHz == 3'200'000'000_q_Hz);
static_assert((10_q_Hz * 1_q_min).count() == 10);
static_assert(10_q_Hz * 1_q_min == dimensionless<scaled_unit<ratio(60), one>>(10));
static_assert(10_q_Hz * 1_q_min == dimensionless<one>(600));
static_assert(2 / 1_q_Hz == 2_q_s);
// force
static_assert(10q_kg * 10q_m_per_s2 == 100q_N);
static_assert(100q_N / 1q_m_per_s2 == 100q_kg);
static_assert(100q_N / 1q_kg == 100q_m_per_s2);
static_assert(10_q_kg * 10_q_m_per_s2 == 100_q_N);
static_assert(100_q_N / 1_q_m_per_s2 == 100_q_kg);
static_assert(100_q_N / 1_q_kg == 100_q_m_per_s2);
// pressure
static_assert(10q_N / 10q_m2 == 1q_Pa);
static_assert(10q_N / 1q_Pa == 10q_m2);
static_assert(1q_Pa * 10q_m2 == 10q_N);
static_assert(10_q_N / 10_q_m2 == 1_q_Pa);
static_assert(10_q_N / 1_q_Pa == 10_q_m2);
static_assert(1_q_Pa * 10_q_m2 == 10_q_N);
// energy
static_assert(1000q_mJ == 1q_J);
static_assert(1000q_J == 1q_kJ);
static_assert(1000q_kJ == 1q_MJ);
static_assert(1000q_MJ == 1q_GJ);
static_assert(1000_q_mJ == 1_q_J);
static_assert(1000_q_J == 1_q_kJ);
static_assert(1000_q_kJ == 1_q_MJ);
static_assert(1000_q_MJ == 1_q_GJ);
static_assert(millijoule::symbol == "mJ");
static_assert(kilojoule::symbol == "kJ");
static_assert(megajoule::symbol == "MJ");
static_assert(gigajoule::symbol == "GJ");
static_assert(10q_N * 10q_m == 100q_J);
static_assert(100q_J / 10q_m == 10q_N);
static_assert(100q_J / 10q_N == 10q_m);
static_assert(10q_Pa * 10q_m3 == 100q_J);
static_assert(100q_J / 10q_Pa == 10q_m3);
static_assert(100q_J / 10q_m3 == 10q_Pa);
static_assert(10_q_N * 10_q_m == 100_q_J);
static_assert(100_q_J / 10_q_m == 10_q_N);
static_assert(100_q_J / 10_q_N == 10_q_m);
static_assert(10_q_Pa * 10_q_m3 == 100_q_J);
static_assert(100_q_J / 10_q_Pa == 10_q_m3);
static_assert(100_q_J / 10_q_m3 == 10_q_Pa);
// power
static_assert(1000q_mW == 1q_W);
static_assert(1000q_W == 1q_kW);
static_assert(1000q_kW == 1q_MW);
static_assert(1000q_MW == 1q_GW);
static_assert(1000_q_mW == 1_q_W);
static_assert(1000_q_W == 1_q_kW);
static_assert(1000_q_kW == 1_q_MW);
static_assert(1000_q_MW == 1_q_GW);
static_assert(milliwatt::symbol == "mW");
static_assert(kilowatt::symbol == "kW");
static_assert(megawatt::symbol == "MW");
static_assert(gigawatt::symbol == "GW");
static_assert(10q_J / 10q_s == 1q_W);
static_assert(1q_W * 10q_s == 10q_J);
static_assert(10q_J / 1q_W == 10q_s);
static_assert(10_q_J / 10_q_s == 1_q_W);
static_assert(1_q_W * 10_q_s == 10_q_J);
static_assert(10_q_J / 1_q_W == 10_q_s);
// electric charge
static_assert(10q_A * 10q_s == 100q_C);
static_assert(100q_C / 10q_A == 10q_s);
static_assert(100q_C / 10q_s == 10q_A);
static_assert(10_q_A * 10_q_s == 100_q_C);
static_assert(100_q_C / 10_q_A == 10_q_s);
static_assert(100_q_C / 10_q_s == 10_q_A);
// voltage
static_assert(10q_W / 10q_A == 1q_V);
static_assert(10q_W / 1q_V == 10q_A);
static_assert(1q_V * 10q_A == 10q_W);
static_assert(10q_J / 10q_C == 1q_V);
static_assert(10q_J / 1q_V == 10q_C);
static_assert(10q_C * 1q_V == 10q_J);
static_assert(10_q_W / 10_q_A == 1_q_V);
static_assert(10_q_W / 1_q_V == 10_q_A);
static_assert(1_q_V * 10_q_A == 10_q_W);
static_assert(10_q_J / 10_q_C == 1_q_V);
static_assert(10_q_J / 1_q_V == 10_q_C);
static_assert(10_q_C * 1_q_V == 10_q_J);
// capacitance
static_assert(10q_C / 10q_V == 1q_F);
static_assert(10q_C / 1q_F == 10q_V);
static_assert(10q_V * 1q_F == 10q_C);
static_assert(10_q_C / 10_q_V == 1_q_F);
static_assert(10_q_C / 1_q_F == 10_q_V);
static_assert(10_q_V * 1_q_F == 10_q_C);
// magnetic induction
static_assert(1q_T == 1q_V * 1q_s / (1q_m * 1q_m));
static_assert(10q_T / 1q_s == 10q_V / (1q_m * 1q_m));
static_assert(10q_T * (1q_m * 1q_m) == 10q_s * 1q_V);
static_assert(10q_N / (1q_A * 1q_m) == 10q_T);
static_assert(1_q_T == 1_q_V * 1_q_s / (1_q_m * 1_q_m));
static_assert(10_q_T / 1_q_s == 10_q_V / (1_q_m * 1_q_m));
static_assert(10_q_T * (1_q_m * 1_q_m) == 10_q_s * 1_q_V);
static_assert(10_q_N / (1_q_A * 1_q_m) == 10_q_T);
static_assert(millitesla::symbol == "mT");
static_assert(microtesla::symbol == basic_symbol_text("µT", "uT"));
@@ -190,9 +190,9 @@ static_assert(picotesla::symbol == "pT");
// magnetic flux
static_assert(1q_Wb == 1q_T * 1q_m2);
static_assert(1q_J == 1q_Wb * 1q_A);
static_assert(1q_N * 1q_s == 1q_Wb * 1q_C / 1q_m);
static_assert(1_q_Wb == 1_q_T * 1_q_m2);
static_assert(1_q_J == 1_q_Wb * 1_q_A);
static_assert(1_q_N * 1_q_s == 1_q_Wb * 1_q_C / 1_q_m);
static_assert(milliweber::symbol == "mWb");
static_assert(microweber::symbol == basic_symbol_text("µWb", "uWb"));
@@ -201,9 +201,9 @@ static_assert(picoweber::symbol == "pWb");
// inductance
static_assert(1q_H == 1q_Wb / 1q_A);
static_assert(1q_V == 1q_H * 1q_A / 1q_s);
static_assert(1q_J == 1q_H * 1q_A * 1q_A);
static_assert(1_q_H == 1_q_Wb / 1_q_A);
static_assert(1_q_V == 1_q_H * 1_q_A / 1_q_s);
static_assert(1_q_J == 1_q_H * 1_q_A * 1_q_A);
static_assert(millihenry::symbol == "mH");
static_assert(microhenry::symbol == basic_symbol_text("µH", "uH"));
@@ -212,9 +212,9 @@ static_assert(picohenry::symbol == "pH");
// conductance
static_assert(1q_S * 1q_R == 1);
static_assert(1q_S == 1q_A / 1q_V);
static_assert(1q_W == 1q_A * 1q_A / 1q_S);
static_assert(1_q_S * 1_q_R == 1);
static_assert(1_q_S == 1_q_A / 1_q_V);
static_assert(1_q_W == 1_q_A * 1_q_A / 1_q_S);
static_assert(millisiemens::symbol == "mS");
static_assert(microsiemens::symbol == basic_symbol_text("µS", "uS"));
@@ -222,16 +222,16 @@ static_assert(nanosiemens::symbol == "nS");
// catalytic activity
static_assert(1q_kat == 1q_mol / 1q_s);
static_assert(1'000'000q_U == 1q_mol / 1q_min);
static_assert(1_q_kat == 1_q_mol / 1_q_s);
static_assert(1'000'000_q_U == 1_q_mol / 1_q_min);
static_assert(katal::symbol == "kat");
static_assert(enzyme_unit::symbol == "U");
// absorbed dose
static_assert(1q_Gy == 1q_J / 1q_kg);
static_assert(9.q_W * 3q_s / 60q_kg == 450q_mGy);
static_assert(1_q_Gy == 1_q_J / 1_q_kg);
static_assert(9._q_W * 3_q_s / 60_q_kg == 450_q_mGy);
static_assert(gray::symbol == "Gy");
static_assert(milligray::symbol == "mGy");
@@ -241,42 +241,42 @@ static_assert(kilogray::symbol == "kGy");
// speed
static_assert(is_same_v<decltype(1q_km / 1q_s), speed<scaled_unit<ratio(1, 1, 3), metre_per_second>, std::int64_t>>);
static_assert(is_same_v<decltype(1_q_km / 1_q_s), speed<scaled_unit<ratio(1, 1, 3), metre_per_second>, std::int64_t>>);
static_assert(10q_m / 5q_s == 2q_m_per_s);
static_assert(10 / 5q_s * 1q_m == 2q_m_per_s);
static_assert(1q_km / 1q_s == 1000q_m_per_s);
// static_assert(1q_km / 1q_h == 1q_km_per_h); // should not compile
static_assert(1.0q_km / 1q_h == 1q_km_per_h);
static_assert(1000.0q_m / 3600.0q_s == 1q_km_per_h);
static_assert(10_q_m / 5_q_s == 2_q_m_per_s);
static_assert(10 / 5_q_s * 1_q_m == 2_q_m_per_s);
static_assert(1_q_km / 1_q_s == 1000_q_m_per_s);
// static_assert(1_q_km / 1_q_h == 1_q_km_per_h); // should not compile
static_assert(1.0_q_km / 1_q_h == 1_q_km_per_h);
static_assert(1000.0_q_m / 3600.0_q_s == 1_q_km_per_h);
static_assert(2q_km_per_h * 2q_h == 4q_km);
// static_assert(2q_km_per_h * 15q_min == 500q_m); // should not compile
static_assert(2q_km_per_h * 15.0q_min == 500q_m);
static_assert(2.0q_km_per_h * 15q_min == 500q_m);
static_assert(2_q_km_per_h * 2_q_h == 4_q_km);
// static_assert(2_q_km_per_h * 15_q_min == 500_q_m); // should not compile
static_assert(2_q_km_per_h * 15.0_q_min == 500_q_m);
static_assert(2.0_q_km_per_h * 15_q_min == 500_q_m);
static_assert(2q_km / 2q_km_per_h == 1q_h);
// static_assert(2000q_m / 2q_km_per_h == 1q_h); // should not compile
static_assert(quantity_cast<kilometre>(2000q_m) / 2q_km_per_h == 1q_h);
static_assert(2_q_km / 2_q_km_per_h == 1_q_h);
// static_assert(2000_q_m / 2_q_km_per_h == 1_q_h); // should not compile
static_assert(quantity_cast<kilometre>(2000_q_m) / 2_q_km_per_h == 1_q_h);
static_assert(detail::unit_text<dim_speed, metre_per_second>() == "m/s");
static_assert(kilometre_per_hour::symbol == "km/h");
// acceleration
static_assert(10q_m_per_s / 10q_s == 1q_m_per_s2);
static_assert(10q_m_per_s / 1q_m_per_s2 == 10q_s);
static_assert(1q_m_per_s2 * 10q_s == 10q_m_per_s);
static_assert(10_q_m_per_s / 10_q_s == 1_q_m_per_s2);
static_assert(10_q_m_per_s / 1_q_m_per_s2 == 10_q_s);
static_assert(1_q_m_per_s2 * 10_q_s == 10_q_m_per_s);
static_assert(detail::unit_text<dim_acceleration, metre_per_second_sq>() == basic_symbol_text("m/s²", "m/s^2"));
// area
static_assert(10q_m * 10q_m == 100q_m2);
static_assert(100q_m2 / 10q_m == 10q_m);
static_assert(10q_km * 10q_km == 100q_km2);
static_assert(1q_m2 == 10'000q_cm2);
static_assert(1q_ha == 10'000q_m2);
static_assert(10_q_m * 10_q_m == 100_q_m2);
static_assert(100_q_m2 / 10_q_m == 10_q_m);
static_assert(10_q_km * 10_q_km == 100_q_km2);
static_assert(1_q_m2 == 10'000_q_cm2);
static_assert(1_q_ha == 10'000_q_m2);
static_assert(hectare::symbol == "ha");
@@ -284,13 +284,13 @@ static_assert(detail::unit_text<dim_area, square_metre>() == basic_symbol_text("
// volume
static_assert(1q_m * 1q_m * 1q_m == 1q_m3);
static_assert(10q_m2 * 10q_m == 100q_m3);
static_assert(10q_km * 10q_km * 10q_km == 1000q_km3);
static_assert(1q_m3 == 1'000'000q_cm3);
static_assert(1q_dm * 1q_dm * 1q_dm == 1q_l);
static_assert(1000q_l == 1q_m3);
static_assert(1q_kl == 1q_m3);
static_assert(1_q_m * 1_q_m * 1_q_m == 1_q_m3);
static_assert(10_q_m2 * 10_q_m == 100_q_m3);
static_assert(10_q_km * 10_q_km * 10_q_km == 1000_q_km3);
static_assert(1_q_m3 == 1'000'000_q_cm3);
static_assert(1_q_dm * 1_q_dm * 1_q_dm == 1_q_l);
static_assert(1000_q_l == 1_q_m3);
static_assert(1_q_kl == 1_q_m3);
static_assert(litre::symbol == "l");
static_assert(kilolitre::symbol == "kl");
@@ -299,89 +299,89 @@ static_assert(detail::unit_text<dim_volume, cubic_metre>() == basic_symbol_text(
/* ************** DERIVED DIMENSIONS IN TERMS OF OTHER UNITS **************** */
static_assert(10q_N / 2q_m == 5q_N_per_m);
static_assert(10q_N / 5q_N_per_m == 2q_m);
static_assert(2q_m * 5q_N_per_m == 10q_N);
static_assert(10_q_N / 2_q_m == 5_q_N_per_m);
static_assert(10_q_N / 5_q_N_per_m == 2_q_m);
static_assert(2_q_m * 5_q_N_per_m == 10_q_N);
static_assert(detail::unit_text<dim_surface_tension, newton_per_metre>() == "N/m");
// current density
static_assert(12q_A_per_m2 == 60q_A / 5q_m2);
static_assert(1q_A_per_m2 == 1q_S * 1q_V / 1q_m2);
static_assert(12_q_A_per_m2 == 60_q_A / 5_q_m2);
static_assert(1_q_A_per_m2 == 1_q_S * 1_q_V / 1_q_m2);
static_assert(detail::unit_text<dim_current_density, ampere_per_metre_sq>() == basic_symbol_text("A/m²", "A/m^2"));
// concentration
static_assert(1q_mol_per_m3 == 1q_kg_per_m3 * 1q_mol / 1q_kg);
static_assert(1_q_mol_per_m3 == 1_q_kg_per_m3 * 1_q_mol / 1_q_kg);
static_assert(detail::unit_text<dim_concentration, ampere_per_metre_sq>() == basic_symbol_text("mol/m³", "mol/m^3"));
// luminance
static_assert(1q_cd_per_m2 == 1q_cd / 1q_m2);
static_assert(1_q_cd_per_m2 == 1_q_cd / 1_q_m2);
static_assert(detail::unit_text<dim_luminance, candela_per_metre_sq>() == basic_symbol_text("cd/m²", "cd/m^2"));
// dynamic viscosity
static_assert(1q_Pa_s == 1q_N * 1q_s / 1q_m2);
static_assert(1_q_Pa_s == 1_q_N * 1_q_s / 1_q_m2);
static_assert(detail::unit_text<dim_dynamic_viscosity, pascal_second>() == basic_symbol_text("Pa ⋅ s", "Pa s"));
// [specific|molar] heath capacity
static_assert(1q_J_per_K == 1q_J_per_kg_K * 1q_kg);
static_assert(1q_J_per_K * 1q_K == 1q_s * 1q_N * 1q_m_per_s);
static_assert(1q_J_per_mol_K == 1q_J_per_K / 1q_mol);
static_assert(1_q_J_per_K == 1_q_J_per_kg_K * 1_q_kg);
static_assert(1_q_J_per_K * 1_q_K == 1_q_s * 1_q_N * 1_q_m_per_s);
static_assert(1_q_J_per_mol_K == 1_q_J_per_K / 1_q_mol);
static_assert(detail::unit_text<dim_heat_capacity, joule_per_kelvin>() == "J/K");
static_assert(detail::unit_text<dim_specific_heat_capacity, joule_per_kilogram_kelvin>() == basic_symbol_text("J ⋅ K⁻¹ ⋅ kg⁻¹", "J K^-1 kg^-1"));
// thermal conductivity
static_assert(20q_W_per_m_K * 10q_m * 300q_K == 60'000q_W);
static_assert(20_q_W_per_m_K * 10_q_m * 300_q_K == 60'000_q_W);
static_assert(detail::unit_text<dim_thermal_conductivity, watt_per_metre_kelvin>() == basic_symbol_text("W ⋅ m⁻¹ ⋅ K⁻¹", "W m^-1 K^-1"));
// electric field strength
static_assert(100q_N/20q_C == 5q_V_per_m);
static_assert(1q_C * 10q_V_per_m * 3q_m == 30q_J);
static_assert(100_q_N/20_q_C == 5_q_V_per_m);
static_assert(1_q_C * 10_q_V_per_m * 3_q_m == 30_q_J);
static_assert(detail::unit_text<dim_electric_field_strength, volt_per_metre>() == "V/m");
// [surface] charge density
static_assert(20.q_C / 40q_m3 == 0.5q_C_per_m3);
static_assert(10.q_C / 20q_m2 == 0.5q_C_per_m2);
static_assert(20.q_C_per_m3 == 10.q_C_per_m2 / 0.5q_m);
static_assert(1q_C / 1q_m / 1q_m == 1q_C / 1q_m2);
static_assert(1q_C_per_m2 == 1q_C_per_m3 * 1q_m);
static_assert(1q_V_per_m * 10q_C_per_m3 * 1q_m3 == 10q_N);
static_assert(20._q_C / 40_q_m3 == 0.5_q_C_per_m3);
static_assert(10._q_C / 20_q_m2 == 0.5_q_C_per_m2);
static_assert(20._q_C_per_m3 == 10._q_C_per_m2 / 0.5_q_m);
static_assert(1_q_C / 1_q_m / 1_q_m == 1_q_C / 1_q_m2);
static_assert(1_q_C_per_m2 == 1_q_C_per_m3 * 1_q_m);
static_assert(1_q_V_per_m * 10_q_C_per_m3 * 1_q_m3 == 10_q_N);
static_assert(detail::unit_text<dim_charge_density, coulomb_per_metre_cub>() == basic_symbol_text("C/m³", "C/m^3"));
static_assert(detail::unit_text<dim_surface_charge_density, coulomb_per_metre_sq>() == basic_symbol_text("C/m²", "C/m^2"));
// permittivity
static_assert(1q_F_per_m == 1q_F / 1q_m);
static_assert(1/(1q_F_per_m) * 1q_C * 1q_C / 1q_m2 == 1q_N);
static_assert(1q_C_per_m3 / 1q_F_per_m * 1q_m == 1q_V_per_m);
static_assert(1_q_F_per_m == 1_q_F / 1_q_m);
static_assert(1/(1_q_F_per_m) * 1_q_C * 1_q_C / 1_q_m2 == 1_q_N);
static_assert(1_q_C_per_m3 / 1_q_F_per_m * 1_q_m == 1_q_V_per_m);
static_assert(detail::unit_text<dim_permittivity, farad_per_metre>() == "F/m");
// permeability
static_assert(1q_H_per_m * 1q_A / 1q_m == 1q_T);
static_assert(1q_H_per_m * 1q_A * 1q_A == 1q_N);
static_assert(1_q_H_per_m * 1_q_A / 1_q_m == 1_q_T);
static_assert(1_q_H_per_m * 1_q_A * 1_q_A == 1_q_N);
static_assert(detail::unit_text<dim_permeability, henry_per_metre>() == "H/m");
// molar energy
static_assert(1q_J_per_mol * 1q_mol_per_m3 * 1q_m3 == 1q_N * 1q_m);
static_assert(1_q_J_per_mol * 1_q_mol_per_m3 * 1_q_m3 == 1_q_N * 1_q_m);
static_assert(detail::unit_text<dim_molar_energy, joule_per_mole>() == "J/mol");
// angular velocity
static_assert(1q_rad / 1q_s == 1q_rad_per_s);
static_assert(1_q_rad / 1_q_s == 1_q_rad_per_s);
static_assert(detail::unit_text<dim_angular_velocity, radian_per_second>() == basic_symbol_text("ω", "w"));
} // namespace
test/unit_test/static/us_test.cpp
+6 -6
View File
@@ -42,19 +42,19 @@ using namespace units::physical::international;
// length
static_assert(1q_yd == 0.9144q_m);
static_assert(1q_yd == 3q_ft);
static_assert(1q_ft == 12q_in);
static_assert(1q_mi == 1760q_yd);
static_assert(1_q_yd == 0.9144_q_m);
static_assert(1_q_yd == 3_q_ft);
static_assert(1_q_ft == 12_q_in);
static_assert(1_q_mi == 1760_q_yd);
static_assert(5q_in + 8q_cm == 207q_mm);
static_assert(5_q_in + 8_q_cm == 207_q_mm);
/* ************** DERIVED DIMENSIONS IN TERMS OF BASE UNITS **************** */
// speed
static_assert(10.0q_mi / 2q_h == 5q_mi_per_h);
static_assert(10.0_q_mi / 2_q_h == 5_q_mi_per_h);
static_assert(mile_per_hour::symbol == "mi/h");