ceph/src/boost/libs/units/test/test_output.cpp

   1 // Boost.Units - A C++ library for zero-overhead dimensional analysis and
   2 // unit/quantity manipulation and conversion
   3 //
   4 // Copyright (C) 2009 Steven Watanabe
   5 // Copyright Paul A. Bristow 2010
   6 //
   7 // Distributed under the Boost Software License, Version 1.0. (See
   8 // accompanying file LICENSE_1_0.txt or copy at
   9 // http://www.boost.org/LICENSE_1_0.txt)
  10
  11 /**
  12 \file test_output.cpp
  13
  14 \brief
  15 Test unit and quantity printing
  16 \details
  17 Tests for output from various units, name, symbol and raw formats, and automatic prefixing in engineering and binary units.
  18 **/
  19
  20 #include <boost/units/quantity.hpp>
  21 #include <boost/units/io.hpp>
  22 #include <boost/units/unit.hpp>
  23 #include <boost/units/scale.hpp>
  24 #include <boost/units/scaled_base_unit.hpp>
  25 #include <boost/units/make_scaled_unit.hpp>
  26 #include <boost/units/base_unit.hpp>
  27 #include <boost/units/make_system.hpp>
  28 #include <boost/units/absolute.hpp>
  29 #include <boost/units/physical_dimensions/length.hpp>
  30 #include <boost/units/physical_dimensions/time.hpp>
  31 #include <boost/units/physical_dimensions/velocity.hpp>
  32 #include <boost/units/physical_dimensions/volume.hpp>
  33 #include <boost/units/physical_dimensions/acceleration.hpp>
  34 #include <boost/units/physical_dimensions/area.hpp>
  35
  36 #include <boost/regex.hpp>
  37
  38 #include <iostream>
  39 #include <sstream>
  40 #include <boost/config.hpp>
  41 #include <limits>
  42
  43 #define BOOST_TEST_MAIN
  44 #include <boost/test/unit_test.hpp>
  45
  46 struct meter_base_unit : boost::units::base_unit<meter_base_unit, boost::units::length_dimension, 1> {
  47     static BOOST_CONSTEXPR const char* name() { return("meter"); }
  48     static BOOST_CONSTEXPR const char* symbol() { return("m"); }
  49 };
  50
  51 struct second_base_unit : boost::units::base_unit<second_base_unit, boost::units::time_dimension, 2> {
  52     static BOOST_CONSTEXPR const char* name() { return("second"); }
  53     static BOOST_CONSTEXPR const char* symbol() { return("s"); }
  54 };
  55
  56 struct byte_base_unit : boost::units::base_unit<byte_base_unit, boost::units::dimensionless_type, 3> {
  57     static BOOST_CONSTEXPR const char* name() { return("byte"); }
  58     static BOOST_CONSTEXPR const char* symbol() { return("b"); }
  59 };
  60
  61 typedef boost::units::make_system<meter_base_unit, second_base_unit>::type my_system;
  62
  63 typedef boost::units::unit<boost::units::length_dimension, my_system> length;
  64 typedef boost::units::unit<boost::units::velocity_dimension, my_system> velocity;
  65
  66 typedef boost::units::make_scaled_unit<length, boost::units::scale<10, boost::units::static_rational<3> > >::type scaled_length;
  67 typedef boost::units::make_scaled_unit<velocity, boost::units::scale<10, boost::units::static_rational<3> > >::type scaled_velocity1;
  68
  69 typedef boost::units::scaled_base_unit<second_base_unit, boost::units::scale<10, boost::units::static_rational<-3> > > millisecond_base_unit;
  70
  71 typedef boost::units::make_system<meter_base_unit, millisecond_base_unit>::type scaled_system;
  72
  73 typedef boost::units::unit<boost::units::time_dimension, scaled_system> scaled_time;
  74 typedef boost::units::unit<boost::units::velocity_dimension, scaled_system> scaled_velocity2;
  75
  76 typedef boost::units::unit<boost::units::area_dimension, my_system> area;
  77 typedef boost::units::make_scaled_unit<area, boost::units::scale<10, boost::units::static_rational<3> > >::type scaled_area;
  78
  79 typedef boost::units::make_scaled_unit<scaled_length, boost::units::scale<2, boost::units::static_rational<10> > >::type double_scaled_length;
  80
  81 typedef boost::units::scaled_base_unit<meter_base_unit, boost::units::scale<100, boost::units::static_rational<1> > > scaled_length_base_unit;
  82 namespace boost {
  83 namespace units {
  84 template<>
  85 struct base_unit_info<scaled_length_base_unit> {
  86     static BOOST_CONSTEXPR const char* symbol() { return("scm"); }
  87     static BOOST_CONSTEXPR const char* name() { return("scaled_meter"); }
  88 };
  89 }
  90 }
  91 typedef boost::units::scaled_base_unit<scaled_length_base_unit, boost::units::scale<10, boost::units::static_rational<3> > > double_scaled_length_base_unit;
  92 typedef double_scaled_length_base_unit::unit_type double_scaled_length2;
  93
  94 typedef boost::units::reduce_unit<boost::units::unit<boost::units::volume_dimension, my_system> >::type custom1;
  95
  96 std::string name_string(const custom1&) { return("custom1"); }
  97 std::string symbol_string(const custom1&) { return("c1"); }
  98
  99 typedef boost::units::reduce_unit<boost::units::unit<boost::units::acceleration_dimension, my_system> >::type custom2;
 100
 101 BOOST_CONSTEXPR const char* name_string(const custom2&) { return("custom2"); }
 102 BOOST_CONSTEXPR const char* symbol_string(const custom2&) { return("c2"); }
 103
 104 typedef boost::units::make_scaled_unit<custom1, boost::units::scale<10, boost::units::static_rational<3> > >::type scaled_custom1;
 105 typedef boost::units::make_scaled_unit<custom2, boost::units::scale<10, boost::units::static_rational<3> > >::type scaled_custom2;
 106
 107 #ifndef BOOST_NO_CWCHAR
 108
 109 #define BOOST_UNITS_TEST_OUTPUT(v, expected)                \
 110 {                                                           \
 111     std::ostringstream ss;                                  \
 112     ss FORMATTERS << v;                                     \
 113     BOOST_CHECK_EQUAL(ss.str(), expected);                  \
 114 }                                                           \
 115 {                                                           \
 116     std::wostringstream ss;                                 \
 117     ss FORMATTERS << v;                                     \
 118     BOOST_CHECK(ss.str() == BOOST_PP_CAT(L, expected));     \
 119 }
 120
 121 #define BOOST_UNITS_TEST_OUTPUT_REGEX(v, expected)          \
 122 {                                                           \
 123     std::ostringstream ss;                                  \
 124     ss FORMATTERS << v;                                     \
 125     boost::regex r(expected);                               \
 126     BOOST_CHECK_MESSAGE(boost::regex_match(ss.str(), r),    \
 127         ss.str() + " does not match " + expected);          \
 128 }                                                           \
 129 {                                                           \
 130     std::wostringstream ss;                                 \
 131     ss FORMATTERS << v;                                     \
 132     boost::wregex r(BOOST_PP_CAT(L, expected));             \
 133     BOOST_CHECK(boost::regex_match(ss.str(), r));           \
 134 }
 135
 136 #define BOOST_UNITS_TEST_OUTPUT_DISPLAY(v)                  \
 137 {                                                           \
 138     std::ostringstream ss;                                  \
 139     ss FORMATTERS << v;                                     \
 140     std::cout << #v << ": " << ss.str() << std::endl;       \
 141 }                                                           \
 142 {                                                           \
 143     std::wostringstream ss;                                 \
 144     ss FORMATTERS << v;                                     \
 145     std::wcout << #v << ": " << ss.str() << std::endl;      \
 146 }
 147
 148 #else
 149
 150 #define BOOST_UNITS_TEST_OUTPUT(v, expected)                \
 151 {                                                           \
 152     std::ostringstream ss;                                  \
 153     ss FORMATTERS << v;                                     \
 154     BOOST_CHECK_EQUAL(ss.str(), expected);                  \
 155 }
 156
 157 #define BOOST_UNITS_TEST_OUTPUT_REGEX(v, expected)          \
 158 {                                                           \
 159     std::ostringstream ss;                                  \
 160     ss FORMATTERS << v;                                     \
 161     boost::regex r(expected);                               \
 162     BOOST_CHECK_MESSAGE(boost::regex_match(ss.str(), r),    \
 163         ss.str() + " does not match " + expected);          \
 164 }
 165
 166 #define BOOST_UNITS_TEST_OUTPUT_DISPLAY(v)                  \
 167 {                                                           \
 168     std::ostringstream ss;                                  \
 169     ss FORMATTERS << v;                                     \
 170     std::cout << #v << ": " << ss.str() << std::endl;       \
 171 }
 172
 173 #endif
 174
 175 BOOST_AUTO_TEST_CASE(test_output_unit_symbol)
 176 {  // base units using default symbol_format (no format specified) and no auto prefixing.
 177 #define FORMATTERS
 178     BOOST_UNITS_TEST_OUTPUT(meter_base_unit::unit_type(), "m");
 179     BOOST_UNITS_TEST_OUTPUT(velocity(), "m s^-1");
 180     BOOST_UNITS_TEST_OUTPUT(scaled_length(), "km");
 181     BOOST_UNITS_TEST_OUTPUT(scaled_velocity1(), "k(m s^-1)");
 182     BOOST_UNITS_TEST_OUTPUT(millisecond_base_unit::unit_type(), "ms");
 183     BOOST_UNITS_TEST_OUTPUT(scaled_time(), "ms");
 184     BOOST_UNITS_TEST_OUTPUT(scaled_velocity2(), "m ms^-1");
 185     BOOST_UNITS_TEST_OUTPUT(area(), "m^2");
 186     BOOST_UNITS_TEST_OUTPUT(scaled_area(), "k(m^2)");
 187     BOOST_UNITS_TEST_OUTPUT(double_scaled_length(), "Kikm");
 188     BOOST_UNITS_TEST_OUTPUT(double_scaled_length2(), "kscm");
 189     BOOST_UNITS_TEST_OUTPUT(custom1(), "c1");
 190     BOOST_UNITS_TEST_OUTPUT(custom2(), "c2");
 191     BOOST_UNITS_TEST_OUTPUT(scaled_custom1(), "kc1");
 192     BOOST_UNITS_TEST_OUTPUT(scaled_custom2(), "kc2");
 193     BOOST_UNITS_TEST_OUTPUT(boost::units::absolute<meter_base_unit::unit_type>(), "absolute m");
 194 #undef FORMATTERS
 195 }
 196
 197 BOOST_AUTO_TEST_CASE(test_output_unit_raw)
 198 {  // raw format specified
 199 #define FORMATTERS << boost::units::raw_format
 200     BOOST_UNITS_TEST_OUTPUT(meter_base_unit::unit_type(), "m");
 201     BOOST_UNITS_TEST_OUTPUT(velocity(), "m s^-1");
 202     BOOST_UNITS_TEST_OUTPUT(scaled_length(), "km");
 203     BOOST_UNITS_TEST_OUTPUT(scaled_velocity1(), "k(m s^-1)");
 204     BOOST_UNITS_TEST_OUTPUT(millisecond_base_unit::unit_type(), "ms");
 205     BOOST_UNITS_TEST_OUTPUT(scaled_time(), "ms");
 206     BOOST_UNITS_TEST_OUTPUT(scaled_velocity2(), "m ms^-1");
 207     BOOST_UNITS_TEST_OUTPUT(area(), "m^2");
 208     BOOST_UNITS_TEST_OUTPUT(scaled_area(), "k(m^2)");
 209     BOOST_UNITS_TEST_OUTPUT(double_scaled_length(), "Kikm");
 210     BOOST_UNITS_TEST_OUTPUT(double_scaled_length2(), "kscm");
 211     // when using raw format, we ignore the user defined overloads
 212     BOOST_UNITS_TEST_OUTPUT(custom1(), "m^3");
 213     BOOST_UNITS_TEST_OUTPUT(custom2(), "m s^-2");
 214     BOOST_UNITS_TEST_OUTPUT(scaled_custom1(), "k(m^3)");
 215     BOOST_UNITS_TEST_OUTPUT(scaled_custom2(), "k(m s^-2)");
 216     BOOST_UNITS_TEST_OUTPUT(boost::units::absolute<meter_base_unit::unit_type>(), "absolute m");
 217 #undef FORMATTERS
 218 }
 219
 220 BOOST_AUTO_TEST_CASE(test_output_unit_name)
 221 {  // name format specified.
 222 #define FORMATTERS << boost::units::name_format
 223     BOOST_UNITS_TEST_OUTPUT(meter_base_unit::unit_type(), "meter");
 224     BOOST_UNITS_TEST_OUTPUT(velocity(), "meter second^-1");
 225     BOOST_UNITS_TEST_OUTPUT(scaled_length(), "kilometer");
 226     BOOST_UNITS_TEST_OUTPUT(scaled_velocity1(), "kilo(meter second^-1)");
 227     BOOST_UNITS_TEST_OUTPUT(millisecond_base_unit::unit_type(), "millisecond");
 228     BOOST_UNITS_TEST_OUTPUT(scaled_time(), "millisecond");
 229     BOOST_UNITS_TEST_OUTPUT(scaled_velocity2(), "meter millisecond^-1");
 230     BOOST_UNITS_TEST_OUTPUT(area(), "meter^2");
 231     BOOST_UNITS_TEST_OUTPUT(scaled_area(), "kilo(meter^2)");
 232     BOOST_UNITS_TEST_OUTPUT(double_scaled_length(), "kibikilometer");
 233     BOOST_UNITS_TEST_OUTPUT(double_scaled_length2(), "kiloscaled_meter");
 234     BOOST_UNITS_TEST_OUTPUT(custom1(), "custom1");
 235     BOOST_UNITS_TEST_OUTPUT(custom2(), "custom2");
 236     BOOST_UNITS_TEST_OUTPUT(scaled_custom1(), "kilocustom1");
 237     BOOST_UNITS_TEST_OUTPUT(scaled_custom2(), "kilocustom2");
 238     BOOST_UNITS_TEST_OUTPUT(boost::units::absolute<meter_base_unit::unit_type>(), "absolute meter");
 239 #undef FORMATTERS
 240 }
 241
 242
 243 BOOST_AUTO_TEST_CASE(test_output_quantity_symbol)
 244 { // quantity symbols using default format.
 245 #define FORMATTERS
 246     BOOST_UNITS_TEST_OUTPUT(1.5*meter_base_unit::unit_type(), "1.5 m");
 247     BOOST_UNITS_TEST_OUTPUT(1.5*velocity(), "1.5 m s^-1");
 248     BOOST_UNITS_TEST_OUTPUT(1.5*scaled_length(), "1.5 km");
 249     BOOST_UNITS_TEST_OUTPUT(1.5*scaled_velocity1(), "1.5 k(m s^-1)");
 250     BOOST_UNITS_TEST_OUTPUT(1.5*millisecond_base_unit::unit_type(), "1.5 ms");
 251     BOOST_UNITS_TEST_OUTPUT(1.5*scaled_time(), "1.5 ms");
 252     BOOST_UNITS_TEST_OUTPUT(1.5*scaled_velocity2(), "1.5 m ms^-1");
 253     BOOST_UNITS_TEST_OUTPUT(1.5*area(), "1.5 m^2");
 254     BOOST_UNITS_TEST_OUTPUT(1.5*scaled_area(), "1.5 k(m^2)");
 255     BOOST_UNITS_TEST_OUTPUT(1.5*double_scaled_length(), "1.5 Kikm");
 256     BOOST_UNITS_TEST_OUTPUT(1.5*double_scaled_length2(), "1.5 kscm");
 257     BOOST_UNITS_TEST_OUTPUT(1.5*custom1(), "1.5 c1");
 258     BOOST_UNITS_TEST_OUTPUT(1.5*custom2(), "1.5 c2");
 259     BOOST_UNITS_TEST_OUTPUT(1.5*scaled_custom1(), "1.5 kc1");
 260     BOOST_UNITS_TEST_OUTPUT(1.5*scaled_custom2(), "1.5 kc2");
 261     BOOST_UNITS_TEST_OUTPUT(1.5*boost::units::absolute<meter_base_unit::unit_type>(), "1.5 absolute m");
 262     BOOST_UNITS_TEST_OUTPUT(std::pow(2., 10) * byte_base_unit::unit_type(), "1024 b");
 263
 264 #undef FORMATTERS
 265 }
 266
 267 BOOST_AUTO_TEST_CASE(test_output_quantity_raw)
 268 { // quantity symbols using raw format.
 269 #define FORMATTERS << boost::units::raw_format
 270     BOOST_UNITS_TEST_OUTPUT(1.5*meter_base_unit::unit_type(), "1.5 m");
 271     BOOST_UNITS_TEST_OUTPUT(1.5*velocity(), "1.5 m s^-1");
 272     BOOST_UNITS_TEST_OUTPUT(1.5*scaled_length(), "1.5 km");
 273     BOOST_UNITS_TEST_OUTPUT(1.5*scaled_velocity1(), "1.5 k(m s^-1)");
 274     BOOST_UNITS_TEST_OUTPUT(1.5*millisecond_base_unit::unit_type(), "1.5 ms");
 275     BOOST_UNITS_TEST_OUTPUT(1.5*scaled_time(), "1.5 ms");
 276     BOOST_UNITS_TEST_OUTPUT(1.5*scaled_velocity2(), "1.5 m ms^-1");
 277     BOOST_UNITS_TEST_OUTPUT(1.5*area(), "1.5 m^2");
 278     BOOST_UNITS_TEST_OUTPUT(1.5*scaled_area(), "1.5 k(m^2)");
 279     BOOST_UNITS_TEST_OUTPUT(1.5*double_scaled_length(), "1.5 Kikm");
 280     BOOST_UNITS_TEST_OUTPUT(1.5*double_scaled_length2(), "1.5 kscm");
 281     // when using raw format, we ignore the user defined overloads
 282     BOOST_UNITS_TEST_OUTPUT(1.5*custom1(), "1.5 m^3");
 283     BOOST_UNITS_TEST_OUTPUT(1.5*custom2(), "1.5 m s^-2");
 284     BOOST_UNITS_TEST_OUTPUT(1.5*scaled_custom1(), "1.5 k(m^3)");
 285     BOOST_UNITS_TEST_OUTPUT(1.5*scaled_custom2(), "1.5 k(m s^-2)");
 286     BOOST_UNITS_TEST_OUTPUT(1.5*boost::units::absolute<meter_base_unit::unit_type>(), "1.5 absolute m");
 287 #undef FORMATTERS
 288 }
 289
 290 BOOST_AUTO_TEST_CASE(test_output_quantity_name)
 291 { // // quantity symbols using name format.
 292 #define FORMATTERS << boost::units::name_format
 293     BOOST_UNITS_TEST_OUTPUT(1.5*meter_base_unit::unit_type(), "1.5 meter");
 294     BOOST_UNITS_TEST_OUTPUT(1.5*velocity(), "1.5 meter second^-1");
 295     BOOST_UNITS_TEST_OUTPUT(1.5*scaled_length(), "1.5 kilometer");
 296     BOOST_UNITS_TEST_OUTPUT(1.5*scaled_velocity1(), "1.5 kilo(meter second^-1)");
 297     BOOST_UNITS_TEST_OUTPUT(1.5*millisecond_base_unit::unit_type(), "1.5 millisecond");
 298     BOOST_UNITS_TEST_OUTPUT(1.5*scaled_time(), "1.5 millisecond");
 299     BOOST_UNITS_TEST_OUTPUT(1.5*scaled_velocity2(), "1.5 meter millisecond^-1");
 300     BOOST_UNITS_TEST_OUTPUT(1.5*area(), "1.5 meter^2");
 301     BOOST_UNITS_TEST_OUTPUT(1.5*scaled_area(), "1.5 kilo(meter^2)");
 302     BOOST_UNITS_TEST_OUTPUT(1.5*double_scaled_length(), "1.5 kibikilometer");
 303     BOOST_UNITS_TEST_OUTPUT(1.5*double_scaled_length2(), "1.5 kiloscaled_meter");
 304     BOOST_UNITS_TEST_OUTPUT(1.5*custom1(), "1.5 custom1");
 305     BOOST_UNITS_TEST_OUTPUT(1.5*custom2(), "1.5 custom2");
 306     BOOST_UNITS_TEST_OUTPUT(1.5*scaled_custom1(), "1.5 kilocustom1");
 307     BOOST_UNITS_TEST_OUTPUT(1.5*scaled_custom2(), "1.5 kilocustom2");
 308     BOOST_UNITS_TEST_OUTPUT(1.5*boost::units::absolute<meter_base_unit::unit_type>(), "1.5 absolute meter");
 309 #undef FORMATTERS
 310 }
 311
 312 BOOST_AUTO_TEST_CASE(test_output_autoprefixed_quantity_name)
 313 { // Engineering autoprefix, with name format.
 314 #define FORMATTERS << boost::units::name_format << boost::units::engineering_prefix
 315   // Single base unit like meter.
 316     BOOST_UNITS_TEST_OUTPUT(1.5*meter_base_unit::unit_type(), "1.5 meter");
 317     BOOST_UNITS_TEST_OUTPUT(1500.0*meter_base_unit::unit_type(), "1.5 kilometer");
 318     BOOST_UNITS_TEST_OUTPUT(1.5e7*meter_base_unit::unit_type(), "15 megameter");
 319     BOOST_UNITS_TEST_OUTPUT(1.5e-3*meter_base_unit::unit_type(), "1.5 millimeter");
 320     BOOST_UNITS_TEST_OUTPUT(1.5e-9*meter_base_unit::unit_type(), "1.5 nanometer");
 321     BOOST_UNITS_TEST_OUTPUT(1.5e-8*meter_base_unit::unit_type(), "15 nanometer");
 322     BOOST_UNITS_TEST_OUTPUT(1.5e-10*meter_base_unit::unit_type(), "150 picometer");
 323     BOOST_UNITS_TEST_OUTPUT(0.0000000012345 * meter_base_unit::unit_type(), "1.2345 nanometer");
 324
 325   // Too small or large for a multiple name.
 326     BOOST_UNITS_TEST_OUTPUT_REGEX(9.99999e-25 * meter_base_unit::unit_type(), "9\\.99999e-0?25 meter"); // Just too small for multiple.
 327     BOOST_UNITS_TEST_OUTPUT_REGEX(1e+28 * meter_base_unit::unit_type(), "1e\\+0?28 meter"); // Just too large for multiple.
 328     BOOST_UNITS_TEST_OUTPUT_REGEX(1.5e-25 * meter_base_unit::unit_type(), "1\\.5e-0?25 meter"); // Too small for multiple.
 329     BOOST_UNITS_TEST_OUTPUT_REGEX(1.5e+28 * meter_base_unit::unit_type(), "1\\.5e\\+0?28 meter"); // Too large for multiple.
 330   // Too 'biggest or too smallest'.
 331     BOOST_UNITS_TEST_OUTPUT_REGEX((std::numeric_limits<float>::max)()*meter_base_unit::unit_type(), "3\\.40282e\\+0?38 meter");
 332     BOOST_UNITS_TEST_OUTPUT_REGEX((std::numeric_limits<float>::min)()*meter_base_unit::unit_type(), "1\\.17549e-0?38 meter");
 333     BOOST_UNITS_TEST_OUTPUT((std::numeric_limits<double>::max)()*meter_base_unit::unit_type(), "1.79769e+308 meter");
 334     BOOST_UNITS_TEST_OUTPUT((std::numeric_limits<double>::min)()*meter_base_unit::unit_type(), "2.22507e-308 meter");
 335    // Infinity and NaN
 336     BOOST_UNITS_TEST_OUTPUT_REGEX(std::numeric_limits<float>::infinity()*meter_base_unit::unit_type(), "(1\\.#INF|inf|INF|Inf) meter");
 337     BOOST_UNITS_TEST_OUTPUT_REGEX(-std::numeric_limits<float>::infinity()*meter_base_unit::unit_type(), "-(1\\.#INF|inf|INF|Inf) meter");
 338     BOOST_UNITS_TEST_OUTPUT_REGEX(std::numeric_limits<double>::quiet_NaN()*meter_base_unit::unit_type(), "(1\\.#QNAN|nan|NaNQ|NaN) meter");
 339     BOOST_UNITS_TEST_OUTPUT_REGEX(-std::numeric_limits<double>::quiet_NaN()*meter_base_unit::unit_type(), "-?(1\\.#IND|nan|nan\\(ind\\)|NaNQ|NaN) meter");
 340
 341     BOOST_UNITS_TEST_OUTPUT(1.5*velocity(), "1.5 meter second^-1");
 342     BOOST_UNITS_TEST_OUTPUT(1.5*scaled_length(), "1.5 kilometer");
 343     BOOST_UNITS_TEST_OUTPUT(1.5*scaled_velocity1(), "1.5 kilo(meter second^-1)");
 344     BOOST_UNITS_TEST_OUTPUT(1.5*millisecond_base_unit::unit_type(), "1.5 millisecond");
 345     BOOST_UNITS_TEST_OUTPUT(1.5*scaled_time(), "1.5 millisecond");
 346     BOOST_UNITS_TEST_OUTPUT(1.5*scaled_velocity2(), "1.5 meter millisecond^-1");
 347     BOOST_UNITS_TEST_OUTPUT(1.5*area(), "1.5 meter^2");
 348     BOOST_UNITS_TEST_OUTPUT(1.5*scaled_area(), "1.5 kilo(meter^2)");
 349     BOOST_UNITS_TEST_OUTPUT(1.5*double_scaled_length(), "1.536 megameter"); // 1.5 * 2^10 = 1.5 * 1024 = 1.536
 350     BOOST_UNITS_TEST_OUTPUT(1.5*double_scaled_length2(), "1.5 kiloscaled_meter");
 351     BOOST_UNITS_TEST_OUTPUT(1.5*custom1(), "1.5 custom1");
 352     BOOST_UNITS_TEST_OUTPUT(1.5*custom2(), "1.5 custom2");
 353     BOOST_UNITS_TEST_OUTPUT(1.5*scaled_custom1(), "1.5 kilocustom1");
 354     BOOST_UNITS_TEST_OUTPUT(1.5*scaled_custom2(), "1.5 kilocustom2");
 355     BOOST_UNITS_TEST_OUTPUT(1.5*boost::units::absolute<meter_base_unit::unit_type>(), "1.5 absolute meter");
 356     BOOST_UNITS_TEST_OUTPUT(std::pow(2., 10) * byte_base_unit::unit_type(), "1.024 kilobyte");
 357
 358     BOOST_UNITS_TEST_OUTPUT(1.5, "1.5"); // scalar.
 359     BOOST_UNITS_TEST_OUTPUT(1567., "1567"); // scalars are *not* autoprefixed.
 360     BOOST_UNITS_TEST_OUTPUT(0.00015, "0.00015"); // scalars are *not* autoprefixed.
 361     BOOST_UNITS_TEST_OUTPUT(-1.5, "-1.5"); // scalar.
 362     BOOST_UNITS_TEST_OUTPUT(-1567., "-1567"); // scalars are *not* autoprefixed.
 363     BOOST_UNITS_TEST_OUTPUT(-0.00015, "-0.00015"); // scalars are *not* autoprefixed.
 364 #undef FORMATTERS
 365 }
 366
 367 BOOST_AUTO_TEST_CASE(test_output_autoprefixed_quantity_symbol)
 368 { // Engineering autoprefix, with symbol format.
 369 #define FORMATTERS << boost::units::symbol_format << boost::units::engineering_prefix
 370   // Single base unit like m.
 371     BOOST_UNITS_TEST_OUTPUT(1.5*meter_base_unit::unit_type(), "1.5 m");
 372     BOOST_UNITS_TEST_OUTPUT(1500.0*meter_base_unit::unit_type(), "1.5 km");
 373     BOOST_UNITS_TEST_OUTPUT(1.5e7*meter_base_unit::unit_type(), "15 Mm");
 374     BOOST_UNITS_TEST_OUTPUT(1.5e-3*meter_base_unit::unit_type(), "1.5 mm");
 375     BOOST_UNITS_TEST_OUTPUT(1.5e-9*meter_base_unit::unit_type(), "1.5 nm");
 376     BOOST_UNITS_TEST_OUTPUT(1.5e-8*meter_base_unit::unit_type(), "15 nm");
 377     BOOST_UNITS_TEST_OUTPUT(1.5e-10*meter_base_unit::unit_type(), "150 pm");
 378   // Too small or large for a multiple name.
 379     BOOST_UNITS_TEST_OUTPUT_REGEX(9.99999e-25 * meter_base_unit::unit_type(), "9\\.99999e-0?25 m"); // Just too small for multiple.
 380     BOOST_UNITS_TEST_OUTPUT_REGEX(1e+28 * meter_base_unit::unit_type(), "1e\\+0?28 m"); // Just too large for multiple.
 381     BOOST_UNITS_TEST_OUTPUT_REGEX(1.5e-25 * meter_base_unit::unit_type(), "1\\.5e-0?25 m"); // Too small for multiple.
 382     BOOST_UNITS_TEST_OUTPUT_REGEX(1.5e+28 * meter_base_unit::unit_type(), "1\\.5e\\+0?28 m"); // Too large for multiple.
 383   //
 384     BOOST_UNITS_TEST_OUTPUT_REGEX((std::numeric_limits<float>::max)()*meter_base_unit::unit_type(), "3\\.40282e\\+0?38 m");
 385     BOOST_UNITS_TEST_OUTPUT_REGEX((std::numeric_limits<float>::min)()*meter_base_unit::unit_type(), "1\\.17549e-0?38 m");
 386     BOOST_UNITS_TEST_OUTPUT((std::numeric_limits<double>::max)()*meter_base_unit::unit_type(), "1.79769e+308 m");
 387     BOOST_UNITS_TEST_OUTPUT((std::numeric_limits<double>::min)()*meter_base_unit::unit_type(), "2.22507e-308 m");
 388
 389     BOOST_UNITS_TEST_OUTPUT(1.5*velocity(), "1.5 m s^-1");
 390     BOOST_UNITS_TEST_OUTPUT(1.5*scaled_length(), "1.5 km");
 391     BOOST_UNITS_TEST_OUTPUT(1.5*scaled_velocity1(), "1.5 k(m s^-1)");
 392     BOOST_UNITS_TEST_OUTPUT(1.5*millisecond_base_unit::unit_type(), "1.5 ms");
 393     BOOST_UNITS_TEST_OUTPUT(1.5*scaled_time(), "1.5 ms");
 394     BOOST_UNITS_TEST_OUTPUT(1.5*scaled_velocity2(), "1.5 m ms^-1");
 395     BOOST_UNITS_TEST_OUTPUT(1.5*area(), "1.5 m^2");
 396     BOOST_UNITS_TEST_OUTPUT(1.5*scaled_area(), "1.5 k(m^2)");
 397     BOOST_UNITS_TEST_OUTPUT(1.5*double_scaled_length(), "1.536 Mm"); // 1.5 * 2^10 = 1.5 * 1024 = 1.536
 398     BOOST_UNITS_TEST_OUTPUT(1.5*double_scaled_length2(), "1.5 kscm");
 399     BOOST_UNITS_TEST_OUTPUT(1.5*custom1(), "1.5 c1");
 400     BOOST_UNITS_TEST_OUTPUT(1.5*custom2(), "1.5 c2");
 401     BOOST_UNITS_TEST_OUTPUT(1.5*scaled_custom1(), "1.5 kc1");
 402     BOOST_UNITS_TEST_OUTPUT(1.5*scaled_custom2(), "1.5 kc2");
 403     BOOST_UNITS_TEST_OUTPUT(1.5*boost::units::absolute<meter_base_unit::unit_type>(), "1.5 absolute m");
 404     BOOST_UNITS_TEST_OUTPUT(std::pow(2., 10) * byte_base_unit::unit_type(), "1.024 kb");
 405
 406 #undef FORMATTERS
 407 }
 408
 409 BOOST_AUTO_TEST_CASE(test_output_auto_binary_prefixed_quantity_symbol)
 410 { // Binary prefix with symbol format.
 411 #define FORMATTERS << boost::units::symbol_format << boost::units::binary_prefix
 412     BOOST_UNITS_TEST_OUTPUT(1024 * byte_base_unit::unit_type(), "1 Kib");
 413     BOOST_UNITS_TEST_OUTPUT(std::pow(2., 20) * byte_base_unit::unit_type(), "1 Mib");
 414     BOOST_UNITS_TEST_OUTPUT(std::pow(2., 30) * byte_base_unit::unit_type(), "1 Gib");
 415     BOOST_UNITS_TEST_OUTPUT(std::pow(2., 40) * byte_base_unit::unit_type(), "1 Tib");
 416     BOOST_UNITS_TEST_OUTPUT(std::pow(2., 50) * byte_base_unit::unit_type(), "1 Pib");
 417     BOOST_UNITS_TEST_OUTPUT(std::pow(2., 60) * byte_base_unit::unit_type(), "1 Eib");
 418     BOOST_UNITS_TEST_OUTPUT(std::pow(2., 70) * byte_base_unit::unit_type(), "1 Zib");
 419     BOOST_UNITS_TEST_OUTPUT(std::pow(2., 80) * byte_base_unit::unit_type(), "1 Yib");
 420     BOOST_UNITS_TEST_OUTPUT(42, "42"); // integer scalar.
 421     BOOST_UNITS_TEST_OUTPUT(-42, "-42"); // integer scalar.
 422     BOOST_UNITS_TEST_OUTPUT(1567, "1567"); // scalars are *not* autoprefixed.
 423     BOOST_UNITS_TEST_OUTPUT(-1567, "-1567"); // scalars are *not* autoprefixed.
 424 #undef FORMATTERS
 425 }
 426
 427 BOOST_AUTO_TEST_CASE(test_output_auto_binary_prefixed_quantity_name)
 428 { // Binary prefix with name format.
 429   // http://physics.nist.gov/cuu/Units/binary.html
 430   // 1998 the International Electrotechnical Commission (IEC) approved
 431   // IEC 60027-2, Second edition, 2000-11, Letter symbols to be used in electrical technology
 432   // - Part 2: Telecommunications and electronics.
 433   // IEC 80000-13:2008, Quantities and units
 434   // - Part 13: Information science and technology
 435 #define FORMATTERS << boost::units::name_format << boost::units::binary_prefix
 436     BOOST_UNITS_TEST_OUTPUT(2048  * byte_base_unit::unit_type(), "2 kibibyte");
 437     BOOST_UNITS_TEST_OUTPUT(std::pow(2., 32) *byte_base_unit::unit_type(), "4 gibibyte");
 438     BOOST_UNITS_TEST_OUTPUT(std::pow(2., 41) *byte_base_unit::unit_type(), "2 tebibyte"); // http://en.wikipedia.org/wiki/Tebibyte
 439     BOOST_UNITS_TEST_OUTPUT(std::pow(2., 50) *byte_base_unit::unit_type(), "1 pebibyte");
 440     BOOST_UNITS_TEST_OUTPUT(std::pow(2., 60) *byte_base_unit::unit_type(), "1 exbibyte");
 441     BOOST_UNITS_TEST_OUTPUT(std::pow(2., 70) *byte_base_unit::unit_type(), "1 zebibyte");
 442     BOOST_UNITS_TEST_OUTPUT(std::pow(2., 80) *byte_base_unit::unit_type(), "1 yobibyte");
 443     BOOST_UNITS_TEST_OUTPUT(2048, "2048"); // scalars are *not* autoprefixed.
 444     BOOST_UNITS_TEST_OUTPUT(-4096, "-4096"); // scalars are *not* autoprefixed.
 445 #undef FORMATTERS
 446 }
 447
 448 // Tests on using more than one format or prefix - only the last specified should be used.
 449 // (This may indicate a programming mistake, but it is ignored).
 450 BOOST_AUTO_TEST_CASE(test_output_quantity_name_duplicate)
 451 { // Ensure that if more than one format specified, only the last is used.
 452 #define FORMATTERS << boost::units::symbol_format << boost::units::name_format
 453     BOOST_UNITS_TEST_OUTPUT(1.5*meter_base_unit::unit_type(), "1.5 meter");
 454 #undef FORMATTERS
 455 }
 456
 457 BOOST_AUTO_TEST_CASE(test_output_quantity_symbol_duplicate)
 458 { // Ensure that if more than one format specified, only the last is used.
 459 #define FORMATTERS << boost::units::name_format << boost::units::symbol_format
 460     BOOST_UNITS_TEST_OUTPUT(1.5*meter_base_unit::unit_type(), "1.5 m");
 461 #undef FORMATTERS
 462 }
 463
 464 BOOST_AUTO_TEST_CASE(test_output_auto_binary_prefixed_quantity_name_duplicate)
 465 { // Ensure that if more than one auto prefix specified, only the last is used.
 466 #define FORMATTERS << boost::units::name_format << boost::units::binary_prefix << boost::units::engineering_prefix
 467     BOOST_UNITS_TEST_OUTPUT(2048 * byte_base_unit::unit_type(), "2.048 kilobyte");
 468 #undef FORMATTERS
 469 }
 470
 471 BOOST_AUTO_TEST_CASE(test_output_auto_binary_prefixed_quantity_symbol_duplicate)
 472 { // Ensure that if more than one auto prefix specified, only the last is used.
 473 #define FORMATTERS << boost::units::symbol_format << boost::units::engineering_prefix << boost::units::binary_prefix
 474     BOOST_UNITS_TEST_OUTPUT(2048 * byte_base_unit::unit_type(), "2 Kib");
 475 #undef FORMATTERS
 476 }
 477
 478 BOOST_AUTO_TEST_CASE(test_output_typename_format)
 479 {  // Displays typename formatting result. The test doesn't check the formatting result
 480    // and thus doesn't fail because the formatting result is platform-dependent.
 481 #define FORMATTERS << boost::units::typename_format
 482     BOOST_UNITS_TEST_OUTPUT_DISPLAY(meter_base_unit::unit_type());
 483     BOOST_UNITS_TEST_OUTPUT_DISPLAY(velocity());
 484     BOOST_UNITS_TEST_OUTPUT_DISPLAY(scaled_length());
 485     BOOST_UNITS_TEST_OUTPUT_DISPLAY(scaled_velocity1());
 486     BOOST_UNITS_TEST_OUTPUT_DISPLAY(millisecond_base_unit::unit_type());
 487     BOOST_UNITS_TEST_OUTPUT_DISPLAY(scaled_time());
 488     BOOST_UNITS_TEST_OUTPUT_DISPLAY(scaled_velocity2());
 489     BOOST_UNITS_TEST_OUTPUT_DISPLAY(area());
 490     BOOST_UNITS_TEST_OUTPUT_DISPLAY(scaled_area());
 491     BOOST_UNITS_TEST_OUTPUT_DISPLAY(double_scaled_length());
 492     BOOST_UNITS_TEST_OUTPUT_DISPLAY(double_scaled_length2());
 493     BOOST_UNITS_TEST_OUTPUT_DISPLAY(custom1());
 494     BOOST_UNITS_TEST_OUTPUT_DISPLAY(custom2());
 495     BOOST_UNITS_TEST_OUTPUT_DISPLAY(scaled_custom1());
 496     BOOST_UNITS_TEST_OUTPUT_DISPLAY(scaled_custom2());
 497     BOOST_UNITS_TEST_OUTPUT_DISPLAY(boost::units::absolute<meter_base_unit::unit_type>());
 498 #undef FORMATTERS
 499 }