From 5869506f40473422fb379be3c283f26d66af8eec Mon Sep 17 00:00:00 2001
From: Rochas <thibaut.rochas@etudiant.univ-rennes1.fr>
Date: Sun, 7 Dec 2025 20:35:29 +0100
Subject: [PATCH] Q3 et 4

---
 .vscode/settings.json                         |  3 ++
 .../main/java/fr/istic/vv/StringUtils.java    | 39 +++++--------------
 .../java/fr/istic/vv/StringUtilsTest.java     | 26 ++++++-------
 exercises/balanced-strings.md                 | 30 +++++++++-----
 exercises/test-date-class.md                  | 27 +++++++++++++
 5 files changed, 71 insertions(+), 54 deletions(-)
 create mode 100644 .vscode/settings.json

diff --git a/.vscode/settings.json b/.vscode/settings.json
new file mode 100644
index 0000000..c995aa5
--- /dev/null
+++ b/.vscode/settings.json
@@ -0,0 +1,3 @@
+{
+    "java.debug.settings.onBuildFailureProceed": true
+}
\ No newline at end of file
diff --git a/code/tp3-balanced-strings/src/main/java/fr/istic/vv/StringUtils.java b/code/tp3-balanced-strings/src/main/java/fr/istic/vv/StringUtils.java
index c0422c8..3283b75 100644
--- a/code/tp3-balanced-strings/src/main/java/fr/istic/vv/StringUtils.java
+++ b/code/tp3-balanced-strings/src/main/java/fr/istic/vv/StringUtils.java
@@ -4,7 +4,6 @@ import java.util.ArrayDeque;
 import java.util.Deque;
 import java.util.HashMap;
 import java.util.Map;
-import java.util.Queue;
 import java.util.Set;
 
 public class StringUtils {
@@ -27,39 +26,19 @@ public class StringUtils {
     public static boolean isBalanced(String str) {
         Deque<Character> balancedQueue = new ArrayDeque<Character>();
 
-        return reqIsBalanced(str, balancedQueue);
-    }
-
-
-    public static boolean reqIsBalanced(String str,Deque<Character> balancedQueue){
-        int nbRemove = 1;
-        if(str.length()>0){
-            char c=str.charAt(0);
-            while(true){
-                if(OPEN.contains(c)){
-                    balancedQueue.push(c);
-                    
-                    return reqIsBalanced(str.substring(nbRemove), balancedQueue);
+        for(int i = 0; i<str.length(); i++){
+            char c = str.charAt(i);
+            if(OPEN.contains(c)){
+                balancedQueue.push(c);
+            }
+            else if(CLOSE.contains(c)){
+                if(balancedQueue.isEmpty() || CONVERT.get(balancedQueue.pollFirst()) != c){ //vérifie et retire en même temps
+                    return false;
                 }
-                else if(CLOSE.contains(c)){
-                    if(balancedQueue.isEmpty()){
-                        return false;
-                    }
-                    else if(CONVERT.get(balancedQueue.pollFirst()) == c){
-                        return reqIsBalanced(str.substring(nbRemove),balancedQueue);
-                    }
-                    else{
-                        return false;
-                    }
-                }
-                else if(nbRemove<str.length()){
-                    c = str.charAt(nbRemove);
-                    nbRemove++;
-                }
-                else return balancedQueue.isEmpty();
             }
         }
         return balancedQueue.isEmpty();
     }
+
 }
 
diff --git a/code/tp3-balanced-strings/src/test/java/fr/istic/vv/StringUtilsTest.java b/code/tp3-balanced-strings/src/test/java/fr/istic/vv/StringUtilsTest.java
index 32b3020..b4dd714 100644
--- a/code/tp3-balanced-strings/src/test/java/fr/istic/vv/StringUtilsTest.java
+++ b/code/tp3-balanced-strings/src/test/java/fr/istic/vv/StringUtilsTest.java
@@ -8,6 +8,12 @@ import static org.junit.jupiter.api.Assertions.*;
 class StringUtilsTest {
 
 
+    @Test
+    public void testEmpty(){
+        String prog1 = "";
+        assertTrue(isBalanced(prog1));
+    }
+    
     @Test
     public void testBalancedSimple(){
         String prog1 = "()";
@@ -31,16 +37,9 @@ class StringUtilsTest {
 
     }
 
-
-    @Test
-    public void testEmpty(){
-        String prog1 = "";
-        assertTrue(isBalanced(prog1));
-    }
-
     @Test
     public void testOnlyText(){
-        String prog1 = "abc";
+        String prog1 = "test";
         String prog2 = "abc'éhçfez_énrui";
         assertTrue(isBalanced(prog1));
         assertTrue(isBalanced(prog2));
@@ -49,8 +48,8 @@ class StringUtilsTest {
     @Test
     public void testBalancedSimpleWithText(){
         String prog1 = "(abc)";
-        String prog2 = "abc'[éhçfez]_énrui";
-        String prog3 = "abc'{éhçfez_énrui<}";
+        String prog2 = "a[b]";
+        String prog3 = "aaa{aaaa}aa";
         assertTrue(isBalanced(prog1));
         assertTrue(isBalanced(prog2));
         assertTrue(isBalanced(prog3));
@@ -83,20 +82,19 @@ class StringUtilsTest {
 
     @Test
     public void testBalancedFull(){
-        String prog1 = "for(int i = 0;i<10; i++){System.out.println(\"tab[i]\");}";
+        String prog1 = "white(true){println(\"Tester c\'est pas douter\");}";
         assertTrue(isBalanced(prog1));
     }
 
     @Test
     public void testnotBalancedFullForgotClose(){
-        String prog1 = "for(int i = 0;i<10; i++{System.out.println(\"tab[i]\");}";
+        String prog1 = "white(true){println(\"Tester c\'est pas douter\";}";
         assertFalse(isBalanced(prog1));
     }
 
-
     @Test
     public void testnotBalancedFullFrogotOpen(){
-        String prog1 = "forint i = 0;i<10; i++){System.out.println(\"tab[i]\");}";
+        String prog1 = "white(true){println\"Tester c\'est pas douter\");}";
         assertFalse(isBalanced(prog1));
     }
 
diff --git a/exercises/balanced-strings.md b/exercises/balanced-strings.md
index 3f42e93..86317a1 100644
--- a/exercises/balanced-strings.md
+++ b/exercises/balanced-strings.md
@@ -28,31 +28,41 @@ Use the project in [tp3-balanced-strings](../code/tp3-balanced-strings) to compl
 
 1.
 Test simple true:
-"{}","[]","()","(a)","a[b]","" et "test"
+"()", "{}", "[]", "(abc)", "a[b]", "aaa{aaaa}aa", "" et "test"
 
 des test simple false :
-"{]","(}","[)","a{]","(b}"
+"(]", "{)", "[}", ")(", "a{]", "a()b[c]{)}"
 
 des Test avec des parenthèsé qui se suivent :
-"{}()a[a]"
+"a()b[c]{}"
 
 La même chose avec des erreur :
-"{}()a[a}"
+"a()b[c]{)}"
 
 des Test avec des parenthèse imbriqué :
-"white(true){println("Tester c'est pas douter")}
+"white(true){println("Tester c'est pas douter");}"
 
 des Test avec des oublies, d'ouverture et fermeture:
-"whitetrue){println("Tester c'est pas douter")}",
-"white(true{println("Tester c'est pas douter")}"
+"white(true){println("Tester c'est pas douter";}",
+"white(true){println"Tester c'est pas douter");}"
 
 
 2.
 avec ses tests la couverture est à 100%
 
 3.
-toutes les conditions n'ont qu'un seul opérateur boolean
+if(balancedQueue.isEmpty() || CONVERT.get(balancedQueue.pollFirst()) != c)
+if(A||B)
+
+B est exécuté que si A est vrai, sinon B lèverait une exception
+
+on a donc que 3 cas possibles :
+A B
+1 1   1
+1 0   0
+0 err 0
+
 
 4.
-
-un mutant qui remplacé un return par un return true, il s'agit du cas ou le programme avec une erreur de parenthésage fini par des caractère, ex : "(a" on peut donc le rajouter dans les "test simple"
\ No newline at end of file
+```mvn test-compile org.pitest:pitest-maven:mutationCoverage```
+Tout les mutants on été tué.
\ No newline at end of file
diff --git a/exercises/test-date-class.md b/exercises/test-date-class.md
index 76ee9cb..c9757c8 100644
--- a/exercises/test-date-class.md
+++ b/exercises/test-date-class.md
@@ -53,3 +53,30 @@ Use the project in [tp3-date](../code/tp3-date) to complete this exercise.
 
 ## Answer
 
+1.
+isLeapYear : une année bissextile est un multiple de 4, on a juste à tester un multiple de 4 et un non multiple de 4
+
+isValidDate : on a plusieurs choses à tester :
+    mois valide entre 1 et 12 : on teste donc le mois 0, le mois 10, et le mois 13
+    jour valide entre 1 et 28,29,30 ou 31 : on doit donc avoir plusieurs catégories de test :
+        -le jour 0, le jour 32, le jour 10
+        -bissextile 
+        -non bissextile  :
+        -mois en 30
+        -mois en 31
+
+constructeur Date : il doit vérifier qu'une date non valide génère une Exception, et une valide n'en génère pas
+
+nextDate : dans le même principe que isValidDate, on doit vérifier dans les mêmes cas
+
+previousDate : pareil que nextDate
+
+compareTo : On teste une différence pour un jour différent, un mois différent et une année différente.
+
+2.
+Avec la coverage, on a pu détecter une vérification redondante et une condition inutile qui généraient du code mort, et une opération boolean inutile dans une condition
+3.
+La coverage précédent nous apermis de detecter un opérateur inutile. Les autre condition n'on qu'un seul opérateure.
+
+4.
+En lançant PIT, tous les mutants générés ont été tués.
\ No newline at end of file