merge with release

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);
+	}
+}