diff --git a/forge-gui-desktop/src/test/java/forge/card/CardDbTestCase.java b/forge-gui-desktop/src/test/java/forge/card/CardDbCardMockTestCase.java similarity index 86% rename from forge-gui-desktop/src/test/java/forge/card/CardDbTestCase.java rename to forge-gui-desktop/src/test/java/forge/card/CardDbCardMockTestCase.java index 6c0cf5d013c..9a9f71bc4ca 100644 --- a/forge-gui-desktop/src/test/java/forge/card/CardDbTestCase.java +++ b/forge-gui-desktop/src/test/java/forge/card/CardDbCardMockTestCase.java @@ -1,20 +1,31 @@ package forge.card; +import static org.testng.Assert.assertEquals; +import static org.testng.Assert.assertFalse; +import static org.testng.Assert.assertNotNull; +import static org.testng.Assert.assertNull; +import static org.testng.Assert.assertTrue; +import static org.testng.Assert.fail; + +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.time.Instant; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Date; +import java.util.List; + +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.Test; + import com.google.common.base.Predicate; + import forge.StaticData; import forge.item.IPaperCard; import forge.item.PaperCard; import forge.model.FModel; -import org.testng.annotations.BeforeMethod; -import org.testng.annotations.Test; -import java.text.ParseException; -import java.text.SimpleDateFormat; -import java.time.Instant; -import java.util.*; -import static org.testng.Assert.*; - -public class CardDbTestCase extends ForgeCardMockTestCase { +public class CardDbCardMockTestCase extends CardMockTestCase { protected LegacyCardDb legacyCardDb; protected CardDb cardDb; @@ -31,11 +42,11 @@ public class CardDbTestCase extends ForgeCardMockTestCase { protected final String collNrLightningDragon = "202"; // Get a card with multiple arts - protected final String cardNameHymnToTourach = "Hymn to Tourach"; // good 'ol hymn w/ four different art - protected final String[] collectorNumbersHymnToTourach = {"38a", "38b", "38c", "38d"}; + protected final String cardNameHymnToTourach = "Hymn to Tourach"; // good 'ol hymn w/ four different art + protected final String[] collectorNumbersHymnToTourach = { "38a", "38b", "38c", "38d" }; protected final String editionHymnToTourach = "FEM"; - //Get Card From Editions Test fixtures + // Get Card From Editions Test fixtures protected final String originalArtShivanDragonEdition = "LEA"; protected final String latestArtShivanDragonEdition = "M20"; @@ -72,30 +83,31 @@ public class CardDbTestCase extends ForgeCardMockTestCase { protected final String releasedAfterAnthologiesDate = "1998-11-01"; protected final String originalArtHymnToTourachEditionReleasedAfterAnthologies = "PRM"; - // NOTE: This is the only edition (reprint) matching art preference after Anthologies + // NOTE: This is the only edition (reprint) matching art preference after + // Anthologies protected final String originalArtHymnToTourachEditionReleasedAfterAnthologiesNoPromo = "EMA"; - // Get a card that has lots of editions so that we can test fetching for specific editions and print dates + // Get a card that has lots of editions so that we can test fetching for + // specific editions and print dates protected final String cardNameCounterspell = "Counterspell"; - protected final String[] editionsCounterspell = {"3ED", "4ED", "ICE", "5ED", "TMP", "S99", "MMQ", - "BTD", "BRB", "A25", "MH2", "SLD"}; + protected final String[] editionsCounterspell = { "3ED", "4ED", "ICE", "5ED", "TMP", "S99", "MMQ", "BTD", "BRB", + "A25", "MH2", "SLD" }; protected final String counterspellReleasedBeforeMagicOnlinePromosDate = "2018-03-15"; - protected final String[] counterspellLatestArtsReleasedBeforeMagicOnlinePromos = {"MPS_AKH", "EMA"}; + protected final String[] counterspellLatestArtsReleasedBeforeMagicOnlinePromos = { "MPS_AKH", "EMA" }; protected final String counterspellReleasedBeforeEternalMastersDate = "2016-06-10"; - protected final String[] counterspellLatestArtReleasedBeforeEternalMasters = {"TPR", "7ED"}; - protected final String[] counterspellOriginalArtReleasedAfterEternalMasters = {"MPS_AKH", "A25"}; + protected final String[] counterspellLatestArtReleasedBeforeEternalMasters = { "TPR", "7ED" }; + protected final String[] counterspellOriginalArtReleasedAfterEternalMasters = { "MPS_AKH", "A25" }; protected final String counterspellReleasedAfterBattleRoyaleDate = "1999-11-12"; - protected final String[] counterspellOriginalArtReleasedAfterBattleRoyale = {"G00", "7ED"}; + protected final String[] counterspellOriginalArtReleasedAfterBattleRoyale = { "G00", "7ED" }; // test for date restrictions - boundary cases protected final String alphaEditionReleaseDate = "1993-08-05"; - @BeforeMethod - public void setup(){ + public void setup() { StaticData data = FModel.getMagicDb(); this.cardDb = data.getCommonCards(); this.legacyCardDb = new LegacyCardDb(data.getCommonCards().getAllCards(), data.getEditions()); @@ -106,7 +118,7 @@ public class CardDbTestCase extends ForgeCardMockTestCase { */ @Test - public void testGetAllCardsWithName(){ + public void testGetAllCardsWithName() { List allCounterSpellPrints = this.cardDb.getAllCards(this.cardNameCounterspell); assertNotNull(allCounterSpellPrints); for (PaperCard card : allCounterSpellPrints) @@ -114,7 +126,7 @@ public class CardDbTestCase extends ForgeCardMockTestCase { } @Test - public void testGetAllCardsThatWerePrintedInSets(){ + public void testGetAllCardsThatWerePrintedInSets() { List allowedSets = new ArrayList<>(); allowedSets.add(this.latestArtShivanDragonEdition); Predicate wasPrinted = (Predicate) this.cardDb.wasPrintedInSets(allowedSets); @@ -122,7 +134,8 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertNotNull(allCardsInSet); } - @Test void testGetAllCardsOfaGivenNameAndPrintedInSets(){ + @Test + void testGetAllCardsOfaGivenNameAndPrintedInSets() { List allowedSets = new ArrayList<>(Arrays.asList(this.editionsCounterspell)); Predicate printedInSets = (Predicate) this.cardDb.wasPrintedInSets(allowedSets); List allCounterSpellsInSets = this.cardDb.getAllCards(this.cardNameCounterspell, printedInSets); @@ -135,7 +148,7 @@ public class CardDbTestCase extends ForgeCardMockTestCase { } @Test - public void testGetAllCardsLegalInSets(){ + public void testGetAllCardsLegalInSets() { List allowedSets = new ArrayList<>(); allowedSets.add(this.latestArtShivanDragonEdition); Predicate legalInSets = (Predicate) this.cardDb.isLegal(allowedSets); @@ -145,7 +158,8 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertEquals(card.getEdition(), this.latestArtShivanDragonEdition); } - @Test void testGetAllCardsOfaGivenNameAndLegalInSets(){ + @Test + void testGetAllCardsOfaGivenNameAndLegalInSets() { List allowedSets = new ArrayList<>(Arrays.asList(this.editionsCounterspell)); Predicate legalInSets = (Predicate) this.cardDb.isLegal(allowedSets); List allCounterSpellsInSets = this.cardDb.getAllCards(this.cardNameCounterspell, legalInSets); @@ -171,7 +185,7 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertNotNull(legacyCard); assertEquals(legacyCard.getName(), cardNameShivanDragon); - //Foil card + // Foil card PaperCard legacyFoilCard = this.legacyCardDb.getCard(cardNameFoilLightningDragon); PaperCard foildCard = this.cardDb.getCard(cardNameFoilLightningDragon); @@ -199,7 +213,7 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertEquals(card, legacyCard); - //Foil card + // Foil card PaperCard legacyFoilCard = this.legacyCardDb.getCard(cardNameFoilLightningDragon, editionLightningDragon); PaperCard foildCard = this.cardDb.getCard(cardNameFoilLightningDragon, editionLightningDragon); @@ -244,8 +258,9 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertEquals(card.getEdition(), editionShivanDragon); assertEquals(card.getCollectorNumber(), collNrShivanDragon); - //Foil card - PaperCard foildCard = this.cardDb.getCard(cardNameFoilLightningDragon, editionLightningDragon, collNrLightningDragon); + // Foil card + PaperCard foildCard = this.cardDb.getCard(cardNameFoilLightningDragon, editionLightningDragon, + collNrLightningDragon); assertEquals(foildCard.getName(), cardNameLightningDragon); assertEquals(foildCard.getEdition(), editionLightningDragon); assertEquals(foildCard.getCollectorNumber(), collNrLightningDragon); @@ -267,7 +282,8 @@ public class CardDbTestCase extends ForgeCardMockTestCase { PaperCard card; for (int i = 0; i < 4; i++) { int artIndex = i + 1; - card = this.cardDb.getCard(cardNameHymnToTourach, editionHymnToTourach, artIndex, collectorNumbersHymnToTourach[i]); + card = this.cardDb.getCard(cardNameHymnToTourach, editionHymnToTourach, artIndex, + collectorNumbersHymnToTourach[i]); assertEquals(card.getName(), cardNameHymnToTourach); assertEquals(card.getEdition(), editionHymnToTourach); assertEquals(card.getCollectorNumber(), collectorNumbersHymnToTourach[i]); @@ -314,8 +330,7 @@ public class CardDbTestCase extends ForgeCardMockTestCase { @Test public void testNewGetCardFromSetWithCardNameFoilMarker() { CardEdition cardEdition = FModel.getMagicDb().getEditions().get(editionLightningDragon); - PaperCard foilCard = this.cardDb.getCardFromSet(cardNameFoilLightningDragon, - cardEdition, false); + PaperCard foilCard = this.cardDb.getCardFromSet(cardNameFoilLightningDragon, cardEdition, false); assertNotNull(foilCard); assertTrue(foilCard.isFoil()); } @@ -357,8 +372,8 @@ public class CardDbTestCase extends ForgeCardMockTestCase { @Test public void testNewGetCardFromSetWithAllInfo() { CardEdition ce = FModel.getMagicDb().getEditions().get(editionHymnToTourach); - PaperCard card = this.cardDb.getCardFromSet(cardNameHymnToTourach, ce, 2, - collectorNumbersHymnToTourach[1], false); + PaperCard card = this.cardDb.getCardFromSet(cardNameHymnToTourach, ce, 2, collectorNumbersHymnToTourach[1], + false); assertNotNull(card); assertEquals(card.getName(), cardNameHymnToTourach); assertEquals(card.getEdition(), editionHymnToTourach); @@ -366,8 +381,8 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertEquals(card.getArtIndex(), 2); assertFalse(card.isFoil()); - PaperCard foilCard = this.cardDb.getCardFromSet(cardNameHymnToTourach, ce, 2, - collectorNumbersHymnToTourach[1], true); + PaperCard foilCard = this.cardDb.getCardFromSet(cardNameHymnToTourach, ce, 2, collectorNumbersHymnToTourach[1], + true); assertNotNull(foilCard); assertTrue(foilCard.isFoil()); assertEquals(card.getArtIndex(), foilCard.getArtIndex()); @@ -378,9 +393,9 @@ public class CardDbTestCase extends ForgeCardMockTestCase { @Test public void testGetCardFromEditionsWithCardNameAndCardArtPreference() { - /* -------------- - Latest Print - -------------*/ + /* + * -------------- Latest Print ------------- + */ CardDb.CardArtPreference frame = CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS; PaperCard sdCard = this.cardDb.getCardFromEditions(cardNameShivanDragon, frame); @@ -401,9 +416,9 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertEquals(httCard.getName(), cardNameHymnToTourach); assertEquals(httCard.getEdition(), latestArtHymnToTourachEdition); - /* ---------------------- - Latest Print No Promo - ----------------------*/ + /* + * ---------------------- Latest Print No Promo ---------------------- + */ frame = CardDb.CardArtPreference.LATEST_ART_CORE_EXPANSIONS_REPRINT_ONLY; sdCard = this.cardDb.getCardFromEditions(cardNameShivanDragon, frame); @@ -424,9 +439,9 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertEquals(httCard.getName(), cardNameHymnToTourach); assertEquals(httCard.getEdition(), latestArtHymnToTourachEditionNoPromo); - /* -------------- - Old Print - -------------*/ + /* + * -------------- Old Print ------------- + */ frame = CardDb.CardArtPreference.ORIGINAL_ART_ALL_EDITIONS; sdCard = this.cardDb.getCardFromEditions(cardNameShivanDragon, frame); @@ -447,9 +462,9 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertEquals(httCard.getName(), cardNameHymnToTourach); assertEquals(httCard.getEdition(), originalArtHymnToTourachEdition); - /* -------------------- - Old Print No Promo - ----------------------*/ + /* + * -------------------- Old Print No Promo ---------------------- + */ frame = CardDb.CardArtPreference.ORIGINAL_ART_CORE_EXPANSIONS_REPRINT_ONLY; sdCard = this.cardDb.getCardFromEditions(cardNameShivanDragon, frame); @@ -473,9 +488,9 @@ public class CardDbTestCase extends ForgeCardMockTestCase { @Test public void testGetCardFromEditionsWithCardNameAndCardArtPreferenceComparedWithLegacy() { - /* -------------- - Latest Print - -------------*/ + /* + * -------------- Latest Print ------------- + */ CardDb.CardArtPreference frame = CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS; LegacyCardDb.LegacySetPreference setPreference = LegacyCardDb.LegacySetPreference.Latest; @@ -491,9 +506,9 @@ public class CardDbTestCase extends ForgeCardMockTestCase { PaperCard httCardLegacy = this.legacyCardDb.getCardFromEdition(cardNameHymnToTourach, setPreference); assertEquals(httCard, httCardLegacy); - /* ---------------------- - Latest Print No Promo - ----------------------*/ + /* + * ---------------------- Latest Print No Promo ---------------------- + */ frame = CardDb.CardArtPreference.LATEST_ART_CORE_EXPANSIONS_REPRINT_ONLY; setPreference = LegacyCardDb.LegacySetPreference.LatestCoreExp; @@ -509,9 +524,9 @@ public class CardDbTestCase extends ForgeCardMockTestCase { httCardLegacy = this.legacyCardDb.getCardFromEdition(cardNameHymnToTourach, setPreference); assertEquals(httCard, httCardLegacy); - /* -------------- - Old Print - -------------*/ + /* + * -------------- Old Print ------------- + */ frame = CardDb.CardArtPreference.ORIGINAL_ART_ALL_EDITIONS; setPreference = LegacyCardDb.LegacySetPreference.Earliest; @@ -527,9 +542,9 @@ public class CardDbTestCase extends ForgeCardMockTestCase { httCardLegacy = this.legacyCardDb.getCardFromEdition(cardNameHymnToTourach, setPreference); assertEquals(httCard, httCardLegacy); - /* -------------------- - Old Print No Promo - ----------------------*/ + /* + * -------------------- Old Print No Promo ---------------------- + */ frame = CardDb.CardArtPreference.LATEST_ART_CORE_EXPANSIONS_REPRINT_ONLY; setPreference = LegacyCardDb.LegacySetPreference.LatestCoreExp; @@ -548,13 +563,13 @@ public class CardDbTestCase extends ForgeCardMockTestCase { @Test public void testGetCardFromEditionsWithCardNameAndFramePreferenceWithArtIndex() { - /* NOTE: - testing case of errors here - will do in a separate test. + /* + * NOTE: testing case of errors here - will do in a separate test. */ - /* -------------- - Latest Print - -------------*/ + /* + * -------------- Latest Print ------------- + */ CardDb.CardArtPreference frame = CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS; PaperCard httCard = this.cardDb.getCardFromEditions(cardNameHymnToTourach, frame, 1); @@ -569,9 +584,9 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertEquals(ldFoilCard.getArtIndex(), 1); assertTrue(ldFoilCard.isFoil()); - /* ---------------------- - Latest Print No Promo - ----------------------*/ + /* + * ---------------------- Latest Print No Promo ---------------------- + */ frame = CardDb.CardArtPreference.LATEST_ART_CORE_EXPANSIONS_REPRINT_ONLY; httCard = this.cardDb.getCardFromEditions(cardNameHymnToTourach, frame, 1); @@ -586,9 +601,9 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertEquals(ldFoilCard.getArtIndex(), 1); assertTrue(ldFoilCard.isFoil()); - /* -------------- - Old Print - -------------*/ + /* + * -------------- Old Print ------------- + */ frame = CardDb.CardArtPreference.ORIGINAL_ART_ALL_EDITIONS; for (int artIdx = 1; artIdx <= 4; artIdx++) { @@ -596,7 +611,7 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertEquals(httCard.getName(), cardNameHymnToTourach); assertEquals(httCard.getEdition(), originalArtHymnToTourachEdition); assertEquals(httCard.getArtIndex(), artIdx); - assertEquals(httCard.getCollectorNumber(), collectorNumbersHymnToTourach[artIdx-1]); + assertEquals(httCard.getCollectorNumber(), collectorNumbersHymnToTourach[artIdx - 1]); } // foil card @@ -606,9 +621,9 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertEquals(ldFoilCard.getArtIndex(), 1); assertTrue(ldFoilCard.isFoil()); - /* -------------------- - Old Print No Promo - ----------------------*/ + /* + * -------------------- Old Print No Promo ---------------------- + */ frame = CardDb.CardArtPreference.ORIGINAL_ART_CORE_EXPANSIONS_REPRINT_ONLY; for (int artIdx = 1; artIdx <= 4; artIdx++) { @@ -616,7 +631,7 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertEquals(httCard.getName(), cardNameHymnToTourach); assertEquals(httCard.getEdition(), originalArtHymnToTourachEdition); assertEquals(httCard.getArtIndex(), artIdx); - assertEquals(httCard.getCollectorNumber(), collectorNumbersHymnToTourach[artIdx-1]); + assertEquals(httCard.getCollectorNumber(), collectorNumbersHymnToTourach[artIdx - 1]); } // foil card @@ -665,7 +680,7 @@ public class CardDbTestCase extends ForgeCardMockTestCase { } @Test - public void testGetCardFromEditionsUsingDefaultCardArtPreference(){ + public void testGetCardFromEditionsUsingDefaultCardArtPreference() { // Test default value first assertEquals(this.cardDb.getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); PaperCard shivanDragonCard = this.cardDb.getCardFromEditions(cardNameShivanDragon); @@ -681,7 +696,8 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertEquals(this.cardDb.getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); } - // == Specialised Card Art Preference Retrieval and Release Date Constraint (BEFORE) + // == Specialised Card Art Preference Retrieval and Release Date Constraint + // (BEFORE) @Test public void testGetCardFromEditionsWithCardNameAndCardArtPreferenceReleasedBeforeDate() { // Set Reference Dates @@ -697,79 +713,91 @@ public class CardDbTestCase extends ForgeCardMockTestCase { fail(); } - /* -------------- - Latest Print - -------------*/ + /* + * -------------- Latest Print ------------- + */ CardDb.CardArtPreference artPreference = CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS; - PaperCard sdCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameShivanDragon, artPreference, fromTheVaultReleaseDate); + PaperCard sdCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameShivanDragon, artPreference, + fromTheVaultReleaseDate); assertEquals(sdCard.getName(), cardNameShivanDragon); assertEquals(sdCard.getEdition(), latestArtShivanDragonEditionReleasedBeforeFromTheVault); // foiled card request - PaperCard ldFoilCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameFoilLightningDragon, artPreference, fromTheVaultReleaseDate); + PaperCard ldFoilCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameFoilLightningDragon, artPreference, + fromTheVaultReleaseDate); assertEquals(ldFoilCard.getName(), cardNameLightningDragon); assertEquals(ldFoilCard.getEdition(), latestArtLightningDragonEditionReleasedBeforeFromTheVault); assertTrue(ldFoilCard.isFoil()); - PaperCard httCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameHymnToTourach, artPreference, eternalMastersReleaseDate); + PaperCard httCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameHymnToTourach, artPreference, + eternalMastersReleaseDate); assertEquals(httCard.getName(), cardNameHymnToTourach); assertEquals(httCard.getEdition(), latestArtHymnToTourachEditionReleasedBeforeEternalMasters); - /* ---------------------- - Latest Print No Promo - ----------------------*/ + /* + * ---------------------- Latest Print No Promo ---------------------- + */ artPreference = CardDb.CardArtPreference.LATEST_ART_CORE_EXPANSIONS_REPRINT_ONLY; - sdCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameShivanDragon, artPreference, fromTheVaultReleaseDate); + sdCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameShivanDragon, artPreference, + fromTheVaultReleaseDate); assertEquals(sdCard.getName(), cardNameShivanDragon); assertEquals(sdCard.getEdition(), latestArtShivanDragonEditionReleasedBeforeFromTheVaultNoPromo); // foiled card request - ldFoilCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameFoilLightningDragon, artPreference, fromTheVaultReleaseDate); + ldFoilCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameFoilLightningDragon, artPreference, + fromTheVaultReleaseDate); assertEquals(ldFoilCard.getName(), cardNameLightningDragon); assertEquals(ldFoilCard.getEdition(), latestArtLightningDragonEditionReleasedBeforeFromTheVaultNoPromo); assertTrue(ldFoilCard.isFoil()); - httCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameHymnToTourach, artPreference, eternalMastersReleaseDate); + httCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameHymnToTourach, artPreference, + eternalMastersReleaseDate); assertEquals(httCard.getName(), cardNameHymnToTourach); assertEquals(httCard.getEdition(), latestArtHymnToTourachEditionReleasedBeforeEternalMastersNoPromo); - /* -------------- - Old Print - -------------*/ + /* + * -------------- Old Print ------------- + */ artPreference = CardDb.CardArtPreference.ORIGINAL_ART_ALL_EDITIONS; - sdCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameShivanDragon, artPreference, fromTheVaultReleaseDate); + sdCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameShivanDragon, artPreference, + fromTheVaultReleaseDate); assertEquals(sdCard.getName(), cardNameShivanDragon); assertEquals(sdCard.getEdition(), originalArtShivanDragonEdition); // foiled card request - ldFoilCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameFoilLightningDragon, artPreference, fromTheVaultReleaseDate); + ldFoilCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameFoilLightningDragon, artPreference, + fromTheVaultReleaseDate); assertEquals(ldFoilCard.getName(), cardNameLightningDragon); assertEquals(ldFoilCard.getEdition(), originalArtLightningDragonEdition); assertTrue(ldFoilCard.isFoil()); - httCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameHymnToTourach, artPreference, eternalMastersReleaseDate); + httCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameHymnToTourach, artPreference, + eternalMastersReleaseDate); assertEquals(httCard.getName(), cardNameHymnToTourach); assertEquals(httCard.getEdition(), originalArtHymnToTourachEdition); - /* -------------------- - Old Print No Promo - ----------------------*/ + /* + * -------------------- Old Print No Promo ---------------------- + */ artPreference = CardDb.CardArtPreference.ORIGINAL_ART_CORE_EXPANSIONS_REPRINT_ONLY; - sdCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameShivanDragon, artPreference, fromTheVaultReleaseDate); + sdCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameShivanDragon, artPreference, + fromTheVaultReleaseDate); assertEquals(sdCard.getName(), cardNameShivanDragon); assertEquals(sdCard.getEdition(), originalArtShivanDragonEdition); // foiled card request - ldFoilCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameFoilLightningDragon, artPreference, fromTheVaultReleaseDate); + ldFoilCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameFoilLightningDragon, artPreference, + fromTheVaultReleaseDate); assertEquals(ldFoilCard.getName(), cardNameLightningDragon); assertEquals(ldFoilCard.getEdition(), originalArtLightningDragonEditionNoPromo); assertTrue(ldFoilCard.isFoil()); - httCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameHymnToTourach, artPreference, eternalMastersReleaseDate); + httCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameHymnToTourach, artPreference, + eternalMastersReleaseDate); assertEquals(httCard.getName(), cardNameHymnToTourach); assertEquals(httCard.getEdition(), originalArtHymnToTourachEditionNoPromo); } @@ -789,23 +817,26 @@ public class CardDbTestCase extends ForgeCardMockTestCase { fail(); } - /* -------------- - Latest Print - -------------*/ + /* + * -------------- Latest Print ------------- + */ CardDb.CardArtPreference artPreference = CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS; LegacyCardDb.LegacySetPreference setPref = LegacyCardDb.LegacySetPreference.Latest; - PaperCard sdCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameShivanDragon, artPreference, sdReleaseDate); + PaperCard sdCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameShivanDragon, artPreference, + sdReleaseDate); PaperCard sdCardLegacy = this.legacyCardDb.getCardFromEdition(cardNameShivanDragon, sdReleaseDate, setPref); assertEquals(sdCard.getEdition(), latestArtShivanDragonEditionReleasedBeforeFromTheVault); assertEquals(sdCard, sdCardLegacy); - PaperCard ldCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameLightningDragon, artPreference, sdReleaseDate); + PaperCard ldCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameLightningDragon, artPreference, + sdReleaseDate); PaperCard ldCardLegacy = this.legacyCardDb.getCardFromEdition(cardNameLightningDragon, sdReleaseDate, setPref); assertEquals(ldCard.getEdition(), latestArtLightningDragonEditionReleasedBeforeFromTheVault); assertEquals(ldCard, ldCardLegacy); - PaperCard httCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameHymnToTourach, artPreference, httReleaseDate); + PaperCard httCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameHymnToTourach, artPreference, + httReleaseDate); PaperCard httCardLegacy = this.legacyCardDb.getCardFromEdition(cardNameHymnToTourach, httReleaseDate, setPref); assertEquals(httCard.getEdition(), latestArtHymnToTourachEditionReleasedBeforeEternalMasters); assertEquals(httCard, httCardLegacy); @@ -828,9 +859,9 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertEquals(httCard.getEdition(), latestArtHymnToTourachEditionReleasedBeforeEternalMasters); assertEquals(httCard, httCardLegacy); - /* ---------------------- - Latest Print No Promo - ----------------------*/ + /* + * ---------------------- Latest Print No Promo ---------------------- + */ artPreference = CardDb.CardArtPreference.LATEST_ART_CORE_EXPANSIONS_REPRINT_ONLY; setPref = LegacyCardDb.LegacySetPreference.LatestCoreExp; @@ -849,9 +880,9 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertEquals(httCard.getEdition(), latestArtHymnToTourachEditionReleasedBeforeEternalMastersNoPromo); assertEquals(httCard, httCardLegacy); - /* -------------- - Old Print - -------------*/ + /* + * -------------- Old Print ------------- + */ artPreference = CardDb.CardArtPreference.ORIGINAL_ART_ALL_EDITIONS; setPref = LegacyCardDb.LegacySetPreference.Earliest; @@ -870,9 +901,9 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertEquals(httCard.getEdition(), originalArtHymnToTourachEdition); assertEquals(httCard, httCardLegacy); - /* -------------------- - Old Print No Promo - ----------------------*/ + /* + * -------------------- Old Print No Promo ---------------------- + */ artPreference = CardDb.CardArtPreference.ORIGINAL_ART_CORE_EXPANSIONS_REPRINT_ONLY; setPref = LegacyCardDb.LegacySetPreference.EarliestCoreExp; @@ -894,7 +925,8 @@ public class CardDbTestCase extends ForgeCardMockTestCase { @Test public void testGetCardFromEditionsWithCardNameAndCardArtPreferenceReleasedBeforeDateComparedWithLegacyAlsoIncludingArtIndex() { - // NOTE: Not passing in ArtIndex (so testing w/ default value) whenever artIndex is irrelevant (already default) + // NOTE: Not passing in ArtIndex (so testing w/ default value) whenever artIndex + // is irrelevant (already default) // Set Reference Dates Date sdReleaseDate = null; Date httReleaseDate = null; @@ -908,30 +940,35 @@ public class CardDbTestCase extends ForgeCardMockTestCase { fail(); } - /* -------------- - Latest Print - -------------*/ + /* + * -------------- Latest Print ------------- + */ CardDb.CardArtPreference artPreference = CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS; LegacyCardDb.LegacySetPreference setPref = LegacyCardDb.LegacySetPreference.Latest; - PaperCard sdCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameShivanDragon, artPreference, sdReleaseDate); + PaperCard sdCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameShivanDragon, artPreference, + sdReleaseDate); PaperCard sdCardLegacy = this.legacyCardDb.getCardFromEdition(cardNameShivanDragon, sdReleaseDate, setPref, 1); assertEquals(sdCard.getEdition(), latestArtShivanDragonEditionReleasedBeforeFromTheVault); assertEquals(sdCard, sdCardLegacy); - PaperCard ldCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameLightningDragon, artPreference, sdReleaseDate); - PaperCard ldCardLegacy = this.legacyCardDb.getCardFromEdition(cardNameLightningDragon, sdReleaseDate, setPref, 1); + PaperCard ldCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameLightningDragon, artPreference, + sdReleaseDate); + PaperCard ldCardLegacy = this.legacyCardDb.getCardFromEdition(cardNameLightningDragon, sdReleaseDate, setPref, + 1); assertEquals(ldCard.getEdition(), latestArtLightningDragonEditionReleasedBeforeFromTheVault); assertEquals(ldCard, ldCardLegacy); - PaperCard httCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameHymnToTourach, artPreference, httReleaseDate); - PaperCard httCardLegacy = this.legacyCardDb.getCardFromEdition(cardNameHymnToTourach, httReleaseDate, setPref, 1); + PaperCard httCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameHymnToTourach, artPreference, + httReleaseDate); + PaperCard httCardLegacy = this.legacyCardDb.getCardFromEdition(cardNameHymnToTourach, httReleaseDate, setPref, + 1); assertEquals(httCard.getEdition(), latestArtHymnToTourachEditionReleasedBeforeEternalMasters); assertEquals(httCard, httCardLegacy); - /* ---------------------- - Latest Print No Promo - ----------------------*/ + /* + * ---------------------- Latest Print No Promo ---------------------- + */ artPreference = CardDb.CardArtPreference.LATEST_ART_CORE_EXPANSIONS_REPRINT_ONLY; setPref = LegacyCardDb.LegacySetPreference.LatestCoreExp; @@ -950,9 +987,9 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertEquals(httCard.getEdition(), latestArtHymnToTourachEditionReleasedBeforeEternalMastersNoPromo); assertEquals(httCard, httCardLegacy); - /* -------------- - Old Print - -------------*/ + /* + * -------------- Old Print ------------- + */ artPreference = CardDb.CardArtPreference.ORIGINAL_ART_ALL_EDITIONS; setPref = LegacyCardDb.LegacySetPreference.Earliest; @@ -967,15 +1004,17 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertEquals(ldCard, ldCardLegacy); for (int artIdx = 1; artIdx <= 4; artIdx++) { - httCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameHymnToTourach, artPreference, artIdx, httReleaseDate); - httCardLegacy = this.legacyCardDb.getCardFromEdition(cardNameHymnToTourach, httReleaseDate, setPref, artIdx); - assertEquals(httCard.getCollectorNumber(), collectorNumbersHymnToTourach[artIdx-1]); + httCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameHymnToTourach, artPreference, artIdx, + httReleaseDate); + httCardLegacy = this.legacyCardDb.getCardFromEdition(cardNameHymnToTourach, httReleaseDate, setPref, + artIdx); + assertEquals(httCard.getCollectorNumber(), collectorNumbersHymnToTourach[artIdx - 1]); assertEquals(httCard, httCardLegacy); } - /* -------------------- - Old Print No Promo - ----------------------*/ + /* + * -------------------- Old Print No Promo ---------------------- + */ artPreference = CardDb.CardArtPreference.ORIGINAL_ART_CORE_EXPANSIONS_REPRINT_ONLY; setPref = LegacyCardDb.LegacySetPreference.EarliestCoreExp; @@ -990,33 +1029,38 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertEquals(ldCard, ldCardLegacy); for (int artIdx = 1; artIdx <= 4; artIdx++) { - httCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameHymnToTourach, artPreference, artIdx, httReleaseDate); - httCardLegacy = this.legacyCardDb.getCardFromEdition(cardNameHymnToTourach, httReleaseDate, setPref, artIdx); - assertEquals(httCard.getCollectorNumber(), collectorNumbersHymnToTourach[artIdx-1]); + httCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameHymnToTourach, artPreference, artIdx, + httReleaseDate); + httCardLegacy = this.legacyCardDb.getCardFromEdition(cardNameHymnToTourach, httReleaseDate, setPref, + artIdx); + assertEquals(httCard.getCollectorNumber(), collectorNumbersHymnToTourach[artIdx - 1]); assertEquals(httCard, httCardLegacy); } // Testing with default value of CardArt Preference with multiple artIndex assertEquals(this.cardDb.getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); - this.cardDb.setCardArtPreference(false, true); // Original Print, Filter on Core - assertEquals(this.cardDb.getCardArtPreference(), CardDb.CardArtPreference.ORIGINAL_ART_CORE_EXPANSIONS_REPRINT_ONLY); + this.cardDb.setCardArtPreference(false, true); // Original Print, Filter on Core + assertEquals(this.cardDb.getCardArtPreference(), + CardDb.CardArtPreference.ORIGINAL_ART_CORE_EXPANSIONS_REPRINT_ONLY); for (int artIdx = 1; artIdx <= 4; artIdx++) { httCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameHymnToTourach, artIdx, httReleaseDate); - httCardLegacy = this.legacyCardDb.getCardFromEdition(cardNameHymnToTourach, httReleaseDate, setPref, artIdx); - assertEquals(httCard.getCollectorNumber(), collectorNumbersHymnToTourach[artIdx-1]); + httCardLegacy = this.legacyCardDb.getCardFromEdition(cardNameHymnToTourach, httReleaseDate, setPref, + artIdx); + assertEquals(httCard.getCollectorNumber(), collectorNumbersHymnToTourach[artIdx - 1]); assertEquals(httCard, httCardLegacy); } // Restore Default Card Art Preference, for later use - this.cardDb.setCardArtPreference(true, false); // Latest Print, NO Filter + this.cardDb.setCardArtPreference(true, false); // Latest Print, NO Filter assertEquals(this.cardDb.getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); } - // == Specialised Card Art Preference Retrieval and Release Date Constraint (AFTER) + // == Specialised Card Art Preference Retrieval and Release Date Constraint + // (AFTER) @Test - public void testGetCardFromEditionsWithCardNameAndCardArtPreferenceReleasedAfterDate(){ + public void testGetCardFromEditionsWithCardNameAndCardArtPreferenceReleasedAfterDate() { // Set Reference Dates Date tenthEditionReleaseDate = null; Date anthologiesDate = null; @@ -1033,29 +1077,34 @@ public class CardDbTestCase extends ForgeCardMockTestCase { // == Original Art CardDb.CardArtPreference artPreference = CardDb.CardArtPreference.ORIGINAL_ART_ALL_EDITIONS; - PaperCard sdCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameShivanDragon, artPreference, tenthEditionReleaseDate); + PaperCard sdCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameShivanDragon, artPreference, + tenthEditionReleaseDate); assertEquals(sdCard.getName(), cardNameShivanDragon); assertEquals(sdCard.getEdition(), originalArtShivanDragonEditionReleasedAfterTenthEdition); // foiled card request - PaperCard ldFoilCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameFoilLightningDragon, artPreference, tenthEditionReleaseDate); + PaperCard ldFoilCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameFoilLightningDragon, artPreference, + tenthEditionReleaseDate); assertEquals(ldFoilCard.getName(), cardNameLightningDragon); assertEquals(ldFoilCard.getEdition(), originalArtLightningDragonEditionReleasedAfterTenthEdition); assertTrue(ldFoilCard.isFoil()); - PaperCard httCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameHymnToTourach, artPreference, anthologiesDate); + PaperCard httCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameHymnToTourach, artPreference, + anthologiesDate); assertEquals(httCard.getName(), cardNameHymnToTourach); assertEquals(httCard.getEdition(), originalArtHymnToTourachEditionReleasedAfterAnthologies); // == Original Art NO PROMO artPreference = CardDb.CardArtPreference.ORIGINAL_ART_CORE_EXPANSIONS_REPRINT_ONLY; - sdCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameShivanDragon, artPreference, tenthEditionReleaseDate); + sdCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameShivanDragon, artPreference, + tenthEditionReleaseDate); assertEquals(sdCard.getName(), cardNameShivanDragon); assertEquals(sdCard.getEdition(), originalArtShivanDragonEditionReleasedAfterTenthEditionNoPromo); // foiled card request - ldFoilCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameFoilLightningDragon, artPreference, tenthEditionReleaseDate); + ldFoilCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameFoilLightningDragon, artPreference, + tenthEditionReleaseDate); assertEquals(ldFoilCard.getName(), cardNameLightningDragon); assertEquals(ldFoilCard.getEdition(), originalArtLightningDragonEditionReleasedAfterTenthEditionNoPromo); assertTrue(ldFoilCard.isFoil()); @@ -1064,15 +1113,17 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertEquals(httCard.getName(), cardNameHymnToTourach); assertEquals(httCard.getEdition(), originalArtHymnToTourachEditionReleasedAfterAnthologiesNoPromo); - // == Latest Art + // == Latest Art artPreference = CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS; - sdCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameShivanDragon, artPreference, tenthEditionReleaseDate); + sdCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameShivanDragon, artPreference, + tenthEditionReleaseDate); assertEquals(sdCard.getName(), cardNameShivanDragon); assertEquals(sdCard.getEdition(), latestArtShivanDragonEdition); // foiled card request - ldFoilCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameFoilLightningDragon, artPreference, tenthEditionReleaseDate); + ldFoilCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameFoilLightningDragon, artPreference, + tenthEditionReleaseDate); assertEquals(ldFoilCard.getName(), cardNameLightningDragon); assertEquals(ldFoilCard.getEdition(), latestArtLightningDragonEdition); assertTrue(ldFoilCard.isFoil()); @@ -1084,12 +1135,14 @@ public class CardDbTestCase extends ForgeCardMockTestCase { // == Latest Art NO PROMO artPreference = CardDb.CardArtPreference.LATEST_ART_CORE_EXPANSIONS_REPRINT_ONLY; - sdCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameShivanDragon, artPreference, tenthEditionReleaseDate); + sdCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameShivanDragon, artPreference, + tenthEditionReleaseDate); assertEquals(sdCard.getName(), cardNameShivanDragon); assertEquals(sdCard.getEdition(), latestArtShivanDragonEdition); // foiled card request - ldFoilCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameFoilLightningDragon, artPreference, tenthEditionReleaseDate); + ldFoilCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameFoilLightningDragon, artPreference, + tenthEditionReleaseDate); assertEquals(ldFoilCard.getName(), cardNameLightningDragon); assertEquals(ldFoilCard.getEdition(), latestArtLightningDragonEdition); assertTrue(ldFoilCard.isFoil()); @@ -1100,7 +1153,7 @@ public class CardDbTestCase extends ForgeCardMockTestCase { } @Test - public void testGetCardFromEditionsWithCardNameAndCardArtPreferenceReleasedAfterDateAlsoIncludingArtIndex(){ + public void testGetCardFromEditionsWithCardNameAndCardArtPreferenceReleasedAfterDateAlsoIncludingArtIndex() { // Set Reference Dates Date tenthEditionReleaseDate = null; Date anthologiesDate = null; @@ -1120,71 +1173,82 @@ public class CardDbTestCase extends ForgeCardMockTestCase { // == Original Art CardDb.CardArtPreference artPreference = CardDb.CardArtPreference.ORIGINAL_ART_ALL_EDITIONS; - PaperCard sdCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameShivanDragon, artPreference, 1, tenthEditionReleaseDate); + PaperCard sdCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameShivanDragon, artPreference, 1, + tenthEditionReleaseDate); assertEquals(sdCard.getName(), cardNameShivanDragon); assertEquals(sdCard.getEdition(), originalArtShivanDragonEditionReleasedAfterTenthEdition); assertEquals(sdCard.getArtIndex(), 1); // foiled card request - PaperCard ldFoilCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameFoilLightningDragon, artPreference, 1, tenthEditionReleaseDate); + PaperCard ldFoilCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameFoilLightningDragon, artPreference, + 1, tenthEditionReleaseDate); assertEquals(ldFoilCard.getName(), cardNameLightningDragon); assertEquals(ldFoilCard.getEdition(), originalArtLightningDragonEditionReleasedAfterTenthEdition); assertTrue(ldFoilCard.isFoil()); assertEquals(ldFoilCard.getArtIndex(), 1); - PaperCard httCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameHymnToTourach, artPreference, 1, anthologiesDate); + PaperCard httCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameHymnToTourach, artPreference, 1, + anthologiesDate); assertEquals(httCard.getName(), cardNameHymnToTourach); assertEquals(httCard.getEdition(), originalArtHymnToTourachEditionReleasedAfterAnthologies); assertEquals(httCard.getArtIndex(), 1); for (int artIdx = 1; artIdx <= 4; artIdx++) { - httCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameHymnToTourach, artPreference, artIdx, alphaRelaseDate); - assertEquals(httCard.getCollectorNumber(), collectorNumbersHymnToTourach[artIdx-1]); + httCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameHymnToTourach, artPreference, artIdx, + alphaRelaseDate); + assertEquals(httCard.getCollectorNumber(), collectorNumbersHymnToTourach[artIdx - 1]); assertEquals(httCard.getArtIndex(), artIdx); } // == Original Art NO PROMO artPreference = CardDb.CardArtPreference.ORIGINAL_ART_CORE_EXPANSIONS_REPRINT_ONLY; - sdCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameShivanDragon, artPreference, 1, tenthEditionReleaseDate); + sdCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameShivanDragon, artPreference, 1, + tenthEditionReleaseDate); assertEquals(sdCard.getName(), cardNameShivanDragon); assertEquals(sdCard.getEdition(), originalArtShivanDragonEditionReleasedAfterTenthEditionNoPromo); assertEquals(sdCard.getArtIndex(), 1); // foiled card request - ldFoilCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameFoilLightningDragon, artPreference, 1, tenthEditionReleaseDate); + ldFoilCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameFoilLightningDragon, artPreference, 1, + tenthEditionReleaseDate); assertEquals(ldFoilCard.getName(), cardNameLightningDragon); assertEquals(ldFoilCard.getEdition(), originalArtLightningDragonEditionReleasedAfterTenthEditionNoPromo); assertTrue(ldFoilCard.isFoil()); assertEquals(ldFoilCard.getArtIndex(), 1); - httCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameHymnToTourach, artPreference, 1, anthologiesDate); + httCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameHymnToTourach, artPreference, 1, + anthologiesDate); assertEquals(httCard.getName(), cardNameHymnToTourach); assertEquals(httCard.getEdition(), originalArtHymnToTourachEditionReleasedAfterAnthologiesNoPromo); assertEquals(httCard.getArtIndex(), 1); for (int artIdx = 1; artIdx <= 4; artIdx++) { - httCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameHymnToTourach, artPreference, artIdx, alphaRelaseDate); - assertEquals(httCard.getCollectorNumber(), collectorNumbersHymnToTourach[artIdx-1]); + httCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameHymnToTourach, artPreference, artIdx, + alphaRelaseDate); + assertEquals(httCard.getCollectorNumber(), collectorNumbersHymnToTourach[artIdx - 1]); assertEquals(httCard.getArtIndex(), artIdx); } // == Latest Art artPreference = CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS; - sdCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameShivanDragon, artPreference, 1, tenthEditionReleaseDate); + sdCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameShivanDragon, artPreference, 1, + tenthEditionReleaseDate); assertEquals(sdCard.getName(), cardNameShivanDragon); assertEquals(sdCard.getEdition(), latestArtShivanDragonEdition); assertEquals(sdCard.getArtIndex(), 1); // foiled card request - ldFoilCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameFoilLightningDragon, artPreference, 1, tenthEditionReleaseDate); + ldFoilCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameFoilLightningDragon, artPreference, 1, + tenthEditionReleaseDate); assertEquals(ldFoilCard.getName(), cardNameLightningDragon); assertEquals(ldFoilCard.getEdition(), latestArtLightningDragonEdition); assertTrue(ldFoilCard.isFoil()); assertEquals(ldFoilCard.getArtIndex(), 1); - httCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameHymnToTourach, artPreference, 1, anthologiesDate); + httCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameHymnToTourach, artPreference, 1, + anthologiesDate); assertEquals(httCard.getName(), cardNameHymnToTourach); assertEquals(httCard.getEdition(), latestArtHymnToTourachEdition); assertEquals(httCard.getArtIndex(), 1); @@ -1192,26 +1256,29 @@ public class CardDbTestCase extends ForgeCardMockTestCase { // == Latest Art NO PROMO artPreference = CardDb.CardArtPreference.LATEST_ART_CORE_EXPANSIONS_REPRINT_ONLY; - sdCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameShivanDragon, artPreference, 1, tenthEditionReleaseDate); + sdCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameShivanDragon, artPreference, 1, + tenthEditionReleaseDate); assertEquals(sdCard.getName(), cardNameShivanDragon); assertEquals(sdCard.getEdition(), latestArtShivanDragonEdition); assertEquals(sdCard.getArtIndex(), 1); // foiled card request - ldFoilCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameFoilLightningDragon, artPreference, 1, tenthEditionReleaseDate); + ldFoilCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameFoilLightningDragon, artPreference, 1, + tenthEditionReleaseDate); assertEquals(ldFoilCard.getName(), cardNameLightningDragon); assertEquals(ldFoilCard.getEdition(), latestArtLightningDragonEdition); assertTrue(ldFoilCard.isFoil()); assertEquals(ldFoilCard.getArtIndex(), 1); - httCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameHymnToTourach, artPreference, 1, anthologiesDate); + httCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameHymnToTourach, artPreference, 1, + anthologiesDate); assertEquals(httCard.getName(), cardNameHymnToTourach); assertEquals(httCard.getEdition(), latestArtHymnToTourachEditionNoPromo); assertEquals(httCard.getArtIndex(), 1); } @Test - public void testGetCardFromEditionsAfterReleaseDateUsingDefaultCardArtPreference(){ + public void testGetCardFromEditionsAfterReleaseDateUsingDefaultCardArtPreference() { assertEquals(this.cardDb.getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); // Set Reference Dates Date tenthEditionReleaseDate = null; @@ -1229,10 +1296,11 @@ public class CardDbTestCase extends ForgeCardMockTestCase { fail(); } - // == NOTE == Avoiding passing in also ArtIndex when it's not relevant (i.e. different than default) + // == NOTE == Avoiding passing in also ArtIndex when it's not relevant (i.e. + // different than default) // == Original Art - this.cardDb.setCardArtPreference(false, false); // Original Print, Filter on Core + this.cardDb.setCardArtPreference(false, false); // Original Print, Filter on Core assertEquals(this.cardDb.getCardArtPreference(), CardDb.CardArtPreference.ORIGINAL_ART_ALL_EDITIONS); PaperCard sdCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameShivanDragon, tenthEditionReleaseDate); @@ -1241,7 +1309,8 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertEquals(sdCard.getArtIndex(), 1); // foiled card request - PaperCard ldFoilCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameFoilLightningDragon, tenthEditionReleaseDate); + PaperCard ldFoilCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameFoilLightningDragon, + tenthEditionReleaseDate); assertEquals(ldFoilCard.getName(), cardNameLightningDragon); assertEquals(ldFoilCard.getEdition(), originalArtLightningDragonEditionReleasedAfterTenthEdition); assertTrue(ldFoilCard.isFoil()); @@ -1254,13 +1323,14 @@ public class CardDbTestCase extends ForgeCardMockTestCase { for (int artIdx = 1; artIdx <= 4; artIdx++) { httCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameHymnToTourach, artIdx, alphaRelaseDate); - assertEquals(httCard.getCollectorNumber(), collectorNumbersHymnToTourach[artIdx-1]); + assertEquals(httCard.getCollectorNumber(), collectorNumbersHymnToTourach[artIdx - 1]); assertEquals(httCard.getArtIndex(), artIdx); } // == Original Art NO PROMO - this.cardDb.setCardArtPreference(false, true); // Original Print, Filter on Core - assertEquals(this.cardDb.getCardArtPreference(), CardDb.CardArtPreference.ORIGINAL_ART_CORE_EXPANSIONS_REPRINT_ONLY); + this.cardDb.setCardArtPreference(false, true); // Original Print, Filter on Core + assertEquals(this.cardDb.getCardArtPreference(), + CardDb.CardArtPreference.ORIGINAL_ART_CORE_EXPANSIONS_REPRINT_ONLY); sdCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameShivanDragon, tenthEditionReleaseDate); assertEquals(sdCard.getName(), cardNameShivanDragon); @@ -1281,19 +1351,19 @@ public class CardDbTestCase extends ForgeCardMockTestCase { for (int artIdx = 1; artIdx <= 4; artIdx++) { httCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameHymnToTourach, artIdx, alphaRelaseDate); - assertEquals(httCard.getCollectorNumber(), collectorNumbersHymnToTourach[artIdx-1]); + assertEquals(httCard.getCollectorNumber(), collectorNumbersHymnToTourach[artIdx - 1]); assertEquals(httCard.getArtIndex(), artIdx); } // Restore Default Card Art Preference, for later use - this.cardDb.setCardArtPreference(true, false); // Latest Print, NO Filter + this.cardDb.setCardArtPreference(true, false); // Latest Print, NO Filter assertEquals(this.cardDb.getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); } @Test - public void testCounterSpellManyEditionsAlsoWithDateRestrictionsAndCardArtPreferences(){ + public void testCounterSpellManyEditionsAlsoWithDateRestrictionsAndCardArtPreferences() { // Test fetching counterspell at different editions - for (String setCode : this.editionsCounterspell){ + for (String setCode : this.editionsCounterspell) { PaperCard counterSpell = this.cardDb.getCard(this.cardNameCounterspell, setCode); assertEquals(counterSpell.getName(), this.cardNameCounterspell); assertEquals(counterSpell.getEdition(), setCode); @@ -1364,41 +1434,49 @@ public class CardDbTestCase extends ForgeCardMockTestCase { // == Latest Art this.cardDb.setCardArtPreference(true, false); - counterSpellCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameCounterspell, releaseDatebeforeMagicOnlinePromos); + counterSpellCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameCounterspell, + releaseDatebeforeMagicOnlinePromos); assertEquals(counterSpellCard.getName(), cardNameCounterspell); assertEquals(counterSpellCard.getEdition(), counterspellLatestArtsReleasedBeforeMagicOnlinePromos[0]); - counterSpellCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameCounterspell, releaseDateBeforeEternalMasters); + counterSpellCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameCounterspell, + releaseDateBeforeEternalMasters); assertEquals(counterSpellCard.getName(), cardNameCounterspell); assertEquals(counterSpellCard.getEdition(), counterspellLatestArtReleasedBeforeEternalMasters[0]); // == Latest Art No Promo this.cardDb.setCardArtPreference(true, true); - counterSpellCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameCounterspell, releaseDatebeforeMagicOnlinePromos); + counterSpellCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameCounterspell, + releaseDatebeforeMagicOnlinePromos); assertEquals(counterSpellCard.getName(), cardNameCounterspell); assertEquals(counterSpellCard.getEdition(), counterspellLatestArtsReleasedBeforeMagicOnlinePromos[1]); - counterSpellCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameCounterspell, releaseDateBeforeEternalMasters); + counterSpellCard = this.cardDb.getCardFromEditionsReleasedBefore(cardNameCounterspell, + releaseDateBeforeEternalMasters); assertEquals(counterSpellCard.getName(), cardNameCounterspell); assertEquals(counterSpellCard.getEdition(), counterspellLatestArtReleasedBeforeEternalMasters[1]); // == Original Art this.cardDb.setCardArtPreference(false, false); - counterSpellCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameCounterspell, releaseDateBeforeEternalMasters); + counterSpellCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameCounterspell, + releaseDateBeforeEternalMasters); assertEquals(counterSpellCard.getName(), cardNameCounterspell); assertEquals(counterSpellCard.getEdition(), counterspellOriginalArtReleasedAfterEternalMasters[0]); - counterSpellCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameCounterspell, releaseDateAfterBattleRoyale); + counterSpellCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameCounterspell, + releaseDateAfterBattleRoyale); assertEquals(counterSpellCard.getName(), cardNameCounterspell); assertEquals(counterSpellCard.getEdition(), counterspellOriginalArtReleasedAfterBattleRoyale[0]); // == Original Art No Promo this.cardDb.setCardArtPreference(false, true); - counterSpellCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameCounterspell, releaseDateBeforeEternalMasters); + counterSpellCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameCounterspell, + releaseDateBeforeEternalMasters); assertEquals(counterSpellCard.getName(), cardNameCounterspell); assertEquals(counterSpellCard.getEdition(), counterspellOriginalArtReleasedAfterEternalMasters[1]); - counterSpellCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameCounterspell, releaseDateAfterBattleRoyale); + counterSpellCard = this.cardDb.getCardFromEditionsReleasedAfter(cardNameCounterspell, + releaseDateAfterBattleRoyale); assertEquals(counterSpellCard.getName(), cardNameCounterspell); assertEquals(counterSpellCard.getEdition(), counterspellOriginalArtReleasedAfterBattleRoyale[1]); @@ -1407,17 +1485,17 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertEquals(this.cardDb.getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); } - // == Testing other Non-Correct Input Parameter values @Test - public void testGetCardByNameWithNull(){ + public void testGetCardByNameWithNull() { PaperCard nullCard = this.cardDb.getCard(null); assertNull(nullCard); } @Test - public void testGetCardByNameAndSetWithNullSet(){ - /*If no set is specified, the method will ultimately resort to be using the + public void testGetCardByNameAndSetWithNullSet() { + /* + * If no set is specified, the method will ultimately resort to be using the * CardArtPreference policy to retrieve a copy of the card requested. */ PaperCard httCard = this.cardDb.getCard(cardNameHymnToTourach, null); @@ -1428,7 +1506,8 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertEquals(httCard.getEdition(), latestArtHymnToTourachEdition); // Try changing the policy this.cardDb.setCardArtPreference(false, true); - assertEquals(this.cardDb.getCardArtPreference(), CardDb.CardArtPreference.ORIGINAL_ART_CORE_EXPANSIONS_REPRINT_ONLY); + assertEquals(this.cardDb.getCardArtPreference(), + CardDb.CardArtPreference.ORIGINAL_ART_CORE_EXPANSIONS_REPRINT_ONLY); httCard = this.cardDb.getCardFromEditions(cardNameHymnToTourach); assertEquals(httCard.getEdition(), originalArtHymnToTourachEditionNoPromo); // restore default @@ -1437,7 +1516,7 @@ public class CardDbTestCase extends ForgeCardMockTestCase { } @Test - public void testGetCardByNameAndSetWitNegativeArtIndex(){ + public void testGetCardByNameAndSetWitNegativeArtIndex() { PaperCard httCard = this.cardDb.getCard(cardNameHymnToTourach, editionHymnToTourach, -10); assertNotNull(httCard); assertEquals(httCard.getName(), cardNameHymnToTourach); @@ -1447,7 +1526,7 @@ public class CardDbTestCase extends ForgeCardMockTestCase { } @Test - public void testThatCardRequestPassedInHaveNoSideEffectAndThatAreCorrectlyProcessed(){ + public void testThatCardRequestPassedInHaveNoSideEffectAndThatAreCorrectlyProcessed() { String cardName = this.cardNameHymnToTourach; String httEdition = this.originalArtHymnToTourachEdition; int artIndexFEM = 3; @@ -1478,14 +1557,16 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertEquals(hymnToTourachCard.getEdition(), httEdition); assertEquals(hymnToTourachCard.getArtIndex(), artIndexFEM); - // == 4. Pass in RequestInfo as CardName but then requesting for different artIndex + // == 4. Pass in RequestInfo as CardName but then requesting for different + // artIndex hymnToTourachCard = this.cardDb.getCard(requestInfo, httEdition, 2); assertNotNull(hymnToTourachCard); assertEquals(hymnToTourachCard.getName(), cardName); assertEquals(hymnToTourachCard.getEdition(), httEdition); assertEquals(hymnToTourachCard.getArtIndex(), 2); - // == 5. Pass in RequestInfo as CardName but then requesting for different edition and artIndex + // == 5. Pass in RequestInfo as CardName but then requesting for different + // edition and artIndex hymnToTourachCard = this.cardDb.getCard(requestInfo, latestArtHymnToTourachEdition, 1); assertNotNull(hymnToTourachCard); assertEquals(hymnToTourachCard.getName(), cardName); @@ -1495,27 +1576,31 @@ public class CardDbTestCase extends ForgeCardMockTestCase { // === Get Card From Set // == 1. Reference with all expected params - hymnToTourachCard = this.cardDb.getCardFromSet(cardName, StaticData.instance().getCardEdition(httEdition), artIndexFEM, false); + hymnToTourachCard = this.cardDb.getCardFromSet(cardName, StaticData.instance().getCardEdition(httEdition), + artIndexFEM, false); assertNotNull(hymnToTourachCard); assertEquals(hymnToTourachCard.getName(), cardName); assertEquals(hymnToTourachCard.getEdition(), httEdition); assertEquals(hymnToTourachCard.getArtIndex(), artIndexFEM); // == 2. Pass in RequestInfo as Card Name - hymnToTourachCard = this.cardDb.getCardFromSet(requestInfo, StaticData.instance().getCardEdition(httEdition), artIndexFEM, false); + hymnToTourachCard = this.cardDb.getCardFromSet(requestInfo, StaticData.instance().getCardEdition(httEdition), + artIndexFEM, false); assertNotNull(hymnToTourachCard); assertEquals(hymnToTourachCard.getName(), cardName); assertEquals(hymnToTourachCard.getEdition(), httEdition); assertEquals(hymnToTourachCard.getArtIndex(), artIndexFEM); // == 3. Pass in RequestInfo but request for a different art Index - hymnToTourachCard = this.cardDb.getCardFromSet(requestInfo, StaticData.instance().getCardEdition(httEdition), 2, false); + hymnToTourachCard = this.cardDb.getCardFromSet(requestInfo, StaticData.instance().getCardEdition(httEdition), 2, + false); assertNotNull(hymnToTourachCard); assertEquals(hymnToTourachCard.getName(), cardName); assertEquals(hymnToTourachCard.getEdition(), httEdition); assertEquals(hymnToTourachCard.getArtIndex(), 2); - // == 4. Pass in RequestInfo as Card Name but request for a different art Index and Edition + // == 4. Pass in RequestInfo as Card Name but request for a different art Index + // and Edition hymnToTourachCard = this.cardDb.getCardFromSet(requestInfo, StaticData.instance().getCardEdition(latestArtHymnToTourachEdition), 1, false); assertNotNull(hymnToTourachCard); @@ -1526,23 +1611,28 @@ public class CardDbTestCase extends ForgeCardMockTestCase { // === Get Card From Editions // == 1. Reference case - hymnToTourachCard = this.cardDb.getCardFromEditions(cardName, CardDb.CardArtPreference.ORIGINAL_ART_ALL_EDITIONS); + hymnToTourachCard = this.cardDb.getCardFromEditions(cardName, + CardDb.CardArtPreference.ORIGINAL_ART_ALL_EDITIONS); assertNotNull(hymnToTourachCard); assertEquals(hymnToTourachCard.getName(), cardName); assertEquals(hymnToTourachCard.getEdition(), httEdition); assertEquals(hymnToTourachCard.getArtIndex(), 1); // == 2. Pass in Request String as CardName - hymnToTourachCard = this.cardDb.getCardFromEditions(requestInfo, CardDb.CardArtPreference.ORIGINAL_ART_ALL_EDITIONS); + hymnToTourachCard = this.cardDb.getCardFromEditions(requestInfo, + CardDb.CardArtPreference.ORIGINAL_ART_ALL_EDITIONS); assertNotNull(hymnToTourachCard); assertEquals(hymnToTourachCard.getName(), cardName); assertEquals(hymnToTourachCard.getEdition(), httEdition); // expecting this because artIndex is already in Request Info assertEquals(hymnToTourachCard.getArtIndex(), artIndexFEM); - // == 3. Changing CardArtPreference so that it would not be compliant with request - // STILL expecting to get in return whatever is in request as no extra param has been provided. - hymnToTourachCard = this.cardDb.getCardFromEditions(requestInfo, CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); + // == 3. Changing CardArtPreference so that it would not be compliant with + // request + // STILL expecting to get in return whatever is in request as no extra param has + // been provided. + hymnToTourachCard = this.cardDb.getCardFromEditions(requestInfo, + CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); assertNotNull(hymnToTourachCard); assertEquals(hymnToTourachCard.getName(), cardName); // expecting this edition as present in request info @@ -1550,7 +1640,8 @@ public class CardDbTestCase extends ForgeCardMockTestCase { // expecting this because artIndex is already in Request Info assertEquals(hymnToTourachCard.getArtIndex(), 3); - // == 4. Changing Art Index (not default) so still requesting card via request String + // == 4. Changing Art Index (not default) so still requesting card via request + // String hymnToTourachCard = this.cardDb.getCardFromEditions(requestInfo, CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS, 2); assertNotNull(hymnToTourachCard); @@ -1560,14 +1651,16 @@ public class CardDbTestCase extends ForgeCardMockTestCase { // artIndex should be overwritten this time, as it's provided and not default assertEquals(hymnToTourachCard.getArtIndex(), 2); - // == 4. Changing Art Index (this time with default) = so initially requested artIndex won't get changed! + // == 4. Changing Art Index (this time with default) = so initially requested + // artIndex won't get changed! hymnToTourachCard = this.cardDb.getCardFromEditions(requestInfo, CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS, 1); assertNotNull(hymnToTourachCard); assertEquals(hymnToTourachCard.getName(), cardName); // expecting this edition as present in request info assertEquals(hymnToTourachCard.getEdition(), httEdition); - // artIndex should still be the one requested in CardRequest as value passed is default + // artIndex should still be the one requested in CardRequest as value passed is + // default assertEquals(hymnToTourachCard.getArtIndex(), artIndexFEM); // == 5. Passing in Card Name Only @@ -1580,8 +1673,8 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertEquals(hymnToTourachCard.getArtIndex(), 1); // == 6. Forcing in a specific Art Index will overrule Art Preference - hymnToTourachCard = this.cardDb.getCardFromEditions(cardName, - CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS, artIndexFEM); + hymnToTourachCard = this.cardDb.getCardFromEditions(cardName, CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS, + artIndexFEM); assertNotNull(hymnToTourachCard); assertEquals(hymnToTourachCard.getName(), cardName); // expecting this edition as returned due to CardArtPreference @@ -1591,7 +1684,7 @@ public class CardDbTestCase extends ForgeCardMockTestCase { } @Test - public void testGetCardByNameAndSetWithWrongORNullCollectorNumber(){ + public void testGetCardByNameAndSetWithWrongORNullCollectorNumber() { PaperCard httCard = this.cardDb.getCard(cardNameHymnToTourach, editionHymnToTourach, "589b"); assertNull(httCard); @@ -1604,7 +1697,7 @@ public class CardDbTestCase extends ForgeCardMockTestCase { } @Test - public void testGetCardFromSetWithNullValues(){ + public void testGetCardFromSetWithNullValues() { CardEdition cardEdition = FModel.getMagicDb().getEditions().get(editionShivanDragon); PaperCard nullCard = this.cardDb.getCardFromSet(null, cardEdition, false); @@ -1614,27 +1707,27 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertNull(nullCard); // null collector number - PaperCard shivanCard = this.cardDb.getCardFromSet(cardNameShivanDragon, cardEdition, null,false); + PaperCard shivanCard = this.cardDb.getCardFromSet(cardNameShivanDragon, cardEdition, null, false); assertEquals(shivanCard.getArtIndex(), 1); assertEquals(shivanCard.getName(), cardNameShivanDragon); assertEquals(shivanCard.getEdition(), editionShivanDragon); assertEquals(shivanCard.getCollectorNumber(), collNrShivanDragon); // negative artIndex - shivanCard = this.cardDb.getCardFromSet(cardNameShivanDragon, cardEdition, -20,false); + shivanCard = this.cardDb.getCardFromSet(cardNameShivanDragon, cardEdition, -20, false); assertEquals(shivanCard.getArtIndex(), 1); assertEquals(shivanCard.getName(), cardNameShivanDragon); assertEquals(shivanCard.getEdition(), editionShivanDragon); assertEquals(shivanCard.getCollectorNumber(), collNrShivanDragon); // both above cases - shivanCard = this.cardDb.getCardFromSet(cardNameShivanDragon, cardEdition, -20, null,false); + shivanCard = this.cardDb.getCardFromSet(cardNameShivanDragon, cardEdition, -20, null, false); assertEquals(shivanCard.getArtIndex(), 1); assertEquals(shivanCard.getName(), cardNameShivanDragon); assertEquals(shivanCard.getEdition(), editionShivanDragon); assertEquals(shivanCard.getCollectorNumber(), collNrShivanDragon); - shivanCard = this.cardDb.getCardFromSet(cardNameShivanDragon, cardEdition, null,false); + shivanCard = this.cardDb.getCardFromSet(cardNameShivanDragon, cardEdition, null, false); assertEquals(shivanCard.getArtIndex(), 1); assertEquals(shivanCard.getName(), cardNameShivanDragon); assertEquals(shivanCard.getEdition(), editionShivanDragon); @@ -1642,7 +1735,7 @@ public class CardDbTestCase extends ForgeCardMockTestCase { } @Test - public void testNullAndBoundaryDateValuesForGetCardFromEditionsWithDateRestrictions(){ + public void testNullAndBoundaryDateValuesForGetCardFromEditionsWithDateRestrictions() { assertEquals(this.cardDb.getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); PaperCard shivanDragon = this.cardDb.getCardFromEditionsReleasedBefore(cardNameShivanDragon, null); assertNotNull(shivanDragon); @@ -1656,7 +1749,7 @@ public class CardDbTestCase extends ForgeCardMockTestCase { Date alphaRelaseDate = null; Date currentDate = Date.from(Instant.now()); - Date latestShivanDragonReleaseDateToDate = null; // latest print to date for Shivan is in M20 + Date latestShivanDragonReleaseDateToDate = null; // latest print to date for Shivan is in M20 try { SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd"); alphaRelaseDate = format.parse(alphaEditionReleaseDate); @@ -1668,7 +1761,8 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertNull(this.cardDb.getCardFromEditionsReleasedBefore(cardNameShivanDragon, alphaRelaseDate)); assertNull(this.cardDb.getCardFromEditionsReleasedAfter(cardNameShivanDragon, currentDate)); - assertNull(this.cardDb.getCardFromEditionsReleasedAfter(cardNameShivanDragon, latestShivanDragonReleaseDateToDate)); + assertNull(this.cardDb.getCardFromEditionsReleasedAfter(cardNameShivanDragon, + latestShivanDragonReleaseDateToDate)); } @Test @@ -1706,12 +1800,13 @@ public class CardDbTestCase extends ForgeCardMockTestCase { @Test public void testSetCardArtPreference() { - // First Off try and see if using constants returned by CardArtPreference.getPreferences will work - CardDb.CardArtPreference[] prefs = {CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS, - CardDb.CardArtPreference.LATEST_ART_CORE_EXPANSIONS_REPRINT_ONLY, - CardDb.CardArtPreference.ORIGINAL_ART_ALL_EDITIONS, - CardDb.CardArtPreference.ORIGINAL_ART_CORE_EXPANSIONS_REPRINT_ONLY}; - for (int i = 0; i < 4; i++){ + // First Off try and see if using constants returned by + // CardArtPreference.getPreferences will work + CardDb.CardArtPreference[] prefs = { CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS, + CardDb.CardArtPreference.LATEST_ART_CORE_EXPANSIONS_REPRINT_ONLY, + CardDb.CardArtPreference.ORIGINAL_ART_ALL_EDITIONS, + CardDb.CardArtPreference.ORIGINAL_ART_CORE_EXPANSIONS_REPRINT_ONLY }; + for (int i = 0; i < 4; i++) { boolean latest = prefs[i].latestFirst; boolean coreExpFilter = prefs[i].filterSets; this.cardDb.setCardArtPreference(latest, coreExpFilter); @@ -1722,13 +1817,15 @@ public class CardDbTestCase extends ForgeCardMockTestCase { // LEGACY OPTIONS this.cardDb.setCardArtPreference("LatestCoreExp"); - assertEquals(this.cardDb.getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_CORE_EXPANSIONS_REPRINT_ONLY); + assertEquals(this.cardDb.getCardArtPreference(), + CardDb.CardArtPreference.LATEST_ART_CORE_EXPANSIONS_REPRINT_ONLY); this.cardDb.setCardArtPreference("Earliest"); assertEquals(this.cardDb.getCardArtPreference(), CardDb.CardArtPreference.ORIGINAL_ART_ALL_EDITIONS); this.cardDb.setCardArtPreference("EarliestCoreExp"); - assertEquals(this.cardDb.getCardArtPreference(), CardDb.CardArtPreference.ORIGINAL_ART_CORE_EXPANSIONS_REPRINT_ONLY); + assertEquals(this.cardDb.getCardArtPreference(), + CardDb.CardArtPreference.ORIGINAL_ART_CORE_EXPANSIONS_REPRINT_ONLY); this.cardDb.setCardArtPreference("Latest"); assertEquals(this.cardDb.getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); @@ -1741,7 +1838,8 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertEquals(this.cardDb.getCardArtPreference(), CardDb.CardArtPreference.ORIGINAL_ART_ALL_EDITIONS); this.cardDb.setCardArtPreference("Earliest Editions (Core Expansions Reprint)"); - assertEquals(this.cardDb.getCardArtPreference(), CardDb.CardArtPreference.ORIGINAL_ART_CORE_EXPANSIONS_REPRINT_ONLY); + assertEquals(this.cardDb.getCardArtPreference(), + CardDb.CardArtPreference.ORIGINAL_ART_CORE_EXPANSIONS_REPRINT_ONLY); this.cardDb.setCardArtPreference("Old Card Frame"); assertEquals(this.cardDb.getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); @@ -1750,7 +1848,8 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertEquals(this.cardDb.getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); this.cardDb.setCardArtPreference("Latest Editions (Core Expansions Reprint)"); - assertEquals(this.cardDb.getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_CORE_EXPANSIONS_REPRINT_ONLY); + assertEquals(this.cardDb.getCardArtPreference(), + CardDb.CardArtPreference.LATEST_ART_CORE_EXPANSIONS_REPRINT_ONLY); this.cardDb.setCardArtPreference("Latest (All Editions)"); assertEquals(this.cardDb.getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); @@ -1762,10 +1861,12 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertEquals(this.cardDb.getCardArtPreference(), CardDb.CardArtPreference.ORIGINAL_ART_ALL_EDITIONS); this.cardDb.setCardArtPreference("LATEST_ART_CORE_EXPANSIONS_REPRINT_ONLY"); - assertEquals(this.cardDb.getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_CORE_EXPANSIONS_REPRINT_ONLY); + assertEquals(this.cardDb.getCardArtPreference(), + CardDb.CardArtPreference.LATEST_ART_CORE_EXPANSIONS_REPRINT_ONLY); this.cardDb.setCardArtPreference("ORIGINAL_ART_CORE_EXPANSIONS_REPRINT_ONLY"); - assertEquals(this.cardDb.getCardArtPreference(), CardDb.CardArtPreference.ORIGINAL_ART_CORE_EXPANSIONS_REPRINT_ONLY); + assertEquals(this.cardDb.getCardArtPreference(), + CardDb.CardArtPreference.ORIGINAL_ART_CORE_EXPANSIONS_REPRINT_ONLY); // Test non existing option this.cardDb.setCardArtPreference("Non existing option"); @@ -1774,7 +1875,7 @@ public class CardDbTestCase extends ForgeCardMockTestCase { } @Test - public void testSnowCoveredBasicLandsWithCartArtPreference(){ + public void testSnowCoveredBasicLandsWithCartArtPreference() { this.cardDb.setCardArtPreference(true, false); assertEquals(this.cardDb.getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); @@ -1785,7 +1886,8 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertEquals(landCard.getEdition(), "KHM"); this.cardDb.setCardArtPreference(true, true); - assertEquals(this.cardDb.getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_CORE_EXPANSIONS_REPRINT_ONLY); + assertEquals(this.cardDb.getCardArtPreference(), + CardDb.CardArtPreference.LATEST_ART_CORE_EXPANSIONS_REPRINT_ONLY); landCard = this.cardDb.getCard(snowCoveredLand); assertNotNull(landCard); @@ -1798,31 +1900,31 @@ public class CardDbTestCase extends ForgeCardMockTestCase { } /** - * This set is crucial to test Card Art Preference and Strict Policies. - * In particular, we wish to test whether the DB is robust enough to retrieve - * the card even if Art Preference is too strict, that is: the card is only + * This set is crucial to test Card Art Preference and Strict Policies. In + * particular, we wish to test whether the DB is robust enough to retrieve the + * card even if Art Preference is too strict, that is: the card is only * available in Filtered sets. * - * When this happens, we also want to be sure that retrieved card will be - * still compliant with Art Preference, when multiple candidates are possible + * When this happens, we also want to be sure that retrieved card will be still + * compliant with Art Preference, when multiple candidates are possible * (therefore, latest or original art first) * - * For this test we will use the following card/editions as fixtures: - * - Militant Angel: ONLY available in forge in Game Night - * - Loyal Unicorn: Available in Forge in The List, and COMMANDER 2018 - * - Selfless Squire: Available in Forge in COMMANDER 2021, Treasure Chest, and COMMANDER 2016 - * - Atog: Test card available in Promo and Non-Promo Print. We will use this card as reference - * which will have multiple editions returned over the preference selections. + * For this test we will use the following card/editions as fixtures: - Militant + * Angel: ONLY available in forge in Game Night - Loyal Unicorn: Available in + * Forge in The List, and COMMANDER 2018 - Selfless Squire: Available in Forge + * in COMMANDER 2021, Treasure Chest, and COMMANDER 2016 - Atog: Test card + * available in Promo and Non-Promo Print. We will use this card as reference + * which will have multiple editions returned over the preference selections. */ @Test - public void testCardsAlwaysReturnedEvenIfCardArtPreferenceIsTooStrictAlsoComparedWithLegacyDb(){ + public void testCardsAlwaysReturnedEvenIfCardArtPreferenceIsTooStrictAlsoComparedWithLegacyDb() { // == 1. REFERENCE CASE - Latest Art NO FILTER assertEquals(this.cardDb.getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); String cnAtog = "Atog"; PaperCard atog = this.cardDb.getCard(cnAtog); assertNotNull(atog); - assertEquals(atog.getEdition(), "ME4"); // Masters Edition IV + assertEquals(atog.getEdition(), "ME4"); // Masters Edition IV PaperCard legacyAtog = this.legacyCardDb.getCardFromEdition(cnAtog, LegacyCardDb.LegacySetPreference.Latest); if (legacyAtog != null) @@ -1831,7 +1933,7 @@ public class CardDbTestCase extends ForgeCardMockTestCase { String cnMilitantAngel = "Militant Angel"; PaperCard militantAngel = this.cardDb.getCard(cnMilitantAngel); assertNotNull(militantAngel); - assertEquals(militantAngel.getEdition(), "GNT"); // Game Night + assertEquals(militantAngel.getEdition(), "GNT"); // Game Night PaperCard legacyMilitantAngel = this.legacyCardDb.getCardFromEdition(cnMilitantAngel, LegacyCardDb.LegacySetPreference.Latest); @@ -1842,18 +1944,19 @@ public class CardDbTestCase extends ForgeCardMockTestCase { String cnLoyalUnicorn = "Loyal Unicorn"; PaperCard loyalUnicorn = this.cardDb.getCard(cnLoyalUnicorn); assertNotNull(loyalUnicorn); - assertEquals(loyalUnicorn.getEdition(), "PLIST"); // The List + assertEquals(loyalUnicorn.getEdition(), "PLIST"); // The List PaperCard legacyLoyalUnicorn = this.legacyCardDb.getCardFromEdition(cnLoyalUnicorn, LegacyCardDb.LegacySetPreference.Latest); if (legacyLoyalUnicorn != null) assertEquals(loyalUnicorn, legacyLoyalUnicorn); - // Selfless Squire: Available in Forge in COMMANDER 2021; Treasure Chest; COMMANDER 2016 + // Selfless Squire: Available in Forge in COMMANDER 2021; Treasure Chest; + // COMMANDER 2016 String cnSelflessSquire = "Selfless Squire"; PaperCard selflessSquire = this.cardDb.getCard(cnSelflessSquire); assertNotNull(selflessSquire); - assertEquals(selflessSquire.getEdition(), "C21"); // Commander 2021 + assertEquals(selflessSquire.getEdition(), "C21"); // Commander 2021 PaperCard legacySelflessSquire = this.legacyCardDb.getCardFromEdition(cnSelflessSquire, LegacyCardDb.LegacySetPreference.Latest); @@ -1862,7 +1965,8 @@ public class CardDbTestCase extends ForgeCardMockTestCase { // == 2. Set Strictness to Expansions and Reprint Only (LATEST) this.cardDb.setCardArtPreference(true, true); - assertEquals(this.cardDb.getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_CORE_EXPANSIONS_REPRINT_ONLY); + assertEquals(this.cardDb.getCardArtPreference(), + CardDb.CardArtPreference.LATEST_ART_CORE_EXPANSIONS_REPRINT_ONLY); // ONLY CHANGE HERE IS FOR ATOG atog = this.cardDb.getCard(cnAtog); @@ -1892,7 +1996,8 @@ public class CardDbTestCase extends ForgeCardMockTestCase { if (legacyLoyalUnicorn != null) assertEquals(loyalUnicorn, legacyLoyalUnicorn); - // Selfless Squire: Available in Forge in COMMANDER 2021; Treasure Chest; COMMANDER 2016 + // Selfless Squire: Available in Forge in COMMANDER 2021; Treasure Chest; + // COMMANDER 2016 selflessSquire = this.cardDb.getCard(cnSelflessSquire); assertNotNull(selflessSquire); assertEquals(selflessSquire.getEdition(), "C21"); @@ -1933,7 +2038,8 @@ public class CardDbTestCase extends ForgeCardMockTestCase { if (legacyLoyalUnicorn != null) assertEquals(loyalUnicorn, legacyLoyalUnicorn); - // Selfless Squire: Available in Forge in COMMANDER 2021; Treasure Chest; COMMANDER 2016 + // Selfless Squire: Available in Forge in COMMANDER 2021; Treasure Chest; + // COMMANDER 2016 selflessSquire = this.cardDb.getCard(cnSelflessSquire); assertNotNull(selflessSquire); assertEquals(selflessSquire.getEdition(), "C16"); @@ -1945,7 +2051,8 @@ public class CardDbTestCase extends ForgeCardMockTestCase { // == 4. Set Strictness to ORIGINAL ART WITH FILTER (*only*) this.cardDb.setCardArtPreference(false, true); - assertEquals(this.cardDb.getCardArtPreference(), CardDb.CardArtPreference.ORIGINAL_ART_CORE_EXPANSIONS_REPRINT_ONLY); + assertEquals(this.cardDb.getCardArtPreference(), + CardDb.CardArtPreference.ORIGINAL_ART_CORE_EXPANSIONS_REPRINT_ONLY); atog = this.cardDb.getCard(cnAtog); assertNotNull(atog); @@ -1988,10 +2095,10 @@ public class CardDbTestCase extends ForgeCardMockTestCase { } @Test - public void testGetCardFromUnknownSet(){ + public void testGetCardFromUnknownSet() { String unknownCardName = "Unknown Card Name"; PaperCard unknownCard = new PaperCard(CardRules.getUnsupportedCardNamed(unknownCardName), - CardEdition.UNKNOWN.getCode(), CardRarity.Unknown); + CardEdition.UNKNOWN.getCode(), CardRarity.Unknown); this.cardDb.addCard(unknownCard); assertTrue(this.cardDb.getAllCards().contains(unknownCard)); assertNotNull(this.cardDb.getAllCards(unknownCardName)); @@ -2004,21 +2111,21 @@ public class CardDbTestCase extends ForgeCardMockTestCase { } @Test - public void testGetCardFromWrongEditionOrNonExistingEditionReturnsNullResult(){ + public void testGetCardFromWrongEditionOrNonExistingEditionReturnsNullResult() { String cardName = "Blinding Angel"; - String wrongSetCode = "LEA"; // obiviously wrong + String wrongSetCode = "LEA"; // obiviously wrong String requestInfo = CardDb.CardRequest.compose(cardName, wrongSetCode); PaperCard blindingAngelCard = this.cardDb.getCard(requestInfo); PaperCard legacyBlindingAngelCard = this.legacyCardDb.getCard(requestInfo); - assertNull(legacyBlindingAngelCard); // be sure behaviour is the same + assertNull(legacyBlindingAngelCard); // be sure behaviour is the same assertNull(blindingAngelCard); - String nonExistingSetCode = "9TH"; // non-existing, should be 9ED + String nonExistingSetCode = "9TH"; // non-existing, should be 9ED requestInfo = CardDb.CardRequest.compose(cardName, nonExistingSetCode); blindingAngelCard = this.cardDb.getCard(requestInfo); legacyBlindingAngelCard = this.legacyCardDb.getCard(requestInfo); - assertNull(legacyBlindingAngelCard); // be sure behaviour is the same + assertNull(legacyBlindingAngelCard); // be sure behaviour is the same assertNull(blindingAngelCard); } @@ -2039,9 +2146,9 @@ public class CardDbTestCase extends ForgeCardMockTestCase { } @Test - public void testWrongCaseInEditionSetCodeReturnsNull(){ + public void testWrongCaseInEditionSetCodeReturnsNull() { String cardName = "Aether Barrier"; // correct name - String setCode = "nmS"; // wrong case, non-existing + String setCode = "nmS"; // wrong case, non-existing String requestInfo = CardDb.CardRequest.compose(cardName, setCode); PaperCard aetherBarrierCard = this.cardDb.getCard(requestInfo); assertNotNull(aetherBarrierCard); @@ -2056,20 +2163,21 @@ public class CardDbTestCase extends ForgeCardMockTestCase { // "Problematic" Card names @Test - public void testRetrievingBorrowing100_000ArrowsCard(){ + public void testRetrievingBorrowing100_000ArrowsCard() { String cardName = "Borrowing 100,000 Arrows"; PaperCard borrowingCard = this.cardDb.getCard(cardName); assertNotNull(borrowingCard); assertEquals(borrowingCard.getName(), cardName); // Compare w/ LegacyDb - PaperCard legacyBorrowingCard = this.legacyCardDb.getCardFromEdition(cardName, LegacyCardDb.LegacySetPreference.Latest); + PaperCard legacyBorrowingCard = this.legacyCardDb.getCardFromEdition(cardName, + LegacyCardDb.LegacySetPreference.Latest); assertEquals(legacyBorrowingCard, borrowingCard); } @Test - public void testGetCardWithDashInNameAndWrongCaseToo(){ - String requestInfo = "Ainok Bond-kin|KTK"; // wrong case for last 'k' and dash in name + public void testGetCardWithDashInNameAndWrongCaseToo() { + String requestInfo = "Ainok Bond-kin|KTK"; // wrong case for last 'k' and dash in name PaperCard ainokCard = this.cardDb.getCard(requestInfo); assertNotNull(ainokCard); assertEquals(ainokCard.getName(), "Ainok Bond-Kin"); @@ -2081,17 +2189,19 @@ public class CardDbTestCase extends ForgeCardMockTestCase { } @Test - public void testGetIslandsFromEditionsWithSpecificArtIndex(){ + public void testGetIslandsFromEditionsWithSpecificArtIndex() { String cardName = "Island"; assertEquals(this.cardDb.getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); - PaperCard islandLatest = this.cardDb.getCardFromEditions(cardName, CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS, 12); + PaperCard islandLatest = this.cardDb.getCardFromEditions(cardName, + CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS, 12); assertNotNull(islandLatest); assertEquals(islandLatest.getName(), "Island"); assertEquals(islandLatest.getEdition(), "SLD"); assertEquals(islandLatest.getArtIndex(), 12); // SLD - PaperCard islandOriginal = this.cardDb.getCardFromEditions(cardName, CardDb.CardArtPreference.ORIGINAL_ART_CORE_EXPANSIONS_REPRINT_ONLY, 12); + PaperCard islandOriginal = this.cardDb.getCardFromEditions(cardName, + CardDb.CardArtPreference.ORIGINAL_ART_CORE_EXPANSIONS_REPRINT_ONLY, 12); assertNotNull(islandOriginal); assertEquals(islandOriginal.getName(), "Island"); assertEquals(islandOriginal.getEdition(), "SLD"); @@ -2099,13 +2209,13 @@ public class CardDbTestCase extends ForgeCardMockTestCase { } @Test - public void testMaxArtCountForBasicLand(){ + public void testMaxArtCountForBasicLand() { int maxArtIndex = this.cardDb.getMaxArtIndex("Island"); assertTrue(maxArtIndex >= 14); } @Test - public void testGetCardFromEditionsWithFilteredPool(){ + public void testGetCardFromEditionsWithFilteredPool() { // test initial conditions assertEquals(this.cardDb.getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); @@ -2120,21 +2230,22 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertEquals(shivanDragonCard.getEdition(), this.latestArtShivanDragonEdition); // Use Original Art Preference Now - shivanDragonCard = this.cardDb.getCardFromEditions(this.cardNameShivanDragon, CardDb.CardArtPreference.ORIGINAL_ART_ALL_EDITIONS, printedInSetPredicate); + shivanDragonCard = this.cardDb.getCardFromEditions(this.cardNameShivanDragon, + CardDb.CardArtPreference.ORIGINAL_ART_ALL_EDITIONS, printedInSetPredicate); assertNotNull(shivanDragonCard); assertEquals(shivanDragonCard.getName(), this.cardNameShivanDragon); assertEquals(shivanDragonCard.getEdition(), this.originalArtShivanDragonEdition); // Testing null cards allowedSets.clear(); - allowedSets.add(this.originalArtHymnToTourachEdition); // FEM - it does not exist a shivan in FEM + allowedSets.add(this.originalArtHymnToTourachEdition); // FEM - it does not exist a shivan in FEM printedInSetPredicate = (Predicate) this.cardDb.wasPrintedInSets(allowedSets); shivanDragonCard = this.cardDb.getCardFromEditions(this.cardNameShivanDragon, printedInSetPredicate); assertNull(shivanDragonCard); } @Test - public void testGetCardsFromEditionsReleasedBeforeDateWithFilter(){ + public void testGetCardsFromEditionsReleasedBeforeDateWithFilter() { // test initial conditions assertEquals(this.cardDb.getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); @@ -2153,35 +2264,36 @@ public class CardDbTestCase extends ForgeCardMockTestCase { allowedSets.add(this.originalArtShivanDragonEdition); allowedSets.add(this.originalArtShivanDragonEditionReleasedAfterTenthEditionNoPromo); Predicate legalInSetFilter = (Predicate) this.cardDb.isLegal(allowedSets); - PaperCard shivanDragonCard = this.cardDb.getCardFromEditionsReleasedAfter(this.cardNameShivanDragon, CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS, - afterTenthEdition, legalInSetFilter); + PaperCard shivanDragonCard = this.cardDb.getCardFromEditionsReleasedAfter(this.cardNameShivanDragon, + CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS, afterTenthEdition, legalInSetFilter); assertNotNull(shivanDragonCard); assertEquals(shivanDragonCard.getName(), cardNameShivanDragon); assertEquals(shivanDragonCard.getEdition(), latestArtShivanDragonEdition); // Original Art Should be excluded by date filter - shivanDragonCard = this.cardDb.getCardFromEditionsReleasedAfter(this.cardNameShivanDragon, CardDb.CardArtPreference.ORIGINAL_ART_ALL_EDITIONS, - afterTenthEdition, legalInSetFilter); + shivanDragonCard = this.cardDb.getCardFromEditionsReleasedAfter(this.cardNameShivanDragon, + CardDb.CardArtPreference.ORIGINAL_ART_ALL_EDITIONS, afterTenthEdition, legalInSetFilter); assertNotNull(shivanDragonCard); assertEquals(shivanDragonCard.getName(), cardNameShivanDragon); assertEquals(shivanDragonCard.getEdition(), originalArtShivanDragonEditionReleasedAfterTenthEditionNoPromo); // == Try same but with Released Before - shivanDragonCard = this.cardDb.getCardFromEditionsReleasedBefore(this.cardNameShivanDragon, CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS, - afterTenthEdition, legalInSetFilter); + shivanDragonCard = this.cardDb.getCardFromEditionsReleasedBefore(this.cardNameShivanDragon, + CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS, afterTenthEdition, legalInSetFilter); assertNotNull(shivanDragonCard); assertEquals(shivanDragonCard.getName(), cardNameShivanDragon); assertEquals(shivanDragonCard.getEdition(), originalArtShivanDragonEdition); // Original Art Should be excluded by date filter - shivanDragonCard = this.cardDb.getCardFromEditionsReleasedBefore(this.cardNameShivanDragon, CardDb.CardArtPreference.ORIGINAL_ART_ALL_EDITIONS, - afterTenthEdition, legalInSetFilter); + shivanDragonCard = this.cardDb.getCardFromEditionsReleasedBefore(this.cardNameShivanDragon, + CardDb.CardArtPreference.ORIGINAL_ART_ALL_EDITIONS, afterTenthEdition, legalInSetFilter); assertNotNull(shivanDragonCard); assertEquals(shivanDragonCard.getName(), cardNameShivanDragon); assertEquals(shivanDragonCard.getEdition(), originalArtShivanDragonEdition); } - @Test void testCardRequestWithSetCodeAllInLowercase(){ + @Test + void testCardRequestWithSetCodeAllInLowercase() { assertEquals(this.cardDb.getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); PaperCard counterSpellCard = this.cardDb.getCard(this.cardNameCounterspell, "tmp"); @@ -2189,15 +2301,17 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertEquals(counterSpellCard.getName(), cardNameCounterspell); } - @Test void prepareTestCaseForSetPreferredArtTest(){ + @Test + void prepareTestCaseForSetPreferredArtTest() { String setCode = this.editionsCounterspell[0]; - int artIndex = 4; // non-existing + int artIndex = 4; // non-existing String cardRequest = CardDb.CardRequest.compose(this.cardNameCounterspell, setCode, artIndex); PaperCard nonExistingCounterSpell = this.cardDb.getCard(cardRequest); assertNull(nonExistingCounterSpell); } - @Test void setPreferredArtForCard(){ + @Test + void setPreferredArtForCard() { String cardName = "Mountain"; String setCode = "3ED"; int artIndex = 5; @@ -2205,8 +2319,8 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertTrue(this.cardDb.setPreferredArt(cardName, setCode, 1)); } - - @Test void testThatWithCardPreferenceSetAndNoRequestForSpecificEditionAlwaysReturnsPreferredArt(){ + @Test + void testThatWithCardPreferenceSetAndNoRequestForSpecificEditionAlwaysReturnsPreferredArt() { String cardRequest = CardDb.CardRequest.compose("Island", "MIR", 3); PaperCard islandCard = this.cardDb.getCard(cardRequest); assertNotNull(islandCard); @@ -2232,7 +2346,8 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertEquals(islandCard.getEdition(), "MIR"); assertEquals(islandCard.getArtIndex(), 3); - // Now asking for a foiled island - I will get the one from preferred art - but foiled + // Now asking for a foiled island - I will get the one from preferred art - but + // foiled cardRequest = CardDb.CardRequest.compose("Island", true); islandCard = this.cardDb.getCard(cardRequest); assertNotNull(islandCard); @@ -2242,7 +2357,8 @@ public class CardDbTestCase extends ForgeCardMockTestCase { assertTrue(islandCard.isFoil()); } - @Test void testGetDualAndDoubleCards(){ + @Test + void testGetDualAndDoubleCards() { String fireAndIce = "Fire // Ice"; PaperCard fireAndIceCard = this.cardDb.getCard(fireAndIce); assertNotNull(fireAndIceCard); diff --git a/forge-gui-desktop/src/test/java/forge/card/CardDbTestLazyCardLoading.java b/forge-gui-desktop/src/test/java/forge/card/CardDbLazyCardLoadingCardMockTestCase.java similarity index 83% rename from forge-gui-desktop/src/test/java/forge/card/CardDbTestLazyCardLoading.java rename to forge-gui-desktop/src/test/java/forge/card/CardDbLazyCardLoadingCardMockTestCase.java index 2ca5b7b828a..a4a999fa2c5 100644 --- a/forge-gui-desktop/src/test/java/forge/card/CardDbTestLazyCardLoading.java +++ b/forge-gui-desktop/src/test/java/forge/card/CardDbLazyCardLoadingCardMockTestCase.java @@ -1,21 +1,24 @@ package forge.card; +import static org.testng.Assert.assertEquals; +import static org.testng.Assert.assertNotNull; +import static org.testng.Assert.assertNull; + +import org.powermock.api.mockito.PowerMockito; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.Test; + import forge.StaticData; import forge.gamesimulationtests.util.CardDatabaseHelper; import forge.item.PaperCard; import forge.model.FModel; -import org.powermock.api.mockito.PowerMockito; -import org.testng.annotations.BeforeMethod; -import org.testng.annotations.Test; -import static org.testng.Assert.*; - -public class CardDbTestLazyCardLoading extends ForgeCardMockTestCase { +public class CardDbLazyCardLoadingCardMockTestCase extends CardMockTestCase { protected CardDb cardDb; @BeforeMethod - public void setup(){ + public void setup() { StaticData data = FModel.getMagicDb(); this.cardDb = data.getCommonCards(); } @@ -27,9 +30,9 @@ public class CardDbTestLazyCardLoading extends ForgeCardMockTestCase { } @Test - public void testLoadAndGetBorrowing100_000ArrowsCardFromAllEditions(){ + public void testLoadAndGetBorrowing100_000ArrowsCardFromAllEditions() { String cardName = "Borrowing 100,000 Arrows"; - String[] allAvailableEds = new String[] {"PTK", "ME3", "C13", "CMA", "A25", "MB1"}; + String[] allAvailableEds = new String[] { "PTK", "ME3", "C13", "CMA", "A25", "MB1" }; assertEquals(this.cardDb.getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); @@ -45,7 +48,7 @@ public class CardDbTestLazyCardLoading extends ForgeCardMockTestCase { assertEquals(borrowingCard.getEdition(), "MB1"); // Now get card from all the specified editions - for (String setCode : allAvailableEds){ + for (String setCode : allAvailableEds) { borrowingCard = this.cardDb.getCard(cardName, setCode); assertNotNull(borrowingCard); assertEquals(borrowingCard.getName(), cardName); @@ -54,8 +57,8 @@ public class CardDbTestLazyCardLoading extends ForgeCardMockTestCase { } @Test - public void testLoadAndGetAinokBondKinFromKTKWithCaseInsensitiveCardName(){ - String cardName = "aiNOk Bond-kin"; // wrong case + public void testLoadAndGetAinokBondKinFromKTKWithCaseInsensitiveCardName() { + String cardName = "aiNOk Bond-kin"; // wrong case String expectedCardName = "Ainok Bond-Kin"; String setCode = "KTK"; @@ -72,12 +75,12 @@ public class CardDbTestLazyCardLoading extends ForgeCardMockTestCase { assertEquals(borrowingCard.getName(), expectedCardName); assertEquals(borrowingCard.getEdition(), setCode); - assertNull(this.cardDb.getCard(cardName, "IMA")); // not added yet + assertNull(this.cardDb.getCard(cardName, "IMA")); // not added yet } @Test - public void tesLoadAndGetAetherVialWithWrongCase(){ - String cardName = "AEther vial"; // wrong case + public void tesLoadAndGetAetherVialWithWrongCase() { + String cardName = "AEther vial"; // wrong case String expectedCardName = "Aether Vial"; PaperCard aetherVialCard = this.cardDb.getCard(cardName); assertNull(aetherVialCard); @@ -91,10 +94,10 @@ public class CardDbTestLazyCardLoading extends ForgeCardMockTestCase { } @Test - public void tesLoadAndGetUnsupportedCardHavingWrongSetCode(){ + public void tesLoadAndGetUnsupportedCardHavingWrongSetCode() { String cardName = "Dominating Licid"; String wrongSetCode = "AA"; - String expectedSetCode = "EXO"; // Exodus + String expectedSetCode = "EXO"; // Exodus CardRarity expectedCardRarity = CardRarity.Rare; PaperCard dominatingLycidCard = this.cardDb.getCard(cardName); diff --git a/forge-gui-desktop/src/test/java/forge/card/CardDbPerformanceTests.java b/forge-gui-desktop/src/test/java/forge/card/CardDbPerformanceTests.java index 1332a0a5d53..37acaf779c4 100644 --- a/forge-gui-desktop/src/test/java/forge/card/CardDbPerformanceTests.java +++ b/forge-gui-desktop/src/test/java/forge/card/CardDbPerformanceTests.java @@ -1,16 +1,17 @@ package forge.card; -import forge.item.PaperCard; -import org.testng.annotations.BeforeMethod; -import org.testng.annotations.Test; +import static org.testng.Assert.assertNotNull; import java.util.Collection; import java.util.Set; import java.util.TreeSet; -import static org.testng.Assert.assertNotNull; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.Test; -public class CardDbPerformanceTests extends CardDbTestCase { +import forge.item.PaperCard; + +public class CardDbPerformanceTests extends CardDbCardMockTestCase { private Set fullDbCardNames = new TreeSet<>(); @@ -23,11 +24,11 @@ public class CardDbPerformanceTests extends CardDbTestCase { this.fullDbCardNames.add(card.getName()); } - @Test(enabled = false) // disabled to not run in battery + @Test(enabled = false) // disabled to not run in battery public void testBenchmarkFullDbGetCardLegacyImplementation() { int nRuns = 100; long averageTime = 0; - long minTime = 10000; // 10 secs + long minTime = 10000; // 10 secs long maxTime = 0; for (int r = 1; r <= nRuns; r++) { long start = System.currentTimeMillis(); @@ -42,17 +43,17 @@ public class CardDbPerformanceTests extends CardDbTestCase { if (timeRun > maxTime) maxTime = timeRun; } - System.out.println("[LEGACY] Total Time (in sec): " + ((double) averageTime)/ 1000); - System.out.println("[LEGACY] Average Time (in sec): " + ((double) averageTime / nRuns)/ 1000); - System.out.println("[LEGACY] Best Time (in sec): " + ((double) minTime)/ 1000); - System.out.println("[LEGACY] Worst Time (in sec): " + ((double) maxTime)/ 1000); + System.out.println("[LEGACY] Total Time (in sec): " + ((double) averageTime) / 1000); + System.out.println("[LEGACY] Average Time (in sec): " + ((double) averageTime / nRuns) / 1000); + System.out.println("[LEGACY] Best Time (in sec): " + ((double) minTime) / 1000); + System.out.println("[LEGACY] Worst Time (in sec): " + ((double) maxTime) / 1000); } - @Test(enabled = false) // disabled to not run in battery + @Test(enabled = false) // disabled to not run in battery public void testBenchmarkFullDbGetCardNewDbImplementation() { int nRuns = 100; long averageTime = 0; - long minTime = 10000; // 10 secs + long minTime = 10000; // 10 secs long maxTime = 0; for (int r = 1; r <= nRuns; r++) { long start = System.currentTimeMillis(); @@ -67,14 +68,14 @@ public class CardDbPerformanceTests extends CardDbTestCase { if (timeRun > maxTime) maxTime = timeRun; } - System.out.println("[NEW] Total Time (in sec): " + ((double) averageTime)/ 1000); - System.out.println("[NEW] Average Time (in sec): " + ((double) averageTime / nRuns)/ 1000); - System.out.println("[NEW] Best Time (in sec): " + ((double) minTime)/ 1000); - System.out.println("[NEW] Worst Time (in sec): " + ((double) maxTime)/ 1000); + System.out.println("[NEW] Total Time (in sec): " + ((double) averageTime) / 1000); + System.out.println("[NEW] Average Time (in sec): " + ((double) averageTime / nRuns) / 1000); + System.out.println("[NEW] Best Time (in sec): " + ((double) minTime) / 1000); + System.out.println("[NEW] Worst Time (in sec): " + ((double) maxTime) / 1000); } @Test - public void testGetCardFullDbNewImplementationToProfile(){ + public void testGetCardFullDbNewImplementationToProfile() { for (String name : this.fullDbCardNames) { PaperCard card = this.cardDb.getCard(name); assertNotNull(card); @@ -82,7 +83,7 @@ public class CardDbPerformanceTests extends CardDbTestCase { } @Test - public void testGetCardFullDbLegacyImplementationToProfile(){ + public void testGetCardFullDbLegacyImplementationToProfile() { for (String name : this.fullDbCardNames) { PaperCard card = this.legacyCardDb.getCard(name); assertNotNull(card); diff --git a/forge-gui-desktop/src/test/java/forge/card/CardDbTestWithNoImage.java b/forge-gui-desktop/src/test/java/forge/card/CardDbWithNoImageCardDbMockTestCase.java similarity index 77% rename from forge-gui-desktop/src/test/java/forge/card/CardDbTestWithNoImage.java rename to forge-gui-desktop/src/test/java/forge/card/CardDbWithNoImageCardDbMockTestCase.java index c3ac9a9fa0b..43a61ed61d9 100644 --- a/forge-gui-desktop/src/test/java/forge/card/CardDbTestWithNoImage.java +++ b/forge-gui-desktop/src/test/java/forge/card/CardDbWithNoImageCardDbMockTestCase.java @@ -1,30 +1,31 @@ package forge.card; -import forge.ImageCache; -import forge.ImageKeys; -import forge.item.PaperCard; +import static org.testng.Assert.assertFalse; +import static org.testng.Assert.assertNotNull; + +import javax.imageio.ImageIO; + import org.mockito.Mockito; import org.powermock.api.mockito.PowerMockito; import org.testng.annotations.BeforeMethod; import org.testng.annotations.Test; -import javax.imageio.ImageIO; - -import static org.testng.Assert.assertFalse; -import static org.testng.Assert.assertNotNull; +import forge.ImageCache; +import forge.ImageKeys; +import forge.item.PaperCard; /** - * Test Case for CardDb forcing No Image for all the cards. - * Check that everything still applies the same. + * Test Case for CardDb forcing No Image for all the cards. Check that + * everything still applies the same. * - * Note: Run test for the class, being subclass will also run all - * other tests as regression. + * Note: Run test for the class, being subclass will also run all other tests as + * regression. */ -public class CardDbTestWithNoImage extends CardDbTestCase { +public class CardDbWithNoImageCardDbMockTestCase extends CardDbCardMockTestCase { @Override @BeforeMethod - public void setup(){ + public void setup() { super.setup(); } @@ -37,7 +38,7 @@ public class CardDbTestWithNoImage extends CardDbTestCase { } @Test - public void testCardIsReturnedEvenIfThereIsNoImage(){ + public void testCardIsReturnedEvenIfThereIsNoImage() { PaperCard shivanDragon = this.cardDb.getCard(cardNameShivanDragon); assertNotNull(shivanDragon); assertFalse(ImageKeys.hasImage(shivanDragon)); diff --git a/forge-gui-desktop/src/test/java/forge/card/CardEditionCollectionTestCase.java b/forge-gui-desktop/src/test/java/forge/card/CardEditionCollectionCardMockTestCase.java similarity index 75% rename from forge-gui-desktop/src/test/java/forge/card/CardEditionCollectionTestCase.java rename to forge-gui-desktop/src/test/java/forge/card/CardEditionCollectionCardMockTestCase.java index 7fed05a55f7..8adf304e4d3 100644 --- a/forge-gui-desktop/src/test/java/forge/card/CardEditionCollectionTestCase.java +++ b/forge-gui-desktop/src/test/java/forge/card/CardEditionCollectionCardMockTestCase.java @@ -1,26 +1,27 @@ package forge.card; -import forge.deck.CardPool; -import forge.item.PaperCard; -import forge.model.FModel; -import org.testng.annotations.Test; +import static org.testng.Assert.assertEquals; import java.util.ArrayList; import java.util.List; -import static org.testng.Assert.assertEquals; +import org.testng.annotations.Test; -public class CardEditionCollectionTestCase extends ForgeCardMockTestCase { +import forge.deck.CardPool; +import forge.item.PaperCard; +import forge.model.FModel; + +public class CardEditionCollectionCardMockTestCase extends CardMockTestCase { @Test - public void testGetTheLatestOfAllTheOriginalEditionsOfCardsInPoolWithOriginalSets(){ + public void testGetTheLatestOfAllTheOriginalEditionsOfCardsInPoolWithOriginalSets() { CardEdition.Collection editions = FModel.getMagicDb().getEditions(); CardDb cardDb = FModel.getMagicDb().getCommonCards(); - String[] cardNames = {"Shivan Dragon", "Animate Wall", "Balance", "Blessing", "Force of Will"}; - String[] expectedSets = {"LEA", "LEA", "LEA", "LEA", "ALL"}; + String[] cardNames = { "Shivan Dragon", "Animate Wall", "Balance", "Blessing", "Force of Will" }; + String[] expectedSets = { "LEA", "LEA", "LEA", "LEA", "ALL" }; List cards = new ArrayList<>(); - for (int i=0; i < 5; i++){ + for (int i = 0; i < 5; i++) { String cardName = cardNames[i]; String expectedSet = expectedSets[i]; PaperCard card = cardDb.getCardFromEditions(cardName, CardDb.CardArtPreference.ORIGINAL_ART_ALL_EDITIONS); @@ -35,18 +36,18 @@ public class CardEditionCollectionTestCase extends ForgeCardMockTestCase { } @Test - public void testGetTheLatestOfAllTheOriginalEditionsOfCardsInPoolWithLatestArtSets(){ + public void testGetTheLatestOfAllTheOriginalEditionsOfCardsInPoolWithLatestArtSets() { CardEdition.Collection editions = FModel.getMagicDb().getEditions(); CardDb cardDb = FModel.getMagicDb().getCommonCards(); - String[] cardNames = {"Shivan Dragon", "Animate Wall", "Balance", "Blessing", "Force of Will"}; - String[] expectedSets = {"M20", "MED", "SLD", "M14", "2XM"}; + String[] cardNames = { "Shivan Dragon", "Animate Wall", "Balance", "Blessing", "Force of Will" }; + String[] expectedSets = { "M20", "MED", "SLD", "M14", "2XM" }; List cards = new ArrayList<>(); - for (int i=0; i < 5; i++){ + for (int i = 0; i < 5; i++) { String cardName = cardNames[i]; String expectedSet = expectedSets[i]; PaperCard card = cardDb.getCardFromEditions(cardName, CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); - assertEquals(card.getEdition(), expectedSet, "Assertion Failed for "+cardName); + assertEquals(card.getEdition(), expectedSet, "Assertion Failed for " + cardName); cards.add(card); } diff --git a/forge-gui-desktop/src/test/java/forge/card/ForgeCardMockTestCase.java b/forge-gui-desktop/src/test/java/forge/card/CardMockTestCase.java similarity index 87% rename from forge-gui-desktop/src/test/java/forge/card/ForgeCardMockTestCase.java rename to forge-gui-desktop/src/test/java/forge/card/CardMockTestCase.java index c73da4db0a0..e7d36d8e6f2 100644 --- a/forge-gui-desktop/src/test/java/forge/card/ForgeCardMockTestCase.java +++ b/forge-gui-desktop/src/test/java/forge/card/CardMockTestCase.java @@ -1,5 +1,25 @@ package forge.card; +import java.io.File; +import java.lang.reflect.Field; +import java.util.Collections; +import java.util.Enumeration; +import java.util.Locale; +import java.util.ResourceBundle; + +import javax.imageio.ImageIO; + +import org.apache.commons.lang3.StringUtils; +import org.mockito.Mockito; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PowerMockIgnore; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.core.classloader.annotations.SuppressStaticInitializationFor; +import org.powermock.modules.testng.PowerMockTestCase; +import org.testng.IObjectFactory; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.ObjectFactory; + import forge.ImageCache; import forge.ImageKeys; import forge.Singletons; @@ -11,31 +31,13 @@ import forge.localinstance.properties.ForgePreferences; import forge.model.FModel; import forge.util.Localizer; import forge.util.TextUtil; -import org.apache.commons.lang3.StringUtils; -import org.mockito.Mockito; -import org.powermock.api.mockito.PowerMockito; -import org.powermock.core.classloader.annotations.PowerMockIgnore; -import org.powermock.core.classloader.annotations.PrepareForTest; -import org.powermock.core.classloader.annotations.SuppressStaticInitializationFor; -import org.powermock.modules.testng.PowerMockTestCase; -import org.testng.IObjectFactory; -import org.testng.annotations.BeforeMethod; -import org.testng.annotations.ObjectFactory; -import javax.imageio.ImageIO; -import java.io.File; -import java.lang.reflect.Field; -import java.util.Collections; -import java.util.Enumeration; -import java.util.Locale; -import java.util.ResourceBundle; - -@PrepareForTest(value = {FModel.class, Singletons.class, ResourceBundle.class, - ImageCache.class, ImageIO.class, ImageKeys.class, - ForgeConstants.class, Localizer.class}) -@SuppressStaticInitializationFor({"forge.ImageCache", "forge.localinstance.properties.ForgeConstants"}) -@PowerMockIgnore({"javax.xml.*", "org.xml.sax.*", "com.sun.org.apache.xerces.*", "org.w3c.dom.*", "org.springframework.context.*", "org.apache.log4j.*"}) -public class ForgeCardMockTestCase extends PowerMockTestCase { +@PrepareForTest(value = { FModel.class, Singletons.class, ResourceBundle.class, ImageCache.class, ImageIO.class, + ImageKeys.class, ForgeConstants.class, Localizer.class }) +@SuppressStaticInitializationFor({ "forge.ImageCache", "forge.localinstance.properties.ForgeConstants" }) +@PowerMockIgnore({ "javax.xml.*", "org.xml.sax.*", "com.sun.org.apache.xerces.*", "org.w3c.dom.*", + "org.springframework.context.*", "org.apache.log4j.*" }) +public class CardMockTestCase extends PowerMockTestCase { public static final String MOCKED_LOCALISED_STRING = "any localised string"; @@ -73,7 +75,7 @@ public class ForgeCardMockTestCase extends PowerMockTestCase { Field fAssetsDir = PowerMockito.field(ForgeConstants.class, "ASSETS_DIR"); fAssetsDir.set(ForgeConstants.class, assetDir); // User Dir - String homeDir = ForgeCardMockTestCase.getUserDir(); + String homeDir = CardMockTestCase.getUserDir(); Field fUserDir = PowerMockito.field(ForgeConstants.class, "USER_DIR"); fUserDir.set(ForgeConstants.class, homeDir); // User Pref Dir @@ -130,11 +132,14 @@ public class ForgeCardMockTestCase extends PowerMockTestCase { @BeforeMethod protected void initMocks() throws Exception { - //Loading a card also automatically loads the image, which we do not want (even if it wouldn't cause exceptions). - //The static initializer block in ImageCache can't fully be mocked (https://code.google.com/p/powermock/issues/detail?id=256), so we also need to mess with ImageIO... + // Loading a card also automatically loads the image, which we do not want (even + // if it wouldn't cause exceptions). + // The static initializer block in ImageCache can't fully be mocked + // (https://code.google.com/p/powermock/issues/detail?id=256), so we also need + // to mess with ImageIO... initCardImageMocks(); initForgeConstants(); - //Mocking some more static stuff + // Mocking some more static stuff initForgePreferences(); initializeStaticData(); } @@ -166,7 +171,8 @@ public class ForgeCardMockTestCase extends PowerMockTestCase { } protected void initCardImageMocks() { - //make sure that loading images only happens in a GUI environment, so we no longer need to mock this + // make sure that loading images only happens in a GUI environment, so we no + // longer need to mock this PowerMockito.mockStatic(ImageIO.class); PowerMockito.mockStatic(ImageCache.class); PowerMockito.mockStatic(ImageKeys.class); diff --git a/forge-gui-desktop/src/test/java/forge/card/CardRequestTestCase.java b/forge-gui-desktop/src/test/java/forge/card/CardRequestTest.java similarity index 90% rename from forge-gui-desktop/src/test/java/forge/card/CardRequestTestCase.java rename to forge-gui-desktop/src/test/java/forge/card/CardRequestTest.java index f09e27eb496..ffb3826fac0 100644 --- a/forge-gui-desktop/src/test/java/forge/card/CardRequestTestCase.java +++ b/forge-gui-desktop/src/test/java/forge/card/CardRequestTest.java @@ -1,14 +1,19 @@ package forge.card; -import forge.card.CardDb.CardRequest; -import forge.item.IPaperCard; +import static org.testng.Assert.assertEquals; +import static org.testng.Assert.assertFalse; +import static org.testng.Assert.assertNotEquals; +import static org.testng.Assert.assertNull; +import static org.testng.Assert.assertTrue; + import org.testng.annotations.BeforeTest; import org.testng.annotations.Test; -import static org.testng.Assert.*; +import forge.card.CardDb.CardRequest; +import forge.item.IPaperCard; @Test(timeOut = 1000, enabled = true) -public class CardRequestTestCase { +public class CardRequestTest { private String cardName; private String edition; @@ -20,7 +25,7 @@ public class CardRequestTestCase { private final char sep = CardDb.NameSetSeparator; @BeforeTest - public void setup(){ + public void setup() { cardName = "Shivan Dragon"; edition = "2ED"; collNr = "175"; @@ -31,7 +36,7 @@ public class CardRequestTestCase { foilCollNr = "202"; } - public void testComposeCardNameAndSet(){ + public void testComposeCardNameAndSet() { // OK request String requestInfo = CardRequest.compose(cardName, edition); String expected = cardName + sep + edition; @@ -50,7 +55,7 @@ public class CardRequestTestCase { assertEquals(requestInfoFoil, foilCardName + sep + foilEdition); } - public void testComposeCardNameSetAndArtIndex(){ + public void testComposeCardNameSetAndArtIndex() { String requestInfo = CardRequest.compose(cardName, edition, 2); String expected = cardName + sep + edition + sep + 2; assertEquals(requestInfo, expected); @@ -61,20 +66,21 @@ public class CardRequestTestCase { assertEquals(requestNegativeArtIndex, expected); } - public void testComposeCardNameSetAndCollectorNumber(){ + public void testComposeCardNameSetAndCollectorNumber() { String requestInfo = CardRequest.compose(cardName, edition, collNr); String expCN = "[" + collNr + "]"; String expected = cardName + sep + edition + sep + expCN; assertEquals(requestInfo, expected); // collNr only one bracket - requestInfo = CardRequest.compose(cardName, edition, "["+collNr); + requestInfo = CardRequest.compose(cardName, edition, "[" + collNr); assertEquals(requestInfo, expected); - requestInfo = CardRequest.compose(cardName, edition, collNr+"]"); + requestInfo = CardRequest.compose(cardName, edition, collNr + "]"); assertEquals(requestInfo, expected); - // collNr with leading spaces, as possible result from a wrong parsing in a deck file + // collNr with leading spaces, as possible result from a wrong parsing in a deck + // file requestInfo = CardRequest.compose(cardName, edition, "\t\t 175 "); assertEquals(requestInfo, expected); @@ -83,13 +89,13 @@ public class CardRequestTestCase { assertEquals(requestInfo, cardName + sep + edition + sep); } - public void testComposeFullRequest(){ + public void testComposeFullRequest() { String requestInfo = CardRequest.compose(cardName, edition, 1, collNr); String expected = cardName + sep + edition + sep + 1 + sep + "[" + collNr + "]"; assertEquals(requestInfo, expected); } - public void testFromStringCardNameOnly(){ + public void testFromStringCardNameOnly() { CardRequest request = CardRequest.fromString(cardName); assertEquals(request.cardName, cardName); assertEquals(request.artIndex, IPaperCard.DEFAULT_ART_INDEX); @@ -97,7 +103,7 @@ public class CardRequestTestCase { assertEquals(request.collectorNumber, IPaperCard.NO_COLLECTOR_NUMBER); } - public void testFromStringCardNameAndSetCode(){ + public void testFromStringCardNameAndSetCode() { String requestString = cardName + sep + edition; CardRequest request = CardRequest.fromString(requestString); assertEquals(request.cardName, cardName); @@ -115,7 +121,7 @@ public class CardRequestTestCase { assertEquals(request.collectorNumber, IPaperCard.NO_COLLECTOR_NUMBER); } - public void testFromStringCardNameAndSetCodeAndArtIndex(){ + public void testFromStringCardNameAndSetCodeAndArtIndex() { String requestString = cardName + sep + edition + sep + 2; CardRequest request = CardRequest.fromString(requestString); assertEquals(request.cardName, cardName); @@ -131,7 +137,6 @@ public class CardRequestTestCase { assertEquals(request.artIndex, 20); assertEquals(request.collectorNumber, IPaperCard.NO_COLLECTOR_NUMBER); - // foil requestString = foilCardNameFoil + sep + foilEdition + sep + IPaperCard.DEFAULT_ART_INDEX; request = CardRequest.fromString(requestString); @@ -142,7 +147,7 @@ public class CardRequestTestCase { assertEquals(request.collectorNumber, IPaperCard.NO_COLLECTOR_NUMBER); } - public void testFromStringCardNameAndSetCodeAndCollectorNumber(){ + public void testFromStringCardNameAndSetCodeAndCollectorNumber() { String requestString = cardName + sep + edition + sep + "[" + collNr + "]"; CardRequest request = CardRequest.fromString(requestString); assertEquals(request.cardName, cardName); @@ -168,7 +173,7 @@ public class CardRequestTestCase { assertEquals(request.collectorNumber, foilCollNr); } - public void fromStringFullInfo(){ + public void fromStringFullInfo() { String requestString = cardName + sep + edition + sep + 2 + sep + "[" + collNr + "]"; CardRequest request = CardRequest.fromString(requestString); assertEquals(request.cardName, cardName); @@ -185,17 +190,17 @@ public class CardRequestTestCase { assertEquals(request.collectorNumber, IPaperCard.NO_COLLECTOR_NUMBER); // foil - requestString = foilCardNameFoil + sep + foilEdition + sep + 3 + sep +"[" + foilCollNr + "]"; + requestString = foilCardNameFoil + sep + foilEdition + sep + 3 + sep + "[" + foilCollNr + "]"; request = CardRequest.fromString(requestString); assertEquals(request.cardName, foilCardName); assertEquals(request.edition, foilEdition); - assertEquals(request.artIndex,3); + assertEquals(request.artIndex, 3); assertTrue(request.isFoil); assertEquals(request.collectorNumber, foilCollNr); } @Test - public void testCreatingCardRequestUsingAnotherRequestStringAsCardName(){ + public void testCreatingCardRequestUsingAnotherRequestStringAsCardName() { String requestString = CardRequest.compose(cardName, edition, 1); CardRequest request = CardRequest.fromString(requestString); @@ -216,7 +221,7 @@ public class CardRequestTestCase { } @Test - public void testCreatingCardRequestWithArtIndexGreaterThanNine(){ + public void testCreatingCardRequestWithArtIndexGreaterThanNine() { String requestString = CardRequest.compose("Island", "SLD", 13); CardRequest request = CardRequest.fromString(requestString); @@ -226,14 +231,16 @@ public class CardRequestTestCase { assertEquals(request.collectorNumber, IPaperCard.NO_COLLECTOR_NUMBER); } - @Test void isFoilCardNameMethod(){ + @Test + void isFoilCardNameMethod() { assertTrue(CardRequest.isFoilCardName("Counterspell+")); assertFalse(CardRequest.isFoilCardName("Counterspell")); assertTrue(CardRequest.isFoilCardName(" Counterspell+ ")); assertFalse(CardRequest.isFoilCardName(" Counterspell ")); } - @Test void testComposeCardRequestWithCardNameAndFoil(){ + @Test + void testComposeCardRequestWithCardNameAndFoil() { String cardName = "Counterspell"; String foilCardName = "Counterspell+"; diff --git a/forge-gui-desktop/src/test/java/forge/card/LegacyCardDb.java b/forge-gui-desktop/src/test/java/forge/card/LegacyCardDb.java index 876910c870d..14732520ee4 100644 --- a/forge-gui-desktop/src/test/java/forge/card/LegacyCardDb.java +++ b/forge-gui-desktop/src/test/java/forge/card/LegacyCardDb.java @@ -1,49 +1,54 @@ package forge.card; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Date; +import java.util.List; +import java.util.TreeMap; + +import org.apache.commons.lang3.StringUtils; + import com.google.common.base.Predicate; import com.google.common.collect.Iterables; import com.google.common.collect.ListMultimap; import com.google.common.collect.Lists; import com.google.common.collect.Multimaps; + import forge.item.PaperCard; import forge.util.Aggregates; import forge.util.CollectionSuppliers; import forge.util.MyRandom; import forge.util.TextUtil; -import org.apache.commons.lang3.StringUtils; - -import java.util.*; /** - * Test Class (only for test purposes) to compare previous method implementations - * with the new refactored ones. This class has been updated to the latest version - * available of methods' implementation before the change is going to be submitted. - * This is also a useful way to keep a backlog of changes whenever major - * API changes like this MR are going to happen. + * Test Class (only for test purposes) to compare previous method + * implementations with the new refactored ones. This class has been updated to + * the latest version available of methods' implementation before the change is + * going to be submitted. This is also a useful way to keep a backlog of changes + * whenever major API changes like this MR are going to happen. */ public class LegacyCardDb { public CardEdition.Collection editions; - public ListMultimap allCardsByName = Multimaps.newListMultimap(new TreeMap<>(String.CASE_INSENSITIVE_ORDER), CollectionSuppliers.arrayLists()); + public ListMultimap allCardsByName = Multimaps + .newListMultimap(new TreeMap<>(String.CASE_INSENSITIVE_ORDER), CollectionSuppliers.arrayLists()); public enum LegacySetPreference { - Latest(false), - LatestCoreExp(true), - Earliest(false), - EarliestCoreExp(true), - Random(false); + Latest(false), LatestCoreExp(true), Earliest(false), EarliestCoreExp(true), Random(false); final boolean filterSets; + LegacySetPreference(boolean filterIrregularSets) { filterSets = filterIrregularSets; } public boolean accept(CardEdition ed) { - if (ed == null) return false; - return !filterSets || ed.getType() == CardEdition.Type.CORE || ed.getType() == CardEdition.Type.EXPANSION || ed.getType() == CardEdition.Type.REPRINT; + if (ed == null) + return false; + return !filterSets || ed.getType() == CardEdition.Type.CORE || ed.getType() == CardEdition.Type.EXPANSION + || ed.getType() == CardEdition.Type.REPRINT; } } - public final static String foilSuffix = "+"; public final static char NameSetSeparator = '|'; @@ -53,7 +58,7 @@ public class LegacyCardDb { public String edition; public int artIndex; public boolean isFoil; - + private LegacyCardRequest(String name, String edition, int artIndex, boolean isFoil) { cardName = name; this.edition = edition; @@ -70,7 +75,8 @@ public class LegacyCardDb { String[] nameParts = TextUtil.split(name, NameSetSeparator); int setPos = nameParts.length >= 2 && !StringUtils.isNumeric(nameParts[1]) ? 1 : -1; - int artPos = nameParts.length >= 2 && StringUtils.isNumeric(nameParts[1]) ? 1 : nameParts.length >= 3 && StringUtils.isNumeric(nameParts[2]) ? 2 : -1; + int artPos = nameParts.length >= 2 && StringUtils.isNumeric(nameParts[1]) ? 1 + : nameParts.length >= 3 && StringUtils.isNumeric(nameParts[2]) ? 2 : -1; String cardName = nameParts[0]; if (cardName.endsWith(foilSuffix)) { @@ -88,9 +94,9 @@ public class LegacyCardDb { } } - public LegacyCardDb(Collection cards0, CardEdition.Collection editions){ + public LegacyCardDb(Collection cards0, CardEdition.Collection editions) { this.editions = editions; - for (PaperCard card : cards0){ + for (PaperCard card : cards0) { allCardsByName.put(card.getName(), card); } } @@ -133,7 +139,9 @@ public class LegacyCardDb { private PaperCard tryGetCard(LegacyCardDb.LegacyCardRequest request) { Collection cards = getAllCards(request.cardName); - if (cards == null) { return null; } + if (cards == null) { + return null; + } PaperCard result = null; @@ -149,8 +157,7 @@ public class LegacyCardDb { Collection candidates; if (reqEdition == null) { candidates = new ArrayList<>(cards); - } - else { + } else { candidates = new ArrayList<>(); for (PaperCard pc : cards) { if (pc.getEdition().equalsIgnoreCase(reqEdition)) { @@ -163,13 +170,12 @@ public class LegacyCardDb { } result = Aggregates.random(candidates); - //if card image doesn't exist for chosen candidate, try another one if possible + // if card image doesn't exist for chosen candidate, try another one if possible while (candidates.size() > 1 && !result.hasImage()) { candidates.remove(result); result = Aggregates.random(candidates); } - } - else { + } else { for (PaperCard pc : cards) { if (pc.getEdition().equalsIgnoreCase(reqEdition) && request.artIndex == pc.getArtIndex()) { result = pc; @@ -177,7 +183,9 @@ public class LegacyCardDb { } } } - if (result == null) { return null; } + if (result == null) { + return null; + } return request.isFoil ? getFoiled(result) : result; } @@ -185,28 +193,32 @@ public class LegacyCardDb { public PaperCard getFoiled(PaperCard card0) { return card0.getFoiled(); } - + public PaperCard getCardFromEdition(final String cardName, LegacySetPreference fromSet) { return getCardFromEdition(cardName, null, fromSet); } - - public PaperCard getCardFromEdition(final String cardName, final Date printedBefore, final LegacySetPreference fromSet) { + + public PaperCard getCardFromEdition(final String cardName, final Date printedBefore, + final LegacySetPreference fromSet) { return getCardFromEdition(cardName, printedBefore, fromSet, -1); } - - public PaperCard getCardFromEdition(final String cardName, final Date printedBefore, final LegacySetPreference fromSets, int artIndex) { + + public PaperCard getCardFromEdition(final String cardName, final Date printedBefore, + final LegacySetPreference fromSets, int artIndex) { final CardDb.CardRequest cr = CardDb.CardRequest.fromString(cardName); LegacySetPreference fromSet = fromSets; List cards = getAllCards(cr.cardName); - if (printedBefore != null){ + if (printedBefore != null) { cards = Lists.newArrayList(Iterables.filter(cards, new Predicate() { - @Override public boolean apply(PaperCard c) { + @Override + public boolean apply(PaperCard c) { CardEdition ed = editions.get(c.getEdition()); - return ed.getDate().before(printedBefore); } + return ed.getDate().before(printedBefore); + } })); } - if (cards.size() == 0) // Don't bother continuing! No cards has been found! + if (cards.size() == 0) // Don't bother continuing! No cards has been found! return null; boolean cardsListReadOnly = true; @@ -217,7 +229,10 @@ public class LegacyCardDb { if (StringUtils.isNotBlank(cr.edition)) { cards = Lists.newArrayList(Iterables.filter(cards, new Predicate() { - @Override public boolean apply(PaperCard input) { return input.getEdition().equalsIgnoreCase(cr.edition); } + @Override + public boolean apply(PaperCard input) { + return input.getEdition().equalsIgnoreCase(cr.edition); + } })); } if (artIndex == -1 && cr.artIndex > 0) { @@ -227,25 +242,25 @@ public class LegacyCardDb { int sz = cards.size(); if (fromSet == LegacySetPreference.Earliest || fromSet == LegacySetPreference.EarliestCoreExp) { PaperCard firstWithoutImage = null; - for (int i = sz - 1 ; i >= 0 ; i--) { + for (int i = sz - 1; i >= 0; i--) { PaperCard pc = cards.get(i); CardEdition ed = editions.get(pc.getEdition()); if (!fromSet.accept(ed)) { continue; } - if ((artIndex <= 0 || pc.getArtIndex() == artIndex) && (printedBefore == null || ed.getDate().before(printedBefore))) { + if ((artIndex <= 0 || pc.getArtIndex() == artIndex) + && (printedBefore == null || ed.getDate().before(printedBefore))) { if (pc.hasImage()) { return pc; - } - else if (firstWithoutImage == null) { - firstWithoutImage = pc; //ensure first without image returns if none have image + } else if (firstWithoutImage == null) { + firstWithoutImage = pc; // ensure first without image returns if none have image } } } return firstWithoutImage; - } - else if (fromSet == LegacySetPreference.LatestCoreExp || fromSet == LegacySetPreference.Latest || fromSet == null || fromSet == LegacySetPreference.Random) { + } else if (fromSet == LegacySetPreference.LatestCoreExp || fromSet == LegacySetPreference.Latest + || fromSet == null || fromSet == LegacySetPreference.Random) { PaperCard firstWithoutImage = null; for (int i = 0; i < sz; i++) { PaperCard pc = cards.get(i); @@ -254,31 +269,29 @@ public class LegacyCardDb { continue; } - if ((artIndex < 0 || pc.getArtIndex() == artIndex) && (printedBefore == null || ed.getDate().before(printedBefore))) { + if ((artIndex < 0 || pc.getArtIndex() == artIndex) + && (printedBefore == null || ed.getDate().before(printedBefore))) { if (fromSet == LegacySetPreference.LatestCoreExp || fromSet == LegacySetPreference.Latest) { if (pc.hasImage()) { return pc; + } else if (firstWithoutImage == null) { + firstWithoutImage = pc; // ensure first without image returns if none have image } - else if (firstWithoutImage == null) { - firstWithoutImage = pc; //ensure first without image returns if none have image - } - } - else { + } else { while (sz > i) { int randomIndex = i + MyRandom.getRandom().nextInt(sz - i); pc = cards.get(randomIndex); if (pc.hasImage()) { return pc; - } - else { + } else { if (firstWithoutImage == null) { - firstWithoutImage = pc; //ensure first without image returns if none have image + firstWithoutImage = pc; // ensure first without image returns if none have image } - if (cardsListReadOnly) { //ensure we don't modify a cached collection + if (cardsListReadOnly) { // ensure we don't modify a cached collection cards = new ArrayList<>(cards); cardsListReadOnly = false; } - cards.remove(randomIndex); //remove card from collection and try another random card + cards.remove(randomIndex); // remove card from collection and try another random card sz--; } } diff --git a/forge-gui-desktop/src/test/java/forge/deck/DeckRecognizerTest.java b/forge-gui-desktop/src/test/java/forge/deck/DeckRecognizerTest.java index 21c111fac5e..b6c661e97c2 100644 --- a/forge-gui-desktop/src/test/java/forge/deck/DeckRecognizerTest.java +++ b/forge-gui-desktop/src/test/java/forge/deck/DeckRecognizerTest.java @@ -3,7 +3,7 @@ package forge.deck; import forge.StaticData; import forge.card.CardDb; import forge.card.CardEdition; -import forge.card.ForgeCardMockTestCase; +import forge.card.CardMockTestCase; import forge.card.MagicColor; import forge.item.IPaperCard; import forge.item.PaperCard; @@ -19,13 +19,13 @@ import java.util.regex.Matcher; import java.util.regex.Pattern; import java.util.stream.Collectors; -public class DeckRecognizerTest extends ForgeCardMockTestCase { +public class DeckRecognizerTest extends CardMockTestCase { private Set mtgUniqueCardNames; private Set mtgUniqueSetCodes; private Set mtgUniqueCollectorNumbers; - private void initMaps(){ + private void initMaps() { StaticData magicDb = FModel.getMagicDb(); mtgUniqueCardNames = new HashSet<>(); mtgUniqueSetCodes = new HashSet<>(); @@ -60,11 +60,12 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { /*================================== * Rex Parsing and Matching: CARD DB * ================================= */ - @Test void testMatchAllCardNamesInForgeDB(){ + @Test + void testMatchAllCardNamesInForgeDB() { if (mtgUniqueCardNames == null) this.initMaps(); Pattern cardNamePattern = Pattern.compile(DeckRecognizer.REX_CARD_NAME); - for (String cardName : this.mtgUniqueCardNames){ + for (String cardName : this.mtgUniqueCardNames) { Matcher cardNameMatcher = cardNamePattern.matcher(cardName); assertTrue(cardNameMatcher.matches(), "Fail on " + cardName); String matchedCardName = cardNameMatcher.group(DeckRecognizer.REGRP_CARD); @@ -72,11 +73,12 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { } } - @Test void testMatchAllSetCodesAndAlternateCodesInForgeDB(){ + @Test + void testMatchAllSetCodesAndAlternateCodesInForgeDB() { if (mtgUniqueCardNames == null) this.initMaps(); Pattern setCodePattern = Pattern.compile(DeckRecognizer.REX_SET_CODE); - for (String setCode : this.mtgUniqueSetCodes){ + for (String setCode : this.mtgUniqueSetCodes) { Matcher setCodeMatcher = setCodePattern.matcher(setCode); assertTrue(setCodeMatcher.matches(), "Fail on " + setCode); String matchedSetCode = setCodeMatcher.group(DeckRecognizer.REGRP_SET); @@ -84,11 +86,12 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { } } - @Test void testMatchAllPossibleCollectorNumbersInForgeDB(){ + @Test + void testMatchAllPossibleCollectorNumbersInForgeDB() { if (mtgUniqueCardNames == null) this.initMaps(); Pattern collNumberPattern = Pattern.compile(DeckRecognizer.REX_COLL_NUMBER); - for (String collectorNumber : this.mtgUniqueCollectorNumbers){ + for (String collectorNumber : this.mtgUniqueCollectorNumbers) { Matcher collNumberMatcher = collNumberPattern.matcher(collectorNumber); assertTrue(collNumberMatcher.matches()); String matchedCollNr = collNumberMatcher.group(DeckRecognizer.REGRP_COLLNR); @@ -96,17 +99,18 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { } } - @Test void testCardQuantityRequest(){ + @Test + void testCardQuantityRequest() { Pattern cardCountPattern = Pattern.compile(DeckRecognizer.REX_CARD_COUNT); - String[] correctAmountRequests = new String[] {"0", "2", "12", "4", "8x", "12x"}; - String[] inCorrectAmountRequests = new String[] {"-2", "-23", "NO", "133"}; + String[] correctAmountRequests = new String[] { "0", "2", "12", "4", "8x", "12x" }; + String[] inCorrectAmountRequests = new String[] { "-2", "-23", "NO", "133" }; for (String correctReq : correctAmountRequests) { Matcher matcher = cardCountPattern.matcher(correctReq); assertTrue(matcher.matches()); String expectedRequestAmount = correctReq; if (correctReq.endsWith("x")) - expectedRequestAmount = correctReq.substring(0, correctReq.length()-1); + expectedRequestAmount = correctReq.substring(0, correctReq.length() - 1); assertEquals(matcher.group(DeckRecognizer.REGRP_CARDNO), expectedRequestAmount); int expectedAmount = Integer.parseInt(expectedRequestAmount); @@ -119,7 +123,8 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { } } - @Test void testMatchingFoilCardName(){ + @Test + void testMatchingFoilCardName() { String foilCardName = "Counter spell+"; Pattern cardNamePattern = Pattern.compile(DeckRecognizer.REX_CARD_NAME); Matcher cardNameMatcher = cardNamePattern.matcher(foilCardName); @@ -128,7 +133,8 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(matchedCardName, foilCardName, "Fail on " + foilCardName); } - @Test void testMatchDeckName(){ + @Test + void testMatchDeckName() { Pattern deckNamePattern = DeckRecognizer.DECK_NAME_PATTERN; String matchingDeckName = "Deck: Red Green Aggro"; @@ -214,7 +220,8 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(DeckRecognizer.deckNameMatch(matchingDeckName), ""); } - @Test void testDeckNameAsInNetDecksWithSymbols(){ + @Test + void testDeckNameAsInNetDecksWithSymbols() { String deckName = "Name = [Standard] #02 - Dimir Rogues"; Pattern deckNamePattern = DeckRecognizer.DECK_NAME_PATTERN; Matcher deckNameMatcher = deckNamePattern.matcher(deckName); @@ -224,9 +231,10 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(DeckRecognizer.deckNameMatch(deckName), "[Standard] #02 - Dimir Rogues"); } - @Test void testMatchDeckSectionNames(){ - String[] dckSections = new String[] {"Main", "main", "Mainboard", "Sideboard", "Side", "Schemes", "Avatar", - "avatar", "Commander", "Conspiracy", "card", "Planes", "Dungeon"}; + @Test + void testMatchDeckSectionNames() { + String[] dckSections = new String[] { "Main", "main", "Mainboard", "Sideboard", "Side", "Schemes", "Avatar", + "avatar", "Commander", "Conspiracy", "card", "Planes", "Dungeon" }; for (String section : dckSections) assertTrue(DeckRecognizer.isDeckSectionName(section), "Unrecognised Deck Section: " + section); @@ -235,17 +243,18 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertFalse(DeckRecognizer.isDeckSectionName("Planeswalker's Mischief")); assertFalse(DeckRecognizer.isDeckSectionName("Demon of Dark Schemes")); - String[] deckSectionEntriesFoundInMDExportFromTappedOut = new String[]{ - "## Sideboard (15)", "## Mainboard (86)"}; - for (String entry: deckSectionEntriesFoundInMDExportFromTappedOut) - assertTrue(DeckRecognizer.isDeckSectionName(entry), "Fail on "+entry); + String[] deckSectionEntriesFoundInMDExportFromTappedOut = new String[] { "## Sideboard (15)", + "## Mainboard (86)" }; + for (String entry : deckSectionEntriesFoundInMDExportFromTappedOut) + assertTrue(DeckRecognizer.isDeckSectionName(entry), "Fail on " + entry); - String[] deckSectionEntriesFoundInDCKFormat = new String[] {"[Main]", "[Sideboard]", "[Dungeon]"}; - for (String entry: deckSectionEntriesFoundInDCKFormat) - assertTrue(DeckRecognizer.isDeckSectionName(entry), "Fail on "+entry); + String[] deckSectionEntriesFoundInDCKFormat = new String[] { "[Main]", "[Sideboard]", "[Dungeon]" }; + for (String entry : deckSectionEntriesFoundInDCKFormat) + assertTrue(DeckRecognizer.isDeckSectionName(entry), "Fail on " + entry); } - @Test void testSBshortAsPlaceholderForSideboard(){ + @Test + void testSBshortAsPlaceholderForSideboard() { String dckSec = "SB:"; assertTrue(DeckRecognizer.isDeckSectionName(dckSec)); @@ -256,73 +265,75 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(token.getText(), "Sideboard"); } - @Test void testMatchCardTypes(){ - String[] cardTypes = new String[] {"Spell", "instants", "Sorceries", "Sorcery", - "Artifact", "creatures", "land"}; + @Test + void testMatchCardTypes() { + String[] cardTypes = new String[] { "Spell", "instants", "Sorceries", "Sorcery", "Artifact", "creatures", + "land" }; for (String cardType : cardTypes) - assertTrue(DeckRecognizer.isCardType(cardType), "Fail on "+cardType); + assertTrue(DeckRecognizer.isCardType(cardType), "Fail on " + cardType); - String[] cardTypesEntriesFoundInMDExportFromTappedOut = new String[]{ - "### Instant (14)", "### Sorcery (9)", "### Artifact (14)", - "### Creature (2)", "### Land (21)", }; - for (String entry: cardTypesEntriesFoundInMDExportFromTappedOut) - assertTrue(DeckRecognizer.isCardType(entry), "Fail on "+entry); + String[] cardTypesEntriesFoundInMDExportFromTappedOut = new String[] { "### Instant (14)", "### Sorcery (9)", + "### Artifact (14)", "### Creature (2)", "### Land (21)", }; + for (String entry : cardTypesEntriesFoundInMDExportFromTappedOut) + assertTrue(DeckRecognizer.isCardType(entry), "Fail on " + entry); - String[] cardTypesInDecFormat = new String[] { - "//Lands", "//Artifacts", "//Enchantments", - "//Instants", "//Sorceries", "//Planeswalkers", - "//Creatures"}; + String[] cardTypesInDecFormat = new String[] { "//Lands", "//Artifacts", "//Enchantments", "//Instants", + "//Sorceries", "//Planeswalkers", "//Creatures" }; for (String entry : cardTypesInDecFormat) assertTrue(DeckRecognizer.isCardType(entry), "Fail on " + entry); } - @Test void testOnlyContainingCardTypeWontMatchCardTypeToken(){ - String[] nonCardTypes = new String[] {"Spell collection", "instants list", - "creatures elves", "land list"}; + @Test + void testOnlyContainingCardTypeWontMatchCardTypeToken() { + String[] nonCardTypes = new String[] { "Spell collection", "instants list", "creatures elves", "land list" }; for (String nonCardTypeTokens : nonCardTypes) - assertFalse(DeckRecognizer.isCardType(nonCardTypeTokens), "Fail on "+nonCardTypeTokens); + assertFalse(DeckRecognizer.isCardType(nonCardTypeTokens), "Fail on " + nonCardTypeTokens); } - @Test void testRarityTypeTokenMatch(){ - String[] rarityTokens = new String[] {"Common", "uncommon", "rare", "mythic", "mythic rare", "land", "special"}; + @Test + void testRarityTypeTokenMatch() { + String[] rarityTokens = new String[] { "Common", "uncommon", "rare", "mythic", "mythic rare", "land", + "special" }; for (String line : rarityTokens) - assertTrue(DeckRecognizer.isCardRarity(line), "Fail on "+line); + assertTrue(DeckRecognizer.isCardRarity(line), "Fail on " + line); - String[] nonRarityTokens = new String[] {"Common cards", "uncommon cards", "mythics", "rares", "lands"}; + String[] nonRarityTokens = new String[] { "Common cards", "uncommon cards", "mythics", "rares", "lands" }; for (String line : nonRarityTokens) - assertFalse(DeckRecognizer.isCardRarity(line), "Fail on "+line); + assertFalse(DeckRecognizer.isCardRarity(line), "Fail on " + line); } - @Test void testCMCTokenMatch(){ - String[] cmcTokens = new String[] {"CC0", "CMC2", "CMC11", "cc3"}; + @Test + void testCMCTokenMatch() { + String[] cmcTokens = new String[] { "CC0", "CMC2", "CMC11", "cc3" }; for (String line : cmcTokens) - assertTrue(DeckRecognizer.isCardCMC(line), "Fail on "+line); + assertTrue(DeckRecognizer.isCardCMC(line), "Fail on " + line); - String[] nonCMCtokens = new String[] {"cc", "CMC", "cc322", "cmc111"}; + String[] nonCMCtokens = new String[] { "cc", "CMC", "cc322", "cmc111" }; for (String line : nonCMCtokens) - assertFalse(DeckRecognizer.isCardCMC(line), "Fail on "+line); + assertFalse(DeckRecognizer.isCardCMC(line), "Fail on " + line); } - @Test void testManaSymbolsMatches(){ + @Test + void testManaSymbolsMatches() { Pattern manaSymbolPattern = DeckRecognizer.MANA_PATTERN; List colours = Arrays.asList(MagicColor.Color.COLORLESS, MagicColor.Color.BLACK, MagicColor.Color.BLUE, MagicColor.Color.GREEN, MagicColor.Color.RED, MagicColor.Color.GREEN); - for (MagicColor.Color color : colours){ + for (MagicColor.Color color : colours) { String matchingManaSymbol = color.getSymbol(); Matcher manaSymbolMatcher = manaSymbolPattern.matcher(matchingManaSymbol); assertTrue(manaSymbolMatcher.matches(), "Failed on : " + matchingManaSymbol); } // Lowercase - for (MagicColor.Color color : colours){ + for (MagicColor.Color color : colours) { String matchingManaSymbol = color.getSymbol().toLowerCase(); Matcher manaSymbolMatcher = manaSymbolPattern.matcher(matchingManaSymbol); assertTrue(manaSymbolMatcher.matches(), "Failed on : " + matchingManaSymbol); } // No Brackets - SO expected to fail matching - for (MagicColor.Color color : colours){ + for (MagicColor.Color color : colours) { String matchingManaSymbol = color.getSymbol().toLowerCase().substring(1, color.getSymbol().length()); Matcher manaSymbolMatcher = manaSymbolPattern.matcher(matchingManaSymbol); assertFalse(manaSymbolMatcher.matches(), "Failed on : " + matchingManaSymbol); @@ -342,19 +353,17 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertFalse(manaSymbolMatcher.matches()); } - @Test void testManaTokenMatch(){ + @Test + void testManaTokenMatch() { DeckRecognizer recognizer = new DeckRecognizer(); - String[] cmcTokens = new String[] {"Blue", "red", "White", "// Black", - " //Colorless----", "(green)", - "// Multicolor", "// MultiColour"}; + String[] cmcTokens = new String[] { "Blue", "red", "White", "// Black", " //Colorless----", "(green)", + "// Multicolor", "// MultiColour" }; - String cname = ForgeCardMockTestCase.MOCKED_LOCALISED_STRING; - String[] expectedTokenText = new String[] { - String.format("%s {U}", cname), String.format("%s {R}", cname), - String.format("%s {W}", cname), String.format("%s {B}", cname), - String.format("%s {C}", cname), String.format("%s {G}", cname), - String.format("%s {W}{U}{B}{R}{G}", cname), String.format("%s {W}{U}{B}{R}{G}", cname) - }; + String cname = CardMockTestCase.MOCKED_LOCALISED_STRING; + String[] expectedTokenText = new String[] { String.format("%s {U}", cname), String.format("%s {R}", cname), + String.format("%s {W}", cname), String.format("%s {B}", cname), String.format("%s {C}", cname), + String.format("%s {G}", cname), String.format("%s {W}{U}{B}{R}{G}", cname), + String.format("%s {W}{U}{B}{R}{G}", cname) }; for (int i = 0; i < cmcTokens.length; i++) { String line = cmcTokens[i]; assertTrue(DeckRecognizer.isManaToken(line), "Fail on " + line); @@ -363,28 +372,21 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(manaToken.getText(), expectedTokenText[i]); } - String[] nonCMCtokens = new String[] {"blues", "red more words", "mainboard"}; + String[] nonCMCtokens = new String[] { "blues", "red more words", "mainboard" }; for (String line : nonCMCtokens) - assertFalse(DeckRecognizer.isManaToken(line), "Fail on "+line); + assertFalse(DeckRecognizer.isManaToken(line), "Fail on " + line); } - @Test void testManaTokensBiColors(){ + @Test + void testManaTokensBiColors() { DeckRecognizer recognizer = new DeckRecognizer(); - String[] cmcTokens = new String[] { - "Blue White", "red-black", "White green", "// Black Blue", "(green|red)"}; - String[] manaTokens = new String[] { - "{U} {W}", "{r}-{b}", "{W} {g}", "// {B} {U}", "({g}|{r})"}; - String[] mixedSymbols = new String[] { - "{u} White", "{R}-black", "White {g}", "// {b} Blue", "(green|{r})" - }; - String cname = ForgeCardMockTestCase.MOCKED_LOCALISED_STRING; - String[] expectedTokenText = new String[] { - String.format("%s/%s %s", cname, cname, "{WU}"), - String.format("%s/%s %s", cname, cname, "{BR}"), - String.format("%s/%s %s", cname, cname, "{GW}"), - String.format("%s/%s %s", cname, cname, "{UB}"), - String.format("%s/%s %s", cname, cname, "{RG}") - }; + String[] cmcTokens = new String[] { "Blue White", "red-black", "White green", "// Black Blue", "(green|red)" }; + String[] manaTokens = new String[] { "{U} {W}", "{r}-{b}", "{W} {g}", "// {B} {U}", "({g}|{r})" }; + String[] mixedSymbols = new String[] { "{u} White", "{R}-black", "White {g}", "// {b} Blue", "(green|{r})" }; + String cname = CardMockTestCase.MOCKED_LOCALISED_STRING; + String[] expectedTokenText = new String[] { String.format("%s/%s %s", cname, cname, "{WU}"), + String.format("%s/%s %s", cname, cname, "{BR}"), String.format("%s/%s %s", cname, cname, "{GW}"), + String.format("%s/%s %s", cname, cname, "{UB}"), String.format("%s/%s %s", cname, cname, "{RG}") }; for (int i = 0; i < cmcTokens.length; i++) { String line = cmcTokens[i]; @@ -392,7 +394,7 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { Token manaToken = recognizer.recogniseNonCardToken(line); assertNotNull(manaToken); assertEquals(manaToken.getText(), expectedTokenText[i]); - //Symbol + // Symbol String symbol = manaTokens[i]; assertTrue(DeckRecognizer.isManaToken(symbol), "Fail on " + symbol); Token manaSymbolToken = recognizer.recogniseNonCardToken(symbol); @@ -407,24 +409,19 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { } } - @Test void testTokenBiColorSymbols(){ + @Test + void testTokenBiColorSymbols() { DeckRecognizer recognizer = new DeckRecognizer(); - String[] manaSymbols = new String[] {"{WU}", "{UB}", "{BR}", "{GW}", "{RG}", - "{WB}", "{UR}", "{BG}", "{RW}", "{GU}"}; + String[] manaSymbols = new String[] { "{WU}", "{UB}", "{BR}", "{GW}", "{RG}", "{WB}", "{UR}", "{BG}", "{RW}", + "{GU}" }; - String cname = ForgeCardMockTestCase.MOCKED_LOCALISED_STRING; - String[] expectedTokenText = new String[] { - String.format("%s/%s %s", cname, cname, "{WU}"), - String.format("%s/%s %s", cname, cname, "{UB}"), - String.format("%s/%s %s", cname, cname, "{BR}"), - String.format("%s/%s %s", cname, cname, "{GW}"), - String.format("%s/%s %s", cname, cname, "{RG}"), - String.format("%s/%s %s", cname, cname, "{WB}"), - String.format("%s/%s %s", cname, cname, "{UR}"), - String.format("%s/%s %s", cname, cname, "{BG}"), - String.format("%s/%s %s", cname, cname, "{RW}"), - String.format("%s/%s %s", cname, cname, "{GU}") - }; + String cname = CardMockTestCase.MOCKED_LOCALISED_STRING; + String[] expectedTokenText = new String[] { String.format("%s/%s %s", cname, cname, "{WU}"), + String.format("%s/%s %s", cname, cname, "{UB}"), String.format("%s/%s %s", cname, cname, "{BR}"), + String.format("%s/%s %s", cname, cname, "{GW}"), String.format("%s/%s %s", cname, cname, "{RG}"), + String.format("%s/%s %s", cname, cname, "{WB}"), String.format("%s/%s %s", cname, cname, "{UR}"), + String.format("%s/%s %s", cname, cname, "{BG}"), String.format("%s/%s %s", cname, cname, "{RW}"), + String.format("%s/%s %s", cname, cname, "{GU}") }; for (int i = 0; i < manaSymbols.length; i++) { String manaSymbol = manaSymbols[i]; @@ -435,11 +432,11 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { } } - @Test void testManaTokensRepeatedAreIgnored(){ + @Test + void testManaTokensRepeatedAreIgnored() { DeckRecognizer recognizer = new DeckRecognizer(); - String[] cmcTokens = new String[] {"Blue Blue", "red-red", "White white", - "// black BLACK", "(Green|grEEn)", }; - String[] expectedTokenText = new String[] {"{U}", "{R}", "{W}", "{B}", "{G}"}; + String[] cmcTokens = new String[] { "Blue Blue", "red-red", "White white", "// black BLACK", "(Green|grEEn)", }; + String[] expectedTokenText = new String[] { "{U}", "{R}", "{W}", "{B}", "{G}" }; for (int i = 0; i < cmcTokens.length; i++) { String line = cmcTokens[i]; assertTrue(DeckRecognizer.isManaToken(line), "Fail on " + line); @@ -448,35 +445,33 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertTrue(manaToken.getText().endsWith(expectedTokenText[i])); } - String[] manaTokens = new String[] {"{u} {u}", "{R}-{R}", "{w} {W}", - "// {b} {B}", "({G}|{g})", }; - String[] expectedManaSymbols = new String[] {"{U}", "{R}", "{W}", "{B}", "{G}"}; + String[] manaTokens = new String[] { "{u} {u}", "{R}-{R}", "{w} {W}", "// {b} {B}", "({G}|{g})", }; + String[] expectedManaSymbols = new String[] { "{U}", "{R}", "{W}", "{B}", "{G}" }; for (int i = 0; i < manaTokens.length; i++) { String line = manaTokens[i]; assertTrue(DeckRecognizer.isManaToken(line), "Fail on " + line); Token manaToken = recognizer.recogniseNonCardToken(line); assertNotNull(manaToken); assertTrue(manaToken.getText().endsWith(expectedManaSymbols[i])); - assertFalse(manaToken.getText().endsWith( - String.format("%s %s", expectedManaSymbols[i], expectedManaSymbols[i]))); - assertFalse(manaToken.getText().endsWith( - String.format("%s%s", expectedManaSymbols[i], expectedManaSymbols[i]))); - assertFalse(manaToken.getText().endsWith( - String.format("%s/%s", expectedManaSymbols[i], expectedManaSymbols[i]))); + assertFalse(manaToken.getText() + .endsWith(String.format("%s %s", expectedManaSymbols[i], expectedManaSymbols[i]))); + assertFalse(manaToken.getText() + .endsWith(String.format("%s%s", expectedManaSymbols[i], expectedManaSymbols[i]))); + assertFalse(manaToken.getText() + .endsWith(String.format("%s/%s", expectedManaSymbols[i], expectedManaSymbols[i]))); } } - @Test void testMultiColourOrColourlessManaTokensWillBeHandledSeparately(){ + @Test + void testMultiColourOrColourlessManaTokensWillBeHandledSeparately() { DeckRecognizer recognizer = new DeckRecognizer(); - String[] cmcTokens = new String[] {"Blue Colourless", "Red Multicolour", "Colorless White", - "// Multicolour ", "(green|Colourless)"}; - String cname = ForgeCardMockTestCase.MOCKED_LOCALISED_STRING; - String[] expectedTokenText = new String[] { - String.format("%s {U} // %s {C}", cname, cname), + String[] cmcTokens = new String[] { "Blue Colourless", "Red Multicolour", "Colorless White", "// Multicolour ", + "(green|Colourless)" }; + String cname = CardMockTestCase.MOCKED_LOCALISED_STRING; + String[] expectedTokenText = new String[] { String.format("%s {U} // %s {C}", cname, cname), String.format("%s {R} // %s {W}{U}{B}{R}{G}", cname, cname), - String.format("%s {C} // %s {W}", cname, cname), - String.format("%s {W}{U}{B}{R}{G}", cname), - String.format("%s {G} // %s {C}", cname, cname)}; + String.format("%s {C} // %s {W}", cname, cname), String.format("%s {W}{U}{B}{R}{G}", cname), + String.format("%s {G} // %s {C}", cname, cname) }; for (int i = 0; i < cmcTokens.length; i++) { String line = cmcTokens[i]; assertTrue(DeckRecognizer.isManaToken(line), "Fail on " + line); @@ -486,17 +481,15 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { } } - @Test void testCornerCasesWithSpecialMulticolourAndColorlessTokens(){ + @Test + void testCornerCasesWithSpecialMulticolourAndColorlessTokens() { DeckRecognizer recognizer = new DeckRecognizer(); // Test repeated - String[] cmcTokens = new String[] {"Colorless Colourless", "Multicolor Multicolour", - "Colorless colourless"}; + String[] cmcTokens = new String[] { "Colorless Colourless", "Multicolor Multicolour", "Colorless colourless" }; - String cname = ForgeCardMockTestCase.MOCKED_LOCALISED_STRING; - String[] expectedTokenText = new String[] { - String.format("%s {C}", cname), - String.format("%s {W}{U}{B}{R}{G}", cname), - String.format("%s {C}", cname)}; + String cname = CardMockTestCase.MOCKED_LOCALISED_STRING; + String[] expectedTokenText = new String[] { String.format("%s {C}", cname), + String.format("%s {W}{U}{B}{R}{G}", cname), String.format("%s {C}", cname) }; for (int i = 0; i < cmcTokens.length; i++) { String line = cmcTokens[i]; @@ -509,10 +502,12 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { // Test symbols } - /*============================= - * TEST RECOGNISE NON-CARD LINES - * ============================= */ - @Test void testMatchNonCardLine(){ + /* + * ============================= TEST RECOGNISE NON-CARD LINES + * ============================= + */ + @Test + void testMatchNonCardLine() { DeckRecognizer recognizer = new DeckRecognizer(); // Test Token Types @@ -592,13 +587,13 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { t = recognizer.recogniseNonCardToken("//Blue"); assertNotNull(t); assertEquals(t.getType(), TokenType.MANA_COLOUR); - assertEquals(t.getText(), String.format("%s {U}", ForgeCardMockTestCase.MOCKED_LOCALISED_STRING)); + assertEquals(t.getText(), String.format("%s {U}", CardMockTestCase.MOCKED_LOCALISED_STRING)); assertEquals(t.getQuantity(), 0); t = recognizer.recogniseNonCardToken("(Colorless)"); assertNotNull(t); assertEquals(t.getType(), TokenType.MANA_COLOUR); - assertEquals(t.getText(), String.format("%s {C}", ForgeCardMockTestCase.MOCKED_LOCALISED_STRING)); + assertEquals(t.getText(), String.format("%s {C}", CardMockTestCase.MOCKED_LOCALISED_STRING)); assertEquals(t.getQuantity(), 0); t = recognizer.recogniseNonCardToken("//Planes"); @@ -608,12 +603,14 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(t.getQuantity(), 0); } - /*============================= - * TEST RECOGNISE CARD LINES - * =============================*/ + /* + * ============================= TEST RECOGNISE CARD LINES + * ============================= + */ // === Card-Set Pattern Request - @Test void testValidMatchCardSetLine(){ + @Test + void testValidMatchCardSetLine() { String validRequest = "1 Power Sink TMP"; Matcher matcher = DeckRecognizer.CARD_SET_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); @@ -621,21 +618,21 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink"); assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "TMP"); - validRequest = "Power Sink TMP"; // no count + validRequest = "Power Sink TMP"; // no count matcher = DeckRecognizer.CARD_SET_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); assertNull(matcher.group(DeckRecognizer.REGRP_CARDNO)); assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink"); assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "TMP"); - validRequest = "Power Sink tmp"; // set cde in lower case + validRequest = "Power Sink tmp"; // set cde in lower case matcher = DeckRecognizer.CARD_SET_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); assertNull(matcher.group(DeckRecognizer.REGRP_CARDNO)); assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink"); assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "tmp"); - validRequest = "10 Power Sink TMP"; // double digits + validRequest = "10 Power Sink TMP"; // double digits matcher = DeckRecognizer.CARD_SET_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); assertEquals(matcher.group(DeckRecognizer.REGRP_CARDNO), "10"); @@ -651,21 +648,21 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "TMP"); // -- Set code with delimiters - validRequest = "Power Sink|TMP"; // pipe delimiter + validRequest = "Power Sink|TMP"; // pipe delimiter matcher = DeckRecognizer.CARD_SET_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); assertNull(matcher.group(DeckRecognizer.REGRP_CARDNO)); assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink"); assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "TMP"); - validRequest = "Power Sink (TMP)"; // MTGArena-like + validRequest = "Power Sink (TMP)"; // MTGArena-like matcher = DeckRecognizer.CARD_SET_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); assertNull(matcher.group(DeckRecognizer.REGRP_CARDNO)); assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink "); // requires trim assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "TMP"); - validRequest = "Power Sink|TMP"; // pipe delimiter + validRequest = "Power Sink|TMP"; // pipe delimiter matcher = DeckRecognizer.CARD_SET_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); assertNull(matcher.group(DeckRecognizer.REGRP_CARDNO)); @@ -679,51 +676,51 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink "); // TRIM assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "TMP"); - validRequest = "Power Sink|TMP"; // pipe delimiter + validRequest = "Power Sink|TMP"; // pipe delimiter matcher = DeckRecognizer.CARD_SET_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); assertNull(matcher.group(DeckRecognizer.REGRP_CARDNO)); assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink"); assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "TMP"); - validRequest = "Power Sink {TMP}"; // Alternative braces delimiter + validRequest = "Power Sink {TMP}"; // Alternative braces delimiter matcher = DeckRecognizer.CARD_SET_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); assertNull(matcher.group(DeckRecognizer.REGRP_CARDNO)); - assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink "); // TRIM + assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink "); // TRIM assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "TMP"); // -- also valid = delimiters can also be partial - validRequest = "Power Sink (TMP"; // pipe delimiter + validRequest = "Power Sink (TMP"; // pipe delimiter matcher = DeckRecognizer.CARD_SET_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); assertNull(matcher.group(DeckRecognizer.REGRP_CARDNO)); - assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink "); // TRIM + assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink "); // TRIM assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "TMP"); - validRequest = "Power Sink(TMP)"; // No space + validRequest = "Power Sink(TMP)"; // No space matcher = DeckRecognizer.CARD_SET_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); assertNull(matcher.group(DeckRecognizer.REGRP_CARDNO)); assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink"); assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "TMP"); - validRequest = "Power Sink|TMP"; // pipe delimiter + validRequest = "Power Sink|TMP"; // pipe delimiter matcher = DeckRecognizer.CARD_SET_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); assertNull(matcher.group(DeckRecognizer.REGRP_CARDNO)); assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink"); assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "TMP"); - validRequest = "Power Sink [TMP)"; // Mixed + validRequest = "Power Sink [TMP)"; // Mixed matcher = DeckRecognizer.CARD_SET_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); assertNull(matcher.group(DeckRecognizer.REGRP_CARDNO)); - assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink "); // TRIM + assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink "); // TRIM assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "TMP"); - validRequest = "Power Sink TMP]"; // last bracket to be stripped, but using space from card name + validRequest = "Power Sink TMP]"; // last bracket to be stripped, but using space from card name matcher = DeckRecognizer.CARD_SET_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); assertNull(matcher.group(DeckRecognizer.REGRP_CARDNO)); @@ -731,11 +728,12 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "TMP"); } - @Test void testInvalidMatchCardSetLine(){ + @Test + void testInvalidMatchCardSetLine() { // == Invalid Cases for this REGEX // Remeber: this rex *always* expects a Set Code! - String invalidRequest = "Power Sink "; // mind last space + String invalidRequest = "Power Sink "; // mind last space Matcher matcher = DeckRecognizer.CARD_SET_PATTERN.matcher(invalidRequest); assertTrue(matcher.matches()); assertNull(matcher.group(DeckRecognizer.REGRP_CARDNO)); @@ -743,7 +741,7 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertNotNull(matcher.group(DeckRecognizer.REGRP_SET)); assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "Sink"); - invalidRequest = "22 Power Sink"; // mind last space + invalidRequest = "22 Power Sink"; // mind last space matcher = DeckRecognizer.CARD_SET_PATTERN.matcher(invalidRequest); assertTrue(matcher.matches()); assertEquals(matcher.group(DeckRecognizer.REGRP_CARDNO), "22"); @@ -753,7 +751,8 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { } // === Set-Card Pattern Request - @Test void testValidMatchSetCardLine(){ + @Test + void testValidMatchSetCardLine() { String validRequest = "1 TMP Power Sink"; Matcher matcher = DeckRecognizer.SET_CARD_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); @@ -761,21 +760,21 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink"); assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "TMP"); - validRequest = "TMP Power Sink"; // no count + validRequest = "TMP Power Sink"; // no count matcher = DeckRecognizer.SET_CARD_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); assertNull(matcher.group(DeckRecognizer.REGRP_CARDNO)); assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink"); assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "TMP"); - validRequest = "tmp Power Sink"; // set code in lowercase + validRequest = "tmp Power Sink"; // set code in lowercase matcher = DeckRecognizer.SET_CARD_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); assertNull(matcher.group(DeckRecognizer.REGRP_CARDNO)); assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink"); assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "tmp"); - validRequest = "10 TMP Power Sink"; // double digits + validRequest = "10 TMP Power Sink"; // double digits matcher = DeckRecognizer.SET_CARD_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); assertEquals(matcher.group(DeckRecognizer.REGRP_CARDNO), "10"); @@ -791,72 +790,73 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "TMP"); // -- separators - validRequest = "TMP|Power Sink"; // pipe-after set code + validRequest = "TMP|Power Sink"; // pipe-after set code matcher = DeckRecognizer.SET_CARD_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink"); assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "TMP"); - validRequest = "(TMP)Power Sink"; // parenthesis + validRequest = "(TMP)Power Sink"; // parenthesis matcher = DeckRecognizer.SET_CARD_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink"); assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "TMP"); - validRequest = "[TMP]Power Sink"; // brackets + validRequest = "[TMP]Power Sink"; // brackets matcher = DeckRecognizer.SET_CARD_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink"); assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "TMP"); - validRequest = "{TMP}Power Sink"; // braces + validRequest = "{TMP}Power Sink"; // braces matcher = DeckRecognizer.SET_CARD_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink"); assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "TMP"); - validRequest = "TMP Power Sink"; // lots of spaces + validRequest = "TMP Power Sink"; // lots of spaces matcher = DeckRecognizer.SET_CARD_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink"); assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "TMP"); - validRequest = "(TMP|Power Sink"; // mixed + validRequest = "(TMP|Power Sink"; // mixed matcher = DeckRecognizer.SET_CARD_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink"); assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "TMP"); - validRequest = "(TMP]Power Sink"; // mixed 2 + validRequest = "(TMP]Power Sink"; // mixed 2 matcher = DeckRecognizer.SET_CARD_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink"); assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "TMP"); - validRequest = "TMP]Power Sink"; // partial + validRequest = "TMP]Power Sink"; // partial matcher = DeckRecognizer.SET_CARD_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink"); assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "TMP"); - validRequest = "TMP] Power Sink"; // partial with spaces + validRequest = "TMP] Power Sink"; // partial with spaces matcher = DeckRecognizer.SET_CARD_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink"); assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "TMP"); - validRequest = "(TMP Power Sink"; // only left-handside + validRequest = "(TMP Power Sink"; // only left-handside matcher = DeckRecognizer.SET_CARD_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink"); assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "TMP"); } - @Test void testInvalidMatchSetCardLine(){ + @Test + void testInvalidMatchSetCardLine() { // == Invalid Cases for this REGEX // Remeber: this rex *always* expects a Set Code! - String invalidRequest = "Power Sink"; // mind last space + String invalidRequest = "Power Sink"; // mind last space Matcher matcher = DeckRecognizer.SET_CARD_PATTERN.matcher(invalidRequest); assertTrue(matcher.matches()); assertNull(matcher.group(DeckRecognizer.REGRP_CARDNO)); @@ -864,7 +864,7 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertNotNull(matcher.group(DeckRecognizer.REGRP_SET)); assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "Power"); - invalidRequest = "22 Power Sink"; // mind last space + invalidRequest = "22 Power Sink"; // mind last space matcher = DeckRecognizer.SET_CARD_PATTERN.matcher(invalidRequest); assertTrue(matcher.matches()); assertEquals(matcher.group(DeckRecognizer.REGRP_CARDNO), "22"); @@ -873,8 +873,9 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "Power"); } - //=== Card-Set-CollectorNumber Pattern Request - @Test void testMatchFullCardSetRequest(){ + // === Card-Set-CollectorNumber Pattern Request + @Test + void testMatchFullCardSetRequest() { String validRequest = "1 Power Sink TMP 78"; Matcher matcher = DeckRecognizer.CARD_SET_COLLNO_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); @@ -891,42 +892,43 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "TMP"); assertEquals(matcher.group(DeckRecognizer.REGRP_COLLNR), "78"); - validRequest = "1 Power Sink (TMP) 78"; // MTG Arena alike + validRequest = "1 Power Sink (TMP) 78"; // MTG Arena alike matcher = DeckRecognizer.CARD_SET_COLLNO_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); assertEquals(matcher.group(DeckRecognizer.REGRP_CARDNO), "1"); - assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink "); // TRIM + assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink "); // TRIM assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "TMP"); assertEquals(matcher.group(DeckRecognizer.REGRP_COLLNR), "78"); - validRequest = "Power Sink (TMP) 78"; // MTG Arena alike + validRequest = "Power Sink (TMP) 78"; // MTG Arena alike matcher = DeckRecognizer.CARD_SET_COLLNO_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); assertNull(matcher.group(DeckRecognizer.REGRP_CARDNO)); - assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink "); // TRIM + assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink "); // TRIM assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "TMP"); assertEquals(matcher.group(DeckRecognizer.REGRP_COLLNR), "78"); - validRequest = "Power Sink (TMP)|78"; // Pipe to separate collector number (as in .Dec files) + validRequest = "Power Sink (TMP)|78"; // Pipe to separate collector number (as in .Dec files) matcher = DeckRecognizer.CARD_SET_COLLNO_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); assertNull(matcher.group(DeckRecognizer.REGRP_CARDNO)); - assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink "); // TRIM + assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink "); // TRIM assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "TMP"); assertEquals(matcher.group(DeckRecognizer.REGRP_COLLNR), "78"); - validRequest = "Power Sink|TMP|78"; // .Dec file export entry format + validRequest = "Power Sink|TMP|78"; // .Dec file export entry format matcher = DeckRecognizer.CARD_SET_COLLNO_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); assertNull(matcher.group(DeckRecognizer.REGRP_CARDNO)); - assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink"); // TRIM + assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink"); // TRIM assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "TMP"); assertEquals(matcher.group(DeckRecognizer.REGRP_COLLNR), "78"); } - @Test void testInvalidMatchFullCardSetRequest(){ + @Test + void testInvalidMatchFullCardSetRequest() { // NOTE: this will be matcher by another pattern - String invalidRequest = "1 Power Sink TMP"; // missing collector number + String invalidRequest = "1 Power Sink TMP"; // missing collector number Matcher matcher = DeckRecognizer.CARD_SET_COLLNO_PATTERN.matcher(invalidRequest); assertTrue(matcher.matches()); assertEquals(matcher.group(DeckRecognizer.REGRP_CARDNO), "1"); @@ -941,7 +943,8 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { } // === Set-Card-CollectorNumber Pattern Request - @Test void testMatchFullSetCardRequest(){ + @Test + void testMatchFullSetCardRequest() { String validRequest = "1 TMP Power Sink 78"; Matcher matcher = DeckRecognizer.SET_CARD_COLLNO_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); @@ -990,7 +993,7 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "TMP"); assertEquals(matcher.group(DeckRecognizer.REGRP_COLLNR), "78"); - validRequest = "TMP| Power Sink 78"; // extra space + validRequest = "TMP| Power Sink 78"; // extra space matcher = DeckRecognizer.SET_CARD_COLLNO_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); assertNull(matcher.group(DeckRecognizer.REGRP_CARDNO)); @@ -998,7 +1001,7 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "TMP"); assertEquals(matcher.group(DeckRecognizer.REGRP_COLLNR), "78"); - validRequest = "tmp Power Sink 78"; // set code lowercase + validRequest = "tmp Power Sink 78"; // set code lowercase matcher = DeckRecognizer.SET_CARD_COLLNO_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); assertNull(matcher.group(DeckRecognizer.REGRP_CARDNO)); @@ -1006,7 +1009,7 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "tmp"); assertEquals(matcher.group(DeckRecognizer.REGRP_COLLNR), "78"); - validRequest = "(TMP} Power Sink 78"; // mixed delimiters - still valid :D + validRequest = "(TMP} Power Sink 78"; // mixed delimiters - still valid :D matcher = DeckRecognizer.SET_CARD_COLLNO_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); assertNull(matcher.group(DeckRecognizer.REGRP_CARDNO)); @@ -1014,7 +1017,7 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "TMP"); assertEquals(matcher.group(DeckRecognizer.REGRP_COLLNR), "78"); - validRequest = "(TMP} Power Sink|78"; // Pipe to separate collector number as in .Dec format + validRequest = "(TMP} Power Sink|78"; // Pipe to separate collector number as in .Dec format matcher = DeckRecognizer.SET_CARD_COLLNO_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); assertNull(matcher.group(DeckRecognizer.REGRP_CARDNO)); @@ -1023,9 +1026,10 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(matcher.group(DeckRecognizer.REGRP_COLLNR), "78"); } - @Test void testInvalidMatchFullSetCardRequest(){ + @Test + void testInvalidMatchFullSetCardRequest() { // NOTE: this will be matcher by another pattern - String invalidRequest = "1 Power Sink TMP"; // missing collector number + String invalidRequest = "1 Power Sink TMP"; // missing collector number Matcher matcher = DeckRecognizer.SET_CARD_COLLNO_PATTERN.matcher(invalidRequest); assertTrue(matcher.matches()); assertEquals(matcher.group(DeckRecognizer.REGRP_CARDNO), "1"); @@ -1039,7 +1043,8 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertFalse(matcher.matches()); } - @Test void testCrossRexForDifferentLineRequests(){ + @Test + void testCrossRexForDifferentLineRequests() { String cardRequest = "4x Power Sink TMP 78"; assertTrue(DeckRecognizer.CARD_SET_COLLNO_PATTERN.matcher(cardRequest).matches()); assertTrue(DeckRecognizer.SET_CARD_COLLNO_PATTERN.matcher(cardRequest).matches()); @@ -1068,7 +1073,8 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { } // === Card Only Pattern Request (No Set) - @Test void testMatchCardOnlyRequest(){ + @Test + void testMatchCardOnlyRequest() { String validRequest = "4x Power Sink"; Matcher matcher = DeckRecognizer.CARD_ONLY_PATTERN.matcher(validRequest); assertTrue(matcher.matches()); @@ -1085,20 +1091,21 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { matcher = DeckRecognizer.CARD_ONLY_PATTERN.matcher(invalidRequest); assertFalse(matcher.matches()); - invalidRequest = "TMP"; // set code (there is no way for this to not match) + invalidRequest = "TMP"; // set code (there is no way for this to not match) matcher = DeckRecognizer.CARD_ONLY_PATTERN.matcher(invalidRequest); assertTrue(matcher.matches()); assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "TMP"); assertNull(matcher.group(DeckRecognizer.REGRP_CARDNO)); - invalidRequest = "78"; // collector number (there is no way for this to not match) + invalidRequest = "78"; // collector number (there is no way for this to not match) matcher = DeckRecognizer.CARD_ONLY_PATTERN.matcher(invalidRequest); assertTrue(matcher.matches()); assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "78"); assertNull(matcher.group(DeckRecognizer.REGRP_CARDNO)); } - @Test void testRecogniseCardToken(){ + @Test + void testRecogniseCardToken() { DeckRecognizer recognizer = new DeckRecognizer(); String lineRequest = "4x Power Sink+ (TMP) 78"; @@ -1195,7 +1202,8 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertFalse(cardToken.cardRequestHasNoCode()); // Relax Set Preference - assertEquals(StaticData.instance().getCommonCards().getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); + assertEquals(StaticData.instance().getCommonCards().getCardArtPreference(), + CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); lineRequest = "4x Power Sink"; cardToken = recognizer.recogniseCardToken(lineRequest, null); @@ -1234,7 +1242,8 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertTrue(cardToken.cardRequestHasNoCode()); } - @Test void testSingleWordCardNameMatchesCorrectly(){ + @Test + void testSingleWordCardNameMatchesCorrectly() { DeckRecognizer recognizer = new DeckRecognizer(); String lineRequest = "2x Counterspell ICE"; @@ -1249,7 +1258,8 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertFalse(cardToken.cardRequestHasNoCode()); // Remove Set code - assertEquals(StaticData.instance().getCommonCards().getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); + assertEquals(StaticData.instance().getCommonCards().getCardArtPreference(), + CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); lineRequest = "2x Counterspell"; cardToken = recognizer.recogniseCardToken(lineRequest, null); assertNotNull(cardToken); @@ -1263,10 +1273,12 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { } - /*========================================= - * TOKEN/CARD PARSING: (Alternate) Set Code - * ======================================== */ - @Test void testRecognisingCardFromSetUsingAlternateCode(){ + /* + * ========================================= TOKEN/CARD PARSING: (Alternate) Set + * Code ======================================== + */ + @Test + void testRecognisingCardFromSetUsingAlternateCode() { DeckRecognizer recognizer = new DeckRecognizer(); String lineRequest = "4x Power Sink+ TE 78"; @@ -1286,17 +1298,19 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertFalse(cardToken.cardRequestHasNoCode()); } - /*================================== - * TOKEN/CARD PARSING: Foil Requests - * ================================= */ - @Test void testMatchFoilCardRequest(){ + /* + * ================================== TOKEN/CARD PARSING: Foil Requests + * ================================= + */ + @Test + void testMatchFoilCardRequest() { // card-set-collnr String foilRequest = "4x Power Sink+ (TMP) 78"; Pattern target = DeckRecognizer.CARD_SET_COLLNO_PATTERN; Matcher matcher = target.matcher(foilRequest); assertTrue(matcher.matches()); assertEquals(matcher.group(DeckRecognizer.REGRP_CARDNO), "4"); - assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink+ "); // TRIM + assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink+ "); // TRIM assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "TMP"); assertEquals(matcher.group(DeckRecognizer.REGRP_COLLNR), "78"); @@ -1337,7 +1351,8 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Power Sink+"); } - @Test void testMatchFoilCardRequestMTGGoldfishFormat(){ + @Test + void testMatchFoilCardRequestMTGGoldfishFormat() { // card-set-collnr String foilRequest = "4 Aspect of Hydra [BNG] (F)"; Pattern target = DeckRecognizer.CARD_SET_COLLNO_PATTERN; @@ -1348,7 +1363,7 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { matcher = target.matcher(foilRequest); assertTrue(matcher.matches()); assertEquals(matcher.group(DeckRecognizer.REGRP_CARDNO), "4"); - assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Aspect of Hydra "); // TRIM + assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Aspect of Hydra "); // TRIM assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "BNG"); assertEquals(matcher.group(DeckRecognizer.REGRP_COLLNR), "117"); assertNotNull(matcher.group(DeckRecognizer.REGRP_FOIL_GFISH)); @@ -1374,7 +1389,7 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { matcher = target.matcher(foilRequest); assertTrue(matcher.matches()); assertEquals(matcher.group(DeckRecognizer.REGRP_CARDNO), "4"); - assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Aspect of Hydra "); // TRIM + assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Aspect of Hydra "); // TRIM assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "BNG"); assertEquals(matcher.group(DeckRecognizer.REGRP_FOIL_GFISH), "(F)"); @@ -1384,7 +1399,7 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { matcher = target.matcher(foilRequest); assertTrue(matcher.matches()); assertEquals(matcher.group(DeckRecognizer.REGRP_CARDNO), "4"); - assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Aspect of Hydra "); // TRIM + assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Aspect of Hydra "); // TRIM assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "BNG"); assertEquals(matcher.group(DeckRecognizer.REGRP_FOIL_GFISH), "(F)"); @@ -1394,14 +1409,17 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { matcher = target.matcher(foilRequest); assertTrue(matcher.matches()); assertEquals(matcher.group(DeckRecognizer.REGRP_CARDNO), "4"); - assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Aspect of Hydra "); // TRIM + assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Aspect of Hydra "); // TRIM assertEquals(matcher.group(DeckRecognizer.REGRP_FOIL_GFISH), "(F)"); } - /*=================================================== - * TOKEN/CARD PARSING: Collector Number and Art Index - * ================================================== */ - @Test void testPassingInArtIndexRatherThanCollectorNumber(){ + /* + * =================================================== TOKEN/CARD PARSING: + * Collector Number and Art Index + * ================================================== + */ + @Test + void testPassingInArtIndexRatherThanCollectorNumber() { DeckRecognizer recognizer = new DeckRecognizer(); String lineRequest = "20x Mountain MIR 3"; @@ -1418,7 +1436,8 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertFalse(cardToken.cardRequestHasNoCode()); } - @Test void testCollectorNumberIsNotConfusedAsArtIndexInstead(){ + @Test + void testCollectorNumberIsNotConfusedAsArtIndexInstead() { DeckRecognizer recognizer = new DeckRecognizer(); String lineRequest = "2x Auspicious Ancestor MIR 3"; @@ -1435,10 +1454,11 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertFalse(cardToken.cardRequestHasNoCode()); } - @Test void testCardRequestWithWrongCollectorNumberStillReturnsTheCardFromSetIfAny(){ + @Test + void testCardRequestWithWrongCollectorNumberStillReturnsTheCardFromSetIfAny() { DeckRecognizer recognizer = new DeckRecognizer(); - String requestLine = "3 Jayemdae Tome (LEB) 231"; // actually found in TappedOut Deck Export + String requestLine = "3 Jayemdae Tome (LEB) 231"; // actually found in TappedOut Deck Export // NOTE: Expected Coll Nr should be 255 Token cardToken = recognizer.recogniseCardToken(requestLine, null); assertNotNull(cardToken); @@ -1451,7 +1471,7 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertFalse(cardToken.cardRequestHasNoCode()); // No Match - Unknown card - requestLine = "3 Jayemdae Tome (TMP)"; // actually found in TappedOut Deck Export + requestLine = "3 Jayemdae Tome (TMP)"; // actually found in TappedOut Deck Export // NOTE: Expected Coll Nr should be 255 cardToken = recognizer.recogniseCardToken(requestLine, null); assertNotNull(cardToken); @@ -1460,10 +1480,12 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(cardToken.getType(), TokenType.UNKNOWN_CARD); } - /*================================= - * TOKEN/CARD PARSING: UNKNOWN CARD - * ================================ */ - @Test void testRequestingCardFromTheWrongSetReturnsUnknownCard(){ + /* + * ================================= TOKEN/CARD PARSING: UNKNOWN CARD + * ================================ + */ + @Test + void testRequestingCardFromTheWrongSetReturnsUnknownCard() { DeckRecognizer recognizer = new DeckRecognizer(); String lineRequest = "2x Counterspell FEM"; @@ -1473,7 +1495,8 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertNull(cardToken.getCard()); } - @Test void testRequestingCardFromNonExistingSetReturnsUnknownCard(){ + @Test + void testRequestingCardFromNonExistingSetReturnsUnknownCard() { DeckRecognizer recognizer = new DeckRecognizer(); String lineRequest = "2x Counterspell BOU"; @@ -1484,13 +1507,16 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertNull(cardToken.getTokenSection()); } - /*======================================= - * TEST CONSTRAINTS: Edition Release Date - * ====================================== */ - @Test void testRequestingCardWithReleaseDateConstraints(){ + /* + * ======================================= TEST CONSTRAINTS: Edition Release + * Date ====================================== + */ + @Test + void testRequestingCardWithReleaseDateConstraints() { DeckRecognizer recognizer = new DeckRecognizer(); recognizer.setDateConstraint(2002, 1); - assertEquals(StaticData.instance().getCommonCards().getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); + assertEquals(StaticData.instance().getCommonCards().getCardArtPreference(), + CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); String lineRequest = "Ancestral Recall"; Token cardToken = recognizer.recogniseCardToken(lineRequest, null); @@ -1500,7 +1526,8 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { PaperCard ancestralCard = cardToken.getCard(); assertEquals(cardToken.getQuantity(), 1); assertEquals(ancestralCard.getName(), "Ancestral Recall"); - assertEquals(StaticData.instance().getCommonCards().getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); + assertEquals(StaticData.instance().getCommonCards().getCardArtPreference(), + CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); assertEquals(ancestralCard.getEdition(), "2ED"); assertTrue(cardToken.cardRequestHasNoCode()); @@ -1518,10 +1545,12 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertTrue(cardToken.cardRequestHasNoCode()); } - @Test void testInvalidCardRequestWhenReleaseDateConstraintsAreUp(){ + @Test + void testInvalidCardRequestWhenReleaseDateConstraintsAreUp() { DeckRecognizer recognizer = new DeckRecognizer(); - assertEquals(StaticData.instance().getCommonCards().getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); + assertEquals(StaticData.instance().getCommonCards().getCardArtPreference(), + CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); // First run without constraint to check that it's a valid request String lineRequest = "Counterspell|MH2"; @@ -1543,14 +1572,17 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertFalse(cardToken.cardRequestHasNoCode()); } - /*====================================== - * TEST CONSTRAINTS: Card Art Preference - * ===================================== */ - @Test void testChangesInArtPreference(){ + /* + * ====================================== TEST CONSTRAINTS: Card Art Preference + * ===================================== + */ + @Test + void testChangesInArtPreference() { DeckRecognizer recognizer = new DeckRecognizer(); // Baseline - no constraints - uses default card art - assertEquals(StaticData.instance().getCommonCards().getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); + assertEquals(StaticData.instance().getCommonCards().getCardArtPreference(), + CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); String lineRequest = "Counterspell"; Token cardToken = recognizer.recogniseCardToken(lineRequest, null); assertNotNull(cardToken); @@ -1579,7 +1611,8 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertTrue(cardToken.cardRequestHasNoCode()); } - @Test void testCardRequestVariesUponChangesInArtPreference(){ + @Test + void testCardRequestVariesUponChangesInArtPreference() { assertEquals(StaticData.instance().getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); DeckRecognizer recognizer = new DeckRecognizer(); @@ -1621,11 +1654,13 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertTrue(cardToken.cardRequestHasNoCode()); } - /*============================== - * TEST CONSTRAINTS: Game Format - * ============================= */ + /* + * ============================== TEST CONSTRAINTS: Game Format + * ============================= + */ - @Test void testRequestingCardWithRestrictionsOnSetsFromGameFormat(){ + @Test + void testRequestingCardWithRestrictionsOnSetsFromGameFormat() { DeckRecognizer recognizer = new DeckRecognizer(); // Setting Fantasy Constructed Game Format: Urza's Block Format List allowedSets = Arrays.asList("USG", "ULG", "UDS", "PUDS", "PULG", "PUSG"); @@ -1639,7 +1674,7 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertNull(cardToken.getTokenSection()); assertFalse(cardToken.cardRequestHasNoCode()); - lineRequest = "2x Counterspell"; // It does not exist any Counterspell in Urza's block + lineRequest = "2x Counterspell"; // It does not exist any Counterspell in Urza's block cardToken = recognizer.recogniseCardToken(lineRequest, null); assertNotNull(cardToken); assertEquals(cardToken.getType(), TokenType.CARD_FROM_NOT_ALLOWED_SET); @@ -1648,7 +1683,8 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertTrue(cardToken.cardRequestHasNoCode()); } - @Test void testRequestingCardWithRestrictionsOnDeckFormat(){ + @Test + void testRequestingCardWithRestrictionsOnDeckFormat() { DeckRecognizer recognizer = new DeckRecognizer(); String lineRequest = "Ancestral Recall"; @@ -1659,7 +1695,8 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { PaperCard ancestralCard = cardToken.getCard(); assertEquals(cardToken.getQuantity(), 1); assertEquals(ancestralCard.getName(), "Ancestral Recall"); - assertEquals(StaticData.instance().getCommonCards().getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); + assertEquals(StaticData.instance().getCommonCards().getCardArtPreference(), + CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); assertEquals(ancestralCard.getEdition(), "VMA"); assertTrue(cardToken.cardRequestHasNoCode()); @@ -1674,15 +1711,16 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertTrue(cardToken.cardRequestHasNoCode()); } - @Test void testCardRequestUnderGameConstraints(){ + @Test + void testCardRequestUnderGameConstraints() { // == Simulate Pioneer Format Banned List DeckRecognizer recognizer = new DeckRecognizer(); - List bannedList = Arrays.asList( - StringUtils.split("Balustrade Spy;Bloodstained Mire;Felidar Guardian;Field of the Dead;Flooded Strand;Inverter of Truth;Kethis, the Hidden Hand;Leyline of Abundance;Nexus of Fate;Oko, Thief of Crowns;Once Upon a Time;Polluted Delta;Smuggler's Copter;Teferi, Time Raveler;Undercity Informer;Underworld Breach;Uro, Titan of Nature's Wrath;Veil of Summer;Walking Ballista;Wilderness Reclamation;Windswept Heath;Wooded Foothills", - ';')); - List allowedPioneerSets = Arrays.asList( - StringUtils.split("RTR,GTC,DGM,M14,THS,BNG,JOU,M15,KTK,FRF,DTK,ORI,BFZ,OGW,SOI,EMN,KLD,AER,AKH,HOU,XLN,RIX,DOM,M19,G18,GRN,RNA,WAR,M20,ELD,THB,IKO,M21,ZNR,KHM,STX,AFR,MID,VOW", - ",")); + List bannedList = Arrays.asList(StringUtils.split( + "Balustrade Spy;Bloodstained Mire;Felidar Guardian;Field of the Dead;Flooded Strand;Inverter of Truth;Kethis, the Hidden Hand;Leyline of Abundance;Nexus of Fate;Oko, Thief of Crowns;Once Upon a Time;Polluted Delta;Smuggler's Copter;Teferi, Time Raveler;Undercity Informer;Underworld Breach;Uro, Titan of Nature's Wrath;Veil of Summer;Walking Ballista;Wilderness Reclamation;Windswept Heath;Wooded Foothills", + ';')); + List allowedPioneerSets = Arrays.asList(StringUtils.split( + "RTR,GTC,DGM,M14,THS,BNG,JOU,M15,KTK,FRF,DTK,ORI,BFZ,OGW,SOI,EMN,KLD,AER,AKH,HOU,XLN,RIX,DOM,M19,G18,GRN,RNA,WAR,M20,ELD,THB,IKO,M21,ZNR,KHM,STX,AFR,MID,VOW", + ",")); List restrictedList = null; recognizer.setGameFormatConstraint(allowedPioneerSets, bannedList, restrictedList); @@ -1714,20 +1752,21 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertTrue(cardToken.cardRequestHasNoCode()); } - @Test void testGameFormatRestrictionsAlsoWithRestrictedCardList(){ + @Test + void testGameFormatRestrictionsAlsoWithRestrictedCardList() { // SIMULATE A GAME OF VINTAGE DeckRecognizer recognizer = new DeckRecognizer(); - List allowedSetCodes = Arrays.asList( - StringUtils.split("7ED, 9ED, ORI, M14, M15, 6ED, 8ED, M11, 3ED, M10, M12, 10E, M13, G18, M21, M20, M19, 5ED, 2ED, 4ED, LEB, LEA, 5DN, SOM, KTK, THS, DIS, JOU, MOR, TMP, SOI, FEM, USG, ALL, ROE, EXO, TSP, LRW, TOR, ALA, RIX, DGM, DKA, MBS, AER, RNA, GTC, CSP, HML, NPH, OGW, ZNR, EMN, UDS, SHM, BNG, SOK, EVE, INV, THB, DOM, NMS, VIS, WAR, GRN, PCY, SCG, MRD, XLN, ONS, IKO, MMQ, CHK, ULG, AKH, MIR, ISD, AVR, KLD, APC, RTR, WWK, PLC, HOU, LEG, AFR, ARN, ICE, STX, LGN, ARB, KHM, CFX, TSB, ZEN, ELD, JUD, GPT, BFZ, BOK, DTK, FRF, FUT, WTH, ODY, RAV, ATQ, DRK, PLS, STH, DST, TD2, HA1, ME4, HA3, HA2, HA5, HA4, MED, ANB, ME3, KLR, PZ2, ANA, PRM, PZ1, AJMP, ME2, TD1, TD0, TPR, VMA, AKR, MBP, PZEN, PGTW, PL21, PFUT, PWAR, PAL01, PJUD, PAL00, PTKDF, PWOR, PWP12, PSTH, POGW, PFRF, PG07, PSUS, PUST, J18, PWP10, PAL02, PAL03, PWP11, J19, PGRN, PM10, PDP14, PRTR, PMPS06, PBNG, PJ21, G09, PNPH, PM15, PAL06, G08, PDST, J20, PMBS, PMPS07, PEXO, PDOM, PONS, PRW2, PMPS11, PMPS, PM19, PWWK, PCEL, PAL04, PAL05, PMPS10, PDTK, PALP, F10, F04, PMOR, PAL99, PEMN, PCNS, PPLC, PRAV, PPP1, PI14, PXLN, PF20, PTSP, F05, F11, PSCG, PBOOK, F07, F13, PODY, PM12, P08, PSS1, P2HG, P09, PTOR, PDP13, F12, F06, PALA, PXTC, F02, F16, PHOU, PSOM, PI13, PCON, PDGM, PIDW, PMRD, PRNA, P9ED, PHEL, F17, F03, PURL, F15, F01, PWOS, PPC1, PBOK, PTMP, PS19, PS18, PF19, PGPT, PCHK, FNM, F14, PISD, PAKH, PDP15, PRIX, PS15, PPCY, OLGC, OVNT, PLGN, PS14, P03, PDTP, PM14, FS, PPLS, MPR, PKTK, PS16, PRWK, PS17, PBFZ, PSS2, PINV, G03, P8ED, PARL, P04, P10, PSDC, JGP, G99, WW, P11, P05, PDIS, PROE, PDP10, F08, P10E, PELP, PMH1, P07, P5DN, PGRU, SHC, PM11, P06, PUSG, PCMP, PULG, F09, PUDS, PARB, DRC94, PMPS09, PORI, J12, G06, PMMQ, G07, J13, PMPS08, PM20, PSOI, PJSE, G05, G11, PNAT, PSOK, PEVE, PRED, G10, G04, PSHM, PPRO, PAPC, PJJT, ARENA, PKLD, G00, J14, PLGM, P15A, PCSP, PWPN, PJAS, PWP21, PWP09, PDKA, PNEM, PPTK, J15, G01, PG08, PLRW, PMEI, PM13, PHJ, PGTC, J17, PRES, PWCQ, PJOU, PDP12, PAER, PAVR, PTHS, G02, J16, PSUM, PGPX, UGF, PSS3, MM2, MM3, MB1, FMB1, A25, 2XM, MMA, PLIST, CHR, EMA, IMA, TSR, UMA, PUMA, E02, DPA, ATH, MD1, GK1, GK2, CST, BRB, BTD, DKM, FVE, V17, V13, STA, MPS_RNA, V16, SLD, V12, CC1, MPS_GRN, DRB, FVR, SS3, SS1, MPS_AKH, FVL, V15, MPS_KLD, ZNE, PDS, SS2, PD3, SLU, V14, PD2, EXP, MPS_WAR, DDQ, DDE, GS1, DDS, DDU, DD1, DDL, DDF, DDP, DD2, DDR, DDH, DDT, DDK, DDG, DDC, DDM, DDJ, DDO, GVL, JVC, DDI, DVD, DDN, EVG, DDD, C18, C19, C21, C20, C13, CMA, C14, C15, KHC, ZNC, AFC, C17, C16, COM, CM1,CM2,PO2,S99,W16,W17,S00,PTK,CP3,POR,CP1,CP2,CMR,MH2,H1R,CNS,BBD,MH1,CN2,JMP,PCA,GNT,ARC,GN2,PC2,E01,HOP,PLG20,PLG21,CC2,MID,MIC,VOW,VOC", - ",")); + List allowedSetCodes = Arrays.asList(StringUtils.split( + "7ED, 9ED, ORI, M14, M15, 6ED, 8ED, M11, 3ED, M10, M12, 10E, M13, G18, M21, M20, M19, 5ED, 2ED, 4ED, LEB, LEA, 5DN, SOM, KTK, THS, DIS, JOU, MOR, TMP, SOI, FEM, USG, ALL, ROE, EXO, TSP, LRW, TOR, ALA, RIX, DGM, DKA, MBS, AER, RNA, GTC, CSP, HML, NPH, OGW, ZNR, EMN, UDS, SHM, BNG, SOK, EVE, INV, THB, DOM, NMS, VIS, WAR, GRN, PCY, SCG, MRD, XLN, ONS, IKO, MMQ, CHK, ULG, AKH, MIR, ISD, AVR, KLD, APC, RTR, WWK, PLC, HOU, LEG, AFR, ARN, ICE, STX, LGN, ARB, KHM, CFX, TSB, ZEN, ELD, JUD, GPT, BFZ, BOK, DTK, FRF, FUT, WTH, ODY, RAV, ATQ, DRK, PLS, STH, DST, TD2, HA1, ME4, HA3, HA2, HA5, HA4, MED, ANB, ME3, KLR, PZ2, ANA, PRM, PZ1, AJMP, ME2, TD1, TD0, TPR, VMA, AKR, MBP, PZEN, PGTW, PL21, PFUT, PWAR, PAL01, PJUD, PAL00, PTKDF, PWOR, PWP12, PSTH, POGW, PFRF, PG07, PSUS, PUST, J18, PWP10, PAL02, PAL03, PWP11, J19, PGRN, PM10, PDP14, PRTR, PMPS06, PBNG, PJ21, G09, PNPH, PM15, PAL06, G08, PDST, J20, PMBS, PMPS07, PEXO, PDOM, PONS, PRW2, PMPS11, PMPS, PM19, PWWK, PCEL, PAL04, PAL05, PMPS10, PDTK, PALP, F10, F04, PMOR, PAL99, PEMN, PCNS, PPLC, PRAV, PPP1, PI14, PXLN, PF20, PTSP, F05, F11, PSCG, PBOOK, F07, F13, PODY, PM12, P08, PSS1, P2HG, P09, PTOR, PDP13, F12, F06, PALA, PXTC, F02, F16, PHOU, PSOM, PI13, PCON, PDGM, PIDW, PMRD, PRNA, P9ED, PHEL, F17, F03, PURL, F15, F01, PWOS, PPC1, PBOK, PTMP, PS19, PS18, PF19, PGPT, PCHK, FNM, F14, PISD, PAKH, PDP15, PRIX, PS15, PPCY, OLGC, OVNT, PLGN, PS14, P03, PDTP, PM14, FS, PPLS, MPR, PKTK, PS16, PRWK, PS17, PBFZ, PSS2, PINV, G03, P8ED, PARL, P04, P10, PSDC, JGP, G99, WW, P11, P05, PDIS, PROE, PDP10, F08, P10E, PELP, PMH1, P07, P5DN, PGRU, SHC, PM11, P06, PUSG, PCMP, PULG, F09, PUDS, PARB, DRC94, PMPS09, PORI, J12, G06, PMMQ, G07, J13, PMPS08, PM20, PSOI, PJSE, G05, G11, PNAT, PSOK, PEVE, PRED, G10, G04, PSHM, PPRO, PAPC, PJJT, ARENA, PKLD, G00, J14, PLGM, P15A, PCSP, PWPN, PJAS, PWP21, PWP09, PDKA, PNEM, PPTK, J15, G01, PG08, PLRW, PMEI, PM13, PHJ, PGTC, J17, PRES, PWCQ, PJOU, PDP12, PAER, PAVR, PTHS, G02, J16, PSUM, PGPX, UGF, PSS3, MM2, MM3, MB1, FMB1, A25, 2XM, MMA, PLIST, CHR, EMA, IMA, TSR, UMA, PUMA, E02, DPA, ATH, MD1, GK1, GK2, CST, BRB, BTD, DKM, FVE, V17, V13, STA, MPS_RNA, V16, SLD, V12, CC1, MPS_GRN, DRB, FVR, SS3, SS1, MPS_AKH, FVL, V15, MPS_KLD, ZNE, PDS, SS2, PD3, SLU, V14, PD2, EXP, MPS_WAR, DDQ, DDE, GS1, DDS, DDU, DD1, DDL, DDF, DDP, DD2, DDR, DDH, DDT, DDK, DDG, DDC, DDM, DDJ, DDO, GVL, JVC, DDI, DVD, DDN, EVG, DDD, C18, C19, C21, C20, C13, CMA, C14, C15, KHC, ZNC, AFC, C17, C16, COM, CM1,CM2,PO2,S99,W16,W17,S00,PTK,CP3,POR,CP1,CP2,CMR,MH2,H1R,CNS,BBD,MH1,CN2,JMP,PCA,GNT,ARC,GN2,PC2,E01,HOP,PLG20,PLG21,CC2,MID,MIC,VOW,VOC", + ",")); allowedSetCodes = allowedSetCodes.stream().map(String::trim).collect(Collectors.toList()); - List bannedCards = Arrays.asList( - StringUtils.split("Adriana's Valor; Advantageous Proclamation; Assemble the Rank and Vile; Backup Plan; Brago's Favor; Double Stroke; Echoing Boon; Emissary's Ploy; Hired Heist; Hold the Perimeter; Hymn of the Wilds; Immediate Action; Incendiary Dissent; Iterative Analysis; Muzzio's Preparations; Natural Unity; Power Play; Secret Summoning; Secrets of Paradise; Sentinel Dispatch; Sovereign's Realm; Summoner's Bond; Unexpected Potential; Weight Advantage; Worldknit; Amulet of Quoz; Bronze Tablet; Contract from Below; Darkpact; Demonic Attorney; Jeweled Bird; Rebirth; Tempest Efreet; Timmerian Fiends; Chaos Orb; Falling Star; Shahrazad; Cleanse; Crusade; Imprison; Invoke Prejudice; Jihad; Pradesh Gypsies; Stone-Throwing Devils", - ":")); + List bannedCards = Arrays.asList(StringUtils.split( + "Adriana's Valor; Advantageous Proclamation; Assemble the Rank and Vile; Backup Plan; Brago's Favor; Double Stroke; Echoing Boon; Emissary's Ploy; Hired Heist; Hold the Perimeter; Hymn of the Wilds; Immediate Action; Incendiary Dissent; Iterative Analysis; Muzzio's Preparations; Natural Unity; Power Play; Secret Summoning; Secrets of Paradise; Sentinel Dispatch; Sovereign's Realm; Summoner's Bond; Unexpected Potential; Weight Advantage; Worldknit; Amulet of Quoz; Bronze Tablet; Contract from Below; Darkpact; Demonic Attorney; Jeweled Bird; Rebirth; Tempest Efreet; Timmerian Fiends; Chaos Orb; Falling Star; Shahrazad; Cleanse; Crusade; Imprison; Invoke Prejudice; Jihad; Pradesh Gypsies; Stone-Throwing Devils", + ":")); bannedCards = bannedCards.stream().map(String::trim).collect(Collectors.toList()); - List restrictedCards = Arrays.asList( - StringUtils.split("Ancestral Recall; Balance; Black Lotus; Brainstorm; Chalice of the Void; Channel; Demonic Consultation; Demonic Tutor; Dig Through Time; Flash; Gitaxian Probe; Golgari Grave-Troll; Gush; Imperial Seal; Karn, the Great Creator; Library of Alexandria; Lion's Eye Diamond; Lodestone Golem; Lotus Petal; Mana Crypt; Mana Vault; Memory Jar; Mental Misstep; Merchant Scroll; Mind's Desire; Monastery Mentor; Mox Emerald; Mox Jet; Mox Pearl; Mox Ruby; Mox Sapphire; Mystic Forge; Mystical Tutor; Narset, Parter of Veils; Necropotence; Ponder; Sol Ring; Strip Mine; Thorn of Amethyst; Time Vault; Time Walk; Timetwister; Tinker; Tolarian Academy; Treasure Cruise; Trinisphere; Vampiric Tutor; Wheel of Fortune; Windfall; Yawgmoth's Will", - ";")); + List restrictedCards = Arrays.asList(StringUtils.split( + "Ancestral Recall; Balance; Black Lotus; Brainstorm; Chalice of the Void; Channel; Demonic Consultation; Demonic Tutor; Dig Through Time; Flash; Gitaxian Probe; Golgari Grave-Troll; Gush; Imperial Seal; Karn, the Great Creator; Library of Alexandria; Lion's Eye Diamond; Lodestone Golem; Lotus Petal; Mana Crypt; Mana Vault; Memory Jar; Mental Misstep; Merchant Scroll; Mind's Desire; Monastery Mentor; Mox Emerald; Mox Jet; Mox Pearl; Mox Ruby; Mox Sapphire; Mystic Forge; Mystical Tutor; Narset, Parter of Veils; Necropotence; Ponder; Sol Ring; Strip Mine; Thorn of Amethyst; Time Vault; Time Walk; Timetwister; Tinker; Tolarian Academy; Treasure Cruise; Trinisphere; Vampiric Tutor; Wheel of Fortune; Windfall; Yawgmoth's Will", + ";")); restrictedCards = restrictedCards.stream().map(String::trim).collect(Collectors.toList()); recognizer.setGameFormatConstraint(allowedSetCodes, bannedCards, restrictedCards); @@ -1758,7 +1797,8 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertTrue(cardToken.cardRequestHasNoCode()); } - @Test void testSettingPartialConstraintsOnGameFormatsAreStillApplied(){ + @Test + void testSettingPartialConstraintsOnGameFormatsAreStillApplied() { // Setting only Partial Game Constraints DeckRecognizer recognizer = new DeckRecognizer(); List allowedSetCodes = Arrays.asList("MIR", "VIS", "WTH"); @@ -1862,15 +1902,18 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertTrue(cardToken.cardRequestHasNoCode()); } - /*====================================== - * TEST CONSTRAINTS: Combined Constraints - * ===================================== */ + /* + * ====================================== TEST CONSTRAINTS: Combined Constraints + * ===================================== + */ - @Test void testCardMatchWithDateANDGameFormatConstraints(){ + @Test + void testCardMatchWithDateANDGameFormatConstraints() { DeckRecognizer recognizer = new DeckRecognizer(); // Baseline - no constraints - assertEquals(StaticData.instance().getCommonCards().getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); + assertEquals(StaticData.instance().getCommonCards().getCardArtPreference(), + CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); String lineRequest = "2x Lightning Dragon"; Token cardToken = recognizer.recogniseCardToken(lineRequest, null); assertNotNull(cardToken); @@ -1882,7 +1925,7 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(tc.getEdition(), "VMA"); assertTrue(cardToken.cardRequestHasNoCode()); - recognizer.setDateConstraint(2000, 0); // Jan 2000 + recognizer.setDateConstraint(2000, 0); // Jan 2000 // Setting Fantasy Constructed Game Format: Urza's Block Format (no promo) List allowedSets = Arrays.asList("USG", "ULG", "UDS"); recognizer.setGameFormatConstraint(allowedSets, null, null); @@ -1907,11 +1950,11 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertNotNull(cardToken.getCard()); tc = cardToken.getCard(); assertEquals(tc.getName(), "Lightning Dragon"); - assertEquals(tc.getEdition(), "USG"); // the latest available within set requested + assertEquals(tc.getEdition(), "USG"); // the latest available within set requested assertTrue(cardToken.cardRequestHasNoCode()); // Now setting a tighter date constraint - recognizer.setDateConstraint(1998, 0); // Jan 1998 + recognizer.setDateConstraint(1998, 0); // Jan 1998 lineRequest = "2x Lightning Dragon|USG"; cardToken = recognizer.recogniseCardToken(lineRequest, null); assertNotNull(cardToken); @@ -1931,7 +1974,7 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { // Now relaxing date constraint but removing USG from allowed sets // VMA release date: 2014-06-16 - recognizer.setDateConstraint(2015, 0); // This will match VMA + recognizer.setDateConstraint(2015, 0); // This will match VMA recognizer.setGameFormatConstraint(Arrays.asList("ULG", "UDS"), null, null); lineRequest = "2x Lightning Dragon|USG"; @@ -1952,7 +1995,7 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { // Now relaxing date constraint but removing USG from allowed sets // VMA release date: 2014-06-16 - recognizer.setDateConstraint(2015, 0); // This will match VMA + recognizer.setDateConstraint(2015, 0); // This will match VMA recognizer.setGameFormatConstraint(Arrays.asList("VMA", "ULG", "UDS"), null, null); lineRequest = "2x Lightning Dragon"; cardToken = recognizer.recogniseCardToken(lineRequest, null); @@ -1966,11 +2009,13 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertTrue(cardToken.cardRequestHasNoCode()); } - @Test void testCardMatchWithDateANDdeckFormatConstraints(){ + @Test + void testCardMatchWithDateANDdeckFormatConstraints() { DeckRecognizer recognizer = new DeckRecognizer(); // Baseline - no constraints - assertEquals(StaticData.instance().getCommonCards().getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); + assertEquals(StaticData.instance().getCommonCards().getCardArtPreference(), + CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); String lineRequest = "Flash"; Token cardToken = recognizer.recogniseCardToken(lineRequest, null); @@ -1983,7 +2028,7 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(tc.getEdition(), "A25"); assertTrue(cardToken.cardRequestHasNoCode()); - recognizer.setDateConstraint(2012, 0); // Jan 2012 + recognizer.setDateConstraint(2012, 0); // Jan 2012 recognizer.setDeckFormatConstraint(DeckFormat.TinyLeaders); lineRequest = "Flash"; @@ -2005,7 +2050,7 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertNotNull(cardToken.getCard()); tc = cardToken.getCard(); assertEquals(tc.getName(), "Cancel"); - assertEquals(tc.getEdition(), "M12"); // the latest within date constraint + assertEquals(tc.getEdition(), "M12"); // the latest within date constraint assertTrue(cardToken.cardRequestHasNoCode()); lineRequest = "2x Cancel|M21"; @@ -2018,11 +2063,13 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertFalse(cardToken.cardRequestHasNoCode()); } - @Test void testCardMatchWithGameANDdeckFormatConstraints(){ + @Test + void testCardMatchWithGameANDdeckFormatConstraints() { DeckRecognizer recognizer = new DeckRecognizer(); // Baseline - no constraints - assertEquals(StaticData.instance().getCommonCards().getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); + assertEquals(StaticData.instance().getCommonCards().getCardArtPreference(), + CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); String lineRequest = "Flash"; Token cardToken = recognizer.recogniseCardToken(lineRequest, null); @@ -2073,7 +2120,7 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { lineRequest = "Noble Elephant"; cardToken = recognizer.recogniseCardToken(lineRequest, null); assertNotNull(cardToken); - assertEquals(cardToken.getType(), TokenType.LIMITED_CARD); // violating Deck format + assertEquals(cardToken.getType(), TokenType.LIMITED_CARD); // violating Deck format assertEquals(cardToken.getQuantity(), 1); assertNotNull(cardToken.getCard()); assertEquals(cardToken.getText(), "Noble Elephant [MIR] #30"); @@ -2085,18 +2132,20 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { lineRequest = "Incinerate|ICE"; cardToken = recognizer.recogniseCardToken(lineRequest, null); assertNotNull(cardToken); - assertEquals(cardToken.getType(), TokenType.CARD_FROM_NOT_ALLOWED_SET); // violating Game format + assertEquals(cardToken.getType(), TokenType.CARD_FROM_NOT_ALLOWED_SET); // violating Game format assertEquals(cardToken.getQuantity(), 1); assertNotNull(cardToken.getCard()); assertEquals(cardToken.getText(), "Incinerate [ICE] #194"); assertFalse(cardToken.cardRequestHasNoCode()); } - @Test void testCardMatchWitDateANDgameANDdeckFormatConstraints(){ + @Test + void testCardMatchWitDateANDgameANDdeckFormatConstraints() { DeckRecognizer recognizer = new DeckRecognizer(); // Baseline - no constraints - assertEquals(StaticData.instance().getCommonCards().getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); + assertEquals(StaticData.instance().getCommonCards().getCardArtPreference(), + CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); String lineRequest = "Flash"; Token cardToken = recognizer.recogniseCardToken(lineRequest, null); @@ -2111,7 +2160,7 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { recognizer.setGameFormatConstraint(Arrays.asList("MIR", "VIS", "WTH"), null, null); recognizer.setDeckFormatConstraint(DeckFormat.TinyLeaders); - recognizer.setDateConstraint(1999, 2); // March '99 + recognizer.setDateConstraint(1999, 2); // March '99 cardToken = recognizer.recogniseCardToken(lineRequest, null); assertNotNull(cardToken); @@ -2127,9 +2176,9 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { lineRequest = "Ardent Militia"; cardToken = recognizer.recogniseCardToken(lineRequest, null); assertNotNull(cardToken); - assertEquals(cardToken.getType(), TokenType.LIMITED_CARD); // illegal in deck format + assertEquals(cardToken.getType(), TokenType.LIMITED_CARD); // illegal in deck format assertNotNull(cardToken.getCard()); - assertEquals(cardToken.getText(), "Ardent Militia [WTH] #5"); // within set constraints + assertEquals(cardToken.getText(), "Ardent Militia [WTH] #5"); // within set constraints assertEquals(cardToken.getTokenSection(), DeckSection.Main); assertNotNull(cardToken.getLimitedCardType()); assertEquals(cardToken.getLimitedCardType(), DeckRecognizer.LimitedCardType.BANNED); @@ -2138,21 +2187,21 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { lineRequest = "Buried Alive|UMA"; cardToken = recognizer.recogniseCardToken(lineRequest, null); assertNotNull(cardToken); - assertEquals(cardToken.getType(), TokenType.CARD_FROM_NOT_ALLOWED_SET); // illegal in game format + assertEquals(cardToken.getType(), TokenType.CARD_FROM_NOT_ALLOWED_SET); // illegal in game format assertNotNull(cardToken.getCard()); - assertEquals(cardToken.getText(), "Buried Alive [UMA] #88"); // within set constraints + assertEquals(cardToken.getText(), "Buried Alive [UMA] #88"); // within set constraints assertFalse(cardToken.cardRequestHasNoCode()); lineRequest = "Buried Alive"; cardToken = recognizer.recogniseCardToken(lineRequest, null); assertNotNull(cardToken); - assertEquals(cardToken.getType(), TokenType.LEGAL_CARD); // illegal in deck format + assertEquals(cardToken.getType(), TokenType.LEGAL_CARD); // illegal in deck format assertNotNull(cardToken.getCard()); assertEquals(cardToken.getCard().getName(), "Buried Alive"); - assertEquals(cardToken.getCard().getEdition(), "WTH"); // within set constraints + assertEquals(cardToken.getCard().getEdition(), "WTH"); // within set constraints assertTrue(cardToken.cardRequestHasNoCode()); - recognizer.setDateConstraint(1997, 2); // March '97 - before WTH + recognizer.setDateConstraint(1997, 2); // March '97 - before WTH lineRequest = "Buried Alive"; cardToken = recognizer.recogniseCardToken(lineRequest, null); assertNotNull(cardToken); @@ -2162,18 +2211,20 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertTrue(cardToken.cardRequestHasNoCode()); } - /*================================== - * TEST RECOGNISE CARD EXTRA FORMATS - * =================================*/ + /* + * ================================== TEST RECOGNISE CARD EXTRA FORMATS + * ================================= + */ // === MTG Goldfish - @Test void testFoilRequestInMTGGoldfishExportFormat(){ + @Test + void testFoilRequestInMTGGoldfishExportFormat() { String mtgGoldfishRequest = "18 Forest <254> [THB]"; Pattern target = DeckRecognizer.CARD_COLLNO_SET_PATTERN; Matcher matcher = target.matcher(mtgGoldfishRequest); assertTrue(matcher.matches()); assertEquals(matcher.group(DeckRecognizer.REGRP_CARDNO), "18"); - assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Forest"); // TRIM + assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Forest"); // TRIM assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "THB"); assertEquals(matcher.group(DeckRecognizer.REGRP_COLLNR), "254"); assertNull(matcher.group(DeckRecognizer.REGRP_FOIL_GFISH)); @@ -2216,9 +2267,11 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertFalse(matcher.matches()); } - @Test void testCardRecognisedMTGGoldfishFormat(){ + @Test + void testCardRecognisedMTGGoldfishFormat() { DeckRecognizer recognizer = new DeckRecognizer(); - assertEquals(StaticData.instance().getCommonCards().getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); + assertEquals(StaticData.instance().getCommonCards().getCardArtPreference(), + CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); String lineRequest = "4 Aspect of Hydra [BNG] (F)"; Token cardToken = recognizer.recogniseCardToken(lineRequest, null); @@ -2246,7 +2299,8 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { } // === TappedOut Markdown Format - @Test void testPurgeLinksInLineRequests(){ + @Test + void testPurgeLinksInLineRequests() { String line = "* 1 [Ancestral Recall](http://tappedout.nethttp://tappedout.net/mtg-card/ancestral-recall/)"; String expected = "* 1 [Ancestral Recall]"; assertEquals(DeckRecognizer.purgeAllLinks(line), expected); @@ -2256,9 +2310,11 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(DeckRecognizer.purgeAllLinks(line), expected); } - @Test void testCardNameEntryInMarkDownExportFromTappedOut(){ + @Test + void testCardNameEntryInMarkDownExportFromTappedOut() { DeckRecognizer recognizer = new DeckRecognizer(); - assertEquals(StaticData.instance().getCommonCards().getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); + assertEquals(StaticData.instance().getCommonCards().getCardArtPreference(), + CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); String line = "* 1 [Ancestral Recall](http://tappedout.nethttp://tappedout.net/mtg-card/ancestral-recall/)"; @@ -2273,13 +2329,14 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { } // === XMage Format - @Test void testMatchCardRequestXMageFormat(){ + @Test + void testMatchCardRequestXMageFormat() { String xmageFormatRequest = "1 [LRW:51] Amoeboid Changeling"; Pattern target = DeckRecognizer.SET_COLLNO_CARD_XMAGE_PATTERN; Matcher matcher = target.matcher(xmageFormatRequest); assertTrue(matcher.matches()); assertEquals(matcher.group(DeckRecognizer.REGRP_CARDNO), "1"); - assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Amoeboid Changeling"); // TRIM + assertEquals(matcher.group(DeckRecognizer.REGRP_CARD), "Amoeboid Changeling"); // TRIM assertEquals(matcher.group(DeckRecognizer.REGRP_SET), "LRW"); assertEquals(matcher.group(DeckRecognizer.REGRP_COLLNR), "51"); assertNull(matcher.group(DeckRecognizer.REGRP_FOIL_GFISH)); @@ -2311,7 +2368,8 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertFalse(matcher.matches()); } - @Test void testRecognizeCardTokenInXMageFormatRequest(){ + @Test + void testRecognizeCardTokenInXMageFormatRequest() { DeckRecognizer recognizer = new DeckRecognizer(); String xmageFormatRequest = "1 [LRW:51] Amoeboid Changeling"; @@ -2328,7 +2386,8 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { } // === Deckstats Commander - @Test void testRecognizeCommanderCardInDeckstatsExportFormat(){ + @Test + void testRecognizeCommanderCardInDeckstatsExportFormat() { DeckRecognizer recognizer = new DeckRecognizer(); String deckstatsCommanderRequest = "1 Sliver Overlord #!Commander"; @@ -2359,7 +2418,8 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { } // === Double-Sided Cards - @Test void testRecognizeDoubleSidedCards(){ + @Test + void testRecognizeDoubleSidedCards() { String leftSideRequest = "Afflicted Deserter"; String rightSideRequest = "Werewolf Ransacker"; String doubleSideRequest = "Afflicted Deserter // Werewolf Ransacker"; @@ -2384,7 +2444,8 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(cardToken.getTokenSection(), DeckSection.Main); assertNotNull(cardToken.getCard()); PaperCard rightSideCard = cardToken.getCard(); - assertEquals(rightSideCard.getName(), leftSideRequest); // NOTE: this is not a blunder! Back side will result in front side name + assertEquals(rightSideCard.getName(), leftSideRequest); // NOTE: this is not a blunder! Back side will result in + // front side name assertEquals(cardToken.getQuantity(), 1); assertTrue(cardToken.cardRequestHasNoCode()); @@ -2400,10 +2461,12 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertTrue(cardToken.cardRequestHasNoCode()); } - /*================================= - * TEST CARD TOKEN SECTION MATCHING - * ================================ */ - @Test void testCardTokenIsAssignedToCorrectDeckSection(){ + /* + * ================================= TEST CARD TOKEN SECTION MATCHING + * ================================ + */ + @Test + void testCardTokenIsAssignedToCorrectDeckSection() { DeckRecognizer recognizer = new DeckRecognizer(); String cardRequest = "2x Counterspell |TMP"; @@ -2449,10 +2512,11 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(cardToken.getTokenSection(), DeckSection.Sideboard); } - @Test void testCardSectionIsAdaptedToCardRegardlessOfCurrentSection(){ + @Test + void testCardSectionIsAdaptedToCardRegardlessOfCurrentSection() { DeckRecognizer recognizer = new DeckRecognizer(); - String cardRequest = "2x All in good time"; // Scheme Card + String cardRequest = "2x All in good time"; // Scheme Card Token cardToken = recognizer.recogniseCardToken(cardRequest, null); assertNotNull(cardToken); assertEquals(cardToken.getType(), TokenType.LEGAL_CARD); @@ -2470,10 +2534,11 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(cardToken.getTokenSection(), DeckSection.Schemes); } - @Test void testCardSectionIsAdpatedToCardRegardlessOfSectionInCardRequest(){ + @Test + void testCardSectionIsAdpatedToCardRegardlessOfSectionInCardRequest() { DeckRecognizer recognizer = new DeckRecognizer(); - String cardRequest = "CM: 4x Incinerate"; // Incinerate in Commander Section + String cardRequest = "CM: 4x Incinerate"; // Incinerate in Commander Section Token cardToken = recognizer.recogniseCardToken(cardRequest, null); assertNotNull(cardToken); assertEquals(cardToken.getType(), TokenType.LEGAL_CARD); @@ -2482,7 +2547,8 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(cardToken.getQuantity(), 4); assertEquals(cardToken.getTokenSection(), DeckSection.Main); - // Current Deck Section is Sideboard, so Side should be used as replacing Deck Section + // Current Deck Section is Sideboard, so Side should be used as replacing Deck + // Section cardToken = recognizer.recogniseCardToken(cardRequest, DeckSection.Sideboard); assertNotNull(cardToken); assertEquals(cardToken.getType(), TokenType.LEGAL_CARD); @@ -2492,11 +2558,12 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(cardToken.getTokenSection(), DeckSection.Sideboard); } - @Test void testDeckSectionTokenValidationAlsoAppliesToNonLegalCards(){ + @Test + void testDeckSectionTokenValidationAlsoAppliesToNonLegalCards() { DeckRecognizer recognizer = new DeckRecognizer(); recognizer.setGameFormatConstraint(null, Collections.singletonList("Incinerate"), null); - String cardRequest = "CM: 4x Incinerate"; // Incinerate in Commander Section + String cardRequest = "CM: 4x Incinerate"; // Incinerate in Commander Section Token cardToken = recognizer.recogniseCardToken(cardRequest, null); assertNotNull(cardToken); assertEquals(cardToken.getType(), TokenType.LIMITED_CARD); @@ -2507,7 +2574,8 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(cardToken.getQuantity(), 4); assertEquals(cardToken.getTokenSection(), DeckSection.Main); - // Current Deck Section is Sideboard, so Side should be used as replacing Deck Section + // Current Deck Section is Sideboard, so Side should be used as replacing Deck + // Section cardToken = recognizer.recogniseCardToken(cardRequest, DeckSection.Sideboard); assertNotNull(cardToken); assertEquals(cardToken.getType(), TokenType.LIMITED_CARD); @@ -2519,7 +2587,8 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(cardToken.getTokenSection(), DeckSection.Sideboard); } - @Test void testCornerCaseWhenThereIsNoCurrentSectionAndMatchedSectionIsNotAllowedButCouldMatchMain(){ + @Test + void testCornerCaseWhenThereIsNoCurrentSectionAndMatchedSectionIsNotAllowedButCouldMatchMain() { DeckRecognizer recognizer = new DeckRecognizer(); String cardRequest = "All in Good Time"; // Scheme Section @@ -2581,11 +2650,13 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(cardToken.getTokenSection(), DeckSection.Schemes); } - /*================================= - * TEST UNKNOWN CARDS - * ================================ */ + /* + * ================================= TEST UNKNOWN CARDS + * ================================ + */ - @Test void testUknonwCardIsReturnedForAnExistingCardFromTheWrongSet(){ + @Test + void testUknonwCardIsReturnedForAnExistingCardFromTheWrongSet() { String cardRequest = "Counterspell FEM"; DeckRecognizer recognizer = new DeckRecognizer(); Token unknonwCardToken = recognizer.recogniseCardToken(cardRequest, null); @@ -2595,7 +2666,8 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertNull(unknonwCardToken.getTokenSection()); } - @Test void testUknownCardIsReturnedForLineRequestsThatLooksLikeACardButAreNotSupported(){ + @Test + void testUknownCardIsReturnedForLineRequestsThatLooksLikeACardButAreNotSupported() { String cardRequest = "2x Counterspelling TMP"; DeckRecognizer recognizer = new DeckRecognizer(); Token unknonwCardToken = recognizer.recogniseCardToken(cardRequest, null); @@ -2618,21 +2690,21 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertNull(unknonwCardToken.getCard()); assertNull(unknonwCardToken.getTokenSection()); - cardRequest = "SB: 2x Counterspelling TMP"; // adding deck section reference + cardRequest = "SB: 2x Counterspelling TMP"; // adding deck section reference unknonwCardToken = recognizer.recogniseCardToken(cardRequest, null); assertNotNull(unknonwCardToken); assertEquals(unknonwCardToken.getType(), TokenType.UNKNOWN_CARD); assertNull(unknonwCardToken.getCard()); assertNull(unknonwCardToken.getTokenSection()); - cardRequest = "SB: 2x Counterspelling TMP (F)"; // adding deck section reference + cardRequest = "SB: 2x Counterspelling TMP (F)"; // adding deck section reference unknonwCardToken = recognizer.recogniseCardToken(cardRequest, null); assertNotNull(unknonwCardToken); assertEquals(unknonwCardToken.getType(), TokenType.UNKNOWN_CARD); assertNull(unknonwCardToken.getCard()); assertNull(unknonwCardToken.getTokenSection()); - cardRequest = "SB: 2x Counterspelling+ TMP"; // adding deck section reference + cardRequest = "SB: 2x Counterspelling+ TMP"; // adding deck section reference unknonwCardToken = recognizer.recogniseCardToken(cardRequest, null); assertNotNull(unknonwCardToken); assertEquals(unknonwCardToken.getType(), TokenType.UNKNOWN_CARD); @@ -2640,10 +2712,11 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertNull(unknonwCardToken.getTokenSection()); } - /*=============== - * TEST TOKEN-KEY - * ============== */ - @Test void testTokenKeyForLegalCard() { + /* + * =============== TEST TOKEN-KEY ============== + */ + @Test + void testTokenKeyForLegalCard() { DeckRecognizer recognizer = new DeckRecognizer(); String cardRequest = "Viashino Sandstalker"; Token cardToken = recognizer.recogniseCardToken(cardRequest, null); @@ -2667,7 +2740,8 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertNull(tokenKey.limitedType); } - @Test void testTokenKeyWithGameConstraints(){ + @Test + void testTokenKeyWithGameConstraints() { DeckRecognizer recognizer = new DeckRecognizer(); List allowedSetCodes = Arrays.asList("MIR", "VIS", "WTH"); List bannedCards = Collections.singletonList("Squandered Resources"); @@ -2728,7 +2802,8 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(tokenKey.limitedType, cardToken.getLimitedCardType()); } - @Test void testTokenKeyWithNonCardTokens(){ + @Test + void testTokenKeyWithNonCardTokens() { DeckRecognizer recognizer = new DeckRecognizer(); // Deck Name String line = "Name: Test Deck"; @@ -2842,7 +2917,8 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertNull(lineToken.getLimitedCardType()); } - @Test void testTokenKeyFromString(){ + @Test + void testTokenKeyFromString() { DeckRecognizer recognizer = new DeckRecognizer(); String cardRequest = "Viashino Sandstalker"; Token cardToken = recognizer.recogniseCardToken(cardRequest, null); @@ -2877,7 +2953,8 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(newTokenKey.limitedType, tokenKey.limitedType); } - @Test void testTokenKeyWithFoiledCard(){ + @Test + void testTokenKeyWithFoiledCard() { DeckRecognizer recognizer = new DeckRecognizer(); String cardRequest = "Mountain|M21 (F)"; Token cardToken = recognizer.recogniseCardToken(cardRequest, null); @@ -2903,7 +2980,8 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(tokenKey.deckSection, cardToken.getTokenSection()); } - @Test void testTokenKeyFoilCardFromString() { + @Test + void testTokenKeyFoilCardFromString() { DeckRecognizer recognizer = new DeckRecognizer(); String cardRequest = "Mountain|M21 (F)"; Token cardToken = recognizer.recogniseCardToken(cardRequest, null); @@ -2940,15 +3018,18 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(newTokenKey.limitedType, tokenKey.limitedType); } - /*==================================== - * TEST PARSE INPUT - * ==================================*/ + /* + * ==================================== TEST PARSE INPUT + * ================================== + */ // === MIXED inputs === - @Test void testRecognizeLines(){ + @Test + void testRecognizeLines() { DeckRecognizer recognizer = new DeckRecognizer(); - assertEquals(StaticData.instance().getCommonCards().getCardArtPreference(), CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); + assertEquals(StaticData.instance().getCommonCards().getCardArtPreference(), + CardDb.CardArtPreference.LATEST_ART_ALL_EDITIONS); String lineRequest = "// MainBoard"; Token token = recognizer.recognizeLine(lineRequest, null); @@ -3043,13 +3124,13 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { } // === Parsing Card List === - @Test void testParsingCardListNoConstraint(){ - String[] cardList = new String[]{ - "//Sideboard", // decksection + @Test + void testParsingCardListNoConstraint() { + String[] cardList = new String[] { "//Sideboard", // decksection "2x Counterspell FEM", // unknonw card - "4x Incinerate|ICE", // known card to side - "Gibberish to ignore", // ignored - "#Comment to report" // comment token + "4x Incinerate|ICE", // known card to side + "Gibberish to ignore", // ignored + "#Comment to report" // comment token }; DeckRecognizer recognizer = new DeckRecognizer(); List tokens = recognizer.parseCardList(cardList); @@ -3081,11 +3162,11 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(commentToken.getType(), TokenType.COMMENT); } - @Test void testParseCardListWithAllowedSectionsRaisesUnsupportedCardsAndSection(){ - String[] cardList = new String[]{ - "//Sideboard", // decksection - unsupported section + @Test + void testParseCardListWithAllowedSectionsRaisesUnsupportedCardsAndSection() { + String[] cardList = new String[] { "//Sideboard", // decksection - unsupported section "All in Good Time", // Schemes - unsupported card - "4x Incinerate|ICE", // known card to main + "4x Incinerate|ICE", // known card to main }; DeckRecognizer recognizer = new DeckRecognizer(); recognizer.setAllowedDeckSections(Arrays.asList(DeckSection.Main, DeckSection.Commander)); @@ -3115,11 +3196,11 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(cardToken.getTokenSection(), DeckSection.Main); } - @Test void testCardListWithDeckNameHasDeckNameOnTop(){ - String[] cardList = new String[]{ - "//Sideboard", // decksection + @Test + void testCardListWithDeckNameHasDeckNameOnTop() { + String[] cardList = new String[] { "//Sideboard", // decksection "Name: Test deck", // goes on top - "4x Incinerate|ICE", // known card to side + "4x Incinerate|ICE", // known card to side }; DeckRecognizer recognizer = new DeckRecognizer(); List tokens = recognizer.parseCardList(cardList); @@ -3145,11 +3226,11 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(cardToken.getTokenSection(), DeckSection.Sideboard); } - @Test void testCardsInDifferentSectionsWillAddAlsoDeckSectionPlaceholders(){ - String[] cardList = new String[]{ - "2x Counterspell | TMP", // card legal in Main (+placeholder) - "SB:4x Incinerate|ICE", // card legal in Side (+ placeholder) - "2x Fireball 5ED" // card legal in Side + @Test + void testCardsInDifferentSectionsWillAddAlsoDeckSectionPlaceholders() { + String[] cardList = new String[] { "2x Counterspell | TMP", // card legal in Main (+placeholder) + "SB:4x Incinerate|ICE", // card legal in Side (+ placeholder) + "2x Fireball 5ED" // card legal in Side }; DeckRecognizer recognizer = new DeckRecognizer(); List tokens = recognizer.parseCardList(cardList); @@ -3194,11 +3275,11 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(cardToken.getTokenSection(), DeckSection.Sideboard); } - @Test void testDeckSectionValidationForTokensAddPlaceholderAndRestoresMainSection(){ - String[] cardList = new String[]{ - "2x Counterspell | TMP", // card legal in Main (+placeholder) - "All in Good Time", // card legal in Schemes (+ placeholder) - "2x Fireball 5ED" // card legal in Main (+ placeholder as section changes again) + @Test + void testDeckSectionValidationForTokensAddPlaceholderAndRestoresMainSection() { + String[] cardList = new String[] { "2x Counterspell | TMP", // card legal in Main (+placeholder) + "All in Good Time", // card legal in Schemes (+ placeholder) + "2x Fireball 5ED" // card legal in Main (+ placeholder as section changes again) }; DeckRecognizer recognizer = new DeckRecognizer(); List tokens = recognizer.parseCardList(cardList); @@ -3247,14 +3328,15 @@ public class DeckRecognizerTest extends ForgeCardMockTestCase { assertEquals(cardToken.getTokenSection(), DeckSection.Main); } - @Test void testUnsupportedCardIsReturnedOnlyWhenNoOtherOptionExistForSectionMatching(){ + @Test + void testUnsupportedCardIsReturnedOnlyWhenNoOtherOptionExistForSectionMatching() { DeckRecognizer recognizer = new DeckRecognizer(); // Now add constraint recognizer.setAllowedDeckSections(Arrays.asList(DeckSection.Main, DeckSection.Sideboard)); - String[] cardList = new String[]{ - "1 Anowon, the Ruin Thief", // Commander Section but will go in MAIN + placeholder - "All in Good Time", // card legal in Schemes but Section not allowed - UNSUPPORTED + String[] cardList = new String[] { "1 Anowon, the Ruin Thief", // Commander Section but will go in MAIN + + // placeholder + "All in Good Time", // card legal in Schemes but Section not allowed - UNSUPPORTED }; List parsedTokens = recognizer.parseCardList(cardList); diff --git a/forge-gui-desktop/src/test/java/forge/gamesimulationtests/BaseGameSimulationTest.java b/forge-gui-desktop/src/test/java/forge/gamesimulationtests/BaseGameSimulationTest.java index 50c85a362ea..186c364c963 100644 --- a/forge-gui-desktop/src/test/java/forge/gamesimulationtests/BaseGameSimulationTest.java +++ b/forge-gui-desktop/src/test/java/forge/gamesimulationtests/BaseGameSimulationTest.java @@ -3,7 +3,7 @@ package forge.gamesimulationtests; import forge.ImageCache; import forge.ImageKeys; import forge.Singletons; -import forge.card.ForgeCardMockTestCase; +import forge.card.CardMockTestCase; import forge.game.GameLogFormatter; import forge.gamesimulationtests.util.GameWrapper; import forge.gamesimulationtests.util.player.PlayerSpecification; @@ -24,44 +24,46 @@ import org.testng.annotations.BeforeMethod; import javax.imageio.ImageIO; import java.util.ResourceBundle; -@PrepareForTest(value = {FModel.class, Singletons.class, ResourceBundle.class, - ImageCache.class, ImageIO.class, ImageKeys.class, - ForgeConstants.class, Localizer.class, Sentry.class, GameLogFormatter.class}) -@SuppressStaticInitializationFor({"forge.ImageCache", "forge.localinstance.properties.ForgeConstants"}) -@PowerMockIgnore({"javax.xml.*", "org.xml.sax.*", "com.sun.org.apache.xerces.*", "org.w3c.dom.*", "org.springframework.context.*", "org.apache.log4j.*"}) -public class BaseGameSimulationTest extends ForgeCardMockTestCase { +@PrepareForTest(value = { FModel.class, Singletons.class, ResourceBundle.class, ImageCache.class, ImageIO.class, + ImageKeys.class, ForgeConstants.class, Localizer.class, Sentry.class, GameLogFormatter.class }) +@SuppressStaticInitializationFor({ "forge.ImageCache", "forge.localinstance.properties.ForgeConstants" }) +@PowerMockIgnore({ "javax.xml.*", "org.xml.sax.*", "com.sun.org.apache.xerces.*", "org.w3c.dom.*", + "org.springframework.context.*", "org.apache.log4j.*" }) +public class BaseGameSimulationTest extends CardMockTestCase { - @BeforeMethod - @Override - protected void initMocks() throws Exception { - super.initMocks(); - PowerMockito.mockStatic(Sentry.class); - PowerMockito.mockStatic(GameLogFormatter.class); - //PowerMockito.when(Sentry.getContext()).thenReturn(new Context()); - Lang.createInstance("en-US"); - } + @BeforeMethod + @Override + protected void initMocks() throws Exception { + super.initMocks(); + PowerMockito.mockStatic(Sentry.class); + PowerMockito.mockStatic(GameLogFormatter.class); + // PowerMockito.when(Sentry.getContext()).thenReturn(new Context()); + Lang.createInstance("en-US"); + } - protected void runGame(GameWrapper game, PlayerSpecification expectedWinner, int finalTurn, AssertAction... postGameAssertActions) { - try { - initMocks(); - game.runGame(); - verifyThatTheGameHasFinishedAndThatPlayerHasWonOnTurn(game, expectedWinner, finalTurn); - if(postGameAssertActions != null && postGameAssertActions.length > 0) { - for(AssertAction assertAction : postGameAssertActions) { - assertAction.performAssertion(game.getGame()); - } - } - } catch (Throwable t) { - System.out.println(game.toString()); - throw new RuntimeException(t); - } - } - - protected void verifyThatTheGameHasFinishedAndThatPlayerHasWonOnTurn(GameWrapper game, PlayerSpecification expectedWinner, int finalTurn) { - Assert.assertTrue(game.getGame().isGameOver()); - Assert.assertEquals(game.getGame().getOutcome().getLastTurnNumber(), finalTurn); - Assert.assertEquals(game.getGame().getOutcome().getWinningPlayer().getPlayer().getName(), - PlayerSpecificationHandler.INSTANCE.find(game.getGame(), expectedWinner).getName()); - Assert.assertTrue(game.getPlayerActions() == null || game.getPlayerActions().isEmpty()); - } + protected void runGame(GameWrapper game, PlayerSpecification expectedWinner, int finalTurn, + AssertAction... postGameAssertActions) { + try { + initMocks(); + game.runGame(); + verifyThatTheGameHasFinishedAndThatPlayerHasWonOnTurn(game, expectedWinner, finalTurn); + if (postGameAssertActions != null && postGameAssertActions.length > 0) { + for (AssertAction assertAction : postGameAssertActions) { + assertAction.performAssertion(game.getGame()); + } + } + } catch (Throwable t) { + System.out.println(game.toString()); + throw new RuntimeException(t); + } + } + + protected void verifyThatTheGameHasFinishedAndThatPlayerHasWonOnTurn(GameWrapper game, + PlayerSpecification expectedWinner, int finalTurn) { + Assert.assertTrue(game.getGame().isGameOver()); + Assert.assertEquals(game.getGame().getOutcome().getLastTurnNumber(), finalTurn); + Assert.assertEquals(game.getGame().getOutcome().getWinningPlayer().getPlayer().getName(), + PlayerSpecificationHandler.INSTANCE.find(game.getGame(), expectedWinner).getName()); + Assert.assertTrue(game.getPlayerActions() == null || game.getPlayerActions().isEmpty()); + } }