using MiscUtil;
using NUnit.Framework;

namespace System
{
    /// <summary>
    /// A set of tests for determining proper operation of the following 
    /// operators: + (binary), - (unary and binary), * , /
    /// </summary>
    /// <typeparam name="T">The type that is to be tested.</typeparam>
    public abstract class MathematicalOperatorTests<T>
    {
        [Test, Description("A test for checking the binary addition (+) operator.")]
        public void BinaryAdditionTest()
        {
            if(default(T).Equals(ExpectedBinaryAdditionResult) == false)
            {
                {
                    T result = Operator.Add(CreateX(), CreateY());
                    Assert.AreEqual(ExpectedBinaryAdditionResult, result,
                        "X + Y did not produce the expected result.");   
                }

                {
                    T result = Operator.Add(CreateY(), CreateX());
                    Assert.AreEqual(OppositeExpectedBinaryAdditionResult, result,
                        "Y + X did not produce the expected result.");   
                }
            }
            else
                Assert.Pass("Type does not implement binary addition operator.");
        }

        [Test, Description("A test for checking the binary subtraction (-) operator.")]
        public void BinarySubtractionTest()
        {
            if (default(T).Equals(ExpectedBinarySubtractionResult) == false)
            {
                {
                    T result = Operator.Subtract(CreateX(), CreateY());
                    Assert.AreEqual(ExpectedBinarySubtractionResult, result,
                        "X - Y did not produce the expected result.");
                }

                {
                    T result = Operator.Subtract(CreateY(), CreateX());
                    Assert.AreEqual(OppositeExpectedBinarySubtractionResult, result,
                        "Y - X did not produce the expected result.");
                }
            }
            else
                Assert.Pass("Type does not implement binary subtraction operator.");
        }

        [Test, Description("A test for checking the negation (-) operator.")]
        public void NegationTest()
        {
            if (default(T).Equals(ExpectedNegationResult) == false)
            {
                {
                    T result = Operator.Negate(CreateX());
                    Assert.AreEqual(ExpectedNegationResult, result,
                        "-X + Y did not produce the expected result.");
                }
            }
            else
                Assert.Pass("Type does not implement negation operator.");
        }

        [Test, Description("A test for checking the multiplication operator.")]
        public void MultiplicationTest()
        {
            if (default(T).Equals(ExpectedMultiplicationResult) == false)
            {
                {
                    T result = Operator.Multiply(CreateX(), CreateY());
                    Assert.AreEqual(ExpectedMultiplicationResult, result,
                        "X * Y did not produce the expected result.");
                }

                {
                    T result = Operator.Multiply(CreateY(), CreateX());
                    Assert.AreEqual(OppositeExpectedMultiplicationResult, result,
                        "Y * X did not produce the expected result.");
                }
            }
            else
                Assert.Pass("Type does not implement multiplication operator.");
        }

        [Test, Description("A test for checking the division operator.")]
        public void DivisionTest()
        {
            if (default(T).Equals(ExpectedDivisionResult) == false)
            {
                {
                    T result = Operator.Divide(CreateX(), CreateY());
                    Assert.AreEqual(ExpectedDivisionResult, result,
                        "X / Y did not produce the expected result.");
                }

                {
                    T result = Operator.Divide(CreateY(), CreateX());
                    Assert.AreEqual(OppositeExpectedDivisionResult, result,
                        "Y / X did not produce the expected result.");
                }
            }
            else
                Assert.Pass("Type does not implement division operator.");
        }

        // TODO: Tests for the increment (++x), decrement (--x), and unary plus (+x) operators need to be implemented.

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

        /// <summary>
        /// Creates the second operand or 'Y'.
        /// </summary>
        /// <returns>The instance to be tested.</returns>
        protected abstract T CreateY();

        /// <summary>
        /// Returns the result that is expected from the operation: 
        /// <see cref="CreateX()"/> + <see cref="CreateY()"/>. If this property
        /// returns the default(T) value, then it is assumed that the type
        /// <typeparamref name="T"/> does not implement a binary addition
        /// operation and it is therefore not tested.
        /// </summary>
        protected abstract T ExpectedBinaryAdditionResult { get; }

        /// <summary>
        /// Returns the result that is expected from the operation: 
        /// <see cref="CreateY()"/> + <see cref="CreateX()"/>. By default, 
        /// this property returns the value of 
        /// <see cref="ExpectedBinaryAdditionResult"/>. In other words, by
        /// default, the test assumes the operation being tested on type 
        /// <typeparamref name="T"/> is commutative.
        /// </summary>
        protected virtual T OppositeExpectedBinaryAdditionResult { get { return ExpectedBinaryAdditionResult; } }

        /// <summary>
        /// Returns the result that is expected from the operation: 
        /// <see cref="CreateX()"/> - <see cref="CreateY()"/>. If this property
        /// returns the default(T) value, then it is assumed that the type
        /// <typeparamref name="T"/> does not implement a binary subtraction
        /// operation and it is therefore not tested.
        /// </summary>
        protected abstract T ExpectedBinarySubtractionResult { get; }

        /// <summary>
        /// Returns the result that is expected from the operation: 
        /// <see cref="CreateY()"/> - <see cref="CreateX()"/>. If this property
        /// returns the default(T) value, then it is assumed that the type
        /// <typeparamref name="T"/> does not implement a binary subtraction
        /// operation and it is therefore not tested.
        /// </summary>
        protected abstract T OppositeExpectedBinarySubtractionResult { get; }

        /// <summary>
        /// Returns the result that is expected from the operation: 
        /// -<see cref="CreateX()"/>. If this property returns the default(T) 
        /// value, then it is assumed that the type <typeparamref name="T"/> 
        /// does not implement a negation operation and it is therefore not 
        /// tested.
        /// </summary>
        protected abstract T ExpectedNegationResult { get; }

        /// <summary>
        /// Returns the result that is expected from the operation: 
        /// <see cref="CreateX()"/> * <see cref="CreateY()"/>. If this property
        /// returns the default(T) value, then it is assumed that the type
        /// <typeparamref name="T"/> does not implement a multiplication
        /// operation and it is therefore not tested.
        /// </summary>
        protected abstract T ExpectedMultiplicationResult { get; }

        /// <summary>
        /// Returns the result that is expected from the operation: 
        /// <see cref="CreateY()"/> * <see cref="CreateX()"/>. By default, 
        /// this property returns the value of 
        /// <see cref="ExpectedMultiplicationResult"/>. In other words, by
        /// default, the test assumes the operation being tested on type 
        /// <typeparamref name="T"/> is commutative.
        /// </summary>
        protected virtual T OppositeExpectedMultiplicationResult { get { return ExpectedMultiplicationResult; } }

        /// <summary>
        /// Returns the result that is expected from the operation: 
        /// <see cref="CreateX()"/> / <see cref="CreateY()"/>. If this property
        /// returns the default(T) value, then it is assumed that the type
        /// <typeparamref name="T"/> does not implement a division
        /// operation and it is therefore not tested.
        /// </summary>
        protected abstract T ExpectedDivisionResult { get; }

        /// <summary>
        /// Returns the result that is expected from the operation: 
        /// <see cref="CreateY()"/> / <see cref="CreateX()"/>. If this property
        /// returns the default(T) value, then it is assumed that the type
        /// <typeparamref name="T"/> does not implement a division
        /// operation and it is therefore not tested.
        /// </summary>
        protected abstract T OppositeExpectedDivisionResult { get; }
    }
}