using DominionBase;
using DominionBase.Cards;
using DominionBase.Cards.Menagerie;
using DominionBase.Currencies;
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 UnitTestMenagerie : UnitTestCards
	{
		[TestMethod]
		public void Test_Alliance_Basic()
		{
			using (var card = new Alliance())
			{
				Assert.AreEqual(Categories.Event, card.Category);
				Assert.AreEqual(new Cost(10), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Alliance_Bought()
		{
			var mockProvince = new Mock<ISupply>();
			var mockDuchy = new Mock<ISupply>();
			var mockEstate = new Mock<ISupply>();
			var mockGold = new Mock<ISupply>();
			var mockSilver = new Mock<ISupply>();
			var mockCopper = new Mock<ISupply>();
			mockTable.SetupGet(_ => _.Province).Returns(mockProvince.Object);
			mockTable.SetupGet(_ => _.Duchy).Returns(mockDuchy.Object);
			mockTable.SetupGet(_ => _.Estate).Returns(mockEstate.Object);
			mockTable.SetupGet(_ => _.Gold).Returns(mockGold.Object);
			mockTable.SetupGet(_ => _.Silver).Returns(mockSilver.Object);
			mockTable.SetupGet(_ => _.Copper).Returns(mockCopper.Object);

			using (Event card = new Alliance())
			{
				card.Bought(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(It.IsAny<ISupply>(), card, 1, false), Times.Exactly(6));
				mockPlayer.Verify(_ => _.Gain(mockProvince.Object, card, 1, false), Times.Once);
				mockPlayer.Verify(_ => _.Gain(mockDuchy.Object, card, 1, false), Times.Once);
				mockPlayer.Verify(_ => _.Gain(mockEstate.Object, card, 1, false), Times.Once);
				mockPlayer.Verify(_ => _.Gain(mockGold.Object, card, 1, false), Times.Once);
				mockPlayer.Verify(_ => _.Gain(mockSilver.Object, card, 1, false), Times.Once);
				mockPlayer.Verify(_ => _.Gain(mockCopper.Object, card, 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_AnimalFair_Basic()
		{
			using (var card = new AnimalFair())
			{
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
				Assert.AreEqual(new Cost(7, special: true), card.BaseCost);
				Assert.AreEqual(4, card.Benefit.Currency.Coin.Value);
			}
		}
		[TestMethod]
		public void Test_AnimalFair_Play_No_Empty_Piles()
		{
			mockTable.SetupGet(_ => _.EmptySupplyPiles).Returns(0);

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


				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_AnimalFair_Play_One_Empty_Pile()
		{
			mockTable.SetupGet(_ => _.EmptySupplyPiles).Returns(1);

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


				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Exactly(2));
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Buys == 1), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_AnimalFair_Can_Buy_7_Coins_No_Actions()
		{
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);

			using (Card card = new AnimalFair())
			using (Currency currency = new Currency(7))
			{
				Assert.IsTrue(card.CanBuy(mockPlayer.Object, currency));
			}
		}
		[TestMethod]
		public void Test_AnimalFair_Can_Buy_2_Coins_No_Actions()
		{
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);

			using (Card card = new AnimalFair())
			using (Currency currency = new Currency(2))
			{
				Assert.IsFalse(card.CanBuy(mockPlayer.Object, currency));
			}
		}
		[TestMethod]
		public void Test_AnimalFair_Can_Buy_7_Coins_Action_In_Hand()
		{
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner)
			{
				new Groom()
			};
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);

			using (Card card = new AnimalFair())
			using (Currency currency = new Currency(7))
			{
				Assert.IsTrue(card.CanBuy(mockPlayer.Object, currency));
			}
		}
		[TestMethod]
		public void Test_AnimalFair_Can_Buy_2_Coins_Action_In_Hand()
		{
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner)
			{
				new Groom()
			};
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);

			using (Card card = new AnimalFair())
			using (Currency currency = new Currency(2))
			{
				Assert.IsTrue(card.CanBuy(mockPlayer.Object, currency));
			}
		}
		[TestMethod]
		public void Test_AnimalFair_Pay_For_With_Coins()
		{
			var mockOpponent = new Mock<IPlayer>();
			var players = new PlayerCollection(mockGame.Object)
			{
				mockPlayer.Object,
				mockOpponent.Object
			};
			mockGame.SetupGet(_ => _.Players).Returns(players);
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.Options.Count == 1)))
				.Returns((Choice c) => new ChoiceResult(new List<string> { c.Options[0].Text }));

			using (Card card = new AnimalFair())
			using (Currency currency = new Currency(7))
			{
				card.SetupCard(mockGame.Object);


				var cpeArgs = new CardPayEventArgs(card, currency, new Currency(7));
				mockPlayer.Raise(_ => _.CardPaying += null, cpeArgs);

				Assert.IsTrue(cpeArgs.Resolvers.Values.Any());
				cpeArgs.Resolvers.Values.First().Method(mockPlayer.Object, ref cpeArgs);
				Assert.IsTrue(cpeArgs.HandledBy.Contains(card));

				mockPlayer.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Once);
				mockPlayer.Verify(_ => _.Trash(card, It.IsAny<Card>()), Times.Never);
				mockPlayer.Verify(_ => _.Trash(card, It.IsAny<ItemCollection<Card>>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_AnimalFair_Pay_For_With_Action_Card()
		{
			var mockOpponent = new Mock<IPlayer>();
			var players = new PlayerCollection(mockGame.Object)
			{
				mockPlayer.Object,
				mockOpponent.Object
			};
			mockGame.SetupGet(_ => _.Players).Returns(players);
			var toTrash = new BlackCat();
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner)
			{
				toTrash
			};
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options && c.Options.Count == 2)))
				.Returns((Choice c) => new ChoiceResult(new List<string> { c.Options[1].Text }));
			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)))
				.Returns((Choice c) => new ChoiceResult(new ItemCollection<Card> { toTrash }));

			using (Card card = new AnimalFair())
			using (Currency currency = new Currency(7))
			{
				card.SetupCard(mockGame.Object);


				var cpeArgs = new CardPayEventArgs(card, currency, new Currency(7));
				mockPlayer.Raise(_ => _.CardPaying += null, cpeArgs);

				Assert.IsTrue(cpeArgs.Resolvers.Values.Any());
				cpeArgs.Resolvers.Values.First().Method(mockPlayer.Object, ref cpeArgs);
				Assert.IsTrue(cpeArgs.HandledBy.Contains(card));

				mockPlayer.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Exactly(2));
				mockPlayer.Verify(_ => _.Trash(card, It.Is<ItemCollection<Card>>(ic => ic.Count == 1 && ic[0] == toTrash)), Times.Once);
			}
		}
		[TestMethod]
		public void Test_AnimalFair_Teardown()
		{
			var mockOpponent = new Mock<IPlayer>();
			var players = new PlayerCollection(mockGame.Object)
			{
				mockPlayer.Object,
				mockOpponent.Object
			};
			mockGame.SetupGet(_ => _.Players).Returns(players);

			using (Card card = new AnimalFair())
			using (Currency currency = new Currency(7))
			{
				card.SetupCard(mockGame.Object);

				card.TearDown(mockGame.Object);

				var cpeArgs = new CardPayEventArgs(card, currency, new Currency(7));
				mockPlayer.Raise(_ => _.CardPaying += null, cpeArgs);

				Assert.IsFalse(cpeArgs.Resolvers.Values.Any());
			}
		}
		[TestMethod]
		public void Test_Banish_Basic()
		{
			using (var card = new Banish())
			{
				Assert.AreEqual(Categories.Event, card.Category);
				Assert.AreEqual(new Cost(4), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Banish_Bought()
		{
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner)
			{
				new BlackCat(),
				new BlackCat(),
				new Supplies(),
				new Groom()
			};
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)))
				.Returns((Choice c) => new ChoiceResult(new CardCollection { c.Cards.First() }));
			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options)))
				.Returns((Choice c) => new ChoiceResult(new List<string> { c.Options.Last().Text }));
			mockPlayer
				.Setup(_ => _.RetrieveCardsFrom(DeckLocation.Hand, It.IsAny<Predicate<Card>>(), It.IsAny<int>()))
				.Returns((DeckLocation dl, Predicate<Card> predicate, int c) =>
				{
					return hand.Retrieve(mockPlayer.Object, DeckPosition.Automatic, predicate, c);
				});

			using (Event card = new Banish())
			{
				card.Bought(mockPlayer.Object);


				mockPlayer.Verify(_ => _.AddCardsInto(TypeClass.Exile,
					It.Is<IEnumerable<Card>>(ic => ic.Count() == 2 && ic.All(c => c.Name == ic.ElementAt(0).Name)),
					It.IsAny<DeckPosition>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Banish_Bought_No_Hand()
		{
			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((Choice c) => new ChoiceResult(new CardCollection()));

			using (Event card = new Banish())
			{
				card.Bought(mockPlayer.Object);


				mockPlayer.Verify(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options)), Times.Never);
				mockPlayer.Verify(_ => _.RetrieveCardsFrom(DeckLocation.Hand, It.IsAny<Predicate<Card>>(), It.IsAny<int>()), Times.Never);
				mockPlayer.Verify(_ => _.AddCardsInto(TypeClass.Exile, It.IsAny<IEnumerable<Card>>(), It.IsAny<DeckPosition>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Bargain_Basic()
		{
			using (var card = new Bargain())
			{
				Assert.AreEqual(Categories.Event, card.Category);
				Assert.AreEqual(new Cost(4), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Bargain_Setup_Correctly()
		{
			// SpecialPiles should maybe be mocked as well??
			var specialPiles = new TableEntityCollection();
			mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

			using (var card = new Bargain())
			{
				card.Finalize(mockGame.Object);


				Assert.IsTrue(specialPiles.ContainsKey(TypeClass.Horse));
			}
		}
		[TestMethod]
		public void Test_Bargain_Bought_2_Player()
		{
			var mockOpponent = new Mock<IPlayer>();
			var players = new PlayerCollection(mockGame.Object)
			{
				mockPlayer.Object,
				mockOpponent.Object
			};
			mockGame.SetupGet(_ => _.Players).Returns(players);
			mockGame.Setup(_ => _.GetPlayersStartingWithEnumerator(mockPlayer.Object)).Returns<IPlayer>(x => { var y = players.GetPlayersStartingWithEnumerator(x); return y; });

			var gainType = TypeClass.Supplies;
			var supplies = new TableEntityCollection
			{
				{ gainType, mockSupply.Object }
			};
			mockTable.SetupGet(_ => _.TableEntities).Returns(supplies);
			// SpecialPiles should maybe be mocked as well??
			var specialPiles = new TableEntityCollection();
			mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

			var toGain = new Mock<ICost>();
			toGain.SetupGet(_ => _.Type).Returns(gainType);
			mockSupply.SetupGet(_ => _.TopCard).Returns(toGain.Object);
			mockSupply.Setup(_ => _.CanGain()).Returns(true);
			mockSupply.SetupGet(_ => _.CurrentCost).Returns(new Cost(2));
			mockSupply.SetupGet(_ => _.TableableType).Returns(gainType);

			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(mockSupply.Object));
			mockPlayer
				.Setup(_ => _.Gain(It.IsAny<ISupply>(), It.IsAny<IGameObject>(), It.IsAny<int>(), It.IsAny<bool>()))
				.Returns(true);

			using (Event card = new Bargain())
			{
				card.Finalize(mockGame.Object);
				mockTable.SetupGet(_ => _[TypeClass.Horse]).Returns(specialPiles[TypeClass.Horse]);


				card.Bought(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, 1, false), Times.Once);
				mockPlayer.Verify(_ => _.Gain(It.Is<ISupply>(s => s.Type == TypeClass.Horse), card, It.IsAny<int>(), It.IsAny<bool>()), Times.Never);

				mockOpponent.Verify(_ => _.Gain(It.Is<ISupply>(s => s.Type == TypeClass.Horse), card, 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Barge_Basic()
		{
			using (var card = new Barge())
			{
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Duration, card.Category);
				Assert.AreEqual(new Cost(5), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Barge_Play_Now()
		{
			mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options))).Returns(new ChoiceResult(new List<string> { ResourcesHelper.Get("Now") }));

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


				Assert.IsTrue(card.CanCleanUp);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards == 3 && cb.Buys == 1), It.IsAny<bool>()), 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_Barge_Play_Next_Turn()
		{
			mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options))).Returns(new ChoiceResult(new List<string> { ResourcesHelper.Get("NextTurn") }));

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


				Assert.IsFalse(card.CanCleanUp);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Once);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards == 3 && cb.Buys == 1), It.IsAny<bool>()), Times.Never);

				// 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.Cards == 3 && cb.Buys == 1), It.IsAny<bool>()), Times.Once);

			}
		}
		[TestMethod]
		public void Test_Barge_Teardown()
		{
			using (Card card = new Barge())
			{
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options))).Returns(new ChoiceResult(new List<string> { ResourcesHelper.Get("NextTurn") }));


				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_BlackCat_Basic()
		{
			using (var card = new BlackCat())
			{
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Attack | Categories.Reaction, card.Category);
				Assert.AreEqual(new Cost(2), card.BaseCost);
				Assert.AreEqual(2, card.Benefit.Cards);
			}
		}
		[TestMethod]
		public void Test_BlackCat_Play_During_Turn()
		{
			var mockAttackee = new Mock<IPlayer>();
			var players = new PlayerCollection(mockGame.Object)
			{
				mockPlayer.Object,
				mockAttackee.Object
			};
			mockGame.SetupGet(_ => _.Players).Returns(players);
			mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);
			mockGame.Setup(_ => _.GetPlayersStartingWithEnumerator(mockPlayer.Object)).Returns<IPlayer>(x => { var y = players.GetPlayersStartingWithEnumerator(x); return y; });
			mockTable.SetupGet(_ => _.Curse).Returns(mockSupply.Object);
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
			mockAttackee.SetupGet(_ => _.Hand).Returns(hand);
			mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Action);

			using (Card card = new BlackCat())
			{
				mockAttackee.Setup(_ => _.AttackedByPlayerAllowed(mockPlayer.Object, card)).Returns(true);

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


				mockAttackee.Verify(_ => _.Gain(mockSupply.Object, card, 1, false), Times.Never);
			}
		}
		[TestMethod]
		public void Test_BlackCat_Play_During_Opponent_Turn_From_Victory_Gain()
		{
			var toGain = new DominionBase.Cards.Universal.Province();
			var mockAttackee = new Mock<IPlayer>();
			var players = new PlayerCollection(mockGame.Object)
			{
				mockPlayer.Object,
				mockAttackee.Object
			};
			mockGame.SetupGet(_ => _.Players).Returns(players);
			mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockAttackee.Object);
			mockGame.Setup(_ => _.GetPlayersStartingWithEnumerator(mockPlayer.Object)).Returns<IPlayer>(x => { var y = players.GetPlayersStartingWithEnumerator(x); return y; });
			mockTable.Setup(_ => _.TableEntities).Returns(new TableEntityCollection());
			mockTable.SetupGet(_ => _.Curse).Returns(mockSupply.Object);
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
			mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Action);
			using (Card card = new BlackCat())
			{
				mockAttackee.Setup(_ => _.AttackedByPlayerAllowed(mockPlayer.Object, card)).Returns(true);
				mockPlayer
					.Setup(_ => _.PlayCard(It.IsAny<Card>(), DeckLocation.InPlay))
					.Callback((Card cardToPlay, DeckLocation dl) =>
					{
						// Sets up the IsAttackBlocked dictionary properly
						card.PlaySetup(mockPlayer.Object);
						card.RemovedFrom(DeckLocation.Hand, mockPlayer.Object);
						card.FollowInstructions(mockPlayer.Object);
					});
				hand.Add(card);
				card.AddedTo(DeckLocation.Hand, mockPlayer.Object);


				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, toGain, null, DeckLocation.Discard, DeckPosition.Top, true);
				mockAttackee.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsTrue(cgeArgs.Resolvers.Any());

				cgeArgs.Resolvers.Values.First().Method(mockPlayer.Object, ref cgeArgs);

				mockAttackee.Verify(_ => _.Gain(mockSupply.Object, card, 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_BlackCat_Opponent_Gain_NonVictory()
		{
			var toGain = new DominionBase.Cards.Universal.Gold();
			var mockAttackee = new Mock<IPlayer>();
			var players = new PlayerCollection(mockGame.Object)
			{
				mockPlayer.Object,
				mockAttackee.Object
			};
			mockGame.SetupGet(_ => _.Players).Returns(players);
			mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockAttackee.Object);
			mockGame.Setup(_ => _.GetPlayersStartingWithEnumerator(mockPlayer.Object)).Returns<IPlayer>(x => { var y = players.GetPlayersStartingWithEnumerator(x); return y; });
			mockTable.Setup(_ => _.TableEntities).Returns(new TableEntityCollection());
			mockTable.SetupGet(_ => _.Curse).Returns(mockSupply.Object);
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
			mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Action);
			using (Card card = new BlackCat())
			{
				hand.Add(card);
				card.AddedTo(DeckLocation.Hand, mockPlayer.Object);


				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, toGain, null, DeckLocation.Discard, DeckPosition.Top, true);
				mockAttackee.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsFalse(cgeArgs.Resolvers.Any());

				mockAttackee.Verify(_ => _.Gain(mockSupply.Object, card, 1, false), Times.Never);
			}
		}
		[TestMethod]
		public void Test_BlackCat_Teardown()
		{
			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.Setup(_ => _.TableEntities).Returns(new TableEntityCollection());
			var toGain = new DominionBase.Cards.Universal.Province();
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);

			using (Card card = new BlackCat())
			{
				hand.Add(card);
				card.AddedTo(DeckLocation.Hand, mockPlayer.Object);


				card.TearDown(mockGame.Object);


				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, toGain, null, DeckLocation.Discard, DeckPosition.Top, true);
				mockAttackee.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsFalse(cgeArgs.Resolvers.Any());
			}
		}
		[TestMethod]
		public void Test_BountyHunter_Basic()
		{
			using (var card = new BountyHunter())
			{
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
				Assert.AreEqual(new Cost(4), card.BaseCost);
				Assert.AreEqual(1, card.Benefit.Actions);
			}
		}
		[TestMethod]
		public void Test_BountyHunter_Play_Nothing_To_Exile()
		{
			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new CardCollection()));

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


				mockPlayer.Verify(_ => _.RetrieveCardFrom(DeckLocation.Hand, It.IsAny<Card>()), Times.Never);
				mockPlayer.Verify(_ => _.AddCardInto(TypeClass.Exile, It.IsAny<Card>(), It.IsAny<DeckPosition>()), Times.Never);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_BountyHunter_Play_Exile_First_Copy()
		{
			var toExile = new CamelTrain();
			var cardMats = new CardMats { [TypeClass.Exile] = new Exile() };
			mockPlayer.SetupGet(_ => _.PlayerMats).Returns(cardMats);
			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)))
				.Returns(new ChoiceResult(new CardCollection { toExile }));
			mockPlayer
				.Setup(_ => _.RetrieveCardFrom(DeckLocation.Hand, toExile))
				.Returns(toExile);
			mockPlayer
				.Setup(_ => _.AddCardInto(TypeClass.Exile, It.IsAny<Card>(), It.IsAny<DeckPosition>()))
				.Callback((Type type, Card card, DeckPosition dp) =>
				{
					cardMats[type].Add(card);
				});

			using (Card card = new BountyHunter())
			using (Currency benefit = new Currency(3))
			{
				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.RetrieveCardFrom(DeckLocation.Hand, toExile), Times.Once);
				mockPlayer.Verify(_ => _.AddCardInto(TypeClass.Exile, toExile, It.IsAny<DeckPosition>()), Times.Once);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Currency == benefit), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_BountyHunter_Play_Exile_Existing_Copy()
		{
			var toExile = new CamelTrain();
			var cardMats = new CardMats { [TypeClass.Exile] = new Exile { new CamelTrain() } };
			mockPlayer.SetupGet(_ => _.PlayerMats).Returns(cardMats);
			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)))
				.Returns(new ChoiceResult(new CardCollection { toExile }));
			mockPlayer
				.Setup(_ => _.RetrieveCardFrom(DeckLocation.Hand, toExile))
				.Returns(toExile);
			mockPlayer
				.Setup(_ => _.AddCardInto(TypeClass.Exile, It.IsAny<Card>(), It.IsAny<DeckPosition>()))
				.Callback((Type type, Card card, DeckPosition dp) =>
				{
					cardMats[type].Add(card);
				});

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


				mockPlayer.Verify(_ => _.RetrieveCardFrom(DeckLocation.Hand, toExile), Times.Once);
				mockPlayer.Verify(_ => _.AddCardInto(TypeClass.Exile, toExile, It.IsAny<DeckPosition>()), Times.Once);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_CamelTrain_Basic()
		{
			using (var card = new CamelTrain())
			{
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
				Assert.AreEqual(new Cost(3), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_CamelTrain_Gain()
		{
			var players = new PlayerCollection(mockGame.Object)
			{
				mockPlayer.Object,
				mockPlayer.Object
			};
			mockGame.SetupGet(_ => _.Players).Returns(players);
			mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Buy);
			var mockGold = new Mock<ISupply>();
			mockTable.SetupGet(_ => _.Gold).Returns(mockGold.Object);
			var exiledGold = new DominionBase.Cards.Universal.Gold();
			mockGold.SetupGet(_ => _.Count).Returns(5);
			mockGold.Setup(_ => _.Take()).Returns(exiledGold);

			using (Card card = new CamelTrain())
			{
				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.CamelTrain.ToString()));

				cgeArgs.Resolvers.Values.First().Method(mockPlayer.Object, ref cgeArgs);


				mockGold.Verify(_ => _.Take(), Times.Once);
				mockPlayer.Verify(_ => _.AddCardInto(TypeClass.Exile, exiledGold, It.IsAny<DeckPosition>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_CamelTrain_Play()
		{
			var supplies = new TableEntityCollection
			{
				{ TypeClass.Cavalry, mockSupply.Object }
			};
			mockTable.SetupGet(_ => _.TableEntities).Returns(supplies);
			// SpecialPiles should maybe be mocked as well??
			var specialPiles = new TableEntityCollection();
			mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);
			var toExile = new Cavalry();
			mockSupply.SetupGet(_ => _.TopCard).Returns(toExile);
			mockSupply.Setup(_ => _.CanGain()).Returns(true);
			mockSupply.SetupGet(_ => _.CurrentCost).Returns(new Cost(4));
			mockSupply.SetupGet(_ => _.TableableType).Returns(TypeClass.Cavalry);
			mockSupply.Setup(_ => _.Take()).Returns(toExile);
			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(mockSupply.Object));

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


				mockSupply.Verify(_ => _.Take(), Times.Once);
				mockPlayer.Verify(_ => _.AddCardInto(TypeClass.Exile, toExile, It.IsAny<DeckPosition>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_CamelTrain_Teardown()
		{
			var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
			mockGame.SetupGet(_ => _.Players).Returns(players);

			using (Card card = new CamelTrain())
			{
				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.CamelTrain.ToString()));

				// Tear Down the card, then verify that the On-Gain trigger doesn't happen
				card.TearDown(mockGame.Object);


				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.CamelTrain.ToString()));
			}
		}
		[TestMethod]
		public void Test_Cardinal_Basic()
		{
			using (var card = new Cardinal())
			{
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Attack, card.Category);
				Assert.AreEqual(new Cost(4), card.BaseCost);
				Assert.AreEqual(2, card.Benefit.Currency.Coin.Value);
			}
		}
		[TestMethod]
		public void Test_Cardinal_Play_Found_Match()
		{
			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);
			mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Action);
			mockAttackee.SetupGet(_ => _._Game).Returns(mockGame.Object);
			var toExile = new CamelTrain();
			var revealed = new Deck(DeckLocation.Revealed, Visibility.All, VisibilityTo.All)
			{
				new BlackCat(),
				toExile
			};
			mockAttackee.SetupGet(_ => _.Revealed).Returns(revealed);
			mockAttackee
				.Setup(_ => _.RetrieveCardFrom(DeckLocation.Revealed, toExile))
				.Returns(toExile);
			mockAttackee
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)))
				.Returns((Choice c) => new ChoiceResult(new CardCollection { c.Cards.First() }));

			using (Card card = new Cardinal())
			{
				mockAttackee.Setup(_ => _.AttackedByPlayerAllowed(mockPlayer.Object, card)).Returns(true);


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


				mockAttackee.Verify(_ => _.Draw(2, DeckLocation.Revealed), Times.Once);
				mockAttackee.Verify(_ => _.RetrieveCardFrom(DeckLocation.Revealed, toExile), Times.Once);
				mockAttackee.Verify(_ => _.AddCardInto(TypeClass.Exile, toExile, It.IsAny<DeckPosition>()), Times.Once);
				mockAttackee.Verify(_ => _.DiscardRevealed(), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Cardinal_Play_Nothing_Matches()
		{
			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);
			mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Action);
			mockAttackee.SetupGet(_ => _._Game).Returns(mockGame.Object);
			var revealed = new Deck(DeckLocation.Revealed, Visibility.All, VisibilityTo.All)
			{
				new BlackCat(),
				new AnimalFair()
			};
			mockAttackee.SetupGet(_ => _.Revealed).Returns(revealed);
			mockAttackee
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)))
				.Returns((Choice c) => new ChoiceResult(new CardCollection()));

			using (Card card = new Cardinal())
			{
				mockAttackee.Setup(_ => _.AttackedByPlayerAllowed(mockPlayer.Object, card)).Returns(true);


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


				mockAttackee.Verify(_ => _.Draw(2, DeckLocation.Revealed), Times.Once);
				mockAttackee.Verify(_ => _.RetrieveCardFrom(DeckLocation.Revealed, It.IsAny<Card>()), Times.Never);
				mockAttackee.Verify(_ => _.AddCardInto(TypeClass.Exile, It.IsAny<Card>(), It.IsAny<DeckPosition>()), Times.Never);
				mockAttackee.Verify(_ => _.DiscardRevealed(), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Cavalry_Basic()
		{
			using (var card = new Cavalry())
			{
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
				Assert.AreEqual(new Cost(4), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Cavalry_Setup()
		{
			// SpecialPiles should maybe be mocked as well??
			var specialPiles = new TableEntityCollection();
			mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

			using (Card card = new Cavalry())
			{
				card.SetupSupply(mockGame.Object, mockSupply.Object);


				Assert.IsTrue(specialPiles.ContainsKey(TypeClass.Horse));
			}
		}
		[TestMethod]
		public void Test_Cavalry_Gain_In_Buy_Phase()
		{
			var players = new PlayerCollection(mockGame.Object)
			{
				mockPlayer.Object,
				mockPlayer.Object
			};
			mockGame.SetupGet(_ => _.Players).Returns(players);
			mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Buy);

			using (Card card = new Cavalry())
			{
				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.Cavalry.ToString()));

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


				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards == 2 && cb.Buys == 1), It.IsAny<bool>()), Times.Once);
				mockPlayer.Verify(_ => _.GoToActionPhase(), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Cavalry_Gain_In_Action_Phase()
		{
			var players = new PlayerCollection(mockGame.Object)
			{
				mockPlayer.Object,
				mockPlayer.Object
			};
			mockGame.SetupGet(_ => _.Players).Returns(players);
			mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Action);

			using (Card card = new Cavalry())
			{
				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.Cavalry.ToString()));

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


				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards == 2 && cb.Buys == 1), It.IsAny<bool>()), Times.Once);
				mockPlayer.Verify(_ => _.GoToActionPhase(), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Cavalry_Play()
		{
			// SpecialPiles should maybe be mocked as well??
			var specialPiles = new TableEntityCollection();
			mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

			using (Card card = new Cavalry())
			{
				card.SetupSupply(mockGame.Object, mockSupply.Object);

				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(It.Is<ISupply>(s => s.Type == TypeClass.Horse), card, 2, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Cavalry_Teardown()
		{
			using (Card card = new Cavalry())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.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.Cavalry.ToString()));

				// Tear Down the card, then verify that the On-Gain trigger doesn't happen
				card.TearDown(mockGame.Object);


				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.Cavalry.ToString()));
			}
		}
		[TestMethod]
		public void Test_Commerce_Basic()
		{
			using (var card = new Commerce())
			{
				Assert.AreEqual(Categories.Event, card.Category);
				Assert.AreEqual(new Cost(5), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Commerce_Bought_Nothing_Gained()
		{
			var goldSupply = new Mock<ISupply>();
			mockTable.SetupGet(_ => _.Gold).Returns(goldSupply.Object);
			var turn = new Turn(mockPlayer.Object);
			mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(turn);

			using (Event card = new Commerce())
			{
				card.Bought(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(goldSupply.Object, card, It.IsAny<int>(), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Commerce_Bought_Gained_2_Unique()
		{
			var goldSupply = new Mock<ISupply>();
			mockTable.SetupGet(_ => _.Gold).Returns(goldSupply.Object);
			var turn = new Turn(mockPlayer.Object);
			turn.CardsGained.AddRange(new List<Card> { new Goatherd(), new Supplies() });
			mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(turn);

			using (Event card = new Commerce())
			{
				card.Bought(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(goldSupply.Object, card, It.IsAny<int>(), It.IsAny<bool>()), Times.Once);
				mockPlayer.Verify(_ => _.Gain(goldSupply.Object, card, 2, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Commerce_Bought_Gained_2_Duplicates()
		{
			var goldSupply = new Mock<ISupply>();
			mockTable.SetupGet(_ => _.Gold).Returns(goldSupply.Object);
			var turn = new Turn(mockPlayer.Object);
			turn.CardsGained.AddRange(new List<Card> { new Goatherd(), new Goatherd() });
			mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(turn);

			using (Event card = new Commerce())
			{
				card.Bought(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(goldSupply.Object, card, It.IsAny<int>(), It.IsAny<bool>()), Times.Once);
				mockPlayer.Verify(_ => _.Gain(goldSupply.Object, card, 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Coven_Basic()
		{
			using (var card = new Coven())
			{
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Attack, card.Category);
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(1, card.Benefit.Actions);
				Assert.AreEqual(2, card.Benefit.Currency.Coin.Value);
			}
		}
		[TestMethod]
		public void Test_Coven_Play_Curse_Available()
		{
			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; });
			var mockCurse = new Mock<ISupply>();
			mockTable.SetupGet(_ => _.Curse).Returns(mockCurse.Object);
			var exiledCurse = new DominionBase.Cards.Universal.Curse();
			mockCurse.SetupGet(_ => _.Count).Returns(5);
			mockCurse.Setup(_ => _.Take()).Returns(exiledCurse);
			mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Action);
			mockAttackee.SetupGet(_ => _._Game).Returns(mockGame.Object);

			using (Card card = new Coven())
			{
				mockAttackee.Setup(_ => _.AttackedByPlayerAllowed(mockPlayer.Object, card)).Returns(true);


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


				mockCurse.Verify(_ => _.Take(), Times.Once);
				mockAttackee.Verify(_ => _.AddCardInto(TypeClass.Exile, exiledCurse, It.IsAny<DeckPosition>()), Times.Once);
				mockAttackee.Verify(_ => _.Discard(DeckLocation.PlayerMat, TypeClass.Exile, It.IsAny<Predicate<Card>>(), It.IsAny<int>(), It.IsAny<CardsDiscardResolver>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Coven_Play_No_Curses_Available()
		{
			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; });
			var mockCurse = new Mock<ISupply>();
			mockTable.SetupGet(_ => _.Curse).Returns(mockCurse.Object);
			var exiledCurse = new DominionBase.Cards.Universal.Curse();
			mockCurse.SetupGet(_ => _.Count).Returns(0);
			mockCurse.Setup(_ => _.Take()).Returns(exiledCurse);
			mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Action);
			mockAttackee.SetupGet(_ => _._Game).Returns(mockGame.Object);

			using (Card card = new Coven())
			{
				mockAttackee.Setup(_ => _.AttackedByPlayerAllowed(mockPlayer.Object, card)).Returns(true);


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


				mockCurse.Verify(_ => _.Take(), Times.Never);
				mockAttackee.Verify(_ => _.AddCardInto(TypeClass.Exile, exiledCurse, It.IsAny<DeckPosition>()), Times.Never);
				mockAttackee.Verify(_ => _.Discard(DeckLocation.PlayerMat, TypeClass.Exile, It.Is<Predicate<Card>>(pc => pc.Invoke(exiledCurse)), It.IsAny<int>(), It.IsAny<CardsDiscardResolver>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Delay_Basic()
		{
			using (var card = new Delay())
			{
				Assert.AreEqual(Categories.Event, card.Category);
				Assert.AreEqual(new Cost(0), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Delay_Bought_No_Action()
		{
			var mats = new CardMats();
			mockPlayer.SetupGet(_ => _.PlayerMats).Returns(mats);
			var hand = new Deck(DeckLocation.Hand);
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new CardCollection()));

			using (Event card = new Delay())
			{
				card.Bought(mockPlayer.Object);

				var teeArgs = new TurnEndedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnEnded += null, teeArgs);
				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.IsFalse(tseArgs.Resolvers.Any());
			}
		}
		[TestMethod]
		public void Test_Delay_Bought_Action()
		{
			var mats = new CardMats();
			mockPlayer.SetupGet(_ => _.PlayerMats).Returns(mats);
			var hand = new Deck(DeckLocation.Hand);
			var toPlay = new Barge();
			hand.AddRange(mockPlayer.Object, new List<Card> { toPlay });
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
			mockPlayer.SetupGet(_ => _.DiscardPile).Returns(new Deck(DeckLocation.Discard));
			mockPlayer.SetupGet(_ => _.Private).Returns(new Deck(DeckLocation.Private));
			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new CardCollection { toPlay }));
			mockPlayer.Setup(_ => _.RetrieveCardFrom(TypeClass.DelaySetAside, toPlay)).Returns(toPlay);

			using (Event card = new Delay())
			{
				card.Bought(mockPlayer.Object);

				var teeArgs = new TurnEndedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnEnded += null, teeArgs);
				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.AreEqual(1, tseArgs.Resolvers.Count);

				tseArgs.Resolvers.Values.First().Method(mockPlayer.Object, ref tseArgs);

				mockPlayer.Verify(_ => _.PutCardIntoPlay(toPlay, It.IsAny<string>()), Times.Once);
				mockPlayer.Verify(_ => _.PlayCard(toPlay, It.IsAny<PlayerMode>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Delay_Bought_2x_Action()
		{
			var mats = new CardMats();
			mockPlayer.SetupGet(_ => _.PlayerMats).Returns(mats);
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
			var toPlay1 = new Barge();
			var toPlay2 = new Horse();
			hand.AddRange(mockPlayer.Object, new List<Card> { toPlay1, toPlay2 });
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
			mockPlayer.SetupGet(_ => _.DiscardPile).Returns(new Deck(DeckLocation.Discard));
			mockPlayer.SetupGet(_ => _.Private).Returns(new Deck(DeckLocation.Private));
			mockPlayer
				.Setup(_ => _.MakeChoice(It.IsAny<Choice>()))
				.Returns((Choice c) =>
				{
					var card = hand.First();
					hand.Remove(card);
					return new ChoiceResult(new CardCollection { card });
				});
			mockPlayer.Setup(_ => _.RetrieveCardFrom(TypeClass.DelaySetAside, toPlay1)).Returns(toPlay1);
			mockPlayer.Setup(_ => _.RetrieveCardFrom(TypeClass.DelaySetAside, toPlay2)).Returns(toPlay2);

			using (Event card = new Delay())
			{
				card.Bought(mockPlayer.Object);
				card.Bought(mockPlayer.Object);

				var teeArgs = new TurnEndedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnEnded += null, teeArgs);
				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.AreEqual(2, tseArgs.Resolvers.Count);

				tseArgs.Resolvers.Values.First().Method(mockPlayer.Object, ref tseArgs);

				tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				tseArgs.Resolvers.Values.First().Method(mockPlayer.Object, ref tseArgs);

				mockPlayer.Verify(_ => _.PutCardIntoPlay(toPlay1, It.IsAny<string>()), Times.Once);
				mockPlayer.Verify(_ => _.PlayCard(toPlay1, It.IsAny<PlayerMode>()), Times.Once);
				mockPlayer.Verify(_ => _.PutCardIntoPlay(toPlay2, It.IsAny<string>()), Times.Once);
				mockPlayer.Verify(_ => _.PlayCard(toPlay2, It.IsAny<PlayerMode>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Delay_Teardown()
		{
			var mockOpponent = new Mock<IPlayer>();
			var players = new PlayerCollection(mockGame.Object)
			{
				mockPlayer.Object,
				mockOpponent.Object
			};
			mockGame.SetupGet(_ => _.Players).Returns(players);

			var mats = new CardMats();
			mockPlayer.SetupGet(_ => _.PlayerMats).Returns(mats);
			var hand = new Deck(DeckLocation.Hand);
			var toPlay = new Barge();
			hand.AddRange(mockPlayer.Object, new List<Card> { toPlay });
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
			mockPlayer.SetupGet(_ => _.DiscardPile).Returns(new Deck(DeckLocation.Discard));
			mockPlayer.SetupGet(_ => _.Private).Returns(new Deck(DeckLocation.Private));
			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new CardCollection { toPlay }));

			using (Event card = new Delay())
			{
				card.Bought(mockPlayer.Object);

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

				card.End(mockPlayer.Object, new DisplayableCollection());
				card.TearDown(mockGame.Object);


				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.IsFalse(tseArgs.Resolvers.Any());
			}
		}
		[TestMethod]
		public void Test_Demand_Basic()
		{
			using (var card = new Demand())
			{
				Assert.AreEqual(Categories.Event, card.Category);
				Assert.AreEqual(new Cost(5), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Demand_Setup_Correctly()
		{
			// SpecialPiles should maybe be mocked as well??
			var specialPiles = new TableEntityCollection();
			mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

			using (var card = new Demand())
			{
				card.Finalize(mockGame.Object);


				Assert.IsTrue(specialPiles.ContainsKey(TypeClass.Horse));
			}
		}
		[TestMethod]
		public void Test_Demand_Bought()
		{
			var gainType = TypeClass.Supplies;
			var supplies = new TableEntityCollection
			{
				{ gainType, mockSupply.Object }
			};
			mockTable.SetupGet(_ => _.TableEntities).Returns(supplies);
			// SpecialPiles should maybe be mocked as well??
			var specialPiles = new TableEntityCollection();
			mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

			var toGain = new Mock<ICost>();
			toGain.SetupGet(_ => _.Type).Returns(gainType);
			mockSupply.SetupGet(_ => _.TopCard).Returns(toGain.Object);
			mockSupply.Setup(_ => _.CanGain()).Returns(true);
			mockSupply.SetupGet(_ => _.CurrentCost).Returns(new Cost(2));
			mockSupply.SetupGet(_ => _.TableableType).Returns(gainType);

			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(mockSupply.Object));
			var deck = new List<ICard>();
			mockPlayer
				.Setup(_ => _.Gain(It.IsAny<ISupply>(), It.IsAny<IGameObject>(), DeckLocation.Deck, DeckPosition.Top, It.IsAny<int>(), It.IsAny<bool>()))
				.Callback((ISupply s, IGameObject go, DeckLocation dl, DeckPosition dp, int c, bool b) =>
				{
					var card = new Mock<ICard>();
					card.SetupGet(_ => _.Type).Returns(s.TopCard.Type);
					for (var i = 0; i < c; i++)
						deck.Insert(0, card.Object);
				});

			using (Event card = new Demand())
			{
				card.Finalize(mockGame.Object);
				mockTable.SetupGet(_ => _[TypeClass.Horse]).Returns(specialPiles[TypeClass.Horse]);


				card.Bought(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(It.Is<ISupply>(s => s.Type == TypeClass.Horse), card, DeckLocation.Deck, DeckPosition.Top, 1, false), Times.Once);
				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, DeckLocation.Deck, DeckPosition.Top, 1, false), Times.Once);
				Assert.AreEqual(2, deck.Count);
				Assert.AreEqual(TypeClass.Supplies, deck[0].Type);
				Assert.AreEqual(TypeClass.Horse, deck[1].Type);
			}
		}
		[TestMethod]
		public void Test_Desperation_Basic()
		{
			using (var card = new Desperation())
			{
				Assert.AreEqual(Categories.Event, card.Category);
				Assert.AreEqual(new Cost(0), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Desperation_Bought_Gain_Curse()
		{
			var curseSupply = new Mock<ISupply>();
			mockTable.SetupGet(_ => _.Curse).Returns(curseSupply.Object);
			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new List<string> { ResourcesHelper.Get("Yes") }));
			var turn = new Turn(mockPlayer.Object);
			mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(turn);
			mockPlayer.SetupGet(_ => _.TokenPiles).Returns(new TokenCollections());

			using (Event card = new Desperation())
			{
				card.Init(mockGame.Object, new PlayerCollection(mockGame.Object));
				mockPlayer.Setup(_ => _.Gain(curseSupply.Object, card, 1, false)).Returns(true);
				Assert.IsTrue(card.CanBuy(mockPlayer.Object, new Currency(5)));


				card.Bought(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(curseSupply.Object, card, 1, false), Times.Once);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Exactly(2));
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Buys == 1 && cb.Currency.Coin == new Coin(2)), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Desperation_Cant_Buy_Twice()
		{
			var turn = new Turn(mockPlayer.Object);
			mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(turn);

			using (Event card = new Desperation())
			{
				turn.CardsBought.Add(card);


				Assert.IsFalse(card.CanBuy(mockPlayer.Object, new Currency(5)));
			}
		}
		[TestMethod]
		public void Test_Desperation_Bought_No_Gain_Curse()
		{
			var curseSupply = new Mock<ISupply>();
			mockTable.SetupGet(_ => _.Curse).Returns(curseSupply.Object);
			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new List<string> { ResourcesHelper.Get("No") }));
			var turn = new Turn(mockPlayer.Object);
			mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(turn);
			mockPlayer.SetupGet(_ => _.TokenPiles).Returns(new TokenCollections());

			using (Event card = new Desperation())
			{
				card.Init(mockGame.Object, new PlayerCollection(mockGame.Object));
				mockPlayer.Setup(_ => _.Gain(curseSupply.Object, card, 1, false)).Returns(true);
				Assert.IsTrue(card.CanBuy(mockPlayer.Object, new Currency(5)));


				card.Bought(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(It.IsAny<ISupply>(), card, It.IsAny<int>(), It.IsAny<bool>()), Times.Never);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Desperation_Bought_No_Curses()
		{
			var curseSupply = new Mock<ISupply>();
			mockTable.SetupGet(_ => _.Curse).Returns(curseSupply.Object);
			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new List<string> { ResourcesHelper.Get("Yes") }));
			var turn = new Turn(mockPlayer.Object);
			mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(turn);
			mockPlayer.SetupGet(_ => _.TokenPiles).Returns(new TokenCollections());

			using (Event card = new Desperation())
			{
				card.Init(mockGame.Object, new PlayerCollection(mockGame.Object));
				mockPlayer.Setup(_ => _.Gain(curseSupply.Object, card, It.IsAny<int>(), It.IsAny<bool>())).Returns(false);
				Assert.IsTrue(card.CanBuy(mockPlayer.Object, new Currency(5)));


				card.Bought(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(curseSupply.Object, card, 1, false), Times.Once);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Destrier_Basic()
		{
			using (var card = new Destrier())
			{
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
				Assert.AreEqual(new Cost(6, special: true), card.BaseCost);
				Assert.AreEqual(2, card.Benefit.Cards);
				Assert.AreEqual(1, card.Benefit.Actions);
			}
		}
		[TestMethod]
		public void Test_Destrier_Check_Cost_No_Gains()
		{
			mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);
			var turn = new Turn(mockPlayer.Object);
			mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(turn);

			using (Card card = new Destrier())
			{
				card.SetupCard(mockGame.Object);

				var cceArgs = new CostComputeEventArgs(card, card.BaseCost);
				mockGame.Raise(_ => _.CostCompute += null, cceArgs);

				Assert.AreEqual(card.BaseCost, cceArgs.Cost);
			}
		}
		[TestMethod]
		public void Test_Destrier_Check_Cost_3_Cards_Gained()
		{
			mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);
			var turn = new Turn(mockPlayer.Object);
			turn.CardsGained.AddRange(new List<Card> { new Barge(), new Scrap(), new Horse() });
			mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(turn);

			using (Card card = new Destrier())
			{
				card.SetupCard(mockGame.Object);

				var cceArgs = new CostComputeEventArgs(card, card.BaseCost);
				mockGame.Raise(_ => _.CostCompute += null, cceArgs);

				Assert.AreNotEqual(card.BaseCost, cceArgs.Cost);
				Assert.AreEqual(card.BaseCost.Coin.Value - 3, cceArgs.Cost.Coin.Value);
			}
		}
		[TestMethod]
		public void Test_Destrier_Check_Cost_9_Cards_Gained()
		{
			mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);
			var turn = new Turn(mockPlayer.Object);
			turn.CardsGained.AddRange(new List<Card> { new Barge(), new Scrap(), new Horse(), new Barge(), new Scrap(), new Horse(), new Barge(), new Scrap(), new Horse() });
			mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(turn);

			using (Card card = new Destrier())
			{
				card.SetupCard(mockGame.Object);

				var cceArgs = new CostComputeEventArgs(card, card.BaseCost);
				mockGame.Raise(_ => _.CostCompute += null, cceArgs);

				Assert.AreNotEqual(card.BaseCost, cceArgs.Cost);
				Assert.AreEqual(0, cceArgs.Cost.Coin.Value);
			}
		}
		[TestMethod]
		public void Test_Destrier_Check_Cost_3_Cards_Gained_No_Contamination()
		{
			mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);
			var turn = new Turn(mockPlayer.Object);
			turn.CardsGained.AddRange(new List<Card> { new Barge(), new Scrap(), new Horse() });
			mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(turn);
			var otherCard = new Cavalry();

			using (Card card = new Destrier())
			{
				card.SetupCard(mockGame.Object);

				var cceArgs = new CostComputeEventArgs(otherCard, otherCard.BaseCost);
				mockGame.Raise(_ => _.CostCompute += null, cceArgs);

				Assert.AreEqual(otherCard.BaseCost, cceArgs.Cost);
			}
		}
		[TestMethod]
		public void Test_Destrier_Teardown()
		{
			mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);
			var turn = new Turn(mockPlayer.Object);
			turn.CardsGained.AddRange(new List<Card> { new Barge(), new Scrap(), new Horse() });
			mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(turn);

			using (Card card = new Destrier())
			{
				card.SetupCard(mockGame.Object);

				card.TearDown(mockGame.Object);

				var cceArgs = new CostComputeEventArgs(card, card.BaseCost);
				mockGame.Raise(_ => _.CostCompute += null, cceArgs);

				Assert.AreEqual(card.BaseCost, cceArgs.Cost);
			}
		}
		[TestMethod]
		public void Test_Displace_Basic()
		{
			using (var card = new Displace())
			{
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
				Assert.AreEqual(new Cost(5), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Displace_Play_Nothing_To_Exile()
		{
			mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards))).Returns(new ChoiceResult(new CardCollection()));

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


				mockPlayer.Verify(_ => _.RetrieveCardFrom(DeckLocation.Hand, It.IsAny<Card>()), Times.Never);
				mockPlayer.Verify(_ => _.AddCardInto(TypeClass.Exile, It.IsAny<Card>(), It.IsAny<DeckPosition>()), Times.Never);
				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, It.IsAny<int>(), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Displace_Play_Exile_Gain()
		{
			var toExile = new CamelTrain();
			var mockSupply2 = new Mock<ISupply>();
			var supply2Card = new AnimalFair();
			var mockSupply3 = new Mock<ISupply>();
			var supply3Card = new Cardinal();
			var supplies = new TableEntityCollection
			{
				{ toExile.Type, mockSupply.Object },
				{ supply2Card.Type, mockSupply2.Object },
				{ supply3Card.Type, mockSupply3.Object }
			};
			mockTable.SetupGet(_ => _.TableEntities).Returns(supplies);
			mockSupply.Setup(_ => _.CanGain()).Returns(true);
			mockSupply.SetupGet(_ => _.CurrentCost).Returns(toExile.BaseCost);
			mockSupply.SetupGet(_ => _.TableableType).Returns(toExile.Type);
			mockSupply.SetupGet(_ => _.TopCard).Returns(toExile);
			mockSupply2.Setup(_ => _.CanGain()).Returns(true);
			mockSupply2.SetupGet(_ => _.CurrentCost).Returns(supply2Card.BaseCost);
			mockSupply2.SetupGet(_ => _.TableableType).Returns(supply2Card.Type);
			mockSupply2.SetupGet(_ => _.TopCard).Returns(supply2Card);
			mockSupply3.Setup(_ => _.CanGain()).Returns(true);
			mockSupply3.SetupGet(_ => _.CurrentCost).Returns(supply3Card.BaseCost);
			mockSupply3.SetupGet(_ => _.TableableType).Returns(supply3Card.Type);
			mockSupply3.SetupGet(_ => _.TopCard).Returns(supply3Card);

			var cardMats = new CardMats { [TypeClass.Exile] = new Exile() };
			mockPlayer.SetupGet(_ => _.PlayerMats).Returns(cardMats);
			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)))
				.Returns(new ChoiceResult(new CardCollection { toExile }));
			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Supplies)))
				.Returns((Choice c) => new ChoiceResult((ISupply)c.Supplies.Values.First()));
			mockPlayer
				.Setup(_ => _.RetrieveCardFrom(DeckLocation.Hand, toExile))
				.Returns(toExile);
			mockPlayer
				.Setup(_ => _.AddCardInto(TypeClass.Exile, It.IsAny<Card>(), It.IsAny<DeckPosition>()))
				.Callback((Type type, Card card, DeckPosition dp) =>
				{
					cardMats[type].Add(card);
				});

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


				mockPlayer.Verify(_ => _.RetrieveCardFrom(DeckLocation.Hand, toExile), Times.Once);
				mockPlayer.Verify(_ => _.AddCardInto(TypeClass.Exile, toExile, It.IsAny<DeckPosition>()), Times.Once);
				// Camel Train shouldn't be allowed since it's the same name as the exiled card
				// Animal Fair shouldn't be allowed since it's too expensive
				// Only Cardinal should be allowed as a choice
				mockPlayer.Verify(_ => _.MakeChoice(It.Is<Choice>(
					c => c.ChoiceType == ChoiceType.Supplies && c.Supplies.Count == 1
				)), Times.Once);
				mockPlayer.Verify(_ => _.Gain(mockSupply3.Object, card, 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Enclave_Basic()
		{
			using (var card = new Enclave())
			{
				Assert.AreEqual(Categories.Event, card.Category);
				Assert.AreEqual(new Cost(8), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Enclave_Bought()
		{
			var goldSupply = new Mock<ISupply>();
			var duchySupply = new Mock<ISupply>();
			mockTable.SetupGet(_ => _.Gold).Returns(goldSupply.Object);
			mockTable.SetupGet(_ => _.Duchy).Returns(duchySupply.Object);
			duchySupply.SetupGet(_ => _.Count).Returns(5);
			var toExile = new DominionBase.Cards.Universal.Duchy();
			duchySupply.Setup(_ => _.Take()).Returns(toExile);

			using (Event card = new Enclave())
			{
				card.Bought(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(goldSupply.Object, card, 1, false), Times.Once);
				mockPlayer.Verify(_ => _.AddCardInto(TypeClass.Exile, toExile, It.IsAny<DeckPosition>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Enhance_Basic()
		{
			using (var card = new Enhance())
			{
				Assert.AreEqual(Categories.Event, card.Category);
				Assert.AreEqual(new Cost(3), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Enhance_Bought_No_Hand()
		{
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);

			using (Event card = new Enhance())
			{
				card.Bought(mockPlayer.Object);


				mockPlayer.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Never);
				mockPlayer.Verify(_ => _.Trash(card, It.IsAny<ItemCollection<Card>>()), Times.Never);
				mockPlayer.Verify(_ => _.Gain(It.IsAny<ISupply>(), card, It.IsAny<int>(), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Enhance_Bought_No_Trash()
		{
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner)
			{
				new DominionBase.Cards.Universal.Curse()
			};
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
			mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards))).Returns(new ChoiceResult(new CardCollection()));

			using (Event card = new Enhance())
			{
				card.Bought(mockPlayer.Object);


				mockPlayer.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Once);
				mockPlayer.Verify(_ => _.Trash(card, It.IsAny<ItemCollection<Card>>()), Times.Never);
				mockPlayer.Verify(_ => _.Gain(It.IsAny<ISupply>(), card, It.IsAny<int>(), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Enhance_Bought_No_Match()
		{
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner)
			{
				new DominionBase.Cards.Universal.Estate()
			};
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
			mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards))).Returns(new ChoiceResult(new CardCollection()));

			using (Event card = new Enhance())
			{
				card.Bought(mockPlayer.Object);


				mockPlayer.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Never);
				mockPlayer.Verify(_ => _.Trash(card, It.IsAny<ItemCollection<Card>>()), Times.Never);
				mockPlayer.Verify(_ => _.Gain(It.IsAny<ISupply>(), card, It.IsAny<int>(), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Enhance_Bought_Trash_Gain()
		{
			var gainType = TypeClass.Supplies;
			var supplies = new TableEntityCollection
			{
				{ gainType, mockSupply.Object }
			};
			mockTable.SetupGet(_ => _.TableEntities).Returns(supplies);

			var toGain = new Mock<ICost>();
			toGain.SetupGet(_ => _.Type).Returns(gainType);
			mockSupply.SetupGet(_ => _.TopCard).Returns(toGain.Object);
			mockSupply.Setup(_ => _.CanGain()).Returns(true);
			mockSupply.SetupGet(_ => _.CurrentCost).Returns(new Cost(2));
			mockSupply.SetupGet(_ => _.TableableType).Returns(gainType);

			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(mockSupply.Object));
			mockPlayer
				.Setup(_ => _.Gain(It.IsAny<ISupply>(), It.IsAny<IGameObject>(), It.IsAny<int>(), It.IsAny<bool>()))
				.Returns(true);

			var toTrash = new DominionBase.Cards.Universal.Curse();
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner)
			{
				toTrash
			};
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
			mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards))).Returns(new ChoiceResult(new CardCollection { toTrash }));
			mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Supplies))).Returns(new ChoiceResult(mockSupply.Object));

			using (Event card = new Enhance())
			{
				card.Bought(mockPlayer.Object);


				mockPlayer.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Exactly(2));
				mockPlayer.Verify(_ => _.Trash(card, It.Is<ItemCollection<Card>>(ic => ic.Count == 1 && ic[0] == toTrash)), Times.Once);
				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Falconer_Basic()
		{
			using (var card = new Falconer())
			{
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Reaction, card.Category);
				Assert.AreEqual(new Cost(5), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Falconer_Play_During_Turn()
		{
			var supplies = new TableEntityCollection
			{
				{ TypeClass.Cavalry, mockSupply.Object }
			};
			mockTable.SetupGet(_ => _.TableEntities).Returns(supplies);
			var toGain = new Mock<ICost>();
			mockSupply.SetupGet(_ => _.TopCard).Returns(toGain.Object);
			mockSupply.Setup(_ => _.CanGain()).Returns(true);
			mockSupply.SetupGet(_ => _.CurrentCost).Returns(new Cost(4));
			mockSupply.SetupGet(_ => _.TableableType).Returns(TypeClass.Cavalry);

			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(mockSupply.Object));

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


				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, DeckLocation.Hand, It.IsAny<DeckPosition>(), 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Falconer_Play_During_Opponent_Turn_From_MultiType_Gain()
		{
			var mockOpponent = new Mock<IPlayer>();
			var players = new PlayerCollection(mockGame.Object)
			{
				mockPlayer.Object,
				mockOpponent.Object
			};
			mockGame.SetupGet(_ => _.Players).Returns(players);
			mockGame.Setup(_ => _.GetPlayersStartingWithEnumerator(mockPlayer.Object)).Returns<IPlayer>(x => { var y = players.GetPlayersStartingWithEnumerator(x); return y; });

			var supplies = new TableEntityCollection
			{
				{ TypeClass.Cavalry, mockSupply.Object }
			};
			mockTable.SetupGet(_ => _.TableEntities).Returns(supplies);
			var toGain = new Mock<ICost>();
			mockSupply.SetupGet(_ => _.TopCard).Returns(toGain.Object);
			mockSupply.Setup(_ => _.CanGain()).Returns(true);
			mockSupply.SetupGet(_ => _.CurrentCost).Returns(new Cost(4));
			mockSupply.SetupGet(_ => _.TableableType).Returns(TypeClass.Cavalry);

			var opponentGain = new BlackCat();

			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(mockSupply.Object));

			using (Card card = new Falconer())
			{
				// Mock logic to play the card
				mockPlayer
					.Setup(_ => _.PlayCard(It.IsAny<Card>(), DeckLocation.InPlay))
					.Callback((Card cardToPlay, DeckLocation dl) =>
					{
						card.RemovedFrom(DeckLocation.Hand, mockPlayer.Object);
						card.FollowInstructions(mockPlayer.Object);
					});
				hand.Add(card);
				card.AddedTo(DeckLocation.Hand, mockPlayer.Object);

				// Opponent gaining a card
				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, opponentGain, null, DeckLocation.Discard, DeckPosition.Top, true);
				mockOpponent.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsTrue(cgeArgs.Resolvers.Any());

				cgeArgs.Resolvers.Values.First().Method(mockPlayer.Object, ref cgeArgs);

				// Make sure we've played Falconer / gained a card
				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, DeckLocation.Hand, It.IsAny<DeckPosition>(), 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Falconer_Opponent_Gain_NonDual()
		{
			var toGain = new DominionBase.Cards.Universal.Gold();
			var mockAttackee = new Mock<IPlayer>();
			var players = new PlayerCollection(mockGame.Object)
			{
				mockPlayer.Object,
				mockAttackee.Object
			};
			mockGame.SetupGet(_ => _.Players).Returns(players);
			mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockAttackee.Object);
			mockGame.Setup(_ => _.GetPlayersStartingWithEnumerator(mockPlayer.Object)).Returns<IPlayer>(x => { var y = players.GetPlayersStartingWithEnumerator(x); return y; });
			mockTable.Setup(_ => _.TableEntities).Returns(new TableEntityCollection());
			mockTable.SetupGet(_ => _.Curse).Returns(mockSupply.Object);
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
			mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Action);
			using (Card card = new Falconer())
			{
				hand.Add(card);
				card.AddedTo(DeckLocation.Hand, mockPlayer.Object);


				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, toGain, null, DeckLocation.Discard, DeckPosition.Top, true);
				mockAttackee.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsFalse(cgeArgs.Resolvers.Any());

				mockAttackee.Verify(_ => _.Gain(mockSupply.Object, card, 1, false), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Falconer_Play_During_Opponent_Turn_From_Own_MultiType_Gain()
		{
			var mockOpponent = new Mock<IPlayer>();
			var players = new PlayerCollection(mockGame.Object)
			{
				mockPlayer.Object,
				mockOpponent.Object
			};
			mockGame.SetupGet(_ => _.Players).Returns(players);
			mockGame.Setup(_ => _.GetPlayersStartingWithEnumerator(mockPlayer.Object)).Returns<IPlayer>(x => { var y = players.GetPlayersStartingWithEnumerator(x); return y; });

			var supplies = new TableEntityCollection
			{
				{ TypeClass.Cavalry, mockSupply.Object }
			};
			mockTable.SetupGet(_ => _.TableEntities).Returns(supplies);
			var toGain = new Mock<ICost>();
			mockSupply.SetupGet(_ => _.TopCard).Returns(toGain.Object);
			mockSupply.Setup(_ => _.CanGain()).Returns(true);
			mockSupply.SetupGet(_ => _.CurrentCost).Returns(new Cost(4));
			mockSupply.SetupGet(_ => _.TableableType).Returns(TypeClass.Cavalry);

			var playerGain = new BlackCat();

			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(mockSupply.Object));

			using (Card card = new Falconer())
			{
				// Mock logic to play the card
				mockPlayer
					.Setup(_ => _.PlayCard(It.IsAny<Card>(), DeckLocation.InPlay))
					.Callback((Card cardToPlay, DeckLocation dl) =>
					{
						card.RemovedFrom(DeckLocation.Hand, mockPlayer.Object);
						card.FollowInstructions(mockPlayer.Object);
					});
				hand.Add(card);
				card.AddedTo(DeckLocation.Hand, mockPlayer.Object);

				// Opponent gaining a card
				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, playerGain, null, DeckLocation.Discard, DeckPosition.Top, true);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsTrue(cgeArgs.Resolvers.Any());

				cgeArgs.Resolvers.Values.First().Method(mockPlayer.Object, ref cgeArgs);

				// Make sure we've played Falconer / gained a card
				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, DeckLocation.Hand, It.IsAny<DeckPosition>(), 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Falconer_Teardown()
		{
			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.Setup(_ => _.TableEntities).Returns(new TableEntityCollection());
			var toGain = new DominionBase.Cards.Universal.Province();
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);

			using (Card card = new Falconer())
			{
				hand.Add(card);
				card.AddedTo(DeckLocation.Hand, mockPlayer.Object);


				card.TearDown(mockGame.Object);


				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, toGain, null, DeckLocation.Discard, DeckPosition.Top, true);
				mockAttackee.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsFalse(cgeArgs.Resolvers.Any());
			}
		}
		[TestMethod]
		public void Test_Fisherman_Basic()
		{
			using (var card = new Fisherman())
			{
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
				Assert.AreEqual(new Cost(5, special: true), card.BaseCost);
				Assert.AreEqual(1, card.Benefit.Cards);
				Assert.AreEqual(1, card.Benefit.Actions);
				Assert.AreEqual(new Currency(1), card.Benefit.Currency);
			}
		}
		[TestMethod]
		public void Test_Fisherman_Check_Cost_Nonempty_Discard()
		{
			mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);
			var discard = new Deck(DeckLocation.Discard, Visibility.Top, VisibilityTo.All) { new Horse() };
			mockPlayer.SetupGet(_ => _.DiscardPile).Returns(discard);

			using (Card card = new Fisherman())
			{
				card.SetupCard(mockGame.Object);

				var cceArgs = new CostComputeEventArgs(card, card.BaseCost);
				mockGame.Raise(_ => _.CostCompute += null, cceArgs);

				Assert.AreEqual(card.BaseCost, cceArgs.Cost);
			}
		}
		[TestMethod]
		public void Test_Fisherman_Check_Cost_Empty_Discard()
		{
			mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);
			mockPlayer.SetupGet(_ => _.DiscardPile).Returns(new Deck(DeckLocation.Discard, Visibility.Top, VisibilityTo.All));

			using (Card card = new Fisherman())
			{
				card.SetupCard(mockGame.Object);

				var cceArgs = new CostComputeEventArgs(card, card.BaseCost);
				mockGame.Raise(_ => _.CostCompute += null, cceArgs);

				Assert.AreNotEqual(card.BaseCost, cceArgs.Cost);
				Assert.AreEqual(card.BaseCost.Coin.Value - 3, cceArgs.Cost.Coin.Value);
			}
		}
		[TestMethod]
		public void Test_Fisherman_Check_Cost_Nonmpty_Discard_No_Contamination()
		{
			mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);
			mockPlayer.SetupGet(_ => _.DiscardPile).Returns(new Deck(DeckLocation.Discard, Visibility.Top, VisibilityTo.All));
			var otherCard = new Cavalry();

			using (Card card = new Fisherman())
			{
				card.SetupCard(mockGame.Object);

				var cceArgs = new CostComputeEventArgs(otherCard, otherCard.BaseCost);
				mockGame.Raise(_ => _.CostCompute += null, cceArgs);

				Assert.AreEqual(otherCard.BaseCost, cceArgs.Cost);
			}
		}
		[TestMethod]
		public void Test_Fisherman_Teardown()
		{
			mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);
			mockPlayer.SetupGet(_ => _.DiscardPile).Returns(new Deck(DeckLocation.Discard, Visibility.Top, VisibilityTo.All));

			using (Card card = new Fisherman())
			{
				card.SetupCard(mockGame.Object);

				card.TearDown(mockGame.Object);

				var cceArgs = new CostComputeEventArgs(card, card.BaseCost);
				mockGame.Raise(_ => _.CostCompute += null, cceArgs);

				Assert.AreEqual(card.BaseCost, cceArgs.Cost);
			}
		}
		[TestMethod]
		public void Test_Gamble_Basic()
		{
			using (var card = new Gamble())
			{
				Assert.AreEqual(Categories.Event, card.Category);
				Assert.AreEqual(new Cost(2), card.BaseCost);
				Assert.AreEqual(1, card.Benefit.Buys);
			}
		}
		[TestMethod]
		public void Test_Gamble_Bought_No_Deck()
		{
			mockPlayer.Setup(_ => _.Draw(1, DeckLocation.Revealed)).Returns(new CardCollection());

			using (Event card = new Gamble())
			{
				card.Bought(mockPlayer.Object);


				mockPlayer.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Never);
				mockPlayer.Verify(_ => _.PutCardIntoPlay(It.IsAny<Card>(), It.IsAny<string>()), Times.Never);
				mockPlayer.Verify(_ => _.PlayCard(It.IsAny<Card>(), It.IsAny<PlayerMode>()), Times.Never);
				mockPlayer.Verify(_ => _.DiscardRevealed(), Times.AtMostOnce);
			}
		}
		[TestMethod]
		public void Test_Gamble_Bought_Non_Matching()
		{
			var toDraw = new DominionBase.Cards.Universal.Curse();
			mockPlayer.Setup(_ => _.Draw(1, DeckLocation.Revealed)).Returns(new CardCollection { toDraw });

			using (Event card = new Gamble())
			{
				card.Bought(mockPlayer.Object);


				mockPlayer.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Never);
				mockPlayer.Verify(_ => _.PutCardIntoPlay(It.IsAny<Card>(), It.IsAny<string>()), Times.Never);
				mockPlayer.Verify(_ => _.PlayCard(It.IsAny<Card>(), It.IsAny<PlayerMode>()), Times.Never);
				mockPlayer.Verify(_ => _.DiscardRevealed(), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Gamble_Bought_Treasure_No_Play()
		{
			var toDraw = new Supplies();
			mockPlayer.Setup(_ => _.Draw(1, DeckLocation.Revealed)).Returns(new CardCollection { toDraw });
			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new List<string> { ResourcesHelper.Get("No") }));

			using (Event card = new Gamble())
			{
				card.Bought(mockPlayer.Object);


				mockPlayer.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Once);
				mockPlayer.Verify(_ => _.PutCardIntoPlay(It.IsAny<Card>(), It.IsAny<string>()), Times.Never);
				mockPlayer.Verify(_ => _.PlayCard(It.IsAny<Card>(), It.IsAny<PlayerMode>()), Times.Never);
				mockPlayer.Verify(_ => _.DiscardRevealed(), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Gamble_Bought_Action_Play()
		{
			var toDraw = new Groom();
			mockPlayer.Setup(_ => _.Draw(1, DeckLocation.Revealed)).Returns(new CardCollection { toDraw });
			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new List<string> { ResourcesHelper.Get("Yes") }));

			using (Event card = new Gamble())
			{
				card.Bought(mockPlayer.Object);


				mockPlayer.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Once);
				mockPlayer.Verify(_ => _.PutCardIntoPlay(toDraw, It.IsAny<string>()), Times.Once);
				mockPlayer.Verify(_ => _.PlayCard(toDraw, It.IsAny<PlayerMode>()), Times.Once);
				mockPlayer.Verify(_ => _.DiscardRevealed(), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Gatekeeper_Basic()
		{
			using (var card = new Gatekeeper())
			{
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Attack | Categories.Duration, card.Category);
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(3, card.DurationBenefit.Currency.Coin.Value);
			}
		}
		[TestMethod]
		public void Test_Gatekeeper_Play_Resolve_Duration()
		{
			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; });

			using (Card card = new Gatekeeper())
			using (Currency durationBenefit = new Currency(3))
			{
				mockAttackee.Setup(_ => _.AttackedByPlayerAllowed(mockPlayer.Object, card)).Returns(false);


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

				Assert.IsFalse(card.CanCleanUp);
				// Go to opponent's turn
				mockPlayer.Raise(_ => _.TurnEnded += null, new TurnEndedEventArgs(mockPlayer.Object));
				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.Currency == durationBenefit), It.IsAny<bool>()), Times.Once);

				// Clean up card at end of turn
				card.RemovedFrom(DeckLocation.SetAside, mockPlayer.Object);
				tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.IsFalse(tseArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Gatekeeper_Play_Opponent_Gain_Action_No_Matching_Exile_No_Exile_Mat()
		{
			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);
			mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Action);

			var toGain = new CamelTrain();

			mockAttackee.SetupGet(_ => _._Game).Returns(mockGame.Object);
			mockAttackee.SetupGet(_ => _.PlayerMats).Returns(new CardMats());
			mockAttackee
				.Setup(_ => _.RetrieveCardFrom(It.IsAny<DeckLocation>(), toGain))
				.Returns(toGain);


			using (Card card = new Gatekeeper())
			{
				mockAttackee.Setup(_ => _.AttackedByPlayerAllowed(mockPlayer.Object, card)).Returns(true);


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

				// Go to opponent's turn
				mockPlayer.Raise(_ => _.TurnEnded += null, new TurnEndedEventArgs(mockPlayer.Object));
				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, toGain, null, DeckLocation.Discard, DeckPosition.Top, true);
				mockAttackee.Raise(_ => _.CardGained += null, cgeArgs);
				var key = TypeClass.Gatekeeper.ToString();
				Assert.IsTrue(cgeArgs.Resolvers.ContainsKey(key));
				cgeArgs.Resolvers[key].Method(mockAttackee.Object, ref cgeArgs);


				Assert.IsTrue(cgeArgs.Cancelled);
				Assert.IsTrue(cgeArgs.IsLostTrackOf);
				mockAttackee.Verify(_ => _.AddCardInto(TypeClass.Exile, toGain, It.IsAny<DeckPosition>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Gatekeeper_Play_Opponent_Gain_Action_Matching_Exile()
		{
			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);
			mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Action);

			var toGain = new CamelTrain();

			mockAttackee.SetupGet(_ => _._Game).Returns(mockGame.Object);
			var mats = new CardMats();
			mats.Add(mockAttackee.Object, TypeClass.Exile, new ItemCollection<Card> { new CamelTrain() });
			mockAttackee.SetupGet(_ => _.PlayerMats).Returns(mats);
			mockAttackee
				.Setup(_ => _.RetrieveCardFrom(It.IsAny<DeckLocation>(), toGain))
				.Returns(toGain);


			using (Card card = new Gatekeeper())
			{
				mockAttackee.Setup(_ => _.AttackedByPlayerAllowed(mockPlayer.Object, card)).Returns(true);


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

				// Go to opponent's turn
				mockPlayer.Raise(_ => _.TurnEnded += null, new TurnEndedEventArgs(mockPlayer.Object));
				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, toGain, null, DeckLocation.Discard, DeckPosition.Top, true);
				mockAttackee.Raise(_ => _.CardGained += null, cgeArgs);
				var key = TypeClass.Gatekeeper.ToString();
				Assert.IsFalse(cgeArgs.Resolvers.ContainsKey(key));

				mockAttackee.Verify(_ => _.AddCardInto(TypeClass.Exile, toGain, It.IsAny<DeckPosition>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Gatekeeper_Play_Opponent_Gain_TreasureVictory_No_Matching_Exile()
		{
			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);
			mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Action);

			var toGain = new DominionBase.Cards.Intrigue.Harem();

			mockAttackee.SetupGet(_ => _._Game).Returns(mockGame.Object);
			var mats = new CardMats();
			mats.Add(mockAttackee.Object, TypeClass.Exile, new ItemCollection<Card> { new CamelTrain() });
			mockAttackee.SetupGet(_ => _.PlayerMats).Returns(mats);
			mockAttackee
				.Setup(_ => _.RetrieveCardFrom(It.IsAny<DeckLocation>(), toGain))
				.Returns(toGain);


			using (Card card = new Gatekeeper())
			{
				mockAttackee.Setup(_ => _.AttackedByPlayerAllowed(mockPlayer.Object, card)).Returns(true);


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

				// Go to opponent's turn
				mockPlayer.Raise(_ => _.TurnEnded += null, new TurnEndedEventArgs(mockPlayer.Object));
				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, toGain, null, DeckLocation.Discard, DeckPosition.Top, true);
				mockAttackee.Raise(_ => _.CardGained += null, cgeArgs);
				var key = TypeClass.Gatekeeper.ToString();
				Assert.IsTrue(cgeArgs.Resolvers.ContainsKey(key));
				cgeArgs.Resolvers[key].Method(mockAttackee.Object, ref cgeArgs);


				Assert.IsTrue(cgeArgs.Cancelled);
				Assert.IsTrue(cgeArgs.IsLostTrackOf);
				mockAttackee.Verify(_ => _.AddCardInto(TypeClass.Exile, toGain, It.IsAny<DeckPosition>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Gatekeeper_Play_Opponent_Gain_Night()
		{
			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);
			mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Action);

			var toGain = new DominionBase.Cards.Nocturne.Vampire();

			mockAttackee.SetupGet(_ => _._Game).Returns(mockGame.Object);
			var mats = new CardMats();
			mats.Add(mockAttackee.Object, TypeClass.Exile, new ItemCollection<Card> { new CamelTrain() });
			mockAttackee.SetupGet(_ => _.PlayerMats).Returns(mats);
			mockAttackee
				.Setup(_ => _.RetrieveCardFrom(It.IsAny<DeckLocation>(), toGain))
				.Returns(toGain);


			using (Card card = new Gatekeeper())
			{
				mockAttackee.Setup(_ => _.AttackedByPlayerAllowed(mockPlayer.Object, card)).Returns(true);


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

				// Go to opponent's turn
				mockPlayer.Raise(_ => _.TurnEnded += null, new TurnEndedEventArgs(mockPlayer.Object));
				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, toGain, null, DeckLocation.Discard, DeckPosition.Top, true);
				mockAttackee.Raise(_ => _.CardGained += null, cgeArgs);
				var key = TypeClass.Gatekeeper.ToString();
				Assert.IsFalse(cgeArgs.Resolvers.ContainsKey(key));

				mockAttackee.Verify(_ => _.AddCardInto(TypeClass.Exile, toGain, It.IsAny<DeckPosition>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Gatekeeper_Teardown()
		{
			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);
			mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Action);

			var toGain = new CamelTrain();

			mockAttackee.SetupGet(_ => _._Game).Returns(mockGame.Object);
			mockAttackee.SetupGet(_ => _.PlayerMats).Returns(new CardMats());
			mockAttackee
				.Setup(_ => _.RetrieveCardFrom(It.IsAny<DeckLocation>(), toGain))
				.Returns(toGain);


			using (Card card = new Gatekeeper())
			{
				mockAttackee.Setup(_ => _.AttackedByPlayerAllowed(mockPlayer.Object, card)).Returns(true);


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

				// Go to opponent's turn
				mockPlayer.Raise(_ => _.TurnEnded += null, new TurnEndedEventArgs(mockPlayer.Object));

				card.TearDown(mockGame.Object);

				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, toGain, null, DeckLocation.Discard, DeckPosition.Top, true);
				mockAttackee.Raise(_ => _.CardGained += null, cgeArgs);
				var keyCg = TypeClass.Gatekeeper.ToString();
				Assert.IsFalse(cgeArgs.Resolvers.ContainsKey(keyCg));

				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				var keyTs = card.ToString();
				Assert.IsFalse(tseArgs.Resolvers.ContainsKey(keyTs));
			}
		}
		[TestMethod]
		public void Test_Goatherd_Basic()
		{
			using (var card = new Goatherd())
			{
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
				Assert.AreEqual(new Cost(3), card.BaseCost);
				Assert.AreEqual(1, card.Benefit.Actions);
			}
		}
		[TestMethod]
		public void Test_Goatherd_Play_No_Trash_Nothing_Trashed()
		{
			var mockNeighbor = new Mock<IPlayer>();
			mockGame.Setup(_ => _.GetPlayerFromIndex(mockPlayer.Object, -1)).Returns(mockNeighbor.Object);
			var lastTurn = new Turn(mockNeighbor.Object);
			var turns = new TurnCollection { lastTurn };
			mockGame.SetupGet(_ => _.TurnsTaken).Returns(turns);
			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new CardCollection()));
			using (Card card = new Goatherd())
			{


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Trash(card, It.IsAny<Card>()), Times.Never);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Goatherd_Play_Trash_Card_Nothing_Trashed()
		{
			var mockNeighbor = new Mock<IPlayer>();
			mockGame.Setup(_ => _.GetPlayerFromIndex(mockPlayer.Object, -1)).Returns(mockNeighbor.Object);
			var lastTurn = new Turn(mockNeighbor.Object);
			var turns = new TurnCollection { lastTurn };
			mockGame.SetupGet(_ => _.TurnsTaken).Returns(turns);
			var toTrash = new Supplies();
			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new CardCollection { toTrash }));
			mockPlayer
				.Setup(_ => _.RetrieveCardsFrom(DeckLocation.Hand, It.IsAny<ItemCollection<Card>>()))
				.Returns(() => new CardCollection { toTrash });
			using (Card card = new Goatherd())
			{


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Trash(card, It.Is<ItemCollection<Card>>(ic => ic.Count == 1 && ic[0] == toTrash)), Times.Once);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Goatherd_Play_No_Trash_Cards_Trashed()
		{
			var mockNeighbor = new Mock<IPlayer>();
			mockGame.Setup(_ => _.GetPlayerFromIndex(mockPlayer.Object, -1)).Returns(mockNeighbor.Object);
			var lastTurn = new Turn(mockNeighbor.Object);
			lastTurn.CardsTrashed.AddRange(new CardCollection { new Supplies(), new Goatherd() });
			var turns = new TurnCollection { lastTurn };
			mockGame.SetupGet(_ => _.TurnsTaken).Returns(turns);
			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new CardCollection()));
			using (Card card = new Goatherd())
			{


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Trash(card, It.IsAny<Card>()), Times.Never);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Exactly(2));
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards == 2), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Groom_Basic()
		{
			using (var card = new Groom())
			{
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
				Assert.AreEqual(new Cost(4), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Groom_Setup()
		{
			// SpecialPiles should maybe be mocked as well??
			var specialPiles = new TableEntityCollection();
			mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

			using (Card card = new Groom())
			{
				card.SetupSupply(mockGame.Object, mockSupply.Object);


				Assert.IsTrue(specialPiles.ContainsKey(TypeClass.Horse));
			}
		}
		[TestMethod]
		public void Test_Groom_Play_Gain_Action()
		{
			var supplies = new TableEntityCollection
			{
				{ TypeClass.Cavalry, mockSupply.Object }
			};
			mockTable.SetupGet(_ => _.TableEntities).Returns(supplies);
			// SpecialPiles should maybe be mocked as well??
			var specialPiles = new TableEntityCollection();
			mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);
			var mockSilver = new Mock<ISupply>();
			mockTable.Setup(_ => _.Silver).Returns(mockSilver.Object);
			var toGain = new Mock<ICost>();
			toGain.SetupGet(_ => _.Category).Returns(Categories.Card | Categories.Action);
			mockSupply.SetupGet(_ => _.TopCard).Returns(toGain.Object);
			mockSupply.Setup(_ => _.CanGain()).Returns(true);
			mockSupply.SetupGet(_ => _.CurrentCost).Returns(new Cost(4));
			mockSupply.SetupGet(_ => _.TableableType).Returns(TypeClass.Cavalry);
			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(mockSupply.Object));
			mockPlayer
				.Setup(_ => _.Gain(It.IsAny<ISupply>(), It.IsAny<IGameObject>(), It.IsAny<int>(), It.IsAny<bool>()))
				.Returns(true);

			using (Card card = new Groom())
			{
				card.SetupSupply(mockGame.Object, mockSupply.Object);

				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, 1, false), Times.Once);
				mockPlayer.Verify(_ => _.Gain(It.Is<ISupply>(s => s.Type == TypeClass.Horse), card, 1, false), Times.Once);
				mockPlayer.Verify(_ => _.Gain(mockSilver.Object, card, It.IsAny<int>(), It.IsAny<bool>()), Times.Never);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Groom_Play_Gain_Treasure()
		{
			mockTable.SetupGet(_ => _.TableEntities).Returns(new TableEntityCollection());
			// SpecialPiles should maybe be mocked as well??
			var specialPiles = new TableEntityCollection();
			mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);
			var mockSilver = new Mock<ISupply>();
			mockTable.Setup(_ => _.Silver).Returns(mockSilver.Object);
			var toGain = new Mock<ICost>();
			toGain.SetupGet(_ => _.Category).Returns(Categories.Card | Categories.Treasure);
			mockSupply.Setup(_ => _.TopCard).Returns(toGain.Object);
			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(mockSupply.Object));
			mockPlayer
				.Setup(_ => _.Gain(It.IsAny<ISupply>(), It.IsAny<IGameObject>(), It.IsAny<int>(), It.IsAny<bool>()))
				.Returns(true);

			using (Card card = new Groom())
			{
				card.SetupSupply(mockGame.Object, mockSupply.Object);

				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, 1, false), Times.Once);
				mockPlayer.Verify(_ => _.Gain(It.Is<ISupply>(s => s.Type == TypeClass.Horse), card, It.IsAny<int>(), It.IsAny<bool>()), Times.Never);
				mockPlayer.Verify(_ => _.Gain(mockSilver.Object, card, 1, false), Times.Once);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Groom_Play_Gain_Victory()
		{
			mockTable.SetupGet(_ => _.TableEntities).Returns(new TableEntityCollection());
			// SpecialPiles should maybe be mocked as well??
			var specialPiles = new TableEntityCollection();
			mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);
			var mockSilver = new Mock<ISupply>();
			mockTable.Setup(_ => _.Silver).Returns(mockSilver.Object);
			var toGain = new Mock<ICost>();
			toGain.SetupGet(_ => _.Category).Returns(Categories.Card | Categories.Victory);
			mockSupply.Setup(_ => _.TopCard).Returns(toGain.Object);
			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(mockSupply.Object));
			mockPlayer
				.Setup(_ => _.Gain(It.IsAny<ISupply>(), It.IsAny<IGameObject>(), It.IsAny<int>(), It.IsAny<bool>()))
				.Returns(true);

			using (Card card = new Groom())
			{
				card.SetupSupply(mockGame.Object, mockSupply.Object);

				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, 1, false), Times.Once);
				mockPlayer.Verify(_ => _.Gain(It.Is<ISupply>(s => s.Type == TypeClass.Horse), card, It.IsAny<int>(), It.IsAny<bool>()), Times.Never);
				mockPlayer.Verify(_ => _.Gain(mockSilver.Object, card, It.IsAny<int>(), It.IsAny<bool>()), Times.Never);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Exactly(2));
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards == 1 && cb.Actions == 1), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Groom_Play_Gain_0_Types()
		{
			mockTable.SetupGet(_ => _.TableEntities).Returns(new TableEntityCollection());
			// SpecialPiles should maybe be mocked as well??
			var specialPiles = new TableEntityCollection();
			mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);
			var mockSilver = new Mock<ISupply>();
			mockTable.Setup(_ => _.Silver).Returns(mockSilver.Object);
			var toGain = new Mock<ICost>();
			toGain.SetupGet(_ => _.Category).Returns(Categories.Card | Categories.Night);
			mockSupply.Setup(_ => _.TopCard).Returns(toGain.Object);
			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(mockSupply.Object));
			mockPlayer
				.Setup(_ => _.Gain(It.IsAny<ISupply>(), It.IsAny<IGameObject>(), It.IsAny<int>(), It.IsAny<bool>()))
				.Returns(true);

			using (Card card = new Groom())
			{
				card.SetupSupply(mockGame.Object, mockSupply.Object);

				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, 1, false), Times.Once);
				mockPlayer.Verify(_ => _.Gain(It.Is<ISupply>(s => s.Type == TypeClass.Horse), card, It.IsAny<int>(), It.IsAny<bool>()), Times.Never);
				mockPlayer.Verify(_ => _.Gain(mockSilver.Object, card, It.IsAny<int>(), It.IsAny<bool>()), Times.Never);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Once);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards == 1 && cb.Actions == 1), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Groom_Play_Gain_3_Types()
		{
			mockTable.SetupGet(_ => _.TableEntities).Returns(new TableEntityCollection());
			// SpecialPiles should maybe be mocked as well??
			var specialPiles = new TableEntityCollection();
			mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);
			var mockSilver = new Mock<ISupply>();
			mockTable.Setup(_ => _.Silver).Returns(mockSilver.Object);
			var toGain = new Mock<ICost>();
			toGain.SetupGet(_ => _.Category).Returns(Categories.Card | Categories.Action | Categories.Treasure | Categories.Victory);
			mockSupply.Setup(_ => _.TopCard).Returns(toGain.Object);
			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(mockSupply.Object));
			mockPlayer
				.Setup(_ => _.Gain(It.IsAny<ISupply>(), It.IsAny<IGameObject>(), It.IsAny<int>(), It.IsAny<bool>()))
				.Returns(true);

			using (Card card = new Groom())
			{
				card.SetupSupply(mockGame.Object, mockSupply.Object);

				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, 1, false), Times.Once);
				mockPlayer.Verify(_ => _.Gain(It.Is<ISupply>(s => s.Type == TypeClass.Horse), card, 1, false), Times.Once);
				mockPlayer.Verify(_ => _.Gain(mockSilver.Object, card, 1, false), Times.Once);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Exactly(2));
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards == 1 && cb.Actions == 1), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Horse_Basic()
		{
			using (var card = new Horse())
			{
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
				Assert.AreEqual(new Cost(3, special: true), card.BaseCost);
				Assert.AreEqual(2, card.Benefit.Cards);
				Assert.AreEqual(1, card.Benefit.Actions);
			}
		}
		[TestMethod]
		public void Test_Horse_Play()
		{
			using (Card card = new Horse())
			{
				mockTable.Setup(_ => _[TypeClass.Horse]).Returns(mockSupply.Object);
				mockSupply.Setup(_ => _.Type).Returns(TypeClass.Horse);
				var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
				mockPlayer.SetupGet(_ => _.InPlay).Returns(inPlay);


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


				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Once);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards == 2 && cb.Actions == 1), It.IsAny<bool>()), Times.Once);
				mockPlayer.Verify(_ => _.Lose(card), Times.Once);
				mockSupply.Verify(_ => _.AddTo(card, It.IsAny<int>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Hostelry_Basic()
		{
			using (var card = new Hostelry())
			{
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
				Assert.AreEqual(new Cost(4), card.BaseCost);
				Assert.AreEqual(1, card.Benefit.Cards);
				Assert.AreEqual(2, card.Benefit.Actions);
			}
		}
		[TestMethod]
		public void Test_Hostelry_Setup()
		{
			// SpecialPiles should maybe be mocked as well??
			var specialPiles = new TableEntityCollection();
			mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

			using (Card card = new Hostelry())
			{
				card.SetupSupply(mockGame.Object, mockSupply.Object);


				Assert.IsTrue(specialPiles.ContainsKey(TypeClass.Horse));
			}
		}
		[TestMethod]
		public void Test_Hostelry_Gain_Discard_0_Cards()
		{
			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);
			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 Hostelry())
			{
				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.Hostelry.ToString()));

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


				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(_ => _.Gain(It.Is<ISupply>(s => s.Type == TypeClass.Horse), card, It.IsAny<int>(), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Hostelry_Gain_Discard_2_Cards()
		{
			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);
			var cardsToDiscard = new List<Card> { new Supplies(), new Supplies() };
			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 Hostelry())
			{
				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.Hostelry.ToString()));

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


				mockPlayer.Verify(_ => _.AddCardsInto(DeckLocation.Revealed, cardsToDiscard, It.IsAny<DeckPosition>()), Times.Once);
				mockPlayer.Verify(_ => _.Discard(DeckLocation.Hand, cardsToDiscard, null), Times.Once);
				mockPlayer.Verify(_ => _.Gain(It.Is<ISupply>(s => s.Type == TypeClass.Horse), card, 2, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Hostelry_Teardown()
		{
			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);

			using (Card card = new Hostelry())
			{
				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.Hostelry.ToString()));

				// Tear Down the card, then verify that the On-Gain trigger doesn't happen
				card.TearDown(mockGame.Object);


				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.Hostelry.ToString()));
			}
		}
		[TestMethod]
		public void Test_HuntingLodge_Basic()
		{
			using (var card = new HuntingLodge())
			{
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
				Assert.AreEqual(new Cost(5), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_HuntingLodge_Play_No_Discard()
		{
			mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options))).Returns(new ChoiceResult(new List<string> { ResourcesHelper.Get("No") }));

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


				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Once);
				mockPlayer.Verify(_ => _.DiscardHand(It.IsAny<bool>()), Times.Never);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards == 5), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_HuntingLodge_Play_Discard()
		{
			mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options))).Returns(new ChoiceResult(new List<string> { ResourcesHelper.Get("Yes") }));

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


				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Exactly(2));
				mockPlayer.Verify(_ => _.DiscardHand(It.IsAny<bool>()), Times.Once);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards == 5), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Invest_Basic()
		{
			using (var card = new Invest())
			{
				Assert.AreEqual(Categories.Event, card.Category);
				Assert.AreEqual(new Cost(4), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Invest_Bought_Exile_From_Supply()
		{
			var mockOpponent = new Mock<IPlayer>();
			var players = new PlayerCollection(mockGame.Object)
			{
				mockPlayer.Object,
				mockOpponent.Object
			};
			mockGame.SetupGet(_ => _.Players).Returns(players);
			#region Set up supplies
			var toExile = new Cavalry();
			var cavalrySupply = new Mock<ISupply>();
			cavalrySupply.SetupGet(_ => _.TopCard).Returns(toExile);
			cavalrySupply.Setup(_ => _.CanGain()).Returns(true);
			cavalrySupply.SetupGet(_ => _.CurrentCost).Returns(toExile.BaseCost);
			cavalrySupply.SetupGet(_ => _.TableableType).Returns(toExile.Type);
			cavalrySupply.Setup(_ => _.Take()).Returns(toExile);
			var suppliesTopCard = new Supplies();
			var suppliesSupply = new Mock<ISupply>();
			suppliesSupply.SetupGet(_ => _.TopCard).Returns(suppliesTopCard);
			suppliesSupply.Setup(_ => _.CanGain()).Returns(true);
			suppliesSupply.SetupGet(_ => _.CurrentCost).Returns(suppliesTopCard.BaseCost);
			suppliesSupply.SetupGet(_ => _.TableableType).Returns(suppliesTopCard.Type);
			#endregion
			var supplies = new TableEntityCollection
			{
				{ TypeClass.Cavalry, cavalrySupply.Object },
				{ TypeClass.Supplies, suppliesSupply.Object }
			};
			mockTable.SetupGet(_ => _.TableEntities).Returns(supplies);

			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Supplies)))
				.Returns((Choice c) => new ChoiceResult((ISupply)c.Supplies.Values.First()));
			var cardMats = new CardMats();
			cardMats.Add(mockPlayer.Object, TypeClass.Exile, new CardCollection());
			mockPlayer.SetupGet(_ => _.PlayerMats).Returns(cardMats);

			using (Event card = new Invest())
			{
				card.Finalize(mockGame.Object);
				card.Bought(mockPlayer.Object);


				// Make sure no non-Action supplies are allowed
				mockPlayer.Verify(_ => _.MakeChoice(It.Is<Choice>(c =>
					c.ChoiceType == ChoiceType.Supplies
					&& c.Supplies.Any(s => !((ISupply)s.Value).TopCard.Category.HasFlag(Categories.Action))
				)), Times.Never);
				cavalrySupply.Verify(_ => _.Take(), Times.Once);
				mockPlayer.Verify(_ => _.AddCardInto(TypeClass.Exile, toExile, It.IsAny<DeckPosition>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Invest_Exiled_Action_Opponent_Gain_Same()
		{
			var mockOpponent = new Mock<IPlayer>();
			var players = new PlayerCollection(mockGame.Object)
			{
				mockPlayer.Object,
				mockOpponent.Object
			};
			mockGame.SetupGet(_ => _.Players).Returns(players);
			#region Set up supplies
			var toExile = new Cavalry();
			var cavalrySupply = new Mock<ISupply>();
			cavalrySupply.SetupGet(_ => _.TopCard).Returns(toExile);
			cavalrySupply.Setup(_ => _.CanGain()).Returns(true);
			cavalrySupply.SetupGet(_ => _.CurrentCost).Returns(toExile.BaseCost);
			cavalrySupply.SetupGet(_ => _.TableableType).Returns(toExile.Type);
			cavalrySupply.Setup(_ => _.Take()).Returns(toExile);
			#endregion
			var supplies = new TableEntityCollection { { TypeClass.Cavalry, cavalrySupply.Object }, };
			mockTable.SetupGet(_ => _.TableEntities).Returns(supplies);

			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Supplies)))
				.Returns((Choice c) => new ChoiceResult(cavalrySupply.Object));
			var cardMats = new CardMats();
			cardMats.Add(mockPlayer.Object, TypeClass.Exile, new CardCollection());
			mockPlayer.SetupGet(_ => _.PlayerMats).Returns(cardMats);

			using (Event card = new Invest())
			{
				card.Finalize(mockGame.Object);
				card.Bought(mockPlayer.Object);

				var oppGain = new Cavalry();
				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, oppGain, null, DeckLocation.Discard, DeckPosition.Automatic, false);
				mockOpponent.Raise(_ => _.CardGained += null, cgeArgs);

				Assert.IsTrue(cgeArgs.Resolvers.Any());
				cgeArgs.Resolvers.Values.First().Method(mockOpponent.Object, ref cgeArgs);

				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards == 2), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Invest_Exiled_Action_Opponent_Gain_Different()
		{
			var mockOpponent = new Mock<IPlayer>();
			var players = new PlayerCollection(mockGame.Object)
			{
				mockPlayer.Object,
				mockOpponent.Object
			};
			mockGame.SetupGet(_ => _.Players).Returns(players);
			#region Set up supplies
			var toExile = new Cavalry();
			var cavalrySupply = new Mock<ISupply>();
			cavalrySupply.SetupGet(_ => _.TopCard).Returns(toExile);
			cavalrySupply.Setup(_ => _.CanGain()).Returns(true);
			cavalrySupply.SetupGet(_ => _.CurrentCost).Returns(toExile.BaseCost);
			cavalrySupply.SetupGet(_ => _.TableableType).Returns(toExile.Type);
			cavalrySupply.Setup(_ => _.Take()).Returns(toExile);
			#endregion
			var supplies = new TableEntityCollection { { TypeClass.Cavalry, cavalrySupply.Object }, };
			mockTable.SetupGet(_ => _.TableEntities).Returns(supplies);

			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Supplies)))
				.Returns((Choice c) => new ChoiceResult(cavalrySupply.Object));
			var cardMats = new CardMats();
			cardMats.Add(mockPlayer.Object, TypeClass.Exile, new CardCollection());
			mockPlayer.SetupGet(_ => _.PlayerMats).Returns(cardMats);

			using (Event card = new Invest())
			{
				card.Finalize(mockGame.Object);
				card.Bought(mockPlayer.Object);

				var oppGain = new Groom();
				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, oppGain, null, DeckLocation.Discard, DeckPosition.Automatic, false);
				mockOpponent.Raise(_ => _.CardGained += null, cgeArgs);

				Assert.IsFalse(cgeArgs.Resolvers.Any());

				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards > 0), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Invest_Exiled_Action_Opponent_Exiles_Same()
		{
			var mockOpponent = new Mock<IPlayer>();
			var players = new PlayerCollection(mockGame.Object)
			{
				mockPlayer.Object,
				mockOpponent.Object
			};
			mockGame.SetupGet(_ => _.Players).Returns(players);
			#region Set up supplies
			var toExile = new Cavalry();
			var cavalrySupply = new Mock<ISupply>();
			cavalrySupply.SetupGet(_ => _.TopCard).Returns(toExile);
			cavalrySupply.Setup(_ => _.CanGain()).Returns(true);
			cavalrySupply.SetupGet(_ => _.CurrentCost).Returns(toExile.BaseCost);
			cavalrySupply.SetupGet(_ => _.TableableType).Returns(toExile.Type);
			cavalrySupply.Setup(_ => _.Take()).Returns(toExile);
			#endregion
			var supplies = new TableEntityCollection { { TypeClass.Cavalry, cavalrySupply.Object }, };
			mockTable.SetupGet(_ => _.TableEntities).Returns(supplies);

			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Supplies)))
				.Returns((Choice c) => new ChoiceResult(cavalrySupply.Object));
			var cardMats = new CardMats();
			cardMats.Add(mockPlayer.Object, TypeClass.Exile, new CardCollection());
			mockPlayer.SetupGet(_ => _.PlayerMats).Returns(cardMats);

			mockOpponent.SetupGet(_ => _._Game).Returns(mockGame.Object);
			mockOpponent
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Supplies)))
				.Returns((Choice c) => new ChoiceResult(cavalrySupply.Object));
			var cardMatsOpponent = new CardMats();
			cardMatsOpponent.Add(mockOpponent.Object, TypeClass.Exile, new CardCollection());
			mockOpponent.SetupGet(_ => _.PlayerMats).Returns(cardMatsOpponent);

			using (Event card = new Invest())
			{
				card.Finalize(mockGame.Object);
				card.Bought(mockPlayer.Object);

				card.Bought(mockOpponent.Object);

				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards == 2), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Invest_Exiled_Action_x2_Opponent_Exiles_Same()
		{
			var mockOpponent = new Mock<IPlayer>();
			var players = new PlayerCollection(mockGame.Object)
			{
				mockPlayer.Object,
				mockOpponent.Object
			};
			mockGame.SetupGet(_ => _.Players).Returns(players);
			#region Set up supplies
			var toExile = new Cavalry();
			var cavalrySupply = new Mock<ISupply>();
			cavalrySupply.SetupGet(_ => _.TopCard).Returns(toExile);
			cavalrySupply.Setup(_ => _.CanGain()).Returns(true);
			cavalrySupply.SetupGet(_ => _.CurrentCost).Returns(toExile.BaseCost);
			cavalrySupply.SetupGet(_ => _.TableableType).Returns(toExile.Type);
			cavalrySupply.Setup(_ => _.Take()).Returns(toExile);
			#endregion
			var supplies = new TableEntityCollection { { TypeClass.Cavalry, cavalrySupply.Object }, };
			mockTable.SetupGet(_ => _.TableEntities).Returns(supplies);

			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Supplies)))
				.Returns((Choice c) => new ChoiceResult(cavalrySupply.Object));
			var cardMats = new CardMats();
			cardMats.Add(mockPlayer.Object, TypeClass.Exile, new CardCollection());
			mockPlayer.SetupGet(_ => _.PlayerMats).Returns(cardMats);

			mockOpponent.SetupGet(_ => _._Game).Returns(mockGame.Object);
			mockOpponent
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Supplies)))
				.Returns((Choice c) => new ChoiceResult(cavalrySupply.Object));
			var cardMatsOpponent = new CardMats();
			cardMatsOpponent.Add(mockOpponent.Object, TypeClass.Exile, new CardCollection());
			mockOpponent.SetupGet(_ => _.PlayerMats).Returns(cardMatsOpponent);

			using (Event card = new Invest())
			{
				card.Finalize(mockGame.Object);
				card.Bought(mockPlayer.Object);
				card.Bought(mockPlayer.Object);

				card.Bought(mockOpponent.Object);

				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards == 4), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Invest_Exiled_Action_Discarded_Opponent_Exiles_Same()
		{
			var mockOpponent = new Mock<IPlayer>();
			var players = new PlayerCollection(mockGame.Object)
			{
				mockPlayer.Object,
				mockOpponent.Object
			};
			mockGame.SetupGet(_ => _.Players).Returns(players);
			#region Set up supplies
			var toExile = new Cavalry();
			var cavalrySupply = new Mock<ISupply>();
			cavalrySupply.SetupGet(_ => _.TopCard).Returns(toExile);
			cavalrySupply.Setup(_ => _.CanGain()).Returns(true);
			cavalrySupply.SetupGet(_ => _.CurrentCost).Returns(toExile.BaseCost);
			cavalrySupply.SetupGet(_ => _.TableableType).Returns(toExile.Type);
			cavalrySupply.Setup(_ => _.Take()).Returns(toExile);
			#endregion
			var supplies = new TableEntityCollection { { TypeClass.Cavalry, cavalrySupply.Object }, };
			mockTable.SetupGet(_ => _.TableEntities).Returns(supplies);

			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Supplies)))
				.Returns((Choice c) => new ChoiceResult(cavalrySupply.Object));
			var cardMats = new CardMats();
			cardMats.Add(mockPlayer.Object, TypeClass.Exile, new CardCollection());
			mockPlayer.SetupGet(_ => _.PlayerMats).Returns(cardMats);
			mockPlayer
				.Setup(_ => _.AddCardInto(TypeClass.Exile, It.IsAny<Card>(), It.IsAny<DeckPosition>()))
				.Callback((Type t, Card c, DeckPosition dp) =>
				{
					cardMats.Add(mockPlayer.Object, t, new CardCollection { c });
				});

			mockOpponent.SetupGet(_ => _._Game).Returns(mockGame.Object);
			mockOpponent
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Supplies)))
				.Returns((Choice c) => new ChoiceResult(cavalrySupply.Object));
			var cardMatsOpponent = new CardMats();
			cardMatsOpponent.Add(mockOpponent.Object, TypeClass.Exile, new CardCollection());
			mockOpponent.SetupGet(_ => _.PlayerMats).Returns(cardMatsOpponent);
			mockOpponent
				.Setup(_ => _.AddCardInto(TypeClass.Exile, It.IsAny<Card>(), It.IsAny<DeckPosition>()))
				.Callback((Type t, Card c, DeckPosition dp) =>
				{
					cardMatsOpponent.Add(mockOpponent.Object, t, new CardCollection { c });
				});

			using (Event card = new Invest())
			{
				card.Finalize(mockGame.Object);
				card.Bought(mockPlayer.Object);

				var retrievedFromExile = cardMats.Retrieve(mockPlayer.Object, TypeClass.Exile, c => c is Cavalry, 1);

				card.Bought(mockOpponent.Object);

				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards > 0), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Invest_Teardown()
		{
			var mockOpponent = new Mock<IPlayer>();
			var players = new PlayerCollection(mockGame.Object)
			{
				mockPlayer.Object,
				mockOpponent.Object
			};
			mockGame.SetupGet(_ => _.Players).Returns(players);
			#region Set up supplies
			var toExile = new Cavalry();
			var cavalrySupply = new Mock<ISupply>();
			cavalrySupply.SetupGet(_ => _.TopCard).Returns(toExile);
			cavalrySupply.Setup(_ => _.CanGain()).Returns(true);
			cavalrySupply.SetupGet(_ => _.CurrentCost).Returns(toExile.BaseCost);
			cavalrySupply.SetupGet(_ => _.TableableType).Returns(toExile.Type);
			cavalrySupply.Setup(_ => _.Take()).Returns(toExile);
			#endregion
			var supplies = new TableEntityCollection { { TypeClass.Cavalry, cavalrySupply.Object }, };
			mockTable.SetupGet(_ => _.TableEntities).Returns(supplies);

			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Supplies)))
				.Returns((Choice c) => new ChoiceResult(cavalrySupply.Object));
			var cardMats = new CardMats();
			cardMats.Add(mockPlayer.Object, TypeClass.Exile, new CardCollection());
			mockPlayer.SetupGet(_ => _.PlayerMats).Returns(cardMats);

			using (Event card = new Invest())
			{
				card.Finalize(mockGame.Object);
				card.Bought(mockPlayer.Object);

				card.TearDown(mockGame.Object);

				var oppGain = new Cavalry();
				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, oppGain, null, DeckLocation.Discard, DeckPosition.Automatic, false);
				mockOpponent.Raise(_ => _.CardGained += null, cgeArgs);

				Assert.IsFalse(cgeArgs.Resolvers.Any());
			}
		}
		[TestMethod]
		public void Test_Kiln_Basic()
		{
			using (var card = new Kiln())
			{
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(2, card.Benefit.Currency.Coin.Value);
			}
		}
		[TestMethod]
		public void Test_Kiln_Play_No_Second_Play()
		{
			using (Card card = new Kiln())
			{
				card.FollowInstructions(mockPlayer.Object);

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

				var playingCard = new Barge();
				var creArgs = new CardResolvingEventArgs(mockPlayer.Object, playingCard);
				mockPlayer.Raise(_ => _.CardResolving += null, creArgs);
				Assert.IsFalse(creArgs.Resolvers.ContainsKey(card.Type.ToString()));

				var cfieArgs = new CardFollowingInstructionsEventArgs(mockPlayer.Object, playingCard);
				mockPlayer.Raise(_ => _.CardFollowingInstructions += null, cfieArgs);
			}
		}
		[TestMethod]
		public void Test_Kiln_Play_Play_Gainable_Gain()
		{
			var playingCard = new Barge();
			mockTable.Setup(_ => _[It.Is<ICardBase>(cb => cb.Type == playingCard.Type)]).Returns(mockSupply.Object);
			mockSupply.Setup(_ => _.CanGain()).Returns(true);
			mockSupply.SetupGet(_ => _.TopCard).Returns(playingCard);

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

				var creArgs = new CardResolvingEventArgs(mockPlayer.Object, playingCard);
				mockPlayer.Raise(_ => _.CardResolving += null, creArgs);
				Assert.IsTrue(creArgs.Resolvers.ContainsKey(card.Type.ToString()));

				creArgs.Resolvers.Values.First().Method(mockPlayer.Object, ref creArgs);
				mockPlayer.Raise(_ => _.CardFollowingInstructions += null, new CardFollowingInstructionsEventArgs(mockPlayer.Object, playingCard));

				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Kiln_Play_Play_Gainable_No_Gain()
		{
			var playingCard = new Barge();
			mockTable.Setup(_ => _[It.Is<ICardBase>(cb => cb.Type == playingCard.Type)]).Returns(mockSupply.Object);
			mockSupply.Setup(_ => _.CanGain()).Returns(true);
			mockSupply.SetupGet(_ => _.TopCard).Returns(playingCard);

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

				var creArgs = new CardResolvingEventArgs(mockPlayer.Object, playingCard);
				mockPlayer.Raise(_ => _.CardResolving += null, creArgs);
				mockPlayer.Raise(_ => _.CardFollowingInstructions += null, new CardFollowingInstructionsEventArgs(mockPlayer.Object, playingCard));

				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, It.IsAny<int>(), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Kiln_Play_Play_Not_Gainable()
		{
			var playingCard = new DominionBase.Cards.Empires.Patrician();
			var splitPileCard2 = new DominionBase.Cards.Empires.Emporium();
			mockTable.Setup(_ => _[It.Is<ICardBase>(cb => cb.Type == playingCard.Type)]).Returns(mockSupply.Object);
			mockSupply.Setup(_ => _.CanGain()).Returns(true);
			mockSupply.SetupGet(_ => _.TopCard).Returns(splitPileCard2);

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

				var creArgs = new CardResolvingEventArgs(mockPlayer.Object, playingCard);
				mockPlayer.Raise(_ => _.CardResolving += null, creArgs);
				Assert.IsFalse(creArgs.Resolvers.ContainsKey(card.Type.ToString()));
				mockPlayer.Raise(_ => _.CardFollowingInstructions += null, new CardFollowingInstructionsEventArgs(mockPlayer.Object, playingCard));

				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, It.IsAny<int>(), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Kiln_Play_Play_Gainable_No_Gain_Play_Second()
		{
			var playingCard = new Barge();
			mockTable.Setup(_ => _[It.Is<ICardBase>(cb => cb.Type == playingCard.Type)]).Returns(mockSupply.Object);
			mockSupply.Setup(_ => _.CanGain()).Returns(true);
			mockSupply.SetupGet(_ => _.TopCard).Returns(playingCard);

			var playingCard2 = new Supplies();
			var suppliesSupply = new Mock<ISupply>();
			mockTable.Setup(_ => _[It.Is<ICardBase>(cb => cb.Type == playingCard2.Type)]).Returns(suppliesSupply.Object);
			suppliesSupply.Setup(_ => _.CanGain()).Returns(true);
			suppliesSupply.SetupGet(_ => _.TopCard).Returns(playingCard2);

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

				var creArgs = new CardResolvingEventArgs(mockPlayer.Object, playingCard);
				mockPlayer.Raise(_ => _.CardResolving += null, creArgs);
				mockPlayer.Raise(_ => _.CardFollowingInstructions += null, new CardFollowingInstructionsEventArgs(mockPlayer.Object, playingCard));

				var creArgs2 = new CardResolvingEventArgs(mockPlayer.Object, playingCard2);
				mockPlayer.Raise(_ => _.CardResolving += null, creArgs2);
				mockPlayer.Raise(_ => _.CardFollowingInstructions += null, new CardFollowingInstructionsEventArgs(mockPlayer.Object, playingCard2));
				Assert.IsFalse(creArgs2.Resolvers.ContainsKey(card.Type.ToString()));

				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, It.IsAny<int>(), It.IsAny<bool>()), Times.Never);
				mockPlayer.Verify(_ => _.Gain(suppliesSupply.Object, card, It.IsAny<int>(), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Livery_Basic()
		{
			using (var card = new Livery())
			{
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(3, card.Benefit.Currency.Coin.Value);
			}
		}
		[TestMethod]
		public void Test_Livery_Setup()
		{
			// SpecialPiles should maybe be mocked as well??
			var specialPiles = new TableEntityCollection();
			mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

			using (Card card = new Livery())
			{
				card.SetupSupply(mockGame.Object, mockSupply.Object);


				Assert.IsTrue(specialPiles.ContainsKey(TypeClass.Horse));
			}
		}
		[TestMethod]
		public void Test_Livery_Play_No_Gain()
		{
			using (Card card = new Livery())
			{
				card.ObtainedBy(mockPlayer.Object);
				card.FollowInstructions(mockPlayer.Object);


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

				var gainedCard = new Barge();
				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, gainedCard, null, DeckLocation.Discard, DeckPosition.Top, false);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsFalse(cgeArgs.Resolvers.ContainsKey(card.Type.ToString()));
			}
		}
		[TestMethod]
		public void Test_Livery_Play_Gain_1()
		{
			// SpecialPiles should maybe be mocked as well??
			var specialPiles = new TableEntityCollection();
			mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

			using (Card card = new Livery())
			{
				card.SetupSupply(mockGame.Object, mockSupply.Object);

				card.ObtainedBy(mockPlayer.Object);
				card.FollowInstructions(mockPlayer.Object);


				var gainedCard = new Barge();
				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, gainedCard, null, DeckLocation.Discard, DeckPosition.Top, false);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				var key = card.Type.ToString();
				Assert.IsTrue(cgeArgs.Resolvers.ContainsKey(key));

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

				var cgeArgs2 = new DominionBase.Players.CardGainEventArgs(mockGame.Object, gainedCard, null, DeckLocation.Discard, DeckPosition.Top, false);
				cgeArgs2.HandledBy.AddRange(cgeArgs.HandledBy);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs2);
				Assert.IsFalse(cgeArgs2.Resolvers.ContainsKey(key));


				mockPlayer.Verify(_ => _.Gain(It.Is<ISupply>(s => s.Type == TypeClass.Horse), card, 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Livery_Play_Gain_2()
		{
			// SpecialPiles should maybe be mocked as well??
			var specialPiles = new TableEntityCollection();
			mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

			using (Card card = new Livery())
			{
				card.SetupSupply(mockGame.Object, mockSupply.Object);

				card.ObtainedBy(mockPlayer.Object);
				card.FollowInstructions(mockPlayer.Object);


				var key = card.Type.ToString();

				var gainedCard = new Barge();
				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, gainedCard, null, DeckLocation.Discard, DeckPosition.Top, false);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsTrue(cgeArgs.Resolvers.ContainsKey(key));

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

				var gainedCard2 = new Groom();
				var cgeArgs2 = new DominionBase.Players.CardGainEventArgs(mockGame.Object, gainedCard, null, DeckLocation.Discard, DeckPosition.Top, false);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs2);
				Assert.IsTrue(cgeArgs2.Resolvers.ContainsKey(key));

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


				mockPlayer.Verify(_ => _.Gain(It.Is<ISupply>(s => s.Type == TypeClass.Horse), card, 1, false), Times.Exactly(2));
			}
		}
		[TestMethod]
		public void Test_Livery_Play_Twice_Gain_1()
		{
			// SpecialPiles should maybe be mocked as well??
			var specialPiles = new TableEntityCollection();
			mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

			using (Card card = new Livery())
			{
				card.SetupSupply(mockGame.Object, mockSupply.Object);


				card.ObtainedBy(mockPlayer.Object);
				card.FollowInstructions(mockPlayer.Object);
				card.FollowInstructions(mockPlayer.Object);


				var key = card.Type.ToString();
				var gainedCard = new Barge();

				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, gainedCard, null, DeckLocation.Discard, DeckPosition.Top, false);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsTrue(cgeArgs.Resolvers.ContainsKey(key));
				cgeArgs.Resolvers[key].Method(mockPlayer.Object, ref cgeArgs);

				var cgeArgs2 = new DominionBase.Players.CardGainEventArgs(mockGame.Object, gainedCard, null, DeckLocation.Discard, DeckPosition.Top, false);
				cgeArgs2.HandledBy.AddRange(cgeArgs.HandledBy);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs2);
				Assert.IsTrue(cgeArgs2.Resolvers.ContainsKey(key));
				cgeArgs2.Resolvers[key].Method(mockPlayer.Object, ref cgeArgs2);


				mockPlayer.Verify(_ => _.Gain(It.Is<ISupply>(s => s.Type == TypeClass.Horse), card, 1, false), Times.Exactly(2));
			}
		}
		[TestMethod]
		public void Test_Livery_Play_Teardown()
		{
			var players = new PlayerCollection(mockGame.Object)
			{
				mockPlayer.Object,
				mockPlayer.Object
			};
			mockGame.SetupGet(_ => _.Players).Returns(players);

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


				card.TearDown(mockGame.Object);

				var gainedCard = new Barge();
				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, gainedCard, null, DeckLocation.Discard, DeckPosition.Top, false);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsFalse(cgeArgs.Resolvers.ContainsKey(card.Type.ToString()));
			}
		}
		[TestMethod]
		public void Test_March_Basic()
		{
			using (var card = new March())
			{
				Assert.AreEqual(Categories.Event, card.Category);
				Assert.AreEqual(new Cost(3), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_March_Bought_No_Discard()
		{
			var discard = new Deck(DeckLocation.Discard, Visibility.Top, VisibilityTo.All);
			mockPlayer.SetupGet(_ => _.DiscardPile).Returns(discard);

			using (Event card = new March())
			{
				card.Bought(mockPlayer.Object);


				mockPlayer.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Never);
				mockPlayer.Verify(_ => _.PutCardIntoPlay(It.IsAny<Card>(), It.IsAny<string>()), Times.Never);
				mockPlayer.Verify(_ => _.PlayCard(It.IsAny<Card>(), It.IsAny<PlayerMode>()), Times.Never);
				mockPlayer.Verify(_ => _.PlayNothing(It.IsAny<string>()), Times.AtMostOnce);
			}
		}
		[TestMethod]
		public void Test_March_Bought_No_Actions()
		{
			var discard = new Deck(DeckLocation.Discard, Visibility.Top, VisibilityTo.All)
			{
				new Supplies()
			};
			mockPlayer.SetupGet(_ => _.DiscardPile).Returns(discard);

			using (Event card = new March())
			{
				card.Bought(mockPlayer.Object);


				mockPlayer.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Never);
				mockPlayer.Verify(_ => _.PutCardIntoPlay(It.IsAny<Card>(), It.IsAny<string>()), Times.Never);
				mockPlayer.Verify(_ => _.PlayCard(It.IsAny<Card>(), It.IsAny<PlayerMode>()), Times.Never);
				mockPlayer.Verify(_ => _.PlayNothing(It.IsAny<string>()), Times.AtMostOnce);
			}
		}
		[TestMethod]
		public void Test_March_Bought_No_Play()
		{
			var discard = new Deck(DeckLocation.Discard, Visibility.Top, VisibilityTo.All)
			{
				new Horse()
			};
			mockPlayer.SetupGet(_ => _.DiscardPile).Returns(discard);
			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new CardCollection()));

			using (Event card = new March())
			{
				card.Bought(mockPlayer.Object);


				mockPlayer.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Once);
				mockPlayer.Verify(_ => _.PutCardIntoPlay(It.IsAny<Card>(), It.IsAny<string>()), Times.Never);
				mockPlayer.Verify(_ => _.PlayCard(It.IsAny<Card>(), It.IsAny<PlayerMode>()), Times.Never);
				mockPlayer.Verify(_ => _.PlayNothing(It.IsAny<string>()), Times.AtMostOnce);
			}
		}
		[TestMethod]
		public void Test_March_Bought_Play_Action()
		{
			var toPlay = new Horse();
			var discard = new Deck(DeckLocation.Discard, Visibility.Top, VisibilityTo.All)
			{
				toPlay
			};
			mockPlayer.SetupGet(_ => _.DiscardPile).Returns(discard);
			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new CardCollection { toPlay }));

			using (Event card = new March())
			{
				card.Bought(mockPlayer.Object);


				mockPlayer.Verify(_ => _.PutCardIntoPlay(toPlay, It.IsAny<string>()), Times.Once);
				mockPlayer.Verify(_ => _.PlayCard(toPlay, It.IsAny<PlayerMode>()), Times.Once);
				mockPlayer.Verify(_ => _.PlayNothing(It.IsAny<string>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Mastermind_Basic()
		{
			using (var card = new Mastermind())
			{
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Duration, card.Category);
				Assert.AreEqual(new Cost(5), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Mastermind_Play_Basic_Action()
		{
			mockTable.SetupGet(_ => _.TableEntities).Returns(new TableEntityCollection());
			var toPlay = new Livery();
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner)
			{
				toPlay
			};
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card> { toPlay }));
			mockPlayer.Setup(_ => _.RetrieveCardFrom(DeckLocation.Hand, toPlay)).Returns(toPlay);

			using (var card = new Mastermind())
			{
				// Just sets the card in play
				card.FollowInstructions(mockPlayer.Object);
				Assert.IsFalse(card.CanCleanUp);


				var teeArgs = new TurnEndedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnEnded += null, teeArgs);
				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(_ => _.PlayCard(toPlay, It.IsAny<PlayerMode>()), Times.Exactly(3));
				Assert.IsTrue(card.CanCleanUp);


				// Teardown at the end (Make sure event listener isn't listening any more)
				teeArgs = new TurnEndedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnEnded += null, teeArgs);
				tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.IsFalse(tseArgs.Resolvers.ContainsKey(card.Name));
			}
		}
		[TestMethod]
		public void Test_Mastermind_Play_No_Action()
		{
			mockTable.SetupGet(_ => _.TableEntities).Returns(new TableEntityCollection());
			var toPlay = new Livery();
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner)
			{
				toPlay
			};
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>()));
			mockPlayer.Setup(_ => _.RetrieveCardFrom(DeckLocation.Hand, toPlay)).Returns(toPlay);

			using (var card = new Mastermind())
			{
				// Just sets the card in play
				card.FollowInstructions(mockPlayer.Object);
				Assert.IsFalse(card.CanCleanUp);


				var teeArgs = new TurnEndedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnEnded += null, teeArgs);
				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(_ => _.PlayCard(toPlay, It.IsAny<PlayerMode>()), Times.Never);
				Assert.IsTrue(card.CanCleanUp);
			}
		}
		[TestMethod]
		public void Test_Mastermind_Play_Duration_Action()
		{
			mockTable.SetupGet(_ => _.TableEntities).Returns(new TableEntityCollection());
			var toPlay = new Barge();
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner)
			{
				toPlay
			};
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)))
				.Returns(new ChoiceResult(new ItemCollection<Card> { toPlay }));
			mockPlayer.Setup(_ => _.RetrieveCardFrom(DeckLocation.Hand, toPlay)).Returns(toPlay);
			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options)))
				.Returns(new ChoiceResult(new List<string> { ResourcesHelper.Get("NextTurn") }));
			mockPlayer
				.Setup(_ => _.PlayCard(toPlay, It.IsAny<PlayerMode>()))
				.Callback<Card, PlayerMode>((c, pm) =>
				{
					c.FollowInstructions(mockPlayer.Object);
				});

			using (var card = new Mastermind())
			{
				// Just sets the card in play
				card.FollowInstructions(mockPlayer.Object);
				Assert.IsFalse(card.CanCleanUp);


				var teeArgs = new TurnEndedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnEnded += null, teeArgs);
				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(_ => _.PlayCard(toPlay, It.IsAny<PlayerMode>()), Times.Exactly(3));
				Assert.IsFalse(card.CanCleanUp);


				// 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_Mastermind_Teardown()
		{
			using (var card = new Mastermind())
			{
				mockTable.SetupGet(_ => _.TableEntities).Returns(new TableEntityCollection());


				// Just sets the card in play
				card.FollowInstructions(mockPlayer.Object);
				var teeArgs = new TurnEndedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnEnded += null, teeArgs);
				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_Paddock_Basic()
		{
			using (var card = new Paddock())
			{
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(2, card.Benefit.Currency.Coin.Value);
			}
		}
		[TestMethod]
		public void Test_Paddock_Setup()
		{
			// SpecialPiles should maybe be mocked as well??
			var specialPiles = new TableEntityCollection();
			mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

			using (Card card = new Paddock())
			{
				card.SetupSupply(mockGame.Object, mockSupply.Object);


				Assert.IsTrue(specialPiles.ContainsKey(TypeClass.Horse));
			}
		}
		[TestMethod]
		public void Test_Paddock_Play_No_Empty()
		{
			var supplies = new TableEntityCollection
			{
				{ TypeClass.Cavalry, mockSupply.Object }
			};
			mockTable.SetupGet(_ => _.TableEntities).Returns(supplies);
			mockSupply.SetupGet(_ => _.Location).Returns(Location.Kingdom);
			mockSupply.SetupGet(_ => _.Count).Returns(10);
			// SpecialPiles should maybe be mocked as well??
			var specialPiles = new TableEntityCollection();
			mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

			using (Card card = new Paddock())
			{
				card.SetupSupply(mockGame.Object, mockSupply.Object);

				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(It.Is<ISupply>(s => s.Type == TypeClass.Horse), card, 2, false), Times.Once);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Paddock_Play_2_Empty()
		{
			var supplies = new TableEntityCollection
			{
				{ TypeClass.Cavalry, mockSupply.Object },
				{ TypeClass.Barge, mockSupply.Object }
			};
			mockTable.SetupGet(_ => _.TableEntities).Returns(supplies);
			mockSupply.SetupGet(_ => _.Location).Returns(Location.Kingdom);
			mockSupply.SetupGet(_ => _.Count).Returns(0);
			// SpecialPiles should maybe be mocked as well??
			var specialPiles = new TableEntityCollection();
			mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

			using (Card card = new Paddock())
			{
				card.SetupSupply(mockGame.Object, mockSupply.Object);

				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(It.Is<ISupply>(s => s.Type == TypeClass.Horse), card, 2, false), Times.Once);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Exactly(2));
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Actions == 2), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Populate_Basic()
		{
			using (var card = new Populate())
			{
				Assert.AreEqual(Categories.Event, card.Category);
				Assert.AreEqual(new Cost(10), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Populate_Bought_No_Actions()
		{
			var randomizer = new Mock<IDisplayable>();
			randomizer.SetupGet(_ => _.Category).Returns(Categories.Card | Categories.Treasure);
			mockSupply.SetupGet(_ => _.Randomizer).Returns(randomizer.Object);
			mockSupply.Setup(_ => _.CanGain()).Returns(true);

			var supplies = new TableEntityCollection
			{
				{ TypeClass.Supplies, mockSupply.Object }
			};
			mockTable.SetupGet(_ => _.TableEntities).Returns(supplies);

			using (Event card = new Populate())
			{
				card.Bought(mockPlayer.Object);


				mockPlayer.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Populate_Bought_Gain_All_Actions()
		{
			var randomizer = new Mock<IDisplayable>();
			randomizer.SetupGet(_ => _.Category).Returns(Categories.Card | Categories.Action);
			mockSupply.SetupGet(_ => _.Randomizer).Returns(randomizer.Object);
			mockSupply.SetupGet(_ => _.TableableType).Returns(TypeClass.Goatherd);
			mockSupply.Setup(_ => _.CanGain()).Returns(true);

			var mockSupply2 = new Mock<ISupply>();
			var randomizer2 = new Mock<IDisplayable>();
			randomizer2.SetupGet(_ => _.Category).Returns(Categories.Card | Categories.Action | Categories.Reaction);
			mockSupply2.SetupGet(_ => _.Randomizer).Returns(randomizer2.Object);
			mockSupply2.SetupGet(_ => _.TableableType).Returns(DominionBase.Cards.Base.TypeClass.Moat);
			mockSupply2.Setup(_ => _.CanGain()).Returns(true);

			var supplies = new TableEntityCollection
			{
				{ mockSupply.Object.TableableType, mockSupply.Object },
				{ mockSupply2.Object.TableableType, mockSupply2.Object }
			};
			mockTable.SetupGet(_ => _.TableEntities).Returns(supplies);

			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Supplies)))
				.Returns((Choice c) => new ChoiceResult((ISupply)c.Supplies.Values.First()));

			using (Event card = new Populate())
			{
				card.Bought(mockPlayer.Object);


				mockPlayer.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Exactly(2));
				mockPlayer.Verify(_ => _.Gain(It.IsAny<ISupply>(), card, 1, false), Times.Exactly(2));
			}
		}
		[TestMethod]
		public void Test_Pursue_Basic()
		{
			using (var card = new Pursue())
			{
				Assert.AreEqual(Categories.Event, card.Category);
				Assert.AreEqual(new Cost(2), card.BaseCost);
				Assert.AreEqual(1, card.Benefit.Buys);
			}
		}
		[TestMethod]
		public void Test_Pursue_Bought_No_Matches()
		{
			var toDraw = new CardCollection { new Paddock(), new Scrap(), new Wayfarer(), new Paddock() };

			var supplies = new TableEntityCollection
			{
				{ TypeClass.Supplies, mockSupply.Object }
			};
			mockTable.SetupGet(_ => _.TableEntities).Returns(supplies);
			mockTable.SetupGet(_ => _.SpecialPiles).Returns(new TableEntityCollection());
			var mockRand = new Mock<IDisplayable>();
			mockSupply.SetupGet(_ => _.Randomizer).Returns(mockRand.Object);
			mockRand.SetupGet(_ => _.Traits).Returns(Traits.None);
			mockSupply.SetupGet(_ => _.Location).Returns(Location.Kingdom);
			mockSupply.SetupGet(_ => _.TableableType).Returns(TypeClass.Supplies);
			mockSupply.SetupGet(_ => _.Name).Returns("Supplies");

			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.SuppliesAndCards)))
				.Returns((Choice c) =>
				{
					return new ChoiceResult((ISupply)c.Supplies.Values.First());
				});
			mockPlayer
				.Setup(_ => _.RetrieveCardsFrom(DeckLocation.Revealed, It.IsAny<Predicate<Card>>(), It.IsAny<int>()))
				.Returns((DeckLocation dl, Predicate<Card> pred, int count) =>
				{
					return toDraw.FindAll(pred);
				});

			using (Event card = new Pursue())
			{
				card.Bought(mockPlayer.Object);


				mockPlayer.Verify(_ => _.AddCardsToDeck(It.Is<IEnumerable<Card>>(ic => ic.Any()), DeckPosition.Top), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Pursue_Bought_All_Matches()
		{
			var toDraw = new CardCollection { new Supplies(), new Supplies(), new Supplies(), new Supplies() };

			var supplies = new TableEntityCollection
			{
				{ TypeClass.Supplies, mockSupply.Object }
			};
			mockTable.SetupGet(_ => _.TableEntities).Returns(supplies);
			mockTable.SetupGet(_ => _.SpecialPiles).Returns(new TableEntityCollection());
			var mockRand = new Mock<IDisplayable>();
			mockSupply.SetupGet(_ => _.Randomizer).Returns(mockRand.Object);
			mockRand.SetupGet(_ => _.Traits).Returns(Traits.None);
			mockSupply.SetupGet(_ => _.Location).Returns(Location.Kingdom);
			mockSupply.SetupGet(_ => _.TableableType).Returns(TypeClass.Supplies);
			mockSupply.SetupGet(_ => _.Name).Returns(toDraw.First().Name);

			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.SuppliesAndCards)))
				.Returns((Choice c) =>
				{
					return new ChoiceResult((ISupply)c.Supplies.Values.First());
				});
			mockPlayer
				.Setup(_ => _.RetrieveCardsFrom(DeckLocation.Revealed, It.IsAny<Predicate<Card>>(), It.IsAny<int>()))
				.Returns((DeckLocation dl, Predicate<Card> pred, int count) =>
				{
					return toDraw.FindAll(pred);
				});

			using (Event card = new Pursue())
			{
				card.Bought(mockPlayer.Object);


				mockPlayer.Verify(_ => _.AddCardsToDeck(It.Is<IEnumerable<Card>>(ic => ic.Count() == 4), DeckPosition.Top), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Reap_Basic()
		{
			using (var card = new Reap())
			{
				Assert.AreEqual(Categories.Event, card.Category);
				Assert.AreEqual(new Cost(7), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Reap_Bought()
		{
			var toGain = new DominionBase.Cards.Universal.Gold();
			var mockGold = new Mock<ISupply>();
			mockTable.SetupGet(_ => _.Gold).Returns(mockGold.Object);
			var mats = new CardMats();
			mockPlayer.SetupGet(_ => _.PlayerMats).Returns(mats);
			mockPlayer.SetupGet(_ => _.DiscardPile).Returns(new Deck(DeckLocation.Discard));
			mockPlayer.SetupGet(_ => _.Private).Returns(new Deck(DeckLocation.Private));
			mockPlayer.Setup(_ => _.RetrieveCardFrom(TypeClass.ReapSetAside, toGain)).Returns(toGain);

			using (Event card = new Reap())
			{
				card.Bought(mockPlayer.Object);

				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, toGain, card, DeckLocation.Discard, DeckPosition.Top, false);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.AreEqual(1, cgeArgs.Resolvers.Count);
				cgeArgs.Resolvers.Values.First().Method(mockPlayer.Object, ref cgeArgs);


				var teeArgs = new TurnEndedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnEnded += null, teeArgs);
				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.AreEqual(1, tseArgs.Resolvers.Count);

				tseArgs.Resolvers.Values.First().Method(mockPlayer.Object, ref tseArgs);

				mockPlayer.Verify(_ => _.PutCardIntoPlay(It.Is<Card>(c => c.Type == DominionBase.Cards.Universal.TypeClass.Gold), It.IsAny<string>()), Times.Once);
				mockPlayer.Verify(_ => _.PlayCard(It.Is<Card>(c => c.Type == DominionBase.Cards.Universal.TypeClass.Gold), It.IsAny<PlayerMode>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Reap_Bought_2x()
		{
			var toGain1 = new DominionBase.Cards.Universal.Gold();
			var toGain2 = new DominionBase.Cards.Universal.Gold();
			var mockGold = new Mock<ISupply>();
			mockTable.SetupGet(_ => _.Gold).Returns(mockGold.Object);
			var mats = new CardMats();
			mockPlayer.SetupGet(_ => _.PlayerMats).Returns(mats);
			mockPlayer.SetupGet(_ => _.DiscardPile).Returns(new Deck(DeckLocation.Discard));
			mockPlayer.SetupGet(_ => _.Private).Returns(new Deck(DeckLocation.Private));
			mockPlayer.Setup(_ => _.RetrieveCardFrom(TypeClass.ReapSetAside, toGain1)).Returns(toGain1);
			mockPlayer.Setup(_ => _.RetrieveCardFrom(TypeClass.ReapSetAside, toGain2)).Returns(toGain2);

			using (Event card = new Reap())
			{
				card.Bought(mockPlayer.Object);

				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, toGain1, card, DeckLocation.Discard, DeckPosition.Top, false);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.AreEqual(1, cgeArgs.Resolvers.Count);
				cgeArgs.Resolvers.Values.First().Method(mockPlayer.Object, ref cgeArgs);

				card.Bought(mockPlayer.Object);

				cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, toGain2, card, DeckLocation.Discard, DeckPosition.Top, false);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.AreEqual(1, cgeArgs.Resolvers.Count);
				cgeArgs.Resolvers.Values.First().Method(mockPlayer.Object, ref cgeArgs);


				var teeArgs = new TurnEndedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnEnded += null, teeArgs);
				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.AreEqual(1, tseArgs.Resolvers.Count);
				tseArgs.Resolvers.Values.First().Method(mockPlayer.Object, ref tseArgs);

				tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.AreEqual(1, tseArgs.Resolvers.Count);
				tseArgs.Resolvers.Values.First().Method(mockPlayer.Object, ref tseArgs);

				mockPlayer.Verify(_ => _.PutCardIntoPlay(It.Is<Card>(c => c.Type == DominionBase.Cards.Universal.TypeClass.Gold), It.IsAny<string>()), Times.Exactly(2));
				mockPlayer.Verify(_ => _.PlayCard(It.Is<Card>(c => c.Type == DominionBase.Cards.Universal.TypeClass.Gold), It.IsAny<PlayerMode>()), Times.Exactly(2));
			}
		}
		[TestMethod]
		public void Test_Reap_Teardown()
		{
			var mockOpponent = new Mock<IPlayer>();
			var players = new PlayerCollection(mockGame.Object)
			{
				mockPlayer.Object,
				mockOpponent.Object
			};
			mockGame.SetupGet(_ => _.Players).Returns(players);

			var toGain = new DominionBase.Cards.Universal.Gold();
			var mats = new CardMats();
			mockPlayer.SetupGet(_ => _.PlayerMats).Returns(mats);
			var hand = new Deck(DeckLocation.Hand);
			var toPlay = new Barge();
			hand.AddRange(mockPlayer.Object, new List<Card> { toPlay });
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
			mockPlayer.SetupGet(_ => _.DiscardPile).Returns(new Deck(DeckLocation.Discard));
			mockPlayer.SetupGet(_ => _.Private).Returns(new Deck(DeckLocation.Private));
			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new CardCollection { toPlay }));

			using (Event card = new Reap())
			{
				card.Bought(mockPlayer.Object);

				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, toGain, card, DeckLocation.Discard, DeckPosition.Top, false);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.AreEqual(1, cgeArgs.Resolvers.Count);
				cgeArgs.Resolvers.Values.First().Method(mockPlayer.Object, ref cgeArgs);

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

				card.End(mockPlayer.Object, new DisplayableCollection());
				card.End(mockOpponent.Object, new DisplayableCollection());
				card.TearDown(mockGame.Object);


				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.IsFalse(tseArgs.Resolvers.Any());
			}
		}
		[TestMethod]
		public void Test_Ride_Basic()
		{
			using (var card = new Ride())
			{
				Assert.AreEqual(Categories.Event, card.Category);
				Assert.AreEqual(new Cost(2), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Ride_Setup_Correctly()
		{
			// SpecialPiles should maybe be mocked as well??
			var specialPiles = new TableEntityCollection();
			mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

			using (var card = new Ride())
			{
				card.Finalize(mockGame.Object);


				Assert.IsTrue(specialPiles.ContainsKey(TypeClass.Horse));
			}
		}
		[TestMethod]
		public void Test_Ride_Bought()
		{
			// SpecialPiles should maybe be mocked as well??
			var specialPiles = new TableEntityCollection();
			mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

			using (Event card = new Ride())
			{
				card.Finalize(mockGame.Object);
				mockTable.SetupGet(_ => _[TypeClass.Horse]).Returns(specialPiles[TypeClass.Horse]);


				card.Bought(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(It.Is<ISupply>(s => s.Type == TypeClass.Horse), card, 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Sanctuary_Basic()
		{
			using (var card = new Sanctuary())
			{
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(1, card.Benefit.Actions);
				Assert.AreEqual(1, card.Benefit.Cards);
				Assert.AreEqual(1, card.Benefit.Buys);
			}
		}
		[TestMethod]
		public void Test_Sanctuary_Play_Nothing_To_Exile()
		{
			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new CardCollection()));

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


				mockPlayer.Verify(_ => _.RetrieveCardFrom(DeckLocation.Hand, It.IsAny<Card>()), Times.Never);
				mockPlayer.Verify(_ => _.AddCardInto(TypeClass.Exile, It.IsAny<Card>(), It.IsAny<DeckPosition>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Sanctuary_Play_Exile_Card()
		{
			var toExile = new CamelTrain();
			var cardMats = new CardMats { [TypeClass.Exile] = new Exile() };
			mockPlayer.SetupGet(_ => _.PlayerMats).Returns(cardMats);
			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)))
				.Returns(new ChoiceResult(new CardCollection { toExile }));
			mockPlayer
				.Setup(_ => _.RetrieveCardFrom(DeckLocation.Hand, toExile))
				.Returns(toExile);
			mockPlayer
				.Setup(_ => _.AddCardInto(TypeClass.Exile, It.IsAny<Card>(), It.IsAny<DeckPosition>()))
				.Callback((Type type, Card card, DeckPosition dp) =>
				{
					cardMats[type].Add(card);
				});

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


				mockPlayer.Verify(_ => _.RetrieveCardFrom(DeckLocation.Hand, toExile), Times.Once);
				mockPlayer.Verify(_ => _.AddCardInto(TypeClass.Exile, toExile, It.IsAny<DeckPosition>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Scrap_Basic()
		{
			using (var card = new Scrap())
			{
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
				Assert.AreEqual(new Cost(3), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Scrap_Setup()
		{
			// SpecialPiles should maybe be mocked as well??
			var specialPiles = new TableEntityCollection();
			mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

			using (Card card = new Scrap())
			{
				card.SetupSupply(mockGame.Object, mockSupply.Object);


				Assert.IsTrue(specialPiles.ContainsKey(TypeClass.Horse));
			}
		}
		[TestMethod]
		public void Test_Scrap_Play_Nothing_To_Trash()
		{
			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new CardCollection()));

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


				mockPlayer.Verify(_ => _.Trash(card, It.IsAny<ItemCollection<Card>>()), Times.Never);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Once);
				mockPlayer.Verify(_ => _.Gain(It.IsAny<ISupply>(), card, It.IsAny<int>(), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Scrap_Play_Trash_0_Cost()
		{
			var toTrash = new DominionBase.Cards.Universal.Copper();
			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)))
				.Returns(new ChoiceResult(new CardCollection { toTrash }));
			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options)))
				.Returns((Choice c) => new ChoiceResult(new List<string>()));
			mockPlayer
				.Setup(_ => _.RetrieveCardsFrom(DeckLocation.Hand, It.IsAny<ItemCollection<Card>>()))
				.Returns(new CardCollection { toTrash });

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


				mockPlayer.Verify(_ => _.Trash(card, It.IsAny<ItemCollection<Card>>()), Times.Once);
				mockPlayer.Verify(_ => _.Trash(card, It.Is<ItemCollection<Card>>(ic => ic.Count == 1 && ic[0] == toTrash)), Times.Once);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Once);
				mockPlayer.Verify(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options)), Times.Never);
				mockPlayer.Verify(_ => _.Gain(It.IsAny<ISupply>(), card, It.IsAny<int>(), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Scrap_Play_Trash_1_Cost()
		{
			var toTrash = new DominionBase.Cards.DarkAges.PoorHouse();
			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)))
				.Returns(new ChoiceResult(new CardCollection { toTrash }));
			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options)))
				.Returns((Choice c) => new ChoiceResult(new List<string> { c.Options[0].Text }));
			mockPlayer
				.Setup(_ => _.RetrieveCardsFrom(DeckLocation.Hand, It.IsAny<ItemCollection<Card>>()))
				.Returns(new CardCollection { toTrash });

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


				mockPlayer.Verify(_ => _.Trash(card, It.IsAny<ItemCollection<Card>>()), Times.Once);
				mockPlayer.Verify(_ => _.Trash(card, It.Is<ItemCollection<Card>>(ic => ic.Count == 1 && ic[0] == toTrash)), Times.Once);
				mockPlayer.Verify(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options && c.Minimum == 1)), Times.Once);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Exactly(2));
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards == 1), It.IsAny<bool>()), Times.Once);
				mockPlayer.Verify(_ => _.Gain(It.IsAny<ISupply>(), card, It.IsAny<int>(), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Scrap_Play_Trash_6_Cost()
		{
			// SpecialPiles should maybe be mocked as well??
			var specialPiles = new TableEntityCollection();
			mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);
			mockTable.Setup(_ => _.Silver).Returns(mockSupply.Object);

			var toTrash = new DominionBase.Cards.Universal.Gold();
			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)))
				.Returns(new ChoiceResult(new CardCollection { toTrash }));
			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options)))
				.Returns((Choice c) => new ChoiceResult(c.Options.Select(o => o.Text).ToList()));
			mockPlayer
				.Setup(_ => _.RetrieveCardsFrom(DeckLocation.Hand, It.IsAny<ItemCollection<Card>>()))
				.Returns(new CardCollection { toTrash });

			using (Card card = new Scrap())
			{
				card.SetupSupply(mockGame.Object, mockSupply.Object);

				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Trash(card, It.IsAny<ItemCollection<Card>>()), Times.Once);
				mockPlayer.Verify(_ => _.Trash(card, It.Is<ItemCollection<Card>>(ic => ic.Count == 1 && ic[0] == toTrash)), Times.Once);
				mockPlayer.Verify(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options && c.Minimum == 6)), Times.Once);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Exactly(2));
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards == 1 && cb.Actions == 1 && cb.Buys == 1 && cb.Currency.Coin == new Coin(1)), It.IsAny<bool>()), Times.Once);
				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, 1, false), Times.Once);
				mockPlayer.Verify(_ => _.Gain(It.Is<ISupply>(s => s.Type == TypeClass.Horse), card, 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Scrap_Play_Trash_8_Cost()
		{
			// SpecialPiles should maybe be mocked as well??
			var specialPiles = new TableEntityCollection();
			mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);
			mockTable.Setup(_ => _.Silver).Returns(mockSupply.Object);

			var toTrash = new DominionBase.Cards.Universal.Province();
			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)))
				.Returns(new ChoiceResult(new CardCollection { toTrash }));
			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options)))
				.Returns((Choice c) => new ChoiceResult(c.Options.Select(o => o.Text).ToList()));
			mockPlayer
				.Setup(_ => _.RetrieveCardsFrom(DeckLocation.Hand, It.IsAny<ItemCollection<Card>>()))
				.Returns(new CardCollection { toTrash });

			using (Card card = new Scrap())
			{
				card.SetupSupply(mockGame.Object, mockSupply.Object);

				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Trash(card, It.IsAny<ItemCollection<Card>>()), Times.Once);
				mockPlayer.Verify(_ => _.Trash(card, It.Is<ItemCollection<Card>>(ic => ic.Count == 1 && ic[0] == toTrash)), Times.Once);
				mockPlayer.Verify(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options && c.Minimum == 6)), Times.Once);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Exactly(2));
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards == 1 && cb.Actions == 1 && cb.Buys == 1 && cb.Currency.Coin == new Coin(1)), It.IsAny<bool>()), Times.Once);
				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, 1, false), Times.Once);
				mockPlayer.Verify(_ => _.Gain(It.Is<ISupply>(s => s.Type == TypeClass.Horse), card, 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Sheepdog_Basic()
		{
			using (var card = new Sheepdog())
			{
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Reaction, card.Category);
				Assert.AreEqual(new Cost(3), card.BaseCost);
				Assert.AreEqual(2, card.Benefit.Cards);
			}
		}
		[TestMethod]
		public void Test_Sheepdog_Gain_No_Play()
		{
			var toGain = new Scrap();
			var mockOpponent = new Mock<IPlayer>();
			var players = new PlayerCollection(mockGame.Object)
			{
				mockPlayer.Object,
				mockOpponent.Object
			};
			mockGame.SetupGet(_ => _.Players).Returns(players);
			mockTable.Setup(_ => _.TableEntities).Returns(new TableEntityCollection());
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);

			using (Card card = new Sheepdog())
			{
				card.ObtainedBy(mockPlayer.Object);
				hand.Add(card);
				card.AddedTo(DeckLocation.Hand, mockPlayer.Object);


				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, toGain, null, DeckLocation.Discard, DeckPosition.Top, true);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsTrue(cgeArgs.Resolvers.Any());

				mockPlayer.Verify(_ => _.PlayCard(card, DeckLocation.InPlay), Times.Never);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Sheepdog_Gain_Play()
		{
			var toGain = new Scrap();
			var mockOpponent = new Mock<IPlayer>();
			var players = new PlayerCollection(mockGame.Object)
			{
				mockPlayer.Object,
				mockOpponent.Object
			};
			mockGame.SetupGet(_ => _.Players).Returns(players);
			mockTable.Setup(_ => _.TableEntities).Returns(new TableEntityCollection());
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
			mockPlayer
				.Setup(_ => _.PlayCard(It.IsAny<Card>(), DeckLocation.InPlay))
				.Callback((Card cardToPlay, DeckLocation dl) =>
				{
					cardToPlay.RemovedFrom(DeckLocation.Hand, mockPlayer.Object);
					cardToPlay.FollowInstructions(mockPlayer.Object);
				});

			using (Card card = new Sheepdog())
			{
				card.ObtainedBy(mockPlayer.Object);
				hand.Add(card);
				card.AddedTo(DeckLocation.Hand, mockPlayer.Object);


				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, toGain, null, DeckLocation.Discard, DeckPosition.Top, true);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsTrue(cgeArgs.Resolvers.Any());

				cgeArgs.Resolvers.Values.First().Method(mockPlayer.Object, ref cgeArgs);

				mockPlayer.Verify(_ => _.PlayCard(card, DeckLocation.InPlay), Times.Once);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards == 2), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Sheepdog_Teardown()
		{
			var toGain = new Scrap();
			var mockOpponent = new Mock<IPlayer>();
			var players = new PlayerCollection(mockGame.Object)
			{
				mockPlayer.Object,
				mockOpponent.Object
			};
			mockGame.SetupGet(_ => _.Players).Returns(players);
			mockTable.Setup(_ => _.TableEntities).Returns(new TableEntityCollection());
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);

			using (Card card = new Sheepdog())
			{
				card.ObtainedBy(mockPlayer.Object);
				hand.Add(card);
				card.AddedTo(DeckLocation.Hand, mockPlayer.Object);


				card.TearDown(mockGame.Object);


				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, toGain, null, DeckLocation.Discard, DeckPosition.Top, true);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsFalse(cgeArgs.Resolvers.Any());
			}
		}
		[TestMethod]
		public void Test_SeizeTheDay_Basic()
		{
			using (var card = new SeizeTheDay())
			{
				Assert.AreEqual(Categories.Event, card.Category);
				Assert.AreEqual(new Cost(4), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_SeizeTheDay_Bought_First_Turn()
		{
			var allTurns = new TurnCollection();
			var currentTurn = new Turn(mockPlayer.Object);
			allTurns.Add(currentTurn);
			mockGame.SetupGet(_ => _.TurnsTaken).Returns(allTurns);
			mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(currentTurn);
			mockPlayer.SetupGet(_ => _.TokenPiles).Returns(new TokenCollections());

			using (Event card = new SeizeTheDay())
			{
				card.Init(mockGame.Object, new PlayerCollection(mockGame.Object));

				Assert.IsTrue(card.CanBuy(mockPlayer.Object, new Currency(4)));

				currentTurn.Bought(card);
				card.Bought(mockPlayer.Object);


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

				Assert.AreEqual(mockPlayer.Object, teeArgs.NextPlayer);
				Assert.AreEqual(card, teeArgs.NextGrantedBy);
			}
		}
		[TestMethod]
		public void Test_SeizeTheDay_Bought_2x()
		{
			var opponent = new Mock<IPlayer>();
			var allTurns = new TurnCollection()
			{
				new Turn(opponent.Object),
				new Turn(mockPlayer.Object),
				new Turn(opponent.Object),
				new Turn(mockPlayer.Object),
				new Turn(opponent.Object)
			};
			var currentTurn = new Turn(mockPlayer.Object);
			allTurns.Add(currentTurn);
			mockGame.SetupGet(_ => _.TurnsTaken).Returns(allTurns);
			mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(currentTurn);
			mockPlayer.SetupGet(_ => _.TokenPiles).Returns(new TokenCollections());

			using (Event card = new SeizeTheDay())
			{
				card.Init(mockGame.Object, new PlayerCollection(mockGame.Object));

				currentTurn.Bought(card);
				card.Bought(mockPlayer.Object);


				Assert.IsFalse(card.CanBuy(mockPlayer.Object, new Currency(4)));
				currentTurn.Bought(card);
				card.Bought(mockPlayer.Object);


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

				Assert.AreEqual(mockPlayer.Object, teeArgs.NextPlayer);
				Assert.AreEqual(card, teeArgs.NextGrantedBy);
			}
		}
		[TestMethod]
		public void Test_SeizeTheDay_Bought_Teardown()
		{
			var opponent = new Mock<IPlayer>();
			var allTurns = new TurnCollection()
			{
				new Turn(opponent.Object),
				new Turn(mockPlayer.Object),
				new Turn(opponent.Object),
				new Turn(mockPlayer.Object),
				new Turn(opponent.Object)
			};
			var currentTurn = new Turn(mockPlayer.Object);
			allTurns.Add(currentTurn);
			var players = new PlayerCollection(mockGame.Object)
			{
				opponent.Object,
				mockPlayer.Object
			};
			mockGame.SetupGet(_ => _.Players).Returns(players);
			mockGame.SetupGet(_ => _.TurnsTaken).Returns(allTurns);
			mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(currentTurn);
			mockPlayer.SetupGet(_ => _.TokenPiles).Returns(new TokenCollections());

			using (Event card = new SeizeTheDay())
			{
				currentTurn.Bought(card);
				card.Bought(mockPlayer.Object);

				card.TearDown(mockGame.Object);

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

				Assert.AreNotEqual(mockPlayer.Object, teeArgs.NextPlayer);
				Assert.AreNotEqual(card, teeArgs.NextGrantedBy);
			}
		}
		[TestMethod]
		public void Test_Sleigh_Basic()
		{
			using (var card = new Sleigh())
			{
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Reaction, card.Category);
				Assert.AreEqual(new Cost(2), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Sleigh_Setup()
		{
			// SpecialPiles should maybe be mocked as well??
			var specialPiles = new TableEntityCollection();
			mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

			using (Card card = new Sleigh())
			{
				card.SetupSupply(mockGame.Object, mockSupply.Object);


				Assert.IsTrue(specialPiles.ContainsKey(TypeClass.Horse));
			}
		}
		[TestMethod]
		public void Test_Sleigh_Play()
		{
			// SpecialPiles should maybe be mocked as well??
			var specialPiles = new TableEntityCollection();
			mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

			using (Card card = new Sleigh())
			{
				card.SetupSupply(mockGame.Object, mockSupply.Object);

				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(It.Is<ISupply>(s => s.Type == TypeClass.Horse), card, 2, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Sleigh_Gain_Other_No_Discard()
		{
			var toGain = new Barge();
			mockTable.Setup(_ => _.TableEntities).Returns(new TableEntityCollection());
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);

			using (Card card = new Sleigh())
			{
				card.ObtainedBy(mockPlayer.Object);
				hand.Add(card);
				card.AddedTo(DeckLocation.Hand, mockPlayer.Object);

				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, toGain, null, DeckLocation.Discard, DeckPosition.Top, true);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsTrue(cgeArgs.Resolvers.Any());

				Assert.AreEqual(DeckLocation.Discard, cgeArgs.Location);
				Assert.AreEqual(DeckPosition.Top, cgeArgs.Position);

				mockPlayer.Verify(_ => _.Discard(DeckLocation.Hand, card), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Sleigh_Gain_Other_Discard_Hand()
		{
			var toGain = new Barge();
			mockTable.Setup(_ => _.TableEntities).Returns(new TableEntityCollection());
			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 List<string> { ResourcesHelper.Get("PutIntoHand") }));

			using (Card card = new Sleigh())
			{
				card.ObtainedBy(mockPlayer.Object);
				hand.Add(card);
				card.AddedTo(DeckLocation.Hand, mockPlayer.Object);

				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, toGain, null, DeckLocation.Discard, DeckPosition.Top, true);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsTrue(cgeArgs.Resolvers.Any());

				cgeArgs.Resolvers.Values.First().Method(mockPlayer.Object, ref cgeArgs);

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

				mockPlayer.Verify(_ => _.Discard(DeckLocation.Hand, card), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Sleigh_Gain_Other_Discard_Topdeck()
		{
			var toGain = new Barge();
			mockTable.Setup(_ => _.TableEntities).Returns(new TableEntityCollection());
			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 List<string> { ResourcesHelper.Get("PutOnDeck") }));

			using (Card card = new Sleigh())
			{
				card.ObtainedBy(mockPlayer.Object);
				hand.Add(card);
				card.AddedTo(DeckLocation.Hand, mockPlayer.Object);

				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, toGain, null, DeckLocation.Discard, DeckPosition.Top, true);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsTrue(cgeArgs.Resolvers.Any());

				cgeArgs.Resolvers.Values.First().Method(mockPlayer.Object, ref cgeArgs);

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

				mockPlayer.Verify(_ => _.Discard(DeckLocation.Hand, card), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Sleigh_Discard_From_Hand_Gain_No_Trigger()
		{
			var toGain = new Barge();
			mockTable.Setup(_ => _.TableEntities).Returns(new TableEntityCollection());
			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 List<string> { ResourcesHelper.Get("PutIntoHand") }));

			using (Card card = new Sleigh())
			{
				card.ObtainedBy(mockPlayer.Object);
				hand.Add(card);
				card.AddedTo(DeckLocation.Hand, mockPlayer.Object);
				hand.Remove(card);
				card.RemovedFrom(DeckLocation.Hand, mockPlayer.Object);

				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, toGain, null, DeckLocation.Discard, DeckPosition.Top, true);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);

				Assert.IsFalse(cgeArgs.Resolvers.Any());
			}
		}
		[TestMethod]
		public void Test_SnowyVillage_Basic()
		{
			using (var card = new SnowyVillage())
			{
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
				Assert.AreEqual(new Cost(3), card.BaseCost);
				Assert.AreEqual(1, card.Benefit.Cards);
				Assert.AreEqual(4, card.Benefit.Actions);
				Assert.AreEqual(1, card.Benefit.Buys);
			}
		}
		[TestMethod]
		public void Test_SnowyVillage_Play()
		{
			using (Card card = new SnowyVillage())
			{
				card.FollowInstructions(mockPlayer.Object);


				// Trigger benefit gain
				var mockCard = new Mock<ICard>();
				var source = new DominionBase.Cards.DarkAges.Necropolis();
				var rbeArgs = new BenefitReceiveEventArgs(mockPlayer.Object, source, source.Benefit);
				mockPlayer.Raise(_ => _.BenefitReceiving += null, rbeArgs);


				Assert.AreEqual(0, rbeArgs.Benefit.Actions);
				Assert.AreEqual(2, source.Benefit.Actions);
			}
		}
		[TestMethod]
		public void Test_SnowyVillage_EndTurn()
		{
			using (Card card = new SnowyVillage())
			{
				card.FollowInstructions(mockPlayer.Object);


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

				// Trigger benefit gain
				var mockCard = new Mock<ICard>();
				var source = new DominionBase.Cards.DarkAges.Necropolis();
				var rbeArgs = new BenefitReceiveEventArgs(mockPlayer.Object, source, source.Benefit);
				mockPlayer.Raise(_ => _.BenefitReceiving += null, rbeArgs);


				Assert.AreEqual(2, source.Benefit.Actions);
			}
		}
		[TestMethod]
		public void Test_SnowyVillage_Teardown()
		{
			using (Card card = new SnowyVillage())
			{
				card.FollowInstructions(mockPlayer.Object);
				card.TearDown(mockGame.Object);

				// Trigger benefit gain
				var mockCard = new Mock<ICard>();
				var source = new DominionBase.Cards.DarkAges.Necropolis();
				var rbeArgs = new BenefitReceiveEventArgs(mockPlayer.Object, source, source.Benefit);
				mockPlayer.Raise(_ => _.BenefitReceiving += null, rbeArgs);


				Assert.AreEqual(2, source.Benefit.Actions);
			}
		}
		[TestMethod]
		public void Test_Stampede_Basic()
		{
			using (var card = new Stampede())
			{
				Assert.AreEqual(Categories.Event, card.Category);
				Assert.AreEqual(new Cost(5), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Stampede_Setup_Correctly()
		{
			// SpecialPiles should maybe be mocked as well??
			var specialPiles = new TableEntityCollection();
			mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

			using (var card = new Stampede())
			{
				card.Finalize(mockGame.Object);


				Assert.IsTrue(specialPiles.ContainsKey(TypeClass.Horse));
			}
		}
		[TestMethod]
		public void Test_Stampede_Bought_Few_Cards_InPlay()
		{
			// SpecialPiles should maybe be mocked as well??
			var specialPiles = new TableEntityCollection();
			mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);
			var inPlay = new Deck(DeckLocation.InPlay);
			inPlay.AddRange(mockPlayer.Object, new List<Card> { new Goatherd(), new Goatherd(), new Supplies() });
			var ipasa = new DeckCollection { inPlay };
			mockPlayer.SetupGet(_ => _.InPlayAndSetAside).Returns(ipasa);

			using (Event card = new Stampede())
			{
				card.Finalize(mockGame.Object);
				mockTable.SetupGet(_ => _[TypeClass.Horse]).Returns(specialPiles[TypeClass.Horse]);


				card.Bought(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(It.Is<ISupply>(s => s.Type == TypeClass.Horse), card, DeckLocation.Deck, DeckPosition.Top, 5, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Stampede_Bought_Many_Cards_InPlay()
		{
			// SpecialPiles should maybe be mocked as well??
			var specialPiles = new TableEntityCollection();
			mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);
			var inPlay = new Deck(DeckLocation.InPlay);
			inPlay.AddRange(mockPlayer.Object, new List<Card> { new Goatherd(), new Goatherd(), new Goatherd(), new Goatherd(), new Goatherd(), new Supplies() });
			var ipasa = new DeckCollection { inPlay };
			mockPlayer.SetupGet(_ => _.InPlayAndSetAside).Returns(ipasa);

			using (Event card = new Stampede())
			{
				card.Finalize(mockGame.Object);
				mockTable.SetupGet(_ => _[TypeClass.Horse]).Returns(specialPiles[TypeClass.Horse]);


				card.Bought(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(It.Is<ISupply>(s => s.Type == TypeClass.Horse), card, DeckLocation.Deck, DeckPosition.Top, It.IsAny<int>(), false), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Stockpile_Basic()
		{
			using (var card = new Stockpile())
			{
				Assert.AreEqual(Categories.Card | Categories.Treasure, card.Category);
				Assert.AreEqual(new Cost(3), card.BaseCost);
				Assert.AreEqual(new Currency(3), card.Benefit.Currency);
				Assert.AreEqual(1, card.Benefit.Buys);
			}
		}
		[TestMethod]
		public void Test_Stockpile_Play()
		{
			var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
			mockPlayer.SetupGet(_ => _.InPlay).Returns(inPlay);

			using (Card card = new Stockpile())
			{
				inPlay.Add(card);
				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.RetrieveCardFrom(DeckLocation.InPlay, card), Times.Once);
				mockPlayer.Verify(_ => _.AddCardInto(TypeClass.Exile, card, It.IsAny<DeckPosition>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Supplies_Basic()
		{
			using (var card = new Supplies())
			{
				Assert.AreEqual(Categories.Card | Categories.Treasure, card.Category);
				Assert.AreEqual(new Cost(2), card.BaseCost);
				Assert.AreEqual(new Currency(1), card.Benefit.Currency);
			}
		}
		[TestMethod]
		public void Test_Supplies_Setup()
		{
			// SpecialPiles should maybe be mocked as well??
			var specialPiles = new TableEntityCollection();
			mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

			using (Card card = new Supplies())
			{
				card.SetupSupply(mockGame.Object, mockSupply.Object);


				Assert.IsTrue(specialPiles.ContainsKey(TypeClass.Horse));
			}
		}
		[TestMethod]
		public void Test_Supplies_Play()
		{
			// SpecialPiles should maybe be mocked as well??
			var specialPiles = new TableEntityCollection();
			mockTable.Setup(_ => _.SpecialPiles).Returns(specialPiles);

			using (Card card = new Supplies())
			{
				card.SetupSupply(mockGame.Object, mockSupply.Object);


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(It.Is<ISupply>(s => s.Type == TypeClass.Horse), card, DeckLocation.Deck, DeckPosition.Top, 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Toil_Basic()
		{
			using (var card = new Toil())
			{
				Assert.AreEqual(Categories.Event, card.Category);
				Assert.AreEqual(new Cost(2), card.BaseCost);
				Assert.AreEqual(1, card.Benefit.Buys);
			}
		}
		[TestMethod]
		public void Test_Toil_Bought_No_Hand()
		{
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);

			using (Event card = new Toil())
			{
				card.Bought(mockPlayer.Object);


				mockPlayer.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Never);
				mockPlayer.Verify(_ => _.PutCardIntoPlay(It.IsAny<Card>(), It.IsAny<string>()), Times.Never);
				mockPlayer.Verify(_ => _.PlayCard(It.IsAny<Card>(), It.IsAny<PlayerMode>()), Times.Never);
				mockPlayer.Verify(_ => _.PlayNothing(It.IsAny<string>()), Times.AtMostOnce);
			}
		}
		[TestMethod]
		public void Test_Toil_Bought_No_Actions()
		{
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner)
			{
				new Supplies()
			};
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);

			using (Event card = new Toil())
			{
				card.Bought(mockPlayer.Object);


				mockPlayer.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Never);
				mockPlayer.Verify(_ => _.PutCardIntoPlay(It.IsAny<Card>(), It.IsAny<string>()), Times.Never);
				mockPlayer.Verify(_ => _.PlayCard(It.IsAny<Card>(), It.IsAny<PlayerMode>()), Times.Never);
				mockPlayer.Verify(_ => _.PlayNothing(It.IsAny<string>()), Times.AtMostOnce);
			}
		}
		[TestMethod]
		public void Test_Toil_Bought_No_Play()
		{
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner)
			{
				new Horse()
			};
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new CardCollection()));

			using (Event card = new Toil())
			{
				card.Bought(mockPlayer.Object);


				mockPlayer.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Once);
				mockPlayer.Verify(_ => _.PutCardIntoPlay(It.IsAny<Card>(), It.IsAny<string>()), Times.Never);
				mockPlayer.Verify(_ => _.PlayCard(It.IsAny<Card>(), It.IsAny<PlayerMode>()), Times.Never);
				mockPlayer.Verify(_ => _.PlayNothing(It.IsAny<string>()), Times.AtMostOnce);
			}
		}
		[TestMethod]
		public void Test_Toil_Bought_Play_Action()
		{
			var toPlay = new Horse();
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner)
			{
				toPlay
			};
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new CardCollection { toPlay }));

			using (Event card = new Toil())
			{
				card.Bought(mockPlayer.Object);


				mockPlayer.Verify(_ => _.PutCardIntoPlay(toPlay, It.IsAny<string>()), Times.Once);
				mockPlayer.Verify(_ => _.PlayCard(toPlay, It.IsAny<PlayerMode>()), Times.Once);
				mockPlayer.Verify(_ => _.PlayNothing(It.IsAny<string>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Transport_Basic()
		{
			using (var card = new Transport())
			{
				Assert.AreEqual(Categories.Event, card.Category);
				Assert.AreEqual(new Cost(3), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Transport_Bought_Exile_From_Supply()
		{
			#region Set up supplies
			var toExile = new Cavalry();
			var cavalrySupply = new Mock<ISupply>();
			cavalrySupply.SetupGet(_ => _.TopCard).Returns(toExile);
			cavalrySupply.Setup(_ => _.CanGain()).Returns(true);
			cavalrySupply.SetupGet(_ => _.CurrentCost).Returns(toExile.BaseCost);
			cavalrySupply.SetupGet(_ => _.TableableType).Returns(toExile.Type);
			cavalrySupply.Setup(_ => _.Take()).Returns(toExile);
			var suppliesTopCard = new Supplies();
			var suppliesSupply = new Mock<ISupply>();
			suppliesSupply.SetupGet(_ => _.TopCard).Returns(suppliesTopCard);
			suppliesSupply.Setup(_ => _.CanGain()).Returns(true);
			suppliesSupply.SetupGet(_ => _.CurrentCost).Returns(suppliesTopCard.BaseCost);
			suppliesSupply.SetupGet(_ => _.TableableType).Returns(suppliesTopCard.Type);
			#endregion
			var supplies = new TableEntityCollection
			{
				{ TypeClass.Cavalry, cavalrySupply.Object },
				{ TypeClass.Supplies, suppliesSupply.Object }
			};
			mockTable.SetupGet(_ => _.TableEntities).Returns(supplies);

			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options)))
				.Returns((Choice c) => new ChoiceResult(ResourcesHelper.Get("ExileActionSupply")));
			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Supplies)))
				.Returns((Choice c) => new ChoiceResult((ISupply)c.Supplies.Values.First()));

			using (Event card = new Transport())
			{
				card.Bought(mockPlayer.Object);


				// Make sure no non-Action supplies are allowed
				mockPlayer.Verify(_ => _.MakeChoice(It.Is<Choice>(c =>
					c.ChoiceType == ChoiceType.Supplies
					&& c.Supplies.Any(s => !((ISupply)s.Value).TopCard.Category.HasFlag(Categories.Action))
				)), Times.Never);
				cavalrySupply.Verify(_ => _.Take(), Times.Once);
				mockPlayer.Verify(_ => _.AddCardInto(TypeClass.Exile, toExile, It.IsAny<DeckPosition>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Transport_Bought_Topdeck_From_Exile_Nothing_In_Exile()
		{
			var mats = new CardMats();
			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options)))
				.Returns((Choice c) => new ChoiceResult(ResourcesHelper.Get("TopdeckExiledAction")));
			mockPlayer.SetupGet(_ => _.PlayerMats).Returns(mats);
			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)))
				.Returns((Choice c) =>
				{
					if (c.Cards.Any())
						return new ChoiceResult(c.Cards.First());
					return new ChoiceResult(new CardCollection());
				});

			using (Event card = new Transport())
			{
				card.Bought(mockPlayer.Object);

				mockPlayer.Verify(_ => _.AddCardToDeck(It.IsAny<Card>(), It.IsAny<DeckPosition>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Transport_Bought_Topdeck_From_Exile_No_Actions_To_Topdeck()
		{
			var mats = new CardMats();
			mats.Add(mockPlayer.Object, TypeClass.Exile, new CardCollection { new Supplies(), new DominionBase.Cards.Universal.Duchy() });
			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options)))
				.Returns((Choice c) => new ChoiceResult(ResourcesHelper.Get("TopdeckExiledAction")));
			mockPlayer.SetupGet(_ => _.PlayerMats).Returns(mats);
			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)))
				.Returns((Choice c) =>
				{
					if (c.Cards.Any())
						return new ChoiceResult(c.Cards.First());
					return new ChoiceResult(new CardCollection());
				});

			using (Event card = new Transport())
			{
				card.Bought(mockPlayer.Object);

				mockPlayer.Verify(_ => _.AddCardToDeck(It.IsAny<Card>(), It.IsAny<DeckPosition>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Transport_Bought_Topdeck_From_Exile_Topdeck_Successful()
		{
			var toTopdeck = new Groom();
			var mats = new CardMats();
			mats.Add(mockPlayer.Object, TypeClass.Exile, new CardCollection { new Supplies(), toTopdeck, new DominionBase.Cards.Universal.Duchy() });
			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options)))
				.Returns((Choice c) => new ChoiceResult(ResourcesHelper.Get("TopdeckExiledAction")));
			mockPlayer.SetupGet(_ => _.PlayerMats).Returns(mats);
			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)))
				.Returns((Choice c) =>
				{
					if (c.Cards.Any())
						return new ChoiceResult(c.Cards.First());
					return new ChoiceResult(new CardCollection());
				});

			using (Event card = new Transport())
			{
				card.Bought(mockPlayer.Object);

				mockPlayer.Verify(_ => _.AddCardToDeck(toTopdeck, It.IsAny<DeckPosition>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_VillageGreen_Basic()
		{
			using (var card = new VillageGreen())
			{
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Duration | Categories.Reaction, card.Category);
				Assert.AreEqual(new Cost(4), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_VillageGreen_Play_Now()
		{
			mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options))).Returns(new ChoiceResult(new List<string> { ResourcesHelper.Get("Now") }));

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


				Assert.IsTrue(card.CanCleanUp);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards == 1 && cb.Actions == 2), It.IsAny<bool>()), 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_VillageGreen_Play_Next_Turn()
		{
			mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);
			mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options))).Returns(new ChoiceResult(new List<string> { ResourcesHelper.Get("NextTurn") }));

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


				Assert.IsFalse(card.CanCleanUp);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Once);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards == 1 && cb.Actions == 2), It.IsAny<bool>()), Times.Never);

				// End of turn
				mockPlayer.Raise(_ => _.TurnEnded += null, new TurnEndedEventArgs(mockPlayer.Object));

				// Start of next turn (make sure we get its benefit)
				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.Cards == 1 && cb.Actions == 2), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_VillageGreen_Owner_Changed()
		{
			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);

			using (Card card = new VillageGreen())
			{
				card.Owner = oldOwner.Object;

				var cdeArgs = new CardsDiscardEventArgs(DeckLocation.Hand, card);
				oldOwner.Raise(_ => _.CardsDiscarding += null, cdeArgs);
				var key = Tuple.Create(TypeClass.VillageGreen, TypeClass.VillageGreen);
				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_VillageGreen_Discard_Play_Now()
		{
			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);
			mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options))).Returns(new ChoiceResult(new List<string> { ResourcesHelper.Get("Now") }));

			using (Card card = new VillageGreen())
			{
				// Mock playing a card
				mockPlayer
					.Setup(_ => _.PlayCard(It.IsAny<Card>(), DeckLocation.InPlay))
					.Callback((Card cardToPlay, DeckLocation dl) =>
					{
						// Sets up the IsAttackBlocked dictionary properly
						card.PlaySetup(mockPlayer.Object);
						card.RemovedFrom(DeckLocation.Hand, mockPlayer.Object);
						card.FollowInstructions(mockPlayer.Object);
					});

				card.Owner = mockPlayer.Object;

				// Do the discard
				var cdeArgs = new CardsDiscardEventArgs(DeckLocation.Hand, card);
				mockPlayer.Raise(_ => _.CardsDiscarding += null, cdeArgs);
				var key = Tuple.Create(TypeClass.VillageGreen, TypeClass.VillageGreen);
				Assert.IsTrue(cdeArgs.Resolvers.ContainsKey(key));
				cdeArgs.Resolvers[key].Method(mockPlayer.Object, ref cdeArgs);

				// Make sure the discard went correctly
				Assert.IsFalse(cdeArgs.Cards.Contains(card));
				mockPlayer.Verify(_ => _.AddCardInto(DeckLocation.Revealed, card, It.IsAny<DeckPosition>()), Times.Once);

				// Check that we've received our benefit
				Assert.IsTrue(card.CanCleanUp);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards == 1 && cb.Actions == 2), It.IsAny<bool>()), Times.Once);

				// Trigger end of turn
				var teeArgs = new TurnEndedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnEnded += null, teeArgs);

				// 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_VillageGreen_Discard_Play_Next_Turn()
		{
			mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);
			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);
			mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options))).Returns(new ChoiceResult(new List<string> { ResourcesHelper.Get("NextTurn") }));

			using (Card card = new VillageGreen())
			{
				// Mock playing a card
				mockPlayer
					.Setup(_ => _.PlayCard(It.IsAny<Card>(), DeckLocation.InPlay))
					.Callback((Card cardToPlay, DeckLocation dl) =>
					{
						// Sets up the IsAttackBlocked dictionary properly
						card.PlaySetup(mockPlayer.Object);
						card.RemovedFrom(DeckLocation.Hand, mockPlayer.Object);
						card.FollowInstructions(mockPlayer.Object);
					});

				card.Owner = mockPlayer.Object;

				// Do the discard
				var cdeArgs = new CardsDiscardEventArgs(DeckLocation.Hand, card);
				mockPlayer.Raise(_ => _.CardsDiscarding += null, cdeArgs);
				var key = Tuple.Create(TypeClass.VillageGreen, TypeClass.VillageGreen);
				Assert.IsTrue(cdeArgs.Resolvers.ContainsKey(key));
				cdeArgs.Resolvers[key].Method(mockPlayer.Object, ref cdeArgs);

				// Make sure the discard went correctly
				Assert.IsFalse(cdeArgs.Cards.Contains(card));
				mockPlayer.Verify(_ => _.AddCardInto(DeckLocation.Revealed, card, It.IsAny<DeckPosition>()), Times.Once);

				// Check that we've received our benefit
				Assert.IsFalse(card.CanCleanUp);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards == 1 && cb.Actions == 2), It.IsAny<bool>()), Times.Never);


				// End of turn
				mockPlayer.Raise(_ => _.TurnEnded += null, new TurnEndedEventArgs(mockPlayer.Object));

				// Start of next turn (make sure we get its benefit)
				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.Cards == 1 && cb.Actions == 2), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_VillageGreen_Teardown()
		{
			var mockOpponent = new Mock<IPlayer>();
			var players = new PlayerCollection(mockGame.Object)
			{
				mockPlayer.Object,
				mockOpponent.Object
			};
			mockGame.SetupGet(_ => _.Players).Returns(players);
			mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);
			mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options))).Returns(new ChoiceResult(new List<string> { ResourcesHelper.Get("NextTurn") }));

			using (Card card = new VillageGreen())
			{
				card.Owner = mockPlayer.Object;
				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_Wayfarer_Basic()
		{
			using (var card = new Wayfarer())
			{
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
				Assert.AreEqual(new Cost(6, special: true), card.BaseCost);
				Assert.AreEqual(3, card.Benefit.Cards);
			}
		}
		[TestMethod]
		public void Test_Wayfarer_Play_Gain_Silver()
		{
			var mockSilver = new Mock<ISupply>();
			mockTable.Setup(_ => _.Silver).Returns(mockSilver.Object);

			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new List<string> { ResourcesHelper.Get("Yes") }));

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


				mockPlayer.Verify(_ => _.Gain(mockSilver.Object, card, 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Wayfarer_Play_No_Gain_Silver()
		{
			var mockSilver = new Mock<ISupply>();
			mockTable.Setup(_ => _.Silver).Returns(mockSilver.Object);

			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new List<string> { ResourcesHelper.Get("No") }));

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


				mockPlayer.Verify(_ => _.Gain(mockSilver.Object, card, It.IsAny<int>(), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Wayfarer_Check_Cost_Nothing_Gained()
		{
			mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);
			var turn = new Turn(mockPlayer.Object);
			mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(turn);

			using (Card card = new Wayfarer())
			{
				card.SetupCard(mockGame.Object);

				var cceArgs = new CostComputeEventArgs(card, card.BaseCost);
				mockGame.Raise(_ => _.CostCompute += null, cceArgs);

				Assert.AreEqual(card.BaseCost, cceArgs.Cost);
			}
		}
		[TestMethod]
		public void Test_Wayfarer_Check_Cost_Copper_Gained()
		{
			mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);
			var turn = new Turn(mockPlayer.Object);
			turn.CardsGained.Add(new DominionBase.Cards.Universal.Copper());
			mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(turn);

			using (Card card = new Wayfarer())
			{
				card.SetupCard(mockGame.Object);

				var cceArgs = new CostComputeEventArgs(card, card.BaseCost);
				mockGame.Raise(_ => _.CostCompute += null, cceArgs);

				Assert.AreNotEqual(card.BaseCost, cceArgs.Cost);
				Assert.AreEqual(0, cceArgs.Cost.Coin.Value);
			}
		}
		[TestMethod]
		public void Test_Wayfarer_Check_Cost_Copper_Gained_No_Contamination()
		{
			mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);
			var turn = new Turn(mockPlayer.Object);
			turn.CardsGained.Add(new DominionBase.Cards.Universal.Copper());
			mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(turn);
			var otherCard = new Cavalry();

			using (Card card = new Wayfarer())
			{
				card.SetupCard(mockGame.Object);

				var cceArgs = new CostComputeEventArgs(otherCard, otherCard.BaseCost);
				mockGame.Raise(_ => _.CostCompute += null, cceArgs);

				Assert.AreEqual(otherCard.BaseCost, cceArgs.Cost);
			}
		}
		[TestMethod]
		public void Test_Wayfarer_Check_Cost_Vineyard_Gained()
		{
			mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);
			var turn = new Turn(mockPlayer.Object);
			turn.CardsGained.Add(new DominionBase.Cards.Alchemy.Vineyard());
			mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(turn);

			using (Card card = new Wayfarer())
			{
				card.SetupCard(mockGame.Object);

				var cceArgs = new CostComputeEventArgs(card, card.BaseCost);
				mockGame.Raise(_ => _.CostCompute += null, cceArgs);

				Assert.AreNotEqual(card.BaseCost, cceArgs.Cost);
				Assert.AreEqual(0, cceArgs.Cost.Coin.Value);
				Assert.AreEqual(1, cceArgs.Cost.Potion.Value);
			}
		}
		[TestMethod]
		public void Test_Wayfarer_Check_Cost_Fortune_Gained()
		{
			mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);
			var turn = new Turn(mockPlayer.Object);
			turn.CardsGained.Add(new DominionBase.Cards.Empires.Fortune());
			mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(turn);

			using (Card card = new Wayfarer())
			{
				card.SetupCard(mockGame.Object);

				var cceArgs = new CostComputeEventArgs(card, card.BaseCost);
				mockGame.Raise(_ => _.CostCompute += null, cceArgs);

				Assert.AreNotEqual(card.BaseCost, cceArgs.Cost);
				Assert.AreEqual(8, cceArgs.Cost.Coin.Value);
				Assert.AreEqual(8, cceArgs.Cost.Debt.Value);
			}
		}
		[TestMethod]
		public void Test_Wayfarer_Teardown()
		{
			mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);
			var turn = new Turn(mockPlayer.Object);
			turn.CardsGained.Add(new DominionBase.Cards.Universal.Copper());
			mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(turn);

			using (Card card = new Wayfarer())
			{
				card.SetupCard(mockGame.Object);

				card.TearDown(mockGame.Object);

				var cceArgs = new CostComputeEventArgs(card, card.BaseCost);
				mockGame.Raise(_ => _.CostCompute += null, cceArgs);

				Assert.AreEqual(card.BaseCost, cceArgs.Cost);
			}
		}
		[TestMethod]
		public void Test_WayOfTheButterfly_Basic()
		{
			using (Way way = new WayOfTheButterfly())
			{
				Assert.AreEqual(Categories.Way, way.Category);
			}
		}
		[TestMethod]
		public void Test_WayOfTheButterfly_Play_Can_Return_Can_Gain()
		{
			mockTable.Setup(_ => _.FindSupplyPileByType(TypeClass.Sleigh, true)).Returns(mockSupply.Object);
			var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
			mockPlayer.SetupGet(_ => _.InPlay).Returns(inPlay);
			var supplyCard = new BlackCat();
			var mockSupply2 = new Mock<ISupply>();
			var supply2Card = new Scrap();
			var mockSupply3 = new Mock<ISupply>();
			var supply3Card = new Groom();
			var supplies = new TableEntityCollection
			{
				{ supplyCard.Type, mockSupply.Object },
				{ supply2Card.Type, mockSupply2.Object },
				{ supply3Card.Type, mockSupply3.Object }
			};
			mockTable.SetupGet(_ => _.TableEntities).Returns(supplies);
			mockSupply.Setup(_ => _.CanGain()).Returns(true);
			mockSupply.SetupGet(_ => _.CurrentCost).Returns(supplyCard.BaseCost);
			mockSupply.SetupGet(_ => _.TableableType).Returns(supplyCard.Type);
			mockSupply.SetupGet(_ => _.TopCard).Returns(supplyCard);
			mockSupply2.Setup(_ => _.CanGain()).Returns(true);
			mockSupply2.SetupGet(_ => _.CurrentCost).Returns(supply2Card.BaseCost);
			mockSupply2.SetupGet(_ => _.TableableType).Returns(supply2Card.Type);
			mockSupply2.SetupGet(_ => _.TopCard).Returns(supply2Card);
			mockSupply3.Setup(_ => _.CanGain()).Returns(true);
			mockSupply3.SetupGet(_ => _.CurrentCost).Returns(supply3Card.BaseCost);
			mockSupply3.SetupGet(_ => _.TableableType).Returns(supply3Card.Type);
			mockSupply3.SetupGet(_ => _.TopCard).Returns(supply3Card);

			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Supplies)))
				.Returns((Choice c) => new ChoiceResult((ISupply)c.Supplies.Values.First()));

			using (Way way = new WayOfTheButterfly())
			using (Card card = new Sleigh())
			{
				inPlay.Add(card);
				way.FollowAlternateInstructions(mockPlayer.Object, card);


				mockPlayer.Verify(_ => _.Lose(card), Times.Once);
				mockSupply.Verify(_ => _.AddTo(card, It.IsAny<int>()), Times.Once);
				mockPlayer.Verify(_ => _.Gain(It.IsAny<ISupply>(), way, It.IsAny<int>(), It.IsAny<bool>()), Times.Once);
				mockPlayer.Verify(_ => _.Gain(mockSupply2.Object, way, 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_WayOfTheButterfly_Play_Can_Return_Nothing_To_Gain()
		{
			mockTable.Setup(_ => _.FindSupplyPileByType(TypeClass.Sleigh, true)).Returns(mockSupply.Object);
			var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
			mockPlayer.SetupGet(_ => _.InPlay).Returns(inPlay);
			var supplyCard = new BlackCat();
			var mockSupply3 = new Mock<ISupply>();
			var supply3Card = new Groom();
			var supplies = new TableEntityCollection
			{
				{ supplyCard.Type, mockSupply.Object },
				{ supply3Card.Type, mockSupply3.Object }
			};
			mockTable.SetupGet(_ => _.TableEntities).Returns(supplies);
			mockSupply.Setup(_ => _.CanGain()).Returns(true);
			mockSupply.SetupGet(_ => _.CurrentCost).Returns(supplyCard.BaseCost);
			mockSupply.SetupGet(_ => _.TableableType).Returns(supplyCard.Type);
			mockSupply.SetupGet(_ => _.TopCard).Returns(supplyCard);
			mockSupply3.Setup(_ => _.CanGain()).Returns(true);
			mockSupply3.SetupGet(_ => _.CurrentCost).Returns(supply3Card.BaseCost);
			mockSupply3.SetupGet(_ => _.TableableType).Returns(supply3Card.Type);
			mockSupply3.SetupGet(_ => _.TopCard).Returns(supply3Card);

			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Supplies)))
				.Returns((Choice c) => new ChoiceResult());

			using (Way way = new WayOfTheButterfly())
			using (Card card = new Sleigh())
			{
				inPlay.Add(card);
				way.FollowAlternateInstructions(mockPlayer.Object, card);


				mockPlayer.Verify(_ => _.Lose(card), Times.Once);
				mockSupply.Verify(_ => _.AddTo(card, It.IsAny<int>()), Times.Once);
				mockPlayer.Verify(_ => _.Gain(It.IsAny<ISupply>(), way, It.IsAny<int>(), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_WayOfTheButterfly_Play_Cant_Return()
		{
			mockTable.Setup(_ => _[It.Is<Card>(c => c.Type == DominionBase.Cards.DarkAges.TypeClass.Necropolis)]).Returns<ISupply>(null);
			var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
			mockPlayer.SetupGet(_ => _.InPlay).Returns(inPlay);

			using (Way way = new WayOfTheButterfly())
			using (Card card = new DominionBase.Cards.DarkAges.Necropolis())
			{
				inPlay.Add(card);
				way.FollowAlternateInstructions(mockPlayer.Object, card);


				mockPlayer.Verify(_ => _.Lose(It.IsAny<Card>()), Times.Never);
				mockSupply.Verify(_ => _.AddTo(It.IsAny<Card>(), It.IsAny<int>()), Times.Never);
				mockPlayer.Verify(_ => _.Gain(It.IsAny<ISupply>(), way, It.IsAny<int>(), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_WayOfTheCamel_Basic()
		{
			using (Way way = new WayOfTheCamel())
			{
				Assert.AreEqual(Categories.Way, way.Category);
			}
		}
		[TestMethod]
		public void Test_WayOfTheCamel_Play_Can_Exile()
		{
			var players = new PlayerCollection(mockGame.Object)
			{
				mockPlayer.Object,
				mockPlayer.Object
			};
			mockGame.SetupGet(_ => _.Players).Returns(players);
			var mockGold = new Mock<ISupply>();
			mockTable.SetupGet(_ => _.Gold).Returns(mockGold.Object);
			var exiledGold = new DominionBase.Cards.Universal.Gold();
			mockGold.SetupGet(_ => _.Count).Returns(5);
			//mockGold.Setup(_ => _.Any()).Returns(true);  // Can't mock extension methods.  WTF to do now?
			mockGold.Setup(_ => _.Take()).Returns(exiledGold);

			using (Way way = new WayOfTheCamel())
			using (Card card = new Sleigh())
			{
				way.FollowAlternateInstructions(mockPlayer.Object, card);


				mockGold.Verify(_ => _.Take(), Times.Once);
				mockPlayer.Verify(_ => _.AddCardInto(TypeClass.Exile, exiledGold, It.IsAny<DeckPosition>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_WayOfTheCamel_Play_No_Golds()
		{
			var players = new PlayerCollection(mockGame.Object)
			{
				mockPlayer.Object,
				mockPlayer.Object
			};
			mockGame.SetupGet(_ => _.Players).Returns(players);
			var mockGold = new Mock<ISupply>();
			mockTable.SetupGet(_ => _.Gold).Returns(mockGold.Object);
			var exiledGold = new DominionBase.Cards.Universal.Gold();
			mockGold.SetupGet(_ => _.Count).Returns(0);
			mockGold.Setup(_ => _.Take()).Returns(exiledGold);

			using (Way way = new WayOfTheCamel())
			using (Card card = new Sleigh())
			{
				way.FollowAlternateInstructions(mockPlayer.Object, card);


				mockGold.Verify(_ => _.Take(), Times.Never);
				mockPlayer.Verify(_ => _.AddCardInto(TypeClass.Exile, exiledGold, It.IsAny<DeckPosition>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_WayOfTheChameleon_Basic()
		{
			using (Way way = new WayOfTheChameleon())
			{
				Assert.AreEqual(Categories.Way, way.Category);
			}
		}
		[TestMethod]
		public void Test_WayOfTheChameleon_Play_Cards_To_Coins()
		{
			var Benefit = new CardBenefit();
			mockPlayer
				.Setup(_ => _.ReceiveBenefit(It.IsAny<ICardBase>(), It.IsAny<CardBenefit>(), It.IsAny<bool>()))
				.Callback((ICardBase source, CardBenefit benefit, bool isInternal) =>
				{
					if (benefit.Any)
					{
						var brea = new BenefitReceiveEventArgs(mockPlayer.Object, source, benefit);
						mockPlayer.Raise(_ => _.BenefitReceiving += null, brea);
						benefit = brea.Benefit;
					}

					Benefit = benefit;
				});

			using (Way way = new WayOfTheChameleon())
			using (Card card = new Sheepdog())
			using (var currency = new Currency(2))
			{
				way.FollowAlternateInstructions(mockPlayer.Object, card);


				Assert.AreEqual(0, Benefit.Cards);
				Assert.AreEqual(currency, Benefit.Currency);
			}
		}
		[TestMethod]
		public void Test_WayOfTheChameleon_Play_Coins_To_Cards()
		{
			var Benefit = new CardBenefit();
			mockPlayer
				.Setup(_ => _.ReceiveBenefit(It.IsAny<ICardBase>(), It.IsAny<CardBenefit>(), It.IsAny<bool>()))
				.Callback((ICardBase source, CardBenefit benefit, bool isInternal) =>
				{
					if (benefit.Any)
					{
						var brea = new BenefitReceiveEventArgs(mockPlayer.Object, source, benefit);
						mockPlayer.Raise(_ => _.BenefitReceiving += null, brea);
						benefit = brea.Benefit;
					}

					Benefit = benefit;
				});

			using (Way way = new WayOfTheChameleon())
			using (Card card = new Livery())
			using (var currency = new Currency(0))
			{
				way.FollowAlternateInstructions(mockPlayer.Object, card);


				Assert.AreEqual(currency, Benefit.Currency);
				Assert.AreEqual(3, Benefit.Cards);
			}
		}
		[TestMethod]
		public void Test_WayOfTheChameleon_Play_Swap_Both()
		{
			var Benefit = new CardBenefit();
			mockPlayer
				.Setup(_ => _.ReceiveBenefit(It.IsAny<ICardBase>(), It.IsAny<CardBenefit>(), It.IsAny<bool>()))
				.Callback((ICardBase source, CardBenefit benefit, bool isInternal) =>
				{
					if (benefit.Any)
					{
						var brea = new BenefitReceiveEventArgs(mockPlayer.Object, source, benefit);
						mockPlayer.Raise(_ => _.BenefitReceiving += null, brea);
						benefit = brea.Benefit;
					}

					Benefit = benefit;
				});

			using (Way way = new WayOfTheChameleon())
			using (Card card = new DominionBase.Cards.Prosperity.GrandMarket())
			using (var currency = new Currency(1))
			{
				way.FollowAlternateInstructions(mockPlayer.Object, card);


				Assert.AreEqual(currency, Benefit.Currency);
				Assert.AreEqual(2, Benefit.Cards);
			}
		}
		[TestMethod]
		public void Test_WayOfTheFrog_Basic()
		{
			using (Way way = new WayOfTheFrog())
			{
				Assert.AreEqual(Categories.Way, way.Category);
				Assert.AreEqual(1, way.Benefit.Actions);
			}
		}
		[TestMethod]
		public void Test_WayOfTheFrog_Play_Simple()
		{
			var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
			mockPlayer.SetupGet(_ => _.InPlay).Returns(inPlay);

			using (Way way = new WayOfTheFrog())
			using (Card card = new Sleigh())
			{
				mockPlayer.Setup(_ => _.RetrieveCardFrom(DeckLocation.InPlay, card)).Returns(card);


				inPlay.Add(card);
				way.FollowAlternateInstructions(mockPlayer.Object, card);


				var cdea = new CardsDiscardEventArgs(DeckLocation.InPlay, new ItemCollection<Card> { card });
				mockPlayer.Raise(_ => _.CardsDiscarding += null, cdea);
				var key = Tuple.Create(TypeClass.WayOfTheFrog, TypeClass.Sleigh);
				Assert.IsTrue(cdea.Resolvers.ContainsKey(key));

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

				mockPlayer.Verify(_ => _.AddCardToDeck(card, DeckPosition.Top), Times.Once);
			}
		}
		[TestMethod]
		public void Test_WayOfTheFrog_Play_Stays_In_Play()
		{
			var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
			mockPlayer.SetupGet(_ => _.InPlay).Returns(inPlay);

			using (Way way = new WayOfTheFrog())
			using (Card card = new Sleigh())
			{
				mockPlayer.Setup(_ => _.RetrieveCardFrom(DeckLocation.InPlay, card)).Returns(card);


				inPlay.Add(card);
				way.FollowAlternateInstructions(mockPlayer.Object, card);


				var cdea = new CardsDiscardEventArgs(DeckLocation.InPlay, new ItemCollection<Card>());
				mockPlayer.Raise(_ => _.CardsDiscarding += null, cdea);
				var key = Tuple.Create(TypeClass.WayOfTheFrog, TypeClass.Sleigh);
				Assert.IsFalse(cdea.Resolvers.ContainsKey(key));

				mockPlayer.Verify(_ => _.AddCardToDeck(card, DeckPosition.Top), Times.Never);
			}
		}
		[TestMethod]
		public void Test_WayOfTheGoat_Basic()
		{
			using (Way way = new WayOfTheGoat())
			{
				Assert.AreEqual(Categories.Way, way.Category);
			}
		}
		[TestMethod]
		public void Test_WayOfTheGoat_Play_Trash_Card()
		{
			var toTrash = new DominionBase.Cards.DarkAges.PoorHouse();
			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)))
				.Returns(new ChoiceResult(new CardCollection { toTrash }));
			mockPlayer
				.Setup(_ => _.RetrieveCardsFrom(DeckLocation.Hand, It.IsAny<ItemCollection<Card>>()))
				.Returns(new CardCollection { toTrash });

			using (Way way = new WayOfTheGoat())
			using (Card card = new Sleigh())
			{
				way.FollowAlternateInstructions(mockPlayer.Object, card);


				mockPlayer.Verify(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)), Times.Once);
				mockPlayer.Verify(_ => _.Trash(way, It.IsAny<ItemCollection<Card>>()), Times.Once);
				mockPlayer.Verify(_ => _.Trash(way, It.Is<ItemCollection<Card>>(ic => ic.Count == 1 && ic[0] == toTrash)), Times.Once);
			}
		}
		[TestMethod]
		public void Test_WayOfTheGoat_Play_Nothing_To_Trash()
		{
			mockPlayer
				.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)))
				.Returns(new ChoiceResult(new CardCollection()));

			using (Way way = new WayOfTheGoat())
			using (Card card = new Sleigh())
			{
				way.FollowAlternateInstructions(mockPlayer.Object, card);


				mockPlayer.Verify(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)), Times.Once);
				mockPlayer.Verify(_ => _.Trash(way, It.IsAny<ItemCollection<Card>>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_WayOfTheHorse_Basic()
		{
			using (Way way = new WayOfTheHorse())
			{
				Assert.AreEqual(Categories.Way, way.Category);
				Assert.AreEqual(2, way.Benefit.Cards);
				Assert.AreEqual(1, way.Benefit.Actions);
			}
		}
		[TestMethod]
		public void Test_WayOfTheHorse_Play_Can_Return()
		{
			mockTable.Setup(_ => _.FindSupplyPileByType(TypeClass.Sleigh, true)).Returns(mockSupply.Object);
			var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
			mockPlayer.SetupGet(_ => _.InPlay).Returns(inPlay);

			using (Way way = new WayOfTheHorse())
			using (Card card = new Sleigh())
			{
				inPlay.Add(card);
				way.FollowAlternateInstructions(mockPlayer.Object, card);


				mockPlayer.Verify(_ => _.ReceiveBenefit(way, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Once);
				mockPlayer.Verify(_ => _.ReceiveBenefit(way, It.Is<CardBenefit>(cb => cb.Cards == 2 && cb.Actions == 1), It.IsAny<bool>()), Times.Once);
				mockPlayer.Verify(_ => _.Lose(card), Times.Once);
				mockSupply.Verify(_ => _.AddTo(card, It.IsAny<int>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_WayOfTheHorse_Play_Cant_Return()
		{
			mockTable.Setup(_ => _[It.Is<Card>(c => c.Type == DominionBase.Cards.DarkAges.TypeClass.Necropolis)]).Returns<ISupply>(null);
			var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
			mockPlayer.SetupGet(_ => _.InPlay).Returns(inPlay);

			using (Way way = new WayOfTheHorse())
			using (Card card = new DominionBase.Cards.DarkAges.Necropolis())
			{
				inPlay.Add(card);
				way.FollowAlternateInstructions(mockPlayer.Object, card);


				mockPlayer.Verify(_ => _.ReceiveBenefit(way, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Once);
				mockPlayer.Verify(_ => _.ReceiveBenefit(way, It.Is<CardBenefit>(cb => cb.Cards == 2 && cb.Actions == 1), It.IsAny<bool>()), Times.Once);
				mockPlayer.Verify(_ => _.Lose(It.IsAny<Card>()), Times.Never);
				mockSupply.Verify(_ => _.AddTo(It.IsAny<Card>(), It.IsAny<int>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_WayOfTheMole_Basic()
		{
			using (Way way = new WayOfTheMole())
			{
				Assert.AreEqual(Categories.Way, way.Category);
				Assert.AreEqual(1, way.Benefit.Actions);
			}
		}
		[TestMethod]
		public void Test_WayOfTheMole_Play()
		{
			using (Way way = new WayOfTheMole())
			using (Card card = new Sleigh())
			{
				way.FollowAlternateInstructions(mockPlayer.Object, card);


				mockPlayer.Verify(_ => _.DiscardHand(true), Times.Once);
				mockPlayer.Verify(_ => _.ReceiveBenefit(way, It.Is<CardBenefit>(cb => cb.Actions == 1), It.IsAny<bool>()), Times.Once);
				mockPlayer.Verify(_ => _.ReceiveBenefit(way, It.Is<CardBenefit>(cb => cb.Cards == 3), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_WayOfTheMonkey_Basic()
		{
			using (Way way = new WayOfTheMonkey())
			{
				Assert.AreEqual(Categories.Way, way.Category);
				Assert.AreEqual(1, way.Benefit.Buys);
				Assert.AreEqual(new Currency(1), way.Benefit.Currency);
			}
		}
		[TestMethod]
		public void Test_WayOfTheMonkey_Play()
		{
			using (Way way = new WayOfTheMonkey())
			using (Card card = new Sleigh())
			using (var currency = new Currency(1))
			{
				way.FollowAlternateInstructions(mockPlayer.Object, card);


				mockPlayer.Verify(_ => _.ReceiveBenefit(way, It.Is<CardBenefit>(cb => cb.Buys == 1 && cb.Currency == currency), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_WayOfTheMule_Basic()
		{
			using (Way way = new WayOfTheMule())
			{
				Assert.AreEqual(Categories.Way, way.Category);
				Assert.AreEqual(1, way.Benefit.Actions);
				Assert.AreEqual(new Currency(1), way.Benefit.Currency);
			}
		}
		[TestMethod]
		public void Test_WayOfTheMule_Play()
		{
			using (Way way = new WayOfTheMule())
			using (Card card = new Sleigh())
			using (var currency = new Currency(1))
			{
				way.FollowAlternateInstructions(mockPlayer.Object, card);


				mockPlayer.Verify(_ => _.ReceiveBenefit(way, It.Is<CardBenefit>(cb => cb.Actions == 1 && cb.Currency == currency), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_WayOfTheOtter_Basic()
		{
			using (Way way = new WayOfTheOtter())
			{
				Assert.AreEqual(Categories.Way, way.Category);
				Assert.AreEqual(2, way.Benefit.Cards);
			}
		}
		[TestMethod]
		public void Test_WayOfTheOtter_Play()
		{
			using (Way way = new WayOfTheOtter())
			using (Card card = new Sleigh())
			{
				way.FollowAlternateInstructions(mockPlayer.Object, card);


				mockPlayer.Verify(_ => _.ReceiveBenefit(way, It.Is<CardBenefit>(cb => cb.Cards == 2), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_WayOfTheOwl_Basic()
		{
			using (Way way = new WayOfTheOwl())
			{
				Assert.AreEqual(Categories.Way, way.Category);
			}
		}
		[TestMethod]
		public void Test_WayOfTheOwl_Play_No_Cards_In_Hand()
		{
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
			mockPlayer.SetupGet(_ => _.CanDraw).Returns(true);
			mockPlayer
				.Setup(_ => _.DrawHand(It.IsAny<int>()))
				.Callback((int toDraw) =>
				{
					hand.Add(new Horse());
				});

			using (Way way = new WayOfTheOwl())
			using (Card card = new Sleigh())
			{
				way.FollowAlternateInstructions(mockPlayer.Object, card);


				Assert.AreEqual(6, hand.Count);
				mockPlayer.Verify(_ => _.DrawHand(1), Times.Exactly(6));
			}
		}
		[TestMethod]
		public void Test_WayOfTheOwl_Play_2_Cards_In_Hand()
		{
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
			hand.AddRange(mockPlayer.Object, new CardCollection { new Horse(), new Horse() });
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
			mockPlayer.SetupGet(_ => _.CanDraw).Returns(true);
			mockPlayer
				.Setup(_ => _.DrawHand(It.IsAny<int>()))
				.Callback((int toDraw) =>
				{
					hand.Add(new Horse());
				});

			using (Way way = new WayOfTheOwl())
			using (Card card = new Sleigh())
			{
				way.FollowAlternateInstructions(mockPlayer.Object, card);


				Assert.AreEqual(6, hand.Count);
				mockPlayer.Verify(_ => _.DrawHand(1), Times.Exactly(4));
			}
		}
		[TestMethod]
		public void Test_WayOfTheOwl_Play_7_Cards_In_Hand()
		{
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
			hand.AddRange(mockPlayer.Object, new CardCollection { new Horse(), new Horse(), new Horse(), new Horse(), new Horse(), new Horse(), new Horse() });
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
			mockPlayer.SetupGet(_ => _.CanDraw).Returns(true);
			mockPlayer
				.Setup(_ => _.DrawHand(It.IsAny<int>()))
				.Callback((int toDraw) => hand.Add(new Horse()));

			using (Way way = new WayOfTheOwl())
			using (Card card = new Sleigh())
			{
				way.FollowAlternateInstructions(mockPlayer.Object, card);


				Assert.AreEqual(7, hand.Count);
				mockPlayer.Verify(_ => _.DrawHand(1), Times.Never);
			}
		}
		[TestMethod]
		public void Test_WayOfTheOwl_Play_Nothing_To_Draw()
		{
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
			hand.AddRange(mockPlayer.Object, new CardCollection { new Horse(), new Horse() });
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
			mockPlayer.SetupGet(_ => _.CanDraw).Returns(false);
			mockPlayer
				.Setup(_ => _.DrawHand(It.IsAny<int>()))
				.Callback((int toDraw) => hand.Add(new Horse()));

			using (Way way = new WayOfTheOwl())
			using (Card card = new Sleigh())
			{
				way.FollowAlternateInstructions(mockPlayer.Object, card);


				Assert.AreEqual(2, hand.Count);
				mockPlayer.Verify(_ => _.DrawHand(1), Times.Never);
			}
		}
		[TestMethod]
		public void Test_WayOfTheOx_Basic()
		{
			using (Way way = new WayOfTheOx())
			{
				Assert.AreEqual(Categories.Way, way.Category);
				Assert.AreEqual(2, way.Benefit.Actions);
			}
		}
		[TestMethod]
		public void Test_WayOfTheOx_Play()
		{
			using (Way way = new WayOfTheOx())
			using (Card card = new Sleigh())
			{
				way.FollowAlternateInstructions(mockPlayer.Object, card);


				mockPlayer.Verify(_ => _.ReceiveBenefit(way, It.Is<CardBenefit>(cb => cb.Actions == 2), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_WayOfThePig_Basic()
		{
			using (Way way = new WayOfThePig())
			{
				Assert.AreEqual(Categories.Way, way.Category);
				Assert.AreEqual(1, way.Benefit.Cards);
				Assert.AreEqual(1, way.Benefit.Actions);
			}
		}
		[TestMethod]
		public void Test_WayOfThePig_Play()
		{
			using (Way way = new WayOfThePig())
			using (Card card = new Sleigh())
			{
				way.FollowAlternateInstructions(mockPlayer.Object, card);


				mockPlayer.Verify(_ => _.ReceiveBenefit(way, It.Is<CardBenefit>(cb => cb.Cards == 1 && cb.Actions == 1), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_WayOfTheRat_Basic()
		{
			using (Way way = new WayOfTheRat())
			{
				Assert.AreEqual(Categories.Way, way.Category);
			}
		}
		[TestMethod]
		public void Test_WayOfTheRat_Play_No_Discard()
		{
			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>()));

			using (Way way = new WayOfTheRat())
			using (Card card = new Sleigh())
			{
				way.FollowAlternateInstructions(mockPlayer.Object, card);


				mockPlayer.Verify(_ => _.Discard(DeckLocation.Hand, It.IsAny<ItemCollection<Card>>(), null), Times.Never);
				mockPlayer.Verify(_ => _.Gain(It.IsAny<ISupply>(), It.IsAny<IGameObject>(), It.IsAny<int>(), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_WayOfTheRat_Play_Discard_Treasure_Gain()
		{
			mockTable.Setup(_ => _.FindSupplyPileByType(TypeClass.Sleigh, It.IsAny<bool>())).Returns(mockSupply.Object);
			mockSupply.Setup(_ => _.CanGain(TypeClass.Sleigh)).Returns(true);
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
			var cardToDiscard = new Supplies();
			mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards))).Returns(new ChoiceResult(new ItemCollection<Card>(cardToDiscard)));

			using (Way way = new WayOfTheRat())
			using (Card card = new Sleigh())
			{
				way.FollowAlternateInstructions(mockPlayer.Object, card);


				mockPlayer.Verify(_ => _.Discard(DeckLocation.Hand, new ItemCollection<Card>(cardToDiscard), null), Times.Once);
				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, way, 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_WayOfTheRat_Play_Discard_Treasure_Multipile_Cant_Gain()
		{
			mockTable.Setup(_ => _.FindSupplyPileByType(DominionBase.Cards.Empires.TypeClass.SmallCastle, It.IsAny<bool>())).Returns<ISupply>(null);
			mockSupply.Setup(_ => _.CanGain(DominionBase.Cards.Empires.TypeClass.SmallCastle)).Returns(false);
			var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
			mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
			var cardToDiscard = new Supplies();
			mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards))).Returns(new ChoiceResult(new ItemCollection<Card>(cardToDiscard)));

			using (Way way = new WayOfTheRat())
			using (Card card = new DominionBase.Cards.Empires.SmallCastle())
			{
				way.FollowAlternateInstructions(mockPlayer.Object, card);


				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_WayOfTheSeal_Basic()
		{
			using (Way way = new WayOfTheSeal())
			{
				Assert.AreEqual(Categories.Way, way.Category);
			}
		}
		[TestMethod]
		public void Test_WayOfTheSeal_Play_Gain_Card_Topdeck()
		{
			using (Way way = new WayOfTheSeal())
			using (Card card = new Sleigh())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame
					.Setup(_ => _.GetPlayersStartingWithActiveEnumerator())
					.Returns(players.GetPlayersStartingWithEnumerator(mockPlayer.Object));
				mockGame.SetupGet(_ => _.Players).Returns(players);
				way.Finalize(mockGame.Object);


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


				var gainedCard = new BlackCat();
				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.WayOfTheSeal.ToString()));

				cgeArgs.Resolvers[TypeClass.WayOfTheSeal.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)
				mockPlayer.Raise(_ => _.TurnEnded += null, new TurnEndedEventArgs(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.WayOfTheSeal.ToString()));
			}
		}
		[TestMethod]
		public void Test_WayOfTheSeal_Play_Gain_Card_No_Topdeck()
		{
			using (Way way = new WayOfTheSeal())
			using (Card card = new Sleigh())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame
					.Setup(_ => _.GetPlayersStartingWithActiveEnumerator())
					.Returns(players.GetPlayersStartingWithEnumerator(mockPlayer.Object));
				mockGame.SetupGet(_ => _.Players).Returns(players);
				way.Finalize(mockGame.Object);


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


				var gainedCard = new BlackCat();
				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.WayOfTheSeal.ToString()));
				Assert.IsFalse(cgeArgs.Cancelled);
				Assert.AreNotEqual(DeckLocation.Deck, cgeArgs.Location);
				Assert.AreNotEqual(DeckPosition.Top, cgeArgs.Position);
				Assert.IsFalse(cgeArgs.HandledBy.Contains(TypeClass.WayOfTheSeal));
			}
		}
		[TestMethod]
		public void Test_WayOfTheSeal_Teardown()
		{
			using (Way way = new WayOfTheSeal())
			using (Card card = new Sleigh())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame
					.Setup(_ => _.GetPlayersStartingWithActiveEnumerator())
					.Returns(players.GetPlayersStartingWithEnumerator(mockPlayer.Object));
				mockGame.SetupGet(_ => _.Players).Returns(players);
				way.Finalize(mockGame.Object);

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


				var gainedCard = new BlackCat();
				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.WayOfTheSeal.ToString()));

				way.TearDown(mockGame.Object);


				// Verify the Teardown works correctly
				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.WayOfTheSeal.ToString()));
			}
		}
		[TestMethod]
		public void Test_WayOfTheSheep_Basic()
		{
			using (Way way = new WayOfTheSheep())
			{
				Assert.AreEqual(Categories.Way, way.Category);
				Assert.AreEqual(new Currency(2), way.Benefit.Currency);
			}
		}
		[TestMethod]
		public void Test_WayOfTheSheep_Play()
		{
			using (Way way = new WayOfTheSheep())
			using (Card card = new Sleigh())
			using (var currency = new Currency(2))
			{
				way.FollowAlternateInstructions(mockPlayer.Object, card);


				mockPlayer.Verify(_ => _.ReceiveBenefit(way, It.Is<CardBenefit>(cb => cb.Currency == currency), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_WayOfTheSquirrel_Basic()
		{
			using (Way way = new WayOfTheSquirrel())
			{
				Assert.AreEqual(Categories.Way, way.Category);
			}
		}
		[TestMethod]
		public void Test_WayOfTheSquirrel_Play()
		{
			mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);
			var turn = new Turn(mockPlayer.Object);
			mockGame.SetupGet(_ => _.CurrentTurn).Returns(turn);

			using (Way way = new WayOfTheSquirrel())
			using (Card card = new Sleigh())
			{
				way.FollowAlternateInstructions(mockPlayer.Object, card);


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


				mockPlayer.Verify(_ => _.ReceiveBenefit(way, It.Is<CardBenefit>(cb => cb.Cards == 2), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_WayOfTheTurtle_Basic()
		{
			using (Way way = new WayOfTheTurtle())
			{
				Assert.AreEqual(Categories.Way, way.Category);
			}
		}
		[TestMethod]
		public void Test_WayOfTheTurtle_Play_Simple()
		{
			mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);
			var discard = new Deck(DeckLocation.Discard, Visibility.Top, VisibilityTo.All);
			mockPlayer.SetupGet(_ => _.DiscardPile).Returns(discard);
			var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
			mockPlayer.SetupGet(_ => _.InPlay).Returns(inPlay);
			var @private = new Deck(DeckLocation.Private, Visibility.All, VisibilityTo.Owner);
			mockPlayer.SetupGet(_ => _.Private).Returns(@private);
			var cardMats = new CardMats();
			mockPlayer.SetupGet(_ => _.PlayerMats).Returns(cardMats);

			using (Way way = new WayOfTheTurtle())
			using (Card card = new Sleigh())
			{
				inPlay.Add(card);
				mockPlayer.Setup(_ => _.RetrieveCardFrom(DeckLocation.InPlay, card)).Returns(card);


				way.FollowAlternateInstructions(mockPlayer.Object, card);


				mockPlayer.Raise(_ => _.TurnEnded += null, new TurnEndedEventArgs(mockPlayer.Object));
				var tsea = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tsea);
				var key = $"{way.Name}_{card.Name}";
				Assert.IsTrue(tsea.Resolvers.ContainsKey(key));

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

				mockPlayer.Verify(_ => _.PutCardIntoPlay(card, It.IsAny<string>()), Times.Once);
				mockPlayer.Verify(_ => _.PlayCard(card, It.IsAny<PlayerMode>()), Times.Once);

				tsea = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tsea);
				Assert.IsFalse(tsea.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_WayOfTheTurtle_Play_Twice_Resolve_Once()
		{
			mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);
			var discard = new Deck(DeckLocation.Discard, Visibility.Top, VisibilityTo.All);
			mockPlayer.SetupGet(_ => _.DiscardPile).Returns(discard);
			var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
			mockPlayer.SetupGet(_ => _.InPlay).Returns(inPlay);
			var @private = new Deck(DeckLocation.Private, Visibility.All, VisibilityTo.Owner);
			mockPlayer.SetupGet(_ => _.Private).Returns(@private);
			var cardMats = new CardMats();
			mockPlayer.SetupGet(_ => _.PlayerMats).Returns(cardMats);

			using (Way way = new WayOfTheTurtle())
			using (Card card = new Sleigh())
			{
				inPlay.Add(card);
				mockPlayer
					.Setup(_ => _.RetrieveCardFrom(DeckLocation.InPlay, card))
					.Returns((DeckLocation dl, Card c) =>
					{
						if (inPlay.Contains(c))
						{
							inPlay.Remove(c);
							return c;
						}
						return null;
					});


				way.FollowAlternateInstructions(mockPlayer.Object, card);
				way.FollowAlternateInstructions(mockPlayer.Object, card);


				mockPlayer.Raise(_ => _.TurnEnded += null, new TurnEndedEventArgs(mockPlayer.Object));
				var tsea = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tsea);
				var key = $"{way.Name}_{card.Name}";
				Assert.IsTrue(tsea.Resolvers.ContainsKey(key));

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

				mockPlayer.Verify(_ => _.PutCardIntoPlay(card, It.IsAny<string>()), Times.Once);
				mockPlayer.Verify(_ => _.PlayCard(card, It.IsAny<PlayerMode>()), Times.Once);

				tsea = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tsea);
				Assert.IsFalse(tsea.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_WayOfTheTurtle_End_Before_End_Turn()
		{
			mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);
			var discard = new Deck(DeckLocation.Discard, Visibility.Top, VisibilityTo.All);
			mockPlayer.SetupGet(_ => _.DiscardPile).Returns(discard);
			var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
			mockPlayer.SetupGet(_ => _.InPlay).Returns(inPlay);
			var @private = new Deck(DeckLocation.Private, Visibility.All, VisibilityTo.Owner);
			mockPlayer.SetupGet(_ => _.Private).Returns(@private);
			var cardMats = new CardMats();
			mockPlayer.SetupGet(_ => _.PlayerMats).Returns(cardMats);

			using (Way way = new WayOfTheTurtle())
			using (Card card = new Sleigh())
			{
				inPlay.Add(card);
				mockPlayer.Setup(_ => _.RetrieveCardFrom(DeckLocation.InPlay, card)).Returns(card);


				way.FollowAlternateInstructions(mockPlayer.Object, card);


				var displayables = new DisplayableCollection();
				way.End(mockPlayer.Object, displayables);
				Assert.IsTrue(displayables.Contains(card));

			}
		}
		[TestMethod]
		public void Test_WayOfTheTurtle_End_After_End_Turn()
		{
			mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);
			var discard = new Deck(DeckLocation.Discard, Visibility.Top, VisibilityTo.All);
			mockPlayer.SetupGet(_ => _.DiscardPile).Returns(discard);
			var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
			mockPlayer.SetupGet(_ => _.InPlay).Returns(inPlay);
			var @private = new Deck(DeckLocation.Private, Visibility.All, VisibilityTo.Owner);
			mockPlayer.SetupGet(_ => _.Private).Returns(@private);
			var cardMats = new CardMats();
			mockPlayer.SetupGet(_ => _.PlayerMats).Returns(cardMats);

			using (Way way = new WayOfTheTurtle())
			using (Card card = new Sleigh())
			{
				inPlay.Add(card);
				mockPlayer.Setup(_ => _.RetrieveCardFrom(DeckLocation.InPlay, card)).Returns(card);


				way.FollowAlternateInstructions(mockPlayer.Object, card);


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

				var displayables = new DisplayableCollection();
				way.End(mockPlayer.Object, displayables);
				Assert.IsTrue(displayables.Contains(card));
			}
		}
		[TestMethod]
		public void Test_WayOfTheTurtle_Teardown()
		{
			var players = new PlayerCollection(mockGame.Object)
			{
				mockPlayer.Object,
				new Mock<IPlayer>().Object
			};
			mockGame.SetupGet(_ => _.Players).Returns(players);
			mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);
			var discard = new Deck(DeckLocation.Discard, Visibility.Top, VisibilityTo.All);
			mockPlayer.SetupGet(_ => _.DiscardPile).Returns(discard);
			var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
			mockPlayer.SetupGet(_ => _.InPlay).Returns(inPlay);
			var @private = new Deck(DeckLocation.Private, Visibility.All, VisibilityTo.Owner);
			mockPlayer.SetupGet(_ => _.Private).Returns(@private);
			var cardMats = new CardMats();
			mockPlayer.SetupGet(_ => _.PlayerMats).Returns(cardMats);

			using (Way way = new WayOfTheTurtle())
			using (Card card = new Sleigh())
			{
				inPlay.Add(card);
				mockPlayer.Setup(_ => _.RetrieveCardFrom(DeckLocation.InPlay, card)).Returns(card);


				way.FollowAlternateInstructions(mockPlayer.Object, card);


				way.TearDown(mockGame.Object);
				mockPlayer.Raise(_ => _.TurnEnded += null, new TurnEndedEventArgs(mockPlayer.Object));
				var tsea = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tsea);
				var key = $"{way.Name}_{card.Name}";
				Assert.IsFalse(tsea.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_WayOfTheWorm_Basic()
		{
			using (Way way = new WayOfTheWorm())
			{
				Assert.AreEqual(Categories.Way, way.Category);
			}
		}
		[TestMethod]
		public void Test_WayOfTheWorm_Play_Can_Exile()
		{
			var players = new PlayerCollection(mockGame.Object)
			{
				mockPlayer.Object,
				mockPlayer.Object
			};
			mockGame.SetupGet(_ => _.Players).Returns(players);
			var mockEstate = new Mock<ISupply>();
			mockTable.SetupGet(_ => _.Estate).Returns(mockEstate.Object);
			var exiledEstate = new DominionBase.Cards.Universal.Estate();
			mockEstate.SetupGet(_ => _.Count).Returns(5);
			//mockEstate.Setup(_ => _.Any()).Returns(true);  // Can't mock extension methods.  WTF to do now?
			mockEstate.Setup(_ => _.Take()).Returns(exiledEstate);

			using (Way way = new WayOfTheWorm())
			using (Card card = new Sleigh())
			{
				way.FollowAlternateInstructions(mockPlayer.Object, card);


				mockEstate.Verify(_ => _.Take(), Times.Once);
				mockPlayer.Verify(_ => _.AddCardInto(TypeClass.Exile, exiledEstate, It.IsAny<DeckPosition>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_WayOfTheWorm_Play_No_Estates()
		{
			var players = new PlayerCollection(mockGame.Object)
			{
				mockPlayer.Object,
				mockPlayer.Object
			};
			mockGame.SetupGet(_ => _.Players).Returns(players);
			var mockEstate = new Mock<ISupply>();
			mockTable.SetupGet(_ => _.Estate).Returns(mockEstate.Object);
			var exiledEstate = new DominionBase.Cards.Universal.Estate();
			mockEstate.SetupGet(_ => _.Count).Returns(0);
			mockEstate.Setup(_ => _.Take()).Returns(exiledEstate);

			using (Way way = new WayOfTheWorm())
			using (Card card = new Sleigh())
			{
				way.FollowAlternateInstructions(mockPlayer.Object, card);


				mockEstate.Verify(_ => _.Take(), Times.Never);
				mockPlayer.Verify(_ => _.AddCardInto(TypeClass.Exile, exiledEstate, It.IsAny<DeckPosition>()), Times.Never);
			}
		}
	}
}