tp4 step 5

Author: ctruchi

tp4/src/main/kotlin/fmt/kotlin/fundamentals/Container.kt

@@ -10,6 +10,8 @@ sealed class Container(
         }
     }
 
+    val equipments: List<String> = emptyList()
+
     fun containersNeededToPourIn(container: Container) = when (this) {
         is Tank -> when (container) {
             is Barrel, is FixedVolumeContainer -> capacity / container.capacity

tp4/src/test/kotlin/fmt/kotlin/fundamentals/ContainerTest.kt

@@ -6,6 +6,7 @@ import strikt.api.expectCatching
 import strikt.api.expectThat
 import strikt.api.expectThrows
 import strikt.assertions.isA
+import strikt.assertions.isEmpty
 import strikt.assertions.isEqualTo
 import strikt.assertions.isFailure
 import strikt.assertions.isSuccess
@@ -22,7 +23,7 @@ class ContainerTest {
 
         @Test
         fun `Tank should be a Container`() {
-            expectThat(Tank(3000000)).isA<Container>()
+            expectThat(Tank(3000000, emptyList())).isA<Container>()
         }
     }
 
@@ -53,21 +54,21 @@ class ContainerTest {
         @Test
         fun `Tank should be created with 3000000 cL`() {
             expectCatching {
-                Tank(3000000)
+                Tank(3000000, emptyList())
             }.isSuccess()
         }
 
         @Test
         fun `Tank should not be created with 1800000 cL`() {
             expectCatching {
-                Tank(1800000)
+                Tank(1800000, emptyList())
             }.isFailure()
         }
 
         @Test
         fun `Tank should not be created with 12000000 cL`() {
             expectCatching {
-                Tank(12000000)
+                Tank(12000000, emptyList())
             }.isFailure()
         }
     }
@@ -100,38 +101,38 @@ class ContainerTest {
         @Test
         fun `should not be able to pour Tank in Tank`() {
             expectThrows<IllegalArgumentException> {
-                Tank(3000000).containersNeededToPourIn(Tank(3000000))
+                Tank(3000000, emptyList()).containersNeededToPourIn(Tank(3000000, emptyList()))
             }
         }
 
         @Test
         fun `should be able to pour Tank in Barrel`() {
             expectCatching {
-                Tank(3000000).containersNeededToPourIn(Barrel(20000))
+                Tank(3000000, emptyList()).containersNeededToPourIn(Barrel(20000))
             }.isSuccess()
                 .isEqualTo(150)
         }
 
         @Test
         fun `should be able to pour Tank in Magnum`() {
             expectCatching {
-                Tank(3000000).containersNeededToPourIn(Magnum())
+                Tank(3000000, emptyList()).containersNeededToPourIn(Magnum())
             }.isSuccess()
                 .isEqualTo(20000)
         }
 
         @Test
         fun `should be able to pour Tank in Bottle`() {
             expectCatching {
-                Tank(3000000).containersNeededToPourIn(Bottle())
+                Tank(3000000, emptyList()).containersNeededToPourIn(Bottle())
             }.isSuccess()
                 .isEqualTo(40000)
         }
 
         @Test
         fun `should not be able to pour Barrel in Tank`() {
             expectThrows<IllegalArgumentException> {
-                Barrel(20000).containersNeededToPourIn(Tank(3000000))
+                Barrel(20000).containersNeededToPourIn(Tank(3000000, emptyList()))
             }
         }
 
@@ -161,7 +162,7 @@ class ContainerTest {
         @Test
         fun `should not be able to pour Magnum in Tank`() {
             expectThrows<IllegalArgumentException> {
-                Magnum().containersNeededToPourIn(Tank(3000000))
+                Magnum().containersNeededToPourIn(Tank(3000000, emptyList()))
             }
         }
 
@@ -189,7 +190,7 @@ class ContainerTest {
         @Test
         fun `should not be able to pour Bottle in Tank`() {
             expectThrows<IllegalArgumentException> {
-                Bottle().containersNeededToPourIn(Tank(3000000))
+                Bottle().containersNeededToPourIn(Tank(3000000, emptyList()))
             }
         }
 
@@ -214,4 +215,36 @@ class ContainerTest {
             }
         }
     }
+
+    @Nested
+    inner class Equipments {
+
+        @Test
+        fun `Tank equipments should be what I set it to`() {
+            expectThat(Tank(3000000, listOf("Porte", "Contrôle de température", "Dégustateur"))) {
+                get { equipments }.isEqualTo(listOf("Porte", "Contrôle de température", "Dégustateur"))
+            }
+        }
+
+        @Test
+        fun `Barrel equipments should be Robinet, Bonde`() {
+            expectThat(Barrel(22500)) {
+                get { equipments }.isEqualTo(listOf("Robinet", "Bonde"))
+            }
+        }
+
+        @Test
+        fun `Magnum should not have equipments`() {
+            expectThat(Magnum()) {
+                get { equipments }.isEmpty()
+            }
+        }
+
+        @Test
+        fun `Bottle should not have equipments`() {
+            expectThat(Bottle()) {
+                get { equipments }.isEmpty()
+            }
+        }
+    }
 }