using UnitTestSharp;
using System.Collections.Generic;
using System.Collections;
using System.Linq;

namespace TestsForUnitTestSharp
{
    public class AssertTests : TestFixture
    {
        Assert assert = null;

        public override void FixtureSetup()
        {
            
        }

        public override void TestSetup()
        {
            assert = new Assert();
        }

        [UnitTestSharp.IgnoreTest]
        private void PreTest()
        {
            CheckEqual(0, assert.internals.FailedChecks);            
        }

        [UnitTestSharp.IgnoreTest]
        private void PostTest(bool testShouldPass)
        {
            int failedChecks = assert.internals.FailedChecks;
            
            CheckEqual(testShouldPass ? 0 : 1, failedChecks);
        }

        public void TODO()
        {
            const string todo = "Something I need to do.";
            PreTest();
            assert.TODO(todo);
            CheckEqual(0, assert.internals.FailedChecks);
            CheckNotEqual("", assert.internals.TestLog);
        }

        public void CheckTest_False()
        {
            PreTest();
            assert.Check(false);
            PostTest(false);
        }

        public void CheckTest_True()
        {
            PreTest();
            assert.Check(true);
            PostTest(true);
        }

        public void CheckGreater_True()
        {
            PreTest();
            assert.CheckGreater(4, 3);
            PostTest(true);
        }

        public void CheckGreater_False()
        {
            PreTest();
            assert.CheckGreater(3, 4);
            PostTest(false);
        }

        public void CheckGreater_Equal()
        {
            PreTest();
            assert.CheckGreater(4, 4);
            PostTest(false);
        }

        public void CheckGreater_ReferenceEquals()
        {
            PreTest();
            var obj = new object();
            assert.CheckGreater(obj, obj);
            PostTest(false);
        }

        public void CheckGreater_ExpectedNull()
        {
            PreTest();
            var obj = new object();
            CheckThrow();
            assert.CheckGreater(null, obj);
        }

        public void CheckGreater_ActualNull()
        {
            PreTest();
            var obj = new object();
            CheckThrow();
            assert.CheckGreater(null, null);
        }

        public void CheckGreater_NotComparable()
        {
            PreTest();
            CheckThrow();
            assert.CheckGreater(new object(), new object());
        }

        public void CheckLess_True()
        {
            PreTest();
            assert.CheckLess(3, 4);
            PostTest(true);
        }

        public void CheckLess_False()
        {
            PreTest();
            assert.CheckLess(4, 3);
            PostTest(false);
        }

        public void CheckLess_Equal()
        {
            PreTest();
            assert.CheckLess(4, 4);
            PostTest(false);
        }

        public void CheckLess_ReferenceEquals()
        {
            PreTest();
            var obj = new object();
            assert.CheckLess(obj, obj);
            PostTest(false);
        }

        public void CheckLess_ExpectedNull()
        {
            PreTest();
            var obj = new object();
            CheckThrow();
            assert.CheckLess(null, obj);
        }

        public void CheckLess_ActualNull()
        {
            PreTest();
            var obj = new object();
            CheckThrow();
            assert.CheckLess(null, null);
        }

        public void CheckLess_NotComparable()
        {
            PreTest();
            CheckThrow();
            assert.CheckLess(new object(), new object());
        }

        public void CheckTrueTest_False()
        {
            PreTest();
            assert.CheckTrue(false);
            PostTest(false);
        }

        public void CheckTrueTest_True()
        {
            PreTest();
            assert.CheckTrue(true);
            PostTest(true);
        }

        public void CheckFalseTest_False()
        {
            PreTest();
            assert.CheckFalse(true);
            PostTest(false); 
        }

        public void CheckFalseTest_True()
        {
            PreTest();
            assert.CheckFalse(false);
            PostTest(true);
        }

        public void CheckEqualTest_False()
        {
            PreTest();
            assert.CheckEqual(1, 0);
            PostTest(false);
        }

        public void CheckEqualTest_True()
        {
            PreTest();
            assert.CheckEqual(1, 1);
            PostTest(true);
        }

        public void CheckEqual_ExpectedNull()
        {
            PreTest();
            assert.CheckEqual(null, 1);
            PostTest(false);
        }

        public void CheckEqual_ActualNull()
        {
            PreTest();
            assert.CheckEqual(1, null);
            PostTest(false);
        }

        public void CheckEqual_BothNull()
        {
            PreTest();
            assert.CheckEqual(null, null);
            PostTest(true);
        }

        public void CheckNotEqualTest_False()
        {
            PreTest();
            assert.CheckNotEqual(1, 0);
            PostTest(true);
        }

        public void CheckNotEqualTest_True()
        {
            PreTest();
            assert.CheckNotEqual(1, 1);
            PostTest(false);
        }

        public void CheckNotEqual_ExpectedNull()
        {
            PreTest();
            assert.CheckNotEqual(null, 1);
            PostTest(true);
        }

        public void CheckNotEqual_ActualNull()
        {
            PreTest();
            assert.CheckNotEqual(1, null);
            PostTest(true);
        }

        public void CheckNotEqual_BothNull()
        {
            PreTest();
            assert.CheckNotEqual(null, null);
            PostTest(false);
        }

		public void CheckNullTest_null()
		{
			PreTest();
			assert.CheckNull(null);
			PostTest(true);
		}

		public void CheckNullTest_NotNull()
		{
			PreTest();
			assert.CheckNull(4);
			PostTest(false);
		}

		public void CheckNotNullTest_null()
		{
			PreTest();
			assert.CheckNotNull(null);
			PostTest(false);
		}

		public void CheckNotNullTest_NotNull()
		{
			PreTest();
			assert.CheckNotNull(4);
			PostTest(true);
		}

        public void CheckEqualTest_DifferentTypes_False_IJ()
        {
            bool i = false;
            float j = 5.5f;

            PreTest();
            assert.CheckEqual(i, j);
            PostTest(false);
        }

        public void CheckEqualTest_DifferentTypes_False_JI()
        {
            bool i = false;
            float j = 5.5f;

            PreTest();
            assert.CheckEqual(j, i);
            PostTest(false);
        }

        public void CheckEqualTest_DifferentTypes_True_IJ()
        {
            double i = 5;
            float j = 5;

            PreTest();
            assert.CheckEqual(j, i);
            PostTest(true);
        }

        public void CheckEqualTest_DifferentTypes_True_JI()
        {
            double i = 5;
            float j = 5;

            PreTest();
            assert.CheckEqual(j, i);
            PostTest(true);
        }

        public void CheckEqualTest_DifferentTypes_IJ()
        {
            byte i = 5;
            double j = 2000;

            PreTest();
            assert.CheckEqual(i, j);
            PostTest(false);
        }

        public void CheckEqualTest_DifferentTypes_JI()
        {
            byte i = 5;
            double j = 2000;

            PreTest();
            assert.CheckEqual(j, i);
            PostTest(false);
        }

        public struct FauxScalar
        {
            public override bool Equals(object obj)
            {
                return true;
            }

            public override int GetHashCode()
            {
                return base.GetHashCode();
            }
        }

        public void CheckEqualTest_DifferentTypes_SymmetryDoesntHold_IJ()
        {
            FauxScalar i = new FauxScalar();
            double j = 2;

            PreTest();
            assert.CheckEqual(i, j);
            PostTest(true);
        }

        public void CheckEqualTest_DifferentTypes_SymmetryDoesntHold_JI()
        {
            FauxScalar i = new FauxScalar();
            double j = 2;

            PreTest();
            assert.CheckEqual(j, i);
            PostTest(true);
        }

		public void BinaryEqualsThrows()
		{
			CheckThrow(typeof(System.Exception));
			Assert.Equals(1, 2);
		}

		public void UnaryEqualsThrows()
		{
			CheckThrow(typeof(System.Exception));
			assert.Equals(10);
		}

        public void CheckEqual_Collections()
        {
            IList<int> a = new int[] { 0, 1, 2 };
            var b = new int[] { 0, 1, 2 };

            CheckEqual(a, b);
            CheckEqual(b, a);
        }

        public void CheckEqual_YieldReturnCollections()
        {
            IList<int> a = new int[] { 0, 1, 2 };

            CheckEqual(a, a.Take(3));
        }

        public void CheckNotEqual_Collections()
        {
            IList<int> a = new int[] { 0, 1, 2 };
            var b = new int[] { 2, 1, 0 };

            CheckNotEqual(a, b);
            CheckNotEqual(b, a);
        }

        public void CheckNotEqual_Collections_DifferentSizes()
        {
            IList<int> a = new int[] { 0, 1, 2 };
            var b = new int[] { 0, 1, };

            CheckNotEqual(a, b);
            CheckNotEqual(b, a);
        }

        public void CheckEqual_Collections_Empty()
        {
            IList<int> a = new int[] { };
            var b = new int[] { };

            CheckEqual(a, b);
            CheckEqual(b, a);
        }

        public void CheckEqualCommutative_Equal()
        {
            IList<int> a = new int[] { 0, 1, 2 };
            var b = new int[] { 2, 1, 0 };

            CheckEqualCommutative(a, b);
            CheckEqualCommutative(b, a);
        }

        public void CheckEqualCommutative_ActualLonger()
        {
            IList<int> a = new int[] { 0, 1, 2 };
            var b = new int[] { 2, 1, 0, 2 };

            PreTest();
            assert.CheckEqualCommutative(a, b);
            PostTest(false);
        }

        public void CheckEqualCommutative_ExpectedLonger()
        {
            IList<int> a = new int[] { 0, 1, 2 };
            var b = new int[] { 2, 1, 0, 2 };

            PreTest();
            assert.CheckEqualCommutative(b, a);
            PostTest(false);
        }

        public void CheckEqualCommutative_MultiplicityOff()
        {
            IList<int> a = new int[] { 0, 1, 2, 1 };
            var b = new int[] { 2, 1, 0, 2 };

            PreTest();
            assert.CheckEqualCommutative(b, a);
            CheckEqual(2, assert.internals.FailedChecks);
        }

        public void CheckEqualCommutative_Strings()
        {
            var a = new string[]
            {
                "hello",
                "this",
                "one",
            };

            var b = new string[]
            {                
                "one",
                "hello",
                "this",                
            };

            CheckEqualCommutative(b, a);
            CheckEqualCommutative(a, b);
        }

        public void CheckEqualRegex_Positive()
        {   
            PreTest();
            assert.CheckEqualRegex("foo", "barfoobar");
            PostTest(true);
        }

        public void CheckEqualRegex_Negative()
        {
            PreTest();
            assert.CheckEqualRegex("foo", "barbar");
            PostTest(false);
        }

        public void CheckNotEqualRegex_Positive()
        {
            PreTest();
            assert.CheckNotEqualRegex("foo", "barbar");
            PostTest(true);
        }

        public void CheckNotEqualRegex_Negative()
        {
            PreTest();
            assert.CheckNotEqualRegex("foo", "barfoobar");
            PostTest(false);
        }

        public struct Testy
        {
            public int a;

            public Testy(int a)
            {
                this.a = a;
            }

            static int hash = 0;
            public override int GetHashCode()
            {
                return ++hash;
            }

            public override bool Equals(object obj)
            {
                return ((Testy)obj).a == a;
            }
        }

        public void UnreliableHashFunction()
        {
            var a = new Testy[] { new Testy(0), new Testy(1), new Testy(2) };
            var b = new Testy[] { new Testy(2), new Testy(1), new Testy(0) };

            CheckEqualCommutative(a, b);
            CheckEqualCommutative(b, a);
        }

        public void CheckThrowBasic()
        {
            CheckThrow(typeof(System.Exception));
            throw new System.Exception();
        }

        public void CheckThrowCatchesSubtypes()
        {
            CheckThrow(typeof(System.Exception));
            throw new System.ArgumentException();
        }

        public void CheckThrowDefault()
        {
            CheckThrow();
            throw new System.Exception();
        }
    }
}