itemengine-cypress-automation 1.0.240-textentrychangesreverted-28d08d1.0 → 1.0.241-28thAugustRepoUpdate-dc7df0c.0

package/cypress/pages/listOrderingPage.js

@@ -79,7 +79,22 @@ const selectors = {
     //set points popup
     setPointsButton: () => cy.get('.list-ordering-set-correct-answer button'),
     optionWrapperSetPointsPopup: () => cy.get('[class*="OptionContainerstyle__OptionsWrapper"]'),
-    pointsLabelSetPointsPopup: () => cy.get('.dialog-content [class*="PointsLabel-"]')
+    pointsLabelSetPointsPopup: () => cy.get('.dialog-content [class*="PointsLabel-"]'),
+
+    optionHorizontalSpecifyCorrectAnswerSection: () => cy.get('.list-ordering-set-correct-answer .horizontal-drag-item-wrapper'),
+    optionHorizontalPreviewTab: () => cy.get('[class*="question-preview-wrapper"] .horizontal-drag-item-wrapper'),
+    optionOrientationSectionLabel: () => cy.get('.single-select-toggle-group-title'),
+    singleSelectToggleButton: () => cy.get('.single-select-toggle-group'),
+    enableWrappingLabel: () => cy.get('.enable-wrapper'),
+    enableWrappingCheckbox: () => cy.get('.enable-wrapper .label-selected'),
+    horizontalOptionWrapperSpecifyCorrectAnswerSection: () => cy.get('[class*="ReorderSameListstyles__GridItemsWrapper"]'),
+
+
+    //Reorder as seperate List
+    dropzoneSeperateList: () => cy.get('[class*="MultipleDroppableHotspotstyle__DroppableHotspotWrapper"]'),
+    optionsSeperateList: () => cy.get('[class*="DraggableItemstyle__ItemWrapper"]'),
+    droppedOptionSeperateList: () => cy.get('[class*="MultipleDroppedItemstyles__FlexWrapper"]'),
+    correctAnswersWrapper: () => cy.get('.correct-answers-wrapper'),
 }
 
 const steps = {
@@ -891,6 +906,17 @@ const steps = {
                 expect($element[0].className.includes('icon-incorrect')).to.be.true;
             });
     },
+    /**
+    * @param {string} optionsText option to be checked for the correct icon
+    * @description This function verifies the correct icon in the preview tab for an option in horizontal option orientation for seperate list.
+    */
+    verifyIncorrectOptionIconHorizontalOrientationSeperateList: (optionsText) => {
+        listOrderingPage.droppedOptionSeperateList()
+            .contains(optionsText)
+            .parents('[class*="MultipleDroppedItemstyles__FlexWrapper"]')
+            .find('.tick-icon-wrapper')
+            .should('have.class', 'icon-incorrect');
+    },
 
     verifyCorrectOptionIconsCorrectAnswerSection: () => {
         listOrderingPage.correctAnswerSectionIconWrapper()
@@ -991,7 +1017,352 @@ const steps = {
      */
     verifyTextContentOfHorizontalOptionInPreviewTab: (optionsText, index) => {
         utilities.verifyTextContent(utilities.getNthElement(listOrderingPage.horizontalOptionPreviewTab(), index), optionsText);
-    }
+    },
+
+    /** Verifies the orientation option on the list ordering page.
+    * @param {'Vertical' | 'Horizontal'} orientationOption - The orientation option to verify.
+    */
+    verifySelectedStateOfOptionOrientationToggle: (orientationOption) => {
+        switch (orientationOption) {
+            case 'Vertical':
+                listOrderingPage.verticalButton()
+                    .should('have.class', 'single-select-toggle-button-selected');
+                break;
+            case 'Horizontal':
+                listOrderingPage.horizontalButton()
+                    .should('have.class', 'single-select-toggle-button-selected');
+                break;
+        }
+    },
+
+    verifyEnableWrappingCheckboxChecked: () => {
+        listOrderingPage.enableWrappingCheckbox()
+            .find('.icon-checkbox-selected')
+            .should('exist');
+    },
+
+
+    verifyEnableWrappingCheckboxUnchecked: () => {
+        listOrderingPage.enableWrappingCheckbox()
+            .should('not.exist');
+    },
+
+    /** Verifies the orientation option on the list ordering page in specify correct answer.
+    * @param {'Vertical' | 'Horizontal'} orientationOption - The orientation option to verify.
+    */
+    verifyOptionOrientation: (orientationOption) => {
+        switch (orientationOption) {
+            case 'Vertical':
+                listOrderingPage.optionWrapperSpecifyCorrectAnswerSection()
+                    .should('have.css', 'flex-flow', 'column wrap');
+                break;
+            case 'Horizontal':
+                listOrderingPage.horizontalOptionWrapperSpecifyCorrectAnswerSection()
+                    .should('have.css', 'display', 'flex');
+                break;
+        }
+    },
+
+    /** Verifies the orientation option on the list ordering page in specify correct answer.
+    * @param {'enabled' | 'disabled'} wrappingState - The orientation option to verify.
+    */
+    verifyHorizontalWrapping: (wrappingState) => {
+        switch (wrappingState) {
+            case 'enabled':
+                listOrderingPage.horizontalOptionWrapperSpecifyCorrectAnswerSection()
+                    .should('have.css', 'flex-wrap', 'wrap');
+                break;
+            case 'disabled':
+                listOrderingPage.horizontalOptionWrapperSpecifyCorrectAnswerSection()
+                    .should('not.have.css', 'flex-wrap', 'wrap');
+                break;
+        }
+    },
+
+    /** Verifies the orientation option on the list ordering page in preview tab.
+    * @param {'Vertical' | 'Horizontal'} orientationOption - The orientation option to verify.
+    */
+    verifyOptionOrientationInPreviewTab: (orientationOption) => {
+        switch (orientationOption) {
+            case 'Vertical':
+                listOrderingPage.optionWrapperSpecifyCorrectAnswerSection()
+                    .should('have.css', 'flex-flow', 'column wrap');
+                break;
+            case 'Horizontal':
+                listOrderingPage.horizontalOptionWrapperSpecifyCorrectAnswerSection()
+                    .should('have.css', 'display', 'flex');
+                break;
+        }
+    },
+
+    /**
+     * @param {string} optionsText text content of the option
+     * @param {number} targetIndex the position at which the options is being dropped
+     * @description click and drop a option into a position in the specify correct answer section
+     */
+    clickAndReorderOptionInHorizontalSpecifyCorrectAnswerSection: (optionsText, targetIndex) => {
+        listOrderingPage.optionHorizontalSpecifyCorrectAnswerSection()
+            .contains(optionsText)
+            .click();
+        listOrderingPage.optionHorizontalSpecifyCorrectAnswerSection()
+            .eq(targetIndex)
+            .click();
+    },
+
+    /**
+     * @param {string} optionsText text content of the option
+     * @param {number} targetIndex the position at which the options is being dropped
+     * @description click and drop a option into a position in the specify correct answer section
+     */
+    clickAndReorderOptionInHorizontalPreviewTab: (optionsText, targetIndex) => {
+        listOrderingPage.optionHorizontalPreviewTab()
+            .contains(optionsText)
+            .click();
+        listOrderingPage.optionHorizontalPreviewTab()
+            .eq(targetIndex)
+            .click();
+    },
+
+    checkEnableWrappingCheckbox: () => {
+        listOrderingPage.enableWrappingCheckbox()
+            .click()
+            .should('be.checked');
+    },
+
+    uncheckEnableWrappingCheckbox: () => {
+        listOrderingPage.enableWrappingCheckbox()
+            .click()
+            .should('not.be.checked');
+    },
+
+    /**
+    * @param {string} optionsText option to be checked for the correct icon
+    * @description This function verifies the correct icon in the preview tab
+    */
+    verifyIncorrectOptionIconSeperateList: (optionsText) => {
+        listOrderingPage.dropzoneSeperateList()
+            .contains(optionsText)
+            .parents('[class*="MultipleDroppedItemstyles__FlexWrapper"]')
+            .within(() => {
+                utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.incorrectIcon(), 'exist');
+            });
+    },
+
+    /**
+     * Verifies the order of options in the dropzone of order as seperate list.
+     * @param {string[]} optionsTextArray - An array containing the text of options in the expected order.
+     */
+    verifyOptionsInDropzoneOrderAsSeperateList: (optionsTextArray) => {
+        optionsTextArray.forEach((option, index) => {
+            utilities.verifyInnerText(utilities.getNthElement(listOrderingPage.dropzoneSeperateList().find('[class*="MultipleDroppedItemstyles__FlexWrapper"]'), index), option);
+        });
+    },
+
+    /**
+    * @param {string} optionsText option to be checked for the correct icon
+    * @description This function verifies the correct icon in the preview tab
+    */
+    verifyCorrectOptionIconSeperateList: (optionsText) => {
+        listOrderingPage.dropzoneSeperateList()
+            .contains(optionsText)
+            .parents('[class*="MultipleDroppedItemstyles__FlexWrapper"]')
+            .within(() => {
+                utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.correctIcon(), 'exist');
+            });
+    },
+
+    /**
+     * @param {string[]} optionsTextArray options array for preview tab options
+     * @description this function verifies options text content
+     */
+    verifyTextContentOfOptionSeperateList: (optionsText, index) => {
+        utilities.verifyInnerText(utilities.getNthElement(listOrderingPage.optionsSeperateList(), index), optionsText);
+    },
+
+    /**
+    * @param {string} optionsText text content of the option
+    * @description click and drop a option into the dropzone in the specify correct answer section
+    */
+    clickAndDropOptionSeperateList: (optionsText) => {
+        listOrderingPage.optionsSeperateList()
+            .contains(optionsText)
+            .click();
+        listOrderingPage.dropzoneSeperateList()
+            .click();
+    },
+
+    /**
+     * Verifies the order of Horizontal options in the "Specify Correct Answer" section.
+     * @param {string[]} optionsTextArray - An array containing the text of options in the expected order.
+     */
+    verifyHorizontalOptionsOrderInSpecifyCorrectAnswerSection: (optionsTextArray) => {
+        optionsTextArray.forEach((option, index) => {
+            utilities.verifyInnerText(utilities.getNthElement(listOrderingPage.optionHorizontalSpecifyCorrectAnswerSection().find('[class*="DragItemstyles__DragItemWrapper"]'), index), option);
+        });
+    },
+
+    /**
+     * Verifies the order of horizontal options in the preview tab
+     * @param {string[]} optionsTextArray - An array containing the text of options in the expected order.
+     */
+    verifyHorizontalOptionsOrderInPreviewTab: (optionsTextArray) => {
+        optionsTextArray.forEach((option, index) => {
+            utilities.verifyInnerText(utilities.getNthElement(listOrderingPage.optionHorizontalPreviewTab(), index), option);
+        });
+    },
+
+    /**
+     * @description Verifies that the equation text in the Preview tab is correct.
+     * @param {number} optionIndex - The index of the option in the Preview tab.
+     */
+    verifyOptionWithEquationTextInDropzonePreviewTabSeperateList: (optionIndex) => {
+        listOrderingPage.droppedOptionSeperateList()
+            .eq(optionIndex)
+            .find('[role="math"]')
+            .should('have.attr', 'aria-label', constants.CKEditorInputFieldEnteredEquationAriaLabel)
+            .contains(constants.CKEditorInputFieldEnteredEquationText);
+    },
+
+    /**
+     * @description Verifies that the equation text in the correct answer section is correct.
+     * @param {number} optionIndex - The index of the option in the Preview tab.
+     */
+    verifyOptionWithEquationTextInDropzoneCorrectAnswerSectionSeperateList: (optionIndex) => {
+        listOrderingPage.correctAnswerSectionIconWrapper()
+            .eq(optionIndex)
+            .find('[role="math"]')
+            .should('have.attr', 'aria-label', constants.CKEditorInputFieldEnteredEquationAriaLabel)
+            .contains(constants.CKEditorInputFieldEnteredEquationText);
+    },
+
+    /**
+     * @description Verifies that the equation text in the Preview tab is correct.
+     * @param {number} optionIndex - The index of the option in the Preview tab.
+     */
+    verifyOptionWithEquationTextInOptionsContainerPreviewTabSeperateList: (optionIndex) => {
+        listOrderingPage.optionsSeperateList()
+            .eq(optionIndex)
+            .find('[role="math"]')
+            .should('have.attr', 'aria-label', constants.CKEditorInputFieldEnteredEquationAriaLabel)
+            .contains(constants.CKEditorInputFieldEnteredEquationText);
+    },
+
+    /**
+     * @param {string[]} optionsTextArray options array for preview tab options
+     * @description this function verifies options text content
+     */
+    verifyTextContentOfOptionInDropzonePreviewTabSeperateList: (optionsText, index) => {
+        utilities.verifyTextContent(utilities.getNthElement(listOrderingPage.droppedOptionSeperateList(), index), optionsText);
+    },
+    /**
+     * @param {string[]} optionsTextArray options array for preview tab options
+     * @description this function verifies options text content
+     */
+    verifyTextContentOfOptionInPreviewTabSeperateList: (optionsText, index) => {
+        utilities.verifyTextContent(utilities.getNthElement(listOrderingPage.optionsSeperateList(), index), optionsText);
+    },
+
+    /**
+     * @param {string[]} optionsTextArray options array for correct answer section options
+     * @description this function verifies options text content
+     */
+    verifyTextContentOfOptionInDropzoneCorrectAnswerSectionSeperateList: (optionsText, index) => {
+        utilities.verifyTextContent(utilities.getNthElement(listOrderingPage.correctAnswerSectionIconWrapper(), index), optionsText);
+    },
+
+    /**
+     * @description Verifies that the bold text in the Preview tab is correct for seperate list.
+     * @param {number} optionIndex - The index of the option in the Preview tab.
+     */
+    verifyOptionWithBoldTextInDropzonePreviewTabSeperateList: (optionIndex) => {
+        listOrderingPage.droppedOptionSeperateList()
+            .eq(optionIndex)
+            .find('strong')
+            .should('have.text', 'This is a bold option');
+    },
+
+    /**
+     * @description Verifies that the bold text in the correct answer section is correct for seperate list.
+     * @param {number} optionIndex - The index of the option in the Preview tab.
+     */
+    verifyOptionWithBoldTextInDropzoneCorrectAnswerSectionSeperateList: (optionIndex) => {
+        listOrderingPage.correctAnswerSectionIconWrapper()
+            .eq(optionIndex)
+            .find('strong')
+            .should('have.text', 'This is a bold option');
+    },
+
+    /**
+     * @description Verifies that the bold text in the Preview tab is correct for seperate list.
+     * @param {number} optionIndex - The index of the option in the Preview tab.
+     */
+    verifyOptionWithBoldTextInOptionsContainerPreviewTabSeperateList: (optionIndex) => {
+        listOrderingPage.optionsSeperateList()
+            .eq(optionIndex)
+            .find('strong')
+            .should('have.text', 'This is a bold option');
+    },
+
+    /**
+    * @description Verifies that the image in the Preview tab has the correct source and alt text.
+    * @param {number} optionIndex - The index of the option in the Preview tab.
+    */
+    verifyOptionWithImageInDropzonePreviewTabSeperateList: (optionIndex) => {
+        listOrderingPage.droppedOptionSeperateList()
+            .eq(optionIndex)
+            .find('img')
+            .should('have.attr', 'src', constants.foxImageLink)
+            .and('have.attr', 'alt', constants.foxImageAltText);
+    },
+
+    /**
+    * @description Verifies that the image in the correct answer section has the correct source and alt text.
+    * @param {number} optionIndex - The index of the option in the Preview tab.
+    */
+    verifyOptionWithImageInDropzoneCorrectAnswerSectionTabSeperateList: (optionIndex) => {
+        listOrderingPage.correctAnswerSectionIconWrapper()
+            .eq(optionIndex)
+            .find('img')
+            .should('have.attr', 'src', constants.foxImageLink)
+            .and('have.attr', 'alt', constants.foxImageAltText);
+    },
+
+    /**
+    * @description Verifies that the image in the Preview tab has the correct source and alt text.
+    * @param {number} optionIndex - The index of the option in the Preview tab.
+    */
+    verifyOptionWithImageInOptionsContainerPreviewTabSeperateList: (optionIndex) => {
+        listOrderingPage.optionsSeperateList()
+            .eq(optionIndex)
+            .find('img')
+            .should('have.attr', 'src', constants.foxImageLink)
+            .and('have.attr', 'alt', constants.foxImageAltText);
+    },
+
+    /**
+    * @param {string} optionsText option to be checked for the correct icon
+    * @description This function verifies the correct icon in the preview tab for an option in horizontal option orientation
+    */
+    verifyCorrectOptionIconOrientationSeperateList: (optionsText) => {
+        listOrderingPage.droppedOptionSeperateList()
+            .contains(optionsText)
+            .parents('[class*="MultipleDroppedItemstyles__FlexWrapper"]')
+            .find('.tick-icon-wrapper')
+            .should('have.class', 'icon-correct');
+    },
+
+    /**
+     * @param {string} optionsText text content of the option
+     * @param {number} targetIndex the position at which the options is being dropped
+     * @description verifies option cant be selected in grading view
+     */
+    verifyOptionNotEditableInGradingViewSeperateList: (optionsTextArray) => {
+        optionsTextArray.forEach(optionsText => {
+            listOrderingPage.droppedOptionSeperateList()
+                .contains(optionsText)
+                .should('have.css', 'pointer-events', 'none');
+        });
+    },
 }
 
 const tests = {

package/cypress/pages/matchingPage.js

@@ -27,8 +27,9 @@ const selectors = {
     //Edit tab
     promptInputField: () => cy.get('.edit-mcq-stems-wrapper [role="textbox"]'),
     promptInputFieldWrapper: () => cy.get('.edit-mcq-stems-wrapper .edit-mcq-option-wrapper'),
-    optionInputField: () => cy.get('.edit-mcq-options-wrapper [data-rbd-draggable-id*="option-draggable"] [role="textbox"]'),
+    optionInputField: () => cy.get('.edit-mcq-options-wrapper [data-rbd-draggable-id*="option-draggable"] [role="textbox"], .edit-mcq-options-wrapper [data-rbd-draggable-id*="option-draggable"] [type="text"]'),
     optionsLabel: () => cy.get('.cloze-with-drag-and-drop-options-label'),
+    matchingLayoutLabel: () => cy.get('.match-layout-container .options-label'),
     optionWrapper: () => cy.get('.response-options-wrapper [data-rbd-draggable-id*="option-draggable"]'),
     promptNumeration: () => cy.get('[class*="SingleOptionstyle__AdornmentDiv"]'),
     promptLabel: () => cy.get('.match-list-stem-label'),
@@ -49,18 +50,26 @@ const selectors = {
         }
     },
     optionInputFieldDropdown: () => cy.get('.edit-mcq-options-wrapper [data-rbd-draggable-id*="option-draggable"] [type="text"]'),
+    connectorButton: () => cy.get('button[aria-label*="Matching layout Connectors"]'),
+    noConnectorButton: () => cy.get('button[aria-label*="Matching layout No connectors"]'),
+    connectorLabel: () => cy.get('button[aria-label*="Matching layout Connectors"] .ngie-toggle-button-label'),
+    noConnectorLabel: () => cy.get('button[aria-label*="Matching layout No connectors"] .ngie-toggle-button-label'),
+    optionInnnerFieldInputFieldDropdown: () => cy.get(' .edit-mcq-options-wrapper [data-rbd-draggable-id*="option-draggable"] .MuiOutlinedInput-inputAdornedStart'),
     //Specify correct answer section
+    connectorIcon: () => cy.get('.correct-answer-accordion [class*="ClozeWithDragAndDropstyles__ShowIconWrapper"]'),
     dropzoneSpecifyCorrectAnswerSection: () => cy.get('.correct-answer-wrapper .authoring-droppable-hotspot-wrapper'),
     dropzoneWrapperSpecifyCorrectAnswerSection: () => cy.get('.match-list-form-control-wrapper-preview .authoring-droppable-hotspot-wrapper'),
     optionContainerOptionsSpecifyCorrectAnswerSection: () => cy.get('.draggable-selected-item'),
     addPromptButton: () => cy.get('.add-option-wrapper-cls button').contains('Add prompt'),
     deletePromptButton: () => cy.get('[aria-label*="Delete prompt "]'),
-    optionNumeration: () => cy.get('.response-options-wrapper [class*="SingleOptionstyle__AdornmentDiv"]'),
+    optionNumeration: () => cy.get('.response-options-wrapper [class*="SingleOptionstyle__AdornmentDiv"],[class*="OptionSelectionComponentstyle__OptionsWrapper"] [class*="MuiInputAdornment-positionStart"]'),
     promptSpecifyCorrectAnswerSection: () => cy.get('.correct-answer-wrapper .stem-container [data-testid="question-instruction-element"]'),
     draggableOptionInDropzoneInSpecifyCorrectAnswer: () => cy.get('.item-content-wrapper'),
     droppedDraggableOptionInDropzoneSpecifyCorrectAnswerSection: () => cy.get('[class*="MultipleDroppedItemstyles__ItemWrapper"]'),
     optionsContainerSpecifyCorrectAnswerSection: () => cy.get('.draggable-wrapper'),
     dropdownSpecifyCorrectAnswerSection: () => cy.get('.correct-answer-wrapper [aria-haspopup="listbox"]'),
+    dropdownSpecifyCorrectAnswerSectionOption: () => cy.get('.correct-answer-wrapper .dropdown-form-control'),
+    dropdownPreviewTabOption: () => cy.get('[class*="ResponseDropdownComponentstyles__ResponseDropdownWrapper"] .dropdown-form-control'),
     dropdownPreviewTab: () => cy.get('[class*="ResponseDropdownComponentstyles__ResponseDropdownWrapper"] [aria-haspopup="listbox"]'),
     dropdownGradingView: () => cy.get('.dropdown-form-control'),
     dropdownList: () => cy.get('.dropdown-list-ul'),
@@ -104,7 +113,8 @@ const selectors = {
     droppedDraggableOptionInDropzonePreviewTab: () => cy.get('[class*="MultipleDroppedItemstyles__ItemWrapper"]'),
     warningMessage: () => cy.get('[class*="DropzoneLimitErrorMessagestyles__ErrorWrapper"] [class*="DropzoneLimitErrorMessagestyles__ErrorMessage"]'),
     warningMessageContainer: () => cy.get('[class*="DropzoneLimitErrorMessagestyles__ErrorWrapper"]'),
-    dropzoneColumnAndPromptHeaderWrapperPreviewTab: () => cy.get('.edit-question-preview-wrapper [class*="ClozeWithDragAndDropstyles__ResponseHeaderWrapper"]')
+    dropzoneColumnAndPromptHeaderWrapperPreviewTab: () => cy.get('.edit-question-preview-wrapper [class*="ClozeWithDragAndDropstyles__ResponseHeaderWrapper"]'),
+    connectorIconPreviewTab: () => cy.get('.edit-question-preview-wrapper  [class*="ClozeWithDragAndDropstyles__ShowIconWrapper"]'),
 }
 
 const steps = {
@@ -276,7 +286,11 @@ const steps = {
             matchingPage.optionInputField()
                 .eq(index)
                 .clear()
+            matchingPage.optionInputField()
+                .eq(index)
                 .type(options, { delay: 50 })
+            matchingPage.optionInputField()
+                .eq(index)
                 .blur();
         });
     },
@@ -351,21 +365,6 @@ const steps = {
             .should('have.text', '​​​​​​​This is a bold option');
     },
 
-    /**
-    * @param {number} index of the option
-    * @description verify the enter option input field, drag handle, delete button and option numeration
-    */
-    verifyOptionsContents: (index) => {
-        matchingPage.optionInputField()
-            .eq(index)
-            .should('have.attr', 'data-cke-editorplaceholder', 'Enter option');
-        utilities.verifyElementVisibilityState(commonComponents.dragHandleButton(), 'exist');
-        utilities.verifyElementVisibilityState(commonComponents.deleteButton(), 'visible');
-        matchingPage.optionNumeration()
-            .eq(index)
-            .should('have.text', index + 1);
-    },
-
     verifyDeleteOptionButtonDisabledState: () => {
         matchingPage.optionWrapper()
             .eq(0)
@@ -431,15 +430,22 @@ const steps = {
     * @param {number} index of the option
     * @description verify the enter option input field, drag handle, delete button and option numeration
     */
-    verifyOptionsContents: (index) => {
-        matchingPage.optionInputField()
-            .eq(index)
-            .should('have.attr', 'data-cke-editorplaceholder', 'Enter option');
+    verifyOptionsContents: (index, questionType = null) => {
+        if (questionType === 'dropdown') {
+            matchingPage.optionInputField()
+                .eq(index)
+                .should('have.attr', 'placeholder', 'Enter option');
+        } else {
+            matchingPage.optionInputField()
+                .eq(index)
+                .should('have.attr', 'data-cke-editorplaceholder', 'Enter option');
+        }
+
         utilities.verifyElementVisibilityState(commonComponents.dragHandleButton(), 'exist');
         utilities.verifyElementVisibilityState(commonComponents.deleteButton(), 'visible');
         matchingPage.optionNumeration()
             .eq(index)
-            .should('have.text', index + 1);
+            .should('have.text', `${index + 1}`);
     },
 
     verifyDeleteOptionButtonDisabledState: () => {
@@ -1446,6 +1452,27 @@ const steps = {
         });
     },
 
+    /**
+     * Selects the matching layout on the matching page.
+     * @param {'Connectors' | 'noConnectors'} matchingLayoutButton - The matching layout button to select.
+     */
+    selectMatchingLayout: (matchingLayoutButton) => {
+        switch (matchingLayoutButton) {
+            case 'Connectors':
+                matchingPage.connectorButton()
+                    .click()
+                    .should('have.attr', 'aria-pressed', 'true');
+                break;
+            case 'noConnectors':
+                matchingPage.noConnectorButton()
+                    .click()
+                    .should('have.attr', 'aria-pressed', 'true');
+                break;
+            default:
+                throw new Error('Invalid option');
+        }
+    },
+
     /**
      * @description Verifies if the specified text is displayed in the dropdown specify correct answer section.
      * @param {number} dropdownIndex - The index of the dropdown.
@@ -1552,6 +1579,18 @@ const steps = {
         });
     },
 
+    /**
+     * Verify that a specific dropdown is disabled in the specify correct answer setion.
+     * @param {number} index - The index of the disabled dropdown.
+     */
+    enterNewTextInOptionInputFieldDropdown: (index, options) => {
+        matchingPage.optionInputFieldDropdown()
+            .eq(index)
+            .clear()
+            .type(options, { delay: 50 })
+            .blur();
+    },
+
     verifyWarningIconOnRequiredFields: (requiredFieldsArray) => {
         requiredFieldsArray.forEach((field) => {
             if (field === 'Please set points') {
@@ -1571,6 +1610,25 @@ const steps = {
                     });
             }
         })
+    },
+
+    /**
+     * Verifies the matching layout option on the matching page..
+     * @param {'Connectors' | 'noConnectors'} selectedOption - The matching layout Option  to verify.
+     */
+    verifyMatchingLayoutSelected: (selectedOption) => {
+        switch (selectedOption) {
+            case 'Connectors':
+                matchingPage.connectorButton()
+                    .should('have.attr', 'aria-pressed', 'true');
+                break;
+            case 'NoConnectors':
+                matchingPage.noConnectorButton()
+                    .should('have.attr', 'aria-pressed', 'true');
+                break;
+            default:
+                throw new Error('Invalid option');
+        }
     }
 }
 
@@ -1617,14 +1675,14 @@ const tests = {
      * Verifies the contents and styling of the 'Options' section.
      * @param {number} optionFieldsCount - The expected number of option input fields.
      */
-    verifyOptionsSectionContents: ({ optionFieldsCount, optionLabel }) => {
+    verifyOptionsSectionContents: ({ optionFieldsCount, optionLabel, questionType = null }) => {
         it(`\'${optionLabel}\' label should be displayed`, () => {
             utilities.verifyInnerText(matchingPage.optionsLabel(), optionLabel);
         });
 
         it(`By default ${optionFieldsCount} option input fields with placeholder text, drag handle and delete option icon buttons should be displayed`, () => {
             for (let index = 0; index < optionFieldsCount; index++) {
-                steps.verifyOptionsContents(index);
+                steps.verifyOptionsContents(index, questionType);
             };
         });
 
@@ -1658,14 +1716,14 @@ const tests = {
     },
 
     //Need to remove when https://redmine.zeuslearning.com/issues/566720 is resolved
-    verifyAddOptionFunctionality: () => {
+    verifyAddOptionFunctionality: (questionType = null) => {
         it('When user adds an option using \'Add Option\' button then the added option input field should be displayed and option numeration should increment', () => {
             let initialOptionCount;
             matchingPage.steps.getOptionCount().then((count) => {
                 initialOptionCount = count;
                 optionsWrapperComponent.steps.addOption();
                 matchingPage.steps.getOptionCount().should('eq', initialOptionCount + 1);
-                matchingPage.steps.verifyOptionsContents(initialOptionCount);
+                matchingPage.steps.verifyOptionsContents(initialOptionCount, questionType);
             });
         });
     },
@@ -1983,24 +2041,22 @@ const tests = {
             matchingPage.steps.clickAndDropOptionInDropzoneSpecifyCorrectAnswerSection([{ optionText: 'Petals', dropzoneIndex: 0 }]);
         });
 
-        it(`When the user has removed all the options from the dropzone in the ${accordionName} accordion, \'Error: Please set a correct answer.\' error message should be thrown along with an error icon on the \'${accordionName}\' accordion`, () => {
+        it(`When the user has removed all the options from the dropzone in the ${accordionName} accordion,  should not be thrown any error in  \'${accordionName}\' accordion`, () => {
             matchingPage.steps.clickAndDropOptionInOptionsContainerInSpecifyCorrectAnswerSection('Petals');
-            utilities.verifyElementVisibilityState(commonComponents.errorMessage(), 'visible')
-            utilities.verifyInnerText(commonComponents.errorMessage(), 'Error: Please set a correct answer.');
+            commonComponents.steps.verifyErrorMessageIsNotDisplayed();
             if (accordionName == 'Correct') {
                 autoScoredSpecifyCorrectAnswerSection.correctAnswerAccordion()
                     .within(() => {
-                        utilities.verifyElementVisibilityState(autoScoredSpecifyCorrectAnswerSection.specifyCorrectAnswerErrorIcon(), 'visible');
+                        utilities.verifyElementVisibilityState(autoScoredSpecifyCorrectAnswerSection.specifyCorrectAnswerErrorIcon(), 'notExist');
                     });
             } else {
                 autoScoredSpecifyCorrectAnswerSection.alternativeAnswerAccordion()
                     .within(() => {
-                        utilities.verifyElementVisibilityState(autoScoredSpecifyCorrectAnswerSection.specifyCorrectAnswerErrorIcon(), 'visible');
+                        utilities.verifyElementVisibilityState(autoScoredSpecifyCorrectAnswerSection.specifyCorrectAnswerErrorIcon(), 'notExist');
                     });
             };
         });
 
-        autoScoredSpecifyCorrectAnswerSection.tests.verifyAutoScoredCorrectAnswerErrorMessageCSSAndA11y();
 
         it('CSS of the dropzone border', { tags: 'css' }, () => {
             utilities.verifyCSS(matchingPage.dropzoneSpecifyCorrectAnswerSection().eq(0), {