Object Comparer

using System;

using Vts.UnitTest;

namespace Clifton.Tools.Compare
{
	[TestFixture]
	public class CompareUnitTests
	{
		public enum EnumTest
		{
			Zero,
			One,
			Two,
			Three
		}

		private Comparer comparer;

		public CompareUnitTests()
		{
		}

		[TestFixtureSetUp]
		public void Setup()
		{
			comparer=new Comparer();
		}

		// String comparisons

		[Test]
		public void CompareStringLT()
		{
			int ret=comparer.Compare("abc", "def");
			Assertion.Assert(ret == -1, "Unexpected return.");
		}

		[Test]
		public void CompareStringEQ()
		{
			int ret=comparer.Compare("abc", "abc");
			Assertion.Assert(ret == 0, "Unexpected return.");
		}

		[Test]
		public void CompareStringGT()
		{
			int ret=comparer.Compare("def", "abc");
			Assertion.Assert(ret == 1, "Unexpected return.");
		}

		// Numeric strings

		[Test]
		public void CompareNumericStringsLT()
		{
			string s1="1.9";
			string s2="2";
			int ret=comparer.Compare(s1, s2);
			Assertion.Assert(ret == -1, "Unexpected return.");
		}

		[Test]
		public void CompareNumericStringsEQ()
		{
			string s1="1";
			string s2="1.0";
			int ret=comparer.Compare(s1, s2);
			Assertion.Assert(ret == 0, "Unexpected return.");
		}

		[Test]
		public void CompareNumericStringsGT()
		{
			string s1="2";
			string s2="1.9";
			int ret=comparer.Compare(s1, s2);
			Assertion.Assert(ret == 1, "Unexpected return.");
		}

		// DateTime comparisons

		[Test]
		public void CompareDateTimeLT()
		{
			DateTime dt1=DateTime.Now - new TimeSpan(1, 0, 0, 0, 0);
			DateTime dt2=DateTime.Now;
			int ret=comparer.Compare(dt1, dt2);
			Assertion.Assert(ret == -1, "Unexpected return.");
		}

		[Test]
		public void CompareDateTimeEQ()
		{
			DateTime dt1=DateTime.Now;
			DateTime dt2=DateTime.Now;
			int ret=comparer.Compare(dt1, dt2);
			Assertion.Assert(ret == 0, "Unexpected return.");
		}

		[Test]
		public void CompareDateTimeGT()
		{
			DateTime dt1=DateTime.Now + new TimeSpan(1, 0, 0, 0, 0);
			DateTime dt2=DateTime.Now;
			int ret=comparer.Compare(dt1, dt2);
			Assertion.Assert(ret == 1, "Unexpected return.");
		}

		// Guid comparisons

		[Test]
		public void CompareGuidLT()
		{
			Guid g1=new Guid("CA761232-ED42-11CE-BACD-00AA0057B223");
			Guid g2=new Guid("DA761232-ED42-11CE-BACD-00AA0057B223");
			int ret=comparer.Compare(g1, g2);
			Assertion.Assert(ret == -1, "Unexpected return.");
		}

		[Test]
		public void CompareGuidEQ()
		{
			Guid g1=new Guid("CA761232-ED42-11CE-BACD-00AA0057B223");
			Guid g2=new Guid("CA761232-ED42-11CE-BACD-00AA0057B223");
			int ret=comparer.Compare(g1, g2);
			Assertion.Assert(ret == 0, "Unexpected return.");
		}

		[Test]
		public void CompareGuidGT()
		{
			Guid g1=new Guid("DA761232-ED42-11CE-BACD-00AA0057B223");
			Guid g2=new Guid("CA761232-ED42-11CE-BACD-00AA0057B223");
			int ret=comparer.Compare(g1, g2);
			Assertion.Assert(ret == 1, "Unexpected return.");
		}

		// Numeric comparisons of same type

		[Test]
		public void CompareNumericLT()
		{
			int i1=10;
			int i2=20;
			int ret=comparer.Compare(i1, i2);
			Assertion.Assert(ret == -1, "Unexpected return.");
		}

		[Test]
		public void CompareNumericEQ()
		{
			int i1=10;
			int i2=10;
			int ret=comparer.Compare(i1, i2);
			Assertion.Assert(ret == 0, "Unexpected return.");
		}

		[Test]
		public void CompareNumericGT()
		{
			int i1=20;
			int i2=10;
			int ret=comparer.Compare(i1, i2);
			Assertion.Assert(ret == 1, "Unexpected return.");
		}

		// Numeric comparisons of different types

		[Test]
		public void CompareIntToDoubleLT()
		{
			int i=1;
			double d=1.1;
			int ret=comparer.Compare(i, d);
			Assertion.Assert(ret == -1, "Unexpected return.");
		}

		[Test]
		public void CompareDoubleToIntLT()
		{
			double d=1.9;
			int i=2;
			int ret=comparer.Compare(d, i);
			Assertion.Assert(ret == -1, "Unexpected return.");
		}

		[Test]
		public void CompareDoubleToIntEQ()
		{
			double d=2;
			int i=2;
			int ret=comparer.Compare(d, i);
			Assertion.Assert(ret == 0, "Unexpected return.");
		}

		// String to numeric type comparison

		[Test]
		public void CompareDoubleToString()
		{
			double d=1.9;
			string s="2";
			int ret=comparer.Compare(d, s);
			Assertion.Assert(ret == -1, "Unexpected return.");
		}

		[Test]
		public void CompareStringToDouble()
		{
			string s="1.9";
			double d=2;
			int ret=comparer.Compare(s, d);
			Assertion.Assert(ret == -1, "Unexpected return.");
		}

		// Compare string of non-int type with string

		[Test]
		public void CompareStringDoubleToInt()
		{
			string s="1.9";
			int i=2;
			int ret=comparer.Compare(s, i);
			Assertion.Assert(ret == -1, "Unexpected return.");
		}

		// Enum tests with int's

		[Test]
		public void CompareEnumToIntLT()
		{
			EnumTest et=EnumTest.One;
			int i=2;
			int ret=comparer.Compare(et, i);
			Assertion.Assert(ret == -1, "Unexpected return.");
		}

		[Test]
		public void CompareEnumToIntEQ()
		{
			EnumTest et=EnumTest.One;
			int i=1;
			int ret=comparer.Compare(et, i);
			Assertion.Assert(ret == 0, "Unexpected return.");
		}

		[Test]
		public void CompareEnumToIntGT()
		{
			EnumTest et=EnumTest.Two;
			int i=1;
			int ret=comparer.Compare(et, i);
			Assertion.Assert(ret == 1, "Unexpected return.");
		}

		// Enum tests with doubles's

		[Test]
		public void CompareEnumToDoubleLT()
		{
			EnumTest et=EnumTest.One;
			double d=2;
			int ret=comparer.Compare(et, d);
			Assertion.Assert(ret == -1, "Unexpected return.");
		}

		[Test]
		public void CompareEnumToDoubleEQ()
		{
			EnumTest et=EnumTest.One;
			double d=1;
			int ret=comparer.Compare(et, d);
			Assertion.Assert(ret == 0, "Unexpected return.");
		}

		[Test]
		public void CompareEnumToDoubleGT()
		{
			EnumTest et=EnumTest.Two;
			double d=1;
			int ret=comparer.Compare(et, d);
			Assertion.Assert(ret == 1, "Unexpected return.");
		}

		// Unsigned comparisons

		[Test]
		public void CompareUnsignedToSigned()
		{
			ushort s1=0xFFFF;
			short s2=0x7FFF;
			int ret=comparer.Compare(s1, s2);
			Assertion.Assert(ret == 1, "Unexpected return.");
		}

		[Test]
		public void CompareSignedToUnsigned()
		{
			short s1=0x7FFF;
			ushort s2=0xFFFF;
			int ret=comparer.Compare(s1, s2);
			Assertion.Assert(ret == -1, "Unexpected return.");
		}

		// boolean tests

		[Test]
		public void BooleanLT()
		{
			bool b=false;
			int ret=comparer.Compare(b, 1);
			Assertion.Assert(ret == -1, "Unexpected return.");
		}
	}
}