itemengine-cypress-automation 1.0.2

package/cypress/pages/dragAndDropIntoCategoriesPage.js

@@ -0,0 +1,1556 @@
+import { additionalSettingsPanel, autoScoredAdditionalSettings, autoScoredPreviewBase, autoScoredScoringSection, autoScoredScoringSectionMultipleResponsesType, autoScoredSetCorrectAnswerSection, commonComponents, createQuestionBasePage, dragAndDropResponseOptions, dragAndDropSetCorrectAnswerCheckboxComponents, draggableOptionsContainer, optionsWrapperComponent, previewScoringAndShowCorrectAnswerComponent, questionInstructionsComponent, scoringSectionBase, answerNumerationComponent, studentResponseAndLayoutComponent } from "./components";
+const css = Cypress.env('css');
+const answerResponseOptions = ['Bat', 'Eagle', 'Platypus', 'Ostrich', 'Whale', 'Parrot', 'Flying squirrel', 'Peacock', 'Falcon'];
+const correctTabAnswerArray = [['Bat'], ['Eagle', 'Parrot'], ['Platypus', 'Whale'], ['Ostrich']];
+
+const selectors = {
+    ...questionInstructionsComponent,
+    ...commonComponents,
+    ...optionsWrapperComponent,
+    ...dragAndDropSetCorrectAnswerCheckboxComponents,
+    ...autoScoredSetCorrectAnswerSection,
+    ...autoScoredScoringSectionMultipleResponsesType,
+    ...scoringSectionBase,
+    ...dragAndDropResponseOptions,
+    ...additionalSettingsPanel,
+    ...autoScoredAdditionalSettings,
+    ...previewScoringAndShowCorrectAnswerComponent,
+    ...autoScoredPreviewBase,
+    ...createQuestionBasePage,
+    ...draggableOptionsContainer,
+    ...answerNumerationComponent,
+    categoryLabel: () => cy.get('[class*="AddCategoriesAndRowsstyles__Label"]').eq(0),
+    optionNumeration: () => cy.get('[class*="OptionsComponentstyles__IndexWrapper"]'),
+    categoryInputField: () => cy.get('[title*="Enter category"]'),
+    //TODO:need to create separate delete buttons for delete category and delete row icon buttons
+    deleteButton: () => cy.get('.ngie-icon-btn-cls'),
+    addCategoryButton: () => cy.get('.add-option-wrapper-cls button').eq(0),
+    addRowButton: () => cy.get('.add-option-wrapper-cls button').eq(1),
+    rowLabel: () => cy.get('[class*="AddCategoriesAndRowsstyles__Label"]').eq(1),
+    rowInputField: () => cy.get('[title*="Enter row"]'),
+    setCorrectAnswerSectionCategoryTitle: () => cy.get('.column-header-cell'),
+    setCorrectAnswerSectionRowTitle: () => cy.get('.row-header-cell'),
+    setCorrectAnswerSectionCategoryCell: () => cy.get('[class*="DragAndDropMatrixstyles__CellContainer"]'),
+    previewTabCategoryTitle: () => cy.get('.classification-response-preview-wrapper .column-header-cell'),
+    previewTabRowTitle: () => cy.get('.classification-response-preview-wrapper .row-header-cell'),
+    previewTabCategoryCell: () => cy.get('.classification-response-preview-wrapper [class*="DragAndDropMatrixstyles__CellContainer"]'),
+    setCorrectAnswerSectionRowContainer: () => cy.get('.row'),
+    previewTabRowContainer: () => cy.get('.classification-response-preview-wrapper .row'),
+    scoringSubtypeLabel: () => cy.get('#Scoring-Subtype-dropdown-label'),
+    scoringSubtypeDropdown: () => cy.get('#Scoring-Subtype-select'),
+    scoringSubtypeDropdownListOption: (ariaLabel = null) => {
+        if (ariaLabel) {
+            return cy.get(`[aria-labelledby*="Scoring-Subtype-dropdown-label"] [role="option"][aria-label*="${ariaLabel}"]`)
+        } else {
+            return cy.get('[aria-labelledby*="Scoring-Subtype-dropdown-label "] [role="option"]')
+        }
+    },
+    categoryCellNumeration: () => cy.get('[class*="DragAndDropMatrixstyles__CellIndexWrapper"]'),
+    correctAnswerCategoryCell: () => cy.get('[class*="DragAndDropMatrixstyles__AnswerCell"]'),
+    correctAnswerOption: () => cy.get('[class*="DragAndDropMatrixstyles__AnswerWrapper"]'),
+    correctIncorrectAnswerBorder: () => cy.get('.edit-question-preview-wrapper [class*="DragAndDropMatrixstyles__CorrectAnswerBorder"]'),
+    correctIncorrectAnswerLabel: () => cy.get('[class*="AnswerStatusText"]'),
+    correctAnswerContainer: () => cy.get('[class*="CorrectAnswerWrapper"]'),
+    checkCellIcon: () => cy.get('.check-cell-icon'),
+    correctIncorrectCellBorder: () => cy.get('[class*="border-top"][class*="border-right"][class*="border-bottom"][class*="border-left"]'),
+    correctAnswerLabel: () => cy.get('[class*="DragAndDropMatrixstyles__CorrectAnswerLabel"]'),
+    setCorrectAnswerSectionCategoryGrid: () => cy.get('[class*="DragAndDropMatrixstyles__TableWrapper"]'),
+    previewTabCategoryGrid: () => cy.get('.edit-question-preview-wrapper [class*="DragAndDropMatrixstyles__TableWrapper"]'),
+    //Additional settings
+    rowHeadingLabel: () => cy.get('[class*="Classificationstyle__RowResponseWrapper"] .inline-text-property-label').eq(0),
+    rowHeadingInputField: () => cy.get('input[aria-label="Row heading"]'),
+    rowHeadingSetCorrectAnswerSection: () => cy.get('[class*="DragAndDropMatrixstyles__RowTitleCell"]'),
+    rowHeadingPreviewTab: () => cy.get('.edit-question-preview-wrapper [class*="DragAndDropMatrixstyles__RowTitleCell"]'),
+    rowTitleWidthLabel: () => cy.get('label[aria-labelledby="Row title width (px)"]'),
+    rowTitleWidthInputField: () => cy.get('input[aria-label="Row title width (px)"]'),
+    rowMinHeightLabel: () => cy.get('label[aria-labelledby="Row minimum height (px)"]'),
+    rowMinHeightInputField: () => cy.get('input[aria-label="Row minimum height (px)"]'),
+    maxResponsePerCellLabel: () => cy.get('label[aria-labelledby="Maximum responses per cell"]'),
+    maxResponsePerCellInputField: () => cy.get('input[aria-label="Maximum responses per cell"]'),
+    optionsWrapper: () => cy.get('[class*="DragAndDropMatrixstyles__DraggableItemWrapper"]'),
+    responseOptionPlacementLabel: () => cy.get('#Response-option-placement-dropdown-label'),
+    responseOptionPlacementDropdown: () => cy.get('#Response-option-placement-select'),
+    responseOptionPlacementDropdownListOption: (ariaLabel = null) => {
+        if (ariaLabel) {
+            return cy.get(`[aria-labelledby*="Response-option-placement-dropdown-label"] [role="option"][aria-label*="${ariaLabel}"]`);
+        } else {
+            return cy.get('[aria-labelledby*="Response-option-placement-dropdown-label"] [role="option"]');
+        }
+    },
+    questionPreviewWrapper: () => cy.get('.classification-response-preview-wrapper')
+}
+
+const steps = {
+    ...questionInstructionsComponent.steps,
+    ...commonComponents.steps,
+    ...createQuestionBasePage.steps,
+    ...autoScoredSetCorrectAnswerSection.steps,
+    ...autoScoredScoringSection.steps,
+    ...scoringSectionBase.steps,
+    ...autoScoredScoringSectionMultipleResponsesType.steps,
+    ...dragAndDropResponseOptions.steps,
+    ...additionalSettingsPanel.steps,
+    ...autoScoredAdditionalSettings.steps,
+    ...previewScoringAndShowCorrectAnswerComponent.steps,
+    ...autoScoredPreviewBase.steps,
+    ...dragAndDropSetCorrectAnswerCheckboxComponents.steps,
+    ...optionsWrapperComponent.steps,
+    ...draggableOptionsContainer.steps,
+    ...answerNumerationComponent.steps,
+    ...autoScoredAdditionalSettings.steps,
+    //functions related to category
+    /**
+     * @param {number} count is the number of category input fields present
+     * @description verify the count of category input fields present
+     */
+    verifyCountOfCategoryInputFields: (count) => {
+        dragAndDropIntoCategoriesPage.categoryInputField()
+            .should('have.length', count);
+    },
+
+    addCategory: () => {
+        dragAndDropIntoCategoriesPage.addCategoryButton()
+            .click();
+    },
+
+    /**
+     * @param {number} inputFieldIndex indicates the category input field index
+     * @param {string} textContent indicates the text that is entered and verified in the category input field
+     * @description enter text in the category input field
+     */
+    enterTextInCategoryInputField: (inputFieldIndex, textContent) => {
+        dragAndDropIntoCategoriesPage.categoryInputField()
+            .eq(inputFieldIndex)
+            .clear()
+            .type(textContent, { delay: 0 })
+            .blur()
+            .focus()
+            .should('have.text', textContent);
+    },
+
+    /**
+     * @param {number} inputFieldIndex indicates the category input field index
+     * @description clears text in a category input field
+     */
+    clearTextInCategoryInputField: (inputFieldIndex) => {
+        dragAndDropIntoCategoriesPage.categoryInputField()
+            .eq(inputFieldIndex)
+            .focus()
+            .clear()
+            .should('have.text', '')
+            .blur();
+    },
+
+    /**
+     * @param {number} inputFieldIndex indicates the category input field index
+     * @description verify placeholder text of category input field
+     */
+    verifyPlaceholderTextInCategoryInputField: (inputFieldIndex) => {
+        dragAndDropIntoCategoriesPage.categoryInputField()
+            .eq(inputFieldIndex)
+            .should('have.attr', 'data-cke-editorplaceholder', 'Enter category title');
+    },
+
+    /**
+     * @param {number} inputFieldIndex indicates the category input field index
+     * @description verify placeholder text does not exist in a category input field 
+     */
+    verifyPlaceholderTextNotExistInCategoryInputField: (inputFieldIndex) => {
+        dragAndDropIntoCategoriesPage.categoryInputField()
+            .eq(inputFieldIndex)
+            .should('not.have.attr', 'data-cke-editorplaceholder');
+    },
+
+    /**
+     * @param {number} inputFieldIndex indicates the category input field index
+     * @description delete a category input field
+     */
+    deleteCategoryInputField: (inputFieldIndex) => {
+        dragAndDropIntoCategoriesPage.categoryInputField()
+            .eq(inputFieldIndex)
+            .parents('[class*="OptionsComponentstyles__TitleWrapper"]')
+            .find('[aria-label*="Delete category"]')
+            .click();
+    },
+
+    /**
+     * @param {number} inputFieldIndex indicates the category input field index
+     * @description verify the delete category button is visible and enabled
+     */
+    verifyDeleteCategoryButton: (inputFieldIndex) => {
+        dragAndDropIntoCategoriesPage.categoryInputField()
+            .eq(inputFieldIndex)
+            .parents('[class*="OptionsComponentstyles__TitleWrapper"]')
+            .find('[aria-label*="Delete category"]')
+            .should('be.visible')
+            .and('be.enabled');
+    },
+
+    verifyNumerationOfCategoryInputFields: () => {
+        dragAndDropIntoCategoriesPage.categoryInputField()
+            .then(elements => {
+                for (let inputFieldIndex = 0; inputFieldIndex < elements.length; inputFieldIndex++) {
+                    cy.wrap(elements)
+                        .eq(inputFieldIndex)
+                        .parents('[class*="OptionsComponentstyles__TitleWrapper"]')
+                        .find('[class*="OptionsComponentstyles__IndexWrapper"]')
+                        .should('have.text', `${inputFieldIndex + 1}`);
+                };
+            });
+    },
+
+    /**
+     * @param {number} count denotes the number of category titles present
+     * @description verify count of category titles in set correct answer section 
+     */
+    verifyCountOfCategoryTitlesInSetCorrectAnswerSection: (count) => {
+        dragAndDropIntoCategoriesPage.setCorrectAnswerSectionCategoryTitle()
+            .should('have.length', count);
+    },
+
+    /**
+     * @param {number} count denotes the number of categories present
+     * @description verify count of categories in set correct answer section 
+     */
+    verifyCountOfCategoriesInSetCorrectAnswerSection: (count) => {
+        dragAndDropIntoCategoriesPage.setCorrectAnswerSectionCategoryCell()
+            .should('have.length', count);
+    },
+
+    /**
+     * @param {number} categoryIndex denotes the index of the category title
+     * @param {string} title denotes the category title
+     * @description verify category title in set correct answer section
+     */
+    verifyCategoryTitleInSetCorrectAnswerSection: (categoryIndex, title) => {
+        dragAndDropIntoCategoriesPage.setCorrectAnswerSectionCategoryTitle()
+            .eq(categoryIndex)
+            .should('have.text', title)
+            .and('be.visible');
+    },
+
+    /**
+     * @param {number} count denotes the number of categories titles present
+     * @description verify count of category titles in preview tab
+     */
+    verifyCountOfCategoryTitlesInPreviewTab: (count) => {
+        dragAndDropIntoCategoriesPage.previewTabCategoryTitle()
+            .should('have.length', count);
+    },
+
+    /**
+     * @param {number} count denotes the number of categories
+     * @description verify count of categories in preview tab
+     */
+    verifyCountOfCategoriesInPreviewTab: (count) => {
+        dragAndDropIntoCategoriesPage.previewTabCategoryCell()
+            .should('have.length', count);
+    },
+
+    /**
+     * @param {number} categoryIndex denotes the index of the category title
+     * @param {string} title denotes the category title
+     * @description verify category title in preview tab
+     */
+    verifyCategoryTitleInPreviewTab: (categoryIndex, title) => {
+        dragAndDropIntoCategoriesPage.previewTabCategoryTitle()
+            .eq(categoryIndex)
+            .should('have.text', title)
+            .and('be.visible');
+    },
+
+    /**
+     * @param {number} inputFieldIndex denotes the category input field index
+     * @description focus in and out of a category input field
+     */
+    focusInAndFocusOutOfCategoryInputField: (inputFieldIndex) => {
+        dragAndDropIntoCategoriesPage.categoryInputField()
+            .eq(inputFieldIndex)
+            .click()
+            .blur();
+    },
+
+    /**
+     * @param {number} inputFieldIndex denotes the category input field index
+     * @description verify tooltip of Delete category button
+     */
+    verifyDeleteCategoryTooltip: (inputFieldIndex) => {
+        dragAndDropIntoCategoriesPage.categoryInputField()
+            .eq(inputFieldIndex)
+            .parents('[class*="OptionsComponentstyles__TitleWrapper"]')
+            .find('button')
+            .verifyTooltip('Delete category');
+    },
+
+    //functions related to row
+
+    /**
+     * @param {number} count denotes the number of row input fields
+     * @description verify count of number of row input fields present
+     */
+    verifyCountOfRowInputFields: (count) => {
+        dragAndDropIntoCategoriesPage.rowInputField()
+            .should('have.length', count);
+    },
+
+    /**
+     * @param {number} inputFieldIndex is the index of the row input field
+     * @description verify the default state of a row input field
+     */
+    verifyDefaultStateOfRowInputField: (inputFieldIndex) => {
+        dragAndDropIntoCategoriesPage.rowInputField()
+            .eq(inputFieldIndex)
+            .should('have.text', '')
+            .and('have.attr', 'data-cke-editorplaceholder', 'Enter row title')
+            .parents('[class*="OptionsComponentstyles__TitleWrapper"]')
+            .find('[class*="OptionsComponentstyles__IndexWrapper"]')
+            .should('have.text', `${inputFieldIndex + 1}`);
+    },
+
+    verifyNumerationOfRowInputFields: () => {
+        dragAndDropIntoCategoriesPage.rowInputField()
+            .then(elements => {
+                for (let inputFieldIndex = 0; inputFieldIndex < elements.length; inputFieldIndex++) {
+                    cy.wrap(elements)
+                        .eq(inputFieldIndex)
+                        .parents('[class*="OptionsComponentstyles__TitleWrapper"]')
+                        .find('[class*="OptionsComponentstyles__IndexWrapper"]')
+                        .should('have.text', `${inputFieldIndex + 1}`);
+                };
+            });
+    },
+
+    /**
+     * @param {number} inputFieldIndex is the index of the row input field
+     * @description verify if the delete row button is disabled
+     */
+    verifyDisabledDeleteRowButton: (inputFieldIndex) => {
+        dragAndDropIntoCategoriesPage.rowInputField()
+            .eq(inputFieldIndex)
+            .parents('[class*="OptionsComponentstyles__TitleWrapper"]')
+            .find('button')
+            .should('be.visible')
+            .and('be.disabled');
+    },
+
+    /**
+     * @param {number} inputFieldIndex is the index of the row input field
+     * @description verify if the delete row button is enabled
+     */
+    verifyEnabledDeleteRowButton: (inputFieldIndex) => {
+        dragAndDropIntoCategoriesPage.rowInputField()
+            .eq(inputFieldIndex)
+            .parents('[class*="OptionsComponentstyles__TitleWrapper"]')
+            .find('button')
+            .should('be.visible')
+            .and('be.enabled');
+    },
+
+    /**
+     * @param {number} inputFieldIndex is the index of the row input field
+     * @description verify placeholder text in the row input field
+     */
+    verifyPlaceholderTextInRowInputField: (inputFieldIndex) => {
+        dragAndDropIntoCategoriesPage.rowInputField()
+            .eq(inputFieldIndex)
+            .should('have.attr', 'data-cke-editorplaceholder', 'Enter row title');
+    },
+
+    /**
+     * @param {number} inputFieldIndex is the index of the row input field
+     * @description verify placeholder does not exist in the row input field
+     */
+    verifyPlaceholderTextNotExistInRowInputField: (inputFieldIndex) => {
+        dragAndDropIntoCategoriesPage.rowInputField()
+            .eq(inputFieldIndex)
+            .should('not.have.attr', 'data-cke-editorplaceholder');
+    },
+
+    /**
+     * @param {number} inputFieldIndex is the index of the row input field
+     * @param {string} textContent text that is entered in the row input field
+     * @description enter text and verify in the row input field
+     */
+    enterTextInRowInputField: (inputFieldIndex, textContent) => {
+        dragAndDropIntoCategoriesPage.rowInputField()
+            .eq(inputFieldIndex)
+            .clear()
+            .type(textContent, { delay: 0 })
+            .blur()
+            .focus()
+            .should('have.text', textContent);
+    },
+
+    addRow: () => {
+        dragAndDropIntoCategoriesPage.addRowButton()
+            .click();
+    },
+
+    /**
+     * @param {number} inputFieldIndex is the index of the row input field
+     * @description delete a row input field
+     */
+    deleteRowInputField: (inputFieldIndex) => {
+        dragAndDropIntoCategoriesPage.rowInputField()
+            .eq(inputFieldIndex)
+            .parents('[class*="OptionsComponentstyles__TitleWrapper"]')
+            .find('button')
+            .click();
+    },
+
+    /**
+     * @param {number} count denotes the number of rows
+     * @description verify count of rows present in set correct answer section
+     */
+    verifyCountOfRowsInSetCorrectAnswerSection: (count) => {
+        dragAndDropIntoCategoriesPage.setCorrectAnswerSectionRowContainer()
+            .should('have.length', count);
+    },
+
+    /**
+     * @param {number} count denotes the number of ro titles
+     * @description verify count of row titles present in the set correct answer section
+     */
+    verifyCountOfRowTitlesInSetCorrectAnswerSection: (count) => {
+        dragAndDropIntoCategoriesPage.setCorrectAnswerSectionRowTitle()
+            .should('have.length', count)
+    },
+
+    /**
+     * @param {number} count denotes the number of rows present
+     * @description verify count of rows in the preview tab
+     */
+    verifyCountOfRowsInPreviewTab: (count) => {
+        dragAndDropIntoCategoriesPage.previewTabRowContainer()
+            .should('have.length', count);
+    },
+
+    /**
+     * @param {number} count denotes the number of rows titles
+     * @description verify count of row titles  present in the preview tab
+     */
+    verifyCountOfRowTitlesInPreviewTab: (count) => {
+        dragAndDropIntoCategoriesPage.previewTabRowTitle()
+            .should('have.length', count)
+    },
+
+    verifyDisabledRowInputFieldTooltip: () => {
+        dragAndDropIntoCategoriesPage.rowInputField()
+            .parents('[class*="OptionsComponentstyles__TitleWrapper"]')
+            .within(() => {
+                dragAndDropIntoCategoriesPage.deleteButton()
+                    .trigger('mouseover', { force: true });
+            });
+        commonComponents.tooltipText()
+            .verifyInnerText('Minimum one row is required');
+        dragAndDropIntoCategoriesPage.rowInputField()
+            .parents('[class*="OptionsComponentstyles__TitleWrapper"]')
+            .within(() => {
+                dragAndDropIntoCategoriesPage.deleteButton()
+                    .trigger('mouseout', { force: true });
+            });
+        commonComponents.tooltipText()
+            .should('not.exist');
+    },
+
+    /**
+     * @param {number} inputFieldIndex is the index of the row input field
+     * @description focus in and out of a row input field
+     */
+    focusInAndFocusOutOfRowInputField: (inputFieldIndex) => {
+        dragAndDropIntoCategoriesPage.rowInputField()
+            .eq(inputFieldIndex)
+            .click()
+            .blur();
+    },
+
+    /**
+     * @param {number} inputFieldIndex is the index of the row input field
+     * @description verify tooltip of enabled 'Delete row' button
+     */
+    verifyEnabledDeleteRowInputFieldTooltip: (inputFieldIndex) => {
+        dragAndDropIntoCategoriesPage.rowInputField()
+            .eq(inputFieldIndex)
+            .parents('[class*="OptionsComponentstyles__TitleWrapper"]')
+            .within(() => {
+                dragAndDropIntoCategoriesPage.deleteButton()
+                    .trigger('mouseover');
+            });
+        commonComponents.tooltipText()
+            .verifyInnerText('Delete row');
+        dragAndDropIntoCategoriesPage.rowInputField()
+            .eq(inputFieldIndex)
+            .parents('[class*="OptionsComponentstyles__TitleWrapper"]')
+            .within(() => {
+                dragAndDropIntoCategoriesPage.deleteButton()
+                    .trigger('mouseout');
+            });
+        commonComponents.tooltipText()
+            .should('not.exist');
+    },
+
+    /**
+     * @param {number} rowIndex is the index of the row title
+     * @param {string} title is the text of the row title
+     * @description verify row title in set correct answer section
+     */
+    verifyRowTitleInSetCorrectAnswerSection: (rowIndex, title) => {
+        dragAndDropIntoCategoriesPage.setCorrectAnswerSectionRowTitle()
+            .eq(rowIndex)
+            .should('have.text', title)
+            .and('be.visible');
+    },
+
+    /**
+     * @param {number} rowIndex is the index of the row title
+     * @param {string} title is the text of the row title
+     * @description verify row title in preview tab
+     */
+    verifyRowTitleInPreviewTab: (rowIndex, title) => {
+        dragAndDropIntoCategoriesPage.previewTabRowTitle()
+            .eq(rowIndex)
+            .should('have.text', title)
+            .and('be.visible');
+    },
+
+    /**
+     * @param {string} optionName denotes the text content of the draggable option 
+     * @param {number} categoryIndex denotes the category in which draggable option is being dropped
+     * @description click and drop a draggable option into a category in the set correct answer section
+    */
+    clickAndDropDraggableOptionInCategoryCellOfSetCorrectAnswerSection: (optionName, categoryIndex) => {
+        draggableOptionsContainer.setCorrectAnswerDraggableOptionsWrapper('drag and drop into categories')
+            .within(() => {
+                draggableOptionsContainer.draggableOption()
+                    .contains(optionName)
+                    .click();
+            });
+        dragAndDropIntoCategoriesPage.setCorrectAnswerSectionCategoryCell()
+            .eq(categoryIndex)
+            .click({ force: true });
+    },
+
+    /**
+     * @param {string} optionName denotes the text content of the draggable option 
+     * @param {number} categoryIndex denotes the category in which draggable option is being dropped
+     * @description click and drop a draggable option into a category in the preview tab
+    */
+    clickAndDropDraggableOptionInCategoryCellOfPreviewTab: (optionName, categoryIndex) => {
+        draggableOptionsContainer.previewTabDraggableOptionsWrapper('drag and drop into categories')
+            .within(() => {
+                draggableOptionsContainer.draggableOption()
+                    .contains(optionName)
+                    .click();
+            });
+        dragAndDropIntoCategoriesPage.previewTabCategoryCell()
+            .eq(categoryIndex)
+            .click({ force: true });
+    },
+
+    /**
+     * @param {number} categoryIndex index of the category cell in set correct answer section
+     * @param {string[]} responseArray array of options set as correct responses in a category cell
+     */
+    verifyDraggableOptionInCategoryCellOfSetCorrectAnswerSection: (categoryIndex, responseArray) => {
+        dragAndDropIntoCategoriesPage.setCorrectAnswerSectionCategoryCell()
+            .eq(categoryIndex)
+            .within(() => {
+                responseArray.forEach((response, count) => {
+                    draggableOptionsContainer.draggableOption()
+                        .eq(count)
+                        .verifyInnerText(response);
+                });
+            });
+    },
+
+    clickOnScoringSubtypeDropdown: () => {
+        dragAndDropIntoCategoriesPage.scoringSubtypeDropdown()
+            .scrollIntoView()
+            .click();
+    },
+
+    verifyListOptionsOfScoringSubtypeDropdown: () => {
+        dragAndDropIntoCategoriesPage.scoringSubtypeDropdownListOption()
+            .should('be.visible');
+        let dropdownOptions = ['All or nothing', 'Total score divided between each correct response', 'Partial - score for each correct response', 'Total score divided between each cell', 'Partial - score for each cell'];
+        dropdownOptions.forEach((option, count) => {
+            dragAndDropIntoCategoriesPage.scoringSubtypeDropdownListOption()
+                .eq(count)
+                .verifyInnerText(option);
+        });
+        //Note: Clicking on an option to close the dropdown
+        cy.get('body')
+            .click();
+        commonComponents.dropdownList()
+            .should('not.exist');
+    },
+
+    /**
+     * @param {string} optionName option from the scoring subtype dropdown. Should be one of 'All or nothing', 'Total score divided between each correct response', 'Partial - score for each correct response', 'Total score divided between each cell', 'Partial - score for each cell'
+     * @description select an option from the scoring subtype dropdown
+     */
+    selectScoringSubTypeDropdownOption: (optionName) => {
+        dragAndDropIntoCategoriesPage.scoringSubtypeDropdownListOption(optionName)
+            .click();
+    },
+
+    /**
+     * @param {string[]} optionsArray the array of options present in the category container
+     * @param {number} points allocated points present in the points input field
+     * @description verify the correct answer options and points
+     */
+    verifyCorrectAnswerOptionsAndPointsInSetCorrectAnswerSection: (optionsArray, points) => {
+        optionsArray.forEach((responseText, count) => {
+            dragAndDropIntoCategoriesPage.setCorrectAnswerSectionCategoryCell()
+                .eq(count)
+                .verifyInnerText(responseText);
+        });
+        scoringSectionBase.pointsInputField()
+            .should('have.value', points);
+    },
+
+    setQuestion: () => {
+        questionInstructionsComponent.questionInstructionsInputField()
+            .type('Fill the categories with the right answer.', { delay: 0 })
+            .blur();
+        dragAndDropIntoCategoriesPage.steps.enterTextInCategoryInputField(0, 'Mammal');
+        dragAndDropIntoCategoriesPage.steps.enterTextInCategoryInputField(1, 'Not mammal');
+        dragAndDropIntoCategoriesPage.addRowButton()
+            .click()
+        dragAndDropIntoCategoriesPage.steps.enterTextInRowInputField(0, 'Can fly');
+        dragAndDropIntoCategoriesPage.steps.enterTextInRowInputField(1, 'Cannot fly');
+        const numberOfClicks = 7;
+        const addOptionButton = optionsWrapperComponent.addOptionButton();
+        for (let i = 0; i < numberOfClicks; i++) {
+            addOptionButton.click();
+        };
+        dragAndDropResponseOptions.steps.addInputToOptionsForDragAndDropFields(answerResponseOptions);
+    },
+
+    /**
+     * Verifies the numeration of category cells in the question preview.
+     * @param {Array<string>} numerationArray - An array of expected numeration values for category cells.
+     * @returns {void}
+     */
+    verifyNumerationOfCategoryCellsInQuestionPreview: (numerationArray) => {
+        numerationArray.forEach((option, count) => {
+            dragAndDropIntoCategoriesPage.previewTabCategoryCell()
+                .eq(count)
+                .within(() => {
+                    dragAndDropIntoCategoriesPage.categoryCellNumeration()
+                        .should('have.text', option)
+                        .and('be.visible');
+                });
+        });
+    },
+
+    /**
+     * @param {string[][]} correctAnswerArray array of correct answer option of a category
+     * @param {number[]} categoryCellIndexArray numeration of the category cells of the correct answer options
+     * @description verify the correct answer options of a category and numeration of the category cell
+     */
+    verifyCorrectAnswerResponsesInCorrectAnswerSectionAndCount: (correctAnswerArray, categoryCellIndexArray) => {
+        dragAndDropIntoCategoriesPage.steps.verifyCountOfCorrectAnswerCategoryCells(correctAnswerArray.length);
+        correctAnswerArray.forEach((correctAnswer, index) => {
+            dragAndDropIntoCategoriesPage.correctAnswerCategoryCell()
+                .eq(index)
+                .within(() => {
+                    dragAndDropIntoCategoriesPage.categoryCellNumeration()
+                        .should('have.text', categoryCellIndexArray[index]);
+                    correctAnswer.forEach((answerOption, optionIndex) => {
+                        dragAndDropIntoCategoriesPage.correctAnswerOption()
+                            .eq(optionIndex)
+                            .should('have.text', answerOption);
+                    });
+                });
+        });
+    },
+
+    /**
+     * @param {number} categoryCellCount count of correct answer category cells
+     * @description verify the count of correct answer category cells present in the correct answer section
+     */
+    verifyCountOfCorrectAnswerCategoryCells: (categoryCellCount) => {
+        dragAndDropIntoCategoriesPage.correctAnswerCategoryCell()
+            .should('have.length', categoryCellCount)
+    },
+
+    verifyCorrectAttemptBorder: () => {
+        dragAndDropIntoCategoriesPage.correctIncorrectAnswerBorder()
+            .should('have.css', 'border-width', '1px')
+            .and('have.css', 'border-style', 'solid')
+            .and('have.css', 'border-color', `${css.color.correctAnswer}`);
+    },
+
+    verifyIncorrectAttemptBorder: () => {
+        dragAndDropIntoCategoriesPage.correctIncorrectAnswerBorder()
+            .should('have.css', 'border-width', '1px')
+            .and('have.css', 'border-style', 'solid')
+            .and('have.css', 'border-color', `${css.color.incorrectAnswer}`);
+    },
+
+    verifyCorrectIncorrectBorderNotVisible: () => {
+        dragAndDropIntoCategoriesPage.correctIncorrectAnswerBorder()
+            .should('have.css', 'border-style', 'none');
+    },
+
+    /**
+     * @param {number} optionIndex index of the response option in category cell
+     * @description verify the incorrect cross-mark icon against the incorrect response
+     */
+    verifyIncorrectOptionCrossmarkIcon: (optionIndex) => {
+        dragAndDropIntoCategoriesPage.previewTabCategoryGrid()
+            .within(() => {
+                dragAndDropIntoCategoriesPage.optionsWrapper()
+                    .eq(optionIndex)
+                    .find('.tick-icon-wrapper')
+                    .should('have.class', 'icon-incorrect')
+                    .and('be.visible');
+            })
+    },
+
+    /**
+     * @param {number} optionIndex index of the response option in category cell
+     * @description verify the correct cross-mark icon against the correct response
+     */
+    verifyCorrectOptionCheckmarkIcon: (optionIndex) => {
+        dragAndDropIntoCategoriesPage.previewTabCategoryGrid()
+            .within(() => {
+                dragAndDropIntoCategoriesPage.optionsWrapper()
+                    .eq(optionIndex)
+                    .find('.tick-icon-wrapper')
+                    .should('have.class', 'icon-correct')
+                    .and('be.visible');
+            })
+    },
+
+    /**
+     * @param {string} labelText correct/incorrect label
+     * @description verify the correct/incorrect label
+     */
+    verifyCorrectIncorrectAnswerLabel: (labelText) => {
+        let labelIconText = labelText.toLowerCase();
+        dragAndDropIntoCategoriesPage.correctIncorrectAnswerLabel()
+            .should('be.visible')
+            .verifyInnerText(`${labelText} answer`)
+            .parents('[class*="AnswerStatusWrapper"]')
+            .find('[class*="AnswerStatusIcon"]')
+            .should('be.visible')
+            .should('have.class', `icon-${labelIconText}`);
+    },
+
+    verifyCorrectAnswerSectionNotVisible: () => {
+        dragAndDropIntoCategoriesPage.correctAnswerContainer()
+            .should('not.visible');
+    },
+
+    verifyQuestionPreviewStateWhenShowCorrectAnswerIsUnchecked: () => {
+        cy.log('After deselecting Show correct answer checkbox, the question preview should return to the previous state');
+        previewScoringAndShowCorrectAnswerComponent.showCorrectAnswerCheckbox()
+            .click()
+            .should('not.be.checked');
+        autoScoredPreviewBase.correctIcon()
+            .should('not.exist');
+        autoScoredPreviewBase.incorrectIcon()
+            .should('not.exist');
+        dragAndDropIntoCategoriesPage.correctIncorrectAnswerLabel()
+            .should('not.exist');
+        dragAndDropIntoCategoriesPage.steps.verifyCorrectIncorrectBorderNotVisible();
+    },
+
+    resetQuestionPreview: () => {
+        cy.log('Switching to edit tab and back to preview tab to reset the question preview')
+        dragAndDropIntoCategoriesPage.steps.switchToEditTab();
+        dragAndDropIntoCategoriesPage.steps.switchToPreviewTab();
+    },
+
+    verifyCorrectAnswersLabel: () => {
+        dragAndDropIntoCategoriesPage.correctAnswerContainer()
+            .should('contain', 'Correct answers:')
+            .and('be.visible');
+    },
+
+    verifyCorrectIncorrectCellBorderNotExists: () => {
+        dragAndDropIntoCategoriesPage.correctIncorrectCellBorder()
+            .should('not.exist');
+        dragAndDropIntoCategoriesPage.checkCellIcon()
+            .should('not.exist');
+    },
+
+    /**
+     * @param {string} optionName denotes the text content of the draggable option 
+     * @description click and drop a draggable option into the response container in the set correct answer section
+    */
+    clickAndDropDraggableOptionInResponseContainerOfSetCorrectAnswerSection: (optionName) => {
+        draggableOptionsContainer.draggableOption()
+            .contains(optionName)
+            .click();
+        draggableOptionsContainer.setCorrectAnswerDraggableOptionsWrapper('drag and drop into categories')
+            .find('[class*="DragAndDropMatrixstyles__DroppableWrapper"]')
+            .click({ force: true });
+    },
+
+    /**
+     * @param {string} optionName denotes the text content of the draggable option 
+     * @description click and drop a draggable option into the grouped response container in the set correct answer section
+    */
+    clickAndDropDraggableOptionInResponseContainerOfPreviewTab: (optionName) => {
+        dragAndDropIntoCategoriesPage.previewTabCategoryGrid()
+            .within(() => {
+                draggableOptionsContainer.draggableOption()
+                    .contains(optionName)
+                    .click();
+            });
+        draggableOptionsContainer.previewTabDraggableOptionsWrapper('drag and drop into categories')
+            .find('[class*="DragAndDropMatrixstyles__DroppableWrapper"]')
+            .click({ force: true });
+    },
+
+    /**
+     * @param {string} optionName denotes the text content of the draggable option 
+     * @description click and drop a draggable option into the grouped response container in the set correct answer section
+    */
+    clickAndDropDraggableOptionInGroupedResponseContainerOfSetCorrectAnswerSection: (optionName) => {
+        dragAndDropIntoCategoriesPage.setCorrectAnswerSectionCategoryGrid()
+            .within(() => {
+                draggableOptionsContainer.draggableOption()
+                    .contains(optionName)
+                    .click();
+            });
+        draggableOptionsContainer.setCorrectAnswerDraggableOptionsWrapper('drag and drop into categories')
+            .find('.item-list')
+            .eq(0)
+            .click({ force: true });
+    },
+
+    /**
+     * @param {string} optionName denotes the text content of the draggable option 
+     * @description click and drop a draggable option into the grouped response container in the set correct answer section
+    */
+    clickAndDropDraggableOptionInGroupedResponseContainerOfPreviewTab: (optionName) => {
+        dragAndDropIntoCategoriesPage.previewTabCategoryGrid()
+            .within(() => {
+                draggableOptionsContainer.draggableOption()
+                    .contains(optionName)
+                    .click();
+            });
+        draggableOptionsContainer.previewTabDraggableOptionsWrapper('drag and drop into categories')
+            .find('.item-list')
+            .eq(0)
+            .click({ force: true });
+    },
+
+    verifyCorrectCellCheckmarkIcon: (categoryCellIndexArray) => {
+        categoryCellIndexArray.forEach((cellIndex) => {
+            dragAndDropIntoCategoriesPage.correctIncorrectCellBorder()
+                .eq(cellIndex)
+                .within(() => {
+                    dragAndDropIntoCategoriesPage.checkCellIcon()
+                        .should('have.class', 'icon-correct')
+                        .and('be.visible');
+                });
+        });
+    },
+
+    verifyIncorrectCellCrossmarkIcon: (categoryCellIndexArray) => {
+        categoryCellIndexArray.forEach((cellIndex) => {
+            dragAndDropIntoCategoriesPage.correctIncorrectCellBorder()
+                .eq(cellIndex)
+                .within(() => {
+                    dragAndDropIntoCategoriesPage.checkCellIcon()
+                        .should('have.class', 'icon-incorrect')
+                        .and('be.visible');
+                });
+        });
+    },
+
+    verifyOptionsErrorMessageIsDisplayed: (index) => {
+        optionsWrapperComponent.optionsSectionWrapper()
+            .within(() => {
+                optionsWrapperComponent.optionWrapper()
+                    .eq(index)
+                    .within(() => {
+                        commonComponents.errorMessage()
+                            .should('have.text', 'Error: Option is required.');
+                    });
+            });
+    },
+
+    verifyOptionsErrorMessageIsNotDisplayed: (index) => {
+        optionsWrapperComponent.optionsSectionWrapper()
+            .within(() => {
+                optionsWrapperComponent.optionWrapper()
+                    .eq(index)
+                    .within(() => {
+                        commonComponents.errorMessage()
+                            .should('not.exist');
+                    });
+            });
+    },
+
+    setCorrectTabAnswerOptions: () => {
+        dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfSetCorrectAnswerSection('Bat', 0);
+        dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfSetCorrectAnswerSection('Eagle', 1);
+        dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfSetCorrectAnswerSection('Parrot', 1);
+        dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfSetCorrectAnswerSection('Platypus', 2);
+        dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfSetCorrectAnswerSection('Whale', 2);
+        dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfSetCorrectAnswerSection('Ostrich', 3);
+    },
+
+    verifyEmptyStateOfCategoryCellInSetCorrectAnswerSection: (cellIndex) => {
+        dragAndDropIntoCategoriesPage.setCorrectAnswerSectionCategoryCell()
+            .eq(cellIndex)
+            .should('have.text', '');
+    },
+
+    verifyEmptyStateOfCategoryCellInPreviewTab: (cellIndex) => {
+        dragAndDropIntoCategoriesPage.previewTabCategoryCell()
+            .eq(cellIndex)
+            .should('have.text', '');
+    },
+
+    /**
+     * @param {number} categoryIndex index of the category cell in preview tab
+     * @param {string[]} responseArray array of options set as correct responses in a category cell
+     */
+    verifyDraggableOptionInCategoryCellOfPreviewTab: (categoryIndex, responseArray) => {
+        dragAndDropIntoCategoriesPage.previewTabCategoryCell()
+            .eq(categoryIndex)
+            .within(() => {
+                responseArray.forEach((response, count) => {
+                    draggableOptionsContainer.draggableOption()
+                        .eq(count)
+                        .verifyInnerText(response);
+                });
+            });
+    },
+
+    setQuestionForGroupedResponseOptions: () => {
+        let animals = [['Bat', 'Platypus', 'Panda', 'Zebra'],
+        ['Peacock', 'Falcon', 'Eagle', 'Tiger'],
+        ['Parrot', 'Lion', 'Whale', 'Elephant'],
+        ['Giraffe', 'Kangaroo', 'Ostrich', 'Flying squirrel']
+        ];
+        let groupTitles = ['Group A', 'Group B', 'Group C', 'Group D'];
+        questionInstructionsComponent.questionInstructionsInputField()
+            .type('Fill the categories with the right answer.', { delay: 0 })
+            .blur();
+        dragAndDropIntoCategoriesPage.steps.enterTextInCategoryInputField(0, 'Mammal');
+        dragAndDropIntoCategoriesPage.steps.enterTextInCategoryInputField(1, 'Not mammal');
+        dragAndDropIntoCategoriesPage.addRowButton()
+            .click()
+        dragAndDropIntoCategoriesPage.steps.enterTextInRowInputField(0, 'Can fly');
+        dragAndDropIntoCategoriesPage.steps.enterTextInRowInputField(1, 'Cannot fly');
+        dragAndDropResponseOptions.steps.selectResponseOptionsLayout('Grouped')
+        dragAndDropResponseOptions.steps.addGroupTitle(0, groupTitles[0]);
+        optionsWrapperComponent.addOptionButton()
+            .click();
+        optionsWrapperComponent.addOptionButton()
+            .click();
+        dragAndDropResponseOptions.steps.addInputToOptionsForGroupedResponseLayout(0, animals[0]);
+        dragAndDropResponseOptions.steps.addGroupWithTitleAndOptionsInResponseOptionsSection(1, groupTitles[1], animals[1]);
+        dragAndDropResponseOptions.steps.addGroupWithTitleAndOptionsInResponseOptionsSection(2, groupTitles[2], animals[2]);
+        dragAndDropResponseOptions.steps.addGroupWithTitleAndOptionsInResponseOptionsSection(3, groupTitles[3], animals[3]);
+    },
+
+    verifyInactiveStateOfAllCategoryCellsInSetCorrectAnswerSection: () => {
+        dragAndDropIntoCategoriesPage.setCorrectAnswerSectionCategoryGrid()
+            .should('not.have.class', 'active-area-on-tap');
+    },
+
+    verifyActiveStateOfAllCategoryCellsInSetCorrectAnswerSection: () => {
+        dragAndDropIntoCategoriesPage.setCorrectAnswerSectionCategoryGrid()
+            .should('have.class', 'active-area-on-tap');
+    },
+
+    verifyInactiveStateOfAllCategoryCellsInPreviewTab: () => {
+        dragAndDropIntoCategoriesPage.previewTabCategoryGrid()
+            .should('not.have.class', 'active-area-on-tap');
+    },
+
+    verifyActiveStateOfAllCategoryCellsInPreviewTab: () => {
+        dragAndDropIntoCategoriesPage.previewTabCategoryGrid()
+            .should('have.class', 'active-area-on-tap');
+    },
+
+    /**
+     * @param {number} responseAreaIndex Index of the stem response area in set correct answer section
+     * @description Verify drag handle is not visible in filled category cell in set correct answer section
+     */
+    verifyDragHandleNotVisibleInFilledCategoryCellOfSetCorrectAnswerSection: (responseAreaIndex) => {
+        dragAndDropIntoCategoriesPage.setCorrectAnswerSectionCategoryCell()
+            .eq(responseAreaIndex)
+            .within(() => {
+                draggableOptionsContainer.draggableOptionDragIcon()
+                    .should('not.be.visible');
+            });
+    },
+
+    /**
+     * @param {number} responseAreaIndex Index of the stem response area in set correct answer section
+     * @description Verify drag handle is not visible in filled category cell in preview tab
+     */
+    verifyDragHandleNotVisibleInFilledCategoryCellOfPreviewTab: (responseAreaIndex) => {
+        dragAndDropIntoCategoriesPage.previewTabCategoryCell()
+            .eq(responseAreaIndex)
+            .within(() => {
+                draggableOptionsContainer.draggableOptionDragIcon()
+                    .should('not.be.visible');
+            });
+    },
+
+    /**
+     * @param {string} optionName denotes the text content of the draggable option 
+     * @description click on a draggable option present in the category cell of set correct answer section
+    */
+    clickOnDraggableOptionInCategoryCellOfSetCorrectAnswerSection: (optionName) => {
+        dragAndDropIntoCategoriesPage.setCorrectAnswerSectionCategoryGrid()
+            .within(() => {
+                draggableOptionsContainer.draggableOption()
+                    .contains(optionName)
+                    .click();
+            });
+    },
+
+    verifyPleaseSetACorrectAnswerErrorMessage: () => {
+        commonComponents.errorMessage()
+            .verifyInnerText('Error: Please set a correct answer.')
+            .should('be.visible');
+    },
+
+    clickOnCategoryCellInCategoryCellOfSetCorrectAnswerSection: (categoryIndex) => {
+        dragAndDropIntoCategoriesPage.setCorrectAnswerSectionCategoryCell()
+            .eq(categoryIndex)
+            .click({ force: true });
+    },
+
+    clickOnCategoryCellInCategoryCellOfPreviewTab: (categoryIndex) => {
+        dragAndDropIntoCategoriesPage.previewTabCategoryCell()
+            .eq(categoryIndex)
+            .click({ force: true });
+    },
+
+    /**
+     * @param {string} optionName denotes the text content of the draggable option 
+     * @description click on a draggable option present in the category cell of preview tab
+    */
+    clickOnDraggableOptionInCategoryCellOfPreviewTab: (optionName) => {
+        dragAndDropIntoCategoriesPage.previewTabCategoryGrid()
+            .within(() => {
+                draggableOptionsContainer.draggableOption()
+                    .contains(optionName)
+                    .click();
+            });
+    },
+
+    /**
+     * Verifies the numeration of correct answer container category cells.
+     * @param {Array<string>} categoryCellIndexArray - An array of expected numeration values for category cells.
+     * @returns {void}
+     */
+    verifyCorrectAnswerContainerNumeration: (categoryCellIndexArray) => {
+        categoryCellIndexArray.forEach((categoryCellNumeration, index) => {
+            dragAndDropIntoCategoriesPage.correctAnswerCategoryCell()
+                .eq(index)
+                .within(() => {
+                    dragAndDropIntoCategoriesPage.categoryCellNumeration()
+                        .should('have.text', `${categoryCellNumeration}`);
+                });
+        });
+    },
+
+    /**
+     * Enters text into the row title width input field.
+     * @param {string} text - The text to be entered into the row input field.
+     * @returns {void}
+     */
+    enterTextInRowTitleWidthInputField: (text) => {
+        dragAndDropIntoCategoriesPage.rowTitleWidthInputField()
+            .type(text, { delay: 0 })
+            .blur();
+    },
+
+    clearTextInRowTitleWidthInputField: () => {
+        dragAndDropIntoCategoriesPage.rowTitleWidthInputField()
+            .clear();
+    },
+
+    /**
+     * Verifies the value of the row title width input field.
+     * @param {string} width - The expected width value to compare against.
+     * @returns {void}
+     */
+    verifyRowTitleWidthInputFieldValue: (width) => {
+        dragAndDropIntoCategoriesPage.rowTitleWidthInputField()
+            .should('have.attr', 'value', width)
+    },
+
+    /**
+     * Enters text into the row minimum height input field.
+     * @param {string} text - The text to be entered into the row minimum height input field.
+     * @returns {void}
+     */
+    enterTextInRowMinHeightInputField: (text) => {
+        dragAndDropIntoCategoriesPage.rowMinHeightInputField()
+            .type(text, { delay: 0 })
+            .blur();
+    },
+
+    clearTextInRowMinHeightInputField: () => {
+        dragAndDropIntoCategoriesPage.rowMinHeightInputField()
+            .clear();
+    },
+
+    /**
+     * Verifies the value of the row minimum height input field.
+     * @param {string} value - The expected row minimum height value to compare against.
+     * @returns {void}
+     */
+    verifyRowMinHeightInputFieldValue: (value) => {
+        dragAndDropIntoCategoriesPage.rowMinHeightInputField()
+            .should('have.attr', 'value', value)
+    },
+
+    /**
+     * Enters text into the row heading input field.
+     * @param {string} text - The text to be entered into the row heading input field.
+     * @returns {void}
+     */
+    enterTextInRowHeadingInputField: (text) => {
+        dragAndDropIntoCategoriesPage.rowHeadingInputField()
+            .type(text, { delay: 0 })
+            .blur();
+    },
+
+    clearTextInRowHeadingInputField: () => {
+        dragAndDropIntoCategoriesPage.rowHeadingInputField()
+            .clear();
+    },
+
+    /**
+     * Verifies the value of the row heading input field.
+     * @param {string} value - The expected row heading value to compare against.
+     * @returns {void}
+     */
+    verifyRowHeadingInputFieldValue: (value) => {
+        dragAndDropIntoCategoriesPage.rowHeadingInputField()
+            .should('have.attr', 'value', value)
+    },
+
+    /**
+     * Verifies the width of the row title in the 'Set correct answer' section.
+     * @param {number} expectedWidth - The expected width value to compare against.
+     * @returns {void}
+     */
+    verifyRowTitleWidthSetCorrectAnswerSection: (expectedWidth) => {
+        dragAndDropIntoCategoriesPage.setCorrectAnswerSectionRowTitle()
+            .parents('[class*="RowHeaderCellContainer"]')
+            .should(($element) => {
+                const width = $element.width();
+                expect(width).to.be.equal(expectedWidth);
+            });
+    },
+
+    /**
+     * Verifies the width of the row title in the 'Preview tab'.
+     * @param {number} expectedWidth - The expected width value to compare against.
+     * @returns {void}
+     */
+    verifyRowTitleWidthPreviewTab: (expectedWidth) => {
+        dragAndDropIntoCategoriesPage.previewTabRowTitle()
+            .parents('[class*="RowHeaderCellContainer"]')
+            .should(($element) => {
+                const width = $element.width();
+                expect(width).to.be.equal(expectedWidth);
+            });
+    },
+
+    /**
+     * Verifies the minimum height of a row in the 'Set correct answer' section.
+     * @param {number} expectedMinHeight - The expected minimum height value to compare against.
+     * @returns {void}
+     */
+    verifyRowMinHeightSetCorrectAnswerSection: (expectedMinHeight) => {
+        dragAndDropIntoCategoriesPage.setCorrectAnswerSectionCategoryCell()
+            .parents('[class*="RowContainer"]')
+            .should(($element) => {
+                const minHeight = parseFloat($element.css('min-height'));
+                expect(minHeight).to.be.equal(expectedMinHeight);
+            });
+    },
+
+    /**
+     * Verifies the minimum height of a row in the 'Preview tab'.
+     * @param {number} expectedMinHeight - The expected minimum height value to compare against.
+     * @returns {void}
+     */
+    verifyRowMinHeightPreviewTab: (expectedMinHeight) => {
+        dragAndDropIntoCategoriesPage.previewTabCategoryCell()
+            .parents('[class*="RowContainer"]')
+            .should(($element) => {
+                const minHeight = parseFloat($element.css('min-height'));
+                expect(minHeight).to.be.equal(expectedMinHeight);
+            });
+    },
+
+    /**
+     * Sets the maximum response value per cell in max response per cell input field
+     * @param {string} value - The value to set as the maximum response per cell.
+     * @returns {void}
+     */
+    setMaxResponsePerCell: (value) => {
+        dragAndDropIntoCategoriesPage.maxResponsePerCellInputField()
+            .type(value, { delay: 0 })
+            .blur();
+    },
+
+    clearMaxResponsePerCellInputField: () => {
+        dragAndDropIntoCategoriesPage.maxResponsePerCellInputField()
+            .clear();
+    },
+
+    /**
+     * Verifies the value of the maximum response per cell input field.
+     * @param {string} value - The expected value to compare against.
+     * @returns {void}
+     */
+    verifyMaxResponsePerCellInputFieldValue: (value) => {
+        dragAndDropIntoCategoriesPage.maxResponsePerCellInputField()
+            .should('have.attr', 'value', value)
+    },
+
+    clickOnResponseOptionPlacementDropdown: () => {
+        dragAndDropIntoCategoriesPage.responseOptionPlacementDropdown()
+            .click();
+    },
+
+    /**
+     * Selects an option from the response option placement dropdown list.
+     * @param {string} dropdownOption - The option to select from the dropdown list ('Bottom', 'Top', 'Left', or 'Right')..
+     * @returns {void}
+     */
+    selectResponseOptionPlacementDropdownOption: (dropdownOption) => {
+        dragAndDropIntoCategoriesPage.responseOptionPlacementDropdownListOption(dropdownOption)
+            .click();
+    },
+
+    verifyResponseOptionPlacementDropdownOptions: () => {
+        let dropdownOptions = ['Top', 'Bottom', 'Left', 'Right'];
+        dragAndDropIntoCategoriesPage.responseOptionPlacementDropdownListOption()
+            .each(($el, index) => {
+                cy.wrap($el)
+                    .should('have.text', dropdownOptions[index]);
+            });
+    },
+
+    /**
+     * Verifies the placement option of a response option in the preview tab.
+     * @param {string} placementOption - The placement option to verify ('Bottom', 'Top', 'Left', or 'Right').
+     * @throws {Error} Throws an error if an invalid placement option is provided.
+     */
+    verifyResponseOptionPlacementPreviewTab: (placementOption) => {
+        const questionPreviewWrapper = dragAndDropIntoCategoriesPage.questionPreviewWrapper();
+        switch (placementOption) {
+            case 'Bottom':
+                questionPreviewWrapper
+                    .should('not.have.class', 'classification-preview-top')
+                    .and('not.have.class', 'classification-preview-left')
+                    .and('not.have.class', 'classification-preview-right');
+                break;
+            case 'Top':
+                questionPreviewWrapper
+                    .should('have.class', 'classification-preview-top');
+                break;
+            case 'Left':
+                questionPreviewWrapper
+                    .should('have.class', 'classification-preview-left');
+                break;
+            case 'Right':
+                questionPreviewWrapper
+                    .should('have.class', 'classification-preview-right');
+                break;
+            default:
+                throw new Error('Invalid placement option');
+        }
+    }
+}
+
+const tests = {
+    ...questionInstructionsComponent.tests,
+    ...dragAndDropResponseOptions.tests,
+    ...autoScoredSetCorrectAnswerSection.tests,
+    ...dragAndDropSetCorrectAnswerCheckboxComponents.tests,
+    ...autoScoredScoringSection.tests,
+    ...scoringSectionBase.tests,
+    ...dragAndDropResponseOptions.tests,
+    ...additionalSettingsPanel.tests,
+    ...autoScoredAdditionalSettings.tests,
+    ...autoScoredScoringSectionMultipleResponsesType.tests,
+    ...previewScoringAndShowCorrectAnswerComponent.tests,
+    ...createQuestionBasePage.tests,
+    ...commonComponents.tests,
+    ...draggableOptionsContainer.tests,
+    ...answerNumerationComponent.tests,
+    ...studentResponseAndLayoutComponent.tests,
+    ...autoScoredAdditionalSettings.tests,
+    /**
+     * @param {string} scoringSubtype option from the scoring subtype dropdown. Should be one of 'Total score divided between each correct response', 'Total score divided between each cell'
+     * @description verify the contents of the selected scoring subtype that have round down score feature
+     */
+    verifyScoringSubtypeWithRoundDownScoreContents: (scoringSubtype) => {
+        it(`When the user selects \'${scoringSubtype}\' option from the scoring subtype dropdown, penalty points label and input field, minimum score awarded (if attempted) label and input field and round down score label with checkbox in checked state should be displayed`, () => {
+            dragAndDropIntoCategoriesPage.steps.clickOnScoringSubtypeDropdown();
+            dragAndDropIntoCategoriesPage.steps.selectScoringSubTypeDropdownOption(scoringSubtype);
+            autoScoredScoringSectionMultipleResponsesType.steps.verifyDefaultPenaltyPointsInputFieldAndLabel();
+            scoringSectionBase.steps.verifyDefaultMinimumScoreIfAttemptedLabelAndPointsField();
+            autoScoredScoringSectionMultipleResponsesType.steps.verifyDefaultRoundDownScoreCheckboxCheckedAndLabel();
+        });
+    },
+
+    /**
+     * @param {string} optionName option from the scoring subtype dropdown. Should be one of 'Partial - score for each correct response', 'Partial - score for each cell'
+     * @description verify the contents of the selected scoring subtype that do not have round down score feature
+     */
+    verifyScoringSubtypeWithoutRoundDownScoreContents: (scoringSubtype) => {
+        it(`When the user selects \'${scoringSubtype}\' option from the scoring subtype dropdown, penalty points label and input field, minimum score awarded (if attempted) label and input field should be displayed`, () => {
+            dragAndDropIntoCategoriesPage.steps.clickOnScoringSubtypeDropdown();
+            dragAndDropIntoCategoriesPage.steps.selectScoringSubTypeDropdownOption(scoringSubtype);
+            autoScoredScoringSectionMultipleResponsesType.steps.verifyDefaultPenaltyPointsInputFieldAndLabel();
+            scoringSectionBase.steps.verifyDefaultMinimumScoreIfAttemptedLabelAndPointsField();
+            autoScoredScoringSectionMultipleResponsesType.rounddownScoreCheckboxLabel()
+                .should('not.exist');
+            autoScoredScoringSectionMultipleResponsesType.rounddownScoreCheckbox()
+                .should('not.exist');
+        });
+    },
+
+    /**
+     * @param {number} allocatedPoints points allocated to the question
+     * @description verify the contents of the question preview on selecting the show correct answer checkbox without attempting the question
+     */
+    verifyQuestionPreviewOnSelectingShowCorrectAnswerWithoutAttempting: (allocatedPoints) => {
+        it('When the user selects \'Show correct answer\' checkbox without attempting the question, numeration should appear in each category cell, correct/incorrect cell border or icons should not be displayed, a correct answer section with \'Correct answers:\' label and all correct answers should be displayed below the question preview', () => {
+            dragAndDropIntoCategoriesPage.steps.checkShowCorrectAnswerCheckbox();
+            dragAndDropIntoCategoriesPage.steps.verifyNumerationOfCategoryCellsInQuestionPreview([1, 2, 3, 4]);
+            dragAndDropIntoCategoriesPage.steps.verifyCorrectIncorrectBorderNotVisible();
+            dragAndDropIntoCategoriesPage.steps.verifyCorrectIncorrectCellBorderNotExists();
+            dragAndDropIntoCategoriesPage.steps.verifyCorrectAnswersLabel();
+            dragAndDropIntoCategoriesPage.steps.verifyCorrectAnswerResponsesInCorrectAnswerSectionAndCount(correctTabAnswerArray, [1, 2, 3, 4]);
+            dragAndDropIntoCategoriesPage.previewScoreText()
+                .verifyInnerText(`0/${allocatedPoints}`);
+        });
+    },
+
+    verifyQuestionPreviewOnClickingCheckAnswerWithoutAttempting: () => {
+        it('When user selects Check answer button without attempting the question, correct/incorrect border and icon for cell should not be displayed, correct/incorrect answer border for the question and label should not be displayed below the question preview and no correct answer section should not be displayed', () => {
+            cy.log('Pre-step: Deselect the show correct checkbox')
+            dragAndDropIntoCategoriesPage.steps.uncheckShowCorrectAnswerCheckbox();
+            dragAndDropIntoCategoriesPage.steps.checkAnswer();
+            dragAndDropIntoCategoriesPage.correctIncorrectAnswerLabel()
+                .should('not.exist');
+            dragAndDropIntoCategoriesPage.steps.verifyCorrectIncorrectBorderNotVisible();
+            dragAndDropIntoCategoriesPage.steps.verifyCorrectAnswerSectionNotVisible();
+        });
+    },
+
+    /**
+     * @param {number} totalPoints the maximum points that can be scored by the user
+     * @description verify the functionality of minimum points when penalty points are not set and user attempts incorrect answer
+     */
+    verifyMinimumScoreAwardedIfAttemptedFunctionalityForIncorrectAnswer: (totalPoints) => {
+        it('When user has provided minimum score awarded (if attempted) points, then in Preview tab on entering incorrect answer, minimum score should be provided for the question', () => {
+            cy.log('Switch to edit tab and set minimum score if attempted points')
+            createQuestionBasePage.steps.switchToEditTab();
+            scoringSectionBase.steps.allotMinimumScoreAwardedIfAttempted(1)
+            createQuestionBasePage.steps.switchToPreviewTab()
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Bat', 2);
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Eagle', 3);
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Platypus', 1);
+            previewScoringAndShowCorrectAnswerComponent.previewScoreText()
+                .verifyInnerText(`1/${totalPoints}`);
+        });
+
+        it('When user removes minimum score awarded (if attempted) points, then in Preview tab on selecting any options other than correct answers, points should not be provided', () => {
+            cy.log('Switch to edit tab and remove minimum score if attempted points')
+            createQuestionBasePage.steps.switchToEditTab();
+            dragAndDropIntoCategoriesPage.steps.clearMinimumScoreIfAttemptedPointsField();
+            createQuestionBasePage.steps.switchToPreviewTab()
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Bat', 2);
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Eagle', 3);
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Platypus', 1);
+            previewScoringAndShowCorrectAnswerComponent.previewScoreText()
+                .verifyInnerText(`0/${totalPoints}`);
+        });
+    },
+
+    /**
+     * @param {number} scoredPoints the points scored by the user
+     * @param {number} totalPoints the maximum points that can be scored by the user
+     * @description verify the functionality of Penalty points when minimum points are not set and user attempts incorrect answer
+     */
+    verifyPenaltyPointsFunctionalityForIncorrectAnswer: (scoredPoints, totalPoints) => {
+        it('When user has defined penalty points', () => {
+            cy.log('Pre-step: Switch to edit tab and set penalty points');
+            createQuestionBasePage.steps.switchToEditTab();
+            autoScoredScoringSectionMultipleResponsesType.steps.allotPenaltyPoints(3)
+
+            cy.log('After switching to preview tab, when user adds an incorrect answer input, then 0 points should be awarded(no negative points)');
+            createQuestionBasePage.steps.switchToPreviewTab();
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Bat', 2);
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Eagle', 3);
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Platypus', 1);
+            previewScoringAndShowCorrectAnswerComponent.previewScoreText()
+                .verifyInnerText(`0/${totalPoints}`);
+
+            cy.log('When user adds a partially correct answer input, the points should be updated accordingly with deducted penalty points');
+            dragAndDropIntoCategoriesPage.steps.resetQuestionPreview();
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Bat', 0);
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Eagle', 1);
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Parrot', 1);
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Platypus', 2);
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Flying squirrel', 2);
+            previewScoringAndShowCorrectAnswerComponent.previewScoreText()
+                .verifyInnerText(`${scoredPoints}/${totalPoints}`);
+        });
+    },
+
+    /**
+     * @param {number[]} pointsScoredArray An array of numbers representing points scored in different cases.
+     *   - The first element represents points scored for incorrect answers.
+     *   - The second element represents points scored for partially correct answers.
+     *   - The third element represents points scored when minimum score awarded (if attempted) points is greater than the points achieved by attempting the question partially correct
+     * @param {number} minimumPointsForPartialCorrectAnswers minimum score awarded (if attempted) points on attempting the question partially correct
+     * @param {number} totalPoints the maximum points that can be achieved by the user
+     * @description verify the functionality of Minimum score awarded (if attempted) and penalty points are set and user attempts the question for the following cases.
+     * - For all incorrect responses
+     * - For partially correct responses, when points scored > minimum score awarded(if attempted) points
+     * - For partially correct responses, when minimum score awarded(if attempted) points > points scored
+     */
+    verifyMinimumScoreIfAttemptedAndPenaltyPointsFunctionalityForIncorrectAnswer: (pointsScoredArray, minimumPointsForPartialCorrectAnswers, totalPoints) => {
+        it('When user has defined both penalty points and minimum score awarded (if attempted) points', () => {
+            cy.log('Pre-step: Switch to edit tab and set minimum score awarded (if attempted) points');
+            createQuestionBasePage.steps.switchToEditTab();
+            scoringSectionBase.steps.allotMinimumScoreAwardedIfAttempted(1);
+
+            cy.log('Switch to preview tab and give incorrect answer input to check that minimum points are displayed');
+            createQuestionBasePage.steps.switchToPreviewTab();
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Bat', 2);
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Eagle', 3);
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Platypus', 1);
+            previewScoringAndShowCorrectAnswerComponent.previewScoreText()
+                .verifyInnerText(`${pointsScoredArray[0]}/${totalPoints}`);
+
+            cy.log('When user adds a partially correct answer such that the points of the attempt(with penalty points deducted) is more than the minimum score awarded(if attempted) points');
+            dragAndDropIntoCategoriesPage.steps.resetQuestionPreview();
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Bat', 0);
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Eagle', 1);
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Parrot', 1);
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Platypus', 2);
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Flying squirrel', 3);
+            previewScoringAndShowCorrectAnswerComponent.previewScoreText()
+                .verifyInnerText(`${pointsScoredArray[1]}/${totalPoints}`);
+
+            cy.log('When user switches to edit tab and increases the minimum score awarded (if attempted) points to check the case for an attempt in which points of the attempt is less than minimum score awarded (if attempted) points, then the minimum score awarded (if attempted) points should be displayed to the user');
+            createQuestionBasePage.steps.switchToEditTab();
+            scoringSectionBase.steps.clearMinimumScoreIfAttemptedPointsField()
+            scoringSectionBase.steps.allotMinimumScoreAwardedIfAttempted(minimumPointsForPartialCorrectAnswers);
+            cy.log('Switching to preview tab');
+            createQuestionBasePage.steps.switchToPreviewTab();
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Bat', 0);
+            previewScoringAndShowCorrectAnswerComponent.previewScoreText()
+                .verifyInnerText(`${pointsScoredArray[2]}/${totalPoints}`);
+        });
+    },
+
+    /**
+     * @param {number[]} pointsScoredArray An array of numbers representing points scored in different cases.
+     *   - The first element represents points scored for a partially correct answer when round down score is selected.
+     *   - The second element represents points scored for full correct answer when round down score is selected.
+     *   - The third element represents points scored for a partially correct answer when round down score is deselected.
+     * @param {number} totalPoints the maximum points that can be achieved by the user
+     * @description verify the functionality of round down score for following cases.
+     * - For partially correct response, when round down score is selected.
+     * - For full correct answer response, when round down score is selected
+     * - For partially correct response, when round down score is deselected.
+     * - For full correct answer response, when round down score is deselected
+     */
+    verifyRoundDownScoreFunctionality: (pointsScoredArray, totalPoints) => {
+        it('When the \'Round down score\' checkbox is selected, then in preview tab when user enters partially or fully correct answer responses, the score displayed should be rounded down to the nearest whole number', () => {
+            dragAndDropIntoCategoriesPage.previewScoreText()
+                .verifyInnerText(`0/${totalPoints}`);
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Bat', 0);
+            dragAndDropIntoCategoriesPage.previewScoreText()
+                .verifyInnerText(`${pointsScoredArray[0]}/${totalPoints}`);
+            dragAndDropIntoCategoriesPage.steps.verifyPreviewTabPointsBackgroundForIncorrectOrPartiallyCorrectAnswer();
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Eagle', 1);
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Parrot', 1);
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Platypus', 2);
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Whale', 2);
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Ostrich', 3);
+            dragAndDropIntoCategoriesPage.previewScoreText()
+                .verifyInnerText(`${pointsScoredArray[1]}/${totalPoints}`);
+            dragAndDropIntoCategoriesPage.steps.verifyPreviewTabPointsBackgroundForIncorrectOrPartiallyCorrectAnswer();
+        });
+
+        it('When the \'Round down score\' checkbox is not selected, then in preview tab when user selects partially or fully correct answers the points should be displayed in decimal points if applicable as per the options selected by the user', () => {
+            cy.log('Switching to Edit tab')
+            dragAndDropIntoCategoriesPage.steps.switchToEditTab();
+            dragAndDropIntoCategoriesPage.steps.uncheckRoundDownScoreCheckbox();
+            cy.log('Switching to Preview tab')
+            dragAndDropIntoCategoriesPage.steps.switchToPreviewTab();
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Bat', 0);
+            dragAndDropIntoCategoriesPage.previewScoreText()
+                .verifyInnerText(`${pointsScoredArray[2]}/${totalPoints}`);
+            dragAndDropIntoCategoriesPage.steps.verifyPreviewTabPointsBackgroundForIncorrectOrPartiallyCorrectAnswer();
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Eagle', 1);
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Parrot', 1);
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Platypus', 2);
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Whale', 2);
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Ostrich', 3);
+            dragAndDropIntoCategoriesPage.previewScoreText()
+                .verifyInnerText(`${totalPoints}/${totalPoints}`);
+        });
+    },
+
+    verifyReuseOptionScoring: () => {
+        it('When the user has set same answer options in the \'Set correct answer\' section, then the user should be awarded full points on attempting the question with reused options', () => {
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Bat', 0);
+            dragAndDropIntoCategoriesPage.steps.clickAndDropDraggableOptionInCategoryCellOfPreviewTab('Bat', 1);
+            dragAndDropIntoCategoriesPage.previewScoreText()
+                .verifyInnerText('5/5');
+            dragAndDropIntoCategoriesPage.steps.verifyPreviewTabPointsBackgroundForCorrectAnswer();
+        });
+    },
+
+    //Additional settings
+    /**
+     * @param {string[]} numerationArray array of the numeration displayed with options numbers| lowercase| uppercase
+     * @description this function checks the numeration displayed for the options and correct answer container options when Show correct answer is checked
+     */
+    verifyCategoryCellsAndCorrectAnswerContainerNumerationWhenShowCorrectAnswerCheckboxIsChecked: (numerationArray) => {
+        it('When user clicks on \'Show correct answer\' checkbox then the numeration should be displayed on the options as well as \'Correct answers:\' section', () => {
+            previewScoringAndShowCorrectAnswerComponent.steps.checkShowCorrectAnswerCheckbox()
+            steps.verifyNumerationOfCategoryCellsInQuestionPreview(numerationArray)
+            steps.verifyCorrectAnswerContainerNumeration(numerationArray)
+            cy.log('Post step: Uncheck \'Show correct answer\' checkbox')
+            previewScoringAndShowCorrectAnswerComponent.steps.uncheckShowCorrectAnswerCheckbox()
+        });
+    },
+
+    /**
+    * @param {string[]} numerationArray array of the numeration displayed with options numbers| lowercase| uppercase
+    * @description this function checks the numeration displayed for the options and correct answer container options when check answer is selected
+    */
+    verifyCategoryCellsNumerationNotDisplayedWhenCheckAnswerIsSelected: () => {
+        it('When user clicks on \'Check answer\' button then the numeration should not be displayed in the category cells', () => {
+            autoScoredPreviewBase.steps.checkAnswer()
+            dragAndDropIntoCategoriesPage.categoryCellNumeration()
+                .should('not.exist');
+        });
+    }
+}
+export const dragAndDropIntoCategoriesPage = {
+    ...selectors,
+    steps,
+    tests
+};