diff --git a/OpenSim/Tests/Common/ANumericalToleranceConstraint.cs b/OpenSim/Tests/Common/ANumericalToleranceConstraint.cs
index 289e4bbb7a..2a6993d46a 100644
--- a/OpenSim/Tests/Common/ANumericalToleranceConstraint.cs
+++ b/OpenSim/Tests/Common/ANumericalToleranceConstraint.cs
@@ -1,30 +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;
- }
- }
-}
+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
index f3da236c6c..eb71aeb52c 100644
--- a/OpenSim/Tests/Common/DoubleToleranceConstraint.cs
+++ b/OpenSim/Tests/Common/DoubleToleranceConstraint.cs
@@ -1,52 +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;
- }
-
- ///
- ///Test whether the constraint is satisfied by a given value
- ///
- ///The value to be tested
- ///
- ///True for success, false for failure
- ///
- 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);
- }
- }
-}
+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;
+ }
+
+ ///
+ ///Test whether the constraint is satisfied by a given value
+ ///
+ ///The value to be tested
+ ///
+ ///True for success, false for failure
+ ///
+ 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
index f59c1575c0..9dc6aa7502 100644
--- a/OpenSim/Tests/Common/TestHelper.cs
+++ b/OpenSim/Tests/Common/TestHelper.cs
@@ -1,25 +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;
- }
- }
-}
+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
index 1faf7dd5f1..3f32830598 100644
--- a/OpenSim/Tests/Common/VectorToleranceConstraint.cs
+++ b/OpenSim/Tests/Common/VectorToleranceConstraint.cs
@@ -1,58 +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;
- }
-
- ///
- ///Test whether the constraint is satisfied by a given value
- ///
- ///The value to be tested
- ///
- ///True for success, false for failure
- ///
- 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);
- }
- }
-}
+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;
+ }
+
+ ///
+ ///Test whether the constraint is satisfied by a given value
+ ///
+ ///The value to be tested
+ ///
+ ///True for success, false for failure
+ ///
+ 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
index ef42eeed50..8aaacc64ae 100644
--- a/OpenSim/Tests/OpenSim/Framework/UtilTest.cs
+++ b/OpenSim/Tests/OpenSim/Framework/UtilTest.cs
@@ -1,115 +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.");
- }
- }
- }
-}
+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.");
+ }
+ }
+ }
+}