@uuv/cypress 1.14.3 → 1.16.0

package/src/cucumber/step_definitions/cypress/generated/enriched/en/_en-generated-steps-definition_alertdialog.ts

@@ -29,37 +29,41 @@ import {
 } from "../../../core-engine";
 
 
-When(`Within a(n) alert dialog named {string}`, function(name: string) {
+When(`within an alert dialog named {string}`, function(name: string) {
     return withinRoleAndName("alertdialog", name);
 });
 
-Then(`I should see a(n) alert dialog named {string}`, async function(name: string) {
+Then(`I should see an alert dialog named {string}`, async function(name: string) {
     findWithRoleAndName("alertdialog", name);
 });
 
 Then(
-    `I should not see a(n) alert dialog named {string}`,
+    `I should not see an alert dialog named {string}`,
     async function(name: string) {
         notFoundWithRoleAndName("alertdialog", name);
     }
 );
 
+When(`I type the sentence {string} in the alert dialog named {string}`, function(textToType: string, name: string) {
+    cy.uuvFindByRole("alertdialog", { name: name }).uuvFoundedElement().type(textToType);
+});
+
 Then(
-    `I should see a(n) alert dialog named {string} and containing {string}`,
+    `I should see an alert dialog named {string} and containing {string}`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContent("alertdialog", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) alert dialog named {string} and containing {string} disabled`,
+    `I should see an alert dialog named {string} and containing {string} disabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentDisable("alertdialog", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) alert dialog named {string} and containing {string} enabled`,
+    `I should see an alert dialog named {string} and containing {string} enabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentEnable("alertdialog", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/cypress/generated/enriched/en/_en-generated-steps-definition_application.ts

@@ -29,37 +29,41 @@ import {
 } from "../../../core-engine";
 
 
-When(`Within a(n) application named {string}`, function(name: string) {
+When(`within an application named {string}`, function(name: string) {
     return withinRoleAndName("application", name);
 });
 
-Then(`I should see a(n) application named {string}`, async function(name: string) {
+Then(`I should see an application named {string}`, async function(name: string) {
     findWithRoleAndName("application", name);
 });
 
 Then(
-    `I should not see a(n) application named {string}`,
+    `I should not see an application named {string}`,
     async function(name: string) {
         notFoundWithRoleAndName("application", name);
     }
 );
 
+When(`I type the sentence {string} in the application named {string}`, function(textToType: string, name: string) {
+    cy.uuvFindByRole("application", { name: name }).uuvFoundedElement().type(textToType);
+});
+
 Then(
-    `I should see a(n) application named {string} and containing {string}`,
+    `I should see an application named {string} and containing {string}`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContent("application", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) application named {string} and containing {string} disabled`,
+    `I should see an application named {string} and containing {string} disabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentDisable("application", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) application named {string} and containing {string} enabled`,
+    `I should see an application named {string} and containing {string} enabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentEnable("application", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/cypress/generated/enriched/en/_en-generated-steps-definition_article.ts

@@ -29,37 +29,41 @@ import {
 } from "../../../core-engine";
 
 
-When(`Within a(n) article named {string}`, function(name: string) {
+When(`within an article named {string}`, function(name: string) {
     return withinRoleAndName("article", name);
 });
 
-Then(`I should see a(n) article named {string}`, async function(name: string) {
+Then(`I should see an article named {string}`, async function(name: string) {
     findWithRoleAndName("article", name);
 });
 
 Then(
-    `I should not see a(n) article named {string}`,
+    `I should not see an article named {string}`,
     async function(name: string) {
         notFoundWithRoleAndName("article", name);
     }
 );
 
+When(`I type the sentence {string} in the article named {string}`, function(textToType: string, name: string) {
+    cy.uuvFindByRole("article", { name: name }).uuvFoundedElement().type(textToType);
+});
+
 Then(
-    `I should see a(n) article named {string} and containing {string}`,
+    `I should see an article named {string} and containing {string}`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContent("article", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) article named {string} and containing {string} disabled`,
+    `I should see an article named {string} and containing {string} disabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentDisable("article", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) article named {string} and containing {string} enabled`,
+    `I should see an article named {string} and containing {string} enabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentEnable("article", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/cypress/generated/enriched/en/_en-generated-steps-definition_banner.ts

@@ -29,37 +29,41 @@ import {
 } from "../../../core-engine";
 
 
-When(`Within a(n) banner named {string}`, function(name: string) {
+When(`within a banner named {string}`, function(name: string) {
     return withinRoleAndName("banner", name);
 });
 
-Then(`I should see a(n) banner named {string}`, async function(name: string) {
+Then(`I should see a banner named {string}`, async function(name: string) {
     findWithRoleAndName("banner", name);
 });
 
 Then(
-    `I should not see a(n) banner named {string}`,
+    `I should not see a banner named {string}`,
     async function(name: string) {
         notFoundWithRoleAndName("banner", name);
     }
 );
 
+When(`I type the sentence {string} in the banner named {string}`, function(textToType: string, name: string) {
+    cy.uuvFindByRole("banner", { name: name }).uuvFoundedElement().type(textToType);
+});
+
 Then(
-    `I should see a(n) banner named {string} and containing {string}`,
+    `I should see a banner named {string} and containing {string}`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContent("banner", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) banner named {string} and containing {string} disabled`,
+    `I should see a banner named {string} and containing {string} disabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentDisable("banner", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) banner named {string} and containing {string} enabled`,
+    `I should see a banner named {string} and containing {string} enabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentEnable("banner", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/cypress/generated/enriched/en/_en-generated-steps-definition_button.ts

@@ -29,37 +29,41 @@ import {
 } from "../../../core-engine";
 
 
-When(`Within a(n) button named {string}`, function(name: string) {
+When(`within a button named {string}`, function(name: string) {
     return withinRoleAndName("button", name);
 });
 
-Then(`I should see a(n) button named {string}`, async function(name: string) {
+Then(`I should see a button named {string}`, async function(name: string) {
     findWithRoleAndName("button", name);
 });
 
 Then(
-    `I should not see a(n) button named {string}`,
+    `I should not see a button named {string}`,
     async function(name: string) {
         notFoundWithRoleAndName("button", name);
     }
 );
 
+When(`I type the sentence {string} in the button named {string}`, function(textToType: string, name: string) {
+    cy.uuvFindByRole("button", { name: name }).uuvFoundedElement().type(textToType);
+});
+
 Then(
-    `I should see a(n) button named {string} and containing {string}`,
+    `I should see a button named {string} and containing {string}`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContent("button", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) button named {string} and containing {string} disabled`,
+    `I should see a button named {string} and containing {string} disabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentDisable("button", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) button named {string} and containing {string} enabled`,
+    `I should see a button named {string} and containing {string} enabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentEnable("button", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/cypress/generated/enriched/en/_en-generated-steps-definition_cell.ts

@@ -29,37 +29,41 @@ import {
 } from "../../../core-engine";
 
 
-When(`Within a(n) cell named {string}`, function(name: string) {
+When(`within a cell named {string}`, function(name: string) {
     return withinRoleAndName("cell", name);
 });
 
-Then(`I should see a(n) cell named {string}`, async function(name: string) {
+Then(`I should see a cell named {string}`, async function(name: string) {
     findWithRoleAndName("cell", name);
 });
 
 Then(
-    `I should not see a(n) cell named {string}`,
+    `I should not see a cell named {string}`,
     async function(name: string) {
         notFoundWithRoleAndName("cell", name);
     }
 );
 
+When(`I type the sentence {string} in the cell named {string}`, function(textToType: string, name: string) {
+    cy.uuvFindByRole("cell", { name: name }).uuvFoundedElement().type(textToType);
+});
+
 Then(
-    `I should see a(n) cell named {string} and containing {string}`,
+    `I should see a cell named {string} and containing {string}`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContent("cell", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) cell named {string} and containing {string} disabled`,
+    `I should see a cell named {string} and containing {string} disabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentDisable("cell", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) cell named {string} and containing {string} enabled`,
+    `I should see a cell named {string} and containing {string} enabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentEnable("cell", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/cypress/generated/enriched/en/_en-generated-steps-definition_checkbox.ts

@@ -29,37 +29,41 @@ import {
 } from "../../../core-engine";
 
 
-When(`Within a(n) checkbox named {string}`, function(name: string) {
+When(`within a checkbox named {string}`, function(name: string) {
     return withinRoleAndName("checkbox", name);
 });
 
-Then(`I should see a(n) checkbox named {string}`, async function(name: string) {
+Then(`I should see a checkbox named {string}`, async function(name: string) {
     findWithRoleAndName("checkbox", name);
 });
 
 Then(
-    `I should not see a(n) checkbox named {string}`,
+    `I should not see a checkbox named {string}`,
     async function(name: string) {
         notFoundWithRoleAndName("checkbox", name);
     }
 );
 
+When(`I type the sentence {string} in the checkbox named {string}`, function(textToType: string, name: string) {
+    cy.uuvFindByRole("checkbox", { name: name }).uuvFoundedElement().type(textToType);
+});
+
 Then(
-    `I should see a(n) checkbox named {string} and containing {string}`,
+    `I should see a checkbox named {string} and containing {string}`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContent("checkbox", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) checkbox named {string} and containing {string} disabled`,
+    `I should see a checkbox named {string} and containing {string} disabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentDisable("checkbox", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) checkbox named {string} and containing {string} enabled`,
+    `I should see a checkbox named {string} and containing {string} enabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentEnable("checkbox", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/cypress/generated/enriched/en/_en-generated-steps-definition_columnheader.ts

@@ -29,37 +29,41 @@ import {
 } from "../../../core-engine";
 
 
-When(`Within a(n) column header named {string}`, function(name: string) {
+When(`within a column header named {string}`, function(name: string) {
     return withinRoleAndName("columnheader", name);
 });
 
-Then(`I should see a(n) column header named {string}`, async function(name: string) {
+Then(`I should see a column header named {string}`, async function(name: string) {
     findWithRoleAndName("columnheader", name);
 });
 
 Then(
-    `I should not see a(n) column header named {string}`,
+    `I should not see a column header named {string}`,
     async function(name: string) {
         notFoundWithRoleAndName("columnheader", name);
     }
 );
 
+When(`I type the sentence {string} in the column header named {string}`, function(textToType: string, name: string) {
+    cy.uuvFindByRole("columnheader", { name: name }).uuvFoundedElement().type(textToType);
+});
+
 Then(
-    `I should see a(n) column header named {string} and containing {string}`,
+    `I should see a column header named {string} and containing {string}`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContent("columnheader", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) column header named {string} and containing {string} disabled`,
+    `I should see a column header named {string} and containing {string} disabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentDisable("columnheader", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) column header named {string} and containing {string} enabled`,
+    `I should see a column header named {string} and containing {string} enabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentEnable("columnheader", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/cypress/generated/enriched/en/_en-generated-steps-definition_combobox.ts

@@ -29,37 +29,41 @@ import {
 } from "../../../core-engine";
 
 
-When(`Within a(n) combo box named {string}`, function(name: string) {
+When(`within a combo box named {string}`, function(name: string) {
     return withinRoleAndName("combobox", name);
 });
 
-Then(`I should see a(n) combo box named {string}`, async function(name: string) {
+Then(`I should see a combo box named {string}`, async function(name: string) {
     findWithRoleAndName("combobox", name);
 });
 
 Then(
-    `I should not see a(n) combo box named {string}`,
+    `I should not see a combo box named {string}`,
     async function(name: string) {
         notFoundWithRoleAndName("combobox", name);
     }
 );
 
+When(`I type the sentence {string} in the combo box named {string}`, function(textToType: string, name: string) {
+    cy.uuvFindByRole("combobox", { name: name }).uuvFoundedElement().type(textToType);
+});
+
 Then(
-    `I should see a(n) combo box named {string} and containing {string}`,
+    `I should see a combo box named {string} and containing {string}`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContent("combobox", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) combo box named {string} and containing {string} disabled`,
+    `I should see a combo box named {string} and containing {string} disabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentDisable("combobox", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) combo box named {string} and containing {string} enabled`,
+    `I should see a combo box named {string} and containing {string} enabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentEnable("combobox", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/cypress/generated/enriched/en/_en-generated-steps-definition_command.ts

@@ -29,37 +29,41 @@ import {
 } from "../../../core-engine";
 
 
-When(`Within a(n) command named {string}`, function(name: string) {
+When(`within a command named {string}`, function(name: string) {
     return withinRoleAndName("command", name);
 });
 
-Then(`I should see a(n) command named {string}`, async function(name: string) {
+Then(`I should see a command named {string}`, async function(name: string) {
     findWithRoleAndName("command", name);
 });
 
 Then(
-    `I should not see a(n) command named {string}`,
+    `I should not see a command named {string}`,
     async function(name: string) {
         notFoundWithRoleAndName("command", name);
     }
 );
 
+When(`I type the sentence {string} in the command named {string}`, function(textToType: string, name: string) {
+    cy.uuvFindByRole("command", { name: name }).uuvFoundedElement().type(textToType);
+});
+
 Then(
-    `I should see a(n) command named {string} and containing {string}`,
+    `I should see a command named {string} and containing {string}`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContent("command", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) command named {string} and containing {string} disabled`,
+    `I should see a command named {string} and containing {string} disabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentDisable("command", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) command named {string} and containing {string} enabled`,
+    `I should see a command named {string} and containing {string} enabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentEnable("command", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/cypress/generated/enriched/en/_en-generated-steps-definition_comment.ts

@@ -29,37 +29,41 @@ import {
 } from "../../../core-engine";
 
 
-When(`Within a(n) comment named {string}`, function(name: string) {
+When(`within a comment named {string}`, function(name: string) {
     return withinRoleAndName("comment", name);
 });
 
-Then(`I should see a(n) comment named {string}`, async function(name: string) {
+Then(`I should see a comment named {string}`, async function(name: string) {
     findWithRoleAndName("comment", name);
 });
 
 Then(
-    `I should not see a(n) comment named {string}`,
+    `I should not see a comment named {string}`,
     async function(name: string) {
         notFoundWithRoleAndName("comment", name);
     }
 );
 
+When(`I type the sentence {string} in the comment named {string}`, function(textToType: string, name: string) {
+    cy.uuvFindByRole("comment", { name: name }).uuvFoundedElement().type(textToType);
+});
+
 Then(
-    `I should see a(n) comment named {string} and containing {string}`,
+    `I should see a comment named {string} and containing {string}`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContent("comment", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) comment named {string} and containing {string} disabled`,
+    `I should see a comment named {string} and containing {string} disabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentDisable("comment", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) comment named {string} and containing {string} enabled`,
+    `I should see a comment named {string} and containing {string} enabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentEnable("comment", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/cypress/generated/enriched/en/_en-generated-steps-definition_complementary.ts

@@ -29,37 +29,41 @@ import {
 } from "../../../core-engine";
 
 
-When(`Within a(n) complementary named {string}`, function(name: string) {
+When(`within a complementary named {string}`, function(name: string) {
     return withinRoleAndName("complementary", name);
 });
 
-Then(`I should see a(n) complementary named {string}`, async function(name: string) {
+Then(`I should see a complementary named {string}`, async function(name: string) {
     findWithRoleAndName("complementary", name);
 });
 
 Then(
-    `I should not see a(n) complementary named {string}`,
+    `I should not see a complementary named {string}`,
     async function(name: string) {
         notFoundWithRoleAndName("complementary", name);
     }
 );
 
+When(`I type the sentence {string} in the complementary named {string}`, function(textToType: string, name: string) {
+    cy.uuvFindByRole("complementary", { name: name }).uuvFoundedElement().type(textToType);
+});
+
 Then(
-    `I should see a(n) complementary named {string} and containing {string}`,
+    `I should see a complementary named {string} and containing {string}`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContent("complementary", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) complementary named {string} and containing {string} disabled`,
+    `I should see a complementary named {string} and containing {string} disabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentDisable("complementary", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) complementary named {string} and containing {string} enabled`,
+    `I should see a complementary named {string} and containing {string} enabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentEnable("complementary", name, expectedTextContent);
     }

package/src/cucumber/step_definitions/cypress/generated/enriched/en/_en-generated-steps-definition_composite.ts

@@ -29,37 +29,41 @@ import {
 } from "../../../core-engine";
 
 
-When(`Within a(n) composite named {string}`, function(name: string) {
+When(`within a composite named {string}`, function(name: string) {
     return withinRoleAndName("composite", name);
 });
 
-Then(`I should see a(n) composite named {string}`, async function(name: string) {
+Then(`I should see a composite named {string}`, async function(name: string) {
     findWithRoleAndName("composite", name);
 });
 
 Then(
-    `I should not see a(n) composite named {string}`,
+    `I should not see a composite named {string}`,
     async function(name: string) {
         notFoundWithRoleAndName("composite", name);
     }
 );
 
+When(`I type the sentence {string} in the composite named {string}`, function(textToType: string, name: string) {
+    cy.uuvFindByRole("composite", { name: name }).uuvFoundedElement().type(textToType);
+});
+
 Then(
-    `I should see a(n) composite named {string} and containing {string}`,
+    `I should see a composite named {string} and containing {string}`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContent("composite", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) composite named {string} and containing {string} disabled`,
+    `I should see a composite named {string} and containing {string} disabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentDisable("composite", name, expectedTextContent);
     }
 );
 
 Then(
-    `I should see a(n) composite named {string} and containing {string} enabled`,
+    `I should see a composite named {string} and containing {string} enabled`,
     async function(name: string, expectedTextContent: string) {
         findWithRoleAndNameAndContentEnable("composite", name, expectedTextContent);
     }