@uuv/playwright 1.14.3 → 1.16.0

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

@@ -21,43 +21,57 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 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 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);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 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

@@ -21,43 +21,57 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 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 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);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 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

@@ -21,43 +21,57 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 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 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);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 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

@@ -21,43 +21,57 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 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 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);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 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

@@ -21,43 +21,57 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 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 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);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 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

@@ -21,43 +21,57 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 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 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);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 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

@@ -21,43 +21,57 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 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 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);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 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

@@ -21,43 +21,57 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 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 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);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 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

@@ -21,43 +21,57 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 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 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);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 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

@@ -21,43 +21,57 @@ NE PAS MODIFIER, FICHIER GENERE
 import { Then, When } from "@cucumber/cucumber";
 import {
     findWithRoleAndName,
-    findWithRoleAndNameAndContent, findWithRoleAndNameAndContentDisable, findWithRoleAndNameAndContentEnable,
+    findWithRoleAndNameAndContent,
+    findWithRoleAndNameAndContentDisable,
+    findWithRoleAndNameAndContentEnable,
+    getPageOrElement,
     notFoundWithRoleAndName,
     withinRoleAndName
 } from "../../../core-engine";
 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 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);
+        await byRole.type(textToType);
+        await this.context.clearCookies();
+    });
+});
+
+
 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);
     }