using NUnit.Framework;

namespace System
{
    /// <summary>
    /// A set of tests for comparing <see cref="IComparable{T}"/> types.
    /// </summary>
    /// <typeparam name="T">The type that is passed to 
    /// <see cref="IEquatable{T}"/> as its generic parameter. The type being 
    /// compared against.</typeparam>
    public abstract class ComparableTests<T>
    {
        [Test, Description("A test to ensure that the IComparable<T>.CompareTo(T) " + 
            "method returns a value less than 0 when the instance passed to it " + 
            "is less than the IComparable<T>.")]
        public void LessThanTest()
        {
            IComparable<T> comparable = CreateComparable();
            T item = CreateLessThanObject();
            int value = comparable.CompareTo(item);

            Assert.Greater(value, 0, "The comparison showed that the IComparable<T> " +
                "was not less than the object passed to the IComparable<T>.CompareTo(T) " + 
                "method even though it was supposed to be.");
        }

        [Test, Description("A test to ensure that the IComparable<T>.CompareTo(T) " +
            "method returns a value equal to 0 when the instance passed to it " +
            "is equal to the IComparable<T>.")]
        public void EqualToTest()
        {
            IComparable<T> comparable = CreateComparable();
            T item = CreateEqualObject();
            int value = comparable.CompareTo(item);

            Assert.AreEqual(value, 0, "The comparison showed that the IComparable<T> " +
                "was not equal to the object passed to the IComparable<T>.CompareTo(T) " +
                "method even though it was supposed to be.");
        }

        [Test, Description("A test to ensure that the IComparable<T>.CompareTo(T) " +
            "method returns a value greater than 0 when the instance passed to " +
            "it is greater than the IComparable<T>.")]
        public void GreaterThanTest()
        {
            IComparable<T> comparable = CreateComparable();
            T item = CreateGreaterThanObject();
            int value = comparable.CompareTo(item);

            Assert.Less(value, 0, "The comparison showed that the IComparable<T> " +
                "was not greater than the object passed to the IComparable<T>.CompareTo(T) " +
                "method even though it was supposed to be.");
        }

        /// <summary>
        /// Creates the <see cref="IComparable{T}"/> instance that is to be 
        /// tested. This method should always create a new 
        /// <see cref="IComparable{T}"/> when this method is invoked and never 
        /// reuse instances.
        /// </summary>
        /// <returns>The <see cref="IComparable{T}"/> to test.</returns>
        protected abstract IComparable<T> CreateComparable();

        /// <summary>
        /// Creates an instance that should be less than the 
        /// <see cref="IComparable{T}"/> created by 
        /// <see cref="CreateComparable()"/>
        /// </summary>
        /// <returns>The instance to be tested against.</returns>
        protected abstract T CreateLessThanObject();

        /// <summary>
        /// Creates an instance that should be equal to the 
        /// <see cref="IComparable{T}"/> created by 
        /// <see cref="CreateComparable()"/>
        /// </summary>
        /// <returns>The instance to be tested against.</returns>
        protected abstract T CreateEqualObject();

        /// <summary>
        /// Creates an instance that should be greater than the 
        /// <see cref="IComparable{T}"/> created by 
        /// <see cref="CreateComparable()"/>
        /// </summary>
        /// <returns>The instance to be tested against.</returns>
        protected abstract T CreateGreaterThanObject();
    }
}