diff options
Diffstat (limited to 'indra/llcommon/tests/llunits_test.cpp')
| -rw-r--r-- | indra/llcommon/tests/llunits_test.cpp | 219 |
1 files changed, 219 insertions, 0 deletions
diff --git a/indra/llcommon/tests/llunits_test.cpp b/indra/llcommon/tests/llunits_test.cpp new file mode 100644 index 0000000000..a5df51f6de --- /dev/null +++ b/indra/llcommon/tests/llunits_test.cpp @@ -0,0 +1,219 @@ +/** + * @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 "llunit.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); +} + +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(float_quatloos == 0.f); + + LLUnit<F32, Quatloos> float_initialize_quatloos(1); + ensure(float_initialize_quatloos == 1.f); + + LLUnit<S32, Quatloos> int_quatloos; + ensure(int_quatloos == 0); + + int_quatloos = 42; + ensure(int_quatloos == 42); + float_quatloos = int_quatloos; + ensure(float_quatloos == 42.f); + + int_quatloos = float_quatloos; + ensure(int_quatloos == 42); + + float_quatloos = 42.1f; + ensure(float_quatloos == 42.1f); + int_quatloos = float_quatloos; + ensure(int_quatloos == 42); + LLUnit<U32, Quatloos> unsigned_int_quatloos(float_quatloos); + ensure(unsigned_int_quatloos == 42); + } + + // conversions to/from base unit + template<> template<> + void units_object_t::test<2>() + { + LLUnit<F32, Quatloos> quatloos(1.f); + ensure(quatloos == 1.f); + LLUnit<F32, Latinum> latinum_bars(quatloos); + ensure(latinum_bars == 1.f / 4.f); + + latinum_bars = 256; + quatloos = latinum_bars; + ensure(quatloos == 1024); + + LLUnit<F32, Solari> solari(quatloos); + ensure(solari == 4096); + } + + // conversions across non-base units + template<> template<> + void units_object_t::test<3>() + { + LLUnit<F32, Solari> solari = 4.f; + LLUnit<F32, Latinum> latinum_bars = solari; + ensure(latinum_bars == 0.25f); + } + + // math operations + template<> template<> + void units_object_t::test<4>() + { + LLUnit<F32, Quatloos> quatloos = 1.f; + quatloos *= 4.f; + ensure(quatloos == 4); + quatloos = quatloos * 2; + ensure(quatloos == 8); + quatloos = 2.f * quatloos; + ensure(quatloos == 16); + + quatloos += 4.f; + ensure(quatloos == 20); + quatloos += 4; + ensure(quatloos == 24); + quatloos = quatloos + 4; + ensure(quatloos == 28); + quatloos = 4 + quatloos; + ensure(quatloos == 32); + quatloos += quatloos * 3; + ensure(quatloos == 128); + + quatloos -= quatloos / 4 * 3; + ensure(quatloos == 32); + quatloos = quatloos - 8; + ensure(quatloos == 24); + quatloos -= 4; + ensure(quatloos == 20); + quatloos -= 4.f; + ensure(quatloos == 16); + + quatloos *= 2.f; + ensure(quatloos == 32); + quatloos = quatloos * 2.f; + ensure(quatloos == 64); + quatloos = 0.5f * quatloos; + ensure(quatloos == 32); + + quatloos /= 2.f; + ensure(quatloos == 16); + quatloos = quatloos / 4; + ensure(quatloos == 4); + + F32 ratio = quatloos / LLUnit<F32, Quatloos>(4.f); + ensure(ratio == 1); + ratio = quatloos / LLUnit<F32, Solari>(16.f); + ensure(ratio == 1); + + quatloos += LLUnit<F32, Solari>(4.f); + ensure(quatloos == 5); + quatloos -= LLUnit<F32, Latinum>(1.f); + ensure(quatloos == 1); + } + + // implicit units + template<> template<> + void units_object_t::test<5>() + { + // 0-initialized + LLUnit<F32, Quatloos> quatloos(0); + // initialize implicit unit from explicit + LLUnitImplicit<F32, Quatloos> quatloos_implicit = quatloos + 1; + ensure(quatloos_implicit == 1); + + // assign implicit to explicit, or perform math operations + quatloos = quatloos_implicit; + ensure(quatloos == 1); + quatloos += quatloos_implicit; + ensure(quatloos == 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(float_val == 16); + + S32 int_val = quatloos_implicit; + ensure(int_val == 16); + + // conversion of implicits + LLUnitImplicit<F32, Latinum> latinum_implicit(2); + ensure(latinum_implicit == 2); + + ensure(latinum_implicit * 2 == quatloos_implicit); + } +} |