diff --git a/ANX.Framework.TestCenter/ANX.Framework.TestCenter.csproj b/ANX.Framework.TestCenter/ANX.Framework.TestCenter.csproj
index 6a74311c..fc485849 100644
--- a/ANX.Framework.TestCenter/ANX.Framework.TestCenter.csproj
+++ b/ANX.Framework.TestCenter/ANX.Framework.TestCenter.csproj
@@ -49,6 +49,7 @@
+
@@ -59,7 +60,6 @@
-
diff --git a/ANX.Framework.TestCenter/AssertHelper.cs b/ANX.Framework.TestCenter/AssertHelper.cs
new file mode 100644
index 00000000..d65ed3bc
--- /dev/null
+++ b/ANX.Framework.TestCenter/AssertHelper.cs
@@ -0,0 +1,207 @@
+#region Using Statements
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+
+#endregion // Using Statements
+
+#region License
+
+//
+// This file is part of the ANX.Framework created by the "ANX.Framework developer group".
+//
+// This file is released under the Ms-PL license.
+//
+//
+//
+// Microsoft Public License (Ms-PL)
+//
+// This license governs use of the accompanying software. If you use the software, you accept this license.
+// If you do not accept the license, do not use the software.
+//
+// 1.Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning
+// here as under U.S. copyright law.
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+//
+// 2.Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations
+// in section 3, each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to
+// reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution
+// or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in
+// section 3, each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed
+// patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution
+// in the software or derivative works of the contribution in the software.
+//
+// 3.Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, your
+// patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or
+// object code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees,
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the
+// extent permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a
+// particular purpose and non-infringement.
+
+#endregion // License
+
+using XNAColor = Microsoft.Xna.Framework.Color;
+using ANXColor = ANX.Framework.Color;
+
+using XNAVector2 = Microsoft.Xna.Framework.Vector2;
+using ANXVector2 = ANX.Framework.Vector2;
+
+using XNAVector3 = Microsoft.Xna.Framework.Vector3;
+using ANXVector3 = ANX.Framework.Vector3;
+
+using XNAVector4 = Microsoft.Xna.Framework.Vector4;
+using ANXVector4 = ANX.Framework.Vector4;
+
+using XNABoundingBox = Microsoft.Xna.Framework.BoundingBox;
+using ANXBoundingBox = ANX.Framework.BoundingBox;
+
+using XNABoundingSphere = Microsoft.Xna.Framework.BoundingSphere;
+using ANXBoundingSphere = ANX.Framework.BoundingSphere;
+
+using XNARect = Microsoft.Xna.Framework.Rectangle;
+using ANXRect = ANX.Framework.Rectangle;
+
+namespace ANX.Framework.TestCenter
+{
+ class AssertHelper
+ {
+ public static void ConvertEquals(byte a, byte b, String test)
+ {
+ if (a == b)
+ {
+ Assert.Pass(test + " passed");
+ }
+ else
+ {
+ Assert.Fail(String.Format("{0} failed: byte a: ({1}) byte b: ({2})", test, a, b));
+ }
+ }
+
+ public static void ConvertEquals(XNAColor xna, ANXColor anx, String test)
+ {
+ if (xna.R == anx.R &&
+ xna.G == anx.G &&
+ xna.B == anx.B &&
+ xna.A == anx.A)
+ {
+ Assert.Pass(test + " passed");
+ }
+ else
+ {
+ Assert.Fail(String.Format("{0} failed: xna({1}) anx({2})", test, xna.ToString(), anx.ToString()));
+ }
+ }
+
+ public static void ConvertEquals(XNAVector2 xna, ANXVector2 anx, String test)
+ {
+ //comparing string to catch "not defined" and "infinity" (which seems not to be equal)
+ if (xna.X.ToString().Equals(anx.X.ToString()) && xna.Y.ToString().Equals(anx.Y.ToString()))
+ {
+ Assert.Pass(test + " passed");
+ }
+ else
+ {
+ Assert.Fail(test + " failed: xna({" + xna.X + "}{" + xna.Y + "}) anx({" + anx.X + "}{" + anx.Y + "})");
+ }
+ }
+
+ public static void ConvertEquals(ANXVector2 xna, ANXVector2 anx, String test)
+ {
+ //comparing string to catch "not defined" and "infinity" (which seems not to be equal)
+ if (anx.X.ToString().Equals(anx.X.ToString()) && anx.Y.ToString().Equals(anx.Y.ToString()))
+ {
+ Assert.Pass(test + " passed");
+ }
+ else
+ {
+ Assert.Fail(test + " failed: anx({" + xna.X + "}{" + xna.Y + "}) compared to anx({" + anx.X + "}{" + anx.Y + "})");
+ }
+ }
+
+ public static void ConvertEquals(XNAVector3 xna, ANXVector3 anx, String test)
+ {
+ //comparing string to catch "not defined" and "infinity" (which seems not to be equal)
+ if ((xna.X == anx.X) && (xna.Y == anx.Y) && (xna.Z == anx.Z))
+ {
+ Assert.Pass(test + " passed");
+ }
+ else
+ {
+ Assert.Fail(string.Format("{0} failed: xna({1},{2},{3}) anx({4},{5},{6})", test, xna.X, xna.Y, xna.Z, anx.X, anx.Y, anx.Z));
+ }
+ }
+
+ public static void ConvertEquals(XNAVector4 xna, ANXVector4 anx, String test)
+ {
+ //comparing string to catch "not defined" and "infinity" (which seems not to be equal)
+ if ((xna.X == anx.X) && (xna.Y == anx.Y) && (xna.Z == anx.Z) && (xna.W == anx.W))
+ {
+ Assert.Pass(test + " passed");
+ }
+ else
+ {
+ Assert.Fail(string.Format("{0} failed: xna({1},{2},{3},{4}) anx({5},{6},{7},{8})", test, xna.X, xna.Y, xna.Z, xna.W, anx.X, anx.Y, anx.Z, anx.W));
+ }
+ }
+
+ public static void ConvertEquals(XNABoundingBox xna, ANXBoundingBox anx, String test)
+ {
+ if (xna.Min.X == anx.Min.X &&
+ xna.Min.Y == anx.Min.Y &&
+ xna.Min.Z == anx.Min.Z &&
+ xna.Max.X == anx.Max.X &&
+ xna.Max.Y == anx.Max.Y &&
+ xna.Max.Z == anx.Max.Z)
+ {
+ Assert.Pass(test + " passed");
+ }
+ else
+ {
+ Assert.Fail(String.Format("{0} failed: xna({1}) anx({2})", test, xna.ToString(), anx.ToString()));
+ }
+ }
+
+ public static void ConvertEquals(XNABoundingSphere xna, ANXBoundingSphere anx, String test)
+ {
+ if (xna.Center.X == anx.Center.X &&
+ xna.Center.Y == anx.Center.Y &&
+ xna.Center.Z == anx.Center.Z &&
+ xna.Radius == anx.Radius)
+ {
+ Assert.Pass(test + " passed");
+ }
+ else
+ {
+ Assert.Fail(String.Format("{0} failed: xna({1}) anx({2})", test, xna.ToString(), anx.ToString()));
+ }
+ }
+
+ public static void ConvertEquals(XNARect xna, ANXRect anx, String test)
+ {
+ //comparing string to catch "not defined" and "infinity" (which seems not to be equal)
+ if (xna.ToString().Equals(anx.ToString()))
+ {
+ Assert.Pass(test + " passed");
+ }
+ else
+ {
+ Assert.Fail(test + " failed: xna({" + xna.X + "}{" + xna.Y + "}{" + xna.Width + "}{" + xna.Height + "}) anx({" + anx.X + "}{" + anx.Y + "}{" + anx.Width + "}{" + anx.Height + "})");
+ }
+ }
+
+ }
+}
diff --git a/ANX.Framework.TestCenter/DataFactory.cs b/ANX.Framework.TestCenter/DataFactory.cs
index cd4f897b..8263a7e5 100644
--- a/ANX.Framework.TestCenter/DataFactory.cs
+++ b/ANX.Framework.TestCenter/DataFactory.cs
@@ -76,6 +76,14 @@ namespace ANX.Framework.TestCenter
return result;
}
+ public static float RandomNormalizedFloat
+ {
+ get
+ {
+ return 1.0f / MathHelper.Clamp(RandomFloat, 0f, float.MaxValue);
+ }
+ }
+
public static float RandomFloat
{
get { return (float)(r.NextDouble() * (float.MaxValue - 1) - r.NextDouble() * (float.MinValue + 1)); }
diff --git a/ANX.Framework.TestCenter/Strukturen/BoundingBoxTest.cs b/ANX.Framework.TestCenter/Strukturen/BoundingBoxTest.cs
index aa9d3b83..4c57229f 100644
--- a/ANX.Framework.TestCenter/Strukturen/BoundingBoxTest.cs
+++ b/ANX.Framework.TestCenter/Strukturen/BoundingBoxTest.cs
@@ -65,79 +65,56 @@ namespace ANX.Framework.TestCenter.Strukturen
class BoundingBoxTest
{
#region Helper
- private static Random r = new Random();
-
- public static float RandomFloat
- {
- get { return (float)(r.NextDouble()); }
- }
-
static object[] sixfloat =
{
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
};
static object[] ninefloat =
{
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
};
static object[] tenfloat =
{
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
};
static object[] twelvefloat =
{
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
};
static object[] twentytwofloat =
{
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat,
- RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat,
- RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat,
- RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat,
- RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat,
- RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat,
+ DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat,
+ DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat,
+ DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat,
+ DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat,
+ DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
};
- private void ConvertEquals(XNABoundingBox xna, ANXBoundingBox anx, String test)
- {
- if (xna.Min.X == anx.Min.X &&
- xna.Min.Y == anx.Min.Y &&
- xna.Min.Z == anx.Min.Z &&
- xna.Max.X == anx.Max.X &&
- xna.Max.Y == anx.Max.Y &&
- xna.Max.Z == anx.Max.Z)
- {
- Assert.Pass(test + " passed");
- }
- else
- {
- Assert.Fail(String.Format("{0} failed: xna({1}) anx({2})", test, xna.ToString(), anx.ToString()));
- }
- }
#endregion
#region Constructors
@@ -148,7 +125,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXBoundingBox anx = new ANXBoundingBox();
- ConvertEquals(xna, anx, "constructor0");
+ AssertHelper.ConvertEquals(xna, anx, "constructor0");
}
[Test, TestCaseSource("sixfloat")]
@@ -158,7 +135,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXBoundingBox anx = new ANXBoundingBox(new ANXVector3(xMin, yMin, zMin), new ANXVector3(xMax, yMax, zMax));
- ConvertEquals(xna, anx, "constructor0");
+ AssertHelper.ConvertEquals(xna, anx, "constructor0");
}
#endregion
@@ -259,7 +236,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNABoundingBox xna = XNABoundingBox.CreateFromPoints(pointsXNA);
ANXBoundingBox anx = ANXBoundingBox.CreateFromPoints(pointsANX);
- ConvertEquals(xna, anx, "CreateFromPointsStatic");
+ AssertHelper.ConvertEquals(xna, anx, "CreateFromPointsStatic");
}
[Test, TestCaseSource("ninefloat")]
@@ -276,7 +253,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNABoundingBox xna = XNABoundingBox.CreateFromSphere(xnaSphere);
ANXBoundingBox anx = ANXBoundingBox.CreateFromSphere(anxSphere);
- ConvertEquals(xna, anx, "CreateFromSphereStatic");
+ AssertHelper.ConvertEquals(xna, anx, "CreateFromSphereStatic");
}
[Test, TestCaseSource("twelvefloat")]
@@ -293,7 +270,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNABoundingBox xna = XNABoundingBox.CreateMerged(xnaBox1, xnaBox2);
ANXBoundingBox anx = ANXBoundingBox.CreateMerged(anxBox1, anxBox2);
- ConvertEquals(xna, anx, "CreateMergedStatic");
+ AssertHelper.ConvertEquals(xna, anx, "CreateMergedStatic");
}
[Test, TestCaseSource("sixfloat")]
diff --git a/ANX.Framework.TestCenter/Strukturen/BoundingSphereTest.cs b/ANX.Framework.TestCenter/Strukturen/BoundingSphereTest.cs
index 44194399..56fbdb9b 100644
--- a/ANX.Framework.TestCenter/Strukturen/BoundingSphereTest.cs
+++ b/ANX.Framework.TestCenter/Strukturen/BoundingSphereTest.cs
@@ -65,68 +65,47 @@ namespace ANX.Framework.TestCenter.Strukturen
class BoundingSphereTest
{
#region Helper
- private static Random r = new Random();
-
- public static float RandomFloat
- {
- get { return (float)(r.NextDouble()); }
- }
-
static object[] fourfloat =
{
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
};
static object[] eightfloat =
{
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
};
static object[] tenfloat =
{
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
};
static object[] twentyfloat =
{
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat,
- RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat,
- RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat,
- RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat,
- RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat,
- RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat,
+ DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat,
+ DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat,
+ DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat,
+ DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat,
+ DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
};
- private void ConvertEquals(XNABoundingSphere xna, ANXBoundingSphere anx, String test)
- {
- if (xna.Center.X == anx.Center.X &&
- xna.Center.Y == anx.Center.Y &&
- xna.Center.Z == anx.Center.Z &&
- xna.Radius == anx.Radius)
- {
- Assert.Pass(test + " passed");
- }
- else
- {
- Assert.Fail(String.Format("{0} failed: xna({1}) anx({2})", test, xna.ToString(), anx.ToString()));
- }
- }
#endregion
#region Constructors
@@ -137,7 +116,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXBoundingSphere anx = new ANXBoundingSphere();
- ConvertEquals(xna, anx, "constructor0");
+ AssertHelper.ConvertEquals(xna, anx, "constructor0");
}
[Test, TestCaseSource("fourfloat")]
@@ -147,7 +126,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXBoundingSphere anx = new ANXBoundingSphere(new ANXVector3(x, y, z), r);
- ConvertEquals(xna, anx, "constructor0");
+ AssertHelper.ConvertEquals(xna, anx, "constructor0");
}
#endregion
@@ -245,7 +224,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNABoundingSphere xna = XNABoundingSphere.CreateFromBoundingBox(xnaBox);
ANXBoundingSphere anx = ANXBoundingSphere.CreateFromBoundingBox(anxBox);
- ConvertEquals(xna, anx, "CreateFromBoundingBox");
+ AssertHelper.ConvertEquals(xna, anx, "CreateFromBoundingBox");
}
[Test, TestCaseSource("twentyfloat")]
@@ -261,7 +240,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNABoundingSphere xna = XNABoundingSphere.CreateFromFrustum(xnaFrustum);
ANXBoundingSphere anx = ANXBoundingSphere.CreateFromFrustum(anxFrustum);
- ConvertEquals(xna, anx, "CreateFromFrustumStatic");
+ AssertHelper.ConvertEquals(xna, anx, "CreateFromFrustumStatic");
}
[Test, TestCaseSource("tenfloat")]
@@ -284,7 +263,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNABoundingSphere xna = XNABoundingSphere.CreateFromPoints(pointsXNA);
ANXBoundingSphere anx = ANXBoundingSphere.CreateFromPoints(pointsANX);
- ConvertEquals(xna, anx, "CreateFromPointsStatic");
+ AssertHelper.ConvertEquals(xna, anx, "CreateFromPointsStatic");
}
[Test, TestCaseSource("tenfloat")]
@@ -302,7 +281,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNABoundingSphere xna = XNABoundingSphere.CreateMerged(xnaSphere1, xnaSphere2);
ANXBoundingSphere anx = ANXBoundingSphere.CreateMerged(anxSphere1, anxSphere2);
- ConvertEquals(xna, anx, "CreateMergedStatic");
+ AssertHelper.ConvertEquals(xna, anx, "CreateMergedStatic");
}
[Test, TestCaseSource("tenfloat")]
@@ -417,7 +396,7 @@ namespace ANX.Framework.TestCenter.Strukturen
xnaSphere.Transform(xnaMatrix);
anxSphere.Transform(anxMatrix);
- ConvertEquals(xnaSphere, anxSphere, "Transform");
+ AssertHelper.ConvertEquals(xnaSphere, anxSphere, "Transform");
}
#endregion
diff --git a/ANX.Framework.TestCenter/Strukturen/ColorTest.cs b/ANX.Framework.TestCenter/Strukturen/ColorTest.cs
index 4112f38e..be447fea 100644
--- a/ANX.Framework.TestCenter/Strukturen/ColorTest.cs
+++ b/ANX.Framework.TestCenter/Strukturen/ColorTest.cs
@@ -56,6 +56,9 @@ using System.Text;
using XNAColor = Microsoft.Xna.Framework.Color;
using ANXColor = ANX.Framework.Color;
+using XNAVector3 = Microsoft.Xna.Framework.Vector3;
+using ANXVector3 = ANX.Framework.Vector3;
+
using NUnit.Framework;
namespace ANX.Framework.TestCenter.Strukturen
@@ -63,55 +66,33 @@ namespace ANX.Framework.TestCenter.Strukturen
[TestFixture]
class ColorTest
{
- private static Random r = new Random();
-
- public static float RandomFloat
- {
- get { return (float)(r.NextDouble()); }
- }
-
static object[] fourfloats =
{
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat }
+ new object[] { DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat },
+ new object[] { DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat },
+ new object[] { DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat },
+ new object[] { DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat },
+ new object[] { DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat }
};
static object[] eightfloats =
{
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat }
};
static object[] ninefloats =
{
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
- new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat }
};
- private void ConvertEquals(XNAColor xna, ANXColor anx, String test)
- {
- if (xna.R == anx.R &&
- xna.G == anx.G &&
- xna.B == anx.B &&
- xna.A == anx.A)
- {
- Assert.Pass(test + " passed");
- }
- else
- {
- Assert.Fail(String.Format("{0} failed: xna({1}) anx({2})", test, xna.ToString(), anx.ToString()));
- }
- }
-
#region Constructors
[Test]
public void constructor0()
@@ -119,7 +100,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAColor xna = new XNAColor();
ANXColor anx = new ANXColor();
- ConvertEquals(xna, anx, "constructor0");
+ AssertHelper.ConvertEquals(xna, anx, "constructor0");
}
[Test, TestCaseSource("fourfloats")]
@@ -128,7 +109,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAColor xna = new XNAColor(new Microsoft.Xna.Framework.Vector3(r, g, b));
ANXColor anx = new ANXColor(new ANX.Framework.Vector3(r, g, b));
- ConvertEquals(xna, anx, "constructor1");
+ AssertHelper.ConvertEquals(xna, anx, "constructor1");
}
[Test, TestCaseSource("fourfloats")]
@@ -137,7 +118,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAColor xna = new XNAColor(new Microsoft.Xna.Framework.Vector4(r, g, b, a));
ANXColor anx = new ANXColor(new ANX.Framework.Vector4(r, g, b, a));
- ConvertEquals(xna, anx, "constructor2");
+ AssertHelper.ConvertEquals(xna, anx, "constructor2");
}
[Test, TestCaseSource("fourfloats")]
@@ -146,7 +127,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAColor xna = new XNAColor(r, g, b);
ANXColor anx = new ANXColor(r, g, b);
- ConvertEquals(xna, anx, "constructor3");
+ AssertHelper.ConvertEquals(xna, anx, "constructor3");
}
[Test, TestCaseSource("fourfloats")]
@@ -155,7 +136,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAColor xna = new XNAColor((int)(r * 255), (int)(g * 255), (int)(b * 255));
ANXColor anx = new ANXColor((int)(r * 255), (int)(g * 255), (int)(b * 255));
- ConvertEquals(xna, anx, "constructor4");
+ AssertHelper.ConvertEquals(xna, anx, "constructor4");
}
[Test, TestCaseSource("fourfloats")]
@@ -164,7 +145,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAColor xna = new XNAColor(r, g, b) * a;
ANXColor anx = new ANXColor(r, g, b) * a;
- ConvertEquals(xna, anx, "constructor5");
+ AssertHelper.ConvertEquals(xna, anx, "constructor5");
}
[Test, TestCaseSource("fourfloats")]
@@ -173,7 +154,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAColor xna = new XNAColor((int)(r * 255), (int)(g * 255), (int)(b * 255), (int)(a * 255));
ANXColor anx = new ANXColor((int)(r * 255), (int)(g * 255), (int)(b * 255), (int)(a * 255));
- ConvertEquals(xna, anx, "constructor6");
+ AssertHelper.ConvertEquals(xna, anx, "constructor6");
}
#endregion
@@ -233,7 +214,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXColor anx = ANXColor.FromNonPremultiplied((int)(r * 255), (int)(g * 255), (int)(b * 255), (int)(a * 255));
- ConvertEquals(xna, anx, "FromNonPremultipliedIntStatic");
+ AssertHelper.ConvertEquals(xna, anx, "FromNonPremultipliedIntStatic");
}
[Test, TestCaseSource("fourfloats")]
@@ -243,7 +224,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXColor anx = ANXColor.FromNonPremultiplied(new ANX.Framework.Vector4(r, g, b, a));
- ConvertEquals(xna, anx, "FromNonPremultipliedVector4Static");
+ AssertHelper.ConvertEquals(xna, anx, "FromNonPremultipliedVector4Static");
}
[Test, TestCaseSource("ninefloats")]
@@ -251,6 +232,8 @@ namespace ANX.Framework.TestCenter.Strukturen
float r1, float g1, float b1, float a1,
float r2, float g2, float b2, float a2, float amount)
{
+ amount = MathHelper.Clamp(amount, 0, 1);
+
XNAColor xna1 = new XNAColor(r1, g1, b1) * a1;
XNAColor xna2 = new XNAColor(r2, g2, b2) * a2;
@@ -260,7 +243,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAColor xna = XNAColor.Lerp(xna1, xna2, amount);
ANXColor anx = ANXColor.Lerp(anx1, anx2, amount);
- ConvertEquals(xna, anx, "LerpStatic");
+ AssertHelper.ConvertEquals(xna, anx, "LerpStatic");
}
[Test, TestCaseSource("eightfloats")]
@@ -273,7 +256,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAColor.Multiply(xna, scale);
ANXColor.Multiply(anx, scale);
- ConvertEquals(xna, anx, "MultiplyStatic");
+ AssertHelper.ConvertEquals(xna, anx, "MultiplyStatic");
}
[Test, TestCaseSource("eightfloats")]
@@ -286,7 +269,7 @@ namespace ANX.Framework.TestCenter.Strukturen
xna *= scale;
anx *= scale;
- ConvertEquals(xna, anx, "MultiplyOperator");
+ AssertHelper.ConvertEquals(xna, anx, "MultiplyOperator");
}
[Test, TestCaseSource("fourfloats")]
@@ -299,14 +282,7 @@ namespace ANX.Framework.TestCenter.Strukturen
Microsoft.Xna.Framework.Vector3 xna = xnaColor.ToVector3();
ANX.Framework.Vector3 anx = anxColor.ToVector3();
- if (xna.Equals(anx))
- {
- Assert.Pass("ToVector3 passed");
- }
- else
- {
- Assert.Fail(String.Format("ToVector3 failed: xna({0}) anx({1})", xna.ToString(), anx.ToString()));
- }
+ AssertHelper.ConvertEquals(xna, anx, "ToVector3");
}
[Test, TestCaseSource("fourfloats")]
@@ -319,14 +295,7 @@ namespace ANX.Framework.TestCenter.Strukturen
Microsoft.Xna.Framework.Vector4 xna = xnaColor.ToVector4();
ANX.Framework.Vector4 anx = anxColor.ToVector4();
- if (xna.Equals(anx))
- {
- Assert.Pass("ToVector4 passed");
- }
- else
- {
- Assert.Fail(String.Format("ToVector4 failed: xna({0}) anx({1})", xna.ToString(), anx.ToString()));
- }
+ AssertHelper.ConvertEquals(xna, anx, "ToVector4");
}
#endregion // Methods
@@ -360,17 +329,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXColor anxColor = new ANXColor(r, g, b) * a;
- byte xna = xnaColor.R;
- byte anx = anxColor.R;
-
- if (xna.Equals(anx))
- {
- Assert.Pass("R passed");
- }
- else
- {
- Assert.Fail(String.Format("R failed: xna({0}) anx({1})", xna.ToString(), anx.ToString()));
- }
+ AssertHelper.ConvertEquals(xnaColor.R, anxColor.R, "R");
}
[Test, TestCaseSource("fourfloats")]
@@ -380,17 +339,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXColor anxColor = new ANXColor(r, g, b) * a;
- byte xna = xnaColor.G;
- byte anx = anxColor.G;
-
- if (xna.Equals(anx))
- {
- Assert.Pass("G passed");
- }
- else
- {
- Assert.Fail(String.Format("G failed: xna({0}) anx({1})", xna.ToString(), anx.ToString()));
- }
+ AssertHelper.ConvertEquals(xnaColor.G, anxColor.G, "G");
}
[Test, TestCaseSource("fourfloats")]
@@ -400,17 +349,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXColor anxColor = new ANXColor(r, g, b) * a;
- byte xna = xnaColor.B;
- byte anx = anxColor.B;
-
- if (xna.Equals(anx))
- {
- Assert.Pass("B passed");
- }
- else
- {
- Assert.Fail(String.Format("B failed: xna({0}) anx({1})", xna.ToString(), anx.ToString()));
- }
+ AssertHelper.ConvertEquals(xnaColor.B, anxColor.B, "B");
}
[Test, TestCaseSource("fourfloats")]
@@ -420,18 +359,9 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXColor anxColor = new ANXColor(r, g, b) * a;
- byte xna = xnaColor.A;
- byte anx = anxColor.A;
-
- if (xna.Equals(anx))
- {
- Assert.Pass("A passed");
- }
- else
- {
- Assert.Fail(String.Format("A failed: xna({0}) anx({1})", xna.ToString(), anx.ToString()));
- }
- #endregion
+ AssertHelper.ConvertEquals(xnaColor.A, anxColor.A, "A");
}
+
+ #endregion
}
}
diff --git a/ANX.Framework.TestCenter/Strukturen/MatrixTest.cs b/ANX.Framework.TestCenter/Strukturen/MatrixTest.cs
index 3a7ea61e..4d5dbfe5 100644
--- a/ANX.Framework.TestCenter/Strukturen/MatrixTest.cs
+++ b/ANX.Framework.TestCenter/Strukturen/MatrixTest.cs
@@ -94,30 +94,13 @@ namespace ANX.Framework.TestCenter.Strukturen
#endregion
#region Testdata
- private static Random r = new Random();
-
- public static float RandomFloat
- {
- get { return (float)(r.NextDouble() * (float.MaxValue - 1) - r.NextDouble() * (float.MinValue + 1)); }
- }
-
- public static int RandomBitPlus
- {
- get { return r.Next(3) - 1; }
- }
-
- public static float randomValue
- {
- get { return r.Next(1000) * RandomBitPlus; }
- }
-
static object[] sixteenfloats =
{
- new object[] { MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue },
- new object[] { MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue },
- new object[] { MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue },
- new object[] { MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue },
- new object[] { MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue },
+ new object[] { DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat },
};
#endregion
diff --git a/ANX.Framework.TestCenter/Strukturen/RectangleTest.cs b/ANX.Framework.TestCenter/Strukturen/RectangleTest.cs
index b669bba1..a81cab33 100644
--- a/ANX.Framework.TestCenter/Strukturen/RectangleTest.cs
+++ b/ANX.Framework.TestCenter/Strukturen/RectangleTest.cs
@@ -63,23 +63,6 @@ namespace ANX.Framework.TestCenter.Strukturen
[TestFixture]
class RectangleTest
{
- #region Helper
- public void ConvertEquals(XNARect xna, ANXRect anx, String test)
- {
- //comparing string to catch "not defined" and "infinity" (which seems not to be equal)
- if (xna.ToString().Equals(anx.ToString()))
- {
- Assert.Pass(test + " passed");
- }
- else
- {
- Assert.Fail(test + " failed: xna({" + xna.X + "}{" + xna.Y + "}{" + xna.Width + "}{" + xna.Height + "}) anx({" + anx.X + "}{" + anx.Y + "}{" + anx.Width + "}{" + anx.Height + "})");
- }
- }
-
- #endregion
-
-
static object[] ninefloats =
{
@@ -131,7 +114,7 @@ namespace ANX.Framework.TestCenter.Strukturen
[Test]
public void Empty()
{
- ConvertEquals(XNARect.Empty, ANXRect.Empty, "Empty");
+ AssertHelper.ConvertEquals(XNARect.Empty, ANXRect.Empty, "Empty");
}
@@ -209,7 +192,7 @@ namespace ANX.Framework.TestCenter.Strukturen
{
XNARect xna = new XNARect(x1, y1, w1, h1);
ANXRect anx = new ANXRect(x1, y1, w1, h1);
- ConvertEquals(xna, anx, "Constructor");
+ AssertHelper.ConvertEquals(xna, anx, "Constructor");
}
#endregion
@@ -262,7 +245,7 @@ namespace ANX.Framework.TestCenter.Strukturen
xna.Inflate(x2, y2);
anx.Inflate(x2, y2);
- ConvertEquals(xna, anx, "Inflate");
+ AssertHelper.ConvertEquals(xna, anx, "Inflate");
}
[Test, TestCaseSource("ninefloats6")]
@@ -285,7 +268,7 @@ namespace ANX.Framework.TestCenter.Strukturen
xna.Offset(x2, y2);
anx.Offset(x2, y2);
- ConvertEquals(xna, anx, "Offset");
+ AssertHelper.ConvertEquals(xna, anx, "Offset");
}
@@ -298,7 +281,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNARect xna2 = new XNARect(x2, y2, w2, h2);
ANXRect anx2 = new ANXRect(x2, y2, w2, h2);
- ConvertEquals(XNARect.Intersect(xna, xna2), ANXRect.Intersect(anx, anx2), "Intersection");
+ AssertHelper.ConvertEquals(XNARect.Intersect(xna, xna2), ANXRect.Intersect(anx, anx2), "Intersection");
}
@@ -310,7 +293,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNARect xna2 = new XNARect(x2, y2, w2, h2);
ANXRect anx2 = new ANXRect(x2, y2, w2, h2);
- ConvertEquals(XNARect.Union(xna, xna2), ANXRect.Union(anx, anx2), "Union");
+ AssertHelper.ConvertEquals(XNARect.Union(xna, xna2), ANXRect.Union(anx, anx2), "Union");
}
diff --git a/ANX.Framework.TestCenter/Strukturen/Vector2Test.cs b/ANX.Framework.TestCenter/Strukturen/Vector2Test.cs
index 35c5ce7a..b96f3346 100644
--- a/ANX.Framework.TestCenter/Strukturen/Vector2Test.cs
+++ b/ANX.Framework.TestCenter/Strukturen/Vector2Test.cs
@@ -66,35 +66,6 @@ namespace ANX.Framework.TestCenter.Strukturen
[TestFixture]
class Vector2Test
{
- #region Helper
- public void ConvertEquals(XNAVector2 xna, ANXVector2 anx, String test)
- {
- //comparing string to catch "not defined" and "infinity" (which seems not to be equal)
- if (xna.X.ToString().Equals(anx.X.ToString()) && xna.Y.ToString().Equals(anx.Y.ToString()))
- {
- Assert.Pass(test + " passed");
- }
- else
- {
- Assert.Fail(test + " failed: xna({" + xna.X + "}{" + xna.Y + "}) anx({" + anx.X + "}{" + anx.Y + "})");
- }
- }
-
- public void ConvertEquals(ANXVector2 xna, ANXVector2 anx, String test)
- {
- //comparing string to catch "not defined" and "infinity" (which seems not to be equal)
- if (anx.X.ToString().Equals(anx.X.ToString()) && anx.Y.ToString().Equals(anx.Y.ToString()))
- {
- Assert.Pass(test + " passed");
- }
- else
- {
- Assert.Fail(test + " failed: anx({" + xna.X + "}{" + xna.Y + "}) compared to anx({" + anx.X + "}{" + anx.Y + "})");
- }
- }
-
- #endregion
-
#region Testdata
static object[] ninefloats =
@@ -121,27 +92,25 @@ namespace ANX.Framework.TestCenter.Strukturen
[Test]
public void One()
{
-
- ConvertEquals(XNAVector2.One, ANXVector2.One, "One");
+ AssertHelper.ConvertEquals(XNAVector2.One, ANXVector2.One, "One");
}
[Test]
public void UnitX()
{
- ConvertEquals(XNAVector2.UnitX, ANXVector2.UnitX, "UnitX");
+ AssertHelper.ConvertEquals(XNAVector2.UnitX, ANXVector2.UnitX, "UnitX");
}
[Test]
public void UnitY()
{
- ConvertEquals(XNAVector2.UnitY, ANXVector2.UnitY, "UnitY");
+ AssertHelper.ConvertEquals(XNAVector2.UnitY, ANXVector2.UnitY, "UnitY");
}
[Test]
public void Zero()
{
- ConvertEquals(XNAVector2.Zero, ANXVector2.Zero, "Zero");
-
+ AssertHelper.ConvertEquals(XNAVector2.Zero, ANXVector2.Zero, "Zero");
}
#endregion
@@ -155,8 +124,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXVector2 anxR = new ANXVector2(x);
- ConvertEquals(xnaR, anxR, "Constructor1");
-
+ AssertHelper.ConvertEquals(xnaR, anxR, "Constructor1");
}
[Test, TestCaseSource("ninefloats")]
@@ -166,7 +134,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXVector2 anxR = new ANXVector2(x, y);
- ConvertEquals(xnaR, anxR, "Constructor2");
+ AssertHelper.ConvertEquals(xnaR, anxR, "Constructor2");
}
#endregion
@@ -185,7 +153,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Add(xna1, xna2);
ANXVector2 anxR = ANXVector2.Add(anx1, anx2);
- ConvertEquals(xnaR, anxR, "Add");
+ AssertHelper.ConvertEquals(xnaR, anxR, "Add");
}
[Test, TestCaseSource("ninefloats")]
@@ -204,7 +172,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Barycentric(xna1, xna2, xna3, amount1, amount2);
ANXVector2 anxR = ANXVector2.Barycentric(anx1, anx2, anx3, amount1, amount2);
- ConvertEquals(xnaR, anxR, "Barycentric");
+ AssertHelper.ConvertEquals(xnaR, anxR, "Barycentric");
}
[Test, TestCaseSource("ninefloats")]
@@ -223,7 +191,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.CatmullRom(xna1, xna2, xna3, xna4, amount);
ANXVector2 anxR = ANXVector2.CatmullRom(anx1, anx2, anx3, anx4, amount);
- ConvertEquals(xnaR, anxR, "CatmullRom");
+ AssertHelper.ConvertEquals(xnaR, anxR, "CatmullRom");
}
[Test, TestCaseSource("ninefloats")]
@@ -242,7 +210,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Clamp(xna1, xna2, xna3);
ANXVector2 anxR = ANXVector2.Clamp(anx1, anx2, anx3);
- ConvertEquals(xnaR, anxR, "Clamp");
+ AssertHelper.ConvertEquals(xnaR, anxR, "Clamp");
}
[Test, TestCaseSource("ninefloats")]
@@ -287,7 +255,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Divide(xna1, divider);
ANXVector2 anxR = ANXVector2.Divide(anx1, divider);
- ConvertEquals(xnaR, anxR, "DivideVectorDivider");
+ AssertHelper.ConvertEquals(xnaR, anxR, "DivideVectorDivider");
}
[Test, TestCaseSource("ninefloats")]
@@ -302,7 +270,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Divide(xna1, xna2);
ANXVector2 anxR = ANXVector2.Divide(anx1, anx2);
- ConvertEquals(xnaR, anxR, "DivideVectorVector");
+ AssertHelper.ConvertEquals(xnaR, anxR, "DivideVectorVector");
}
[Test, TestCaseSource("ninefloats")]
@@ -351,7 +319,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Hermite(xna1, xna2, xna3, xna4, amount);
ANXVector2 anxR = ANXVector2.Hermite(anx1, anx2, anx3, anx4, amount);
- ConvertEquals(xnaR, anxR, "Hermite");
+ AssertHelper.ConvertEquals(xnaR, anxR, "Hermite");
}
[Test, TestCaseSource("ninefloats")]
@@ -382,7 +350,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Lerp(xna1, xna2, amount);
ANXVector2 anxR = ANXVector2.Lerp(anx1, anx2, amount);
- ConvertEquals(xnaR, anxR, "Lerp");
+ AssertHelper.ConvertEquals(xnaR, anxR, "Lerp");
}
[Test, TestCaseSource("ninefloats")]
@@ -397,7 +365,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Max(xna1, xna2);
ANXVector2 anxR = ANXVector2.Max(anx1, anx2);
- ConvertEquals(xnaR, anxR, "Max");
+ AssertHelper.ConvertEquals(xnaR, anxR, "Max");
}
@@ -413,7 +381,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Min(xna1, xna2);
ANXVector2 anxR = ANXVector2.Min(anx1, anx2);
- ConvertEquals(xnaR, anxR, "Min");
+ AssertHelper.ConvertEquals(xnaR, anxR, "Min");
}
[Test, TestCaseSource("ninefloats")]
@@ -426,7 +394,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Multiply(xna1, scale);
ANXVector2 anxR = ANXVector2.Multiply(anx1, scale);
- ConvertEquals(xnaR, anxR, "MultiplyVectorFloat");
+ AssertHelper.ConvertEquals(xnaR, anxR, "MultiplyVectorFloat");
}
[Test, TestCaseSource("ninefloats")]
@@ -441,7 +409,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Multiply(xna1, xna2);
ANXVector2 anxR = ANXVector2.Multiply(anx1, anx2);
- ConvertEquals(xnaR, anxR, "MultiplyVectorVector");
+ AssertHelper.ConvertEquals(xnaR, anxR, "MultiplyVectorVector");
}
[Test, TestCaseSource("ninefloats")]
@@ -454,7 +422,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Negate(xna1);
ANXVector2 anxR = ANXVector2.Negate(anx1);
- ConvertEquals(xnaR, anxR, "Negate");
+ AssertHelper.ConvertEquals(xnaR, anxR, "Negate");
}
[Test, TestCaseSource("ninefloats")]
@@ -467,7 +435,7 @@ namespace ANX.Framework.TestCenter.Strukturen
xnaR.Normalize();
anxR.Normalize();
- ConvertEquals(xnaR, anxR, "NormalizeInstanz");
+ AssertHelper.ConvertEquals(xnaR, anxR, "NormalizeInstanz");
}
[Test, TestCaseSource("ninefloats")]
@@ -480,7 +448,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Normalize(xna1);
ANXVector2 anxR = ANXVector2.Normalize(anx1);
- ConvertEquals(xnaR, anxR, "NormalizeStatic");
+ AssertHelper.ConvertEquals(xnaR, anxR, "NormalizeStatic");
}
[Test, TestCaseSource("ninefloats")]
@@ -495,7 +463,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Reflect(xna1, xna2);
ANXVector2 anxR = ANXVector2.Reflect(anx1, anx2);
- ConvertEquals(xnaR, anxR, "Reflect");
+ AssertHelper.ConvertEquals(xnaR, anxR, "Reflect");
}
[Test, TestCaseSource("ninefloats")]
@@ -510,7 +478,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.SmoothStep(xna1, xna2, amount);
ANXVector2 anxR = ANXVector2.SmoothStep(anx1, anx2, amount);
- ConvertEquals(xnaR, anxR, "SmoothStep");
+ AssertHelper.ConvertEquals(xnaR, anxR, "SmoothStep");
}
[Test, TestCaseSource("ninefloats")]
@@ -525,7 +493,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Subtract(xna1, xna2);
ANXVector2 anxR = ANXVector2.Subtract(anx1, anx2);
- ConvertEquals(xnaR, anxR, "Subtract");
+ AssertHelper.ConvertEquals(xnaR, anxR, "Subtract");
}
[Test, TestCaseSource("ninefloats")]
@@ -555,7 +523,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2.Transform(ref xna1, ref xnaMatrix, out xnaResult);
ANXVector2.Transform(ref anx1, ref anxMatrix, out anxResult);
- ConvertEquals(xnaResult, anxResult, "StaticTransform");
+ AssertHelper.ConvertEquals(xnaResult, anxResult, "StaticTransform");
}
[Test, TestCaseSource("ninefloats")]
@@ -569,7 +537,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXMatrix anxMatrix = ANXMatrix.CreateRotationX(nop1) * ANXMatrix.CreateRotationY(nop2) * ANXMatrix.CreateRotationZ(nop3) * ANXMatrix.CreateTranslation(nop4, nop5, nop1);
ANXVector2 anxResult = ANXVector2.Transform(anx1, anxMatrix);
- ConvertEquals(xnaResult, anxResult, "StaticTransform2");
+ AssertHelper.ConvertEquals(xnaResult, anxResult, "StaticTransform2");
}
[Test, TestCaseSource("ninefloats")]
@@ -583,7 +551,7 @@ namespace ANX.Framework.TestCenter.Strukturen
Vector2.Transform(ref anx1, ref anxMatrix, out anxResult2);
- ConvertEquals(anxResult1, anxResult2, "StaticTransform3_ANXonly");
+ AssertHelper.ConvertEquals(anxResult1, anxResult2, "StaticTransform3_ANXonly");
}
/*
diff --git a/ANX.Framework.TestCenter/Strukturen/Vector3Test.cs b/ANX.Framework.TestCenter/Strukturen/Vector3Test.cs
index ccdadf3a..22c6cf42 100644
--- a/ANX.Framework.TestCenter/Strukturen/Vector3Test.cs
+++ b/ANX.Framework.TestCenter/Strukturen/Vector3Test.cs
@@ -66,23 +66,6 @@ namespace ANX.Framework.TestCenter.Strukturen
[TestFixture]
class Vector3Test
{
- #region Helper
-
- public void ConvertEquals(XNAVector3 xna, ANXVector3 anx, String test)
- {
- //comparing string to catch "not defined" and "infinity" (which seems not to be equal)
- if ((xna.X == anx.X) && (xna.Y == anx.Y) && (xna.Z == anx.Z))
- {
- Assert.Pass(test + " passed");
- }
- else
- {
- Assert.Fail(string.Format("{0} failed: xna({1}{2}{3}) anx({4}{5}{6})", test, xna.X, xna.Y, xna.Z, anx.X, anx.Y, anx.Z));
- }
- }
-
- #endregion
-
#region Testdata
static object[] thirteenFloats =
@@ -109,67 +92,67 @@ namespace ANX.Framework.TestCenter.Strukturen
[Test]
public void One()
{
- ConvertEquals(XNAVector3.One, ANXVector3.One, "One");
+ AssertHelper.ConvertEquals(XNAVector3.One, ANXVector3.One, "One");
}
[Test]
public void Zero()
{
- ConvertEquals(XNAVector3.Zero, ANXVector3.Zero, "Zero");
+ AssertHelper.ConvertEquals(XNAVector3.Zero, ANXVector3.Zero, "Zero");
}
[Test]
public void Up()
{
- ConvertEquals(XNAVector3.Up, ANXVector3.Up, "Up");
+ AssertHelper.ConvertEquals(XNAVector3.Up, ANXVector3.Up, "Up");
}
[Test]
public void Down()
{
- ConvertEquals(XNAVector3.Down, ANXVector3.Down, "Down");
+ AssertHelper.ConvertEquals(XNAVector3.Down, ANXVector3.Down, "Down");
}
[Test]
public void Backward()
{
- ConvertEquals(XNAVector3.Backward, ANXVector3.Backward, "Backward");
+ AssertHelper.ConvertEquals(XNAVector3.Backward, ANXVector3.Backward, "Backward");
}
[Test]
public void Forward()
{
- ConvertEquals(XNAVector3.Forward, ANXVector3.Forward, "Forward");
+ AssertHelper.ConvertEquals(XNAVector3.Forward, ANXVector3.Forward, "Forward");
}
[Test]
public void Left()
{
- ConvertEquals(XNAVector3.Left, ANXVector3.Left, "Left");
+ AssertHelper.ConvertEquals(XNAVector3.Left, ANXVector3.Left, "Left");
}
[Test]
public void Right()
{
- ConvertEquals(XNAVector3.Right, ANXVector3.Right, "Right");
+ AssertHelper.ConvertEquals(XNAVector3.Right, ANXVector3.Right, "Right");
}
[Test]
public void UnitX()
{
- ConvertEquals(XNAVector3.UnitX, ANXVector3.UnitX, "UnitX");
+ AssertHelper.ConvertEquals(XNAVector3.UnitX, ANXVector3.UnitX, "UnitX");
}
[Test]
public void UnitY()
{
- ConvertEquals(XNAVector3.UnitY, ANXVector3.UnitY, "UnitY");
+ AssertHelper.ConvertEquals(XNAVector3.UnitY, ANXVector3.UnitY, "UnitY");
}
[Test]
public void UnitZ()
{
- ConvertEquals(XNAVector3.UnitZ, ANXVector3.UnitZ, "UnitZ");
+ AssertHelper.ConvertEquals(XNAVector3.UnitZ, ANXVector3.UnitZ, "UnitZ");
}
#endregion
@@ -183,7 +166,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXVector3 anxR = new ANXVector3();
- ConvertEquals(xnaR, anxR, "Constructor1");
+ AssertHelper.ConvertEquals(xnaR, anxR, "Constructor1");
}
[Test, TestCaseSource("thirteenFloats")]
@@ -193,7 +176,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXVector3 anxR = new ANXVector3(x);
- ConvertEquals(xnaR, anxR, "Constructor2");
+ AssertHelper.ConvertEquals(xnaR, anxR, "Constructor2");
}
[Test, TestCaseSource("thirteenFloats")]
@@ -205,7 +188,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXVector2 anxV2 = new ANXVector2(x, y);
ANXVector3 anxR = new ANXVector3(anxV2, z);
- ConvertEquals(xnaR, anxR, "Constructor3");
+ AssertHelper.ConvertEquals(xnaR, anxR, "Constructor3");
}
[Test, TestCaseSource("thirteenFloats")]
@@ -215,7 +198,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXVector3 anxR = new ANXVector3(x, y, z);
- ConvertEquals(xnaR, anxR, "Constructor4");
+ AssertHelper.ConvertEquals(xnaR, anxR, "Constructor4");
}
#endregion
@@ -234,7 +217,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Add(xna1, xna2);
ANXVector3 anxR = ANXVector3.Add(anx1, anx2);
- ConvertEquals(xnaR, anxR, "Add");
+ AssertHelper.ConvertEquals(xnaR, anxR, "Add");
}
@@ -254,7 +237,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Barycentric(xna1, xna2, xna3, amount1, amount2);
ANXVector3 anxR = ANXVector3.Barycentric(anx1, anx2, anx3, amount1, amount2);
- ConvertEquals(xnaR, anxR, "Barycentric");
+ AssertHelper.ConvertEquals(xnaR, anxR, "Barycentric");
}
[Test, TestCaseSource("thirteenFloats")]
@@ -273,7 +256,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.CatmullRom(xna1, xna2, xna3, xna4, amount);
ANXVector3 anxR = ANXVector3.CatmullRom(anx1, anx2, anx3, anx4, amount);
- ConvertEquals(xnaR, anxR, "CatmullRom");
+ AssertHelper.ConvertEquals(xnaR, anxR, "CatmullRom");
}
[Test, TestCaseSource("thirteenFloats")]
@@ -290,7 +273,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Clamp(xna1, xna2, xna3);
ANXVector3 anxR = ANXVector3.Clamp(anx1, anx2, anx3);
- ConvertEquals(xnaR, anxR, "Clamp");
+ AssertHelper.ConvertEquals(xnaR, anxR, "Clamp");
}
[Test, TestCaseSource("thirteenFloats")]
@@ -305,7 +288,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Cross(xna1, xna2);
ANXVector3 anxR = ANXVector3.Cross(anx2, anx2);
- ConvertEquals(xnaR, anxR, "Cross");
+ AssertHelper.ConvertEquals(xnaR, anxR, "Cross");
}
[Test, TestCaseSource("thirteenFloats")]
@@ -348,7 +331,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Divide(xna1, divider);
ANXVector3 anxR = ANXVector3.Divide(anx1, divider);
- ConvertEquals(xnaR, anxR, "DivideVectorDivider");
+ AssertHelper.ConvertEquals(xnaR, anxR, "DivideVectorDivider");
}
[Test, TestCaseSource("thirteenFloats")]
@@ -363,7 +346,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Divide(xna1, xna2);
ANXVector3 anxR = ANXVector3.Divide(anx1, anx2);
- ConvertEquals(xnaR, anxR, "DivideVectorVector");
+ AssertHelper.ConvertEquals(xnaR, anxR, "DivideVectorVector");
}
[Test, TestCaseSource("thirteenFloats")]
@@ -411,7 +394,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Hermite(xna1, xna2, xna3, xna4, amount);
ANXVector3 anxR = ANXVector3.Hermite(anx1, anx2, anx3, anx4, amount);
- ConvertEquals(xnaR, anxR, "Hermite");
+ AssertHelper.ConvertEquals(xnaR, anxR, "Hermite");
}
[Test, TestCaseSource("thirteenFloats")]
@@ -442,7 +425,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Lerp(xna1, xna2, amount);
ANXVector3 anxR = ANXVector3.Lerp(anx1, anx2, amount);
- ConvertEquals(xnaR, anxR, "Lerp");
+ AssertHelper.ConvertEquals(xnaR, anxR, "Lerp");
}
[Test, TestCaseSource("thirteenFloats")]
@@ -457,7 +440,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Max(xna1, xna2);
ANXVector3 anxR = ANXVector3.Max(anx1, anx2);
- ConvertEquals(xnaR, anxR, "Max");
+ AssertHelper.ConvertEquals(xnaR, anxR, "Max");
}
@@ -473,7 +456,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Min(xna1, xna2);
ANXVector3 anxR = ANXVector3.Min(anx1, anx2);
- ConvertEquals(xnaR, anxR, "Min");
+ AssertHelper.ConvertEquals(xnaR, anxR, "Min");
}
[Test, TestCaseSource("thirteenFloats")]
@@ -488,7 +471,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Multiply(xna1, scale);
ANXVector3 anxR = ANXVector3.Multiply(anx1, scale);
- ConvertEquals(xnaR, anxR, "MultiplyVectorFloat");
+ AssertHelper.ConvertEquals(xnaR, anxR, "MultiplyVectorFloat");
}
[Test, TestCaseSource("thirteenFloats")]
@@ -503,7 +486,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Multiply(xna1, xna2);
ANXVector3 anxR = ANXVector3.Multiply(anx1, anx2);
- ConvertEquals(xnaR, anxR, "MultiplyVectorVector");
+ AssertHelper.ConvertEquals(xnaR, anxR, "MultiplyVectorVector");
}
[Test, TestCaseSource("thirteenFloats")]
@@ -516,7 +499,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Negate(xna1);
ANXVector3 anxR = ANXVector3.Negate(anx1);
- ConvertEquals(xnaR, anxR, "Negate");
+ AssertHelper.ConvertEquals(xnaR, anxR, "Negate");
}
[Test, TestCaseSource("thirteenFloats")]
@@ -529,7 +512,7 @@ namespace ANX.Framework.TestCenter.Strukturen
xnaR.Normalize();
anxR.Normalize();
- ConvertEquals(xnaR, anxR, "NormalizeInstanz");
+ AssertHelper.ConvertEquals(xnaR, anxR, "NormalizeInstanz");
}
[Test, TestCaseSource("thirteenFloats")]
@@ -542,7 +525,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Normalize(xna1);
ANXVector3 anxR = ANXVector3.Normalize(anx1);
- ConvertEquals(xnaR, anxR, "NormalizeStatic");
+ AssertHelper.ConvertEquals(xnaR, anxR, "NormalizeStatic");
}
[Test, TestCaseSource("thirteenFloats")]
@@ -557,7 +540,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Reflect(xna1, xna2);
ANXVector3 anxR = ANXVector3.Reflect(anx1, anx2);
- ConvertEquals(xnaR, anxR, "Reflect");
+ AssertHelper.ConvertEquals(xnaR, anxR, "Reflect");
}
[Test, TestCaseSource("thirteenFloats")]
@@ -572,7 +555,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.SmoothStep(xna1, xna2, amount);
ANXVector3 anxR = ANXVector3.SmoothStep(anx1, anx2, amount);
- ConvertEquals(xnaR, anxR, "SmoothStep");
+ AssertHelper.ConvertEquals(xnaR, anxR, "SmoothStep");
}
[Test, TestCaseSource("thirteenFloats")]
@@ -587,7 +570,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Subtract(xna1, xna2);
ANXVector3 anxR = ANXVector3.Subtract(anx1, anx2);
- ConvertEquals(xnaR, anxR, "Subtract");
+ AssertHelper.ConvertEquals(xnaR, anxR, "Subtract");
}
[Test, TestCaseSource("thirteenFloats")]
diff --git a/ANX.Framework.TestCenter/Strukturen/Vector4Test.cs b/ANX.Framework.TestCenter/Strukturen/Vector4Test.cs
index af2a60eb..b0083606 100644
--- a/ANX.Framework.TestCenter/Strukturen/Vector4Test.cs
+++ b/ANX.Framework.TestCenter/Strukturen/Vector4Test.cs
@@ -87,14 +87,17 @@ namespace ANX.Framework.TestCenter.Strukturen
#region Testdata
+ static object[] fourFloats =
+ {
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
+ new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat }
+ };
+
static object[] seventeenFloats =
{
- // new object[] {Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat ,Vector2Test.RandomFloat},
- // new object[] {Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat ,Vector2Test.RandomFloat},
- // new object[] {Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat },
- // new object[] {Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat ,Vector2Test.RandomFloat},
- // new object[] {Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat },
-
new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue},
new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue},
new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue},
@@ -158,8 +161,8 @@ namespace ANX.Framework.TestCenter.Strukturen
ConvertEquals(xnaR, anxR, "Constructor1");
}
- [Test, TestCaseSource("seventeenFloats")]
- public void constructor2(float x, float nop1, float nop2, float nop3, float nop4, float nop5, float nop6, float nop7, float nop8, float nop9, float nop10, float nop11, float nop12)
+ [Test, TestCaseSource("fourFloats")]
+ public void constructor2(float x, float nop1, float nop2, float nop3)
{
XNAVector4 xnaR = new XNAVector4(x);
@@ -168,8 +171,8 @@ namespace ANX.Framework.TestCenter.Strukturen
ConvertEquals(xnaR, anxR, "Constructor2");
}
- [Test, TestCaseSource("seventeenFloats")]
- public void constructor3(float x, float y, float z, float w, float nop1, float nop2, float nop3, float nop4, float nop5, float nop6, float nop7, float nop8, float nop9)
+ [Test, TestCaseSource("fourFloats")]
+ public void constructor3(float x, float y, float z, float w)
{
XNAVector3 xnaV3 = new XNAVector3(x, y, z);
XNAVector4 xnaR = new XNAVector4(xnaV3, w);
@@ -180,8 +183,8 @@ namespace ANX.Framework.TestCenter.Strukturen
ConvertEquals(xnaR, anxR, "Constructor3");
}
- [Test, TestCaseSource("seventeenFloats")]
- public void constructor4(float x, float y, float z, float w, float nop1, float nop2, float nop3, float nop4, float nop5, float nop6, float nop7, float nop8, float nop9)
+ [Test, TestCaseSource("fourFloats")]
+ public void constructor4(float x, float y, float z, float w)
{
XNAVector2 xnaV2 = new XNAVector2(x, y);
XNAVector4 xnaR = new XNAVector4(xnaV2, z, w);
@@ -192,8 +195,8 @@ namespace ANX.Framework.TestCenter.Strukturen
ConvertEquals(xnaR, anxR, "Constructor4");
}
- [Test, TestCaseSource("seventeenFloats")]
- public void constructor5(float x, float y, float z, float w, float nop1, float nop2, float nop3, float nop4, float nop5, float nop6, float nop7, float nop8, float nop9)
+ [Test, TestCaseSource("fourFloats")]
+ public void constructor5(float x, float y, float z, float w)
{
XNAVector4 xnaR = new XNAVector4(x, y, z, w);
diff --git a/ANX.Framework/Color.cs b/ANX.Framework/Color.cs
index a16e4400..377a4f03 100644
--- a/ANX.Framework/Color.cs
+++ b/ANX.Framework/Color.cs
@@ -865,12 +865,32 @@ namespace ANX.Framework
public static Color FromNonPremultiplied(int r, int g, int b, int a)
{
- throw new NotImplementedException();
+ Color color;
+
+ r = r * a;
+ g = g * a;
+ b = b * a;
+
+ if (((((r | g) | b) | a) & -256) != 0)
+ {
+ r = r < 0 ? 0 : (r > 255 ? 255 : r);
+ g = g < 0 ? 0 : (g > 255 ? 255 : g);
+ b = b < 0 ? 0 : (b > 255 ? 255 : b);
+ a = a < 0 ? 0 : (a > 255 ? 255 : a);
+ }
+
+ color.packedValue = (uint)(((r | g << 8) | b << 16) | a << 24);
+
+ return color;
}
public static Color FromNonPremultiplied(Vector4 vector)
{
- throw new NotImplementedException();
+ Color color;
+
+ color.packedValue = ColorPack(vector.X * vector.W, vector.Y * vector.W, vector.Z * vector.W, vector.W);
+
+ return color;
}
public override int GetHashCode()
@@ -880,12 +900,54 @@ namespace ANX.Framework
public static Color Lerp(Color value1, Color value2, float amount)
{
- throw new NotImplementedException();
+ Color color;
+
+ byte r1 = (byte)value1.packedValue;
+ byte g1 = (byte)(value1.packedValue >> 8);
+ byte b1 = (byte)(value1.packedValue >> 16);
+ byte a1 = (byte)(value1.packedValue >> 24);
+
+ byte r2 = (byte)value2.packedValue;
+ byte g2 = (byte)(value2.packedValue >> 8);
+ byte b2 = (byte)(value2.packedValue >> 16);
+ byte a2 = (byte)(value2.packedValue >> 24);
+
+ int factor = (int)PackUNormal(65536f, amount);
+
+ int r3 = r1 + (((r2 - r1) * factor) >> 16);
+ int g3 = g1 + (((g2 - g1) * factor) >> 16);
+ int b3 = b1 + (((b2 - b1) * factor) >> 16);
+ int a3 = a1 + (((a2 - a1) * factor) >> 16);
+
+ color.packedValue = (uint)(((r3 | (g3 << 8)) | (b3 << 16)) | (a3 << 24));
+
+ return color;
}
public static Color Multiply(Color value, float scale)
{
- throw new NotImplementedException();
+ Color color;
+
+ uint r = (byte)value.packedValue;
+ uint g = (byte)(value.packedValue >> 8);
+ uint b = (byte)(value.packedValue >> 16);
+ uint a = (byte)(value.packedValue >> 24);
+
+ uint uintScale = (uint)MathHelper.Clamp(scale * 65536f, 0, 0xffffff);
+
+ r = (r * uintScale) >> 16;
+ g = (g * uintScale) >> 16;
+ b = (b * uintScale) >> 16;
+ a = (a * uintScale) >> 16;
+
+ r = r > 255 ? 255 : r;
+ g = g > 255 ? 255 : g;
+ b = b > 255 ? 255 : b;
+ a = a > 255 ? 255 : a;
+
+ color.packedValue = ((r | (g << 8)) | (b << 0x10)) | (a << 0x18);
+
+ return color;
}
public static Color operator *(Color a, float scale)
@@ -900,12 +962,29 @@ namespace ANX.Framework
public Vector3 ToVector3()
{
- return new Vector3(R, G, B);
+ Vector3 result;
+
+ result.X = (packedValue & 255);
+ result.Y = (packedValue >> 8 & 255);
+ result.Z = (packedValue >> 16 & 255);
+
+ result /= 0xff;
+
+ return result;
}
public Vector4 ToVector4()
{
- return new Vector4(R, G, B, A);
+ Vector4 result;
+
+ result.X = (packedValue & 255);
+ result.Y = (packedValue >> 8 & 255);
+ result.Z = (packedValue >> 16 & 255);
+ result.W = (packedValue >> 24 & 255);
+
+ result /= 0xff;
+
+ return result;
}
public void PackFromVector4(Vector4 vector)
diff --git a/ANX.Framework/Vector3.cs b/ANX.Framework/Vector3.cs
index 894f2402..eef2994a 100644
--- a/ANX.Framework/Vector3.cs
+++ b/ANX.Framework/Vector3.cs
@@ -264,7 +264,7 @@ namespace ANX.Framework
public static void Divide(ref Vector3 value1, float value2, out Vector3 result)
{
- float divFactor = 1 / value2;
+ float divFactor = 1f / value2;
Multiply(ref value1, divFactor, out result);
}