ambidextrous/gemp-lotr
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added some package namespaces for less haphazard individual card testing. Added GenericCardTestHelper, which is intended to be used to make unit tests less obscure. Altered the default AbstractAtTest format to multipath instead of movie.

Browse Source
This commit is contained in:
Christian 'ketura' McCarty
2021-02-06 18:54:34 -06:00
parent da7da8b8b6
commit 998acd4888
5 changed files with 614 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
gemp-lotr/gemp-lotr-server/src/test/java/com/gempukku/lotro/at/AbstractAtTest.java
View File

@@ -53,7 +53,7 @@ public abstract class AbstractAtTest {
_userFeedback = new DefaultUserFeedback();
LotroFormatLibrary formatLibrary = new LotroFormatLibrary(new DefaultAdventureLibrary(), _library);
LotroFormat format = formatLibrary.getFormat("movie");
LotroFormat format = formatLibrary.getFormat("multipath");
_game = new DefaultLotroGame(format, decks, _userFeedback, _library);
_userFeedback.setGame(_game);

424
gemp-lotr/gemp-lotr-server/src/test/java/com/gempukku/lotro/cards/GenericCardTestHelper.java Normal file
View File

@@ -0,0 +1,424 @@
package com.gempukku.lotro.cards;
import com.gempukku.lotro.at.AbstractAtTest;
import com.gempukku.lotro.common.Keyword;
import com.gempukku.lotro.common.Phase;
import com.gempukku.lotro.common.Zone;
import com.gempukku.lotro.game.CardNotFoundException;
import com.gempukku.lotro.game.PhysicalCard;
import com.gempukku.lotro.game.PhysicalCardImpl;
import com.gempukku.lotro.game.state.Assignment;
import com.gempukku.lotro.logic.GameUtils;
import com.gempukku.lotro.logic.decisions.AwaitingDecision;
import com.gempukku.lotro.logic.decisions.DecisionResultInvalidException;
import com.gempukku.lotro.logic.modifiers.Modifier;
import com.gempukku.lotro.logic.vo.LotroDeck;
import java.util.*;
import static org.junit.Assert.assertEquals;
public class GenericCardTestHelper extends AbstractAtTest {
private int LastCardID = 100;
public static final HashMap<String, String> FellowshipSites = new HashMap<String, String>() {{
put("site1", "1_319");
put("site2", "1_327");
put("site3", "1_337");
put("site4", "1_343");
put("site5", "1_349");
put("site6", "1_350");
put("site7", "1_353");
put("site8", "1_356");
put("site9", "1_360");
}};
public static final String FOTRFrodo = "1_290";
public static final String FOTRRing = "1_2";
// Player key, then name/card
public Map<String, Map<String, PhysicalCardImpl>> Cards = new HashMap<>();
public GenericCardTestHelper(Map<String, String> cardIDs) throws CardNotFoundException, DecisionResultInvalidException {
this(cardIDs, null, null, null);
}
public GenericCardTestHelper(Map<String, String> cardIDs, Map<String, String> siteIDs, String ringBearerID, String ringID) throws CardNotFoundException, DecisionResultInvalidException {
super();
if(siteIDs == null || ringBearerID == null || ringID == null) {
initializeSimplestGame();
}
else {
Map<String, LotroDeck> decks = new HashMap<String, LotroDeck>();
decks.put(P1, new LotroDeck(P1));
decks.put(P2, new LotroDeck(P2));
for(String name : siteIDs.keySet()) {
String id = siteIDs.get(name);
decks.get(P1).addSite(id);
decks.get(P2).addSite(id);
}
decks.get(P1).setRingBearer(ringBearerID);
decks.get(P2).setRingBearer(ringBearerID);
decks.get(P1).setRing(ringID);
decks.get(P2).setRing(ringID);
initializeGameWithDecks(decks);
}
Cards.put(P1, new HashMap<>());
Cards.put(P2, new HashMap<>());
if(cardIDs != null) {
for(String name : cardIDs.keySet()) {
String id = cardIDs.get(name);
PhysicalCardImpl card = CreateCard(P1, id);
Cards.get(P1).put(name, card);
FreepsMoveCardToDeck(card);
card = CreateCard(P2, id);
Cards.get(P2).put(name, card);
FreepsMoveCardToDeck(card);
}
}
}
public PhysicalCardImpl CreateCard(String playerID, String cardID) throws CardNotFoundException {
return new PhysicalCardImpl(LastCardID++, cardID, playerID, _library.getLotroCardBlueprint(cardID));
}
public void StartGame() throws DecisionResultInvalidException {
skipMulligans();
}
public PhysicalCardImpl GetFreepsCard(String cardName) { return Cards.get(P1).get(cardName); }
public PhysicalCardImpl GetShadowCard(String cardName) { return Cards.get(P2).get(cardName); }
public PhysicalCardImpl GetFreepsSite(int siteNum) { return GetSite(P1, siteNum); }
public PhysicalCardImpl GetShadowSite(int siteNum) { return GetSite(P2, siteNum); }
public PhysicalCardImpl GetSite(String playerID, int siteNum)
{
List<PhysicalCardImpl> advDeck = (List<PhysicalCardImpl>)_game.getGameState().getAdventureDeck(playerID);
// for (PhysicalCardImpl card : advDeck) {
// if (card.getSiteNumber() == siteNum){
// return card;
// }
// }
return advDeck.stream().filter(x -> x.getBlueprint().getSiteNumber() == siteNum).findFirst().get();
}
public List<String> FreepsGetAvailableActions() { return GetAvailableActions(P1); }
public List<String> ShadowGetAvailableActions() { return GetAvailableActions(P2); }
public List<String> GetAvailableActions(String playerID) {
AwaitingDecision decision = GetAwaitingDecision(playerID);
if(decision == null) {
return new ArrayList<String>();
}
return Arrays.asList((String[])decision.getDecisionParameters().get("actionText"));
}
public AwaitingDecision FreepsGetAwaitingDecision() { return GetAwaitingDecision(P1); }
public AwaitingDecision ShadowGetAwaitingDecision() { return GetAwaitingDecision(P2); }
public AwaitingDecision GetAwaitingDecision(String playerID) { return _userFeedback.getAwaitingDecision(playerID); }
public Boolean FreepsDecisionAvailable(String text) { return DecisionAvailable(P1, text); }
public Boolean ShadowDecisionAvailable(String text) { return DecisionAvailable(P2, text); }
public Boolean DecisionAvailable(String playerID, String text)
{
AwaitingDecision ad = GetAwaitingDecision(playerID);
String lowerText = text.toLowerCase();
return ad.getText().toLowerCase().contains(lowerText);
}
public Boolean FreepsActionAvailable(String action) { return ActionAvailable(P1, action); }
public Boolean FreepsCardActionAvailable(PhysicalCardImpl card) { return ActionAvailable(P1, "Use " + GameUtils.getFullName(card)); }
public Boolean FreepsCardPlayAvailable(PhysicalCardImpl card) { return ActionAvailable(P1, "Play " + GameUtils.getFullName(card)); }
public Boolean ShadowActionAvailable(String action) { return ActionAvailable(P2, action); }
public Boolean ShadowCardActionAvailable(PhysicalCardImpl card) { return ActionAvailable(P2, "Use " + GameUtils.getFullName(card)); }
public Boolean ShadowCardPlayAvailable(PhysicalCardImpl card) { return ActionAvailable(P2, "Play " + GameUtils.getFullName(card)); }
public Boolean ActionAvailable(String player, String action) {
List<String> actions = GetAvailableActions(player);
String lowerAction = action.toLowerCase();
return actions.stream().anyMatch(x -> x.toLowerCase().contains(lowerAction));
}
public Boolean FreepsAnyActionsAvailable() { return AnyActionsAvailable(P1); }
public Boolean ShadowAnyActionsAvailable() { return AnyActionsAvailable(P2); }
public Boolean AnyActionsAvailable(String player) {
List<String> actions = GetAvailableActions(player);
return actions.size() > 0;
}
public Boolean FreepsAnyDecisionsAvailable() { return AnyDecisionsAvailable(P1); }
public Boolean ShadowAnyDecisionsAvailable() { return AnyDecisionsAvailable(P2); }
public Boolean AnyDecisionsAvailable(String player) {
AwaitingDecision ad = GetAwaitingDecision(player);
return ad != null;
}
public List<String> FreepsGetCardChoices() { return GetADParamAsList(P1, "cardId"); }
public List<String> ShadowGetCardChoices() { return GetADParamAsList(P2, "cardId"); }
public List<String> FreepsGetMultipleChoices() { return GetADParamAsList(P1, "results"); }
public List<String> ShadowGetMultipleChoices() { return GetADParamAsList(P2, "results"); }
public List<String> FreepsGetADParamAsList(String paramName) { return GetADParamAsList(P1, paramName); }
public List<String> ShadowGetADParamAsList(String paramName) { return GetADParamAsList(P2, paramName); }
public List<String> GetADParamAsList(String playerID, String paramName) { return Arrays.asList((String[])GetAwaitingDecisionParam(playerID, paramName)); }
public Object FreepsGetADParam(String paramName) { return GetAwaitingDecisionParam(P1, paramName); }
public Object ShadowGetADParam(String paramName) { return GetAwaitingDecisionParam(P2, paramName); }
public Object GetAwaitingDecisionParam(String playerID, String paramName) {
AwaitingDecision decision = _userFeedback.getAwaitingDecision(playerID);
return decision.getDecisionParameters().get(paramName);
}
public Map<String, Object> GetAwaitingDecisionParams(String playerID) {
AwaitingDecision decision = _userFeedback.getAwaitingDecision(playerID);
return decision.getDecisionParameters();
}
public void FreepsUseCardAction(String name) throws DecisionResultInvalidException { playerDecided(P1, getCardActionId(P1, name)); }
public void FreepsUseCardAction(PhysicalCardImpl card) throws DecisionResultInvalidException { playerDecided(P1, getCardActionId(P1, "Use " + GameUtils.getFullName(card))); }
public void ShadowUseCardAction(String name) throws DecisionResultInvalidException { playerDecided(P2, getCardActionId(P2, name)); }
public void ShadowUseCardAction(PhysicalCardImpl card) throws DecisionResultInvalidException { playerDecided(P2, getCardActionId(P2, "Use " + GameUtils.getFullName(card))); }
public void FreepsPlayCard(String name) throws DecisionResultInvalidException { FreepsPlayCard(GetFreepsCard(name)); }
public void FreepsPlayCard(PhysicalCardImpl card) throws DecisionResultInvalidException { playerDecided(P1, getCardActionId(P1, "Play " + GameUtils.getFullName(card))); }
public void ShadowPlayCard(String name) throws DecisionResultInvalidException { ShadowPlayCard(GetShadowCard(name)); }
public void ShadowPlayCard(PhysicalCardImpl card) throws DecisionResultInvalidException { playerDecided(P2, getCardActionId(P2, "Play " + GameUtils.getFullName(card))); }
public int FreepsGetWoundsOn(String cardName) { return GetWoundsOn(GetFreepsCard(cardName)); }
public int ShadowGetWoundsOn(String cardName) { return GetWoundsOn(GetShadowCard(cardName)); }
public int GetWoundsOn(PhysicalCardImpl card) { return _game.getGameState().getWounds(card); }
public int GetBurdens() { return _game.getGameState().getBurdens(); }
public int GetFreepsHandCount() { return GetPlayerHandCount(P1); }
public int GetShadowHandCount() { return GetPlayerHandCount(P2); }
public int GetPlayerHandCount(String player)
{
return _game.getGameState().getHand(player).size();
}
public int GetFreepsDeckCount() { return GetPlayerDeckCount(P1); }
public int GetShadowDeckCount() { return GetPlayerDeckCount(P2); }
public int GetPlayerDeckCount(String player)
{
return _game.getGameState().getDeck(player).size();
}
public int GetFreepsDiscardCount() { return GetPlayerDiscardCount(P1); }
public int GetShadowDiscardCount() { return GetPlayerDiscardCount(P2); }
public int GetPlayerDiscardCount(String player)
{
return _game.getGameState().getDiscard(player).size();
}
public Phase GetCurrentPhase() { return _game.getGameState().getCurrentPhase(); }
public void FreepsMoveCardToHand(String cardName) { MoveCardToZone(P1, GetFreepsCard(cardName), Zone.HAND); }
public void FreepsMoveCardToHand(PhysicalCardImpl...cards) {
for(PhysicalCardImpl card : cards) {
MoveCardToZone(P1, card, Zone.HAND);
}
}
public void ShadowMoveCardToHand(String cardName) { MoveCardToZone(P2, GetShadowCard(cardName), Zone.HAND); }
public void ShadowMoveCardToHand(PhysicalCardImpl...cards) {
for(PhysicalCardImpl card : cards) {
MoveCardToZone(P2, card, Zone.HAND);
}
}
public void AttachCard(PhysicalCardImpl card, PhysicalCardImpl bearer) { _game.getGameState().attachCard(_game, card, bearer); }
public void FreepsMoveCardToDeck(String...cardNames) {
Arrays.stream(cardNames).forEach(cardName -> FreepsMoveCardToDeck(GetFreepsCard(cardName)));
}
public void FreepsMoveCardToDeck(PhysicalCardImpl...cards) {
Arrays.stream(cards).forEach(card -> MoveCardToZone(P1, card, Zone.DECK));
}
public void ShadowMoveCardToDeck(String...cardNames) {
Arrays.stream(cardNames).forEach(cardName -> ShadowMoveCardToDeck(GetShadowCard(cardName)));
}
public void ShadowMoveCardToDeck(PhysicalCardImpl...cards) {
Arrays.stream(cards).forEach(card -> MoveCardToZone(P1, card, Zone.DECK));
}
public void FreepsMoveCharToTable(String cardName) { FreepsMoveCharToTable(GetFreepsCard(cardName)); }
public void FreepsMoveCharToTable(PhysicalCardImpl...cards) {
Arrays.stream(cards).forEach(card -> MoveCardToZone(P1, card, Zone.FREE_CHARACTERS));
}
public void ShadowMoveCharToTable(String cardName) { FreepsMoveCharToTable(GetShadowCard(cardName)); }
public void ShadowMoveCharToTable(PhysicalCardImpl...cards) {
Arrays.stream(cards).forEach(card -> MoveCardToZone(P2, card, Zone.SHADOW_CHARACTERS));
}
public void FreepsMoveCardToSupportArea(String cardName) { FreepsMoveCardToSupportArea(GetFreepsCard(cardName)); }
public void FreepsMoveCardToSupportArea(PhysicalCardImpl...cards) {
Arrays.stream(cards).forEach(card -> MoveCardToZone(P1, card, Zone.SUPPORT));
}
public void ShadowMoveCardToSupportArea(String cardName) { ShadowMoveCardToSupportArea(GetShadowCard(cardName)); }
public void ShadowMoveCardToSupportArea(PhysicalCardImpl...cards) {
Arrays.stream(cards).forEach(card -> MoveCardToZone(P1, card, Zone.SUPPORT));
}
public void MoveCardToZone(String player, PhysicalCardImpl card, Zone zone) {
if(card.getZone() != null)
{
_game.getGameState().removeCardsFromZone(player, new ArrayList<PhysicalCard>() {{ add(card); }});
}
_game.getGameState().addCardToZone(_game, card, zone);
}
public void FreepsAddWoundsToChar(String cardName, int count) { AddWoundsToChar(GetFreepsCard(cardName), count); }
public void ShadowAddWoundsToChar(String cardName, int count) { AddWoundsToChar(GetShadowCard(cardName), count); }
public void AddWoundsToChar(PhysicalCardImpl card, int count) {
for(int i = 0; i < count; i++)
{
_game.getGameState().addWound(card);
}
}
public int GetTwilight() { return _game.getGameState().getTwilightPool(); }
public void SetTwilight(int amount) { _game.getGameState().setTwilight(amount); }
public PhysicalCardImpl GetRingBearer() { return (PhysicalCardImpl)_game.getGameState().getRingBearer(P1); }
public PhysicalCardImpl GetCurrentSite() { return (PhysicalCardImpl)_game.getGameState().getCurrentSite(); }
public void SkipToPhase(Phase target) throws DecisionResultInvalidException {
for(int attempts = 1; attempts <= 20; attempts++)
{
Phase current = _game.getGameState().getCurrentPhase();
if(current == target)
break;
SkipCurrentPhaseActions();
if(attempts == 20)
{
throw new DecisionResultInvalidException("Could not arrive at target '" + target + "' after 20 attempts!");
}
}
}
public void SkipCurrentPhaseActions() throws DecisionResultInvalidException {
FreepsSkipCurrentPhaseAction();
ShadowSkipCurrentPhaseAction();
}
public void FreepsSkipCurrentPhaseAction() throws DecisionResultInvalidException {
if(_userFeedback.getAwaitingDecision(P1) != null) {
playerDecided(P1, "");
}
}
public void ShadowSkipCurrentPhaseAction() throws DecisionResultInvalidException {
if(_userFeedback.getAwaitingDecision(P2) != null) {
playerDecided(P2, "");
}
}
public void FreepsAssignToMinion(String name, String target) throws DecisionResultInvalidException { FreepsAssignToMinion(GetFreepsCard(name), GetShadowCard(target)); }
public void FreepsAssignToMinion(PhysicalCardImpl comp, PhysicalCardImpl minion) throws DecisionResultInvalidException {
playerDecided(P1, comp.getCardId() + " " + minion.getCardId());
}
public void FreepsAssignToMinions(PhysicalCardImpl[]... groups) throws DecisionResultInvalidException {
String result = "";
for (PhysicalCardImpl[] group : groups) {
result += group[0].getCardId();
for(int i = 1; i < group.length; i++)
{
result += " " + group[i].getCardId();
}
result += ",";
}
playerDecided(P1, result);
}
public List<PhysicalCardImpl> FreepsGetAttachedCards(String name) { return GetAttachedCards(GetFreepsCard(name)); }
public List<PhysicalCardImpl> GetAttachedCards(PhysicalCardImpl card) {
return (List<PhysicalCardImpl>)(List<?>)_game.getGameState().getAttachedCards(card);
}
public void FreepsResolveSkirmish(String name) throws DecisionResultInvalidException { FreepsResolveSkirmish(GetFreepsCard(name)); }
public void FreepsResolveSkirmish(PhysicalCardImpl comp) throws DecisionResultInvalidException { FreepsChooseCard(comp); }
public void FreepsChooseCard(PhysicalCardImpl card) throws DecisionResultInvalidException {
playerDecided(P1, String.valueOf(card.getCardId()));
}
public void ShadowChooseCard(PhysicalCardImpl card) throws DecisionResultInvalidException {
playerDecided(P2, String.valueOf(card.getCardId()));
}
public boolean FreepsCanChooseCharacter(PhysicalCardImpl card) { return FreepsGetCardChoices().contains(String.valueOf(card.getCardId())); }
public boolean ShadowCanChooseCharacter(PhysicalCardImpl card) { return ShadowGetCardChoices().contains(String.valueOf(card.getCardId())); }
public int FreepsCardChoiceCount() { return FreepsGetCardChoices().size(); }
public int ShadowCardChoiceCount() { return ShadowGetCardChoices().size(); }
public boolean IsCharAssigned(PhysicalCardImpl card) {
List<Assignment> assigns = _game.getGameState().getAssignments();
return assigns.stream().anyMatch(x -> x.getFellowshipCharacter() == card || x.getShadowCharacters().contains(card));
}
public boolean IsAttachedTo(PhysicalCardImpl card, PhysicalCardImpl bearer) {
if(card.getZone() != Zone.ATTACHED) {
return false;
}
return bearer == card.getAttachedTo();
}
public int FreepsGetStrength(String name) { return GetStrength(GetFreepsCard(name)); }
public int ShadowGetStrength(String name) { return GetStrength(GetShadowCard(name)); }
public int GetStrength(PhysicalCardImpl card)
{
return _game.getModifiersQuerying().getStrength(_game, card);
}
public boolean HasKeyword(PhysicalCardImpl card, Keyword keyword)
{
return _game.getModifiersQuerying().hasKeyword(_game, card, keyword);
}
public void InsertAdHocModifier(Modifier mod)
{
_game.getModifiersEnvironment().addUntilEndOfTurnModifier(mod);
}
public void FreepsChooseToMove() throws DecisionResultInvalidException { playerDecided(P1, "0"); }
public void FreepsChooseToStay() throws DecisionResultInvalidException { playerDecided(P1, "1"); }
public void FreepsAcceptOptionalTrigger() throws DecisionResultInvalidException { playerDecided(P1, "0"); }
public void FreepsDeclineOptionalTrigger() throws DecisionResultInvalidException { playerDecided(P1, "1"); }
public void ShadowAcceptOptionalTrigger() throws DecisionResultInvalidException { playerDecided(P2, "0"); }
public void ShadowDeclineOptionalTrigger() throws DecisionResultInvalidException { playerDecided(P2, "1"); }
public void FreepsChooseMultipleChoiceOption(String option) throws DecisionResultInvalidException { ChooseMultipleChoiceOption(P1, option); }
public void ShadowChooseMultipleChoiceOption(String option) throws DecisionResultInvalidException { ChooseMultipleChoiceOption(P2, option); }
public void ChooseMultipleChoiceOption(String playerID, String option) throws DecisionResultInvalidException { ChooseAction(playerID, "results", option); }
public void ChooseAction(String playerID, String paramName, String option) throws DecisionResultInvalidException {
List<String> choices = GetADParamAsList(playerID, paramName);
for(String choice : choices){
if(choice.toLowerCase().contains(option.toLowerCase())) {
playerDecided(playerID, String.valueOf(choices.indexOf(choice)));
return;
}
}
//couldn't find an exact match, so maybe it's a direct index:
playerDecided(playerID, option);
}
public void FreepsResolveActionOrder(String option) throws DecisionResultInvalidException { ChooseAction(P1, "actionText", option); }
}

64
gemp-lotr/gemp-lotr-server/src/test/java/com/gempukku/lotro/cards/official/set18/Card18_118Tests.java Normal file
View File

@@ -0,0 +1,64 @@
package com.gempukku.lotro.cards.official.set18;
import com.gempukku.lotro.cards.GenericCardTestHelper;
import com.gempukku.lotro.common.Phase;
import com.gempukku.lotro.game.CardNotFoundException;
import com.gempukku.lotro.game.PhysicalCardImpl;
import com.gempukku.lotro.logic.decisions.DecisionResultInvalidException;
import org.junit.Test;
import java.util.HashMap;
import static junit.framework.Assert.assertEquals;
import static junit.framework.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
// Wielder of the Flame
public class Card18_118Tests
{
protected GenericCardTestHelper GetScenario() throws CardNotFoundException, DecisionResultInvalidException {
return new GenericCardTestHelper(
new HashMap<String, String>()
{{
put("aragorn", "1_89");
put("lurtz", "18_118");
}}
);
}
@Test
public void LurtzAbilityOffersChoiceOfPrevention() throws DecisionResultInvalidException, CardNotFoundException {
//Pre-game setup
GenericCardTestHelper scn = GetScenario();
PhysicalCardImpl frodo = scn.GetRingBearer();
PhysicalCardImpl aragorn = scn.GetFreepsCard("aragorn");
scn.FreepsMoveCharToTable(aragorn);
PhysicalCardImpl lurtz = scn.GetShadowCard("lurtz");
scn.ShadowMoveCharToTable(lurtz);
scn.StartGame();
scn.SkipToPhase(Phase.ARCHERY);
scn.SkipCurrentPhaseActions();
scn.FreepsChooseCard(frodo);
//assignment phase
scn.FreepsSkipCurrentPhaseAction();
assertEquals(0, scn.GetWoundsOn(lurtz));
scn.ShadowUseCardAction(lurtz);
assertEquals(2, scn.GetWoundsOn(lurtz));
assertTrue(scn.FreepsAnyDecisionsAvailable());
scn.FreepsAcceptOptionalTrigger();
assertTrue(scn.FreepsAnyDecisionsAvailable());
assertEquals("Exert - Aragorn, Ranger of the North", scn.FreepsGetADParamAsList("results").toArray()[0]);
assertEquals("Add 1 burden", scn.FreepsGetADParamAsList("results").toArray()[1]);
}
}

65
gemp-lotr/gemp-lotr-server/src/test/java/com/gempukku/lotro/cards/official/set2/Card2_013Tests.java Normal file
View File

@@ -0,0 +1,65 @@
package com.gempukku.lotro.cards.official.set2;
import com.gempukku.lotro.cards.GenericCardTestHelper;
import com.gempukku.lotro.common.Keyword;
import com.gempukku.lotro.common.Phase;
import com.gempukku.lotro.game.CardNotFoundException;
import com.gempukku.lotro.game.PhysicalCardImpl;
import com.gempukku.lotro.logic.decisions.DecisionResultInvalidException;
import org.junit.Test;
import java.util.HashMap;
import static junit.framework.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
// Tidings of Erebor
public class Card2_013Tests
{
protected GenericCardTestHelper GetScenario() throws CardNotFoundException, DecisionResultInvalidException {
return new GenericCardTestHelper(
new HashMap<String, String>()
{{
put("tidings", "2_13");
put("gimli", "1_13");
put("deckcard1", "1_13");
put("deckcard2", "1_13");
put("deckcard3", "1_13");
}}
);
}
@Test
public void TidingsAbilityCanBePrevented() throws DecisionResultInvalidException, CardNotFoundException {
//Pre-game setup
GenericCardTestHelper scn = GetScenario();
PhysicalCardImpl tidings = scn.GetFreepsCard("tidings");
PhysicalCardImpl gimli = scn.GetFreepsCard("gimli");
scn.FreepsMoveCharToTable(gimli);
scn.FreepsMoveCardToHand(tidings);
scn.FreepsMoveCardToDeck("deckcard1", "deckcard2", "deckcard3");
scn.StartGame();
scn.FreepsSkipCurrentPhaseAction();
scn.SkipToPhase(Phase.REGROUP);
scn.FreepsPlayCard(tidings);
assertEquals(3, scn.GetTwilight());
assertEquals(0, scn.GetFreepsHandCount());
assertEquals(3, scn.GetFreepsDeckCount());
scn.ShadowAcceptOptionalTrigger();
assertEquals(0, scn.GetTwilight());
assertEquals(0, scn.GetFreepsHandCount());
assertEquals(3, scn.GetFreepsDeckCount());
}
}

60
gemp-lotr/gemp-lotr-server/src/test/java/com/gempukku/lotro/cards/official/set2/Card2_028Tests.java Normal file
View File

@@ -0,0 +1,60 @@
package com.gempukku.lotro.cards.official.set2;
import com.gempukku.lotro.cards.GenericCardTestHelper;
import com.gempukku.lotro.common.Phase;
import com.gempukku.lotro.game.CardNotFoundException;
import com.gempukku.lotro.game.PhysicalCardImpl;
import com.gempukku.lotro.logic.decisions.DecisionResultInvalidException;
import org.junit.Test;
import java.util.HashMap;
import static junit.framework.Assert.assertEquals;
import static junit.framework.Assert.assertFalse;
// Wielder of the Flame
public class Card2_028Tests
{
protected GenericCardTestHelper GetScenario() throws CardNotFoundException, DecisionResultInvalidException {
return new GenericCardTestHelper(
new HashMap<String, String>()
{{
put("wielder", "2_28");
put("gandalf", "1_364");
put("runner", "1_178");
}}
);
}
@Test
public void WielderAbilityCanBePrevented() throws DecisionResultInvalidException, CardNotFoundException {
//Pre-game setup
GenericCardTestHelper scn = GetScenario();
PhysicalCardImpl wielder = scn.GetFreepsCard("wielder");
PhysicalCardImpl gandalf = scn.GetFreepsCard("gandalf");
scn.FreepsMoveCharToTable(gandalf);
scn.FreepsMoveCardToHand(wielder);
PhysicalCardImpl runner = scn.GetShadowCard("runner");
scn.ShadowMoveCharToTable(runner);
scn.StartGame();
scn.FreepsSkipCurrentPhaseAction();
scn.SkipToPhase(Phase.MANEUVER);
scn.FreepsPlayCard(wielder);
assertEquals(4, scn.GetTwilight());
scn.ShadowAcceptOptionalTrigger();
assertEquals(1, scn.GetTwilight());
assertFalse(scn.FreepsAnyActionsAvailable());
}
}