test/marnav/units/Test_basic_quantity.cpp

   1 #include <marnav/units/units.hpp>
   2 #include <gtest/gtest.h>
   3
   4 namespace
   5 {
   6 using namespace marnav::units;
   7
   8 TEST(basic_quantity, get_dimension_from_quantity)
   9 {
  10         EXPECT_EQ(1, length::dimension::len);
  11         EXPECT_EQ(0, length::dimension::mas);
  12         EXPECT_EQ(0, length::dimension::tim);
  13         EXPECT_EQ(0, length::dimension::tem);
  14         EXPECT_EQ(0, length::dimension::cur);
  15         EXPECT_EQ(0, length::dimension::amt);
  16         EXPECT_EQ(0, length::dimension::lum);
  17 }
  18
  19 TEST(basic_quantity, construct_quantity_from_unit)
  20 {
  21         const length q1(meters{1});
  22
  23         EXPECT_EQ(1.0, q1.value());
  24
  25         // using squaremeters = basic_unit<basic_squaremeter<double>>;
  26         // length q2(squaremeters{});
  27 }
  28
  29 TEST(basic_quantity, retrieve_units_from_quantity)
  30 {
  31         const length q1(feet{1.0});
  32         EXPECT_EQ(0.3048, q1.get<meters>().value());
  33         EXPECT_EQ(1.0, q1.get<feet>().value());
  34
  35         // using meter2 = basic_unit<basic_squaremeter<double>>;
  36         // const meter2 sq = q1.get<meter2>();
  37 }
  38
  39 TEST(basic_quantity, retrieve_units_from_quantity_different_ratio)
  40 {
  41         const length q1(meters{100.0});
  42         EXPECT_EQ(0.1, q1.get<kilometers>().value());
  43         EXPECT_EQ(100000.0, q1.get<millimeters>().value());
  44 }
  45
  46 TEST(basic_quantity, scale_onto_self_with_value_type)
  47 {
  48         {
  49                 length q{meters{1.0}};
  50                 q *= 2.0;
  51                 EXPECT_EQ(2.0, q.value());
  52         }
  53         {
  54                 length q{meters{1.0}};
  55                 q /= 2.0;
  56                 EXPECT_EQ(0.5, q.value());
  57         }
  58 }
  59
  60 TEST(basic_quantity, scale_onto_self_with_convertible_type)
  61 {
  62         {
  63                 length q{meters{1.0}};
  64                 q *= 2.0f;
  65                 EXPECT_EQ(2.0, q.value());
  66         }
  67         {
  68                 length q{meters{1.0}};
  69                 q *= 2;
  70                 EXPECT_EQ(2.0, q.value());
  71         }
  72         {
  73                 length q{meters{1.0}};
  74                 q /= 2.0f;
  75                 EXPECT_EQ(0.5, q.value());
  76         }
  77         {
  78                 length q{meters{1.0}};
  79                 q /= 2;
  80                 EXPECT_EQ(0.5, q.value());
  81         }
  82         {
  83                 struct foo {
  84                         operator double() const { return 2.0; }
  85                 };
  86
  87                 length q{meters{1.0}};
  88                 q *= foo{};
  89                 EXPECT_EQ(2.0, q.value());
  90         }
  91         {
  92                 struct foo {
  93                         operator int() const { return 2; }
  94                 };
  95
  96                 length q{meters{1.0}};
  97                 q *= foo{};
  98                 EXPECT_EQ(2.0, q.value());
  99         }
 100 }
 101
 102 TEST(basic_quantity, unary_minus)
 103 {
 104         auto l = length{meters{2.0}};
 105         EXPECT_EQ(-2.0, (-l).value());
 106 }
 107
 108 TEST(basic_quantity, add_onto_self)
 109 {
 110         length q{meters{2}};
 111
 112         q += length{meters{1}};
 113
 114         EXPECT_EQ(3.0, q.value());
 115 }
 116
 117 TEST(basic_quantity, sub_onto_self)
 118 {
 119         length q{meters{2}};
 120
 121         q -= length{meters{1}};
 122
 123         EXPECT_EQ(1.0, q.value());
 124 }
 125
 126 TEST(basic_quantity, add)
 127 {
 128         const length q1{meters{2}};
 129         const length q2{feet{1}};
 130
 131         const length q = q1 + q2;
 132
 133         EXPECT_EQ(2.3048, q.value());
 134 }
 135
 136 TEST(basic_quantity, add_units_resulting_quanity)
 137 {
 138         const auto l1 = meters{2};
 139         const auto l2 = feet{1};
 140
 141         const length q = l1 + l2;
 142
 143         EXPECT_EQ(2.3048, q.value());
 144 }
 145
 146 TEST(basic_quantity, sub)
 147 {
 148         const length q1{meters{2}};
 149         const length q2{feet{1}};
 150
 151         const length q = q1 - q2;
 152
 153         EXPECT_EQ(1.6952, q.value());
 154 }
 155
 156 TEST(basic_quantity, sub_units_resulting_quantity)
 157 {
 158         const auto l1 = meters{2};
 159         const auto l2 = feet{1};
 160
 161         const length q = l1 - l2;
 162
 163         EXPECT_EQ(1.6952, q.value());
 164 }
 165
 166 TEST(basic_quantity, mul)
 167 {
 168         const auto q = length{meters{2}} * length{meters{3}};
 169
 170         EXPECT_EQ(6.0, q.value());
 171
 172         using dim = decltype(q)::dimension;
 173
 174         EXPECT_EQ(2, dim::len);
 175         EXPECT_EQ(0, dim::mas);
 176         EXPECT_EQ(0, dim::tim);
 177         EXPECT_EQ(0, dim::tem);
 178         EXPECT_EQ(0, dim::cur);
 179         EXPECT_EQ(0, dim::amt);
 180         EXPECT_EQ(0, dim::lum);
 181 }
 182
 183 TEST(basic_quantity, mul_units_resulting_in_quantity)
 184 {
 185         {
 186                 const auto q = meters{2} * meters{3};
 187
 188                 EXPECT_EQ(6.0, q.value());
 189
 190                 using dim = decltype(q)::dimension;
 191
 192                 EXPECT_EQ(2, dim::len);
 193                 EXPECT_EQ(0, dim::mas);
 194                 EXPECT_EQ(0, dim::tim);
 195                 EXPECT_EQ(0, dim::tem);
 196                 EXPECT_EQ(0, dim::cur);
 197                 EXPECT_EQ(0, dim::amt);
 198                 EXPECT_EQ(0, dim::lum);
 199         }
 200         {
 201                 const auto q = meters{2} * feet{3};
 202
 203                 EXPECT_NEAR(1.8288, q.value(), 1e-4);
 204
 205                 using dim = decltype(q)::dimension;
 206
 207                 EXPECT_EQ(2, dim::len);
 208                 EXPECT_EQ(0, dim::mas);
 209                 EXPECT_EQ(0, dim::tim);
 210                 EXPECT_EQ(0, dim::tem);
 211                 EXPECT_EQ(0, dim::cur);
 212                 EXPECT_EQ(0, dim::amt);
 213                 EXPECT_EQ(0, dim::lum);
 214         }
 215 }
 216
 217 TEST(basic_quantity, div)
 218 {
 219         const auto q = area{squaremeters{6}} / length{meters{2}};
 220
 221         EXPECT_EQ(3.0, q.value());
 222
 223         using dim = decltype(q)::dimension;
 224
 225         EXPECT_EQ(1, dim::len);
 226         EXPECT_EQ(0, dim::mas);
 227         EXPECT_EQ(0, dim::tim);
 228         EXPECT_EQ(0, dim::tem);
 229         EXPECT_EQ(0, dim::cur);
 230         EXPECT_EQ(0, dim::amt);
 231         EXPECT_EQ(0, dim::lum);
 232 }
 233
 234 TEST(basic_quantity, div_units_resuling_in_quantity)
 235 {
 236         {
 237                 const auto q = squaremeters{6} / meters{2};
 238
 239                 EXPECT_EQ(3.0, q.value());
 240
 241                 using dim = decltype(q)::dimension;
 242
 243                 EXPECT_EQ(1, dim::len);
 244                 EXPECT_EQ(0, dim::mas);
 245                 EXPECT_EQ(0, dim::tim);
 246                 EXPECT_EQ(0, dim::tem);
 247                 EXPECT_EQ(0, dim::cur);
 248                 EXPECT_EQ(0, dim::amt);
 249                 EXPECT_EQ(0, dim::lum);
 250         }
 251         {
 252                 const auto q = squaremeters{6} / feet{2};
 253
 254                 EXPECT_NEAR(9.84252, q.value(), 1e-5);
 255
 256                 using dim = decltype(q)::dimension;
 257
 258                 EXPECT_EQ(1, dim::len);
 259                 EXPECT_EQ(0, dim::mas);
 260                 EXPECT_EQ(0, dim::tim);
 261                 EXPECT_EQ(0, dim::tem);
 262                 EXPECT_EQ(0, dim::cur);
 263                 EXPECT_EQ(0, dim::amt);
 264                 EXPECT_EQ(0, dim::lum);
 265         }
 266 }
 267
 268 TEST(basic_quantity, floor)
 269 {
 270         EXPECT_EQ(+1.0, floor(length{meters{+1.0}}).value());
 271         EXPECT_EQ(+1.0, floor(length{meters{+1.4}}).value());
 272         EXPECT_EQ(+1.0, floor(length{meters{+1.5}}).value());
 273         EXPECT_EQ(+1.0, floor(length{meters{+1.6}}).value());
 274         EXPECT_EQ(+2.0, floor(length{meters{+2.0}}).value());
 275         EXPECT_EQ(+2.0, floor(length{meters{+2.5}}).value());
 276         EXPECT_EQ(-1.0, floor(length{meters{-1.0}}).value());
 277         EXPECT_EQ(-2.0, floor(length{meters{-1.5}}).value());
 278         EXPECT_EQ(-2.0, floor(length{meters{-2.0}}).value());
 279         EXPECT_EQ(-3.0, floor(length{meters{-2.5}}).value());
 280 }
 281
 282 TEST(basic_quantity, ceil)
 283 {
 284         EXPECT_EQ(+1.0, ceil(length{meters{+1.0}}).value());
 285         EXPECT_EQ(+2.0, ceil(length{meters{+1.4}}).value());
 286         EXPECT_EQ(+2.0, ceil(length{meters{+1.5}}).value());
 287         EXPECT_EQ(+2.0, ceil(length{meters{+1.6}}).value());
 288         EXPECT_EQ(+2.0, ceil(length{meters{+2.0}}).value());
 289         EXPECT_EQ(+3.0, ceil(length{meters{+2.5}}).value());
 290         EXPECT_EQ(-1.0, ceil(length{meters{-1.0}}).value());
 291         EXPECT_EQ(-1.0, ceil(length{meters{-1.5}}).value());
 292         EXPECT_EQ(-2.0, ceil(length{meters{-2.0}}).value());
 293         EXPECT_EQ(-2.0, ceil(length{meters{-2.5}}).value());
 294 }
 295
 296 TEST(basic_quantity, round)
 297 {
 298         EXPECT_EQ(+1.0, round(length{meters{+1.0}}).value());
 299         EXPECT_EQ(+1.0, round(length{meters{+1.4}}).value());
 300         EXPECT_EQ(+2.0, round(length{meters{+1.5}}).value());
 301         EXPECT_EQ(+2.0, round(length{meters{+1.6}}).value());
 302         EXPECT_EQ(+2.0, round(length{meters{+2.0}}).value());
 303         EXPECT_EQ(+3.0, round(length{meters{+2.5}}).value());
 304         EXPECT_EQ(-1.0, round(length{meters{-1.0}}).value());
 305         EXPECT_EQ(-2.0, round(length{meters{-1.5}}).value());
 306         EXPECT_EQ(-2.0, round(length{meters{-2.0}}).value());
 307         EXPECT_EQ(-3.0, round(length{meters{-2.5}}).value());
 308 }
 309
 310 TEST(basic_quantity, abs)
 311 {
 312         EXPECT_EQ(1.0, abs(length{meters{+1.0}}).value());
 313         EXPECT_EQ(1.4, abs(length{meters{+1.4}}).value());
 314         EXPECT_EQ(1.5, abs(length{meters{+1.5}}).value());
 315         EXPECT_EQ(1.6, abs(length{meters{+1.6}}).value());
 316         EXPECT_EQ(2.0, abs(length{meters{+2.0}}).value());
 317         EXPECT_EQ(2.5, abs(length{meters{+2.5}}).value());
 318         EXPECT_EQ(1.0, abs(length{meters{-1.0}}).value());
 319         EXPECT_EQ(1.5, abs(length{meters{-1.5}}).value());
 320         EXPECT_EQ(2.0, abs(length{meters{-2.0}}).value());
 321         EXPECT_EQ(2.5, abs(length{meters{-2.5}}).value());
 322 }
 323
 324 TEST(basic_quantity, comparison_equal)
 325 {
 326         EXPECT_TRUE(length{meters{1}} == length{meters{1}});
 327         EXPECT_FALSE(length{meters{1}} == length{feet{1}});
 328 }
 329
 330 TEST(basic_quantity, comparison_less)
 331 {
 332         EXPECT_TRUE(length{meters{1}} < length{meters{2}});
 333         EXPECT_TRUE(length{meters{1}} < length{feet{8}});
 334         EXPECT_FALSE(length{meters{1}} < length{meters{1}});
 335         EXPECT_FALSE(length{meters{2}} < length{meters{1}});
 336         EXPECT_FALSE(length{feet{4}} < length{meters{1}});
 337 }
 338 }