// This is an open source non-commercial project. Dear PVS-Studio, please check it.
// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
/** 
 * @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);
	}
}
