From 21526b822de1f6057bb57651f9a3bd31eed59d39 Mon Sep 17 00:00:00 2001 From: corelie Date: Tue, 8 Oct 2024 13:46:43 -0400 Subject: [PATCH 01/37] 3 tests --- .../java/org/jsoup/nodes/AttributeTest.java | 87 +++++++++++++++++++ .../java/org/jsoup/nodes/ElementTest.java | 15 ++++ 2 files changed, 102 insertions(+) diff --git a/src/test/java/org/jsoup/nodes/AttributeTest.java b/src/test/java/org/jsoup/nodes/AttributeTest.java index 454b3bb041..359cce3626 100644 --- a/src/test/java/org/jsoup/nodes/AttributeTest.java +++ b/src/test/java/org/jsoup/nodes/AttributeTest.java @@ -3,7 +3,16 @@ import org.jsoup.Jsoup; import org.jsoup.parser.ParseSettings; import org.jsoup.parser.Parser; +import org.jsoup.parser.Tag; +import org.jspecify.annotations.Nullable; import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.CsvSource; +import org.junit.jupiter.params.provider.MethodSource; + +import java.util.Objects; +import java.util.stream.Stream; import static org.junit.jupiter.api.Assertions.*; @@ -89,4 +98,82 @@ public void html() { Document doc2 = Jsoup.parse(html, Parser.htmlParser().settings(ParseSettings.preserveCase)); assertEquals("One", doc2.selectFirst("a").outerHtml()); } + + @ParameterizedTest + /** + * Teste la fonction getValidKey ainsi que tous les cas des deux sous fonctions qu'elle appelle: + * isValidXmlKey et isValidHtmlKey. + * Celles-ci permettent de vérifier la validité d'une clé XML ou HTML. + * Le test permet également de révéler ce qui je pense être une erreur dans le code, le charactère 174, + * qui correspond au symbole trademark est accepté comme une valeur valide de clé HTML. J'explique plus le problème + * dans le rapport. + * @author Corélie Godefroid + */ + @MethodSource("keyValidityGenerator") + public void testGetValidKey(String input, String expected, Document.OutputSettings.Syntax syntax){ + String actual=Attribute.getValidKey(input,syntax); + assertEquals(expected,actual); + + } + + /** + * génère les données pour le test testGetValidKey + * @author Corélie Godefroid + */ + private static Stream keyValidityGenerator() { + return Stream.of( + Arguments.of("!test","_test",Document.OutputSettings.Syntax.xml), + Arguments.of("te!st","te_st",Document.OutputSettings.Syntax.xml), + Arguments.of("test","test",Document.OutputSettings.Syntax.xml), + Arguments.of("",null,Document.OutputSettings.Syntax.xml), + Arguments.of("TEST","TEST",Document.OutputSettings.Syntax.xml), + Arguments.of(":test",":test",Document.OutputSettings.Syntax.xml), + Arguments.of("_test","_test",Document.OutputSettings.Syntax.xml), + Arguments.of("a_test","a_test",Document.OutputSettings.Syntax.xml), + Arguments.of("z_test","z_test",Document.OutputSettings.Syntax.xml), + Arguments.of("A_test","A_test",Document.OutputSettings.Syntax.xml), + Arguments.of("Z_test","Z_test",Document.OutputSettings.Syntax.xml), + Arguments.of("1test",null,Document.OutputSettings.Syntax.xml), + Arguments.of("",null,Document.OutputSettings.Syntax.html), + Arguments.of(new String(new char[] { 31 }), "_", Document.OutputSettings.Syntax.html) , + Arguments.of(new String(new char[] { 127 }), "_", Document.OutputSettings.Syntax.html), + Arguments.of(new String(new char[] { 159 }), "_", Document.OutputSettings.Syntax.html), + Arguments.of(" ", "_", Document.OutputSettings.Syntax.html), + Arguments.of("\"", "_", Document.OutputSettings.Syntax.html), + Arguments.of("\'", "_", Document.OutputSettings.Syntax.html), + Arguments.of("/", "_", Document.OutputSettings.Syntax.html), + Arguments.of("=", "_", Document.OutputSettings.Syntax.html), + Arguments.of("A", "A", Document.OutputSettings.Syntax.html), + Arguments.of(new String(new char[] { 174}), new String(new char[] { 174}), Document.OutputSettings.Syntax.html) + ); + } + + @ParameterizedTest + /** + * Teste la méthode equals de Attribute. + * Prends en entrée main l'Attribute qui va appeler la méthode equals avec en entrée le deuxième argument + * Object compared. Expected est la valeur attendue de cette égalité, c'est un Boolean. + */ + @MethodSource("equalsGenerator") + public void testAttributeEquals(Attribute main, Object compared, Boolean expected){ + + Boolean actual= main.equals(compared); + assertEquals(expected,actual); + } + + private static Stream equalsGenerator() { + Attribute a = new Attribute("test", null); + return Stream.of( + Arguments.of(a, a, true), //même element + Arguments.of(a, new Element("p"), false), //différente classe + Arguments.of(a, new Attribute("abc", null), false), //différente clé + Arguments.of(a, new Attribute("test", "val"), false), //différente valeur + Arguments.of(a, new Attribute("abc", "val"), false), // tout différent + Arguments.of(a, new Attribute("test", null), true), //identique + Arguments.of(a, null, false) //null + + ); + } + + } diff --git a/src/test/java/org/jsoup/nodes/ElementTest.java b/src/test/java/org/jsoup/nodes/ElementTest.java index de35495ff1..46139b4518 100644 --- a/src/test/java/org/jsoup/nodes/ElementTest.java +++ b/src/test/java/org/jsoup/nodes/ElementTest.java @@ -1539,6 +1539,21 @@ public void elementByTagName() { assertEquals("P", a.tagName()); } + + @Test + /** + * Teste l'instanciation d'un Element avec un namespace spécifique. + * Crée l'élément via le constructeur de classe correspondant ( qui n'était préalablement pas testé) + * Fait deux assert pour vérifier que le tagname et le namespace sont bien attribués + * @author Corélie Godefroid + */ + public void testCreateElementWithNamespace(){ + Element a = new Element( "comments","fb"); + Tag tag_de_a=a.tag(); + assertEquals("fb",tag_de_a.namespace()); + assertEquals("comments",a.tagName()); + } + @Test public void testChildrenElements() { String html = "

One

Two

Three
Four"; From b288242cb6c8705215803c34ddb7b612e65b2998 Mon Sep 17 00:00:00 2001 From: corelie Date: Tue, 8 Oct 2024 16:22:26 -0400 Subject: [PATCH 02/37] 2 autres tests --- pom.xml | 7 ++++ .../java/org/jsoup/helper/ValidateTest.java | 37 +++++++++++++++++++ .../java/org/jsoup/nodes/AttributeTest.java | 34 ++++++++++++++++- 3 files changed, 76 insertions(+), 2 deletions(-) diff --git a/pom.xml b/pom.xml index 988d836d72..0b777e66ff 100644 --- a/pom.xml +++ b/pom.xml @@ -451,6 +451,13 @@ 1.0.0 provided + + + + com.github.javafaker + javafaker + 1.0.2 + diff --git a/src/test/java/org/jsoup/helper/ValidateTest.java b/src/test/java/org/jsoup/helper/ValidateTest.java index c7a093c358..babc237fe8 100644 --- a/src/test/java/org/jsoup/helper/ValidateTest.java +++ b/src/test/java/org/jsoup/helper/ValidateTest.java @@ -43,4 +43,41 @@ public void testNotNull() { } assertTrue(threw); } + +@Test +/** + * Teste les 2 fonctions notEmpty et la fonction notEmptyParam de Validate. Ces 3 fonctions font exactement la même chose, + * ce pourquoi j'ai jugé bon de les réunir dans un même test. Les trois prennent en entrée un string vérifie s'il est vide + * et si oui jettent une Exception. La seule différence est le message affiché, le premier notEmpty n'en affiche pas, + * le second prends un string en entrée et l'affiche et notEmptyParam prends le nom du paramètre en entrée et l'affiche + * dans le message. + * + * Le test vérifie que l'Exception est bien lancée et que le bon message est affiché si le string est vide ou null. + * Il vérifie également qu'aucune exception n'est levée en cas de string valide. + * @author Corélie Godefroid + */ + public void testNotEmpty(){ + String test_null=null; + String test_empty=""; + String test_ok="test"; + + + ValidationException exception1 = assertThrows(ValidationException.class, () -> {Validate.notEmpty(test_null,"null");}); + ValidationException exception2 = assertThrows(ValidationException.class, () -> {Validate.notEmpty(test_empty,"empty");}); + ValidationException exception3 = assertThrows(ValidationException.class, () -> {Validate.notEmptyParam(test_null,"nullParam");}); + ValidationException exception4 = assertThrows(ValidationException.class, () -> {Validate.notEmptyParam(test_empty,"emptyParam");}); + + assertEquals("null", exception1.getMessage()); + assertEquals("empty", exception2.getMessage()); + assertEquals("The 'nullParam' parameter must not be empty.", exception3.getMessage()); + assertEquals("The 'emptyParam' parameter must not be empty.", exception4.getMessage()); + + assertThrows(ValidationException.class, () -> {Validate.notEmpty(test_null);}); + assertThrows(ValidationException.class, () -> {Validate.notEmpty(test_empty);}); + + assertDoesNotThrow(() -> {Validate.notEmpty(test_ok);}); + assertDoesNotThrow(() -> {Validate.notEmpty(test_ok,"ok");}); + assertDoesNotThrow(() -> {Validate.notEmptyParam(test_ok,"okParam");}); + +} } diff --git a/src/test/java/org/jsoup/nodes/AttributeTest.java b/src/test/java/org/jsoup/nodes/AttributeTest.java index 359cce3626..3ce49ab240 100644 --- a/src/test/java/org/jsoup/nodes/AttributeTest.java +++ b/src/test/java/org/jsoup/nodes/AttributeTest.java @@ -1,4 +1,5 @@ package org.jsoup.nodes; +import com.github.javafaker.Faker; import org.jsoup.Jsoup; import org.jsoup.parser.ParseSettings; @@ -153,6 +154,9 @@ private static Stream keyValidityGenerator() { * Teste la méthode equals de Attribute. * Prends en entrée main l'Attribute qui va appeler la méthode equals avec en entrée le deuxième argument * Object compared. Expected est la valeur attendue de cette égalité, c'est un Boolean. + * + * Le test applique la fonction equals sur main et compared et vérifie le resultat de cette égalité. + * @author Corélie Godefroid */ @MethodSource("equalsGenerator") public void testAttributeEquals(Attribute main, Object compared, Boolean expected){ @@ -161,8 +165,16 @@ public void testAttributeEquals(Attribute main, Object compared, Boolean expecte assertEquals(expected,actual); } + /** + * génère les données pour le test testAttributeEquals, utilisa la bibliothèque java-faker pour créer des données + * aléatoires. + * @author Corélie Godefroid + */ private static Stream equalsGenerator() { Attribute a = new Attribute("test", null); + Faker faker = new Faker(); + String key = faker.regexify("[a-z]{1,10}"); + String value = faker.regexify("[a-z]{1,10}"); return Stream.of( Arguments.of(a, a, true), //même element Arguments.of(a, new Element("p"), false), //différente classe @@ -170,10 +182,28 @@ private static Stream equalsGenerator() { Arguments.of(a, new Attribute("test", "val"), false), //différente valeur Arguments.of(a, new Attribute("abc", "val"), false), // tout différent Arguments.of(a, new Attribute("test", null), true), //identique - Arguments.of(a, null, false) //null + Arguments.of(a, null, false),//null + Arguments.of( new Attribute(key,value), new Attribute(key,value),true) //généré aléatoirement mais égaux ); } + @Test + /** + * Teste la fonction clone de la classe Attribute. Génère un objet Attribute avec une clé et une valeur aléatoires + * grâce à la bibliothèque java-faker. Clone cet objet Attribute puis compare le clone et l'objet original. + * @author Corélie Godefroid + */ + public void testAttributeClone(){ + Faker faker = new Faker(); + String key = faker.regexify("[a-z]{1,10}"); + String value = faker.regexify("[a-z]{1,10}"); + Attribute a = new Attribute(key,value); + + Attribute clone_a= a.clone(); + + assertTrue(a.equals(clone_a)); + + + } - } From 968bf62e0b941c08c0028f06a4a918a097c8750c Mon Sep 17 00:00:00 2001 From: corelie Date: Tue, 8 Oct 2024 18:19:12 -0400 Subject: [PATCH 03/37] changements dans les commentaires --- src/test/java/org/jsoup/helper/ValidateTest.java | 2 +- src/test/java/org/jsoup/nodes/AttributeTest.java | 9 +++++---- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/src/test/java/org/jsoup/helper/ValidateTest.java b/src/test/java/org/jsoup/helper/ValidateTest.java index babc237fe8..18dce9c7fd 100644 --- a/src/test/java/org/jsoup/helper/ValidateTest.java +++ b/src/test/java/org/jsoup/helper/ValidateTest.java @@ -46,7 +46,7 @@ public void testNotNull() { @Test /** - * Teste les 2 fonctions notEmpty et la fonction notEmptyParam de Validate. Ces 3 fonctions font exactement la même chose, + * Teste les 2 méthodes notEmpty et la méthode notEmptyParam de Validate. Ces 3 méthodes font exactement la même chose, * ce pourquoi j'ai jugé bon de les réunir dans un même test. Les trois prennent en entrée un string vérifie s'il est vide * et si oui jettent une Exception. La seule différence est le message affiché, le premier notEmpty n'en affiche pas, * le second prends un string en entrée et l'affiche et notEmptyParam prends le nom du paramètre en entrée et l'affiche diff --git a/src/test/java/org/jsoup/nodes/AttributeTest.java b/src/test/java/org/jsoup/nodes/AttributeTest.java index 3ce49ab240..ccc104ca70 100644 --- a/src/test/java/org/jsoup/nodes/AttributeTest.java +++ b/src/test/java/org/jsoup/nodes/AttributeTest.java @@ -105,9 +105,9 @@ public void html() { * Teste la fonction getValidKey ainsi que tous les cas des deux sous fonctions qu'elle appelle: * isValidXmlKey et isValidHtmlKey. * Celles-ci permettent de vérifier la validité d'une clé XML ou HTML. - * Le test permet également de révéler ce qui je pense être une erreur dans le code, le charactère 174, - * qui correspond au symbole trademark est accepté comme une valeur valide de clé HTML. J'explique plus le problème - * dans le rapport. + * Le test permet également de révéler ce qui je pense être une erreur dans le code,le symbole >, + * est accepté comme une valeur valide de clé HTML.Je n'ai pas modifié le test pour pouvoir les rouler en automatique. + * J'explique plus le problème dans le rapport. * @author Corélie Godefroid */ @MethodSource("keyValidityGenerator") @@ -145,7 +145,8 @@ private static Stream keyValidityGenerator() { Arguments.of("/", "_", Document.OutputSettings.Syntax.html), Arguments.of("=", "_", Document.OutputSettings.Syntax.html), Arguments.of("A", "A", Document.OutputSettings.Syntax.html), - Arguments.of(new String(new char[] { 174}), new String(new char[] { 174}), Document.OutputSettings.Syntax.html) + Arguments.of(new String(new char[] { 174}), new String(new char[] { 174}), Document.OutputSettings.Syntax.html), + Arguments.of(">", ">", Document.OutputSettings.Syntax.html) //est accepte dans le code actuel mais normalement devrait retourner "_" ); } From 28d2fb66d2eea757c2c0d41ea524b0055c774e34 Mon Sep 17 00:00:00 2001 From: corelie Date: Tue, 8 Oct 2024 18:27:14 -0400 Subject: [PATCH 04/37] =?UTF-8?q?Rapport=20partie=20Cor=C3=A9lie?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Tache2_README.md | 52 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 52 insertions(+) create mode 100644 Tache2_README.md diff --git a/Tache2_README.md b/Tache2_README.md new file mode 100644 index 0000000000..4bdc4ca27e --- /dev/null +++ b/Tache2_README.md @@ -0,0 +1,52 @@ +# Tâche #2 +### Mariel Leano -20218008 Corélie Godefroid -20205217 +### Choix de l'étude de cas : jsoup + +# Explications des tests: + + +## 1. testCreateElementWithNamespace() +[Lien du test](https://github.com/Corelie/jsoup/blob/b288242cb6c8705215803c34ddb7b612e65b2998/src/test/java/org/jsoup/nodes/ElementTest.java#L1543-L1555) +Ce test a pour but de tester le constructeur suivant de la classe Element: + + public Element(String tag, String namespace) { + this(Tag.valueOf(tag, namespace, ParseSettings.preserveCase), null);} + +Ce constructeur a pour but de créer un objet Element dans un namespace spécifique. +Étant donné qu'il s'agit du constructeur de cette classe il est crucial de le tester pour vérifier qu'il fait exactement ce qu'il est supposé faire, c'est à dire créer correctement l'Element voulu. Si cette fonction malfonctionne sans que l'on ne s'en rende compte c'est toute la classe Element et tout le code qui en dépends qui serait sujet à des bugs. + +Nous avons donc créé un test simple pour vérifier que ce constructeur fait bien ce qui est attendu de lui, ce test crée un nouvel Element et ensuite vérifie que les valeurs que nous lui avons données lui ont bien été attribuées. + +## 2. testGetValidKey() +[Lien du test](https://github.com/Corelie/jsoup/blob/968bf62e0b941c08c0028f06a4a918a097c8750c/src/test/java/org/jsoup/nodes/AttributeTest.java#L103-L151) +Ce test a pour but de tester la méthode getValidKey() de la classe Attribute. Il teste également les deux méthodes appelées par celle-ci : isValidXmlKey et isValidHtmlKey. + +La méthode getValidKey() est une méthode très importante de la classe Attribute puisqu'elle permet de vérifié si la clé d'un attribut html ou xml corresponds à un format valide et la transforme si elle ne l'est pas. + +Nous avons donc créé un test paramétré permettant de tester toutes les valeurs limites possibles d'une clé HTML et XML afin de s'assurer que les méthodes fonctionnaient correctement. + +Ce processus nous a effectivement permis de trouver une erreur dans le code. La fonction isValidHtmlKey considère le symbole ">" comme pouvant faire partie d'une clé d'attribut html valide. +Or en lisant la [documentation d'html](https://html.spec.whatwg.org/multipage/syntax.html#attributes-2) pour nous assurer que la méthode correspondait bien aux standards, nous avons découvert que le symbole ">" était explicitement mentionné comme ne pouvant pas faire partie d'une clé valide: + +> "Attributes have a name and a value. Attribute names must consist of one or more characters **other than** controls, U+0020 SPACE, U+0022 ("), U+0027 ('), **U+003E (>)**, U+002F (/), U+003D (=), and noncharacters." + +Cette erreur montre bien l'importance des tests pour cette méthode. + +## 3. testAttributeEquals() +[Lien du test](https://github.com/Corelie/jsoup/blob/968bf62e0b941c08c0028f06a4a918a097c8750c/src/test/java/org/jsoup/nodes/AttributeTest.java#L153-L190) +Ce test a pour but de tester la méthode equals() de la classe Attribute. Cette méthode vient définir l'égalité entre deux objets Attribute. Étant donné qu'elle est utilisé à de nombreux endroits dans le code et notamment dans des tests (puisque assertEquals() de deux Attribute vient utiliser cette méthode) il est très important de s'assurer de son bon fonctionnement. +Nous avons utilisé un test paramétré pour tester tous les cas de non égalité ou d'égalité, ainsi que la bibliothèque java-faker pour générer des cas différents. + +## 4. testAttributeClone() +[Lien du test](https://github.com/Corelie/jsoup/blob/968bf62e0b941c08c0028f06a4a918a097c8750c/src/test/java/org/jsoup/nodes/AttributeTest.java#L191-L208) +Ce test vérifie la méthode clone() de la classe Attribute. +Cette méthode est utilisée à plusieurs endroits dans le code il est donc important de s'assurer de son bon fonctionnement. +Nous utilisons la bibliothèque java-faker pour génerer un objet Attribute à chaque test, nous appliquons la méthode clone() dessus puis testons pour vérifier qu'il est bien égal à l'original. + +## 5. testNotEmpty() +[Lien du test](https://github.com/Corelie/jsoup/blob/968bf62e0b941c08c0028f06a4a918a097c8750c/src/test/java/org/jsoup/helper/ValidateTest.java#L47-L82) +Ce test valide les 2 méthodes notEmpty et la méthode notEmptyParam de la classe Validate. Ces 3 méthodes font exactement la même chose, c'est pourquoi nous avons jugé bon de les réunir dans un même test. Les trois prennent en entrée un string vérifie s'il est vide et si oui lancent une exception. La seule différence est le message affiché: le premier notEmpty n'en affiche pas, le second prends un string en entrée et l'affiche et notEmptyParam prends le nom du paramètre en entrée et l'affiche dans le message. + +Ces méthodes notEmpty vérifient la validité de strings à de nombreux endroits dans le code, il est donc important de vérifier qu'elles fonctionnent correctement sinon ce sont de grosses parties du code qui ne sont pas validées correctement. + +Le test vérifie que l'exception est bien lancée et que le bon message est affiché si le string est vide ou null. Il vérifie également qu'aucune exception n'est levée en cas de string valide. From 58720f8fa52c2e75d633ddd124304e9551f39f1e Mon Sep 17 00:00:00 2001 From: Corelie <91093459+Corelie@users.noreply.github.com> Date: Tue, 8 Oct 2024 18:28:32 -0400 Subject: [PATCH 05/37] Update Tache2_README.md --- Tache2_README.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/Tache2_README.md b/Tache2_README.md index 4bdc4ca27e..3c9ff805cb 100644 --- a/Tache2_README.md +++ b/Tache2_README.md @@ -7,6 +7,7 @@ ## 1. testCreateElementWithNamespace() [Lien du test](https://github.com/Corelie/jsoup/blob/b288242cb6c8705215803c34ddb7b612e65b2998/src/test/java/org/jsoup/nodes/ElementTest.java#L1543-L1555) + Ce test a pour but de tester le constructeur suivant de la classe Element: public Element(String tag, String namespace) { @@ -19,6 +20,7 @@ Nous avons donc créé un test simple pour vérifier que ce constructeur fait bi ## 2. testGetValidKey() [Lien du test](https://github.com/Corelie/jsoup/blob/968bf62e0b941c08c0028f06a4a918a097c8750c/src/test/java/org/jsoup/nodes/AttributeTest.java#L103-L151) + Ce test a pour but de tester la méthode getValidKey() de la classe Attribute. Il teste également les deux méthodes appelées par celle-ci : isValidXmlKey et isValidHtmlKey. La méthode getValidKey() est une méthode très importante de la classe Attribute puisqu'elle permet de vérifié si la clé d'un attribut html ou xml corresponds à un format valide et la transforme si elle ne l'est pas. @@ -34,17 +36,20 @@ Cette erreur montre bien l'importance des tests pour cette méthode. ## 3. testAttributeEquals() [Lien du test](https://github.com/Corelie/jsoup/blob/968bf62e0b941c08c0028f06a4a918a097c8750c/src/test/java/org/jsoup/nodes/AttributeTest.java#L153-L190) + Ce test a pour but de tester la méthode equals() de la classe Attribute. Cette méthode vient définir l'égalité entre deux objets Attribute. Étant donné qu'elle est utilisé à de nombreux endroits dans le code et notamment dans des tests (puisque assertEquals() de deux Attribute vient utiliser cette méthode) il est très important de s'assurer de son bon fonctionnement. Nous avons utilisé un test paramétré pour tester tous les cas de non égalité ou d'égalité, ainsi que la bibliothèque java-faker pour générer des cas différents. ## 4. testAttributeClone() [Lien du test](https://github.com/Corelie/jsoup/blob/968bf62e0b941c08c0028f06a4a918a097c8750c/src/test/java/org/jsoup/nodes/AttributeTest.java#L191-L208) + Ce test vérifie la méthode clone() de la classe Attribute. Cette méthode est utilisée à plusieurs endroits dans le code il est donc important de s'assurer de son bon fonctionnement. Nous utilisons la bibliothèque java-faker pour génerer un objet Attribute à chaque test, nous appliquons la méthode clone() dessus puis testons pour vérifier qu'il est bien égal à l'original. ## 5. testNotEmpty() [Lien du test](https://github.com/Corelie/jsoup/blob/968bf62e0b941c08c0028f06a4a918a097c8750c/src/test/java/org/jsoup/helper/ValidateTest.java#L47-L82) + Ce test valide les 2 méthodes notEmpty et la méthode notEmptyParam de la classe Validate. Ces 3 méthodes font exactement la même chose, c'est pourquoi nous avons jugé bon de les réunir dans un même test. Les trois prennent en entrée un string vérifie s'il est vide et si oui lancent une exception. La seule différence est le message affiché: le premier notEmpty n'en affiche pas, le second prends un string en entrée et l'affiche et notEmptyParam prends le nom du paramètre en entrée et l'affiche dans le message. Ces méthodes notEmpty vérifient la validité de strings à de nombreux endroits dans le code, il est donc important de vérifier qu'elles fonctionnent correctement sinon ce sont de grosses parties du code qui ne sont pas validées correctement. From 906af7edadbaac67e4152ca2e3e85b5bb28cefb1 Mon Sep 17 00:00:00 2001 From: MarielLF <91103465+MarielLF@users.noreply.github.com> Date: Wed, 9 Oct 2024 18:29:36 -0400 Subject: [PATCH 06/37] Update HtmlTreeBuilderStateTest.java --- .../parser/HtmlTreeBuilderStateTest.java | 159 ++++++++++++++++++ 1 file changed, 159 insertions(+) diff --git a/src/test/java/org/jsoup/parser/HtmlTreeBuilderStateTest.java b/src/test/java/org/jsoup/parser/HtmlTreeBuilderStateTest.java index cb09e458cf..f2def50066 100644 --- a/src/test/java/org/jsoup/parser/HtmlTreeBuilderStateTest.java +++ b/src/test/java/org/jsoup/parser/HtmlTreeBuilderStateTest.java @@ -5,12 +5,25 @@ import org.jsoup.parser.HtmlTreeBuilderState.Constants; import org.junit.jupiter.api.Test; +import org.jsoup.parser.Parser; +import org.jsoup.parser.HtmlTreeBuilder; +import org.jsoup.parser.Token; +import org.jsoup.parser.HtmlTreeBuilderState; +import java.io.StringReader; +import java.io.Reader; +import java.lang.String; +import org.jsoup.nodes.Attributes; +import org.jsoup.nodes.Element; + + + import java.lang.reflect.Field; import java.lang.reflect.Modifier; import java.util.ArrayList; import java.util.Arrays; import java.util.List; + import static org.jsoup.parser.HtmlTreeBuilderState.Constants.InBodyStartInputAttribs; import static org.junit.jupiter.api.Assertions.*; @@ -112,4 +125,150 @@ public void nestedAnchorElements02() { "", s); } + + /** + * This test verifies the behavior of the HtmlTreeBuilderState.BeforeHead state. + * It checks how different token types, such as whitespace, comments, and tags, + * are processed in the BeforeHead state. + * @author Mariel Leano + */ + @Test + public void testBeforeHeadStateProcess() { + HtmlTreeBuilder treeBuilder = new HtmlTreeBuilder(); + StringReader reader = new StringReader(""); + Parser parser = Parser.htmlParser(); + treeBuilder.initialiseParse(reader, "http://example.com", parser); + + Token.Character whitespaceToken = new Token.Character(); + whitespaceToken.data(" "); + assertTrue(HtmlTreeBuilderState.BeforeHead.process(whitespaceToken, treeBuilder)); + + Token.Comment commentToken = new Token.Comment(); + commentToken.append("This is a comment"); + assertTrue(HtmlTreeBuilderState.BeforeHead.process(commentToken, treeBuilder)); + + Token.Doctype doctypeToken = new Token.Doctype(); + assertFalse(HtmlTreeBuilderState.BeforeHead.process(doctypeToken, treeBuilder)); + + Token.StartTag htmlStartTag = new Token.StartTag(treeBuilder); + htmlStartTag.name("html"); + assertTrue(HtmlTreeBuilderState.BeforeHead.process(htmlStartTag, treeBuilder)); + + Token.StartTag headStartTag = new Token.StartTag(treeBuilder); + headStartTag.name("head"); + assertTrue(HtmlTreeBuilderState.BeforeHead.process(headStartTag, treeBuilder)); + + Token.EndTag headEndTag = new Token.EndTag(treeBuilder); + headEndTag.name("head"); + assertTrue(HtmlTreeBuilderState.BeforeHead.process(headEndTag, treeBuilder)); + + Token.EndTag bodyEndTag = new Token.EndTag(treeBuilder); + bodyEndTag.name("body"); + assertTrue(HtmlTreeBuilderState.BeforeHead.process(bodyEndTag, treeBuilder)); + } + + /** + * This test ensures that the tag is properly handled in the InBody state. + * It checks if the tag is processed correctly and added to the active + * formatting elements stack. + * @author Mariel Leano + */ + @Test + public void testProcessNobrTagInTreeBuilder() { + HtmlTreeBuilder tb = new HtmlTreeBuilder(); + StringReader reader = new StringReader(""); + Parser parser = new Parser(tb); + tb.initialiseParse(reader, "", parser); + + Token.StartTag htmlTag = new Token.StartTag(tb).nameAttr("html", new Attributes()); + tb.process(htmlTag, HtmlTreeBuilderState.InBody); + Token.StartTag bodyTag = new Token.StartTag(tb).nameAttr("body", new Attributes()); + tb.process(bodyTag, HtmlTreeBuilderState.InBody); + Token.StartTag startTag = new Token.StartTag(tb).nameAttr("nobr", new Attributes()); + + boolean result = tb.process(startTag, HtmlTreeBuilderState.InBody); + + assertTrue(result); + assertTrue(tb.getActiveFormattingElement("nobr") != null); + } + + /** + * This test checks how the HtmlTreeBuilder handles the tag in the InBody state. + * It verifies if the tag is correctly pushed to and popped from the stack. + * @author Mariel Leano + */ + @Test + public void testInBodyStartApplets() { + HtmlTreeBuilder tb = new HtmlTreeBuilder(); + Parser parser = new Parser(tb); + + tb.initialiseParse(new StringReader(""), "", parser); + Token.StartTag startTag = new Token.StartTag(tb); + startTag.nameAttr("applet", new Attributes()); + tb.process(startTag); + + assertTrue(tb.onStack("applet"), "Should contain applet in the stack"); + Token.EndTag endTag = new Token.EndTag(tb); + endTag.name("applet"); + boolean result = tb.process(endTag); + + assertTrue(result, "Should have processed applet end tag successfully"); + assertFalse(tb.onStack("applet"), "Should not contain applet in the stack after closing"); + } + + /** + * This test ensures that the end tag is not processed when the parser + * is inside a element. It checks for proper handling in the InCaption state. + * @author Mariel Leano + */ + @Test + void testProcessEndTagCaptionInCaption() { + HtmlTreeBuilder tb = new HtmlTreeBuilder(); + Parser parser = new Parser(tb); + tb.initialiseParse(new StringReader(""), "", parser); + + tb.transition(HtmlTreeBuilderState.InCaption); + + Token.EndTag endTag = new Token.EndTag(tb); + endTag.name("caption"); + + boolean result = tb.process(endTag); + + assertFalse(result, "Processing of the 'caption' end tag should not be successful"); + } + + /** + * This test verifies that the end tag is correctly processed in the InColumnGroup state. + * It ensures that the HtmlTreeBuilder processes the end tag of the colgroup element properly. + * @author Mariel Leano + */ + @Test + public void testProcessEndTagColgroup() { + HtmlTreeBuilder tb = new HtmlTreeBuilder(); + Parser parser = new Parser(tb); + + tb.initialiseParse(new StringReader("
"), "", parser); + + Token.StartTag tableStartTag = new Token.StartTag(tb); + tableStartTag.name("table"); + tb.process(tableStartTag); + + Token.StartTag colgroupStartTag = new Token.StartTag(tb); + colgroupStartTag.name("colgroup"); + tb.process(colgroupStartTag); + + Token.EndTag colgroupEndTag = new Token.EndTag(tb); + colgroupEndTag.name("colgroup"); + + boolean result = HtmlTreeBuilderState.InColumnGroup.process(colgroupEndTag, tb); + + assertTrue(result, "Processing of 'colgroup' end tag should succeed."); + } + + + + + + + } \ No newline at end of file From 02ce46807abc01440496ce4e8ea67e2a27be49c9 Mon Sep 17 00:00:00 2001 From: corelie Date: Wed, 9 Oct 2024 18:41:22 -0400 Subject: [PATCH 07/37] Update Tache2_README.md --- Tache2_README.md | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/Tache2_README.md b/Tache2_README.md index 4bdc4ca27e..0ffa15bf3e 100644 --- a/Tache2_README.md +++ b/Tache2_README.md @@ -2,9 +2,22 @@ ### Mariel Leano -20218008 Corélie Godefroid -20205217 ### Choix de l'étude de cas : jsoup +## Coverage sans l'ajout de nos tests +|fichier|class|method|line| branch | +|---|---|---|---|-----------------| +| general |96% (254/263)|92% (1730/1879)|89% (8342/9296)| 85% (8360/9806) | +|Element|100% (3/3)|99% (152/153)|99% (496/499)| 96% (556/576) | +| Attribute| 100% (1/1)|80% (21/26)|87% (87/100)| 75% (158/208) | +|Validate|100% (1/1)|83% (15/18)| 78% (37/47)| 76% (52/68) | +| HtmlTreeBuilderState| 96% (26/27)|98% (70/71)|87% (1155/1323)| 82% (1418/1720) | # Explications des tests: +general: class 96% (254/263) method 92% (1730/1879) line 89% (8342/9296) branch 85% (8360/9806) +element : class 100% (3/3) method 99% (152/153) line 99% (496/499) branch 96% (556/576) +Attribute: class 100% (1/1) method 80% (21/26) line 87% (87/100) branch 75% (158/208) +Validate : class 100% (1/1) method 83% (15/18) line 78% (37/47) branch 76% (52/68) +HtmlTreeBuilderState: class 96% (26/27) method 98% (70/71) line 87% (1155/1323) branch 82% (1418/1720) ## 1. testCreateElementWithNamespace() [Lien du test](https://github.com/Corelie/jsoup/blob/b288242cb6c8705215803c34ddb7b612e65b2998/src/test/java/org/jsoup/nodes/ElementTest.java#L1543-L1555) Ce test a pour but de tester le constructeur suivant de la classe Element: From 0f168e82a2ff0c3de364d48e9c51a3a84cc566d3 Mon Sep 17 00:00:00 2001 From: MarielLF <91103465+MarielLF@users.noreply.github.com> Date: Wed, 9 Oct 2024 18:51:34 -0400 Subject: [PATCH 08/37] Update Tache2_README.md Rapport 5 derniers tests --- Tache2_README.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/Tache2_README.md b/Tache2_README.md index 8f5a6da353..38c0f77318 100644 --- a/Tache2_README.md +++ b/Tache2_README.md @@ -18,7 +18,7 @@ element : class 100% (3/3) method 99% (152/153) line 99% (496/499) branch 96% (5 Attribute: class 100% (1/1) method 80% (21/26) line 87% (87/100) branch 75% (158/208) Validate : class 100% (1/1) method 83% (15/18) line 78% (37/47) branch 76% (52/68) HtmlTreeBuilderState: class 96% (26/27) method 98% (70/71) line 87% (1155/1323) branch 82% (1418/1720) -## 1. testCreateElementWithNamespace() +## 6. testCreateElementWithNamespace() [Lien du test](https://github.com/Corelie/jsoup/blob/b288242cb6c8705215803c34ddb7b612e65b2998/src/test/java/org/jsoup/nodes/ElementTest.java#L1543-L1555) Ce test a pour but de tester le constructeur suivant de la classe Element: @@ -31,7 +31,7 @@ Ce constructeur a pour but de créer un objet Element dans un namespace spécifi Nous avons donc créé un test simple pour vérifier que ce constructeur fait bien ce qui est attendu de lui, ce test crée un nouvel Element et ensuite vérifie que les valeurs que nous lui avons données lui ont bien été attribuées. -## 2. testGetValidKey() +## 7. testGetValidKey() [Lien du test](https://github.com/Corelie/jsoup/blob/968bf62e0b941c08c0028f06a4a918a097c8750c/src/test/java/org/jsoup/nodes/AttributeTest.java#L103-L151) Ce test a pour but de tester la méthode getValidKey() de la classe Attribute. Il teste également les deux méthodes appelées par celle-ci : isValidXmlKey et isValidHtmlKey. @@ -47,20 +47,20 @@ Or en lisant la [documentation d'html](https://html.spec.whatwg.org/multipage/sy Cette erreur montre bien l'importance des tests pour cette méthode. -## 3. testAttributeEquals() +## 8. testAttributeEquals() [Lien du test](https://github.com/Corelie/jsoup/blob/968bf62e0b941c08c0028f06a4a918a097c8750c/src/test/java/org/jsoup/nodes/AttributeTest.java#L153-L190) Ce test a pour but de tester la méthode equals() de la classe Attribute. Cette méthode vient définir l'égalité entre deux objets Attribute. Étant donné qu'elle est utilisé à de nombreux endroits dans le code et notamment dans des tests (puisque assertEquals() de deux Attribute vient utiliser cette méthode) il est très important de s'assurer de son bon fonctionnement. Nous avons utilisé un test paramétré pour tester tous les cas de non égalité ou d'égalité, ainsi que la bibliothèque java-faker pour générer des cas différents. -## 4. testAttributeClone() +## 9. testAttributeClone() [Lien du test](https://github.com/Corelie/jsoup/blob/968bf62e0b941c08c0028f06a4a918a097c8750c/src/test/java/org/jsoup/nodes/AttributeTest.java#L191-L208) Ce test vérifie la méthode clone() de la classe Attribute. Cette méthode est utilisée à plusieurs endroits dans le code il est donc important de s'assurer de son bon fonctionnement. Nous utilisons la bibliothèque java-faker pour génerer un objet Attribute à chaque test, nous appliquons la méthode clone() dessus puis testons pour vérifier qu'il est bien égal à l'original. -## 5. testNotEmpty() +## 10. testNotEmpty() [Lien du test](https://github.com/Corelie/jsoup/blob/968bf62e0b941c08c0028f06a4a918a097c8750c/src/test/java/org/jsoup/helper/ValidateTest.java#L47-L82) Ce test valide les 2 méthodes notEmpty et la méthode notEmptyParam de la classe Validate. Ces 3 méthodes font exactement la même chose, c'est pourquoi nous avons jugé bon de les réunir dans un même test. Les trois prennent en entrée un string vérifie s'il est vide et si oui lancent une exception. La seule différence est le message affiché: le premier notEmpty n'en affiche pas, le second prends un string en entrée et l'affiche et notEmptyParam prends le nom du paramètre en entrée et l'affiche dans le message. From 07c9394f0daba9a093334b65302f8b74228f8332 Mon Sep 17 00:00:00 2001 From: corelie Date: Wed, 9 Oct 2024 18:52:12 -0400 Subject: [PATCH 09/37] Tableau after coverage --- Tache2_README.md | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/Tache2_README.md b/Tache2_README.md index 8f5a6da353..5a6d655987 100644 --- a/Tache2_README.md +++ b/Tache2_README.md @@ -10,14 +10,18 @@ | Attribute| 100% (1/1)|80% (21/26)|87% (87/100)| 75% (158/208) | |Validate|100% (1/1)|83% (15/18)| 78% (37/47)| 76% (52/68) | | HtmlTreeBuilderState| 96% (26/27)|98% (70/71)|87% (1155/1323)| 82% (1418/1720) | -# Explications des tests: +## Coverage après l'ajout de nos tests +|fichier|class| method | line | branch | +|---|---|-------------|-----------------|-----------------| +| general |96% (254/263)| 92% (1733/1879) | 90% (8377/9296) | 86% (8440/9806) | +|Element|100% (3/3)| 100% (153/153) | 99% (498/499) | 96% (556/576) | +| Attribute| 100% (1/1)| 88% (23/26) | 92% (92/100) | 95% (198/208) | +|Validate|100% (1/1)| 83% (15/18) | 80% (38/47) | 85% (58/68) | +| HtmlTreeBuilderState| 96% (26/27)| 98% (70/71) | 89% (1181/1323) | 84% (1450/1720) | + +# Explications des tests: -general: class 96% (254/263) method 92% (1730/1879) line 89% (8342/9296) branch 85% (8360/9806) -element : class 100% (3/3) method 99% (152/153) line 99% (496/499) branch 96% (556/576) -Attribute: class 100% (1/1) method 80% (21/26) line 87% (87/100) branch 75% (158/208) -Validate : class 100% (1/1) method 83% (15/18) line 78% (37/47) branch 76% (52/68) -HtmlTreeBuilderState: class 96% (26/27) method 98% (70/71) line 87% (1155/1323) branch 82% (1418/1720) ## 1. testCreateElementWithNamespace() [Lien du test](https://github.com/Corelie/jsoup/blob/b288242cb6c8705215803c34ddb7b612e65b2998/src/test/java/org/jsoup/nodes/ElementTest.java#L1543-L1555) From 0209e311bd18b6dd1a0b5eb9801bd8657433c82a Mon Sep 17 00:00:00 2001 From: MarielLF <91103465+MarielLF@users.noreply.github.com> Date: Wed, 9 Oct 2024 18:57:33 -0400 Subject: [PATCH 10/37] Update Tache2_README.md Correction du rapport 5 derniers tests --- Tache2_README.md | 45 ++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 40 insertions(+), 5 deletions(-) diff --git a/Tache2_README.md b/Tache2_README.md index 38c0f77318..5a5172b016 100644 --- a/Tache2_README.md +++ b/Tache2_README.md @@ -18,7 +18,7 @@ element : class 100% (3/3) method 99% (152/153) line 99% (496/499) branch 96% (5 Attribute: class 100% (1/1) method 80% (21/26) line 87% (87/100) branch 75% (158/208) Validate : class 100% (1/1) method 83% (15/18) line 78% (37/47) branch 76% (52/68) HtmlTreeBuilderState: class 96% (26/27) method 98% (70/71) line 87% (1155/1323) branch 82% (1418/1720) -## 6. testCreateElementWithNamespace() +## 1. testCreateElementWithNamespace() [Lien du test](https://github.com/Corelie/jsoup/blob/b288242cb6c8705215803c34ddb7b612e65b2998/src/test/java/org/jsoup/nodes/ElementTest.java#L1543-L1555) Ce test a pour but de tester le constructeur suivant de la classe Element: @@ -31,7 +31,7 @@ Ce constructeur a pour but de créer un objet Element dans un namespace spécifi Nous avons donc créé un test simple pour vérifier que ce constructeur fait bien ce qui est attendu de lui, ce test crée un nouvel Element et ensuite vérifie que les valeurs que nous lui avons données lui ont bien été attribuées. -## 7. testGetValidKey() +## 2. testGetValidKey() [Lien du test](https://github.com/Corelie/jsoup/blob/968bf62e0b941c08c0028f06a4a918a097c8750c/src/test/java/org/jsoup/nodes/AttributeTest.java#L103-L151) Ce test a pour but de tester la méthode getValidKey() de la classe Attribute. Il teste également les deux méthodes appelées par celle-ci : isValidXmlKey et isValidHtmlKey. @@ -47,20 +47,20 @@ Or en lisant la [documentation d'html](https://html.spec.whatwg.org/multipage/sy Cette erreur montre bien l'importance des tests pour cette méthode. -## 8. testAttributeEquals() +## 3. testAttributeEquals() [Lien du test](https://github.com/Corelie/jsoup/blob/968bf62e0b941c08c0028f06a4a918a097c8750c/src/test/java/org/jsoup/nodes/AttributeTest.java#L153-L190) Ce test a pour but de tester la méthode equals() de la classe Attribute. Cette méthode vient définir l'égalité entre deux objets Attribute. Étant donné qu'elle est utilisé à de nombreux endroits dans le code et notamment dans des tests (puisque assertEquals() de deux Attribute vient utiliser cette méthode) il est très important de s'assurer de son bon fonctionnement. Nous avons utilisé un test paramétré pour tester tous les cas de non égalité ou d'égalité, ainsi que la bibliothèque java-faker pour générer des cas différents. -## 9. testAttributeClone() +## 4. testAttributeClone() [Lien du test](https://github.com/Corelie/jsoup/blob/968bf62e0b941c08c0028f06a4a918a097c8750c/src/test/java/org/jsoup/nodes/AttributeTest.java#L191-L208) Ce test vérifie la méthode clone() de la classe Attribute. Cette méthode est utilisée à plusieurs endroits dans le code il est donc important de s'assurer de son bon fonctionnement. Nous utilisons la bibliothèque java-faker pour génerer un objet Attribute à chaque test, nous appliquons la méthode clone() dessus puis testons pour vérifier qu'il est bien égal à l'original. -## 10. testNotEmpty() +## 5. testNotEmpty() [Lien du test](https://github.com/Corelie/jsoup/blob/968bf62e0b941c08c0028f06a4a918a097c8750c/src/test/java/org/jsoup/helper/ValidateTest.java#L47-L82) Ce test valide les 2 méthodes notEmpty et la méthode notEmptyParam de la classe Validate. Ces 3 méthodes font exactement la même chose, c'est pourquoi nous avons jugé bon de les réunir dans un même test. Les trois prennent en entrée un string vérifie s'il est vide et si oui lancent une exception. La seule différence est le message affiché: le premier notEmpty n'en affiche pas, le second prends un string en entrée et l'affiche et notEmptyParam prends le nom du paramètre en entrée et l'affiche dans le message. @@ -68,3 +68,38 @@ Ce test valide les 2 méthodes notEmpty et la méthode notEmptyParam de la class Ces méthodes notEmpty vérifient la validité de strings à de nombreux endroits dans le code, il est donc important de vérifier qu'elles fonctionnent correctement sinon ce sont de grosses parties du code qui ne sont pas validées correctement. Le test vérifie que l'exception est bien lancée et que le bon message est affiché si le string est vide ou null. Il vérifie également qu'aucune exception n'est levée en cas de string valide. + +## 6. testBeforeHeadStateProcess() +[Lien du test](https://github.com/MarielLeano/jsoup/blob/main/src/test/java/org/jsoup/parser/HtmlTreeBuilderStateTest.java) + +Ce test vise à vérifier le comportement de l'état BeforeHead dans le HtmlTreeBuilder lors du traitement de différents types de tokens. Nous testons ici les cas suivants : + + un token de type espace blanc, + un commentaire, + une balise de début html et head, + et une balise de fin inattendue telle que body. + +Ces tests sont cruciaux pour s'assurer que le constructeur gère correctement la phase BeforeHead, permettant un traitement fluide des documents HTML bien formés ou mal formés dès le début de la construction du DOM. + +## 7. testProcessNobrTagInTreeBuilder() +[Lien du test](https://github.com/MarielLeano/jsoup/blob/main/src/test/java/org/jsoup/parser/HtmlTreeBuilderStateTest.java) + +Ce test vérifie le comportement du HtmlTreeBuilder lors du traitement de la balise nobr dans l'état InBody. La balise nobr est utilisée pour interdire le retour à la ligne dans une section de texte. Le test simule un document HTML contenant les balises html, body, et nobr, et s'assure que la balise est bien gérée et ajoutée aux éléments de formatage actif. Ce test est essentiel pour garantir que le constructeur traite correctement les balises non standards ou spécifiques. + + +## 8. testInBodyStartApplets() +[Lien du test](https://github.com/MarielLeano/jsoup/blob/main/src/test/java/org/jsoup/parser/HtmlTreeBuilderStateTest.java) + +Ce test examine comment le HtmlTreeBuilder traite la balise applet dans l'état InBody. Cette balise, rarement utilisée, est gérée de manière spéciale dans les documents HTML. Le test simule l'ouverture d'une balise applet, vérifie qu'elle est ajoutée à la pile d'éléments ouverts, puis simule la fermeture de la balise pour s'assurer qu'elle est correctement retirée de la pile. Ce test garantit que la gestion des balises obsolètes comme applet est bien prise en charge par le parser. + + +## 9. testProcessEndTagCaptionInCaption() +[Lien du test](https://github.com/MarielLeano/jsoup/blob/main/src/test/java/org/jsoup/parser/HtmlTreeBuilderStateTest.java) + +Ce test est conçu pour vérifier le comportement du HtmlTreeBuilder lorsqu'il rencontre une balise de fin caption dans l'état InCaption. La balise caption est utilisée dans les tableaux HTML pour donner un titre aux éléments. Ce test vérifie que la fermeture d'une balise caption dans cet état échoue comme prévu, assurant ainsi une gestion correcte des erreurs et des structures mal formées dans le DOM. + + +## 10. testProcessEndTagColgroup() +[Lien du test](https://github.com/MarielLeano/jsoup/blob/main/src/test/java/org/jsoup/parser/HtmlTreeBuilderStateTest.java) + +Ce test valide le traitement des balises de fin colgroup dans l'état InColumnGroup. La balise colgroup est utilisée dans les tableaux HTML pour spécifier un groupe de colonnes avec un format particulier. Le test simule un document HTML contenant une balise table et une balise colgroup, puis vérifie que la balise de fin colgroup est traitée correctement, garantissant ainsi que les tableaux HTML sont construits conformément aux spécifications du DOM. From 1d37e60fad63b757c322fab555838c9413c68735 Mon Sep 17 00:00:00 2001 From: Corelie <91093459+Corelie@users.noreply.github.com> Date: Wed, 9 Oct 2024 19:09:11 -0400 Subject: [PATCH 11/37] Update Tache2_README.md --- Tache2_README.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/Tache2_README.md b/Tache2_README.md index 7c488ff3b5..5206085043 100644 --- a/Tache2_README.md +++ b/Tache2_README.md @@ -74,7 +74,7 @@ Ces méthodes notEmpty vérifient la validité de strings à de nombreux endroit Le test vérifie que l'exception est bien lancée et que le bon message est affiché si le string est vide ou null. Il vérifie également qu'aucune exception n'est levée en cas de string valide. ## 6. testBeforeHeadStateProcess() -[Lien du test](https://github.com/MarielLeano/jsoup/blob/main/src/test/java/org/jsoup/parser/HtmlTreeBuilderStateTest.java) +[Lien du test](https://github.com/Corelie/jsoup/blob/deb8e4482feea981ee052b7c414a5122cb4d9093/src/test/java/org/jsoup/parser/HtmlTreeBuilderStateTest.java#L129-L169) Ce test vise à vérifier le comportement de l'état BeforeHead dans le HtmlTreeBuilder lors du traitement de différents types de tokens. Nous testons ici les cas suivants : @@ -86,24 +86,24 @@ Ce test vise à vérifier le comportement de l'état BeforeHead dans le HtmlTree Ces tests sont cruciaux pour s'assurer que le constructeur gère correctement la phase BeforeHead, permettant un traitement fluide des documents HTML bien formés ou mal formés dès le début de la construction du DOM. ## 7. testProcessNobrTagInTreeBuilder() -[Lien du test](https://github.com/MarielLeano/jsoup/blob/main/src/test/java/org/jsoup/parser/HtmlTreeBuilderStateTest.java) +[Lien du test](https://github.com/Corelie/jsoup/blob/deb8e4482feea981ee052b7c414a5122cb4d9093/src/test/java/org/jsoup/parser/HtmlTreeBuilderStateTest.java#L170-L193) Ce test vérifie le comportement du HtmlTreeBuilder lors du traitement de la balise nobr dans l'état InBody. La balise nobr est utilisée pour interdire le retour à la ligne dans une section de texte. Le test simule un document HTML contenant les balises html, body, et nobr, et s'assure que la balise est bien gérée et ajoutée aux éléments de formatage actif. Ce test est essentiel pour garantir que le constructeur traite correctement les balises non standards ou spécifiques. ## 8. testInBodyStartApplets() -[Lien du test](https://github.com/MarielLeano/jsoup/blob/main/src/test/java/org/jsoup/parser/HtmlTreeBuilderStateTest.java) +[Lien du test](https://github.com/Corelie/jsoup/blob/deb8e4482feea981ee052b7c414a5122cb4d9093/src/test/java/org/jsoup/parser/HtmlTreeBuilderStateTest.java#L195-L217) Ce test examine comment le HtmlTreeBuilder traite la balise applet dans l'état InBody. Cette balise, rarement utilisée, est gérée de manière spéciale dans les documents HTML. Le test simule l'ouverture d'une balise applet, vérifie qu'elle est ajoutée à la pile d'éléments ouverts, puis simule la fermeture de la balise pour s'assurer qu'elle est correctement retirée de la pile. Ce test garantit que la gestion des balises obsolètes comme applet est bien prise en charge par le parser. ## 9. testProcessEndTagCaptionInCaption() -[Lien du test](https://github.com/MarielLeano/jsoup/blob/main/src/test/java/org/jsoup/parser/HtmlTreeBuilderStateTest.java) +[Lien du test](https://github.com/Corelie/jsoup/blob/deb8e4482feea981ee052b7c414a5122cb4d9093/src/test/java/org/jsoup/parser/HtmlTreeBuilderStateTest.java#L219-L238) Ce test est conçu pour vérifier le comportement du HtmlTreeBuilder lorsqu'il rencontre une balise de fin caption dans l'état InCaption. La balise caption est utilisée dans les tableaux HTML pour donner un titre aux éléments. Ce test vérifie que la fermeture d'une balise caption dans cet état échoue comme prévu, assurant ainsi une gestion correcte des erreurs et des structures mal formées dans le DOM. ## 10. testProcessEndTagColgroup() -[Lien du test](https://github.com/MarielLeano/jsoup/blob/main/src/test/java/org/jsoup/parser/HtmlTreeBuilderStateTest.java) +[Lien du test](https://github.com/Corelie/jsoup/blob/deb8e4482feea981ee052b7c414a5122cb4d9093/src/test/java/org/jsoup/parser/HtmlTreeBuilderStateTest.java#L240-L266) Ce test valide le traitement des balises de fin colgroup dans l'état InColumnGroup. La balise colgroup est utilisée dans les tableaux HTML pour spécifier un groupe de colonnes avec un format particulier. Le test simule un document HTML contenant une balise table et une balise colgroup, puis vérifie que la balise de fin colgroup est traitée correctement, garantissant ainsi que les tableaux HTML sont construits conformément aux spécifications du DOM. From 6b60830cef6eb38307d824c411964c1cfd4fbcea Mon Sep 17 00:00:00 2001 From: corelie Date: Mon, 11 Nov 2024 18:02:26 -0500 Subject: [PATCH 12/37] ajout du flag ea --- .github/workflows/testTache31.yml | 50 +++++++++++++++++++++++++++++++ 1 file changed, 50 insertions(+) create mode 100644 .github/workflows/testTache31.yml diff --git a/.github/workflows/testTache31.yml b/.github/workflows/testTache31.yml new file mode 100644 index 0000000000..7efa1d914d --- /dev/null +++ b/.github/workflows/testTache31.yml @@ -0,0 +1,50 @@ +name: TestTache31 +on: + push: + pull_request: + +jobs: + test: + runs-on: ${{ matrix.os }} + strategy: + matrix: + os: [ubuntu-latest] + # choosing to run a reduced set of LTS, current, and next, to balance coverage and execution time + java: [17] + fail-fast: false + name: Test JDK ${{ matrix.java }}, ${{ matrix.os }} + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Set up JDK ${{ matrix.java }} + uses: actions/setup-java@v4 + with: + java-version: ${{ matrix.java }} + distribution: 'zulu' + cache: 'maven' + + - name: Maven Compile + run: mvn -X compile -B --file pom.xml + + - name: Maven Verify + run: mvn -X verify -B --file pom.xml + env: + JAVA_TOOL_OPTIONS: "-ea" + + - name: Get JaCoCo Coverage + id: coverage + run: | + coverage=$(python3 config/coverage.py target/site/jacoco/jacoco.csv) + echo "COVERAGE=$coverage" >> $GITHUB_ENV + + - name: Fail if coverage has not improved. + run: | + coverage=$COVERAGE + threshold=90.41 + if (( $(echo "$coverage - $threshold <= 0.1" | bc -l) )); then + echo "Coverage has not improved." + exit 1 + else + echo "New coverage: $coverage%" + fi From b4dfbefb8c9ce9a4496be9c1d56fc997bb0eb6f8 Mon Sep 17 00:00:00 2001 From: corelie Date: Mon, 11 Nov 2024 18:09:35 -0500 Subject: [PATCH 13/37] changement flag Xmx --- .github/workflows/testTache31.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/testTache31.yml b/.github/workflows/testTache31.yml index 7efa1d914d..e0afe4bcbb 100644 --- a/.github/workflows/testTache31.yml +++ b/.github/workflows/testTache31.yml @@ -30,7 +30,7 @@ jobs: - name: Maven Verify run: mvn -X verify -B --file pom.xml env: - JAVA_TOOL_OPTIONS: "-ea" + JAVA_TOOL_OPTIONS: "-Xmx2g" - name: Get JaCoCo Coverage id: coverage From 8d241828f11f57980d44faed2ccac710018d6a3d Mon Sep 17 00:00:00 2001 From: corelie Date: Mon, 11 Nov 2024 18:14:23 -0500 Subject: [PATCH 14/37] ajout Xms 1g --- .github/workflows/testTache31.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/testTache31.yml b/.github/workflows/testTache31.yml index e0afe4bcbb..a5569f07c4 100644 --- a/.github/workflows/testTache31.yml +++ b/.github/workflows/testTache31.yml @@ -30,7 +30,7 @@ jobs: - name: Maven Verify run: mvn -X verify -B --file pom.xml env: - JAVA_TOOL_OPTIONS: "-Xmx2g" + JAVA_TOOL_OPTIONS: "-Xmx2g -Xms1g" - name: Get JaCoCo Coverage id: coverage From db9a7332c890b2889464fdac5fc5b9c83b682540 Mon Sep 17 00:00:00 2001 From: corelie Date: Mon, 11 Nov 2024 18:18:07 -0500 Subject: [PATCH 15/37] ajout flag log garbage collector --- .github/workflows/testTache32.yml | 50 +++++++++++++++++++++++++++++++ 1 file changed, 50 insertions(+) create mode 100644 .github/workflows/testTache32.yml diff --git a/.github/workflows/testTache32.yml b/.github/workflows/testTache32.yml new file mode 100644 index 0000000000..41e9ef8acd --- /dev/null +++ b/.github/workflows/testTache32.yml @@ -0,0 +1,50 @@ +name: TestTache32 +on: + push: + pull_request: + +jobs: + test: + runs-on: ${{ matrix.os }} + strategy: + matrix: + os: [ubuntu-latest] + # choosing to run a reduced set of LTS, current, and next, to balance coverage and execution time + java: [17] + fail-fast: false + name: Test JDK ${{ matrix.java }}, ${{ matrix.os }} + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Set up JDK ${{ matrix.java }} + uses: actions/setup-java@v4 + with: + java-version: ${{ matrix.java }} + distribution: 'zulu' + cache: 'maven' + + - name: Maven Compile + run: mvn -X compile -B --file pom.xml + + - name: Maven Verify + run: mvn -X verify -B --file pom.xml + env: + JAVA_TOOL_OPTIONS: "-XX:+PrintGCDetails -XX:+PrintGCDateStamps" + + - name: Get JaCoCo Coverage + id: coverage + run: | + coverage=$(python3 config/coverage.py target/site/jacoco/jacoco.csv) + echo "COVERAGE=$coverage" >> $GITHUB_ENV + + - name: Fail if coverage has not improved. + run: | + coverage=$COVERAGE + threshold=90.41 + if (( $(echo "$coverage - $threshold <= 0.1" | bc -l) )); then + echo "Coverage has not improved." + exit 1 + else + echo "New coverage: $coverage%" + fi From 59a6fe8cd14acdbc6200a3f42210b95a58ea04c0 Mon Sep 17 00:00:00 2001 From: corelie Date: Mon, 11 Nov 2024 18:22:19 -0500 Subject: [PATCH 16/37] retire gc datestamp --- .github/workflows/testTache32.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/testTache32.yml b/.github/workflows/testTache32.yml index 41e9ef8acd..624b2e5187 100644 --- a/.github/workflows/testTache32.yml +++ b/.github/workflows/testTache32.yml @@ -30,7 +30,7 @@ jobs: - name: Maven Verify run: mvn -X verify -B --file pom.xml env: - JAVA_TOOL_OPTIONS: "-XX:+PrintGCDetails -XX:+PrintGCDateStamps" + JAVA_TOOL_OPTIONS: "-XX:+PrintGCDetails" - name: Get JaCoCo Coverage id: coverage From bbb78534146a18943cc613b0f94ff383f54f6ccc Mon Sep 17 00:00:00 2001 From: corelie Date: Mon, 11 Nov 2024 18:29:22 -0500 Subject: [PATCH 17/37] ajout test out of memory error --- .github/workflows/testTache33.yml | 50 +++++++++++++++++++++++++++++++ 1 file changed, 50 insertions(+) create mode 100644 .github/workflows/testTache33.yml diff --git a/.github/workflows/testTache33.yml b/.github/workflows/testTache33.yml new file mode 100644 index 0000000000..4dd520d5c9 --- /dev/null +++ b/.github/workflows/testTache33.yml @@ -0,0 +1,50 @@ +name: TestTache32 +on: + push: + pull_request: + +jobs: + test: + runs-on: ${{ matrix.os }} + strategy: + matrix: + os: [ubuntu-latest] + # choosing to run a reduced set of LTS, current, and next, to balance coverage and execution time + java: [17] + fail-fast: false + name: Test JDK ${{ matrix.java }}, ${{ matrix.os }} + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Set up JDK ${{ matrix.java }} + uses: actions/setup-java@v4 + with: + java-version: ${{ matrix.java }} + distribution: 'zulu' + cache: 'maven' + + - name: Maven Compile + run: mvn -X compile -B --file pom.xml + + - name: Maven Verify + run: mvn -X verify -B --file pom.xml + env: + JAVA_TOOL_OPTIONS: "-XX:+ExitOnOutOfMemoryError" + + - name: Get JaCoCo Coverage + id: coverage + run: | + coverage=$(python3 config/coverage.py target/site/jacoco/jacoco.csv) + echo "COVERAGE=$coverage" >> $GITHUB_ENV + + - name: Fail if coverage has not improved. + run: | + coverage=$COVERAGE + threshold=90.41 + if (( $(echo "$coverage - $threshold <= 0.1" | bc -l) )); then + echo "Coverage has not improved." + exit 1 + else + echo "New coverage: $coverage%" + fi From 6903b7cd6a9b0176d84e3f19f936b45a08ae7416 Mon Sep 17 00:00:00 2001 From: corelie Date: Mon, 11 Nov 2024 18:41:20 -0500 Subject: [PATCH 18/37] Ajout exit on error --- .github/workflows/testTache33.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/testTache33.yml b/.github/workflows/testTache33.yml index 4dd520d5c9..4bf648142f 100644 --- a/.github/workflows/testTache33.yml +++ b/.github/workflows/testTache33.yml @@ -1,4 +1,4 @@ -name: TestTache32 +name: TestTache33 on: push: pull_request: @@ -30,7 +30,7 @@ jobs: - name: Maven Verify run: mvn -X verify -B --file pom.xml env: - JAVA_TOOL_OPTIONS: "-XX:+ExitOnOutOfMemoryError" + JAVA_TOOL_OPTIONS: "-XX:+ExitOnOutOfMemoryError -XX:+ExitOnError" - name: Get JaCoCo Coverage id: coverage From 98e060bb7ed151fc62e5bb5a9aaf4b1cc88efe63 Mon Sep 17 00:00:00 2001 From: corelie Date: Mon, 11 Nov 2024 18:50:34 -0500 Subject: [PATCH 19/37] ajout des logs et modification flag garbage collector --- .github/workflows/testTache31.yml | 4 ++++ .github/workflows/testTache32.yml | 6 +++++- .github/workflows/testTache33.yml | 7 ++++++- 3 files changed, 15 insertions(+), 2 deletions(-) diff --git a/.github/workflows/testTache31.yml b/.github/workflows/testTache31.yml index a5569f07c4..3ab1b97471 100644 --- a/.github/workflows/testTache31.yml +++ b/.github/workflows/testTache31.yml @@ -32,6 +32,10 @@ jobs: env: JAVA_TOOL_OPTIONS: "-Xmx2g -Xms1g" + - name: Flags supplementaires utilisees + run: | + echo "Les flags supplementaires utilises sont : -Xmx2g -Xms1g" + - name: Get JaCoCo Coverage id: coverage run: | diff --git a/.github/workflows/testTache32.yml b/.github/workflows/testTache32.yml index 624b2e5187..d53bc6e789 100644 --- a/.github/workflows/testTache32.yml +++ b/.github/workflows/testTache32.yml @@ -30,7 +30,11 @@ jobs: - name: Maven Verify run: mvn -X verify -B --file pom.xml env: - JAVA_TOOL_OPTIONS: "-XX:+PrintGCDetails" + JAVA_TOOL_OPTIONS: "-Xlog:gc*" + + - name: Flags supplementaires utilisees + run: | + echo "Les flags supplementaires utilises sont : -Xlog:gc*" - name: Get JaCoCo Coverage id: coverage diff --git a/.github/workflows/testTache33.yml b/.github/workflows/testTache33.yml index 4bf648142f..24358abd59 100644 --- a/.github/workflows/testTache33.yml +++ b/.github/workflows/testTache33.yml @@ -30,7 +30,12 @@ jobs: - name: Maven Verify run: mvn -X verify -B --file pom.xml env: - JAVA_TOOL_OPTIONS: "-XX:+ExitOnOutOfMemoryError -XX:+ExitOnError" + JAVA_TOOL_OPTIONS: "-XX:+ExitOnOutOfMemoryError " + + - name: Flags supplementaires utilisees + run: | + echo "Les flags supplementaires utilises sont : -XX:+ExitOnOutOfMemoryError" + - name: Get JaCoCo Coverage id: coverage From dc947e3bbf23c965a872c9c43d6d614b35d8a3ee Mon Sep 17 00:00:00 2001 From: corelie Date: Tue, 12 Nov 2024 14:37:25 -0500 Subject: [PATCH 20/37] ajoutheap dump et test des xmx et xms --- .github/workflows/testTache32.yml | 2 +- .github/workflows/testTache33.yml | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/testTache32.yml b/.github/workflows/testTache32.yml index d53bc6e789..f2c3b6156a 100644 --- a/.github/workflows/testTache32.yml +++ b/.github/workflows/testTache32.yml @@ -30,7 +30,7 @@ jobs: - name: Maven Verify run: mvn -X verify -B --file pom.xml env: - JAVA_TOOL_OPTIONS: "-Xlog:gc*" + JAVA_TOOL_OPTIONS: "-Xlog:gc* -Xmx2g -Xms1g" - name: Flags supplementaires utilisees run: | diff --git a/.github/workflows/testTache33.yml b/.github/workflows/testTache33.yml index 24358abd59..e443bd0346 100644 --- a/.github/workflows/testTache33.yml +++ b/.github/workflows/testTache33.yml @@ -30,11 +30,11 @@ jobs: - name: Maven Verify run: mvn -X verify -B --file pom.xml env: - JAVA_TOOL_OPTIONS: "-XX:+ExitOnOutOfMemoryError " + JAVA_TOOL_OPTIONS: "-XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=./java_pid_heap_dump.hprof -XX:+ExitOnOutOfMemoryError " - name: Flags supplementaires utilisees run: | - echo "Les flags supplementaires utilises sont : -XX:+ExitOnOutOfMemoryError" + echo "Les flags supplementaires utilises sont : -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=./java_pid_heap_dump.hprof -XX:+ExitOnOutOfMemoryError" - name: Get JaCoCo Coverage From 0a4e9e03207d82818e580e6802973ddbbd06df8c Mon Sep 17 00:00:00 2001 From: corelie Date: Tue, 12 Nov 2024 14:42:47 -0500 Subject: [PATCH 21/37] test xmx5g --- .github/workflows/testTache31.yml | 4 ++-- .github/workflows/testTache32.yml | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/testTache31.yml b/.github/workflows/testTache31.yml index 3ab1b97471..33e3b866a8 100644 --- a/.github/workflows/testTache31.yml +++ b/.github/workflows/testTache31.yml @@ -30,11 +30,11 @@ jobs: - name: Maven Verify run: mvn -X verify -B --file pom.xml env: - JAVA_TOOL_OPTIONS: "-Xmx2g -Xms1g" + JAVA_TOOL_OPTIONS: "-Xmx5g -Xms1g" - name: Flags supplementaires utilisees run: | - echo "Les flags supplementaires utilises sont : -Xmx2g -Xms1g" + echo "Les flags supplementaires utilises sont : -Xmx5g -Xms1g" - name: Get JaCoCo Coverage id: coverage diff --git a/.github/workflows/testTache32.yml b/.github/workflows/testTache32.yml index f2c3b6156a..51bf70b17b 100644 --- a/.github/workflows/testTache32.yml +++ b/.github/workflows/testTache32.yml @@ -30,7 +30,7 @@ jobs: - name: Maven Verify run: mvn -X verify -B --file pom.xml env: - JAVA_TOOL_OPTIONS: "-Xlog:gc* -Xmx2g -Xms1g" + JAVA_TOOL_OPTIONS: "-Xlog:gc* " - name: Flags supplementaires utilisees run: | From a49ef3142698c9251fd72659393b06196742bda6 Mon Sep 17 00:00:00 2001 From: corelie Date: Tue, 12 Nov 2024 14:51:34 -0500 Subject: [PATCH 22/37] Update testTache31.yml --- .github/workflows/testTache31.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/testTache31.yml b/.github/workflows/testTache31.yml index 33e3b866a8..e069cc608c 100644 --- a/.github/workflows/testTache31.yml +++ b/.github/workflows/testTache31.yml @@ -30,7 +30,7 @@ jobs: - name: Maven Verify run: mvn -X verify -B --file pom.xml env: - JAVA_TOOL_OPTIONS: "-Xmx5g -Xms1g" + JAVA_TOOL_OPTIONS: "-Xmx1g -Xms1g" - name: Flags supplementaires utilisees run: | From add2d9a206d6fd73f093c12701bbb183912c44a3 Mon Sep 17 00:00:00 2001 From: corelie Date: Tue, 12 Nov 2024 14:55:21 -0500 Subject: [PATCH 23/37] test xlog dans test 1 et ajoutreadMe --- .github/workflows/testTache31.yml | 2 +- Tache3_README.md | 0 2 files changed, 1 insertion(+), 1 deletion(-) create mode 100644 Tache3_README.md diff --git a/.github/workflows/testTache31.yml b/.github/workflows/testTache31.yml index e069cc608c..e14905c0af 100644 --- a/.github/workflows/testTache31.yml +++ b/.github/workflows/testTache31.yml @@ -30,7 +30,7 @@ jobs: - name: Maven Verify run: mvn -X verify -B --file pom.xml env: - JAVA_TOOL_OPTIONS: "-Xmx1g -Xms1g" + JAVA_TOOL_OPTIONS: "-Xmx1g -Xms1g -Xlog:gc*" - name: Flags supplementaires utilisees run: | diff --git a/Tache3_README.md b/Tache3_README.md new file mode 100644 index 0000000000..e69de29bb2 From 2e26554968cab5e460c4d8d35f1911b0cae2b604 Mon Sep 17 00:00:00 2001 From: corelie Date: Tue, 12 Nov 2024 15:10:09 -0500 Subject: [PATCH 24/37] test use string cache --- .github/workflows/testTache31.yml | 4 ++-- .github/workflows/testTache32.yml | 2 +- .github/workflows/testTache33.yml | 2 +- Tache3_README.md | 11 +++++++++++ 4 files changed, 15 insertions(+), 4 deletions(-) diff --git a/.github/workflows/testTache31.yml b/.github/workflows/testTache31.yml index e14905c0af..a3cb76790c 100644 --- a/.github/workflows/testTache31.yml +++ b/.github/workflows/testTache31.yml @@ -1,4 +1,4 @@ -name: TestTache31 +name: Action1Tache3 on: push: pull_request: @@ -30,7 +30,7 @@ jobs: - name: Maven Verify run: mvn -X verify -B --file pom.xml env: - JAVA_TOOL_OPTIONS: "-Xmx1g -Xms1g -Xlog:gc*" + JAVA_TOOL_OPTIONS: "-XX:+UseStringCache" - name: Flags supplementaires utilisees run: | diff --git a/.github/workflows/testTache32.yml b/.github/workflows/testTache32.yml index 51bf70b17b..41c357ac06 100644 --- a/.github/workflows/testTache32.yml +++ b/.github/workflows/testTache32.yml @@ -1,4 +1,4 @@ -name: TestTache32 +name: Action2Tache3 on: push: pull_request: diff --git a/.github/workflows/testTache33.yml b/.github/workflows/testTache33.yml index e443bd0346..cce8fd96c4 100644 --- a/.github/workflows/testTache33.yml +++ b/.github/workflows/testTache33.yml @@ -1,4 +1,4 @@ -name: TestTache33 +name: Action3Tache3 on: push: pull_request: diff --git a/Tache3_README.md b/Tache3_README.md index e69de29bb2..6511d0057a 100644 --- a/Tache3_README.md +++ b/Tache3_README.md @@ -0,0 +1,11 @@ +# Tâche #3 +### Mariel Leano -20218008 Corélie Godefroid -20205217 +### Choix de l'étude de cas : jsoup + +# Explications des flags choisis: + +## Action 1 Tâche_3: + +## Action 2 Tâche_3: + +## Action 3 Tâche_3: \ No newline at end of file From 872312fa047e4a792e05c58dfd7b2d6534b75548 Mon Sep 17 00:00:00 2001 From: corelie Date: Tue, 12 Nov 2024 15:16:00 -0500 Subject: [PATCH 25/37] remplace string cache par string deduplication --- .github/workflows/testTache31.yml | 2 +- Tache3_README.md | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/.github/workflows/testTache31.yml b/.github/workflows/testTache31.yml index a3cb76790c..bc2e2d76c3 100644 --- a/.github/workflows/testTache31.yml +++ b/.github/workflows/testTache31.yml @@ -30,7 +30,7 @@ jobs: - name: Maven Verify run: mvn -X verify -B --file pom.xml env: - JAVA_TOOL_OPTIONS: "-XX:+UseStringCache" + JAVA_TOOL_OPTIONS: "-XX:+StringDeduplication" - name: Flags supplementaires utilisees run: | diff --git a/Tache3_README.md b/Tache3_README.md index 6511d0057a..5ae990e088 100644 --- a/Tache3_README.md +++ b/Tache3_README.md @@ -6,6 +6,8 @@ ## Action 1 Tâche_3: +Cette action utilise + ## Action 2 Tâche_3: ## Action 3 Tâche_3: \ No newline at end of file From 0986a66d191dffe70c269af3e1083dce5edbc429 Mon Sep 17 00:00:00 2001 From: corelie Date: Tue, 12 Nov 2024 15:19:34 -0500 Subject: [PATCH 26/37] Update testTache31.yml --- .github/workflows/testTache31.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/testTache31.yml b/.github/workflows/testTache31.yml index bc2e2d76c3..eb05be3768 100644 --- a/.github/workflows/testTache31.yml +++ b/.github/workflows/testTache31.yml @@ -30,7 +30,7 @@ jobs: - name: Maven Verify run: mvn -X verify -B --file pom.xml env: - JAVA_TOOL_OPTIONS: "-XX:+StringDeduplication" + JAVA_TOOL_OPTIONS: "-XX:+UseG1GC -XX:+UseStringDeduplication -XX:+PrintStringDeduplicationStatistics" - name: Flags supplementaires utilisees run: | From 776e00bb5d45b6256c815408c55e08214db6a716 Mon Sep 17 00:00:00 2001 From: corelie Date: Tue, 12 Nov 2024 15:22:01 -0500 Subject: [PATCH 27/37] Update testTache31.yml --- .github/workflows/testTache31.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/testTache31.yml b/.github/workflows/testTache31.yml index eb05be3768..294e4b6fd8 100644 --- a/.github/workflows/testTache31.yml +++ b/.github/workflows/testTache31.yml @@ -30,7 +30,7 @@ jobs: - name: Maven Verify run: mvn -X verify -B --file pom.xml env: - JAVA_TOOL_OPTIONS: "-XX:+UseG1GC -XX:+UseStringDeduplication -XX:+PrintStringDeduplicationStatistics" + JAVA_TOOL_OPTIONS: "-XX:+UseG1GC -XX:+UseStringDeduplication " - name: Flags supplementaires utilisees run: | From 5deefa82e52f25e8ccfab3f39553316d896d588d Mon Sep 17 00:00:00 2001 From: corelie Date: Tue, 12 Nov 2024 15:43:32 -0500 Subject: [PATCH 28/37] read me + coverage dans le log de l'action --- .github/workflows/testTache31.yml | 9 +++++---- Tache3_README.md | 9 ++++++++- 2 files changed, 13 insertions(+), 5 deletions(-) diff --git a/.github/workflows/testTache31.yml b/.github/workflows/testTache31.yml index 294e4b6fd8..fcacab9795 100644 --- a/.github/workflows/testTache31.yml +++ b/.github/workflows/testTache31.yml @@ -32,10 +32,6 @@ jobs: env: JAVA_TOOL_OPTIONS: "-XX:+UseG1GC -XX:+UseStringDeduplication " - - name: Flags supplementaires utilisees - run: | - echo "Les flags supplementaires utilises sont : -Xmx5g -Xms1g" - - name: Get JaCoCo Coverage id: coverage run: | @@ -52,3 +48,8 @@ jobs: else echo "New coverage: $coverage%" fi + + - name: Flags supplementaires utilisees + run: | + echo "Les flags supplementaires utilises sont : -XX:+UseG1GC -XX:+UseStringDeduplication " + echo "Le coverage est de : $coverage" diff --git a/Tache3_README.md b/Tache3_README.md index 5ae990e088..da11a4c135 100644 --- a/Tache3_README.md +++ b/Tache3_README.md @@ -6,8 +6,15 @@ ## Action 1 Tâche_3: -Cette action utilise +Cette action utilise les flags: ## Action 2 Tâche_3: +Cette action utilise le flag -Xlog:gc*. +Ce flag permet d'imprimer toutes les actions effectuées par le garbage collector et combien de temps elles durent. C'est une fonctionnalité particulièrement utile afin de surveiller les performances du garbage collector et de la taille de la heap. En effet, en ayant une heap trop petite le garbage collector est obligé de la vider très souvent ce qui emmène un temps de pause au total très long, car les pauses sont trop fréquentes. Au contraire en ayant une heap trop importante les pauses du grabage collector sont moins fréquentes mais très longues. Il faut trouver le bon juste milieu et cela ne peut-être fait qu'on observant les log du garbage collector. +Il est également bon d'observer son fonctionement afin de pouvoir vérifier que le garbage collector est bien optimisé et qu'aucun changment brusque dans ses performances n'apparait (ce qui pourrait indiquer un problème autre part). + +Personnellement ce flag a pu me servir dans mon travail sur cette tâche, j'essayait initialement d'optimiser la taille de la heap puis la vitesse du garbage collector avant de me rendre compte, grâce aux comparaisons avec cette action (qui avait le flag -Xlog:gc* d'activé), que mes changements n'amélioraient pas vraiment les performance puisque la heap et le garbage collector étaient déjà assez bien optimisé. J'ai donc pu me concentrer sur l'exploration de d'autres flags de la JVM à la place. + +Ce flag permet donc d'améliorer l'observabilité du code. ## Action 3 Tâche_3: \ No newline at end of file From e6fd2c7ad0e2d54878d6d936941c05096a59b343 Mon Sep 17 00:00:00 2001 From: corelie Date: Tue, 12 Nov 2024 16:01:55 -0500 Subject: [PATCH 29/37] Update testTache31.yml --- .github/workflows/testTache31.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/testTache31.yml b/.github/workflows/testTache31.yml index fcacab9795..114b8c9663 100644 --- a/.github/workflows/testTache31.yml +++ b/.github/workflows/testTache31.yml @@ -49,7 +49,8 @@ jobs: echo "New coverage: $coverage%" fi - - name: Flags supplementaires utilisees + - name: Flags supplementaires utilises run: | + coverage=$COVERAGE echo "Les flags supplementaires utilises sont : -XX:+UseG1GC -XX:+UseStringDeduplication " echo "Le coverage est de : $coverage" From 109f6a67a14b3a12ee589c8f5dea6eeccf2898de Mon Sep 17 00:00:00 2001 From: corelie Date: Tue, 12 Nov 2024 16:35:27 -0500 Subject: [PATCH 30/37] read me corelie et log des actions --- .github/workflows/testTache32.yml | 10 ++++++---- .github/workflows/testTache33.yml | 10 ++++++---- Tache3_README.md | 33 +++++++++++++++++++++++++------ 3 files changed, 39 insertions(+), 14 deletions(-) diff --git a/.github/workflows/testTache32.yml b/.github/workflows/testTache32.yml index 41c357ac06..9c029144b2 100644 --- a/.github/workflows/testTache32.yml +++ b/.github/workflows/testTache32.yml @@ -31,10 +31,6 @@ jobs: run: mvn -X verify -B --file pom.xml env: JAVA_TOOL_OPTIONS: "-Xlog:gc* " - - - name: Flags supplementaires utilisees - run: | - echo "Les flags supplementaires utilises sont : -Xlog:gc*" - name: Get JaCoCo Coverage id: coverage @@ -52,3 +48,9 @@ jobs: else echo "New coverage: $coverage%" fi + + - name: Flags supplementaires utilises + run: | + coverage=$COVERAGE + echo "Le flag supplementaire utilise est : -Xlog:gc*" + echo "Le coverage est de : $coverage" diff --git a/.github/workflows/testTache33.yml b/.github/workflows/testTache33.yml index cce8fd96c4..67e52d17c0 100644 --- a/.github/workflows/testTache33.yml +++ b/.github/workflows/testTache33.yml @@ -32,10 +32,6 @@ jobs: env: JAVA_TOOL_OPTIONS: "-XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=./java_pid_heap_dump.hprof -XX:+ExitOnOutOfMemoryError " - - name: Flags supplementaires utilisees - run: | - echo "Les flags supplementaires utilises sont : -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=./java_pid_heap_dump.hprof -XX:+ExitOnOutOfMemoryError" - - name: Get JaCoCo Coverage id: coverage @@ -53,3 +49,9 @@ jobs: else echo "New coverage: $coverage%" fi + + - name: Flags supplementaires utilises + run: | + coverage=$COVERAGE + echo "Les flags supplementaires utilises sont : -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=./java_pid_heap_dump.hprof -XX:+ExitOnOutOfMemoryError" + echo "Le coverage est de : $coverage" diff --git a/Tache3_README.md b/Tache3_README.md index da11a4c135..9d9ccb21de 100644 --- a/Tache3_README.md +++ b/Tache3_README.md @@ -2,19 +2,40 @@ ### Mariel Leano -20218008 Corélie Godefroid -20205217 ### Choix de l'étude de cas : jsoup +Pour chaque action la section "Flags supplementaires utilises" contient le log du coverage et des flags modifiés pour cette action. + # Explications des flags choisis: ## Action 1 Tâche_3: -Cette action utilise les flags: +Cette action utilise les flags -XX:+UseG1GC et -XX:+UseStringDeduplication. + +Normalement le flag UseG1GC est déjà activé dans les actions du code (cela est observable dans les log du gc de l'action 2) mais puisque le flag UseStringDeduplication fonctionne avec ce flag, j'ai préféré l'ajouter explicitement afin d'éviter d'éventuels bugs futurs dans un cas où il ne serait plus utilisé par défaut. Il permet une meilleure efficacité du garbage collector, sur des machines à plusieurs processeurs, en libérant des régions presque vides de la heap d'abord ce qui permet de libérer beaucoup d'espace rapidement. + +Le flag UseStringDeduplication permet de réunir les strings dupliqués sur la heap en une seule instance ce qui évite de surcharger la mémoire avec des strings identiques. Ce flag est particulièrement utile dans des cas où le code utilise beaucoup de strings ou utilise des strings fréquemment. Étant donné que Jsoup est une librairie qui permet d'extraire, manipuler ou encore vérifier du code HTML, c'est un flag très pertinent à utiliser puisque la manipulation de strings est très fréquente. + +Ce flag permet d'améliorer la performance du code en libérant plus d'espace, mais également sa qualité, en s'assurant qu'on a plus d'espace libre dans la mémoire on prévient d'éventuels problèmes de manque de mémoire. ## Action 2 Tâche_3: Cette action utilise le flag -Xlog:gc*. -Ce flag permet d'imprimer toutes les actions effectuées par le garbage collector et combien de temps elles durent. C'est une fonctionnalité particulièrement utile afin de surveiller les performances du garbage collector et de la taille de la heap. En effet, en ayant une heap trop petite le garbage collector est obligé de la vider très souvent ce qui emmène un temps de pause au total très long, car les pauses sont trop fréquentes. Au contraire en ayant une heap trop importante les pauses du grabage collector sont moins fréquentes mais très longues. Il faut trouver le bon juste milieu et cela ne peut-être fait qu'on observant les log du garbage collector. -Il est également bon d'observer son fonctionement afin de pouvoir vérifier que le garbage collector est bien optimisé et qu'aucun changment brusque dans ses performances n'apparait (ce qui pourrait indiquer un problème autre part). +Ce flag permet d'imprimer toutes les actions effectuées par le garbage collector et combien de temps elles durent. C'est une fonctionnalité particulièrement utile afin de surveiller les performances du garbage collector et de la taille de la heap. En effet, en ayant une heap trop petite le garbage collector est obligé de la vider très souvent ce qui emmène un temps de pause au total très long, car les pauses sont trop fréquentes. Au contraire en ayant une heap trop importante les pauses du garbage collector sont moins fréquentes mais très longues. Il faut trouver le bon juste milieu et cela ne peut être fait qu'en observant les logs du garbage collector. + +Il est également bon d'observer son fonctionnement afin de pouvoir vérifier que le garbage collector est bien optimisé et qu'aucun changement brusque dans ses performances n'apparaît (ce qui pourrait indiquer un problème autre part). + +Personnellement ce flag a pu me servir dans mon travail sur cette tâche, j'essayais initialement d'optimiser la taille de la heap puis la vitesse du garbage collector avant de me rendre compte, grâce aux comparaisons avec cette action (qui avait le flag -Xlog:gc* d'activé), que mes changements n'amélioraient pas vraiment les performances puisque la heap et le garbage collector étaient déjà assez bien optimisé. J'ai donc pu me concentrer sur l'exploration d'autres flags de la JVM à la place. + +Ce flag permet donc d'améliorer l'observabilité du code en rendant accessibles les actions du garbage collector. +## Action 3 Tâche_3: +Cette action utilise les flags -XX:+HeapDumpOnOutOfMemoryError, -XX:HeapDumpPath=./java_pid\_heap_dump.hprof et -XX:+ExitOnOutOfMemoryError . + + +Ces 3 flags permettent ensemble de correctement gérer une erreur de manque de mémoire. Ce sont des flags utiles à avoir, car des erreurs de mémoire sont des problèmes assez fréquents lors de l'écriture ou de l'utilisation d'un code et peuvent être difficiles à comprendre. + +Le premier flag -XX:+HeapDumpOnOutOfMemoryError permet de vider le contenu de la heap dans un fichier lorsqu'une telle erreur se produit. Cela permet alors de pouvoir vérifier à quel moment l'erreur est survenue grâce aux éléments qui étaient manipulés à ce moment-là, ainsi que de comprendre comment leurs allocations ont rempli la heap et ont causé cette erreur. + +Le deuxième flag -XX:HeapDumpPath=./java_pid\_heap_dump.hprof permet d'indiquer que l'on veut vider le contenu de la heap dans le fichier ./java_pid\_heap_dump.hprof . L'inclusion de \ permet au processus d'y insérer l'identifiant du thread ayant causé l'erreur. Avoir cet identifiant permet encore plus de comprendre l'erreur, car on peut alors inspecter exactement l'exécution de ce thread. -Personnellement ce flag a pu me servir dans mon travail sur cette tâche, j'essayait initialement d'optimiser la taille de la heap puis la vitesse du garbage collector avant de me rendre compte, grâce aux comparaisons avec cette action (qui avait le flag -Xlog:gc* d'activé), que mes changements n'amélioraient pas vraiment les performance puisque la heap et le garbage collector étaient déjà assez bien optimisé. J'ai donc pu me concentrer sur l'exploration de d'autres flags de la JVM à la place. +Le dernier flag -XX:+ExitOnOutOfMemoryError permet de forcer la fin de l'exécution et évite que l'on poursuivre l'exécution dans un état instable suite à cette erreur. -Ce flag permet donc d'améliorer l'observabilité du code. -## Action 3 Tâche_3: \ No newline at end of file +Ces 3 flags permettent donc d'améliorer la qualité, en s'assurant de ne pas poursuivre l'exécution dans un état instable, et l'observabilité, en rendant accessibles les données de la heap ce qui permet de mieux comprendre le code et d'en diagnostiquer les problèmes. From 3d80632b9c208d8d522f23d29ad0db8fff4a6ee2 Mon Sep 17 00:00:00 2001 From: MarielLF <91103465+MarielLF@users.noreply.github.com> Date: Wed, 13 Nov 2024 21:14:40 -0500 Subject: [PATCH 31/37] Create testTache34.yml --- .github/workflows/testTache34.yml | 55 +++++++++++++++++++++++++++++++ 1 file changed, 55 insertions(+) create mode 100644 .github/workflows/testTache34.yml diff --git a/.github/workflows/testTache34.yml b/.github/workflows/testTache34.yml new file mode 100644 index 0000000000..50dec1a86e --- /dev/null +++ b/.github/workflows/testTache34.yml @@ -0,0 +1,55 @@ +name: Action4Tache3 +on: + push: + pull_request: + +jobs: + test: + runs-on: ${{ matrix.os }} + strategy: + matrix: + os: [ubuntu-latest] + java: [17] + fail-fast: false + name: Test JDK ${{ matrix.java }}, ${{ matrix.os }} + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Set up JDK ${{ matrix.java }} + uses: actions/setup-java@v4 + with: + java-version: ${{ matrix.java }} + distribution: 'zulu' + cache: 'maven' + + - name: Maven Compile + run: mvn -X compile -B --file pom.xml + + - name: Maven Verify + run: mvn -X verify -B --file pom.xml + env: + JAVA_TOOL_OPTIONS: "-XX:+UseCompressedOops -XX:+AggressiveOpts" + + - name: Get JaCoCo Coverage + id: coverage + run: | + coverage=$(python3 config/coverage.py target/site/jacoco/jacoco.csv) + echo "COVERAGE=$coverage" >> $GITHUB_ENV + + - name: Fail if coverage has not improved. + run: | + coverage=$COVERAGE + threshold=90.41 + if (( $(echo "$coverage - $threshold <= 0.1" | bc -l) )); then + echo "Coverage has not improved." + exit 1 + else + echo "New coverage: $coverage%" + fi + + - name: Flags supplementaires utilises + run: | + coverage=$COVERAGE + echo "Les flags supplementaires utilises sont : -XX:+UseCompressedOops -XX:+AggressiveOpts" + echo "Le coverage est de : $coverage" From 646989e2dfae06a3c8eebd6ae2a208b1663c87b2 Mon Sep 17 00:00:00 2001 From: MarielLF <91103465+MarielLF@users.noreply.github.com> Date: Wed, 13 Nov 2024 21:15:57 -0500 Subject: [PATCH 32/37] Create testTache35.yml --- .github/workflows/testTache35.yml | 55 +++++++++++++++++++++++++++++++ 1 file changed, 55 insertions(+) create mode 100644 .github/workflows/testTache35.yml diff --git a/.github/workflows/testTache35.yml b/.github/workflows/testTache35.yml new file mode 100644 index 0000000000..dcb988f356 --- /dev/null +++ b/.github/workflows/testTache35.yml @@ -0,0 +1,55 @@ +name: Action5Tache3 +on: + push: + pull_request: + +jobs: + test: + runs-on: ${{ matrix.os }} + strategy: + matrix: + os: [ubuntu-latest] + java: [17] + fail-fast: false + name: Test JDK ${{ matrix.java }}, ${{ matrix.os }} + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Set up JDK ${{ matrix.java }} + uses: actions/setup-java@v4 + with: + java-version: ${{ matrix.java }} + distribution: 'zulu' + cache: 'maven' + + - name: Maven Compile + run: mvn -X compile -B --file pom.xml + + - name: Maven Verify + run: mvn -X verify -B --file pom.xml + env: + JAVA_TOOL_OPTIONS: "-XX:+UseConcMarkSweepGC -XX:ConcGCThreads=2" + + - name: Get JaCoCo Coverage + id: coverage + run: | + coverage=$(python3 config/coverage.py target/site/jacoco/jacoco.csv) + echo "COVERAGE=$coverage" >> $GITHUB_ENV + + - name: Fail if coverage has not improved. + run: | + coverage=$COVERAGE + threshold=90.41 + if (( $(echo "$coverage - $threshold <= 0.1" | bc -l) )); then + echo "Coverage has not improved." + exit 1 + else + echo "New coverage: $coverage%" + fi + + - name: Flags supplementaires utilises + run: | + coverage=$COVERAGE + echo "Les flags supplementaires utilises sont : -XX:+UseConcMarkSweepGC -XX:ConcGCThreads=2" + echo "Le coverage est de : $coverage" From af541b3cf6b7e56618296a2bdff3646f668be020 Mon Sep 17 00:00:00 2001 From: MarielLF <91103465+MarielLF@users.noreply.github.com> Date: Wed, 13 Nov 2024 21:23:51 -0500 Subject: [PATCH 33/37] Update testTache34.yml --- .github/workflows/testTache34.yml | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/.github/workflows/testTache34.yml b/.github/workflows/testTache34.yml index 50dec1a86e..49c095cda6 100644 --- a/.github/workflows/testTache34.yml +++ b/.github/workflows/testTache34.yml @@ -29,7 +29,7 @@ jobs: - name: Maven Verify run: mvn -X verify -B --file pom.xml env: - JAVA_TOOL_OPTIONS: "-XX:+UseCompressedOops -XX:+AggressiveOpts" + JAVA_TOOL_OPTIONS: "-XX:+UseCompressedOops -XX:+OptimizeStringConcat" - name: Get JaCoCo Coverage id: coverage @@ -51,5 +51,6 @@ jobs: - name: Flags supplementaires utilises run: | coverage=$COVERAGE - echo "Les flags supplementaires utilises sont : -XX:+UseCompressedOops -XX:+AggressiveOpts" + echo "Les flags supplementaires utilises sont : -XX:+UseCompressedOops -XX:+OptimizeStringConcat" echo "Le coverage est de : $coverage" + From c6a4729cf07a3386ffba79d9960c5dac419f7b26 Mon Sep 17 00:00:00 2001 From: MarielLF <91103465+MarielLF@users.noreply.github.com> Date: Wed, 13 Nov 2024 21:31:26 -0500 Subject: [PATCH 34/37] Update testTache34.yml --- .github/workflows/testTache34.yml | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/.github/workflows/testTache34.yml b/.github/workflows/testTache34.yml index 49c095cda6..05445e28b0 100644 --- a/.github/workflows/testTache34.yml +++ b/.github/workflows/testTache34.yml @@ -29,7 +29,7 @@ jobs: - name: Maven Verify run: mvn -X verify -B --file pom.xml env: - JAVA_TOOL_OPTIONS: "-XX:+UseCompressedOops -XX:+OptimizeStringConcat" + JAVA_TOOL_OPTIONS: "-XX:+UseG1GC -XX:MaxGCPauseMillis=200" - name: Get JaCoCo Coverage id: coverage @@ -51,6 +51,5 @@ jobs: - name: Flags supplementaires utilises run: | coverage=$COVERAGE - echo "Les flags supplementaires utilises sont : -XX:+UseCompressedOops -XX:+OptimizeStringConcat" + echo "Les flags supplementaires utilises sont : -XX:+UseG1GC -XX:MaxGCPauseMillis=200" echo "Le coverage est de : $coverage" - From 77b5016bf23a14480272ea05aa00cb6e7abfdd4d Mon Sep 17 00:00:00 2001 From: MarielLF <91103465+MarielLF@users.noreply.github.com> Date: Wed, 13 Nov 2024 21:46:06 -0500 Subject: [PATCH 35/37] Update env testTache35.yml --- .github/workflows/testTache35.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/testTache35.yml b/.github/workflows/testTache35.yml index dcb988f356..1e1787ecf0 100644 --- a/.github/workflows/testTache35.yml +++ b/.github/workflows/testTache35.yml @@ -29,7 +29,7 @@ jobs: - name: Maven Verify run: mvn -X verify -B --file pom.xml env: - JAVA_TOOL_OPTIONS: "-XX:+UseConcMarkSweepGC -XX:ConcGCThreads=2" + JAVA_TOOL_OPTIONS: "-XX:+UseG1GC -XX:MaxGCPauseMillis=200" - name: Get JaCoCo Coverage id: coverage From e6e8ec5a5106206421d636497d6bf59d45ff103a Mon Sep 17 00:00:00 2001 From: MarielLF <91103465+MarielLF@users.noreply.github.com> Date: Wed, 13 Nov 2024 21:52:37 -0500 Subject: [PATCH 36/37] Update Tache3_README.md --- Tache3_README.md | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/Tache3_README.md b/Tache3_README.md index 9d9ccb21de..595d25e4a4 100644 --- a/Tache3_README.md +++ b/Tache3_README.md @@ -39,3 +39,19 @@ Le deuxième flag -XX:HeapDumpPath=./java_pid\_heap_dump.hprof permet d'i Le dernier flag -XX:+ExitOnOutOfMemoryError permet de forcer la fin de l'exécution et évite que l'on poursuivre l'exécution dans un état instable suite à cette erreur. Ces 3 flags permettent donc d'améliorer la qualité, en s'assurant de ne pas poursuivre l'exécution dans un état instable, et l'observabilité, en rendant accessibles les données de la heap ce qui permet de mieux comprendre le code et d'en diagnostiquer les problèmes. +## Action 4 Tâche_3: +Cette action utilise les flags -XX:+UseG1GC et -XX:MaxGCPauseMillis=200. + +Le flag UseG1GC active le ramasse-miettes (garbage collector) G1, qui est particulièrement efficace pour les applications qui nécessitent des temps de réponse prévisibles. Le ramasse-miettes G1 fonctionne en divisant la mémoire en plusieurs régions, ce qui lui permet de libérer plus efficacement les parties de la mémoire qui ne sont plus utilisées, sans affecter la totalité de la heap. + +En complément, le flag MaxGCPauseMillis=200 définit un objectif de pause maximum de 200 millisecondes pour le ramasse-miettes G1. Cela signifie que le garbage collector essaie de ne pas dépasser cette durée de pause lors de l'exécution. Ce flag est particulièrement utile dans des applications qui nécessitent des temps de réponse rapides, car il permet d’éviter les longues pauses pendant lesquelles le garbage collector fonctionne. + +Ces flags combinés permettent d’améliorer la performance du code en réduisant les pauses et en assurant une gestion plus efficace de la mémoire. +## Action 5 Tâche_3: +Cette action utilise les flags -XX:+AlwaysPreTouch et -XX:ParallelGCThreads=2. + +Le flag AlwaysPreTouch force la JVM à charger en mémoire toutes les pages nécessaires au démarrage de l'application. Cette opération réduit les retards dus aux accès à la mémoire pendant l'exécution, car les pages sont déjà chargées et prêtes à être utilisées. Ce flag est particulièrement utile dans des environnements où la latence doit être réduite autant que possible. + +Le flag ParallelGCThreads=2 limite le nombre de threads que le ramasse-miettes parallèle utilise à deux. En réduisant le nombre de threads pour la collecte de déchets, nous pouvons limiter l'utilisation de la CPU par le garbage collector dans des environnements où les ressources CPU sont limitées. Cela permet un meilleur équilibre entre l'usage des ressources par le garbage collector et les autres processus de l’application. + +Ces flags permettent donc d’améliorer l’efficacité de la gestion de la mémoire et d’optimiser les performances dans des environnements avec des contraintes de ressources, tout en assurant un démarrage plus rapide grâce à la précharge de la mémoire. From ae5a929671c00518063b2cd8f213c1c326a0ebf2 Mon Sep 17 00:00:00 2001 From: Corelie <91093459+Corelie@users.noreply.github.com> Date: Thu, 14 Nov 2024 07:36:51 -0500 Subject: [PATCH 37/37] Update Tache3_README.md --- Tache3_README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Tache3_README.md b/Tache3_README.md index 595d25e4a4..d7526ea1d8 100644 --- a/Tache3_README.md +++ b/Tache3_README.md @@ -52,6 +52,6 @@ Cette action utilise les flags -XX:+AlwaysPreTouch et -XX:ParallelGCThreads=2. Le flag AlwaysPreTouch force la JVM à charger en mémoire toutes les pages nécessaires au démarrage de l'application. Cette opération réduit les retards dus aux accès à la mémoire pendant l'exécution, car les pages sont déjà chargées et prêtes à être utilisées. Ce flag est particulièrement utile dans des environnements où la latence doit être réduite autant que possible. -Le flag ParallelGCThreads=2 limite le nombre de threads que le ramasse-miettes parallèle utilise à deux. En réduisant le nombre de threads pour la collecte de déchets, nous pouvons limiter l'utilisation de la CPU par le garbage collector dans des environnements où les ressources CPU sont limitées. Cela permet un meilleur équilibre entre l'usage des ressources par le garbage collector et les autres processus de l’application. +Le flag ParallelGCThreads=2 limite le nombre de threads que le ramasse-miettes parallèle utilise à deux. En réduisant le nombre de threads pour la collecte de déchets, nous pouvons limiter l'utilisation du CPU par le garbage collector dans des environnements où les ressources CPU sont limitées. Cela permet un meilleur équilibre entre l'usage des ressources par le garbage collector et les autres processus de l’application. Ces flags permettent donc d’améliorer l’efficacité de la gestion de la mémoire et d’optimiser les performances dans des environnements avec des contraintes de ressources, tout en assurant un démarrage plus rapide grâce à la précharge de la mémoire.