using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
using UnitTestSharp;
using Action = System.Action;

namespace Amphora.UnitTests
{
    public class ExceptionSandboxTests : TestFixture
    {
        public static readonly Assembly AmphoraAssembly = typeof(ExceptionSandbox).Assembly;

        public static readonly ExceptionSite SiteA = new ExceptionSite(new object(), phase: 0);
        public static readonly ExceptionSite SiteB = new ExceptionSite(new object(), phase: 0);

        /// <summary>
        /// One throw site for whatever exception it's handed.
        /// </summary>
        public static readonly Action<Exception> Rethrow = exception => throw exception;

        /// <summary>
        /// A comparer that throws when asked to compare, standing in for client code that Amphora calls.
        /// </summary>
        public sealed class ThrowingComparer : IEqualityComparer<int>
        {
            public bool Equals(int left, int right)
            {
                throw new InvalidOperationException("Thrown by client code.");
            }

            public int GetHashCode(int value)
            {
                return value;
            }
        }

        /// <summary>
        /// Returns a dictionary whose lookups of its one key run a comparer that throws.
        /// </summary>
        public static OrderedDictionary<int, int> DictionaryWhoseComparerThrows()
        {
            var returnMe = new OrderedDictionary<int, int>(new ThrowingComparer());
            returnMe.Add(1, 1);
            return returnMe;
        }

        /// <summary>
        /// A target built in client code.
        /// </summary>
        public sealed class ClientTarget
        {
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        public static void ThrowFromClientHelper()
        {
            throw new InvalidOperationException("Thrown by a client helper.");
        }

        /// <summary>
        /// Does nothing.  Calling it after another call keeps the caller's frame, which an x64 tail call would drop.
        /// </summary>
        [MethodImpl(MethodImplOptions.NoInlining)]
        public static void KeepsTheCallerOnTheStack()
        {
        }

        public static int ClientFactory()
        {
            return 1;
        }

        public static ExceptionSandbox NewSandbox()
        {
            return new ExceptionSandbox(AmphoraAssembly);
        }

        public static ExceptionSandbox NewDroppingSandbox()
        {
            return new ExceptionSandbox(stackCanDropFrames: true, anchors: new[] { AmphoraAssembly });
        }

        public static ExceptionSandbox NewKeepingSandbox()
        {
            return new ExceptionSandbox(stackCanDropFrames: false, anchors: new[] { AmphoraAssembly });
        }

        public static ExceptionSite SiteAt(object target)
        {
            return new ExceptionSite(target, phase: 0);
        }

        public static Dictionary<string, string> Notes(string label, string value)
        {
            return new Dictionary<string, string> { { label, value } };
        }

        /// <summary>
        /// Runs <paramref name="action"/> behind a boundary filtered by <paramref name="sandbox"/>, and returns
        /// whether the sandbox claimed what it threw.
        /// </summary>
        public static bool Run(ExceptionSandbox sandbox, ExceptionSite site, Action action,
            IReadOnlyDictionary<string, string> notes = null)
        {
            try
            {
                action();
            }
            catch (Exception exception) when (sandbox.Claims(exception, site, notes))
            {
                return true;
            }

            return false;
        }

        public static bool Run<T>(ExceptionSandbox sandbox, ExceptionSite site, Action<T> action, T argument,
            IReadOnlyDictionary<string, string> notes = null)
        {
            try
            {
                action(argument);
            }
            catch (Exception exception) when (sandbox.Claims(exception, site, notes))
            {
                return true;
            }

            return false;
        }

        public static bool Run<T1, T2>(ExceptionSandbox sandbox, ExceptionSite site, Action<T1, T2> action,
            T1 first, T2 second)
        {
            try
            {
                action(first, second);
            }
            catch (Exception exception) when (sandbox.Claims(exception, site, notes: null))
            {
                return true;
            }

            return false;
        }

        public static bool RunFunc<T>(ExceptionSandbox sandbox, ExceptionSite site, Func<T, bool> function,
            T argument)
        {
            try
            {
                function(argument);
            }
            catch (Exception exception) when (sandbox.Claims(exception, site, notes: null))
            {
                return true;
            }

            return false;
        }

        /// <summary>
        /// Has client code throw a new <typeparamref name="TException"/> at <paramref name="site"/>, and returns the
        /// entry it landed in.
        /// </summary>
        public static ExceptionEntry Hit<TException>(ExceptionSandbox sandbox, ExceptionSite site)
            where TException : Exception, new()
        {
            Run(sandbox, site, Rethrow, new TException());
            return sandbox.Entries.Single(entry => entry.Exception.GetType() == typeof(TException));
        }

        public class CtorTests : TestFixture
        {
            public void StartsAtFrameZero()
            {
                CheckEqual(0L, NewSandbox().Frame);
            }

            public void StartsAtTimeZero()
            {
                CheckEqual(Duration.Zero, NewSandbox().Now);
            }

            public void StartsWithNoEntries()
            {
                CheckEqual(0, NewSandbox().Entries.Count);
            }

            public void Default_LetsTheStackDropFramesOnlyOnX64()
            {
                CheckEqual(IntPtr.Size == 8, NewSandbox().StackCanDropFrames);
            }

            public void StackCanDropFrames_IsKept()
            {
                CheckTrue(NewDroppingSandbox().StackCanDropFrames);
                CheckFalse(NewKeepingSandbox().StackCanDropFrames);
            }

            public void Anchors_AreKept()
            {
                Assembly other = typeof(UnitTestSharp.TestFixture).Assembly;

                var sandbox = new ExceptionSandbox(AmphoraAssembly, other);

                CheckEqual(new[] { AmphoraAssembly, other }, sandbox.Anchors.ToArray());
            }

            public void Anchors_AreCopied()
            {
                var anchors = new[] { AmphoraAssembly };
                var sandbox = new ExceptionSandbox(stackCanDropFrames: false, anchors: anchors);

                anchors[0] = typeof(UnitTestSharp.TestFixture).Assembly;

                CheckEqual(new[] { AmphoraAssembly }, sandbox.Anchors.ToArray());
            }

            public void NoAnchors_Throws()
            {
                CheckThrow(typeof(ArgumentException));
                new ExceptionSandbox();
            }

            public void NullAnchorList_Throws()
            {
                CheckThrow(typeof(ArgumentNullException));
                new ExceptionSandbox((Assembly[])null);
            }

            public void NullAnchor_Throws()
            {
                CheckThrow(typeof(ArgumentException));
                new ExceptionSandbox(AmphoraAssembly, null);
            }
        }

        public class AdvanceTests : TestFixture
        {
            private ExceptionSandbox sandbox;
            private List<ExceptionEntry> announced;

            public override void TestSetup()
            {
                sandbox = NewSandbox();
                announced = new List<ExceptionEntry>();
                sandbox.EntryAdded += entry => announced.Add(entry);
            }

            public void Always_CountsOneFrame()
            {
                sandbox.Advance(TimeSpan.FromMilliseconds(16));
                sandbox.Advance(TimeSpan.FromMilliseconds(16));

                CheckEqual(2L, sandbox.Frame);
            }

            public void Always_AccumulatesTheElapsedTime()
            {
                sandbox.Advance(TimeSpan.FromMilliseconds(16));
                sandbox.Advance(TimeSpan.FromMilliseconds(4));

                CheckEqual(Duration.FromMilliseconds(20), sandbox.Now);
            }

            public void InfiniteElapsed_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                sandbox.Advance(Duration.Forever);
            }

            public void NegativeInfiniteElapsed_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                sandbox.Advance(-Duration.Forever);
            }

            public void InfiniteElapsed_LeavesTheClockAlone()
            {
                try
                {
                    sandbox.Advance(Duration.Forever);
                }
                catch (ArgumentOutOfRangeException)
                {
                }

                CheckEqual(0L, sandbox.Frame);
                CheckEqual(Duration.Zero, sandbox.Now);
            }

            public void ElapsedTimePastTheLargestFiniteDuration_ClampsTheClock()
            {
                sandbox.Advance(Duration.MaxValue);
                sandbox.Advance(Duration.FromMilliseconds(16));

                CheckEqual(Duration.MaxValue, sandbox.Now);
            }

            public void ZeroElapsed_StillCountsAFrame()
            {
                sandbox.Advance(TimeSpan.Zero);

                CheckEqual(1L, sandbox.Frame);
                CheckEqual(Duration.Zero, sandbox.Now);
            }

            public void NewEntry_IsAnnouncedOnlyOnceAdvanced()
            {
                ExceptionEntry entry = Hit<InvalidOperationException>(sandbox, SiteA);
                CheckEqual(0, announced.Count);

                sandbox.Advance(TimeSpan.Zero);

                CheckEqual(1, announced.Count);
                CheckEqual(entry, announced[0]);
            }

            public void EntryHitAgain_IsNotAnnouncedAgain()
            {
                Hit<InvalidOperationException>(sandbox, SiteA);
                sandbox.Advance(TimeSpan.Zero);

                Hit<InvalidOperationException>(sandbox, SiteA);
                sandbox.Advance(TimeSpan.Zero);

                CheckEqual(1, announced.Count);
            }

            public void EntryAddedWithNoSubscriber_IsNotAnnouncedToALaterOne()
            {
                ExceptionSandbox unsubscribed = NewSandbox();
                Hit<InvalidOperationException>(unsubscribed, SiteA);
                unsubscribed.Advance(TimeSpan.Zero);

                unsubscribed.EntryAdded += entry => announced.Add(entry);
                unsubscribed.Advance(TimeSpan.Zero);

                CheckEqual(0, announced.Count);
            }

            public void SeveralNewEntries_AreAnnouncedInTheOrderTheyWereAdded()
            {
                ExceptionEntry first = Hit<InvalidOperationException>(sandbox, SiteA);
                ExceptionEntry second = Hit<ArgumentException>(sandbox, SiteA);

                sandbox.Advance(TimeSpan.Zero);

                CheckEqual(2, announced.Count);
                CheckEqual(first, announced[0]);
                CheckEqual(second, announced[1]);
            }
        }

        public class SnoozeTests : TestFixture
        {
            public void Always_SnoozesUntilNowPlusTheDuration()
            {
                ExceptionSandbox sandbox = NewSandbox();
                sandbox.Advance(TimeSpan.FromMilliseconds(16));
                var entry = new ExceptionEntry(new InvalidOperationException(), sandbox.Frame, sandbox.Now);

                sandbox.Snooze(entry, TimeSpan.FromMilliseconds(10));

                CheckEqual(Duration.FromMilliseconds(26), entry.SnoozedUntil);
            }

            public void Forever_SnoozesUntilForever()
            {
                ExceptionSandbox sandbox = NewSandbox();
                sandbox.Advance(TimeSpan.FromMilliseconds(16));
                var entry = new ExceptionEntry(new InvalidOperationException(), sandbox.Frame, sandbox.Now);

                sandbox.Snooze(entry, Duration.Forever);

                CheckEqual(Duration.Forever, entry.SnoozedUntil);
            }

            public void ADurationPastTheLargestFiniteTime_ClampsInsteadOfWrapping()
            {
                ExceptionSandbox sandbox = NewSandbox();
                sandbox.Advance(TimeSpan.FromMilliseconds(16));
                var entry = new ExceptionEntry(new InvalidOperationException(), sandbox.Frame, sandbox.Now);

                sandbox.Snooze(entry, Duration.MaxValue);

                CheckEqual(Duration.MaxValue, entry.SnoozedUntil);
            }
        }

        public class ClaimsTests : TestFixture
        {
            private ExceptionSandbox sandbox;

            public override void TestSetup()
            {
                sandbox = NewSandbox();
            }

            public void ExceptionFromClientCode_IsClaimed()
            {
                CheckTrue(Run(sandbox, SiteA, () => throw new InvalidOperationException()));
                CheckEqual(1, sandbox.Entries.Count);
            }

            public void ExceptionFromAnAnchorAlone_Propagates()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Run<int>(sandbox, SiteA, new DynamicArray<int>().RemoveAt, 5);
            }

            public void ExceptionFromALibraryBeneathTheAnchorsAlone_Propagates()
            {
                var list = new List<int>();
                IEnumerator enumerator = list.GetEnumerator();
                list.Add(1);

                CheckThrow(typeof(InvalidOperationException));
                Run(sandbox, SiteA, enumerator.Reset);
            }

            public void AnchorExceptionReachedThroughClientCode_IsClaimed()
            {
                CheckTrue(Run(sandbox, SiteA, () =>
                {
                    new DynamicArray<int>().RemoveAt(5);
                    KeepsTheCallerOnTheStack();
                }));
            }

            public void ClientExceptionReachedThroughAnAnchor_IsClaimed()
            {
                OrderedDictionary<int, int> dictionary = DictionaryWhoseComparerThrows();

                CheckTrue(RunFunc(sandbox, SiteA, dictionary.ContainsKey, 1));
            }

            public void OutOfMemory_Propagates()
            {
                CheckThrow(typeof(OutOfMemoryException));
                Run(sandbox, SiteA, () => throw new OutOfMemoryException());
            }

            public void ClientExceptionReachedThroughALibraryBeneathTheAnchors_IsClaimed()
            {
                CheckTrue(Run<Action<int>>(sandbox, SiteA, new List<int> { 1 }.ForEach,
                    _ => throw new InvalidOperationException()));
            }

            public void DynamicCodeCalledFromClientCode_IsClaimed()
            {
                Action compiled = Expression.Lambda<Action>(
                    Expression.Throw(Expression.New(typeof(InvalidOperationException)))).Compile();

                CheckTrue(Run(sandbox, SiteA, () =>
                {
                    compiled();
                    KeepsTheCallerOnTheStack();
                }));
            }

            public void SameDynamicThrowTwice_MakesOneEntry()
            {
                Action compiled = Expression.Lambda<Action>(
                    Expression.Throw(Expression.New(typeof(InvalidOperationException)))).Compile();
                Action callCompiled = () =>
                {
                    compiled();
                    KeepsTheCallerOnTheStack();
                };

                Run(sandbox, SiteA, callCompiled);
                Run(sandbox, SiteA, callCompiled);

                CheckEqual(1, sandbox.Entries.Count);
            }

            public void DifferentThrowSites_MakeSeparateEntries()
            {
                Run(sandbox, SiteA, () => throw new InvalidOperationException());
                Run(sandbox, SiteA, () => throw new InvalidOperationException());

                CheckEqual(2, sandbox.Entries.Count);
            }

            public void SameThrowSiteWithDifferentMessages_MakesOneEntry()
            {
                Run(sandbox, SiteA, Rethrow, new InvalidOperationException("one"));
                Run(sandbox, SiteA, Rethrow, new InvalidOperationException("two"));

                CheckEqual(1, sandbox.Entries.Count);
                CheckEqual(2, sandbox.Entries[0].Count);
            }

            public void SameThrowSiteWithDifferentExceptionTypes_MakesSeparateEntries()
            {
                Run(sandbox, SiteA, Rethrow, new InvalidOperationException());
                Run(sandbox, SiteA, Rethrow, new ArgumentException());

                CheckEqual(2, sandbox.Entries.Count);
            }

            public void SameClientThrowReachedThroughDifferentAnchorCallers_MakesOneEntry()
            {
                OrderedDictionary<int, int> dictionary = DictionaryWhoseComparerThrows();

                RunFunc(sandbox, SiteA, dictionary.ContainsKey, 1);
                RunFunc(sandbox, SiteB, dictionary.Remove, 1);

                CheckEqual(1, sandbox.Entries.Count);
                CheckEqual(2, sandbox.Entries[0].Count);
            }

            public void SameThrowSiteReachedFromDifferentClientCode_MakesSeparateEntries()
            {
                Run(sandbox, SiteA, () =>
                {
                    ThrowFromClientHelper();
                    KeepsTheCallerOnTheStack();
                });
                Run(sandbox, SiteA, () =>
                {
                    ThrowFromClientHelper();
                    KeepsTheCallerOnTheStack();
                });

                CheckEqual(2, sandbox.Entries.Count);
            }

            public void RepeatHit_KeepsTheFirstException()
            {
                var first = new InvalidOperationException("first");

                Run(sandbox, SiteA, Rethrow, first);
                Run(sandbox, SiteA, Rethrow, new InvalidOperationException("second"));

                CheckEqual(first, sandbox.Entries[0].Exception);
            }

            public void SecondSiteHittingTheSameBug_JoinsItsEntry()
            {
                Hit<InvalidOperationException>(sandbox, SiteA);
                Hit<InvalidOperationException>(sandbox, SiteB);

                CheckEqual(1, sandbox.Entries.Count);
                CheckEqualCommutative(new[] { SiteA, SiteB }, sandbox.Entries[0].Sites);
            }

            public void Always_RecordsTheNotesAtTheSite()
            {
                Run(sandbox, SiteA, Rethrow, new InvalidOperationException(), Notes("path", "screen > okButton"));

                CheckEqual("screen > okButton", sandbox.Entries[0].NotesOf(SiteA).Single()["path"]);
            }

            public void NoNotes_RecordsOneEmptySet()
            {
                Run(sandbox, SiteA, Rethrow, new InvalidOperationException());

                CheckEqual(0, sandbox.Entries[0].NotesOf(SiteA).Single().Count);
            }

            public void MultipleAnchors_AClientOfAnyOneIsClient()
            {
                Assembly unrelated = Assembly.Load(
                    "System.Xml, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
                var sandbox = new ExceptionSandbox(AmphoraAssembly, unrelated);

                CheckTrue(Run(sandbox, SiteA, () => throw new InvalidOperationException()));
            }

            public void AnchorStackAtATargetWithAClientSubscriber_IsClaimedWhenFramesCanDrop()
            {
                var target = new Lazy<int>(ClientFactory);

                CheckTrue(Run<int>(NewDroppingSandbox(), SiteAt(target), new DynamicArray<int>().RemoveAt, 5));
            }

            public void AnchorStackAtATargetWithAClientSubscriber_PropagatesWhenFramesCannotDrop()
            {
                var target = new Lazy<int>(ClientFactory);

                CheckThrow(typeof(ArgumentOutOfRangeException));
                Run<int>(NewKeepingSandbox(), SiteAt(target), new DynamicArray<int>().RemoveAt, 5);
            }

            public void AnchorStackAtAClientSubclass_IsClaimedWhenFramesCanDrop()
            {
                CheckTrue(Run<int>(NewDroppingSandbox(), SiteAt(new ClientTarget()), new DynamicArray<int>().RemoveAt,
                    5));
            }

            public void AnchorStackAtAClientSubscriberToABaseClassDelegate_IsClaimedWhenFramesCanDrop()
            {
                var target = new Task<int>(ClientFactory);

                CheckTrue(Run<int>(NewDroppingSandbox(), SiteAt(target), new DynamicArray<int>().RemoveAt, 5));
            }

            public void AnchorStackAtATargetWithLibraryAndClientSubscribers_IsClaimedWhenFramesCanDrop()
            {
                var combined = (Func<int>)Delegate.Combine(new Func<int>("text".GetHashCode),
                    new Func<int>(ClientFactory));
                var target = new Lazy<int>(combined);

                CheckTrue(Run<int>(NewDroppingSandbox(), SiteAt(target), new DynamicArray<int>().RemoveAt, 5));
            }

            public void AnchorStackAtATargetWithOnlyLibrarySubscribers_Propagates()
            {
                var target = new Lazy<int>("text".GetHashCode);

                CheckThrow(typeof(ArgumentOutOfRangeException));
                Run<int>(NewDroppingSandbox(), SiteAt(target), new DynamicArray<int>().RemoveAt, 5);
            }

            public void AnchorStackAtATargetWithNoSubscribers_Propagates()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Run<int>(NewDroppingSandbox(), SiteAt(new object()), new DynamicArray<int>().RemoveAt, 5);
            }

            public void AnchorStackWithNoTarget_Propagates()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Run<int>(NewDroppingSandbox(), SiteAt(null), new DynamicArray<int>().RemoveAt, 5);
            }

            public void SameAnchorStackAtTwoTargetsWithClientCode_MakesOneEntry()
            {
                ExceptionSandbox dropping = NewDroppingSandbox();

                Run<int>(dropping, SiteAt(new ClientTarget()), new DynamicArray<int>().RemoveAt, 5);
                Run<int>(dropping, SiteAt(new ClientTarget()), new DynamicArray<int>().RemoveAt, 5);

                CheckEqual(1, dropping.Entries.Count);
                CheckEqual(2, dropping.Entries[0].Count);
            }

            public void DifferentAnchorCallersOfOneThrowAtATargetWithClientCode_MakeSeparateEntries()
            {
                ExceptionSandbox dropping = NewDroppingSandbox();
                var target = new ClientTarget();

                Run<int>(dropping, SiteAt(target), new DynamicArray<int>().RemoveAt, 5);
                Run<int, int>(dropping, SiteAt(target), new DynamicArray<int>().Insert, 5, 0);

                CheckEqual(2, dropping.Entries.Count);
            }
        }

        public class QuarantineTests : TestFixture
        {
            private ExceptionSandbox sandbox;
            private List<(ExceptionSite site, ExceptionEntry entry)> announced;

            public override void TestSetup()
            {
                sandbox = NewSandbox();
                announced = new List<(ExceptionSite site, ExceptionEntry entry)>();
                sandbox.SiteQuarantined += (site, entry) => announced.Add((site, entry));
            }

            [IgnoreTest]
            private bool Fault(ExceptionSite site, bool quarantine = true)
            {
                try
                {
                    Rethrow(new InvalidOperationException());
                }
                catch (Exception exception) when (sandbox.Claims(exception, site, notes: null, quarantine))
                {
                    return true;
                }

                return false;
            }

            public void NothingFaulted_HasNoQuarantinedSites()
            {
                CheckEqual(0, sandbox.QuarantinedSites.Count);
                CheckFalse(sandbox.IsQuarantined(SiteA));
            }

            public void ClaimWithQuarantine_QuarantinesAndSkipsTheSite()
            {
                Fault(SiteA);

                CheckTrue(sandbox.IsQuarantined(SiteA));
                CheckTrue(sandbox.IsSkipped(SiteA));
                CheckEqual(new[] { SiteA }, sandbox.QuarantinedSites.ToArray());
            }

            public void ClaimWithoutQuarantine_LeavesTheSiteRunning()
            {
                Fault(SiteA, quarantine: false);

                CheckFalse(sandbox.IsQuarantined(SiteA));
                CheckFalse(sandbox.IsSkipped(SiteA));
            }

            public void ClaimWithQuarantine_LeavesOtherSitesRunning()
            {
                Fault(SiteA);

                CheckFalse(sandbox.IsSkipped(SiteB));
                CheckFalse(sandbox.IsSkipped(new ExceptionSite(SiteA.Target, phase: 1)));
            }

            public void ExceptionThatPropagates_QuarantinesNothing()
            {
                bool propagated = false;
                try
                {
                    try
                    {
                        new DynamicArray<int>().RemoveAt(5);
                    }
                    catch (ArgumentOutOfRangeException exception) when (
                        sandbox.Claims(exception, SiteA, notes: null, quarantine: true))
                    {
                    }
                }
                catch (ArgumentOutOfRangeException)
                {
                    propagated = true;
                }

                CheckTrue(propagated);
                CheckFalse(sandbox.IsQuarantined(SiteA));
            }

            public void Release_LetsTheSiteRunAndReportsItWasQuarantined()
            {
                Fault(SiteA);

                CheckTrue(sandbox.Release(SiteA));
                CheckFalse(sandbox.IsQuarantined(SiteA));
                CheckFalse(sandbox.IsSkipped(SiteA));
            }

            public void ReleaseOfASiteThatIsNotQuarantined_ReportsNothingToDo()
            {
                CheckFalse(sandbox.Release(SiteA));
            }

            public void ReleasedSiteThatFaultsAgain_IsQuarantinedAgain()
            {
                Fault(SiteA);
                sandbox.Release(SiteA);

                Fault(SiteA);

                CheckTrue(sandbox.IsSkipped(SiteA));
            }

            public void IgnoringOrSnoozingTheEntry_DoesNotReleaseTheSite()
            {
                Fault(SiteA);
                ExceptionEntry entry = sandbox.Entries[0];

                entry.Ignored = true;
                entry.Ignored = false;
                sandbox.Snooze(entry, TimeSpan.FromMilliseconds(10));
                sandbox.Advance(TimeSpan.FromMilliseconds(20));

                CheckTrue(sandbox.IsQuarantined(SiteA));
                CheckTrue(sandbox.IsSkipped(SiteA));
            }

            public void SiteWithAnActiveEntry_IsStillSkippedWhileQuarantined()
            {
                Hit<ArgumentException>(sandbox, SiteA);
                Fault(SiteA);

                CheckTrue(sandbox.IsSkipped(SiteA));
            }

            public void Announcement_WaitsForTheNextAdvance()
            {
                Fault(SiteA);
                CheckEqual(0, announced.Count);

                sandbox.Advance(TimeSpan.Zero);

                CheckEqual(1, announced.Count);
                CheckEqual(SiteA, announced[0].site);
                CheckEqual(sandbox.Entries[0], announced[0].entry);
            }

            public void Announcement_IsOnceNoMatterHowOftenTheSiteFaults()
            {
                Fault(SiteA);
                Fault(SiteA);
                sandbox.Advance(TimeSpan.Zero);
                sandbox.Advance(TimeSpan.Zero);

                CheckEqual(1, announced.Count);
            }

            public void SeveralSites_AreAnnouncedInTheOrderTheyFaulted()
            {
                Fault(SiteB);
                Fault(SiteA);

                sandbox.Advance(TimeSpan.Zero);

                CheckEqual(new[] { SiteB, SiteA }, announced.Select(pair => pair.site).ToArray());
            }

            public void ReleasedSiteThatFaultsAgain_IsAnnouncedAgain()
            {
                Fault(SiteA);
                sandbox.Advance(TimeSpan.Zero);
                sandbox.Release(SiteA);
                Fault(SiteA);

                sandbox.Advance(TimeSpan.Zero);

                CheckEqual(2, announced.Count);
            }

            public void ClaimWithoutQuarantine_IsNotAnnounced()
            {
                Fault(SiteA, quarantine: false);
                sandbox.Advance(TimeSpan.Zero);

                CheckEqual(0, announced.Count);
            }

            public void NoSubscriber_AdvanceStillClearsTheAnnouncement()
            {
                ExceptionSandbox quiet = NewSandbox();
                try
                {
                    Rethrow(new InvalidOperationException());
                }
                catch (Exception exception) when (quiet.Claims(exception, SiteA, notes: null, quarantine: true))
                {
                }

                quiet.Advance(TimeSpan.Zero);
                quiet.SiteQuarantined += (site, entry) => announced.Add((site, entry));
                quiet.Advance(TimeSpan.Zero);

                CheckEqual(0, announced.Count);
            }
        }

        public class IsSkippedTests : TestFixture
        {
            private ExceptionSandbox sandbox;

            public override void TestSetup()
            {
                sandbox = NewSandbox();
            }

            public void NothingEverThrown_IsNotSkipped()
            {
                CheckFalse(sandbox.IsSkipped(SiteA));
            }

            public void SiteOfAnActiveEntry_IsNotSkipped()
            {
                Hit<InvalidOperationException>(sandbox, SiteA);
                CheckFalse(sandbox.IsSkipped(SiteA));
            }

            public void SiteOfAnIgnoredEntry_IsSkipped()
            {
                Hit<InvalidOperationException>(sandbox, SiteA).Ignored = true;
                CheckTrue(sandbox.IsSkipped(SiteA));
            }

            public void SiteOfASnoozedEntry_IsSkipped()
            {
                sandbox.Snooze(Hit<InvalidOperationException>(sandbox, SiteA), TimeSpan.FromMilliseconds(10));
                sandbox.Advance(TimeSpan.FromMilliseconds(9));

                CheckTrue(sandbox.IsSkipped(SiteA));
            }

            public void SiteOfAnEntrySnoozedForever_StaysSkipped()
            {
                sandbox.Snooze(Hit<InvalidOperationException>(sandbox, SiteA), Duration.Forever);
                sandbox.Advance(Duration.MaxValue);

                CheckTrue(sandbox.IsSkipped(SiteA));
            }

            public void SiteOfAnExpiredSnooze_IsNotSkipped()
            {
                sandbox.Snooze(Hit<InvalidOperationException>(sandbox, SiteA), TimeSpan.FromMilliseconds(10));
                sandbox.Advance(TimeSpan.FromMilliseconds(10));

                CheckFalse(sandbox.IsSkipped(SiteA));
            }

            public void SameTargetInAnotherPhase_IsNotSkipped()
            {
                Hit<InvalidOperationException>(sandbox, SiteA).Ignored = true;
                CheckFalse(sandbox.IsSkipped(new ExceptionSite(SiteA.Target, phase: 1)));
            }

            public void SiteThatNeverThrew_IsNotSkippedWhileAnotherIs()
            {
                Hit<InvalidOperationException>(sandbox, SiteA).Ignored = true;
                CheckFalse(sandbox.IsSkipped(SiteB));
            }

            public void SiteOfAnActiveEntry_IsNotSkippedWhileAnotherEntryIs()
            {
                Hit<InvalidOperationException>(sandbox, SiteA).Ignored = true;
                Hit<ArgumentException>(sandbox, SiteB);

                CheckFalse(sandbox.IsSkipped(SiteB));
            }

            public void SiteWithAnIgnoredAndAnActiveEntry_IsNotSkipped()
            {
                Hit<InvalidOperationException>(sandbox, SiteA).Ignored = true;
                Hit<ArgumentException>(sandbox, SiteA);

                CheckFalse(sandbox.IsSkipped(SiteA));
            }

            public void SiteWithEveryEntryIgnoredOrSnoozed_IsSkipped()
            {
                Hit<InvalidOperationException>(sandbox, SiteA).Ignored = true;
                sandbox.Snooze(Hit<ArgumentException>(sandbox, SiteA), TimeSpan.FromSeconds(1));

                CheckTrue(sandbox.IsSkipped(SiteA));
            }
        }
    }
}