diff options
Diffstat (limited to 'game-engine/src/test/kotlin')
10 files changed, 549 insertions, 5 deletions
diff --git a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/cards/CardTest.kt b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/cards/CardTest.kt index 170ae1e4..3253136c 100644 --- a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/cards/CardTest.kt +++ b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/cards/CardTest.kt @@ -7,6 +7,7 @@ import org.luxons.sevenwonders.game.Settings import org.luxons.sevenwonders.game.api.Table import org.luxons.sevenwonders.game.boards.Board import org.luxons.sevenwonders.game.effects.ProductionIncrease +import org.luxons.sevenwonders.game.resources.Production import org.luxons.sevenwonders.game.resources.ResourceTransactions import org.luxons.sevenwonders.game.resources.ResourceType import org.luxons.sevenwonders.game.resources.Resources @@ -31,8 +32,9 @@ class CardTest { table = Table(boards) val treeFarmRequirements = Requirements(1) - val treeFarmEffect = ProductionIncrease() - treeFarmEffect.production.addChoice(ResourceType.WOOD, ResourceType.CLAY) + val treeFarmProduction = Production() + treeFarmProduction.addChoice(ResourceType.WOOD, ResourceType.CLAY) + val treeFarmEffect = ProductionIncrease(treeFarmProduction, false) treeFarmCard = testCard("Tree Farm", Color.BROWN, treeFarmEffect, treeFarmRequirements) } diff --git a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/effects/BonusPerBoardElementTest.kt b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/effects/BonusPerBoardElementTest.kt new file mode 100644 index 00000000..ccc1c142 --- /dev/null +++ b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/effects/BonusPerBoardElementTest.kt @@ -0,0 +1,141 @@ +package org.luxons.sevenwonders.game.effects + +import org.junit.Before +import org.junit.experimental.theories.DataPoints +import org.junit.experimental.theories.Theories +import org.junit.experimental.theories.Theory +import org.junit.runner.RunWith +import org.luxons.sevenwonders.game.api.Table +import org.luxons.sevenwonders.game.boards.BoardElementType +import org.luxons.sevenwonders.game.boards.RelativeBoardPosition +import org.luxons.sevenwonders.game.cards.CardBack +import org.luxons.sevenwonders.game.cards.Color +import org.luxons.sevenwonders.game.test.* + +import org.junit.Assert.assertEquals + +@RunWith(Theories::class) +class BonusPerBoardElementTest { + + private var table: Table? = null + + @Before + fun setUp() { + table = testTable(4) + } + + @Theory + fun computePoints_countsCards( + boardPosition: RelativeBoardPosition, nbCards: Int, nbOtherCards: Int, + points: Int, gold: Int, color: Color + ) { + val board = table!!.getBoard(0, boardPosition) + addCards(board, nbCards, nbOtherCards, color) + + val bonus = BonusPerBoardElement(listOf(boardPosition), BoardElementType.CARD, gold, points, listOf(color)) + + assertEquals((nbCards * points).toLong(), bonus.computePoints(table!!, 0).toLong()) + } + + @Theory + fun computePoints_countsDefeatTokens( + boardPosition: RelativeBoardPosition, nbDefeatTokens: Int, points: Int, + gold: Int + ) { + val board = table!!.getBoard(0, boardPosition) + for (i in 0 until nbDefeatTokens) { + board.military.defeat() + } + + val bonus = BonusPerBoardElement(listOf(boardPosition), BoardElementType.DEFEAT_TOKEN, gold, points, listOf()) + + assertEquals((nbDefeatTokens * points).toLong(), bonus.computePoints(table!!, 0).toLong()) + } + + @Theory + fun computePoints_countsWonderStages( + boardPosition: RelativeBoardPosition, nbStages: Int, points: Int, + gold: Int + ) { + val board = table!!.getBoard(0, boardPosition) + for (i in 0 until nbStages) { + board.wonder.buildLevel(CardBack("")) + } + + val bonus = + BonusPerBoardElement(listOf(boardPosition), BoardElementType.BUILT_WONDER_STAGES, gold, points, listOf()) + + assertEquals((nbStages * points).toLong(), bonus.computePoints(table!!, 0).toLong()) + } + + @Theory + fun apply_countsCards( + boardPosition: RelativeBoardPosition, nbCards: Int, nbOtherCards: Int, points: Int, + gold: Int, color: Color + ) { + val board = table!!.getBoard(0, boardPosition) + addCards(board, nbCards, nbOtherCards, color) + + val bonus = BonusPerBoardElement(listOf(boardPosition), BoardElementType.CARD, gold, points, listOf(color)) + + val selfBoard = table!!.getBoard(0) + val initialGold = selfBoard.gold + bonus.apply(table!!, 0) + assertEquals((initialGold + nbCards * gold).toLong(), selfBoard.gold.toLong()) + } + + @Theory + fun apply_countsDefeatTokens( + boardPosition: RelativeBoardPosition, nbDefeatTokens: Int, points: Int, + gold: Int + ) { + val board = table!!.getBoard(0, boardPosition) + for (i in 0 until nbDefeatTokens) { + board.military.defeat() + } + + val bonus = BonusPerBoardElement(listOf(boardPosition), BoardElementType.DEFEAT_TOKEN, gold, points, listOf()) + + val selfBoard = table!!.getBoard(0) + val initialGold = selfBoard.gold + bonus.apply(table!!, 0) + assertEquals((initialGold + nbDefeatTokens * gold).toLong(), selfBoard.gold.toLong()) + } + + @Theory + fun apply_countsWonderStages(boardPosition: RelativeBoardPosition, nbStages: Int, points: Int, gold: Int) { + val board = table!!.getBoard(0, boardPosition) + for (i in 0 until nbStages) { + board.wonder.buildLevel(CardBack("")) + } + + val bonus = + BonusPerBoardElement(listOf(boardPosition), BoardElementType.BUILT_WONDER_STAGES, gold, points, listOf()) + + val selfBoard = table!!.getBoard(0) + val initialGold = selfBoard.gold + bonus.apply(table!!, 0) + assertEquals((initialGold + nbStages * gold).toLong(), selfBoard.gold.toLong()) + } + + companion object { + + @JvmStatic + @DataPoints + fun values(): IntArray { + return intArrayOf(0, 1, 2, 3) + } + + @JvmStatic + @DataPoints + fun colors(): Array<Color> { + return Color.values() + } + + @JvmStatic + @DataPoints + fun positions(): Array<RelativeBoardPosition> { + return RelativeBoardPosition.values() + } + } +} diff --git a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/effects/DiscountTest.kt b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/effects/DiscountTest.kt new file mode 100644 index 00000000..e228d585 --- /dev/null +++ b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/effects/DiscountTest.kt @@ -0,0 +1,72 @@ +package org.luxons.sevenwonders.game.effects + +import org.junit.Assert.assertEquals +import org.junit.Assume +import org.junit.experimental.theories.DataPoints +import org.junit.experimental.theories.Theories +import org.junit.experimental.theories.Theory +import org.junit.runner.RunWith +import org.luxons.sevenwonders.game.resources.Provider +import org.luxons.sevenwonders.game.resources.ResourceType +import org.luxons.sevenwonders.game.test.createTransactions +import org.luxons.sevenwonders.game.test.testBoard + +@RunWith(Theories::class) +class DiscountTest { + + @Theory + fun apply_givesDiscountedPrice(discountedPrice: Int, discountedType: ResourceType, provider: Provider) { + val board = testBoard(ResourceType.CLAY, 3) + val discount = Discount(listOf(discountedType), listOf(provider), discountedPrice) + discount.apply(board) + + val transactions = createTransactions(provider, discountedType) + assertEquals(discountedPrice.toLong(), board.tradingRules.computeCost(transactions).toLong()) + } + + @Theory + fun apply_doesNotAffectOtherResources( + discountedPrice: Int, discountedType: ResourceType, provider: Provider, + otherType: ResourceType, otherProvider: Provider + ) { + Assume.assumeTrue(otherProvider != provider) + Assume.assumeTrue(otherType != discountedType) + + val board = testBoard(ResourceType.CLAY, 3) + val discount = Discount(listOf(discountedType), listOf(provider), discountedPrice) + discount.apply(board) + + // this is the default in the settings used by TestUtilsKt.testBoard() + val normalPrice = 2 + + val fromOtherType = createTransactions(provider, otherType) + assertEquals(normalPrice.toLong(), board.tradingRules.computeCost(fromOtherType).toLong()) + + val fromOtherProvider = createTransactions(otherProvider, discountedType) + assertEquals(normalPrice.toLong(), board.tradingRules.computeCost(fromOtherProvider).toLong()) + + val fromOtherProviderAndType = createTransactions(otherProvider, otherType) + assertEquals(normalPrice.toLong(), board.tradingRules.computeCost(fromOtherProviderAndType).toLong()) + } + + companion object { + + @JvmStatic + @DataPoints + fun discountedPrices(): IntArray { + return intArrayOf(0, 1, 2) + } + + @JvmStatic + @DataPoints + fun resourceTypes(): Array<ResourceType> { + return ResourceType.values() + } + + @JvmStatic + @DataPoints + fun providers(): Array<Provider> { + return Provider.values() + } + } +} diff --git a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/effects/GoldIncreaseTest.kt b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/effects/GoldIncreaseTest.kt new file mode 100644 index 00000000..175f15ea --- /dev/null +++ b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/effects/GoldIncreaseTest.kt @@ -0,0 +1,46 @@ +package org.luxons.sevenwonders.game.effects + +import org.junit.experimental.theories.DataPoints +import org.junit.experimental.theories.Theories +import org.junit.experimental.theories.Theory +import org.junit.runner.RunWith +import org.luxons.sevenwonders.game.resources.ResourceType +import org.luxons.sevenwonders.game.test.* + +import org.junit.Assert.assertEquals + +@RunWith(Theories::class) +class GoldIncreaseTest { + + @Theory + fun apply_increaseGoldWithRightAmount(initialAmount: Int, goldIncreaseAmount: Int, type: ResourceType) { + val board = testBoard(type, initialAmount) + val goldIncrease = GoldIncrease(goldIncreaseAmount) + + goldIncrease.apply(board) + + assertEquals((initialAmount + goldIncreaseAmount).toLong(), board.gold.toLong()) + } + + @Theory + fun computePoints_isAlwaysZero(gold: Int) { + val goldIncrease = GoldIncrease(gold) + val table = testTable(5) + assertEquals(0, goldIncrease.computePoints(table, 0).toLong()) + } + + companion object { + + @JvmStatic + @DataPoints + fun goldAmounts(): IntArray { + return intArrayOf(-5, -1, 0, 1, 2, 5, 10) + } + + @JvmStatic + @DataPoints + fun resourceTypes(): Array<ResourceType> { + return ResourceType.values() + } + } +} diff --git a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/effects/MilitaryReinforcementsTest.kt b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/effects/MilitaryReinforcementsTest.kt new file mode 100644 index 00000000..a8bd01d6 --- /dev/null +++ b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/effects/MilitaryReinforcementsTest.kt @@ -0,0 +1,47 @@ +package org.luxons.sevenwonders.game.effects + +import org.junit.experimental.theories.DataPoints +import org.junit.experimental.theories.Theories +import org.junit.experimental.theories.Theory +import org.junit.runner.RunWith +import org.luxons.sevenwonders.game.resources.ResourceType +import org.luxons.sevenwonders.game.test.* + +import org.junit.Assert.assertEquals + +@RunWith(Theories::class) +class MilitaryReinforcementsTest { + + @Theory + fun apply_increaseGoldWithRightAmount(initialShields: Int, additionalShields: Int, type: ResourceType) { + val board = testBoard(type) + board.military.addShields(initialShields) + + val reinforcements = MilitaryReinforcements(additionalShields) + reinforcements.apply(board) + + assertEquals((initialShields + additionalShields).toLong(), board.military.nbShields.toLong()) + } + + @Theory + fun computePoints_isAlwaysZero(shields: Int) { + val reinforcements = MilitaryReinforcements(shields) + val table = testTable(5) + assertEquals(0, reinforcements.computePoints(table, 0).toLong()) + } + + companion object { + + @JvmStatic + @DataPoints + fun shieldCounts(): IntArray { + return intArrayOf(0, 1, 2, 3, 5) + } + + @JvmStatic + @DataPoints + fun resourceTypes(): Array<ResourceType> { + return ResourceType.values() + } + } +} diff --git a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/effects/ProductionIncreaseTest.kt b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/effects/ProductionIncreaseTest.kt new file mode 100644 index 00000000..6f8da55d --- /dev/null +++ b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/effects/ProductionIncreaseTest.kt @@ -0,0 +1,72 @@ +package org.luxons.sevenwonders.game.effects + +import org.junit.experimental.theories.DataPoints +import org.junit.experimental.theories.Theories +import org.junit.experimental.theories.Theory +import org.junit.runner.RunWith +import org.luxons.sevenwonders.game.resources.ResourceType +import org.luxons.sevenwonders.game.test.* + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue + +@RunWith(Theories::class) +class ProductionIncreaseTest { + + @Theory + fun apply_boardContainsAddedResourceType( + initialType: ResourceType, + addedType: ResourceType, + extraType: ResourceType + ) { + val board = testBoard(initialType) + val effect = ProductionIncrease(fixedProduction(addedType), false) + + effect.apply(board) + + val resources = createResources(initialType, addedType) + assertTrue(board.production.contains(resources)) + assertFalse(board.publicProduction.contains(resources)) + + val moreResources = createResources(initialType, addedType, extraType) + assertFalse(board.production.contains(moreResources)) + assertFalse(board.publicProduction.contains(moreResources)) + } + + @Theory + fun apply_boardContainsAddedResourceType_sellable( + initialType: ResourceType, + addedType: ResourceType, + extraType: ResourceType + ) { + val board = testBoard(initialType) + val effect = ProductionIncrease(fixedProduction(addedType), true) + + effect.apply(board) + + val resources = createResources(initialType, addedType) + assertTrue(board.production.contains(resources)) + assertTrue(board.publicProduction.contains(resources)) + + val moreResources = createResources(initialType, addedType, extraType) + assertFalse(board.production.contains(moreResources)) + assertFalse(board.publicProduction.contains(moreResources)) + } + + @Theory + fun computePoints_isAlwaysZero(addedType: ResourceType) { + val effect = ProductionIncrease(fixedProduction(addedType), false) + val table = testTable(5) + assertEquals(0, effect.computePoints(table, 0).toLong()) + } + + companion object { + + @JvmStatic + @DataPoints + fun resourceTypes(): Array<ResourceType> { + return ResourceType.values() + } + } +} diff --git a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/effects/RawPointsIncreaseTest.kt b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/effects/RawPointsIncreaseTest.kt new file mode 100644 index 00000000..844c28eb --- /dev/null +++ b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/effects/RawPointsIncreaseTest.kt @@ -0,0 +1,28 @@ +package org.luxons.sevenwonders.game.effects + +import org.junit.Assert.assertEquals +import org.junit.experimental.theories.DataPoints +import org.junit.experimental.theories.Theories +import org.junit.experimental.theories.Theory +import org.junit.runner.RunWith +import org.luxons.sevenwonders.game.test.testTable + +@RunWith(Theories::class) +class RawPointsIncreaseTest { + + @Theory + fun computePoints_equalsNbOfPoints(points: Int) { + val rawPointsIncrease = RawPointsIncrease(points) + val table = testTable(5) + assertEquals(points.toLong(), rawPointsIncrease.computePoints(table, 0).toLong()) + } + + companion object { + + @JvmStatic + @DataPoints + fun points(): IntArray { + return intArrayOf(0, 1, 2, 3, 5) + } + } +} diff --git a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/effects/ScienceProgressTest.kt b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/effects/ScienceProgressTest.kt new file mode 100644 index 00000000..cbea1581 --- /dev/null +++ b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/effects/ScienceProgressTest.kt @@ -0,0 +1,43 @@ +package org.luxons.sevenwonders.game.effects + +import org.junit.Assert.assertEquals +import org.junit.experimental.theories.DataPoints +import org.junit.experimental.theories.Theories +import org.junit.experimental.theories.Theory +import org.junit.runner.RunWith +import org.luxons.sevenwonders.game.boards.ScienceType +import org.luxons.sevenwonders.game.resources.ResourceType +import org.luxons.sevenwonders.game.test.createScience +import org.luxons.sevenwonders.game.test.createScienceProgress +import org.luxons.sevenwonders.game.test.testBoard + +@RunWith(Theories::class) +class ScienceProgressTest { + + @Theory + fun apply_initContainsAddedScience( + initCompasses: Int, initWheels: Int, initTablets: Int, initJokers: Int, + compasses: Int, wheels: Int, tablets: Int, jokers: Int + ) { + val board = testBoard(ResourceType.ORE) + val initialScience = createScience(initCompasses, initWheels, initTablets, initJokers) + board.science.addAll(initialScience) + + val effect = createScienceProgress(compasses, wheels, tablets, jokers) + effect.apply(board) + + assertEquals((initCompasses + compasses).toLong(), board.science.getQuantity(ScienceType.COMPASS).toLong()) + assertEquals((initWheels + wheels).toLong(), board.science.getQuantity(ScienceType.WHEEL).toLong()) + assertEquals((initTablets + tablets).toLong(), board.science.getQuantity(ScienceType.TABLET).toLong()) + assertEquals((initJokers + jokers).toLong(), board.science.jokers.toLong()) + } + + companion object { + + @JvmStatic + @DataPoints + fun elementsCount(): IntArray { + return intArrayOf(0, 1, 2) + } + } +} diff --git a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/effects/SpecialAbilityActivationTest.kt b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/effects/SpecialAbilityActivationTest.kt new file mode 100644 index 00000000..7282d60d --- /dev/null +++ b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/effects/SpecialAbilityActivationTest.kt @@ -0,0 +1,95 @@ +package org.luxons.sevenwonders.game.effects + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Assume +import org.junit.Test +import org.junit.experimental.theories.DataPoints +import org.junit.experimental.theories.Theories +import org.junit.experimental.theories.Theory +import org.junit.runner.RunWith +import org.luxons.sevenwonders.game.boards.BoardElementType +import org.luxons.sevenwonders.game.boards.RelativeBoardPosition +import org.luxons.sevenwonders.game.cards.Card +import org.luxons.sevenwonders.game.cards.Color +import org.luxons.sevenwonders.game.test.createGuildCard +import org.luxons.sevenwonders.game.test.testTable + +@RunWith(Theories::class) +class SpecialAbilityActivationTest { + + @Theory + fun apply_addsAbility(ability: SpecialAbility) { + val effect = SpecialAbilityActivation(ability) + val table = testTable(5) + + effect.apply(table, 0) + + val board = table.getBoard(0) + assertTrue(board.hasSpecial(ability)) + } + + @Theory + fun computePoints_zeroExceptForCopyGuild(ability: SpecialAbility) { + Assume.assumeTrue(ability !== SpecialAbility.COPY_GUILD) + + val effect = SpecialAbilityActivation(ability) + val table = testTable(5) + + assertEquals(0, effect.computePoints(table, 0).toLong()) + } + + @Theory + fun computePoints_copiedGuild(guildCard: Card, neighbour: RelativeBoardPosition) { + val effect = SpecialAbilityActivation(SpecialAbility.COPY_GUILD) + val table = testTable(5) + + val neighbourBoard = table.getBoard(0, neighbour) + neighbourBoard.addCard(guildCard) + + val board = table.getBoard(0) + board.copiedGuild = guildCard + + val directPointsFromGuildCard = guildCard.effects.stream().mapToInt { e -> e.computePoints(table, 0) }.sum() + assertEquals(directPointsFromGuildCard.toLong(), effect.computePoints(table, 0).toLong()) + } + + @Test(expected = IllegalStateException::class) + fun computePoints_copyGuild_failWhenNoChosenGuild() { + val effect = SpecialAbilityActivation(SpecialAbility.COPY_GUILD) + val table = testTable(5) + effect.computePoints(table, 0) + } + + companion object { + + @JvmStatic + @DataPoints + fun abilities(): Array<SpecialAbility> { + return SpecialAbility.values() + } + + @JvmStatic + @DataPoints + fun neighbours(): Array<RelativeBoardPosition> { + return arrayOf(RelativeBoardPosition.LEFT, RelativeBoardPosition.RIGHT) + } + + @JvmStatic + @DataPoints + fun guilds(): Array<Card> { + val bonus = BonusPerBoardElement( + listOf(RelativeBoardPosition.LEFT, RelativeBoardPosition.RIGHT), + BoardElementType.CARD, + points = 1, + colors = listOf(Color.GREY, Color.BROWN) + ) + val bonus2 = BonusPerBoardElement( + listOf(RelativeBoardPosition.LEFT, RelativeBoardPosition.SELF, RelativeBoardPosition.RIGHT), + BoardElementType.BUILT_WONDER_STAGES, + points = 1 + ) + return arrayOf(createGuildCard(1, bonus), createGuildCard(2, bonus2)) + } + } +} diff --git a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/test/TestUtils.kt b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/test/TestUtils.kt index 85caa35f..28ab714d 100644 --- a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/test/TestUtils.kt +++ b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/test/TestUtils.kt @@ -183,9 +183,7 @@ fun getDifferentColorFrom(vararg colors: Color): Color { } fun createScienceProgress(compasses: Int, wheels: Int, tablets: Int, jokers: Int): ScienceProgress { - val progress = ScienceProgress() - progress.science = createScience(compasses, wheels, tablets, jokers) - return progress + return ScienceProgress(createScience(compasses, wheels, tablets, jokers)) } fun createScience(compasses: Int, wheels: Int, tablets: Int, jokers: Int): Science { |