EquivalentWithTests

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace CollectionEquality.Tests
{
    [TestClass]
    public class EquivalentWithTests
    {
        [TestMethod]
        [ExpectedException(typeof(ArgumentNullException))]
        public void BothEnumerableNullWillNotPass()
        {
            IEnumerable<int> source = null;
            IEnumerable<int> other = null;
            source.EquivalentWith(other);
        }

        [TestMethod]
        [ExpectedException(typeof(ArgumentNullException))]
        public void SourceEnumerableNullWillNotPass()
        {
            IEnumerable<int> source = null;
            IEnumerable<int> other = new[] { 1, 2, 3, 4, 5, 6 };
            source.EquivalentWith(other);
        }

        [TestMethod]
        [ExpectedException(typeof(ArgumentNullException))]
        public void OtherEnumerableNullWillNotPass()
        {
            IEnumerable<int> source = new[] { 1, 2, 3, 4, 5, 6 };
            IEnumerable<int> other = null;
            source.EquivalentWith(other);
        }

        [TestMethod]
        [ExpectedException(typeof(ArgumentNullException))]
        public void SameEnumerableNullWillPass()
        {
            IEnumerable<int> source = null;
            source.EquivalentWith(source);
        }

        [TestMethod]
        public void SameEnumerableWillPass()
        {
            IEnumerable<int> source = new[] { 1, 2, 3, 4, 5, 6 };
            Assert.IsTrue(source.EquivalentWith(source));
        }

        [TestMethod]
        public void BothEnumerableSameWillPass()
        {
            IEnumerable<int> source = new[] { 1, 2, 3, 4, 5, 6 };
            IEnumerable<int> other = new[] { 1, 2, 3, 4, 5, 6 };
            Assert.IsTrue(source.EquivalentWith(other));
        }

        [TestMethod]
        public void EnumerableDifferentSizeWillNotPass()
        {
            IEnumerable<int> source = Enumerable.Range(0, 5000);
            IEnumerable<int> other = Enumerable.Range(0, 500);
            Assert.IsFalse(source.EquivalentWith(other));
        }
        [TestMethod]
        public void CollectionsDifferentSizeWillNotPass()
        {
            var source = new List<int>(Enumerable.Range(0, 50));
            var other = new List<int>(Enumerable.Range(0, 40));
            Assert.IsFalse(source.EquivalentWith(other));
        }

        [TestMethod]
        public void BothEnumerableDifferentWillNotPass()
        {
            IEnumerable<int> source = new[] { 1, 2, 3, 4, 5, 6 };
            IEnumerable<int> other = new[] { 3, 4, 5, 6, 7, 8 };
            Assert.IsFalse(source.EquivalentWith(other));
        }

        [TestMethod]
        public void OtherEnumerableReversedWillPass()
        {
            IEnumerable<int> source = new[] { 1, 2, 3, 4, 5, 6 };
            IEnumerable<int> other = new[] { 6, 5, 4, 3, 2, 1 };
            Assert.IsTrue(source.EquivalentWith(other));
        }

        [TestMethod]
        public void OtherEnumerableReversedBothContainingNonUniqueAndUniqueWillPass()
        {
            IEnumerable<int> source = new[] { 1, 2, 2, 4, 5, 6 };
            IEnumerable<int> other = new[] { 6, 5, 4, 2, 2, 1 };
            Assert.IsTrue(source.EquivalentWith(other));
        }

        [TestMethod]
        public void OtherEnumerableReversedBothContainingNonUniqueAndUniqueButDifferentWillPass()
        {
            IEnumerable<int> source = new[] { 1, 2, 2, 4, 5, 6 };
            IEnumerable<int> other = new[] { 6, 5, 4, 4, 2, 1 };

            Assert.IsFalse(source.EquivalentWith(other));
        }


        [TestMethod]
        public void OtherEnumerableReversedBothContainingUniqueAndNullButDifferentWillPass()
        {
            var source = new int?[] { 1, 2, 3, 4, 5, 6, null };
            var other = new int?[] { 6, 5, 4, 3, 2, 1, null };

            Assert.IsTrue(source.EquivalentWith(other));
        }

        [TestMethod]
        public void OtherEnumerableReversedBothContainingUniqueAndNotUniqueAndNullButDifferentWillPass()
        {
            var source = new int?[] { 1, 2, 3, 2, 5, 6, null };
            var other = new int?[] { 6, 5, 2, 3, 2, 1, null };

            Assert.IsTrue(source.EquivalentWith(other));
        }
    }
}