using MiscUtil;
using NUnit.Framework;

namespace System
{
    /// <summary>
    /// A set of tests for testing types that overload the equality operators
    /// (== or !=).
    /// </summary>
    /// <typeparam name="T">The type that is to be tested.</typeparam>
    public abstract class EqualityOperatorTests<T>
    {
        [Test, Description("A test to ensure the following code produces the " + 
            "proper result: X == Y")]
        public void EqualTest()
        {
            {
                bool result = Operator.Equal(CreateX(), CreateEqual());
                Assert.True(result, "The result of the operation was not what " +
                    "was expected");   
            }

            {
                bool result = Operator.Equal(CreateX(), CreateNotEqual());
                Assert.False(result, "The result of the operation was not what " +
                    "was expected");   
            }
        }

        [Test, Description("A test to ensure the following code produces the " +
            "proper result: Y == X")]
        public void FlippedEqualTest()
        {
            {
                bool result = Operator.Equal(CreateEqual(), CreateX());
                Assert.True(result, "The result of the operation was not what " +
                    "was expected");
            }

            {
                bool result = Operator.Equal(CreateNotEqual(), CreateX());
                Assert.False(result, "The result of the operation was not what " +
                    "was expected");
            }
        }

        [Test, Description("A test to ensure the following code produces the " +
            "proper result: X != Y")]
        public void NotEqualTest()
        {
            {
                bool result = Operator.NotEqual(CreateX(), CreateEqual());
                Assert.False(result, "The result of the operation was not what " +
                    "was expected");
            }

            {
                bool result = Operator.NotEqual(CreateX(), CreateNotEqual());
                Assert.True(result, "The result of the operation was not what " +
                    "was expected");
            }
        }

        [Test, Description("A test to ensure the following code produces the " +
            "proper result: Y != X")]
        public void FlippedNotEqualTest()
        {
            {
                bool result = Operator.NotEqual(CreateEqual(), CreateX() );
                Assert.False(result, "The result of the operation was not what " +
                    "was expected");
            }

            {
                bool result = Operator.NotEqual(CreateNotEqual(), CreateX());
                Assert.True(result, "The result of the operation was not what " +
                    "was expected");
            }
        }

        /// <summary>
        /// Creates an operand to be tested (or 'X'). 
        /// </summary>
        /// <returns>The instance to be tested.</returns>
        protected abstract T CreateX();

        /// <summary>
        /// Creates an instance of type <typeparamref name="T"/> that is equal
        /// to the instance created by <see cref="CreateX()"/>.
        /// </summary>
        /// <returns>The instance to be tested.</returns>
        protected abstract T CreateEqual();

        /// <summary>
        /// Creates an instance of type <typeparamref name="T"/> that is not 
        /// equal to the instance created by <see cref="CreateX()"/>.
        /// </summary>
        /// <returns>The instance to be tested.</returns>
        protected abstract T CreateNotEqual();
    }

    /// <summary>
    /// A set of tests for testing the overloaded operators of references types.
    /// In other words, these tests take into account null values. This class
    /// also derives from <see cref="EqualityOperatorTests{T}"/> so that the 
    /// the tests provided by that class are implemented.
    /// </summary>
    /// <typeparam name="T">The reference type that is to be tested.</typeparam>
    public abstract class ReferenceEqualityOperatorTests<T> : EqualityOperatorTests<T> where T : class
    {
        [Test, Description("A test to ensure the following code produces the " +
            "proper result: X == null")]
        public void NullEqualTest()
        {
            bool result = Operator.Equal(CreateX(), null);
            Assert.False(result, "The result of the operation was not what " +
                "was expected");
        }

        [Test, Description("A test to ensure the following code produces the " +
            "proper result: null == Y")]
        public void FlippedNullEqualTest()
        {
            bool result = Operator.Equal(null, CreateX());
            Assert.False(result, "The result of the operation was not what " +
                "was expected");
        }

        [Test, Description("A test to ensure the following code produces the " +
            "proper result: X != null")]
        public void NullNotEqualTest()
        {
            bool result = Operator.NotEqual(CreateX(), null);
            Assert.True(result, "The result of the operation was not what " +
                "was expected");
        }

        [Test, Description("A test to ensure the following code produces the " +
            "proper result: null != Y")]
        public void FlippedNullNotEqualTest()
        {
            bool result = Operator.NotEqual(null, CreateX());
            Assert.True(result, "The result of the operation was not what " +
                "was expected");
        }
    }
}