DEV-41085 Convert legacy tut tests into llmath integration tests. Batch 1.

6 files changed, 1949 insertions, 1 deletions

diff --git a/indra/llmath/CMakeLists.txt b/indra/llmath/CMakeLists.txt
index 2bb3800144..81ccdcdfad 100644
--- a/indra/llmath/CMakeLists.txt
+++ b/indra/llmath/CMakeLists.txt
@@ -82,7 +82,7 @@ list(APPEND llmath_SOURCE_FILES ${llmath_HEADER_FILES})
 
 add_library (llmath ${llmath_SOURCE_FILES})
 
-
+# Add tests
 include(LLAddBuildTest)
 SET(llmath_TEST_SOURCE_FILES
   # nat 2009-08-28: found this commented out and considered implementing it
@@ -91,3 +91,9 @@ SET(llmath_TEST_SOURCE_FILES
   )
 LL_ADD_PROJECT_UNIT_TESTS(llmath "${llmath_TEST_SOURCE_FILES}")
 
+set(test_libs llmath llcommon ${LLCOMMON_LIBRARIES} ${WINDOWS_LIBRARIES})
+LL_ADD_INTEGRATION_TEST(v3color v3color.cpp "${test_libs}")
+LL_ADD_INTEGRATION_TEST(v3dmath v3dmath.cpp "${test_libs}")
+LL_ADD_INTEGRATION_TEST(v4color v4color.cpp "${test_libs}")
+LL_ADD_INTEGRATION_TEST(v4coloru v4coloru.cpp "${test_libs}")
+LL_ADD_INTEGRATION_TEST(v4math v4math.cpp "${test_libs}")
diff --git a/indra/llmath/tests/v3color_test.cpp b/indra/llmath/tests/v3color_test.cpp
new file mode 100644
index 0000000000..bb6e234fd6
--- /dev/null
+++ b/indra/llmath/tests/v3color_test.cpp
@@ -0,0 +1,315 @@
+/**
+ * @file v3color_tut.cpp
+ * @author Adroit
+ * @date 2007-03
+ * @brief v3color test cases.
+ *
+ * $LicenseInfo:firstyear=2007&license=viewergpl$
+ * 
+ * Copyright (c) 2007-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+#include "../test/lltut.h"
+
+#include "../v3color.h"
+
+
+namespace tut
+{
+	struct v3color_data
+	{
+	};
+	typedef test_group<v3color_data> v3color_test;
+	typedef v3color_test::object v3color_object;
+	tut::v3color_test v3color_testcase("v3color");
+
+	template<> template<>
+	void v3color_object::test<1>()
+	{
+		LLColor3 llcolor3;
+		ensure("1:LLColor3:Fail to default-initialize ", (0.0f == llcolor3.mV[0]) && (0.0f == llcolor3.mV[1]) && (0.0f == llcolor3.mV[2]));
+		F32 r = 2.0f, g = 3.2f, b = 1.f;
+		F32 v1,v2,v3;
+		LLColor3 llcolor3a(r,g,b);
+		ensure("2:LLColor3:Fail to initialize " ,(2.0f == llcolor3a.mV[0]) && (3.2f == llcolor3a.mV[1]) && (1.f == llcolor3a.mV[2]));
+		
+		const F32 vec[3] = {2.0f, 3.2f,1.f};
+		LLColor3 llcolor3b(vec);
+		ensure("3:LLColor3:Fail to initialize " ,(2.0f == llcolor3b.mV[0]) && (3.2f == llcolor3b.mV[1]) && (1.f == llcolor3b.mV[2]));
+		const char* str = "561122";
+		LLColor3 llcolor3c(str);
+		v1 = (F32)86.0f/255.0f; // 0x56 = 86
+		v2 = (F32)17.0f/255.0f; // 0x11 = 17
+		v3 = (F32)34.0f/255.f;  // 0x22 = 34
+		ensure("4:LLColor3:Fail to initialize " , is_approx_equal(v1, llcolor3c.mV[0]) && is_approx_equal(v2, llcolor3c.mV[1]) && is_approx_equal(v3, llcolor3c.mV[2]));
+	}
+
+	template<> template<>
+	void v3color_object::test<2>()
+	{
+		LLColor3 llcolor3;
+		llcolor3.setToBlack();
+		ensure("setToBlack:Fail to set black ", ((llcolor3.mV[0] == 0.f) && (llcolor3.mV[1] == 0.f) && (llcolor3.mV[2] == 0.f)));
+		llcolor3.setToWhite();
+		ensure("setToWhite:Fail to set white  ", ((llcolor3.mV[0] == 1.f) && (llcolor3.mV[1] == 1.f) && (llcolor3.mV[2] == 1.f)));
+	}
+
+	template<> template<>
+	void v3color_object::test<3>()
+	{
+		F32 r = 2.3436212f, g = 1231.f, b = 4.7849321232f;
+		LLColor3 llcolor3, llcolor3a;
+		llcolor3.setVec(r,g,b);
+		ensure("1:setVec(r,g,b) Fail ",((r == llcolor3.mV[0]) && (g == llcolor3.mV[1]) && (b == llcolor3.mV[2])));
+		llcolor3a.setVec(llcolor3);
+		ensure_equals("2:setVec(LLColor3) Fail ", llcolor3,llcolor3a);
+		F32 vec[3] = {1.2324f, 2.45634f, .234563f};
+		llcolor3.setToBlack();
+		llcolor3.setVec(vec);
+		ensure("3:setVec(F32*) Fail ",((vec[0] == llcolor3.mV[0]) && (vec[1] == llcolor3.mV[1]) && (vec[2] == llcolor3.mV[2])));
+	}
+
+	template<> template<>
+	void v3color_object::test<4>()
+	{
+		F32 r = 2.3436212f, g = 1231.f, b = 4.7849321232f;
+		LLColor3 llcolor3(r,g,b);
+		ensure("magVecSquared:Fail ", is_approx_equal(llcolor3.magVecSquared(), (r*r + g*g + b*b)));
+		ensure("magVec:Fail ", is_approx_equal(llcolor3.magVec(), fsqrtf(r*r + g*g + b*b)));
+	}
+
+	template<> template<>
+	void v3color_object::test<5>()
+	{
+		F32 r = 2.3436212f, g = 1231.f, b = 4.7849321232f;
+		F32 val1, val2,val3;
+		LLColor3 llcolor3(r,g,b);
+		F32 vecMag = llcolor3.normVec();
+		F32 mag = fsqrtf(r*r + g*g + b*b);
+		F32 oomag = 1.f / mag;
+		val1 = r * oomag;
+		val2 = g * oomag;
+		val3 = b * oomag;
+		ensure("1:normVec failed ", (is_approx_equal(val1, llcolor3.mV[0]) && is_approx_equal(val2, llcolor3.mV[1]) && is_approx_equal(val3, llcolor3.mV[2]) && is_approx_equal(vecMag, mag)));
+		r = .000000000f, g = 0.f, b = 0.0f;
+		llcolor3.setVec(r,g,b);
+		vecMag = llcolor3.normVec();
+		ensure("2:normVec failed should be 0. ", (0. == llcolor3.mV[0] && 0. == llcolor3.mV[1] && 0. == llcolor3.mV[2] && vecMag == 0.));
+	}
+
+	template<> template<>
+	void v3color_object::test<6>()
+	{
+		F32 r = 2.3436212f, g = -1231.f, b = .7849321232f;
+		std::ostringstream stream1, stream2;
+		LLColor3 llcolor3(r,g,b),llcolor3a;
+		stream1 << llcolor3;
+		llcolor3a.setVec(r,g,b);
+		stream2 << llcolor3a;
+		ensure("operator << failed ", (stream1.str() == stream2.str()));	
+	}
+		
+	template<> template<>
+	void v3color_object::test<7>()
+	{
+		F32 r = 2.3436212f, g = -1231.f, b = .7849321232f;
+		LLColor3 llcolor3(r,g,b),llcolor3a;
+		llcolor3a = llcolor3;
+		ensure("operator == failed ", (llcolor3a == llcolor3));	
+	}
+
+	template<> template<>
+	void v3color_object::test<8>()
+	{
+		F32 r1 =1.f, g1 = 2.f,b1 = 1.2f, r2 = -2.3f, g2 = 1.11f, b2 = 1234.234f;
+		LLColor3 llcolor3(r1,g1,b1),llcolor3a(r2,g2,b2),llcolor3b;
+		llcolor3b = llcolor3 + llcolor3a ;
+		ensure("1:operator+ failed",is_approx_equal(r1+r2 ,llcolor3b.mV[0]) && is_approx_equal(g1+g2,llcolor3b.mV[1])&& is_approx_equal(b1+b2,llcolor3b.mV[2]));
+		r1 = -.235f, g1 = -24.32f, b1 = 2.13f,  r2 = -2.3f, g2 = 1.f, b2 = 34.21f;
+		llcolor3.setVec(r1,g1,b1);
+		llcolor3a.setVec(r2,g2,b2);
+		llcolor3b = llcolor3 + llcolor3a;
+		ensure("2:operator+ failed",is_approx_equal(r1+r2 ,llcolor3b.mV[0]) && is_approx_equal(g1+g2,llcolor3b.mV[1])&& is_approx_equal(b1+b2,llcolor3b.mV[2]));
+	}
+
+	template<> template<>
+	void v3color_object::test<9>()
+	{
+		F32 r1 =1.f, g1 = 2.f,b1 = 1.2f, r2 = -2.3f, g2 = 1.11f, b2 = 1234.234f;
+		LLColor3 llcolor3(r1,g1,b1),llcolor3a(r2,g2,b2),llcolor3b;
+		llcolor3b = llcolor3 - llcolor3a ;
+		ensure("1:operator- failed",is_approx_equal(r1-r2 ,llcolor3b.mV[0]) && is_approx_equal(g1-g2,llcolor3b.mV[1])&& is_approx_equal(b1-b2,llcolor3b.mV[2]));
+		r1 = -.235f, g1 = -24.32f, b1 = 2.13f,  r2 = -2.3f, g2 = 1.f, b2 = 34.21f;
+		llcolor3.setVec(r1,g1,b1);
+		llcolor3a.setVec(r2,g2,b2);
+		llcolor3b = llcolor3 - llcolor3a;
+		ensure("2:operator- failed",is_approx_equal(r1-r2 ,llcolor3b.mV[0]) && is_approx_equal(g1-g2,llcolor3b.mV[1])&& is_approx_equal(b1-b2,llcolor3b.mV[2]));
+	}
+
+	template<> template<>
+	void v3color_object::test<10>()
+	{
+		F32 r1 =1.f, g1 = 2.f,b1 = 1.2f, r2 = -2.3f, g2 = 1.11f, b2 = 1234.234f;
+		LLColor3 llcolor3(r1,g1,b1),llcolor3a(r2,g2,b2),llcolor3b;
+		llcolor3b = llcolor3 * llcolor3a;
+		ensure("1:operator* failed",is_approx_equal(r1*r2 ,llcolor3b.mV[0]) && is_approx_equal(g1*g2,llcolor3b.mV[1])&& is_approx_equal(b1*b2,llcolor3b.mV[2]));
+		llcolor3a.setToBlack();
+		F32 mulVal = 4.332f;
+		llcolor3a = llcolor3 * mulVal;
+		ensure("2:operator* failed",is_approx_equal(r1*mulVal ,llcolor3a.mV[0]) && is_approx_equal(g1*mulVal,llcolor3a.mV[1])&& is_approx_equal(b1*mulVal,llcolor3a.mV[2]));
+		llcolor3a.setToBlack();
+		llcolor3a = mulVal * llcolor3;
+		ensure("3:operator* failed",is_approx_equal(r1*mulVal ,llcolor3a.mV[0]) && is_approx_equal(g1*mulVal,llcolor3a.mV[1])&& is_approx_equal(b1*mulVal,llcolor3a.mV[2]));
+	}
+
+	template<> template<>
+	void v3color_object::test<11>()
+	{
+		F32 r = 2.3436212f, g = 1231.f, b = 4.7849321232f;
+		LLColor3 llcolor3(r,g,b),llcolor3a;
+		llcolor3a = -llcolor3;
+		ensure("operator- failed ", (-llcolor3a == llcolor3));	
+	}
+
+	template<> template<>
+	void v3color_object::test<12>()
+	{
+		F32 r = 2.3436212f, g = 1231.f, b = 4.7849321232f;
+		LLColor3 llcolor3(r,g,b),llcolor3a(r,g,b);
+		ensure_equals("1:operator== failed",llcolor3a,llcolor3);
+		r = 13.3436212f, g = -11.f, b = .7849321232f;
+		llcolor3.setVec(r,g,b);
+		llcolor3a.setVec(r,g,b);
+		ensure_equals("2:operator== failed",llcolor3a,llcolor3);
+	}
+
+	template<> template<>
+	void v3color_object::test<13>()
+	{
+		F32 r1 =1.f, g1 = 2.f,b1 = 1.2f, r2 = -2.3f, g2 = 1.11f, b2 = 1234.234f;
+		LLColor3 llcolor3(r1,g1,b1),llcolor3a(r2,g2,b2);
+		ensure("1:operator!= failed",(llcolor3 != llcolor3a));
+		llcolor3.setToBlack();
+		llcolor3a.setVec(llcolor3);
+		ensure("2:operator!= failed", ( FALSE == (llcolor3a != llcolor3)));
+	}
+
+	template<> template<>
+	void v3color_object::test<14>()
+	{
+		F32 r1 =1.f, g1 = 2.f,b1 = 1.2f, r2 = -2.3f, g2 = 1.11f, b2 = 1234.234f;
+		LLColor3 llcolor3(r1,g1,b1),llcolor3a(r2,g2,b2);
+		llcolor3a += llcolor3;
+		ensure("1:operator+= failed",is_approx_equal(r1+r2 ,llcolor3a.mV[0]) && is_approx_equal(g1+g2,llcolor3a.mV[1])&& is_approx_equal(b1+b2,llcolor3a.mV[2]));
+		llcolor3.setVec(r1,g1,b1);
+		llcolor3a.setVec(r2,g2,b2);
+		llcolor3a += llcolor3;
+		ensure("2:operator+= failed",is_approx_equal(r1+r2 ,llcolor3a.mV[0]) && is_approx_equal(g1+g2,llcolor3a.mV[1])&& is_approx_equal(b1+b2,llcolor3a.mV[2]));
+	}
+
+	template<> template<>
+	void v3color_object::test<15>()
+	{
+		F32 r1 =1.f, g1 = 2.f,b1 = 1.2f, r2 = -2.3f, g2 = 1.11f, b2 = 1234.234f;
+		LLColor3 llcolor3(r1,g1,b1),llcolor3a(r2,g2,b2);
+		llcolor3a -= llcolor3;
+		ensure("1:operator-= failed", is_approx_equal(r2-r1, llcolor3a.mV[0]));
+		ensure("2:operator-= failed", is_approx_equal(g2-g1, llcolor3a.mV[1]));
+		ensure("3:operator-= failed", is_approx_equal(b2-b1, llcolor3a.mV[2]));
+		llcolor3.setVec(r1,g1,b1);
+		llcolor3a.setVec(r2,g2,b2);
+		llcolor3a -= llcolor3;
+		ensure("4:operator-= failed", is_approx_equal(r2-r1, llcolor3a.mV[0]));
+		ensure("5:operator-= failed", is_approx_equal(g2-g1, llcolor3a.mV[1]));
+		ensure("6:operator-= failed", is_approx_equal(b2-b1, llcolor3a.mV[2]));
+	}
+	
+	template<> template<>
+	void v3color_object::test<16>()
+	{
+		F32 r1 =1.f, g1 = 2.f,b1 = 1.2f, r2 = -2.3f, g2 = 1.11f, b2 = 1234.234f;
+		LLColor3 llcolor3(r1,g1,b1),llcolor3a(r2,g2,b2);
+		llcolor3a *= llcolor3;
+		ensure("1:operator*= failed",is_approx_equal(r1*r2 ,llcolor3a.mV[0]) && is_approx_equal(g1*g2,llcolor3a.mV[1])&& is_approx_equal(b1*b2,llcolor3a.mV[2]));
+		F32 mulVal = 4.332f;
+		llcolor3 *=mulVal;
+		ensure("2:operator*= failed",is_approx_equal(r1*mulVal ,llcolor3.mV[0]) && is_approx_equal(g1*mulVal,llcolor3.mV[1])&& is_approx_equal(b1*mulVal,llcolor3.mV[2]));
+	}
+
+	template<> template<>
+	void v3color_object::test<17>()
+	{
+		F32 r = 2.3436212f, g = -1231.f, b = .7849321232f;
+		LLColor3 llcolor3(r,g,b);
+		llcolor3.clamp();
+		ensure("1:clamp:Fail to clamp " ,(1.0f == llcolor3.mV[0]) && (0.f == llcolor3.mV[1]) && (b == llcolor3.mV[2]));
+		r = -2.3436212f, g = -1231.f, b = 67.7849321232f;
+		llcolor3.setVec(r,g,b);
+		llcolor3.clamp();
+		ensure("2:clamp:Fail to clamp " ,(0.f == llcolor3.mV[0]) && (0.f == llcolor3.mV[1]) && (1.f == llcolor3.mV[2]));
+	}
+
+	template<> template<>
+	void v3color_object::test<18>()
+	{
+		F32 r1 =1.f, g1 = 2.f,b1 = 1.2f, r2 = -2.3f, g2 = 1.11f, b2 = 1234.234f;
+		F32 val = 2.3f,val1,val2,val3;
+		LLColor3 llcolor3(r1,g1,b1),llcolor3a(r2,g2,b2);
+		val1 = r1 + (r2 - r1)* val;
+		val2 = g1 + (g2 - g1)* val;
+		val3 = b1 + (b2 - b1)* val;
+		LLColor3 llcolor3b = lerp(llcolor3,llcolor3a,val);
+		ensure("lerp failed ", ((val1 ==llcolor3b.mV[0])&& (val2 ==llcolor3b.mV[1]) && (val3 ==llcolor3b.mV[2])));		
+	}
+
+	template<> template<>
+	void v3color_object::test<19>()
+	{
+		F32 r1 =1.f, g1 = 2.f,b1 = 1.2f, r2 = -2.3f, g2 = 1.11f, b2 = 1234.234f;
+		LLColor3 llcolor3(r1,g1,b1),llcolor3a(r2,g2,b2);
+		F32 val = distVec(llcolor3,llcolor3a);
+		ensure("distVec failed ", is_approx_equal(fsqrtf((r1-r2)*(r1-r2) + (g1-g2)*(g1-g2) + (b1-b2)*(b1-b2)) ,val));
+		
+		F32 val1 = distVec_squared(llcolor3,llcolor3a);
+		ensure("distVec_squared failed ", is_approx_equal(((r1-r2)*(r1-r2) + (g1-g2)*(g1-g2) + (b1-b2)*(b1-b2)) ,val1));
+	}
+
+	template<> template<>
+	void v3color_object::test<20>()
+	{
+		F32 r1 = 1.02223f, g1 = 22222.212f, b1 = 122222.00002f;
+		LLColor3 llcolor31(r1,g1,b1);
+
+		LLSD sd = llcolor31.getValue();
+		LLColor3 llcolor32;
+		llcolor32.setValue(sd);
+		ensure_equals("LLColor3::setValue/getValue failed", llcolor31, llcolor32);
+
+		LLColor3 llcolor33(sd);
+		ensure_equals("LLColor3(LLSD) failed", llcolor31, llcolor33);
+	}
+}
diff --git a/indra/llmath/tests/v3dmath_test.cpp b/indra/llmath/tests/v3dmath_test.cpp
new file mode 100644
index 0000000000..780495e53d
--- /dev/null
+++ b/indra/llmath/tests/v3dmath_test.cpp
@@ -0,0 +1,532 @@
+/**
+ * @file v3dmath_tut.cpp
+ * @author Adroit
+ * @date 2007-03
+ * @brief v3dmath test cases.
+ *
+ * $LicenseInfo:firstyear=2007&license=viewergpl$
+ * 
+ * Copyright (c) 2007-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+ 
+#include "linden_common.h"
+#include "llsd.h"
+#include "../test/lltut.h"
+
+#include "../llquaternion.h"
+#include "../m3math.h"
+#include "../v4math.h"
+#include "../v3dmath.h"
+#include "../v3dmath.h"
+
+namespace tut
+{
+	struct v3dmath_data
+	{
+	};
+	typedef test_group<v3dmath_data> v3dmath_test;
+	typedef v3dmath_test::object v3dmath_object;
+	tut::v3dmath_test v3dmath_testcase("v3dmath");
+
+	template<> template<>
+	void v3dmath_object::test<1>()
+	{
+		LLVector3d vec3D;
+		ensure("1:LLVector3d:Fail to initialize ", ((0 == vec3D.mdV[VX]) && (0 == vec3D.mdV[VY]) && (0 == vec3D.mdV[VZ])));
+		F64 x = 2.32f, y = 1.212f, z = -.12f;
+		LLVector3d vec3Da(x,y,z);
+		ensure("2:LLVector3d:Fail to initialize ", ((2.32f == vec3Da.mdV[VX]) && (1.212f == vec3Da.mdV[VY]) && (-.12f == vec3Da.mdV[VZ])));
+		const F64 vec[3] = {1.2f ,3.2f, -4.2f};
+		LLVector3d vec3Db(vec);
+		ensure("3:LLVector3d:Fail to initialize ", ((1.2f == vec3Db.mdV[VX]) && (3.2f == vec3Db.mdV[VY]) && (-4.2f == vec3Db.mdV[VZ])));
+		LLVector3 vec3((F32)x,(F32)y,(F32)z);
+		LLVector3d vec3Dc(vec3);
+		ensure_equals("4:LLVector3d Fail to initialize",vec3Da,vec3Dc);
+	}
+
+	template<> template<>
+	void v3dmath_object::test<2>()
+	{
+		S32 a = -235;
+		LLSD llsd(a);
+		LLVector3d vec3d(llsd);
+		LLSD sd = vec3d.getValue();
+		LLVector3d vec3da(sd);
+		ensure("1:getValue:Fail ", (vec3d == vec3da));
+	}
+
+	template<> template<>
+	void v3dmath_object::test<3>()
+	{
+		F64 a = 232345521.411132;
+		LLSD llsd(a);
+		LLVector3d vec3d;
+		vec3d.setValue(llsd);
+		LLSD sd = vec3d.getValue();
+		LLVector3d vec3da(sd);
+		ensure("1:setValue:Fail to initialize ", (vec3d == vec3da));
+	}
+
+	template<> template<>
+	void v3dmath_object::test<4>()
+	{
+		F64 a[3] = {222231.43222, 12345.2343, -434343.33222};
+		LLSD llsd;
+		llsd[0] = a[0];
+		llsd[1] = a[1];
+		llsd[2] = a[2];
+		LLVector3d vec3D;
+		vec3D = (LLVector3d)llsd;
+		ensure("1:operator=:Fail to initialize ", ((llsd[0].asReal()== vec3D.mdV[VX]) && (llsd[1].asReal() == vec3D.mdV[VY]) && (llsd[2].asReal() == vec3D.mdV[VZ])));
+	}
+	
+	template<> template<>
+	void v3dmath_object::test<5>()
+	{
+		F64 x = 2.32f, y = 1.212f, z = -.12f;
+		LLVector3d vec3D(x,y,z);
+		vec3D.clearVec();
+		ensure("1:clearVec:Fail to initialize ", ((0 == vec3D.mdV[VX]) && (0 == vec3D.mdV[VY]) && (0 == vec3D.mdV[VZ])));
+		vec3D.setVec(x,y,z);
+		ensure("2:setVec:Fail to initialize ", ((x == vec3D.mdV[VX]) && (y == vec3D.mdV[VY]) && (z == vec3D.mdV[VZ])));
+		vec3D.zeroVec();
+		ensure("3:zeroVec:Fail to initialize ", ((0 == vec3D.mdV[VX]) && (0 == vec3D.mdV[VY]) && (0 == vec3D.mdV[VZ])));
+		vec3D.clearVec();
+		LLVector3 vec3((F32)x,(F32)y,(F32)z);
+		vec3D.setVec(vec3);
+		ensure("4:setVec:Fail to initialize ", ((x == vec3D.mdV[VX]) && (y == vec3D.mdV[VY]) && (z == vec3D.mdV[VZ])));
+		vec3D.clearVec();
+		const F64 vec[3] = {x,y,z};
+		vec3D.setVec(vec);
+		ensure("5:setVec:Fail to initialize ", ((x == vec3D.mdV[VX]) && (y == vec3D.mdV[VY]) && (z == vec3D.mdV[VZ])));
+		LLVector3d vec3Da;
+		vec3Da.setVec(vec3D);
+		ensure_equals("6:setVec: Fail to initialize", vec3D, vec3Da);
+	}
+	
+	template<> template<>
+	void v3dmath_object::test<6>()
+	{
+		F64 x = -2.32, y = 1.212, z = -.12;
+		LLVector3d vec3D(x,y,z);
+		vec3D.abs();
+		ensure("1:abs:Fail  ", ((-x == vec3D.mdV[VX]) && (y == vec3D.mdV[VY]) && (-z == vec3D.mdV[VZ])));
+		ensure("2:isNull():Fail ", (FALSE == vec3D.isNull()));	
+		vec3D.clearVec();
+		x =.00000001, y = .000001001, z = .000001001;
+		vec3D.setVec(x,y,z);
+		ensure("3:isNull():Fail ", (TRUE == vec3D.isNull()));	
+		ensure("4:isExactlyZero():Fail ", (FALSE == vec3D.isExactlyZero()));	
+		x =.0000000, y = .00000000, z = .00000000;
+		vec3D.setVec(x,y,z);
+		ensure("5:isExactlyZero():Fail ", (TRUE == vec3D.isExactlyZero()));	
+	}
+
+	template<> template<>
+	void v3dmath_object::test<7>()
+	{
+		F64 x = -2.32, y = 1.212, z = -.12;
+		LLVector3d vec3D(x,y,z);
+		
+		ensure("1:operator [] failed",( x ==  vec3D[0]));	
+		ensure("2:operator [] failed",( y ==  vec3D[1]));
+		ensure("3:operator [] failed",( z ==  vec3D[2]));
+		vec3D.clearVec();
+		x = 23.23, y = -.2361, z = 3.25;
+		vec3D.setVec(x,y,z);
+		F64 &ref1 = vec3D[0];
+		ensure("4:operator [] failed",( ref1 ==  vec3D[0]));
+		F64 &ref2 = vec3D[1];
+		ensure("5:operator [] failed",( ref2 ==  vec3D[1]));
+		F64 &ref3 = vec3D[2];
+		ensure("6:operator [] failed",( ref3 ==  vec3D[2]));
+	}
+
+	template<> template<>
+	void v3dmath_object::test<8>()
+	{
+		F32 x = 1.f, y = 2.f, z = -1.f;
+		LLVector4 vec4(x,y,z);		
+		LLVector3d vec3D;
+		vec3D = vec4;
+		ensure("1:operator=:Fail to initialize ", ((vec4.mV[VX] == vec3D.mdV[VX]) && (vec4.mV[VY] == vec3D.mdV[VY]) && (vec4.mV[VZ] == vec3D.mdV[VZ])));
+	}
+
+	template<> template<>
+	void v3dmath_object::test<9>()
+	{
+		F64 x1 = 1.78787878, y1 = 232322.2121, z1 = -12121.121212;
+		F64 x2 = 1.2, y2 = 2.5, z2 = 1.;
+		LLVector3d vec3D(x1,y1,z1),vec3Da(x2,y2,z2),vec3Db;
+		vec3Db = vec3Da+ vec3D;
+		ensure("1:operator+:Fail to initialize ", ((x1+x2 == vec3Db.mdV[VX]) && (y1+y2 == vec3Db.mdV[VY]) && (z1+z2 == vec3Db.mdV[VZ])));
+		x1 = -2.45, y1 = 2.1, z1 = 3.0;
+		vec3D.clearVec();
+		vec3Da.clearVec();
+		vec3D.setVec(x1,y1,z1);
+		vec3Da += vec3D;
+		ensure_equals("2:operator+=: Fail to initialize", vec3Da,vec3D);
+		vec3Da += vec3D;
+		ensure("3:operator+=:Fail to initialize ", ((2*x1 == vec3Da.mdV[VX]) && (2*y1 == vec3Da.mdV[VY]) && (2*z1 == vec3Da.mdV[VZ])));
+	}
+
+	template<> template<>
+	void v3dmath_object::test<10>()
+	{
+		F64 x1 = 1., y1 = 2., z1 = -1.1;
+		F64 x2 = 1.2, y2 = 2.5, z2 = 1.;
+		LLVector3d vec3D(x1,y1,z1),vec3Da(x2,y2,z2),vec3Db;
+		vec3Db = vec3Da - vec3D;
+		ensure("1:operator-:Fail to initialize ", ((x2-x1 == vec3Db.mdV[VX]) && (y2-y1 == vec3Db.mdV[VY]) && (z2-z1 == vec3Db.mdV[VZ])));
+		x1 = -2.45, y1 = 2.1, z1 = 3.0;
+		vec3D.clearVec();
+		vec3Da.clearVec();
+		vec3D.setVec(x1,y1,z1);
+		vec3Da -=vec3D;
+		ensure("2:operator-=:Fail to initialize ", ((2.45 == vec3Da.mdV[VX]) && (-2.1 == vec3Da.mdV[VY]) && (-3.0 == vec3Da.mdV[VZ])));
+		vec3Da -= vec3D;
+		ensure("3:operator-=:Fail to initialize ", ((-2*x1 == vec3Da.mdV[VX]) && (-2*y1 == vec3Da.mdV[VY]) && (-2*z1 == vec3Da.mdV[VZ])));
+	}
+	template<> template<>
+	void v3dmath_object::test<11>()
+	{
+		F64 x1 = 1., y1 = 2., z1 = -1.1;
+		F64 x2 = 1.2, y2 = 2.5, z2 = 1.;
+		LLVector3d vec3D(x1,y1,z1),vec3Da(x2,y2,z2);
+		F64 res = vec3D * vec3Da;
+		ensure_approximately_equals(
+			"1:operator* failed",
+			res,
+			(x1*x2 + y1*y2 + z1*z2),
+			8);
+		vec3Da.clearVec();
+		F64 mulVal = 4.2;
+		vec3Da = vec3D * mulVal;
+		ensure_approximately_equals(
+			"2a:operator* failed",
+			vec3Da.mdV[VX],
+			x1*mulVal,
+			8);
+		ensure_approximately_equals(
+			"2b:operator* failed",
+			vec3Da.mdV[VY],
+			y1*mulVal,
+			8);
+		ensure_approximately_equals(
+			"2c:operator* failed",
+			vec3Da.mdV[VZ],
+			z1*mulVal,
+			8);
+		vec3Da.clearVec();
+		vec3Da = mulVal * vec3D;
+		ensure_approximately_equals(
+			"3a:operator* failed",
+			vec3Da.mdV[VX],
+			x1*mulVal,
+			8);
+		ensure_approximately_equals(
+			"3b:operator* failed",
+			vec3Da.mdV[VY],
+			y1*mulVal,
+			8);
+		ensure_approximately_equals(
+			"3c:operator* failed",
+			vec3Da.mdV[VZ],
+			z1*mulVal,
+			8);
+		vec3D *= mulVal;
+		ensure_approximately_equals(
+			"4a:operator*= failed",
+			vec3D.mdV[VX],
+			x1*mulVal,
+			8);
+		ensure_approximately_equals(
+			"4b:operator*= failed",
+			vec3D.mdV[VY],
+			y1*mulVal,
+			8);
+		ensure_approximately_equals(
+			"4c:operator*= failed",
+			vec3D.mdV[VZ],
+			z1*mulVal,
+			8);
+	}
+
+	template<> template<>
+	void v3dmath_object::test<12>()
+	{
+		F64 x1 = 1., y1 = 2., z1 = -1.1;
+		F64 x2 = 1.2, y2 = 2.5, z2 = 1.;
+		F64 val1, val2, val3;
+		LLVector3d vec3D(x1,y1,z1),vec3Da(x2,y2,z2), vec3Db;
+		vec3Db = vec3D % vec3Da;
+		val1 = y1*z2 - y2*z1;
+		val2 = z1*x2 -z2*x1;
+		val3 = x1*y2-x2*y1;
+		ensure("1:operator% failed",(val1 == vec3Db.mdV[VX]) && (val2 == vec3Db.mdV[VY]) && (val3 == vec3Db.mdV[VZ])); 
+		vec3D %= vec3Da;
+		ensure("2:operator%= failed",
+		       is_approx_equal(vec3D.mdV[VX],vec3Db.mdV[VX]) &&
+		       is_approx_equal(vec3D.mdV[VY],vec3Db.mdV[VY]) &&
+		       is_approx_equal(vec3D.mdV[VZ],vec3Db.mdV[VZ]) ); 
+	}
+
+	template<> template<>
+	void v3dmath_object::test<13>()
+	{
+		F64 x1 = 1., y1 = 2., z1 = -1.1,div = 4.2;
+		F64 t = 1.f / div;
+		LLVector3d vec3D(x1,y1,z1), vec3Da;
+		vec3Da = vec3D/div;
+		ensure_approximately_equals(
+			"1a:operator/ failed",
+			vec3Da.mdV[VX],
+			x1*t,
+			8);
+		ensure_approximately_equals(
+			"1b:operator/ failed",
+			vec3Da.mdV[VY],
+			y1*t,
+			8);
+		ensure_approximately_equals(
+			"1c:operator/ failed",
+			vec3Da.mdV[VZ],
+			z1*t,
+			8);
+		x1 = 1.23, y1 = 4., z1 = -2.32;
+		vec3D.clearVec();
+		vec3Da.clearVec();
+		vec3D.setVec(x1,y1,z1);
+		vec3Da = vec3D/div;
+		ensure_approximately_equals(
+			"2a:operator/ failed",
+			vec3Da.mdV[VX],
+			x1*t,
+			8);
+		ensure_approximately_equals(
+			"2b:operator/ failed",
+			vec3Da.mdV[VY],
+			y1*t,
+			8);
+		ensure_approximately_equals(
+			"2c:operator/ failed",
+			vec3Da.mdV[VZ],
+			z1*t,
+			8);
+		vec3D /= div;
+		ensure_approximately_equals(
+			"3a:operator/= failed",
+			vec3D.mdV[VX],
+			x1*t,
+			8);
+		ensure_approximately_equals(
+			"3b:operator/= failed",
+			vec3D.mdV[VY],
+			y1*t,
+			8);
+		ensure_approximately_equals(
+			"3c:operator/= failed",
+			vec3D.mdV[VZ],
+			z1*t,
+			8);
+	}
+
+	template<> template<>
+	void v3dmath_object::test<14>()
+	{
+		F64 x1 = 1., y1 = 2., z1 = -1.1;
+		LLVector3d vec3D(x1,y1,z1), vec3Da;
+		ensure("1:operator!= failed",(TRUE == (vec3D !=vec3Da)));
+		vec3Da = vec3D;
+		ensure("2:operator== failed",(vec3D ==vec3Da)); 
+		vec3D.clearVec();
+		vec3Da.clearVec();
+		x1 = .211, y1 = 21.111, z1 = 23.22;
+		vec3D.setVec(x1,y1,z1);
+		vec3Da.setVec(x1,y1,z1);
+		ensure("3:operator== failed",(vec3D ==vec3Da)); 
+		ensure("4:operator!= failed",(FALSE == (vec3D !=vec3Da)));
+	}
+		
+	template<> template<>
+	void v3dmath_object::test<15>()
+	{
+		F64 x1 = 1., y1 = 2., z1 = -1.1;
+		LLVector3d vec3D(x1,y1,z1), vec3Da;
+		std::ostringstream stream1, stream2;
+		stream1 << vec3D;
+		vec3Da.setVec(x1,y1,z1);
+		stream2 << vec3Da;
+		ensure("1:operator << failed",(stream1.str() == stream2.str()));	
+	}
+
+	template<> template<>
+	void v3dmath_object::test<16>()
+	{
+		F64 x1 = 1.23, y1 = 2.0, z1 = 4.;
+		std::string buf("1.23 2. 4");
+		LLVector3d vec3D, vec3Da(x1,y1,z1);
+		LLVector3d::parseVector3d(buf, &vec3D);
+		ensure_equals("1:parseVector3d: failed " , vec3D, vec3Da);	
+	}
+
+	template<> template<>
+	void v3dmath_object::test<17>()
+	{
+		F64 x1 = 1., y1 = 2., z1 = -1.1;
+		LLVector3d vec3D(x1,y1,z1), vec3Da;
+		vec3Da = -vec3D;
+		ensure("1:operator- failed", (vec3D == - vec3Da));	
+	}
+
+	template<> template<>
+	void v3dmath_object::test<18>()
+	{
+		F64 x = 1., y = 2., z = -1.1;
+		LLVector3d vec3D(x,y,z);
+		F64 res = (x*x + y*y + z*z) - vec3D.magVecSquared();
+		ensure("1:magVecSquared:Fail ", ((-F_APPROXIMATELY_ZERO <= res)&& (res <=F_APPROXIMATELY_ZERO)));
+		res = fsqrtf(x*x + y*y + z*z) - vec3D.magVec();
+		ensure("2:magVec: Fail ", ((-F_APPROXIMATELY_ZERO <= res)&& (res <=F_APPROXIMATELY_ZERO)));	
+	}
+
+	template<> template<>
+	void v3dmath_object::test<19>()
+	{
+		F64 x = 1., y = 2., z = -1.1;
+		LLVector3d vec3D(x,y,z);
+		F64 mag = vec3D.normVec();
+		mag = 1.f/ mag;
+		ensure_approximately_equals(
+			"1a:normVec: Fail ",
+			vec3D.mdV[VX],
+			x * mag,
+			8);
+		ensure_approximately_equals(
+			"1b:normVec: Fail ",
+			vec3D.mdV[VY],
+			y * mag,
+			8);
+		ensure_approximately_equals(
+			"1c:normVec: Fail ",
+			vec3D.mdV[VZ],
+			z * mag,
+			8);
+		x = 0.000000001, y = 0.000000001, z = 0.000000001;
+		vec3D.clearVec();
+		vec3D.setVec(x,y,z);
+		mag = vec3D.normVec();
+		ensure_approximately_equals(
+			"2a:normVec: Fail ",
+			vec3D.mdV[VX],
+			x * mag,
+			8);
+		ensure_approximately_equals(
+			"2b:normVec: Fail ",
+			vec3D.mdV[VY],
+			y * mag,
+			8);
+		ensure_approximately_equals(
+			"2c:normVec: Fail ",
+			vec3D.mdV[VZ],
+			z * mag,
+			8);
+	}
+
+	template<> template<>
+	void v3dmath_object::test<20>()
+	{
+		F64 x1 = 1111.232222;
+		F64 y1 = 2222222222.22;
+		F64 z1 = 422222222222.0;
+		std::string buf("1111.232222 2222222222.22 422222222222");
+		LLVector3d vec3Da, vec3Db(x1,y1,z1);
+		LLVector3d::parseVector3d(buf, &vec3Da);
+		ensure_equals("1:parseVector3 failed", vec3Da, vec3Db);	
+	}
+
+	template<> template<>
+	void v3dmath_object::test<21>()
+	{
+		F64 x1 = 1., y1 = 2., z1 = -1.1;
+		F64 x2 = 1.2, y2 = 2.5, z2 = 1.;
+		F64 val = 2.3f,val1,val2,val3;
+		val1 = x1 + (x2 - x1)* val;
+		val2 = y1 + (y2 - y1)* val;
+		val3 = z1 + (z2 - z1)* val;
+		LLVector3d vec3Da(x1,y1,z1),vec3Db(x2,y2,z2);
+		LLVector3d vec3d = lerp(vec3Da,vec3Db,val);
+		ensure("1:lerp failed", ((val1 ==vec3d.mdV[VX])&& (val2 ==vec3d.mdV[VY]) && (val3 ==vec3d.mdV[VZ])));		
+	}
+
+	template<> template<>
+	void v3dmath_object::test<22>()
+	{
+		F64 x = 2.32, y = 1.212, z = -.12;
+		F64 min = 0.0001, max = 3.0;
+		LLVector3d vec3d(x,y,z);		
+		ensure("1:clamp:Fail ", (TRUE == (vec3d.clamp(min, max))));
+		x = 0.000001f, z = 5.3f;
+		vec3d.setVec(x,y,z);
+		ensure("2:clamp:Fail ", (TRUE == (vec3d.clamp(min, max))));
+	}
+
+	template<> template<>
+	void v3dmath_object::test<23>()
+	{
+		F64 x = 10., y = 20., z = -15.;
+		F64 epsilon = .23425;
+		LLVector3d vec3Da(x,y,z), vec3Db(x,y,z);
+		ensure("1:are_parallel: Fail ", (TRUE == are_parallel(vec3Da,vec3Db,epsilon)));
+		F64 x1 = -12., y1 = -20., z1 = -100.;
+		vec3Db.clearVec();
+		vec3Db.setVec(x1,y1,z1);
+		ensure("2:are_parallel: Fail ", (FALSE == are_parallel(vec3Da,vec3Db,epsilon)));
+	}
+
+	template<> template<>
+	void v3dmath_object::test<24>()
+	{
+#if LL_WINDOWS && _MSC_VER < 1400
+		skip("This fails on VS2003!");
+#else
+		F64 x = 10., y = 20., z = -15.;
+		F64 angle1, angle2;
+		LLVector3d vec3Da(x,y,z), vec3Db(x,y,z);
+		angle1 = angle_between(vec3Da, vec3Db);
+		ensure("1:angle_between: Fail ", (0 == angle1));
+		F64 x1 = -1., y1 = -20., z1 = -1.;
+		vec3Da.clearVec();
+		vec3Da.setVec(x1,y1,z1);
+		angle2 = angle_between(vec3Da, vec3Db);
+		vec3Db.normVec();
+		vec3Da.normVec();
+		F64 angle = vec3Db*vec3Da;
+		angle = acos(angle);
+		ensure("2:angle_between: Fail ", (angle == angle2));
+#endif
+	}
+}
diff --git a/indra/llmath/tests/v4color_test.cpp b/indra/llmath/tests/v4color_test.cpp
new file mode 100644
index 0000000000..166c9b9ff2
--- /dev/null
+++ b/indra/llmath/tests/v4color_test.cpp
@@ -0,0 +1,365 @@
+/**
+ * @file v4color_tut.cpp
+ * @author Adroit
+ * @date 2007-03
+ * @brief v4color test cases.
+ *
+ * $LicenseInfo:firstyear=2007&license=viewergpl$
+ * 
+ * Copyright (c) 2007-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+
+#include "linden_common.h"
+#include "../test/lltut.h"
+
+#include "../v4coloru.h"
+#include "llsd.h"
+#include "../v3color.h"
+#include "../v4color.h"
+
+
+namespace tut
+{
+	struct v4color_data
+	{
+	};
+	typedef test_group<v4color_data> v4color_test;
+	typedef v4color_test::object v4color_object;
+	tut::v4color_test v4color_testcase("v4color");
+
+	template<> template<>
+	void v4color_object::test<1>()
+	{
+		LLColor4 llcolor4;
+		ensure("1:LLColor4:Fail to initialize ", ((0 == llcolor4.mV[VX]) && (0 == llcolor4.mV[VY]) && (0 == llcolor4.mV[VZ])&& (1.0f == llcolor4.mV[VW])));
+
+		F32 r = 0x20, g = 0xFFFF, b = 0xFF, a = 0xAF;
+		LLColor4 llcolor4a(r,g,b);
+		ensure("2:LLColor4:Fail to initialize ", ((r == llcolor4a.mV[VX]) && (g == llcolor4a.mV[VY]) && (b == llcolor4a.mV[VZ])&& (1.0f == llcolor4a.mV[VW])));
+		
+		LLColor4 llcolor4b(r,g,b,a);
+		ensure("3:LLColor4:Fail to initialize ", ((r == llcolor4b.mV[VX]) && (g == llcolor4b.mV[VY]) && (b == llcolor4b.mV[VZ])&& (a == llcolor4b.mV[VW])));
+		
+		const F32 vec[4] = {.112f ,23.2f, -4.2f, -.0001f};
+		LLColor4 llcolor4c(vec);
+		ensure("4:LLColor4:Fail to initialize ", ((vec[0] == llcolor4c.mV[VX]) && (vec[1] == llcolor4c.mV[VY]) && (vec[2] == llcolor4c.mV[VZ])&& (vec[3] == llcolor4c.mV[VW])));		
+		
+		LLColor3 llcolor3(-2.23f,1.01f,42.3f);
+		F32 val = -.1f;
+		LLColor4 llcolor4d(llcolor3,val);
+		ensure("5:LLColor4:Fail to initialize ", ((llcolor3.mV[VX] == llcolor4d.mV[VX]) && (llcolor3.mV[VY] == llcolor4d.mV[VY]) && (llcolor3.mV[VZ] == llcolor4d.mV[VZ])&& (val == llcolor4d.mV[VW])));
+
+		LLSD sd = llcolor4d.getValue();
+		LLColor4 llcolor4e(sd);
+		ensure_equals("6:LLColor4:(LLSD) failed ", llcolor4d, llcolor4e);
+		
+		U8 r1 = 0xF2, g1 = 0xFA, b1 = 0xBF;
+		LLColor4U color4u(r1,g1,b1);
+		LLColor4 llcolor4g(color4u);
+		const F32 SCALE = 1.f/255.f;
+		F32 r2 = r1*SCALE, g2 = g1* SCALE, b2 = b1* SCALE;
+		ensure("7:LLColor4:Fail to initialize ", ((r2 == llcolor4g.mV[VX]) && (g2 == llcolor4g.mV[VY]) && (b2 == llcolor4g.mV[VZ])));
+	}
+
+	template<> template<>
+	void v4color_object::test<2>()
+	{
+		LLColor4 llcolor(1.0, 2.0, 3.0, 4.0);
+		LLSD llsd = llcolor.getValue();
+		LLColor4 llcolor4(llsd), llcolor4a;
+		llcolor4a.setValue(llsd);
+		ensure("setValue: failed", (llcolor4 == llcolor4a));
+		LLSD sd = llcolor4a.getValue();
+		LLColor4 llcolor4b(sd);
+		ensure("getValue: Failed ", (llcolor4b == llcolor4a));
+	}
+
+	template<> template<>
+	void v4color_object::test<3>()
+	{
+		F32 r = 0x20, g = 0xFFFF, b = 0xFF,a = 0xAF;
+		LLColor4 llcolor4(r,g,b,a);
+		llcolor4.setToBlack();
+		ensure("setToBlack:Fail to set the black ", ((0 == llcolor4.mV[VX]) && (0 == llcolor4.mV[VY]) && (0 == llcolor4.mV[VZ])&& (1.0f == llcolor4.mV[VW])));
+
+		llcolor4.setToWhite();
+		ensure("setToWhite:Fail to set the white ", ((1.f == llcolor4.mV[VX]) && (1.f == llcolor4.mV[VY]) && (1.f == llcolor4.mV[VZ])&& (1.0f == llcolor4.mV[VW])));
+	}
+
+	template<> template<>
+	void v4color_object::test<4>()
+	{
+		F32 r = 0x20, g = 0xFFFF, b = 0xFF, a = 0xAF;
+		LLColor4 llcolor4;
+		llcolor4.setVec(r,g,b);
+		ensure("1:setVec:Fail to set the values ", ((r == llcolor4.mV[VX]) && (g == llcolor4.mV[VY]) && (b == llcolor4.mV[VZ])&& (1.f == llcolor4.mV[VW])));
+
+		llcolor4.setVec(r,g,b,a);
+		ensure("2:setVec:Fail to set the values ", ((r == llcolor4.mV[VX]) && (g == llcolor4.mV[VY]) && (b == llcolor4.mV[VZ])&& (a == llcolor4.mV[VW])));
+
+		LLColor4 llcolor4a; 
+		llcolor4a.setVec(llcolor4);
+		ensure_equals("3:setVec:Fail to set the values ", llcolor4a,llcolor4);
+
+		LLColor3 llcolor3(-2.23f,1.01f,42.3f);
+		llcolor4a.setVec(llcolor3);
+		ensure("4:setVec:Fail to set the values ", ((llcolor3.mV[VX] == llcolor4a.mV[VX]) && (llcolor3.mV[VY] == llcolor4a.mV[VY]) && (llcolor3.mV[VZ] == llcolor4a.mV[VZ])));
+
+		F32 val = -.33f;
+		llcolor4a.setVec(llcolor3,val);
+		ensure("4:setVec:Fail to set the values ", ((llcolor3.mV[VX] == llcolor4a.mV[VX]) && (llcolor3.mV[VY] == llcolor4a.mV[VY]) && (llcolor3.mV[VZ] == llcolor4a.mV[VZ]) && (val == llcolor4a.mV[VW])));
+
+		const F32 vec[4] = {.112f ,23.2f, -4.2f, -.0001f};
+		LLColor4 llcolor4c;
+		llcolor4c.setVec(vec);
+		ensure("5:setVec:Fail to initialize ", ((vec[0] == llcolor4c.mV[VX]) && (vec[1] == llcolor4c.mV[VY]) && (vec[2] == llcolor4c.mV[VZ])&& (vec[3] == llcolor4c.mV[VW])));		
+
+		U8 r1 = 0xF2, g1 = 0xFA, b1= 0xBF;
+		LLColor4U color4u(r1,g1,b1);
+		llcolor4.setVec(color4u);
+		const F32 SCALE = 1.f/255.f;
+		F32 r2 = r1*SCALE, g2 = g1* SCALE, b2 = b1* SCALE;
+		ensure("6:setVec:Fail to initialize ", ((r2 == llcolor4.mV[VX]) && (g2 == llcolor4.mV[VY]) && (b2 == llcolor4.mV[VZ])));
+	}
+
+	template<> template<>
+	void v4color_object::test<5>()
+	{
+		F32 alpha = 0xAF;
+		LLColor4 llcolor4;
+		llcolor4.setAlpha(alpha);
+		ensure("setAlpha:Fail to initialize ", (alpha == llcolor4.mV[VW]));
+	}
+
+	template<> template<>
+	void v4color_object::test<6>()
+	{
+		F32 r = 0x20, g = 0xFFFF, b = 0xFF;
+		LLColor4 llcolor4(r,g,b);
+		ensure("magVecSquared:Fail ", is_approx_equal(llcolor4.magVecSquared(), (r*r + g*g + b*b)));
+		ensure("magVec:Fail ", is_approx_equal(llcolor4.magVec(), fsqrtf(r*r + g*g + b*b)));
+	}
+
+	template<> template<>
+	void v4color_object::test<7>()
+	{
+		F32 r = 0x20, g = 0xFFFF, b = 0xFF;
+		LLColor4 llcolor4(r,g,b);
+		F32 vecMag = llcolor4.normVec();
+		F32 mag = fsqrtf(r*r + g*g + b*b);
+		F32 oomag = 1.f / mag;
+		F32 val1 = r * oomag, val2 = g * oomag,	val3 = b * oomag;
+		ensure("1:normVec failed ", (is_approx_equal(val1, llcolor4.mV[0]) && is_approx_equal(val2, llcolor4.mV[1]) && is_approx_equal(val3, llcolor4.mV[2]) && is_approx_equal(vecMag, mag)));
+	}
+
+	template<> template<>
+	void v4color_object::test<8>()
+	{
+		LLColor4 llcolor4;
+		ensure("1:isOpaque failed ",(1 == llcolor4.isOpaque()));
+		F32 r = 0x20, g = 0xFFFF, b = 0xFF,a = 1.f;
+		llcolor4.setVec(r,g,b,a);
+		ensure("2:isOpaque failed ",(1 == llcolor4.isOpaque()));
+		a = 2.f;
+		llcolor4.setVec(r,g,b,a);
+		ensure("3:isOpaque failed ",(0 == llcolor4.isOpaque()));
+	}
+
+	template<> template<>
+	void v4color_object::test<9>()
+	{
+		F32 r = 0x20, g = 0xFFFF, b = 0xFF;
+		LLColor4 llcolor4(r,g,b);
+		ensure("1:operator [] failed",( r ==  llcolor4[0]));	
+		ensure("2:operator [] failed",( g ==  llcolor4[1]));
+		ensure("3:operator [] failed",( b ==  llcolor4[2]));
+
+		r = 0xA20, g = 0xFBFF, b = 0xFFF;
+		llcolor4.setVec(r,g,b);
+		F32 &ref1 = llcolor4[0];
+		ensure("4:operator [] failed",( ref1 ==  llcolor4[0]));
+		F32 &ref2 = llcolor4[1];
+		ensure("5:operator [] failed",( ref2 ==  llcolor4[1]));
+		F32 &ref3 = llcolor4[2];
+		ensure("6:operator [] failed",( ref3 ==  llcolor4[2]));
+	}
+
+	template<> template<>
+	void v4color_object::test<10>()
+	{
+		F32 r = 0x20, g = 0xFFFF, b = 0xFF;
+		LLColor3 llcolor3(r,g,b);
+		LLColor4 llcolor4a,llcolor4b;
+		llcolor4a = llcolor3;
+		ensure("Operator=:Fail to initialize ", ((llcolor3.mV[0] == llcolor4a.mV[VX]) && (llcolor3.mV[1] == llcolor4a.mV[VY]) && (llcolor3.mV[2] == llcolor4a.mV[VZ])));
+		LLSD sd = llcolor4a.getValue();
+		llcolor4b = sd;
+		ensure_equals("Operator= LLSD:Fail ", llcolor4a, llcolor4b);
+	}
+
+	template<> template<>
+	void v4color_object::test<11>()
+	{
+		F32 r = 0x20, g = 0xFFFF, b = 0xFF;
+		std::ostringstream stream1, stream2;
+		LLColor4 llcolor4a(r,g,b),llcolor4b;
+		stream1 << llcolor4a;
+		llcolor4b.setVec(r,g,b);
+		stream2 << llcolor4b;
+		ensure("operator << failed ", (stream1.str() == stream2.str()));	
+	}
+
+	template<> template<>
+	void v4color_object::test<12>()
+	{
+		F32 r1 = 0x20, g1 = 0xFFFF, b1 = 0xFF;
+		F32 r2 = 0xABF, g2 = 0xFB, b2 = 0xFFF;
+		LLColor4 llcolor4a(r1,g1,b1),llcolor4b(r2,g2,b2),llcolor4c;
+		llcolor4c = llcolor4b + llcolor4a;
+		ensure("operator+:Fail to Add the values ",  (is_approx_equal(r1+r2,llcolor4c.mV[VX]) && is_approx_equal(g1+g2,llcolor4c.mV[VY]) && is_approx_equal(b1+b2,llcolor4c.mV[VZ])));
+
+		llcolor4b += llcolor4a;
+		ensure("operator+=:Fail to Add the values ",  (is_approx_equal(r1+r2,llcolor4b.mV[VX]) && is_approx_equal(g1+g2,llcolor4b.mV[VY]) && is_approx_equal(b1+b2,llcolor4b.mV[VZ])));
+	}
+
+	template<> template<>
+	void v4color_object::test<13>()
+	{
+		F32 r1 = 0x20, g1 = 0xFFFF, b1 = 0xFF;
+		F32 r2 = 0xABF, g2 = 0xFB, b2 = 0xFFF;
+		LLColor4 llcolor4a(r1,g1,b1),llcolor4b(r2,g2,b2),llcolor4c;
+		llcolor4c = llcolor4a - llcolor4b;
+		ensure("operator-:Fail to subtract the values ",  (is_approx_equal(r1-r2,llcolor4c.mV[VX]) && is_approx_equal(g1-g2,llcolor4c.mV[VY]) && is_approx_equal(b1-b2,llcolor4c.mV[VZ])));
+
+		llcolor4a -= llcolor4b;
+		ensure("operator-=:Fail to subtract the values ",  (is_approx_equal(r1-r2,llcolor4a.mV[VX]) && is_approx_equal(g1-g2,llcolor4a.mV[VY]) && is_approx_equal(b1-b2,llcolor4a.mV[VZ])));
+	}
+
+	template<> template<>
+	void v4color_object::test<14>()
+	{
+		F32 r1 = 0x20, g1 = 0xFFFF, b1 = 0xFF;
+		F32 r2 = 0xABF, g2 = 0xFB, b2 = 0xFFF;
+		LLColor4 llcolor4a(r1,g1,b1),llcolor4b(r2,g2,b2),llcolor4c;
+		llcolor4c = llcolor4a * llcolor4b;
+		ensure("1:operator*:Fail to multiply the values",  (is_approx_equal(r1*r2,llcolor4c.mV[VX]) && is_approx_equal(g1*g2,llcolor4c.mV[VY]) && is_approx_equal(b1*b2,llcolor4c.mV[VZ])));
+		
+		F32 mulVal = 3.33f;
+		llcolor4c = llcolor4a * mulVal;
+		ensure("2:operator*:Fail ",  (is_approx_equal(r1*mulVal,llcolor4c.mV[VX]) && is_approx_equal(g1*mulVal,llcolor4c.mV[VY]) && is_approx_equal(b1*mulVal,llcolor4c.mV[VZ])));
+		llcolor4c = mulVal * llcolor4a;
+		ensure("3:operator*:Fail to multiply the values",  (is_approx_equal(r1*mulVal,llcolor4c.mV[VX]) && is_approx_equal(g1*mulVal,llcolor4c.mV[VY]) && is_approx_equal(b1*mulVal,llcolor4c.mV[VZ])));
+
+		llcolor4a *= mulVal;
+		ensure("4:operator*=:Fail to multiply the values ",  (is_approx_equal(r1*mulVal,llcolor4a.mV[VX]) && is_approx_equal(g1*mulVal,llcolor4a.mV[VY]) && is_approx_equal(b1*mulVal,llcolor4a.mV[VZ])));
+
+		LLColor4 llcolor4d(r1,g1,b1),llcolor4e(r2,g2,b2);
+		llcolor4e *= llcolor4d;
+		ensure("5:operator*=:Fail to multiply the values ",  (is_approx_equal(r1*r2,llcolor4e.mV[VX]) && is_approx_equal(g1*g2,llcolor4e.mV[VY]) && is_approx_equal(b1*b2,llcolor4e.mV[VZ])));
+	}
+
+	template<> template<>
+	void v4color_object::test<15>()
+	{
+		F32 r = 0x20, g = 0xFFFF, b = 0xFF,a = 0x30;
+		F32 div = 12.345f;
+		LLColor4 llcolor4a(r,g,b,a),llcolor4b;
+		llcolor4b = llcolor4a % div;//chnage only alpha value nor r,g,b;
+		ensure("1operator%:Fail ",  (is_approx_equal(r,llcolor4b.mV[VX]) && is_approx_equal(g,llcolor4b.mV[VY]) && is_approx_equal(b,llcolor4b.mV[VZ])&& is_approx_equal(div*a,llcolor4b.mV[VW])));
+		
+		llcolor4b = div % llcolor4a;
+		ensure("2operator%:Fail ",  (is_approx_equal(r,llcolor4b.mV[VX]) && is_approx_equal(g,llcolor4b.mV[VY]) && is_approx_equal(b,llcolor4b.mV[VZ])&& is_approx_equal(div*a,llcolor4b.mV[VW])));
+
+		llcolor4a %= div;
+		ensure("operator%=:Fail ",  (is_approx_equal(a*div,llcolor4a.mV[VW])));
+	}
+
+	template<> template<>
+	void v4color_object::test<16>()
+	{
+		F32 r = 0x20, g = 0xFFFF, b = 0xFF,a = 0x30;
+		LLColor4 llcolor4a(r,g,b,a),llcolor4b;
+		llcolor4b = llcolor4a;
+		ensure("1:operator== failed to ensure the equality ", (llcolor4b == llcolor4a));	
+		F32 r1 = 0x2, g1 = 0xFF, b1 = 0xFA;
+		LLColor3 llcolor3(r1,g1,b1);
+		llcolor4b = llcolor3;
+		ensure("2:operator== failed to ensure the equality ", (llcolor4b == llcolor3));	
+		ensure("2:operator!= failed to ensure the equality ", (llcolor4a != llcolor3));
+	}
+
+	template<> template<>
+	void v4color_object::test<17>()
+	{
+		F32 r = 0x20, g = 0xFFFF, b = 0xFF;
+		LLColor4 llcolor4a(r,g,b),llcolor4b;
+		LLColor3 llcolor3 = vec4to3(llcolor4a);
+		ensure("vec4to3:Fail to convert vec4 to vec3 ",  (is_approx_equal(llcolor3.mV[VX],llcolor4a.mV[VX]) && is_approx_equal(llcolor3.mV[VY],llcolor4a.mV[VY]) && is_approx_equal(llcolor3.mV[VZ],llcolor4a.mV[VZ])));
+		llcolor4b = vec3to4(llcolor3);
+		ensure_equals("vec3to4:Fail to convert vec3 to vec4 ",  llcolor4b, llcolor4a);
+	}
+
+	template<> template<>
+	void v4color_object::test<18>()
+	{
+		F32 r1 = 0x20, g1 = 0xFFFF, b1 = 0xFF, val = 0x20;
+		F32 r2 = 0xABF, g2 = 0xFB, b2 = 0xFFF;
+		LLColor4 llcolor4a(r1,g1,b1),llcolor4b(r2,g2,b2),llcolor4c;
+		llcolor4c = lerp(llcolor4a,llcolor4b,val);
+		ensure("lerp:Fail ",  (is_approx_equal(r1 + (r2 - r1)* val,llcolor4c.mV[VX]) && is_approx_equal(g1 + (g2 - g1)* val,llcolor4c.mV[VY]) && is_approx_equal(b1 + (b2 - b1)* val,llcolor4c.mV[VZ])));
+	}
+
+	template<> template<>
+	void v4color_object::test<19>()
+	{
+		F32 r = 12.0f, g = -2.3f, b = 1.32f, a = 5.0f;
+		LLColor4 llcolor4a(r,g,b,a),llcolor4b;
+		std::string color("red");
+		LLColor4::parseColor(color, &llcolor4b);
+		ensure_equals("1:parseColor() failed to parse the color value ", llcolor4b, LLColor4::red);
+
+		color = "12.0, -2.3, 1.32, 5.0";
+		LLColor4::parseColor(color, &llcolor4b);
+		llcolor4a = llcolor4a * (1.f / 255.f);
+		ensure_equals("2:parseColor() failed to parse the color value ",  llcolor4a,llcolor4b);
+
+		color = "yellow5";
+		llcolor4a.setVec(r,g,b);
+		LLColor4::parseColor(color, &llcolor4a);
+		ensure_equals("3:parseColor() failed to parse the color value ", llcolor4a, LLColor4::yellow5);
+	}
+
+	template<> template<>
+	void v4color_object::test<20>()
+	{
+		F32 r = 12.0f, g = -2.3f, b = 1.32f, a = 5.0f;
+		LLColor4 llcolor4a(r,g,b,a),llcolor4b;
+		std::string color("12.0, -2.3, 1.32, 5.0");
+		LLColor4::parseColor4(color, &llcolor4b);
+		ensure_equals("parseColor4() failed to parse the color value ",  llcolor4a, llcolor4b);
+	}
+}
diff --git a/indra/llmath/tests/v4coloru_test.cpp b/indra/llmath/tests/v4coloru_test.cpp
new file mode 100644
index 0000000000..00515893da
--- /dev/null
+++ b/indra/llmath/tests/v4coloru_test.cpp
@@ -0,0 +1,342 @@
+/**
+ * @file v4coloru_tut.cpp
+ * @author Adroit
+ * @date 2007-03
+ * @brief v4coloru test cases.
+ *
+ * $LicenseInfo:firstyear=2007&license=viewergpl$
+ * 
+ * Copyright (c) 2007-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/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");
+
+	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(), fsqrtf(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)llround(r * fVal) == llcolor4u1.mV[VX]) && (U8)llround(g * fVal) == llcolor4u1.mV[VY]
+											&& ((U8)llround(b * fVal) == llcolor4u1.mV[VZ])&& ((U8)llround(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 = llround(r * color_scale_factor);
+		S32 g2 = llround(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])));
+	}
+}
diff --git a/indra/llmath/tests/v4math_test.cpp b/indra/llmath/tests/v4math_test.cpp
new file mode 100644
index 0000000000..e020038ae5
--- /dev/null
+++ b/indra/llmath/tests/v4math_test.cpp
@@ -0,0 +1,388 @@
+/**
+ * @file v4math_tut.cpp
+ * @author Adroit
+ * @date 2007-03
+ * @brief v4math test cases.
+ *
+ * $LicenseInfo:firstyear=2007&license=viewergpl$
+ * 
+ * Copyright (c) 2007-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+ 
+#include "linden_common.h"
+#include "../test/lltut.h"
+#include "llsd.h"
+
+#include "../llquaternion.h"
+#include "../m4math.h"
+#include "../v4math.h"
+
+namespace tut
+{
+	struct v4math_data
+	{
+	};
+	typedef test_group<v4math_data> v4math_test;
+	typedef v4math_test::object v4math_object;
+	tut::v4math_test v4math_testcase("v4math");
+
+	template<> template<>
+	void v4math_object::test<1>()
+	{
+		LLVector4 vec4;
+		ensure("1:LLVector4:Fail to initialize " ,((0 == vec4.mV[VX]) && (0 == vec4.mV[VY]) && (0 == vec4.mV[VZ])&& (1.0f == vec4.mV[VW])));
+		F32 x = 10.f, y = -2.3f, z = -.023f, w = -2.0f;
+		LLVector4 vec4a(x,y,z);
+		ensure("2:LLVector4:Fail to initialize " ,((x == vec4a.mV[VX]) && (y == vec4a.mV[VY]) && (z == vec4a.mV[VZ])&& (1.0f == vec4a.mV[VW])));
+		LLVector4 vec4b(x,y,z,w);
+		ensure("3:LLVector4:Fail to initialize " ,((x == vec4b.mV[VX]) && (y == vec4b.mV[VY]) && (z == vec4b.mV[VZ])&& (w == vec4b.mV[VW])));
+		const F32 vec[4] = {.112f ,23.2f, -4.2f, -.0001f};
+		LLVector4 vec4c(vec);
+		ensure("4:LLVector4:Fail to initialize " ,((vec[0] == vec4c.mV[VX]) && (vec[1] == vec4c.mV[VY]) && (vec[2] == vec4c.mV[VZ])&& (vec[3] == vec4c.mV[VW])));
+		LLVector3 vec3(-2.23f,1.01f,42.3f);
+		LLVector4 vec4d(vec3);
+		ensure("5:LLVector4:Fail to initialize " ,((vec3.mV[VX] == vec4d.mV[VX]) && (vec3.mV[VY] == vec4d.mV[VY]) && (vec3.mV[VZ] == vec4d.mV[VZ])&& (1.f == vec4d.mV[VW])));
+		F32 w1 = -.234f;
+		LLVector4 vec4e(vec3,w1);
+		ensure("6:LLVector4:Fail to initialize " ,((vec3.mV[VX] == vec4e.mV[VX]) && (vec3.mV[VY] == vec4e.mV[VY]) && (vec3.mV[VZ] == vec4e.mV[VZ])&& (w1 == vec4e.mV[VW])));
+	}
+
+	template<> template<>
+	void v4math_object::test<2>()
+	{
+		F32 x = 10.f, y = -2.3f, z = -.023f, w = -2.0f;
+		LLVector4 vec4;
+		vec4.setVec(x,y,z);
+		ensure("1:setVec:Fail to initialize " ,((x == vec4.mV[VX]) && (y == vec4.mV[VY]) && (z == vec4.mV[VZ])&& (1.0f == vec4.mV[VW])));
+		vec4.clearVec();
+		ensure("2:clearVec:Fail " ,((0 == vec4.mV[VX]) && (0 == vec4.mV[VY]) && (0 == vec4.mV[VZ])&& (1.0f == vec4.mV[VW])));
+		vec4.setVec(x,y,z,w);
+		ensure("3:setVec:Fail to initialize " ,((x == vec4.mV[VX]) && (y == vec4.mV[VY]) && (z == vec4.mV[VZ])&& (w == vec4.mV[VW])));
+		vec4.zeroVec();
+		ensure("4:zeroVec:Fail " ,((0 == vec4.mV[VX]) && (0 == vec4.mV[VY]) && (0 == vec4.mV[VZ])&& (0 == vec4.mV[VW])));
+		LLVector3 vec3(-2.23f,1.01f,42.3f);
+		vec4.clearVec();
+		vec4.setVec(vec3);
+		ensure("5:setVec:Fail to initialize " ,((vec3.mV[VX] == vec4.mV[VX]) && (vec3.mV[VY] == vec4.mV[VY]) && (vec3.mV[VZ] == vec4.mV[VZ])&& (1.f == vec4.mV[VW])));
+		F32 w1 = -.234f;
+		vec4.zeroVec();
+		vec4.setVec(vec3,w1);
+		ensure("6:setVec:Fail to initialize " ,((vec3.mV[VX] == vec4.mV[VX]) && (vec3.mV[VY] == vec4.mV[VY]) && (vec3.mV[VZ] == vec4.mV[VZ])&& (w1 == vec4.mV[VW])));
+		const F32 vec[4] = {.112f ,23.2f, -4.2f, -.0001f};
+		LLVector4 vec4a;
+		vec4a.setVec(vec);
+		ensure("7:setVec:Fail to initialize " ,((vec[0] == vec4a.mV[VX]) && (vec[1] == vec4a.mV[VY]) && (vec[2] == vec4a.mV[VZ])&& (vec[3] == vec4a.mV[VW])));
+	}
+
+	template<> template<>
+	void v4math_object::test<3>()
+	{
+		F32 x = 10.f, y = -2.3f, z = -.023f;
+		LLVector4 vec4(x,y,z);
+		ensure("magVec:Fail ", is_approx_equal(vec4.magVec(), fsqrtf(x*x + y*y + z*z)));
+		ensure("magVecSquared:Fail ", is_approx_equal(vec4.magVecSquared(), (x*x + y*y + z*z)));
+	}
+
+	template<> template<>
+	void v4math_object::test<4>()
+	{
+		F32 x = 10.f, y = -2.3f, z = -.023f;
+		LLVector4 vec4(x,y,z);
+		F32 mag = vec4.normVec();
+		mag = 1.f/ mag;
+		ensure("1:normVec: Fail " ,is_approx_equal(mag*x,vec4.mV[VX]) && is_approx_equal(mag*y, vec4.mV[VY])&& is_approx_equal(mag*z, vec4.mV[VZ]));
+		x = 0.000000001f, y = 0.000000001f, z = 0.000000001f;
+		vec4.clearVec();
+		vec4.setVec(x,y,z);
+		mag = vec4.normVec();
+		ensure("2:normVec: Fail " ,is_approx_equal(mag*x,vec4.mV[VX]) && is_approx_equal(mag*y, vec4.mV[VY])&& is_approx_equal(mag*z, vec4.mV[VZ]));
+	}
+
+	template<> template<>
+	void v4math_object::test<5>()
+	{
+		F32 x = 10.f, y = -2.3f, z = -.023f, w = -2.0f;
+		LLVector4 vec4(x,y,z,w);
+		vec4.abs();
+		ensure("abs:Fail " ,((x == vec4.mV[VX]) && (-y == vec4.mV[VY]) && (-z == vec4.mV[VZ])&& (-w == vec4.mV[VW])));
+		vec4.clearVec();
+		ensure("isExactlyClear:Fail " ,(TRUE == vec4.isExactlyClear()));
+		vec4.zeroVec();
+		ensure("isExactlyZero:Fail " ,(TRUE == vec4.isExactlyZero()));
+	}
+
+	template<> template<>
+	void v4math_object::test<6>()
+	{
+		F32 x = 10.f, y = -2.3f, z = -.023f, w = -2.0f;
+		LLVector4 vec4(x,y,z,w),vec4a;
+		vec4a = vec4.scaleVec(vec4);
+		ensure("scaleVec:Fail " ,(is_approx_equal(x*x, vec4a.mV[VX]) && is_approx_equal(y*y, vec4a.mV[VY]) && is_approx_equal(z*z, vec4a.mV[VZ])&& is_approx_equal(w*w, vec4a.mV[VW])));
+	}
+
+	template<> template<>
+	void v4math_object::test<7>()
+	{
+		F32 x = 10.f, y = -2.3f, z = -.023f, w = -2.0f;
+		LLVector4 vec4(x,y,z,w);
+		ensure("1:operator [] failed " ,( x ==  vec4[0]));	
+		ensure("2:operator [] failed " ,( y ==  vec4[1]));
+		ensure("3:operator [] failed " ,( z ==  vec4[2]));
+		ensure("4:operator [] failed " ,( w ==  vec4[3]));
+		x = 23.f, y = -.2361f, z = 3.25;
+		vec4.setVec(x,y,z);
+		F32 &ref1 = vec4[0];
+		ensure("5:operator [] failed " ,( ref1 ==  vec4[0]));
+		F32 &ref2 = vec4[1];
+		ensure("6:operator [] failed " ,( ref2 ==  vec4[1]));
+		F32 &ref3 = vec4[2];
+		ensure("7:operator [] failed " ,( ref3 ==  vec4[2]));	
+		F32 &ref4 = vec4[3];
+		ensure("8:operator [] failed " ,( ref4 ==  vec4[3]));
+	}
+
+	template<> template<>
+	void v4math_object::test<8>()
+	{
+		F32 x = 10.f, y = -2.3f, z = -.023f, w = -2.0f;
+		const  F32 val[16] = {
+            1.f,  2.f,   3.f,    0.f,
+            .34f, .1f,   -.5f,   0.f,
+            2.f,  1.23f, 1.234f, 0.f,
+            .89f, 0.f,   0.f,    0.f
+        };
+		LLMatrix4 mat(val);
+		LLVector4 vec4(x,y,z,w),vec4a;
+		vec4.rotVec(mat);
+		vec4a.setVec(x,y,z,w);
+		vec4a.rotVec(mat);
+		ensure_equals("1:rotVec: Fail " ,vec4a, vec4);
+		F32 a = 2.32f, b = -23.2f, c = -34.1112f, d = 1.010112f;
+		LLQuaternion q(a,b,c,d);
+		LLVector4 vec4b(a,b,c,d),vec4c;
+		vec4b.rotVec(q);
+		vec4c.setVec(a, b, c, d);
+		vec4c.rotVec(q);
+		ensure_equals("2:rotVec: Fail " ,vec4b, vec4c);
+	}
+	
+	template<> template<>
+	void v4math_object::test<9>()
+	{
+		F32 x = 10.f, y = -2.3f, z = -.023f, w = -2.0f;
+		LLVector4 vec4(x,y,z,w),vec4a;;
+		std::ostringstream stream1, stream2;
+		stream1 << vec4;
+		vec4a.setVec(x,y,z,w);
+		stream2 << vec4a;
+		ensure("operator << failed",(stream1.str() == stream2.str()));	
+	}
+	
+	template<> template<>
+	void v4math_object::test<10>()
+	{
+		F32 x1 = 1.f, y1 = 2.f, z1 = -1.1f, w1 = .23f;
+		F32 x2 = 1.2f, y2 = 2.5f, z2 = 1.f, w2 = 1.3f;
+		LLVector4 vec4(x1,y1,z1,w1),vec4a(x2,y2,z2,w2),vec4b;
+		vec4b = vec4a + vec4;
+		ensure("1:operator+:Fail to initialize " ,(is_approx_equal(x1+x2,vec4b.mV[VX]) && is_approx_equal(y1+y2,vec4b.mV[VY]) && is_approx_equal(z1+z2,vec4b.mV[VZ])));
+		x1 = -2.45f, y1 = 2.1f, z1 = 3.0f;
+		vec4.clearVec();
+		vec4a.clearVec();
+		vec4.setVec(x1,y1,z1);
+		vec4a +=vec4;
+		ensure_equals("2:operator+=: Fail to initialize", vec4a,vec4);
+		vec4a += vec4;
+		ensure("3:operator+=:Fail to initialize " ,(is_approx_equal(2*x1,vec4a.mV[VX]) && is_approx_equal(2*y1,vec4a.mV[VY]) && is_approx_equal(2*z1,vec4a.mV[VZ])));
+	}
+	template<> template<>
+	void v4math_object::test<11>()
+	{
+		F32 x1 = 1.f, y1 = 2.f, z1 = -1.1f, w1 = .23f;
+		F32 x2 = 1.2f, y2 = 2.5f, z2 = 1.f, w2 = 1.3f;
+		LLVector4 vec4(x1,y1,z1,w1),vec4a(x2,y2,z2,w2),vec4b;
+		vec4b = vec4a - vec4;
+		ensure("1:operator-:Fail to initialize " ,(is_approx_equal(x2-x1,vec4b.mV[VX]) && is_approx_equal(y2-y1,vec4b.mV[VY]) && is_approx_equal(z2-z1,vec4b.mV[VZ])));
+		x1 = -2.45f, y1 = 2.1f, z1 = 3.0f;
+		vec4.clearVec();
+		vec4a.clearVec();
+		vec4.setVec(x1,y1,z1);
+		vec4a -=vec4;
+		ensure_equals("2:operator-=: Fail to initialize" , vec4a,-vec4);
+		vec4a -=vec4;
+		ensure("3:operator-=:Fail to initialize " ,(is_approx_equal(-2*x1,vec4a.mV[VX]) && is_approx_equal(-2*y1,vec4a.mV[VY]) && is_approx_equal(-2*z1,vec4a.mV[VZ])));
+	}
+
+	template<> template<>
+	void v4math_object::test<12>()
+	{
+		F32 x1 = 1.f, y1 = 2.f, z1 = -1.1f;
+		F32 x2 = 1.2f, y2 = 2.5f, z2 = 1.f;
+		LLVector4 vec4(x1,y1,z1),vec4a(x2,y2,z2);
+		F32 res = vec4 * vec4a;
+		ensure("1:operator* failed " ,is_approx_equal(res, x1*x2 + y1*y2 + z1*z2));
+		vec4a.clearVec();
+		F32 mulVal = 4.2f;
+		vec4a = vec4 * mulVal;
+		ensure("2:operator* failed " ,is_approx_equal(x1*mulVal,vec4a.mV[VX]) && is_approx_equal(y1*mulVal, vec4a.mV[VY])&& is_approx_equal(z1*mulVal, vec4a.mV[VZ]));
+		vec4a.clearVec();
+		vec4a = mulVal *  vec4 ;
+		ensure("3:operator* failed " ,is_approx_equal(x1*mulVal, vec4a.mV[VX]) && is_approx_equal(y1*mulVal, vec4a.mV[VY])&& is_approx_equal(z1*mulVal, vec4a.mV[VZ]));
+		vec4 *= mulVal;
+		ensure("4:operator*= failed " ,is_approx_equal(x1*mulVal, vec4.mV[VX]) && is_approx_equal(y1*mulVal, vec4.mV[VY])&& is_approx_equal(z1*mulVal, vec4.mV[VZ]));
+	}
+
+	template<> template<>
+	void v4math_object::test<13>()
+	{
+		F32 x1 = 1.f, y1 = 2.f, z1 = -1.1f;
+		F32 x2 = 1.2f, y2 = 2.5f, z2 = 1.f;
+		LLVector4 vec4(x1,y1,z1),vec4a(x2,y2,z2),vec4b;
+		vec4b = vec4 % vec4a;
+		ensure("1:operator% failed " ,is_approx_equal(y1*z2 - y2*z1, vec4b.mV[VX]) && is_approx_equal(z1*x2 -z2*x1, vec4b.mV[VY]) && is_approx_equal(x1*y2-x2*y1, vec4b.mV[VZ])); 
+		vec4 %= vec4a;
+		ensure_equals("operator%= failed " ,vec4,vec4b); 
+	}
+
+	template<> template<>
+	void v4math_object::test<14>()
+	{
+		F32 x = 1.f, y = 2.f, z = -1.1f,div = 4.2f;
+		F32 t = 1.f / div;
+		LLVector4 vec4(x,y,z), vec4a;
+		vec4a = vec4/div;
+		ensure("1:operator/ failed " ,is_approx_equal(x*t, vec4a.mV[VX]) && is_approx_equal(y*t, vec4a.mV[VY])&& is_approx_equal(z*t, vec4a.mV[VZ]));
+		x = 1.23f, y = 4.f, z = -2.32f;
+		vec4.clearVec();
+		vec4a.clearVec();
+		vec4.setVec(x,y,z);
+		vec4a = vec4/div;
+		ensure("2:operator/ failed " ,is_approx_equal(x*t, vec4a.mV[VX]) && is_approx_equal(y*t, vec4a.mV[VY])&& is_approx_equal(z*t, vec4a.mV[VZ]));
+		vec4 /= div;
+		ensure("3:operator/ failed " ,is_approx_equal(x*t, vec4.mV[VX]) && is_approx_equal(y*t, vec4.mV[VY])&& is_approx_equal(z*t, vec4.mV[VZ]));
+	}
+
+	template<> template<>
+	void v4math_object::test<15>()
+	{
+		F32 x = 1.f, y = 2.f, z = -1.1f;
+		LLVector4 vec4(x,y,z), vec4a;
+		ensure("operator!= failed " ,(vec4 != vec4a));
+		vec4a = vec4;
+		ensure("operator== failed " ,(vec4 ==vec4a)); 
+	}
+
+	template<> template<>
+	void v4math_object::test<16>()
+	{
+		F32 x = 1.f, y = 2.f, z = -1.1f;
+		LLVector4 vec4(x,y,z), vec4a;
+		vec4a = - vec4;
+		ensure("operator- failed " , (vec4 == - vec4a));	
+	}
+
+	template<> template<>
+	void v4math_object::test<17>()
+	{
+		F32 x = 1.f, y = 2.f, z = -1.1f,epsilon = .23425f;
+		LLVector4 vec4(x,y,z), vec4a(x,y,z);
+		ensure("1:are_parallel: Fail " ,(TRUE == are_parallel(vec4a,vec4,epsilon)));
+		x = 21.f, y = 12.f, z = -123.1f;
+		vec4a.clearVec();
+		vec4a.setVec(x,y,z);
+		ensure("2:are_parallel: Fail " ,(FALSE == are_parallel(vec4a,vec4,epsilon)));
+	}
+
+	template<> template<>
+	void v4math_object::test<18>()
+	{
+		F32 x = 1.f, y = 2.f, z = -1.1f;
+		F32 angle1, angle2;
+		LLVector4 vec4(x,y,z), vec4a(x,y,z);
+		angle1 = angle_between(vec4, vec4a);
+		vec4.normVec();
+		vec4a.normVec();
+		angle2 = acos(vec4 * vec4a);
+		ensure_approximately_equals("1:angle_between: Fail " ,angle1,angle2,8);
+		F32 x1 = 21.f, y1 = 2.23f, z1 = -1.1f;
+		LLVector4 vec4b(x,y,z), vec4c(x1,y1,z1);
+		angle1 = angle_between(vec4b, vec4c);
+		vec4b.normVec();
+		vec4c.normVec();
+		angle2 = acos(vec4b * vec4c);
+		ensure_approximately_equals("2:angle_between: Fail " ,angle1,angle2,8);
+	}
+
+	template<> template<>
+	void v4math_object::test<19>()
+	{
+		F32 x1 =-2.3f, y1 = 2.f,z1 = 1.2f, x2 = 1.3f, y2 = 1.f, z2 = 1.f;
+		F32 val1,val2;
+		LLVector4 vec4(x1,y1,z1),vec4a(x2,y2,z2);
+		val1 = dist_vec(vec4,vec4a);
+		val2 = fsqrtf((x1 - x2)*(x1 - x2) + (y1 - y2)* (y1 - y2) + (z1 - z2)* (z1 -z2));
+		ensure_equals("dist_vec: Fail ",val2, val1);
+		val1 = dist_vec_squared(vec4,vec4a);
+		val2 =((x1 - x2)*(x1 - x2) + (y1 - y2)* (y1 - y2) + (z1 - z2)* (z1 -z2));
+		ensure_equals("dist_vec_squared: Fail ",val2, val1);
+	}
+
+	template<> template<>
+	void v4math_object::test<20>()
+	{
+		F32 x1 =-2.3f, y1 = 2.f,z1 = 1.2f, w1 = -.23f, x2 = 1.3f, y2 = 1.f, z2 = 1.f,w2 = .12f;
+		F32 val = 2.3f,val1,val2,val3,val4;
+		LLVector4 vec4(x1,y1,z1,w1),vec4a(x2,y2,z2,w2);
+		val1 = x1 + (x2 - x1)* val;
+		val2 = y1 + (y2 - y1)* val;
+		val3 = z1 + (z2 - z1)* val;
+		val4 = w1 + (w2 - w1)* val;
+		LLVector4 vec4b = lerp(vec4,vec4a,val);
+		ensure("lerp failed", ((val1 ==vec4b.mV[VX])&& (val2 ==vec4b.mV[VY]) && (val3 ==vec4b.mV[VZ])&& (val4 ==vec4b.mV[VW])));	
+	}
+
+	template<> template<>
+	void v4math_object::test<21>()
+	{
+		F32 x = 1.f, y = 2.f, z = -1.1f;
+		LLVector4 vec4(x,y,z);
+		LLVector3 vec3 = vec4to3(vec4);
+		ensure("vec4to3 failed", ((x == vec3.mV[VX])&& (y == vec3.mV[VY]) && (z == vec3.mV[VZ])));	
+		LLVector4 vec4a = vec3to4(vec3);
+		ensure_equals("vec3to4 failed",vec4a,vec4);	
+	}
+
+	template<> template<>
+	void v4math_object::test<22>()
+	{
+		F32 x = 1.f, y = 2.f, z = -1.1f;
+		LLVector4 vec4(x,y,z);
+		LLSD llsd = vec4.getValue();
+		LLVector3 vec3(llsd);
+		LLVector4 vec4a = vec3to4(vec3);
+		ensure_equals("getValue failed",vec4a,vec4);	
+	}		
+}