using Chernobyl;
using NUnit.Framework;

namespace System
{
    /// <summary>
    /// A utility type that is used to ensure that methods, constructors,
    /// properties and the like throw an <typeparamref name="TException"/>
    /// exception when they receive an invalid argument.
    /// </summary>
    /// <typeparam name="TException">The type of exception to test for.</typeparam>
    /// <typeparam name="T1">The type of the first argument.</typeparam>
    public abstract class ArgumentExceptionTests<TException, T1>
        where TException : Exception
        where T1 : class
    {
        [Test, Description("Ensures a TException is thrown when an invalid first " +
                           "argument is passed in.")]
        public virtual void FirstArgumentException()
        {
            Assert.Throws<TException>(() => OneArgInvoke(InvalidArg1),
                                      "Exception of type \"{0}\" was not thrown " +
                                      "as expected on receipt of invalid value.",
                                      typeof(TException).FullName);
        }

        /// <summary>
        /// The method that is invoked to test whether an 
        /// <see cref="TException"/> is thrown on input of a 
        /// <see cref="ArgumentExceptionTests{TException, T1}.InvalidArg1"/> 
        /// first argument.
        /// </summary>
        protected abstract Action<T1> OneArgInvoke { get; }

        /// <summary>
        /// A valid value to the first argument that will not cause an exception
        /// to be thrown.
        /// </summary>
        protected abstract T1 ValidArg1 { get; }

        /// <summary>
        /// An invalid value to the first argument that will cause an exception
        /// to be thrown.
        /// </summary>
        protected abstract T1 InvalidArg1 { get; }
    }

    /// <summary>
    /// A utility type that is used to ensure that methods, constructors,
    /// properties and the like throw an <typeparamref name="TException"/>
    /// exception when they receive an invalid argument.
    /// </summary>
    /// <typeparam name="TException">The type of exception to test for.</typeparam>
    /// <typeparam name="T1">The type of the first argument.</typeparam>
    /// <typeparam name="T2">The type of the second argument.</typeparam>
    public abstract class ArgumentExceptionTests<TException, T1, T2>
        : ArgumentExceptionTests<TException, T1>
        where TException : Exception
        where T1 : class
        where T2 : class
    {
        [Test, Description("Ensures a TException is thrown when an invalid" +
                           "second argument is passed in.")]
        public virtual void SecondArgumentException()
        {
            Assert.Throws<TException>(() => TwoArgInvoke(ValidArg1, InvalidArg2),
                                      "Exception of type \"{0}\" was not thrown " +
                                      "as expected on receipt of invalid value.",
                                      typeof(TException).FullName);
        }

        /// <summary>
        /// The method that is invoked to test whether an 
        /// <see cref="TException"/> is thrown on input of invalid arguments.
        /// </summary>
        protected abstract Action<T1, T2> TwoArgInvoke { get; }

        /// <summary>
        /// A valid value to the second argument that will not cause an exception
        /// to be thrown.
        /// </summary>
        protected abstract T2 ValidArg2 { get; }

        /// <summary>
        /// An invalid value to the second argument that will cause an exception
        /// to be thrown.
        /// </summary>
        protected abstract T2 InvalidArg2 { get; }

        /// <summary>
        /// The method that is invoked to test whether an 
        /// <see cref="TException"/> is thrown on input of a 
        /// <see cref="ArgumentExceptionTests{TException, T1}.InvalidArg1"/> 
        /// first argument.
        /// </summary>
        protected override Action<T1> OneArgInvoke
        {
            get { return arg => TwoArgInvoke(arg, ValidArg2); }
        }
    }

    /// <summary>
    /// A utility type that is used to ensure that methods, constructors,
    /// properties and the like throw an <typeparamref name="TException" />
    /// exception when they receive an invalid argument.
    /// </summary>
    /// <typeparam name="TException">The type of exception to test for.</typeparam>
    /// <typeparam name="T1">The type of the first argument.</typeparam>
    /// <typeparam name="T2">The type of the second argument.</typeparam>
    /// <typeparam name="T3">The type of the third argument.</typeparam>
    public abstract class ArgumentExceptionTests<TException, T1, T2, T3>
        : ArgumentExceptionTests<TException, T1, T2>
        where TException : Exception
        where T1 : class
        where T2 : class
        where T3 : class
    {
        [Test, Description("Ensures a TException is thrown when an invalid" +
                           "third argument is passed in.")]
        public virtual void ThirdArgumentException()
        {
            Assert.Throws<TException>(() => ThreeArgInvoke(ValidArg1, ValidArg2, InvalidArg3),
                                      "Exception of type \"{0}\" was not thrown " +
                                      "as expected on receipt of invalid value.",
                                      typeof(TException).FullName);
        }

        /// <summary>
        /// The method that is invoked to test whether an 
        /// <see cref="TException"/> is thrown on input of invalid arguments.
        /// </summary>
        protected abstract Action<T1, T2, T3> ThreeArgInvoke { get; }

        /// <summary>
        /// A valid value to the third argument that will not cause an exception
        /// to be thrown.
        /// </summary>
        protected abstract T3 ValidArg3 { get; }

        /// <summary>
        /// An invalid value to the third argument that will cause an exception
        /// to be thrown.
        /// </summary>
        protected abstract T3 InvalidArg3 { get; }

        /// <summary>
        /// The method that is invoked to test whether an 
        /// <see cref="TException"/> is thrown on input of invalid arguments.
        /// </summary>
        protected override Action<T1, T2> TwoArgInvoke
        {
            get { return (arg1, arg2) => ThreeArgInvoke(arg1, arg2, ValidArg3); }
        }
    }

    /// <summary>
    /// A utility type that is used to ensure that methods, constructors,
    /// properties and the like throw an <typeparamref name="TException" />
    /// exception when they receive an invalid argument.
    /// </summary>
    /// <typeparam name="TException">The type of exception to test for.</typeparam>
    /// <typeparam name="T1">The type of the first argument.</typeparam>
    /// <typeparam name="T2">The type of the second argument.</typeparam>
    /// <typeparam name="T3">The type of the third argument.</typeparam>
    /// <typeparam name="T4">The type of the fourth argument.</typeparam>
    public abstract class ArgumentExceptionTests<TException, T1, T2, T3, T4>
        : ArgumentExceptionTests<TException, T1, T2, T3>
        where TException : Exception
        where T1 : class
        where T2 : class
        where T3 : class
        where T4 : class
    {
        [Test, Description("Ensures a TException is thrown when an invalid" +
                           "fourth argument is passed in.")]
        public virtual void FourthArgumentException()
        {
            Assert.Throws<TException>(() => FourArgInvoke(ValidArg1, ValidArg2, ValidArg3, InvalidArg4),
                                      "Exception of type \"{0}\" was not thrown " +
                                      "as expected on receipt of invalid value.",
                                      typeof(TException).FullName);
        }

        /// <summary>
        /// The method that is invoked to test whether an 
        /// <see cref="TException"/> is thrown on input of invalid arguments.
        /// </summary>
        protected abstract Action<T1, T2, T3, T4> FourArgInvoke { get; }

        /// <summary>
        /// A valid value to the fourth argument that will not cause an exception
        /// to be thrown.
        /// </summary>
        protected abstract T4 ValidArg4 { get; }

        /// <summary>
        /// An invalid value to the fourth argument that will cause an exception
        /// to be thrown.
        /// </summary>
        protected abstract T4 InvalidArg4 { get; }

        /// <summary>
        /// The method that is invoked to test whether an 
        /// <see cref="TException"/> is thrown on input of invalid arguments.
        /// </summary>
        protected override Action<T1, T2, T3> ThreeArgInvoke
        {
            get { return (arg1, arg2, arg3) => FourArgInvoke(arg1, arg2, arg3, ValidArg4); }
        }
    }

    /// <summary>
    /// A utility type that is used to ensure that methods, constructors,
    /// properties and the like throw an <typeparamref name="TException" />
    /// exception when they receive an invalid argument.
    /// </summary>
    /// <typeparam name="TException">The type of exception to test for.</typeparam>
    /// <typeparam name="T1">The type of the first argument.</typeparam>
    /// <typeparam name="T2">The type of the second argument.</typeparam>
    /// <typeparam name="T3">The type of the third argument.</typeparam>
    /// <typeparam name="T4">The type of the fourth argument.</typeparam>
    /// <typeparam name="T5">The type of the fifth argument.</typeparam>
    public abstract class ArgumentExceptionTests<TException, T1, T2, T3, T4, T5>
        : ArgumentExceptionTests<TException, T1, T2, T3, T4>
        where TException : Exception
        where T1 : class
        where T2 : class
        where T3 : class
        where T4 : class
        where T5 : class
    {
        [Test, Description("Ensures a TException is thrown when an invalid" +
                           "fifth argument is passed in.")]
        public virtual void FifthArgumentException()
        {
            Assert.Throws<TException>(() => FiveArgInvoke(ValidArg1, ValidArg2, ValidArg3, ValidArg4, InvalidArg5),
                                      "Exception of type \"{0}\" was not thrown " +
                                      "as expected on receipt of invalid value.",
                                      typeof(TException).FullName);
        }

        /// <summary>
        /// The method that is invoked to test whether an 
        /// <see cref="TException"/> is thrown on input of invalid arguments.
        /// </summary>
        protected abstract Action<T1, T2, T3, T4, T5> FiveArgInvoke { get; }

        /// <summary>
        /// A valid value to the fifth argument that will not cause an exception
        /// to be thrown.
        /// </summary>
        protected abstract T5 ValidArg5 { get; }

        /// <summary>
        /// An invalid value to the fifth argument that will cause an exception
        /// to be thrown.
        /// </summary>
        protected abstract T5 InvalidArg5 { get; }

        /// <summary>
        /// The method that is invoked to test whether an 
        /// <see cref="TException"/> is thrown on input of invalid arguments.
        /// </summary>
        protected override Action<T1, T2, T3, T4> FourArgInvoke
        {
            get { return (arg1, arg2, arg3, arg4) => FiveArgInvoke(arg1, arg2, arg3, arg4, ValidArg5); }
        }
    }
}