Added comments to disable ReSharper warnings in tests.

angularsen · angularsen · commit ef79ea1a9d0a · 2013-10-30T19:46:32.000+01:00
diff --git a/Tests/AreaTests.cs b/Tests/AreaTests.cs
@@ -83,6 +83,7 @@ public void CompareToIsImplemented()
         public void CompareToThrowsOnTypeMismatch()
         {
             Area meter = Area.FromSquareMeters(1);
+// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
             meter.CompareTo(new object());
         }
 
@@ -91,6 +92,7 @@ public void CompareToThrowsOnTypeMismatch()
         public void CompareToThrowsOnNull()
         { 
             Area meter = Area.FromSquareMeters(1);
+// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
             meter.CompareTo(null);
         }
 
@@ -101,11 +103,13 @@ public void EqualityOperators()
             Area a = Area.FromSquareMeters(1);
             Area b = Area.FromSquareMeters(2);
 
+// ReSharper disable EqualExpressionComparison
             Assert.True(a == a); 
             Assert.True(a != b);
 
             Assert.False(a == b);
             Assert.False(a != a);
+// ReSharper restore EqualExpressionComparison
         }
 
         [Test]
diff --git a/Tests/ForceTests.cs b/Tests/ForceTests.cs
@@ -79,6 +79,7 @@ public void CompareToIsImplemented()
         public void CompareToThrowsOnTypeMismatch()
         {
             Force newton = Force.FromNewtons(1);
+// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
             newton.CompareTo(new object());
         }
 
@@ -87,6 +88,7 @@ public void CompareToThrowsOnTypeMismatch()
         public void CompareToThrowsOnNull()
         { 
             Force newton = Force.FromNewtons(1);
+// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
             newton.CompareTo(null);
         }
 
@@ -96,11 +98,13 @@ public void EqualityOperators()
             Force a = Force.FromNewtons(1);
             Force b = Force.FromNewtons(2);
 
+// ReSharper disable EqualExpressionComparison
             Assert.True(a == a); 
             Assert.True(a != b);
 
             Assert.False(a == b);
             Assert.False(a != a);
+// ReSharper restore EqualExpressionComparison
         }
 
         [Test]
diff --git a/Tests/Length2dTests.cs b/Tests/Length2dTests.cs
@@ -3,6 +3,7 @@
 namespace UnitsNet.Tests.net35
 {
     [TestFixture]
+// ReSharper disable once InconsistentNaming
     public class Length2dTests
     {
         private const double Delta = 1E-5;
@@ -83,11 +84,13 @@ public void EqualityOperators()
             Length2d a = Length2d.FromMeters(1, 2);
             Length2d b = Length2d.FromMeters(2, 1);
 
+// ReSharper disable EqualExpressionComparison
             Assert.True(a == a); 
             Assert.True(a != b);
 
             Assert.False(a == b);
             Assert.False(a != a);
+// ReSharper restore EqualExpressionComparison
         }
 
         [Test]
diff --git a/Tests/LengthTests.cs b/Tests/LengthTests.cs
@@ -90,6 +90,7 @@ public void CompareToIsImplemented()
         public void CompareToThrowsOnTypeMismatch()
         {
             Length meter = Length.FromMeters(1);
+// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
             meter.CompareTo(new object());
         }
 
@@ -98,6 +99,7 @@ public void CompareToThrowsOnTypeMismatch()
         public void CompareToThrowsOnNull()
         { 
             Length meter = Length.FromMeters(1);
+// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
             meter.CompareTo(null);
         }
 
@@ -108,11 +110,13 @@ public void EqualityOperators()
             Length a = Length.FromMeters(1);
             Length b = Length.FromMeters(2);
 
+// ReSharper disable EqualExpressionComparison
             Assert.True(a == a); 
             Assert.True(a != b);
 
             Assert.False(a == b);
             Assert.False(a != a);
+// ReSharper restore EqualExpressionComparison
         }
 
         [Test]
diff --git a/Tests/MassTests.cs b/Tests/MassTests.cs
@@ -91,6 +91,7 @@ public void CompareToIsImplemented()
         public void CompareToThrowsOnTypeMismatch()
         {
             Mass meter = Mass.FromKilograms(1);
+// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
             meter.CompareTo(new object());
         }
 
@@ -99,6 +100,7 @@ public void CompareToThrowsOnTypeMismatch()
         public void CompareToThrowsOnNull()
         { 
             Mass meter = Mass.FromKilograms(1);
+// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
             meter.CompareTo(null);
         }
 
@@ -109,11 +111,13 @@ public void EqualityOperators()
             Mass a = Mass.FromKilograms(1);
             Mass b = Mass.FromKilograms(2);
 
+// ReSharper disable EqualExpressionComparison
             Assert.True(a == a); 
             Assert.True(a != b);
 
             Assert.False(a == b);
             Assert.False(a != a);
+// ReSharper restore EqualExpressionComparison
         }
 
         [Test]
diff --git a/Tests/PressureTests.cs b/Tests/PressureTests.cs
@@ -87,6 +87,7 @@ public void CompareToIsImplemented()
         public void CompareToThrowsOnTypeMismatch()
         {
             Pressure meter = Pressure.FromPascals(1);
+// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
             meter.CompareTo(new object());
         }
 
@@ -95,6 +96,7 @@ public void CompareToThrowsOnTypeMismatch()
         public void CompareToThrowsOnNull()
         { 
             Pressure meter = Pressure.FromPascals(1);
+// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
             meter.CompareTo(null);
         }
 
@@ -105,11 +107,13 @@ public void EqualityOperators()
             Pressure a = Pressure.FromPascals(1);
             Pressure b = Pressure.FromPascals(2);
 
+// ReSharper disable EqualExpressionComparison
             Assert.True(a == a); 
             Assert.True(a != b);
 
             Assert.False(a == b);
             Assert.False(a != a);
+// ReSharper restore EqualExpressionComparison
         }
 
         [Test]
diff --git a/Tests/UnitConversionTests.cs b/Tests/UnitConversionTests.cs
@@ -1,12 +1,11 @@
-﻿using System;
-using NUnit.Framework;
+﻿using NUnit.Framework;
 
 namespace UnitsNet.Tests.net35
 {
     [TestFixture]
     public class UnitConversionTests
     {
-        private const double Delta = 1E-5;
+        //private const double Delta = 1E-5;
 
         [Test]
         public void KilogramToKilogramForce()
diff --git a/Tests/VolumeTests.cs b/Tests/VolumeTests.cs
@@ -105,6 +105,7 @@ public void CompareToIsImplemented()
         public void CompareToThrowsOnTypeMismatch()
         {
             Volume meter = Volume.FromCubicMeters(1);
+// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
             meter.CompareTo(new object());
         }
 
@@ -113,6 +114,7 @@ public void CompareToThrowsOnTypeMismatch()
         public void CompareToThrowsOnNull()
         { 
             Volume meter = Volume.FromCubicMeters(1);
+// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
             meter.CompareTo(null);
         }
 
@@ -123,11 +125,13 @@ public void EqualityOperators()
             Volume a = Volume.FromCubicMeters(1);
             Volume b = Volume.FromCubicMeters(2);
 
+// ReSharper disable EqualExpressionComparison
             Assert.True(a == a); 
             Assert.True(a != b);
 
             Assert.False(a == b);
             Assert.False(a != a);
+// ReSharper restore EqualExpressionComparison
         }
 
         [Test]

Original file line number	Diff line number	Diff line change
`@@ -83,6 +83,7 @@ public void CompareToIsImplemented()`
`83`	`83`	`public void CompareToThrowsOnTypeMismatch()`
`84`	`84`	`{`
`85`	`85`	`Area meter = Area.FromSquareMeters(1);`
	`86`	`+// ReSharper disable once ReturnValueOfPureMethodIsNotUsed`
`86`	`87`	`meter.CompareTo(new object());`
`87`	`88`	`}`
`88`	`89`
`@@ -91,6 +92,7 @@ public void CompareToThrowsOnTypeMismatch()`
`91`	`92`	`public void CompareToThrowsOnNull()`
`92`	`93`	`{`
`93`	`94`	`Area meter = Area.FromSquareMeters(1);`
	`95`	`+// ReSharper disable once ReturnValueOfPureMethodIsNotUsed`
`94`	`96`	`meter.CompareTo(null);`
`95`	`97`	`}`
`96`	`98`
`@@ -101,11 +103,13 @@ public void EqualityOperators()`
`101`	`103`	`Area a = Area.FromSquareMeters(1);`
`102`	`104`	`Area b = Area.FromSquareMeters(2);`
`103`	`105`
	`106`	`+// ReSharper disable EqualExpressionComparison`
`104`	`107`	`Assert.True(a == a);`
`105`	`108`	`Assert.True(a != b);`
`106`	`109`
`107`	`110`	`Assert.False(a == b);`
`108`	`111`	`Assert.False(a != a);`
	`112`	`+// ReSharper restore EqualExpressionComparison`
`109`	`113`	`}`
`110`	`114`
`111`	`115`	`[Test]`
Original file line number	Diff line number	Diff line change
`@@ -79,6 +79,7 @@ public void CompareToIsImplemented()`
`79`	`79`	`public void CompareToThrowsOnTypeMismatch()`
`80`	`80`	`{`
`81`	`81`	`Force newton = Force.FromNewtons(1);`
	`82`	`+// ReSharper disable once ReturnValueOfPureMethodIsNotUsed`
`82`	`83`	`newton.CompareTo(new object());`
`83`	`84`	`}`
`84`	`85`
`@@ -87,6 +88,7 @@ public void CompareToThrowsOnTypeMismatch()`
`87`	`88`	`public void CompareToThrowsOnNull()`
`88`	`89`	`{`
`89`	`90`	`Force newton = Force.FromNewtons(1);`
	`91`	`+// ReSharper disable once ReturnValueOfPureMethodIsNotUsed`
`90`	`92`	`newton.CompareTo(null);`
`91`	`93`	`}`
`92`	`94`
`@@ -96,11 +98,13 @@ public void EqualityOperators()`
`96`	`98`	`Force a = Force.FromNewtons(1);`
`97`	`99`	`Force b = Force.FromNewtons(2);`
`98`	`100`
	`101`	`+// ReSharper disable EqualExpressionComparison`
`99`	`102`	`Assert.True(a == a);`
`100`	`103`	`Assert.True(a != b);`
`101`	`104`
`102`	`105`	`Assert.False(a == b);`
`103`	`106`	`Assert.False(a != a);`
	`107`	`+// ReSharper restore EqualExpressionComparison`
`104`	`108`	`}`
`105`	`109`
`106`	`110`	`[Test]`
Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@`
`3`	`3`	`namespace UnitsNet.Tests.net35`
`4`	`4`	`{`
`5`	`5`	`[TestFixture]`
	`6`	`+// ReSharper disable once InconsistentNaming`
`6`	`7`	`public class Length2dTests`
`7`	`8`	`{`
`8`	`9`	`private const double Delta = 1E-5;`
`@@ -83,11 +84,13 @@ public void EqualityOperators()`
`83`	`84`	`Length2d a = Length2d.FromMeters(1, 2);`
`84`	`85`	`Length2d b = Length2d.FromMeters(2, 1);`
`85`	`86`
	`87`	`+// ReSharper disable EqualExpressionComparison`
`86`	`88`	`Assert.True(a == a);`
`87`	`89`	`Assert.True(a != b);`
`88`	`90`
`89`	`91`	`Assert.False(a == b);`
`90`	`92`	`Assert.False(a != a);`
	`93`	`+// ReSharper restore EqualExpressionComparison`
`91`	`94`	`}`
`92`	`95`
`93`	`96`	`[Test]`
Original file line number	Diff line number	Diff line change
`@@ -90,6 +90,7 @@ public void CompareToIsImplemented()`
`90`	`90`	`public void CompareToThrowsOnTypeMismatch()`
`91`	`91`	`{`
`92`	`92`	`Length meter = Length.FromMeters(1);`
	`93`	`+// ReSharper disable once ReturnValueOfPureMethodIsNotUsed`
`93`	`94`	`meter.CompareTo(new object());`
`94`	`95`	`}`
`95`	`96`
`@@ -98,6 +99,7 @@ public void CompareToThrowsOnTypeMismatch()`
`98`	`99`	`public void CompareToThrowsOnNull()`
`99`	`100`	`{`
`100`	`101`	`Length meter = Length.FromMeters(1);`
	`102`	`+// ReSharper disable once ReturnValueOfPureMethodIsNotUsed`
`101`	`103`	`meter.CompareTo(null);`
`102`	`104`	`}`
`103`	`105`
`@@ -108,11 +110,13 @@ public void EqualityOperators()`
`108`	`110`	`Length a = Length.FromMeters(1);`
`109`	`111`	`Length b = Length.FromMeters(2);`
`110`	`112`
	`113`	`+// ReSharper disable EqualExpressionComparison`
`111`	`114`	`Assert.True(a == a);`
`112`	`115`	`Assert.True(a != b);`
`113`	`116`
`114`	`117`	`Assert.False(a == b);`
`115`	`118`	`Assert.False(a != a);`
	`119`	`+// ReSharper restore EqualExpressionComparison`
`116`	`120`	`}`
`117`	`121`
`118`	`122`	`[Test]`
Original file line number	Diff line number	Diff line change
`@@ -91,6 +91,7 @@ public void CompareToIsImplemented()`
`91`	`91`	`public void CompareToThrowsOnTypeMismatch()`
`92`	`92`	`{`
`93`	`93`	`Mass meter = Mass.FromKilograms(1);`
	`94`	`+// ReSharper disable once ReturnValueOfPureMethodIsNotUsed`
`94`	`95`	`meter.CompareTo(new object());`
`95`	`96`	`}`
`96`	`97`
`@@ -99,6 +100,7 @@ public void CompareToThrowsOnTypeMismatch()`
`99`	`100`	`public void CompareToThrowsOnNull()`
`100`	`101`	`{`
`101`	`102`	`Mass meter = Mass.FromKilograms(1);`
	`103`	`+// ReSharper disable once ReturnValueOfPureMethodIsNotUsed`
`102`	`104`	`meter.CompareTo(null);`
`103`	`105`	`}`
`104`	`106`
`@@ -109,11 +111,13 @@ public void EqualityOperators()`
`109`	`111`	`Mass a = Mass.FromKilograms(1);`
`110`	`112`	`Mass b = Mass.FromKilograms(2);`
`111`	`113`
	`114`	`+// ReSharper disable EqualExpressionComparison`
`112`	`115`	`Assert.True(a == a);`
`113`	`116`	`Assert.True(a != b);`
`114`	`117`
`115`	`118`	`Assert.False(a == b);`
`116`	`119`	`Assert.False(a != a);`
	`120`	`+// ReSharper restore EqualExpressionComparison`
`117`	`121`	`}`
`118`	`122`
`119`	`123`	`[Test]`
Original file line number	Diff line number	Diff line change
`@@ -87,6 +87,7 @@ public void CompareToIsImplemented()`
`87`	`87`	`public void CompareToThrowsOnTypeMismatch()`
`88`	`88`	`{`
`89`	`89`	`Pressure meter = Pressure.FromPascals(1);`
	`90`	`+// ReSharper disable once ReturnValueOfPureMethodIsNotUsed`
`90`	`91`	`meter.CompareTo(new object());`
`91`	`92`	`}`
`92`	`93`
`@@ -95,6 +96,7 @@ public void CompareToThrowsOnTypeMismatch()`
`95`	`96`	`public void CompareToThrowsOnNull()`
`96`	`97`	`{`
`97`	`98`	`Pressure meter = Pressure.FromPascals(1);`
	`99`	`+// ReSharper disable once ReturnValueOfPureMethodIsNotUsed`
`98`	`100`	`meter.CompareTo(null);`
`99`	`101`	`}`
`100`	`102`
`@@ -105,11 +107,13 @@ public void EqualityOperators()`
`105`	`107`	`Pressure a = Pressure.FromPascals(1);`
`106`	`108`	`Pressure b = Pressure.FromPascals(2);`
`107`	`109`
	`110`	`+// ReSharper disable EqualExpressionComparison`
`108`	`111`	`Assert.True(a == a);`
`109`	`112`	`Assert.True(a != b);`
`110`	`113`
`111`	`114`	`Assert.False(a == b);`
`112`	`115`	`Assert.False(a != a);`
	`116`	`+// ReSharper restore EqualExpressionComparison`
`113`	`117`	`}`
`114`	`118`
`115`	`119`	`[Test]`
Original file line number	Diff line number	Diff line change
`@@ -1,12 +1,11 @@`
`1`		`-using System;`
`2`		`-using NUnit.Framework;`
	`1`	`+using NUnit.Framework;`
`3`	`2`
`4`	`3`	`namespace UnitsNet.Tests.net35`
`5`	`4`	`{`
`6`	`5`	`[TestFixture]`
`7`	`6`	`public class UnitConversionTests`
`8`	`7`	`{`
`9`		`- private const double Delta = 1E-5;`
	`8`	`+ //private const double Delta = 1E-5;`
`10`	`9`
`11`	`10`	`[Test]`
`12`	`11`	`public void KilogramToKilogramForce()`
Original file line number	Diff line number	Diff line change
`@@ -105,6 +105,7 @@ public void CompareToIsImplemented()`
`105`	`105`	`public void CompareToThrowsOnTypeMismatch()`
`106`	`106`	`{`
`107`	`107`	`Volume meter = Volume.FromCubicMeters(1);`
	`108`	`+// ReSharper disable once ReturnValueOfPureMethodIsNotUsed`
`108`	`109`	`meter.CompareTo(new object());`
`109`	`110`	`}`
`110`	`111`
`@@ -113,6 +114,7 @@ public void CompareToThrowsOnTypeMismatch()`
`113`	`114`	`public void CompareToThrowsOnNull()`
`114`	`115`	`{`
`115`	`116`	`Volume meter = Volume.FromCubicMeters(1);`
	`117`	`+// ReSharper disable once ReturnValueOfPureMethodIsNotUsed`
`116`	`118`	`meter.CompareTo(null);`
`117`	`119`	`}`
`118`	`120`
`@@ -123,11 +125,13 @@ public void EqualityOperators()`
`123`	`125`	`Volume a = Volume.FromCubicMeters(1);`
`124`	`126`	`Volume b = Volume.FromCubicMeters(2);`
`125`	`127`
	`128`	`+// ReSharper disable EqualExpressionComparison`
`126`	`129`	`Assert.True(a == a);`
`127`	`130`	`Assert.True(a != b);`
`128`	`131`
`129`	`132`	`Assert.False(a == b);`
`130`	`133`	`Assert.False(a != a);`
	`134`	`+// ReSharper restore EqualExpressionComparison`
`131`	`135`	`}`
`132`	`136`
`133`	`137`	`[Test]`