using MiscUtil;
using NUnit.Framework;

namespace System
{
    /// <summary>
    /// A set of tests for testing types that overload the relational operators:
    /// less than (&lt;), (&gt;)>, less than or equal to (&lt;)=, or 
    /// greater than or equal to (&gt;=).
    /// </summary>
    /// <typeparam name="T">The type that is to be tested.</typeparam>
    public abstract class RelationalOperatorTests<T>
    {
        [Test, Description("A test to ensure the following code produces the " +
            "proper result: X < Y")]
        public void LessThanTest()
        {
            {
                bool result = Operator.LessThan(CreateX(), CreateLessThan());
                Assert.False(result, "The result of the operation was not what " +
                    "was expected.");
            }

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

            {
                bool result = Operator.LessThan(CreateX(), CreateGreaterThan());
                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 FlippedLessThanTest()
        {
            {
                bool result = Operator.LessThan(CreateLessThan(), CreateX());
                Assert.True(result, "The result of the operation was not what " +
                    "was expected.");
            }

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

            {
                bool result = Operator.LessThan(CreateGreaterThan(), 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 GreaterThanTest()
        {
            {
                bool result = Operator.GreaterThan(CreateX(), CreateLessThan());
                Assert.True(result, "The result of the operation was not what " +
                    "was expected.");
            }

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

            {
                bool result = Operator.GreaterThan(CreateX(), CreateGreaterThan());
                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 FlippedGreaterThanTest()
        {
            {
                bool result = Operator.GreaterThan(CreateLessThan(), CreateX());
                Assert.False(result, "The result of the operation was not what " +
                    "was expected.");
            }

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

            {
                bool result = Operator.GreaterThan(CreateGreaterThan(), CreateX());
                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: X <= Y")]
        public void LessThanOrEqualToTest()
        {
            {
                bool result = Operator.LessThanOrEqual(CreateX(), CreateLessThan());
                Assert.False(result, "The result of the operation was not what " +
                    "was expected.");
            }

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

            {
                bool result = Operator.LessThanOrEqual(CreateX(), CreateGreaterThan());
                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 FlippedLessThanOrEqualToTest()
        {
            {
                bool result = Operator.LessThanOrEqual(CreateLessThan(), CreateX());
                Assert.True(result, "The result of the operation was not what " +
                    "was expected.");
            }

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

            {
                bool result = Operator.LessThanOrEqual(CreateGreaterThan(), 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 GreaterThanOrEqualToTest()
        {
            {
                bool result = Operator.GreaterThanOrEqual(CreateX(), CreateLessThan());
                Assert.True(result, "The result of the operation was not what " +
                    "was expected.");
            }

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

            {
                bool result = Operator.GreaterThanOrEqual(CreateX(), CreateGreaterThan());
                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 FlippedGreaterThanOrEqualToTest()
        {
            {
                bool result = Operator.GreaterThanOrEqual(CreateLessThan(), CreateX());
                Assert.False(result, "The result of the operation was not what " +
                    "was expected.");
            }

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

            {
                bool result = Operator.GreaterThanOrEqual(CreateGreaterThan(), 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 the less than.
        /// </summary>
        /// <returns></returns>
        protected abstract T CreateLessThan();

        /// <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 greater
        /// than the instance created by <see cref="CreateX()"/>.
        /// </summary>
        /// <returns>The instance to be tested.</returns>
        protected abstract T CreateGreaterThan();
    }
}