using System;
using NUnit.Framework;

namespace Chernobyl.Measures.Time
{
    [TestFixture, Description("Tests for the Milliseconds type.")]
    public class MillisecondsTests : TimeTests
    {
        [Test, Description("A test that ensures the Milliseconds(double) constructor " +
            "sets the proper value.")]
        public void ConstructorDoubleTest()
        {
            Milliseconds milliseconds = new Milliseconds(32.1);
            Assert.AreEqual(32.1, milliseconds.Value, 0.0,
                "The value returned by Milliseconds.Value is not the expected value.");
        }

        [Test, Description("A test to ensure the implicit Milliseconds to double " +
            "conversion works as expected.")]
        public void ImplicitDoubleToMillisecondsConversionTest()
        {
            Milliseconds milliseconds = new Milliseconds(32.1);

            double value = milliseconds;
            Assert.AreEqual(milliseconds.Value, value, 0.0,
                "The value returned by the implicit Milliseconds to Double conversion " +
                "is not the expected value.");
        }

        [Test, Description("A test to ensure the explicit Double to Milliseconds " +
            "conversion works as expected.")]
        public void ExplicitDoubleToMillisecondsConversionTest()
        {
            const double value = 32.1;
            Milliseconds milliseconds = (Milliseconds)value;

            Assert.AreEqual(value, milliseconds.Value, 0.0,
                "The value returned by the explicit Double to Milliseconds conversion " +
                "is not the expected value.");
        }

        [Test, Description("A test to ensure the implicit Seconds to Milliseconds " +
            "conversion works as expected.")]
        public void ImplicitSecondsToMillisecondsConversionTest()
        {
            Seconds value = new Seconds(32.1);
            Milliseconds milliseconds = value;

            Assert.AreEqual(32100, milliseconds.Value, 0.0,
                "The value returned by the implicit Seconds to Milliseconds conversion " +
                "is not the expected value.");
        }

        [Test, Description("A test to ensure the implicit Milliseconds to Seconds " +
            "conversion works as expected.")]
        public void ImplicitMillisecondsToSecondsConversionTest()
        {
            Milliseconds value = new Milliseconds(3210);
            Seconds seconds = value;

            Assert.AreEqual(3.21, seconds.Value, 0.0,
                "The value returned by the implicit Milliseconds to Seconds conversion " +
                "is not the expected value.");
        }

        [TestFixture, Description("Tests for the IEquatable<T> and Object " +
            "implementations of the Milliseconds type.")]
        public class EquatableTests : EquatableTests<Milliseconds>
        {
            protected override IEquatable<Milliseconds> CreateEquatable()
            {
                return new Milliseconds(32.1);
            }

            protected override Milliseconds CreateEqualObject()
            {
                return new Milliseconds(32.1);
            }

            protected override Milliseconds CreateNotEqualObject()
            {
                return new Milliseconds(15.5);
            }

            protected override string ExpectedToStringResult
            {
                get { return "32.1 ms"; }
            }
        }

        [TestFixture, Description("Tests for the IComparable<T> implementation " +
            "of the Milliseconds type.")]
        public class ComparableTests : ComparableTests<Milliseconds>
        {
            protected override IComparable<Milliseconds> CreateComparable()
            {
                return new Milliseconds(32.0);
            }

            protected override Milliseconds CreateLessThanObject()
            {
                return new Milliseconds(15.0);
            }

            protected override Milliseconds CreateEqualObject()
            {
                return new Milliseconds(32.0);
            }

            protected override Milliseconds CreateGreaterThanObject()
            {
                return new Milliseconds(33.0);
            }
        }

        [TestFixture, Description("Tests for the Milliseconds type's mathematical " +
            "operator overloads.")]
        public class MathematicalOperatorTests : MathematicalOperatorTests<Milliseconds>
        {

            protected override Milliseconds CreateX()
            {
                return new Milliseconds(X);
            }

            protected override Milliseconds CreateY()
            {
                return new Milliseconds(Y);
            }

            protected override Milliseconds ExpectedBinaryAdditionResult
            {
                get { return new Milliseconds(X + Y); }
            }

            protected override Milliseconds ExpectedBinarySubtractionResult
            {
                get { return new Milliseconds(X - Y); }
            }

            protected override Milliseconds OppositeExpectedBinarySubtractionResult
            {
                get { return new Milliseconds(Y - X); }
            }

            protected override Milliseconds ExpectedNegationResult
            {
                get { return new Milliseconds(-X); }
            }

            protected override Milliseconds ExpectedMultiplicationResult
            {
                get { return new Milliseconds(X * Y); }
            }

            protected override Milliseconds ExpectedDivisionResult
            {
                get { return new Milliseconds(X / Y); }
            }

            protected override Milliseconds OppositeExpectedDivisionResult
            {
                get { return new Milliseconds(Y / X); }
            }

            /// <summary>
            /// The double form of <see cref="CreateX()"/>.
            /// </summary>
            const double X = 32.1;

            /// <summary>
            /// The double form of <see cref="CreateY()"/>.
            /// </summary>
            const double Y = -56.75;
        }

        [TestFixture, Description("Tests for the Milliseconds type's equality " +
            "operator overloads.")]
        public class EqualityOperatorTests : EqualityOperatorTests<Milliseconds>
        {
            protected override Milliseconds CreateX()
            {
                return new Milliseconds(32.1);
            }

            protected override Milliseconds CreateEqual()
            {
                return new Milliseconds(32.1);
            }

            protected override Milliseconds CreateNotEqual()
            {
                return new Milliseconds(-43.6);
            }
        }

        [TestFixture, Description("Tests for the Milliseconds type's relational " +
            "operator overloads.")]
        public class RelationalOperatorTests : RelationalOperatorTests<Milliseconds>
        {
            protected override Milliseconds CreateX()
            {
                return new Milliseconds(32.1);
            }

            protected override Milliseconds CreateLessThan()
            {
                return new Milliseconds(32.0);
            }

            protected override Milliseconds CreateEqual()
            {
                return new Milliseconds(32.1);
            }

            protected override Milliseconds CreateGreaterThan()
            {
                return new Milliseconds(32.2);
            }
        }

        protected override ITime CreateTime()
        {
            return (Milliseconds)ToSecondsValue;
        }
    }
}