From a9c190a7bf7be31895608fd6598e79ff8234da7d Mon Sep 17 00:00:00 2001 From: Mateusz Pusz Date: Tue, 27 Dec 2022 12:51:28 +0100 Subject: [PATCH] test: iec80000 unit test added --- test/unit_test/static/iec80000_test.cpp | 87 ++++++++++++++++++------- 1 file changed, 63 insertions(+), 24 deletions(-) diff --git a/test/unit_test/static/iec80000_test.cpp b/test/unit_test/static/iec80000_test.cpp index 05cf0751..e432b835 100644 --- a/test/unit_test/static/iec80000_test.cpp +++ b/test/unit_test/static/iec80000_test.cpp @@ -20,42 +20,81 @@ // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE // SOFTWARE. -#include -#include +#include +#include /* ************** DERIVED DIMENSIONS THAT INCLUDE UNITS WITH SPECIAL NAMES **************** */ namespace { -using namespace units::isq::si::references; -using namespace units::isq::iec80000::references; +using namespace units; +using namespace units::iec80000; +using namespace units::iec80000::unit_symbols; +using namespace units::si::unit_symbols; +using enum units::quantity_character; -// information +[[nodiscard]] consteval bool verify(QuantitySpec auto q, quantity_character ch, Unit auto... units) +{ + return q.character == ch && (... && requires { q[units]; }); +} -static_assert(1 * B == 8 * bit); -static_assert(1024 * bit == 1 * Kibit); -static_assert(1024 * B == 1 * KiB); -static_assert(8 * 1024 * bit == 1 * KiB); -static_assert(8 * 1 * Kibit == 1 * KiB); +// quantities +static_assert(verify(traffic_intensity, scalar, E)); +static_assert(verify(traffic_offered_intensity, scalar, E)); +static_assert(verify(traffic_carried_intensity, scalar, E)); +static_assert(verify(traffic_load, scalar, E)); +static_assert(verify(mean_queue_length, scalar, one)); +static_assert(verify(loss_probability, scalar, one)); +static_assert(verify(waiting_probability, scalar, one)); +static_assert(verify(call_intensity, scalar, 1 / s)); +static_assert(verify(calling_rate, scalar, 1 / s)); +static_assert(verify(completed_call_intensity, scalar, 1 / s)); +static_assert(verify(storage_capacity, scalar, bit, o, B)); +static_assert(verify(storage_size, scalar, bit, o, B)); +static_assert(verify(equivalent_binary_storage_capacity, scalar, bit)); +static_assert(verify(transfer_rate, scalar, o / s, B / s)); +static_assert(verify(period_of_data_elements, scalar, s)); +static_assert(verify(binary_digit_rate, scalar, bit / s)); +static_assert(verify(bit_rate, scalar, bit / s)); +static_assert(verify(period_of_binary_digits, scalar, s)); +static_assert(verify(bit_period, scalar, s)); +static_assert(verify(equivalent_binary_digit_rate, scalar, bit / s)); +static_assert(verify(equivalent_bit_rate, scalar, bit / s)); +static_assert(verify(modulation_rate, scalar, 1 / s, Bd)); +static_assert(verify(line_digit_rate, scalar, 1 / s, Bd)); +static_assert(verify(quantizing_distortion_power, scalar, W)); +static_assert(verify(carrier_power, scalar, W)); +static_assert(verify(signal_energy_per_binary_digit, scalar, J)); +static_assert(verify(error_probability, scalar, one)); +static_assert(verify(Hamming_distance, scalar, one)); +static_assert(verify(clock_frequency, scalar, Hz)); +static_assert(verify(clock_rate, scalar, Hz)); +static_assert(verify(decision_content, scalar, one)); -static_assert(1 * kbit == 1000 * bit); -static_assert(2000 * Mibit == 2097152 * kbit); -static_assert(1 * Kibit == 1024 * bit); -static_assert(1 * Mibit == 1024 * Kibit); -static_assert(1 * Gibit == 1024 * Mibit); -static_assert(1 * Tibit == 1024 * Gibit); -static_assert(1 * Pibit == 1024 * Tibit); -static_assert(1 * Eibit == 1024 * Pibit); +// unit conversions +static_assert(storage_capacity[B](1) == storage_capacity[bit](8)); +static_assert(storage_capacity[bit](1024) == storage_capacity[Kibit](1)); +static_assert(storage_capacity[B](1024) == storage_capacity[KiB](1)); +static_assert(storage_capacity[bit](8 * 1024) == storage_capacity[KiB](1)); +static_assert(storage_capacity[Kibit](8) == storage_capacity[KiB](1)); + +static_assert(storage_capacity[kbit](1) == storage_capacity[bit](1000)); +static_assert(storage_capacity[Mibit](2000) == storage_capacity[kbit](2097152)); + +static_assert(storage_capacity[Kibit](1) == storage_capacity[bit](1024)); +static_assert(storage_capacity[Mibit](1) == storage_capacity[Kibit](1024)); +static_assert(storage_capacity[Gibit](1) == storage_capacity[Mibit](1024)); +static_assert(storage_capacity[Tibit](1) == storage_capacity[Gibit](1024)); +static_assert(storage_capacity[Pibit](1) == storage_capacity[Tibit](1024)); +static_assert(storage_capacity[Eibit](1) == storage_capacity[Pibit](1024)); // transfer rate - -static_assert(16 * B / (2 * s) == 8 * (B / s)); -static_assert(120 * kB / (2 * min) == 1000 * (B / s)); +static_assert(storage_capacity[B](16) / isq::duration[s](2) == transfer_rate[B / s](8)); +static_assert(storage_capacity[kB](120) / isq::duration[min](2) == transfer_rate[B / s](1000)); // modulation rate - -static_assert(12 / (2 * s) == 6 * Bd); -static_assert(6000 / (3 * s) == 2 * kBd); +static_assert(12 / isq::duration[s](2) == modulation_rate[Bd](6)); +static_assert(6000 / isq::duration[s](3) == modulation_rate[kBd](2)); } // namespace