using DominionBase;
using DominionBase.Cards;
using DominionBase.Cards.Renaissance;
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 UnitTestRenaissance : UnitTestCards
	{
		[TestMethod]
		public void Test_Academy_Basic()
		{
			using (Project card = new Academy())
			{
				Assert.AreEqual(Categories.Project, card.Category);
				Assert.AreEqual(new Cost(5), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Academy_Bought()
		{
			using (Project card = new Academy())
			{
				card.Bought(mockPlayer.Object);


				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, new ActingTroupe(), null, DeckLocation.Discard, DeckPosition.Top, false);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				var key = card.ToString();
				Assert.IsTrue(cgeArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Academy_Card_Gained_Non_Action()
		{
			using (Project card = new Academy())
			{
				card.Bought(mockPlayer.Object);


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

				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Academy_Card_Gained_Action()
		{
			using (Project card = new Academy())
			{
				card.Bought(mockPlayer.Object);


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

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

				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Exactly(2));
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Villagers == 1), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Academy_Teardown()
		{
			using (Project card = new Academy())
			{
				card.Bought(mockPlayer.Object);

				card.TearDown(mockGame.Object);

				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, new ActingTroupe(), null, DeckLocation.Discard, DeckPosition.Top, false);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				var key = card.ToString();
				Assert.IsFalse(cgeArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_ActingTroupe_Basic()
		{
			using (var card = new ActingTroupe())
			{
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
				Assert.AreEqual(new Cost(3), card.BaseCost);
				Assert.AreEqual(4, card.Benefit.Villagers);
			}
		}
		[TestMethod]
		public void Test_ActingTroupe_Play()
		{
			using (var card = new ActingTroupe())
			{
				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.Is<CardBenefit>(cb => cb.Villagers == 4), It.IsAny<bool>()), Times.Once);
				mockPlayer.Verify(_ => _.RetrieveCardFrom(DeckLocation.InPlay, card), Times.Once);
				mockPlayer.Verify(_ => _.Trash(card, card), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Barracks_Basic()
		{
			using (Project card = new Barracks())
			{
				Assert.AreEqual(Categories.Project, card.Category);
				Assert.AreEqual(new Cost(6), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Barracks_Bought()
		{
			using (Project card = new Barracks())
			{
				card.Bought(mockPlayer.Object);


				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				var key = card.ToString();
				Assert.IsTrue(tseArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Barracks_TurnStarted()
		{
			using (Project card = new Barracks())
			{
				card.Bought(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.Actions == 1), It.IsAny<bool>()), Times.Once);
				Assert.IsTrue(tseArgs.HandledBy.Contains(key));
			}
		}
		[TestMethod]
		public void Test_Barracks_TurnStarted_Only_Once()
		{
			using (Project card = new Barracks())
			{
				card.Bought(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);

				var tseArgs2 = new TurnStartedEventArgs(mockPlayer.Object);
				tseArgs2.HandledBy.AddRange(tseArgs.HandledBy);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs2);
				Assert.IsFalse(tseArgs2.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Barracks_Teardown()
		{
			using (Project card = new Barracks())
			{
				card.Bought(mockPlayer.Object);

				card.TearDown(mockGame.Object);

				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				var key = card.ToString();
				Assert.IsFalse(tseArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_BorderGuard_Basic()
		{
			using (var card = new BorderGuard())
			{
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
				Assert.AreEqual(new Cost(2), card.BaseCost);
				Assert.AreEqual(1, card.Benefit.Actions);
			}
		}
		[TestMethod]
		public void Test_BorderGuard_Play_No_Actions()
		{
			using (var card = new BorderGuard())
			{
				mockPlayer.Setup(_ => _.Draw(It.IsAny<int>(), DeckLocation.Revealed))
								.Returns(new ItemCollection<Card> { new Ducat(), new Ducat() });
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)))
					.Returns(new ChoiceResult(new ItemCollection<Card>()));


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.DiscardRevealed(), Times.Once);
				mockPlayer.Verify(_ => _.AddCardsToHand(It.IsAny<IEnumerable<Card>>()), Times.Never);
				mockPlayer.Verify(_ => _.Take(It.IsAny<Type>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_BorderGuard_Play_One_Action()
		{
			using (var card = new BorderGuard())
			{
				var ducat = new Ducat();
				var actingTroupe = new ActingTroupe();
				var cardsRevealed = new ItemCollection<Card> { ducat, actingTroupe };
				mockPlayer.Setup(_ => _.Draw(It.IsAny<int>(), DeckLocation.Revealed))
					.Returns(new ItemCollection<Card>(cardsRevealed));
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)))
					.Returns(new ChoiceResult(new ItemCollection<Card> { cardsRevealed.First(c => c.Category.HasFlag(Categories.Action)) }));
				mockPlayer.Setup(_ => _.RetrieveCardsFrom(DeckLocation.Revealed, It.IsAny<Predicate<Card>>(), It.IsAny<int>()))
					.Returns<DeckLocation, Predicate<Card>, int>((dl, pc, i) => cardsRevealed.FindAll(pc));


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.DiscardRevealed(), Times.Once);
				mockPlayer.Verify(_ => _.AddCardsToHand(It.IsAny<IEnumerable<Card>>()), Times.Once);
				mockPlayer.Verify(_ => _.AddCardsToHand(It.Is<IEnumerable<Card>>(ic => ic.Count() == 1 && ic.ElementAt(0) == actingTroupe)), Times.Once);
				mockPlayer.Verify(_ => _.Take(It.IsAny<Type>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_BorderGuard_Play_Two_Actions_Take_Lantern()
		{
			using (var card = new BorderGuard())
			{
				var seer = new Seer();
				var actingTroupe = new ActingTroupe();
				var cardsRevealed = new ItemCollection<Card> { seer, actingTroupe };
				mockPlayer.Setup(_ => _.Draw(It.IsAny<int>(), DeckLocation.Revealed))
					.Returns(new ItemCollection<Card>(cardsRevealed));
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)))
					.Returns(new ChoiceResult(new ItemCollection<Card> { cardsRevealed.First(c => c.Category.HasFlag(Categories.Action)) }));
				mockPlayer.Setup(_ => _.RetrieveCardsFrom(DeckLocation.Revealed, It.IsAny<Predicate<Card>>(), It.IsAny<int>()))
					.Returns<DeckLocation, Predicate<Card>, int>((dl, pc, i) => cardsRevealed.FindAll(pc));
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options)))
					.Returns(new ChoiceResult(new List<string> { ResourcesHelper.Get("TakeLantern") }));


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.DiscardRevealed(), Times.Once);
				mockPlayer.Verify(_ => _.AddCardsToHand(It.IsAny<IEnumerable<Card>>()), Times.Once);
				mockPlayer.Verify(_ => _.AddCardsToHand(It.Is<IEnumerable<Card>>(ic => ic.Count() == 1 && ic.ElementAt(0) == seer)), Times.Once);
				mockPlayer.Verify(_ => _.Take(It.IsAny<Type>()), Times.Once);
				mockPlayer.Verify(_ => _.Take(TypeClass.Lantern), Times.Once);
			}
		}
		[TestMethod]
		public void Test_BorderGuard_Play_Two_Actions_Take_Horn()
		{
			using (var card = new BorderGuard())
			{
				var seer = new Seer();
				var actingTroupe = new ActingTroupe();
				var cardsRevealed = new ItemCollection<Card> { seer, actingTroupe };
				mockPlayer.Setup(_ => _.Draw(It.IsAny<int>(), DeckLocation.Revealed))
					.Returns(new ItemCollection<Card>(cardsRevealed));
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)))
					.Returns(new ChoiceResult(new ItemCollection<Card> { cardsRevealed.First(c => c.Category.HasFlag(Categories.Action)) }));
				mockPlayer.Setup(_ => _.RetrieveCardsFrom(DeckLocation.Revealed, It.IsAny<Predicate<Card>>(), It.IsAny<int>()))
					.Returns<DeckLocation, Predicate<Card>, int>((dl, pc, i) => cardsRevealed.FindAll(pc));
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options)))
					.Returns(new ChoiceResult(new List<string> { ResourcesHelper.Get("TakeHorn") }));


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.DiscardRevealed(), Times.Once);
				mockPlayer.Verify(_ => _.AddCardsToHand(It.IsAny<IEnumerable<Card>>()), Times.Once);
				mockPlayer.Verify(_ => _.AddCardsToHand(It.Is<IEnumerable<Card>>(ic => ic.Count() == 1 && ic.ElementAt(0) == seer)), Times.Once);
				mockPlayer.Verify(_ => _.Take(It.IsAny<Type>()), Times.Once);
				mockPlayer.Verify(_ => _.Take(TypeClass.Horn), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Canal_Basic()
		{
			using (Project card = new Canal())
			{
				Assert.AreEqual(Categories.Project, card.Category);
				Assert.AreEqual(new Cost(7), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Canal_Bought()
		{
			using (Project card = new Canal())
			{
				card.Bought(mockPlayer.Object);


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

				var toCompute = new ActingTroupe();
				var cceArgs = new CostComputeEventArgs(toCompute, toCompute.BaseCost);
				mockGame.Raise(_ => _.CostCompute += null, cceArgs);
				Assert.AreEqual(2, cceArgs.Cost.Coin.Value);
			}
		}
		[TestMethod]
		public void Test_Canal_TurnStarted_Cost_Reduction()
		{
			using (Project card = new Canal())
			{
				card.Bought(mockPlayer.Object);


				// Go to the next turn
				var teeArgs = new TurnEndedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnEnded += null, teeArgs);

				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);

				var toCompute = new ActingTroupe();
				var cceArgs = new CostComputeEventArgs(toCompute, toCompute.BaseCost);
				mockGame.Raise(_ => _.CostCompute += null, cceArgs);
				Assert.AreEqual(2, cceArgs.Cost.Coin.Value);
			}
		}
		[TestMethod]
		public void Test_Canal_TurnStarted_Only_Once()
		{
			using (Project card = new Canal())
			{
				card.Bought(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);

				var tseArgs2 = new TurnStartedEventArgs(mockPlayer.Object);
				tseArgs2.HandledBy.AddRange(tseArgs.HandledBy);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs2);
				Assert.IsFalse(tseArgs2.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Canal_No_Cost_Reduction_After_Turn_End()
		{
			using (Project card = new Canal())
			{
				card.Bought(mockPlayer.Object);


				// Go to the next turn
				var teeArgs = new TurnEndedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnEnded += null, teeArgs);

				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);

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

				// Turn has ended, so cost reduction shouldn't be applied any more
				var toCompute = new ActingTroupe();
				var cceArgs = new CostComputeEventArgs(toCompute, toCompute.BaseCost);
				mockGame.Raise(_ => _.CostCompute += null, cceArgs);
				Assert.AreEqual(3, cceArgs.Cost.Coin.Value);
			}
		}
		[TestMethod]
		public void Test_Canal_Teardown()
		{
			using (Project card = new Canal())
			{
				card.Bought(mockPlayer.Object);

				card.TearDown(mockGame.Object);

				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				var key = card.ToString();
				Assert.IsFalse(tseArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_CargoShip_Basic()
		{
			using (var card = new CargoShip())
			{
				Assert.AreEqual(new Cost(3), card.BaseCost);
				Assert.AreEqual(2, card.Benefit.Currency.Coin.Value);
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Duration, card.Category);
			}
		}
		[TestMethod]
		public void Test_CargoShip_Play_No_Gain()
		{
			using (Card card = new CargoShip())
			{
				card.FollowInstructions(mockPlayer.Object);


				Assert.IsTrue(card.CanCleanUp);
				Assert.IsTrue(card.IsStackable);
				mockPlayer.Verify(_ => _.RetrieveCardFrom(It.IsAny<DeckLocation>(), It.IsAny<Card>()), Times.Never);

				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.ContainsKey(card.Name));
			}
		}
		[TestMethod]
		public void Test_CargoShip_Play_Gain_Not_Set_Aside()
		{
			using (Card card = new CargoShip())
			{
				Card toGain = new Lackeys();


				card.FollowInstructions(mockPlayer.Object);


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

				Assert.IsTrue(card.CanCleanUp);
				Assert.IsTrue(card.IsStackable);
				mockPlayer.Verify(_ => _.RetrieveCardFrom(It.IsAny<DeckLocation>(), It.IsAny<Card>()), Times.Never);

				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.ContainsKey(card.Name));
			}
		}
		[TestMethod]
		public void Test_CargoShip_Play_Gain_Set_Aside()
		{
			using (Card card = new CargoShip())
			{
				Card toGain = new Lackeys();
				mockPlayer.Setup(_ => _.RetrieveCardFrom(It.IsAny<DeckLocation>(), toGain)).Returns(toGain);


				card.FollowInstructions(mockPlayer.Object);


				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, toGain, null, DeckLocation.Discard, DeckPosition.Automatic, true);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				var cgKey = TypeClass.CargoShip.ToString();
				Assert.IsTrue(cgeArgs.Resolvers.ContainsKey(cgKey));
				cgeArgs.Resolvers[cgKey].Method(mockPlayer.Object, ref cgeArgs);


				Assert.IsFalse(card.CanCleanUp);
				Assert.IsFalse(card.IsStackable);
				Assert.AreEqual(2, card.Stack().Count);
				mockPlayer.Verify(_ => _.RetrieveCardFrom(It.IsAny<DeckLocation>(), toGain), Times.Once);


				// Next turn
				var teeArgs = new TurnEndedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnEnded += null, teeArgs);
				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				var tsKey = $"{card.UniqueId}_{toGain.UniqueId}";
				Assert.IsTrue(tseArgs.Resolvers.ContainsKey(tsKey));
				tseArgs.Resolvers[tsKey].Method(mockPlayer.Object, ref tseArgs);

				mockPlayer.Verify(_ => _.AddCardToHand(toGain), Times.Once);
				Assert.IsTrue(card.CanCleanUp);
				Assert.IsTrue(card.IsStackable);
			}
		}
		[TestMethod]
		public void Test_CargoShip_Play_Gain_Second_Card()
		{
			using (Card card = new CargoShip())
			{
				Card toGain = new Lackeys();
				Card toGain2 = new ActingTroupe();
				mockPlayer.Setup(_ => _.RetrieveCardFrom(It.IsAny<DeckLocation>(), toGain)).Returns(toGain);
				mockPlayer.Setup(_ => _.RetrieveCardFrom(It.IsAny<DeckLocation>(), toGain2)).Returns(toGain2);


				card.FollowInstructions(mockPlayer.Object);


				// Gain 1st card
				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, toGain, null, DeckLocation.Discard, DeckPosition.Automatic, true);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				var cgKey = TypeClass.CargoShip.ToString();
				Assert.IsTrue(cgeArgs.Resolvers.ContainsKey(cgKey));
				cgeArgs.Resolvers[cgKey].Method(mockPlayer.Object, ref cgeArgs);

				// Gain 2nd card
				cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, toGain2, null, DeckLocation.Discard, DeckPosition.Automatic, true);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsFalse(cgeArgs.Resolvers.ContainsKey(cgKey));
			}
		}
		[TestMethod]
		public void Test_CargoShip_Play_Multiplier_Gain_Second_Card()
		{
			using (Card card = new CargoShip())
			using (Card multiplier = new DominionBase.Cards.Base2ndEdition.ThroneRoom())
			{
				var hand = new Deck(DeckLocation.Hand)
				{
					card
				};
				Card toGain = new Lackeys();
				Card toGain2 = new ActingTroupe();
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				mockPlayer.Setup(_ => _.RetrieveCardFrom(It.IsAny<DeckLocation>(), toGain)).Returns(toGain);
				mockPlayer.Setup(_ => _.RetrieveCardFrom(It.IsAny<DeckLocation>(), toGain2)).Returns(toGain2);
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.Source == multiplier))).Returns(new ChoiceResult(new ItemCollection<Card> { card }));
				mockPlayer.Setup(_ => _.PlayCard(card, It.IsAny<PlayerMode>())).Callback<Card, PlayerMode>((c, pm) => c.FollowInstructions(mockPlayer.Object));


				// Play Cargo Ship through Throne Room
				multiplier.FollowInstructions(mockPlayer.Object);


				// Gain 1st card
				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, toGain, null, DeckLocation.Discard, DeckPosition.Automatic, true);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				var cgKey = $"{TypeClass.CargoShip}.{DominionBase.Cards.Base2ndEdition.TypeClass.ThroneRoom}";
				Assert.IsTrue(cgeArgs.Resolvers.ContainsKey(cgKey));
				cgeArgs.Resolvers[cgKey].Method(mockPlayer.Object, ref cgeArgs);

				// Gain 2nd card
				cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, toGain2, null, DeckLocation.Discard, DeckPosition.Automatic, true);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				Assert.IsTrue(cgeArgs.Resolvers.ContainsKey(cgKey));
				cgeArgs.Resolvers[cgKey].Method(mockPlayer.Object, ref cgeArgs);

				Assert.IsFalse(card.CanCleanUp);
				Assert.IsFalse(card.IsStackable);
				Assert.AreEqual(3, card.Stack().Count);
			}
		}
		[TestMethod]
		public void Test_CargoShip_Teardown()
		{
			using (Card card = new CargoShip())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				Card toGain = new Lackeys();
				mockPlayer.Setup(_ => _.RetrieveCardFrom(It.IsAny<DeckLocation>(), toGain)).Returns(toGain);


				card.FollowInstructions(mockPlayer.Object);


				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, toGain, null, DeckLocation.Discard, DeckPosition.Automatic, true);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				var cgKey = TypeClass.CargoShip.ToString();
				Assert.IsTrue(cgeArgs.Resolvers.ContainsKey(cgKey));
				cgeArgs.Resolvers[cgKey].Method(mockPlayer.Object, ref cgeArgs);


				Assert.IsFalse(card.CanCleanUp);
				Assert.IsFalse(card.IsStackable);
				mockPlayer.Verify(_ => _.RetrieveCardFrom(It.IsAny<DeckLocation>(), toGain), Times.Once);


				// Next turn
				var teeArgs = new TurnEndedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnEnded += null, teeArgs);
				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);

				// 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);
				var tsKey = $"{card.UniqueId}_{toGain.UniqueId}";
				Assert.IsFalse(tseArgs.Resolvers.ContainsKey(tsKey));
			}
		}
		[TestMethod]
		public void Test_Cathedral_Basic()
		{
			using (Project card = new Cathedral())
			{
				Assert.AreEqual(Categories.Project, card.Category);
				Assert.AreEqual(new Cost(3), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Cathedral_Bought()
		{
			using (Project card = new Cathedral())
			{
				card.Bought(mockPlayer.Object);


				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				var key = card.ToString();
				Assert.IsTrue(tseArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Cathedral_TurnStarted_No_Cards()
		{
			using (Project card = new Cathedral())
			{
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>()));


				card.Bought(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(_ => _.Trash(It.IsAny<IGameObject>(), It.IsAny<Card>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Cathedral_TurnStarted_Trash_Card()
		{
			using (Project card = new Cathedral())
			{
				var toTrash = new Seer();
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card> { toTrash }));
				mockPlayer.Setup(_ => _.RetrieveCardFrom(DeckLocation.Hand, toTrash)).Returns(toTrash);


				card.Bought(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(_ => _.Trash(card, toTrash), Times.Once);
				Assert.IsTrue(tseArgs.HandledBy.Contains(key));
			}
		}
		[TestMethod]
		public void Test_Cathedral_TurnStarted_Trash_Card_Only_Once()
		{
			using (Project card = new Cathedral())
			{
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>()));


				card.Bought(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);

				Assert.IsTrue(tseArgs.HandledBy.Contains(key));

				var tseArgs2 = new TurnStartedEventArgs(mockPlayer.Object);
				tseArgs2.HandledBy.AddRange(tseArgs.HandledBy);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs2);
				Assert.IsFalse(tseArgs2.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Cathedral_Teardown()
		{
			using (Project card = new Cathedral())
			{
				card.Bought(mockPlayer.Object);

				card.TearDown(mockGame.Object);

				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				var key = card.ToString();
				Assert.IsFalse(tseArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Citadel_Basic()
		{
			using (Project card = new Citadel())
			{
				Assert.AreEqual(Categories.Project, card.Category);
				Assert.AreEqual(new Cost(8), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Citadel_Bought()
		{
			using (Project card = new Citadel())
			{
				var turn = new Turn(mockPlayer.Object);
				mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(turn);
				mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);


				card.Bought(mockPlayer.Object);


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

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

				// Not much to test???
			}
		}
		[TestMethod]
		public void Test_Citadel_Action_Played()
		{
			using (Project card = new Citadel())
			{
				var turn = new Turn(mockPlayer.Object);
				mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(turn);
				mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);


				card.Bought(mockPlayer.Object);


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

				Card toPlay = new ActingTroupe();
				var cpeArgs = new CardPlayingEventArgs(mockPlayer.Object, toPlay, "");
				mockPlayer.Raise(_ => _.CardPlaying += null, cpeArgs);

				var cpdeArgs = new CardPlayedEventArgs(mockPlayer.Object, toPlay);
				mockPlayer.Raise(_ => _.CardPlayed += null, cpdeArgs);
				var key = card.Type;
				Assert.IsTrue(cpdeArgs.Resolvers.ContainsKey(key));

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

				Assert.IsTrue(cpdeArgs.HandledBy.Contains(key));
				mockPlayer.Verify(_ => _.PlayCard(toPlay, It.IsAny<PlayerMode>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Citadel_Bought_No_Action_Played()
		{
			using (Project card = new Citadel())
			{
				var turn = new Turn(mockPlayer.Object);
				mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(turn);
				mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);


				card.Bought(mockPlayer.Object);


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

				Card toPlay = new Ducat();
				var cpeArgs = new CardPlayingEventArgs(mockPlayer.Object, toPlay, "");
				mockPlayer.Raise(_ => _.CardPlaying += null, cpeArgs);

				var cpdeArgs = new CardPlayedEventArgs(mockPlayer.Object, toPlay);
				mockPlayer.Raise(_ => _.CardPlayed += null, cpdeArgs);
				var key = card.Type;
				Assert.IsFalse(cpdeArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Citadel_Bought_Second_Action_Played()
		{
			using (Project card = new Citadel())
			{
				var turn = new Turn(mockPlayer.Object);
				turn.CardsPlayed.Add(new Experiment());
				mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(turn);
				mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);


				card.Bought(mockPlayer.Object);


				Card toPlay = new ActingTroupe();
				var cpeArgs = new CardPlayingEventArgs(mockPlayer.Object, toPlay, "");
				mockPlayer.Raise(_ => _.CardPlaying += null, cpeArgs);

				var cpdeArgs = new CardPlayedEventArgs(mockPlayer.Object, toPlay);
				mockPlayer.Raise(_ => _.CardPlayed += null, cpdeArgs);
				var key = card.Type;
				Assert.IsFalse(cpdeArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Citadel_Teardown()
		{
			using (Project card = new Citadel())
			{
				var turn = new Turn(mockPlayer.Object);
				mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(turn);

				card.Bought(mockPlayer.Object);

				card.TearDown(mockGame.Object);

				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				var key = card.ToString();
				Assert.IsFalse(tseArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_CityGate_Basic()
		{
			using (Project card = new CityGate())
			{
				Assert.AreEqual(Categories.Project, card.Category);
				Assert.AreEqual(new Cost(3), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_CityGate_Bought()
		{
			using (Project card = new CityGate())
			{
				card.Bought(mockPlayer.Object);


				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				var key = card.ToString();
				Assert.IsTrue(tseArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_CityGate_TurnStarted()
		{
			using (Project card = new CityGate())
			{
				var toTopdeck = new Seer();
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card> { toTopdeck }));
				mockPlayer.Setup(_ => _.RetrieveCardFrom(DeckLocation.Hand, toTopdeck)).Returns(toTopdeck);


				card.Bought(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.Cards == 1), It.IsAny<bool>()), Times.Once);
				mockPlayer.Verify(_ => _.AddCardToDeck(toTopdeck, DeckPosition.Top), Times.Once);
				Assert.IsTrue(tseArgs.HandledBy.Contains(key));
			}
		}
		[TestMethod]
		public void Test_CityGate_TurnStarted_Only_Once()
		{
			using (Project card = new CityGate())
			{
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>()));


				card.Bought(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);

				Assert.IsTrue(tseArgs.HandledBy.Contains(key));

				var tseArgs2 = new TurnStartedEventArgs(mockPlayer.Object);
				tseArgs2.HandledBy.AddRange(tseArgs.HandledBy);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs2);
				Assert.IsFalse(tseArgs2.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_CityGate_Teardown()
		{
			using (Project card = new CityGate())
			{
				card.Bought(mockPlayer.Object);

				card.TearDown(mockGame.Object);

				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				var key = card.ToString();
				Assert.IsFalse(tseArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_CropRotation_Basic()
		{
			using (Project card = new CropRotation())
			{
				Assert.AreEqual(Categories.Project, card.Category);
				Assert.AreEqual(new Cost(6), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_CropRotation_Bought()
		{
			using (Project card = new CropRotation())
			{
				var victory = new DominionBase.Cards.Universal.Estate();
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				hand.AddRange(mockPlayer.Object, new ItemCollection<Card> { victory });
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);


				card.Bought(mockPlayer.Object);


				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				var key = card.ToString();
				Assert.IsTrue(tseArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_CropRotation_TurnStarted_No_Victories()
		{
			using (Project card = new CropRotation())
			{
				mockPlayer.SetupGet(_ => _.Hand).Returns(new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner));
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>()));


				card.Bought(mockPlayer.Object);


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

				mockPlayer.Verify(_ => _.Discard(DeckLocation.Hand, It.IsAny<IEnumerable<Card>>(), It.IsAny<CardsDiscardResolver>()), Times.Never);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_CropRotation_TurnStarted_Victories_No_Discard()
		{
			using (Project card = new CropRotation())
			{
				var victory1 = new DominionBase.Cards.Universal.Estate();
				var victory2 = new DominionBase.Cards.Universal.Province();
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				hand.AddRange(mockPlayer.Object, new ItemCollection<Card> { victory1, victory2 });
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>()));


				card.Bought(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(_ => _.Discard(DeckLocation.Hand, It.IsAny<IEnumerable<Card>>(), It.IsAny<CardsDiscardResolver>()), Times.Never);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_CropRotation_TurnStarted_Victories_Discard()
		{
			using (Project card = new CropRotation())
			{
				var victory1 = new DominionBase.Cards.Universal.Estate();
				var victory2 = new DominionBase.Cards.Universal.Province();
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				hand.AddRange(mockPlayer.Object, new ItemCollection<Card> { victory1, victory2 });
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card> { victory2 }));


				card.Bought(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(_ => _.Discard(DeckLocation.Hand, It.Is<IEnumerable<Card>>(ic => ic.Count() == 1 && ic.ElementAt(0) == victory2), It.IsAny<CardsDiscardResolver>()), 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 == 2), It.IsAny<bool>()), Times.Once);
				Assert.IsTrue(tseArgs.HandledBy.Contains(key));
			}
		}
		[TestMethod]
		public void Test_CropRotation_TurnStarted_Only_Once()
		{
			using (Project card = new CropRotation())
			{
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				var victory = new DominionBase.Cards.Universal.Estate();
				hand.AddRange(mockPlayer.Object, new ItemCollection<Card> { victory });
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>()));


				card.Bought(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);

				Assert.IsTrue(tseArgs.HandledBy.Contains(key));

				var tseArgs2 = new TurnStartedEventArgs(mockPlayer.Object);
				tseArgs2.HandledBy.AddRange(tseArgs.HandledBy);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs2);
				Assert.IsFalse(tseArgs2.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_CropRotation_Teardown()
		{
			using (Project card = new CropRotation())
			{
				var victory = new DominionBase.Cards.Universal.Estate();
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				hand.AddRange(mockPlayer.Object, new ItemCollection<Card> { victory });
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);


				card.Bought(mockPlayer.Object);

				card.TearDown(mockGame.Object);

				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				var key = card.ToString();
				Assert.IsFalse(tseArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Ducat_Basic()
		{
			using (var card = new Ducat())
			{
				Assert.AreEqual(Categories.Card | Categories.Treasure, card.Category);
				Assert.AreEqual(new Cost(2), card.BaseCost);
				Assert.AreEqual(1, card.Benefit.Buys);
				Assert.AreEqual(1, card.Benefit.Coffers);
				Assert.AreEqual(0, card.Benefit.Currency.Coin.Value);
			}
		}
		[TestMethod]
		public void Test_Ducat_Gain_No_Coppers()
		{
			using (Card card = new Ducat())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceOutcome == ChoiceOutcome.Trash && c.ChoiceType == ChoiceType.Cards)))
					.Returns(new ChoiceResult(new ItemCollection<Card>()));


				card.SetupCard(mockGame.Object);


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

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


				mockPlayer.Verify(_ => _.RetrieveCardsFrom(DeckLocation.Hand, It.IsAny<ItemCollection<Card>>()), Times.Never);
				mockPlayer.Verify(_ => _.Trash(It.IsAny<IGameObject>(), It.IsAny<ItemCollection<Card>>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Ducat_Gain_Trash_Copper()
		{
			using (Card card = new Ducat())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner)
				{
					new DominionBase.Cards.Universal.Copper(),
					new DominionBase.Cards.Universal.Copper()
				};
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceOutcome == ChoiceOutcome.Trash && c.ChoiceType == ChoiceType.Cards)))
					.Returns(new ChoiceResult(new ItemCollection<Card> { hand.First() }));
				mockPlayer.Setup(_ => _.RetrieveCardsFrom(DeckLocation.Hand, It.Is<ItemCollection<Card>>(ic => ic.Count == 1 && ic[0] is DominionBase.Cards.Universal.Copper)))
					.Returns(new ItemCollection<Card> { hand.First() });


				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.Ducat.ToString()));

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


				mockPlayer.Verify(_ => _.RetrieveCardsFrom(DeckLocation.Hand, It.Is<ItemCollection<Card>>(ic => ic.Count == 1 && ic[0] is DominionBase.Cards.Universal.Copper)), Times.Once);
				mockPlayer.Verify(_ => _.Trash(card, It.Is<ItemCollection<Card>>(ic => ic.Count == 1 && ic[0] is DominionBase.Cards.Universal.Copper)), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Ducat_Play()
		{
			using (Card card = new Ducat())
			{
				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.Coffers == 1 && cb.Buys == 1), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Ducat_Teardown()
		{
			using (Card card = new Ducat())
			{
				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.Ducat.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.Ducat.ToString()));
			}
		}
		[TestMethod]
		public void Test_Experiment_Basic()
		{
			using (var card = new Experiment())
			{
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
				Assert.AreEqual(new Cost(3), card.BaseCost);
				Assert.AreEqual(2, card.Benefit.Cards);
				Assert.AreEqual(1, card.Benefit.Actions);
			}
		}
		[TestMethod]
		public void Test_Experiment_Gain()
		{
			using (Card card = new Experiment())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockTable.Setup(_ => _[TypeClass.Experiment]).Returns(mockSupply.Object);
				mockSupply.Setup(_ => _.Type).Returns(TypeClass.Experiment);
				mockPlayer.Setup(_ => _.Gain(It.IsAny<ISupply>(), It.IsAny<IGameObject>(), It.IsAny<int>(), It.IsAny<bool>()))
					.Returns<ISupply, IGameObject, int, bool>((s, go, c, b) =>
					{
						var toGain = new Experiment();
						toGain.SetupCard(mockGame.Object);
						var cgeArgsTemp = new DominionBase.Players.CardGainEventArgs(mockGame.Object, toGain, go, DeckLocation.Discard, DeckPosition.Automatic, b);
						mockPlayer.Raise(_ => _.CardGained += null, cgeArgsTemp);
						return true;
					});


				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.Experiment.ToString()));

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


				mockPlayer.Verify(_ => _.Gain(It.Is<ISupply>(s => s.Type == TypeClass.Experiment), card, 1, false), Times.Once);
				mockPlayer.Verify(_ => _.Gain(It.Is<ISupply>(s => s.Type == TypeClass.Experiment), It.IsAny<IGameObject>(), 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Experiment_Play()
		{
			using (Card card = new Experiment())
			{
				mockTable.Setup(_ => _[TypeClass.Experiment]).Returns(mockSupply.Object);
				mockSupply.Setup(_ => _.Type).Returns(TypeClass.Experiment);
				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_Experiment_Teardown()
		{
			using (Card card = new Experiment())
			{
				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.Experiment.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.Experiment.ToString()));
			}
		}
		[TestMethod]
		public void Test_Exploration_Basic()
		{
			using (Project card = new Exploration())
			{
				Assert.AreEqual(Categories.Project, card.Category);
				Assert.AreEqual(new Cost(4), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Exploration_Bought()
		{
			using (Project card = new Exploration())
			{
				mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Buy);
				var turn = new Turn(mockPlayer.Object);
				mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(turn);


				card.Bought(mockPlayer.Object);


				var pceArgs = new PhaseChangingEventArgs(mockPlayer.Object, PhaseEnum.Night);
				mockPlayer.Raise(_ => _.PhaseChanging += null, pceArgs);
				var key = TypeClass.Exploration;
				Assert.IsTrue(pceArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Exploration_Buy_Phase_Ended_Nothing_Bought()
		{
			using (Project card = new Exploration())
			{
				mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Buy);
				var turn = new Turn(mockPlayer.Object);
				mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(turn);


				card.Bought(mockPlayer.Object);
				turn.CardsBought.Add(card);


				var pceArgs = new PhaseChangingEventArgs(mockPlayer.Object, PhaseEnum.Night);
				mockPlayer.Raise(_ => _.PhaseChanging += null, pceArgs);
				var key = TypeClass.Exploration;
				Assert.IsTrue(pceArgs.Resolvers.ContainsKey(key));

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

				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Coffers == 1 && cb.Villagers == 1), It.IsAny<bool>()), Times.Once);
				Assert.IsTrue(pceArgs.HandledBy.Contains(TypeClass.Exploration));
			}
		}
		[TestMethod]
		public void Test_Exploration_Buy_Phase_Ended_Card_Bought()
		{
			using (Project card = new Exploration())
			{
				mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Buy);
				var turn = new Turn(mockPlayer.Object);
				turn.CardsBought.Add(new ActingTroupe());
				mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(turn);


				card.Bought(mockPlayer.Object);


				var pceArgs = new PhaseChangingEventArgs(mockPlayer.Object, PhaseEnum.Night);
				mockPlayer.Raise(_ => _.PhaseChanging += null, pceArgs);
				var key = TypeClass.Exploration;
				Assert.IsFalse(pceArgs.Resolvers.ContainsKey(key));

				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Coffers == 1 && cb.Villagers == 1), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Exploration_Teardown()
		{
			using (Project card = new Exploration())
			{
				mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Buy);


				card.Bought(mockPlayer.Object);

				card.TearDown(mockGame.Object);

				var pceArgs = new PhaseChangingEventArgs(mockPlayer.Object, PhaseEnum.Night);
				mockPlayer.Raise(_ => _.PhaseChanging += null, pceArgs);
				var key = TypeClass.Exploration;
				Assert.IsFalse(pceArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Fair_Basic()
		{
			using (Project card = new Fair())
			{
				Assert.AreEqual(Categories.Project, card.Category);
				Assert.AreEqual(new Cost(4), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Fair_Bought()
		{
			using (Project card = new Fair())
			{
				card.Bought(mockPlayer.Object);


				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				var key = card.ToString();
				Assert.IsTrue(tseArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Fair_TurnStarted()
		{
			using (Project card = new Fair())
			{
				card.Bought(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.Buys == 1), It.IsAny<bool>()), Times.Once);
				Assert.IsTrue(tseArgs.HandledBy.Contains(key));
			}
		}
		[TestMethod]
		public void Test_Fair_TurnStarted_Only_Once()
		{
			using (Project card = new Fair())
			{
				card.Bought(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);
				Assert.IsTrue(tseArgs.HandledBy.Contains(key));

				var tseArgs2 = new TurnStartedEventArgs(mockPlayer.Object);
				tseArgs2.HandledBy.AddRange(tseArgs.HandledBy);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs2);
				Assert.IsFalse(tseArgs2.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Fair_Teardown()
		{
			using (Project card = new Fair())
			{
				card.Bought(mockPlayer.Object);

				card.TearDown(mockGame.Object);

				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				var key = card.ToString();
				Assert.IsFalse(tseArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Flag_Basic()
		{
			using (Artifact card = new Flag())
			{
				Assert.AreEqual(Categories.Artifact, card.Category);
				Assert.IsFalse(card.CanBeMultiples);
			}
		}
		[TestMethod]
		public void Test_Flag_Taken()
		{
			using (Artifact card = new Flag())
			{
				card.TakenBy(mockPlayer.Object);


				var dnheArgs = new DrawNewHandEventArgs(mockPlayer.Object, 5);
				mockPlayer.Raise(_ => _.DrawNewHand += null, dnheArgs);
				Assert.IsTrue(dnheArgs.Resolvers.ContainsKey(TypeClass.Flag));
			}
		}
		[TestMethod]
		public void Test_Flag_Returned()
		{
			using (Artifact card = new Flag())
			{
				var toDraw = 5;


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


				var dnheArgs = new DrawNewHandEventArgs(mockPlayer.Object, toDraw);
				mockPlayer.Raise(_ => _.DrawNewHand += null, dnheArgs);
				Assert.IsFalse(dnheArgs.Resolvers.ContainsKey(TypeClass.Flag));
			}
		}
		[TestMethod]
		public void Test_Flag_TurnStarted()
		{
			using (Artifact card = new Flag())
			{
				var toDraw = 5;


				card.TakenBy(mockPlayer.Object);


				var dnheArgs = new DrawNewHandEventArgs(mockPlayer.Object, toDraw);
				mockPlayer.Raise(_ => _.DrawNewHand += null, dnheArgs);
				Assert.IsTrue(dnheArgs.Resolvers.ContainsKey(TypeClass.Flag));

				dnheArgs.Resolvers[TypeClass.Flag].Method(mockPlayer.Object, ref dnheArgs);

				Assert.AreEqual(toDraw + 1, dnheArgs.DrawSize);
				Assert.IsTrue(dnheArgs.HandledBy.Contains(card));
			}
		}
		[TestMethod]
		public void Test_Flag_Teardown()
		{
			using (Artifact card = new Flag())
			{
				card.TakenBy(mockPlayer.Object);

				card.TearDown(mockGame.Object);

				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				var key = card.ToString();
				Assert.IsFalse(tseArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_FlagBearer_Basic()
		{
			using (var card = new FlagBearer())
			{
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
				Assert.AreEqual(new Cost(4), card.BaseCost);
				Assert.AreEqual(new Currency(2), card.Benefit.Currency);
			}
		}
		[TestMethod]
		public void Test_FlagBearer_Gain()
		{
			using (Card card = new FlagBearer())
			{
				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.FlagBearer.ToString()));

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


				mockPlayer.Verify(_ => _.Take(It.Is<Type>(t => t == TypeClass.Flag)), Times.Once);
			}
		}
		[TestMethod]
		public void Test_FlagBearer_Trash()
		{
			using (Card card = new FlagBearer())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);


				card.SetupCard(mockGame.Object);


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

				teArgs.Resolvers[TypeClass.FlagBearer].Method(mockPlayer.Object, ref teArgs);


				mockPlayer.Verify(_ => _.Take(It.Is<Type>(t => t == TypeClass.Flag)), Times.Once);
			}
		}
		[TestMethod]
		public void Test_FlagBearer_Play()
		{
			using (Card card = new FlagBearer())
			using (var val = new Currency(2))
			{
				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.Currency == val), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_FlagBearer_Teardown()
		{
			using (Card card = new FlagBearer())
			{
				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.FlagBearer.ToString()));
				var teArgs = new TrashEventArgs(mockPlayer.Object, new Sewers(), new ItemCollection<Card> { card });
				mockPlayer.Raise(_ => _.Trashed += null, teArgs);
				Assert.IsTrue(teArgs.Resolvers.ContainsKey(TypeClass.FlagBearer));


				// 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.FlagBearer.ToString()));
				teArgs = new TrashEventArgs(mockPlayer.Object, new Hideout(), new ItemCollection<Card> { card });
				mockPlayer.Raise(_ => _.Trashed += null, teArgs);
				Assert.IsFalse(teArgs.Resolvers.ContainsKey(TypeClass.FlagBearer));

				mockPlayer.Verify(_ => _.Take(It.Is<Type>(t => t == TypeClass.Flag)), Times.Never);
			}
		}
		[TestMethod]
		public void Test_GuildHall_Basic()
		{
			using (Project card = new GuildHall())
			{
				Assert.AreEqual(Categories.Project, card.Category);
				Assert.AreEqual(new Cost(5), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_GuildHall_Bought()
		{
			using (Project card = new GuildHall())
			{
				card.Bought(mockPlayer.Object);


				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, new Ducat(), null, DeckLocation.Discard, DeckPosition.Top, false);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				var key = card.ToString();
				Assert.IsTrue(cgeArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_GuildHall_Card_Gained_Non_Treasure()
		{
			using (Project card = new GuildHall())
			{
				card.Bought(mockPlayer.Object);


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

				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_GuildHall_Card_Gained_Treasure()
		{
			using (Project card = new GuildHall())
			{
				card.Bought(mockPlayer.Object);


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

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

				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Exactly(2));
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Coffers == 1), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_GuildHall_Teardown()
		{
			using (Project card = new GuildHall())
			{
				card.Bought(mockPlayer.Object);

				card.TearDown(mockGame.Object);

				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, new Ducat(), null, DeckLocation.Discard, DeckPosition.Top, false);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				var key = card.ToString();
				Assert.IsFalse(cgeArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Hideout_Basic()
		{
			using (var card = new Hideout())
			{
				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_Hideout_Play_Trash_NonVictory()
		{
			using (Card card = new Hideout())
			{
				mockTable.SetupGet(_ => _.Curse).Returns(mockSupply.Object);
				mockPlayer.SetupGet(_ => _.Hand).Returns(new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner));
				var copper = new DominionBase.Cards.Universal.Copper();
				var toTrash = new ItemCollection<Card>(copper);
				var fakeResultCards = new ChoiceResult(toTrash);
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(x => x.ChoiceType == ChoiceType.Cards))).Returns(fakeResultCards);
				mockPlayer.Setup(_ => _.RetrieveCardsFrom(DeckLocation.Hand, toTrash)).Returns(toTrash);


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Trash(card, It.Is<ItemCollection<Card>>(ic => ic.Count == 1 && ic[0] == copper)), Times.Once);
				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, It.IsAny<IGameObject>(), It.IsAny<int>(), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Hideout_Play_Trash_Victory()
		{
			using (Card card = new Hideout())
			{
				mockTable.SetupGet(_ => _.Curse).Returns(mockSupply.Object);
				mockPlayer.SetupGet(_ => _.Hand).Returns(new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner));
				var estate = new DominionBase.Cards.Universal.Estate();
				var toTrash = new ItemCollection<Card>(estate);
				var fakeResultCards = new ChoiceResult(toTrash);
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(x => x.ChoiceType == ChoiceType.Cards))).Returns(fakeResultCards);
				mockPlayer.Setup(_ => _.RetrieveCardsFrom(DeckLocation.Hand, toTrash)).Returns(toTrash);


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Trash(card, It.Is<ItemCollection<Card>>(ic => ic.Count == 1 && ic[0] == estate)), Times.Once);
				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, 1, false), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Horn_Basic()
		{
			using (Artifact card = new Horn())
			{
				Assert.AreEqual(Categories.Artifact, card.Category);
				Assert.IsFalse(card.CanBeMultiples);
			}
		}
		[TestMethod]
		public void Test_Horn_Taken()
		{
			using (Artifact card = new Horn())
			{
				card.TakenBy(mockPlayer.Object);


				var cdeArgs = new CardsDiscardEventArgs(DeckLocation.InPlayAndSetAside, new ItemCollection<Card>());
				mockPlayer.Raise(_ => _.CardsDiscarding += null, cdeArgs);
				Assert.IsFalse(cdeArgs.Resolvers.ContainsKey(Tuple.Create(TypeClass.Horn, TypeClass.Horn)));
			}
		}
		[TestMethod]
		public void Test_Horn_Returned()
		{
			using (Artifact card = new Horn())
			{
				card.TakenBy(mockPlayer.Object);
				card.ReturnedBy(mockPlayer.Object);


				var cdeArgs = new CardsDiscardEventArgs(DeckLocation.InPlayAndSetAside, new ItemCollection<Card>());
				mockPlayer.Raise(_ => _.CardsDiscarding += null, cdeArgs);
				Assert.IsFalse(cdeArgs.Resolvers.ContainsKey(Tuple.Create(TypeClass.Horn, TypeClass.Horn)));
			}
		}
		[TestMethod]
		public void Test_Horn_Discard_Non_BorderGuard()
		{
			using (Artifact card = new Horn())
			{
				var toDiscard = new ItemCollection<Card> { new Ducat(), new Villain() };


				card.TakenBy(mockPlayer.Object);


				var cdeArgs = new CardsDiscardEventArgs(DeckLocation.InPlayAndSetAside, toDiscard);
				mockPlayer.Raise(_ => _.CardsDiscarding += null, cdeArgs);
				Assert.IsFalse(cdeArgs.Resolvers.ContainsKey(Tuple.Create(TypeClass.Horn, TypeClass.Horn)));
			}
		}
		[TestMethod]
		public void Test_Horn_Discard_BorderGuard()
		{
			using (Artifact card = new Horn())
			{
				var borderGuard = new BorderGuard();
				var toDiscard = new ItemCollection<Card> { new Ducat(), new Villain(), borderGuard };
				var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
				inPlay.AddRange(mockPlayer.Object, toDiscard);
				mockPlayer.SetupGet(_ => _.InPlay).Returns(inPlay);
				mockPlayer.Setup(_ => _.RetrieveCardFrom(DeckLocation.InPlay, borderGuard)).Returns(borderGuard);


				card.TakenBy(mockPlayer.Object);


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

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

				mockPlayer.Verify(_ => _.AddCardToDeck(borderGuard, DeckPosition.Top), Times.Once);
				Assert.IsFalse(toDiscard.Contains(borderGuard));
				Assert.IsFalse(cdeArgs.Cards.Contains(borderGuard));
			}
		}
		[TestMethod]
		public void Test_Horn_Discard_Multiple_BorderGuards()
		{
			using (Artifact card = new Horn())
			{
				var borderGuard1 = new BorderGuard();
				var borderGuard2 = new BorderGuard();
				var toDiscard = new ItemCollection<Card> { new Ducat(), new Villain(), borderGuard1, borderGuard2 };
				var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
				inPlay.AddRange(mockPlayer.Object, toDiscard);
				mockPlayer.SetupGet(_ => _.InPlay).Returns(inPlay);


				card.TakenBy(mockPlayer.Object);


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

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

				mockPlayer.Verify(_ => _.AddCardToDeck(borderGuard1, DeckPosition.Top), Times.Once);
				Assert.IsFalse(toDiscard.Contains(borderGuard1));
				Assert.IsFalse(cdeArgs.Cards.Contains(borderGuard1));

				// It shouldn't raise a second time after top-decking a Border Guard
				cdeArgs.Resolvers.Clear();
				mockPlayer.Raise(_ => _.CardsDiscarding += null, cdeArgs);
				Assert.IsFalse(cdeArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Horn_Teardown()
		{
			using (Artifact card = new Horn())
			{
				var borderGuard = new BorderGuard();
				var toDiscard = new ItemCollection<Card> { new Ducat(), new Villain(), borderGuard };
				var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
				inPlay.AddRange(mockPlayer.Object, toDiscard);
				mockPlayer.SetupGet(_ => _.InPlay).Returns(inPlay);
				mockPlayer.Setup(_ => _.RetrieveCardFrom(DeckLocation.InPlay, borderGuard)).Returns(borderGuard);


				card.TakenBy(mockPlayer.Object);

				card.TearDown(mockGame.Object);

				var cdeArgs = new CardsDiscardEventArgs(DeckLocation.InPlayAndSetAside, toDiscard);
				mockPlayer.Raise(_ => _.CardsDiscarding += null, cdeArgs);
				var key = Tuple.Create(TypeClass.Horn, TypeClass.Horn);
				Assert.IsFalse(cdeArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Improve_Basic()
		{
			using (var card = new Improve())
			{
				Assert.AreEqual(new Cost(3), card.BaseCost);
				Assert.AreEqual(2, card.Benefit.Currency.Coin.Value);
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
			}
		}
		[TestMethod]
		public void Test_Improve_Play_No_Trash()
		{
			using (Card card = new Improve())
			{
				var movements = new CardMovementCollection
				{
					new CardMovement(card, DeckLocation.InPlay, DeckLocation.Discard)
				};


				card.FollowInstructions(mockPlayer.Object);


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

				// Verify that cleaning-up is not retriggered
				var cdueArgs = new CleanedUpEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.CleanedUp += null, cdueArgs);
				cueArgs.Resolvers.Clear();
				mockPlayer.Raise(_ => _.CleaningUp += null, cueArgs);
				Assert.IsFalse(cueArgs.Resolvers.ContainsKey(TypeClass.Improve));

				mockPlayer.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Never);
				mockPlayer.Verify(_ => _.Trash(It.IsAny<IGameObject>(), It.IsAny<DeckLocation>(), It.IsAny<Card>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Improve_Play_Trash_Itself()
		{
			using (Card card = new Improve())
			{
				var movements = new CardMovementCollection
				{
					new CardMovement(card, DeckLocation.InPlay, DeckLocation.Discard)
				};
				var supplies = new TableEntityCollection
				{
					{ TypeClass.Inventor, mockSupply.Object }
				};
				mockTable.Setup(_ => _.TableEntities).Returns(supplies);
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)))
					.Returns<Choice>(c =>
					{
						var selected = c.Cards.First();
						return new ChoiceResult(new ItemCollection<Card> { selected });
					});
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Supplies)))
					.Returns(new ChoiceResult(mockSupply.Object));


				card.FollowInstructions(mockPlayer.Object);


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

				mockPlayer.Verify(_ => _.Trash(card, It.IsAny<DeckLocation>(), card), Times.Once);
				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, 1, false), Times.Once);
				Assert.IsFalse(movements.Any());
			}
		}
		[TestMethod]
		public void Test_Innovation_Basic()
		{
			using (Project card = new Innovation())
			{
				Assert.AreEqual(Categories.Project, card.Category);
				Assert.AreEqual(new Cost(6), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Innovation_Bought()
		{
			using (Project card = new Innovation())
			{
				mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);
				var turn = new Turn(mockPlayer.Object);
				mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(turn);


				card.Bought(mockPlayer.Object);


				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, new ActingTroupe(), null, DeckLocation.Discard, DeckPosition.Top, false);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				var key = card.ToString();
				Assert.IsTrue(cgeArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Innovation_Card_Gained_Non_Action()
		{
			using (Project card = new Innovation())
			{
				mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);
				var turn = new Turn(mockPlayer.Object);
				mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(turn);


				card.Bought(mockPlayer.Object);


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

				mockPlayer.Verify(_ => _.PlayCardInternal(gainedCard, It.IsAny<DeckLocation>(), It.IsAny<string>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Innovation_Card_Gained_Second_Action()
		{
			using (Project card = new Innovation())
			{
				mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);
				var turn = new Turn(mockPlayer.Object);
				turn.CardsGained.Add(new ActingTroupe());
				mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(turn);


				card.Bought(mockPlayer.Object);


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

				mockPlayer.Verify(_ => _.PlayCardInternal(gainedCard, It.IsAny<DeckLocation>(), It.IsAny<string>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Innovation_Card_Gained_Action()
		{
			using (Project card = new Innovation())
			{
				mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);
				var turn = new Turn(mockPlayer.Object);
				mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(turn);


				card.Bought(mockPlayer.Object);


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

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

				mockPlayer.Verify(_ => _.AddCardInto(DeckLocation.InPlay, gainedCard, It.IsAny<DeckPosition>()), Times.Once);
				mockPlayer.Verify(_ => _.PlayCardInternal(gainedCard, It.IsAny<DeckLocation>(), It.IsAny<string>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Innovation_Card_Gained_Action_Optional()
		{
			using (Project card = new Innovation())
			{
				mockGame.SetupGet(_ => _.ActivePlayer).Returns(mockPlayer.Object);
				var turn = new Turn(mockPlayer.Object);
				mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(turn);


				card.Bought(mockPlayer.Object);


				Card gainedCard = new Experiment();
				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, gainedCard, null, DeckLocation.Discard, DeckPosition.Top, false);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				var key = card.ToString();

				Assert.IsFalse(cgeArgs.Resolvers[key].IsRequired);
			}
		}
		[TestMethod]
		public void Test_Innovation_Teardown()
		{
			using (Project card = new Innovation())
			{
				card.Bought(mockPlayer.Object);

				card.TearDown(mockGame.Object);

				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, new ActingTroupe(), null, DeckLocation.Discard, DeckPosition.Top, false);
				mockPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				var key = card.ToString();
				Assert.IsFalse(cgeArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Improve_Teardown()
		{
			using (Card card = new Improve())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
						mockPlayer.Object,
						mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				var movements = new CardMovementCollection
				{
					new CardMovement(card, DeckLocation.InPlay, DeckLocation.Discard)
				};
				var supplies = new TableEntityCollection
				{
					{ TypeClass.Inventor, mockSupply.Object }
				};
				mockTable.Setup(_ => _.TableEntities).Returns(supplies);
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)))
					.Returns(new ChoiceResult(new ItemCollection<Card> { card }));
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Supplies)))
					.Returns(new ChoiceResult(mockSupply.Object));


				card.FollowInstructions(mockPlayer.Object);



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

				card.TearDown(mockGame.Object);

				cueArgs = new CleaningUpEventArgs(mockPlayer.Object, ref movements);
				mockPlayer.Raise(_ => _.CleaningUp += null, cueArgs);
				Assert.IsFalse(cueArgs.Resolvers.ContainsKey(TypeClass.Improve));
			}
		}
		[TestMethod]
		public void Test_Inventor_Basic()
		{
			using (var card = new Inventor())
			{
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
				Assert.AreEqual(new Cost(4), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Inventor_Play()
		{
			var supplies = new TableEntityCollection
			{
				{ TypeClass.Hideout, mockSupply.Object }
			};
			mockTable.SetupGet(_ => _.TableEntities).Returns(supplies);
			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(mockSupply.Object));


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


				// Trigger cost compute
				var mockCard = new Mock<ICard>();
				var cost = new Cost(5);
				var cceArgs = new CostComputeEventArgs(mockCard.Object, cost);
				mockGame.Raise(_ => _.CostCompute += null, cceArgs);


				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, 1, false), Times.Once);
				Assert.AreEqual(4, cceArgs.Cost.Coin.Value);
			}
		}
		[TestMethod]
		public void Test_Inventor_EndTurn()
		{
			var supplies = new TableEntityCollection
			{
				{ TypeClass.Hideout, mockSupply.Object }
			};
			mockTable.SetupGet(_ => _.TableEntities).Returns(supplies);
			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(mockSupply.Object));


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


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

				// Trigger cost compute
				var mockCard = new Mock<ICard>();
				var cost = new Cost(5);
				var cceArgs = new CostComputeEventArgs(mockCard.Object, cost);
				mockGame.Raise(_ => _.CostCompute += null, cceArgs);

				Assert.AreEqual(5, cceArgs.Cost.Coin.Value);
			}
		}
		[TestMethod]
		public void Test_Inventor_Teardown()
		{
			var supplies = new TableEntityCollection
			{
				{ TypeClass.Hideout, mockSupply.Object }
			};
			mockTable.SetupGet(_ => _.TableEntities).Returns(supplies);
			mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(mockSupply.Object));


			using (Card card = new Inventor())
			{
				card.FollowInstructions(mockPlayer.Object);
				card.TearDown(mockGame.Object);

				// Trigger cost compute
				var mockCard = new Mock<ICard>();
				var cost = new Cost(5);
				var cceArgs = new CostComputeEventArgs(mockCard.Object, cost);
				mockGame.Raise(_ => _.CostCompute += null, cceArgs);

				Assert.AreEqual(5, cceArgs.Cost.Coin.Value);
			}
		}
		[TestMethod]
		public void Test_Key_Basic()
		{
			using (Artifact card = new Key())
			{
				Assert.AreEqual(Categories.Artifact, card.Category);
				Assert.IsFalse(card.CanBeMultiples);
			}
		}
		[TestMethod]
		public void Test_Key_Taken()
		{
			using (Artifact card = new Key())
			{
				card.TakenBy(mockPlayer.Object);


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


				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				var key = card.ToString();
				Assert.IsFalse(tseArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Key_TurnStarted()
		{
			using (Artifact card = new Key())
			{
				card.TakenBy(mockPlayer.Object);


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

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

				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Currency.Coin.Value == 1), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Key_Teardown()
		{
			using (Artifact card = new Key())
			{
				card.TakenBy(mockPlayer.Object);

				card.TearDown(mockGame.Object);

				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				var key = card.ToString();
				Assert.IsFalse(tseArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Lackeys_Basic()
		{
			using (var card = new Lackeys())
			{
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
				Assert.AreEqual(new Cost(2), card.BaseCost);
				Assert.AreEqual(2, card.Benefit.Cards);
			}
		}
		[TestMethod]
		public void Test_Lackeys_Gain()
		{
			Card card = new Lackeys();

			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.Lackeys.ToString()));

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


			mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Villagers == 2), It.IsAny<bool>()), Times.Once);
		}
		[TestMethod]
		public void Test_Lackeys_Play()
		{
			using (Card card = new Lackeys())
			{
				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), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Lackeys_Teardown()
		{
			using (Card card = new Lackeys())
			{
				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.Lackeys.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.Lackeys.ToString()));
			}
		}
		[TestMethod]
		public void Test_Lantern_Basic()
		{
			using (Artifact card = new Lantern())
			{
				Assert.AreEqual(Categories.Artifact, card.Category);
				Assert.IsFalse(card.CanBeMultiples);
			}
		}
		[TestMethod]
		public void Test_Lantern_Taken()
		{
			using (Artifact card = new Lantern())
			{
				card.TakenBy(mockPlayer.Object);


				var cpeArgs = new CardPlayingEventArgs(mockPlayer.Object, new Ducat(), "");
				mockPlayer.Raise(_ => _.CardPlaying += null, cpeArgs);
				// Test ???
			}
		}
		[TestMethod]
		public void Test_Lantern_Returned()
		{
			using (Artifact card = new Lantern())
			{
				card.TakenBy(mockPlayer.Object);
				card.ReturnedBy(mockPlayer.Object);


				var cpeArgs = new CardPlayingEventArgs(mockPlayer.Object, new Ducat(), "");
				mockPlayer.Raise(_ => _.CardPlaying += null, cpeArgs);
				// Test ???
			}
		}
		[TestMethod]
		public void Test_Lantern_Play_BorderGuard()
		{
			using (Artifact card = new Lantern())
			{
				var borderGuard = new BorderGuard();
				var toReveal = new ItemCollection<Card> { new Ducat(), new Spices(), new Scepter() };
				mockPlayer.Setup(_ => _.Draw(It.IsAny<int>(), DeckLocation.Revealed))
					.Returns<int, DeckLocation>((i, dl) => new ItemCollection<Card>(toReveal.Take(i)));
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>()));


				card.TakenBy(mockPlayer.Object);

				var cpeArgs = new CardPlayingEventArgs(mockPlayer.Object, borderGuard, "");
				mockPlayer.Raise(_ => _.CardPlaying += null, cpeArgs);
				borderGuard.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Draw(3, DeckLocation.Revealed), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Lantern_Teardown()
		{
			using (Artifact card = new Lantern())
			{
				var borderGuard = new BorderGuard();
				var toReveal = new ItemCollection<Card> { new Ducat(), new Spices(), new Scepter() };
				var endgame = new PointsCollection(new ItemCollection<Card> { borderGuard });
				mockPlayer.SetupGet(_ => _.EndgamePile).Returns(endgame);
				mockPlayer.Setup(_ => _.RetrieveCardFrom(DeckLocation.InPlay, borderGuard)).Returns(borderGuard);
				mockPlayer.Setup(_ => _.Draw(It.IsAny<int>(), DeckLocation.Revealed))
					.Returns<int, DeckLocation>((i, dl) => new ItemCollection<Card>(toReveal.Take(i)));
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>()));


				card.TakenBy(mockPlayer.Object);

				card.TearDown(mockGame.Object);


				var cpeArgs = new CardPlayingEventArgs(mockPlayer.Object, borderGuard, "");
				mockPlayer.Raise(_ => _.CardPlaying += null, cpeArgs);
				borderGuard.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Draw(3, DeckLocation.Revealed), Times.Never);
			}
		}
		[TestMethod]
		public void Test_MountainVillage_Basic()
		{
			using (var card = new MountainVillage())
			{
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
				Assert.AreEqual(new Cost(4), card.BaseCost);
				Assert.AreEqual(2, card.Benefit.Actions);
			}
		}
		[TestMethod]
		public void Test_MountainVillage_Play_Empty_Discard()
		{
			using (Card card = new MountainVillage())
			{
				var discard = new Deck(DeckLocation.Discard, Visibility.Top, VisibilityTo.All);
				mockPlayer.SetupGet(_ => _.DiscardPile).Returns(discard);


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Never);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards == 1), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_MountainVillage_Play_Draw_From_Discard()
		{
			using (Card card = new MountainVillage())
			{
				var oldWitch = new OldWitch();
				var discard = new Deck(DeckLocation.Discard, Visibility.Top, VisibilityTo.All)
				{
					oldWitch,
					new Ducat(),
					new DominionBase.Cards.Universal.Copper()
				};
				mockPlayer.SetupGet(_ => _.DiscardPile).Returns(discard);
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards && c.ChoiceOutcome == ChoiceOutcome.Select)))
					.Returns<Choice>(c => new ChoiceResult(new ItemCollection<Card> { c.Cards.First() }));


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards == 1), It.IsAny<bool>()), Times.Never);
				mockPlayer.Verify(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards && c.ChoiceOutcome == ChoiceOutcome.Select)), Times.Once);
				mockPlayer.Verify(_ => _.AddCardsToHand(It.Is<IEnumerable<Card>>(ic => ic.Count() == 1 && ic.ElementAt(0) == oldWitch)), Times.Once);
			}
		}
		[TestMethod]
		public void Test_OldWitch_Basic()
		{
			using (var card = new OldWitch())
			{
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Attack, card.Category);
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(3, card.Benefit.Cards);
			}
		}
		[TestMethod]
		public void Test_OldWitch_Play_NoCurseInHand()
		{
			using (Card card = new OldWitch())
			{
				var mockAttackee = new Mock<IPlayer>();
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockAttackee.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockGame.Setup(_ => _.GetPlayersStartingWithEnumerator(mockPlayer.Object)).Returns<IPlayer>(x => { var y = players.GetPlayersStartingWithEnumerator(x); return y; });
				mockTable.SetupGet(_ => _.Curse).Returns(mockSupply.Object);
				mockAttackee.Setup(_ => _.AttackedByPlayerAllowed(mockPlayer.Object, card)).Returns(true);
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				mockAttackee.SetupGet(_ => _.Hand).Returns(hand);
				mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Action);


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


				mockAttackee.Verify(_ => _.Gain(mockSupply.Object, card, 1, false), Times.Once);
				mockAttackee.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Never);
				mockAttackee.Verify(_ => _.RetrieveCardFrom(DeckLocation.Hand, It.IsAny<Card>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_OldWitch_Play_CurseInHand()
		{
			using (Card card = new OldWitch())
			{
				var mockAttackee = new Mock<IPlayer>();
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockAttackee.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockGame.Setup(_ => _.GetPlayersStartingWithEnumerator(mockPlayer.Object)).Returns<IPlayer>(x => { var y = players.GetPlayersStartingWithEnumerator(x); return y; });
				mockTable.SetupGet(_ => _.Curse).Returns(mockSupply.Object);
				mockAttackee.Setup(_ => _.AttackedByPlayerAllowed(mockPlayer.Object, card)).Returns(true);
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner)
				{
					new DominionBase.Cards.Universal.Curse()
				};
				mockAttackee.SetupGet(_ => _.Hand).Returns(hand);
				mockAttackee.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options))).Returns(new ChoiceResult(new List<string> { ResourcesHelper.Get("Yes") }));
				mockAttackee.Setup(_ => _.RetrieveCardFrom(DeckLocation.Hand, DominionBase.Cards.Universal.TypeClass.Curse)).Returns(hand.First());
				mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Action);


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


				mockAttackee.Verify(_ => _.Gain(mockSupply.Object, card, 1, false), Times.Once);
				mockAttackee.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Once);
				mockAttackee.Verify(_ => _.RetrieveCardFrom(DeckLocation.Hand, DominionBase.Cards.Universal.TypeClass.Curse), Times.Once);
				mockAttackee.Verify(_ => _.Trash(card, It.Is<Card>(c => c is DominionBase.Cards.Universal.Curse)), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Pageant_Basic()
		{
			using (Project card = new Pageant())
			{
				Assert.AreEqual(Categories.Project, card.Category);
				Assert.AreEqual(new Cost(3), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Pageant_Bought()
		{
			using (Project card = new Pageant())
			{
				mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Buy);
				mockPlayer.SetupGet(_ => _.Currency).Returns(new Currency(1));


				card.Bought(mockPlayer.Object);


				var pceArgs = new PhaseChangingEventArgs(mockPlayer.Object, PhaseEnum.Night);
				mockPlayer.Raise(_ => _.PhaseChanging += null, pceArgs);
				var key = TypeClass.Pageant;
				Assert.IsTrue(pceArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Pageant_Buy_Phase_Ended_No_Coins()
		{
			using (Project card = new Pageant())
			{
				mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Buy);
				mockPlayer.SetupGet(_ => _.Currency).Returns(new Currency());


				card.Bought(mockPlayer.Object);


				var pceArgs = new PhaseChangingEventArgs(mockPlayer.Object, PhaseEnum.Night);
				mockPlayer.Raise(_ => _.PhaseChanging += null, pceArgs);
				var key = TypeClass.Pageant;
				Assert.IsFalse(pceArgs.Resolvers.ContainsKey(key));

				mockPlayer.Verify(_ => _.SpendCurrency(It.IsAny<Currency>()), Times.Never);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Coffers == 1), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Pageant_Buy_Phase_Ended_No_Resolve()
		{
			using (Project card = new Pageant())
			{
				mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Buy);
				mockPlayer.SetupGet(_ => _.Currency).Returns(new Currency(1));


				card.Bought(mockPlayer.Object);


				var pceArgs = new PhaseChangingEventArgs(mockPlayer.Object, PhaseEnum.Night);
				mockPlayer.Raise(_ => _.PhaseChanging += null, pceArgs);
				var key = TypeClass.Pageant;
				Assert.IsTrue(pceArgs.Resolvers.ContainsKey(key));

				mockPlayer.Verify(_ => _.SpendCurrency(It.IsAny<Currency>()), Times.Never);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Coffers == 1), It.IsAny<bool>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Pageant_Buy_Phase_Ended_Resolve()
		{
			using (Project card = new Pageant())
			using (var toSpend = new Currency(1))
			{
				mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Buy);
				mockPlayer.SetupGet(_ => _.Currency).Returns(new Currency(2));


				card.Bought(mockPlayer.Object);


				var pceArgs = new PhaseChangingEventArgs(mockPlayer.Object, PhaseEnum.Night);
				mockPlayer.Raise(_ => _.PhaseChanging += null, pceArgs);
				var key = TypeClass.Pageant;
				Assert.IsTrue(pceArgs.Resolvers.ContainsKey(key));

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

				mockPlayer.Verify(_ => _.SpendCurrency(toSpend), Times.Once);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Coffers == 1), It.IsAny<bool>()), Times.Once);
				Assert.IsTrue(pceArgs.HandledBy.Contains(TypeClass.Pageant));
			}
		}
		[TestMethod]
		public void Test_Pageant_Buy_Phase_Ended_Resolve_Only_Once()
		{
			using (Project card = new Pageant())
			using (var toSpend = new Currency(1))
			{
				mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Buy);
				mockPlayer.SetupGet(_ => _.Currency).Returns(new Currency(2));


				card.Bought(mockPlayer.Object);


				var pceArgs = new PhaseChangingEventArgs(mockPlayer.Object, PhaseEnum.Night);
				mockPlayer.Raise(_ => _.PhaseChanging += null, pceArgs);
				var key = TypeClass.Pageant;
				Assert.IsTrue(pceArgs.Resolvers.ContainsKey(key));

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

				mockPlayer.Verify(_ => _.SpendCurrency(toSpend), Times.Once);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Coffers == 1), It.IsAny<bool>()), Times.Once);
				Assert.IsTrue(pceArgs.HandledBy.Contains(TypeClass.Pageant));

				var pceArgs2 = new PhaseChangingEventArgs(mockPlayer.Object, PhaseEnum.Night);
				pceArgs2.HandledBy.AddRange(pceArgs.HandledBy);
				mockPlayer.Raise(_ => _.PhaseChanging += null, pceArgs2);
				Assert.IsFalse(pceArgs2.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Pageant_Teardown()
		{
			using (Project card = new Pageant())
			{
				mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Buy);
				mockPlayer.SetupGet(_ => _.Currency).Returns(new Currency());


				card.Bought(mockPlayer.Object);

				card.TearDown(mockGame.Object);

				var pceArgs = new PhaseChangingEventArgs(mockPlayer.Object, PhaseEnum.Night);
				mockPlayer.Raise(_ => _.PhaseChanging += null, pceArgs);
				var key = TypeClass.Pageant;
				Assert.IsFalse(pceArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Patron_Basic()
		{
			using (var card = new Patron())
			{
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Reaction, card.Category);
				Assert.AreEqual(new Cost(4), card.BaseCost);
				Assert.AreEqual(new Currency(2), card.Benefit.Currency);
				Assert.AreEqual(1, card.Benefit.Villagers);
			}
		}
		[TestMethod]
		public void Test_Patron_Play()
		{
			using (var card = new Patron())
			{
				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Villagers == 1 && cb.Currency.Coin.Value == 2), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Patron_Revealed()
		{
			using (var card = new Patron())
			{
				var revealed = new Deck(DeckLocation.Revealed, Visibility.All, VisibilityTo.All);
				mockPlayer.SetupGet(_ => _.Revealed).Returns(revealed);
				mockPlayer.SetupGet(_ => _.DiscardPile).Returns(new Deck(DeckLocation.Discard, Visibility.Top, VisibilityTo.All));
				mockPlayer.SetupGet(_ => _.Private).Returns(new Deck(DeckLocation.Private, Visibility.All, VisibilityTo.Owner));
				card.Owner = mockPlayer.Object;


				revealed.AddRange(mockPlayer.Object, new ItemCollection<Card> { card });


				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Coffers == 1), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Patron_Teardown()
		{
			using (var card = new Patron())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);

				card.TearDown(mockGame.Object);
			}
		}
		[TestMethod]
		public void Test_Piazza_Basic()
		{
			using (Project card = new Piazza())
			{
				Assert.AreEqual(Categories.Project, card.Category);
				Assert.AreEqual(new Cost(5), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Piazza_Bought()
		{
			using (Project card = new Piazza())
			{
				card.Bought(mockPlayer.Object);


				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				var key = card.ToString();
				Assert.IsTrue(tseArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Piazza_TurnStarted_No_Action()
		{
			using (Project card = new Piazza())
			{
				var revealed = new Ducat();
				mockPlayer.Setup(_ => _.Draw(DeckLocation.Revealed)).Returns(revealed);


				card.Bought(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(_ => _.AddCardToDeck(revealed, DeckPosition.Top), Times.Once);
				mockPlayer.Verify(_ => _.RetrieveCardFrom(DeckLocation.Revealed, revealed), Times.Once);
				mockPlayer.Verify(_ => _.PlayCard(revealed, It.IsAny<PlayerMode>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Piazza_TurnStarted_Action()
		{
			using (Project card = new Piazza())
			{
				var revealed = new ActingTroupe();
				mockPlayer.Setup(_ => _.Draw(DeckLocation.Revealed)).Returns(revealed);


				card.Bought(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(_ => _.AddCardToDeck(revealed, DeckPosition.Top), Times.Never);
				mockPlayer.Verify(_ => _.PlayCard(revealed, It.IsAny<PlayerMode>()), Times.Once);
				Assert.IsTrue(tseArgs.HandledBy.Contains(key));
			}
		}
		[TestMethod]
		public void Test_Piazza_TurnStarted_Action_Only_Once()
		{
			using (Project card = new Piazza())
			{
				var revealed = new ActingTroupe();
				mockPlayer.Setup(_ => _.Draw(DeckLocation.Revealed)).Returns(revealed);


				card.Bought(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);

				Assert.IsTrue(tseArgs.HandledBy.Contains(key));

				var tseArgs2 = new TurnStartedEventArgs(mockPlayer.Object);
				tseArgs2.HandledBy.AddRange(tseArgs.HandledBy);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs2);
				Assert.IsFalse(tseArgs2.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Piazza_Teardown()
		{
			using (Project card = new Piazza())
			{
				card.Bought(mockPlayer.Object);

				card.TearDown(mockGame.Object);

				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				var key = card.ToString();
				Assert.IsFalse(tseArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Priest_Basic()
		{
			using (var card = new Priest())
			{
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
				Assert.AreEqual(new Cost(4), card.BaseCost);
				Assert.AreEqual(new Currency(2), card.Benefit.Currency);
			}
		}
		[TestMethod]
		public void Test_Priest_Play_Trash_No_Hand()
		{
			using (Card card = new Priest())
			{
				mockPlayer.SetupGet(_ => _.Hand).Returns(new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner));
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(x => x.ChoiceType == ChoiceType.Cards))).Returns(new ChoiceResult(new ItemCollection<Card>()));
				var currentTurn = new Turn(mockPlayer.Object);
				mockGame.SetupGet(_ => _.CurrentTurn).Returns(currentTurn);


				card.FollowInstructions(mockPlayer.Object);


				var teArgs = new TrashEventArgs(mockPlayer.Object, new Hideout(), new ItemCollection<Card>());
				mockPlayer.Raise(_ => _.Trashed += null, teArgs);
				Assert.IsTrue(teArgs.Resolvers.ContainsKey(TypeClass.Priest));
			}
		}
		[TestMethod]
		public void Test_Priest_Play_Trash_Card()
		{
			using (Card card = new Priest())
			{
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				var cardToTrash = new Ducat();
				hand.Add(cardToTrash);
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(x => x.ChoiceType == ChoiceType.Cards)))
					.Returns<Choice>(c => new ChoiceResult(new ItemCollection<Card> { c.Cards.ElementAt(0) }));
				var currentTurn = new Turn(mockPlayer.Object);
				mockGame.SetupGet(_ => _.CurrentTurn).Returns(currentTurn);


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Trash(card, It.Is<ItemCollection<Card>>(ic => ic.Count == 1 && ic[0] == cardToTrash)), Times.Once);

				var teArgs = new TrashEventArgs(mockPlayer.Object, new Hideout(), new ItemCollection<Card>());
				mockPlayer.Raise(_ => _.Trashed += null, teArgs);
				Assert.IsTrue(teArgs.Resolvers.ContainsKey(TypeClass.Priest));
			}
		}
		[TestMethod]
		public void Test_Priest_Play_Trash_Another()
		{
			using (Card card = new Priest())
			{
				mockPlayer.SetupGet(_ => _.Hand).Returns(new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner));
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(x => x.ChoiceType == ChoiceType.Cards))).Returns(new ChoiceResult(new ItemCollection<Card>()));
				var currentTurn = new Turn(mockPlayer.Object);
				mockGame.SetupGet(_ => _.CurrentTurn).Returns(currentTurn);


				card.FollowInstructions(mockPlayer.Object);


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

				teArgs.Resolvers[TypeClass.Priest].Method(mockPlayer.Object, ref teArgs);

				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Currency.Coin.Value == 2), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Priest_Play_Turn_Ended()
		{
			using (Card card = new Priest())
			{
				mockPlayer.SetupGet(_ => _.Hand).Returns(new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner));
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(x => x.ChoiceType == ChoiceType.Cards))).Returns(new ChoiceResult(new ItemCollection<Card>()));
				var currentTurn = new Turn(mockPlayer.Object);
				mockGame.SetupGet(_ => _.CurrentTurn).Returns(currentTurn);


				card.FollowInstructions(mockPlayer.Object);


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

				// Make sure Trash events no longer trigger
				var teArgs = new TrashEventArgs(mockPlayer.Object, new Hideout(), new ItemCollection<Card>());
				mockPlayer.Raise(_ => _.Trashed += null, teArgs);
				Assert.IsFalse(teArgs.Resolvers.ContainsKey(TypeClass.Priest));
			}
		}
		[TestMethod]
		public void Test_Priest_Teardown()
		{
			using (Card card = new Priest())
			{
				mockPlayer.SetupGet(_ => _.Hand).Returns(new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner));
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(x => x.ChoiceType == ChoiceType.Cards))).Returns(new ChoiceResult(new ItemCollection<Card>()));
				var currentTurn = new Turn(mockPlayer.Object);
				mockGame.SetupGet(_ => _.CurrentTurn).Returns(currentTurn);
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);


				card.FollowInstructions(mockPlayer.Object);


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


				var teArgs = new TrashEventArgs(mockPlayer.Object, new Hideout(), new ItemCollection<Card>());
				mockPlayer.Raise(_ => _.Trashed += null, teArgs);
				Assert.IsFalse(teArgs.Resolvers.ContainsKey(TypeClass.Priest));
			}
		}
		[TestMethod]
		public void Test_Recruiter_Basic()
		{
			using (var card = new Recruiter())
			{
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(2, card.Benefit.Cards);
			}
		}
		[TestMethod]
		public void Test_Recruiter_Play_Trash_Card()
		{
			using (Card card = new Recruiter())
			{
				var toTrash = new Lackeys();
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner)
				{
					toTrash
				};
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card> { toTrash }));
				mockPlayer.Setup(_ => _.RetrieveCardFrom(DeckLocation.Hand, toTrash)).Returns(toTrash);


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Trash(card, toTrash), Times.Once);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.AtLeast(2));
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Villagers == 2), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Recruiter_Play_No_Hand()
		{
			using (Card card = new Recruiter())
			{
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>()));


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Trash(It.IsAny<IGameObject>(), It.IsAny<Card>()), Times.Never);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Research_Basic()
		{
			using (var card = new Research())
			{
				Assert.AreEqual(new Cost(4), card.BaseCost);
				Assert.AreEqual(1, card.Benefit.Actions);
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Duration, card.Category);
			}
		}
		[TestMethod]
		public void Test_Research_Play_No_Trash()
		{
			using (Card card = new Research())
			{
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>()));


				card.FollowInstructions(mockPlayer.Object);


				Assert.IsTrue(card.CanCleanUp);
				Assert.IsTrue(card.IsStackable);
				mockPlayer.Verify(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)), Times.Once);
				mockPlayer.Verify(_ => _.Trash(It.IsAny<IGameObject>(), It.IsAny<Card>()), Times.Never);

				// Teardown at the end (Make sure event listener isn't listening)
				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.IsFalse(tseArgs.Resolvers.ContainsKey(card.Name));
			}
		}
		[TestMethod]
		public void Test_Research_Play_Trash_Zero_Cost()
		{
			using (Card card = new Research())
			{
				var toTrash = new DominionBase.Cards.Universal.Copper();
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner)
				{
					toTrash
				};
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card> { toTrash }));
				mockPlayer.Setup(_ => _.RetrieveCardFrom(DeckLocation.Hand, toTrash)).Returns(toTrash);
				// This is going to need to be changed once the issue with "Draw" vs. "Set Aside"
				mockPlayer.Setup(_ => _.Draw(It.IsAny<int>(), DeckLocation.Private)).Returns<int, DeckLocation>((c, dl) =>
				{
					var r = new ItemCollection<Card>();
					for (var i = 0; i < c; i++)
						r.Add(new Ducat());
					return r;
				});
				mockPlayer.Setup(_ => _.RetrieveCardsFrom(DeckLocation.Private)).Returns(new ItemCollection<Card>());


				card.FollowInstructions(mockPlayer.Object);


				Assert.IsTrue(card.CanCleanUp);
				Assert.IsTrue(card.IsStackable);
				mockPlayer.Verify(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)), Times.Once);
				mockPlayer.Verify(_ => _.Trash(card, It.IsAny<Card>()), Times.Once);
				mockPlayer.Verify(_ => _.Trash(card, toTrash), 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_Research_Play_Trash_Lackeys()
		{
			using (Card card = new Research())
			{
				var toTrash = new Lackeys();
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner)
				{
					toTrash
				};
				var inPrivate = new ItemCollection<Card>();
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card> { toTrash }));
				mockPlayer.Setup(_ => _.RetrieveCardFrom(DeckLocation.Hand, toTrash)).Returns(toTrash);
				// This is going to need to be changed once the issue with "Draw" vs. "Set Aside"
				mockPlayer.Setup(_ => _.Draw(It.IsAny<int>(), DeckLocation.Private)).Returns<int, DeckLocation>((c, dl) =>
				{
					for (var i = 0; i < c; i++)
						inPrivate.Add(new Ducat());
					return inPrivate;
				});
				mockPlayer.Setup(_ => _.RetrieveCardsFrom(DeckLocation.Private)).Returns(inPrivate);


				card.FollowInstructions(mockPlayer.Object);


				Assert.IsFalse(card.CanCleanUp);
				Assert.IsFalse(card.IsStackable);
				Assert.AreEqual(3, card.Stack().Count);
				mockPlayer.Verify(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)), Times.Once);
				mockPlayer.Verify(_ => _.Trash(card, It.IsAny<Card>()), Times.Once);
				mockPlayer.Verify(_ => _.Trash(card, toTrash), Times.Once);

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

				tseArgs.Resolvers[card.Name].Method(mockPlayer.Object, ref tseArgs);
				//mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Currency.Coin == 3), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Research_Teardown()
		{
			using (Card card = new Research())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);

				var toTrash = new Lackeys();
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner)
				{
					toTrash
				};
				var inPrivate = new ItemCollection<Card>();
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card> { toTrash }));
				mockPlayer.Setup(_ => _.RetrieveCardFrom(DeckLocation.Hand, toTrash)).Returns(toTrash);
				// This is going to need to be changed once the issue with "Draw" vs. "Set Aside"
				mockPlayer.Setup(_ => _.Draw(It.IsAny<int>(), DeckLocation.Private)).Returns<int, DeckLocation>((c, dl) =>
				{
					for (var i = 0; i < c; i++)
						inPrivate.Add(new Ducat());
					return inPrivate;
				});
				mockPlayer.Setup(_ => _.RetrieveCardsFrom(DeckLocation.Private)).Returns(inPrivate);


				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_RoadNetwork_Basic()
		{
			using (Project card = new RoadNetwork())
			{
				Assert.AreEqual(Categories.Project, card.Category);
				Assert.AreEqual(new Cost(5), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_RoadNetwork_Bought()
		{
			using (Project card = new RoadNetwork())
			{
				var mockOtherPlayer = new Mock<IPlayer>();
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockOtherPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockGame.Setup(_ => _.GetPlayersStartingWithEnumerator(mockPlayer.Object)).Returns<IPlayer>(x => { var y = players.GetPlayersStartingWithEnumerator(x); return y; });


				card.Bought(mockPlayer.Object);


				// Tests to run? ???
			}
		}
		[TestMethod]
		public void Test_RoadNetwork_Card_Gained_Non_Victory()
		{
			using (Project card = new RoadNetwork())
			{
				var mockOtherPlayer = new Mock<IPlayer>();
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockOtherPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockGame.Setup(_ => _.GetPlayersStartingWithEnumerator(mockPlayer.Object)).Returns<IPlayer>(x => { var y = players.GetPlayersStartingWithEnumerator(x); return y; });


				card.Bought(mockPlayer.Object);


				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, new DominionBase.Cards.Universal.Copper(), null, DeckLocation.Discard, DeckPosition.Top, false);
				mockOtherPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				var key = card.ToString();
				Assert.IsFalse(cgeArgs.Resolvers.ContainsKey(key));

				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_RoadNetwork_Card_Gained_Victory()
		{
			using (Project card = new RoadNetwork())
			{
				var mockOtherPlayer = new Mock<IPlayer>();
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockOtherPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockGame.Setup(_ => _.GetPlayersStartingWithEnumerator(mockPlayer.Object)).Returns<IPlayer>(x => { var y = players.GetPlayersStartingWithEnumerator(x); return y; });


				card.Bought(mockPlayer.Object);


				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, new DominionBase.Cards.Universal.Estate(), null, DeckLocation.Discard, DeckPosition.Top, false);
				mockOtherPlayer.Raise(_ => _.CardGained += null, cgeArgs);

				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);
			}
		}
		[TestMethod]
		public void Test_RoadNetwork_Teardown()
		{
			using (Project card = new RoadNetwork())
			{
				var mockOtherPlayer = new Mock<IPlayer>();
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockOtherPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockGame.Setup(_ => _.GetPlayersStartingWithEnumerator(mockPlayer.Object)).Returns<IPlayer>(x => { var y = players.GetPlayersStartingWithEnumerator(x); return y; });


				card.Bought(mockPlayer.Object);

				card.TearDown(mockGame.Object);

				var cgeArgs = new DominionBase.Players.CardGainEventArgs(mockGame.Object, new DominionBase.Cards.Universal.Estate(), null, DeckLocation.Discard, DeckPosition.Top, false);
				mockOtherPlayer.Raise(_ => _.CardGained += null, cgeArgs);
				var key = card.ToString();
				Assert.IsFalse(cgeArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Scepter_Basic()
		{
			using (var card = new Scepter())
			{
				Assert.AreEqual(Categories.Card | Categories.Treasure, card.Category);
				Assert.AreEqual(new Cost(5), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Scepter_Play_Coins()
		{
			using (var card = new Scepter())
			{
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new List<string> { "+<coin>2</coin>" }));


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Currency.Coin.Value == 2), It.IsAny<bool>()), Times.Once);
				Assert.IsTrue(card.CanCleanUp);
			}
		}
		[TestMethod]
		public void Test_Scepter_Play_No_Action_To_Replay()
		{
			using (var card = new Scepter())
			{

				var ipasa = new DeckCollection();
				mockPlayer.SetupGet(_ => _.InPlayAndSetAside).Returns(ipasa);
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options))).Returns(new ChoiceResult(new List<string> { "Replay an Action card you played this turn that's still in play" }));
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards))).Returns(new ChoiceResult(new ItemCollection<Card>()));


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.ReceiveBenefit(It.IsAny<ICardBase>(), It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Once);
				mockPlayer.Verify(_ => _.PlayCard(It.IsAny<Card>(), It.IsAny<PlayerMode>()), Times.Never);
				Assert.IsTrue(card.CanCleanUp);
			}
		}
		[TestMethod]
		public void Test_Scepter_Play_Normal_Action()
		{
			var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
			var cardInPlay = new Lackeys();
			inPlay.Add(cardInPlay);
			var ipasa = new DeckCollection(inPlay);
			var turn = new Turn(mockPlayer.Object);
			turn.CardsPlayed.Add(cardInPlay);
			mockPlayer.SetupGet(_ => _.InPlayAndSetAside).Returns(ipasa);
			mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(turn);
			mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options))).Returns(new ChoiceResult(new List<string> { "Replay an Action card you played this turn that's still in play" }));
			mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)))
				.Returns<Choice>(c =>
				{
					var selected = c.Cards.FirstOrDefault();
					return new ChoiceResult(new ItemCollection<Card> { selected });
				});

			using (var card = new Scepter())
			{
				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.ReceiveBenefit(It.IsAny<ICardBase>(), It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Once);
				mockPlayer.Verify(_ => _.PlayCard(cardInPlay, It.IsAny<PlayerMode>()), Times.Once);
				Assert.IsTrue(card.CanCleanUp);
			}
		}
		[TestMethod]
		public void Test_Scepter_Play_Duration()
		{
			var inPlay = new Deck(DeckLocation.InPlay, Visibility.All, VisibilityTo.All);
			var cardInPlay = new DominionBase.Cards.Seaside.MerchantShip();
			inPlay.Add(cardInPlay);
			var ipasa = new DeckCollection(inPlay);
			var turn = new Turn(mockPlayer.Object);
			turn.CardsPlayed.Add(cardInPlay);
			mockPlayer.SetupGet(_ => _.InPlayAndSetAside).Returns(ipasa);
			mockPlayer.SetupGet(_ => _.CurrentTurn).Returns(turn);
			mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options))).Returns(new ChoiceResult(new List<string> { "Replay an Action card you played this turn that's still in play" }));
			mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)))
				.Returns<Choice>(c =>
				{
					var selected = c.Cards.FirstOrDefault();
					return new ChoiceResult(new ItemCollection<Card> { selected });
				});
			mockPlayer.Setup(_ => _.PlayCard(cardInPlay, It.IsAny<PlayerMode>())).Callback<Card, PlayerMode>((c, pm) =>
			{
				c.FollowInstructions(mockPlayer.Object);
			});

			using (var card = new Scepter())
			{
				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Once);
				mockPlayer.Verify(_ => _.ReceiveBenefit(cardInPlay, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Once);
				mockPlayer.Verify(_ => _.PlayCard(cardInPlay, It.IsAny<PlayerMode>()), Times.Once);
				Assert.IsFalse(card.CanCleanUp);
				Assert.IsTrue(cardInPlay.ChainedInto.Contains(card));


				// Next turn duration
				card.ResolveDuration(mockPlayer.Object);
				mockPlayer.Verify(_ => _.ReceiveBenefit(cardInPlay, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Exactly(2));
			}
		}
		[TestMethod]
		public void Test_Scholar_Basic()
		{
			using (var card = new Scholar())
			{
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(7, card.Benefit.Cards);
			}
		}
		[TestMethod]
		public void Test_Scholar_Play()
		{
			using (Card card = new Scholar())
			{
				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.DiscardHand(It.IsAny<bool>()), Times.Once);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards == 7), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Sculptor_Basic()
		{
			using (var card = new Sculptor())
			{
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
				Assert.AreEqual(new Cost(5), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Sculptor_Play_Gain_Action()
		{
			using (Card card = new Sculptor())
			{
				mockTable.SetupGet(_ => _.TableEntities).Returns(new TableEntityCollection());
				mockSupply.SetupGet(_ => _.TopCard).Returns(new Lackeys());
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Supplies))).Returns(new ChoiceResult(mockSupply.Object));
				mockPlayer.Setup(_ => _.Gain(It.IsAny<ISupply>(), It.IsAny<IGameObject>(), It.IsAny<DeckLocation>(), It.IsAny<DeckPosition>(), It.IsAny<int>(), It.IsAny<bool>())).Returns(true);


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, DeckLocation.Hand, DeckPosition.Automatic, 1, false), Times.Once);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Sculptor_Play_Gain_Treasure()
		{
			using (Card card = new Sculptor())
			{
				mockTable.SetupGet(_ => _.TableEntities).Returns(new TableEntityCollection());
				mockSupply.SetupGet(_ => _.TopCard).Returns(new Ducat());
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Supplies))).Returns(new ChoiceResult(mockSupply.Object));
				mockPlayer.Setup(_ => _.Gain(It.IsAny<ISupply>(), It.IsAny<IGameObject>(), It.IsAny<DeckLocation>(), It.IsAny<DeckPosition>(), It.IsAny<int>(), It.IsAny<bool>())).Returns(true);


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(mockSupply.Object, card, DeckLocation.Hand, DeckPosition.Automatic, 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.Villagers == 1), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Seer_Basic()
		{
			using (var card = new Seer())
			{
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(1, card.Benefit.Cards);
				Assert.AreEqual(1, card.Benefit.Actions);
			}
		}
		[TestMethod]
		public void Test_Seer_Play_No_Cards()
		{
			using (Card card = new Seer())
			{
				var revealed = new Deck(DeckLocation.Revealed, Visibility.All, VisibilityTo.All);
				mockPlayer.SetupGet(_ => _.Revealed).Returns(revealed);
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards && c.ChoiceOutcome == ChoiceOutcome.Select)))
					.Returns(new ChoiceResult(new ItemCollection<Card>()));


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.RetrieveCardsFrom(DeckLocation.Revealed, It.IsAny<ItemCollection<Card>>()), Times.Once);
				mockPlayer.Verify(_ => _.AddCardsToDeck(It.IsAny<ItemCollection<Card>>(), DeckPosition.Top), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Seer_Play_Cost_Check()
		{
			using (Card card = new Seer())
			{
				var revealed = new Deck(DeckLocation.Revealed, Visibility.All, VisibilityTo.All);
				var ducat = new Ducat();
				var oldwitch = new OldWitch();
				var hideout = new Hideout();
				revealed.Add(ducat);
				revealed.Add(oldwitch);
				revealed.Add(hideout);
				mockPlayer.SetupGet(_ => _.Revealed).Returns(revealed);
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards && c.ChoiceOutcome == ChoiceOutcome.Select)))
					.Returns<Choice>(c => new ChoiceResult(new ItemCollection<Card>(c.Cards)));
				mockPlayer.Setup(_ => _.RetrieveCardsFrom(DeckLocation.Revealed, It.IsAny<Predicate<Card>>(), It.IsAny<int>()))
					.Returns<DeckLocation, Predicate<Card>, int>((dl, pc, i) => new ItemCollection<Card>(revealed.Retrieve(mockPlayer.Object, pc)));


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.RetrieveCardsFrom(DeckLocation.Revealed, It.IsAny<Predicate<Card>>(), It.IsAny<int>()), Times.Once);
				mockPlayer.Verify(_ => _.AddCardsToHand(It.Is<IEnumerable<Card>>(ic => ic.Count() == 2 && ic.Contains(ducat) && ic.Contains(hideout))), Times.Once);
				mockPlayer.Verify(_ => _.RetrieveCardsFrom(DeckLocation.Revealed, It.Is<ItemCollection<Card>>(ic => ic.Count == 1 && ic[0] == oldwitch)), Times.Once);
				mockPlayer.Verify(_ => _.AddCardsToDeck(It.Is<ItemCollection<Card>>(ic => ic.Count == 1 && ic[0] == oldwitch), DeckPosition.Top), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Sewers_Basic()
		{
			using (Project card = new Sewers())
			{
				Assert.AreEqual(Categories.Project, card.Category);
				Assert.AreEqual(new Cost(3), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Sewers_Bought()
		{
			using (Project card = new Sewers())
			{
				card.Bought(mockPlayer.Object);


				var teArgs = new TrashEventArgs(mockPlayer.Object, new Cathedral(), new ItemCollection<Card>());
				mockPlayer.Raise(_ => _.Trashed += null, teArgs);
				var key = TypeClass.Sewers;
				Assert.IsTrue(teArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Sewers_Trashed_Cards_No_Trash()
		{
			using (Project card = new Sewers())
			{
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>()));


				card.Bought(mockPlayer.Object);


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

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

				mockPlayer.Verify(_ => _.Trash(It.IsAny<IGameObject>(), It.IsAny<Card>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Sewers_Trashed_Trash_Card()
		{
			using (Project card = new Sewers())
			{
				var toTrash = new Seer();
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card> { toTrash }));
				mockPlayer.Setup(_ => _.RetrieveCardFrom(DeckLocation.Hand, toTrash)).Returns(toTrash);


				card.Bought(mockPlayer.Object);


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

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

				mockPlayer.Verify(_ => _.Trash(card, toTrash), Times.Once);
				Assert.IsTrue(teArgs.HandledBy.Contains(TypeClass.Sewers));
			}
		}
		[TestMethod]
		public void Test_Sewers_Avoid_Trash_Chain()
		{
			using (Project card = new Sewers())
			{
				card.Bought(mockPlayer.Object);


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

				// Make sure it doesn't ever trigger itself
				teArgs = new TrashEventArgs(mockPlayer.Object, card, new ItemCollection<Card>());
				mockPlayer.Raise(_ => _.Trashed += null, teArgs);
				Assert.IsFalse(teArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Sewers_Teardown()
		{
			using (Project card = new Sewers())
			{
				card.Bought(mockPlayer.Object);

				card.TearDown(mockGame.Object);

				var teArgs = new TrashEventArgs(mockPlayer.Object, new Cathedral(), new ItemCollection<Card>());
				mockPlayer.Raise(_ => _.Trashed += null, teArgs);
				var key = TypeClass.Sewers;
				Assert.IsFalse(teArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_SilkMerchant_Basic()
		{
			using (var card = new SilkMerchant())
			{
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
				Assert.AreEqual(new Cost(4), card.BaseCost);
				Assert.AreEqual(2, card.Benefit.Cards);
				Assert.AreEqual(1, card.Benefit.Buys);
			}
		}
		[TestMethod]
		public void Test_SilkMerchant_Gain()
		{
			using (Card card = new SilkMerchant())
			{

				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.SilkMerchant.ToString()));

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


				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Coffers == 1 && cb.Villagers == 1), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_SilkMerchant_Trash()
		{
			using (Card card = new SilkMerchant())
			{
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockPlayer.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);


				card.SetupCard(mockGame.Object);


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

				teArgs.Resolvers[TypeClass.SilkMerchant].Method(mockPlayer.Object, ref teArgs);


				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Coffers == 1 && cb.Villagers == 1), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_SilkMerchant_Play()
		{
			using (Card card = new SilkMerchant())
			{
				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.Buys == 1), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_SilkMerchant_Teardown()
		{
			using (Card card = new SilkMerchant())
			{

				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.SilkMerchant.ToString()));
				var teArgs = new TrashEventArgs(mockPlayer.Object, new Hideout(), new ItemCollection<Card> { card });
				mockPlayer.Raise(_ => _.Trashed += null, teArgs);
				Assert.IsTrue(teArgs.Resolvers.ContainsKey(TypeClass.SilkMerchant));


				// 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.SilkMerchant.ToString()));
				teArgs = new TrashEventArgs(mockPlayer.Object, new Hideout(), new ItemCollection<Card> { card });
				mockPlayer.Raise(_ => _.Trashed += null, teArgs);
				Assert.IsFalse(teArgs.Resolvers.ContainsKey(TypeClass.SilkMerchant));
			}
		}
		[TestMethod]
		public void Test_Silos_Basic()
		{
			using (Project card = new Silos())
			{
				Assert.AreEqual(Categories.Project, card.Category);
				Assert.AreEqual(new Cost(4), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_Silos_Bought()
		{
			using (Project card = new Silos())
			{
				var copper = new DominionBase.Cards.Universal.Copper();
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				hand.AddRange(mockPlayer.Object, new ItemCollection<Card> { copper });
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);


				card.Bought(mockPlayer.Object);


				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				var key = card.ToString();
				Assert.IsTrue(tseArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Silos_TurnStarted_No_Coppers()
		{
			using (Project card = new Silos())
			{
				mockPlayer.SetupGet(_ => _.Hand).Returns(new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner));
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>()));


				card.Bought(mockPlayer.Object);


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

				mockPlayer.Verify(_ => _.Discard(DeckLocation.Hand, It.IsAny<IEnumerable<Card>>(), It.IsAny<CardsDiscardResolver>()), Times.Never);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Silos_TurnStarted_Coppers_No_Discard()
		{
			using (Project card = new Silos())
			{
				var copper1 = new DominionBase.Cards.Universal.Copper();
				var copper2 = new DominionBase.Cards.Universal.Copper();
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				hand.AddRange(mockPlayer.Object, new ItemCollection<Card> { copper1, copper2 });
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>()));


				card.Bought(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(_ => _.Discard(DeckLocation.Hand, It.IsAny<IEnumerable<Card>>(), It.IsAny<CardsDiscardResolver>()), Times.Never);
				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Silos_TurnStarted_Coppers_Discard_All()
		{
			using (Project card = new Silos())
			{
				var copper1 = new DominionBase.Cards.Universal.Copper();
				var copper2 = new DominionBase.Cards.Universal.Copper();
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				hand.AddRange(mockPlayer.Object, new ItemCollection<Card> { copper1, copper2 });
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card> { copper1, copper2 }));


				card.Bought(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(_ => _.Discard(DeckLocation.Hand, It.Is<IEnumerable<Card>>(ic => ic.Count() == 2 && ic.ElementAt(0) == copper1 && ic.ElementAt(1) == copper2), It.IsAny<CardsDiscardResolver>()), Times.Once);
				mockPlayer.Verify(_ => _.DrawHand(2), Times.Once);
				Assert.IsTrue(tseArgs.HandledBy.Contains(key));
			}
		}
		[TestMethod]
		public void Test_Silos_TurnStarted_Coppers_Only_Once()
		{
			using (Project card = new Silos())
			{
				var copper1 = new DominionBase.Cards.Universal.Copper();
				var copper2 = new DominionBase.Cards.Universal.Copper();
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				hand.AddRange(mockPlayer.Object, new ItemCollection<Card> { copper1, copper2 });
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card> { copper1, copper2 }));


				card.Bought(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(_ => _.Discard(DeckLocation.Hand, It.Is<IEnumerable<Card>>(ic => ic.Count() == 2 && ic.ElementAt(0) == copper1 && ic.ElementAt(1) == copper2), It.IsAny<CardsDiscardResolver>()), Times.Once);
				mockPlayer.Verify(_ => _.DrawHand(2), Times.Once);
				Assert.IsTrue(tseArgs.HandledBy.Contains(key));

				var tseArgs2 = new TurnStartedEventArgs(mockPlayer.Object);
				tseArgs2.HandledBy.AddRange(tseArgs.HandledBy);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs2);
				Assert.IsFalse(tseArgs2.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Silos_Teardown()
		{
			using (Project card = new Silos())
			{
				var copper = new DominionBase.Cards.Universal.Copper();
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				hand.AddRange(mockPlayer.Object, new ItemCollection<Card> { copper });
				mockPlayer.SetupGet(_ => _.Hand).Returns(hand);


				card.Bought(mockPlayer.Object);

				card.TearDown(mockGame.Object);

				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				var key = card.ToString();
				Assert.IsFalse(tseArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_SinisterPlot_Basic()
		{
			using (Project card = new SinisterPlot())
			{
				Assert.AreEqual(Categories.Project, card.Category);
				Assert.AreEqual(new Cost(4), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_SinisterPlot_Bought()
		{
			using (Project card = new SinisterPlot())
			{
				card.Bought(mockPlayer.Object);


				var sinisterPlotMarker = card.Tokens.OfType<SinisterPlotMarker>().FirstOrDefault(spm => spm.Owner == mockPlayer.Object);
				Assert.AreEqual(0, sinisterPlotMarker.TokenCount);

				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				var key = card.ToString();
				Assert.IsTrue(tseArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_SinisterPlot_TurnStarted_Add_Token()
		{
			using (Project card = new SinisterPlot())
			{
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns<Choice>(c => new ChoiceResult(new OptionCollection { c.Options[0] }));


				card.Bought(mockPlayer.Object);


				var sinisterPlotMarker = card.Tokens.OfType<SinisterPlotMarker>().FirstOrDefault(spm => spm.Owner == 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.IsAny<CardBenefit>(), It.IsAny<bool>()), Times.Once);
				Assert.AreEqual(1, sinisterPlotMarker.TokenCount);
			}
		}
		[TestMethod]
		public void Test_SinisterPlot_TurnStarted_Draw_Cards()
		{
			using (Project card = new SinisterPlot())
			{
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns<Choice>(c => new ChoiceResult(new OptionCollection { c.Options[1] }));


				card.Bought(mockPlayer.Object);


				var sinisterPlotMarker = card.Tokens.OfType<SinisterPlotMarker>().FirstOrDefault(spm => spm.Owner == mockPlayer.Object);
				sinisterPlotMarker.TokenCount += 2;

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

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

				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Cards == 2), It.IsAny<bool>()), Times.Once);
				Assert.AreEqual(0, sinisterPlotMarker.TokenCount);
			}
		}
		[TestMethod]
		public void Test_SinisterPlot_Teardown()
		{
			using (Project card = new SinisterPlot())
			{
				card.Bought(mockPlayer.Object);

				card.TearDown(mockGame.Object);

				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				var key = card.ToString();
				Assert.IsFalse(tseArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Spices_Basic()
		{
			using (var card = new Spices())
			{
				Assert.AreEqual(Categories.Card | Categories.Treasure, card.Category);
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(new Currency(2), card.Benefit.Currency);
				Assert.AreEqual(1, card.Benefit.Buys);
			}
		}
		[TestMethod]
		public void Test_Spices_Gain()
		{
			using (Card card = new Spices())
			{
				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.Spices.ToString()));

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


				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Coffers == 2), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Spices_Play()
		{
			using (Card card = new Spices())
			{
				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.Currency.Coin.Value == 2 && cb.Buys == 1), It.IsAny<bool>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Spices_Teardown()
		{
			using (Card card = new Spices())
			{
				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.Spices.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.Spices.ToString()));
			}
		}
		[TestMethod]
		public void Test_StarChart_Basic()
		{
			using (Project card = new StarChart())
			{
				Assert.AreEqual(Categories.Project, card.Category);
				Assert.AreEqual(new Cost(3), card.BaseCost);
			}
		}
		[TestMethod]
		public void Test_StarChart_Bought()
		{
			using (Project card = new StarChart())
			{
				card.Bought(mockPlayer.Object);


				var seArgs = new ShuffleEventArgs(mockPlayer.Object, new ItemCollection<IDisplayable>());
				mockPlayer.Raise(_ => _.Shuffling += null, seArgs);
				var key = TypeClass.StarChart;
				Assert.IsTrue(seArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_StarChart_Shuffle_Card_Selected()
		{
			using (Project card = new StarChart())
			{
				var cardToTop = new ActingTroupe();
				var cardsToShuffle = new ItemCollection<IDisplayable>
				{
					new Hideout(),
					new Ducat(),
					cardToTop,
					new Priest(),
					new DominionBase.Cards.Universal.Copper()
				};
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card> { cardToTop }));


				card.Bought(mockPlayer.Object);


				var seArgs = new ShuffleEventArgs(mockPlayer.Object, cardsToShuffle);
				mockPlayer.Raise(_ => _.Shuffling += null, seArgs);
				var key = TypeClass.StarChart;
				Assert.IsTrue(seArgs.Resolvers.ContainsKey(key));

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

				mockPlayer.Verify(_ => _.AddCardInto(DeckLocation.Deck, cardToTop, DeckPosition.Bottom), Times.Once);
				Assert.IsTrue(seArgs.HandledBy.Contains(key));
				Assert.AreEqual(4, seArgs.ShuffleCards.Count);
				Assert.IsFalse(seArgs.ShuffleCards.Contains(cardToTop));
			}
		}
		[TestMethod]
		public void Test_StarChart_Shuffle_No_Card_Selected()
		{
			using (Project card = new StarChart())
			{
				var cardToTop = new ActingTroupe();
				var cardsToShuffle = new ItemCollection<IDisplayable>
				{
					new Hideout(),
					new Ducat(),
					cardToTop,
					new Priest(),
					new DominionBase.Cards.Universal.Copper()
				};
				mockPlayer.Setup(_ => _.MakeChoice(It.IsAny<Choice>())).Returns(new ChoiceResult(new ItemCollection<Card>()));


				card.Bought(mockPlayer.Object);


				var seArgs = new ShuffleEventArgs(mockPlayer.Object, cardsToShuffle);
				mockPlayer.Raise(_ => _.Shuffling += null, seArgs);
				var key = TypeClass.StarChart;
				Assert.IsTrue(seArgs.Resolvers.ContainsKey(key));

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

				mockPlayer.Verify(_ => _.AddCardInto(DeckLocation.Deck, cardToTop, DeckPosition.Bottom), Times.Never);
				Assert.IsTrue(seArgs.HandledBy.Contains(key));
				Assert.AreEqual(5, seArgs.ShuffleCards.Count);
				Assert.IsTrue(seArgs.ShuffleCards.Contains(cardToTop));
			}
		}
		[TestMethod]
		public void Test_StarChart_Teardown()
		{
			using (Project card = new StarChart())
			{
				card.Bought(mockPlayer.Object);

				card.TearDown(mockGame.Object);

				var seArgs = new ShuffleEventArgs(mockPlayer.Object, new ItemCollection<IDisplayable>());
				mockPlayer.Raise(_ => _.Shuffling += null, seArgs);
				var key = TypeClass.StarChart;
				Assert.IsFalse(seArgs.Resolvers.ContainsKey(key));
			}
		}
		[TestMethod]
		public void Test_Swashbuckler_Basic()
		{
			using (var card = new Swashbuckler())
			{
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(3, card.Benefit.Cards);
			}
		}
		[TestMethod]
		public void Test_Swashbuckler_Play_No_Discard_Pile_No_Coffers()
		{
			using (Card card = new Swashbuckler())
			{
				var discardPile = new Deck(DeckLocation.Discard, Visibility.Top, VisibilityTo.All);
				mockPlayer.SetupGet(_ => _.DiscardPile).Returns(discardPile);
				mockPlayer.SetupGet(_ => _.Coffers).Returns(0);


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.ReceiveBenefit(It.IsAny<ICard>(), It.Is<CardBenefit>(cb => cb.Coffers == 1), It.IsAny<bool>()), Times.Never);
				mockPlayer.Verify(_ => _.Take(It.Is<Type>(t => t == TypeClass.TreasureChest)), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Swashbuckler_Play_No_Discard_Pile_Four_Coffers()
		{
			using (Card card = new Swashbuckler())
			{

				var discardPile = new Deck(DeckLocation.Discard, Visibility.Top, VisibilityTo.All);
				mockPlayer.SetupGet(_ => _.DiscardPile).Returns(discardPile);
				mockPlayer.SetupGet(_ => _.Coffers).Returns(4);


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.ReceiveBenefit(It.IsAny<ICard>(), It.Is<CardBenefit>(cb => cb.Coffers == 1), It.IsAny<bool>()), Times.Never);
				mockPlayer.Verify(_ => _.Take(It.Is<Type>(t => t == TypeClass.TreasureChest)), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Swashbuckler_Play_Discard_Pile_One_Coffers()
		{
			using (Card card = new Swashbuckler())
			{

				var discardPile = new Deck(DeckLocation.Discard, Visibility.Top, VisibilityTo.All);
				discardPile.AddRange(mockPlayer.Object, new ItemCollection<Card> { new Inventor() });
				mockPlayer.SetupGet(_ => _.DiscardPile).Returns(discardPile);
				mockPlayer.SetupGet(_ => _.Coffers).Returns(1);


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Coffers == 1), It.IsAny<bool>()), Times.Once);
				mockPlayer.Verify(_ => _.Take(It.Is<Type>(t => t == TypeClass.TreasureChest)), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Swashbuckler_Play_Discard_Pile_Four_Coffers()
		{
			using (Card card = new Swashbuckler())
			{

				var discardPile = new Deck(DeckLocation.Discard, Visibility.Top, VisibilityTo.All);
				discardPile.AddRange(mockPlayer.Object, new ItemCollection<Card> { new Inventor() });
				mockPlayer.SetupGet(_ => _.DiscardPile).Returns(discardPile);
				mockPlayer.SetupGet(_ => _.Coffers).Returns(4);


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.ReceiveBenefit(card, It.Is<CardBenefit>(cb => cb.Coffers == 1), It.IsAny<bool>()), Times.Once);
				mockPlayer.Verify(_ => _.Take(It.Is<Type>(t => t == TypeClass.TreasureChest)), Times.Once);
			}
		}
		[TestMethod]
		public void Test_TreasureChest_Basic()
		{
			using (Artifact card = new TreasureChest())
			{
				Assert.AreEqual(Categories.Artifact, card.Category);
				Assert.IsFalse(card.CanBeMultiples);
			}
		}
		[TestMethod]
		public void Test_TreasureChest_Taken()
		{
			using (Artifact card = new TreasureChest())
			{
				card.TakenBy(mockPlayer.Object);


				var pceArgs = new PhaseChangingEventArgs(mockPlayer.Object, PhaseEnum.BuyTreasure);
				mockPlayer.Raise(_ => _.PhaseChanging += null, pceArgs);
				Assert.IsTrue(pceArgs.Resolvers.ContainsKey(TypeClass.TreasureChest));
			}
		}
		[TestMethod]
		public void Test_TreasureChest_Returned()
		{
			using (Artifact card = new TreasureChest())
			{
				card.TakenBy(mockPlayer.Object);
				card.ReturnedBy(mockPlayer.Object);


				var pceArgs = new PhaseChangingEventArgs(mockPlayer.Object, PhaseEnum.BuyTreasure);
				mockPlayer.Raise(_ => _.PhaseChanging += null, pceArgs);
				Assert.IsFalse(pceArgs.Resolvers.ContainsKey(TypeClass.TreasureChest));
			}
		}
		[TestMethod]
		public void Test_TreasureChest_TurnStarted()
		{
			using (Artifact card = new TreasureChest())
			{
				mockTable.SetupGet(_ => _.Gold).Returns(mockSupply.Object);
				mockSupply.SetupGet(_ => _.Type).Returns(DominionBase.Cards.Universal.TypeClass.Gold);


				card.TakenBy(mockPlayer.Object);


				var pceArgs = new PhaseChangingEventArgs(mockPlayer.Object, PhaseEnum.BuyTreasure);
				mockPlayer.Raise(_ => _.PhaseChanging += null, pceArgs);
				Assert.IsTrue(pceArgs.Resolvers.ContainsKey(TypeClass.TreasureChest));

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

				mockPlayer.Verify(_ => _.Gain(It.Is<ISupply>(s => s.Type == DominionBase.Cards.Universal.TypeClass.Gold), card, 1, false), Times.Once);
				Assert.IsTrue(pceArgs.HandledBy.Contains(TypeClass.TreasureChest));
			}
		}
		[TestMethod]
		public void Test_TreasureChest_Teardown()
		{
			using (Artifact card = new TreasureChest())
			{
				card.TakenBy(mockPlayer.Object);

				card.TearDown(mockGame.Object);

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

				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(new Currency(3), card.Benefit.Currency);
			}
		}
		[TestMethod]
		public void Test_Treasurer_Play_Trash_Treasure()
		{
			using (Card card = new Treasurer())
			{
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				hand.AddRange(mockPlayer.Object, new ItemCollection<Card> { new Spices(), new Inventor() });
				mockPlayer.Setup(_ => _.Hand).Returns(hand);
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options)))
					.Returns(new ChoiceResult(new List<string> { "Trash a Treasure from your hand" }));
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)))
					.Returns<Choice>(c => new ChoiceResult(new ItemCollection<Card> { c.Cards.First() }));


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.RetrieveCardsFrom(DeckLocation.Hand, It.Is<ItemCollection<Card>>(ic => ic.Count == 1 && hand.Contains(ic[0]))), Times.Once);
				mockPlayer.Verify(_ => _.Trash(card, It.Is<ItemCollection<Card>>(ic => ic.Count == 1 && hand.Contains(ic[0]))), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Treasurer_Play_Trash_Treasure_Nothing_To_Trash()
		{
			using (Card card = new Treasurer())
			{

				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner);
				hand.AddRange(mockPlayer.Object, new ItemCollection<Card> { new Scholar(), new Inventor() });
				mockPlayer.Setup(_ => _.Hand).Returns(hand);
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options)))
					.Returns(new ChoiceResult(new List<string> { "Trash a Treasure from your hand" }));
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)))
					.Returns<Choice>(c => new ChoiceResult(new ItemCollection<Card>()));


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.RetrieveCardsFrom(DeckLocation.Hand, It.Is<ItemCollection<Card>>(ic => ic.Count == 1 && hand.Contains(ic[0]))), Times.Never);
				mockPlayer.Verify(_ => _.Trash(It.IsAny<IGameObject>(), It.Is<ItemCollection<Card>>(ic => ic.Count == 1 && hand.Contains(ic[0]))), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Treasurer_Play_Gain_Treasure_From_Trash()
		{
			using (Card card = new Treasurer())
			{

				var trash = new Trash
				{
					new Spices()
				};
				mockTable.Setup(_ => _.Trash).Returns(trash);
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options)))
					.Returns(new ChoiceResult(new List<string> { "Gain a Treasure from the trash to your hand" }));
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)))
					.Returns<Choice>(c => new ChoiceResult(new ItemCollection<Card> { c.Cards.First() }));


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(trash, trash.First(), card, DeckLocation.Hand, It.IsAny<DeckPosition>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Treasurer_Play_Gain_Treasure_From_Trash_Nothing_To_Gain()
		{
			using (Card card = new Treasurer())
			{

				var trash = new Trash();
				mockTable.Setup(_ => _.Trash).Returns(trash);
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options)))
					.Returns(new ChoiceResult(new List<string> { "Gain a Treasure from the trash to your hand" }));
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards)))
					.Returns<Choice>(c => new ChoiceResult(new ItemCollection<Card>()));


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Gain(trash, It.IsAny<Card>(), card, DeckLocation.Hand, It.IsAny<DeckPosition>()), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Treasurer_Play_Take_Key()
		{
			using (Card card = new Treasurer())
			{

				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Options)))
					.Returns(new ChoiceResult(new List<string> { "Take the Key" }));


				card.FollowInstructions(mockPlayer.Object);


				mockPlayer.Verify(_ => _.Take(It.Is<Type>(t => t == TypeClass.Key)), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Villain_Basic()
		{
			using (var card = new Villain())
			{

				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Attack, card.Category);
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(2, card.Benefit.Coffers);
			}
		}
		[TestMethod]
		public void Test_Villain_Play_Small_Hand()
		{
			using (Card card = new Villain())
			{

				var mockAttackee = new Mock<IPlayer>();
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockAttackee.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockGame.Setup(_ => _.GetPlayersStartingWithEnumerator(mockPlayer.Object)).Returns<IPlayer>(x => { var y = players.GetPlayersStartingWithEnumerator(x); return y; });
				mockAttackee.SetupGet(_ => _.Hand).Returns(new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner));
				mockAttackee.Setup(_ => _.AttackedByPlayerAllowed(mockPlayer.Object, card)).Returns(true);
				mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Action);


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


				mockAttackee.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Never);
				mockAttackee.Verify(_ => _.RevealHand(), Times.Never);
			}
		}
		[TestMethod]
		public void Test_Villain_Play_No_Cheap_Cards()
		{
			using (Card card = new Villain())
			{

				var mockAttackee = new Mock<IPlayer>();
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockAttackee.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockGame.Setup(_ => _.GetPlayersStartingWithEnumerator(mockPlayer.Object)).Returns<IPlayer>(x => { var y = players.GetPlayersStartingWithEnumerator(x); return y; });
				mockAttackee.SetupGet(_ => _._Game).Returns(mockGame.Object);
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner)
				{
					new DominionBase.Cards.Universal.Copper(),
					new DominionBase.Cards.Universal.Copper(),
					new DominionBase.Cards.Universal.Copper(),
					new DominionBase.Cards.Universal.Copper(),
					new DominionBase.Cards.Universal.Copper()
				};
				mockAttackee.SetupGet(_ => _.Hand).Returns(hand);
				mockAttackee.Setup(_ => _.AttackedByPlayerAllowed(mockPlayer.Object, card)).Returns(true);
				mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Action);


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


				mockAttackee.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Never);
				mockAttackee.Verify(_ => _.RevealHand(), Times.Once);
				mockAttackee.Verify(_ => _.ReturnHand(It.IsAny<ItemCollection<Card>>()), Times.Once);
			}
		}
		[TestMethod]
		public void Test_Villain_Play_Discard()
		{
			using (Card card = new Villain())
			{

				var mockAttackee = new Mock<IPlayer>();
				var players = new PlayerCollection(mockGame.Object)
				{
					mockPlayer.Object,
					mockAttackee.Object
				};
				mockGame.SetupGet(_ => _.Players).Returns(players);
				mockGame.Setup(_ => _.GetPlayersStartingWithEnumerator(mockPlayer.Object)).Returns<IPlayer>(x => { var y = players.GetPlayersStartingWithEnumerator(x); return y; });
				mockAttackee.SetupGet(_ => _._Game).Returns(mockGame.Object);
				var oldWitch = new OldWitch();
				var hand = new Deck(DeckLocation.Hand, Visibility.All, VisibilityTo.Owner)
				{
					new DominionBase.Cards.Universal.Duchy(),
					new DominionBase.Cards.Universal.Province(),
					oldWitch,
					new Spices(),
					new Inventor()
				};
				mockAttackee.SetupGet(_ => _.Hand).Returns(hand);
				mockAttackee.Setup(_ => _.AttackedByPlayerAllowed(mockPlayer.Object, card)).Returns(true);
				mockPlayer.SetupGet(_ => _.Phase).Returns(PhaseEnum.Action);
				mockAttackee.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.ChoiceType == ChoiceType.Cards && c.ChoiceOutcome == ChoiceOutcome.Discard)))
					.Returns(new ChoiceResult(new ItemCollection<Card> { oldWitch }));


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


				mockAttackee.Verify(_ => _.MakeChoice(It.IsAny<Choice>()), Times.Once);
				mockAttackee.Verify(_ => _.Discard(DeckLocation.Hand, It.Is<ItemCollection<Card>>(ic => ic.Count == 1 && ic[0] == oldWitch), It.IsAny<CardsDiscardResolver>()), Times.Once);
				mockAttackee.Verify(_ => _.RevealHand(), Times.Never);
				mockAttackee.Verify(_ => _.ReturnHand(It.IsAny<ItemCollection<Card>>()), Times.Never);
			}
		}
	}
}