using System.Linq;
using System.Utility;
using NUnit.Framework;

namespace System.Collections.Generic
{
    /// <summary>
    /// Tests for the <see cref="IDictionary{TKey, TValue}" /> type.
    /// </summary>
    /// <typeparam name="TKey">The type of the key.</typeparam>
    /// <typeparam name="TValue">The type of the value.</typeparam>
    public abstract class DictionaryTests<TKey, TValue>
        : CollectionTests<KeyValuePair<TKey, TValue>>
    {
        /// <summary>
        /// Initializes a new instance of the
        /// <see cref="IDictionary{TKey, TValue}" /> 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 DictionaryTests(bool testIterationOrder)
            : this(testIterationOrder, EqualityComparer<KeyValuePair<TKey, TValue>>.Default)
        {}

        /// <summary>
        /// Initializes a new instance of the
        /// <see cref="IDictionary{TKey, TValue}"/> 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 DictionaryTests(bool testIterationOrder,
            IEqualityComparer<KeyValuePair<TKey, TValue>> comparer)
            : base(testIterationOrder, comparer)
        {}

        ////////////////////////////////////////////////////////////////////////
        #region IDictionary<TKey, TValue>.Add(TKey, TValue) Tests
        ////////////////////////////////////////////////////////////////////////

        [Test, Description("Ensures that IDictionary<TKey, TValue>.Add(TKey, TValue) " +
                           "throws an exception if the key is null. Note that this " +
                           "test assumes TKey can be null. If it cannot be override " +
                           "this test and have it ignored.")]
        public virtual void AddArgumentNullException()
        {
            IDictionary<TKey, TValue> dictionary = CreateDictionary();
            Assert.Throws<ArgumentNullException>(() => dictionary.Add(default(TKey), default(TValue)));
        }

        [Test, Description("Ensures that IDictionary<TKey, TValue>.Add(TKey, TValue) " +
                           "throws an exception if an element with the same key " +
                           "already exists in the dictionary.")]
        public void ExceptionThrownWhenKeyAlreadyExists()
        {
            IDictionary<TKey, TValue> dictionary = CreateDictionary();
            var keyValue = CreateItem();
            dictionary.Add(keyValue.Key, keyValue.Value);
            Assert.Throws<ArgumentException>(() => dictionary.Add(keyValue.Key, keyValue.Value));
        }

        [Test, Description("Ensures that IDictionary<TKey, TValue>.Add(TKey, TValue) " +
                           "throws an exception if it is called when the test is " +
                           "read only.  Note that this test assumes the dictionary " +
                           "can be null. If it cannot be, override this test and " +
                           "have it ignored.")]
        public virtual void AddNotSupportedExceptionWhenReadOnly()
        {
            IDictionary<TKey, TValue> readOnlyDictionary = CreateReadOnlyDictionary();

            if (readOnlyDictionary == null)
                Assert.Ignore("IDictionary<TKey, TValue> cannot be read-only.");

            var keyValue = CreateItem();
            Assert.Throws<NotSupportedException>(() => readOnlyDictionary.Add(keyValue.Key, keyValue.Value));
        }

        [Test, Description("Ensures that IDictionary<TKey, TValue>.Add(TKey, TValue) " +
                           "adds an item.")]
        public void ItemIsAdded()
        {
            IDictionary<TKey, TValue> dictionary = CreateDictionary();
            var keyValue = CreateItem();
            dictionary.Add(keyValue.Key, keyValue.Value);

            TValue value = dictionary[keyValue.Key];
            value.IsEqualTo(keyValue.Value, "dictionary value");
        }

        #endregion

        ////////////////////////////////////////////////////////////////////////
        #region IDictionary<TKey, TValue>.ContainsKey(TKey) Tests
        ////////////////////////////////////////////////////////////////////////

        [Test, Description("Ensures that IDictionary<TKey, TValue>.ContainsKey(TKey) " +
                           "throws an exception if the key is null. Note that this " +
                           "test assumes TKey can be null. If it cannot be override " +
                           "this test and have it ignored.")]
        public virtual void ContainsKeyArgumentNullException()
        {
            IDictionary<TKey, TValue> dictionary = CreateDictionary();
            Assert.Throws<ArgumentNullException>(() => dictionary.ContainsKey(default(TKey)));
        }

        [Test, Description("Ensures that IDictionary<TKey, TValue>.ContainsKey(TKey) " +
                           "returns false when a key is not in the dictionary and" +
                           "true when it is.")]
        public virtual void ContainsKeyReturnsTrueAndFalse()
        {
            IDictionary<TKey, TValue> dictionary = CreateDictionary();
            var keyValue = CreateItem();

            Assert.False(dictionary.ContainsKey(keyValue.Key));

            dictionary.Add(keyValue);

            Assert.True(dictionary.ContainsKey(keyValue.Key));
        }

        #endregion

        ////////////////////////////////////////////////////////////////////////
        #region IDictionary<TKey, TValue>.Remove(TKey) Tests
        ////////////////////////////////////////////////////////////////////////

        [Test, Description("Ensures that IDictionary<TKey, TValue>.Remove(TKey) " +
                           "throws an exception if the key is null. Note that this " +
                           "test assumes TKey can be null. If it cannot be override " +
                           "this test and have it ignored.")]
        public virtual void RemoveArgumentNullException()
        {
            IDictionary<TKey, TValue> dictionary = CreateDictionary();
            Assert.Throws<ArgumentNullException>(() => dictionary.Remove(default(TKey)));
        }

        [Test, Description("Ensures that IDictionary<TKey, TValue>.Remove(TKey) " +
                           "throws a NotSupportedException if the IDictionary<TKey, TValue> " +
                           "is read only. If the IDictionary<TKey, TValue> cannot be read then " +
                           "this test is ignored.")]
        public virtual void RemoveThrowsNotSupportedExceptionWhenDictionaryIsReadOnly()
        {
            IDictionary<TKey, TValue> readOnlyDictionary = CreateReadOnlyDictionary();

            if (readOnlyDictionary == null)
                Assert.Ignore("IDictionary<TKey, TValue> cannot be read-only.");

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

        [Test, Description("Ensures that IDictionary<TKey, TValue>.Remove(TKey) " +
                           "doesn't remove the item when it is not in the " +
                           "IDictionary<TKey, TValue> and removes the item when " +
                           "it is.")]
        public virtual void ItemRemovedAndNotRemoved()
        {
            IDictionary<TKey, TValue> dictionary = CreateDictionary();

            var item = CreateItem();
            int countBeforeRemove = dictionary.Count;
            Assert.False(dictionary.Remove(item.Key), "Item should not have been removed.");

            dictionary.Count.IsEqualTo(countBeforeRemove, "IDictionary<TKey, TValue>.Count");

            dictionary.Add(item);
            countBeforeRemove = dictionary.Count;

            Assert.True(dictionary.Remove(item.Key));
            dictionary.Count.IsNotEqualTo(countBeforeRemove, "IDictionary<TKey, TValue>.Count");
        }

        #endregion

        ////////////////////////////////////////////////////////////////////////
        #region IDictionary<TKey, TValue>.TryGetValue(TKey, TValue) Tests
        ////////////////////////////////////////////////////////////////////////

        [Test, Description("Ensures that IDictionary<TKey, TValue>.TryGetValue(TKey, TValue) " +
                           "throws an exception if the key is null. Note that this " +
                           "test assumes TKey can be null. If it cannot be override " +
                           "this test and have it ignored.")]
        public virtual void TryGetValueArgumentNullException()
        {
            IDictionary<TKey, TValue> dictionary = CreateDictionary();
            TValue value;
            Assert.Throws<ArgumentNullException>(() => dictionary.TryGetValue(default(TKey), out value));
        }

        [Test, Description("Ensures that IDictionary<TKey, TValue>.TryGetValue(TKey, TValue) " +
                           "returns true if a value is in the IDictionary<TKey, TValue>, false" +
                           "if otherwise.")]
        public virtual void ItemRetrievedAndNotRetrieved()
        {
            IDictionary<TKey, TValue> dictionary = CreateDictionary();

            var item = CreateItem();
            TValue retrievedItem;
            Assert.False(dictionary.TryGetValue(item.Key, out retrievedItem),
                "Item should not have been retrieved.");

            // If the value could not be retrieved, then the item should have
            // been set to the default value.
            retrievedItem.IsEqualTo(default(TValue),
                "IDictionary<TKey, TValue>.TryGetValue(TKey, TValue)");

            dictionary.Add(item);

            Assert.True(dictionary.TryGetValue(item.Key, out retrievedItem));
            retrievedItem.IsEqualTo(item.Value, "IDictionary<TKey, TValue>.TryGetValue(TKey, TValue)");
        }

        #endregion

        ////////////////////////////////////////////////////////////////////////
        #region IDictionary<TKey, TValue>.Keys Tests
        ////////////////////////////////////////////////////////////////////////

        [Test, Description("Ensures that IDictionary<TKey, TValue>.Keys " +
                           "contains the proper keys.")]
        public virtual void KeysExpected()
        {
            IDictionary<TKey, TValue> dictionary = CreateDictionary();

            // Keys must exist for this test to work.
            dictionary.Keys.Count.IsNotEqualTo(0, "IDictionary<TKey, TValue>.Keys");

            var keys = dictionary.Select(pair => pair.Key);

            dictionary.Keys.IsEqualTo(keys, "IDictionary<TKey, TValue>.Keys");
        }

        #endregion

        ////////////////////////////////////////////////////////////////////////
        #region IDictionary<TKey, TValue>.this[TKey] Tests
        ////////////////////////////////////////////////////////////////////////

        [Test, Description("Ensures that IDictionary<TKey, TValue>.this[TKey] " +
                           "throws an exception if the key is null. Note that this " +
                           "test assumes TKey can be null. If it cannot be override " +
                           "this test and have it ignored.")]

        public virtual void IndexerArgumentNullException()
        {
            IDictionary<TKey, TValue> dictionary = CreateDictionary();
            Assert.Throws<ArgumentNullException>(() => dictionary[default(TKey)] = default (TValue));
        }

        [Test, Description("Ensures that IDictionary<TKey, TValue>.this[TKey] " +
                           "throws a KeyNotFoundException if the key cannot be " +
                           "found.")]
        public virtual void KeyNotFoundException()
        {
            IDictionary<TKey, TValue> dictionary = CreateDictionary();
            var item = CreateItem();
            Assert.Throws<KeyNotFoundException>(() => Console.WriteLine(dictionary[item.Key]));
        }

        [Test, Description("Ensures that IDictionary<TKey, TValue>.this[TKey] " +
                           "throws a NotSupportedException when the " +
                           "IDictionary<TKey, TValue> is read only. If the " +
                           "IDictionary<TKey, TValue> cannot be read then this " +
                           "test is ignored.")]
        public virtual void IndexerThrowsNotSupportedExceptionWhenDictionaryIsReadOnly()
        {
            IDictionary<TKey, TValue> readOnlyDictionary = CreateReadOnlyDictionary();

            if (readOnlyDictionary == null)
                Assert.Ignore("IDictionary<TKey, TValue> cannot be read-only.");

            var item = readOnlyDictionary.First();
            Assert.Throws<NotSupportedException>(() => Console.WriteLine(readOnlyDictionary[item.Key]));
        }

        [Test, Description("Ensures that IDictionary<TKey, TValue>.this[TKey] " +
                           "returns the expected value.")]
        public virtual void ItemRetrieved()
        {
            IDictionary<TKey, TValue> dictionary = CreateDictionary();

            var item = CreateItem();
            dictionary.Add(item);

            TValue retrievedItem = dictionary[item.Key];
            retrievedItem.IsEqualTo(item.Value, "IDictionary<TKey, TValue>.this[TKey]");
        }

        #endregion

        ////////////////////////////////////////////////////////////////////////
        #region IDictionary<TKey, TValue>.Values Tests
        ////////////////////////////////////////////////////////////////////////

        [Test, Description("Ensures that IDictionary<TKey, TValue>.Values " +
                           "contains the proper keys.")]
        public virtual void ValuesExpected()
        {
            IDictionary<TKey, TValue> dictionary = CreateDictionary();

            // Keys must exist for this test to work.
            dictionary.Values.Count.IsNotEqualTo(0, "IDictionary<TKey, TValue>.Values");

            var values = dictionary.Select(pair => pair.Value);

            dictionary.Values.IsEqualTo(values, "IDictionary<TKey, TValue>.Values");
        }

        #endregion

        ////////////////////////////////////////////////////////////////////////
        #region Overridables
        ////////////////////////////////////////////////////////////////////////

        /// <summary>
        /// Creates an <see cref="IDictionary{TKey, TValue}"/> to test. 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. 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>
        /// <returns>The instance to be tested.</returns>
        protected abstract IDictionary<TKey, TValue> CreateDictionary();

        /// <summary>
        /// Creates a read-only <see cref="IDictionary{TKey, TValue}"/> to test.
        /// This method should behave exactly like the <see cref="CreateDictionary()"/>
        /// method and follow the exact same rules (see the comments on
        /// <see cref="CreateDictionary()"/> for details). If the collection can
        /// never be read-only, then this method should return null.
        /// </summary>
        protected abstract IDictionary<TKey, TValue> CreateReadOnlyDictionary();

        protected override ICollection<KeyValuePair<TKey, TValue>> CreateCollection()
        {
            return CreateDictionary();
        }

        protected override ICollection<KeyValuePair<TKey, TValue>> CreateReadOnlyCollection()
        {
            return CreateReadOnlyDictionary();
        }

        #endregion
    }

    /// <summary>
    /// A test fixture that is used to test the
    /// <see cref="DictionaryTests{TKey, TValue}"/> and to provide an example of
    /// how to create a proper <see cref="DictionaryTests{TKey, TValue}"/>
    /// test fixture.
    /// </summary>
    [TestFixture]
    public class DictionaryTestsFixture : DictionaryTests<string, string>
    {
        public DictionaryTestsFixture()
            : base(false)
        { }

        #region Overridables

        protected override IDictionary<string, string> CreateDictionary()
        {
            IDictionary<string, string> dictionary = new Dictionary<string, string>();
            for (int i = 0; i < RequiredCollectionCount; i++)
            {
                string indexStr = i.ToString();
                dictionary.Add(indexStr, "Value " + indexStr);
            }

            return dictionary;
        }

        protected override IDictionary<string, string> CreateReadOnlyDictionary()
        {
            // DictionaryTests<TKey, TValue> cannot be read-only.
            return null;
        }

        protected override KeyValuePair<string, string> CreateItem()
        {
            string indexStr = (RequiredCollectionCount + 1).ToString();
            return new KeyValuePair<string, string>(indexStr, "Value " + indexStr);
        }

        #endregion
    }

}