using System.Collections;
using System.Linq;
using MbUnit.Framework;
using System.Collections.Generic;
using System;
 
namespace Machine.Specifications.Gallio
{
    public static class GallioCollectionExtensionMethods
    {
        public static ArrayList ToArrayList(this IEnumerable enumerable)
        {
            ArrayList arrayList = new ArrayList();
            foreach (object obj in enumerable)
            {
                arrayList.Add(obj);
            }
            return arrayList;
        }
    }
    public static class GallioShouldExtensionMethods
    {
        public static void ShouldBeFalse(this bool condition)
        {
            Assert.IsFalse(condition);
        }
 
        public static void ShouldBeTrue(this bool condition)
        {
            Assert.IsTrue(condition);
        }
 
        public static object ShouldEqual(this object actual, object expected)
        {
            Assert.AreEqual(expected, actual);
            return expected;
        }
 
        public static T ShouldEqual<T>(this T actual, T expected) where T : IEquatable<T>
        {
            Assert.IsTrue(actual.Equals(expected));
            return expected;
        }
 
        public static object ShouldNotEqual(this object actual, object expected)
        {
            Assert.AreNotEqual(expected, actual);
            return expected;
        }
 
        public static void ShouldBeNull(this object anObject)
        {
            Assert.IsNull(anObject);
        }
 
        public static void ShouldNotBeNull(this object anObject)
        {
            Assert.IsNotNull(anObject);
        }
 
        public static object ShouldBeTheSameAs(this object actual, object expected)
        {
            Assert.AreSame(expected, actual);
            return expected;
        }
 
        public static object ShouldNotBeTheSameAs(this object actual, object expected)
        {
            Assert.AreNotSame(expected, actual);
            return expected;
        }
 
        public static void ShouldBeOfType(this object actual, Type expected)
        {
            Assert.IsInstanceOfType(expected, actual);
        }
 
        public static void ShouldBeOfType<T>(this object actual)
        {
            Assert.IsInstanceOfType(typeof(T), actual);
        }
 
        public static void ShouldBe(this object actual, Type expected)
        {
            Assert.IsInstanceOfType(expected, actual);
        }
 
        public static void ShouldNotBeOfType(this object actual, Type expected)
        {
            Assert.IsNotInstanceOfType(expected, actual);
        }
 
        public static void ShouldContain<T>(this IEnumerable<T> actual, params T[] expected)
        {
            actual.ShouldContain(expected);
        }
 
        public static void ShouldContain<T>(this IEnumerable<T> actual, IEnumerable<T> expected)
        {
            var actualList = new List<T>(actual);
            foreach (var item in expected)
                Assert.Contains(actualList, item); 
        }
 
        public static void ShouldNotContain<T>(this IEnumerable<T> collection, T expected)
        {
            Assert.DoesNotContain(collection, expected);
        }
 
        public static IComparable ShouldBeGreaterThan(this IComparable arg1, IComparable arg2)
        {
            Assert.GreaterThan(arg1, arg2);
            return arg2;
        }
 
        public static IComparable ShouldBeLessThan(this IComparable arg1, IComparable arg2)
        {
            Assert.LessThan(arg1, arg2);
            return arg2;
        }
 
        public static void ShouldBeEmpty(this IEnumerable collection)
        {
            Assert.IsEmpty(collection.ToArrayList());
        }
 
        public static void ShouldBeEmpty(this string aString)
        {
            Assert.IsEmpty(aString);
        }
 
        public static void ShouldNotBeEmpty(this IEnumerable collection)
        {
            Assert.IsNotEmpty(collection.ToArrayList());
        }
 
        public static void ShouldNotBeEmpty(this string aString)
        {
            Assert.IsNotEmpty(aString);
        }
 
        public static void ShouldContain(this string actual, string expected)
        {
            Assert.Contains(actual, expected);
        }
 
        public static string ShouldBeEqualIgnoringCase(this string actual, string expected)
        {
            Assert.IsTrue(expected.Equals(actual, StringComparison.InvariantCultureIgnoreCase));
            return expected;
        }
 
        public static void ShouldStartWith(this string actual, string expected)
        {
            Assert.IsTrue(actual.StartsWith(expected));
        }
 
        public static void ShouldEndWith(this string actual, string expected)
        {
            Assert.IsTrue(actual.EndsWith(expected));
        }
 
        public static void ShouldBeSurroundedWith(this string actual, string expectedStartDelimiter,
          string expectedEndDelimiter)
        {
            actual.ShouldStartWith(expectedStartDelimiter);
            actual.ShouldEndWith(expectedEndDelimiter);
        }
 
        public static void ShouldBeSurroundedWith(this string actual, string expectedDelimiter)
        {
            actual.ShouldBeSurroundedWith(expectedDelimiter, expectedDelimiter);
        }
 
        public static void ShouldContainErrorMessage(this Exception exception, string expected)
        {
            exception.Message.ShouldContain(expected);
        }
 
        public static void ShouldContainOnly<T>(this IEnumerable<T> actual, params T[] expected)
        {
            actual.ShouldContainOnly(expected);
        }
 
        public static void ShouldContainOnly<T>(this IEnumerable<T> actual, IEnumerable<T> expected)
        {
            actual.ShouldContain(expected);
            actual.Count().ShouldEqual(expected.Count());
        }
 
        public static Exception ShouldBeThrownBy(this Type exceptionType, Action method)
        {
            Exception exception = method.GetException();
 
            Assert.IsNotNull(exception);
            Assert.AreEqual(exceptionType, exception.GetType());
            return exception;
        }
 
        static Exception GetException(this Action method)
        {
            Exception exception = null;
 
            try
            {
                method();
            }
            catch (Exception e)
            {
                exception = e;
            }
 
            return exception;
        }
    }
}