#region License

/*
 * Copyright 2004 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#endregion

#region Imports

using System;
using System.Collections;

using Spring.Collections;

using NUnit.Framework;

#endregion

namespace Spring.Collections
{
	/// <summary>
	/// <b>Base</b> class for tests on the <see cref="Spring.Collections.ISet"/>
	/// interface.
    /// </summary>
    /// <remarks>
    /// <p>
    /// This defines a set of tests that exercise the contract of the set interface.
    /// Subclasses need only supply a concrete ISET imnplementation instance... this
    /// instance must be set on the Set property exposed by this class in the
    /// SetUp method. The Set instance must be empty for the start of each new test.
    /// </p>
    /// <p>
    /// The SetForSetOps needs to be set during the SetUp method too.
    /// </p>
    /// </remarks>
    /// <author>Rick Evans</author>
    public abstract class SetTests
    {
        protected static readonly object StuffOne = "This Is";

        protected static readonly object StuffTwo = "Uncle";

        protected static readonly object StuffThree = "Bob";

        protected readonly object [] UniqueStuff = new object [] {StuffOne, StuffTwo, StuffThree};

        protected readonly object [] DuplicatedStuff = new object [] {StuffOne, StuffTwo, StuffTwo};

        /// <summary>
        /// The setup logic executed before the execution of each individual test.
        /// </summary>
        public abstract void SetUp ();

        /// <summary>
        /// The tear down logic executed after the execution of each individual test.
        /// </summary>
        [TearDown]
        public virtual void TearDown () {
            Set = null;
            SetForSetOps = null;
        }

        [Test]
        public void Union() 
        {
            Set.AddAll (UniqueStuff);
            SetForSetOps.AddAll (new object [] {"Bar", StuffOne});
            ISet union = Set.Union (SetForSetOps);
            Assert.IsTrue (union.Count == UniqueStuff.Length + 1);
            Assert.IsFalse (object.ReferenceEquals (union, Set), "Got back same instance after set operation.");
            Assert.IsTrue (Set.Count == UniqueStuff.Length);
            Assert.IsTrue (SetForSetOps.Count == 2);
        }

        [Test]
        public void Intersect() 
        {
            Set.AddAll (UniqueStuff);
            SetForSetOps.AddAll (new object [] {"Bar", StuffOne});
            ISet intersection = Set.Intersect (SetForSetOps);
            Assert.IsTrue (intersection.Count == 1);
            Assert.IsFalse (object.ReferenceEquals (intersection, Set), "Got back same instance after set operation.");
            Assert.IsTrue (Set.Count == UniqueStuff.Length);
            Assert.IsTrue (SetForSetOps.Count == 2);
        }

        [Test]
        public void Minus()
        {
            Set.AddAll (UniqueStuff);
            SetForSetOps.AddAll (new object [] {"Bar", StuffOne});
            ISet minus = Set.Minus (SetForSetOps);
            Assert.IsTrue (minus.Count == UniqueStuff.Length - 1);
            Assert.IsFalse (object.ReferenceEquals (minus, Set), "Got back same instance after set operation.");
            Assert.IsTrue (Set.Count == UniqueStuff.Length);
            Assert.IsTrue (SetForSetOps.Count == 2);
        }

        [Test]
        public void ExclusiveOr()
        {
            Set.AddAll (UniqueStuff);
            SetForSetOps.AddAll (new object [] {"Bar", StuffOne});
            ISet xor = Set.ExclusiveOr (SetForSetOps);
            Assert.IsTrue (xor.Count == 3);
            Assert.IsTrue (xor.ContainsAll (new object [] {"Bar", StuffTwo, StuffThree}));
            Assert.IsFalse (object.ReferenceEquals (xor, Set), "Got back same instance after set operation.");
            Assert.IsTrue (Set.Count == UniqueStuff.Length);
            Assert.IsTrue (SetForSetOps.Count == 2);
        }

        [Test]
        public void Contains()
        {
            Set.AddAll (UniqueStuff);
            Assert.IsTrue (Set.Contains (StuffThree));
            Assert.IsFalse (Set.Contains ("SourDough"));
        }

        [Test]
        public void ContainsAll()
        {
            Set.AddAll (UniqueStuff);
            Assert.IsTrue (Set.ContainsAll (new object [] {StuffThree, StuffTwo, StuffOne}));
        }

        [Test]
        public void IsEmpty ()
        {
            Set.Add (StuffOne);
            Set.Remove (StuffOne);
            Assert.IsTrue (Set.IsEmpty);
        }

        [Test]
        public void Add()
        {
            Assert.IsTrue (Set.Add (StuffOne));
            Assert.IsTrue (Set.Count == 1, "Added 1 unique item, but the Count property wasn't sitting at 1.");
        }

        [Test]
        public void AddNull()
        {
            if (SupportsNull) 
            {
                Assert.IsTrue (Set.Add (StuffOne));
                Assert.IsTrue (Set.Add (null));
                Assert.IsTrue (Set.Count == 2, "Added 2 unique item (one null), but the Count property wasn't sitting at 2.");
                Assert.IsFalse (Set.Add (null));
                Assert.IsTrue (Set.Count == 2, "Added null to a set already containing null, but the Count property changed.");
            }
        }

        [Test]
        public void EnumeratesNull()
        {
            if (SupportsNull) 
            {
                Set.AddAll (new object [] {StuffOne, null, StuffTwo});
                bool gotNull = false;
                foreach (object o in Set) 
                {
                    if (o == null)
                    {
                        gotNull = true;
                        break;
                    }
                }
                Assert.IsTrue (gotNull, "Stuffed a null value into the set but didn't get it back when enumerating over the set.");
            }
        }

        [Test]
        public void CopiesNull () 
        {
            if (SupportsNull) 
            {
                object [] expected = new object [] {StuffOne, null, StuffTwo};
                Set.AddAll (expected);
                object [] actual = new object [expected.Length];
                Set.CopyTo (actual, 0);
                bool gotNull = false;
                foreach (object o in actual) 
                {
                    if (o == null)
                    {
                        gotNull = true;
                        break;
                    }
                }
                Assert.IsTrue (gotNull, "Copied a set with a null value into an array, but the resulting array did not contain a a null.");
            }
        }

        [Test]
        public void AddDuplicate()
        {
            Set.Add (StuffOne);
            Assert.IsFalse (Set.Add (StuffOne));
            Assert.IsTrue (Set.Count == 1, "Added 2 duplicate items, but the Count property wasn't sitting at 1.");
        }

        [Test]
        public void AddAll()
        {
            Assert.IsTrue (Set.AddAll (UniqueStuff));
            Assert.IsTrue (Set.Count == UniqueStuff.Length, "Added 3 unique items, but the Count property wasn't sitting at 3.");
        }

        [Test]
        public void AddAllDuplicated()
        {
            Assert.IsTrue (Set.AddAll (DuplicatedStuff));
            Assert.IsTrue (Set.Count == 2, "Added 3 (2 duplicated) items, but the Count property wasn't sitting at 2.");
        }

        [Test]
        public void Remove()
        {
            Set.AddAll (UniqueStuff);
            Set.Remove (StuffOne);
            Assert.IsTrue (Set.Count == (UniqueStuff.Length - 1));
            Assert.IsFalse (Set.Contains (StuffOne));
            Assert.IsTrue (Set.Contains (StuffTwo));
            Assert.IsTrue (Set.Contains (StuffThree));
        }

        [Test]
        public void RemoveNull()
        {
            if (SupportsNull) 
            {
                Set.AddAll (UniqueStuff);
                Assert.IsFalse (Set.Remove (null));
                Set.Add (null);
                Assert.IsTrue (Set.Remove (null));
            }
        }

        [Test]
        public void RemoveAll()
        {
            Set.AddAll (UniqueStuff);
            object [] removed = new object [] {StuffOne, StuffTwo};
            Set.RemoveAll (removed);
            Assert.IsTrue (Set.Count == (UniqueStuff.Length - removed.Length));
            Assert.IsFalse (Set.Contains (StuffOne));
            Assert.IsFalse (Set.Contains (StuffTwo));
            Assert.IsTrue (Set.Contains (StuffThree));
        }

        [Test]
        public void RetainAll()
        {
            Set.AddAll (UniqueStuff);
            Set.RetainAll (new object [] {StuffOne, StuffTwo});
            Assert.IsTrue (Set.Count == 2);
            Assert.IsTrue (Set.Contains (StuffOne));
            Assert.IsTrue (Set.Contains (StuffTwo));
            Assert.IsFalse (Set.Contains (StuffThree));
        }

        [Test]
        public void Clear()
        {
            Set.AddAll (UniqueStuff);
            Set.Clear ();
            Assert.IsTrue (Set.Count == 0, "Calling Clear () did not remove all of the elements.");
        }

        /// <summary>
        /// The ISet being tested.
        /// </summary>
        protected virtual ISet Set 
        {
            get 
            {
                return _set;
            }
            set 
            {
                _set = value;
            }
        }

        /// <summary>
        /// An extra ISet instance for use during the set operation tests.
        /// </summary>
        protected virtual ISet SetForSetOps
        {
            get 
            {
                return _setForSetOps;
            }
            set 
            {
                _setForSetOps = value;
            }
        }

        /// <summary>
        /// Does the Set being tested support the addition of null values?
        /// </summary>
        /// <remarks>
        /// <p>
        /// If true, then the tests that test the handling of the null value
        /// will be executed.
        /// </p>
        /// </remarks>
        protected bool SupportsNull
        {
            get 
            {
                return _setSupportsNullValue;
            }
            set 
            {
                _setSupportsNullValue = value;
            }
        }

        private ISet _set;
        private ISet _setForSetOps;
        private bool _setSupportsNullValue = true;
	}
}
