using Zinnia.Utility;

namespace Test.Zinnia.Utility
{
    using NUnit.Framework;
    using System.Collections;
    using Test.Zinnia.Utility.Mock;
    using UnityEngine;
    using UnityEngine.TestTools;
    using UnityEngine.TestTools.Utils;

    public class CountdownTimerTest
    {
        private GameObject containingObject;
        private CountdownTimer subject;

        [SetUp]
        public void SetUp()
        {
            containingObject = new GameObject("CountdownTimerTest");
            containingObject.SetActive(false);
            subject = containingObject.AddComponent<CountdownTimer>();
        }

        [TearDown]
        public void TearDown()
        {
            Object.Destroy(containingObject);
        }

        [UnityTest]
        public IEnumerator TimerComplete()
        {
            containingObject.SetActive(true);
            UnityEventListenerMock timerStartedMock = new UnityEventListenerMock();
            UnityEventListenerMock timerCancelledMock = new UnityEventListenerMock();
            UnityEventListenerMock timerCompleteMock = new UnityEventListenerMock();
            UnityEventListenerMock timerStillRunningMock = new UnityEventListenerMock();
            UnityEventListenerMock timerNotRunningMock = new UnityEventListenerMock();

            subject.Started.AddListener(timerStartedMock.Listen);
            subject.Cancelled.AddListener(timerCancelledMock.Listen);
            subject.Completed.AddListener(timerCompleteMock.Listen);
            subject.StillRunning.AddListener(timerStillRunningMock.Listen);
            subject.NotRunning.AddListener(timerNotRunningMock.Listen);

            subject.StartTime = 0.1f;

            Assert.IsFalse(timerStartedMock.Received);
            Assert.IsFalse(timerCancelledMock.Received);
            Assert.IsFalse(timerCompleteMock.Received);
            Assert.IsFalse(timerStillRunningMock.Received);
            Assert.IsFalse(timerNotRunningMock.Received);

            subject.Begin();

            Assert.IsTrue(timerStartedMock.Received);
            Assert.IsFalse(timerCancelledMock.Received);
            Assert.IsFalse(timerCompleteMock.Received);

            subject.EmitStatus();

            Assert.IsTrue(timerStillRunningMock.Received);
            Assert.IsFalse(timerNotRunningMock.Received);

            yield return new WaitForSeconds(0.1f);

            Assert.IsFalse(timerCancelledMock.Received);
            Assert.IsTrue(timerCompleteMock.Received);

            timerStillRunningMock.Reset();
            timerNotRunningMock.Reset();

            subject.EmitStatus();

            Assert.IsFalse(timerStillRunningMock.Received);
            Assert.IsTrue(timerNotRunningMock.Received);
        }

        [UnityTest]
        public IEnumerator TimerRunsOnEnable()
        {
            UnityEventListenerMock timerStartedMock = new UnityEventListenerMock();
            UnityEventListenerMock timerCancelledMock = new UnityEventListenerMock();
            UnityEventListenerMock timerCompleteMock = new UnityEventListenerMock();
            UnityEventListenerMock timerStillRunningMock = new UnityEventListenerMock();
            UnityEventListenerMock timerNotRunningMock = new UnityEventListenerMock();

            subject.Started.AddListener(timerStartedMock.Listen);
            subject.Cancelled.AddListener(timerCancelledMock.Listen);
            subject.Completed.AddListener(timerCompleteMock.Listen);
            subject.StillRunning.AddListener(timerStillRunningMock.Listen);
            subject.NotRunning.AddListener(timerNotRunningMock.Listen);

            subject.StartTime = 0.1f;
            subject.BeginOnEnable = true;

            Assert.IsFalse(timerStartedMock.Received);
            Assert.IsFalse(timerCancelledMock.Received);
            Assert.IsFalse(timerCompleteMock.Received);
            Assert.IsFalse(timerStillRunningMock.Received);
            Assert.IsFalse(timerNotRunningMock.Received);

            containingObject.SetActive(true);

            Assert.IsTrue(timerStartedMock.Received);
            Assert.IsFalse(timerCancelledMock.Received);
            Assert.IsFalse(timerCompleteMock.Received);

            subject.EmitStatus();

            Assert.IsTrue(timerStillRunningMock.Received);
            Assert.IsFalse(timerNotRunningMock.Received);

            yield return new WaitForSeconds(0.1f);

            Assert.IsFalse(timerCancelledMock.Received);
            Assert.IsTrue(timerCompleteMock.Received);

            timerStillRunningMock.Reset();
            timerNotRunningMock.Reset();

            subject.EmitStatus();

            Assert.IsFalse(timerStillRunningMock.Received);
            Assert.IsTrue(timerNotRunningMock.Received);
        }

        [UnityTest]
        public IEnumerator TimerCancelled()
        {
            containingObject.SetActive(true);
            UnityEventListenerMock timerStartedMock = new UnityEventListenerMock();
            UnityEventListenerMock timerCancelledMock = new UnityEventListenerMock();
            UnityEventListenerMock timerCompleteMock = new UnityEventListenerMock();
            UnityEventListenerMock timerStillRunningMock = new UnityEventListenerMock();
            UnityEventListenerMock timerNotRunningMock = new UnityEventListenerMock();

            subject.Started.AddListener(timerStartedMock.Listen);
            subject.Cancelled.AddListener(timerCancelledMock.Listen);
            subject.Completed.AddListener(timerCompleteMock.Listen);
            subject.StillRunning.AddListener(timerStillRunningMock.Listen);
            subject.NotRunning.AddListener(timerNotRunningMock.Listen);

            subject.StartTime = 0.2f;

            Assert.IsFalse(timerStartedMock.Received);
            Assert.IsFalse(timerCancelledMock.Received);
            Assert.IsFalse(timerCompleteMock.Received);

            subject.Begin();

            Assert.IsTrue(timerStartedMock.Received);
            Assert.IsFalse(timerCancelledMock.Received);
            Assert.IsFalse(timerCompleteMock.Received);

            subject.EmitStatus();

            Assert.IsTrue(timerStillRunningMock.Received);
            Assert.IsFalse(timerNotRunningMock.Received);

            yield return new WaitForSeconds(0.1f);

            subject.Cancel();

            Assert.IsTrue(timerCancelledMock.Received);
            Assert.IsFalse(timerCompleteMock.Received);

            timerStillRunningMock.Reset();
            timerNotRunningMock.Reset();

            subject.EmitStatus();

            Assert.IsFalse(timerStillRunningMock.Received);
            Assert.IsTrue(timerNotRunningMock.Received);
        }

        [UnityTest]
        public IEnumerator TimerDoesNotCompleteOnInactiveGameObject()
        {
            containingObject.SetActive(true);
            UnityEventListenerMock timerStartedMock = new UnityEventListenerMock();
            UnityEventListenerMock timerCancelledMock = new UnityEventListenerMock();
            UnityEventListenerMock timerCompleteMock = new UnityEventListenerMock();
            UnityEventListenerMock timerStillRunningMock = new UnityEventListenerMock();
            UnityEventListenerMock timerNotRunningMock = new UnityEventListenerMock();

            subject.Started.AddListener(timerStartedMock.Listen);
            subject.Cancelled.AddListener(timerCancelledMock.Listen);
            subject.Completed.AddListener(timerCompleteMock.Listen);
            subject.StillRunning.AddListener(timerStillRunningMock.Listen);
            subject.NotRunning.AddListener(timerNotRunningMock.Listen);

            subject.gameObject.SetActive(false);

            subject.StartTime = 0.1f;

            Assert.IsFalse(timerStartedMock.Received);
            Assert.IsFalse(timerCancelledMock.Received);
            Assert.IsFalse(timerCompleteMock.Received);
            Assert.IsFalse(timerStillRunningMock.Received);
            Assert.IsFalse(timerNotRunningMock.Received);

            subject.Begin();

            Assert.IsFalse(timerStartedMock.Received);
            Assert.IsFalse(timerCancelledMock.Received);
            Assert.IsFalse(timerCompleteMock.Received);

            subject.EmitStatus();

            Assert.IsFalse(timerStillRunningMock.Received);
            Assert.IsFalse(timerNotRunningMock.Received);

            yield return new WaitForSeconds(0.1f);

            Assert.IsFalse(timerCancelledMock.Received);
            Assert.IsFalse(timerCompleteMock.Received);

            timerStillRunningMock.Reset();
            timerNotRunningMock.Reset();

            subject.EmitStatus();

            Assert.IsFalse(timerStillRunningMock.Received);
            Assert.IsFalse(timerNotRunningMock.Received);
        }

        [UnityTest]
        public IEnumerator TimerDoesNotCompleteOnInactiveComponent()
        {
            containingObject.SetActive(true);
            UnityEventListenerMock timerStartedMock = new UnityEventListenerMock();
            UnityEventListenerMock timerCancelledMock = new UnityEventListenerMock();
            UnityEventListenerMock timerCompleteMock = new UnityEventListenerMock();
            UnityEventListenerMock timerStillRunningMock = new UnityEventListenerMock();
            UnityEventListenerMock timerNotRunningMock = new UnityEventListenerMock();

            subject.Started.AddListener(timerStartedMock.Listen);
            subject.Cancelled.AddListener(timerCancelledMock.Listen);
            subject.Completed.AddListener(timerCompleteMock.Listen);
            subject.StillRunning.AddListener(timerStillRunningMock.Listen);
            subject.NotRunning.AddListener(timerNotRunningMock.Listen);

            subject.enabled = false;

            subject.StartTime = 0.1f;

            Assert.IsFalse(timerStartedMock.Received);
            Assert.IsFalse(timerCancelledMock.Received);
            Assert.IsFalse(timerCompleteMock.Received);
            Assert.IsFalse(timerStillRunningMock.Received);
            Assert.IsFalse(timerNotRunningMock.Received);

            subject.Begin();

            Assert.IsFalse(timerStartedMock.Received);
            Assert.IsFalse(timerCancelledMock.Received);
            Assert.IsFalse(timerCompleteMock.Received);

            subject.EmitStatus();

            Assert.IsFalse(timerStillRunningMock.Received);
            Assert.IsFalse(timerNotRunningMock.Received);

            yield return new WaitForSeconds(0.1f);

            Assert.IsFalse(timerCancelledMock.Received);
            Assert.IsFalse(timerCompleteMock.Received);

            timerStillRunningMock.Reset();
            timerNotRunningMock.Reset();

            subject.EmitStatus();

            Assert.IsFalse(timerStillRunningMock.Received);
            Assert.IsFalse(timerNotRunningMock.Received);
        }

        [UnityTest]
        public IEnumerator TimerCancelledOnDisableGameObject()
        {
            containingObject.SetActive(true);
            UnityEventListenerMock timerStartedMock = new UnityEventListenerMock();
            UnityEventListenerMock timerCancelledMock = new UnityEventListenerMock();
            UnityEventListenerMock timerCompleteMock = new UnityEventListenerMock();
            UnityEventListenerMock timerStillRunningMock = new UnityEventListenerMock();
            UnityEventListenerMock timerNotRunningMock = new UnityEventListenerMock();

            subject.Started.AddListener(timerStartedMock.Listen);
            subject.Cancelled.AddListener(timerCancelledMock.Listen);
            subject.Completed.AddListener(timerCompleteMock.Listen);
            subject.StillRunning.AddListener(timerStillRunningMock.Listen);
            subject.NotRunning.AddListener(timerNotRunningMock.Listen);

            subject.StartTime = 0.2f;

            Assert.IsFalse(timerStartedMock.Received);
            Assert.IsFalse(timerCancelledMock.Received);
            Assert.IsFalse(timerCompleteMock.Received);

            subject.Begin();

            Assert.IsTrue(timerStartedMock.Received);
            Assert.IsFalse(timerCancelledMock.Received);
            Assert.IsFalse(timerCompleteMock.Received);

            subject.EmitStatus();

            Assert.IsTrue(timerStillRunningMock.Received);
            Assert.IsFalse(timerNotRunningMock.Received);

            yield return new WaitForSeconds(0.1f);

            subject.gameObject.SetActive(false);

            Assert.IsTrue(timerCancelledMock.Received);
            Assert.IsFalse(timerCompleteMock.Received);

            timerStillRunningMock.Reset();
            timerNotRunningMock.Reset();

            subject.EmitStatus();

            Assert.IsFalse(timerStillRunningMock.Received);
            Assert.IsFalse(timerNotRunningMock.Received);
        }

        [UnityTest]
        public IEnumerator TimerCancelledOnDisableComponent()
        {
            containingObject.SetActive(true);
            UnityEventListenerMock timerStartedMock = new UnityEventListenerMock();
            UnityEventListenerMock timerCancelledMock = new UnityEventListenerMock();
            UnityEventListenerMock timerCompleteMock = new UnityEventListenerMock();
            UnityEventListenerMock timerStillRunningMock = new UnityEventListenerMock();
            UnityEventListenerMock timerNotRunningMock = new UnityEventListenerMock();

            subject.Started.AddListener(timerStartedMock.Listen);
            subject.Cancelled.AddListener(timerCancelledMock.Listen);
            subject.Completed.AddListener(timerCompleteMock.Listen);
            subject.StillRunning.AddListener(timerStillRunningMock.Listen);
            subject.NotRunning.AddListener(timerNotRunningMock.Listen);

            subject.StartTime = 0.2f;

            Assert.IsFalse(timerStartedMock.Received);
            Assert.IsFalse(timerCancelledMock.Received);
            Assert.IsFalse(timerCompleteMock.Received);

            subject.Begin();

            Assert.IsTrue(timerStartedMock.Received);
            Assert.IsFalse(timerCancelledMock.Received);
            Assert.IsFalse(timerCompleteMock.Received);

            subject.EmitStatus();

            Assert.IsTrue(timerStillRunningMock.Received);
            Assert.IsFalse(timerNotRunningMock.Received);

            yield return new WaitForSeconds(0.1f);

            subject.enabled = false;

            Assert.IsTrue(timerCancelledMock.Received);
            Assert.IsFalse(timerCompleteMock.Received);

            timerStillRunningMock.Reset();
            timerNotRunningMock.Reset();

            subject.EmitStatus();

            Assert.IsFalse(timerStillRunningMock.Received);
            Assert.IsFalse(timerNotRunningMock.Received);
        }

        [UnityTest]
        public IEnumerator TimerEmitTime()
        {
            FloatEqualityComparer comparer = new FloatEqualityComparer(0.1f);
            containingObject.SetActive(true);
            UnityEventListenerMock timerCompleteMock = new UnityEventListenerMock();
            UnityEventValueListenerMock<float> timerElapsedTimeMock = new UnityEventValueListenerMock<float>();
            UnityEventValueListenerMock<float> timerRemainingTimeMock = new UnityEventValueListenerMock<float>();

            subject.Completed.AddListener(timerCompleteMock.Listen);
            subject.ElapsedTimeEmitted.AddListener(timerElapsedTimeMock.Listen);
            subject.RemainingTimeEmitted.AddListener(timerRemainingTimeMock.Listen);

            float beginTime = Time.time;
            float startTime = 0.5f;

            subject.StartTime = startTime;

            Assert.IsFalse(timerElapsedTimeMock.Received);
            Assert.IsFalse(timerRemainingTimeMock.Received);

            subject.EmitElapsedTime();
            Assert.IsTrue(timerElapsedTimeMock.Received);
            Assert.That(timerElapsedTimeMock.Value, Is.EqualTo(0f).Using(comparer));

            subject.EmitRemainingTime();
            Assert.IsTrue(timerRemainingTimeMock.Received);
            Assert.That(timerRemainingTimeMock.Value, Is.EqualTo(0.5f).Using(comparer));

            timerElapsedTimeMock.Reset();
            timerRemainingTimeMock.Reset();

            subject.Begin();

            Assert.IsFalse(timerCompleteMock.Received);

            subject.EmitElapsedTime();
            Assert.IsTrue(timerElapsedTimeMock.Received);
            Assert.That(timerElapsedTimeMock.Value, Is.EqualTo(0f).Using(comparer));

            subject.EmitRemainingTime();
            Assert.IsTrue(timerRemainingTimeMock.Received);
            Assert.That(timerRemainingTimeMock.Value, Is.EqualTo(0.5f).Using(comparer));

            timerElapsedTimeMock.Reset();
            timerRemainingTimeMock.Reset();

            yield return new WaitForSeconds(0.2f);

            float elapsedTime = Time.time - beginTime;
            float remainingTime = startTime + (beginTime - Time.time);

            subject.EmitElapsedTime();
            Assert.IsTrue(timerElapsedTimeMock.Received);
            Assert.AreEqual(timerElapsedTimeMock.Value, elapsedTime);

            subject.EmitRemainingTime();
            Assert.IsTrue(timerRemainingTimeMock.Received);
            Assert.AreEqual(timerRemainingTimeMock.Value, remainingTime);

            timerElapsedTimeMock.Reset();
            timerRemainingTimeMock.Reset();

            yield return new WaitForSeconds(0.3f);

            Assert.IsTrue(timerCompleteMock.Received);

            subject.EmitElapsedTime();
            Assert.IsTrue(timerElapsedTimeMock.Received);
            Assert.That(timerElapsedTimeMock.Value, Is.EqualTo(0.5f).Using(comparer));

            subject.EmitRemainingTime();
            Assert.IsTrue(timerRemainingTimeMock.Received);
            Assert.That(timerRemainingTimeMock.Value, Is.EqualTo(0f).Using(comparer));
        }

        [UnityTest]
        public IEnumerator TimerEmitTimeUnchangedAfterComplete()
        {
            FloatEqualityComparer comparer = new FloatEqualityComparer(0.1f);
            containingObject.SetActive(true);
            UnityEventListenerMock timerCompleteMock = new UnityEventListenerMock();
            UnityEventValueListenerMock<float> timerElapsedTimeMock = new UnityEventValueListenerMock<float>();
            UnityEventValueListenerMock<float> timerRemainingTimeMock = new UnityEventValueListenerMock<float>();

            subject.Completed.AddListener(timerCompleteMock.Listen);
            subject.ElapsedTimeEmitted.AddListener(timerElapsedTimeMock.Listen);
            subject.RemainingTimeEmitted.AddListener(timerRemainingTimeMock.Listen);

            float beginTime = Time.time;
            float startTime = 0.5f;
            subject.StartTime = startTime;

            Assert.IsFalse(timerElapsedTimeMock.Received);
            Assert.IsFalse(timerRemainingTimeMock.Received);

            subject.EmitElapsedTime();
            Assert.IsTrue(timerElapsedTimeMock.Received);
            Assert.That(timerElapsedTimeMock.Value, Is.EqualTo(0f).Using(comparer));

            subject.EmitRemainingTime();
            Assert.IsTrue(timerRemainingTimeMock.Received);
            Assert.That(timerRemainingTimeMock.Value, Is.EqualTo(0.5f).Using(comparer));

            timerElapsedTimeMock.Reset();
            timerRemainingTimeMock.Reset();

            subject.Begin();

            Assert.IsFalse(timerCompleteMock.Received);

            subject.EmitElapsedTime();
            Assert.IsTrue(timerElapsedTimeMock.Received);
            Assert.That(timerElapsedTimeMock.Value, Is.EqualTo(0f).Using(comparer));

            subject.EmitRemainingTime();
            Assert.IsTrue(timerRemainingTimeMock.Received);
            Assert.That(timerRemainingTimeMock.Value, Is.EqualTo(0.5f).Using(comparer));

            timerElapsedTimeMock.Reset();
            timerRemainingTimeMock.Reset();

            yield return new WaitForSeconds(0.5f);

            Assert.IsTrue(timerCompleteMock.Received);

            subject.EmitElapsedTime();
            Assert.IsTrue(timerElapsedTimeMock.Received);
            Assert.That(timerElapsedTimeMock.Value, Is.EqualTo(0.5f).Using(comparer));

            subject.EmitRemainingTime();
            Assert.IsTrue(timerRemainingTimeMock.Received);
            Assert.That(timerRemainingTimeMock.Value, Is.EqualTo(0f).Using(comparer));

            timerElapsedTimeMock.Reset();
            timerRemainingTimeMock.Reset();

            yield return new WaitForSeconds(0.5f);

            subject.EmitElapsedTime();
            Assert.IsTrue(timerElapsedTimeMock.Received);
            Assert.That(timerElapsedTimeMock.Value, Is.EqualTo(0.5f).Using(comparer));

            subject.EmitRemainingTime();
            Assert.IsTrue(timerRemainingTimeMock.Received);
            Assert.That(timerRemainingTimeMock.Value, Is.EqualTo(0f).Using(comparer));
        }

        [UnityTest]
        public IEnumerator TimerEmitTimeUnchangedAfterCancelled()
        {
            FloatEqualityComparer comparer = new FloatEqualityComparer(0.1f);
            containingObject.SetActive(true);
            UnityEventListenerMock timerCompleteMock = new UnityEventListenerMock();
            UnityEventListenerMock timerCancelledMock = new UnityEventListenerMock();
            UnityEventValueListenerMock<float> timerElapsedTimeMock = new UnityEventValueListenerMock<float>();
            UnityEventValueListenerMock<float> timerRemainingTimeMock = new UnityEventValueListenerMock<float>();

            subject.Completed.AddListener(timerCompleteMock.Listen);
            subject.Cancelled.AddListener(timerCancelledMock.Listen);
            subject.ElapsedTimeEmitted.AddListener(timerElapsedTimeMock.Listen);
            subject.RemainingTimeEmitted.AddListener(timerRemainingTimeMock.Listen);

            float beginTime = Time.time;
            float startTime = 0.5f;
            subject.StartTime = startTime;

            Assert.IsFalse(timerElapsedTimeMock.Received);
            Assert.IsFalse(timerRemainingTimeMock.Received);

            subject.EmitElapsedTime();
            Assert.IsTrue(timerElapsedTimeMock.Received);
            Assert.That(timerElapsedTimeMock.Value, Is.EqualTo(0f).Using(comparer));

            subject.EmitRemainingTime();
            Assert.IsTrue(timerRemainingTimeMock.Received);
            Assert.That(timerRemainingTimeMock.Value, Is.EqualTo(0.5f).Using(comparer));

            timerElapsedTimeMock.Reset();
            timerRemainingTimeMock.Reset();

            subject.Begin();

            Assert.IsFalse(timerCompleteMock.Received);
            Assert.IsFalse(timerCancelledMock.Received);

            subject.EmitElapsedTime();
            Assert.IsTrue(timerElapsedTimeMock.Received);
            Assert.That(timerElapsedTimeMock.Value, Is.EqualTo(0f).Using(comparer));

            subject.EmitRemainingTime();
            Assert.IsTrue(timerRemainingTimeMock.Received);
            Assert.That(timerRemainingTimeMock.Value, Is.EqualTo(0.5f).Using(comparer));

            timerElapsedTimeMock.Reset();
            timerRemainingTimeMock.Reset();

            yield return new WaitForSeconds(0.2f);

            float elapsedTime = Time.time - beginTime;
            float remainingTime = startTime + (beginTime - Time.time);

            subject.EmitElapsedTime();
            Assert.IsTrue(timerElapsedTimeMock.Received);
            Assert.AreEqual(timerElapsedTimeMock.Value, elapsedTime);

            subject.EmitRemainingTime();
            Assert.IsTrue(timerRemainingTimeMock.Received);
            Assert.AreEqual(timerRemainingTimeMock.Value, remainingTime);

            timerElapsedTimeMock.Reset();
            timerRemainingTimeMock.Reset();

            subject.Cancel();
            Assert.IsFalse(timerCompleteMock.Received);
            Assert.IsTrue(timerCancelledMock.Received);

            subject.EmitElapsedTime();
            Assert.IsTrue(timerElapsedTimeMock.Received);
            Assert.AreEqual(timerElapsedTimeMock.Value, elapsedTime);

            subject.EmitRemainingTime();
            Assert.IsTrue(timerRemainingTimeMock.Received);
            Assert.AreEqual(timerRemainingTimeMock.Value, remainingTime);

            timerElapsedTimeMock.Reset();
            timerRemainingTimeMock.Reset();

            yield return new WaitForSeconds(0.5f);

            subject.EmitElapsedTime();
            Assert.IsTrue(timerElapsedTimeMock.Received);
            Assert.AreEqual(timerElapsedTimeMock.Value, elapsedTime);

            subject.EmitRemainingTime();
            Assert.IsTrue(timerRemainingTimeMock.Received);
            Assert.AreEqual(timerRemainingTimeMock.Value, remainingTime);
        }

        [UnityTest]
        public IEnumerator PauseResumeTimer()
        {
            FloatEqualityComparer comparer = new FloatEqualityComparer(0.1f);
            containingObject.SetActive(true);

            UnityEventListenerMock timerCompleteMock = new UnityEventListenerMock();
            UnityEventListenerMock timerPausedMock = new UnityEventListenerMock();
            UnityEventListenerMock timerResumedMock = new UnityEventListenerMock();
            subject.Completed.AddListener(timerCompleteMock.Listen);
            subject.Paused.AddListener(timerPausedMock.Listen);
            subject.Resumed.AddListener(timerResumedMock.Listen);

            float beginTime = Time.time;
            float startTime = 1f;
            subject.StartTime = startTime;

            Assert.IsFalse(timerCompleteMock.Received);
            Assert.IsFalse(timerPausedMock.Received);
            Assert.IsFalse(timerResumedMock.Received);
            Assert.AreEqual(0f, subject.ElapsedTime);
            Assert.AreEqual(startTime, subject.RemainingTime);

            subject.Begin();

            Assert.IsFalse(timerCompleteMock.Received);
            Assert.IsFalse(timerPausedMock.Received);
            Assert.IsFalse(timerResumedMock.Received);

            float timeDelay = startTime * 0.5f;

            yield return new WaitForSeconds(timeDelay);

            Assert.That(subject.ElapsedTime, Is.EqualTo(timeDelay).Using(comparer));
            Assert.That(subject.RemainingTime, Is.EqualTo(timeDelay).Using(comparer));

            subject.Pause();

            Assert.IsFalse(timerCompleteMock.Received);
            Assert.IsTrue(timerPausedMock.Received);
            Assert.IsFalse(timerResumedMock.Received);
            timerPausedMock.Reset();

            yield return new WaitForSeconds(timeDelay);

            Assert.That(subject.ElapsedTime, Is.EqualTo(timeDelay).Using(comparer));
            Assert.That(subject.RemainingTime, Is.EqualTo(timeDelay).Using(comparer));

            subject.Resume();

            Assert.IsFalse(timerCompleteMock.Received);
            Assert.IsFalse(timerPausedMock.Received);
            Assert.IsTrue(timerResumedMock.Received);

            yield return new WaitForSeconds(timeDelay);

            Assert.IsTrue(timerCompleteMock.Received);
            Assert.That(subject.ElapsedTime, Is.EqualTo(startTime).Using(comparer));
            Assert.That(subject.RemainingTime, Is.EqualTo(0f).Using(comparer));
        }
    }
}