diff --git a/src/blackmisc/pq/literals.cpp b/src/blackmisc/pq/literals.cpp new file mode 100644 index 000000000..6fdb4733a --- /dev/null +++ b/src/blackmisc/pq/literals.cpp @@ -0,0 +1,468 @@ +/* Copyright (C) 2020 + * swift project Community / Contributors + * + * This file is part of swift project. It is subject to the license terms in the LICENSE file found in the top-level + * directory of this distribution. No part of swift project, including this file, may be copied, modified, propagated, + * or distributed except according to the terms contained in the LICENSE file. + */ + +#include "blackmisc/pq/literals.h" +#include "blackmisc/pq/acceleration.h" +#include "blackmisc/pq/angle.h" +#include "blackmisc/pq/frequency.h" +#include "blackmisc/pq/length.h" +#include "blackmisc/pq/mass.h" +#include "blackmisc/pq/pressure.h" +#include "blackmisc/pq/speed.h" +#include "blackmisc/pq/temperature.h" +#include "blackmisc/pq/time.h" +#include "blackmisc/pq/units.h" + +namespace BlackMisc +{ + namespace PhysicalQuantities + { + namespace Literals + { + CAcceleration operator ""_ft_s2(long double value) + { + return {static_cast(value), CAccelerationUnit::ft_s2()}; + } + + CAcceleration operator ""_ft_s2(unsigned long long value) + { + return {static_cast(value), CAccelerationUnit::ft_s2()}; + } + + CAcceleration operator ""_m_s2(long double value) + { + return {static_cast(value), CAccelerationUnit::m_s2()}; + } + + CAcceleration operator ""_m_s2(unsigned long long value) + { + return {static_cast(value), CAccelerationUnit::m_s2()}; + } + + CAngle operator ""_deg(long double value) + { + return {static_cast(value), CAngleUnit::deg()}; + } + + CAngle operator ""_deg(unsigned long long value) + { + return {static_cast(value), CAngleUnit::deg()}; + } + + CAngle operator ""_rad(long double value) + { + return {static_cast(value), CAngleUnit::rad()}; + } + + CAngle operator ""_rad(unsigned long long value) + { + return {static_cast(value), CAngleUnit::rad()}; + } + + CFrequency operator ""_Hz(long double value) + { + return {static_cast(value), CFrequencyUnit::Hz()}; + } + + CFrequency operator ""_Hz(unsigned long long value) + { + return {static_cast(value), CFrequencyUnit::Hz()}; + } + + CFrequency operator ""_kHz(long double value) + { + return {static_cast(value), CFrequencyUnit::kHz()}; + } + + CFrequency operator ""_kHz(unsigned long long value) + { + return {static_cast(value), CFrequencyUnit::kHz()}; + } + + CFrequency operator ""_MHz(long double value) + { + return {static_cast(value), CFrequencyUnit::MHz()}; + } + + CFrequency operator ""_MHz(unsigned long long value) + { + return {static_cast(value), CFrequencyUnit::MHz()}; + } + + CFrequency operator ""_GHz(long double value) + { + return {static_cast(value), CFrequencyUnit::GHz()}; + } + + CFrequency operator ""_GHz(unsigned long long value) + { + return {static_cast(value), CFrequencyUnit::GHz()}; + } + + CLength operator ""_m(long double value) + { + return {static_cast(value), CLengthUnit::m()}; + } + + CLength operator ""_m(unsigned long long value) + { + return {static_cast(value), CLengthUnit::m()}; + } + + CLength operator ""_NM(long double value) + { + return {static_cast(value), CLengthUnit::NM()}; + } + + CLength operator ""_NM(unsigned long long value) + { + return {static_cast(value), CLengthUnit::NM()}; + } + + CLength operator ""_SM(long double value) + { + return {static_cast(value), CLengthUnit::SM()}; + } + + CLength operator ""_SM(unsigned long long value) + { + return {static_cast(value), CLengthUnit::SM()}; + } + + CLength operator ""_cm(long double value) + { + return {static_cast(value), CLengthUnit::cm()}; + } + + CLength operator ""_cm(unsigned long long value) + { + return {static_cast(value), CLengthUnit::cm()}; + } + + CLength operator ""_ft(long double value) + { + return {static_cast(value), CLengthUnit::ft()}; + } + + CLength operator ""_ft(unsigned long long value) + { + return {static_cast(value), CLengthUnit::ft()}; + } + + CLength operator ""_km(long double value) + { + return {static_cast(value), CLengthUnit::km()}; + } + + CLength operator ""_km(unsigned long long value) + { + return {static_cast(value), CLengthUnit::km()}; + } + + CLength operator ""_mi(long double value) + { + return {static_cast(value), CLengthUnit::mi()}; + } + + CLength operator ""_mi(unsigned long long value) + { + return {static_cast(value), CLengthUnit::mi()}; + } + + CMass operator ""_g(long double value) + { + return {static_cast(value), CMassUnit::g()}; + } + + CMass operator ""_g(unsigned long long value) + { + return {static_cast(value), CMassUnit::g()}; + } + + CMass operator ""_kg(long double value) + { + return {static_cast(value), CMassUnit::kg()}; + } + + CMass operator ""_kg(unsigned long long value) + { + return {static_cast(value), CMassUnit::kg()}; + } + + CMass operator ""_lb(long double value) + { + return {static_cast(value), CMassUnit::lb()}; + } + + CMass operator ""_lb(unsigned long long value) + { + return {static_cast(value), CMassUnit::lb()}; + } + + CMass operator ""_tonne(long double value) + { + return {static_cast(value), CMassUnit::tonne()}; + } + + CMass operator ""_tonne(unsigned long long value) + { + return {static_cast(value), CMassUnit::tonne()}; + } + + CMass operator ""_shortTon(long double value) + { + return {static_cast(value), CMassUnit::shortTon()}; + } + + CMass operator ""_shortTon(unsigned long long value) + { + return {static_cast(value), CMassUnit::shortTon()}; + } + + CPressure operator ""_Pa(long double value) + { + return {static_cast(value), CPressureUnit::Pa()}; + } + + CPressure operator ""_Pa(unsigned long long value) + { + return {static_cast(value), CPressureUnit::Pa()}; + } + + CPressure operator ""_bar(long double value) + { + return {static_cast(value), CPressureUnit::bar()}; + } + + CPressure operator ""_bar(unsigned long long value) + { + return {static_cast(value), CPressureUnit::bar()}; + } + + CPressure operator ""_hPa(long double value) + { + return {static_cast(value), CPressureUnit::hPa()}; + } + + CPressure operator ""_hPa(unsigned long long value) + { + return {static_cast(value), CPressureUnit::hPa()}; + } + + CPressure operator ""_psi(long double value) + { + return {static_cast(value), CPressureUnit::psi()}; + } + + CPressure operator ""_psi(unsigned long long value) + { + return {static_cast(value), CPressureUnit::psi()}; + } + + CPressure operator ""_inHg(long double value) + { + return {static_cast(value), CPressureUnit::inHg()}; + } + + CPressure operator ""_inHg(unsigned long long value) + { + return {static_cast(value), CPressureUnit::inHg()}; + } + + CPressure operator ""_mbar(long double value) + { + return {static_cast(value), CPressureUnit::mbar()}; + } + + CPressure operator ""_mbar(unsigned long long value) + { + return {static_cast(value), CPressureUnit::mbar()}; + } + + CPressure operator ""_mmHg(long double value) + { + return {static_cast(value), CPressureUnit::mmHg()}; + } + + CPressure operator ""_mmHg(unsigned long long value) + { + return {static_cast(value), CPressureUnit::mmHg()}; + } + + CSpeed operator ""_kts(long double value) + { + return {static_cast(value), CSpeedUnit::kts()}; + } + + CSpeed operator ""_kts(unsigned long long value) + { + return {static_cast(value), CSpeedUnit::kts()}; + } + + CSpeed operator ""_m_s(long double value) + { + return {static_cast(value), CSpeedUnit::m_s()}; + } + + CSpeed operator ""_m_s(unsigned long long value) + { + return {static_cast(value), CSpeedUnit::m_s()}; + } + + CSpeed operator ""_NM_h(long double value) + { + return {static_cast(value), CSpeedUnit::NM_h()}; + } + + CSpeed operator ""_NM_h(unsigned long long value) + { + return {static_cast(value), CSpeedUnit::NM_h()}; + } + + CSpeed operator ""_ft_s(long double value) + { + return {static_cast(value), CSpeedUnit::ft_s()}; + } + + CSpeed operator ""_ft_s(unsigned long long value) + { + return {static_cast(value), CSpeedUnit::ft_s()}; + } + + CSpeed operator ""_km_h(long double value) + { + return {static_cast(value), CSpeedUnit::km_h()}; + } + + CSpeed operator ""_km_h(unsigned long long value) + { + return {static_cast(value), CSpeedUnit::km_h()}; + } + + CSpeed operator ""_ft_min(long double value) + { + return {static_cast(value), CSpeedUnit::ft_min()}; + } + + CSpeed operator ""_ft_min(unsigned long long value) + { + return {static_cast(value), CSpeedUnit::ft_min()}; + } + + CTemperature operator ""_degC(long double value) + { + return {static_cast(value), CTemperatureUnit::C()}; + } + + CTemperature operator ""_degC(unsigned long long value) + { + return {static_cast(value), CTemperatureUnit::C()}; + } + + CTemperature operator ""_degF(long double value) + { + return {static_cast(value), CTemperatureUnit::F()}; + } + + CTemperature operator ""_degF(unsigned long long value) + { + return {static_cast(value), CTemperatureUnit::F()}; + } + + CTemperature operator ""_degK(long double value) + { + return {static_cast(value), CTemperatureUnit::K()}; + } + + CTemperature operator ""_degK(unsigned long long value) + { + return {static_cast(value), CTemperatureUnit::K()}; + } + + CTime operator ""_d(long double value) + { + return {static_cast(value), CTimeUnit::d()}; + } + + CTime operator ""_d(unsigned long long value) + { + return {static_cast(value), CTimeUnit::d()}; + } + + CTime operator ""_h(long double value) + { + return {static_cast(value), CTimeUnit::h()}; + } + + CTime operator ""_h(unsigned long long value) + { + return {static_cast(value), CTimeUnit::h()}; + } + + CTime operator ""_s(long double value) + { + return {static_cast(value), CTimeUnit::s()}; + } + + CTime operator ""_s(unsigned long long value) + { + return {static_cast(value), CTimeUnit::s()}; + } + + CTime operator ""_ms(long double value) + { + return {static_cast(value), CTimeUnit::ms()}; + } + + CTime operator ""_ms(unsigned long long value) + { + return {static_cast(value), CTimeUnit::ms()}; + } + + CTime operator ""_min(long double value) + { + return {static_cast(value), CTimeUnit::min()}; + } + + CTime operator ""_min(unsigned long long value) + { + return {static_cast(value), CTimeUnit::min()}; + } + + CTime operator ""_hms(long double value) + { + return {static_cast(value), CTimeUnit::hms()}; + } + + CTime operator ""_hms(unsigned long long value) + { + return {static_cast(value), CTimeUnit::hms()}; + } + + CTime operator ""_hrmin(long double value) + { + return {static_cast(value), CTimeUnit::hrmin()}; + } + + CTime operator ""_hrmin(unsigned long long value) + { + return {static_cast(value), CTimeUnit::hrmin()}; + } + + CTime operator ""_minsec(long double value) + { + return {static_cast(value), CTimeUnit::minsec()}; + } + + CTime operator ""_minsec(unsigned long long value) + { + return {static_cast(value), CTimeUnit::minsec()}; + } + } + } +} diff --git a/src/blackmisc/pq/literals.h b/src/blackmisc/pq/literals.h new file mode 100644 index 000000000..a5cf96c4d --- /dev/null +++ b/src/blackmisc/pq/literals.h @@ -0,0 +1,299 @@ +/* Copyright (C) 2020 + * swift project Community / Contributors + * + * This file is part of swift project. It is subject to the license terms in the LICENSE file found in the top-level + * directory of this distribution. No part of swift project, including this file, may be copied, modified, propagated, + * or distributed except according to the terms contained in the LICENSE file. + */ + +//! \file +#ifndef BLACKMISC_PQ_LITERALS_H +#define BLACKMISC_PQ_LITERALS_H + +#include "blackmisc/blackmiscexport.h" + +namespace BlackMisc +{ + namespace PhysicalQuantities + { + class CAcceleration; + class CAngle; + class CFrequency; + class CLength; + class CMass; + class CPressure; + class CSpeed; + class CTemperature; + class CTime; + namespace Literals + { + //! User-defined literal for ft/s^2 + //! @{ + BLACKMISC_EXPORT CAcceleration operator ""_ft_s2(long double); + BLACKMISC_EXPORT CAcceleration operator ""_ft_s2(unsigned long long); + //! @} + + //! User-defined literal for m/s^2 + //! @{ + BLACKMISC_EXPORT CAcceleration operator ""_m_s2(long double); + BLACKMISC_EXPORT CAcceleration operator ""_m_s2(unsigned long long); + //! @} + + //! User-defined literal for degrees (Angle) + //! @{ + BLACKMISC_EXPORT CAngle operator ""_deg(long double); + BLACKMISC_EXPORT CAngle operator ""_deg(unsigned long long); + //! @} + + //! User-defined literal for radian + //! @{ + BLACKMISC_EXPORT CAngle operator ""_rad(long double); + BLACKMISC_EXPORT CAngle operator ""_rad(unsigned long long); + //! @} + + //! User-defined literal for hertz + //! @{ + BLACKMISC_EXPORT CFrequency operator ""_Hz(long double); + BLACKMISC_EXPORT CFrequency operator ""_Hz(unsigned long long); + //! @} + + //! User-defined literal for kilohertz + //! @{ + BLACKMISC_EXPORT CFrequency operator ""_kHz(long double); + BLACKMISC_EXPORT CFrequency operator ""_kHz(unsigned long long); + //! @} + + //! User-defined literal for megahertz + //! @{ + BLACKMISC_EXPORT CFrequency operator ""_MHz(long double); + BLACKMISC_EXPORT CFrequency operator ""_MHz(unsigned long long); + //! @} + + //! User-defined literal for gigahertz + //! @{ + BLACKMISC_EXPORT CFrequency operator ""_GHz(long double); + BLACKMISC_EXPORT CFrequency operator ""_GHz(unsigned long long); + //! @} + + //! User-defined literal for meters + //! @{ + BLACKMISC_EXPORT CLength operator ""_m(long double); + BLACKMISC_EXPORT CLength operator ""_m(unsigned long long); + //! @} + + //! User-defined literal for nautical miles + //! @{ + BLACKMISC_EXPORT CLength operator ""_NM(long double); + BLACKMISC_EXPORT CLength operator ""_NM(unsigned long long); + //! @} + + //! User-defined literal for statute miles + //! @{ + BLACKMISC_EXPORT CLength operator ""_SM(long double); + BLACKMISC_EXPORT CLength operator ""_SM(unsigned long long); + //! @} + + //! User-defined literal for centimeters + //! @{ + BLACKMISC_EXPORT CLength operator ""_cm(long double); + BLACKMISC_EXPORT CLength operator ""_cm(unsigned long long); + //! @} + + //! User-defined literal for feet + //! @{ + BLACKMISC_EXPORT CLength operator ""_ft(long double); + BLACKMISC_EXPORT CLength operator ""_ft(unsigned long long); + //! @} + + //! User-defined literal for kilometer + //! @{ + BLACKMISC_EXPORT CLength operator ""_km(long double); + BLACKMISC_EXPORT CLength operator ""_km(unsigned long long); + //! @} + + //! User-defined literal for miles + //! @{ + BLACKMISC_EXPORT CLength operator ""_mi(long double); + BLACKMISC_EXPORT CLength operator ""_mi(unsigned long long); + //! @} + + //! User-defined literal for grams + //! @{ + BLACKMISC_EXPORT CMass operator ""_g(long double); + BLACKMISC_EXPORT CMass operator ""_g(unsigned long long); + //! @} + + //! User-defined literal for kilograms + //! @{ + BLACKMISC_EXPORT CMass operator ""_kg(long double); + BLACKMISC_EXPORT CMass operator ""_kg(unsigned long long); + //! @} + + //! User-defined literal for pounds + //! @{ + BLACKMISC_EXPORT CMass operator ""_lb(long double); + BLACKMISC_EXPORT CMass operator ""_lb(unsigned long long); + //! @} + + //! User-defined literal for tonnes + //! @{ + BLACKMISC_EXPORT CMass operator ""_tonne(long double); + BLACKMISC_EXPORT CMass operator ""_tonne(unsigned long long); + //! @} + + //! User-defined literal for US-ton + //! @{ + BLACKMISC_EXPORT CMass operator ""_shortTon(long double); + BLACKMISC_EXPORT CMass operator ""_shortTon(unsigned long long); + //! @} + + //! User-defined literal for pascal + //! @{ + BLACKMISC_EXPORT CPressure operator ""_Pa(long double); + BLACKMISC_EXPORT CPressure operator ""_Pa(unsigned long long); + //! @} + + //! User-defined literal for bar + //! @{ + BLACKMISC_EXPORT CPressure operator ""_bar(long double); + BLACKMISC_EXPORT CPressure operator ""_bar(unsigned long long); + //! @} + + //! User-defined literal for hectopascal + //! @{ + BLACKMISC_EXPORT CPressure operator ""_hPa(long double); + BLACKMISC_EXPORT CPressure operator ""_hPa(unsigned long long); + //! @} + + //! User-defined literal for pounds per square inch (psi) + //! @{ + BLACKMISC_EXPORT CPressure operator ""_psi(long double); + BLACKMISC_EXPORT CPressure operator ""_psi(unsigned long long); + //! @} + + //! User-defined literal for inch of mercury (inHg) + //! @{ + BLACKMISC_EXPORT CPressure operator ""_inHg(long double); + BLACKMISC_EXPORT CPressure operator ""_inHg(unsigned long long); + //! @} + + //! User-defined literal for milibar + //! @{ + BLACKMISC_EXPORT CPressure operator ""_mbar(long double); + BLACKMISC_EXPORT CPressure operator ""_mbar(unsigned long long); + //! @} + + //! User-defined literal for milimetre of mercury + //! @{ + BLACKMISC_EXPORT CPressure operator ""_mmHg(long double); + BLACKMISC_EXPORT CPressure operator ""_mmHg(unsigned long long); + //! @} + + //! User-defined literal for knots + //! @{ + BLACKMISC_EXPORT CSpeed operator ""_kts(long double); + BLACKMISC_EXPORT CSpeed operator ""_kts(unsigned long long); + //! @} + + //! User-defined literal for m/s + //! @{ + BLACKMISC_EXPORT CSpeed operator ""_m_s(long double); + BLACKMISC_EXPORT CSpeed operator ""_m_s(unsigned long long); + //! @} + + //! User-defined literal for NM/h + //! @{ + BLACKMISC_EXPORT CSpeed operator ""_NM_h(long double); + BLACKMISC_EXPORT CSpeed operator ""_NM_h(unsigned long long); + //! @} + + //! User-defined literal for ft/s + //! @{ + BLACKMISC_EXPORT CSpeed operator ""_ft_s(long double); + BLACKMISC_EXPORT CSpeed operator ""_ft_s(unsigned long long); + //! @} + + //! User-defined literal for km/h + //! @{ + BLACKMISC_EXPORT CSpeed operator ""_km_h(long double); + BLACKMISC_EXPORT CSpeed operator ""_km_h(unsigned long long); + //! @} + + //! User-defined literal for ft/min + //! @{ + BLACKMISC_EXPORT CSpeed operator ""_ft_min(long double); + BLACKMISC_EXPORT CSpeed operator ""_ft_min(unsigned long long); + //! @} + + //! User-defined literal for degrees Celsius + //! @{ + BLACKMISC_EXPORT CTemperature operator ""_degC(long double); + BLACKMISC_EXPORT CTemperature operator ""_degC(unsigned long long); + //! @} + + //! User-defined literal for degrees Fahrenheit + //! @{ + BLACKMISC_EXPORT CTemperature operator ""_degF(long double); + BLACKMISC_EXPORT CTemperature operator ""_degF(unsigned long long); + //! @} + + //! User-defined literal for degrees Kelvin + //! @{ + BLACKMISC_EXPORT CTemperature operator ""_degK(long double); + BLACKMISC_EXPORT CTemperature operator ""_degK(unsigned long long); + //! @} + + //! User-defined literal for days + //! @{ + BLACKMISC_EXPORT CTime operator ""_d(long double); + BLACKMISC_EXPORT CTime operator ""_d(unsigned long long); + //! @} + + //! User-defined literal for hours + //! @{ + BLACKMISC_EXPORT CTime operator ""_h(long double); + BLACKMISC_EXPORT CTime operator ""_h(unsigned long long); + //! @} + + //! User-defined literal for seconds + //! @{ + BLACKMISC_EXPORT CTime operator ""_s(long double); + BLACKMISC_EXPORT CTime operator ""_s(unsigned long long); + //! @} + + //! User-defined literal for miliseconds + //! @{ + BLACKMISC_EXPORT CTime operator ""_ms(long double); + BLACKMISC_EXPORT CTime operator ""_ms(unsigned long long); + //! @} + + //! User-defined literal for minutes + //! @{ + BLACKMISC_EXPORT CTime operator ""_min(long double); + BLACKMISC_EXPORT CTime operator ""_min(unsigned long long); + //! @} + + //! User-defined literal for hours/minutes/seconds + //! @{ + BLACKMISC_EXPORT CTime operator ""_hms(long double); + BLACKMISC_EXPORT CTime operator ""_hms(unsigned long long); + //! @} + + //! User-defined literal for hours/minutes + //! @{ + BLACKMISC_EXPORT CTime operator ""_hrmin(long double); + BLACKMISC_EXPORT CTime operator ""_hrmin(unsigned long long); + //! @} + + //! User-defined literal for minutes/seconds + //! @{ + BLACKMISC_EXPORT CTime operator ""_minsec(long double); + BLACKMISC_EXPORT CTime operator ""_minsec(unsigned long long); + //! @} + } + + } + +} + +#endif // BLACKMISC_PQ_LITERALS_H diff --git a/tests/blackmisc/pq/testphysicalquantities/testphysicalquantities.cpp b/tests/blackmisc/pq/testphysicalquantities/testphysicalquantities.cpp index 85d8a6e96..d039b8a81 100644 --- a/tests/blackmisc/pq/testphysicalquantities/testphysicalquantities.cpp +++ b/tests/blackmisc/pq/testphysicalquantities/testphysicalquantities.cpp @@ -16,6 +16,7 @@ #include "blackmisc/pq/constants.h" #include "blackmisc/pq/frequency.h" #include "blackmisc/pq/length.h" +#include "blackmisc/pq/literals.h" #include "blackmisc/pq/mass.h" #include "blackmisc/pq/measurementunit.h" #include "blackmisc/pq/physicalquantity.h" @@ -81,6 +82,9 @@ namespace BlackMiscTest //! Basic arithmetic such as +/- void basicArithmetic(); + + //! Test user-defined literals + void literalsTest(); }; void CTestPhysicalQuantities::unitsBasics() @@ -334,6 +338,117 @@ namespace BlackMiscTest QVERIFY2(a1.valueInteger(CAngleUnit::deg()) == 450, "Expect 450 degrees"); } + + void CTestPhysicalQuantities::literalsTest() + { + using namespace BlackMisc::PhysicalQuantities::Literals; + + // Acceleration + QVERIFY2(12.5_ft_s2 == CAcceleration(12.5, CAccelerationUnit::ft_s2()), "Acceleration needs to be the same"); + QVERIFY2(5.7_m_s2 == CAcceleration(5.7, CAccelerationUnit::m_s2()), "Acceleration needs to be the same"); + QVERIFY2(48_ft_s2 == CAcceleration(48, CAccelerationUnit::ft_s2()), "Acceleration needs to be the same"); + QVERIFY2(39_m_s2 == CAcceleration(39, CAccelerationUnit::m_s2()), "Acceleration needs to be the same"); + + // Angle + QVERIFY2(179.7_deg == CAngle(179.7, CAngleUnit::deg()), "Angle needs to be the same"); + QVERIFY2(1.1_rad == CAngle(1.1, CAngleUnit::rad()), "Angle needs to be the same"); + QVERIFY2(180_deg == CAngle(180, CAngleUnit::deg()), "Angle needs to be the same"); + QVERIFY2(1_rad == CAngle(1, CAngleUnit::rad()), "Angle needs to be the same"); + + // Frequency + QVERIFY2(500.7_Hz == CFrequency(500.7, CFrequencyUnit::Hz()), "Frequency needs to be the same"); + QVERIFY2(99.7_kHz == CFrequency(99.7, CFrequencyUnit::kHz()), "Frequency needs to be the same"); + QVERIFY2(122.8_MHz == CFrequency(122.8, CFrequencyUnit::MHz()), "Frequency needs to be the same"); + QVERIFY2(4.1_GHz == CFrequency(4.1, CFrequencyUnit::GHz()), "Frequency needs to be the same"); + QVERIFY2(3000_Hz == CFrequency(3000, CFrequencyUnit::Hz()), "Frequency needs to be the same"); + QVERIFY2(122_kHz == CFrequency(122, CFrequencyUnit::kHz()), "Frequency needs to be the same"); + QVERIFY2(1333_MHz == CFrequency(1333, CFrequencyUnit::MHz()), "Frequency needs to be the same"); + QVERIFY2(5_GHz == CFrequency(5, CFrequencyUnit::GHz()), "Frequency needs to be the same"); + + // Length + QVERIFY2(79.24_m == CLength(79.24, CLengthUnit::m()), "Length needs to be the same"); + QVERIFY2(1024.2_NM == CLength(1024.2, CLengthUnit::NM()), "Length needs to be the same"); + QVERIFY2(78.1_SM == CLength(78.1, CLengthUnit::SM()), "Length needs to be the same"); + QVERIFY2(99.9_cm == CLength(99.9, CLengthUnit::cm()), "Length needs to be the same"); + QVERIFY2(147.2_ft == CLength(147.2, CLengthUnit::ft()), "Length needs to be the same"); + QVERIFY2(450.4_km == CLength(450.4, CLengthUnit::km()), "Length needs to be the same"); + QVERIFY2(136.2_mi == CLength(136.2, CLengthUnit::mi()), "Length needs to be the same"); + QVERIFY2(100_m == CLength(100, CLengthUnit::m()), "Length needs to be the same"); + QVERIFY2(320_NM == CLength(320, CLengthUnit::NM()), "Length needs to be the same"); + QVERIFY2(145_SM == CLength(145, CLengthUnit::SM()), "Length needs to be the same"); + QVERIFY2(200_cm == CLength(200, CLengthUnit::cm()), "Length needs to be the same"); + QVERIFY2(38000_ft == CLength(38000, CLengthUnit::ft()), "Length needs to be the same"); + QVERIFY2(100_km == CLength(100, CLengthUnit::km()), "Length needs to be the same"); + QVERIFY2(78_mi == CLength(78, CLengthUnit::mi()), "Length needs to be the same"); + + // Mass + QVERIFY2(142.1_g == CMass(142.1, CMassUnit::g()), "Mass needs to be the same"); + QVERIFY2(2048.123_kg == CMass(2048.123, CMassUnit::kg()), "Mass needs to be the same"); + QVERIFY2(8.2_lb == CMass(8.2, CMassUnit::lb()), "Mass needs to be the same"); + QVERIFY2(60.5_tonne == CMass(60.5, CMassUnit::tonne()), "Mass needs to be the same"); + QVERIFY2(45.3_shortTon == CMass(45.3, CMassUnit::shortTon()), "Mass needs to be the same"); + QVERIFY2(100_g == CMass(100, CMassUnit::g()), "Mass needs to be the same"); + QVERIFY2(2048_kg == CMass(2048, CMassUnit::kg()), "Mass needs to be the same"); + QVERIFY2(100_lb == CMass(100, CMassUnit::lb()), "Mass needs to be the same"); + QVERIFY2(30_tonne == CMass(30, CMassUnit::tonne()), "Mass needs to be the same"); + QVERIFY2(10_shortTon == CMass(10, CMassUnit::shortTon()), "Mass needs to be the same"); + + // Pressure + QVERIFY2(36.111_Pa == CPressure(36.111, CPressureUnit::Pa()), "Pressure needs to be the same"); + QVERIFY2(45.4_bar == CPressure(45.4, CPressureUnit::bar()), "Pressure needs to be the same"); + QVERIFY2(67.8_hPa == CPressure(67.8, CPressureUnit::hPa()), "Pressure needs to be the same"); + QVERIFY2(129.2_psi == CPressure(129.2, CPressureUnit::psi()), "Pressure needs to be the same"); + QVERIFY2(20.2_inHg == CPressure(20.2, CPressureUnit::inHg()), "Pressure needs to be the same"); + QVERIFY2(1013.13_mbar == CPressure(1013.13, CPressureUnit::mbar()), "Pressure needs to be the same"); + QVERIFY2(22.92_mmHg == CPressure(22.92, CPressureUnit::mmHg()), "Pressure needs to be the same"); + QVERIFY2(40_Pa == CPressure(40, CPressureUnit::Pa()), "Pressure needs to be the same"); + QVERIFY2(16_bar == CPressure(16, CPressureUnit::bar()), "Pressure needs to be the same"); + QVERIFY2(67_hPa == CPressure(67, CPressureUnit::hPa()), "Pressure needs to be the same"); + QVERIFY2(129_psi == CPressure(129, CPressureUnit::psi()), "Pressure needs to be the same"); + QVERIFY2(20_inHg == CPressure(20, CPressureUnit::inHg()), "Pressure needs to be the same"); + QVERIFY2(1013_mbar == CPressure(1013, CPressureUnit::mbar()), "Pressure needs to be the same"); + QVERIFY2(22_mmHg == CPressure(22, CPressureUnit::mmHg()), "Pressure needs to be the same"); + + // Speed + QVERIFY2(450.2_kts == CSpeed(450.2, CSpeedUnit::kts()), "Speed needs to be the same"); + QVERIFY2(5.7_m_s == CSpeed(5.7, CSpeedUnit::m_s()), "Speed needs to be the same"); + QVERIFY2(470.1_NM_h == CSpeed(470.1, CSpeedUnit::NM_h()), "Speed needs to be the same"); + QVERIFY2(20.45_ft_s == CSpeed(20.45, CSpeedUnit::ft_s()), "Speed needs to be the same"); + QVERIFY2(115.16_km_h == CSpeed(115.16, CSpeedUnit::km_h()), "Speed needs to be the same"); + QVERIFY2(160.5_ft_min == CSpeed(160.5, CSpeedUnit::ft_min()), "Speed needs to be the same"); + QVERIFY2(1020_kts == CSpeed(1020, CSpeedUnit::kts()), "Speed needs to be the same"); + QVERIFY2(20_m_s == CSpeed(20, CSpeedUnit::m_s()), "Speed needs to be the same"); + QVERIFY2(500_NM_h == CSpeed(500, CSpeedUnit::NM_h()), "Speed needs to be the same"); + QVERIFY2(400_ft_s == CSpeed(400, CSpeedUnit::ft_s()), "Speed needs to be the same"); + QVERIFY2(161_km_h == CSpeed(161, CSpeedUnit::km_h()), "Speed needs to be the same"); + QVERIFY2(4000_ft_min == CSpeed(4000, CSpeedUnit::ft_min()), "Speed needs to be the same"); + + // Temperature + QVERIFY2(-15.2_degC == CTemperature(-15.2, CTemperatureUnit::C()), "Temperature needs to be the same"); + QVERIFY2(68.1_degF == CTemperature(68.1, CTemperatureUnit::F()), "Temperature needs to be the same"); + QVERIFY2(232.2_degK == CTemperature(232.2, CTemperatureUnit::K()), "Temperature needs to be the same"); + QVERIFY2(35_degC == CTemperature(35, CTemperatureUnit::C()), "Temperature needs to be the same"); + QVERIFY2(-20_degF == CTemperature(-20, CTemperatureUnit::F()), "Temperature needs to be the same"); + QVERIFY2(140_degK == CTemperature(140, CTemperatureUnit::K()), "Temperature needs to be the same"); + + // Time + QVERIFY2(24.5_d == CTime(24.5, CTimeUnit::d()), "Time needs to be the same"); + QVERIFY2(23.99_h == CTime(23.99, CTimeUnit::h()), "Time needs to be the same"); + QVERIFY2(30.1_s == CTime(30.1, CTimeUnit::s()), "Time needs to be the same"); + QVERIFY2(20.0_ms == CTime(20.0, CTimeUnit::ms()), "Time needs to be the same"); + QVERIFY2(65.7_min == CTime(65.7, CTimeUnit::min()), "Time needs to be the same"); + QVERIFY2(53215.0_hms == CTime(53215, CTimeUnit::hms()), "Time needs to be the same"); + QVERIFY2(236.0_hrmin == CTime(236, CTimeUnit::hrmin()), "Time needs to be the same"); + QVERIFY2(3030.0_minsec == CTime(3030, CTimeUnit::minsec()), "Time needs to be the same"); + QVERIFY2(31_d == CTime(31, CTimeUnit::d()), "Time needs to be the same"); + QVERIFY2(24_h == CTime(24, CTimeUnit::h()), "Time needs to be the same"); + QVERIFY2(60_s == CTime(60, CTimeUnit::s()), "Time needs to be the same"); + QVERIFY2(40_ms == CTime(40, CTimeUnit::ms()), "Time needs to be the same"); + QVERIFY2(36_min == CTime(36, CTimeUnit::min()), "Time needs to be the same"); + QVERIFY2(102010_hms == CTime(102010, CTimeUnit::hms()), "Time needs to be the same"); + QVERIFY2(510_hrmin == CTime(510, CTimeUnit::hrmin()), "Time needs to be the same"); + QVERIFY2(2637_minsec == CTime(2637, CTimeUnit::minsec()), "Time needs to be the same"); + } } // namespace //! main