@uuv/playwright 1.15.0 → 2.0.0

package/src/cucumber/step_definitions/playwright/generated/enriched/fr/_fr-generated-steps-definition_banner.ts

@@ -31,22 +31,22 @@ import {
 import { World } from "../../../../../preprocessor/run/world";
 import { expect } from "@playwright/test";
 
-When(`je vais à l'intérieur de bannière nommé(e) {string}`, async function (this: World, name: string) {
+When(`je vais à l'intérieur de la bannière nommée {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "banner", name);
 });
 
-Then(`je dois voir un(e) bannière nommé(e) {string}`, async function (this: World, name: string)  {
+Then(`je dois voir une bannière nommée {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "banner", name);
 });
 
 Then(
-    `je ne dois pas voir un(e) bannière nommé(e) {string}`,
+    `je ne dois pas voir une bannière nommée {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "banner", name);
     }
 );
 
-When(`je saisie le(s) mot(s) {string} dans le/la bannière nommé(e) {string}`, async function(this: World, textToType: string, name: string) {
+When(`je saisie le(s) mot(s) {string} dans la bannière nommée {string}`, async function(this: World, textToType: string, name: string) {
     await getPageOrElement(this).then(async (element) => {
         const byRole = await element.getByRole("banner", { name: name, includeHidden: true, exact: true });
         await expect(byRole).toHaveCount(1);
@@ -57,21 +57,21 @@ When(`je saisie le(s) mot(s) {string} dans le/la bannière nommé(e) {string}`,
 
 
 Then(
-    `je dois voir un(e) bannière nommé(e) {string} et contenant {string}`,
+    `je dois voir une bannière nommée {string} et contenant {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "banner", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) bannière nommé(e) {string} et contenant {string} inactif`,
+    `je dois voir une bannière nommée {string} et contenant {string} inactif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "banner", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) bannière nommé(e) {string} et contenant {string} actif`,
+    `je dois voir une bannière nommée {string} et contenant {string} actif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "banner", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/playwright/generated/enriched/fr/_fr-generated-steps-definition_button.ts

@@ -31,22 +31,22 @@ import {
 import { World } from "../../../../../preprocessor/run/world";
 import { expect } from "@playwright/test";
 
-When(`je vais à l'intérieur de bouton nommé(e) {string}`, async function (this: World, name: string) {
+When(`je vais à l'intérieur du bouton nommé {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "button", name);
 });
 
-Then(`je dois voir un(e) bouton nommé(e) {string}`, async function (this: World, name: string)  {
+Then(`je dois voir un bouton nommé {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "button", name);
 });
 
 Then(
-    `je ne dois pas voir un(e) bouton nommé(e) {string}`,
+    `je ne dois pas voir un bouton nommé {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "button", name);
     }
 );
 
-When(`je saisie le(s) mot(s) {string} dans le/la bouton nommé(e) {string}`, async function(this: World, textToType: string, name: string) {
+When(`je saisie le(s) mot(s) {string} dans le bouton nommé {string}`, async function(this: World, textToType: string, name: string) {
     await getPageOrElement(this).then(async (element) => {
         const byRole = await element.getByRole("button", { name: name, includeHidden: true, exact: true });
         await expect(byRole).toHaveCount(1);
@@ -57,21 +57,21 @@ When(`je saisie le(s) mot(s) {string} dans le/la bouton nommé(e) {string}`, asy
 
 
 Then(
-    `je dois voir un(e) bouton nommé(e) {string} et contenant {string}`,
+    `je dois voir un bouton nommé {string} et contenant {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "button", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) bouton nommé(e) {string} et contenant {string} inactif`,
+    `je dois voir un bouton nommé {string} et contenant {string} inactif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "button", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) bouton nommé(e) {string} et contenant {string} actif`,
+    `je dois voir un bouton nommé {string} et contenant {string} actif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "button", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/playwright/generated/enriched/fr/_fr-generated-steps-definition_cell.ts

@@ -31,22 +31,22 @@ import {
 import { World } from "../../../../../preprocessor/run/world";
 import { expect } from "@playwright/test";
 
-When(`je vais à l'intérieur de cellule nommé(e) {string}`, async function (this: World, name: string) {
+When(`je vais à l'intérieur de la cellule nommée {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "cell", name);
 });
 
-Then(`je dois voir un(e) cellule nommé(e) {string}`, async function (this: World, name: string)  {
+Then(`je dois voir une cellule nommée {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "cell", name);
 });
 
 Then(
-    `je ne dois pas voir un(e) cellule nommé(e) {string}`,
+    `je ne dois pas voir une cellule nommée {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "cell", name);
     }
 );
 
-When(`je saisie le(s) mot(s) {string} dans le/la cellule nommé(e) {string}`, async function(this: World, textToType: string, name: string) {
+When(`je saisie le(s) mot(s) {string} dans la cellule nommée {string}`, async function(this: World, textToType: string, name: string) {
     await getPageOrElement(this).then(async (element) => {
         const byRole = await element.getByRole("cell", { name: name, includeHidden: true, exact: true });
         await expect(byRole).toHaveCount(1);
@@ -57,21 +57,21 @@ When(`je saisie le(s) mot(s) {string} dans le/la cellule nommé(e) {string}`, as
 
 
 Then(
-    `je dois voir un(e) cellule nommé(e) {string} et contenant {string}`,
+    `je dois voir une cellule nommée {string} et contenant {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "cell", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) cellule nommé(e) {string} et contenant {string} inactif`,
+    `je dois voir une cellule nommée {string} et contenant {string} inactif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "cell", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) cellule nommé(e) {string} et contenant {string} actif`,
+    `je dois voir une cellule nommée {string} et contenant {string} actif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "cell", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/playwright/generated/enriched/fr/_fr-generated-steps-definition_checkbox.ts

@@ -31,22 +31,22 @@ import {
 import { World } from "../../../../../preprocessor/run/world";
 import { expect } from "@playwright/test";
 
-When(`je vais à l'intérieur de case à cocher nommé(e) {string}`, async function (this: World, name: string) {
+When(`je vais à l'intérieur de la case à cocher nommée {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "checkbox", name);
 });
 
-Then(`je dois voir un(e) case à cocher nommé(e) {string}`, async function (this: World, name: string)  {
+Then(`je dois voir une case à cocher nommée {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "checkbox", name);
 });
 
 Then(
-    `je ne dois pas voir un(e) case à cocher nommé(e) {string}`,
+    `je ne dois pas voir une case à cocher nommée {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "checkbox", name);
     }
 );
 
-When(`je saisie le(s) mot(s) {string} dans le/la case à cocher nommé(e) {string}`, async function(this: World, textToType: string, name: string) {
+When(`je saisie le(s) mot(s) {string} dans la case à cocher nommée {string}`, async function(this: World, textToType: string, name: string) {
     await getPageOrElement(this).then(async (element) => {
         const byRole = await element.getByRole("checkbox", { name: name, includeHidden: true, exact: true });
         await expect(byRole).toHaveCount(1);
@@ -57,21 +57,21 @@ When(`je saisie le(s) mot(s) {string} dans le/la case à cocher nommé(e) {strin
 
 
 Then(
-    `je dois voir un(e) case à cocher nommé(e) {string} et contenant {string}`,
+    `je dois voir une case à cocher nommée {string} et contenant {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "checkbox", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) case à cocher nommé(e) {string} et contenant {string} inactif`,
+    `je dois voir une case à cocher nommée {string} et contenant {string} inactif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "checkbox", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) case à cocher nommé(e) {string} et contenant {string} actif`,
+    `je dois voir une case à cocher nommée {string} et contenant {string} actif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "checkbox", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/playwright/generated/enriched/fr/_fr-generated-steps-definition_columnheader.ts

@@ -31,22 +31,22 @@ import {
 import { World } from "../../../../../preprocessor/run/world";
 import { expect } from "@playwright/test";
 
-When(`je vais à l'intérieur de en-tête de colonne nommé(e) {string}`, async function (this: World, name: string) {
+When(`je vais à l'intérieur de l'en-tête de colonne nommée {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "columnheader", name);
 });
 
-Then(`je dois voir un(e) en-tête de colonne nommé(e) {string}`, async function (this: World, name: string)  {
+Then(`je dois voir une en-tête de colonne nommée {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "columnheader", name);
 });
 
 Then(
-    `je ne dois pas voir un(e) en-tête de colonne nommé(e) {string}`,
+    `je ne dois pas voir une en-tête de colonne nommée {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "columnheader", name);
     }
 );
 
-When(`je saisie le(s) mot(s) {string} dans le/la en-tête de colonne nommé(e) {string}`, async function(this: World, textToType: string, name: string) {
+When(`je saisie le(s) mot(s) {string} dans l'en-tête de colonne nommée {string}`, async function(this: World, textToType: string, name: string) {
     await getPageOrElement(this).then(async (element) => {
         const byRole = await element.getByRole("columnheader", { name: name, includeHidden: true, exact: true });
         await expect(byRole).toHaveCount(1);
@@ -57,21 +57,21 @@ When(`je saisie le(s) mot(s) {string} dans le/la en-tête de colonne nommé(e) {
 
 
 Then(
-    `je dois voir un(e) en-tête de colonne nommé(e) {string} et contenant {string}`,
+    `je dois voir une en-tête de colonne nommée {string} et contenant {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "columnheader", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) en-tête de colonne nommé(e) {string} et contenant {string} inactif`,
+    `je dois voir une en-tête de colonne nommée {string} et contenant {string} inactif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "columnheader", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) en-tête de colonne nommé(e) {string} et contenant {string} actif`,
+    `je dois voir une en-tête de colonne nommée {string} et contenant {string} actif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "columnheader", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/playwright/generated/enriched/fr/_fr-generated-steps-definition_combobox.ts

@@ -31,22 +31,22 @@ import {
 import { World } from "../../../../../preprocessor/run/world";
 import { expect } from "@playwright/test";
 
-When(`je vais à l'intérieur de boîte à choix nommé(e) {string}`, async function (this: World, name: string) {
+When(`je vais à l'intérieur de la boîte à choix nommée {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "combobox", name);
 });
 
-Then(`je dois voir un(e) boîte à choix nommé(e) {string}`, async function (this: World, name: string)  {
+Then(`je dois voir une boîte à choix nommée {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "combobox", name);
 });
 
 Then(
-    `je ne dois pas voir un(e) boîte à choix nommé(e) {string}`,
+    `je ne dois pas voir une boîte à choix nommée {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "combobox", name);
     }
 );
 
-When(`je saisie le(s) mot(s) {string} dans le/la boîte à choix nommé(e) {string}`, async function(this: World, textToType: string, name: string) {
+When(`je saisie le(s) mot(s) {string} dans la boîte à choix nommée {string}`, async function(this: World, textToType: string, name: string) {
     await getPageOrElement(this).then(async (element) => {
         const byRole = await element.getByRole("combobox", { name: name, includeHidden: true, exact: true });
         await expect(byRole).toHaveCount(1);
@@ -57,21 +57,21 @@ When(`je saisie le(s) mot(s) {string} dans le/la boîte à choix nommé(e) {stri
 
 
 Then(
-    `je dois voir un(e) boîte à choix nommé(e) {string} et contenant {string}`,
+    `je dois voir une boîte à choix nommée {string} et contenant {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "combobox", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) boîte à choix nommé(e) {string} et contenant {string} inactif`,
+    `je dois voir une boîte à choix nommée {string} et contenant {string} inactif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "combobox", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) boîte à choix nommé(e) {string} et contenant {string} actif`,
+    `je dois voir une boîte à choix nommée {string} et contenant {string} actif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "combobox", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/playwright/generated/enriched/fr/_fr-generated-steps-definition_command.ts

@@ -31,22 +31,22 @@ import {
 import { World } from "../../../../../preprocessor/run/world";
 import { expect } from "@playwright/test";
 
-When(`je vais à l'intérieur de commande nommé(e) {string}`, async function (this: World, name: string) {
+When(`je vais à l'intérieur de la commande nommée {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "command", name);
 });
 
-Then(`je dois voir un(e) commande nommé(e) {string}`, async function (this: World, name: string)  {
+Then(`je dois voir une commande nommée {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "command", name);
 });
 
 Then(
-    `je ne dois pas voir un(e) commande nommé(e) {string}`,
+    `je ne dois pas voir une commande nommée {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "command", name);
     }
 );
 
-When(`je saisie le(s) mot(s) {string} dans le/la commande nommé(e) {string}`, async function(this: World, textToType: string, name: string) {
+When(`je saisie le(s) mot(s) {string} dans la commande nommée {string}`, async function(this: World, textToType: string, name: string) {
     await getPageOrElement(this).then(async (element) => {
         const byRole = await element.getByRole("command", { name: name, includeHidden: true, exact: true });
         await expect(byRole).toHaveCount(1);
@@ -57,21 +57,21 @@ When(`je saisie le(s) mot(s) {string} dans le/la commande nommé(e) {string}`, a
 
 
 Then(
-    `je dois voir un(e) commande nommé(e) {string} et contenant {string}`,
+    `je dois voir une commande nommée {string} et contenant {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "command", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) commande nommé(e) {string} et contenant {string} inactif`,
+    `je dois voir une commande nommée {string} et contenant {string} inactif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "command", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) commande nommé(e) {string} et contenant {string} actif`,
+    `je dois voir une commande nommée {string} et contenant {string} actif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "command", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/playwright/generated/enriched/fr/_fr-generated-steps-definition_comment.ts

@@ -31,22 +31,22 @@ import {
 import { World } from "../../../../../preprocessor/run/world";
 import { expect } from "@playwright/test";
 
-When(`je vais à l'intérieur de commentaire nommé(e) {string}`, async function (this: World, name: string) {
+When(`je vais à l'intérieur du commentaire nommé {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "comment", name);
 });
 
-Then(`je dois voir un(e) commentaire nommé(e) {string}`, async function (this: World, name: string)  {
+Then(`je dois voir un commentaire nommé {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "comment", name);
 });
 
 Then(
-    `je ne dois pas voir un(e) commentaire nommé(e) {string}`,
+    `je ne dois pas voir un commentaire nommé {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "comment", name);
     }
 );
 
-When(`je saisie le(s) mot(s) {string} dans le/la commentaire nommé(e) {string}`, async function(this: World, textToType: string, name: string) {
+When(`je saisie le(s) mot(s) {string} dans le commentaire nommé {string}`, async function(this: World, textToType: string, name: string) {
     await getPageOrElement(this).then(async (element) => {
         const byRole = await element.getByRole("comment", { name: name, includeHidden: true, exact: true });
         await expect(byRole).toHaveCount(1);
@@ -57,21 +57,21 @@ When(`je saisie le(s) mot(s) {string} dans le/la commentaire nommé(e) {string}`
 
 
 Then(
-    `je dois voir un(e) commentaire nommé(e) {string} et contenant {string}`,
+    `je dois voir un commentaire nommé {string} et contenant {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "comment", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) commentaire nommé(e) {string} et contenant {string} inactif`,
+    `je dois voir un commentaire nommé {string} et contenant {string} inactif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "comment", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) commentaire nommé(e) {string} et contenant {string} actif`,
+    `je dois voir un commentaire nommé {string} et contenant {string} actif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "comment", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/playwright/generated/enriched/fr/_fr-generated-steps-definition_complementary.ts

@@ -31,22 +31,22 @@ import {
 import { World } from "../../../../../preprocessor/run/world";
 import { expect } from "@playwright/test";
 
-When(`je vais à l'intérieur de complémentaire nommé(e) {string}`, async function (this: World, name: string) {
+When(`je vais à l'intérieur du complémentaire nommé {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "complementary", name);
 });
 
-Then(`je dois voir un(e) complémentaire nommé(e) {string}`, async function (this: World, name: string)  {
+Then(`je dois voir un complémentaire nommé {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "complementary", name);
 });
 
 Then(
-    `je ne dois pas voir un(e) complémentaire nommé(e) {string}`,
+    `je ne dois pas voir un complémentaire nommé {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "complementary", name);
     }
 );
 
-When(`je saisie le(s) mot(s) {string} dans le/la complémentaire nommé(e) {string}`, async function(this: World, textToType: string, name: string) {
+When(`je saisie le(s) mot(s) {string} dans le complémentaire nommé {string}`, async function(this: World, textToType: string, name: string) {
     await getPageOrElement(this).then(async (element) => {
         const byRole = await element.getByRole("complementary", { name: name, includeHidden: true, exact: true });
         await expect(byRole).toHaveCount(1);
@@ -57,21 +57,21 @@ When(`je saisie le(s) mot(s) {string} dans le/la complémentaire nommé(e) {stri
 
 
 Then(
-    `je dois voir un(e) complémentaire nommé(e) {string} et contenant {string}`,
+    `je dois voir un complémentaire nommé {string} et contenant {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "complementary", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) complémentaire nommé(e) {string} et contenant {string} inactif`,
+    `je dois voir un complémentaire nommé {string} et contenant {string} inactif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "complementary", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) complémentaire nommé(e) {string} et contenant {string} actif`,
+    `je dois voir un complémentaire nommé {string} et contenant {string} actif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "complementary", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/playwright/generated/enriched/fr/_fr-generated-steps-definition_composite.ts

@@ -31,22 +31,22 @@ import {
 import { World } from "../../../../../preprocessor/run/world";
 import { expect } from "@playwright/test";
 
-When(`je vais à l'intérieur de composite nommé(e) {string}`, async function (this: World, name: string) {
+When(`je vais à l'intérieur du composite nommé {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "composite", name);
 });
 
-Then(`je dois voir un(e) composite nommé(e) {string}`, async function (this: World, name: string)  {
+Then(`je dois voir un composite nommé {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "composite", name);
 });
 
 Then(
-    `je ne dois pas voir un(e) composite nommé(e) {string}`,
+    `je ne dois pas voir un composite nommé {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "composite", name);
     }
 );
 
-When(`je saisie le(s) mot(s) {string} dans le/la composite nommé(e) {string}`, async function(this: World, textToType: string, name: string) {
+When(`je saisie le(s) mot(s) {string} dans le composite nommé {string}`, async function(this: World, textToType: string, name: string) {
     await getPageOrElement(this).then(async (element) => {
         const byRole = await element.getByRole("composite", { name: name, includeHidden: true, exact: true });
         await expect(byRole).toHaveCount(1);
@@ -57,21 +57,21 @@ When(`je saisie le(s) mot(s) {string} dans le/la composite nommé(e) {string}`,
 
 
 Then(
-    `je dois voir un(e) composite nommé(e) {string} et contenant {string}`,
+    `je dois voir un composite nommé {string} et contenant {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "composite", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) composite nommé(e) {string} et contenant {string} inactif`,
+    `je dois voir un composite nommé {string} et contenant {string} inactif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "composite", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) composite nommé(e) {string} et contenant {string} actif`,
+    `je dois voir un composite nommé {string} et contenant {string} actif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "composite", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/playwright/generated/enriched/fr/_fr-generated-steps-definition_contentinfo.ts

@@ -31,22 +31,22 @@ import {
 import { World } from "../../../../../preprocessor/run/world";
 import { expect } from "@playwright/test";
 
-When(`je vais à l'intérieur de contentinfo nommé(e) {string}`, async function (this: World, name: string) {
+When(`je vais à l'intérieur de l'information de contenu nommée {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "contentinfo", name);
 });
 
-Then(`je dois voir un(e) contentinfo nommé(e) {string}`, async function (this: World, name: string)  {
+Then(`je dois voir une information de contenu nommée {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "contentinfo", name);
 });
 
 Then(
-    `je ne dois pas voir un(e) contentinfo nommé(e) {string}`,
+    `je ne dois pas voir une information de contenu nommée {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "contentinfo", name);
     }
 );
 
-When(`je saisie le(s) mot(s) {string} dans le/la contentinfo nommé(e) {string}`, async function(this: World, textToType: string, name: string) {
+When(`je saisie le(s) mot(s) {string} dans l'information de contenu nommée {string}`, async function(this: World, textToType: string, name: string) {
     await getPageOrElement(this).then(async (element) => {
         const byRole = await element.getByRole("contentinfo", { name: name, includeHidden: true, exact: true });
         await expect(byRole).toHaveCount(1);
@@ -57,21 +57,21 @@ When(`je saisie le(s) mot(s) {string} dans le/la contentinfo nommé(e) {string}`
 
 
 Then(
-    `je dois voir un(e) contentinfo nommé(e) {string} et contenant {string}`,
+    `je dois voir une information de contenu nommée {string} et contenant {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "contentinfo", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) contentinfo nommé(e) {string} et contenant {string} inactif`,
+    `je dois voir une information de contenu nommée {string} et contenant {string} inactif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "contentinfo", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) contentinfo nommé(e) {string} et contenant {string} actif`,
+    `je dois voir une information de contenu nommée {string} et contenant {string} actif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "contentinfo", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/playwright/generated/enriched/fr/_fr-generated-steps-definition_definition.ts

@@ -31,22 +31,22 @@ import {
 import { World } from "../../../../../preprocessor/run/world";
 import { expect } from "@playwright/test";
 
-When(`je vais à l'intérieur de définition nommé(e) {string}`, async function (this: World, name: string) {
+When(`je vais à l'intérieur de la définition nommée {string}`, async function (this: World, name: string) {
     return await withinRoleAndName(this, "definition", name);
 });
 
-Then(`je dois voir un(e) définition nommé(e) {string}`, async function (this: World, name: string)  {
+Then(`je dois voir une définition nommée {string}`, async function (this: World, name: string)  {
     await findWithRoleAndName(this, "definition", name);
 });
 
 Then(
-    `je ne dois pas voir un(e) définition nommé(e) {string}`,
+    `je ne dois pas voir une définition nommée {string}`,
     async function (this: World, name: string)  {
        await notFoundWithRoleAndName(this, "definition", name);
     }
 );
 
-When(`je saisie le(s) mot(s) {string} dans le/la définition nommé(e) {string}`, async function(this: World, textToType: string, name: string) {
+When(`je saisie le(s) mot(s) {string} dans la définition nommée {string}`, async function(this: World, textToType: string, name: string) {
     await getPageOrElement(this).then(async (element) => {
         const byRole = await element.getByRole("definition", { name: name, includeHidden: true, exact: true });
         await expect(byRole).toHaveCount(1);
@@ -57,21 +57,21 @@ When(`je saisie le(s) mot(s) {string} dans le/la définition nommé(e) {string}`
 
 
 Then(
-    `je dois voir un(e) définition nommé(e) {string} et contenant {string}`,
+    `je dois voir une définition nommée {string} et contenant {string}`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContent(this, "definition", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) définition nommé(e) {string} et contenant {string} inactif`,
+    `je dois voir une définition nommée {string} et contenant {string} inactif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentDisable(this, "definition", name, expectedTextContent);
     }
 );
 
 Then(
-    `je dois voir un(e) définition nommé(e) {string} et contenant {string} actif`,
+    `je dois voir une définition nommée {string} et contenant {string} actif`,
     async function (this: World, name: string, expectedTextContent: string)  {
         await findWithRoleAndNameAndContentEnable(this, "definition", name, expectedTextContent);
     }