mauvaise manip--

.github/workflows/build.yml

@@ -37,3 +37,124 @@ jobs:
       - name: Build ${{ matrix.java-version }}
         run: mvn -B clean test
 
+      - name: Rick Roll On Fail
+        if: failure()
+        run: |
+            echo "![RickRoll](https://media.giphy.com/media/Vuw9m5wXviFIQ/giphy.gif)"
+            cat .github/workflows/rickroll.txt
+
+
+      # Build complet du projet sans exécuter les tests
+      # On compile tous les modules Maven (-DskipTests) sans lancer les tests.
+      - name: build tous les modules
+        run: mvn clean install -DskipTests
+
+
+
+      # Télécharger l'ancien score de mutation du module 'core'
+      # On télécharge l'artefact du précédent pipeline afin de récupérer
+      # le score de mutation précédent (Prec_Score). Cela permet de comparer
+      # le nouveau score avec l’ancien.
+      #
+      # workflow_search: true → cherche dans les workflows précédents
+      # workflow_conclusion: success → seulement les workflows réussis
+      # continue-on-error: true → évite les erreurs lors du tout premier run,
+      # où aucun artefact n’existe encore.
+      - name: Download core-artefact
+        id: download-core-artifact
+        uses: dawidd6/action-download-artifact@v11
+        with:
+          github_token: ${{secrets.GITHUB_TOKEN}}
+          workflow: build.yml
+          workflow_search: true
+          workflow_conclusion: success
+          name: core-artefact-${{ matrix.java-version }}
+          path: core-artefact/
+        continue-on-error: true
+
+      # Exécuter PIT Mutation Testing sur le module 'core'
+      # On génère le rapport PIT pour le module core.
+      # On extrait le pourcentage des mutations "Killed" (score PIT).
+      # On compare le score actuel avec le score stocké dans l’artefact
+      # précédent.
+      # Si le score a baissé -> échec du workflow (exit 1).
+      #
+      # Le fichier "Prec_Score" est mis à jour.
+      - name: Run pitest on core module
+        run: |
+          mvn clean test-compile -pl core org.pitest:pitest-maven:mutationCoverage | tee core/core-score
+
+          Core_Score=$(grep -A15 Statistics core/core-score | grep Killed | grep -oP '\(\K[0-9]+')
+          echo "le score de mutation pour le module core est $Core_Score%" 
+
+          if [ -f core-artefact/Prec_Score ]; then
+            Prev_Score=$(cat core-artefact/Prec_Score)
+          else
+            Prev_Score=0
+          fi
+
+          if [ "$Core_Score" -lt "$Prev_Score" ]; then
+            echo "Le score de mutation dans le module core a baisse $Prev_Score% ---> $Core_Score%"
+            exit 1
+          fi
+          echo "ancien score: $Prev_Score%, nouveau_score: $Core_Score%"
+          echo "$Core_Score" > ./Prec_Score
+
+
+
+      # Upload du nouveau score PIT pour le module core
+      # Cela permet d’utiliser ce score lors du prochain pipeline.
+      - name: 'Upload precedent core-score'
+        uses: actions/upload-artifact@v4
+        with:
+          name: core-artefact-${{ matrix.java-version }}
+          path: ./Prec_Score
+
+
+
+      # Télécharger l’ancien score du module reader-gtfs
+      - name: Download reader-artefact
+        id: download-reader-artifact
+        uses: dawidd6/action-download-artifact@v11
+        with:
+          github_token: ${{secrets.GITHUB_TOKEN}}
+          workflow: build.yml
+          workflow_search: true
+          workflow_conclusion: success
+          name: reader-artefact-${{ matrix.java-version }}
+          path: reader-artefact/
+        continue-on-error: true
+
+
+
+      # Exécuter PIT sur le module reader-gtfs
+      - name: Run pitest on reader-gtfs module
+        run: |
+          mvn clean test-compile -pl reader-gtfs org.pitest:pitest-maven:mutationCoverage | tee reader-gtfs/reader-score
+
+          Reader_Score=$(grep -A15 Statistics reader-gtfs/reader-score | grep Killed | grep -oP '\(\K[0-9]+')
+          echo "le score de mutation pour le module reader-gtfs est $Reader_Score%"
+
+          if [ -f reader-artefact/Prec_Score_gtfs ]; then
+            Prev_Score=$(cat reader-artefact/Prec_Score_gtfs)
+          else
+            Prev_Score=0
+          fi
+
+          if [ "$Reader_Score" -lt "$Prev_Score" ]; then
+            echo "Le score de mutation dans le module core a baisse $Prev_Score% ---> $Reader_Score%"
+            exit 1
+          fi
+
+          echo "ancien score: $Prev_Score%, nouveau_score: $Reader_Score%"
+          echo "$Reader_Score" > ./Prec_Score_gtfs
+
+
+      # Upload du nouveau score PIT reader-gtfs
+      - name: 'Upload preccedent reader-score'
+        uses: actions/upload-artifact@v4
+        with:
+          name: reader-artefact-${{ matrix.java-version }}
+          path: ./Prec_Score_gtfs
+
+

.github/workflows/rickroll.txt

@@ -0,0 +1,25 @@
+⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⢿⡿⣿⣿⡿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⣻⣻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣟⡽⣯⣻⣻⡽⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⢿⣻⣻
+⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⢿⡿⣿⣿⣿⣿⣿⣿⡿⣻⣻⣻⣻⣻⣻⡽⣯⣟⢷⠍⠟⠉⠛⢿⢿⣻⣻⢿⣿⣿⣯⣻⡽⣯⣻⣻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣻⢯
+⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣻⣻⣻⣻⡟⡅⠀⠀⠀⠠⠀⠀⠆⡹⣻⣻⡽⣯⣻⡽⣯⣻⡽⣻⣻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣻⣻⣻
+⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣻⣿⡟⡛⡜⡜⣎⢦⢶⣖⡴⡀⠠⣿⣿⣿⣟⣟⣟⣟⣟⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣻⣻⣻⣻
+⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣻⣻⢆⢭⢎⢎⢞⡝⣝⡽⡽⡣⢂⣟⢯⢯⢯⣿⣻⣻⡽⣻⡽⣻⣻⣿⣿⣿⣿⣿⣿⣿⡿⣟⣿⣿⣿⣿⣻
+⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⣟⢧⡒⡔⢆⢯⢎⠚⡜⡇⣼⣿⣿⣯⣻⣻⣻⣻⢯⣿⣿⣻⣻⣻⣻⢿⣿⣿⣿⣿⡿⣻⣻⣻⣟⣿⣿
+⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⢹⢧⢣⢣⠡⡋⡯⣫⢯⡹⣹⣿⣿⣿⣿⣯⣻⣻⣻⣿⣿⣻⣻⣻⣿⣟⣟⢿⣿⣿⣿⣿⣻⢿⣿⣿⣿
+⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠧⢣⢢⢌⣍⡹⡽⣹⣽⣿⣿⣿⣿⣿⡽⣯⣻⢯⣻⢯⣻⣻⣿⣿⣿⣿⣻⣻⣻⣻⢿⢿⣿⣿⣿⣿
+⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣟⡽⣍⢎⢎⢝⢏⢏⣝⢿⣿⣿⣿⣿⣿⣿⣻⡽⣯⣻⣻⣿⣿⣟⢿⣿⢿⣻⣻⣿⣿⢿⣿⣿⣿⣿⣿⣿
+⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⢿⣿⣿⣟⣟⣟⡜⡜⡜⡝⡭⣫⢫⠂⢫⣿⣿⣿⣟⢯⣻⣻⣻⡽⣻⣿⣿⣿⣟⣿⣿⣿⣻⣟⣟⣿⣿⣿⣿⣿⣿⣿
+⣿⣿⣿⣿⢿⡿⣿⢿⡿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⢿⣿⣿⣿⡿⡽⡻⡿⣇⢣⢣⠱⡱⡱⣽⣿⠀⠀⠀⠀⠐⢉⠍⡛⢿⢯⣻⣻⣿⣿⡿⣿⣿⣿⣿⣟⣟⣿⣿⣿⣿⣿⣿⣿⣿
+⣿⣿⣿⣿⣿⣿⣿⣿⣟⢿⣿⣿⣿⡿⣿⣿⣟⢿⣻⣻⡿⣏⢋⠀⠀⠀⣹⣻⡇⢣⠱⣥⣻⣿⡿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢹⣿⣿⣻⣿⣿⣿⣟⣟⣟⡽⣻⣿⡿⡿⣿⣿⣿
+⣿⣿⣿⣿⣿⢿⣿⣿⣿⢿⣻⣿⢿⣿⣿⢿⣻⣻⣻⡃⠀⠀⠀⠀⠀⠀⠠⠠⡣⢢⠱⡉⠙⠛⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣻⡽⣻⣿⢯⣻⣿⣿⢯⣻⣿⣿⣿⣿⣿⣿
+⣿⣿⣿⣿⢿⣻⣻⣿⣟⣟⣟⣿⣿⣿⣿⣿⡿⣟⣟⠄⠀⠀⠀⠀⠀⠀⠀⢀⢆⡑⠡⠉⠋⠖⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣿⣻⢯⣻⡽⣻⣻⡿⣯⢿⣿⣿⣿⣿⣿
+⣿⣻⣟⣟⣿⣿⣿⣿⣟⣟⣟⣟⣿⣿⣿⣿⣟⣟⡽⡄⠀⠀⠀⠀⠀⠀⠀⢀⠁⣯⠚⠹⠶⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢿⣿⣻⢯⢯⣻⣿⣿⣻⣻⣻⣿⣿⣿⣿⣿
+⣿⣟⢿⣿⣿⣿⣿⣿⣻⣿⡿⣻⣻⣿⣿⣿⢿⣻⢯⠀⠀⠀⠀⠀⠀⠀⠀⠀⠛⣟⠖⡖⡤⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢻⢿⣻⣿⣻⣿⣿⣿⣿⣿⣻⢯⣻⣻⣻
+⣿⣻⣻⣿⣿⣿⣿⣻⣽⣿⣿⣟⣟⢿⣿⣿⡿⣻⣻⠀⠀⠀⠀⠀⠀⠀⠀⠀⢦⢢⣠⣀⠀⠀⠀⠀⠩⡛⡝⡜⡖⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⢿⣿⣻⣿⣿⣿⣿⣿⣿⣿⣿⣿
+⣿⣻⣻⣻⣿⣿⡿⣻⣿⣿⣻⣻⣿⣿⡿⣿⣻⣻⣻⠀⠀⠀⠀⠀⠀⠀⠀⠀⡀⡜⠈⠁⠀⠀⠀⠀⠀⠌⣌⢎⡜⡜⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣻⣿⣿⡿⣟⢿⣿⣿⣿
+⣟⣿⣿⣿⡽⡽⡽⣻⣹⡽⣿⣿⣿⣻⣻⣻⣻⡽⣻⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⢢⠣⠒⠀⠀⠀⠀⠀⠀⠎⢎⢎⢎⢎⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣟⡽⣿⣿⣻⣻⣻⢿⣿⣿
+⣿⣿⢿⣿⣯⣫⣏⢯⣫⣿⣿⣿⣿⣟⣟⣟⣟⡽⡽⠀⡀⠀⠀⠀⠀⢀⢀⠀⠰⡰⠤⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⡝⡽⡽⣿⣿⣿⣻⡝⡽
+⣯⣯⣯⣯⢯⣫⢫⣻⡿⣻⣿⣿⣿⣿⣿⣻⡽⡽⣭⠂⠀⡰⡱⠡⠢⢂⠆⠀⢠⠰⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⢯⢫⣫⡿⣻⣿⣿⣿⣻⡹
+⡿⡿⣻⣻⣻⢭⣚⢧⢫⣻⣿⣿⡿⡽⡽⡽⡽⣹⣝⢇⠄⠀⠀⠄⠄⠄⡐⠀⠄⡐⠐⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡝⣝⡽⣹⢽⢯⡻⣻⣟⢯⢫⣚⣟⣟⣟⣟⣟⣟⡝
+⣯⣻⡽⣯⣻⡜⡵⡽⣎⢭⣻⡝⡽⣽⡽⣝⣝⣝⡝⣗⢭⢎⠀⠀⠂⠂⠀⠀⠀⡐⠐⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣹⣝⣝⡝⣝⡽⡽⡹⣚⠵⡭⢯⢯⢯⣻⡽⡽⣣
+⣟⣟⡽⣯⢯⢎⢎⢯⣏⡗⡝⣝⡽⣻⢯⣫⢫⢫⣫⣻⢯⡳⡱⡱⡱⠀⠀⠀⠀⠠⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠐⡝⡝⡝⣝⡝⡝⡭⣫⢫⢭⣚⣝⣝⣝⡽⣹⣹⢧
+⢏⠯⢫⢫⢫⢪⢎⢯⢏⠳⡹⡹⣻⡿⡯⣫⢫⡹⡹⡽⡽⡹⡸⡜⡄⠀⠀⢀⢂⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡭⡭⣫⡹⡹⡭⣫⢫⢫⣚⡜⡝⡝⣝⣝⢽⡹⡭

core/pom.xml

@@ -164,6 +164,27 @@
                     <failOnUnableToExtractRepoInfo>false</failOnUnableToExtractRepoInfo>
                 </configuration>
             </plugin>
+            <plugin>
+                <groupId>org.pitest</groupId>
+                <artifactId>pitest-maven</artifactId>
+                <version>1.20.2</version>
+                <configuration>
+                    <targetClasses>
+                        <param>com.graphhopper.util.GHUtility</param>
+                        <param>com.graphhopper.util.ArrayUtil</param>
+                    </targetClasses>
+                    <targetTests>
+                        <param>com.graphhopper.util.GHUtilityTest</param>
+                        <param>com.graphhopper.util.ArrayUtilTest</param>
+                    </targetTests>
+                    <mutationThreshold>0</mutationThreshold>
+                    <outputFormats>
+                        <param>HTML</param>
+                        <param>XML</param>
+                    </outputFormats>
+                    <threads>4</threads>
+                </configuration>
+            </plugin>
         </plugins>
 
         <!-- make version available at runtime via version file -->

core/src/test/java/com/graphhopper/util/ArrayUtilTest.java

@@ -21,10 +21,13 @@
 import com.carrotsearch.hppc.IntArrayList;
 import org.junit.jupiter.api.Test;
 
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.List;
 import java.util.Random;
 
 import static com.carrotsearch.hppc.IntArrayList.from;
+import static com.graphhopper.util.ArrayUtil.*;
 import static org.junit.jupiter.api.Assertions.*;
 
 class ArrayUtilTest {
@@ -178,4 +181,111 @@ public void testMerge() {
         int[] b = {3, 7, 9, 10, 11, 12, 15, 20, 21, 26};
         assertEquals(from(2, 3, 6, 7, 8, 9, 10, 11, 12, 15, 20, 21, 26), from(ArrayUtil.merge(a, b)));
     }
+
+
+
+
+    /**
+     * TestSublist0
+     * Vérifie qu'une liste vide n a pas de sous liste.
+     * tentative d’extraction d’une sous liste de la liste vide.
+     * une erreur est attendue.
+     */
+    @Test
+    public void TestSublist0() {
+        int[] a = {};
+        IntArrayList aj = IntArrayList.from(a);
+        assertThrows(Error.class, () -> subList(aj, 3, 5));
+
+    }
+
+    /**
+     * TestSublist1
+     * Vérifie que le tableau retournee est correct.
+     * tentative d’extraction d’une sous liste d'une liste donnee
+     *  le tableau b1 est attendu
+     */
+    @Test
+    public void TestSublist1() {
+        int[] a = {1,2,3,4,5,6,7,8,9,10};
+        int[] b = {4,5};
+        IntArrayList a1 = IntArrayList.from(a);
+        IntArrayList b1 = IntArrayList.from(b);
+        assertEquals(b1, subList(a1, 3, 5));
+    }
+
+
+    /**
+     * TestSublist2
+     * Vérifie que le tableau retournee est correct.
+     * tentative d’extraction d’une sous liste etant donne que fromIndex et toIndex sont egaux
+     *  le tableau b1 est attendu
+     */
+    @Test
+    public void TestSublist2() {
+        int[] a = {1,2,3,4,5,6,7,8,9,10};
+        int[] b = {};
+        IntArrayList a1 = IntArrayList.from(a);
+        IntArrayList b1 = IntArrayList.from(b);
+        assertEquals(b1, subList(a1, 0, 0));
+    }
+
+    /**
+     * testApplyOrder2
+     * Vérifie si le tableau (order)passe en argument est plus grand que le premier tableau (a) une exeption est levee.
+     * un IllegalArgumentException est attendue.
+     */
+    @Test
+    public void testApplyOrder2() {
+        int[] a = {1,2,3,4,5,6,7,8,9,10};
+        int[] b = {1,2,3,4,5,6,7,8,9,10,11};
+        assertThrows(IllegalArgumentException.class, () -> applyOrder(a, b));
+    }
+
+
+    /**
+     * calcSortOrder2
+     * Vérifie si le parametre (length)passe en argument est plus grand que la taille des tableaux une exeption est levee.
+     * un IllegalArgumentException est attendue.
+     */
+    @Test
+    public void testCalcSortOrder2(){
+        int[] a = {1,2,3,4,5,6,7,8,9,10};
+        int[] b = {12,42,387,41,45,69,71,58,98,10};
+        assertThrows(IllegalArgumentException.class, () -> calcSortOrder(a, b, 11));
+
+    }
+
+
+    /**
+     * calcSortOrder3
+     * Vérifie que si les deux tableaux sont de tailles inegales une exeption est levee.
+     * un IllegalArgumentException est attendue.
+     */
+    @Test
+    public void testCalcSortOrder3(){
+        int[] a = {1,2,3,4,5,6,7,8,9,10,11};
+        int[] b = {12,42,387,41,45,69,71,58,98,10};
+        IntArrayList a1 = IntArrayList.from(a);
+        IntArrayList b1 = IntArrayList.from(b);
+        assertThrows(IllegalArgumentException.class, () -> calcSortOrder(a1, b1));
+
+    }
+
+
+
+    /**
+     * TestremoveConsecutiveDuplicates
+     * Vérifie que end est inferieur a zero, une exeption est levee.
+     * un IllegalArgumentException est attendue.
+     */
+    @Test
+    public void TestremoveConsecutiveDuplicates(){
+        int[] a = {1,2,3,4,5,6,7,8,9,10};
+        int b = -1;
+        assertThrows(IllegalArgumentException.class, () -> ArrayUtil.removeConsecutiveDuplicates(a, b));
+
+    }
+
+
 }

core/src/test/java/com/graphhopper/util/DownloaderTest.java

@@ -0,0 +1,44 @@
+package com.graphhopper.util;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.io.*;
+import java.net.HttpURLConnection;
+import static org.mockito.Mockito.*;
+import com.graphhopper.util.Downloader.*;
+
+@ExtendWith(MockitoExtension.class)
+public class DownloaderTest {
+
+    @InjectMocks
+    Downloader downloader;
+
+    @Mock
+    HttpURLConnection connection;
+
+
+    /**
+     * fetchTestNullInputStream
+     * Vérifie que la méthode fetch lance une IOException lorsque
+     * getInputStream() retourne null quand  readErrorStreamNoException = false
+     * Données choisies : mock de HttpURLConnection qui renvoie null quand on fait appel
+     * a getInputStream()
+     * La sortie attendue est une IOException
+     */
+    @Test
+    public void fetchTestNullInputStream(){
+        boolean readErrorStreamNoException = false;
+        try {
+            when(connection.getInputStream()).thenReturn(null);
+            assertThrows(IOException.class, ()-> downloader.fetch(connection, readErrorStreamNoException));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}