From a1625a54104da7872c15618db9e68656c6f6ec2a Mon Sep 17 00:00:00 2001
From: Adam Frisby
Date: Fri, 8 Feb 2008 17:54:30 +0000
Subject: * Applying mantis 339 patches round 2 -- Thanks daedius
---
.../Tests/Common/ANumericalToleranceConstraint.cs | 30 ++++++
OpenSim/Tests/Common/DoubleToleranceConstraint.cs | 52 ++++++++++
OpenSim/Tests/Common/TestHelper.cs | 25 +++++
OpenSim/Tests/Common/VectorToleranceConstraint.cs | 58 +++++++++++
OpenSim/Tests/OpenSim/Framework/UtilTest.cs | 115 +++++++++++++++++++++
5 files changed, 280 insertions(+)
create mode 100644 OpenSim/Tests/Common/ANumericalToleranceConstraint.cs
create mode 100644 OpenSim/Tests/Common/DoubleToleranceConstraint.cs
create mode 100644 OpenSim/Tests/Common/TestHelper.cs
create mode 100644 OpenSim/Tests/Common/VectorToleranceConstraint.cs
create mode 100644 OpenSim/Tests/OpenSim/Framework/UtilTest.cs
(limited to 'OpenSim/Tests')
diff --git a/OpenSim/Tests/Common/ANumericalToleranceConstraint.cs b/OpenSim/Tests/Common/ANumericalToleranceConstraint.cs
new file mode 100644
index 0000000..289e4bb
--- /dev/null
+++ b/OpenSim/Tests/Common/ANumericalToleranceConstraint.cs
@@ -0,0 +1,30 @@
+using System;
+using NUnit.Framework.Constraints;
+
+namespace OpenSim.Tests.Common
+{
+ public abstract class ANumericalToleranceConstraint : Constraint
+ {
+ protected double _tolerance;
+
+ public ANumericalToleranceConstraint(double tolerance)
+ {
+ if (tolerance < 0)
+ {
+ throw new ArgumentException("Tolerance cannot be negative.");
+ }
+ _tolerance = tolerance;
+ }
+
+
+ protected bool IsWithinDoubleConstraint(double doubleValue, double baseValue)
+ {
+ if (doubleValue >= baseValue - _tolerance && doubleValue <= baseValue + _tolerance)
+ {
+ return true;
+ }
+
+ return false;
+ }
+ }
+}
diff --git a/OpenSim/Tests/Common/DoubleToleranceConstraint.cs b/OpenSim/Tests/Common/DoubleToleranceConstraint.cs
new file mode 100644
index 0000000..f3da236
--- /dev/null
+++ b/OpenSim/Tests/Common/DoubleToleranceConstraint.cs
@@ -0,0 +1,52 @@
+using System;
+using NUnit.Framework;
+using NUnit.Framework.Constraints;
+using OpenSim.Tests.Common;
+
+namespace OpenSim.Tests.Common
+{
+ public class DoubleToleranceConstraint : ANumericalToleranceConstraint
+ {
+
+ private double _baseValue;
+ private double _valueToBeTested;
+
+ public DoubleToleranceConstraint(double baseValue, double tolerance) : base(tolerance)
+ {
+ _baseValue = baseValue;
+ }
+
+ ///<summary>
+ ///Test whether the constraint is satisfied by a given value
+ ///</summary>
+ ///<param name="valueToBeTested">The value to be tested</param>
+ ///<returns>
+ ///True for success, false for failure
+ ///</returns>
+ public override bool Matches(object valueToBeTested)
+ {
+ if (valueToBeTested == null)
+ {
+ throw new ArgumentException("Constraint cannot be used upon null values.");
+ }
+ if( valueToBeTested.GetType() != typeof(double))
+ {
+ throw new ArgumentException("Constraint cannot be used upon non double-values.");
+ }
+
+ _valueToBeTested = (double)valueToBeTested;
+
+ return IsWithinDoubleConstraint(_valueToBeTested, _baseValue );
+ }
+
+ public override void WriteDescriptionTo(MessageWriter writer)
+ {
+ writer.WriteExpectedValue(string.Format("A value {0} within tolerance of plus or minus {1}",_baseValue,_tolerance));
+ }
+
+ public override void WriteActualValueTo(MessageWriter writer)
+ {
+ writer.WriteActualValue(_valueToBeTested);
+ }
+ }
+}
diff --git a/OpenSim/Tests/Common/TestHelper.cs b/OpenSim/Tests/Common/TestHelper.cs
new file mode 100644
index 0000000..f59c157
--- /dev/null
+++ b/OpenSim/Tests/Common/TestHelper.cs
@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace OpenSim.Tests.Common
+{
+ public delegate void TestDelegate();
+
+ public class TestHelper
+ {
+ public static bool AssertThisDelegateCausesArgumentException(TestDelegate d)
+ {
+ try
+ {
+ d();
+ }
+ catch(ArgumentException e)
+ {
+ return true;
+ }
+
+ return false;
+ }
+ }
+}
diff --git a/OpenSim/Tests/Common/VectorToleranceConstraint.cs b/OpenSim/Tests/Common/VectorToleranceConstraint.cs
new file mode 100644
index 0000000..1faf7dd
--- /dev/null
+++ b/OpenSim/Tests/Common/VectorToleranceConstraint.cs
@@ -0,0 +1,58 @@
+using System;
+using libsecondlife;
+using NUnit.Framework;
+
+namespace OpenSim.Tests.Common
+{
+ public class VectorToleranceConstraint : ANumericalToleranceConstraint
+ {
+ private LLVector3 _baseValue;
+ private LLVector3 _valueToBeTested;
+
+ public VectorToleranceConstraint(LLVector3 baseValue, double tolerance) : base(tolerance)
+ {
+ _baseValue = baseValue;
+ }
+
+ ///<summary>
+ ///Test whether the constraint is satisfied by a given value
+ ///</summary>
+ ///<param name="valueToBeTested">The value to be tested</param>
+ ///<returns>
+ ///True for success, false for failure
+ ///</returns>
+ public override bool Matches(object valueToBeTested)
+ {
+ if (valueToBeTested == null)
+ {
+ throw new ArgumentException("Constraint cannot be used upon null values.");
+ }
+ if (valueToBeTested.GetType() != typeof (LLVector3))
+ {
+ throw new ArgumentException("Constraint cannot be used upon non vector values.");
+ }
+
+ _valueToBeTested = (LLVector3) valueToBeTested;
+
+ if ( IsWithinDoubleConstraint(_valueToBeTested.X,_baseValue.X) &&
+ IsWithinDoubleConstraint(_valueToBeTested.Y,_baseValue.Y) &&
+ IsWithinDoubleConstraint(_valueToBeTested.Z,_baseValue.Z) )
+ {
+ return true;
+ }
+
+ return false;
+ }
+
+ public override void WriteDescriptionTo(MessageWriter writer)
+ {
+ writer.WriteExpectedValue(
+ string.Format("A value {0} within tolerance of plus or minus {1}", _baseValue, _tolerance));
+ }
+
+ public override void WriteActualValueTo(MessageWriter writer)
+ {
+ writer.WriteActualValue(_valueToBeTested);
+ }
+ }
+}
diff --git a/OpenSim/Tests/OpenSim/Framework/UtilTest.cs b/OpenSim/Tests/OpenSim/Framework/UtilTest.cs
new file mode 100644
index 0000000..ef42eee
--- /dev/null
+++ b/OpenSim/Tests/OpenSim/Framework/UtilTest.cs
@@ -0,0 +1,115 @@
+using libsecondlife;
+using NUnit.Framework;
+using NUnit.Framework.SyntaxHelpers;
+
+using OpenSim.Tests.Common;
+
+namespace OpenSim.Framework.Tests
+{
+ [TestFixture]
+ public class UtilTests
+ {
+ [Test]
+ public void VectorOperationTests()
+ {
+ LLVector3 v1, v2;
+ double expectedDistance;
+ double expectedMagnitude;
+ double lowPrecisionTolerance = 0.001;
+
+ //Lets test a simple case of <0,0,0> and <5,5,5>
+ {
+ v1 = new LLVector3(0, 0, 0);
+ v2 = new LLVector3(5, 5, 5);
+ expectedDistance = 8.66;
+ Assert.That(Util.GetDistanceTo(v1, v2),
+ new DoubleToleranceConstraint(expectedDistance, lowPrecisionTolerance),
+ "Calculated distance between two vectors was not within tolerances.");
+
+ expectedMagnitude = 0;
+ Assert.That(Util.GetMagnitude(v1), Is.EqualTo(0), "Magnitude of null vector was not zero.");
+
+ expectedMagnitude = 8.66;
+ Assert.That(Util.GetMagnitude(v2),
+ new DoubleToleranceConstraint(expectedMagnitude, lowPrecisionTolerance),
+ "Magnitude of vector was incorrect.");
+
+ TestDelegate d = delegate() { Util.GetNormalizedVector(v1); };
+ bool causesArgumentException = TestHelper.AssertThisDelegateCausesArgumentException(d);
+ Assert.That(causesArgumentException, Is.True,
+ "Getting magnitude of null vector did not cause argument exception.");
+
+ LLVector3 expectedNormalizedVector = new LLVector3(.577f, .577f, .577f);
+ double expectedNormalizedMagnitude = 1;
+ LLVector3 normalizedVector = Util.GetNormalizedVector(v2);
+ Assert.That(normalizedVector,
+ new VectorToleranceConstraint(expectedNormalizedVector, lowPrecisionTolerance),
+ "Normalized vector generated from vector was not what was expected.");
+ Assert.That(Util.GetMagnitude(normalizedVector),
+ new DoubleToleranceConstraint(expectedNormalizedMagnitude, lowPrecisionTolerance),
+ "Normalized vector generated from vector does not have magnitude of 1.");
+ }
+
+ //Lets test a simple case of <0,0,0> and <0,0,0>
+ {
+ v1 = new LLVector3(0, 0, 0);
+ v2 = new LLVector3(0, 0, 0);
+ expectedDistance = 0;
+ Assert.That(Util.GetDistanceTo(v1, v2),
+ new DoubleToleranceConstraint(expectedDistance, lowPrecisionTolerance),
+ "Calculated distance between two vectors was not within tolerances.");
+
+ expectedMagnitude = 0;
+ Assert.That(Util.GetMagnitude(v1), Is.EqualTo(0), "Magnitude of null vector was not zero.");
+
+ expectedMagnitude = 0;
+ Assert.That(Util.GetMagnitude(v2),
+ new DoubleToleranceConstraint(expectedMagnitude, lowPrecisionTolerance),
+ "Magnitude of vector was incorrect.");
+
+ TestDelegate d = delegate() { Util.GetNormalizedVector(v1); };
+ bool causesArgumentException = TestHelper.AssertThisDelegateCausesArgumentException(d);
+ Assert.That(causesArgumentException, Is.True,
+ "Getting magnitude of null vector did not cause argument exception.");
+
+ d = delegate() { Util.GetNormalizedVector(v2); };
+ causesArgumentException = TestHelper.AssertThisDelegateCausesArgumentException(d);
+ Assert.That(causesArgumentException, Is.True,
+ "Getting magnitude of null vector did not cause argument exception.");
+ }
+
+ //Lets test a simple case of <0,0,0> and <-5,-5,-5>
+ {
+ v1 = new LLVector3(0, 0, 0);
+ v2 = new LLVector3(-5, -5, -5);
+ expectedDistance = 8.66;
+ Assert.That(Util.GetDistanceTo(v1, v2),
+ new DoubleToleranceConstraint(expectedDistance, lowPrecisionTolerance),
+ "Calculated distance between two vectors was not within tolerances.");
+
+ expectedMagnitude = 0;
+ Assert.That(Util.GetMagnitude(v1), Is.EqualTo(0), "Magnitude of null vector was not zero.");
+
+ expectedMagnitude = 8.66;
+ Assert.That(Util.GetMagnitude(v2),
+ new DoubleToleranceConstraint(expectedMagnitude, lowPrecisionTolerance),
+ "Magnitude of vector was incorrect.");
+
+ TestDelegate d = delegate() { Util.GetNormalizedVector(v1); };
+ bool causesArgumentException = TestHelper.AssertThisDelegateCausesArgumentException(d);
+ Assert.That(causesArgumentException, Is.True,
+ "Getting magnitude of null vector did not cause argument exception.");
+
+ LLVector3 expectedNormalizedVector = new LLVector3(-.577f, -.577f, -.577f);
+ double expectedNormalizedMagnitude = 1;
+ LLVector3 normalizedVector = Util.GetNormalizedVector(v2);
+ Assert.That(normalizedVector,
+ new VectorToleranceConstraint(expectedNormalizedVector, lowPrecisionTolerance),
+ "Normalized vector generated from vector was not what was expected.");
+ Assert.That(Util.GetMagnitude(normalizedVector),
+ new DoubleToleranceConstraint(expectedNormalizedMagnitude, lowPrecisionTolerance),
+ "Normalized vector generated from vector does not have magnitude of 1.");
+ }
+ }
+ }
+}
--
cgit v1.1