using System.Linq;
using NUnit.Framework;

namespace System.Collections.Generic
{
    /// <summary>
    /// A reusable test fixture base class for testing ICollection{T} types. This
    /// helper class also implements the EnumerationTest{T} class to test
    /// the IEnumeration{T} portion of the ICollection{T} being tested."
    /// </summary>
    /// <typeparam name="T">The type held by the collection.</typeparam>
    public abstract class CollectionTests<T> : EnumerationTests<T>
    {
        /// <summary>
        /// Initializes a new instance of the
        /// <see cref="CollectionTests{T}"/> class.
        /// </summary>
        /// <param name="testIterationOrder">True if the order of iteration by
        /// the <see cref="IEnumerable{T}"/> should be tested, false if otherwise.
        /// If you specify true, be sure to implement the
        /// <see cref="EnumerationTests{T}.OrderedItems"/> property.</param>
        protected CollectionTests(bool testIterationOrder)
            : this(testIterationOrder, null)
        { }

        /// <summary>
        /// Initializes a new instance of the
        /// <see cref="CollectionTests{T}"/> class.
        /// </summary>
        /// <param name="testIterationOrder">True if the order of iteration by
        /// the <see cref="IEnumerable{T}"/> should be tested, false if otherwise.
        /// If you specify true, be sure to implement the
        /// <see cref="EnumerationTests{T}.OrderedItems"/> property.</param>
        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> that
        /// is used to compare values in the <see cref="IEnumerable{T}"/> for
        /// uniqueness or null if the default <see cref="IEnumerable{T}"/>
        /// specified by <see cref="EqualityComparer{T}.Default"/> is to be used.</param>
        protected CollectionTests(bool testIterationOrder, IEqualityComparer<T> comparer)
            : base(testIterationOrder, comparer)
        { }

        [Test]
        [Description("Tests read-only classes. Checks if an NotSupportedException " +
            "is thrown if an object is added. If the ICollection<T> is not read " +
            "only, then the test always passes.")]
        public void NotSupportedExceptionWhenAddingToReadOnlyCollection()
        {
            ICollection<T> collection = CreateReadOnlyCollection();
            if (collection == null)
                Assert.Ignore("The collection is NOT read only, so no testing " +
                              "needs to be done.");

            CheckCollectionCount(collection);
            var item = CreateItem();
            Assert.Throws<NotSupportedException>(() => collection.Add(item));
        }

        [Test]
        [Description("Tests read-only classes. Checks if an NotSupportedException " +
            "is thrown when Clear() is called on a collection. If the ICollection<T> " +
            "is not read only, then the test always passes.")]
        public void NotSupportedExceptionWhenClearingAReadOnlyCollection()
        {
            ICollection<T> collection = CreateReadOnlyCollection();
            if (collection == null)
                Assert.Ignore("The collection is NOT read only, so no testing " +
                              "needs to be done.");

            CheckCollectionCount(collection);

            Assert.Throws<NotSupportedException>(() => collection.Clear());
        }

        [Test]
        [Description("Tests read-only classes. Checks if an NotSupportedException " +
            "is thrown when Remove() is called on a collection. If the ICollection<T> " +
            "is not read only, then the test always passes.")]
        public void NotSupportedExceptionWhenRemovingFromAReadOnlyCollection()
        {
            ICollection<T> collection = CreateReadOnlyCollection();
            if (collection == null)
                Assert.Ignore("The collection is NOT read only, so no testing " +
                              "needs to be done.");

            CheckCollectionCount(collection);

            var item = collection.First();
            Assert.Throws<NotSupportedException>(() => collection.Remove(item));
        }

        [Test]
        [Description("Enumerates through the ICollection<T> and checks if the " +
            "Contains(T) method properly returns true for each item in the list.")]
        public void ContainsWorksProperly()
        {
            ICollection<T> collection = CreateCollection();
            CheckCollectionCount(collection);

            foreach (T item in collection)
            {
                Assert.True(collection.Contains(item), "The item \"" + item +
                    "\" is not in the collection even though that item was " +
                    "pulled from the collection.");
            }
        }

        [Test]
        [Description("Calls CopyTo(T[], int) on the ICollection<T> with a null " +
            "array parameter to ensure the CopyTo(T[], int) method throws an " +
            "ArgumentNullException.")]
        public void ArgumentNullExceptionWhenCopyToArrayIsNull()
        {
            ICollection<T> collection = CreateCollection();
            CheckCollectionCount(collection);
            Assert.Throws<ArgumentNullException>(() => collection.CopyTo(null, 0));
        }

        [Test]
        [Description("Calls CopyTo(T[], int) on the ICollection<T> with a -1 " +
            "arrayIndex parameter to ensure the CopyTo(T[], int) method throws an " +
            "ArgumentOutOfRangeException.")]
        public void ArgumentOutOfRangeExceptionWhenCopyToArrayIndexIsNegative()
        {
            ICollection<T> collection = CreateCollection();
            CheckCollectionCount(collection);
            T[] array = new T[RequiredCollectionCount];
            Assert.Throws<ArgumentOutOfRangeException>(() => collection.CopyTo(array, -1));
        }

        [Test]
        [Description("Calls CopyTo(T[], int) on the ICollection<T> with an array " +
            "index parameter that is equal to the length of the array passed in " +
            "to ensure an ArgumentException is thrown.")]
        public void ArgumentExceptionWhenCopyToArrayIndexIsEqualToTheLengthOfTheArray()
        {
            ICollection<T> collection = CreateCollection();
            CheckCollectionCount(collection);
            T[] array = new T[RequiredCollectionCount];
            Assert.Throws<ArgumentException>(() => collection.CopyTo(array, RequiredCollectionCount));
        }

        [Test]
        [Description("Calls CopyTo(T[], int) on the ICollection<T> with an array " +
            "index parameter that is greater than the length of the array passed in " +
            "to ensure an ArgumentException is thrown.")]
        public void ArgumentExceptionWhenCopyToArrayIndexIsGreaterThanTheLengthOfTheArray()
        {
            ICollection<T> collection = CreateCollection();
            CheckCollectionCount(collection);
            T[] array = new T[RequiredCollectionCount];
            Assert.Throws(Is.AssignableTo<ArgumentException>(), () => collection.CopyTo(array, RequiredCollectionCount + 1));
        }

        [Test]
        [Description("Calls CopyTo(T[], int) on the ICollection<T> with an array " +
            "that is smaller than the number of elements from the array index " +
            "passed in to the end of the ICollection<T> to ensure an " +
            "ArgumentException is thrown.")]
        public void ArgumentExceptionWhenCopyToArrayIsSmallerThanTheNumberOfElementsFromArrayIndexToTheEndOfTheCollection()
        {
            ICollection<T> collection = CreateCollection();
            CheckCollectionCount(collection);
            T[] array = new T[1];
            Assert.Throws<ArgumentException>(() => collection.CopyTo(array, 0));
        }

        [Test]
        [Description("Calls CopyTo(T[], int) on the ICollection<T> and then checks " +
            "the returned array to ensure it contains items that are in " +
            "the ICollection<T>.")]
        public void CopyToContainsProperItems()
        {
            ICollection<T> collection = CreateCollection();
            CheckCollectionCount(collection);

            T[] array = new T[RequiredCollectionCount];
            collection.CopyTo(array, 0);

            foreach (T item in array)
            {
                Assert.True(collection.Contains(item), "The item \"" + item + "\" " +
                "copied from the array is not contained within the collection it " +
                "was copied from.");

                Assert.AreEqual(1, array.Count(otherItem => item.Equals(otherItem)),
                "The item \"" + item + "\" is contained within the copied array " +
                "more than once. Each item in the collection must be unique.");
            }
        }

        [Test]
        [Description("Removes() all items from the ICollection<T> using Remove() " +
            "method to ensure the Remove() method works properly")]
        public void RemovesProperly()
        {
            ICollection<T> collection = CreateCollection();
            CheckCollectionCount(collection);

            T[] array = new T[RequiredCollectionCount];
            collection.CopyTo(array, 0);
            foreach (T item in array)
            {
                Assert.True(collection.Remove(item), "Failed to remove one of " +
                    "the items from the list, even though it was contained " +
                    "within the list.");
            }

            Assert.AreEqual(0, collection.Count, "The collection is not empty even " +
                "though all items were supposedly removed. ");
        }

        [Test]
        [Description("Removes() an item from the list twice to ensure the " +
            "Remove() method properly returns true the first time and false the " +
            "second time.")]
        public void RemoveMethodDoesNotRemoveTwice()
        {
            ICollection<T> collection = CreateCollection();
            CheckCollectionCount(collection);

            // grab an item from the center of the list, just for kicks
            T item = collection.Skip((int)(RequiredCollectionCount - (RequiredCollectionCount * 0.5f))).First();

            Assert.True(collection.Remove(item), "Failed to remove an item that " +
                "was supposed to be in the collection.");

            Assert.False(collection.Remove(item), "The Remove() method returned " +
                "true (i.e. it had properly removed an item from the collection) " +
                "even though it had already been removed previously.");
        }

        [Test]
        [Description("Counts the items in the ICollection<T> using iteration and " +
            "then checks that number against the Count property to ensure both " +
            "are correct.")]
        public void CountIsCorrect()
        {
            ICollection<T> collection = CreateCollection();

            Assert.AreEqual(collection.Count(), collection.Count, "The Count() " +
                "LINQ method returned a different value from the ICollection<T>'s " +
                "Count property.");
        }

        /// <summary>
        /// Checks the collection to see if it contains the required number of
        /// items as specified by <see cref="RequiredCollectionCount"/>.
        /// </summary>
        /// <param name="collection">The collection to check.</param>
        void CheckCollectionCount(ICollection<T> collection)
        {
            Assert.AreEqual(RequiredCollectionCount, collection.Count, "The collection " +
                "does not contain the required number of items. It must contain " +
                RequiredCollectionCount + " items.");
        }

        /// <summary>
        /// The number of items each collection is required to contain when it
        /// was created by <see cref="CreateCollection()"/>. The value of this
        /// field is 7.
        /// </summary>
        public const int RequiredCollectionCount = 7;

        /// <summary>
        /// Creates an <see cref="ICollection{T}"/> to test. Derived classes
        /// should always create a new collection and never reuse the same
        /// instance unless it makes sense for the class in question. The created
        /// collection should contain the number of items specified by
        /// <see cref="RequiredCollectionCount"/>. Each item in the list should
        /// be unique so that a comparison of them does not yield duplicates.
        /// This method should also create a collection that follows the rules
        /// specified by the method
        /// <see cref="EnumerationTests{T}.CreateManyItemEnumerable()"/>
        /// (see the comments on that method for details).
        /// </summary>
        protected abstract ICollection<T> CreateCollection();

        /// <summary>
        /// Creates a read-only <see cref="ICollection{T}"/> to test. This method
        /// should behave exactly like the <see cref="CreateCollection()"/> method
        /// and follow the exact same rules (see the comments on
        /// <see cref="CreateCollection()"/> for details). If the collection can
        /// never be read-only, then it should return the same exact thing as the
        /// <see cref="CreateCollection()"/> method.
        /// </summary>
        protected abstract ICollection<T> CreateReadOnlyCollection();

        /// <summary>
        /// Creates an item that can be added to the class.
        /// </summary>
        protected abstract T CreateItem();

        /// <summary>
        /// This method should return a new <see cref="IEnumerable{T}"/> that can
        /// be iterated over exactly once. This method should create a new
        /// <see cref="IEnumerable{T}"/> every time it is invoked and not reuse
        /// instances.
        /// </summary>
        /// <returns>
        /// The <see cref="IEnumerable{T}"/> containing a single item.
        /// </returns>
        protected override IEnumerable<T> CreateSingleItemEnumerable()
        {
            ICollection<T> collection = CreateCollection();

            // skip all of the items except one
            T[] array = new T[collection.Count];
            collection.CopyTo(array, 0);
            IEnumerable<T> itemsToRemove = array.Take(collection.Count - 1);

            foreach (T item in itemsToRemove)
                collection.Remove(item);

            return collection;
        }

        /// <summary>
        /// This method should return a new <see cref="IEnumerable{T}"/> that can
        /// be iterated over five or more times. The items will be compared to
        /// the items in <see cref="EnumerationTests{T}.OrderedItems"/> but only
        /// if the  <see cref="EnumerationTests{T}.TestIterationOrder"/> property
        /// is set to true. This method should create a new
        /// <see cref="IEnumerable{T}"/> every time it is invoked and not reuse
        /// instances. All instances returned  through iteration of the
        /// <see cref="IEnumerable{T}"/> should be unique.
        /// </summary>
        /// <returns>
        /// The <see cref="IEnumerable{T}"/> containing many items.
        /// </returns>
        protected override IEnumerable<T> CreateManyItemEnumerable()
        {
            return CreateCollection();
        }
    }

    /// <summary>
    /// A test fixture that is used to test the
    /// <see cref="CollectionTests{T}"/> and to provide an example of
    /// how to create a proper <see cref="CollectionTests{T}"/>
    /// test fixture.
    /// </summary>
    [TestFixture]
    public class ListCollectionTestsFixture : CollectionTests<int>
    {
        /// <summary>
        /// Initializes a new instance of the
        /// <see cref="ListCollectionTestsFixture"/> class.
        /// </summary>
        public ListCollectionTestsFixture() : base(true)
        { }

        /// <summary>
        /// Creates an <see cref="ICollection{T}"/> to test. Derived classes
        /// should always create a new collection and never reuse the same
        /// instance unless it makes sense for the class in question. The created
        /// collection should contain the number of items specified by
        /// <see cref="CollectionTests{T}.RequiredCollectionCount"/>. Each item in the list should
        /// be unique so that a comparison of them does not yield duplicates.
        /// </summary>
        /// <returns>The </returns>
        protected override ICollection<int> CreateCollection()
        {
            return new List<int>(new[] { 0, 1, 2, 3, 4, 5, 6 });
        }

        /// <summary>
        /// Creates a read-only <see cref="ICollection{T}"/> to test. This method
        /// should behave exactly like the <see cref="CreateCollection()"/> method
        /// and follow the exact same rules (see the comments on
        /// <see cref="CreateCollection()"/> for details). If the collection can
        /// never be read-only, then it should return the same exact thing as the
        /// <see cref="CreateCollection()"/> method.
        /// </summary>
        /// <returns></returns>
        protected override ICollection<int> CreateReadOnlyCollection()
        {
            List<int> list = new List<int>(new[] { 0, 1, 2, 3, 4, 5, 6 });
            return list.AsReadOnly();
        }

        /// <summary>
        /// Creates an item that can be added to the class.
        /// </summary>
        /// <returns>The item that can be added to the list.</returns>
        protected override int CreateItem()
        {
            return 1;
        }

        /// <summary>
        /// Returns the items created by
        /// <see cref="EnumerationTests{T}.CreateManyItemEnumerable()"/>
        /// are expected to be in.
        /// </summary>
        protected override IEnumerable<int> OrderedItems
        {
            get { return _orderedItems; }
        }

        /// <summary>
        /// The backing field to <see cref="OrderedItems"/>.
        /// </summary>
        readonly int[] _orderedItems = {0, 1, 2, 3, 4, 5, 6};
    }

}