389 lines
13 KiB
C++
389 lines
13 KiB
C++
/**
|
|
* @file llsingleton_test.cpp
|
|
* @date 2011-08-11
|
|
* @brief Unit test for the LLSingleton class
|
|
*
|
|
* $LicenseInfo:firstyear=2011&license=viewerlgpl$
|
|
* Second Life Viewer Source Code
|
|
* Copyright (C) 2011, Linden Research, Inc.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation;
|
|
* version 2.1 of the License only.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*
|
|
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
|
|
* $/LicenseInfo$
|
|
*/
|
|
|
|
#include "linden_common.h"
|
|
|
|
#include "llunits.h"
|
|
#include "../test/lltut.h"
|
|
|
|
namespace LLUnits
|
|
{
|
|
// using powers of 2 to allow strict floating point equality
|
|
LL_DECLARE_BASE_UNIT(Quatloos, "Quat");
|
|
LL_DECLARE_DERIVED_UNIT(Latinum, "Lat", Quatloos, / 4);
|
|
LL_DECLARE_DERIVED_UNIT(Solari, "Sol", Latinum, * 16);
|
|
}
|
|
|
|
LL_DECLARE_UNIT_TYPEDEFS(LLUnits, Quatloos);
|
|
LL_DECLARE_UNIT_TYPEDEFS(LLUnits, Latinum);
|
|
LL_DECLARE_UNIT_TYPEDEFS(LLUnits, Solari);
|
|
|
|
namespace LLUnits
|
|
{
|
|
LL_DECLARE_BASE_UNIT(Celcius, "c");
|
|
LL_DECLARE_DERIVED_UNIT(Fahrenheit, "f", Celcius, * 9 / 5 + 32);
|
|
LL_DECLARE_DERIVED_UNIT(Kelvin, "k", Celcius, + 273.15f);
|
|
}
|
|
|
|
LL_DECLARE_UNIT_TYPEDEFS(LLUnits, Celcius);
|
|
LL_DECLARE_UNIT_TYPEDEFS(LLUnits, Fahrenheit);
|
|
LL_DECLARE_UNIT_TYPEDEFS(LLUnits, Kelvin);
|
|
|
|
|
|
namespace tut
|
|
{
|
|
using namespace LLUnits;
|
|
struct units
|
|
{
|
|
};
|
|
|
|
typedef test_group<units> units_t;
|
|
typedef units_t::object units_object_t;
|
|
tut::units_t tut_singleton("LLUnit");
|
|
|
|
// storage type conversions
|
|
template<> template<>
|
|
void units_object_t::test<1>()
|
|
{
|
|
LLUnit<F32, Quatloos> float_quatloos;
|
|
ensure("default float unit is zero", float_quatloos == F32Quatloos(0.f));
|
|
|
|
LLUnit<F32, Quatloos> float_initialize_quatloos(1);
|
|
ensure("non-zero initialized unit", float_initialize_quatloos == F32Quatloos(1.f));
|
|
|
|
LLUnit<S32, Quatloos> int_quatloos;
|
|
ensure("default int unit is zero", int_quatloos == S32Quatloos(0));
|
|
|
|
int_quatloos = S32Quatloos(42);
|
|
ensure("int assignment is preserved", int_quatloos == S32Quatloos(42));
|
|
float_quatloos = int_quatloos;
|
|
ensure("float assignment from int preserves value", float_quatloos == F32Quatloos(42.f));
|
|
|
|
int_quatloos = float_quatloos;
|
|
ensure("int assignment from float preserves value", int_quatloos == S32Quatloos(42));
|
|
|
|
float_quatloos = F32Quatloos(42.1f);
|
|
int_quatloos = float_quatloos;
|
|
ensure("int units truncate float units on assignment", int_quatloos == S32Quatloos(42));
|
|
|
|
LLUnit<U32, Quatloos> unsigned_int_quatloos(float_quatloos);
|
|
ensure("unsigned int can be initialized from signed int", unsigned_int_quatloos == S32Quatloos(42));
|
|
|
|
S32Solari int_solari(1);
|
|
|
|
float_quatloos = int_solari;
|
|
ensure("fractional units are preserved in conversion from integer to float type", float_quatloos == F32Quatloos(0.25f));
|
|
|
|
int_quatloos = S32Quatloos(1);
|
|
F32Solari float_solari = int_quatloos;
|
|
ensure("can convert with fractional intermediates from integer to float type", float_solari == F32Solari(4.f));
|
|
}
|
|
|
|
// conversions to/from base unit
|
|
template<> template<>
|
|
void units_object_t::test<2>()
|
|
{
|
|
LLUnit<F32, Quatloos> quatloos(1.f);
|
|
LLUnit<F32, Latinum> latinum_bars(quatloos);
|
|
ensure("conversion between units is automatic via initialization", latinum_bars == F32Latinum(1.f / 4.f));
|
|
|
|
latinum_bars = S32Latinum(256);
|
|
quatloos = latinum_bars;
|
|
ensure("conversion between units is automatic via assignment, and bidirectional", quatloos == S32Quatloos(1024));
|
|
|
|
LLUnit<S32, Quatloos> single_quatloo(1);
|
|
LLUnit<F32, Latinum> quarter_latinum = single_quatloo;
|
|
ensure("division of integer unit preserves fractional values when converted to float unit", quarter_latinum == F32Latinum(0.25f));
|
|
}
|
|
|
|
// conversions across non-base units
|
|
template<> template<>
|
|
void units_object_t::test<3>()
|
|
{
|
|
LLUnit<F32, Quatloos> quatloos(1024);
|
|
LLUnit<F32, Solari> solari(quatloos);
|
|
ensure("conversions can work between indirectly related units: Quatloos -> Latinum -> Solari", solari == S32Solari(4096));
|
|
|
|
LLUnit<F32, Latinum> latinum_bars = solari;
|
|
ensure("Non base units can be converted between each other", latinum_bars == S32Latinum(256));
|
|
}
|
|
|
|
// math operations
|
|
template<> template<>
|
|
void units_object_t::test<4>()
|
|
{
|
|
// exercise math operations
|
|
LLUnit<F32, Quatloos> quatloos(1.f);
|
|
quatloos *= 4.f;
|
|
ensure(quatloos == S32Quatloos(4));
|
|
quatloos = quatloos * 2;
|
|
ensure(quatloos == S32Quatloos(8));
|
|
quatloos = 2.f * quatloos;
|
|
ensure(quatloos == S32Quatloos(16));
|
|
|
|
quatloos += F32Quatloos(4.f);
|
|
ensure(quatloos == S32Quatloos(20));
|
|
quatloos += S32Quatloos(4);
|
|
ensure(quatloos == S32Quatloos(24));
|
|
quatloos = quatloos + S32Quatloos(4);
|
|
ensure(quatloos == S32Quatloos(28));
|
|
quatloos = S32Quatloos(4) + quatloos;
|
|
ensure(quatloos == S32Quatloos(32));
|
|
quatloos += quatloos * 3;
|
|
ensure(quatloos == S32Quatloos(128));
|
|
|
|
quatloos -= quatloos / 4 * 3;
|
|
ensure(quatloos == S32Quatloos(32));
|
|
quatloos = quatloos - S32Quatloos(8);
|
|
ensure(quatloos == S32Quatloos(24));
|
|
quatloos -= S32Quatloos(4);
|
|
ensure(quatloos == S32Quatloos(20));
|
|
quatloos -= F32Quatloos(4.f);
|
|
ensure(quatloos == S32Quatloos(16));
|
|
|
|
quatloos /= 2.f;
|
|
ensure(quatloos == S32Quatloos(8));
|
|
quatloos = quatloos / 4;
|
|
ensure(quatloos == S32Quatloos(2));
|
|
|
|
F32 ratio = quatloos / LLUnit<F32, Quatloos>(2.f);
|
|
ensure(ratio == 1);
|
|
ratio = quatloos / LLUnit<F32, Solari>(8.f);
|
|
ensure(ratio == 1);
|
|
|
|
quatloos += LLUnit<F32, Solari>(8.f);
|
|
ensure(quatloos == S32Quatloos(4));
|
|
quatloos -= LLUnit<F32, Latinum>(1.f);
|
|
ensure(quatloos == S32Quatloos(0));
|
|
}
|
|
|
|
// comparison operators
|
|
template<> template<>
|
|
void units_object_t::test<5>()
|
|
{
|
|
LLUnit<S32, Quatloos> quatloos(1);
|
|
ensure("can perform less than comparison against same type", quatloos < S32Quatloos(2));
|
|
ensure("can perform less than comparison against different storage type", quatloos < F32Quatloos(2.f));
|
|
ensure("can perform less than comparison against different units", quatloos < S32Latinum(5));
|
|
ensure("can perform less than comparison against different storage type and units", quatloos < F32Latinum(5.f));
|
|
|
|
ensure("can perform greater than comparison against same type", quatloos > S32Quatloos(0));
|
|
ensure("can perform greater than comparison against different storage type", quatloos > F32Quatloos(0.f));
|
|
ensure("can perform greater than comparison against different units", quatloos > S32Latinum(0));
|
|
ensure("can perform greater than comparison against different storage type and units", quatloos > F32Latinum(0.f));
|
|
|
|
}
|
|
|
|
bool accept_explicit_quatloos(S32Quatloos q)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
bool accept_implicit_quatloos(S32Quatloos q)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// signature compatibility
|
|
template<> template<>
|
|
void units_object_t::test<6>()
|
|
{
|
|
S32Quatloos quatloos(1);
|
|
ensure("can pass unit values as argument", accept_explicit_quatloos(S32Quatloos(1)));
|
|
ensure("can pass unit values as argument", accept_explicit_quatloos(quatloos));
|
|
}
|
|
|
|
// implicit units
|
|
template<> template<>
|
|
void units_object_t::test<7>()
|
|
{
|
|
LLUnit<F32, Quatloos> quatloos;
|
|
LLUnitImplicit<F32, Quatloos> quatloos_implicit = quatloos + S32Quatloos(1);
|
|
ensure("can initialize implicit unit from explicit", quatloos_implicit == 1);
|
|
|
|
quatloos = quatloos_implicit;
|
|
ensure("can assign implicit unit to explicit unit", quatloos == S32Quatloos(1));
|
|
quatloos += quatloos_implicit;
|
|
ensure("can perform math operation using mixture of implicit and explicit units", quatloos == S32Quatloos(2));
|
|
|
|
// math operations on implicits
|
|
quatloos_implicit = 1;
|
|
ensure(quatloos_implicit == 1);
|
|
|
|
quatloos_implicit += 2;
|
|
ensure(quatloos_implicit == 3);
|
|
|
|
quatloos_implicit *= 2;
|
|
ensure(quatloos_implicit == 6);
|
|
|
|
quatloos_implicit -= 1;
|
|
ensure(quatloos_implicit == 5);
|
|
|
|
quatloos_implicit /= 5;
|
|
ensure(quatloos_implicit == 1);
|
|
|
|
quatloos_implicit = quatloos_implicit + 3 + quatloos_implicit;
|
|
ensure(quatloos_implicit == 5);
|
|
|
|
quatloos_implicit = 10 - quatloos_implicit - 1;
|
|
ensure(quatloos_implicit == 4);
|
|
|
|
quatloos_implicit = 2 * quatloos_implicit * 2;
|
|
ensure(quatloos_implicit == 16);
|
|
|
|
F32 one_half = quatloos_implicit / (quatloos_implicit * 2);
|
|
ensure(one_half == 0.5f);
|
|
|
|
// implicit conversion to POD
|
|
F32 float_val = quatloos_implicit;
|
|
ensure("implicit units convert implicitly to regular values", float_val == 16);
|
|
|
|
S32 int_val = quatloos_implicit;
|
|
ensure("implicit units convert implicitly to regular values", int_val == 16);
|
|
|
|
// conversion of implicits
|
|
LLUnitImplicit<F32, Latinum> latinum_implicit(2);
|
|
ensure("implicit units of different types are comparable", latinum_implicit * 2 == quatloos_implicit);
|
|
|
|
quatloos_implicit += F32Quatloos(10);
|
|
ensure("can add-assign explicit units", quatloos_implicit == 26);
|
|
|
|
quatloos_implicit -= F32Quatloos(10);
|
|
ensure("can subtract-assign explicit units", quatloos_implicit == 16);
|
|
|
|
// comparisons
|
|
ensure("can compare greater than implicit unit", quatloos_implicit > F32QuatloosImplicit(0.f));
|
|
ensure("can compare greater than non-implicit unit", quatloos_implicit > F32Quatloos(0.f));
|
|
ensure("can compare greater than or equal to implicit unit", quatloos_implicit >= F32QuatloosImplicit(0.f));
|
|
ensure("can compare greater than or equal to non-implicit unit", quatloos_implicit >= F32Quatloos(0.f));
|
|
ensure("can compare less than implicit unit", quatloos_implicit < F32QuatloosImplicit(20.f));
|
|
ensure("can compare less than non-implicit unit", quatloos_implicit < F32Quatloos(20.f));
|
|
ensure("can compare less than or equal to implicit unit", quatloos_implicit <= F32QuatloosImplicit(20.f));
|
|
ensure("can compare less than or equal to non-implicit unit", quatloos_implicit <= F32Quatloos(20.f));
|
|
}
|
|
|
|
// precision tests
|
|
template<> template<>
|
|
void units_object_t::test<8>()
|
|
{
|
|
U32Bytes max_bytes(U32_MAX);
|
|
S32Megabytes mega_bytes = max_bytes;
|
|
ensure("max available precision is used when converting units", mega_bytes == (S32Megabytes)4095);
|
|
|
|
mega_bytes = (S32Megabytes)-5 + (U32Megabytes)1;
|
|
ensure("can mix signed and unsigned in units addition", mega_bytes == (S32Megabytes)-4);
|
|
|
|
mega_bytes = (U32Megabytes)5 + (S32Megabytes)-1;
|
|
ensure("can mix unsigned and signed in units addition", mega_bytes == (S32Megabytes)4);
|
|
}
|
|
|
|
// default units
|
|
template<> template<>
|
|
void units_object_t::test<9>()
|
|
{
|
|
U32Gigabytes GB(1);
|
|
U32Megabytes MB(GB);
|
|
U32Kilobytes KB(GB);
|
|
U32Bytes B(GB);
|
|
|
|
ensure("GB -> MB conversion", MB.value() == 1024);
|
|
ensure("GB -> KB conversion", KB.value() == 1024 * 1024);
|
|
ensure("GB -> B conversion", B.value() == 1024 * 1024 * 1024);
|
|
|
|
KB = U32Kilobytes(1);
|
|
U32Kilobits Kb(KB);
|
|
U32Bits b(KB);
|
|
ensure("KB -> Kb conversion", Kb.value() == 8);
|
|
ensure("KB -> b conversion", b.value() == 8 * 1024);
|
|
|
|
U32Days days(1);
|
|
U32Hours hours(days);
|
|
U32Minutes minutes(days);
|
|
U32Seconds seconds(days);
|
|
U32Milliseconds ms(days);
|
|
|
|
ensure("days -> hours conversion", hours.value() == 24);
|
|
ensure("days -> minutes conversion", minutes.value() == 24 * 60);
|
|
ensure("days -> seconds conversion", seconds.value() == 24 * 60 * 60);
|
|
ensure("days -> ms conversion", ms.value() == 24 * 60 * 60 * 1000);
|
|
|
|
U32Kilometers km(1);
|
|
U32Meters m(km);
|
|
U32Centimeters cm(km);
|
|
U32Millimeters mm(km);
|
|
|
|
ensure("km -> m conversion", m.value() == 1000);
|
|
ensure("km -> cm conversion", cm.value() == 1000 * 100);
|
|
ensure("km -> mm conversion", mm.value() == 1000 * 1000);
|
|
|
|
U32Gigahertz GHz(1);
|
|
U32Megahertz MHz(GHz);
|
|
U32Kilohertz KHz(GHz);
|
|
U32Hertz Hz(GHz);
|
|
|
|
ensure("GHz -> MHz conversion", MHz.value() == 1000);
|
|
ensure("GHz -> KHz conversion", KHz.value() == 1000 * 1000);
|
|
ensure("GHz -> Hz conversion", Hz.value() == 1000 * 1000 * 1000);
|
|
|
|
F32Radians rad(6.2831853071795f);
|
|
S32Degrees deg(rad);
|
|
ensure("radians -> degrees conversion", deg.value() == 360);
|
|
|
|
F32Percent percent(50);
|
|
F32Ratio ratio(percent);
|
|
ensure("percent -> ratio conversion", ratio.value() == 0.5f);
|
|
|
|
U32Kilotriangles ktris(1);
|
|
U32Triangles tris(ktris);
|
|
ensure("kilotriangles -> triangles conversion", tris.value() == 1000);
|
|
}
|
|
|
|
bool value_near(F32 value, F32 target, F32 threshold)
|
|
{
|
|
return fabsf(value - target) < threshold;
|
|
}
|
|
|
|
// linear transforms
|
|
template<> template<>
|
|
void units_object_t::test<10>()
|
|
{
|
|
F32Celcius float_celcius(100);
|
|
F32Fahrenheit float_fahrenheit(float_celcius);
|
|
ensure("floating point celcius -> fahrenheit conversion using linear transform", value_near(float_fahrenheit.value(), 212, 0.1f) );
|
|
|
|
float_celcius = float_fahrenheit;
|
|
ensure("floating point fahrenheit -> celcius conversion using linear transform (round trip)", value_near(float_celcius.value(), 100.f, 0.1f) );
|
|
|
|
S32Celcius int_celcius(100);
|
|
S32Fahrenheit int_fahrenheit(int_celcius);
|
|
ensure("integer celcius -> fahrenheit conversion using linear transform", int_fahrenheit.value() == 212);
|
|
|
|
int_celcius = int_fahrenheit;
|
|
ensure("integer fahrenheit -> celcius conversion using linear transform (round trip)", int_celcius.value() == 100);
|
|
}
|
|
}
|