using DominionBase;
using DominionBase.Cards;
using DominionBase.Cards.Nocturne;
using DominionBase.Enums;
using DominionBase.Piles;
using DominionBase.Players;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;
using System;
using System.Collections.Generic;
using System.Linq;

namespace DominionBaseUnitTest.Cards
{
	[TestClass]
	public class UnitTestNocturne : UnitTestCards
	{
		private void Initialize_ReceiveBoon(Card card)
		{
			mockPlayer.SetupGet(_ => _.Hand).Returns(new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner));
			mockPlayer.SetupGet(_ => _.Private).Returns(new Deck(DeckLocation.Private, Visibility.All, VisibilityTo.Owner));
			mockPlayer.SetupGet(_ => _.DiscardPile).Returns(new Deck(DeckLocation.Discard, Visibility.Top, VisibilityTo.All));

			var fakeResultCards = new ChoiceResult(new ItemCollection<Card>());
			var fakeResultOptions = new ChoiceResult(new List<string> { ResourcesHelper.Get("No") });
			mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(x =>
					x.ChoiceType == ChoiceType.Cards
					&& (x.Source.Type == TypeClass.TheEarthsGift || x.Source.Type == TypeClass.TheFlamesGift || x.Source.Type == TypeClass.TheMoonsGift || x.Source.Type == TypeClass.TheSunsGift)
				))).Returns(fakeResultCards);
			//mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(x => x.ChoiceType == ChoiceType.Cards))).Returns(fakeResultCards);
			mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(x => x.ChoiceType == ChoiceType.Options))).Returns(fakeResultOptions);
			mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(x => x.ChoiceType == ChoiceType.Supplies))).Returns(new ChoiceResult(mockSupply.Object));

			var specialPiles = new TableEntityCollection();
			mockTable.SetupGet(_ => _.SpecialPiles).Returns(specialPiles);
			mockTable.SetupGet(_ => _.TableEntities).Returns(new TableEntityCollection());

			var turn = new Turn(mockPlayer.Object);
			mockGame.SetupGet(_ => _.CurrentTurn).Returns(turn);

			card.SetupSupply(mockGame.Object, mockSupply.Object);
		}

		private void Initialize_ReceiveHex(Card card)
		{
			mockPlayer.SetupGet(_ => _.Hand).Returns(new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner));
			mockPlayer.SetupGet(_ => _.Private).Returns(new Deck(DeckLocation.Private, Visibility.All, VisibilityTo.Owner));
			mockPlayer.SetupGet(_ => _.DiscardPile).Returns(new Deck(DeckLocation.Discard, Visibility.Top, VisibilityTo.All));
			mockPlayer.SetupGet(_ => _.Revealed).Returns(new Deck(DeckLocation.Revealed, Visibility.All, VisibilityTo.All));
			mockPlayer.SetupGet(_ => _.Takeables).Returns(new ItemCollection<ITakeable>());
			var fakeResultCards = new ChoiceResult(new ItemCollection<Card>());
			mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(x => x.ChoiceType == ChoiceType.Cards))).Returns(fakeResultCards);
			var players = new PlayerCollection(mockGame.Object)
			{
				mockPlayer.Object,
				mockPlayer.Object
			};
			mockGame.SetupGet(_ => _.Players).Returns(players);
			var specialPiles = new TableEntityCollection();
			mockTable.SetupGet(_ => _.SpecialPiles).Returns(specialPiles);

			card.SetupSupply(mockGame.Object, mockSupply.Object);
		}

		[TestMethod]
		public void Test_BadOmens_Basic()
		{
			using (var card = new BadOmens())
			{
				Assert.AreEqual(Categories.Hex, card.Category);
			}
		}
		[TestMethod]
		public void Test_BadOmens_Receive_MultipleCoppers()
		{
			using (Hex card = new BadOmens())
			{

				var discard = new Deck(DeckLocation.Discard, Visibility.Top, VisibilityTo.All);
				discard.AddRange(mockPlayer.Object, new List<Card> { new Bard(), new DominionBase.Cards.Universal.Copper(), new DominionBase.Cards.Universal.Copper(), new DominionBase.Cards.Universal.Copper() });
				mockPlayer.SetupGet(_ => _.DiscardPile).Returns(discard);



				card.Receive(mockPlayer.Object);


				// Putting Deck into Discard Pile
				mockPlayer.Verify(_ => _.RetrieveCardsFrom(DeckLocation.Deck), Times.Once);
				mockPlayer.Verify(_ => _.AddCardsInto(DeckLocation.Discard, It.IsAny<IEnumerable<Card>>(), It.IsAny<DeckPosition>()), Times.Once);
				// Message indicating cards in discard pile
				mockGame.Verify(_ => _.SendMessage(mockPlayer.Object, card, "Discard"), Times.Once);
				// Adding cards back to deck
				mockPlayer.Verify(_ => _.RetrieveCardsFrom(DeckLocation.Discard, DominionBase.Cards.Universal.TypeClass.Copper, 2), Times.Once);
				mockPlayer.Verify(_ => _.AddCardsInto(DeckLocation.Revealed, It.IsAny<IEnumerable<Card>>(), It.IsAny<DeckPosition>()), Times.Once);
				mockPlayer.Verify(_ => _.RetrieveCardsFrom(DeckLocation.Revealed), Times.Once);
				mockPlayer.Verify(_ => _.AddCardsToDeck(It.IsAny<IEnumerable<Card>>(), DeckPosition.Top), Times.Once);
				mockGame.Verify(_ => _.SendMessage(mockPlayer.Object, card, "Reveal", It.IsAny<IDisplayable[]>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_BadOmens_Receive_OneCopper()
		{
			using (Hex card = new BadOmens())
			{

				var discard = new Deck(DeckLocation.Discard, Visibility.Top, VisibilityTo.All);
				discard.AddRange(mockPlayer.Object, new List<Card> { new Bard(), new DominionBase.Cards.Universal.Copper() });
				mockPlayer.SetupGet(_ => _.DiscardPile).Returns(discard);



				card.Receive(mockPlayer.Object);


				// Putting Deck into Discard Pile
				mockPlayer.Verify(_ => _.RetrieveCardsFrom(DeckLocation.Deck), Times.Once);
				mockPlayer.Verify(_ => _.AddCardsInto(DeckLocation.Discard, It.IsAny<IEnumerable<Card>>(), It.IsAny<DeckPosition>()), Times.Once);
				// Message indicating cards in discard pile
				mockGame.Verify(_ => _.SendMessage(mockPlayer.Object, card, "Discard"), Times.Once);
				// Adding cards back to deck
				mockPlayer.Verify(_ => _.RetrieveCardsFrom(DeckLocation.Discard, DominionBase.Cards.Universal.TypeClass.Copper, 1), Times.Once);
				mockPlayer.Verify(_ => _.AddCardsInto(DeckLocation.Revealed, It.IsAny<IEnumerable<Card>>(), It.IsAny<DeckPosition>()), Times.Once);
				mockPlayer.Verify(_ => _.RetrieveCardsFrom(DeckLocation.Revealed), Times.Once);
				mockPlayer.Verify(_ => _.AddCardsToDeck(It.IsAny<IEnumerable<Card>>(), DeckPosition.Top), Times.Once);
				mockGame.Verify(_ => _.SendMessage(mockPlayer.Object, card, "Reveal", It.IsAny<IDisplayable[]>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Bard_Basic()
		{
			using (var card = new Bard())
			{
				Assert.AreEqual(new Cost(4), card.BaseCost);
				Assert.AreEqual(new Currency(2), card.Benefit.Currency);
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Fate, card.Category);
			}
		}
		[TestMethod]
		public void Test_Bard_Play()
		{
			using (Card card = new Bard())
			{

				Initialize_ReceiveBoon(card);

				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.ReceiveBenefit(It.IsAny<Boon>(), It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.AtLeastOnce);
			}
		}
		[TestMethod]
		public void Test_Bat_Basic()
		{
			using (var card = new Bat())
			{
				Assert.AreEqual(new Cost(2, special: true), card.BaseCost);
				Assert.AreEqual(Categories.Card | Categories.Night, card.Category);
			}
		}
		[TestMethod]
		public void Test_Bat_Play()
		{
			using (Card card = new Bat())
			{

				mockPlayer.SetupGet(_ => _.Hand).Returns(new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner));
				var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
				mockPlayer.SetupGet(_ => _.InPlayAndSetAside).Returns(new DeckCollection(inPlay));
				mockPlayer.Setup(_ => _.RetrieveCardFrom(It.IsAny<DeckLocation>(), card)).Returns(card);
				var copper = new DominionBase.Cards.Universal.Copper();
				var fakeResultCards = new ChoiceResult(new ItemCollection<Card>(copper));
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(x => x.ChoiceType == ChoiceType.Cards))).Returns(fakeResultCards);
				mockTable.Setup(_ => _.FindSupplyPileByType(TypeClass.Bat, It.IsAny<bool>())).Returns(mockSupply.Object);
				mockTable.Setup(_ => _.FindSupplyPileByType(TypeClass.Vampire, It.IsAny<bool>())).Returns(mockSupply.Object);
				Card vampire = new Vampire();
				mockSupply.Setup(_ => _.Take(TypeClass.Vampire)).Returns(vampire);

				inPlay.Add(card);
				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Once);
				mockPlayer.Verify(_ => _.RetrieveCardsFrom(It.IsAny<DeckLocation>(), It.IsAny<ItemCollection<Card>>()), Times.Once);
				mockPlayer.Verify(_ => _.Trash(card, It.IsAny<ItemCollection<Card>>()), Times.Once);
				mockPlayer.Verify(_ => _.Lose(It.IsAny<Card>()), Times.Once);
				mockSupply.Verify(_ => _.Take(TypeClass.Vampire), Times.Once);
				mockPlayer.Verify(_ => _.AddCardInto(DeckLocation.Discard, It.IsAny<Card>(), It.IsAny<DeckPosition>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_BlessedVillage_Basic()
		{
			using (var card = new BlessedVillage())
			{
				Assert.AreEqual(new Cost(4), card.BaseCost);
				Assert.AreEqual(1, card.Benefit.Cards);
				Assert.AreEqual(2, card.Benefit.Actions);
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Fate, card.Category);
			}
		}
		[TestMethod]
		public void Test_BlessedVillage_Setup()
		{
			using (Card card = new BlessedVillage())
			{
				// SpecialPiles should maybe be mocked as well??
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

				card.SetupSupply(mockGame.Object, mockSupply.Object);

				Assert.IsTrue(specialPiles.ContainsKey(TypeClass.Boons));
			}
		}
		[TestMethod]
		public void Test_BlessedVillage_Gain_Receive_Now()
		{
			using (Card card = new BlessedVillage())
			{
				Initialize_ReceiveBoon(card);
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				var spec = new TableEntityCollection();
				var mockBoonSupply = new Mock<IBoonSupply>();
				var mockBoon = new Mock<IBoon>();
				mockBoonSupply.Setup(_ => _.TakeBoon(mockPlayer.Object)).Returns(mockBoon.Object);
				spec.Add(TypeClass.Boons, mockBoonSupply.Object);
				mockTable.SetupGet(_ => _.SpecialPiles).Returns(spec);
				mockPlayer.Setup(_ => _.TakeBoon(mockBoonSupply.Object)).Returns(mockBoon.Object);
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options))).Returns(new ChoiceResult(new List<string> { "Now" }));


				card.SetupCard(mockGame.Object);
				card.SetupSupply(mockGame.Object, mockSupply.Object);


				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, card, new DominionBase.Cards.Base.Remodel(), DeckLocation.Discard, DeckPosition.Automatic, false);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsTrue(cgeArgs.Resolvers.ContainsKey(TypeClass.BlessedVillage.ToString()));

				cgeArgs.Resolvers[TypeClass.BlessedVillage.ToString()].Method(mockPlayer.Object, ref cgeArgs);


				mockBoon.Verify(_ => _.Receive(mockPlayer.Object), Times.Once);
				// Verify that no on-turn-started trigger is handled
				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.IsFalse(tseArgs.Resolvers.ContainsKey(card.Name));
			}
		}
		[TestMethod]
		public void Test_BlessedVillage_Gain_Receive_Next_Turn()
		{
			using (Card card = new BlessedVillage())
			{
				Initialize_ReceiveBoon(card);
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				var spec = new TableEntityCollection();
				var mockBoonSupply = new Mock<IBoonSupply>();
				var mockBoon = new Mock<IBoon>();
				spec.Add(TypeClass.Boons, mockBoonSupply.Object);
				mockTable.SetupGet(_ => _.SpecialPiles).Returns(spec);
				mockPlayer.Setup(_ => _.TakeBoon(mockBoonSupply.Object)).Returns(mockBoon.Object);
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options))).Returns(new ChoiceResult(new List<string> { "Next Turn" }));


				card.SetupCard(mockGame.Object);
				card.SetupSupply(mockGame.Object, mockSupply.Object);


				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, card, new DominionBase.Cards.Base.Remodel(), DeckLocation.Discard, DeckPosition.Automatic, false);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsTrue(cgeArgs.Resolvers.ContainsKey(TypeClass.BlessedVillage.ToString()));

				cgeArgs.Resolvers[TypeClass.BlessedVillage.ToString()].Method(mockPlayer.Object, ref cgeArgs);


				mockBoon.Verify(_ => _.Receive(mockPlayer.Object), Times.Never);

				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.IsTrue(tseArgs.Resolvers.ContainsKey(card.Name));

				tseArgs.Resolvers[card.Name].Method(mockPlayer.Object, ref tseArgs);


				mockBoon.Verify(_ => _.Receive(mockPlayer.Object), Times.Once);
				// Verify that on-turn-started trigger is removed
				tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.IsFalse(tseArgs.Resolvers.ContainsKey(card.Name));
			}
		}
		[TestMethod]
		public void Test_BlessedVillage_Teardown()
		{
			using (Card card = new BlessedVillage())
			{

				Initialize_ReceiveBoon(card);
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				var spec = new TableEntityCollection();
				var mockBoonSupply = new Mock<IBoonSupply>();
				var mockBoon = new Mock<IBoon>();
				mockBoonSupply.Setup(_ => _.TakeBoon(mockPlayer.Object)).Returns(mockBoon.Object);
				spec.Add(TypeClass.Boons, mockBoonSupply.Object);
				mockTable.SetupGet(_ => _.SpecialPiles).Returns(spec);
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options))).Returns(new ChoiceResult(new List<string> { "Next Turn" }));


				card.SetupCard(mockGame.Object);
				card.SetupSupply(mockGame.Object, mockSupply.Object);

				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, card, new DominionBase.Cards.Base.Remodel(), DeckLocation.Discard, DeckPosition.Automatic, false);

				// Teardown at the end (Make sure event listener isn't listening any more)
				card.TearDown(mockGame.Object);

				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsFalse(cgeArgs.Resolvers.ContainsKey(TypeClass.BlessedVillage.ToString()));
			}
		}
		[TestMethod]
		public void Test_Boons_Setup()
		{
			using (var supply = new Boons(mockGame.Object))
			{
				mockTable.Setup(_ => _.SpecialPiles).Returns(new TableEntityCollection());

				supply.Setup();

				Assert.AreEqual(Categories.Boon, supply.Category);
				Assert.AreEqual(12, supply.Count);
			}
		}
		[TestMethod]
		public void Test_Cemetery_Basic()
		{
			using (var card = new Cemetery())
			{
				Assert.AreEqual(new Cost(4), card.BaseCost);
				Assert.AreEqual(2, card.VictoryPoints);
				Assert.AreEqual(Categories.Card | Categories.Victory, card.Category);
			}
		}
		[TestMethod]
		public void Test_Cemetery_Setup()
		{
			using (Card card = new Cemetery())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);
				mockTable.SetupGet(_ => _.Copper).Returns(mockSupply.Object);

				card.SetupSupply(mockGame.Object, mockSupply.Object);

				mockSupply.Verify(_ => _.AddTo(It.IsAny<HauntedMirror>(), 0), Times.AtLeastOnce);
			}
		}
		[TestMethod]
		public void Test_Cemetery_Gain()
		{
			using (Card card = new Cemetery())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockTable.SetupGet(_ => _.Copper).Returns(mockSupply.Object);
				// SpecialPiles should maybe be mocked as well??
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);
				mockPlayer.SetupGet(_ => _.Hand).Returns(new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner));
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>()))
					.Returns(new ChoiceResult(new ItemCollection<Card>(new DominionBase.Cards.Universal.Copper())));

				card.SetupCard(mockGame.Object);
				card.SetupSupply(mockGame.Object, mockSupply.Object);

				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, card, new DominionBase.Cards.Base.Remodel(), DeckLocation.Discard, DeckPosition.Automatic, false);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsTrue(cgeArgs.Resolvers.ContainsKey(TypeClass.Cemetery.ToString()));

				cgeArgs.Resolvers[TypeClass.Cemetery.ToString()].Method(mockPlayer.Object, ref cgeArgs);

				mockPlayer.Verify(_ => _.Trash(card, It.IsAny<ItemCollection<Card>>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Cemetery_Teardown()
		{
			using (Card card = new Cemetery())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockTable.SetupGet(_ => _.Copper).Returns(mockSupply.Object);
				// SpecialPiles should maybe be mocked as well??
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

				card.SetupCard(mockGame.Object);
				card.SetupSupply(mockGame.Object, mockSupply.Object);

				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, card, new DominionBase.Cards.Base.Remodel(), DeckLocation.Discard, DeckPosition.Automatic, false);

				// Teardown at the end (Make sure event listener isn't listening any more)
				card.TearDown(mockGame.Object);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsFalse(cgeArgs.Resolvers.ContainsKey(TypeClass.Cemetery.ToString()));
			}
		}
		[TestMethod]
		public void Test_Changeling_Basic()
		{
			using (var card = new Changeling())
			{
				Assert.AreEqual(new Cost(3), card.BaseCost);
				Assert.AreEqual(Categories.Card | Categories.Night, card.Category);
			}
		}
		[TestMethod]
		public void Test_Changeling_GainOther()
		{
			using (Card card = new Changeling())
			{

				var players = new PlayerCollection(mockGame.Object);
				var cardToExchange = new DominionBase.Cards.Universal.Silver();
				players.Add(mockPlayer.Object);
				players.Add(mockPlayer.Object);
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockGame.Setup(_ => _.ComputeCost(It.IsAny<ICost>())).Returns(new Cost(3));
				mockTable.SetupGet(_ => _[TypeClass.Changeling]).Returns(mockSupply.Object);
				mockTable.Setup(_ => _.FindSupplyPileByType(cardToExchange.Type, It.IsAny<bool>())).Returns(mockSupply.Object);
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>()))
					.Returns(new ChoiceResult(new ItemCollection<Card>(new DominionBase.Cards.Universal.Copper())));
				mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Buy);
				mockSupply.SetupGet(_ => _.TopCard).Returns(card);
				mockSupply.Setup(_ => _.CanGain()).Returns(true);
				mockSupply.Setup(_ => _.Take(TypeClass.Changeling)).Returns(card);

				card.SetupCard(mockGame.Object);
				card.SetupSupply(mockGame.Object, mockSupply.Object);

				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, cardToExchange, new DominionBase.Cards.Base.Remodel(), DeckLocation.Discard, DeckPosition.Automatic, false);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsTrue(cgeArgs.Resolvers.ContainsKey(TypeClass.Changeling.ToString()));

				cgeArgs.Resolvers[TypeClass.Changeling.ToString()].Method(mockPlayer.Object, ref cgeArgs);

				Assert.IsTrue(cgeArgs.Cancelled);
				mockPlayer.Verify(_ => _.Lose(It.IsAny<Card>()), Times.Once);
				mockPlayer.Verify(_ => _.AddCardInto(DeckLocation.Discard, It.IsAny<Card>(), It.IsAny<DeckPosition>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Changeling_Gain_Potion_Cost()
		{
			using (Card card = new Changeling())
			{

				var players = new PlayerCollection(mockGame.Object);
				var cardToExchange = new DominionBase.Cards.Universal.Silver();
				players.Add(mockPlayer.Object);
				players.Add(mockPlayer.Object);
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockGame.Setup(_ => _.ComputeCost(It.IsAny<ICost>())).Returns(new Cost(2, 1));
				mockTable.SetupGet(_ => _[TypeClass.Changeling]).Returns(mockSupply.Object);
				mockTable.Setup(_ => _.FindSupplyPileByType(cardToExchange.Type, It.IsAny<bool>())).Returns(mockSupply.Object);
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>()))
					.Returns(new ChoiceResult(new ItemCollection<Card>(new DominionBase.Cards.Universal.Copper())));
				mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Buy);
				mockSupply.SetupGet(_ => _.TopCard).Returns(card);
				mockSupply.Setup(_ => _.CanGain()).Returns(true);
				mockSupply.Setup(_ => _.Take(TypeClass.Changeling)).Returns(card);

				card.SetupCard(mockGame.Object);
				card.SetupSupply(mockGame.Object, mockSupply.Object);

				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, cardToExchange, new DominionBase.Cards.Base.Remodel(), DeckLocation.Discard, DeckPosition.Automatic, false);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsFalse(cgeArgs.Resolvers.ContainsKey(TypeClass.Changeling.ToString()));
			}
		}
		[TestMethod]
		public void Test_Changeling_Play()
		{
			using (Card card = new Changeling())
			{
				var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
				inPlay.AddRange(mockPlayer.Object, new List<Card> { card });
				mockPlayer.SetupGet(_ => _.InPlay).Returns(inPlay);
				mockPlayer.SetupGet(_ => _.InPlayAndSetAside).Returns(new DeckCollection());
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(mockSupply.Object));
				mockTable.SetupGet(_ => _.TableEntities).Returns(new TableEntityCollection());


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Trash(card, card), Times.Once);
				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Changeling_Teardown()
		{
			using (Card card = new Changeling())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);

				card.SetupCard(mockGame.Object);
				card.SetupSupply(mockGame.Object, mockSupply.Object);

				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, card, new DominionBase.Cards.Base.Remodel(), DeckLocation.Discard, DeckPosition.Automatic, false);

				// Teardown at the end (Make sure event listener isn't listening any more)
				card.TearDown(mockGame.Object);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsFalse(cgeArgs.Resolvers.ContainsKey(TypeClass.Changeling.ToString()));
			}
		}
		[TestMethod]
		public void Test_Cobbler_Basic()
		{
			using (var card = new Cobbler())
			{
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(Categories.Card | Categories.Night | Categories.Duration, card.Category);
			}
		}
		[TestMethod]
		public void Test_Cobbler_Play()
		{
			using (var card = new Cobbler())
			{
				mockTable.SetupGet(_ => _.TableEntities).Returns(new TableEntityCollection());
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(mockSupply.Object));


				// Just sets the card in play
				card.FollowInstructions(mockPlayer.Object);
				Assert.IsFalse(card.CanCleanUp);


				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.IsTrue(tseArgs.Resolvers.ContainsKey(card.Name));

				tseArgs.Resolvers[card.Name].Method(mockPlayer.Object, ref tseArgs);
				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, DeckLocation.Hand, DeckPosition.Automatic, 1, false), Times.Once);


				// Teardown at the end (Make sure event listener isn't listening any more)
				tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.IsFalse(tseArgs.Resolvers.ContainsKey(card.Name));
			}
		}
		[TestMethod]
		public void Test_Cobbler_Teardown()
		{
			using (var card = new Cobbler())
			{
				mockTable.SetupGet(_ => _.TableEntities).Returns(new TableEntityCollection());


				// Just sets the card in play
				card.FollowInstructions(mockPlayer.Object);
				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.IsTrue(tseArgs.Resolvers.ContainsKey(card.Name));


				// Teardown -- example, at the end of the game before the player got a chance to use it
				card.TearDown(mockGame.Object);


				// Teardown at the end (Make sure event listener isn't listening any more)
				tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.IsFalse(tseArgs.Resolvers.ContainsKey(card.Name));
			}
		}
		[TestMethod]
		public void Test_Conclave_Basic()
		{
			using (var card = new Conclave())
			{
				Assert.AreEqual(new Cost(4), card.BaseCost);
				Assert.AreEqual(new Currency(2), card.Benefit.Currency);
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
			}
		}
		[TestMethod]
		public void Test_Conclave_Play_Nothing()
		{
			using (Card card = new Conclave())
			{
				mockPlayer.SetupGet(_ => _.Hand).Returns(new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner));
				mockPlayer.SetupGet(_ => _.InPlayAndSetAside).Returns(new DeckCollection());
				mockPlayer.SetupGet(_ => _.Actions).Returns(1);
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>()));


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.PlayNothing(It.IsAny<string>()), Times.Once);
				mockPlayer.Verify(_ => _.PlayCard(It.IsAny<Card>(), It.IsAny<PlayerMode>()), Times.Never);
				mockPlayer.VerifySet(_ => _.Actions = 2, Times.Never);
			}
		}
		[TestMethod]
		public void Test_Conclave_Play_Card()
		{
			using (Card card = new Conclave())
			{
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				Card otherAction = new Bard();
				hand.AddRange(mockPlayer.Object, new List<Card> { otherAction });
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				mockPlayer.SetupGet(_ => _.InPlayAndSetAside).Returns(new DeckCollection());
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>(otherAction)));


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.VerifySet(_ => _.Actions = 1, Times.Once);
				mockPlayer.Verify(_ => _.PlayCard(otherAction, It.IsAny<PlayerMode>()), Times.Once);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Actions == 1), It.IsAny<bool>()), Times.Once);
				mockPlayer.Verify(_ => _.PlayNothing(It.IsAny<string>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Crypt_Basic()
		{
			using (var card = new Crypt())
			{
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(Categories.Card | Categories.Night | Categories.Duration, card.Category);
			}
		}
		[TestMethod]
		public void Test_Crypt_No_Cards()
		{
			using (Card card = new Crypt())
			{
				mockPlayer.SetupGet(_ => _.InPlayAndSetAside).Returns(new DeckCollection());
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>()));
				mockPlayer.Setup(_ => _.RetrieveCardsFrom(DeckLocation.InPlayAndSetAside, It.IsAny<ItemCollection<Card>>())).Returns(new ItemCollection<Card>());


				card.FollowInstructions(mockPlayer.Object);


				Assert.IsTrue(card.CanCleanUp);
				mockGame.Verify(_ => _.SendMessage(mockPlayer.Object, card, It.IsAny<IDisplayable[]>()), Times.Once);

				// Teardown at the end (Make sure event listener isn't listening)
				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.AreEqual(0, tseArgs.Resolvers.Count);
			}
		}
		[TestMethod]
		public void Test_Crypt_One_Card()
		{
			using (Card card = new Crypt())
			{
				mockPlayer.SetupGet(_ => _.InPlayAndSetAside).Returns(new DeckCollection());
				var singleCard = new DominionBase.Cards.Universal.Copper();
				var cards = new ItemCollection<Card>(singleCard);
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(cards));
				mockPlayer.Setup(_ => _.RetrieveCardsFrom(DeckLocation.InPlayAndSetAside, It.IsAny<ItemCollection<Card>>())).Returns(new ItemCollection<Card>(cards));


				card.FollowInstructions(mockPlayer.Object);


				Assert.IsFalse(card.CanCleanUp);
				mockGame.Verify(_ => _.SendMessage(mockPlayer.Object, card, It.IsAny<IDisplayable[]>()), Times.Once);

				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.AreEqual(1, tseArgs.Resolvers.Count);
				string key = "";
				foreach (var k in tseArgs.Resolvers.Keys) key = k;
				Assert.IsTrue(tseArgs.Resolvers[key].Card != null && tseArgs.Resolvers[key].Card.Type == TypeClass.Crypt);

				tseArgs.Resolvers[key].Method(mockPlayer.Object, ref tseArgs);
				Assert.IsTrue(card.CanCleanUp);

				// Teardown at the end (Make sure event listener isn't listening)
				tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.AreEqual(0, tseArgs.Resolvers.Count);
			}
		}
		[TestMethod]
		public void Test_Crypt_Two_Cards()
		{
			using (Card card = new Crypt())
			{
				mockPlayer.SetupGet(_ => _.InPlayAndSetAside).Returns(new DeckCollection());
				var firstCard = new DominionBase.Cards.Universal.Copper();
				var secondCard = new DominionBase.Cards.Universal.Copper();
				var cards = new ItemCollection<Card>(new List<Card> { firstCard, secondCard });
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.Minimum == 0))).Returns(new ChoiceResult(cards));
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.Minimum != 0 && c.Cards.Count() == 2))).Returns(new ChoiceResult(new ItemCollection<Card>(firstCard)));
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.Minimum != 0 && c.Cards.Count() == 1))).Returns(new ChoiceResult(new ItemCollection<Card>(secondCard)));
				mockPlayer.Setup(_ => _.RetrieveCardsFrom(DeckLocation.InPlayAndSetAside, It.IsAny<ItemCollection<Card>>())).Returns(new ItemCollection<Card>(cards));


				card.FollowInstructions(mockPlayer.Object);


				Assert.IsFalse(card.CanCleanUp);
				mockGame.Verify(_ => _.SendMessage(mockPlayer.Object, card, It.IsAny<IDisplayable[]>()), Times.Once);
				Assert.AreEqual(3, card.Stack().Count);


				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.AreEqual(1, tseArgs.Resolvers.Count);
				string key = "";
				foreach (var k in tseArgs.Resolvers.Keys) key = k;
				Assert.IsTrue(tseArgs.Resolvers[key].Card != null && tseArgs.Resolvers[key].Card.Type == TypeClass.Crypt);

				tseArgs.Resolvers[key].Method(mockPlayer.Object, ref tseArgs);

				Assert.IsFalse(card.CanCleanUp);
				mockGame.Verify(_ => _.SendMessage(mockPlayer.Object, card, It.IsAny<IDisplayable[]>()), Times.Once);
				Assert.AreEqual(2, card.Stack().Count);


				tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.AreEqual(1, tseArgs.Resolvers.Count);
				key = "";
				foreach (var k in tseArgs.Resolvers.Keys) key = k;
				Assert.IsTrue(tseArgs.Resolvers[key].Card != null && tseArgs.Resolvers[key].Card.Type == TypeClass.Crypt);

				tseArgs.Resolvers[key].Method(mockPlayer.Object, ref tseArgs);

				Assert.IsTrue(card.CanCleanUp);
				Assert.AreEqual(1, card.Stack().Count);

				// Teardown at the end (Make sure event listener isn't listening)
				tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.AreEqual(0, tseArgs.Resolvers.Count);
			}
		}
		[TestMethod]
		public void Test_Crypt_Teardown()
		{
			using (Card card = new Crypt())
			{
				var players = new PlayerCollection(mockGame.Object) { mockPlayer.Object };
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockPlayer.SetupGet(_ => _.InPlayAndSetAside).Returns(new DeckCollection());
				var firstCard = new DominionBase.Cards.Universal.Copper();
				var secondCard = new DominionBase.Cards.Universal.Copper();
				var cards = new ItemCollection<Card>(new List<Card> { firstCard, secondCard });
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(cards));
				mockPlayer.Setup(_ => _.RetrieveCardsFrom(DeckLocation.InPlayAndSetAside, It.IsAny<ItemCollection<Card>>())).Returns(new ItemCollection<Card>(cards));


				card.FollowInstructions(mockPlayer.Object);
				var points = new PointsCollection();
				card.PerformEndgameCalculations(mockPlayer.Object, points);
				card.TearDown(mockGame.Object);

				// Make sure the 2 Crypt'ed cards are returned
				Assert.AreEqual(2, points.Count);

				// Teardown at the end (Make sure event listener isn't listening)
				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.AreEqual(0, tseArgs.Resolvers.Count);
			}
		}
		[TestMethod]
		public void Test_CursedGold_Basic()
		{
			using (var card = new CursedGold())
			{
				Assert.AreEqual(new Cost(4), card.BaseCost);
				Assert.AreEqual(new Currency(3), card.Benefit.Currency);
				Assert.AreEqual(Categories.Card | Categories.Treasure | Categories.Heirloom, card.Category);
			}
		}
		[TestMethod]
		public void Test_CursedGold_Play()
		{
			using (Card card = new CursedGold())
			{
				mockTable.SetupGet(_ => _.Curse).Returns(mockSupply.Object);
				mockSupply.SetupGet(_ => _.Type).Returns(DominionBase.Cards.Universal.TypeClass.Curse);


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(It.Is<ISupply>(s => s.Type == DominionBase.Cards.Universal.TypeClass.Curse), card, 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_CursedVillage_Basic()
		{
			using (var card = new CursedVillage())
			{
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(2, card.Benefit.Actions);
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Doom, card.Category);
			}
		}
		[TestMethod]
		public void Test_CursedVillage_Setup()
		{
			using (Card card = new CursedVillage())
			{

				// SpecialPiles should maybe be mocked as well??
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

				card.SetupSupply(mockGame.Object, mockSupply.Object);

				Assert.IsTrue(specialPiles.ContainsKey(TypeClass.Hexes));
			}
		}
		[TestMethod]
		public void Test_CursedVillage_Play()
		{
			using (Card card = new CursedVillage())
			{
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				hand.AddRange(mockPlayer.Object, new List<Card> { new Bard(), new Bard(), new Bard(), new Bard() });
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				mockPlayer.SetupGet(_ => _.CanDraw).Returns(true);
				mockPlayer.Setup(_ => _.DrawHand(It.IsAny<int>())).Callback((int number) => {
					for (var i = 0; i < number; i++)
						hand.Add(new Imp());
				});


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.DrawHand(1), Times.Exactly(2));
			}
		}
		[TestMethod]
		public void Test_CursedVillage_PlayLotsOfCards()
		{
			using (Card card = new CursedVillage())
			{
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				hand.AddRange(mockPlayer.Object, new List<Card> { new Bard(), new Bard(), new Bard(), new Bard(), new Bard(), new Bard(), new Bard(), new Bard() });
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.ReceiveBenefit(It.IsAny<ICardBase>(), It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Once);
				mockPlayer.Verify(_ => _.ReceiveBenefit(It.IsAny<ICardBase>(), It.Is<CardBenefit>(cb => cb.Cards != 0), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_CursedVillage_Gain()
		{
			using (Card card = new CursedVillage())
			{

				Initialize_ReceiveHex(card);
				card.SetupCard(mockGame.Object);

				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, card, new DominionBase.Cards.Base.Remodel(), DeckLocation.Discard, DeckPosition.Automatic, false);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsTrue(cgeArgs.Resolvers.ContainsKey(TypeClass.CursedVillage.ToString()));

				cgeArgs.Resolvers[TypeClass.CursedVillage.ToString()].Method(mockPlayer.Object, ref cgeArgs);

				mockGame.Verify(_ => _.SendMessage(mockPlayer.Object, It.IsAny<Hex>(), "Receive"), Times.Once);
			}
		}
		[TestMethod]
		public void Test_CursedVillage_Teardown()
		{
			using (Card card = new CursedVillage())
			{

				Initialize_ReceiveHex(card);
				card.SetupCard(mockGame.Object);

				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, card, new DominionBase.Cards.Base.Remodel(), DeckLocation.Discard, DeckPosition.Automatic, false);

				// Teardown at the end (Make sure event listener isn't listening any more)
				card.TearDown(mockGame.Object);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsFalse(cgeArgs.Resolvers.ContainsKey(TypeClass.CursedVillage.ToString()));
			}
		}
		[TestMethod]
		public void Test_Deluded_Basic()
		{
			using (var card = new Deluded())
			{
				Assert.AreEqual(Categories.State, card.Category);
			}
		}
		[TestMethod]
		public void Test_Deluded_Taken_OutsideTurn()
		{
			using (State card = new Deluded())
			{
				card.TakenBy(mockPlayer.Object);


				var pceArgs = new PhaseChangingEventArgs(mockPlayer.Object, PhaseEnum.Starting);
				mockPlayer.Raise(_ => _.PhaseChanging += null, pceArgs);
				Assert.IsFalse(pceArgs.Resolvers.ContainsKey(TypeClass.Deluded));
			}
		}
		[TestMethod]
		public void Test_Deluded_Taken()
		{
			using (State card = new Deluded())
			{
				var mockCostBard = new Mock<ICost>();
				mockSupply.SetupGet(_ => _.TopCard).Returns(mockCostBard.Object);
				mockCostBard.SetupGet(_ => _.Category).Returns(Categories.Card | Categories.Action | Categories.Fate);
				var otherSupply = new Mock<ISupply>();
				var mockCostIdol = new Mock<ICost>();
				otherSupply.SetupGet(_ => _.TopCard).Returns(mockCostIdol.Object);
				mockCostIdol.SetupGet(_ => _.Category).Returns(Categories.Card | Categories.Treasure | Categories.Attack | Categories.Fate);
				var supplies = new TableEntityCollection
				{
					{ TypeClass.Bard, mockSupply.Object },
					{ TypeClass.Idol, otherSupply.Object }
				};
				mockTable.SetupGet(_ => _.TableEntities).Returns(supplies);


				card.TakenBy(mockPlayer.Object);


				// Trigger changing to Buy phase
				var pceArgs = new PhaseChangingEventArgs(mockPlayer.Object, PhaseEnum.BuyTreasure);
				mockPlayer.Raise(_ => _.PhaseChanging += null, pceArgs);
				Assert.IsTrue(pceArgs.Resolvers.ContainsKey(TypeClass.Deluded));

				pceArgs.Resolvers[TypeClass.Deluded].Method(mockPlayer.Object, ref pceArgs);

				// Raise BuyCheck on both supplies to see if they can be bought
				var bceArgsBard = new BuyCheckEventArgs(mockPlayer.Object);
				mockSupply.Raise(_ => _.BuyCheck += null, bceArgsBard);
				Assert.IsTrue(bceArgsBard.Cancelled);
				var bceArgsIdol = new BuyCheckEventArgs(mockPlayer.Object);
				otherSupply.Raise(_ => _.BuyCheck += null, bceArgsIdol);
				Assert.IsFalse(bceArgsIdol.Cancelled);

			}
		}
		[TestMethod]
		public void Test_Deluded_TurnEnded()
		{
			using (State card = new Deluded())
			{
				var mockCostBard = new Mock<ICost>();
				mockSupply.SetupGet(_ => _.TopCard).Returns(mockCostBard.Object);
				mockCostBard.SetupGet(_ => _.Category).Returns(Categories.Card | Categories.Action | Categories.Fate);
				var supplies = new TableEntityCollection { { TypeClass.Bard, mockSupply.Object } };
				mockTable.SetupGet(_ => _.TableEntities).Returns(supplies);
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);


				card.TakenBy(mockPlayer.Object);



				// Trigger changing to Buy phase
				var pceArgs = new PhaseChangingEventArgs(mockPlayer.Object, PhaseEnum.BuyTreasure);
				mockPlayer.Raise(_ => _.PhaseChanging += null, pceArgs);
				Assert.IsTrue(pceArgs.Resolvers.ContainsKey(TypeClass.Deluded));

				pceArgs.Resolvers[TypeClass.Deluded].Method(mockPlayer.Object, ref pceArgs);

				var teeArgs = new TurnEndedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnEnded += null, teeArgs);

				// Raise BuyCheck on both supplies to see if they can be bought (shouldn't be correct, since we tore everything down)
				var bceArgsBard = new BuyCheckEventArgs(mockPlayer.Object);
				mockSupply.Raise(_ => _.BuyCheck += null, bceArgsBard);
				Assert.IsFalse(bceArgsBard.Cancelled);
			}
		}
		[TestMethod]
		public void Test_Deluded_Teardown()
		{
			using (State card = new Deluded())
			{
				var mockCostBard = new Mock<ICost>();
				mockSupply.SetupGet(_ => _.TopCard).Returns(mockCostBard.Object);
				mockCostBard.SetupGet(_ => _.Category).Returns(Categories.Card | Categories.Action | Categories.Fate);
				var supplies = new TableEntityCollection { { TypeClass.Bard, mockSupply.Object } };
				mockTable.SetupGet(_ => _.TableEntities).Returns(supplies);
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);


				card.TakenBy(mockPlayer.Object);



				// Trigger changing to Buy phase
				var pceArgs = new PhaseChangingEventArgs(mockPlayer.Object, PhaseEnum.BuyTreasure);
				mockPlayer.Raise(_ => _.PhaseChanging += null, pceArgs);
				Assert.IsTrue(pceArgs.Resolvers.ContainsKey(TypeClass.Deluded));

				pceArgs.Resolvers[TypeClass.Deluded].Method(mockPlayer.Object, ref pceArgs);

				card.TearDown(mockGame.Object);

				// Raise BuyCheck on both supplies to see if they can be bought (shouldn't be correct, since we tore everything down)
				var bceArgsBard = new BuyCheckEventArgs(mockPlayer.Object);
				mockSupply.Raise(_ => _.BuyCheck += null, bceArgsBard);
				Assert.IsFalse(bceArgsBard.Cancelled);
			}
		}
		[TestMethod]
		public void Test_Delusion_Basic()
		{
			using (var card = new Delusion())
			{
				Assert.AreEqual(Categories.Hex, card.Category);
			}
		}
		[TestMethod]
		public void Test_Delusion_Receive()
		{
			using (Hex card = new Delusion())
			{
				var takeables = new ItemCollection<ITakeable>();
				mockPlayer.SetupGet(_ => _.Takeables).Returns(takeables);


				card.Receive(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Take(TypeClass.Deluded), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Delusion_Receive_Already_Envious()
		{
			using (Hex card = new Envy())
			{
				var takeables = new ItemCollection<ITakeable>(new Envious());
				mockPlayer.SetupGet(_ => _.Takeables).Returns(takeables);


				card.Receive(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Take(TypeClass.Deluded), Times.Never);
			}
		}
		[TestMethod]
		public void Test_DenOfSin_Basic()
		{
			using (var card = new DenOfSin())
			{
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(2, card.DurationBenefit.Cards);
				Assert.AreEqual(Categories.Card | Categories.Night | Categories.Duration, card.Category);
			}
		}
		[TestMethod]
		public void Test_DenOfSin_Gain()
		{
			using (Card card = new DenOfSin())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					new Mock<IPlayer>().Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				card.SetupCard(mockGame.Object);


				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, card, new DominionBase.Cards.Base.Remodel(), DeckLocation.Discard, DeckPosition.Automatic, false);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsTrue(cgeArgs.Resolvers.ContainsKey(TypeClass.DenOfSin.ToString()));

				cgeArgs.Resolvers[TypeClass.DenOfSin.ToString()].Method(mockPlayer.Object, ref cgeArgs);
				Assert.IsTrue(cgeArgs.Cancelled);
				Assert.AreEqual(DeckLocation.Hand, cgeArgs.Location);
			}
		}
		[TestMethod]
		public void Test_DenOfSin_Play()
		{
			using (Card card = new DenOfSin())
			{
				card.FollowInstructions(mockPlayer.Object);


				Assert.IsFalse(card.CanCleanUp);

				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				var key = card.ToString();
				Assert.IsTrue(tseArgs.Resolvers.ContainsKey(key));

				tseArgs.Resolvers[key].Method(mockPlayer.Object, ref tseArgs);

				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards == 2), It.IsAny<bool>()), Times.Once);
				Assert.IsTrue(card.CanCleanUp);
			}
		}
		[TestMethod]
		public void Test_DenOfSin_Teardown()
		{
			using (Card card = new DenOfSin())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					new Mock<IPlayer>().Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				card.SetupCard(mockGame.Object);


				card.FollowInstructions(mockPlayer.Object);
				card.TearDown(mockGame.Object);


				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, card, new DominionBase.Cards.Base.Remodel(), DeckLocation.Discard, DeckPosition.Automatic, false);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsFalse(cgeArgs.Resolvers.ContainsKey(TypeClass.DenOfSin.ToString()));

				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				var key = card.ToString();
				Assert.IsFalse(tseArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_DevilsWorkshop_Basic()
		{
			using (var card = new DevilsWorkshop())
			{
				Assert.AreEqual(new Cost(4), card.BaseCost);
				Assert.AreEqual(Categories.Card | Categories.Night, card.Category);
			}
		}
		[TestMethod]
		public void Test_DevilsWorkshop_Setup()
		{
			using (Card card = new DevilsWorkshop())
			{

				// SpecialPiles should maybe be mocked as well??
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

				card.SetupSupply(mockGame.Object, mockSupply.Object);

				Assert.IsTrue(specialPiles.ContainsKey(TypeClass.Imp));
			}
		}
		[TestMethod]
		public void Test_DevilsWorkshop_Play_0_Gained()
		{
			using (Card card = new DevilsWorkshop())
			{

				// SpecialPiles should maybe be mocked as well??
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);
				mockTable.SetupGet(_ => _.Gold).Returns(mockSupply.Object);
				var currentTurn = new Turn(mockPlayer.Object);
				mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(currentTurn);


				card.SetupSupply(mockGame.Object, mockSupply.Object);


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, 1, false), Times.Once);
				mockPlayer.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_DevilsWorkshop_Play_1_Gained()
		{
			using (Card card = new DevilsWorkshop())
			{

				// SpecialPiles should maybe be mocked as well??
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);
				var mockGold = new Mock<ISupply>();
				mockTable.SetupGet(_ => _.Gold).Returns(mockGold.Object);
				var supplies = new TableEntityCollection() { { TypeClass.Bard, mockSupply.Object } };
				mockTable.SetupGet(_ => _.TableEntities).Returns(supplies);
				var currentTurn = new Turn(mockPlayer.Object);
				currentTurn.CardsGained.Add(new Bard());
				mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(currentTurn);
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(mockSupply.Object));


				card.SetupSupply(mockGame.Object, mockSupply.Object);


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(mockGold.Object, It.IsAny<IGameObject>(), It.IsAny<int>(), It.IsAny<bool>()), Times.Never);
				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_DevilsWorkshop_Play_2_Gained()
		{
			using (Card card = new DevilsWorkshop())
			{

				// SpecialPiles should maybe be mocked as well??
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);
				var mockGold = new Mock<ISupply>();
				mockTable.SetupGet(_ => _.Gold).Returns(mockGold.Object);
				var supplies = new TableEntityCollection() { { TypeClass.Bard, mockSupply.Object } };
				mockTable.SetupGet(_ => _.TableEntities).Returns(supplies);
				var currentTurn = new Turn(mockPlayer.Object);
				currentTurn.CardsGained.AddRange(new List<Card> { new Bard(), new Bard() });
				mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(currentTurn);


				card.SetupSupply(mockGame.Object, mockSupply.Object);


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(mockGold.Object, It.IsAny<IGameObject>(), It.IsAny<int>(), It.IsAny<bool>()), Times.Never);
				mockPlayer.Verify(_ => _.Gain((ISupply)specialPiles[TypeClass.Imp], card, 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Druid_Basic()
		{
			using (var card = new Druid())
			{
				Assert.AreEqual(new Cost(2), card.BaseCost);
				Assert.AreEqual(1, card.Benefit.Buys);
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Fate, card.Category);
			}
		}
		[TestMethod]
		public void Test_Druid_Setup()
		{
			using (Card card = new Druid())
			{

				mockGame.SetupGet(_ => _.Settings).Returns(new GameSettings());
				// SpecialPiles should maybe be mocked as well??
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

				card.SetupSupply(mockGame.Object, mockSupply.Object);

				Assert.IsTrue(specialPiles.ContainsKey(TypeClass.Boons));
				Assert.IsTrue(specialPiles.ContainsKey(TypeClass.DruidBoons));
				DruidBoons druidBoons = (DruidBoons)specialPiles[TypeClass.DruidBoons];
				Assert.IsNotNull(druidBoons);
				Assert.AreEqual(3, druidBoons.Count);
				Assert.AreEqual(9, specialPiles[TypeClass.Boons].Count);
			}
		}
		[TestMethod]
		public void Test_Druid_Play()
		{
			using (Card card = new Druid())
			{
				mockGame.SetupGet(_ => _.Settings).Returns(new GameSettings());
				// SpecialPiles should maybe be mocked as well??
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);
				card.SetupSupply(mockGame.Object, mockSupply.Object);
				var mockBoon = new Mock<IBoon>();
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<IBoon>(mockBoon.Object)));


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Once);
				mockBoon.Verify(_ => _.Receive(mockPlayer.Object), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Envious_Basic()
		{
			using (var card = new Envious())
			{
				Assert.AreEqual(Categories.State, card.Category);
			}
		}
		[TestMethod]
		public void Test_Envious_Taken_OutsideTurn()
		{
			using (State card = new Envious())
			{


				card.TakenBy(mockPlayer.Object);


				var pceArgs = new PhaseChangingEventArgs(mockPlayer.Object, PhaseEnum.Starting);
				mockPlayer.Raise(_ => _.PhaseChanging += null, pceArgs);
				Assert.IsFalse(pceArgs.Resolvers.ContainsKey(TypeClass.Envious));
			}
		}
		[TestMethod]
		public void Test_Envious_Taken_Play_Silver()
		{
			using (State card = new Envious())
			{


				card.TakenBy(mockPlayer.Object);


				// Trigger changing to Buy phase
				var pceArgs = new PhaseChangingEventArgs(mockPlayer.Object, PhaseEnum.BuyTreasure);
				mockPlayer.Raise(_ => _.PhaseChanging += null, pceArgs);
				Assert.IsTrue(pceArgs.Resolvers.ContainsKey(TypeClass.Envious));

				pceArgs.Resolvers[TypeClass.Envious].Method(mockPlayer.Object, ref pceArgs);

				// Raise BuyCheck on both supplies to see if they can be bought
				var cpeArgs = new CardPlayedEventArgs(mockPlayer.Object, new DominionBase.Cards.Universal.Silver());
				mockPlayer.Raise(_ => _.CardPlayed += null, cpeArgs);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Currency.Coin.Value == -1), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Envious_Taken_Play_MultipleTreasures()
		{
			using (State card = new Envious())
			{
				card.TakenBy(mockPlayer.Object);


				// Trigger changing to Buy phase
				var pceArgs = new PhaseChangingEventArgs(mockPlayer.Object, PhaseEnum.BuyTreasure);
				mockPlayer.Raise(_ => _.PhaseChanging += null, pceArgs);
				Assert.IsTrue(pceArgs.Resolvers.ContainsKey(TypeClass.Envious));

				pceArgs.Resolvers[TypeClass.Envious].Method(mockPlayer.Object, ref pceArgs);

				// Raise BuyCheck on both supplies to see if they can be bought
				var cpeArgs = new CardPlayedEventArgs(mockPlayer.Object, new ItemCollection<Card> {
				new DominionBase.Cards.Universal.Gold(), new DominionBase.Cards.Universal.Silver(), new Idol()
			});
				mockPlayer.Raise(_ => _.CardPlayed += null, cpeArgs);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Currency.Coin.Value == -3), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Envious_TurnEnded()
		{
			using (State card = new Envious())
			{
				card.TakenBy(mockPlayer.Object);


				// Trigger changing to Buy phase
				var pceArgs = new PhaseChangingEventArgs(mockPlayer.Object, PhaseEnum.BuyTreasure);
				mockPlayer.Raise(_ => _.PhaseChanging += null, pceArgs);
				Assert.IsTrue(pceArgs.Resolvers.ContainsKey(TypeClass.Envious));

				pceArgs.Resolvers[TypeClass.Envious].Method(mockPlayer.Object, ref pceArgs);

				var teeArgs = new TurnEndedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnEnded += null, teeArgs);

				// Raise BuyCheck on both supplies to see if they can be bought (shouldn't be correct, since we tore everything down)
				var cpeArgs = new CardPlayedEventArgs(mockPlayer.Object, new DominionBase.Cards.Universal.Gold());
				mockPlayer.Raise(_ => _.CardPlayed += null, cpeArgs);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Envious_Teardown()
		{
			using (State card = new Envious())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);


				card.TakenBy(mockPlayer.Object);



				// Trigger changing to Buy phase
				var pceArgs = new PhaseChangingEventArgs(mockPlayer.Object, PhaseEnum.BuyTreasure);
				mockPlayer.Raise(_ => _.PhaseChanging += null, pceArgs);
				Assert.IsTrue(pceArgs.Resolvers.ContainsKey(TypeClass.Envious));

				pceArgs.Resolvers[TypeClass.Envious].Method(mockPlayer.Object, ref pceArgs);

				card.TearDown(mockGame.Object);

				// Raise BuyCheck on both supplies to see if they can be bought (shouldn't be correct, since we tore everything down)
				var cpeArgs = new CardPlayedEventArgs(mockPlayer.Object, new DominionBase.Cards.Universal.Gold());
				mockPlayer.Raise(_ => _.CardPlayed += null, cpeArgs);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Envy_Basic()
		{
			using (var card = new Envy())
				Assert.AreEqual(Categories.Hex, card.Category);
		}
		[TestMethod]
		public void Test_Envy_Receive()
		{
			using (Hex card = new Envy())
			{
				var takeables = new ItemCollection<ITakeable>();
				mockPlayer.SetupGet(_ => _.Takeables).Returns(takeables);


				card.Receive(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Take(TypeClass.Envious), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Envy_Receive_Already_Deluded()
		{
			using (Hex card = new Envy())
			{
				var takeables = new ItemCollection<ITakeable>(new Deluded());
				mockPlayer.SetupGet(_ => _.Takeables).Returns(takeables);


				card.Receive(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Take(TypeClass.Envious), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Exorcist_Basic()
		{
			using (var card = new Exorcist())
			{
				Assert.AreEqual(new Cost(4), card.BaseCost);
				Assert.AreEqual(Categories.Card | Categories.Night, card.Category);
			}
		}
		[TestMethod]
		public void Test_Exorcist_Setup()
		{
			using (Card card = new Exorcist())
			{
				// SpecialPiles should maybe be mocked as well??
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

				card.SetupSupply(mockGame.Object, mockSupply.Object);

				Assert.IsTrue(specialPiles.ContainsKey(TypeClass.Ghost));
				Assert.IsTrue(specialPiles.ContainsKey(TypeClass.Imp));
				Assert.IsTrue(specialPiles.ContainsKey(TypeClass.WillOWisp));
			}
		}
		[TestMethod]
		public void Test_Exorcist_Play()
		{
			using (Card card = new Exorcist())
			using (var urchin = new DominionBase.Cards.DarkAges.Urchin())
			using (var vampire = new Vampire())
			{

				// SpecialPiles should maybe be mocked as well??
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);
				mockPlayer.SetupGet(_ => _.Hand).Returns(new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner));
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceOutcome == ChoiceOutcome.Trash))).Returns(new ChoiceResult(new ItemCollection<Card>(new Bard())));
				var spiritToGain = new WillOWisp();
				var fakeResultCards = new ItemCollection<Card>(spiritToGain);
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceOutcome == ChoiceOutcome.Gain))).Returns(new ChoiceResult(fakeResultCards));

				card.SetupSupply(mockGame.Object, mockSupply.Object);
				// Set up 2 other Supply piles with "special piles" to verify that none of them get gained
				urchin.SetupSupply(mockGame.Object, new Mock<ISupply>().Object);
				vampire.SetupSupply(mockGame.Object, new Mock<ISupply>().Object);



				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(It.Is<ISupply>(s => s.Type == spiritToGain.Type), card, 1, false), Times.Once);
				// Make sure no non-Spirit piles are offered as a choice
				mockPlayer.Verify(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceOutcome == ChoiceOutcome.Gain && c.Cards.Any(cc => !cc.Category.HasFlag(Categories.Spirit)))), Times.Never);
			}
		}
		[TestMethod]
		public void Test_FaithfulHound_Basic()
		{
			using (var card = new FaithfulHound())
			{
				Assert.AreEqual(new Cost(2), card.BaseCost);
				Assert.AreEqual(2, card.Benefit.Cards);
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Reaction, card.Category);
			}
		}
		[TestMethod]
		public void Test_FaithfulHound_Owner_Changed()
		{
			using (Card card = new FaithfulHound())
			{

				var oldOwner = new Mock<IPlayer>();
				var turn = new Turn(mockPlayer.Object);
				mockGame.SetupGet(_ => _.CurrentTurn).Returns(turn);
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);

				card.Owner = oldOwner.Object;

				var cdeArgs = new CardsDiscardEventArgs(DeckLocation.Hand, card);
				oldOwner.Raise(_ => _.CardsDiscarding += null, cdeArgs);
				var key = Tuple.Create(TypeClass.FaithfulHound, TypeClass.FaithfulHound);
				Assert.IsTrue(cdeArgs.Resolvers.ContainsKey(key));

				card.Owner = mockPlayer.Object;

				cdeArgs = new CardsDiscardEventArgs(DeckLocation.Hand, card);
				oldOwner.Raise(_ => _.CardsDiscarding += null, cdeArgs);
				Assert.IsFalse(cdeArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_FaithfulHound_Discard()
		{
			using (Card card = new FaithfulHound())
			{
				var turn = new Turn(mockPlayer.Object);
				mockGame.SetupGet(_ => _.CurrentTurn).Returns(turn);
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);

				card.Owner = mockPlayer.Object;

				var cdeArgs = new CardsDiscardEventArgs(DeckLocation.Hand, card);
				mockPlayer.Raise(_ => _.CardsDiscarding += null, cdeArgs);
				var key = Tuple.Create(TypeClass.FaithfulHound, TypeClass.FaithfulHound);
				Assert.IsTrue(cdeArgs.Resolvers.ContainsKey(key));

				cdeArgs.Resolvers[key].Method(mockPlayer.Object, ref cdeArgs);

				var teeArgs = new TurnEndedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnEnded += null, teeArgs);

				mockPlayer.Verify(_ => _.RetrieveCardFrom(DeckLocation.SetAside, card), Times.Once);
				mockPlayer.Verify(_ => _.AddCardInto(DeckLocation.Hand, It.IsAny<Card>(), It.IsAny<DeckPosition>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_FaithfulHound_Teardown()
		{
			using (Card card = new FaithfulHound())
			{
				var turn = new Turn(mockPlayer.Object);
				mockGame.SetupGet(_ => _.CurrentTurn).Returns(turn);
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);

				card.Owner = mockPlayer.Object;

				var cdeArgs = new CardsDiscardEventArgs(DeckLocation.Hand, card);
				mockPlayer.Raise(_ => _.CardsDiscarding += null, cdeArgs);
				var key = Tuple.Create(TypeClass.FaithfulHound, TypeClass.FaithfulHound);
				Assert.IsTrue(cdeArgs.Resolvers.ContainsKey(key));

				card.TearDown(mockGame.Object);

				cdeArgs = new CardsDiscardEventArgs(DeckLocation.Hand, card);
				mockPlayer.Raise(_ => _.CardsDiscarding += null, cdeArgs);
				Assert.IsFalse(cdeArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Famine_Basic()
		{
			using (var card = new Famine())
			{
				Assert.AreEqual(Categories.Hex, card.Category);
			}
		}
		[TestMethod]
		public void Test_Famine_Receive()
		{
			using (Hex card = new Famine())
			{
				var revealedCards = new ItemCollection<Card>(new List<Card> { new DominionBase.Cards.Universal.Copper(), new Bard(), new DominionBase.Cards.Universal.Copper() });
				mockPlayer.Setup(_ => _.Draw(3, DeckLocation.Revealed)).Returns(revealedCards);


				card.Receive(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Discard(DeckLocation.Revealed, It.IsAny<Predicate<Card>>(), null), Times.Once);
				mockPlayer.Verify(_ => _.RetrieveCardsFrom(DeckLocation.Revealed), Times.Once);
				mockPlayer.Verify(_ => _.AddCardsToDeck(It.IsAny<IEnumerable<Card>>(), DeckPosition.Top), Times.Once);
				mockPlayer.Verify(_ => _.ShuffleDrawPile(), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Fear_Basic()
		{
			using (var card = new Fear())
			{
				Assert.AreEqual(Categories.Hex, card.Category);
			}
		}
		[TestMethod]
		public void Test_Fear_Receive_TooFewCards()
		{
			using (Hex card = new Fear())
			{
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				hand.AddRange(mockPlayer.Object, new List<Card> { new Bard(), new Bard() });
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);


				card.Receive(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Discard(DeckLocation.Hand, It.IsAny<IEnumerable<Card>>(), It.IsAny<CardsDiscardResolver>()), Times.Never);
				mockPlayer.Verify(_ => _.RevealHand(), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Fear_Receive_CanDiscard()
		{
			using (Hex card = new Fear())
			{
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				hand.AddRange(mockPlayer.Object, new List<Card> { new Bard(), new Bard(), new Bard(), new Bard(), new Bard(), new Bard(), new Bard(), new Bard() });
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>(hand.First())));


				card.Receive(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Discard(DeckLocation.Hand, It.Is<IEnumerable<Card>>(ec => ec.Count() == 1 && ec.Contains(hand.First())), null), Times.Once);
				mockPlayer.Verify(_ => _.RevealHand(), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Fear_Receive_NoActionsOrTreasures()
		{
			using (Hex card = new Fear())
			{
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				hand.AddRange(mockPlayer.Object, new List<Card> { new Cemetery(), new Changeling(), new Bat(), new Cemetery(), new Exorcist() });
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>(hand.First())));


				card.Receive(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Discard(DeckLocation.Hand, It.IsAny<IEnumerable<Card>>(), It.IsAny<CardsDiscardResolver>()), Times.Never);
				mockPlayer.Verify(_ => _.RevealHand(), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Fool_Basic()
		{
			using (var card = new Fool())
			{
				Assert.AreEqual(new Cost(3), card.BaseCost);
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Fate, card.Category);
			}
		}
		[TestMethod]
		public void Test_Fool_Setup()
		{
			using (Card card = new Fool())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);
				mockTable.SetupGet(_ => _.Copper).Returns(mockSupply.Object);

				card.SetupSupply(mockGame.Object, mockSupply.Object);

				mockSupply.Verify(_ => _.AddTo(It.IsAny<LuckyCoin>(), 0), Times.AtLeastOnce);
			}
		}
		[TestMethod]
		public void Test_Fool_Play_Not_Lost()
		{
			using (Card card = new Fool())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockTable.SetupGet(_ => _.Copper).Returns(mockSupply.Object);
				Initialize_ReceiveBoon(card);
				var spec = new TableEntityCollection();
				var mockBoonSupply = new Mock<IBoonSupply>();
				var boon1 = new Mock<IBoon>();
				var boon2 = new Mock<IBoon>();
				var boon3 = new Mock<IBoon>();
				var boons = new ItemCollection<IBoon> { boon1.Object, boon2.Object, boon3.Object };
				mockPlayer.Setup(_ => _.TakeBoon(mockBoonSupply.Object, 3)).Returns(boons);
				spec.Add(TypeClass.Boons, mockBoonSupply.Object);
				mockTable.SetupGet(_ => _.SpecialPiles).Returns(spec);
				mockPlayer.SetupGet(_ => _.Takeables).Returns(new ItemCollection<ITakeable>());
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Boons))).Returns<Choice>(c => new ChoiceResult(new ItemCollection<IBoon>(c.Boons.First())));
				boon1.Setup(_ => _.Receive(mockPlayer.Object)).Returns(true);
				boon2.Setup(_ => _.Receive(mockPlayer.Object)).Returns(true);
				boon3.Setup(_ => _.Receive(mockPlayer.Object)).Returns(true);


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Take(TypeClass.LostInTheWoods), Times.Once);
				boon1.Verify(_ => _.Receive(mockPlayer.Object), Times.Once);
				mockPlayer.Verify(_ => _.ReturnBoon(mockBoonSupply.Object, boon1.Object), Times.Once);
				boon2.Verify(_ => _.Receive(mockPlayer.Object), Times.Once);
				mockPlayer.Verify(_ => _.ReturnBoon(mockBoonSupply.Object, boon2.Object), Times.Once);
				boon3.Verify(_ => _.Receive(mockPlayer.Object), Times.Once);
				mockPlayer.Verify(_ => _.ReturnBoon(mockBoonSupply.Object, boon3.Object), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Fool_Play_Already_Lost()
		{
			using (Card card = new Fool())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockTable.SetupGet(_ => _.Copper).Returns(mockSupply.Object);
				Initialize_ReceiveBoon(card);
				var spec = new TableEntityCollection();
				var mockBoonSupply = new Mock<IBoonSupply>();
				var boon1 = new Mock<IBoon>();
				var boon2 = new Mock<IBoon>();
				var boon3 = new Mock<IBoon>();
				var boons = new List<IBoon> { boon1.Object, boon2.Object, boon3.Object };
				spec.Add(TypeClass.Boons, mockBoonSupply.Object);
				mockTable.SetupGet(_ => _.SpecialPiles).Returns(spec);
				mockPlayer.SetupGet(_ => _.Takeables).Returns(new ItemCollection<ITakeable>(new LostInTheWoods()));
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Boons))).Returns<Choice>(c => new ChoiceResult(new ItemCollection<IBoon>(c.Boons.First())));


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Take(TypeClass.LostInTheWoods), Times.Never);
				boon1.Verify(_ => _.Receive(mockPlayer.Object), Times.Never);
				boon2.Verify(_ => _.Receive(mockPlayer.Object), Times.Never);
				boon3.Verify(_ => _.Receive(mockPlayer.Object), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Ghost_Basic()
		{
			using (var card = new Ghost())
			{
				Assert.AreEqual(new Cost(4, special: true), card.BaseCost);
				Assert.AreEqual(Categories.Card | Categories.Night | Categories.Duration | Categories.Spirit, card.Category);
			}
		}
		[TestMethod]
		public void Test_Ghost_Play_Found_Action()
		{
			var ghostedCard = new Bard();
			mockPlayer.SetupGet(_ => _.CanDraw).Returns(true);
			var revealed = new Deck(DeckLocation.Revealed, Visibility.All, VisibilityTo.All);
			mockPlayer.SetupGet(_ => _.Revealed).Returns(revealed);
			var setAside = new Deck(DeckLocation.SetAside, Visibility.All, VisibilityTo.All);
			mockPlayer.SetupGet(_ => _.SetAside).Returns(setAside);
			mockPlayer.Setup(_ => _.RetrieveCardsFrom(DeckLocation.Revealed)).Returns<DeckLocation>(dl => revealed.Retrieve(mockPlayer.Object, c => true));

			using (Card card = new Ghost())
			using (var deck = new Deck(DeckLocation.Deck, Visibility.None, VisibilityTo.All))
			{
				deck.AddRange(mockPlayer.Object, new List<Card> { ghostedCard });
				mockPlayer.Setup(_ => _.Draw(DeckLocation.Revealed)).Callback<DeckLocation>(dl => revealed.AddRange(mockPlayer.Object, new List<Card> { deck.Retrieve(mockPlayer.Object) }));


				card.FollowInstructions(mockPlayer.Object);


				Assert.IsFalse(card.CanCleanUp);
				Assert.IsFalse(card.IsStackable);
				Assert.AreEqual(2, card.Stack().Count);

				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.IsTrue(tseArgs.Resolvers.Any());

				tseArgs.Resolvers[tseArgs.Resolvers.Keys.First()].Method(mockPlayer.Object, ref tseArgs);

				mockPlayer.Verify(_ => _.PlayCard(ghostedCard, It.IsAny<PlayerMode>()), Times.Exactly(2));
				Assert.IsTrue(card.CanCleanUp);
			}
		}
		[TestMethod]
		public void Test_Ghost_Teardown()
		{
			using (var card = new Ghost())
			using (var deck = new Deck(DeckLocation.Deck, Visibility.None, VisibilityTo.All))
			{
				var ghostedCard = new Bard();
				deck.AddRange(mockPlayer.Object, new List<Card> { ghostedCard });
				mockPlayer.SetupGet(_ => _.CanDraw).Returns(true);
				var revealed = new Deck(DeckLocation.Revealed, Visibility.All, VisibilityTo.All);
				mockPlayer.SetupGet(_ => _.Revealed).Returns(revealed);
				mockPlayer.Setup(_ => _.Draw(DeckLocation.Revealed)).Callback<DeckLocation>(dl => revealed.AddRange(mockPlayer.Object, new List<Card> { deck.Retrieve(mockPlayer.Object) }));
				mockPlayer.Setup(_ => _.RetrieveCardsFrom(DeckLocation.Revealed)).Returns<DeckLocation>(dl => revealed.Retrieve(mockPlayer.Object, c => true));


				// Just sets the card in play
				card.FollowInstructions(mockPlayer.Object);
				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.IsTrue(tseArgs.Resolvers.Any());


				// Teardown -- example, at the end of the game before the player got a chance to use it
				card.TearDown(mockGame.Object);


				// Teardown at the end (Make sure event listener isn't listening any more)
				tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.IsFalse(tseArgs.Resolvers.ContainsKey(card.Name));
			}
		}
		[TestMethod]
		public void Test_Ghost_Endgame()
		{
			using (Card card = new Ghost())
			using (var deck = new Deck(DeckLocation.Deck, Visibility.None, VisibilityTo.All))
			{
				var ghostedCard = new Bard();
				deck.AddRange(mockPlayer.Object, new List<Card> { ghostedCard });
				mockPlayer.SetupGet(_ => _.CanDraw).Returns(true);
				var revealed = new Deck(DeckLocation.Revealed, Visibility.All, VisibilityTo.All);
				mockPlayer.SetupGet(_ => _.Revealed).Returns(revealed);
				mockPlayer.Setup(_ => _.Draw(DeckLocation.Revealed)).Callback<DeckLocation>(dl => revealed.AddRange(mockPlayer.Object, new List<Card> { deck.Retrieve(mockPlayer.Object) }));
				mockPlayer.Setup(_ => _.RetrieveCardsFrom(DeckLocation.Revealed)).Returns<DeckLocation>(dl => revealed.Retrieve(mockPlayer.Object, c => true));


				// Just sets the card in play
				card.FollowInstructions(mockPlayer.Object);
				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.IsTrue(tseArgs.Resolvers.Any());

				var points = new PointsCollection();
				card.PerformEndgameCalculations(mockPlayer.Object, points);
				card.TearDown(mockGame.Object);

				// Make sure the Ghost'ed card is returned
				Assert.AreEqual(1, points.Count);

				// Teardown at the end (Make sure event listener isn't listening)
				tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.AreEqual(0, tseArgs.Resolvers.Count);
			}
		}
		[TestMethod]
		public void Test_GhostTown_Basic()
		{
			using (var card = new GhostTown())
			{
				Assert.AreEqual(new Cost(3), card.BaseCost);
				Assert.AreEqual(1, card.DurationBenefit.Cards);
				Assert.AreEqual(1, card.DurationBenefit.Actions);
				Assert.AreEqual(Categories.Card | Categories.Night | Categories.Duration, card.Category);
			}
		}
		[TestMethod]
		public void Test_GhostTown_Gain()
		{
			using (Card card = new GhostTown())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					new Mock<IPlayer>().Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				card.SetupCard(mockGame.Object);


				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, card, new DominionBase.Cards.Base.Remodel(), DeckLocation.Discard, DeckPosition.Automatic, false);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsTrue(cgeArgs.Resolvers.ContainsKey(TypeClass.GhostTown.ToString()));

				cgeArgs.Resolvers[TypeClass.GhostTown.ToString()].Method(mockPlayer.Object, ref cgeArgs);
				Assert.IsTrue(cgeArgs.Cancelled);
				Assert.AreEqual(DeckLocation.Hand, cgeArgs.Location);
			}
		}
		[TestMethod]
		public void Test_GhostTown_Play()
		{
			using (Card card = new GhostTown())
			{
				card.FollowInstructions(mockPlayer.Object);


				Assert.IsFalse(card.CanCleanUp);

				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				var key = card.ToString();
				Assert.IsTrue(tseArgs.Resolvers.ContainsKey(key));

				tseArgs.Resolvers[key].Method(mockPlayer.Object, ref tseArgs);

				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards == 1 && cb.Actions == 1), It.IsAny<bool>()), Times.Once);
				Assert.IsTrue(card.CanCleanUp);
			}
		}
		[TestMethod]
		public void Test_GhostTown_Teardown()
		{
			using (Card card = new GhostTown())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					new Mock<IPlayer>().Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				card.SetupCard(mockGame.Object);


				card.FollowInstructions(mockPlayer.Object);
				card.TearDown(mockGame.Object);


				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, card, new DominionBase.Cards.Base.Remodel(), DeckLocation.Discard, DeckPosition.Automatic, false);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsFalse(cgeArgs.Resolvers.ContainsKey(TypeClass.GhostTown.ToString()));

				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				var key = card.ToString();
				Assert.IsFalse(tseArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Goat_Basic()
		{
			using (var card = new Goat())
			{
				Assert.AreEqual(new Cost(2), card.BaseCost);
				Assert.AreEqual(new Currency(1), card.Benefit.Currency);
				Assert.AreEqual(Categories.Card | Categories.Treasure | Categories.Heirloom, card.Category);
			}
		}
		[TestMethod]
		public void Test_Goat_Play()
		{
			using (Card card = new Goat())
			{
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>(new Cemetery())));


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Once);
				mockPlayer.Verify(_ => _.RetrieveCardsFrom(DeckLocation.Hand, It.IsAny<ItemCollection<Card>>()), Times.Once);
				mockPlayer.Verify(_ => _.Trash(card, It.IsAny<ItemCollection<Card>>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Goat_Play_Trashing_Optional()
		{
			using (Card card = new Goat())
			using (var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner))
			{
				hand.AddRange(mockPlayer.Object, new List<Card> { new Cemetery() });
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>()));


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.MakeChoice(It.Is<Choice>(c => c.Minimum == 0)), Times.Once);
				mockPlayer.Verify(_ => _.RetrieveCardsFrom(DeckLocation.Hand, It.IsAny<ItemCollection<Card>>()), Times.Never);
				mockPlayer.Verify(_ => _.Trash(It.IsAny<IGameObject>(), It.IsAny<ItemCollection<Card>>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Greed_Basic()
		{
			using (var card = new Greed())
			{
				Assert.AreEqual(Categories.Hex, card.Category);
			}
		}
		[TestMethod]
		public void Test_Greed_Receive()
		{
			using (Hex card = new Greed())
			{
				mockTable.SetupGet(_ => _.Copper).Returns(mockSupply.Object);


				card.Receive(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, DeckLocation.Deck, It.IsAny<DeckPosition>(), 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Guardian_Basic()
		{
			using (var card = new Guardian())
			{
				Assert.AreEqual(new Cost(2), card.BaseCost);
				Assert.AreEqual(new Currency(1), card.DurationBenefit.Currency);
				Assert.AreEqual(Categories.Card | Categories.Night | Categories.Duration, card.Category);
			}
		}
		[TestMethod]
		public void Test_Guardian_Gain()
		{
			using (Card card = new Guardian())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					new Mock<IPlayer>().Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				card.SetupCard(mockGame.Object);


				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, card, new DominionBase.Cards.Base.Remodel(), DeckLocation.Discard, DeckPosition.Automatic, false);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsTrue(cgeArgs.Resolvers.ContainsKey(TypeClass.Guardian.ToString()));

				cgeArgs.Resolvers[TypeClass.Guardian.ToString()].Method(mockPlayer.Object, ref cgeArgs);
				Assert.IsTrue(cgeArgs.Cancelled);
				Assert.AreEqual(DeckLocation.Hand, cgeArgs.Location);
			}
		}
		[TestMethod]
		public void Test_Guardian_Play_Duration_Benefit()
		{
			using (Card card = new Guardian())
			{
				var mockAttacker = new Mock<IPlayer>();
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockAttacker.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				card.SetupCard(mockGame.Object);
				Assert.IsTrue(card.CanCleanUp);


				card.FollowInstructions(mockPlayer.Object);


				Assert.IsFalse(card.CanCleanUp);
				var tseArgs = new TurnStartedEventArgs(mockAttacker.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				var key = card.ToString();
				Assert.IsTrue(tseArgs.Resolvers.ContainsKey(key));

				tseArgs.Resolvers[key].Method(mockPlayer.Object, ref tseArgs);
				Assert.IsTrue(card.CanCleanUp);
			}
		}
		[TestMethod]
		public void Test_Guardian_Play_Protected()
		{
			using (Card card = new Guardian())
			{
				var mockAttacker = new Mock<IPlayer>();
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockAttacker.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				card.SetupCard(mockGame.Object);
				Assert.IsTrue(card.CanCleanUp);


				card.FollowInstructions(mockPlayer.Object);


				Assert.IsFalse(card.CanCleanUp);
				var aeArgs = new AttackedEventArgs(mockAttacker.Object, new Vampire());
				mockPlayer.Raise(_ => _.Attacked += null, aeArgs);

				Assert.IsTrue(aeArgs.Cancelled);
				mockGame.Verify(_ => _.SendMessage(mockPlayer.Object, card), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Guardian_Teardown()
		{
			using (Card card = new Guardian())
			{
				var mockAttacker = new Mock<IPlayer>();
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockAttacker.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				card.SetupCard(mockGame.Object);


				card.FollowInstructions(mockPlayer.Object);
				card.TearDown(mockGame.Object);


				var aeArgs = new AttackedEventArgs(mockAttacker.Object, new Vampire());
				mockPlayer.Raise(_ => _.Attacked += null, aeArgs);
				Assert.IsFalse(aeArgs.Cancelled);

				var tseArgs = new TurnStartedEventArgs(mockAttacker.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				var key = card.ToString();
				Assert.IsFalse(tseArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_HauntedMirror_Basic()
		{
			using (var card = new HauntedMirror())
			{
				Assert.AreEqual(new Cost(0), card.BaseCost);
				Assert.AreEqual(new Currency(1), card.Benefit.Currency);
				Assert.AreEqual(Categories.Card | Categories.Treasure | Categories.Heirloom, card.Category);
			}
		}
		[TestMethod]
		public void Test_HauntedMirror_Setup()
		{
			using (Card card = new HauntedMirror())
			{
				var mockOther = new Mock<IPlayer>();
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockOther.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				// SpecialPiles should maybe be mocked as well??
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

				card.SetupCard(mockGame.Object);

				Assert.IsTrue(specialPiles.ContainsKey(TypeClass.Ghost));
			}
		}
		[TestMethod]
		public void Test_HauntedMirror_Trashed_Nothing_Discardable()
		{
			using (Card card = new HauntedMirror())
			{

				// SpecialPiles should maybe be mocked as well??
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);
				var mockAttacker = new Mock<IPlayer>();
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockAttacker.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>()));
				mockPlayer.SetupGet(_ => _.Hand).Returns(new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner));

				card.SetupCard(mockGame.Object);
				card.SetupSupply(mockGame.Object, mockSupply.Object);


				var teArgs = new TrashEventArgs(mockPlayer.Object, new Cemetery(), new ItemCollection<Card>(card));
				mockPlayer.Raise(_ => _.Trashed += null, teArgs);
				Assert.IsTrue(teArgs.Resolvers.ContainsKey(TypeClass.HauntedMirror));

				teArgs.Resolvers[TypeClass.HauntedMirror].Method(mockPlayer.Object, ref teArgs);
				mockPlayer.Verify(_ => _.Discard(DeckLocation.Hand, It.IsAny<ItemCollection<Card>>(), It.IsAny<CardsDiscardResolver>()), Times.Never);
				mockPlayer.Verify(_ => _.Gain(It.IsAny<ISupply>(), It.IsAny<IGameObject>(), It.IsAny<int>(), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_HauntedMirror_Trashed_Discard_Action()
		{
			using (Card card = new HauntedMirror())
			{

				// SpecialPiles should maybe be mocked as well??
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);
				var mockAttacker = new Mock<IPlayer>();
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockAttacker.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				var toDiscard = new ItemCollection<Card>(new Bard());
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(toDiscard));
				mockPlayer.SetupGet(_ => _.Hand).Returns(new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner));

				card.SetupCard(mockGame.Object);
				card.SetupSupply(mockGame.Object, mockSupply.Object);
				mockTable.Setup(_ => _[TypeClass.Ghost]).Returns(specialPiles[TypeClass.Ghost]);


				var teArgs = new TrashEventArgs(mockPlayer.Object, new Cemetery(), new ItemCollection<Card>(card));
				mockPlayer.Raise(_ => _.Trashed += null, teArgs);
				Assert.IsTrue(teArgs.Resolvers.ContainsKey(TypeClass.HauntedMirror));

				teArgs.Resolvers[TypeClass.HauntedMirror].Method(mockPlayer.Object, ref teArgs);
				mockPlayer.Verify(_ => _.Discard(DeckLocation.Hand, toDiscard, null), Times.Once);
				mockPlayer.Verify(_ => _.Gain(It.Is<ISupply>(s => s.Type == TypeClass.Ghost), card, 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_HauntedMirror_Teardown()
		{
			using (Card card = new HauntedMirror())
			{
				var mockAttacker = new Mock<IPlayer>();
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockAttacker.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				// SpecialPiles should maybe be mocked as well??
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

				card.SetupCard(mockGame.Object);
				card.SetupSupply(mockGame.Object, mockSupply.Object);


				card.TearDown(mockGame.Object);


				var teArgs = new TrashEventArgs(mockPlayer.Object, new Cemetery(), new ItemCollection<Card>(card));
				mockPlayer.Raise(_ => _.Trashed += null, teArgs);
				Assert.IsFalse(teArgs.Resolvers.ContainsKey(TypeClass.HauntedMirror));
			}
		}
		[TestMethod]
		public void Test_Haunting_Basic()
		{
			using (var card = new Haunting())
			{
				Assert.AreEqual(Categories.Hex, card.Category);
			}
		}
		[TestMethod]
		public void Test_Haunting_Receive_TooFewCards()
		{
			using (Hex card = new Haunting())
			{
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				hand.AddRange(mockPlayer.Object, new List<Card> { new Bard(), new Cemetery(), new Bat() });
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);


				card.Receive(mockPlayer.Object);


				mockPlayer.Verify(_ => _.RetrieveCardsFrom(DeckLocation.Hand, It.IsAny<ItemCollection<Card>>()), Times.Never);
				mockPlayer.Verify(_ => _.AddCardsToDeck(It.IsAny<ItemCollection<Card>>(), It.IsAny<DeckPosition>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Haunting_Receive_PutBack()
		{
			using (Hex card = new Haunting())
			{
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				hand.AddRange(mockPlayer.Object, new List<Card> { new Bard(), new Cemetery(), new Bat(), new HauntedMirror(), new CursedGold() });
				var toDiscard = new ItemCollection<Card>(hand.First());
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(toDiscard));


				card.Receive(mockPlayer.Object);


				mockPlayer.Verify(_ => _.RetrieveCardsFrom(DeckLocation.Hand, toDiscard), Times.Once);
				mockPlayer.Verify(_ => _.AddCardsToDeck(toDiscard, DeckPosition.Top), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Hexes_Basic()
		{
			using (var supply = new Hexes(mockGame.Object))
			{
				supply.Setup();

				Assert.AreEqual(Categories.Hex, supply.Category);
				Assert.AreEqual(12, supply.Count);
			}
		}
		[TestMethod]
		public void Test_Idol_Basic()
		{
			using (var card = new Idol())
			{
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(new Currency(2), card.Benefit.Currency);
				Assert.AreEqual(Categories.Card | Categories.Treasure | Categories.Attack | Categories.Fate, card.Category);
			}
		}
		[TestMethod]
		public void Test_Idol_Setup()
		{
			using (Card card = new Idol())
			{

				// SpecialPiles should maybe be mocked as well??
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

				card.SetupSupply(mockGame.Object, mockSupply.Object);

				Assert.IsTrue(specialPiles.ContainsKey(TypeClass.Boons));
			}
		}
		[TestMethod]
		public void Test_Idol_Play_Odd()
		{
			using (Card card = new Idol())
			{

				Initialize_ReceiveBoon(card);

				var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
				mockPlayer.SetupGet(_ => _.InPlayAndSetAside).Returns(new DeckCollection(inPlay));

				card.SetupSupply(mockGame.Object, mockSupply.Object);
				var mockBoons = new Mock<IBoonSupply>();
				mockTable.Setup(_ => _[TypeClass.Boons]).Returns(mockBoons.Object);


				inPlay.AddRange(mockPlayer.Object, new List<Card> { card });
				card.FollowInstructions(mockPlayer.Object);
			}
		}
		[TestMethod]
		public void Test_Idol_Play_Even()
		{
			using (Card card = new Idol())
			{

				Initialize_ReceiveBoon(card);
				var mockAttackee = new Mock<IPlayer>();
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockAttackee.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockGame.Setup(_ => _.GetPlayersStartingWithEnumerator(mockPlayer.Object)).Returns<IPlayer>(x => { var y = players.GetPlayersStartingWithEnumerator(x); return y; });
				mockTable.SetupGet(_ => _.Curse).Returns(mockSupply.Object);
				mockAttackee.Setup(_ => _.AttackedByPlayerAllowed(mockPlayer.Object, card)).Returns(true);

				var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
				mockPlayer.SetupGet(_ => _.InPlayAndSetAside).Returns(new DeckCollection(inPlay));
				mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.BuyTreasure);

				card.SetupSupply(mockGame.Object, mockSupply.Object);
				var mockBoons = new Mock<IBoonSupply>();
				mockTable.Setup(_ => _[TypeClass.Boons]).Returns(mockBoons.Object);


				inPlay.AddRange(mockPlayer.Object, new List<Card> { new Idol(), card });
				// Sets up the IsAttackBlocked dictionary properly
				card.PlaySetup(mockPlayer.Object);
				card.FollowInstructions(mockPlayer.Object);


				mockAttackee.Verify(_ => _.Gain(mockSupply.Object, card, 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Imp_Basic()
		{
			using (var card = new Imp())
			{
				Assert.AreEqual(new Cost(2, special: true), card.BaseCost);
				Assert.AreEqual(2, card.Benefit.Cards);
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Spirit, card.Category);
			}
		}
		[TestMethod]
		public void Test_Imp_Play_NoAvailable()
		{
			using (Card card = new Imp())
			{
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				mockPlayer.SetupGet(_ => _.InPlayAndSetAside).Returns(new DeckCollection(inPlay));
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>()));


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.PlayCard(It.IsAny<Card>(), It.IsAny<PlayerMode>()), Times.Never);
				mockPlayer.Verify(_ => _.PlayNothing(It.IsAny<string>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Imp_Play_Card()
		{
			using (Card card = new Imp())
			{
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				mockPlayer.SetupGet(_ => _.InPlayAndSetAside).Returns(new DeckCollection(inPlay));
				var otherCard = new Bard();
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>(otherCard)));


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.PutCardIntoPlay(otherCard, It.IsAny<string>()), Times.Once);
				mockPlayer.Verify(_ => _.PlayCard(otherCard, It.IsAny<PlayerMode>()), Times.Once);
				mockPlayer.Verify(_ => _.PlayNothing(It.IsAny<string>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Leprechaun_Basic()
		{
			using (var card = new Leprechaun())
			{
				Assert.AreEqual(new Cost(3), card.BaseCost);
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Doom, card.Category);
			}
		}
		[TestMethod]
		public void Test_Leprechaun_Setup()
		{
			using (Card card = new Leprechaun())
			{

				// SpecialPiles should maybe be mocked as well??
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

				card.SetupSupply(mockGame.Object, mockSupply.Object);

				Assert.IsTrue(specialPiles.ContainsKey(TypeClass.Hexes));
				Assert.IsTrue(specialPiles.ContainsKey(TypeClass.Wish));
			}
		}
		[TestMethod]
		public void Test_Leprechaun_Play_Not7Cards()
		{
			using (Card card = new Leprechaun())
			{
				Initialize_ReceiveHex(card);
				var mockSupplyGold = new Mock<ISupply>();
				mockTable.SetupGet(_ => _.Gold).Returns(mockSupplyGold.Object);
				var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
				mockPlayer.SetupGet(_ => _.InPlayAndSetAside).Returns(new DeckCollection(inPlay));

				card.SetupSupply(mockGame.Object, mockSupply.Object);


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(mockSupplyGold.Object, card, 1, false), Times.Once);
				mockPlayer.Verify(_ => _.Gain((ISupply)mockTable.Object.SpecialPiles[TypeClass.Wish], It.IsAny<IGameObject>(), 1, false), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Leprechaun_Play_7Cards()
		{
			using (Card card = new Leprechaun())
			{
				Initialize_ReceiveHex(card);
				var mockSupplyGold = new Mock<ISupply>();
				mockTable.SetupGet(_ => _.Gold).Returns(mockSupplyGold.Object);
				var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
				inPlay.AddRange(mockPlayer.Object, new List<Card> { new Bard(), new Bard(), new Bard(), new Bard(), new Bard(), new Bard(), card });
				mockPlayer.SetupGet(_ => _.InPlayAndSetAside).Returns(new DeckCollection(inPlay));

				card.SetupSupply(mockGame.Object, mockSupply.Object);


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(mockSupplyGold.Object, card, 1, false), Times.Once);
				mockPlayer.Verify(_ => _.Gain((ISupply)mockTable.Object.SpecialPiles[TypeClass.Wish], card, 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Locusts_Basic()
		{
			using (var card = new Locusts())
			{
				Assert.AreEqual(Categories.Hex, card.Category);
			}
		}
		[TestMethod]
		public void Test_Locusts_Receive_NoCards()
		{
			using (Hex card = new Locusts())
			{
				mockPlayer.SetupGet(_ => _.CanDraw).Returns(false);


				card.Receive(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Draw(It.IsAny<DeckLocation>()), Times.Never);
				mockPlayer.Verify(_ => _.Trash(It.IsAny<IGameObject>(), It.IsAny<Card>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Locusts_Receive_TrashCopper()
		{
			using (Hex card = new Locusts())
			{
				var supplyCurse = new Mock<ISupply>();
				mockTable.Setup(_ => _.Curse).Returns(supplyCurse.Object);
				mockPlayer.SetupGet(_ => _.CanDraw).Returns(true);
				var cardToTrash = new DominionBase.Cards.Universal.Copper();
				mockPlayer.Setup(_ => _.Draw(DeckLocation.Revealed)).Returns(cardToTrash);


				card.Receive(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Draw(DeckLocation.Revealed), Times.Once);
				mockPlayer.Verify(_ => _.Trash(card, cardToTrash), Times.Once);
				mockPlayer.Verify(_ => _.Gain(supplyCurse.Object, card, 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Locusts_Receive_TrashOther()
		{
			using (Hex card = new Locusts())
			{
				var supplyCurse = new Mock<ISupply>();
				mockTable.Setup(_ => _.Curse).Returns(supplyCurse.Object);
				var mockCostBard = new Mock<ICost>();
				mockSupply.SetupGet(_ => _.TopCard).Returns(mockCostBard.Object);
				mockCostBard.SetupGet(_ => _.Category).Returns(Categories.Card | Categories.Action | Categories.Fate);
				var otherSupply = new Mock<ISupply>();
				var mockCostIdol = new Mock<ICost>();
				otherSupply.SetupGet(_ => _.TopCard).Returns(mockCostIdol.Object);
				mockCostIdol.SetupGet(_ => _.Category).Returns(Categories.Card | Categories.Treasure | Categories.Attack | Categories.Fate);
				var supplies = new TableEntityCollection
				{
					{ TypeClass.Bard, mockSupply.Object },
					{ TypeClass.Idol, otherSupply.Object }
				};
				mockTable.SetupGet(_ => _.TableEntities).Returns(supplies);
				mockPlayer.SetupGet(_ => _.CanDraw).Returns(true);
				var cardToTrash = new DominionBase.Cards.Universal.Gold();
				mockPlayer.Setup(_ => _.Draw(DeckLocation.Revealed)).Returns(cardToTrash);
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(otherSupply.Object));


				card.Receive(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Draw(DeckLocation.Revealed), Times.Once);
				mockPlayer.Verify(_ => _.Trash(card, cardToTrash), Times.Once);
				mockPlayer.Verify(_ => _.Gain(supplyCurse.Object, It.IsAny<IGameObject>(), It.IsAny<int>(), It.IsAny<bool>()), Times.Never);
				mockPlayer.Verify(_ => _.Gain(otherSupply.Object, card, 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_LostInTheWoods_Basic()
		{
			using (var card = new LostInTheWoods())
			{
				Assert.AreEqual(Categories.State, card.Category);
				Assert.IsFalse(card.CanBeMultiples);
			}
		}
		[TestMethod]
		public void Test_LostInTheWoods_Taken()
		{
			using (State card = new LostInTheWoods())
			{


				card.TakenBy(mockPlayer.Object);


				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				var key = card.ToString();
				Assert.IsTrue(tseArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_LostInTheWoods_Returned()
		{
			using (State card = new LostInTheWoods())
			{


				card.TakenBy(mockPlayer.Object);
				card.ReturnedBy(mockPlayer.Object);


				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				var key = card.ToString();
				Assert.IsFalse(tseArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_LostInTheWoods_TurnStarted()
		{
			using (State state = new LostInTheWoods())
			using (Card card = new Fool())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockTable.SetupGet(_ => _.Copper).Returns(mockSupply.Object);
				Initialize_ReceiveBoon(card);
				card.SetupSupply(mockGame.Object, mockSupply.Object);
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(x => x.Source == state && x.ChoiceType == ChoiceType.Cards))).Returns(new ChoiceResult(new ItemCollection<Card> { new Cemetery() }));


				state.TakenBy(mockPlayer.Object);


				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				var key = state.ToString();
				Assert.IsTrue(tseArgs.Resolvers.ContainsKey(key));

				tseArgs.Resolvers[key].Method(mockPlayer.Object, ref tseArgs);

				mockPlayer.Verify(_ => _.Discard(DeckLocation.Hand, It.IsAny<IEnumerable<Card>>(), null), Times.Once);
			}
		}
		[TestMethod]
		public void Test_LostInTheWoods_Teardown()
		{
			using (State card = new LostInTheWoods())
			{
				card.TakenBy(mockPlayer.Object);

				card.TearDown(mockGame.Object);

				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				var key = card.ToString();
				Assert.IsFalse(tseArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_LuckyCoin_Basic()
		{
			using (var card = new LuckyCoin())
			{
				Assert.AreEqual(new Cost(4), card.BaseCost);
				Assert.AreEqual(new Currency(1), card.Benefit.Currency);
				Assert.AreEqual(Categories.Card | Categories.Treasure | Categories.Heirloom, card.Category);
			}
		}
		[TestMethod]
		public void Test_LuckyCoin_Play()
		{
			using (Card card = new LuckyCoin())
			{
				mockTable.SetupGet(_ => _.Silver).Returns(mockSupply.Object);


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_MagicLamp_Basic()
		{
			using (var card = new MagicLamp())
			{
				Assert.AreEqual(new Cost(0), card.BaseCost);
				Assert.AreEqual(new Currency(1), card.Benefit.Currency);
				Assert.AreEqual(Categories.Card | Categories.Treasure | Categories.Heirloom, card.Category);
			}
		}
		[TestMethod]
		public void Test_MagicLamp_Setup()
		{
			using (Card card = new MagicLamp())
			{

				// SpecialPiles should maybe be mocked as well??
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

				card.SetupCard(mockGame.Object);

				Assert.IsTrue(specialPiles.ContainsKey(TypeClass.Wish));
			}
		}
		[TestMethod]
		public void Test_MagicLamp_Play_NotTriggered()
		{
			using (Card card = new MagicLamp())
			{
				// SpecialPiles should maybe be mocked as well??
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);
				var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
				mockPlayer.SetupGet(_ => _.InPlayAndSetAside).Returns(new DeckCollection(inPlay));

				card.SetupCard(mockGame.Object);


				inPlay.AddRange(mockPlayer.Object, new List<Card> { card });
				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain((ISupply)specialPiles[TypeClass.Wish], It.IsAny<IGameObject>(), 3, false), Times.Never);
			}
		}
		[TestMethod]
		public void Test_MagicLamp_Play_Triggered()
		{
			using (Card card = new MagicLamp())
			{
				// SpecialPiles should maybe be mocked as well??
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);
				var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
				inPlay.AddRange(mockPlayer.Object, new List<Card> { new Bard(), new Imp(), new LuckyCoin(), new Conclave(), new BlessedVillage() });
				mockPlayer.SetupGet(_ => _.InPlay).Returns(inPlay);
				mockPlayer.SetupGet(_ => _.InPlayAndSetAside).Returns(new DeckCollection(inPlay));

				card.SetupCard(mockGame.Object);


				inPlay.AddRange(mockPlayer.Object, new List<Card> { card });
				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.RetrieveCardFrom(DeckLocation.InPlay, card), Times.Once);
				mockPlayer.Verify(_ => _.Trash(card, card), Times.Once);
				mockPlayer.Verify(_ => _.Gain((ISupply)specialPiles[TypeClass.Wish], card, 3, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Miserable_Basic()
		{
			using (var card = new Miserable())
			{
				Assert.AreEqual(Categories.State, card.Category);
				Assert.AreEqual(-2, card.VictoryPoints);
			}
		}
		[TestMethod]
		public void Test_Misery_Basic()
		{
			using (var card = new Misery())
			{
				Assert.AreEqual(Categories.Hex, card.Category);
			}
		}
		[TestMethod]
		public void Test_Misery_Receive()
		{
			using (Hex card = new Misery())
			{

				var takeables = new ItemCollection<ITakeable>();
				mockPlayer.SetupGet(_ => _.Takeables).Returns(takeables);


				card.Receive(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Take(TypeClass.Miserable), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Misery_Receive_Miserable()
		{
			using (Hex card = new Misery())
			{
				var takeables = new ItemCollection<ITakeable>
				{
					new Deluded(),
					new Miserable()
				};
				mockPlayer.SetupGet(_ => _.Takeables).Returns(takeables);


				card.Receive(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Take(TypeClass.Miserable), Times.Never);
				mockPlayer.Verify(_ => _.Return(TypeClass.Miserable), Times.Once);
				mockPlayer.Verify(_ => _.Take(TypeClass.TwiceMiserable), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Misery_Receive_TwiceMiserable()
		{
			using (Hex card = new Misery())
			{
				var takeables = new ItemCollection<ITakeable>
				{
					new Deluded(),
					new TwiceMiserable()
				};
				mockPlayer.SetupGet(_ => _.Takeables).Returns(takeables);


				card.Receive(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Take(TypeClass.Miserable), Times.Never);
				mockPlayer.Verify(_ => _.Return(TypeClass.Miserable), Times.Never);
				mockPlayer.Verify(_ => _.Take(TypeClass.TwiceMiserable), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Monastery_Basic()
		{
			using (var card = new Monastery())
			{
				Assert.AreEqual(new Cost(2), card.BaseCost);
				Assert.AreEqual(Categories.Card | Categories.Night, card.Category);
			}
		}
		[TestMethod]
		public void Test_Monastery_Play_NoTrashing()
		{
			using (Card card = new Monastery())
			{
				var turn = new Turn(mockPlayer.Object);
				mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(turn);


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Never);
				mockPlayer.Verify(_ => _.Trash(It.IsAny<IGameObject>(), It.IsAny<Card>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Monastery_Play_CanTrash()
		{
			using (Card card = new Monastery())
			{
				var turn = new Turn(mockPlayer.Object);
				turn.CardsGained.AddRange(new List<Card> { new Crypt(), new DenOfSin(), new Cemetery() });
				mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(turn);
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				var copper = new DominionBase.Cards.Universal.Copper();
				hand.AddRange(mockPlayer.Object, new List<Card> { copper });
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
				mockPlayer.SetupGet(_ => _.InPlayAndSetAside).Returns(new DeckCollection(inPlay));
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>(copper)));


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.RetrieveCardFrom(DeckLocation.Hand, copper), Times.Exactly(3));
				mockPlayer.Verify(_ => _.Trash(card, copper), Times.Exactly(3));
			}
		}
		[TestMethod]
		public void Test_Necromancer_Basic()
		{
			using (Card card = new Necromancer())
			{
				Assert.AreEqual(new Cost(4), card.BaseCost);
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
			}
		}
		[TestMethod]
		public void Test_Necromancer_Setup()
		{
			using (Card card = new Necromancer())
			{
				var trash = new Trash();
				mockTable.Setup(_ => _.Trash).Returns(trash);

				card.Finalize(mockGame.Object, mockSupply.Object);

				Assert.AreEqual(1, trash[TypeClass.ZombieApprentice].Count);
				Assert.AreEqual(1, trash[TypeClass.ZombieMason].Count);
				Assert.AreEqual(1, trash[TypeClass.ZombieSpy].Count);
			}
		}
		[TestMethod]
		public void Test_Necromancer_Play_Nothing()
		{
			using (Card card = new Necromancer())
			{
				var trash = new Trash();
				mockTable.Setup(_ => _.Trash).Returns(trash);
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>()));
				card.Finalize(mockGame.Object, mockSupply.Object);


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.PlayCard(It.IsAny<Card>(), It.IsAny<PlayerMode>()), Times.Never);
				mockPlayer.Verify(_ => _.PlayNothing(It.IsAny<string>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Necromancer_Play_Card()
		{
			using (Card card = new Necromancer())
			{
				var bard = new Bard();
				var trash = new Trash { bard };
				mockTable.Setup(_ => _.Trash).Returns(trash);
				card.Finalize(mockGame.Object, mockSupply.Object);
				var zombie = trash[TypeClass.ZombieSpy].FirstOrDefault();
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>(zombie)));
				mockPlayer.Setup(_ => _.FlipFaceDown(It.IsAny<ICard>())).Returns<ICard>(c =>
				{
					c.FlipFaceDown(mockPlayer.Object);
					return Facing.FaceDown;
				});


				card.FollowInstructions(mockPlayer.Object);


				Assert.AreEqual(Facing.FaceUp, bard.Facing);
				mockPlayer.Verify(_ => _.FlipFaceDown(zombie), Times.Once);
				mockPlayer.Verify(_ => _.PlayCard(zombie, It.IsAny<PlayerMode>()), Times.Once);
				mockPlayer.Verify(_ => _.PlayNothing(It.IsAny<string>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Necromancer_Play_Cannot_Select_Self()
		{
			using (Card card = new Necromancer())
			{
				var trash = new Trash { card };
				mockTable.Setup(_ => _.Trash).Returns(trash);
				card.Finalize(mockGame.Object, mockSupply.Object);
				var zombie = trash[TypeClass.ZombieSpy].FirstOrDefault();
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>(zombie)));
				mockPlayer.Setup(_ => _.FlipFaceDown(It.IsAny<ICard>())).Returns<ICard>(c =>
				{
					c.FlipFaceDown(mockPlayer.Object);
					return Facing.FaceDown;
				});


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.MakeChoice(It.Is<Choice>(choice => choice.Cards.Any(c => c == card))), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Necromancer_End_Of_Turn()
		{
			using (Card card = new Necromancer())
			{
				var trash = new Trash();
				var bard = new Bard();
				trash.Add(bard);
				mockTable.Setup(_ => _.Trash).Returns(trash);
				card.Finalize(mockGame.Object, mockSupply.Object);
				var zombie = trash[TypeClass.ZombieSpy].FirstOrDefault();
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card> { bard }));
				mockPlayer.Setup(_ => _.FlipFaceDown(It.IsAny<ICard>())).Returns<ICard>(c =>
				{
					c.FlipFaceDown(mockPlayer.Object);
					return Facing.FaceDown;
				});
				mockPlayer.Setup(_ => _.FlipFaceUp(It.IsAny<ICard>())).Returns<ICard>(c =>
				{
					c.FlipFaceUp(mockPlayer.Object);
					return Facing.FaceUp;
				});


				card.FollowInstructions(mockPlayer.Object);


				var teeArgs = new TurnEndedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnEnded += null, teeArgs);

				mockPlayer.Verify(_ => _.FlipFaceDown(bard), Times.Once);
				mockPlayer.Verify(_ => _.PlayCard(bard, It.IsAny<PlayerMode>()), Times.Once);
				mockPlayer.Verify(_ => _.FlipFaceUp(bard), Times.Once);
				Assert.AreEqual(Facing.FaceUp, bard.Facing);
			}
		}
		[TestMethod]
		public void Test_NightWatchman_Basic()
		{
			using (var card = new NightWatchman())
			{
				Assert.AreEqual(new Cost(3), card.BaseCost);
				Assert.AreEqual(Categories.Card | Categories.Night, card.Category);
			}
		}
		[TestMethod]
		public void Test_NightWatchman_Gain()
		{
			using (Card card = new NightWatchman())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					new Mock<IPlayer>().Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				card.SetupCard(mockGame.Object);


				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, card, new DominionBase.Cards.Base.Remodel(), DeckLocation.Discard, DeckPosition.Automatic, false);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsTrue(cgeArgs.Resolvers.ContainsKey(TypeClass.NightWatchman.ToString()));

				cgeArgs.Resolvers[TypeClass.NightWatchman.ToString()].Method(mockPlayer.Object, ref cgeArgs);
				Assert.IsTrue(cgeArgs.Cancelled);
				Assert.AreEqual(DeckLocation.Hand, cgeArgs.Location);
			}
		}
		[TestMethod]
		public void Test_NightWatchman_Play()
		{
			using (Card card = new NightWatchman())
			{
				mockPlayer.Setup(_ => _.Draw(5, DeckLocation.Private)).Returns(new ItemCollection<Card>());
				var priv = new Deck(DeckLocation.Private, Visibility.All, VisibilityTo.Owner);
				mockPlayer.SetupGet(_ => _.Private).Returns(priv);
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => !c.IsOrdered))).Returns(new ChoiceResult(new ItemCollection<Card>()));
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.IsOrdered))).Returns(new ChoiceResult(new ItemCollection<Card>()));


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Draw(5, DeckLocation.Private), Times.Once);
				mockPlayer.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Exactly(2));
				mockPlayer.Verify(_ => _.Discard(DeckLocation.Private, It.IsAny<ItemCollection<Card>>(), null), Times.Once);
				mockPlayer.Verify(_ => _.AddCardsToDeck(It.IsAny<ItemCollection<Card>>(), DeckPosition.Top), Times.Once);
			}
		}
		[TestMethod]
		public void Test_NightWatchman_Teardown()
		{
			using (Card card = new NightWatchman())
			{
				mockPlayer.Setup(_ => _.Draw(5, DeckLocation.Private)).Returns(new ItemCollection<Card>());
				var priv = new Deck(DeckLocation.Private, Visibility.All, VisibilityTo.Owner);
				mockPlayer.SetupGet(_ => _.Private).Returns(priv);
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => !c.IsOrdered))).Returns(new ChoiceResult(new ItemCollection<Card>()));
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.IsOrdered))).Returns(new ChoiceResult(new ItemCollection<Card>()));

				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					new Mock<IPlayer>().Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				card.SetupCard(mockGame.Object);


				card.FollowInstructions(mockPlayer.Object);
				card.TearDown(mockGame.Object);


				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, card, new DominionBase.Cards.Base.Remodel(), DeckLocation.Discard, DeckPosition.Automatic, false);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsFalse(cgeArgs.Resolvers.ContainsKey(TypeClass.NightWatchman.ToString()));
			}
		}
		[TestMethod]
		public void Test_Pasture_Basic()
		{
			using (var card = new Pasture())
			{
				Assert.AreEqual(new Cost(2), card.BaseCost);
				Assert.AreEqual(new Currency(1), card.Benefit.Currency);
				Assert.AreEqual(Categories.Card | Categories.Treasure | Categories.Victory | Categories.Heirloom, card.Category);
			}
		}
		[TestMethod]
		public void Test_Pasture_VP_Count()
		{
			using (Card card = new Pasture())
			{
				var result = card.ComputeVictoryPoints(mockPlayer.Object, new List<IPoints> {
					new DominionBase.Cards.Universal.Estate(),
					new DominionBase.Cards.Universal.Estate(),
					new DominionBase.Cards.Universal.Estate(),
					new Cemetery(),
					new DominionBase.Cards.Universal.Estate(),
					new DominionBase.Cards.Universal.Estate(),
				});


				Assert.AreEqual(5, result);
			}
		}
		[TestMethod]
		public void Test_Pixie_Basic()
		{
			using (var card = new Pixie())
			{
				Assert.AreEqual(new Cost(2), card.BaseCost);
				Assert.AreEqual(1, card.Benefit.Cards);
				Assert.AreEqual(1, card.Benefit.Actions);
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Fate, card.Category);
			}
		}
		[TestMethod]
		public void Test_Pixie_Setup()
		{
			using (Card card = new Pixie())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				// SpecialPiles should maybe be mocked as well??
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);
				mockTable.SetupGet(_ => _.Copper).Returns(mockSupply.Object);


				card.SetupSupply(mockGame.Object, mockSupply.Object);


				Assert.IsTrue(specialPiles.ContainsKey(TypeClass.Boons));
				mockSupply.Verify(_ => _.AddTo(It.IsAny<Goat>(), 0), Times.AtLeastOnce);
			}
		}
		[TestMethod]
		public void Test_Pixie_Play_NoTrash()
		{
			using (Card card = new Pixie())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockTable.SetupGet(_ => _.Copper).Returns(mockSupply.Object);
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new List<string> { ResourcesHelper.Get("No") }));
				var mockBoonSupply = new Mock<IBoonSupply>();
				var spec = new TableEntityCollection() { { TypeClass.Boons, mockBoonSupply.Object } };
				mockTable.Setup(_ => _.SpecialPiles).Returns(spec);
				mockBoonSupply.Setup(_ => _.TurnOverNext(mockPlayer.Object)).Returns(true);
				var mockBoon = new Mock<IBoon>();
				mockBoonSupply.SetupGet(_ => _.TopDiscard).Returns(mockBoon.Object);


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Trash(It.IsAny<IGameObject>(), It.IsAny<Card>()), Times.Never);
				mockBoon.Verify(_ => _.Receive(mockPlayer.Object), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Pixie_Play_Trash()
		{
			using (Card card = new Pixie())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockTable.SetupGet(_ => _.Copper).Returns(mockSupply.Object);
				Initialize_ReceiveBoon(card);
				var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
				mockPlayer.SetupGet(_ => _.InPlay).Returns(inPlay);
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options && c.Source == card))).Returns(new ChoiceResult(new List<string> { ResourcesHelper.Get("Yes") }));
				var mockBoonSupply = new Mock<IBoonSupply>();
				var spec = new TableEntityCollection() { { TypeClass.Boons, mockBoonSupply.Object } };
				mockTable.Setup(_ => _.SpecialPiles).Returns(spec);
				mockBoonSupply.Setup(_ => _.TurnOverNext(mockPlayer.Object)).Returns(true);
				var mockBoon = new Mock<IBoon>();
				mockBoonSupply.SetupGet(_ => _.TopDiscard).Returns(mockBoon.Object);


				inPlay.AddRange(mockPlayer.Object, new List<Card> { card });
				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.RetrieveCardFrom(DeckLocation.InPlay, card), Times.Once);
				mockPlayer.Verify(_ => _.Trash(card, It.IsAny<Card>()), Times.Once);
				mockBoon.Verify(_ => _.Receive(mockPlayer.Object), Times.Exactly(2));
			}
		}
		[TestMethod]
		public void Test_Plague_Basic()
		{
			using (var card = new Plague())
			{
				Assert.AreEqual(Categories.Hex, card.Category);
			}
		}
		[TestMethod]
		public void Test_Plague_Receive()
		{
			using (Hex card = new Plague())
			{
				mockTable.SetupGet(_ => _.Curse).Returns(mockSupply.Object);


				card.Receive(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, DeckLocation.Hand, It.IsAny<DeckPosition>(), 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Pooka_Basic()
		{
			using (var card = new Pooka())
			{
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
			}
		}
		[TestMethod]
		public void Test_Pooka_Setup()
		{
			using (Card card = new Pooka())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);
				mockTable.SetupGet(_ => _.Copper).Returns(mockSupply.Object);

				card.SetupSupply(mockGame.Object, mockSupply.Object);

				mockSupply.Verify(_ => _.AddTo(It.IsAny<CursedGold>(), 0), Times.AtLeastOnce);
			}
		}
		[TestMethod]
		public void Test_Pooka_Play_NoTrash()
		{
			using (Card card = new Pooka())
			{
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>()));


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Trash(It.IsAny<IGameObject>(), It.IsAny<Card>()), Times.Never);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards == 4), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Pooka_Play_Trash()
		{
			using (Card card = new Pooka())
			{
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>(new Idol())));


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Trash(card, It.IsAny<Card>()), Times.Once);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards == 4), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Pouch_Basic()
		{
			using (var card = new Pouch())
			{
				Assert.AreEqual(new Cost(2), card.BaseCost);
				Assert.AreEqual(1, card.Benefit.Buys);
				Assert.AreEqual(new Currency(1), card.Benefit.Currency);
				Assert.AreEqual(Categories.Card | Categories.Treasure | Categories.Heirloom, card.Category);
			}
		}
		[TestMethod]
		public void Test_Poverty_Basic()
		{
			using (var card = new Poverty())
			{
				Assert.AreEqual(Categories.Hex, card.Category);
			}
		}
		[TestMethod]
		public void Test_Poverty_Receive()
		{
			using (Hex card = new Poverty())
			{
				mockTable.SetupGet(_ => _.Curse).Returns(mockSupply.Object);
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>()));


				card.Receive(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Discard(DeckLocation.Hand, It.IsAny<ItemCollection<Card>>(), null), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Raider_Basic()
		{
			using (var card = new Raider())
			{
				Assert.AreEqual(new Cost(6), card.BaseCost);
				Assert.AreEqual(new Currency(3), card.DurationBenefit.Currency);
				Assert.AreEqual(Categories.Card | Categories.Night | Categories.Duration | Categories.Attack, card.Category);
			}
		}
		[TestMethod]
		public void Test_Raider_Play_Defended()
		{
			using (Card card = new Raider())
			{
				var mockAttackee = new Mock<IPlayer>();
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockAttackee.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockGame.Setup(_ => _.GetPlayersStartingWithEnumerator(mockPlayer.Object)).Returns<IPlayer>(x => { var y = players.GetPlayersStartingWithEnumerator(x); return y; });
				mockAttackee.Setup(_ => _.AttackedByPlayerAllowed(mockPlayer.Object, card)).Returns(false);
				var attackeeHand = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
				attackeeHand.AddRange(mockPlayer.Object, new List<Card> { new Cemetery(), new Pixie(), new Goat(), new Pixie(), new Cemetery() });
				mockAttackee.SetupGet(_ => _.Hand).Returns(attackeeHand);

				var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
				mockPlayer.SetupGet(_ => _.InPlayAndSetAside).Returns(new DeckCollection(inPlay));
				mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Night);


				// Sets up the IsAttackBlocked dictionary properly
				card.PlaySetup(mockPlayer.Object);
				// Just sets the card in play
				card.FollowInstructions(mockPlayer.Object);


				mockAttackee.Verify(_ => _.Discard(DeckLocation.Hand, It.IsAny<ItemCollection<Card>>(), null), Times.Never);
				mockAttackee.Verify(_ => _.RevealHand(), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Raider_Play_TooFewCards()
		{
			using (Card card = new Raider())
			{
				var mockAttackee = new Mock<IPlayer>();
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockAttackee.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockGame.Setup(_ => _.GetPlayersStartingWithEnumerator(mockPlayer.Object)).Returns<IPlayer>(x => { var y = players.GetPlayersStartingWithEnumerator(x); return y; });
				mockAttackee.Setup(_ => _.AttackedByPlayerAllowed(mockPlayer.Object, card)).Returns(true);
				var attackeeHand = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
				mockAttackee.SetupGet(_ => _.Hand).Returns(attackeeHand);

				var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
				mockPlayer.SetupGet(_ => _.InPlayAndSetAside).Returns(new DeckCollection(inPlay));
				mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Night);


				// Sets up the IsAttackBlocked dictionary properly
				card.PlaySetup(mockPlayer.Object);
				// Just sets the card in play
				card.FollowInstructions(mockPlayer.Object);


				mockAttackee.Verify(_ => _.Discard(DeckLocation.Hand, It.IsAny<ItemCollection<Card>>(), null), Times.Never);
				mockAttackee.Verify(_ => _.RevealHand(), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Raider_Play_NothingMatching()
		{
			using (Card card = new Raider())
			{
				var mockAttackee = new Mock<IPlayer>();
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockAttackee.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockGame.Setup(_ => _.GetPlayersStartingWithEnumerator(mockPlayer.Object)).Returns<IPlayer>(x => { var y = players.GetPlayersStartingWithEnumerator(x); return y; });
				mockAttackee.Setup(_ => _.AttackedByPlayerAllowed(mockPlayer.Object, card)).Returns(true);
				var attackeeHand = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
				attackeeHand.AddRange(mockPlayer.Object, new List<Card> { new Cemetery(), new Pixie(), new Goat(), new Pixie(), new Cemetery() });
				mockAttackee.SetupGet(_ => _.Hand).Returns(attackeeHand);

				var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
				mockPlayer.SetupGet(_ => _.InPlayAndSetAside).Returns(new DeckCollection(inPlay));
				mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Night);


				// Sets up the IsAttackBlocked dictionary properly
				card.PlaySetup(mockPlayer.Object);
				// Just sets the card in play
				card.FollowInstructions(mockPlayer.Object);


				mockAttackee.Verify(_ => _.Discard(DeckLocation.Hand, It.IsAny<ItemCollection<Card>>(), null), Times.Never);
				mockAttackee.Verify(_ => _.RevealHand(), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Raider_Play_Matching()
		{
			using (Card card = new Raider())
			{
				var mockAttackee = new Mock<IPlayer>();
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockAttackee.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockGame.Setup(_ => _.GetPlayersStartingWithEnumerator(mockPlayer.Object)).Returns<IPlayer>(x => { var y = players.GetPlayersStartingWithEnumerator(x); return y; });
				mockAttackee.Setup(_ => _.AttackedByPlayerAllowed(mockPlayer.Object, card)).Returns(true);
				var attackeeHand = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
				var onePixie = new Pixie();
				attackeeHand.AddRange(mockAttackee.Object, new List<Card> { new Cemetery(), onePixie, new Goat(), new Pixie(), new Cemetery() });
				mockAttackee.SetupGet(_ => _.Hand).Returns(attackeeHand);
				mockAttackee.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>(onePixie)));

				var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
				inPlay.AddRange(mockPlayer.Object, new ItemCollection<Card> { new Pixie(), new Bard() });
				mockPlayer.SetupGet(_ => _.InPlayAndSetAside).Returns(new DeckCollection(inPlay));
				mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Night);


				// Sets up the IsAttackBlocked dictionary properly
				card.PlaySetup(mockPlayer.Object);
				// Just sets the card in play
				card.FollowInstructions(mockPlayer.Object);


				mockAttackee.Verify(_ => _.Discard(DeckLocation.Hand, new ItemCollection<Card>(onePixie), null), Times.Once);
				mockAttackee.Verify(_ => _.RevealHand(), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Raider_Resolve_Duration()
		{
			using (Card card = new Raider())
			{
				var players = new PlayerCollection(mockGame.Object) { mockPlayer.Object };
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockGame.Setup(_ => _.GetPlayersStartingWithEnumerator(mockPlayer.Object)).Returns<IPlayer>(x => { var y = players.GetPlayersStartingWithEnumerator(x); return y; });

				// Just sets the card in play
				card.FollowInstructions(mockPlayer.Object);
				Assert.IsFalse(card.CanCleanUp);


				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.IsTrue(tseArgs.Resolvers.ContainsKey(card.Name));

				tseArgs.Resolvers[card.Name].Method(mockPlayer.Object, ref tseArgs);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Currency.Coin == 3), It.IsAny<bool>()), Times.Once);


				// Teardown at the end (Make sure event listener isn't listening any more)
				tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.IsFalse(tseArgs.Resolvers.ContainsKey(card.Name));
			}
		}
		[TestMethod]
		public void Test_Raider_Teardown()
		{
			using (Card card = new Raider())
			{
				var players = new PlayerCollection(mockGame.Object) { mockPlayer.Object };
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockGame.Setup(_ => _.GetPlayersStartingWithEnumerator(mockPlayer.Object)).Returns<IPlayer>(x => { var y = players.GetPlayersStartingWithEnumerator(x); return y; });

				// Just sets the card in play
				card.FollowInstructions(mockPlayer.Object);
				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.IsTrue(tseArgs.Resolvers.ContainsKey(card.Name));


				// Teardown -- example, at the end of the game before the player got a chance to use it
				card.TearDown(mockGame.Object);


				// Teardown at the end (Make sure event listener isn't listening any more)
				tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.IsFalse(tseArgs.Resolvers.ContainsKey(card.Name));
			}
		}
		[TestMethod]
		public void Test_SacredGrove_Basic()
		{
			using (var card = new SacredGrove())
			{
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(1, card.Benefit.Buys);
				Assert.AreEqual(new Currency(3), card.Benefit.Currency);
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Fate, card.Category);
			}
		}
		[TestMethod]
		public void Test_SacredGrove_Setup()
		{
			using (Card card = new SacredGrove())
			{

				// SpecialPiles should maybe be mocked as well??
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

				card.SetupSupply(mockGame.Object, mockSupply.Object);

				Assert.IsTrue(specialPiles.ContainsKey(TypeClass.Boons));
			}
		}
		[TestMethod]
		public void Test_SacredGrove_Play_PlusCoinBoon()
		{
			using (Card card = new SacredGrove())
			{
				var mockOtherPlayer = new Mock<IPlayer>();
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockOtherPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockGame.Setup(_ => _.GetPlayersStartingWithEnumerator(mockPlayer.Object)).Returns<IPlayer>(x => { var y = players.GetPlayersStartingWithEnumerator(x); return y; });

				Initialize_ReceiveBoon(card);

				var mockBoonSupply = new Mock<IBoonSupply>();
				var spec = new TableEntityCollection() { { TypeClass.Boons, mockBoonSupply.Object } };
				mockTable.Setup(_ => _.SpecialPiles).Returns(spec);
				mockBoonSupply.Setup(_ => _.TurnOverNext(mockPlayer.Object)).Returns(true);
				var mockBoon = new Mock<IBoon>();
				mockBoon.SetupGet(_ => _.Benefit).Returns(new CardBenefit(currency: new Currency(1)));
				mockBoonSupply.SetupGet(_ => _.TopDiscard).Returns(mockBoon.Object);



				card.FollowInstructions(mockPlayer.Object);


				mockBoon.Verify(_ => _.Receive(mockPlayer.Object), Times.Once);
				mockGame.Verify(_ => _.GetPlayersStartingWithEnumerator(It.IsAny<IPlayer>()), Times.Never);
				mockOtherPlayer.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Never);
				mockBoon.Verify(_ => _.Receive(It.IsAny<IPlayer>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_SacredGrove_Play_OtherBoon()
		{
			using (Card card = new SacredGrove())
			{
				var mockOtherPlayer = new Mock<IPlayer>();
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockOtherPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockGame.Setup(_ => _.GetPlayersStartingWithEnumerator(mockPlayer.Object)).Returns<IPlayer>(x => { var y = players.GetPlayersStartingWithEnumerator(x); return y; });
				mockOtherPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new List<string> { ResourcesHelper.Get("Yes") }));

				Initialize_ReceiveBoon(card);

				var mockBoonSupply = new Mock<IBoonSupply>();
				var spec = new TableEntityCollection() { { TypeClass.Boons, mockBoonSupply.Object } };
				mockTable.Setup(_ => _.SpecialPiles).Returns(spec);
				mockBoonSupply.Setup(_ => _.TurnOverNext(mockPlayer.Object)).Returns(true);
				var mockBoon = new Mock<IBoon>();
				mockBoon.SetupGet(_ => _.Benefit).Returns(new CardBenefit());
				mockBoonSupply.SetupGet(_ => _.TopDiscard).Returns(mockBoon.Object);



				card.FollowInstructions(mockPlayer.Object);


				mockBoon.Verify(_ => _.Receive(mockPlayer.Object), Times.Once);
				mockGame.Verify(_ => _.GetPlayersStartingWithEnumerator(It.IsAny<IPlayer>()), Times.Once);
				mockOtherPlayer.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.AtLeast(1));
				mockBoon.Verify(_ => _.Receive(It.IsAny<IPlayer>()), Times.AtLeast(2));
			}
		}
		[TestMethod]
		public void Test_SecretCave_Basic()
		{
			using (var card = new SecretCave())
			{
				Assert.AreEqual(new Cost(3), card.BaseCost);
				Assert.AreEqual(1, card.Benefit.Cards);
				Assert.AreEqual(1, card.Benefit.Actions);
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Duration, card.Category);
			}
		}
		[TestMethod]
		public void Test_SecretCave_Setup()
		{
			using (Card card = new SecretCave())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);
				mockTable.SetupGet(_ => _.Copper).Returns(mockSupply.Object);

				card.SetupSupply(mockGame.Object, mockSupply.Object);

				mockSupply.Verify(_ => _.AddTo(It.IsAny<MagicLamp>(), 0), Times.AtLeastOnce);
			}
		}
		[TestMethod]
		public void Test_SecretCave_Play_NoDiscard()
		{
			using (Card card = new SecretCave())
			{
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options))).Returns(new ChoiceResult(new List<string> { ResourcesHelper.Get("No") }));


				card.FollowInstructions(mockPlayer.Object);


				Assert.IsTrue(card.CanCleanUp);
				mockPlayer.Verify(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options)), Times.Once);
				mockPlayer.Verify(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)), Times.Never);
				mockPlayer.Verify(_ => _.Discard(DeckLocation.Hand, It.IsAny<IEnumerable<Card>>(), null), Times.Never);

				// Teardown at the end (Make sure event listener isn't listening)
				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.IsFalse(tseArgs.Resolvers.ContainsKey(card.Name));
			}
		}
		[TestMethod]
		public void Test_SecretCave_Play_Too_Few_Discard()
		{
			using (Card card = new SecretCave())
			{
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options)))
					.Returns(new ChoiceResult(new List<string> { ResourcesHelper.Get("Yes") }));
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)))
					.Returns(new ChoiceResult(new ItemCollection<Card>(new List<Card> { new Cemetery(), new Fool() })));


				card.FollowInstructions(mockPlayer.Object);


				Assert.IsTrue(card.CanCleanUp);
				mockPlayer.Verify(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options)), Times.Once);
				mockPlayer.Verify(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)), Times.Once);
				mockPlayer.Verify(_ => _.Discard(DeckLocation.Hand, It.IsAny<IEnumerable<Card>>(), null), Times.Once);

				// Teardown at the end (Make sure event listener isn't listening)
				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.IsFalse(tseArgs.Resolvers.ContainsKey(card.Name));
			}
		}
		[TestMethod]
		public void Test_SecretCave_Play_Discard_3()
		{
			using (Card card = new SecretCave())
			{
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options)))
					.Returns(new ChoiceResult(new List<string> { ResourcesHelper.Get("Yes") }));
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)))
					.Returns(new ChoiceResult(new ItemCollection<Card>(new List<Card> { new Cemetery(), new Fool(), new GhostTown() })));


				card.FollowInstructions(mockPlayer.Object);


				Assert.IsFalse(card.CanCleanUp);
				mockPlayer.Verify(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options)), Times.Once);
				mockPlayer.Verify(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)), Times.Once);
				mockPlayer.Verify(_ => _.Discard(DeckLocation.Hand, It.IsAny<IEnumerable<Card>>(), null), Times.Once);

				// Teardown at the end (Make sure event listener isn't listening)
				mockPlayer.Raise(_ => _.TurnEnded += null, new TurnEndedEventArgs(mockPlayer.Object));
				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.IsTrue(tseArgs.Resolvers.ContainsKey(card.Name));

				tseArgs.Resolvers[card.Name].Method(mockPlayer.Object, ref tseArgs);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Currency.Coin == 3), It.IsAny<bool>()), Times.Once);

			}
		}
		[TestMethod]
		public void Test_SecretCave_Teardown()
		{
			using (Card card = new SecretCave())
			{
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options)))
					.Returns(new ChoiceResult(new List<string> { ResourcesHelper.Get("Yes") }));
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)))
					.Returns(new ChoiceResult(new ItemCollection<Card>(new List<Card> { new Cemetery(), new Fool(), new GhostTown() })));


				card.FollowInstructions(mockPlayer.Object);


				Assert.IsFalse(card.CanCleanUp);
				mockPlayer.Raise(_ => _.TurnEnded += null, new TurnEndedEventArgs(mockPlayer.Object));
				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.IsTrue(tseArgs.Resolvers.ContainsKey(card.Name));

				// Teardown -- example, at the end of the game before the player got a chance to use it
				card.TearDown(mockGame.Object);

				// Teardown at the end (Make sure event listener isn't listening any more)
				tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.IsFalse(tseArgs.Resolvers.ContainsKey(card.Name));
			}
		}
		[TestMethod]
		public void Test_Shepherd_Basic()
		{
			using (var card = new Shepherd())
			{
				Assert.AreEqual(new Cost(4), card.BaseCost);
				Assert.AreEqual(1, card.Benefit.Actions);
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
			}
		}
		[TestMethod]
		public void Test_Shepherd_Setup()
		{
			using (Card card = new Shepherd())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);
				mockTable.SetupGet(_ => _.Copper).Returns(mockSupply.Object);

				card.SetupSupply(mockGame.Object, mockSupply.Object);

				mockSupply.Verify(_ => _.AddTo(It.IsAny<Pasture>(), 0), Times.AtLeastOnce);
			}
		}
		[TestMethod]
		public void Test_Shepherd_Play_Discard_Zero()
		{
			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>()));
			mockPlayer.Setup(_ => _.RetrieveCardsFrom(DeckLocation.Revealed, It.IsAny<ItemCollection<Card>>())).Returns(new ItemCollection<Card>());
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);

			using (Card card = new Shepherd())
			{
				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.AddCardsInto(DeckLocation.Revealed, It.Is<IEnumerable<Card>>(cl => cl.Count() > 0), It.IsAny<DeckPosition>()), Times.Never);
				mockPlayer.Verify(_ => _.Discard(DeckLocation.Hand, It.Is<IEnumerable<Card>>(cl => cl.Count() > 0), null), Times.Never);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards > 0), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Shepherd_Play_Discard_2_Cards()
		{
			var cardsToDiscard = new List<Card> { new Cemetery(), new Pasture() };
			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>(cardsToDiscard)));
			mockPlayer.Setup(_ => _.RetrieveCardsFrom(DeckLocation.Revealed, It.IsAny<ItemCollection<Card>>())).Returns(new ItemCollection<Card>(cardsToDiscard));
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
			hand.AddRange(mockPlayer.Object, cardsToDiscard);
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);

			using (Card card = new Shepherd())
			{
				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.AddCardsInto(DeckLocation.Revealed, cardsToDiscard, It.IsAny<DeckPosition>()), Times.Once);
				mockPlayer.Verify(_ => _.Discard(DeckLocation.Hand, cardsToDiscard, null), Times.Once);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards == 4), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Skulk_Basic()
		{
			using (var card = new Skulk())
			{
				Assert.AreEqual(new Cost(4), card.BaseCost);
				Assert.AreEqual(1, card.Benefit.Buys);
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Attack | Categories.Doom, card.Category);
			}
		}
		[TestMethod]
		public void Test_Skulk_Setup()
		{
			using (Card card = new Skulk())
			{

				// SpecialPiles should maybe be mocked as well??
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

				card.SetupSupply(mockGame.Object, mockSupply.Object);

				Assert.IsTrue(specialPiles.ContainsKey(TypeClass.Hexes));
			}
		}
		[TestMethod]
		public void Test_Skulk_Gain()
		{
			using (Card card = new Skulk())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockTable.SetupGet(_ => _.Gold).Returns(mockSupply.Object);
				mockSupply.SetupGet(_ => _.Type).Returns(DominionBase.Cards.Universal.TypeClass.Gold);

				card.SetupCard(mockGame.Object);

				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, card, new DominionBase.Cards.Base.Remodel(), DeckLocation.Discard, DeckPosition.Automatic, false);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsTrue(cgeArgs.Resolvers.ContainsKey(TypeClass.Skulk.ToString()));

				cgeArgs.Resolvers[TypeClass.Skulk.ToString()].Method(mockPlayer.Object, ref cgeArgs);

				mockPlayer.Verify(_ => _.Gain(It.Is<ISupply>(s => s.Type == DominionBase.Cards.Universal.TypeClass.Gold), card, 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Skulk_Gain_Cancelled()
		{
			using (Card card = new Skulk())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockTable.SetupGet(_ => _.Gold).Returns(mockSupply.Object);
				mockSupply.SetupGet(_ => _.Type).Returns(DominionBase.Cards.Universal.TypeClass.Gold);

				card.SetupCard(mockGame.Object);

				var key = TypeClass.Skulk.ToString();
				// "Lose" (Ungain) the card -- the on-gain trigger of Skulk should still work
				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, card, new DominionBase.Cards.Base.Remodel(), DeckLocation.Discard, DeckPosition.Automatic, false)
				{
					IsLostTrackOf = true
				};
				card.LostBy(mockPlayer.Object);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsTrue(cgeArgs.Resolvers.ContainsKey(key));
				Assert.IsNotNull(cgeArgs.Resolvers[key].Player);

				cgeArgs.Resolvers[key].Method(mockPlayer.Object, ref cgeArgs);

				mockPlayer.Verify(_ => _.Gain(It.Is<ISupply>(s => s.Type == DominionBase.Cards.Universal.TypeClass.Gold), card, 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Skulk_Play_NotBlocked()
		{
			using (Card card = new Skulk())
			{

				Initialize_ReceiveHex(card);
				var mockAttacker = new Mock<IPlayer>();
				var players = new PlayerCollection(mockGame.Object)
				{
					mockAttacker.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockGame.Setup(_ => _.GetPlayersStartingWithEnumerator(mockAttacker.Object)).Returns<IPlayer>(x => { var y = players.GetPlayersStartingWithEnumerator(x); return y; });
				mockPlayer.Setup(_ => _.AttackedByPlayerAllowed(mockAttacker.Object, card)).Returns(true);
				mockAttacker.SetupGet(_ => _._Game).Returns(mockGame.Object);
				mockAttacker.SetupGet(_ => _.Phase).Returns(PhaseEnum.Action);

				var mockHexSupply = new Mock<IHexSupply>();
				var spec = new TableEntityCollection { { TypeClass.Hexes, mockHexSupply.Object } };
				mockTable.Setup(_ => _.SpecialPiles).Returns(spec);
				mockHexSupply.Setup(_ => _.TurnOverNext(mockAttacker.Object)).Returns(true);
				var mockHex = new Mock<IHex>();
				mockHexSupply.SetupGet(_ => _.TopDiscard).Returns(mockHex.Object);


				// Sets up the IsAttackBlocked dictionary properly
				card.PlaySetup(mockAttacker.Object);
				// Just sets the card in play
				card.FollowInstructions(mockAttacker.Object);


				mockHex.Verify(_ => _.Receive(mockAttacker.Object), Times.Never);
				mockHex.Verify(_ => _.Receive(mockPlayer.Object), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Skulk_Play_Blocked()
		{
			using (Card card = new Skulk())
			{

				Initialize_ReceiveHex(card);
				var players = new PlayerCollection(mockGame.Object);
				var mockAttacker = new Mock<IPlayer>();
				players.Add(mockAttacker.Object);
				players.Add(mockPlayer.Object);
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockGame.Setup(_ => _.GetPlayersStartingWithEnumerator(mockAttacker.Object)).Returns<IPlayer>(x => { var y = players.GetPlayersStartingWithEnumerator(x); return y; });
				mockPlayer.Setup(_ => _.AttackedByPlayerAllowed(mockAttacker.Object, card)).Returns(false);
				mockAttacker.SetupGet(_ => _._Game).Returns(mockGame.Object);
				mockAttacker.SetupGet(_ => _.Phase).Returns(PhaseEnum.Action);

				var mockHexSupply = new Mock<IHexSupply>();
				var spec = new TableEntityCollection() { { TypeClass.Hexes, mockHexSupply.Object } };
				mockTable.Setup(_ => _.SpecialPiles).Returns(spec);
				mockHexSupply.Setup(_ => _.TurnOverNext(mockPlayer.Object)).Returns(true);
				var mockHex = new Mock<IHex>();
				mockHexSupply.SetupGet(_ => _.TopDiscard).Returns(mockHex.Object);


				// Sets up the IsAttackBlocked dictionary properly
				card.PlaySetup(mockAttacker.Object);
				// Just sets the card in play
				card.FollowInstructions(mockAttacker.Object);


				mockHex.Verify(_ => _.Receive(mockAttacker.Object), Times.Never);
				mockHex.Verify(_ => _.Receive(mockPlayer.Object), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Skulk_Teardown()
		{
			using (Card card = new Skulk())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockTable.SetupGet(_ => _.Copper).Returns(mockSupply.Object);

				card.SetupCard(mockGame.Object);

				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, card, new DominionBase.Cards.Base.Remodel(), DeckLocation.Discard, DeckPosition.Automatic, false);

				// Teardown at the end (Make sure event listener isn't listening any more)
				card.TearDown(mockGame.Object);

				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsFalse(cgeArgs.Resolvers.ContainsKey(TypeClass.Skulk.ToString()));
			}
		}
		[TestMethod]
		public void Test_TheEarthsGift_Basic()
		{
			using (var card = new TheEarthsGift())
			{
				Assert.AreEqual(Categories.Boon, card.Category);
			}
		}
		[TestMethod]
		public void Test_TheEarthsGift_Receive_No_Discard()
		{
			using (Boon card = new TheEarthsGift())
			{
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards))).Returns(new ChoiceResult(new ItemCollection<Card>()));


				card.Receive(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Discard(DeckLocation.Hand, It.IsAny<ItemCollection<Card>>(), null), Times.Never);
			}
		}
		[TestMethod]
		public void Test_TheEarthsGift_Receive_Discard_Treasure_Gain_Nothing()
		{
			using (Boon card = new TheEarthsGift())
			{
				mockTable.SetupGet(_ => _.TableEntities).Returns(new TableEntityCollection());
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				var cardToDiscard = new Pasture();
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards))).Returns(new ChoiceResult(new ItemCollection<Card>(cardToDiscard)));
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Supplies))).Returns(new ChoiceResult());


				card.Receive(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Discard(DeckLocation.Hand, new ItemCollection<Card>(cardToDiscard), null), Times.Once);
				mockPlayer.Verify(_ => _.Gain(It.IsAny<ISupply>(), It.IsAny<IGameObject>(), It.IsAny<int>(), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_TheEarthsGift_Receive_Discard_Treasure_Gain_Supply()
		{
			using (Boon card = new TheEarthsGift())
			{
				var tableEntities = new TableEntityCollection { { TypeClass.BlessedVillage, mockSupply.Object } };
				mockTable.SetupGet(_ => _.TableEntities).Returns(tableEntities);
				mockSupply.SetupGet(_ => _.TableableType).Returns(TypeClass.BlessedVillage);
				mockSupply.Setup(_ => _.CanGain()).Returns(true);
				mockSupply.SetupGet(_ => _.CurrentCost).Returns(new Cost(4));
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				var cardToDiscard = new Pasture();
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards))).Returns(new ChoiceResult(new ItemCollection<Card>(cardToDiscard)));
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Supplies))).Returns<Choice>(c =>
				{
					return new ChoiceResult((ISupply)c.Supplies.First().Value);
				});


				card.Receive(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Discard(DeckLocation.Hand, new ItemCollection<Card>(cardToDiscard), null), Times.Once);
				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_TheFieldsGift_Basic()
		{
			using (var card = new TheFieldsGift())
			{
				Assert.AreEqual(1, card.Benefit.Actions);
				Assert.AreEqual(new Currency(1), card.Benefit.Currency);
				Assert.AreEqual(Categories.Boon, card.Category);
			}
		}
		[TestMethod]
		public void Test_TheFieldsGift_Receive()
		{
			using (Boon card = new TheFieldsGift())
			{

				mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);
				var mockBoonSupply = new Mock<IBoonSupply>();
				var spec = new TableEntityCollection { { TypeClass.Boons, mockBoonSupply.Object } };
				mockTable.Setup(_ => _.SpecialPiles).Returns(spec);


				card.Receive(mockPlayer.Object);

				mockBoonSupply.Verify(_ => _.ReturnBoon(card), Times.Never);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Actions == 1 && cb.Currency.Coin == 1), It.IsAny<bool>()), Times.Once);

				var movements = new CardMovementCollection();
				var cueArgs = new CleaningUpEventArgs(mockPlayer.Object, ref movements);
				mockPlayer.Raise(_ => _.CleaningUp += null, cueArgs);
				Assert.IsTrue(cueArgs.Resolvers.ContainsKey(TypeClass.TheFieldsGift));
				cueArgs.Resolvers[TypeClass.TheFieldsGift].Method(mockPlayer.Object, ref cueArgs);

				mockPlayer.Verify(_ => _.ReturnBoon(It.IsAny<IBoonSupply>(), card), Times.Once);
			}
		}
		[TestMethod]
		public void Test_TheFieldsGift_Teardown()
		{
			using (Boon card = new TheFieldsGift())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);
				var mockBoonSupply = new Mock<IBoonSupply>();
				var spec = new TableEntityCollection { { TypeClass.Boons, mockBoonSupply.Object } };
				mockTable.Setup(_ => _.SpecialPiles).Returns(spec);


				card.Receive(mockPlayer.Object);


				mockBoonSupply.Verify(_ => _.ReturnBoon(card), Times.Never);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Actions == 1 && cb.Currency.Coin == 1), It.IsAny<bool>()), Times.Once);

				card.TearDown(mockGame.Object);

				var movements = new CardMovementCollection();
				var cueArgs = new CleaningUpEventArgs(mockPlayer.Object, ref movements);
				mockPlayer.Raise(_ => _.CleaningUp += null, cueArgs);
				Assert.IsFalse(cueArgs.Resolvers.ContainsKey(TypeClass.TheFieldsGift));
			}
		}
		[TestMethod]
		public void Test_TheFlamesGift_Basic()
		{
			using (var card = new TheFlamesGift())
			{
				Assert.AreEqual(Categories.Boon, card.Category);
			}
		}
		[TestMethod]
		public void Test_TheFlamesGift_Receive_Trash_Nothing()
		{
			using (Boon card = new TheFlamesGift())
			{
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>()));
				mockPlayer.Setup(_ => _.RetrieveCardsFrom(DeckLocation.Hand, It.IsAny<ItemCollection<Card>>())).Returns(new ItemCollection<Card>());


				card.Receive(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Trash(card, It.Is<ItemCollection<Card>>(ic => ic.Count == 0)), Times.Once);
			}
		}
		[TestMethod]
		public void Test_TheFlamesGift_Receive_Trash_Cards()
		{
			using (Boon card = new TheFlamesGift())
			{
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				var cardsToTrash = new List<Card> { new Changeling(), new Cemetery() };
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>(cardsToTrash)));
				mockPlayer.Setup(_ => _.RetrieveCardsFrom(DeckLocation.Hand, new ItemCollection<Card>(cardsToTrash))).Returns(new ItemCollection<Card>(cardsToTrash));


				card.Receive(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Trash(card, new ItemCollection<Card>(cardsToTrash)), Times.Once);
			}
		}
		[TestMethod]
		public void Test_TheForestsGift_Basic()
		{
			using (var card = new TheForestsGift())
			{
				Assert.AreEqual(1, card.Benefit.Buys);
				Assert.AreEqual(new Currency(1), card.Benefit.Currency);
				Assert.AreEqual(Categories.Boon, card.Category);
			}
		}
		[TestMethod]
		public void Test_TheForestsGift_Receive()
		{
			using (Boon card = new TheForestsGift())
			{

				mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);
				var mockBoonSupply = new Mock<IBoonSupply>();
				var spec = new TableEntityCollection { { TypeClass.Boons, mockBoonSupply.Object } };
				mockTable.Setup(_ => _.SpecialPiles).Returns(spec);


				card.Receive(mockPlayer.Object);

				mockBoonSupply.Verify(_ => _.ReturnBoon(card), Times.Never);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Buys == 1 && cb.Currency.Coin == 1), It.IsAny<bool>()), Times.Once);

				var movements = new CardMovementCollection();
				var cueArgs = new CleaningUpEventArgs(mockPlayer.Object, ref movements);
				mockPlayer.Raise(_ => _.CleaningUp += null, cueArgs);
				Assert.IsTrue(cueArgs.Resolvers.ContainsKey(TypeClass.TheForestsGift));
				cueArgs.Resolvers[TypeClass.TheForestsGift].Method(mockPlayer.Object, ref cueArgs);

				mockPlayer.Verify(_ => _.ReturnBoon(It.IsAny<IBoonSupply>(), card), Times.Once);
			}
		}
		[TestMethod]
		public void Test_TheForestsGift_Teardown()
		{
			using (Boon card = new TheForestsGift())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);
				var mockBoonSupply = new Mock<IBoonSupply>();
				var spec = new TableEntityCollection { { TypeClass.Boons, mockBoonSupply.Object } };
				mockTable.Setup(_ => _.SpecialPiles).Returns(spec);


				card.Receive(mockPlayer.Object);


				mockBoonSupply.Verify(_ => _.ReturnBoon(card), Times.Never);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Buys == 1 && cb.Currency.Coin == 1), It.IsAny<bool>()), Times.Once);

				card.TearDown(mockGame.Object);

				var movements = new CardMovementCollection();
				var cueArgs = new CleaningUpEventArgs(mockPlayer.Object, ref movements);
				mockPlayer.Raise(_ => _.CleaningUp += null, cueArgs);
				Assert.IsFalse(cueArgs.Resolvers.ContainsKey(TypeClass.TheForestsGift));
			}
		}
		[TestMethod]
		public void Test_TheMoonsGift_Basic()
		{
			using (var card = new TheMoonsGift())
			{
				Assert.AreEqual(Categories.Boon, card.Category);
			}
		}
		[TestMethod]
		public void Test_TheMoonsGift_Receive_Discard_Empty()
		{
			using (Boon card = new TheMoonsGift())
			{
				var discard = new Deck(DeckLocation.Discard, Visibility.Top, VisibilityTo.All);
				mockPlayer.SetupGet(_ => _.DiscardPile).Returns(discard);
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>()));


				card.Receive(mockPlayer.Object);


				mockGame.Verify(_ => _.SendMessage(mockPlayer.Object, card, It.Is<IDisplayable[]>(d => d.Length == 0)), Times.Once);
				mockPlayer.Verify(_ => _.AddCardsToDeck(It.IsAny<IEnumerable<Card>>(), DeckPosition.Top), Times.Never);
			}
		}
		[TestMethod]
		public void Test_TheMoonsGift_Receive_Select_Card()
		{
			using (Boon card = new TheMoonsGift())
			{
				var discard = new Deck(DeckLocation.Discard, Visibility.Top, VisibilityTo.All);
				var selectedCard = new SecretCave();
				discard.AddRange(mockPlayer.Object, new List<Card> { new MagicLamp(), selectedCard, new Leprechaun() });
				mockPlayer.SetupGet(_ => _.DiscardPile).Returns(discard);
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>(selectedCard)));


				card.Receive(mockPlayer.Object);


				mockGame.Verify(_ => _.SendMessage(mockPlayer.Object, card, It.Is<IDisplayable[]>(d => d.Length == 3)), Times.Once);
				mockPlayer.Verify(_ => _.AddCardsToDeck(new List<Card> { selectedCard }, DeckPosition.Top), Times.Once);
			}
		}
		[TestMethod]
		public void Test_TheMountainsGift_Basic()
		{
			using (var card = new TheMountainsGift())
			{
				Assert.AreEqual(Categories.Boon, card.Category);
			}
		}
		[TestMethod]
		public void Test_TheMountainsGift_Receive()
		{
			using (Boon card = new TheMountainsGift())
			{
				mockTable.SetupGet(_ => _.Silver).Returns(mockSupply.Object);
				mockSupply.SetupGet(_ => _.Type).Returns(DominionBase.Cards.Universal.TypeClass.Silver);


				card.Receive(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_TheRiversGift_Basic()
		{
			using (var card = new TheRiversGift())
			{
				Assert.AreEqual(Categories.Boon, card.Category);
			}
		}
		[TestMethod]
		public void Test_TheRiversGift_Receive()
		{
			using (Boon card = new TheRiversGift())
			{

				mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);
				var turn = new Turn(mockPlayer.Object);
				mockGame.SetupGet(_ => _.CurrentTurn).Returns(turn);
				var mockBoonSupply = new Mock<IBoonSupply>();
				var spec = new TableEntityCollection { { TypeClass.Boons, mockBoonSupply.Object } };
				mockTable.Setup(_ => _.SpecialPiles).Returns(spec);


				card.Receive(mockPlayer.Object);

				mockBoonSupply.Verify(_ => _.ReturnBoon(card), Times.Never);

				var movements = new CardMovementCollection();
				var cueArgs = new CleaningUpEventArgs(mockPlayer.Object, ref movements);
				mockPlayer.Raise(_ => _.CleaningUp += null, cueArgs);
				Assert.IsTrue(cueArgs.Resolvers.ContainsKey(TypeClass.TheRiversGift));
				cueArgs.Resolvers[TypeClass.TheRiversGift].Method(mockPlayer.Object, ref cueArgs);

				mockPlayer.Verify(_ => _.ReturnBoon(It.IsAny<IBoonSupply>(), card), Times.Once);

				// Turn is over, so make sure we're cleaned up
				var teeArgs = new TurnEndedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnEnded += null, teeArgs);
				cueArgs = new CleaningUpEventArgs(mockPlayer.Object, ref movements);
				mockPlayer.Raise(_ => _.CleaningUp += null, cueArgs);
				Assert.IsFalse(cueArgs.Resolvers.ContainsKey(TypeClass.TheRiversGift));

				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards == 1), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_TheRiversGift_Teardown()
		{
			using (Boon card = new TheRiversGift())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);
				var turn = new Turn(mockPlayer.Object);
				mockGame.SetupGet(_ => _.CurrentTurn).Returns(turn);
				var mockBoonSupply = new Mock<IBoonSupply>();
				var spec = new TableEntityCollection { { TypeClass.Boons, mockBoonSupply.Object } };
				mockTable.Setup(_ => _.SpecialPiles).Returns(spec);


				card.Receive(mockPlayer.Object);

				mockBoonSupply.Verify(_ => _.ReturnBoon(card), Times.Never);

				card.TearDown(mockGame.Object);

				var movements = new CardMovementCollection();
				var cueArgs = new CleaningUpEventArgs(mockPlayer.Object, ref movements);
				mockPlayer.Raise(_ => _.CleaningUp += null, cueArgs);
				Assert.IsFalse(cueArgs.Resolvers.ContainsKey(TypeClass.TheRiversGift));
			}
		}
		[TestMethod]
		public void Test_TheSeasGift_Basic()
		{
			using (var card = new TheSeasGift())
			{
				Assert.AreEqual(1, card.Benefit.Cards);
				Assert.AreEqual(Categories.Boon, card.Category);
			}
		}
		[TestMethod]
		public void Test_TheSeasGift_Receive()
		{
			using (Boon card = new TheSeasGift())
			{


				card.Receive(mockPlayer.Object);


				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards == 1), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_TheSkysGift_Basic()
		{
			using (var card = new TheSkysGift())
			{
				Assert.AreEqual(Categories.Boon, card.Category);
			}
		}
		[TestMethod]
		public void Test_TheSkysGift_Receive_No_Discard()
		{
			using (Boon card = new TheSkysGift())
			{
				mockTable.SetupGet(_ => _.Gold).Returns(mockSupply.Object);
				mockSupply.SetupGet(_ => _.Type).Returns(DominionBase.Cards.Universal.TypeClass.Gold);
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options))).Returns(new ChoiceResult(new List<string> { ResourcesHelper.Get("No") }));


				card.Receive(mockPlayer.Object);


				mockPlayer.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Once);
				mockPlayer.Verify(_ => _.Discard(DeckLocation.Hand, It.IsAny<IEnumerable<Card>>(), null), Times.Never);
				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, It.IsAny<IGameObject>(), It.IsAny<int>(), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_TheSkysGift_Receive_Discard_Too_Few()
		{
			using (Boon card = new TheSkysGift())
			{
				mockTable.SetupGet(_ => _.Gold).Returns(mockSupply.Object);
				mockSupply.SetupGet(_ => _.Type).Returns(DominionBase.Cards.Universal.TypeClass.Gold);
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				var card1ToDiscard = new CursedGold();
				var card2ToDiscard = new SecretCave();
				hand.AddRange(mockPlayer.Object, new List<Card> { card1ToDiscard, card2ToDiscard });
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options))).Returns(new ChoiceResult(new List<string> { ResourcesHelper.Get("Yes") }));
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards))).Returns(new ChoiceResult(new ItemCollection<Card>(new List<Card> { card1ToDiscard, card2ToDiscard })));


				card.Receive(mockPlayer.Object);


				mockPlayer.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Exactly(2));
				mockPlayer.Verify(_ => _.Discard(DeckLocation.Hand, new List<Card> { card1ToDiscard, card2ToDiscard }, null), Times.Once);
				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, It.IsAny<IGameObject>(), It.IsAny<int>(), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_TheSkysGift_Receive_Discard_3()
		{
			using (Boon card = new TheSkysGift())
			{
				mockTable.SetupGet(_ => _.Gold).Returns(mockSupply.Object);
				mockSupply.SetupGet(_ => _.Type).Returns(DominionBase.Cards.Universal.TypeClass.Gold);
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				var cardsToDiscard = new List<Card> { new CursedGold(), new SecretCave(), new Cemetery() };
				hand.AddRange(mockPlayer.Object, cardsToDiscard);
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options))).Returns(new ChoiceResult(new List<string> { ResourcesHelper.Get("Yes") }));
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards))).Returns(new ChoiceResult(new ItemCollection<Card>(cardsToDiscard)));


				card.Receive(mockPlayer.Object);


				mockPlayer.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Exactly(2));
				mockPlayer.Verify(_ => _.Discard(DeckLocation.Hand, cardsToDiscard, null), Times.Once);
				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_TheSunsGift_Basic()
		{
			using (var card = new TheSunsGift())
			{
				Assert.AreEqual(Categories.Boon, card.Category);
			}
		}
		[TestMethod]
		public void Test_TheSunsGift_Receive()
		{
			using (Boon card = new TheSunsGift())
			{
				mockPlayer.Setup(_ => _.Draw(4, DeckLocation.Private)).Returns(new ItemCollection<Card>());
				var priv = new Deck(DeckLocation.Private, Visibility.All, VisibilityTo.Owner);
				mockPlayer.SetupGet(_ => _.Private).Returns(priv);
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => !c.IsOrdered))).Returns(new ChoiceResult(new ItemCollection<Card>()));
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.IsOrdered))).Returns(new ChoiceResult(new ItemCollection<Card>()));


				card.Receive(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Draw(4, DeckLocation.Private), Times.Once);
				mockPlayer.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Exactly(2));
				mockPlayer.Verify(_ => _.Discard(DeckLocation.Private, It.IsAny<ItemCollection<Card>>(), null), Times.Once);
				mockPlayer.Verify(_ => _.AddCardsToDeck(It.IsAny<ItemCollection<Card>>(), DeckPosition.Top), Times.Once);
			}
		}
		[TestMethod]
		public void Test_TheSwampsGift_Basic()
		{
			using (var card = new TheSwampsGift())
			{
				Assert.AreEqual(Categories.Boon, card.Category);
			}
		}
		[TestMethod]
		public void Test_TheSwampsGift_Setup()
		{
			using (Boon card = new TheSwampsGift())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				// SpecialPiles should maybe be mocked as well??
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

				card.Init(mockGame.Object, players);
				card.Setup();

				Assert.IsTrue(specialPiles.ContainsKey(TypeClass.WillOWisp));
			}
		}
		[TestMethod]
		public void Test_TheSwampsGift_Receive()
		{
			using (Boon card = new TheSwampsGift())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				// SpecialPiles should maybe be mocked as well??
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

				card.Init(mockGame.Object, players);
				card.Setup();

				specialPiles[TypeClass.WillOWisp] = mockSupply.Object;


				card.Receive(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_TheWindsGift_Basic()
		{
			using (var card = new TheWindsGift())
			{
				Assert.AreEqual(2, card.Benefit.Cards);
				Assert.AreEqual(Categories.Boon, card.Category);
			}
		}
		[TestMethod]
		public void Test_TheWindsGift_Receive()
		{
			using (Boon card = new TheWindsGift())
			{


				card.Receive(mockPlayer.Object);


				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards == 2), It.IsAny<bool>()), Times.Once);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.DiscardCards == 2), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Tormentor_Basic()
		{
			using (var card = new Tormentor())
			{
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(new Currency(2), card.Benefit.Currency);
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Attack | Categories.Doom, card.Category);
			}
		}
		[TestMethod]
		public void Test_Tormentor_Setup()
		{
			using (Card card = new Tormentor())
			{

				// SpecialPiles should maybe be mocked as well??
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

				card.SetupSupply(mockGame.Object, mockSupply.Object);

				Assert.IsTrue(specialPiles.ContainsKey(TypeClass.Imp));
			}
		}
		[TestMethod]
		public void Test_Tormentor_Play_Cards_In_Play_Not_Blocked()
		{
			using (Card card = new Tormentor())
			{

				Initialize_ReceiveHex(card);
				var mockAttacker = new Mock<IPlayer>();
				var players = new PlayerCollection(mockGame.Object)
				{
					mockAttacker.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockGame.Setup(_ => _.GetPlayersStartingWithEnumerator(mockAttacker.Object)).Returns<IPlayer>(x => { var y = players.GetPlayersStartingWithEnumerator(x); return y; });
				mockPlayer.Setup(_ => _.AttackedByPlayerAllowed(mockAttacker.Object, card)).Returns(true);
				mockAttacker.SetupGet(_ => _._Game).Returns(mockGame.Object);
				mockAttacker.SetupGet(_ => _.Phase).Returns(PhaseEnum.Action);
				var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
				inPlay.AddRange(mockPlayer.Object, new List<Card> { new Imp() });
				mockAttacker.SetupGet(_ => _.InPlayAndSetAside).Returns(new DeckCollection(inPlay));

				var mockHexSupply = new Mock<IHexSupply>();
				var spec = new TableEntityCollection {
					{ TypeClass.Hexes, mockHexSupply.Object },
					{ TypeClass.Imp, mockSupply.Object }
				};
				mockTable.Setup(_ => _.SpecialPiles).Returns(spec);
				mockHexSupply.Setup(_ => _.TurnOverNext(mockAttacker.Object)).Returns(true);
				var mockHex = new Mock<IHex>();
				mockHexSupply.SetupGet(_ => _.TopDiscard).Returns(mockHex.Object);


				// Sets up the IsAttackBlocked dictionary properly
				card.PlaySetup(mockAttacker.Object);
				// Just sets the card in play
				card.FollowInstructions(mockAttacker.Object);


				mockHex.Verify(_ => _.Receive(mockAttacker.Object), Times.Never);
				mockHex.Verify(_ => _.Receive(mockPlayer.Object), Times.Once);
				mockAttacker.Verify(_ => _.Gain(mockSupply.Object, It.IsAny<IGameObject>(), It.IsAny<int>(), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Tormentor_Play_Cards_In_Play_Blocked()
		{
			using (Card card = new Tormentor())
			{

				Initialize_ReceiveHex(card);
				var mockAttacker = new Mock<IPlayer>();
				var players = new PlayerCollection(mockGame.Object)
				{
					mockAttacker.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockGame.Setup(_ => _.GetPlayersStartingWithEnumerator(mockAttacker.Object)).Returns<IPlayer>(x => { var y = players.GetPlayersStartingWithEnumerator(x); return y; });
				mockPlayer.Setup(_ => _.AttackedByPlayerAllowed(mockAttacker.Object, card)).Returns(false);
				mockAttacker.SetupGet(_ => _._Game).Returns(mockGame.Object);
				mockAttacker.SetupGet(_ => _.Phase).Returns(PhaseEnum.Action);
				var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
				inPlay.AddRange(mockPlayer.Object, new List<Card> { new Imp() });
				mockAttacker.SetupGet(_ => _.InPlayAndSetAside).Returns(new DeckCollection(inPlay));

				var mockHexSupply = new Mock<IHexSupply>();
				var spec = new TableEntityCollection {
					{ TypeClass.Hexes, mockHexSupply.Object },
					{ TypeClass.Imp, mockSupply.Object }
				};
				mockTable.Setup(_ => _.SpecialPiles).Returns(spec);
				mockHexSupply.Setup(_ => _.TurnOverNext(mockPlayer.Object)).Returns(true);
				var mockHex = new Mock<IHex>();
				mockHexSupply.SetupGet(_ => _.TopDiscard).Returns(mockHex.Object);


				// Sets up the IsAttackBlocked dictionary properly
				card.PlaySetup(mockAttacker.Object);
				// Just sets the card in play
				card.FollowInstructions(mockAttacker.Object);


				mockHex.Verify(_ => _.Receive(mockAttacker.Object), Times.Never);
				mockHex.Verify(_ => _.Receive(mockPlayer.Object), Times.Never);
				mockAttacker.Verify(_ => _.Gain(mockSupply.Object, It.IsAny<IGameObject>(), It.IsAny<int>(), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Tormentor_Play_No_Cards_In_Play()
		{
			using (Card card = new Tormentor())
			{

				Initialize_ReceiveHex(card);
				var mockAttacker = new Mock<IPlayer>();
				var players = new PlayerCollection(mockGame.Object)
				{
					mockAttacker.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockGame.Setup(_ => _.GetPlayersStartingWithEnumerator(mockAttacker.Object)).Returns<IPlayer>(x => { var y = players.GetPlayersStartingWithEnumerator(x); return y; });
				mockPlayer.Setup(_ => _.AttackedByPlayerAllowed(mockAttacker.Object, card)).Returns(false);
				mockAttacker.SetupGet(_ => _._Game).Returns(mockGame.Object);
				mockAttacker.SetupGet(_ => _.Phase).Returns(PhaseEnum.Action);
				var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
				mockAttacker.SetupGet(_ => _.InPlayAndSetAside).Returns(new DeckCollection(inPlay));

				var mockHexSupply = new Mock<IHexSupply>();
				var spec = new TableEntityCollection {
					{ TypeClass.Hexes, mockHexSupply.Object },
					{ TypeClass.Imp, mockSupply.Object }
				};
				mockTable.Setup(_ => _.SpecialPiles).Returns(spec);
				mockHexSupply.Setup(_ => _.TurnOverNext(mockPlayer.Object)).Returns(true);
				var mockHex = new Mock<IHex>();
				mockHexSupply.SetupGet(_ => _.TopDiscard).Returns(mockHex.Object);


				// Sets up the IsAttackBlocked dictionary properly
				card.PlaySetup(mockAttacker.Object);
				// Just sets the card in play
				card.FollowInstructions(mockAttacker.Object);


				mockHex.Verify(_ => _.Receive(mockAttacker.Object), Times.Never);
				mockHex.Verify(_ => _.Receive(mockPlayer.Object), Times.Never);
				mockAttacker.Verify(_ => _.Gain(mockSupply.Object, card, 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Tracker_Basic()
		{
			using (var card = new Tracker())
			{
				Assert.AreEqual(new Cost(2), card.BaseCost);
				Assert.AreEqual(new Currency(1), card.Benefit.Currency);
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Fate, card.Category);
			}
		}
		[TestMethod]
		public void Test_Tracker_Setup()
		{
			using (Card card = new Tracker())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				// SpecialPiles should maybe be mocked as well??
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);
				mockTable.SetupGet(_ => _.Copper).Returns(mockSupply.Object);


				card.SetupSupply(mockGame.Object, mockSupply.Object);


				Assert.IsTrue(specialPiles.ContainsKey(TypeClass.Boons));
				mockSupply.Verify(_ => _.AddTo(It.IsAny<Pouch>(), 0), Times.AtLeastOnce);
			}
		}
		[TestMethod]
		public void Test_Tracker_Play()
		{
			using (Card card = new Tracker())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockTable.SetupGet(_ => _.Copper).Returns(mockSupply.Object);
				Initialize_ReceiveBoon(card);


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.ReceiveBenefit(It.IsAny<Boon>(), It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.AtLeastOnce);
			}
		}
		[TestMethod]
		public void Test_Tracker_Play_Gain_Card_No_Topdeck()
		{
			using (Card card = new Tracker())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockTable.SetupGet(_ => _.Copper).Returns(mockSupply.Object);
				Initialize_ReceiveBoon(card);


				// Sets up the CardGained event listener
				card.AddedTo(DeckLocation.InPlay, mockPlayer.Object);
				card.FollowInstructions(mockPlayer.Object);


				var gainedCard = new SecretCave();
				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, gainedCard, new DominionBase.Cards.Base.Remodel(), DeckLocation.Discard, DeckPosition.Automatic, false);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsTrue(cgeArgs.Resolvers.ContainsKey(TypeClass.Tracker.ToString()));
				Assert.IsFalse(cgeArgs.Cancelled);
				Assert.AreNotEqual(DeckLocation.Deck, cgeArgs.Location);
				Assert.AreNotEqual(DeckPosition.Top, cgeArgs.Position);
				Assert.IsFalse(cgeArgs.HandledBy.Contains(TypeClass.Tracker));
			}
		}
		[TestMethod]
		public void Test_Tracker_Play_Gain_Card_Topdeck()
		{
			using (Card card = new Tracker())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockTable.SetupGet(_ => _.Copper).Returns(mockSupply.Object);
				Initialize_ReceiveBoon(card);


				// Sets up the CardGained event listener
				card.AddedTo(DeckLocation.InPlay, mockPlayer.Object);
				card.FollowInstructions(mockPlayer.Object);


				var gainedCard = new SecretCave();
				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, gainedCard, new DominionBase.Cards.Base.Remodel(), DeckLocation.Discard, DeckPosition.Automatic, false);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsTrue(cgeArgs.Resolvers.ContainsKey(TypeClass.Tracker.ToString()));

				cgeArgs.Resolvers[TypeClass.Tracker.ToString()].Method(mockPlayer.Object, ref cgeArgs);

				Assert.IsTrue(cgeArgs.Cancelled);
				Assert.AreEqual(DeckLocation.Deck, cgeArgs.Location);
				Assert.AreEqual(DeckPosition.Top, cgeArgs.Position);


				// Remove it from play at the end (it shouldn't trigger the event)
				card.RemovedFrom(DeckLocation.InPlay, mockPlayer.Object);
				cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, gainedCard, new DominionBase.Cards.Base.Remodel(), DeckLocation.Discard, DeckPosition.Automatic, false);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsFalse(cgeArgs.Resolvers.ContainsKey(TypeClass.Tracker.ToString()));
			}
		}
		[TestMethod]
		public void Test_Tracker_Teardown()
		{
			using (Card card = new Tracker())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockTable.SetupGet(_ => _.Copper).Returns(mockSupply.Object);
				Initialize_ReceiveBoon(card);

				// Sets up the CardGained event listener
				card.AddedTo(DeckLocation.InPlay, mockPlayer.Object);
				card.FollowInstructions(mockPlayer.Object);

				var gainedCard = new SecretCave();
				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, gainedCard, new DominionBase.Cards.Base.Remodel(), DeckLocation.Discard, DeckPosition.Automatic, false);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsTrue(cgeArgs.Resolvers.ContainsKey(TypeClass.Tracker.ToString()));

				card.TearDown(mockGame.Object);


				// Verify the Teardown works correctly
				card.RemovedFrom(DeckLocation.InPlay, mockPlayer.Object);
				cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, gainedCard, new DominionBase.Cards.Base.Remodel(), DeckLocation.Discard, DeckPosition.Automatic, false);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsFalse(cgeArgs.Resolvers.ContainsKey(TypeClass.Tracker.ToString()));
			}
		}
		[TestMethod]
		public void Test_TragicHero_Basic()
		{
			using (var card = new TragicHero())
			{
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(3, card.Benefit.Cards);
				Assert.AreEqual(1, card.Benefit.Buys);
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
			}
		}
		[TestMethod]
		public void Test_TragicHero_Play_Simple()
		{
			using (Card card = new TragicHero())
			{
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				hand.AddRange(mockPlayer.Object, new List<Card> { new Cemetery(), new MagicLamp(), new SecretCave(), new Idol() });
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Trash(It.IsAny<IGameObject>(), card), Times.Never);
			}
		}
		[TestMethod]
		public void Test_TragicHero_Play_Big_Hand()
		{
			using (Card card = new TragicHero())
			{
				mockTable.SetupGet(_ => _.TableEntities).Returns(new TableEntityCollection());
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				hand.AddRange(mockPlayer.Object, new List<Card> { new Cemetery(), new MagicLamp(), new SecretCave(), new Idol(), new Idol(), new Idol(), new Idol(), new Idol() });
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
				mockPlayer.SetupGet(_ => _.InPlay).Returns(inPlay);
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(mockSupply.Object));


				inPlay.AddRange(mockPlayer.Object, new List<Card> { card });
				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Trash(card, card), Times.Once);
				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_TwiceMiserable_Basic()
		{
			using (var card = new TwiceMiserable())
			{
				Assert.AreEqual(Categories.State, card.Category);
				Assert.AreEqual(-4, card.VictoryPoints);
			}
		}
		[TestMethod]
		public void Test_Vampire_Basic()
		{
			using (var card = new Vampire())
			{
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(Categories.Card | Categories.Night | Categories.Attack | Categories.Doom, card.Category);
			}
		}
		[TestMethod]
		public void Test_Vampire_Setup()
		{
			using (Card card = new Vampire())
			{

				// SpecialPiles should maybe be mocked as well??
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

				card.SetupSupply(mockGame.Object, mockSupply.Object);

				Assert.IsTrue(specialPiles.ContainsKey(TypeClass.Hexes));
				Assert.IsTrue(specialPiles.ContainsKey(TypeClass.Bat));
			}
		}
		[TestMethod]
		public void Test_Vampire_Play_Not_Blocked()
		{
			using (Card card = new Vampire())
			{

				var mockVampireSupply = new Mock<ISupply>();
				Initialize_ReceiveHex(card);
				var mockAttacker = new Mock<IPlayer>();
				var players = new PlayerCollection(mockGame.Object)
				{
					mockAttacker.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockGame.Setup(_ => _.GetPlayersStartingWithEnumerator(mockAttacker.Object)).Returns<IPlayer>(x => { var y = players.GetPlayersStartingWithEnumerator(x); return y; });

				var mockHexSupply = new Mock<IHexSupply>();
				var mockBatSupply = new Mock<ISupply>();
				mockBatSupply.Setup(_ => _.Take(TypeClass.Bat)).Returns(new Bat());
				var spec = new TableEntityCollection
				{
					{ TypeClass.Hexes, mockHexSupply.Object },
					{ TypeClass.Bat, mockBatSupply.Object }
				};
				mockTable.SetupGet(_ => _.SpecialPiles).Returns(spec);
				var te = new TableEntityCollection();
				var mockSupply1 = new Mock<ISupply>();
				mockSupply1.Setup(_ => _.CanGain()).Returns(true);
				mockSupply1.SetupGet(_ => _.CurrentCost).Returns(new Cost(4));
				mockSupply1.SetupGet(_ => _.TopCard).Returns(new Bard());
				mockSupply1.SetupGet(_ => _.TableableType).Returns(TypeClass.Bard);
				te.Add(TypeClass.Bard, mockSupply1.Object);
				var mockSupply2 = new Mock<ISupply>();
				mockSupply2.Setup(_ => _.CanGain()).Returns(true);
				mockSupply2.SetupGet(_ => _.CurrentCost).Returns(new Cost(4));
				mockSupply2.SetupGet(_ => _.TopCard).Returns(new Cemetery());
				mockSupply2.SetupGet(_ => _.TableableType).Returns(TypeClass.Cemetery);
				te.Add(TypeClass.Cemetery, mockSupply2.Object);
				mockTable.SetupGet(_ => _.TableEntities).Returns(te);
				mockTable.Setup(_ => _.FindSupplyPileByType(TypeClass.Vampire, true)).Returns(mockVampireSupply.Object);
				mockTable.Setup(_ => _.FindSupplyPileByType(TypeClass.Bat, true)).Returns(mockBatSupply.Object);
				mockHexSupply.Setup(_ => _.TurnOverNext(mockAttacker.Object)).Returns(true);
				var mockHex = new Mock<IHex>();

				mockPlayer.Setup(_ => _.AttackedByPlayerAllowed(mockAttacker.Object, card)).Returns(true);
				mockHexSupply.SetupGet(_ => _.TopDiscard).Returns(mockHex.Object);
				mockAttacker.SetupGet(_ => _._Game).Returns(mockGame.Object);
				mockAttacker.SetupGet(_ => _.Phase).Returns(PhaseEnum.Night);
				var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
				mockAttacker.SetupGet(_ => _.InPlayAndSetAside).Returns(new DeckCollection(inPlay));
				mockAttacker.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Supplies))).Returns<Choice>(c => new ChoiceResult((ISupply)c.Supplies[TypeClass.Bard]));
				mockAttacker.Setup(_ => _.RetrieveCardFrom(It.IsAny<DeckLocation>(), card)).Returns(card);


				card.SetupSupply(mockGame.Object, mockSupply.Object);


				// Sets up the IsAttackBlocked dictionary properly
				card.PlaySetup(mockAttacker.Object);
				// Just sets the card in play
				inPlay.Add(card);
				card.FollowInstructions(mockAttacker.Object);


				mockHex.Verify(_ => _.Receive(mockAttacker.Object), Times.Never);
				mockHex.Verify(_ => _.Receive(mockPlayer.Object), Times.Once);
				mockAttacker.Verify(_ => _.Gain(mockSupply1.Object, card, 1, false), Times.Once);
				mockAttacker.Verify(_ => _.Lose(card), Times.Once);
				mockAttacker.Verify(_ => _.AddCardInto(DeckLocation.Discard, It.IsAny<Bat>(), It.IsAny<DeckPosition>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Vampire_Play_Blocked()
		{
			using (Card card = new Vampire())
			{

				var mockVampireSupply = new Mock<ISupply>();
				Initialize_ReceiveHex(card);
				var mockAttacker = new Mock<IPlayer>();
				var players = new PlayerCollection(mockGame.Object)
				{
					mockAttacker.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockGame.Setup(_ => _.GetPlayersStartingWithEnumerator(mockAttacker.Object)).Returns<IPlayer>(x => { var y = players.GetPlayersStartingWithEnumerator(x); return y; });
				mockPlayer.Setup(_ => _.AttackedByPlayerAllowed(mockAttacker.Object, card)).Returns(false);
				mockAttacker.SetupGet(_ => _._Game).Returns(mockGame.Object);
				mockAttacker.SetupGet(_ => _.Phase).Returns(PhaseEnum.Night);
				var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
				mockAttacker.SetupGet(_ => _.InPlayAndSetAside).Returns(new DeckCollection(inPlay));
				mockAttacker.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Supplies))).Returns(new ChoiceResult(mockSupply.Object));
				mockAttacker.Setup(_ => _.RetrieveCardFrom(It.IsAny<DeckLocation>(), card)).Returns(card);

				var mockHexSupply = new Mock<IHexSupply>();
				var mockBatSupply = new Mock<ISupply>();
				mockBatSupply.Setup(_ => _.Take(TypeClass.Bat)).Returns(new Bat());
				var spec = new TableEntityCollection
				{
					{ TypeClass.Hexes, mockHexSupply.Object },
					{ TypeClass.Bat, mockBatSupply.Object }
				};
				mockTable.SetupGet(_ => _.SpecialPiles).Returns(spec);
				mockTable.SetupGet(_ => _.TableEntities).Returns(new TableEntityCollection());
				mockTable.Setup(_ => _.FindSupplyPileByType(TypeClass.Vampire, true)).Returns(mockVampireSupply.Object);
				mockTable.Setup(_ => _.FindSupplyPileByType(TypeClass.Bat, true)).Returns(mockBatSupply.Object);
				mockHexSupply.Setup(_ => _.TurnOverNext(mockAttacker.Object)).Returns(true);
				var mockHex = new Mock<IHex>();
				mockHexSupply.SetupGet(_ => _.TopDiscard).Returns(mockHex.Object);

				card.SetupSupply(mockGame.Object, mockSupply.Object);


				// Sets up the IsAttackBlocked dictionary properly
				card.PlaySetup(mockAttacker.Object);
				// Just sets the card in play
				inPlay.Add(card);
				card.FollowInstructions(mockAttacker.Object);


				mockHexSupply.Verify(_ => _.TurnOverNext(mockAttacker.Object), Times.Once);
				mockHex.Verify(_ => _.Receive(mockAttacker.Object), Times.Never);
				mockHex.Verify(_ => _.Receive(mockPlayer.Object), Times.Never);
				mockAttacker.Verify(_ => _.Gain(mockSupply.Object, card, 1, false), Times.Once);
				mockAttacker.Verify(_ => _.Lose(card), Times.Once);
				mockAttacker.Verify(_ => _.AddCardInto(DeckLocation.Discard, It.IsAny<Bat>(), It.IsAny<DeckPosition>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_War_Basic()
		{
			using (var card = new War())
			{
				Assert.AreEqual(Categories.Hex, card.Category);
			}
		}
		[TestMethod]
		public void Test_War_Receive_Trash_First_Card()
		{
			using (Hex card = new War())
			{
				mockTable.SetupGet(_ => _.Curse).Returns(mockSupply.Object);
				var revealed = new Deck(DeckLocation.Revealed, Visibility.All, VisibilityTo.All);
				mockPlayer.SetupGet(_ => _.Revealed).Returns(revealed);
				mockPlayer.SetupGet(_ => _.CanDraw).Returns(true);
				mockPlayer.Setup(_ => _.Draw(DeckLocation.Revealed)).Callback(() => { revealed.AddRange(mockPlayer.Object, new List<Card> { new GhostTown() }); });


				card.Receive(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Trash(card, It.IsAny<Card>()), Times.Once);
				mockPlayer.Verify(_ => _.DiscardRevealed(), Times.Once);
			}
		}
		[TestMethod]
		public void Test_War_Receive_Trash_After_Several_Cards()
		{
			using (Hex card = new War())
			{
				mockTable.SetupGet(_ => _.Curse).Returns(mockSupply.Object);
				var revealed = new Deck(DeckLocation.Revealed, Visibility.All, VisibilityTo.All);
				mockPlayer.SetupGet(_ => _.Revealed).Returns(revealed);
				mockPlayer.SetupGet(_ => _.CanDraw).Returns(true);
				mockPlayer.Setup(_ => _.Draw(DeckLocation.Revealed)).Callback(() =>
				{
					if (revealed.Count > 5)
						revealed.AddRange(mockPlayer.Object, new List<Card> { new GhostTown() });
					else
						revealed.AddRange(mockPlayer.Object, new List<Card> { new Pooka() });
				});


				card.Receive(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Draw(DeckLocation.Revealed), Times.Exactly(7));
				mockPlayer.Verify(_ => _.Trash(card, It.IsAny<Card>()), Times.Once);
				mockPlayer.Verify(_ => _.DiscardRevealed(), Times.Once);
			}
		}
		[TestMethod]
		public void Test_War_Receive_Nothing_To_Trash()
		{
			using (Hex card = new War())
			{
				mockTable.SetupGet(_ => _.Curse).Returns(mockSupply.Object);
				var revealed = new Deck(DeckLocation.Revealed, Visibility.All, VisibilityTo.All);
				mockPlayer.SetupGet(_ => _.Revealed).Returns(revealed);
				mockPlayer.SetupGet(_ => _.CanDraw).Returns(() => { return revealed.Count <= 5; });
				mockPlayer.Setup(_ => _.Draw(DeckLocation.Revealed)).Callback(() => { revealed.AddRange(mockPlayer.Object, new List<Card> { new Pooka() }); });


				card.Receive(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Draw(DeckLocation.Revealed), Times.Exactly(6));
				mockPlayer.Verify(_ => _.Trash(It.IsAny<IGameObject>(), It.IsAny<Card>()), Times.Never);
				mockPlayer.Verify(_ => _.DiscardRevealed(), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Werewolf_Basic()
		{
			using (var card = new Werewolf())
			{
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Night | Categories.Attack | Categories.Doom, card.Category);
			}
		}
		[TestMethod]
		public void Test_Werewolf_Setup()
		{
			using (Card card = new Werewolf())
			{

				// SpecialPiles should maybe be mocked as well??
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

				card.SetupSupply(mockGame.Object, mockSupply.Object);

				Assert.IsTrue(specialPiles.ContainsKey(TypeClass.Hexes));
			}
		}
		[TestMethod]
		public void Test_Werewolf_Play_Night_Not_Blocked()
		{
			using (Card card = new Werewolf())
			{

				Initialize_ReceiveHex(card);
				var mockAttacker = new Mock<IPlayer>();
				var players = new PlayerCollection(mockGame.Object)
				{
					mockAttacker.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockGame.Setup(_ => _.GetPlayersStartingWithEnumerator(mockAttacker.Object)).Returns<IPlayer>(x => { var y = players.GetPlayersStartingWithEnumerator(x); return y; });
				mockPlayer.Setup(_ => _.AttackedByPlayerAllowed(mockAttacker.Object, card)).Returns(true);
				mockAttacker.SetupGet(_ => _._Game).Returns(mockGame.Object);
				mockAttacker.SetupGet(_ => _.Phase).Returns(PhaseEnum.Night);
				var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
				mockAttacker.SetupGet(_ => _.InPlay).Returns(inPlay);
				mockAttacker.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Supplies))).Returns(new ChoiceResult(mockSupply.Object));

				var mockHexSupply = new Mock<IHexSupply>();
				var spec = new TableEntityCollection { { TypeClass.Hexes, mockHexSupply.Object } };
				mockTable.SetupGet(_ => _.SpecialPiles).Returns(spec);
				mockTable.SetupGet(_ => _.TableEntities).Returns(new TableEntityCollection());
				mockHexSupply.Setup(_ => _.TurnOverNext(mockAttacker.Object)).Returns(true);
				var mockHex = new Mock<IHex>();
				mockHexSupply.SetupGet(_ => _.TopDiscard).Returns(mockHex.Object);

				card.SetupSupply(mockGame.Object, mockSupply.Object);


				// Sets up the IsAttackBlocked dictionary properly
				card.PlaySetup(mockAttacker.Object);
				// Just sets the card in play
				card.FollowInstructions(mockAttacker.Object);


				mockHex.Verify(_ => _.Receive(mockAttacker.Object), Times.Never);
				mockHex.Verify(_ => _.Receive(mockPlayer.Object), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Werewolf_Play_Night_Blocked()
		{
			using (Card card = new Werewolf())
			{

				Initialize_ReceiveHex(card);
				var mockAttacker = new Mock<IPlayer>();
				var players = new PlayerCollection(mockGame.Object)
				{
					mockAttacker.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockGame.Setup(_ => _.GetPlayersStartingWithEnumerator(mockAttacker.Object)).Returns<IPlayer>(x => { var y = players.GetPlayersStartingWithEnumerator(x); return y; });
				mockPlayer.Setup(_ => _.AttackedByPlayerAllowed(mockAttacker.Object, card)).Returns(false);
				mockAttacker.SetupGet(_ => _._Game).Returns(mockGame.Object);
				mockAttacker.SetupGet(_ => _.Phase).Returns(PhaseEnum.Night);
				var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
				mockAttacker.SetupGet(_ => _.InPlay).Returns(inPlay);
				mockAttacker.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Supplies))).Returns(new ChoiceResult(mockSupply.Object));

				var mockHexSupply = new Mock<IHexSupply>();
				var spec = new TableEntityCollection { {  TypeClass.Hexes, mockHexSupply.Object } };
				mockTable.SetupGet(_ => _.SpecialPiles).Returns(spec);
				mockTable.SetupGet(_ => _.TableEntities).Returns(new TableEntityCollection());
				mockHexSupply.Setup(_ => _.TurnOverNext(mockAttacker.Object)).Returns(true);
				var mockHex = new Mock<IHex>();
				mockHexSupply.SetupGet(_ => _.TopDiscard).Returns(mockHex.Object);

				card.SetupSupply(mockGame.Object, mockSupply.Object);


				// Sets up the IsAttackBlocked dictionary properly
				card.PlaySetup(mockAttacker.Object);
				// Just sets the card in play
				card.FollowInstructions(mockAttacker.Object);


				mockHexSupply.Verify(_ => _.TurnOverNext(mockAttacker.Object), Times.Once);
				mockHex.Verify(_ => _.Receive(mockAttacker.Object), Times.Never);
				mockHex.Verify(_ => _.Receive(mockPlayer.Object), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Werewolf_Play_Action()
		{
			using (Card card = new Werewolf())
			{

				Initialize_ReceiveHex(card);
				var players = new PlayerCollection(mockGame.Object);
				var mockAttacker = new Mock<IPlayer>();
				players.Add(mockAttacker.Object);
				players.Add(mockPlayer.Object);
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockGame.Setup(_ => _.GetPlayersStartingWithEnumerator(mockAttacker.Object)).Returns<IPlayer>(x => { var y = players.GetPlayersStartingWithEnumerator(x); return y; });
				mockPlayer.Setup(_ => _.AttackedByPlayerAllowed(mockAttacker.Object, card)).Returns(true);
				mockAttacker.SetupGet(_ => _._Game).Returns(mockGame.Object);
				mockAttacker.SetupGet(_ => _.Phase).Returns(PhaseEnum.Action);
				var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
				mockAttacker.SetupGet(_ => _.InPlay).Returns(inPlay);
				mockAttacker.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Supplies))).Returns(new ChoiceResult(mockSupply.Object));

				var mockHexSupply = new Mock<IHexSupply>();
				var spec = new TableEntityCollection { { TypeClass.Hexes, mockHexSupply.Object } };
				mockTable.SetupGet(_ => _.SpecialPiles).Returns(spec);
				mockTable.SetupGet(_ => _.TableEntities).Returns(new TableEntityCollection());
				mockHexSupply.Setup(_ => _.TurnOverNext(mockPlayer.Object)).Returns(true);
				var mockHex = new Mock<IHex>();
				mockHexSupply.SetupGet(_ => _.TopDiscard).Returns(mockHex.Object);

				card.SetupSupply(mockGame.Object, mockSupply.Object);


				// Sets up the IsAttackBlocked dictionary properly
				card.PlaySetup(mockAttacker.Object);
				// Just sets the card in play
				card.FollowInstructions(mockAttacker.Object);


				mockHex.Verify(_ => _.Receive(mockAttacker.Object), Times.Never);
				mockHex.Verify(_ => _.Receive(mockPlayer.Object), Times.Never);
				mockAttacker.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards == 3), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_WillOWisp_Basic()
		{
			using (var card = new WillOWisp())
			{
				Assert.AreEqual(new Cost(0, special: true), card.BaseCost);
				Assert.AreEqual(1, card.Benefit.Cards);
				Assert.AreEqual(1, card.Benefit.Actions);
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Spirit, card.Category);
			}
		}
		[TestMethod]
		public void Test_WillOWisp_Play_No_Draw()
		{
			using (Card card = new WillOWisp())
			{

				var deck = new Deck(DeckLocation.Hand, Visibility.None, VisibilityTo.Owner);
				var deckCards = new List<Card> { new Cemetery(), new MagicLamp(), new SecretCave(), new Idol() };
				deck.AddRange(mockPlayer.Object, deckCards);
				mockPlayer.SetupGet(_ => _.DrawPile).Returns(deck);
				mockPlayer.Setup(_ => _.Draw(1, DeckLocation.Revealed)).Returns(new ItemCollection<Card>(deckCards.First()));
				mockPlayer.Setup(_ => _.RetrieveCardsFrom(DeckLocation.Revealed, It.IsAny<ItemCollection<Card>>())).Returns<DeckLocation, ItemCollection<Card>>((dl, c) => c);
				mockPlayer.Setup(_ => _.RetrieveCardsFrom(DeckLocation.Revealed)).Returns(new ItemCollection<Card>(deckCards.First()));


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.AddCardsToHand(It.Is<ItemCollection<Card>>(ic => ic.Count != 0)), Times.Never);
				mockPlayer.Verify(_ => _.AddCardsToDeck(It.Is<ItemCollection<Card>>(ic => ic.Count != 0), DeckPosition.Top), Times.Once);
			}
		}
		[TestMethod]
		public void Test_WillOWisp_Play_Draw()
		{
			using (Card card = new WillOWisp())
			{

				var deck = new Deck(DeckLocation.Hand, Visibility.None, VisibilityTo.Owner);
				var deckCards = new List<Card> { new MagicLamp(), new Cemetery(), new SecretCave(), new Idol() };
				deck.AddRange(mockPlayer.Object, deckCards);
				mockPlayer.SetupGet(_ => _.DrawPile).Returns(deck);
				mockPlayer.Setup(_ => _.Draw(1, DeckLocation.Revealed)).Returns(new ItemCollection<Card>(deckCards.First()));
				mockPlayer.Setup(_ => _.RetrieveCardsFrom(DeckLocation.Revealed, It.IsAny<ItemCollection<Card>>())).Returns<DeckLocation, ItemCollection<Card>>((dl, c) => c);
				mockPlayer.Setup(_ => _.RetrieveCardsFrom(DeckLocation.Revealed)).Returns(new ItemCollection<Card>());


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.AddCardsToHand(It.Is<ItemCollection<Card>>(ic => ic.Count != 0)), Times.Once);
				mockPlayer.Verify(_ => _.AddCardsToDeck(It.Is<ItemCollection<Card>>(ic => ic.Count != 0), DeckPosition.Top), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Wish_Basic()
		{
			using (var card = new Wish())
			{
				Assert.AreEqual(new Cost(0, special: true), card.BaseCost);
				Assert.AreEqual(1, card.Benefit.Actions);
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
			}
		}
		[TestMethod]
		public void Test_Wish_Play_Return_Gain()
		{
			using (Card card = new Wish())
			{
				var mockWishSupply = new Mock<ISupply>();
				var tableEntities = new TableEntityCollection { { TypeClass.BlessedVillage, mockSupply.Object } };
				mockTable.SetupGet(_ => _.TableEntities).Returns(tableEntities);
				mockSupply.SetupGet(_ => _.TableableType).Returns(TypeClass.BlessedVillage);
				mockSupply.Setup(_ => _.CanGain()).Returns(true);
				mockSupply.SetupGet(_ => _.CurrentCost).Returns(new Cost(4));
				mockTable.Setup(_ => _.FindSupplyPileByType(TypeClass.Wish, It.IsAny<bool>())).Returns(mockWishSupply.Object);
				var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
				mockPlayer.SetupGet(_ => _.InPlayAndSetAside).Returns(new DeckCollection(inPlay));
				mockPlayer.Setup(_ => _.RetrieveCardFrom(DeckLocation.InPlay, card)).Returns(card);
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(mockSupply.Object));


				inPlay.AddRange(mockPlayer.Object, new List<Card> { card });
				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Lose(card), Times.Once);
				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, DeckLocation.Hand, It.IsAny<DeckPosition>(), 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Wish_Play_Already_Returned()
		{
			using (Card card = new Wish())
			{

				var mockWishSupply = new Mock<ISupply>();
				mockTable.SetupGet(_ => _.TableEntities).Returns(new TableEntityCollection());
				mockTable.Setup(_ => _.FindSupplyPileByType(TypeClass.Wish, It.IsAny<bool>())).Returns(mockWishSupply.Object);
				var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
				mockPlayer.SetupGet(_ => _.InPlayAndSetAside).Returns(new DeckCollection(inPlay));
				mockPlayer.Setup(_ => _.RetrieveCardFrom(DeckLocation.InPlay, card)).Returns(card);
				mockPlayer.Setup(_ => _.RetrieveCardFrom(DeckLocation.SetAside, card)).Returns<Card>(null);
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(mockSupply.Object));


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Lose(card), Times.Never);
				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, It.IsAny<IGameObject>(), DeckLocation.Hand, It.IsAny<DeckPosition>(), 1, false), Times.Never);
			}
		}
		[TestMethod]
		public void Test_ZombieApprentice_Basic()
		{
			using (var card = new ZombieApprentice())
			{
				Assert.AreEqual(new Cost(3), card.BaseCost);
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Zombie, card.Category);
			}
		}
		[TestMethod]
		public void Test_ZombieApprentice_Play_No_Trash()
		{
			using (Card card = new ZombieApprentice())
			{

				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				hand.AddRange(mockPlayer.Object, new List<Card> { new Bard(), new Cemetery(), new Imp(), new Idol() });
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards))).Returns<Choice>(c => new ChoiceResult(new ItemCollection<Card>()));


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Trash(It.IsAny<IGameObject>(), It.IsAny<Card>()), Times.Never);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Actions == 1 && cb.Cards == 3), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_ZombieApprentice_Play_Trash()
		{
			using (Card card = new ZombieApprentice())
			{

				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				hand.AddRange(mockPlayer.Object, new List<Card> { new Bard(), new Cemetery(), new Imp(), new Idol() });
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards))).Returns<Choice>(c => new ChoiceResult(new ItemCollection<Card>(c.Cards.First())));


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Trash(card, It.Is<Card>(c => hand.Contains(c))), Times.Once);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Actions == 1 && cb.Cards == 3), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_ZombieMason_Basic()
		{
			using (var card = new ZombieMason())
			{
				Assert.AreEqual(new Cost(3), card.BaseCost);
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Zombie, card.Category);
			}
		}
		[TestMethod]
		public void Test_ZombieMason_Play_Trash_Gain()
		{
			using (Card card = new ZombieMason())
			{
				var tableEntities = new TableEntityCollection { { TypeClass.Vampire, mockSupply.Object } };
				mockTable.SetupGet(_ => _.TableEntities).Returns(tableEntities);
				mockSupply.SetupGet(_ => _.TableableType).Returns(TypeClass.Vampire);
				mockSupply.Setup(_ => _.CanGain()).Returns(true);
				mockSupply.SetupGet(_ => _.CurrentCost).Returns(new Cost(5));
				mockPlayer.SetupGet(_ => _.CanDraw).Returns(true);
				mockPlayer.Setup(_ => _.Draw(DeckLocation.Revealed)).Returns(new Bard());
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(mockSupply.Object));


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_ZombieMason_Play_Trash_No_Gain()
		{
			using (Card card = new ZombieMason())
			{
				mockTable.SetupGet(_ => _.TableEntities).Returns(new TableEntityCollection());
				mockPlayer.SetupGet(_ => _.CanDraw).Returns(true);
				mockPlayer.Setup(_ => _.Draw(DeckLocation.Revealed)).Returns(new Bard());
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult((ISupply)null));


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, It.IsAny<IGameObject>(), 1, false), Times.Never);
			}
		}
		[TestMethod]
		public void Test_ZombieSpy_Basic()
		{
			using (var card = new ZombieSpy())
			{
				Assert.AreEqual(new Cost(3), card.BaseCost);
				Assert.AreEqual(1, card.Benefit.Cards);
				Assert.AreEqual(1, card.Benefit.Actions);
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Zombie, card.Category);
			}
		}
		[TestMethod]
		public void Test_ZombieSpy_Play_Discard()
		{
			using (Card card = new ZombieSpy())
			using (Card decideCard = new Cemetery())
			{
				mockPlayer.Setup(_ => _.Draw(1, DeckLocation.Private)).Returns(new ItemCollection<Card>(decideCard));
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options))).Returns(new ChoiceResult(new List<string> { ResourcesHelper.Get("Discard") }));


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Discard(DeckLocation.Private), Times.Once);
				mockPlayer.Verify(_ => _.AddCardsToDeck(It.IsAny<IEnumerable<Card>>(), It.IsAny<DeckPosition>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_ZombieSpy_Play_Put_Back()
		{
			using (Card card = new ZombieSpy())
			using (Card decideCard = new Cemetery())
			{
				mockPlayer.Setup(_ => _.Draw(1, DeckLocation.Private)).Returns(new ItemCollection<Card>(decideCard));
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options))).Returns(new ChoiceResult(new List<string> { ResourcesHelper.Get("PutItBack") }));
				mockPlayer.Setup(_ => _.RetrieveCardsFrom(DeckLocation.Private)).Returns(new ItemCollection<Card>(decideCard));


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Discard(DeckLocation.Private), Times.Never);
				mockPlayer.Verify(_ => _.AddCardsToDeck(new List<Card> { decideCard }, DeckPosition.Top), Times.Once);
			}
		}
		[TestMethod]
		public void Test_ZombieSpy_Play_No_Deck()
		{
			using (Card card = new ZombieSpy())
			using (Card decideCard = new Cemetery())
			{
				mockPlayer.Setup(_ => _.Draw(1, DeckLocation.Private)).Returns(new ItemCollection<Card>());


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Never);
				mockPlayer.Verify(_ => _.Discard(DeckLocation.Private), Times.Never);
				mockPlayer.Verify(_ => _.AddCardsToDeck(It.IsAny<IEnumerable<Card>>(), It.IsAny<DeckPosition>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_MultipleFate_Setup()
		{
			using (var fateCard1 = new BlessedVillage())
			using (var fateCard2 = new SacredGrove())
			{

				// SpecialPiles should maybe be mocked as well??
				var specialPiles = new TableEntityCollection();
				mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

				fateCard1.SetupSupply(mockGame.Object, mockSupply.Object);
				fateCard2.SetupSupply(mockGame.Object, mockSupply.Object);

				Assert.IsTrue(specialPiles.ContainsKey(TypeClass.Boons));
				Assert.AreEqual(12, specialPiles[TypeClass.Boons].Count);
			}
		}
	}
}