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 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 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);
        }
    }
}