init TP1

src/test/kotlin/TestRecursiveFactorial.kt

+import factorial.FactorialStrategy
+import factorial.RecursiveFactorial
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.CsvSource
+
+
+class TestRecursiveFactorial {
+
+    lateinit var facto: FactorialStrategy
+
+    /**
+     * NB cette sous-classe sert à tester le nombre d'appels récursifs
+     */
+    inner class InstrumentedFactorial : RecursiveFactorial() {
+        var nbCalls = 0
+        override fun facto(n: Int): Int {
+            nbCalls++
+            return super.facto(n)
+        }
+    }
+
+
+    @BeforeEach
+    fun init() {
+        facto = InstrumentedFactorial()
+    }
+
+    @Test
+    fun facto0() {
+        assertEquals(1, facto.facto(0))
+        assertEquals(1, (facto as InstrumentedFactorial).nbCalls)
+    }
+
+    @Test
+    fun facto1() {
+        assertEquals(1, facto.facto(1))
+        assertEquals(1, (facto as InstrumentedFactorial).nbCalls)
+    }
+
+    @Test
+    fun facto2() {
+        assertEquals(2, facto.facto(2))
+        assertEquals(2, (facto as InstrumentedFactorial).nbCalls)
+    }
+
+    @ParameterizedTest(name = "factorielle({0}) = {1}")
+    @CsvSource(
+        "0,1,1", "1,1,1", "2,2,2", "3,6,3", "4,24,4", "7,5040,7",
+        "8,40320,8", "9,362880,9", "10,3628800,10", "11,39916800,11",
+        "12,479001600,12",
+    )
+    fun factoData(
+        n: Int,
+        result: Int,
+        call: Int
+    ) {
+        assertEquals(result, facto.facto(n))
+        assertEquals(call, (facto as InstrumentedFactorial).nbCalls)
+    }
+
+    @Test
+    fun facto19() {
+        assertEquals(121_645_100_408_832_000, facto.facto(19))
+        assertEquals(19, (facto as InstrumentedFactorial).nbCalls)
+
+    }
+
+    @Test
+    fun facto20() {
+        assertEquals(2_432_902_008_176_640_000, facto.facto(20))
+        assertEquals(20, (facto as InstrumentedFactorial).nbCalls)
+
+    }
+
+    @ParameterizedTest(name = "factorielle({0}) : impossible")
+    @CsvSource("-1", "-42", "-2", "-4", "-100")
+    fun factoBadData(n: Int) {
+        assertThrows<IllegalArgumentException> { facto.facto(n) }
+    }
+}

src/test/kotlin/TestRecursivePermutations.kt

+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.CsvSource
+import permutations.PermutationsStrategy
+import permutations.RecursiveHeapPermutations
+
+
+class TestRecursivePermutations {
+
+    lateinit var permuteInt: PermutationsStrategy<Int>
+    lateinit var permuteString: PermutationsStrategy<String>
+
+    inner class InstrumentedHeapPermutations<K> : RecursiveHeapPermutations<K>() {
+        var calls = 0
+        override fun heap(data: MutableList<K>, k: Int): List<List<K>> {
+            calls++
+            return super.heap(data, k)
+        }
+    }
+
+    @BeforeEach
+    fun initializePermutationStrategies() {
+        permuteInt = InstrumentedHeapPermutations()
+        permuteString = InstrumentedHeapPermutations()
+    }
+
+    @Test
+    fun permutcompare0() {
+        val expected = listOf(emptyList<String>())
+        val result = permuteString.permutations(emptyList())
+        assertEquals(1, result.size.toLong())
+        assertEquals(expected.size, result.size)
+        expected.forEach { assertTrue(result.contains(it)) }
+        assertEquals(1, (permuteString as InstrumentedHeapPermutations).calls)
+    }
+
+    @Test
+    fun permutcompare1() {
+        val expected = listOf(listOf("1"))
+        val result = permuteString.permutations(listOf("1"))
+        assertEquals(expected.size, result.size)
+        assertEquals(1, result.size.toLong())
+        expected.forEach { assertTrue(result.contains(it)) }
+        assertEquals(1, (permuteString as InstrumentedHeapPermutations).calls)
+
+    }
+
+    @Test
+    fun permutcompare2() {
+        val expected = listOf(listOf(1, 2), listOf(2, 1))
+        val result = permuteInt.permutations(listOf(1, 2))
+        assertEquals(2, result.size.toLong())
+        assertEquals(expected.size, result.size)
+        expected.forEach { assertTrue(result.contains(it)) }
+        assertEquals(3, (permuteInt as InstrumentedHeapPermutations).calls)
+    }
+
+    @ParameterizedTest(name = "elements permuted : {0},{1},{2}")
+    @CsvSource("A,B,C", "A,C,B", "B,A,C", "B,C,A", "C,A,B", "C,B,A")
+    fun permutcompare3(
+        data1: String,
+        data2: String,
+        data3: String,
+    ) {
+        val expected =
+            listOf(
+                listOf("A", "B", "C"),
+                listOf("A", "C", "B"),
+                listOf("B", "A", "C"),
+                listOf("B", "C", "A"),
+                listOf("C", "A", "B"),
+                listOf("C", "B", "A"),
+            )
+        val result = permuteString.permutations(listOf(data1, data2, data3))
+        assertEquals(6, result.size.toLong())
+        assertEquals(expected.size, result.size)
+        expected.forEach { assertTrue(result.contains(it)) }
+        assertEquals(10, (permuteString as InstrumentedHeapPermutations).calls)
+    }
+
+    @ParameterizedTest(name = "elements permuted : {0},{1},{2}")
+    @CsvSource("Riri, Fifi, Loulou", "Riri, Loulou, Fifi", "Fifi, Riri, Loulou")
+    fun permutcompare32(
+        data1: String,
+        data2: String,
+        data3: String,
+    ) {
+        val expected =
+            listOf(
+                listOf("Riri", "Fifi", "Loulou"),
+                listOf("Riri", "Loulou", "Fifi"),
+                listOf("Fifi", "Riri", "Loulou"),
+                listOf("Fifi", "Loulou", "Riri"),
+                listOf("Loulou", "Riri", "Fifi"),
+                listOf("Loulou", "Fifi", "Riri"),
+            )
+        val result = permuteString.permutations(listOf(data1, data2, data3))
+        assertEquals(6, result.size.toLong())
+        assertEquals(expected.size, result.size)
+        println(result)
+        expected.forEach { assertTrue(result.contains(it)) }
+        assertEquals(10, (permuteString as InstrumentedHeapPermutations).calls)
+
+    }
+
+    @Test
+    fun permutcompare4() {
+        val expected =
+            listOf(
+                listOf("Belle Marquise", "vos beaux yeux", "me font mourir", "d'amour"),
+                listOf("Belle Marquise", "vos beaux yeux", "d'amour", "me font mourir"),
+                listOf("Belle Marquise", "me font mourir", "vos beaux yeux", "d'amour"),
+                listOf("Belle Marquise", "me font mourir", "d'amour", "vos beaux yeux"),
+                listOf("Belle Marquise", "d'amour", "me font mourir", "vos beaux yeux"),
+                listOf("Belle Marquise", "d'amour", "vos beaux yeux", "me font mourir"),
+                listOf("vos beaux yeux", "Belle Marquise", "me font mourir", "d'amour"),
+                listOf("vos beaux yeux", "Belle Marquise", "d'amour", "me font mourir"),
+                listOf("vos beaux yeux", "me font mourir", "Belle Marquise", "d'amour"),
+                listOf("vos beaux yeux", "me font mourir", "d'amour", "Belle Marquise"),
+                listOf("vos beaux yeux", "d'amour", "me font mourir", "Belle Marquise"),
+                listOf("vos beaux yeux", "d'amour", "Belle Marquise", "me font mourir"),
+                listOf("me font mourir", "vos beaux yeux", "Belle Marquise", "d'amour"),
+                listOf("me font mourir", "vos beaux yeux", "d'amour", "Belle Marquise"),
+                listOf("me font mourir", "Belle Marquise", "vos beaux yeux", "d'amour"),
+                listOf("me font mourir", "Belle Marquise", "d'amour", "vos beaux yeux"),
+                listOf("me font mourir", "d'amour", "Belle Marquise", "vos beaux yeux"),
+                listOf("me font mourir", "d'amour", "vos beaux yeux", "Belle Marquise"),
+                listOf("d'amour", "vos beaux yeux", "me font mourir", "Belle Marquise"),
+                listOf("d'amour", "vos beaux yeux", "Belle Marquise", "me font mourir"),
+                listOf("d'amour", "me font mourir", "vos beaux yeux", "Belle Marquise"),
+                listOf("d'amour", "me font mourir", "Belle Marquise", "vos beaux yeux"),
+                listOf("d'amour", "Belle Marquise", "me font mourir", "vos beaux yeux"),
+                listOf("d'amour", "Belle Marquise", "vos beaux yeux", "me font mourir"),
+            )
+        val result = permuteString.permutations(listOf("Belle Marquise", "vos beaux yeux", "me font mourir", "d'amour"))
+        assertEquals(24, result.size.toLong())
+        assertEquals(expected.size, result.size)
+        expected.forEach { assertTrue(result.contains(it)) }
+        assertEquals(41, (permuteString as InstrumentedHeapPermutations).calls)
+    }
+
+
+    @ParameterizedTest(name = "nb elements permuted : {0} gives {1} permutations")
+    @CsvSource(
+        "0,1",
+        "1,1",
+        "2,2",
+        "3,6",
+        "4,24",
+        "5,120",
+        "6,720",
+        "7,5040",
+        "8,40320",
+        "9,362880",
+        "10,3628800"
+    )
+    fun permut(limit: Int, nbPermutations: Long) {
+        val data = mutableListOf<Int>()
+        for (i in 0 until limit)
+            data.add(i)
+        val result = permuteInt.permutations(data)
+        assertEquals(nbPermutations, result.size.toLong())
+    }
+
+    @ParameterizedTest(name = "nb elements permuted : {0}  gives {1} permutations")
+    @CsvSource(
+        "11,39916800",
+        "12,479001600",
+    )
+    fun permutTrop(limit: Int, nbPermutations: Long) {
+        val data = mutableListOf<Int>()
+        for (i in 0 until limit)
+            data.add(i)
+        val result = permuteInt.permutations(data)
+        assertEquals(nbPermutations, result.size.toLong())
+    }
+}