using NUnit.Framework;

namespace System
{
    /// <summary>
    /// A helper test fixture base class that can be used to test types the
    /// implement the <see cref="IEquatable{T}"/> interface. This set of tests 
    /// also implements the <see cref="ObjectTests"/> test fixture helper class 
    /// because types that implement <see cref="IEquatable{T}"/> are likely to 
    /// overload methods in <see cref="Object"/> since they are similar in 
    /// function (for example, <see cref="IEquatable{T}.Equals(T)"/> and 
    /// <see cref="Object.Equals(object)"/>).
    /// </summary>
    /// <typeparam name="T">The type that is passed to 
    /// <see cref="IEquatable{T}"/> as its generic parameter.</typeparam>
    public abstract class EquatableTests<T> : ObjectTests
    {
        [Test, Description("Tests the IEquatable<T>.Equals(T) method to ensure " + 
            "it returns true when passed an instance that should be equal to it.")]
        public void AreEqual()
        {
            IEquatable<T> equatable = CreateEquatable();
            T equalInstance = CreateEqualObject();

            Assert.That(equatable.Equals(equalInstance), "The IEquatable<T> " +
                "instance should be equal to the IEquatable<T> instance but the " +
                "IEquatable<T>.Equals(T) method returned false.");
        }

        [Test, Description("Tests the IEquatable<T>.Equals(T) method to ensure " +
            "it returns false when passed an instance that should NOT be equal to it.")]
        public void AreNotEqual()
        {
            IEquatable<T> equatable = CreateEquatable();
            T equalInstance = CreateNotEqualObject();

            Assert.That(equatable.Equals(equalInstance) == false, "The " +
                "IEquatable<T> instance should NOT be equal to the IEquatable<T> " +
                "instance but the IEquatable<T>.Equals(T) method returned true.");
        }

        /// <summary>
        /// Creates an <see cref="Object"/> to use for testing. This method
        /// should always return a new object and never reuse values.
        /// </summary>
        /// <returns>The <see cref="Object"/> to be tested</returns>
        protected override object CreateObject()
        {
            return CreateEquatable();
        }

        /// <summary>
        /// Creates an <see cref="Object"/> to use for testing. This method
        /// should create an object that is the same as the <see cref="Object"/>
        /// created by <see cref="CreateObject()"/> but are not the same
        /// instance (i.e. <see cref="object.ReferenceEquals(Object, Object)"/>
        /// should not return true). This method should always return a new
        /// object and never reuse values.
        /// </summary>
        /// <returns>The <see cref="Object"/> to be tested</returns>
        protected override object CreateSameObject()
        {
            return CreateEqualObject();
        }

        /// <summary>
        /// Creates an <see cref="Object"/> to use for testing. This method
        /// should create an object that is different from the <see cref="Object"/>
        /// created by <see cref="CreateObject()"/>. This method should always
        /// return a new object and never reuse values.
        /// </summary>
        /// <returns>The <see cref="Object"/> to be tested</returns>
        protected override object CreateDifferentObject()
        {
            return CreateNotEqualObject();
        }

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

        /// <summary>
        /// Creates an instance of the type <typeparamref name="T"/> that is 
        /// equal to the instance created by the method 
        /// <see cref="CreateEquatable()"/> (i.e., the 
        /// <see cref="IEquatable{T}.Equals(T)"/> should return true). A new 
        /// instance should be created every time this method is invoked; 
        /// instances should never be reused.
        /// </summary>
        /// <returns>The instance that is to be tested for equality against the 
        /// instance created by <see cref="CreateEquatable()"/>.</returns>
        protected abstract T CreateEqualObject();

        /// <summary>
        /// Creates an instance of the type <typeparamref name="T"/> that is 
        /// NOT equal to the instance created by the method 
        /// <see cref="CreateEquatable()"/> (i.e., the 
        /// <see cref="IEquatable{T}.Equals(T)"/> should return false). A new 
        /// instance should be created every time this method is invoked; 
        /// instances should never be reused.
        /// </summary>
        /// <returns>The instance that is to be tested for equality against the 
        /// instance created by <see cref="CreateEquatable()"/>.</returns>
        protected abstract T CreateNotEqualObject();
    }
}