diff options
Diffstat (limited to 'game-engine/src/test')
14 files changed, 384 insertions, 499 deletions
diff --git a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/GameTest.kt b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/GameTest.kt index 5f76b42e..fb232d9e 100644 --- a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/GameTest.kt +++ b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/GameTest.kt @@ -11,7 +11,9 @@ import org.luxons.sevenwonders.game.data.GameDefinitionLoader import org.luxons.sevenwonders.game.data.LAST_AGE import org.luxons.sevenwonders.game.moves.MoveType import org.luxons.sevenwonders.game.resources.ResourceTransaction -import org.luxons.sevenwonders.game.resources.bestTransaction +import org.luxons.sevenwonders.game.resources.ResourceTransactions +import org.luxons.sevenwonders.game.resources.Resources +import org.luxons.sevenwonders.game.resources.bestSolution import org.luxons.sevenwonders.game.test.testCustomizableSettings import java.util.HashMap @@ -78,16 +80,19 @@ class GameTest { return PlayerMove(MoveType.DISCARD, firstCardInHand.card.name) } - private fun findResourcesToBuyFor(handCard: HandCard, turnInfo: PlayerTurnInfo): List<ResourceTransaction> { + private fun findResourcesToBuyFor(handCard: HandCard, turnInfo: PlayerTurnInfo): Collection<ResourceTransaction> { if (handCard.isFree) { return emptyList() } val requiredResources = handCard.card.requirements.resources val table = turnInfo.table val playerIndex = turnInfo.playerIndex - val transactions = bestTransaction(requiredResources, PlayerContext(playerIndex, table, listOf())) // we're supposed to have a best transaction plan because the card is playable - return transactions!!.asList() + return bestTransaction(requiredResources, PlayerContext(playerIndex, table, listOf())) + } + + private fun bestTransaction(resources: Resources, player: Player): ResourceTransactions { + return bestSolution(resources, player).possibleTransactions.first() } private fun createPickGuildMove(turnInfo: PlayerTurnInfo): PlayerMove { diff --git a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/boards/BoardTest.kt b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/boards/BoardTest.kt index 68799145..0f2a3e0c 100644 --- a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/boards/BoardTest.kt +++ b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/boards/BoardTest.kt @@ -18,9 +18,9 @@ import org.luxons.sevenwonders.game.effects.RawPointsIncrease import org.luxons.sevenwonders.game.effects.SpecialAbility import org.luxons.sevenwonders.game.effects.SpecialAbilityActivation import org.luxons.sevenwonders.game.resources.ResourceType +import org.luxons.sevenwonders.game.resources.resourcesOf import org.luxons.sevenwonders.game.score.ScoreCategory import org.luxons.sevenwonders.game.test.addCards -import org.luxons.sevenwonders.game.test.createResources import org.luxons.sevenwonders.game.test.getDifferentColorFrom import org.luxons.sevenwonders.game.test.playCardWithEffect import org.luxons.sevenwonders.game.test.singleBoardPlayer @@ -47,7 +47,7 @@ class BoardTest { @Theory fun initialProduction_containsInitialResource(type: ResourceType) { val board = Board(testWonder(type), 0, Settings(5)) - val resources = createResources(type) + val resources = resourcesOf(type) assertTrue(board.production.contains(resources)) assertTrue(board.publicProduction.contains(resources)) } 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 e9f95b55..b8be570f 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 @@ -8,8 +8,8 @@ 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.noTransactions import org.luxons.sevenwonders.game.test.testCard import org.luxons.sevenwonders.game.wonders.Wonder @@ -36,7 +36,7 @@ class CardTest { table.getBoard(0).gold = 3 table.getBoard(1).gold = 3 table.getBoard(2).gold = 3 - treeFarmCard.applyTo(SimplePlayer(0, table), ResourceTransactions()) + treeFarmCard.applyTo(SimplePlayer(0, table), noTransactions()) assertEquals(2, table.getBoard(0).gold.toLong()) assertEquals(3, table.getBoard(1).gold.toLong()) assertEquals(3, table.getBoard(2).gold.toLong()) diff --git a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/cards/RequirementsTest.kt b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/cards/RequirementsTest.kt index 95a5e174..a26034f2 100644 --- a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/cards/RequirementsTest.kt +++ b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/cards/RequirementsTest.kt @@ -10,9 +10,9 @@ import org.junit.runner.RunWith import org.luxons.sevenwonders.game.SimplePlayer import org.luxons.sevenwonders.game.api.Table import org.luxons.sevenwonders.game.resources.Provider -import org.luxons.sevenwonders.game.resources.ResourceTransactions import org.luxons.sevenwonders.game.resources.ResourceType -import org.luxons.sevenwonders.game.resources.Resources +import org.luxons.sevenwonders.game.resources.emptyResources +import org.luxons.sevenwonders.game.resources.noTransactions import org.luxons.sevenwonders.game.test.createRequirements import org.luxons.sevenwonders.game.test.createTransactions import org.luxons.sevenwonders.game.test.singleBoardPlayer @@ -25,14 +25,14 @@ class RequirementsTest { @Test fun getResources_emptyAfterInit() { val (_, resources) = Requirements() - assertTrue(resources.isEmpty) + assertTrue(resources.isEmpty()) } @Test fun setResources_success() { - val resources = Resources() - val (_, resources1) = Requirements(0, resources) - assertSame(resources, resources1) + val resources = emptyResources() + val requirements = Requirements(0, resources) + assertSame(resources, requirements.resources) } @Theory @@ -43,7 +43,7 @@ class RequirementsTest { val player = singleBoardPlayer(board) assertEquals(boardGold >= requiredGold, requirements.areMetWithoutNeighboursBy(board)) - assertEquals(boardGold >= requiredGold, requirements.areMetWithHelpBy(board, ResourceTransactions())) + assertEquals(boardGold >= requiredGold, requirements.areMetWithHelpBy(board, noTransactions())) assertEquals(boardGold >= requiredGold, requirements.areMetBy(player)) } @@ -55,10 +55,7 @@ class RequirementsTest { val player = singleBoardPlayer(board) assertEquals(initialResource == requiredResource, requirements.areMetWithoutNeighboursBy(board)) - assertEquals( - initialResource == requiredResource, - requirements.areMetWithHelpBy(board, ResourceTransactions()) - ) + assertEquals(initialResource == requiredResource, requirements.areMetWithHelpBy(board, noTransactions())) if (initialResource == requiredResource) { assertTrue(requirements.areMetBy(player)) @@ -67,7 +64,8 @@ class RequirementsTest { @Theory fun resourceRequirement_ownProduction( - initialResource: ResourceType, producedResource: ResourceType, + initialResource: ResourceType, + producedResource: ResourceType, requiredResource: ResourceType ) { assumeTrue(initialResource != requiredResource) @@ -79,10 +77,7 @@ class RequirementsTest { val player = singleBoardPlayer(board) assertEquals(producedResource == requiredResource, requirements.areMetWithoutNeighboursBy(board)) - assertEquals( - producedResource == requiredResource, - requirements.areMetWithHelpBy(board, ResourceTransactions()) - ) + assertEquals(producedResource == requiredResource, requirements.areMetWithHelpBy(board, noTransactions())) if (producedResource == requiredResource) { assertTrue(requirements.areMetBy(player)) @@ -91,7 +86,8 @@ class RequirementsTest { @Theory fun resourceRequirement_boughtResource( - initialResource: ResourceType, boughtResource: ResourceType, + initialResource: ResourceType, + boughtResource: ResourceType, requiredResource: ResourceType ) { assumeTrue(initialResource != requiredResource) @@ -108,10 +104,7 @@ class RequirementsTest { assertFalse(requirements.areMetWithoutNeighboursBy(board)) assertEquals(boughtResource == requiredResource, requirements.areMetWithHelpBy(board, resources)) - - if (boughtResource == requiredResource) { - assertTrue(requirements.areMetBy(player)) - } + assertEquals(boughtResource == requiredResource, requirements.areMetBy(player)) } @Theory @@ -125,10 +118,7 @@ class RequirementsTest { val table = Table(Arrays.asList(board, neighbourBoard)) val player = SimplePlayer(0, table) - val transactions = createTransactions( - Provider.RIGHT_PLAYER, - requiredResource - ) + val transactions = createTransactions(Provider.RIGHT_PLAYER, requiredResource) assertFalse(requirements.areMetWithoutNeighboursBy(board)) assertTrue(requirements.areMetWithHelpBy(board, transactions)) diff --git a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/data/serializers/ProductionIncreaseSerializerTest.kt b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/data/serializers/ProductionIncreaseSerializerTest.kt index 5b0a47ab..1b87e593 100644 --- a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/data/serializers/ProductionIncreaseSerializerTest.kt +++ b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/data/serializers/ProductionIncreaseSerializerTest.kt @@ -8,6 +8,7 @@ import org.junit.Assert.assertNull import org.junit.Before import org.junit.Test import org.luxons.sevenwonders.game.effects.ProductionIncrease +import org.luxons.sevenwonders.game.resources.MutableResources import org.luxons.sevenwonders.game.resources.Production import org.luxons.sevenwonders.game.resources.ResourceType import org.luxons.sevenwonders.game.resources.Resources @@ -22,6 +23,7 @@ class ProductionIncreaseSerializerTest { }.type gson = GsonBuilder().registerTypeAdapter(Resources::class.java, ResourcesSerializer()) + .registerTypeAdapter(MutableResources::class.java, ResourcesSerializer()) .registerTypeAdapter(ResourceType::class.java, ResourceTypeSerializer()) .registerTypeAdapter(resourceTypeList, ResourceTypesSerializer()) .registerTypeAdapter(Production::class.java, ProductionSerializer()) diff --git a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/data/serializers/ProductionSerializerTest.kt b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/data/serializers/ProductionSerializerTest.kt index f74e21c5..66d4013a 100644 --- a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/data/serializers/ProductionSerializerTest.kt +++ b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/data/serializers/ProductionSerializerTest.kt @@ -7,6 +7,7 @@ import org.junit.Assert.assertEquals import org.junit.Assert.assertNull import org.junit.Before import org.junit.Test +import org.luxons.sevenwonders.game.resources.MutableResources import org.luxons.sevenwonders.game.resources.Production import org.luxons.sevenwonders.game.resources.ResourceType import org.luxons.sevenwonders.game.resources.Resources @@ -17,10 +18,9 @@ class ProductionSerializerTest { @Before fun setUp() { - val resourceTypeList = object : TypeToken<List<ResourceType>>() { - - }.type + val resourceTypeList = object : TypeToken<List<ResourceType>>() {}.type gson = GsonBuilder().registerTypeAdapter(Resources::class.java, ResourcesSerializer()) + .registerTypeAdapter(MutableResources::class.java, ResourcesSerializer()) .registerTypeAdapter(ResourceType::class.java, ResourceTypeSerializer()) .registerTypeAdapter(resourceTypeList, ResourceTypesSerializer()) .registerTypeAdapter(Production::class.java, ProductionSerializer()) diff --git a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/data/serializers/ResourcesSerializerTest.kt b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/data/serializers/ResourcesSerializerTest.kt index 500c2666..426e0f0e 100644 --- a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/data/serializers/ResourcesSerializerTest.kt +++ b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/data/serializers/ResourcesSerializerTest.kt @@ -6,8 +6,11 @@ import org.junit.Assert.assertEquals import org.junit.Assert.assertNull import org.junit.Before import org.junit.Test -import org.luxons.sevenwonders.game.resources.ResourceType +import org.luxons.sevenwonders.game.resources.MutableResources +import org.luxons.sevenwonders.game.resources.ResourceType.* import org.luxons.sevenwonders.game.resources.Resources +import org.luxons.sevenwonders.game.resources.emptyResources +import org.luxons.sevenwonders.game.resources.resourcesOf class ResourcesSerializerTest { @@ -15,7 +18,10 @@ class ResourcesSerializerTest { @Before fun setUp() { - gson = GsonBuilder().registerTypeAdapter(Resources::class.java, ResourcesSerializer()).create() + gson = GsonBuilder() + .registerTypeAdapter(Resources::class.java, ResourcesSerializer()) + .registerTypeAdapter(MutableResources::class.java, ResourcesSerializer()) + .create() } @Test @@ -25,40 +31,31 @@ class ResourcesSerializerTest { @Test fun serialize_emptyResourcesToNull() { - val resources = Resources() + val resources = emptyResources() assertEquals("null", gson!!.toJson(resources)) } @Test fun serialize_singleType() { - val resources = Resources() - resources.add(ResourceType.WOOD, 1) + val resources = resourcesOf(WOOD) assertEquals("\"W\"", gson!!.toJson(resources)) } @Test fun serialize_multipleTimesSameType() { - val resources = Resources() - resources.add(ResourceType.WOOD, 3) + val resources = resourcesOf(WOOD to 3) assertEquals("\"WWW\"", gson!!.toJson(resources)) } @Test fun serialize_mixedTypes() { - val resources = Resources() - resources.add(ResourceType.WOOD, 1) - resources.add(ResourceType.STONE, 1) - resources.add(ResourceType.CLAY, 1) + val resources = resourcesOf(WOOD, STONE, CLAY) assertEquals("\"WSC\"", gson!!.toJson(resources)) } @Test fun serialize_mixedTypes_unordered() { - val resources = Resources() - resources.add(ResourceType.CLAY, 1) - resources.add(ResourceType.WOOD, 2) - resources.add(ResourceType.CLAY, 1) - resources.add(ResourceType.STONE, 1) + val resources = resourcesOf(CLAY to 1, WOOD to 2, CLAY to 1, STONE to 1) assertEquals("\"CCWWS\"", gson!!.toJson(resources)) } @@ -69,39 +66,31 @@ class ResourcesSerializerTest { @Test fun deserialize_emptyList() { - val resources = Resources() + val resources = emptyResources() assertEquals(resources, gson!!.fromJson("\"\"", Resources::class.java)) } @Test fun deserialize_singleType() { - val resources = Resources() - resources.add(ResourceType.WOOD, 1) + val resources = resourcesOf(WOOD) assertEquals(resources, gson!!.fromJson("\"W\"", Resources::class.java)) } @Test fun deserialize_multipleTimesSameType() { - val resources = Resources() - resources.add(ResourceType.WOOD, 3) + val resources = resourcesOf(WOOD to 3) assertEquals(resources, gson!!.fromJson("\"WWW\"", Resources::class.java)) } @Test fun deserialize_mixedTypes() { - val resources = Resources() - resources.add(ResourceType.WOOD, 1) - resources.add(ResourceType.CLAY, 1) - resources.add(ResourceType.STONE, 1) + val resources = resourcesOf(WOOD, CLAY, STONE) assertEquals(resources, gson!!.fromJson("\"WCS\"", Resources::class.java)) } @Test fun deserialize_mixedTypes_unordered() { - val resources = Resources() - resources.add(ResourceType.WOOD, 1) - resources.add(ResourceType.CLAY, 2) - resources.add(ResourceType.STONE, 3) + val resources = resourcesOf(WOOD to 1, CLAY to 2, STONE to 3) assertEquals(resources, gson!!.fromJson("\"SCWCSS\"", Resources::class.java)) } } 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 index 9d5be34f..7973131c 100644 --- 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 @@ -7,7 +7,7 @@ import org.junit.experimental.theories.Theory import org.junit.runner.RunWith import org.luxons.sevenwonders.game.SimplePlayer import org.luxons.sevenwonders.game.resources.ResourceType -import org.luxons.sevenwonders.game.test.createResources +import org.luxons.sevenwonders.game.resources.resourcesOf import org.luxons.sevenwonders.game.test.fixedProduction import org.luxons.sevenwonders.game.test.testBoard import org.luxons.sevenwonders.game.test.testTable @@ -26,11 +26,11 @@ class ProductionIncreaseTest { effect.applyTo(board) - val resources = createResources(initialType, addedType) + val resources = resourcesOf(initialType, addedType) assertTrue(board.production.contains(resources)) assertFalse(board.publicProduction.contains(resources)) - val moreResources = createResources(initialType, addedType, extraType) + val moreResources = resourcesOf(initialType, addedType, extraType) assertFalse(board.production.contains(moreResources)) assertFalse(board.publicProduction.contains(moreResources)) } @@ -46,11 +46,11 @@ class ProductionIncreaseTest { effect.applyTo(board) - val resources = createResources(initialType, addedType) + val resources = resourcesOf(initialType, addedType) assertTrue(board.production.contains(resources)) assertTrue(board.publicProduction.contains(resources)) - val moreResources = createResources(initialType, addedType, extraType) + val moreResources = resourcesOf(initialType, addedType, extraType) assertFalse(board.production.contains(moreResources)) assertFalse(board.publicProduction.contains(moreResources)) } diff --git a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/resources/BestPriceCalculatorTest.kt b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/resources/BestPriceCalculatorTest.kt index ca279d97..67537644 100644 --- a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/resources/BestPriceCalculatorTest.kt +++ b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/resources/BestPriceCalculatorTest.kt @@ -7,7 +7,6 @@ import org.luxons.sevenwonders.game.api.Table import org.luxons.sevenwonders.game.resources.Provider.LEFT_PLAYER import org.luxons.sevenwonders.game.resources.Provider.RIGHT_PLAYER import org.luxons.sevenwonders.game.resources.ResourceType.* -import org.luxons.sevenwonders.game.test.createResources import org.luxons.sevenwonders.game.test.createTransaction import org.luxons.sevenwonders.game.test.createTransactions import org.luxons.sevenwonders.game.test.testBoard @@ -16,13 +15,16 @@ import java.util.Arrays class BestPriceCalculatorTest { + private fun solutions(price: Int, vararg resourceTransactions: ResourceTransactions) = + TransactionPlan(price, setOf(*resourceTransactions)) + @Test fun bestPrice_0forEmptyResources() { val table = testTable(3) val player0 = SimplePlayer(0, table) - val emptyResources = Resources() - val emptyTransactions = ResourceTransactions() - assertEquals(TransactionPlan(0, emptyTransactions), bestSolution(emptyResources, player0)) + val emptyResources = emptyResources() + val emptyTransactions = noTransactions() + assertEquals(solutions(0, emptyTransactions), bestSolution(emptyResources, player0)) } @Test @@ -31,12 +33,12 @@ class BestPriceCalculatorTest { val main = testBoard(STONE) val right = testBoard(WOOD) val table = Table(Arrays.asList(main, right, left)) - + val player0 = SimplePlayer(0, table) val player1 = SimplePlayer(1, table) val player2 = SimplePlayer(2, table) - val resources = createResources(STONE, STONE) + val resources = resourcesOf(STONE, STONE) val stoneLeftSingle = createTransaction(LEFT_PLAYER, STONE) val stoneRightSingle = createTransaction(RIGHT_PLAYER, STONE) @@ -45,9 +47,9 @@ class BestPriceCalculatorTest { val stoneRight = createTransactions(stoneRightSingle) val stoneLeftAndRight = createTransactions(stoneLeftSingle, stoneRightSingle) - assertEquals(TransactionPlan(2, stoneLeft), bestSolution(resources, player0)) - assertEquals(TransactionPlan(4, stoneLeftAndRight), bestSolution(resources, player1)) - assertEquals(TransactionPlan(2, stoneRight), bestSolution(resources, player2)) + assertEquals(solutions(2, stoneLeft), bestSolution(resources, player0)) + assertEquals(solutions(4, stoneLeftAndRight), bestSolution(resources, player1)) + assertEquals(solutions(2, stoneRight), bestSolution(resources, player2)) } @Test @@ -65,15 +67,15 @@ class BestPriceCalculatorTest { val player2 = SimplePlayer(2, table) val player3 = SimplePlayer(3, table) - val resources = createResources(WOOD) + val resources = resourcesOf(WOOD) val woodLeft = createTransactions(LEFT_PLAYER, WOOD) val woodRight = createTransactions(RIGHT_PLAYER, WOOD) - assertEquals(TransactionPlan(1, woodRight), bestSolution(resources, player0)) - assertEquals(TransactionPlan(0, ResourceTransactions()), bestSolution(resources, player1)) - assertEquals(TransactionPlan(2, woodLeft), bestSolution(resources, player2)) - assertEquals(TransactionPlan(0, ResourceTransactions()), bestSolution(resources, player3)) + assertEquals(solutions(1, woodRight), bestSolution(resources, player0)) + assertEquals(solutions(0, noTransactions()), bestSolution(resources, player1)) + assertEquals(solutions(2, woodLeft, woodRight), bestSolution(resources, player2)) + assertEquals(solutions(0, noTransactions()), bestSolution(resources, player3)) } @Test @@ -93,12 +95,12 @@ class BestPriceCalculatorTest { val player1 = SimplePlayer(1, table) val player2 = SimplePlayer(2, table) - val resources = createResources(WOOD) + val resources = resourcesOf(WOOD) val woodRight = createTransactions(RIGHT_PLAYER, WOOD) - assertEquals(TransactionPlan(1, woodRight), bestSolution(resources, player0)) - assertEquals(TransactionPlan(0, ResourceTransactions()), bestSolution(resources, player1)) - assertEquals(TransactionPlan(0, ResourceTransactions()), bestSolution(resources, player2)) + assertEquals(solutions(1, woodRight), bestSolution(resources, player0)) + assertEquals(solutions(0, noTransactions()), bestSolution(resources, player1)) + assertEquals(solutions(0, noTransactions()), bestSolution(resources, player2)) } @Test @@ -121,12 +123,12 @@ class BestPriceCalculatorTest { val player1 = SimplePlayer(1, table) val player2 = SimplePlayer(2, table) - val resources = createResources(ORE, CLAY) + val resources = resourcesOf(ORE, CLAY) val oreAndClayLeft = createTransactions(LEFT_PLAYER, ORE, CLAY) val clayRight = createTransactions(RIGHT_PLAYER, CLAY) - assertEquals(TransactionPlan(1, clayRight), bestSolution(resources, player0)) - assertEquals(TransactionPlan(0, ResourceTransactions()), bestSolution(resources, player1)) - assertEquals(TransactionPlan(4, oreAndClayLeft), bestSolution(resources, player2)) + assertEquals(solutions(1, clayRight), bestSolution(resources, player0)) + assertEquals(solutions(0, noTransactions()), bestSolution(resources, player1)) + assertEquals(solutions(4, oreAndClayLeft), bestSolution(resources, player2)) } } diff --git a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/resources/ProductionTest.kt b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/resources/ProductionTest.kt index 92623a2b..79be288f 100644 --- a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/resources/ProductionTest.kt +++ b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/resources/ProductionTest.kt @@ -3,38 +3,27 @@ package org.luxons.sevenwonders.game.resources import org.junit.Assert.* import org.junit.Before import org.junit.Test +import org.luxons.sevenwonders.game.resources.ResourceType.* import java.util.EnumSet import java.util.HashSet class ProductionTest { - private var emptyResources: Resources = Resources() - private var resources1Wood: Resources = Resources() - private var resources1Stone: Resources = Resources() - private var resources1Stone1Wood: Resources = Resources() - private var resources2Stones: Resources = Resources() - private var resources2Stones3Clay: Resources = Resources() + private lateinit var emptyResources: Resources + private lateinit var resources1Wood: Resources + private lateinit var resources1Stone: Resources + private lateinit var resources1Stone1Wood: Resources + private lateinit var resources2Stones: Resources + private lateinit var resources2Stones3Clay: Resources @Before fun init() { - emptyResources = Resources() - - resources1Wood = Resources() - resources1Wood.add(ResourceType.WOOD, 1) - - resources1Stone = Resources() - resources1Stone.add(ResourceType.STONE, 1) - - resources1Stone1Wood = Resources() - resources1Stone1Wood.add(ResourceType.STONE, 1) - resources1Stone1Wood.add(ResourceType.WOOD, 1) - - resources2Stones = Resources() - resources2Stones.add(ResourceType.STONE, 2) - - resources2Stones3Clay = Resources() - resources2Stones3Clay.add(ResourceType.STONE, 2) - resources2Stones3Clay.add(ResourceType.CLAY, 3) + emptyResources = emptyResources() + resources1Wood = resourcesOf(WOOD) + resources1Stone = resourcesOf(STONE) + resources1Stone1Wood = resourcesOf(STONE to 1, WOOD to 1) + resources2Stones = resourcesOf(STONE to 2) + resources2Stones3Clay = resourcesOf(STONE to 2, CLAY to 3) } @Test @@ -52,67 +41,67 @@ class ProductionTest { @Test fun contains_singleFixedResource_notEnough() { val production = Production() - production.addFixedResource(ResourceType.STONE, 1) + production.addFixedResource(STONE, 1) assertFalse(production.contains(resources2Stones)) } @Test fun contains_singleFixedResource_justEnough() { val production = Production() - production.addFixedResource(ResourceType.STONE, 2) + production.addFixedResource(STONE, 2) assertTrue(production.contains(resources2Stones)) } @Test fun contains_singleFixedResource_moreThanEnough() { val production = Production() - production.addFixedResource(ResourceType.STONE, 3) + production.addFixedResource(STONE, 3) assertTrue(production.contains(resources2Stones)) } @Test fun contains_singleFixedResource_moreThanEnough_amongOthers() { val production = Production() - production.addFixedResource(ResourceType.STONE, 3) - production.addFixedResource(ResourceType.CLAY, 2) + production.addFixedResource(STONE, 3) + production.addFixedResource(CLAY, 2) assertTrue(production.contains(resources2Stones)) } @Test fun contains_multipleFixedResources_notEnoughOfOne() { val production = Production() - production.addFixedResource(ResourceType.STONE, 3) - production.addFixedResource(ResourceType.CLAY, 1) + production.addFixedResource(STONE, 3) + production.addFixedResource(CLAY, 1) assertFalse(production.contains(resources2Stones3Clay)) } @Test fun contains_multipleFixedResources_notEnoughOfBoth() { val production = Production() - production.addFixedResource(ResourceType.STONE, 1) - production.addFixedResource(ResourceType.CLAY, 1) + production.addFixedResource(STONE, 1) + production.addFixedResource(CLAY, 1) assertFalse(production.contains(resources2Stones3Clay)) } @Test fun contains_multipleFixedResources_moreThanEnough() { val production = Production() - production.addFixedResource(ResourceType.STONE, 3) - production.addFixedResource(ResourceType.CLAY, 5) + production.addFixedResource(STONE, 3) + production.addFixedResource(CLAY, 5) assertTrue(production.contains(resources2Stones3Clay)) } @Test fun contains_singleChoice_containsEmpty() { val production = Production() - production.addChoice(ResourceType.STONE, ResourceType.CLAY) + production.addChoice(STONE, CLAY) assertTrue(production.contains(emptyResources)) } @Test fun contains_singleChoice_enough() { val production = Production() - production.addChoice(ResourceType.STONE, ResourceType.WOOD) + production.addChoice(STONE, WOOD) assertTrue(production.contains(resources1Wood)) assertTrue(production.contains(resources1Stone)) } @@ -120,42 +109,42 @@ class ProductionTest { @Test fun contains_multipleChoices_notBoth() { val production = Production() - production.addChoice(ResourceType.STONE, ResourceType.CLAY) - production.addChoice(ResourceType.STONE, ResourceType.CLAY) - production.addChoice(ResourceType.STONE, ResourceType.CLAY) + production.addChoice(STONE, CLAY) + production.addChoice(STONE, CLAY) + production.addChoice(STONE, CLAY) assertFalse(production.contains(resources2Stones3Clay)) } @Test fun contains_multipleChoices_enough() { val production = Production() - production.addChoice(ResourceType.STONE, ResourceType.ORE) - production.addChoice(ResourceType.STONE, ResourceType.WOOD) + production.addChoice(STONE, ORE) + production.addChoice(STONE, WOOD) assertTrue(production.contains(resources1Stone1Wood)) } @Test fun contains_multipleChoices_enoughReverseOrder() { val production = Production() - production.addChoice(ResourceType.STONE, ResourceType.WOOD) - production.addChoice(ResourceType.STONE, ResourceType.ORE) + production.addChoice(STONE, WOOD) + production.addChoice(STONE, ORE) assertTrue(production.contains(resources1Stone1Wood)) } @Test fun contains_multipleChoices_moreThanEnough() { val production = Production() - production.addChoice(ResourceType.LOOM, ResourceType.GLASS, ResourceType.PAPYRUS) - production.addChoice(ResourceType.STONE, ResourceType.ORE) - production.addChoice(ResourceType.STONE, ResourceType.WOOD) + production.addChoice(LOOM, GLASS, PAPYRUS) + production.addChoice(STONE, ORE) + production.addChoice(STONE, WOOD) assertTrue(production.contains(resources1Stone1Wood)) } @Test fun contains_mixedFixedAndChoice_enough() { val production = Production() - production.addFixedResource(ResourceType.WOOD, 1) - production.addChoice(ResourceType.STONE, ResourceType.WOOD) + production.addFixedResource(WOOD, 1) + production.addChoice(STONE, WOOD) assertTrue(production.contains(resources1Stone1Wood)) } @@ -194,8 +183,8 @@ class ProductionTest { @Test fun addAll_production_multipleChoices() { val production = Production() - production.addChoice(ResourceType.STONE, ResourceType.WOOD) - production.addChoice(ResourceType.STONE, ResourceType.ORE) + production.addChoice(STONE, WOOD) + production.addChoice(STONE, ORE) val production2 = Production() production2.addAll(production) @@ -205,8 +194,8 @@ class ProductionTest { @Test fun addAll_production_mixedFixedResourcesAndChoices() { val production = Production() - production.addFixedResource(ResourceType.WOOD, 1) - production.addChoice(ResourceType.STONE, ResourceType.WOOD) + production.addFixedResource(WOOD, 1) + production.addChoice(STONE, WOOD) val production2 = Production() production2.addAll(production) @@ -223,22 +212,22 @@ class ProductionTest { @Test fun asChoices_onlyChoices() { val production = Production() - production.addChoice(ResourceType.STONE, ResourceType.WOOD) - production.addChoice(ResourceType.STONE, ResourceType.ORE) - production.addChoice(ResourceType.CLAY, ResourceType.LOOM, ResourceType.GLASS) + production.addChoice(STONE, WOOD) + production.addChoice(STONE, ORE) + production.addChoice(CLAY, LOOM, GLASS) assertEquals(production.getAlternativeResources(), production.asChoices()) } @Test fun asChoices_onlyFixed() { val production = Production() - production.addFixedResource(ResourceType.WOOD, 1) - production.addFixedResource(ResourceType.CLAY, 2) + production.addFixedResource(WOOD, 1) + production.addFixedResource(CLAY, 2) val expected = HashSet<Set<ResourceType>>() - expected.add(EnumSet.of(ResourceType.WOOD)) - expected.add(EnumSet.of(ResourceType.CLAY)) - expected.add(EnumSet.of(ResourceType.CLAY)) + expected.add(EnumSet.of(WOOD)) + expected.add(EnumSet.of(CLAY)) + expected.add(EnumSet.of(CLAY)) assertEquals(expected, production.asChoices()) } @@ -246,17 +235,17 @@ class ProductionTest { @Test fun asChoices_mixed() { val production = Production() - production.addChoice(ResourceType.STONE, ResourceType.ORE) - production.addChoice(ResourceType.CLAY, ResourceType.LOOM, ResourceType.GLASS) - production.addFixedResource(ResourceType.WOOD, 1) - production.addFixedResource(ResourceType.CLAY, 2) + production.addChoice(STONE, ORE) + production.addChoice(CLAY, LOOM, GLASS) + production.addFixedResource(WOOD, 1) + production.addFixedResource(CLAY, 2) val expected = HashSet<Set<ResourceType>>() - expected.add(EnumSet.of(ResourceType.STONE, ResourceType.ORE)) - expected.add(EnumSet.of(ResourceType.CLAY, ResourceType.LOOM, ResourceType.GLASS)) - expected.add(EnumSet.of(ResourceType.WOOD)) - expected.add(EnumSet.of(ResourceType.CLAY)) - expected.add(EnumSet.of(ResourceType.CLAY)) + expected.add(EnumSet.of(STONE, ORE)) + expected.add(EnumSet.of(CLAY, LOOM, GLASS)) + expected.add(EnumSet.of(WOOD)) + expected.add(EnumSet.of(CLAY)) + expected.add(EnumSet.of(CLAY)) assertEquals(expected, production.asChoices()) } @@ -272,11 +261,11 @@ class ProductionTest { val production1 = Production() val production2 = Production() assertTrue(production1 == production2) - production1.addFixedResource(ResourceType.GLASS, 1) - production2.addFixedResource(ResourceType.GLASS, 1) + production1.addFixedResource(GLASS, 1) + production2.addFixedResource(GLASS, 1) assertTrue(production1 == production2) - production1.addChoice(ResourceType.ORE, ResourceType.WOOD) - production2.addChoice(ResourceType.ORE, ResourceType.WOOD) + production1.addChoice(ORE, WOOD) + production2.addChoice(ORE, WOOD) assertTrue(production1 == production2) } @@ -285,11 +274,11 @@ class ProductionTest { val production1 = Production() val production2 = Production() assertEquals(production1.hashCode().toLong(), production2.hashCode().toLong()) - production1.addFixedResource(ResourceType.GLASS, 1) - production2.addFixedResource(ResourceType.GLASS, 1) + production1.addFixedResource(GLASS, 1) + production2.addFixedResource(GLASS, 1) assertEquals(production1.hashCode().toLong(), production2.hashCode().toLong()) - production1.addChoice(ResourceType.ORE, ResourceType.WOOD) - production2.addChoice(ResourceType.ORE, ResourceType.WOOD) + production1.addChoice(ORE, WOOD) + production2.addChoice(ORE, WOOD) assertEquals(production1.hashCode().toLong(), production2.hashCode().toLong()) } } diff --git a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/resources/ResourceTransactionsTest.kt b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/resources/ResourceTransactionsTest.kt index 26ab16fa..172df278 100644 --- a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/resources/ResourceTransactionsTest.kt +++ b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/resources/ResourceTransactionsTest.kt @@ -2,31 +2,25 @@ package org.luxons.sevenwonders.game.resources import org.junit.Assert.assertEquals import org.junit.Test +import org.luxons.sevenwonders.game.resources.ResourceType.CLAY +import org.luxons.sevenwonders.game.resources.ResourceType.WOOD import org.luxons.sevenwonders.game.test.createTransaction +import org.luxons.sevenwonders.game.test.of class ResourceTransactionsTest { @Test fun toTransactions() { - val transactionList = listOf( - createTransaction(Provider.LEFT_PLAYER, ResourceType.WOOD), - createTransaction(Provider.LEFT_PLAYER, ResourceType.CLAY), - createTransaction(Provider.RIGHT_PLAYER, ResourceType.WOOD) + val transactionMap = mapOf( + Provider.LEFT_PLAYER to (1 of WOOD) + (1 of CLAY), + Provider.RIGHT_PLAYER to (1 of WOOD) ) - val transactions = ResourceTransactions(transactionList) - val expectedNormalized = setOf( - createTransaction(Provider.LEFT_PLAYER, ResourceType.WOOD, ResourceType.CLAY), - createTransaction(Provider.RIGHT_PLAYER, ResourceType.WOOD) + createTransaction(Provider.LEFT_PLAYER, WOOD, CLAY), + createTransaction(Provider.RIGHT_PLAYER, WOOD) ) - assertEquals(expectedNormalized, transactions.asList().toSet()) - } - - @Test(expected = IllegalStateException::class) - fun remove_failsIfNoResourceForThatProvider() { - val transactions = ResourceTransactions() - transactions.remove(Provider.LEFT_PLAYER, Resources(ResourceType.WOOD)) + assertEquals(expectedNormalized, transactionMap.toTransactions().toSet()) } } diff --git a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/resources/ResourcesTest.kt b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/resources/ResourcesTest.kt index a6ffb6c6..9fa0bc55 100644 --- a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/resources/ResourcesTest.kt +++ b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/resources/ResourcesTest.kt @@ -4,6 +4,7 @@ import org.junit.Assert.* import org.junit.Rule import org.junit.Test import org.junit.rules.ExpectedException +import org.luxons.sevenwonders.game.resources.ResourceType.* import java.util.NoSuchElementException class ResourcesTest { @@ -14,503 +15,417 @@ class ResourcesTest { @Test fun init_shouldBeEmpty() { - val resources = Resources() - for (resourceType in ResourceType.values()) { - assertEquals(0, resources.getQuantity(resourceType).toLong()) + val resources = emptyResources() + for (resourceType in values()) { + assertEquals(0, resources[resourceType]) } - assertEquals(0, resources.size().toLong()) - assertTrue(resources.isEmpty) + assertEquals(0, resources.size) + assertTrue(resources.isEmpty()) } @Test fun add_zero() { - val resources = Resources() - resources.add(ResourceType.CLAY, 0) - assertEquals(0, resources.getQuantity(ResourceType.CLAY).toLong()) - assertEquals(0, resources.size().toLong()) - assertTrue(resources.isEmpty) + val resources = mutableResourcesOf() + resources.add(CLAY, 0) + assertEquals(0, resources[CLAY]) + assertEquals(0, resources.size) + assertTrue(resources.isEmpty()) } @Test fun add_simple() { - val resources = Resources() - resources.add(ResourceType.WOOD, 3) - assertEquals(3, resources.getQuantity(ResourceType.WOOD).toLong()) - assertEquals(3, resources.size().toLong()) - assertFalse(resources.isEmpty) + val resources = mutableResourcesOf() + resources.add(WOOD, 3) + assertEquals(3, resources[WOOD]) + assertEquals(3, resources.size) + assertFalse(resources.isEmpty()) } @Test fun add_multipleCallsStacked() { - val resources = Resources() - resources.add(ResourceType.ORE, 3) - resources.add(ResourceType.ORE, 2) - assertEquals(5, resources.getQuantity(ResourceType.ORE).toLong()) - assertEquals(5, resources.size().toLong()) - assertFalse(resources.isEmpty) + val resources = mutableResourcesOf() + resources.add(ORE, 3) + resources.add(ORE, 2) + assertEquals(5, resources[ORE]) + assertEquals(5, resources.size) + assertFalse(resources.isEmpty()) } @Test fun add_interlaced() { - val resources = Resources() - resources.add(ResourceType.GLASS, 3) - resources.add(ResourceType.STONE, 1) - resources.add(ResourceType.WOOD, 4) - resources.add(ResourceType.GLASS, 2) - assertEquals(5, resources.getQuantity(ResourceType.GLASS).toLong()) - assertEquals(10, resources.size().toLong()) - assertFalse(resources.isEmpty) + val resources = mutableResourcesOf() + resources.add(GLASS, 3) + resources.add(STONE, 1) + resources.add(WOOD, 4) + resources.add(GLASS, 2) + assertEquals(5, resources[GLASS]) + assertEquals(10, resources.size) + assertFalse(resources.isEmpty()) } @Test fun plus_zero() { - val resources = Resources(mapOf(ResourceType.CLAY to 2)) - val resourcesPlusZero = resources + Resources() - val zeroPlusResources = Resources() + resources + val resources = resourcesOf(CLAY to 2) + val resourcesPlusZero = resources + emptyResources() + val zeroPlusResources = emptyResources() + resources - assertEquals(2, resourcesPlusZero.getQuantity(ResourceType.CLAY)) - assertEquals(2, resourcesPlusZero.size()) - assertEquals(2, zeroPlusResources.getQuantity(ResourceType.CLAY)) - assertEquals(2, zeroPlusResources.size()) + assertEquals(2, resourcesPlusZero[CLAY]) + assertEquals(2, resourcesPlusZero.size) + assertEquals(2, zeroPlusResources[CLAY]) + assertEquals(2, zeroPlusResources.size) } @Test fun plus_sameResource() { - val resources1 = Resources(mapOf(ResourceType.WOOD to 1)) - val resources2 = Resources(mapOf(ResourceType.WOOD to 3)) + val resources1 = resourcesOf(WOOD to 1) + val resources2 = resourcesOf(WOOD to 3) val sum = resources1 + resources2 - assertEquals(4, sum.getQuantity(ResourceType.WOOD).toLong()) - assertEquals(4, sum.size()) + assertEquals(1, resources1.size) + assertEquals(3, resources2.size) + assertEquals(4, sum[WOOD]) + assertEquals(4, sum.size) } @Test - fun plus_differentResources() { - val resources1 = Resources(mapOf(ResourceType.WOOD to 1)) - val resources2 = Resources(mapOf(ResourceType.ORE to 3)) + fun plus_differentemptyResources() { + val resources1 = resourcesOf(WOOD to 1) + val resources2 = resourcesOf(ORE to 3) val sum = resources1 + resources2 - assertEquals(1, sum.getQuantity(ResourceType.WOOD).toLong()) - assertEquals(3, sum.getQuantity(ResourceType.ORE).toLong()) - assertEquals(4, sum.size()) + assertEquals(1, resources1.size) + assertEquals(3, resources2.size) + assertEquals(1, sum[WOOD]) + assertEquals(3, sum[ORE]) + assertEquals(4, sum.size) } @Test - fun plus_overlappingResources() { - val resources1 = Resources(mapOf(ResourceType.WOOD to 1)) - val resources2 = Resources(mapOf(ResourceType.WOOD to 2, ResourceType.ORE to 4)) + fun plus_overlappingemptyResources() { + val resources1 = resourcesOf(WOOD to 1) + val resources2 = resourcesOf(WOOD to 2, ORE to 4) val sum = resources1 + resources2 - assertEquals(3, sum.getQuantity(ResourceType.WOOD).toLong()) - assertEquals(4, sum.getQuantity(ResourceType.ORE).toLong()) - assertEquals(7, sum.size()) + assertEquals(1, resources1.size) + assertEquals(6, resources2.size) + assertEquals(3, sum[WOOD]) + assertEquals(4, sum[ORE]) + assertEquals(7, sum.size) } @Test fun remove_some() { - val resources = Resources() - resources.add(ResourceType.WOOD, 3) - resources.remove(ResourceType.WOOD, 2) - assertEquals(1, resources.getQuantity(ResourceType.WOOD).toLong()) - assertEquals(1, resources.size().toLong()) - assertFalse(resources.isEmpty) + val resources = mutableResourcesOf(WOOD to 3) + resources.remove(WOOD, 2) + assertEquals(1, resources[WOOD]) + assertEquals(1, resources.size) + assertFalse(resources.isEmpty()) } @Test fun remove_all() { - val resources = Resources() - resources.add(ResourceType.WOOD, 3) - resources.remove(ResourceType.WOOD, 3) - assertEquals(0, resources.getQuantity(ResourceType.WOOD).toLong()) - assertEquals(0, resources.size().toLong()) - assertTrue(resources.isEmpty) + val resources = mutableResourcesOf(WOOD to 3) + resources.remove(WOOD, 3) + assertEquals(0, resources[WOOD]) + assertEquals(0, resources.size) + assertTrue(resources.isEmpty()) } @Test fun remove_tooMany() { - val resources = Resources() - resources.add(ResourceType.WOOD, 2) + val resources = mutableResourcesOf(WOOD to 2) thrown.expect(NoSuchElementException::class.java) - resources.remove(ResourceType.WOOD, 3) + resources.remove(WOOD, 3) } @Test fun addAll_empty() { - val resources = Resources() - resources.add(ResourceType.STONE, 1) - resources.add(ResourceType.CLAY, 3) + val resources = mutableResourcesOf(STONE to 1, CLAY to 3) - val emptyResources = Resources() + val emptyResources = emptyResources() - resources.addAll(emptyResources) - assertEquals(1, resources.getQuantity(ResourceType.STONE).toLong()) - assertEquals(3, resources.getQuantity(ResourceType.CLAY).toLong()) - assertEquals(0, resources.getQuantity(ResourceType.ORE).toLong()) - assertEquals(0, resources.getQuantity(ResourceType.GLASS).toLong()) - assertEquals(0, resources.getQuantity(ResourceType.LOOM).toLong()) - assertEquals(4, resources.size().toLong()) - assertFalse(resources.isEmpty) + resources.add(emptyResources) + assertEquals(1, resources[STONE]) + assertEquals(3, resources[CLAY]) + assertEquals(0, resources[ORE]) + assertEquals(0, resources[GLASS]) + assertEquals(0, resources[LOOM]) + assertEquals(4, resources.size) + assertFalse(resources.isEmpty()) } @Test fun addAll_zeros() { - val resources = Resources() - resources.add(ResourceType.STONE, 1) - resources.add(ResourceType.CLAY, 3) + val resources = mutableResourcesOf(STONE to 1, CLAY to 3) - val emptyResources = Resources() - emptyResources.add(ResourceType.STONE, 0) - emptyResources.add(ResourceType.CLAY, 0) + val emptyResources = resourcesOf(STONE to 0, CLAY to 0) - resources.addAll(emptyResources) - assertEquals(1, resources.getQuantity(ResourceType.STONE).toLong()) - assertEquals(3, resources.getQuantity(ResourceType.CLAY).toLong()) - assertEquals(0, resources.getQuantity(ResourceType.ORE).toLong()) - assertEquals(0, resources.getQuantity(ResourceType.GLASS).toLong()) - assertEquals(0, resources.getQuantity(ResourceType.LOOM).toLong()) - assertEquals(4, resources.size().toLong()) - assertFalse(resources.isEmpty) + resources.add(emptyResources) + assertEquals(1, resources[STONE]) + assertEquals(3, resources[CLAY]) + assertEquals(0, resources[ORE]) + assertEquals(0, resources[GLASS]) + assertEquals(0, resources[LOOM]) + assertEquals(4, resources.size) + assertFalse(resources.isEmpty()) } @Test fun addAll_same() { - val resources = Resources() - resources.add(ResourceType.STONE, 1) - resources.add(ResourceType.CLAY, 3) + val resources = mutableResourcesOf(STONE to 1, CLAY to 3) + val resources2 = resourcesOf(STONE to 2, CLAY to 6) - val resources2 = Resources() - resources.add(ResourceType.STONE, 2) - resources.add(ResourceType.CLAY, 6) - - resources.addAll(resources2) - assertEquals(3, resources.getQuantity(ResourceType.STONE).toLong()) - assertEquals(9, resources.getQuantity(ResourceType.CLAY).toLong()) - assertEquals(0, resources.getQuantity(ResourceType.ORE).toLong()) - assertEquals(0, resources.getQuantity(ResourceType.GLASS).toLong()) - assertEquals(0, resources.getQuantity(ResourceType.LOOM).toLong()) - assertEquals(12, resources.size().toLong()) - assertFalse(resources.isEmpty) + resources.add(resources2) + assertEquals(3, resources[STONE]) + assertEquals(9, resources[CLAY]) + assertEquals(0, resources[ORE]) + assertEquals(0, resources[GLASS]) + assertEquals(0, resources[LOOM]) + assertEquals(12, resources.size) + assertFalse(resources.isEmpty()) } @Test fun addAll_overlap() { - val resources = Resources() - resources.add(ResourceType.STONE, 1) - resources.add(ResourceType.CLAY, 3) - - val resources2 = Resources() - resources.add(ResourceType.CLAY, 6) - resources.add(ResourceType.ORE, 4) + val resources = mutableResourcesOf(STONE to 1, CLAY to 3) + val resources2 = resourcesOf(CLAY to 6, ORE to 4) - resources.addAll(resources2) - assertEquals(1, resources.getQuantity(ResourceType.STONE).toLong()) - assertEquals(9, resources.getQuantity(ResourceType.CLAY).toLong()) - assertEquals(4, resources.getQuantity(ResourceType.ORE).toLong()) - assertEquals(0, resources.getQuantity(ResourceType.GLASS).toLong()) - assertEquals(0, resources.getQuantity(ResourceType.LOOM).toLong()) - assertEquals(14, resources.size().toLong()) - assertFalse(resources.isEmpty) + resources.add(resources2) + assertEquals(1, resources[STONE]) + assertEquals(9, resources[CLAY]) + assertEquals(4, resources[ORE]) + assertEquals(0, resources[GLASS]) + assertEquals(0, resources[LOOM]) + assertEquals(14, resources.size) + assertFalse(resources.isEmpty()) } @Test fun contains_emptyContainsEmpty() { - val emptyResources = Resources() - val emptyResources2 = Resources() + val emptyResources = emptyResources() + val emptyResources2 = emptyResources() assertTrue(emptyResources.containsAll(emptyResources2)) } @Test fun contains_singleTypeContainsEmpty() { - val resources = Resources() - resources.add(ResourceType.STONE, 1) - - val emptyResources = Resources() + val resources = resourcesOf(STONE to 1) + val emptyResources = emptyResources() assertTrue(resources.containsAll(emptyResources)) } @Test fun contains_multipleTypesContainsEmpty() { - val resources = Resources() - resources.add(ResourceType.STONE, 1) - resources.add(ResourceType.CLAY, 3) - - val emptyResources = Resources() + val resources = resourcesOf(STONE to 1, CLAY to 3) + val emptyResources = emptyResources() assertTrue(resources.containsAll(emptyResources)) } @Test fun contains_self() { - val resources = Resources() - resources.add(ResourceType.STONE, 1) - resources.add(ResourceType.CLAY, 3) + val resources = resourcesOf(STONE to 1, CLAY to 3) assertTrue(resources.containsAll(resources)) } @Test fun contains_allOfEachType() { - val resources = Resources() - resources.add(ResourceType.STONE, 1) - resources.add(ResourceType.CLAY, 3) - - val resources2 = Resources() - resources2.add(ResourceType.STONE, 1) - resources2.add(ResourceType.CLAY, 3) + val resources = resourcesOf(STONE to 1, CLAY to 3) + val resources2 = resourcesOf(STONE to 1, CLAY to 3) assertTrue(resources.containsAll(resources2)) } @Test fun contains_someOfEachType() { - val resources = Resources() - resources.add(ResourceType.STONE, 2) - resources.add(ResourceType.CLAY, 4) - - val resources2 = Resources() - resources2.add(ResourceType.STONE, 1) - resources2.add(ResourceType.CLAY, 3) + val resources = resourcesOf(STONE to 2, CLAY to 4) + val resources2 = resourcesOf(STONE to 1, CLAY to 3) assertTrue(resources.containsAll(resources2)) } @Test fun contains_someOfSomeTypes() { - val resources = Resources() - resources.add(ResourceType.STONE, 2) - resources.add(ResourceType.CLAY, 4) - - val resources2 = Resources() - resources2.add(ResourceType.CLAY, 3) + val resources = resourcesOf(STONE to 2, CLAY to 4) + val resources2 = resourcesOf(CLAY to 3) assertTrue(resources.containsAll(resources2)) } @Test fun contains_allOfSomeTypes() { - val resources = Resources() - resources.add(ResourceType.STONE, 2) - resources.add(ResourceType.CLAY, 4) - - val resources2 = Resources() - resources2.add(ResourceType.CLAY, 4) + val resources = resourcesOf(STONE to 2, CLAY to 4) + val resources2 = resourcesOf(CLAY to 4) assertTrue(resources.containsAll(resources2)) } @Test fun minus_empty() { - val resources = Resources() - resources.add(ResourceType.STONE, 1) - resources.add(ResourceType.CLAY, 3) - - val emptyResources = Resources() + val resources = resourcesOf(STONE to 1, CLAY to 3) + val emptyResources = emptyResources() val diff = resources.minus(emptyResources) - assertEquals(1, diff.getQuantity(ResourceType.STONE).toLong()) - assertEquals(3, diff.getQuantity(ResourceType.CLAY).toLong()) - assertEquals(0, diff.getQuantity(ResourceType.ORE).toLong()) - assertEquals(0, diff.getQuantity(ResourceType.GLASS).toLong()) - assertEquals(0, diff.getQuantity(ResourceType.LOOM).toLong()) + assertEquals(1, diff[STONE]) + assertEquals(3, diff[CLAY]) + assertEquals(0, diff[ORE]) + assertEquals(0, diff[GLASS]) + assertEquals(0, diff[LOOM]) } @Test fun minus_self() { - val resources = Resources() - resources.add(ResourceType.STONE, 1) - resources.add(ResourceType.CLAY, 3) + val resources = resourcesOf(STONE to 1, CLAY to 3) val diff = resources.minus(resources) - assertEquals(0, diff.getQuantity(ResourceType.STONE).toLong()) - assertEquals(0, diff.getQuantity(ResourceType.CLAY).toLong()) - assertEquals(0, diff.getQuantity(ResourceType.ORE).toLong()) - assertEquals(0, diff.getQuantity(ResourceType.GLASS).toLong()) - assertEquals(0, diff.getQuantity(ResourceType.LOOM).toLong()) + assertEquals(0, diff[STONE]) + assertEquals(0, diff[CLAY]) + assertEquals(0, diff[ORE]) + assertEquals(0, diff[GLASS]) + assertEquals(0, diff[LOOM]) } @Test fun minus_allOfEachType() { - val resources = Resources() - resources.add(ResourceType.STONE, 1) - resources.add(ResourceType.CLAY, 3) - - val resources2 = Resources() - resources2.add(ResourceType.STONE, 1) - resources2.add(ResourceType.CLAY, 3) + val resources = resourcesOf(STONE to 1, CLAY to 3) + val resources2 = resourcesOf(STONE to 1, CLAY to 3) val diff = resources.minus(resources2) - assertEquals(0, diff.getQuantity(ResourceType.STONE).toLong()) - assertEquals(0, diff.getQuantity(ResourceType.CLAY).toLong()) - assertEquals(0, diff.getQuantity(ResourceType.ORE).toLong()) - assertEquals(0, diff.getQuantity(ResourceType.GLASS).toLong()) - assertEquals(0, diff.getQuantity(ResourceType.LOOM).toLong()) + assertEquals(0, diff[STONE]) + assertEquals(0, diff[CLAY]) + assertEquals(0, diff[ORE]) + assertEquals(0, diff[GLASS]) + assertEquals(0, diff[LOOM]) } @Test fun minus_someOfEachType() { - val resources = Resources() - resources.add(ResourceType.STONE, 2) - resources.add(ResourceType.CLAY, 4) - - val resources2 = Resources() - resources2.add(ResourceType.STONE, 1) - resources2.add(ResourceType.CLAY, 3) + val resources = resourcesOf(STONE to 2, CLAY to 4) + val resources2 = resourcesOf(STONE to 1, CLAY to 3) val diff = resources.minus(resources2) - assertEquals(1, diff.getQuantity(ResourceType.STONE).toLong()) - assertEquals(1, diff.getQuantity(ResourceType.CLAY).toLong()) - assertEquals(0, diff.getQuantity(ResourceType.ORE).toLong()) - assertEquals(0, diff.getQuantity(ResourceType.GLASS).toLong()) - assertEquals(0, diff.getQuantity(ResourceType.LOOM).toLong()) + assertEquals(1, diff[STONE]) + assertEquals(1, diff[CLAY]) + assertEquals(0, diff[ORE]) + assertEquals(0, diff[GLASS]) + assertEquals(0, diff[LOOM]) } @Test fun minus_someOfSomeTypes() { - val resources = Resources() - resources.add(ResourceType.STONE, 2) - resources.add(ResourceType.CLAY, 4) - - val resources2 = Resources() - resources2.add(ResourceType.CLAY, 3) + val resources = resourcesOf(STONE to 2, CLAY to 4) + val resources2 = resourcesOf(CLAY to 3) val diff = resources.minus(resources2) - assertEquals(2, diff.getQuantity(ResourceType.STONE).toLong()) - assertEquals(1, diff.getQuantity(ResourceType.CLAY).toLong()) - assertEquals(0, diff.getQuantity(ResourceType.ORE).toLong()) - assertEquals(0, diff.getQuantity(ResourceType.GLASS).toLong()) - assertEquals(0, diff.getQuantity(ResourceType.LOOM).toLong()) + assertEquals(2, diff[STONE]) + assertEquals(1, diff[CLAY]) + assertEquals(0, diff[ORE]) + assertEquals(0, diff[GLASS]) + assertEquals(0, diff[LOOM]) } @Test fun minus_allOfSomeTypes() { - val resources = Resources() - resources.add(ResourceType.STONE, 2) - resources.add(ResourceType.CLAY, 4) - - val resources2 = Resources() - resources2.add(ResourceType.CLAY, 4) + val resources = resourcesOf(STONE to 2, CLAY to 4) + val resources2 = resourcesOf(CLAY to 4) val diff = resources.minus(resources2) - assertEquals(2, diff.getQuantity(ResourceType.STONE).toLong()) - assertEquals(0, diff.getQuantity(ResourceType.CLAY).toLong()) - assertEquals(0, diff.getQuantity(ResourceType.ORE).toLong()) - assertEquals(0, diff.getQuantity(ResourceType.GLASS).toLong()) - assertEquals(0, diff.getQuantity(ResourceType.LOOM).toLong()) + assertEquals(2, diff[STONE]) + assertEquals(0, diff[CLAY]) + assertEquals(0, diff[ORE]) + assertEquals(0, diff[GLASS]) + assertEquals(0, diff[LOOM]) } @Test fun minus_tooMuchOfExistingType() { - val resources = Resources() - resources.add(ResourceType.CLAY, 4) - - val resources2 = Resources() - resources2.add(ResourceType.CLAY, 5) + val resources = resourcesOf(CLAY to 4) + val resources2 = resourcesOf(CLAY to 5) val diff = resources.minus(resources2) - assertEquals(0, diff.getQuantity(ResourceType.CLAY).toLong()) + assertEquals(0, diff[CLAY]) } @Test fun minus_someOfAnAbsentType() { - val resources = Resources() - - val resources2 = Resources() - resources2.add(ResourceType.LOOM, 5) + val resources = emptyResources() + val resources2 = resourcesOf(LOOM to 5) val diff = resources.minus(resources2) - assertEquals(0, diff.getQuantity(ResourceType.LOOM).toLong()) + assertEquals(0, diff[LOOM]) } @Test fun minus_someOfATypeWithZero() { - val resources = Resources() - resources.add(ResourceType.LOOM, 0) - - val resources2 = Resources() - resources2.add(ResourceType.LOOM, 5) + val resources = resourcesOf(LOOM to 0) + val resources2 = resourcesOf(LOOM to 5) val diff = resources.minus(resources2) - assertEquals(0, diff.getQuantity(ResourceType.LOOM).toLong()) + assertEquals(0, diff[LOOM]) } @Test fun isEmpty_noElement() { - val resources = Resources() - assertTrue(resources.isEmpty) + val resources = emptyResources() + assertTrue(resources.isEmpty()) } @Test fun isEmpty_singleZeroElement() { - val resources = Resources() - resources.add(ResourceType.LOOM, 0) - assertTrue(resources.isEmpty) + val resources = resourcesOf(LOOM to 0) + assertTrue(resources.isEmpty()) } @Test fun isEmpty_multipleZeroElements() { - val resources = Resources() - resources.add(ResourceType.WOOD, 0) - resources.add(ResourceType.ORE, 0) - resources.add(ResourceType.LOOM, 0) - assertTrue(resources.isEmpty) + val resources = resourcesOf(WOOD to 0, ORE to 0, LOOM to 0) + assertTrue(resources.isEmpty()) } @Test fun isEmpty_singleElementMoreThanZero() { - val resources = Resources() - resources.add(ResourceType.LOOM, 3) - assertFalse(resources.isEmpty) + val resources = resourcesOf(LOOM to 3) + assertFalse(resources.isEmpty()) } @Test fun isEmpty_mixedZeroAndNonZeroElements() { - val resources = Resources() - resources.add(ResourceType.WOOD, 0) - resources.add(ResourceType.LOOM, 3) - assertFalse(resources.isEmpty) + val resources = resourcesOf(WOOD to 0, LOOM to 3) + assertFalse(resources.isEmpty()) } @Test fun isEmpty_mixedZeroAndNonZeroElements_reverseOrder() { - val resources = Resources() - resources.add(ResourceType.ORE, 3) - resources.add(ResourceType.PAPYRUS, 0) - assertFalse(resources.isEmpty) - } - - @Test - fun equals_falseWhenNull() { - val resources = Resources() - resources.add(ResourceType.GLASS, 1) - - assertFalse(resources == null) + val resources = resourcesOf(ORE to 3, PAPYRUS to 0) + assertFalse(resources.isEmpty()) } @Test fun equals_trueWhenSame() { - val resources = Resources() + val resources = emptyResources() assertEquals(resources, resources) } @Test fun equals_trueWhenSameContent() { - val resources1 = Resources() - val resources2 = Resources() + val resources1 = mutableResourcesOf() + val resources2 = mutableResourcesOf() assertTrue(resources1 == resources2) - resources1.add(ResourceType.GLASS, 1) - resources2.add(ResourceType.GLASS, 1) + resources1.add(GLASS, 1) + resources2.add(GLASS, 1) assertTrue(resources1 == resources2) } @Test fun hashCode_sameWhenSameContent() { - val resources1 = Resources() - val resources2 = Resources() - assertEquals(resources1.hashCode().toLong(), resources2.hashCode().toLong()) - resources1.add(ResourceType.GLASS, 1) - resources2.add(ResourceType.GLASS, 1) - assertEquals(resources1.hashCode().toLong(), resources2.hashCode().toLong()) + val resources1 = mutableResourcesOf() + val resources2 = mutableResourcesOf() + assertEquals(resources1.hashCode(), resources2.hashCode()) + resources1.add(GLASS, 1) + resources2.add(GLASS, 1) + assertEquals(resources1.hashCode(), resources2.hashCode()) } } diff --git a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/resources/TradingRulesTest.kt b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/resources/TradingRulesTest.kt index 859c997a..ac3f72de 100644 --- a/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/resources/TradingRulesTest.kt +++ b/game-engine/src/test/kotlin/org/luxons/sevenwonders/game/resources/TradingRulesTest.kt @@ -1,15 +1,14 @@ package org.luxons.sevenwonders.game.resources -import java.util.ArrayList - +import org.junit.Assert.assertEquals +import org.junit.Assume.assumeTrue 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.* - -import org.junit.Assert.assertEquals -import org.junit.Assume.assumeTrue +import org.luxons.sevenwonders.game.test.createTransaction +import org.luxons.sevenwonders.game.test.createTransactions +import java.util.ArrayList @RunWith(Theories::class) class TradingRulesTest { @@ -32,7 +31,7 @@ class TradingRulesTest { @Theory fun computeCost_zeroForNoResources(defaultCost: Int) { val rules = TradingRules(defaultCost) - assertEquals(0, rules.computeCost(ResourceTransactions()).toLong()) + assertEquals(0, rules.computeCost(noTransactions()).toLong()) } @Theory @@ -59,9 +58,11 @@ class TradingRulesTest { @Theory fun computeCost_defaultCostWhenOverrideOnOtherProviderOrType( - defaultCost: Int, overriddenCost: Int, + defaultCost: Int, + overriddenCost: Int, overriddenProvider: Provider, - overriddenType: ResourceType, provider: Provider, + overriddenType: ResourceType, + provider: Provider, type: ResourceType ) { assumeTrue(overriddenProvider != provider || overriddenType != type) @@ -73,8 +74,10 @@ class TradingRulesTest { @Theory fun computeCost_oneDefaultAndOneOverriddenType( - defaultCost: Int, overriddenCost: Int, - overriddenType: ResourceType, provider: Provider, + defaultCost: Int, + overriddenCost: Int, + overriddenType: ResourceType, + provider: Provider, type: ResourceType ) { assumeTrue(overriddenType != type) @@ -86,8 +89,10 @@ class TradingRulesTest { @Theory fun computeCost_oneDefaultAndOneOverriddenProvider( - defaultCost: Int, overriddenCost: Int, - overriddenProvider: Provider, provider: Provider, + defaultCost: Int, + overriddenCost: Int, + overriddenProvider: Provider, + provider: Provider, type: ResourceType ) { assumeTrue(overriddenProvider != provider) @@ -98,10 +103,7 @@ class TradingRulesTest { boughtResources.add(createTransaction(provider, type)) boughtResources.add(createTransaction(overriddenProvider, type)) - assertEquals( - (defaultCost + overriddenCost).toLong(), - rules.computeCost(ResourceTransactions(boughtResources)).toLong() - ) + assertEquals(defaultCost + overriddenCost, rules.computeCost(boughtResources)) } companion object { 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 bf718d32..1a360a77 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 @@ -24,6 +24,8 @@ import org.luxons.sevenwonders.game.resources.ResourceTransaction import org.luxons.sevenwonders.game.resources.ResourceTransactions import org.luxons.sevenwonders.game.resources.ResourceType import org.luxons.sevenwonders.game.resources.Resources +import org.luxons.sevenwonders.game.resources.noTransactions +import org.luxons.sevenwonders.game.resources.resourcesOf import org.luxons.sevenwonders.game.wonders.Wonder import org.luxons.sevenwonders.game.wonders.WonderStage import java.util.Arrays @@ -90,34 +92,29 @@ private fun createWonderStage(vararg effects: Effect): WonderStage { fun fixedProduction(vararg producedTypes: ResourceType): Production { val production = Production() - val fixedProducedResources = production.fixedResources - fixedProducedResources.addAll(createResources(*producedTypes)) + production.addAll(resourcesOf(*producedTypes)) return production } -fun createResources(vararg types: ResourceType): Resources { - val resources = Resources() - for (producedType in types) { - resources.add(producedType, 1) - } - return resources +infix fun Int.of(type: ResourceType): Resources { + return resourcesOf(type to this) } internal fun createTransactions(provider: Provider, vararg resources: ResourceType): ResourceTransactions { val transaction = createTransaction(provider, *resources) - return ResourceTransactions(listOf(transaction)) + return listOf(transaction) } internal fun createTransactions(vararg transactions: ResourceTransaction): ResourceTransactions { - return ResourceTransactions(Arrays.asList(*transactions)) + return transactions.toList() } fun createTransaction(provider: Provider, vararg resources: ResourceType): ResourceTransaction { - return ResourceTransaction(provider, createResources(*resources)) + return ResourceTransaction(provider, resourcesOf(*resources)) } fun createRequirements(vararg types: ResourceType): Requirements { - val resources = createResources(*types) + val resources = resourcesOf(*types) return Requirements(resources = resources) } @@ -209,7 +206,7 @@ fun createScience(compasses: Int, wheels: Int, tablets: Int, jokers: Int): Scien internal fun playCardWithEffect(player: Player, color: Color, effect: Effect) { val card = testCard(color, effect) player.board.addCard(card) - card.applyTo(player, ResourceTransactions()) + card.applyTo(player, noTransactions()) } internal fun createMove(context: PlayerContext, card: Card, type: MoveType, vararg transactions: ResourceTransaction): Move { |