/**
 * @file v4coloru_test.cpp
 * @author Adroit
 * @date 2007-03
 * @brief v4coloru test cases.
 *
 * $LicenseInfo:firstyear=2007&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2010, 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 "../test/lltut.h"

#include "llsd.h"

#include "../v4coloru.h"


namespace tut
{
	struct v4coloru_data
	{
	};
	typedef test_group<v4coloru_data> v4coloru_test;
	typedef v4coloru_test::object v4coloru_object;
	tut::v4coloru_test v4coloru_testcase("v4coloru_h");

	template<> template<>
	void v4coloru_object::test<1>()
	{
		LLColor4U llcolor4u;
		ensure("1:LLColor4u:Fail to initialize ", ((0 == llcolor4u.mV[VX]) && (0 == llcolor4u.mV[VY]) && (0 == llcolor4u.mV[VZ])&& (255 == llcolor4u.mV[VW])));

		U8 r = 0x12, g = 0xFF, b = 0xAF, a = 0x23;
		LLColor4U llcolor4u1(r,g,b);
		ensure("2:LLColor4u:Fail to initialize ", ((r == llcolor4u1.mV[VX]) && (g == llcolor4u1.mV[VY]) && (b == llcolor4u1.mV[VZ])&& (255 == llcolor4u1.mV[VW])));
		
		LLColor4U llcolor4u2(r,g,b,a);
		ensure("3:LLColor4u:Fail to initialize ", ((r == llcolor4u2.mV[VX]) && (g == llcolor4u2.mV[VY]) && (b == llcolor4u2.mV[VZ])&& (a == llcolor4u2.mV[VW])));

		const U8 vec[4] = {0x12,0xFF,0xAF,0x23};
		LLColor4U llcolor4u3(vec);
		ensure("4:LLColor4u:Fail to initialize ", ((vec[0] == llcolor4u3.mV[VX]) && (vec[1] == llcolor4u3.mV[VY]) && (vec[2] == llcolor4u3.mV[VZ])&& (vec[3] == llcolor4u3.mV[VW])));		

		LLSD sd = llcolor4u3.getValue();
		LLColor4U llcolor4u4(sd);
		ensure_equals("5:LLColor4u (LLSD) Failed ", llcolor4u4, llcolor4u3);
	}
	
	template<> template<>
	void v4coloru_object::test<2>()
	{
		LLColor4U llcolor4ua(1, 2, 3, 4);
		LLSD sd = llcolor4ua.getValue();
		LLColor4U llcolor4u;
		llcolor4u.setValue(sd);
		ensure_equals("setValue(LLSD)/getValue Failed ", llcolor4u, llcolor4ua);
	}

	template<> template<>
	void v4coloru_object::test<3>()
	{
		U8 r = 0x12, g = 0xFF, b = 0xAF, a = 0x23;
		LLColor4U llcolor4u(r,g,b,a);
		llcolor4u.setToBlack();
		ensure("setToBlack:Fail to set black ", ((0 == llcolor4u.mV[VX]) && (0 == llcolor4u.mV[VY]) && (0 == llcolor4u.mV[VZ])&& (255 == llcolor4u.mV[VW])));

		llcolor4u.setToWhite();
		ensure("setToWhite:Fail to white ", ((255 == llcolor4u.mV[VX]) && (255 == llcolor4u.mV[VY]) && (255 == llcolor4u.mV[VZ])&& (255 == llcolor4u.mV[VW])));
	}
	
	template<> template<>
	void v4coloru_object::test<4>()
	{
		U8 r = 0x12, g = 0xFF, b = 0xAF, a = 0x23;
		LLColor4U llcolor4ua(r,g,b,a);
		LLSD sd = llcolor4ua.getValue();
		LLColor4U llcolor4u = (LLColor4U)sd;
		ensure_equals("Operator=(LLSD) Failed ",  llcolor4u, llcolor4ua);
	}

	template<> template<>
	void v4coloru_object::test<5>()
	{
		U8 r = 0x12, g = 0xFF, b = 0xAF, a = 0x23;
		LLColor4U llcolor4u;
		llcolor4u.setVec(r,g,b,a);
		ensure("1:setVec:Fail to set the values ", ((r == llcolor4u.mV[VX]) && (g == llcolor4u.mV[VY]) && (b == llcolor4u.mV[VZ])&& (a == llcolor4u.mV[VW])));

		llcolor4u.setToBlack();
		llcolor4u.setVec(r,g,b);
		ensure("2:setVec:Fail to set the values ", ((r == llcolor4u.mV[VX]) && (g == llcolor4u.mV[VY]) && (b == llcolor4u.mV[VZ])&& (255 == llcolor4u.mV[VW])));

		LLColor4U llcolor4u1;
		llcolor4u1.setVec(llcolor4u);
		ensure_equals("3:setVec:Fail to set the values ", llcolor4u1,llcolor4u);
		
		const U8 vec[4] = {0x12,0xFF,0xAF,0x23};
		LLColor4U llcolor4u2;
		llcolor4u2.setVec(vec);
		ensure("4:setVec:Fail to set the values ", ((vec[0] == llcolor4u2.mV[VX]) && (vec[1] == llcolor4u2.mV[VY]) && (vec[2] == llcolor4u2.mV[VZ])&& (vec[3] == llcolor4u2.mV[VW])));		
	}
	
	template<> template<>
	void v4coloru_object::test<6>()
	{
		U8 alpha = 0x12;
		LLColor4U llcolor4u;
		llcolor4u.setAlpha(alpha);
		ensure("setAlpha:Fail to set alpha value ", (alpha == llcolor4u.mV[VW]));
	}
	
	template<> template<>
	void v4coloru_object::test<7>()
	{
		U8 r = 0x12, g = 0xFF, b = 0xAF;
		LLColor4U llcolor4u(r,g,b);
		ensure("magVecSquared:Fail ", is_approx_equal(llcolor4u.magVecSquared(), (F32)(r*r + g*g + b*b)));
		ensure("magVec:Fail ", is_approx_equal(llcolor4u.magVec(), (F32) sqrt((F32) (r*r + g*g + b*b))));
	}

	template<> template<>
	void v4coloru_object::test<8>()
	{
		U8 r = 0x12, g = 0xFF, b = 0xAF;
		std::ostringstream stream1, stream2;
		LLColor4U llcolor4u1(r,g,b),llcolor4u2;
		stream1 << llcolor4u1;
		llcolor4u2.setVec(r,g,b);
		stream2 << llcolor4u2;
		ensure("operator << failed ", (stream1.str() == stream2.str()));	
	}

	template<> template<>
	void v4coloru_object::test<9>()
	{
		U8 r1 = 0x12, g1 = 0xFF, b1 = 0xAF;
		U8 r2 = 0x1C, g2 = 0x9A, b2 = 0x1B;
		LLColor4U llcolor4u1(r1,g1,b1), llcolor4u2(r2,g2,b2),llcolor4u3;
		llcolor4u3 = llcolor4u1 + llcolor4u2;
		ensure_equals(
			"1a.operator+:Fail to Add the values ",
			llcolor4u3.mV[VX],
			(U8)(r1+r2));
		ensure_equals(
			"1b.operator+:Fail to Add the values ",
			llcolor4u3.mV[VY],
			(U8)(g1+g2));
		ensure_equals(
			"1c.operator+:Fail to Add the values ",
			llcolor4u3.mV[VZ],
			(U8)(b1+b2));

		llcolor4u2 += llcolor4u1;
		ensure_equals(
			"2a.operator+=:Fail to Add the values ",
			llcolor4u2.mV[VX],
			(U8)(r1+r2));
		ensure_equals(
			"2b.operator+=:Fail to Add the values ",
			llcolor4u2.mV[VY],
			(U8)(g1+g2));
		ensure_equals(
			"2c.operator+=:Fail to Add the values ",
			llcolor4u2.mV[VZ],
			(U8)(b1+b2));
	}

	template<> template<>
	void v4coloru_object::test<10>()
	{
		U8 r1 = 0x12, g1 = 0xFF, b1 = 0xAF;
		U8 r2 = 0x1C, g2 = 0x9A, b2 = 0x1B;
		LLColor4U llcolor4u1(r1,g1,b1), llcolor4u2(r2,g2,b2),llcolor4u3;
		llcolor4u3 = llcolor4u1 - llcolor4u2;
		ensure_equals(
			"1a. operator-:Fail to Add the values ",
			llcolor4u3.mV[VX],
			(U8)(r1-r2));
		ensure_equals(
			"1b. operator-:Fail to Add the values ",
			llcolor4u3.mV[VY],
			(U8)(g1-g2));
		ensure_equals(
			"1c. operator-:Fail to Add the values ",
			llcolor4u3.mV[VZ],
			(U8)(b1-b2));

		llcolor4u1 -= llcolor4u2;
		ensure_equals(
			"2a. operator-=:Fail to Add the values ",
			llcolor4u1.mV[VX],
			(U8)(r1-r2));
		ensure_equals(
			"2b. operator-=:Fail to Add the values ",
			llcolor4u1.mV[VY],
			(U8)(g1-g2));
		ensure_equals(
			"2c. operator-=:Fail to Add the values ",
			llcolor4u1.mV[VZ],
			(U8)(b1-b2));
	}

	template<> template<>
	void v4coloru_object::test<11>()
	{
		U8 r1 = 0x12, g1 = 0xFF, b1 = 0xAF;
		U8 r2 = 0x1C, g2 = 0x9A, b2 = 0x1B;
		LLColor4U llcolor4u1(r1,g1,b1), llcolor4u2(r2,g2,b2),llcolor4u3;
		llcolor4u3 = llcolor4u1 * llcolor4u2;
		ensure_equals(
			"1a. operator*:Fail to multiply the values",
			llcolor4u3.mV[VX],
			(U8)(r1*r2));
		ensure_equals(
			"1b. operator*:Fail to multiply the values",
			llcolor4u3.mV[VY],
			(U8)(g1*g2));
		ensure_equals(
			"1c. operator*:Fail to multiply the values",
			llcolor4u3.mV[VZ],
			(U8)(b1*b2));
		
		U8 mulVal = 123;
		llcolor4u1 *= mulVal;
		ensure_equals(
			"2a. operator*=:Fail to multiply the values",
			llcolor4u1.mV[VX],
			(U8)(r1*mulVal));
		ensure_equals(
			"2b. operator*=:Fail to multiply the values",
			llcolor4u1.mV[VY],
			(U8)(g1*mulVal));
		ensure_equals(
			"2c. operator*=:Fail to multiply the values",
			llcolor4u1.mV[VZ],
			(U8)(b1*mulVal));
	}

	template<> template<>
	void v4coloru_object::test<12>()
	{
		U8 r = 0x12, g = 0xFF, b = 0xAF;
		LLColor4U llcolor4u(r,g,b),llcolor4u1;
		llcolor4u1 = llcolor4u;
		ensure("operator== failed to ensure the equality ", (llcolor4u1 == llcolor4u));	
		llcolor4u1.setToBlack();
		ensure("operator!= failed to ensure the equality ", (llcolor4u1 != llcolor4u));	
	}

	template<> template<>
	void v4coloru_object::test<13>()
	{
		U8 r = 0x12, g = 0xFF, b = 0xAF, a = 12;
		LLColor4U llcolor4u(r,g,b,a);
		U8 modVal = 45;
		llcolor4u %= modVal;
		ensure_equals("operator%=:Fail ", llcolor4u.mV[VW], (U8)(a * modVal));
	}

	template<> template<>
	void v4coloru_object::test<14>()
	{
		U8 r = 0x12, g = 0xFF, b = 0xAF, a = 12;
		LLColor4U llcolor4u1(r,g,b,a);
		std::string color("12, 23, 132, 50");
		LLColor4U::parseColor4U(color, &llcolor4u1);
		ensure("parseColor4U() failed to parse the color value ", ((12 == llcolor4u1.mV[VX]) && (23 == llcolor4u1.mV[VY]) && (132 == llcolor4u1.mV[VZ])&& (50 == llcolor4u1.mV[VW])));

		color = "12, 23, 132";
		ensure("2:parseColor4U() failed to parse the color value ",  (FALSE == LLColor4U::parseColor4U(color, &llcolor4u1)));

		color = "12";
		ensure("2:parseColor4U() failed to parse the color value ",  (FALSE == LLColor4U::parseColor4U(color, &llcolor4u1)));
	}

	template<> template<>
	void v4coloru_object::test<15>()
	{
		U8 r = 12, g = 123, b = 3, a = 2;
		LLColor4U llcolor4u(r,g,b,a),llcolor4u1;
		const F32 fVal = 3.f;
		llcolor4u1 = llcolor4u.multAll(fVal);
		ensure("multAll:Fail to multiply ", (((U8)ll_round(r * fVal) == llcolor4u1.mV[VX]) && (U8)ll_round(g * fVal) == llcolor4u1.mV[VY]
											&& ((U8)ll_round(b * fVal) == llcolor4u1.mV[VZ])&& ((U8)ll_round(a * fVal) == llcolor4u1.mV[VW])));		
	}

	template<> template<>
	void v4coloru_object::test<16>()
	{
		U8 r1 = 12, g1 = 123, b1 = 3, a1 = 2;
		U8 r2 = 23, g2 = 230, b2 = 124, a2 = 255;
		LLColor4U llcolor4u(r1,g1,b1,a1),llcolor4u1(r2,g2,b2,a2);
		llcolor4u1 = llcolor4u1.addClampMax(llcolor4u);
		ensure("1:addClampMax():Fail to add the value ",  ((r1+r2 == llcolor4u1.mV[VX]) && (255 == llcolor4u1.mV[VY]) && (b1+b2 == llcolor4u1.mV[VZ])&& (255 == llcolor4u1.mV[VW])));

		r1 = 132, g1 = 3, b1 = 3, a1 = 2;
		r2 = 123, g2 = 230, b2 = 154, a2 = 25;
		LLColor4U llcolor4u2(r1,g1,b1,a1),llcolor4u3(r2,g2,b2,a2);
		llcolor4u3 = llcolor4u3.addClampMax(llcolor4u2);
		ensure("2:addClampMax():Fail to add the value ",  ((255 == llcolor4u3.mV[VX]) && (g1+g2 == llcolor4u3.mV[VY]) && (b1+b2 == llcolor4u3.mV[VZ])&& (a1+a2 == llcolor4u3.mV[VW])));
	}

	template<> template<>
	void v4coloru_object::test<17>()
	{
		F32 r = 23.f, g = 12.32f, b = -12.3f;
		LLColor3 color3(r,g,b);
		LLColor4U llcolor4u;
		llcolor4u.setVecScaleClamp(color3);
		const S32 MAX_COLOR = 255;
		F32 color_scale_factor = MAX_COLOR/r;
		S32 r2 = ll_round(r * color_scale_factor);
		S32 g2 = ll_round(g * color_scale_factor);
		ensure("setVecScaleClamp():Fail to add the value ",  ((r2 == llcolor4u.mV[VX]) && (g2 == llcolor4u.mV[VY]) && (0 == llcolor4u.mV[VZ])&& (255 == llcolor4u.mV[VW])));
	}
}
