itemengine-cypress-automation 1.0.77 → 1.0.79

package/cypress/pages/dragAndDropIntoCategoriesPage.js

@@ -1,1554 +1,1526 @@
-import { additionalSettingsPanel, autoScoredAdditionalSettings, autoScoredPreviewBase, autoScoredScoringSection, autoScoredScoringSectionMultipleResponsesType, autoScoredSetCorrectAnswerSection, commonComponents, createQuestionBasePage, dragAndDropResponseOptions, dragAndDropSetCorrectAnswerCheckboxComponents, draggableOptionsContainer, optionsWrapperComponent, previewScoringAndShowCorrectAnswerComponent, questionInstructionsComponent, scoringSectionBase, answerNumerationComponent, studentResponseAndLayoutComponent } from "./components";
+import { optionsWrapperComponent, createQuestionBasePage, autoScoredSpecifyCorrectAnswerSection, scoringSectionBaseEditTab, autoScoredScoringSectionMultiResponseType, questionInstructionsComponent, autoScoredStudentViewSettings, autoScoredScoringPreviewTab, commonComponents, ckEditorToolbar, equationEditorFlyout, randomizeOptionsComponent, allowMultipleInstancesOfSameDraggableOptionComponent, studentViewSettingsLabelComponent, additionalSettingsPanel, draggableOptionContainer, draggableOptionsSectionComponent, maximumCapacityPerDropzoneComponent, enableOuterBorderComponent } from "./components";
+import utilities from "../support/helpers/utilities";
+import constants from "../fixtures/constants";
 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 cellPropertyMenuOptions = ['Heading', 'subheading', 'text', 'dropzone', 'none'];
 
 const selectors = {
-    ...questionInstructionsComponent,
+    ...autoScoredScoringPreviewTab,
     ...commonComponents,
+    ...questionInstructionsComponent,
+    ...maximumCapacityPerDropzoneComponent,
+    ...randomizeOptionsComponent,
+    ...draggableOptionContainer,
+    ...allowMultipleInstancesOfSameDraggableOptionComponent,
+    ...autoScoredStudentViewSettings,
+    ...autoScoredSpecifyCorrectAnswerSection,
+    ...autoScoredScoringSectionMultiResponseType,
     ...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"]'),
+    ...draggableOptionsSectionComponent,
+    ...enableOuterBorderComponent,
+    editCellPropertyButton: () => cy.get('button[aria-label="More Action"]'),
+    editCellPropertyList: () => cy.get('.ngie-action-cell-container [role="menu"]'),
+    editCellPropertyListOption: () => cy.get('[class*="MuiMenuItem"][role="menuitem"]'),
+    cellHeadingTextArea: () => cy.get('textarea[aria-label="enter heading"]'),
+    cellSubheadingTextArea: () => cy.get('textarea[aria-label="enter subheading"]'),
+    cellTextTextArea: () => cy.get('textarea[aria-label="Enter text here..."]'),
+    tableCellContainer: () => cy.get('[class*="DragAndDropTablestyles__CellContainer"]'),
+    //Note: remove :visible after https://redmine.zeuslearning.com/issues/556304 gets fixed
+    dropzoneCellSpecifyCorrectAnswerSection: () => cy.get('[class*="DragAndDropMatrixstyles__CellContainer"][class*="dropzone-cell"]:visible'),
+    //Note: Items render twice in student view, need to remove .first()
+    dropzoneCellPreviewTab: () => cy.get('[class*="question-preview-wrapper"] [class*="DragAndDropMatrixstyles__CellContainer"][class*="dropzone-cell"]'),
+    dropzoneCellNumeration: () => cy.get('.answer-numeration-number-box'),
+    correctAnswerDropzoneCell: () => cy.get('[class*="DragAndDropMatrixstyles__AnswerCell"]'),
+    correctAnswerDropzoneCellTickIcon: () => cy.get('[class*="DragAndDropMatrixstyles__GreenBlock"]'),
+    correctAnswersLabel: () => cy.get('.correct-answers-label'),
     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*="RowResponseWrapper"] .text-label '),
-    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"]'),
+    //Note: Items render twice in student view, need to remove .first()
+    categoryGridPreviewTab: () => cy.get('[class*="question-preview-wrapper"] [class*="DragAndDropMatrixstyles__TableWrapper"]').first(),
     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')
+    correctIncorrectAnswerBlock: () => cy.get('[class*="correct-answer-block"]'),
+    correctIncorrectStatusMessageText: () => cy.get('[class*="DragAndDropMatrixstyles__AnswerStatusText"]'),
+    correctIncorrectAnswerLabel: () => cy.get('[class*="DragAndDropMatrixstyles__CorrectIncorrectLabel"]'),
+    correctAnswerContainer: () => cy.get('[class*="_CorrectAnswerWrapper"]'),
+
+    //Specify columns and rows
+    specifyColumnsAndRowsLabel: () => cy.get('[class*="SpecifyColumnRowsLabel"]'),
+    columnsInputStepperLabel: () => cy.get('.input-stepper-label').eq(0),
+    rowsInputStepperLabel: () => cy.get('.input-stepper-label').eq(1),
+    columnsInputStepperWrapper: () => cy.get('.input-stepper-wrapper[aria-label="Columns"]'),
+    rowsInputStepperWrapper: () => cy.get('.input-stepper-wrapper[aria-label="Rows"]'),
+    inputStepperDecreaseButton: () => cy.get('.input-stepper-button[aria-label="Decrease count"]'),
+    inputStepperIncreaseButton: () => cy.get('.input-stepper-button[aria-label="Increase count"]'),
+    inputStepperCountInputField: () => cy.get('.input-stepper-textfield'),
+    specifyColumnsAndRowsTableWrapper: () => cy.get('.drag-drop-table-wrapper'),
+    specifyColumnsAndRowsTableRowContainer: () => cy.get('[class*="DragAndDropTablestyles__RowContainer"]'),
+    setFirstRowCellsAsHeadingCheckbox: () => cy.get('[data-ngie-testid="set-first-row-cells-as-heading-checkbox"] .ngie-checkbox'),
+    setFirstRowCellsAsHeadingLabel: () => cy.get('[data-ngie-testid="set-first-row-cells-as-heading-checkbox"] [class*="label"]'),
+    setFirstColumnCellsAsHeadingCheckbox: () => cy.get('[data-ngie-testid="set-first-column-cells-as-heading-checkbox"] .ngie-checkbox'),
+    setFirstColumnCellsAsHeadingLabel: () => cy.get('[data-ngie-testid="set-first-column-cells-as-heading-checkbox"] [class*="label"]'),
+    dropzoneCellSpecifyColumnsAndRows: () => cy.get('[class*="DragAndDropTablestyles__CellContainer"].dropzone-cell'),
+    leftArrowNavigationButton: () => cy.get('[class*="DragAndDropTablestyles__PaginationLeftControl"]'),
+    rightArrowNavigationButton: () => cy.get('[class*="DragAndDropTablestyles__PaginationRightControl"]'),
+
+    //Specify correct answer matrix
+    tableCellContainerSpecifyCorrectAnswerSection: () => cy.get('[class*="DragAndDropMatrixstyles__CellContainer"]'),
+    tableRowContainerSpecifyCorrectAnswerSection: () => cy.get('[class*="DragAndDropMatrixstyles__RowContainer"]'),
+    leftArrowNavigationButtonSpecifyCorrectAnswerSection: () => cy.get('[aria-label="Left Pagination Button"][class*="DragAndDropMatrixstyles__PaginationControl"]').last(),
+    rightArrowNavigationButtonSpecifyCorrectAnswerSection: () => cy.get('[aria-label="Right Pagination Button"][class*="DragAndDropMatrixstyles__PaginationControl"]').last(),
+    tableCellLabel: () => cy.get('.cell-label'),
+
+    //Additional Settings
+    dropzoneAriaLabelInputField: () => cy.get('[type="text"][aria-label*="Enter ARIA label"]'),
+
+    //Preview tab table
+    tableRowContainerPreviewTab: () => cy.get('[class*="question-preview-wrapper"] [class*="DragAndDropMatrixstyles__RowContainer"]'),
+    leftArrowNavigationButtonPreviewTab: () => cy.get('[class*="question-preview-wrapper"] [aria-label="Left Pagination Button"][class*="DragAndDropMatrixstyles__PaginationControl"]'),
+    rightArrowNavigationButtonPreviewTab: () => cy.get('[class*="question-preview-wrapper"] [aria-label="Right Pagination Button"][class*="DragAndDropMatrixstyles__PaginationControl"]'),
+    cellContainerPreviewTab: () => cy.get('[class*="question-preview-wrapper"] [class*="DragAndDropMatrixstyles__CellContainer"]'),
+    cellContainerSpecifyCorrectAnswer: () => cy.get('[class*="DragAndDropMatrixstyles__CellContainer"]'),
+    incorrectOptionWrapper: () => cy.get('[class*="question-preview-wrapper"] .incorrect-answer-item'),
+    correctOptionWrapper: () => cy.get('[class*="question-preview-wrapper"] .correct-answer-item'),
+    perDropzoneRadioButton: () => cy.get('input[aria-label="per dropzone"]'),
+    perDropzoneRadioButtonLabel: () => cy.get('label[aria-label="per dropzone"]'),
+    perCorrectOptionRadioButton: () => cy.get('input[aria-label="Per correct option"]'),
+    perCorrectOptionRadioButtonLabel: () => cy.get('label[aria-label="Per correct option"]'),
+    totalPointsLabel: () => cy.get('[class*="TotalPointsLabel-"]'),
+    totalPointsValue: () => cy.get('[class*="TotalPointsLabel"] [class*="Value"]'),
+    addColumnButton: () => cy.get('[aria-label="Columns"] [aria-label*="Increase count"]'),
+    addRowButton: () => cy.get('[aria-label="Rows"] [aria-label*="Increase count"]'),
+    deleteColumnButton: () => cy.get('[aria-label="Columns"] [aria-label*="Decrease count"]'),
+    deleteRowButton: () => cy.get('[aria-label="Rows"] [aria-label*="Decrease count"]'),
+    //Note: Need to update selector after https://redmine.zeuslearning.com/issues/556753 gets fixed
+    penaltyPointsForIncorrectDropzoneInputField: () => cy.get('input[aria-label="penalty points for each incorrect option"]'),
+    penaltyPointsForIncorrectOptionInputField: () => cy.get('input[aria-label="penalty points for each incorrect option"]'),
+    penaltyPointsForEachIncorrectOptionOrDropzoneLabel: () => cy.get('[class*="PenaltyScoreForEachIncorrectstyles__PointsLabel"]'),
+    tableOuterBorder: () => cy.get('.table-border'),
+    categoryGridSpecifyCorrectAnswerSection: () => cy.get('[class*="DragAndDropMatrixstyles__TableWrapper"]'),
+    maxLimitInEachDropzoneHelpText: () => cy.get('[class*="DragAndDropMatrixstyles__MaxLimitWrapper"]'),
+    dropzoneGridSpecifyCorrectAnswerSection: () => cy.get('[class*="DragAndDropMatrixstyles__TableWrapper"]'),
+    dropzoneGridPreviewTab: () => cy.get('[class*="question-preview-wrapper"] [class*="DragAndDropMatrixstyles__TableWrapper"]'),
 }
 
 const steps = {
-    ...questionInstructionsComponent.steps,
-    ...commonComponents.steps,
+    ...autoScoredSpecifyCorrectAnswerSection.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
+    ...scoringSectionBaseEditTab.steps,
+    ...autoScoredScoringSectionMultiResponseType.steps,
+    ...autoScoredStudentViewSettings.steps,
+    ...autoScoredScoringPreviewTab.steps,
+    ...questionInstructionsComponent.steps,
+    ...ckEditorToolbar.steps,
+    ...equationEditorFlyout.steps,
+    ...maximumCapacityPerDropzoneComponent.steps,
+    ...randomizeOptionsComponent.steps,
+    ...draggableOptionContainer.steps,
+    ...allowMultipleInstancesOfSameDraggableOptionComponent.steps,
+    ...additionalSettingsPanel.steps,
+    ...commonComponents.steps,
+    ...draggableOptionsSectionComponent.steps,
+    ...commonComponents.steps,
+    ...enableOuterBorderComponent.steps,
     /**
-     * @param {number} count is the number of category input fields present
-     * @description verify the count of category input fields present
+     * @description Modifies the dropzone property based on the specified list option.
+     * @param {("Heading" | "Subheading" | "Text" | "Dropzone" | "None")} listOption - The list option to set to the dropzone.
      */
-    verifyCountOfCategoryInputFields: (count) => {
-        dragAndDropIntoCategoriesPage.categoryInputField()
-            .should('have.length', count);
-    },
-
-    addCategory: () => {
-        dragAndDropIntoCategoriesPage.addCategoryButton()
+    modifyTableCellProperty: (cellIndex, listOption) => {
+        dragAndDropIntoCategoriesPage.editCellPropertyButton()
+            .eq(cellIndex)
+            .scrollIntoView()
             .click();
+        utilities.verifyElementVisibilityState(dragAndDropIntoCategoriesPage.editCellPropertyList(), 'visible');
+        switch (listOption) {
+            case 'Heading':
+                dragAndDropIntoCategoriesPage.editCellPropertyListOption()
+                    .contains('Heading', { matchCase: false })
+                    .click();
+                break;
+            case 'Subheading':
+                dragAndDropIntoCategoriesPage.editCellPropertyListOption()
+                    .contains('Subheading', { matchCase: false })
+                    .click();
+                break;
+            case 'Text':
+                dragAndDropIntoCategoriesPage.editCellPropertyListOption()
+                    .contains('Text', { matchCase: false })
+                    .click();
+                break;
+            case 'Dropzone':
+                dragAndDropIntoCategoriesPage.editCellPropertyListOption()
+                    .contains('Dropzone', { matchCase: false })
+                    .click();
+                break;
+            case 'None':
+                dragAndDropIntoCategoriesPage.editCellPropertyListOption()
+                    .contains('None', { matchCase: false })
+                    .click();
+                break;
+            default:
+                throw new Error('Invalid list option');
+        }
     },
 
     /**
-     * @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
+     * @description Verify the specify columns and rows section table cell property
+     * @param {("Heading" | "Subheading" | "Text" | "Dropzone" | "None")} cellPropertyType - Property of the table cell
      */
-    enterTextInCategoryInputField: (inputFieldIndex, textContent) => {
-        dragAndDropIntoCategoriesPage.categoryInputField()
-            .eq(inputFieldIndex)
-            .clear()
-            .type(textContent, { delay: 0 })
-            .blur()
-            .focus()
-            .should('have.text', textContent);
+    verifySpecifyColumnsAndRowsSectionCellProperty: (cellIndex, cellPropertyType) => {
+        switch (cellPropertyType) {
+            case 'Heading':
+                utilities.getNthElement(dragAndDropIntoCategoriesPage.tableCellContainer(), cellIndex)
+                    .should('have.class', 'heading-dropzone');
+                break;
+            case 'Subheading':
+                utilities.getNthElement(dragAndDropIntoCategoriesPage.tableCellContainer(), cellIndex)
+                    .should('have.class', 'subheading-dropzone');
+                break;
+            case 'Text':
+                utilities.getNthElement(dragAndDropIntoCategoriesPage.tableCellContainer(), cellIndex)
+                    .should('have.class', 'text-dropzone');
+                break;
+            case 'Dropzone':
+                utilities.getNthElement(dragAndDropIntoCategoriesPage.tableCellContainer(), cellIndex)
+                    .should('have.class', 'dropzone-cell');
+                break;
+            case 'None':
+                utilities.getNthElement(dragAndDropIntoCategoriesPage.tableCellContainer(), cellIndex)
+                    .should('have.class', 'text-dropzone')
+                    .find('textarea')
+                    .should('not.exist');
+                break;
+            default:
+                throw new Error('Invalid cell property');
+        }
     },
 
     /**
-     * @param {number} inputFieldIndex indicates the category input field index
-     * @description clears text in a category input field
+     * @description Verify the specify columns and rows section table cell property
+     * @param {("Heading" | "Subheading" | "Text" | "Dropzone" | "None")} cellPropertyType - Property of the table cell
      */
-    clearTextInCategoryInputField: (inputFieldIndex) => {
-        dragAndDropIntoCategoriesPage.categoryInputField()
-            .eq(inputFieldIndex)
-            .focus()
-            .clear()
-            .should('have.text', '')
-            .blur();
+    verifySpecifyCorrectAnswerSectionCellProperty: (cellIndex, cellPropertyType) => {
+        switch (cellPropertyType) {
+            case 'Heading':
+                utilities.getNthElement(dragAndDropIntoCategoriesPage.tableCellContainerSpecifyCorrectAnswerSection(), cellIndex)
+                    .should('have.class', 'heading-dropzone');
+                break;
+            case 'Subheading':
+                utilities.getNthElement(dragAndDropIntoCategoriesPage.tableCellContainerSpecifyCorrectAnswerSection(), cellIndex)
+                    .should('have.class', 'subheading-dropzone');
+                break;
+            case 'Text':
+                utilities.getNthElement(dragAndDropIntoCategoriesPage.tableCellContainerSpecifyCorrectAnswerSection(), cellIndex)
+                    .should('have.class', 'text-dropzone');
+                break;
+            case 'Dropzone':
+                utilities.getNthElement(dragAndDropIntoCategoriesPage.tableCellContainerSpecifyCorrectAnswerSection(), cellIndex)
+                    .should('have.class', 'dropzone-cell');
+                break;
+            case 'None':
+                utilities.getNthElement(dragAndDropIntoCategoriesPage.tableCellContainerSpecifyCorrectAnswerSection(), cellIndex)
+                    .should('have.class', 'text-dropzone')
+                    .find('.cell-label')
+                    .should('not.exist');
+                break;
+            default:
+                throw new Error('Invalid cell property');
+        }
     },
 
     /**
-     * @param {number} inputFieldIndex indicates the category input field index
-     * @description verify placeholder text of category input field
+     * @param {number} cellIndex - Index of the table cell.
+     * @param {("Heading" | "Subheading" | "Text" | "Dropzone" | "None")} cellProperty - Type of property to verify.
+     * @description Verifies the appearance and content of a specific property in a table cell on the preview tab.
      */
-    verifyPlaceholderTextInCategoryInputField: (inputFieldIndex) => {
-        dragAndDropIntoCategoriesPage.categoryInputField()
-            .eq(inputFieldIndex)
-            .should('have.attr', 'data-cke-editorplaceholder', 'Enter category title');
+    verifyTableCellPropertyPreviewTab: (cellIndex, cellProperty) => {
+        switch (cellProperty) {
+            case 'Heading':
+                utilities.getNthElement(dragAndDropIntoCategoriesPage.cellContainerPreviewTab(), cellIndex)
+                    .should('have.class', 'heading-dropzone');
+                break;
+            case 'Subheading':
+                utilities.getNthElement(dragAndDropIntoCategoriesPage.cellContainerPreviewTab(), cellIndex)
+                    .should('have.class', 'subheading-dropzone');
+                break;
+            case 'Text':
+                utilities.getNthElement(dragAndDropIntoCategoriesPage.cellContainerPreviewTab(), cellIndex)
+                    .should('have.class', 'text-dropzone');
+                break;
+            case 'Dropzone':
+                utilities.getNthElement(dragAndDropIntoCategoriesPage.cellContainerPreviewTab(), cellIndex)
+                    .should('have.class', 'dropzone-cell');
+                break;
+            case 'None':
+                utilities.getNthElement(dragAndDropIntoCategoriesPage.cellContainerPreviewTab(), cellIndex)
+                    .should('have.class', 'text-dropzone')
+                    .and('have.text', '');
+                break;
+            default:
+                throw new Error('Invalid list option');
+        };
     },
 
     /**
-     * @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} cellIndex - Index of the table cell.
+    * @param {("Heading" | "Subheading" | "Text" | "Dropzone" | "None")} cellProperty - Type of property to verify.
+    * @description Verifies the appearance and content of a specific property in a table cell on the preview tab.
+    */
+    verifyTableCellPropertySpecifyCorrectAnswer: (cellIndex, cellProperty) => {
+        switch (cellProperty) {
+            case 'Heading':
+                utilities.getNthElement(dragAndDropIntoCategoriesPage.cellContainerSpecifyCorrectAnswer(), cellIndex)
+                    .should('have.class', 'heading-dropzone');
+                break;
+            case 'Subheading':
+                utilities.getNthElement(dragAndDropIntoCategoriesPage.cellContainerSpecifyCorrectAnswer(), cellIndex)
+                    .should('have.class', 'subheading-dropzone');
+                break;
+            case 'Text':
+                utilities.getNthElement(dragAndDropIntoCategoriesPage.cellContainerSpecifyCorrectAnswer(), cellIndex)
+                    .should('have.class', 'text-dropzone');
+                break;
+            case 'Dropzone':
+                utilities.getNthElement(dragAndDropIntoCategoriesPage.cellContainerSpecifyCorrectAnswer(), cellIndex)
+                    .should('have.class', 'dropzone-cell');
+                break;
+            case 'None':
+                utilities.getNthElement(dragAndDropIntoCategoriesPage.cellContainerSpecifyCorrectAnswer(), cellIndex)
+                    .should('have.class', 'text-dropzone')
+                    .and('have.text', '');
+                break;
+            default:
+                throw new Error('Invalid list option');
+        };
     },
 
     /**
-     * @param {number} inputFieldIndex indicates the category input field index
-     * @description delete a category input field
+     * Edits the heading of a cell in the drag-and-drop into categories table.
+     * @param {number} cellIndex - The index of the cell to edit.
+     * @param {string} textContent - The new text content for the heading.
      */
-    deleteCategoryInputField: (inputFieldIndex) => {
-        dragAndDropIntoCategoriesPage.categoryInputField()
-            .eq(inputFieldIndex)
-            .parents('[class*="OptionsComponentstyles__TitleWrapper"]')
-            .find('[aria-label*="Delete category"]')
-            .click();
+    editCellHeading: (cellIndex, textContent) => {
+        dragAndDropIntoCategoriesPage.tableCellContainer()
+            .eq(cellIndex)
+            .within(() => {
+                dragAndDropIntoCategoriesPage.cellHeadingTextArea()
+                    .clear()
+                    .type(textContent)
+                    .blur();
+            });
     },
 
     /**
-     * @param {number} inputFieldIndex indicates the category input field index
-     * @description verify the delete category button is visible and enabled
+     * Edits the subheading of a cell in the drag-and-drop into categories table.
+     * @param {number} cellIndex - The index of the cell to edit.
+     * @param {string} textContent - The new text content for the subheading.
      */
-    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}`);
-                };
+    editCellSubheading: (cellIndex, textContent) => {
+        dragAndDropIntoCategoriesPage.tableCellContainer()
+            .eq(cellIndex)
+            .within(() => {
+                dragAndDropIntoCategoriesPage.cellSubheadingTextArea()
+                    .clear()
+                    .type(textContent)
+                    .blur();
             });
     },
 
     /**
-     * @param {number} count denotes the number of category titles present
-     * @description verify count of category titles in set correct answer section 
+     * Edits the text of a cell in the drag-and-drop into categories table.
+     * @param {number} cellIndex - The index of the cell to edit.
+     * @param {string} textContent - The new text content for the cell.
      */
-    verifyCountOfCategoryTitlesInSetCorrectAnswerSection: (count) => {
-        dragAndDropIntoCategoriesPage.setCorrectAnswerSectionCategoryTitle()
-            .should('have.length', count);
+    editCellText: (cellIndex, textContent) => {
+        dragAndDropIntoCategoriesPage.tableCellContainer()
+            .eq(cellIndex)
+            .within(() => {
+                dragAndDropIntoCategoriesPage.cellTextTextArea()
+                    .clear()
+                    .type(textContent)
+                    .blur();
+            });
     },
 
     /**
-     * @param {number} count denotes the number of categories present
-     * @description verify count of categories in set correct answer section 
+     * Verifies the empty state of a dropzone cell in the Specify Correct Answer section.
+     * @param {number} cellIndex - The index of the dropzone cell to verify.
      */
-    verifyCountOfCategoriesInSetCorrectAnswerSection: (count) => {
-        dragAndDropIntoCategoriesPage.setCorrectAnswerSectionCategoryCell()
-            .should('have.length', count);
+    verifyEmptyStateOfDropzoneInSetCorrectAnswerSection: (cellIndex) => {
+        utilities.verifyTextContent(utilities.getNthElement(dragAndDropIntoCategoriesPage.dropzoneCellSpecifyCorrectAnswerSection(), cellIndex), '');
     },
 
     /**
-     * @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
+     * Verifies the empty state of a dropzone cell in the Preview Tab.
+     * @param {number} cellIndex - The index of the dropzone cell to verify.
      */
-    verifyCategoryTitleInSetCorrectAnswerSection: (categoryIndex, title) => {
-        dragAndDropIntoCategoriesPage.setCorrectAnswerSectionCategoryTitle()
-            .eq(categoryIndex)
-            .should('have.text', title)
-            .and('be.visible');
+    verifyEmptyStateOfDropzoneInPreviewTab: (cellIndex) => {
+        utilities.verifyTextContent(utilities.getNthElement(dragAndDropIntoCategoriesPage.dropzoneCellPreviewTab(), cellIndex), '');
     },
 
     /**
-     * @param {number} count denotes the number of categories titles present
-     * @description verify count of category titles in preview tab
+     * Verifies the numeration of dropzone cells in the Preview Tab.
+     * @param {number[]} dropZoneCellIndexArray - An array of expected numerations for each dropzone cell.
      */
-    verifyCountOfCategoryTitlesInPreviewTab: (count) => {
-        dragAndDropIntoCategoriesPage.previewTabCategoryTitle()
-            .should('have.length', count);
+    verifyDropzoneCellNumeration: (dropZoneCellIndexArray) => {
+        dropZoneCellIndexArray.forEach((dropzoneCellNumeration, index) => {
+            dragAndDropIntoCategoriesPage.dropzoneCellPreviewTab()
+                .eq(index)
+                .within(() => {
+                    utilities.verifyElementVisibilityState(dragAndDropIntoCategoriesPage.dropzoneCellNumeration(), 'visible');
+                    utilities.verifyInnerText(dragAndDropIntoCategoriesPage.dropzoneCellNumeration(), `${dropzoneCellNumeration}`);
+                });
+        });
     },
 
     /**
-     * @param {number} count denotes the number of categories
-     * @description verify count of categories in preview tab
+     * Verifies the numeration of correct answer container dropzone cells.
+     * @param {Array<string>} dropZoneCellIndexArray - An array of expected numeration values for dropzone cells.
+     * @returns {void}
      */
-    verifyCountOfCategoriesInPreviewTab: (count) => {
-        dragAndDropIntoCategoriesPage.previewTabCategoryCell()
-            .should('have.length', count);
+    verifyCorrectAnswerContainerNumeration: (dropZoneCellIndexArray) => {
+        dropZoneCellIndexArray.forEach((dropzoneCellNumeration, index) => {
+            dragAndDropIntoCategoriesPage.correctAnswerDropzoneCell()
+                .eq(index)
+                .within(() => {
+                    utilities.verifyElementVisibilityState(dragAndDropIntoCategoriesPage.correctAnswerDropzoneCellTickIcon(), 'visible');
+                    utilities.verifyTextContent(dragAndDropIntoCategoriesPage.dropzoneCellNumeration(), `${dropzoneCellNumeration}`);
+                });
+        });
     },
 
     /**
-     * @param {number} categoryIndex denotes the index of the category title
-     * @param {string} title denotes the category title
-     * @description verify category title in preview tab
+     * Verifies correct answer responses in the Correct Answer section and counts them.
+     * @param {string[][]} correctAnswerArray - An array of correct answer options for each dropzone cell.
+     * @param {number[]} dropZoneCellIndexArray - An array of expected numerations for each dropzone cell.
      */
-    verifyCategoryTitleInPreviewTab: (categoryIndex, title) => {
-        dragAndDropIntoCategoriesPage.previewTabCategoryTitle()
-            .eq(categoryIndex)
-            .should('have.text', title)
-            .and('be.visible');
+    verifyCorrectAnswerResponsesInCorrectAnswerSectionAndCount: (correctAnswerArray, dropZoneCellIndexArray) => {
+        utilities.verifyElementCount(dragAndDropIntoCategoriesPage.correctAnswerDropzoneCell(), correctAnswerArray.length);
+        correctAnswerArray.forEach((correctAnswer, index) => {
+            dragAndDropIntoCategoriesPage.correctAnswerDropzoneCell()
+                .eq(index)
+                .within(() => {
+                    utilities.verifyTextContent(dragAndDropIntoCategoriesPage.dropzoneCellNumeration(), dropZoneCellIndexArray[index]);
+                    correctAnswer.forEach((answerOption, optionIndex) => {
+                        utilities.verifyTextContent(utilities.getNthElement(dragAndDropIntoCategoriesPage.correctAnswerOption(), optionIndex), answerOption);
+                    });
+                });
+        });
     },
 
     /**
-     * @param {number} inputFieldIndex denotes the category input field index
-     * @description focus in and out of a category input field
+     * Verifies the presence of an incorrect option icon for a specified option in the Preview Tab.
+     * @param {number} optionIndex - The index of the option to verify.
      */
-    focusInAndFocusOutOfCategoryInputField: (inputFieldIndex) => {
-        dragAndDropIntoCategoriesPage.categoryInputField()
-            .eq(inputFieldIndex)
-            .click()
-            .blur();
+    verifyIncorrectOptionIcon: (optionIndex) => {
+        dragAndDropIntoCategoriesPage.categoryGridPreviewTab()
+            .within(() => {
+                dragAndDropIntoCategoriesPage.optionsWrapper()
+                    .eq(optionIndex)
+                    .should('have.class', 'incorrect-answer-item');
+            });
     },
 
     /**
-     * @param {number} inputFieldIndex denotes the category input field index
-     * @description verify tooltip of Delete category button
+     * Verifies the presence of a correct option icon for a specified option in the Preview Tab.
+     * @param {number} optionIndex - The index of the option to verify.
      */
-    verifyDeleteCategoryTooltip: (inputFieldIndex) => {
-        dragAndDropIntoCategoriesPage.categoryInputField()
-            .eq(inputFieldIndex)
-            .parents('[class*="OptionsComponentstyles__TitleWrapper"]')
-            .find('button')
-            .verifyTooltip('Delete category');
+    verifyCorrectOptionIcon: (optionIndex) => {
+        dragAndDropIntoCategoriesPage.categoryGridPreviewTab()
+            .within(() => {
+                dragAndDropIntoCategoriesPage.optionsWrapper()
+                    .eq(optionIndex)
+                    .should('have.class', 'correct-answer-item');
+            });
     },
 
-    //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);
+    setRowsAndColumnsForQuestion: () => {
+        dragAndDropIntoCategoriesPage.steps.modifyTableCellProperty(0, 'None');
+        dragAndDropIntoCategoriesPage.steps.modifyTableCellProperty(3, 'Heading');
+        dragAndDropIntoCategoriesPage.steps.modifyTableCellProperty(6, 'Subheading');
+        dragAndDropIntoCategoriesPage.steps.modifyTableCellProperty(9, 'Text');
+        dragAndDropIntoCategoriesPage.steps.editCellHeading(1, 'Mammal');
+        dragAndDropIntoCategoriesPage.steps.editCellHeading(2, 'Not mammal');
+        dragAndDropIntoCategoriesPage.steps.editCellHeading(3, 'Can fly');
+        dragAndDropIntoCategoriesPage.steps.editCellSubheading(6, 'Can walk');
+        dragAndDropIntoCategoriesPage.steps.editCellText(9, 'Can swim');
     },
 
     /**
-     * @param {number} inputFieldIndex is the index of the row input field
-     * @description verify the default state of a row input field
+     * @param {("correct" | "incorrect")} answerStatus - The status of the answer.
+     * @description Verifies the visibility and content of the correct/incorrect answer label block.
+     * If the answer is correct, it also verifies the visibility of the correct icon;
+     * otherwise, it verifies the visibility of the incorrect icon.
      */
-    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}`);
-                };
-            });
+    verifyCorrectIncorrectAnswerLabel: (answerStatus) => {
+        utilities.verifyElementVisibilityState(dragAndDropIntoCategoriesPage.correctIncorrectAnswerBlock(), 'visible');
+        utilities.verifyInnerText(dragAndDropIntoCategoriesPage.correctIncorrectStatusMessageText(), `Your answer is\n${answerStatus}`)
+        if (answerStatus === 'correct') {
+            utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.correctIcon(), 'visible');
+        } else {
+            utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.incorrectIcon(), 'visible');
+        }
     },
 
     /**
-     * @param {number} inputFieldIndex is the index of the row input field
-     * @description verify if the delete row button is disabled
+     * Sets options in dropzones in the Specify Correct Answer section based on the provided optionsObject.
+     * @param {Object} optionsObject - An object where keys are option texts and values are dropzone indices.
+     * @example clickAndDropOptionInDropzoneSpecifyCorrectAnswerSection({ 'Bat': 0, 'Eagle': 1, 'Parrot': 4, 'Whale': 4 })
      */
-    verifyDisabledDeleteRowButton: (inputFieldIndex) => {
-        dragAndDropIntoCategoriesPage.rowInputField()
-            .eq(inputFieldIndex)
-            .parents('[class*="OptionsComponentstyles__TitleWrapper"]')
-            .find('button')
-            .should('be.visible')
-            .and('be.disabled');
+    clickAndDropOptionInDropzoneSpecifyCorrectAnswerSection: (optionsObject) => {
+        Object.entries(optionsObject).forEach(([optionText, dropzoneIndex]) => {
+            dragAndDropIntoCategoriesPage.optionsContainerSpecifyCorrectAnswerSection()
+                .within(() => {
+                    draggableOptionContainer.draggableOption()
+                        .contains(optionText)
+                        .click();
+                });
+            dragAndDropIntoCategoriesPage.dropzoneCellSpecifyCorrectAnswerSection()
+                .eq(dropzoneIndex)
+                .click({ force: true });
+        });
     },
 
-    /**
-     * @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');
+    clickAndDropOptionInOptionsContainerInSpecifyCorrectAnswerSection: (optionText) => {
+        dragAndDropIntoCategoriesPage.draggableOption()
+            .contains(optionText)
+            .click();
+        dragAndDropIntoCategoriesPage.optionsContainerSpecifyCorrectAnswerSection()
+            .click();
     },
 
     /**
-     * @param {number} inputFieldIndex is the index of the row input field
-     * @description verify placeholder text in the row input field
+     * Sets options in dropzones in the Preview Tab based on the provided optionsObject.
+     * @param {Object} optionsObject - An object where keys are option texts and values are dropzone indices.
+     * @example clickAndDropOptionInDropzonePreviewTab({ 'Bat': 0, 'Eagle': 1, 'Parrot': 4, 'Whale': 4 })
      */
-    verifyPlaceholderTextInRowInputField: (inputFieldIndex) => {
-        dragAndDropIntoCategoriesPage.rowInputField()
-            .eq(inputFieldIndex)
-            .should('have.attr', 'data-cke-editorplaceholder', 'Enter row title');
+    clickAndDropOptionInDropzonePreviewTab: (optionsObject) => {
+        Object.entries(optionsObject).forEach(([optionText, dropzoneIndex]) => {
+            dragAndDropIntoCategoriesPage.optionsContainerPreviewTab()
+                .within(() => {
+                    draggableOptionContainer.draggableOption()
+                        .contains(optionText)
+                        .click();
+                });
+            dragAndDropIntoCategoriesPage.dropzoneCellPreviewTab()
+                .eq(dropzoneIndex)
+                .click({ force: true });
+        });
     },
 
-    /**
-     * @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');
+    verifyCorrectAnswerSectionNotExists: () => {
+        utilities.verifyElementVisibilityState(dragAndDropIntoCategoriesPage.correctAnswerContainer(), 'notExist');
     },
 
-    /**
-     * @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);
+    verifyCorrectIncorrectStatusMessageNotExists: () => {
+        utilities.verifyElementVisibilityState(dragAndDropIntoCategoriesPage.correctIncorrectAnswerBlock(), 'notExist');
     },
 
-    addRow: () => {
-        dragAndDropIntoCategoriesPage.addRowButton()
-            .click();
+    verifyQuestionPreviewStateWhenSwitchingBackToStudentView: () => {
+        cy.log('After switching to student view, the question preview should return to the previous state');
+        autoScoredScoringPreviewTab.steps.switchToStudentView();
+        dragAndDropIntoCategoriesPage.steps.verifyCorrectIncorrectStatusMessageNotExists();
+        dragAndDropIntoCategoriesPage.steps.verifyCorrectAnswerSectionNotExists();
     },
 
     /**
-     * @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();
+    * @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.
+    */
+    verifyDraggableOptionWithImageInPreviewTab: (optionIndex) => {
+        dragAndDropIntoCategoriesPage.optionsContainerPreviewTab()
+            .within(() => {
+                draggableOptionContainer.draggableOption()
+                    .eq(optionIndex)
+                    .find('img')
+                    .should('have.attr', 'src', constants.foxImageLink)
+                    .and('have.attr', 'alt', constants.foxImageAltText);
+                utilities.verifyElementVisibilityState(utilities.getNthElement(draggableOptionContainer.draggableOptionDragIcon(), optionIndex), 'exist');
+            });
     },
 
     /**
-     * @param {number} count denotes the number of rows
-     * @description verify count of rows present in set correct answer section
+     * @description Verify the count of columns in column input stepper
+     * @param {number} value Count of columns in input stepper
      */
-    verifyCountOfRowsInSetCorrectAnswerSection: (count) => {
-        dragAndDropIntoCategoriesPage.setCorrectAnswerSectionRowContainer()
-            .should('have.length', count);
+    verifyColumnInputStepperCountInputFieldValue: (value) => {
+        dragAndDropIntoCategoriesPage.inputStepperCountInputField()
+            .eq(0)
+            .should('have.value', value);
     },
 
     /**
-     * @param {number} count denotes the number of ro titles
-     * @description verify count of row titles present in the set correct answer section
+     * @description Verify the count of rows in rows input stepper
+     * @param {number} value Count of rows in input stepper
      */
-    verifyCountOfRowTitlesInSetCorrectAnswerSection: (count) => {
-        dragAndDropIntoCategoriesPage.setCorrectAnswerSectionRowTitle()
-            .should('have.length', count)
+    verifyRowsInputStepperCountInputFieldValue: (value) => {
+        dragAndDropIntoCategoriesPage.inputStepperCountInputField()
+            .eq(1)
+            .should('have.value', value);
     },
 
     /**
-     * @param {number} count denotes the number of rows present
-     * @description verify count of rows in the preview tab
+     * @description Increase column input stepper count
+     * @param {number} increaseValue The value by which the column input stepper count is to be increased
      */
-    verifyCountOfRowsInPreviewTab: (count) => {
-        dragAndDropIntoCategoriesPage.previewTabRowContainer()
-            .should('have.length', count);
+    increaseColumnInputStepperCount: (increaseValue) => {
+        for (let index = 0; index < increaseValue; index++) {
+            dragAndDropIntoCategoriesPage.inputStepperIncreaseButton()
+                .eq(0)
+                .click();
+        };
     },
 
     /**
-     * @param {number} count denotes the number of rows titles
-     * @description verify count of row titles  present in the preview tab
+     * @description Decrease column input stepper count
+     * @param {number} increaseValue The value by which the column input stepper count is to be decreased
      */
-    verifyCountOfRowTitlesInPreviewTab: (count) => {
-        dragAndDropIntoCategoriesPage.previewTabRowTitle()
-            .should('have.length', count)
+    decreaseColumnInputStepperCount: (increaseValue) => {
+        for (let index = 0; index < increaseValue; index++) {
+            dragAndDropIntoCategoriesPage.inputStepperDecreaseButton()
+                .eq(0)
+                .click();
+        };
     },
 
-    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');
+    /**
+     * @description Increase row input stepper count
+     * @param {number} decreaseValue The value by which the row input stepper count is to be increased
+     */
+    increaseRowInputStepperCount: (decreaseValue) => {
+        for (let index = 0; index < decreaseValue; index++) {
+            dragAndDropIntoCategoriesPage.inputStepperIncreaseButton()
+                .eq(1)
+                .click();
+        };
     },
 
     /**
-     * @param {number} inputFieldIndex is the index of the row input field
-     * @description focus in and out of a row input field
+     * @description Decrease row input stepper count
+     * @param {number} decreaseValue The value by which the row input stepper count is to be decreased
      */
-    focusInAndFocusOutOfRowInputField: (inputFieldIndex) => {
-        dragAndDropIntoCategoriesPage.rowInputField()
-            .eq(inputFieldIndex)
-            .click()
-            .blur();
+    decreaseRowInputStepperCount: (decreaseValue) => {
+        for (let index = 0; index < decreaseValue; index++) {
+            dragAndDropIntoCategoriesPage.inputStepperDecreaseButton()
+                .eq(1)
+                .click();
+        };
     },
 
     /**
-     * @param {number} inputFieldIndex is the index of the row input field
-     * @description verify tooltip of enabled 'Delete row' button
+     * @description Verify the number of columns in the specify columns and rows section table
+     * @param {number} numberOfColumns Number of columns in the specify columns and rows section table
      */
-    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"]')
+    verifyColumnsCountInSpecifyColumnsAndRowsTable: (numberOfColumns) => {
+        dragAndDropIntoCategoriesPage.specifyColumnsAndRowsTableRowContainer()
+            .eq(0)
             .within(() => {
-                dragAndDropIntoCategoriesPage.deleteButton()
-                    .trigger('mouseout');
+                utilities.verifyElementCount(dragAndDropIntoCategoriesPage.tableCellContainer(), numberOfColumns);
             });
-        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');
+    * @description Verify the number of columns in the specify correct answer section table
+    * @param {number} numberOfColumns Number of columns in the specify correct answer section table
+    */
+    verifyColumnsCountInSpecifyCorrectAnswerSectionTable: (numberOfColumns) => {
+        dragAndDropIntoCategoriesPage.tableRowContainerSpecifyCorrectAnswerSection()
+            .eq(0)
+            .within(() => {
+                utilities.verifyElementCount(dragAndDropIntoCategoriesPage.tableCellContainerSpecifyCorrectAnswerSection(), numberOfColumns);
+            });
     },
 
     /**
-     * @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
+     * @description Verifies that the link text in the Preview tab is correct and has the correct href attribute.
+     * @param {number} optionIndex - The index of the option in the Preview tab.
      */
-    verifyRowTitleInPreviewTab: (rowIndex, title) => {
-        dragAndDropIntoCategoriesPage.previewTabRowTitle()
-            .eq(rowIndex)
-            .should('have.text', title)
-            .and('be.visible');
+    verifyDraggableOptionWithLinkTextInPreviewTab: (optionIndex) => {
+        dragAndDropIntoCategoriesPage.optionsContainerPreviewTab()
+            .within(() => {
+                draggableOptionContainer.draggableOption()
+                    .eq(optionIndex)
+                    .find('a')
+                    .should('have.text', 'lorem')
+                    .and('have.attr', 'href', `${Cypress.config().baseUrl}`);
+                utilities.verifyElementVisibilityState(utilities.getNthElement(draggableOptionContainer.draggableOptionDragIcon(), optionIndex), 'exist');
+            });
     },
 
     /**
-     * @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
+    * @description Verifies that the bold text in the Preview tab is correct.
+    * @param {number} optionIndex - The index of the option in the Preview tab.
     */
-    clickAndDropDraggableOptionInCategoryCellOfSetCorrectAnswerSection: (optionName, categoryIndex) => {
-        draggableOptionsContainer.setCorrectAnswerDraggableOptionsWrapper('drag and drop into categories')
+    verifyDraggableOptionWithBoldTextInPreviewTab: (optionIndex) => {
+        dragAndDropIntoCategoriesPage.optionsContainerPreviewTab()
             .within(() => {
-                draggableOptionsContainer.draggableOption()
-                    .contains(optionName)
-                    .click();
+                draggableOptionContainer.draggableOption()
+                    .eq(optionIndex)
+                    .find('strong')
+                    .should('have.text', 'This is a bold option');
+                utilities.verifyElementVisibilityState(utilities.getNthElement(draggableOptionContainer.draggableOptionDragIcon(), optionIndex), 'exist');
             });
-        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
+    * @description Verify the number of columns in the preview tab table
+    * @param {number} numberOfColumns Number of columns in the preview tab table
     */
-    clickAndDropDraggableOptionInCategoryCellOfPreviewTab: (optionName, categoryIndex) => {
-        draggableOptionsContainer.previewTabDraggableOptionsWrapper('drag and drop into categories')
-            .within(() => {
-                draggableOptionsContainer.draggableOption()
-                    .contains(optionName)
-                    .click();
+    verifyTheNumberOfColumnsInPreviewTabTable: (numberOfColumns) => {
+        dragAndDropIntoCategoriesPage.tableRowContainerPreviewTab()
+            .eq(0)
+            .within(($element) => {
+                utilities.verifyElementCount(cy.wrap($element).find('[class*="DragAndDropMatrixstyles__CellContainer"]'), numberOfColumns);
             });
-        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
+     * @description Verifies that the equation text in the Preview tab is correct.
+     * @param {number} optionIndex - The index of the option in the Preview tab.
      */
-    verifyDraggableOptionInCategoryCellOfSetCorrectAnswerSection: (categoryIndex, responseArray) => {
-        dragAndDropIntoCategoriesPage.setCorrectAnswerSectionCategoryCell()
-            .eq(categoryIndex)
+    verifyDraggableOptionWithEquationTextInPreviewTab: (optionIndex) => {
+        dragAndDropIntoCategoriesPage.optionsContainerPreviewTab()
             .within(() => {
-                responseArray.forEach((response, count) => {
-                    draggableOptionsContainer.draggableOption()
-                        .eq(count)
-                        .verifyInnerText(response);
-                });
+                dragAndDropIntoCategoriesPage.draggableOption()
+                    .eq(optionIndex)
+                    .find('[role="math"]')
+                    .should('have.attr', 'aria-label', constants.CKEditorInputFieldEnteredEquationAriaLabel)
+                    .contains(constants.CKEditorInputFieldEnteredEquationText);
+                utilities.verifyElementVisibilityState(utilities.getNthElement(draggableOptionContainer.draggableOptionDragIcon(), optionIndex), 'exist');
             });
     },
 
-    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');
+    verifyDraggableOptionPreviewTab: (optionIndex, optionText) => {
+        dragAndDropIntoCategoriesPage.optionsContainerPreviewTab()
+            .within(() => {
+                utilities.verifyElementVisibilityState(utilities.getNthElement(draggableOptionContainer.draggableOptionDragIcon(), optionIndex), 'exist');
+                utilities.verifyTextContent(utilities.getNthElement(dragAndDropIntoCategoriesPage.draggableOption(), optionIndex), optionText);
+            });
     },
 
     /**
-     * @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();
+    * @description Verify the number of columns in the preview tab table
+    * @param {number} numberOfColumns Number of columns in the preview tab table
+    */
+    verifyColumnsCountInPreviewTabTable: (numberOfColumns) => {
+        dragAndDropIntoCategoriesPage.tableRowContainerPreviewTab()
+            .eq(0)
+            .within(($element) => {
+                utilities.verifyElementCount(cy.wrap($element).find('[class*="DragAndDropMatrixstyles__CellContainer"]'), numberOfColumns);
+            });
     },
 
     /**
-     * @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
+     * @description Verify the number of rows in the specify columns and rows section table
+     * @param {number} numberOfRows Number of rows in the specify columns and rows section table
      */
-    verifyCorrectAnswerOptionsAndPointsInSetCorrectAnswerSection: (optionsArray, points) => {
-        optionsArray.forEach((responseText, count) => {
-            dragAndDropIntoCategoriesPage.setCorrectAnswerSectionCategoryCell()
-                .eq(count)
-                .verifyInnerText(responseText);
-        });
-        scoringSectionBase.pointsInputField()
-            .should('have.value', points);
+    verifyRowsCountInSpecifyColumnsAndRowsTable: (numberOfRows) => {
+        utilities.verifyElementCount(dragAndDropIntoCategoriesPage.specifyColumnsAndRowsTableRowContainer(), numberOfRows);
     },
 
-    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);
+    /**
+    * @description Verify the number of rows in the specify correct answer section table
+    * @param {number} numberOfRows Number of rows in the specify correct answer section table
+    */
+    verifyRowsCountInSpecifyCorrectAnswerSectionTable: (numberOfRows) => {
+        utilities.verifyElementCount(dragAndDropIntoCategoriesPage.tableRowContainerSpecifyCorrectAnswerSection(), numberOfRows);
     },
 
     /**
-     * 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');
-                });
-        });
+    * @description Verify the number of rows in the preview tab table
+    * @param {number} numberOfRows Number of rows in the preview tab table
+    */
+    verifyRowsCountInPreviewTabTable: (numberOfRows) => {
+        utilities.verifyElementCount(dragAndDropIntoCategoriesPage.tableRowContainerPreviewTab(), numberOfRows);
     },
 
     /**
-     * @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
+     * @description Add input to column input stepper input field
+     * @param {number} numberOfColumns Number of columns for the specify columns and rows section table
      */
-    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);
-                    });
-                });
-        });
+    addInputToColumnInputStepper: (numberOfColumns) => {
+        dragAndDropIntoCategoriesPage.inputStepperCountInputField()
+            .eq(0)
+            .type(`{selectAll}${numberOfColumns}`);
     },
 
     /**
-     * @param {number} categoryCellCount count of correct answer category cells
-     * @description verify the count of correct answer category cells present in the correct answer section
+     * @description Add input to column input stepper input field
+     * @param {number} numberOfRows Number of rows for the specify columns and rows section table
      */
-    verifyCountOfCorrectAnswerCategoryCells: (categoryCellCount) => {
-        dragAndDropIntoCategoriesPage.correctAnswerCategoryCell()
-            .should('have.length', categoryCellCount)
+    addInputToRowInputStepper: (numberOfRows) => {
+        dragAndDropIntoCategoriesPage.inputStepperCountInputField()
+            .eq(1)
+            .type(`{selectAll}${numberOfRows}`);
     },
 
-    verifyCorrectAttemptBorder: () => {
-        dragAndDropIntoCategoriesPage.correctIncorrectAnswerBorder()
-            .should('have.css', 'border-width', '1px')
-            .and('have.css', 'border-style', 'solid')
-            .and('have.css', 'border-color', `${css.color.correctAnswer}`);
+    verifyRowInputStepperIncreaseButtonIsDisabled: () => {
+        utilities.verifyElementDisabled(dragAndDropIntoCategoriesPage.inputStepperIncreaseButton().eq(1));
     },
 
-    verifyIncorrectAttemptBorder: () => {
-        dragAndDropIntoCategoriesPage.correctIncorrectAnswerBorder()
-            .should('have.css', 'border-width', '1px')
-            .and('have.css', 'border-style', 'solid')
-            .and('have.css', 'border-color', `${css.color.incorrectAnswer}`);
+    verifyColumnInputStepperDecreaseButtonIsDisabled: () => {
+        utilities.verifyElementDisabled(dragAndDropIntoCategoriesPage.inputStepperDecreaseButton().eq(0));
     },
 
-    verifyCorrectIncorrectBorderNotVisible: () => {
-        dragAndDropIntoCategoriesPage.correctIncorrectAnswerBorder()
-            .should('have.css', 'border-style', 'none');
+    checkSetFirstColumnCellsAsHeadingCheckbox: () => {
+        dragAndDropIntoCategoriesPage.setFirstColumnCellsAsHeadingCheckbox()
+            .click();
+        dragAndDropIntoCategoriesPage.setFirstColumnCellsAsHeadingCheckbox()
+            .should('have.class', 'Mui-checked');
     },
 
-    /**
-     * @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');
-            })
+    uncheckSetFirstColumnCellsAsHeadingCheckbox: () => {
+        dragAndDropIntoCategoriesPage.setFirstColumnCellsAsHeadingCheckbox()
+            .click();
+        dragAndDropIntoCategoriesPage.steps.verifySetFirstColumnCellsAsHeadingCheckboxIsUnchecked();
     },
 
-    /**
-     * @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');
-            })
+    verifySetFirstColumnCellsAsHeadingCheckboxIsUnchecked: () => {
+        dragAndDropIntoCategoriesPage.setFirstColumnCellsAsHeadingCheckbox()
+            .should('not.have.class', 'Mui-checked');
     },
 
-    /**
-     * @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}`);
+    checkSetFirstRowCellsAsHeadingCheckbox: () => {
+        dragAndDropIntoCategoriesPage.setFirstRowCellsAsHeadingCheckbox()
+            .click();
+        dragAndDropIntoCategoriesPage.steps.verifySetFirstRowCellsAsHeadingCheckboxIsChecked();
     },
 
-    verifyCorrectAnswerSectionNotVisible: () => {
-        dragAndDropIntoCategoriesPage.correctAnswerContainer()
-            .should('not.visible');
+    verifySetFirstRowCellsAsHeadingCheckboxIsChecked: () => {
+        dragAndDropIntoCategoriesPage.setFirstRowCellsAsHeadingCheckbox()
+            .should('have.class', 'Mui-checked');
     },
 
-    verifyQuestionPreviewStateWhenShowCorrectAnswerIsUnchecked: () => {
-        cy.log('After deselecting Show correct answer checkbox, the question preview should return to the previous state');
-        previewScoringAndShowCorrectAnswerComponent.steps.uncheckShowCorrectAnswerCheckbox();
-        autoScoredPreviewBase.correctIcon()
-            .should('not.exist');
-        autoScoredPreviewBase.incorrectIcon()
-            .should('not.exist');
-        dragAndDropIntoCategoriesPage.correctIncorrectAnswerLabel()
-            .should('not.exist');
-        dragAndDropIntoCategoriesPage.steps.verifyCorrectIncorrectBorderNotVisible();
+    uncheckSetFirstRowCellsAsHeadingCheckbox: () => {
+        dragAndDropIntoCategoriesPage.setFirstRowCellsAsHeadingCheckbox()
+            .click();
+        dragAndDropIntoCategoriesPage.setFirstRowCellsAsHeadingCheckbox()
+            .should('not.have.class', 'Mui-checked');
     },
 
-    resetQuestionPreview: () => {
-        cy.log('Switching to edit tab and back to preview tab to reset the question preview')
-        dragAndDropIntoCategoriesPage.steps.switchToEditTab();
-        dragAndDropIntoCategoriesPage.steps.switchToPreviewTab();
+    /**
+     * @description Verify that cell property is displayed in cell
+     * @param {number} cellIndex Index of cell
+     */
+    verifyCellPropertyMenuButtonIsDisplayedInACell: (cellIndex) => {
+        dragAndDropIntoCategoriesPage.tableCellContainer()
+            .eq(cellIndex)
+            .within(() => {
+                utilities.verifyElementVisibilityState(dragAndDropIntoCategoriesPage.editCellPropertyButton(), 'visible');
+            });
     },
 
-    verifyCorrectAnswersLabel: () => {
-        dragAndDropIntoCategoriesPage.correctAnswerContainer()
-            .should('contain', 'Correct answers:')
-            .and('be.visible');
+    /**
+     * @param {number} categoryIndex optionIndex of the category cell in set correct answer section
+     * @param {string[]} responseArray array of options set as correct responses in a category cell
+     */
+    verifyDraggableOptionInDropzoneOfPreviewTab: (dropzoneIndex, responseArray) => {
+        dragAndDropIntoCategoriesPage.dropzoneCellPreviewTab()
+            .eq(dropzoneIndex)
+            .within(() => {
+                responseArray.forEach((response, count) => {
+                    utilities.verifyTextContent(utilities.getNthElement(dragAndDropIntoCategoriesPage.draggableOption(), count), response);
+                });
+            });
     },
 
-    verifyCorrectIncorrectCellBorderNotExists: () => {
-        dragAndDropIntoCategoriesPage.correctIncorrectCellBorder()
-            .should('not.exist');
-        dragAndDropIntoCategoriesPage.checkCellIcon()
-            .should('not.exist');
+    /**    
+    * @description Verifies that the equation text in the Preview tab is correct.
+    * @param {number} optionIndex - The index of the option in the Preview tab.
+    */
+    verifyDraggableOptionWithEquationTextInPreviewTab: (optionIndex) => {
+        dragAndDropIntoCategoriesPage.optionsContainerPreviewTab()
+            .within(() => {
+                draggableOptionContainer.draggableOption()
+                    .eq(optionIndex)
+                    .find('[role="math"]')
+                    .should('have.attr', 'aria-label', constants.CKEditorInputFieldEnteredEquationAriaLabel)
+                    .contains(constants.CKEditorInputFieldEnteredEquationText);
+                utilities.verifyElementVisibilityState(utilities.getNthElement(draggableOptionContainer.draggableOptionDragIcon(), optionIndex), '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)
+     * @param {number} categoryIndex optionIndex of the dropzone in set correct answer section
+     * @param {string[]} responseArray array of options set as correct responses in a dropzone
+     * @description Verify the cell properties menu list
+     * @param {number} cellIndex Index of cell in specify columns and rows table
+     */
+    verifyCellPropertyMenuList: (cellIndex) => {
+        dragAndDropIntoCategoriesPage.editCellPropertyButton()
+            .eq(cellIndex)
+            .click();
+        cellPropertyMenuOptions.forEach((cellProperty, index) => {
+            utilities.verifyTextContent(dragAndDropIntoCategoriesPage.editCellPropertyListOption().eq(index), `${cellProperty}`);
+        });
+        //Close the list
+        dragAndDropIntoCategoriesPage.editCellPropertyListOption()
+            .eq(0)
             .click();
-        draggableOptionsContainer.setCorrectAnswerDraggableOptionsWrapper('drag and drop into categories')
-            .find('[class*="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()
+     * @description Verify the text in heading cell input field
+     * @param {number} cellIndex Index of cell in specify columns and rows table
+     * @param {string} text Text to be verified
+     */
+    verifyHeadingCellTypeInputFieldText: (cellIndex, text) => {
+        dragAndDropIntoCategoriesPage.tableCellContainer()
+            .eq(cellIndex)
             .within(() => {
-                draggableOptionsContainer.draggableOption()
-                    .contains(optionName)
-                    .click();
+                utilities.verifyTextContent(dragAndDropIntoCategoriesPage.cellHeadingTextArea(), `${text}`);
             });
-        draggableOptionsContainer.previewTabDraggableOptionsWrapper('drag and drop into categories')
-            .find('[class*="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()
+     * @description Verify the text in subheading cell input field
+     * @param {number} cellIndex Index of cell in specify columns and rows table
+     * @param {string} text Text to be verified
+     */
+    verifySubheadingCellTypeInputFieldText: (cellIndex, text) => {
+        dragAndDropIntoCategoriesPage.tableCellContainer()
+            .eq(cellIndex)
             .within(() => {
-                draggableOptionsContainer.draggableOption()
-                    .contains(optionName)
-                    .click();
+                utilities.verifyTextContent(dragAndDropIntoCategoriesPage.cellSubheadingTextArea(), `${text}`);
             });
-        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()
+     * @param {number} categoryIndex optionIndex of the category cell in set correct answer section
+     * @param {string[]} responseArray array of options set as correct responses in a category cell
+     */
+    verifyDraggableOptionInDropzoneOfPreviewTab: (dropzoneIndex, responseArray) => {
+        dragAndDropIntoCategoriesPage.dropzoneCellPreviewTab()
+            .eq(dropzoneIndex)
             .within(() => {
-                draggableOptionsContainer.draggableOption()
-                    .contains(optionName)
-                    .click();
+                responseArray.forEach((response, count) => {
+                    utilities.verifyTextContent(utilities.getNthElement(draggableOptionContainer.draggableOption(), count), response);
+                });
             });
-        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');
-                });
-        });
+    /**
+     * @description Verify the text in text type cell input field
+     * @param {number} cellIndex Index of cell in specify columns and rows table
+     * @param {string} text Text to be verified
+     */
+    verifyTextCellTypeInputFieldText: (cellIndex, text) => {
+        dragAndDropIntoCategoriesPage.tableCellContainer()
+            .eq(cellIndex)
+            .within(() => {
+                utilities.verifyTextContent(dragAndDropIntoCategoriesPage.cellTextTextArea(), `${text}`);
+            });
     },
 
-    verifyIncorrectCellCrossmarkIcon: (categoryCellIndexArray) => {
-        categoryCellIndexArray.forEach((cellIndex) => {
-            dragAndDropIntoCategoriesPage.correctIncorrectCellBorder()
-                .eq(cellIndex)
-                .within(() => {
-                    dragAndDropIntoCategoriesPage.checkCellIcon()
-                        .should('have.class', 'icon-incorrect')
-                        .and('be.visible');
-                });
-        });
+    /**
+    * Verify the text content of a table cell in the preview tab.
+    * @param { number } cellIndex - The index of the table cell to verify.
+    * @param { string } textContent - The expected text content of the table cell.
+    */
+    verifyTextContentOfTableCellPreviewTab: (cellIndex, textContent) => {
+        utilities.verifyTextContent(utilities.getNthElement(dragAndDropIntoCategoriesPage.cellContainerPreviewTab(), cellIndex), textContent);
     },
 
-    verifyOptionsErrorMessageIsDisplayed: (index) => {
-        optionsWrapperComponent.optionsSectionWrapper()
+    /**
+   * Verify the text content of a table cell in the preview tab.
+   * @param {number} cellIndex - The index of the table cell to verify.
+   * @param {string} textContent - The expected text content of the table cell.
+   */
+    verifyTextContentOfTableCellSpecifyCorrectAnswer: (cellIndex, textContent) => {
+        utilities.verifyTextContent(utilities.getNthElement(dragAndDropIntoCategoriesPage.cellContainerSpecifyCorrectAnswer(), cellIndex), textContent);
+    },
+
+    /**
+     * Clicks on the specified draggable option in the category grid preview tab
+     * and drops it onto the specified dropzone in the same tab.
+     * @param {string} optionText - The text content of the draggable option to be clicked.
+     * @param {number} dropzoneIndex - The index of the dropzone to drop the option into.
+     * @example - clickAndDropOptionFromOneDropzoneToOtherPreviewTab('Bat', 0);
+     */
+    clickAndDropOptionFromOneDropzoneToOtherPreviewTab: (optionText, dropzoneIndex) => {
+        dragAndDropIntoCategoriesPage.categoryGridPreviewTab()
             .within(() => {
-                optionsWrapperComponent.optionWrapper()
-                    .eq(index)
-                    .within(() => {
-                        commonComponents.errorMessage()
-                            .should('have.text', 'Error: Option is required.');
-                    });
+                draggableOptionContainer.draggableOption()
+                    .contains(optionText)
+                    .click();
             });
+        dragAndDropIntoCategoriesPage.dropzoneCellPreviewTab()
+            .eq(dropzoneIndex)
+            .click({ force: true });
     },
 
-    verifyOptionsErrorMessageIsNotDisplayed: (index) => {
-        optionsWrapperComponent.optionsSectionWrapper()
+    /**
+     * @description Verify the text in subheading cell input field
+     * @param {number} cellIndex Index of cell in specify columns and rows table
+     * @param {string} text Text to be verified
+     */
+    verifySubheadingCellTypeInputFieldText: (cellIndex, text) => {
+        dragAndDropIntoCategoriesPage.tableCellContainer()
+            .eq(cellIndex)
             .within(() => {
-                optionsWrapperComponent.optionWrapper()
-                    .eq(index)
-                    .within(() => {
-                        commonComponents.errorMessage()
-                            .should('not.exist');
-                    });
+                utilities.verifyTextContent(dragAndDropIntoCategoriesPage.cellSubheadingTextArea(), `${text}`);
             });
     },
 
-    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);
+    /**
+     * @description Verify the text in text type cell input field
+     * @param {number} cellIndex Index of cell in specify columns and rows table
+     * @param {string} text Text to be verified
+     */
+    verifyTextCellTypeInputFieldText: (cellIndex, text) => {
+        dragAndDropIntoCategoriesPage.tableCellContainer()
+            .eq(cellIndex)
+            .within(() => {
+                utilities.verifyTextContent(dragAndDropIntoCategoriesPage.cellTextTextArea(), `${text}`);
+            });
     },
 
-    verifyEmptyStateOfCategoryCellInSetCorrectAnswerSection: (cellIndex) => {
-        dragAndDropIntoCategoriesPage.setCorrectAnswerSectionCategoryCell()
+    /**
+     * @description Verify the placeholder in text type cell input field
+     * @param {number} cellIndex Index of cell in specify columns and rows table
+     * @param {string} placeholder placeholder text to be verified
+     */
+    verifyTextCellTypeInputFieldPlaceholderText: (cellIndex, placeholder) => {
+        dragAndDropIntoCategoriesPage.tableCellContainer()
             .eq(cellIndex)
-            .should('have.text', '');
+            .within(() => {
+                dragAndDropIntoCategoriesPage.cellTextTextArea()
+                    .should('have.attr', 'placeholder', `${placeholder}`)
+            });
     },
 
-    verifyEmptyStateOfCategoryCellInPreviewTab: (cellIndex) => {
-        dragAndDropIntoCategoriesPage.previewTabCategoryCell()
+    /**
+     * @description Verify the text displayed in specify correct answer table cell
+     * @param {number} cellIndex Index of cell in specify correct answer table
+     * @param {*} cellLabel text to be verified in cell
+     */
+    verifyCellLabelInSpecifyCorrectAnswer: (cellIndex, cellLabel) => {
+        dragAndDropIntoCategoriesPage.tableCellContainerSpecifyCorrectAnswerSection()
             .eq(cellIndex)
-            .should('have.text', '');
+            .within(() => {
+                utilities.verifyInnerText(dragAndDropIntoCategoriesPage.tableCellLabel(), `${cellLabel}`);
+            });
     },
 
     /**
-     * @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
+     * @description Verify the text displayed in preview tab table cell
+     * @param {number} cellIndex Index of cell in preview tab table
+     * @param {*} cellLabel text to be verified in cell
      */
-    verifyDraggableOptionInCategoryCellOfPreviewTab: (categoryIndex, responseArray) => {
-        dragAndDropIntoCategoriesPage.previewTabCategoryCell()
-            .eq(categoryIndex)
+    verifyCellLabelInPreviewTabTable: (cellIndex, cellLabel) => {
+        dragAndDropIntoCategoriesPage.cellContainerPreviewTab()
+            .eq(cellIndex)
             .within(() => {
-                responseArray.forEach((response, count) => {
-                    draggableOptionsContainer.draggableOption()
-                        .eq(count)
-                        .verifyInnerText(response);
-                });
+                utilities.verifyInnerText(dragAndDropIntoCategoriesPage.tableCellLabel(), `${cellLabel}`);
             });
     },
 
-    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()
+    clickOnLeftArrowNavigationButton: () => {
+        dragAndDropIntoCategoriesPage.leftArrowNavigationButton()
             .click();
-        optionsWrapperComponent.addOptionButton()
+    },
+    clickOnLeftArrowNavigationButtonSpecifyCorrectAnswerSection: () => {
+        dragAndDropIntoCategoriesPage.leftArrowNavigationButtonSpecifyCorrectAnswerSection()
             .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');
+    clickOnRightArrowNavigationButton: () => {
+        dragAndDropIntoCategoriesPage.rightArrowNavigationButton()
+            .click();
     },
 
-    verifyActiveStateOfAllCategoryCellsInSetCorrectAnswerSection: () => {
-        dragAndDropIntoCategoriesPage.setCorrectAnswerSectionCategoryGrid()
-            .should('have.class', 'active-area-on-tap');
+    clickOnRightArrowNavigationButtonSpecifyCorrectAnswerSection: () => {
+        dragAndDropIntoCategoriesPage.rightArrowNavigationButtonSpecifyCorrectAnswerSection()
+            .click();
     },
 
-    verifyInactiveStateOfAllCategoryCellsInPreviewTab: () => {
-        dragAndDropIntoCategoriesPage.previewTabCategoryGrid()
-            .should('not.have.class', 'active-area-on-tap');
+    /**
+     * @description Verify column is visible in the specify columns and rows section table
+     * @param {number} columnIndex Index of the column
+     */
+    verifyColumnIsVisibleInSpecifyColumnsAndRowsTable: (columnIndex) => {
+        utilities.verifyElementVisibilityState(dragAndDropIntoCategoriesPage.tableCellContainer().eq(columnIndex), 'visible');
     },
 
-    verifyActiveStateOfAllCategoryCellsInPreviewTab: () => {
-        dragAndDropIntoCategoriesPage.previewTabCategoryGrid()
-            .should('have.class', 'active-area-on-tap');
+    /**
+     * @description Verify column is visible in the specify correct answers section table
+     * @param {number} columnIndex Index of the column
+     */
+    verifyColumnIsVisibleInTableSpecifyCorrectAnswer: (columnIndex) => {
+        utilities.verifyElementVisibilityState(dragAndDropIntoCategoriesPage.tableCellContainerSpecifyCorrectAnswerSection().eq(columnIndex), '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 set correct answer section
+     * @description Verify column is not visible in the specify columns and rows section table
+     * @param {number} columnIndex Index of the column
      */
-    verifyDragHandleNotVisibleInFilledCategoryCellOfSetCorrectAnswerSection: (responseAreaIndex) => {
-        dragAndDropIntoCategoriesPage.setCorrectAnswerSectionCategoryCell()
-            .eq(responseAreaIndex)
-            .within(() => {
-                draggableOptionsContainer.draggableOptionDragIcon()
-                    .should('not.be.visible');
-            });
+    verifyColumnIsNotVisibleInSpecifyColumnsAndRowsTable: (columnIndex) => {
+        utilities.verifyElementVisibilityState(dragAndDropIntoCategoriesPage.tableCellContainer().eq(columnIndex), 'hidden');
     },
 
     /**
-     * @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
+     * @description Verify column is not visible in the specify correct answers section table
+     * @param {number} columnIndex Index of the column
      */
-    verifyDragHandleNotVisibleInFilledCategoryCellOfPreviewTab: (responseAreaIndex) => {
-        dragAndDropIntoCategoriesPage.previewTabCategoryCell()
-            .eq(responseAreaIndex)
-            .within(() => {
-                draggableOptionsContainer.draggableOptionDragIcon()
-                    .should('not.be.visible');
-            });
+    verifyColumnIsNotVisibleInTableSpecifyCorrectAnswer: (columnIndex) => {
+        utilities.verifyElementVisibilityState(dragAndDropIntoCategoriesPage.tableCellContainerSpecifyCorrectAnswerSection().eq(columnIndex), 'hidden');
     },
 
-    /**
-     * @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()
+    verifyColumnInputStepperIncreaseDecreaseButton: () => {
+        dragAndDropIntoCategoriesPage.columnsInputStepperWrapper()
             .within(() => {
-                draggableOptionsContainer.draggableOption()
-                    .contains(optionName)
-                    .click();
+                utilities.verifyElementVisibilityState(dragAndDropIntoCategoriesPage.inputStepperIncreaseButton(), 'visible');
+                utilities.verifyElementVisibilityState(dragAndDropIntoCategoriesPage.inputStepperDecreaseButton(), 'visible');
             });
     },
 
-    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 });
+    verifyRowInputStepperIncreaseDecreaseButton: () => {
+        dragAndDropIntoCategoriesPage.rowsInputStepperWrapper()
+            .within(() => {
+                utilities.verifyElementVisibilityState(dragAndDropIntoCategoriesPage.inputStepperIncreaseButton(), 'visible');
+                utilities.verifyElementVisibilityState(dragAndDropIntoCategoriesPage.inputStepperDecreaseButton(), 'visible');
+            });
     },
 
     /**
-     * @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
+    * @param {("All or nothing" | "Per dropzone" | "Per correct option")} scoringSubtype option from the scoring subtype radio buttons
+    * @description this function selects scoring subtype from the scoring section
     */
-    clickOnDraggableOptionInCategoryCellOfPreviewTab: (optionName) => {
-        dragAndDropIntoCategoriesPage.previewTabCategoryGrid()
-            .within(() => {
-                draggableOptionsContainer.draggableOption()
-                    .contains(optionName)
+    selectAutoScoredScoringSubtype: (scoringSubtype) => {
+        switch (scoringSubtype.toLowerCase()) {
+            case 'all or nothing':
+                autoScoredScoringSectionMultiResponseType.allOrNothingRadioButton()
                     .click();
-            });
+                break;
+            case 'per dropzone':
+                dragAndDropIntoCategoriesPage.perDropzoneRadioButton()
+                    .click();
+                break;
+            case 'per correct option':
+                dragAndDropIntoCategoriesPage.perCorrectOptionRadioButton()
+                    .click();
+                break;
+            default:
+                throw new Error(`Invalid auto scored scoring subtype: ${scoringSubtype}`);
+        }
     },
 
     /**
-     * Verifies the numeration of correct answer container category cells.
-     * @param {Array<string>} categoryCellIndexArray - An array of expected numeration values for category cells.
+     * Verifies correct and incorrect icons for drop zones based on the provided mapping.
+     * @param {Object} statusDropzoneIndexMapping - An object where keys represent the status ('correct' or 'incorrect') and values are drop zone indices.
+     * @example - verifyCorrectIncorrectIconsForDropzone({'correct': 1, incorrect': 3});
      * @returns {void}
      */
-    verifyCorrectAnswerContainerNumeration: (categoryCellIndexArray) => {
-        categoryCellIndexArray.forEach((categoryCellNumeration, index) => {
-            dragAndDropIntoCategoriesPage.correctAnswerCategoryCell()
-                .eq(index)
+    verifyCorrectIncorrectIconsForDropzone: (statusDropzoneIndexMapping) => {
+        Object.entries(statusDropzoneIndexMapping).forEach(([status, dropzoneIndex]) => {
+            dragAndDropIntoCategoriesPage.dropzoneCellNumeration()
+                .eq(dropzoneIndex)
                 .within(() => {
-                    dragAndDropIntoCategoriesPage.categoryCellNumeration()
-                        .should('have.text', `${categoryCellNumeration}`);
+                    const iconElement = (status === 'correct') ? autoScoredScoringPreviewTab.correctIcon() : autoScoredScoringPreviewTab.incorrectIcon();
+                    utilities.verifyElementVisibilityState(iconElement, 'visible');
                 });
         });
     },
 
     /**
-     * Enters text into the row title width input field.
-     * @param {string} text - The text to be entered into the row input field.
-     * @returns {void}
+     * @param {string} optionText aria label of the option to be selected
+     * @description this function selects an option from penalty scoring dropdown and verifies its disability state
      */
-    enterTextInRowTitleWidthInputField: (text) => {
-        dragAndDropIntoCategoriesPage.rowTitleWidthInputField()
-            .type(text)
-            .blur();
+    verifyPenaltyScoringDropdownOptionIsDisabled: (optionText) => {
+        autoScoredScoringSectionMultiResponseType.penaltyScoringDropdownListOptions(optionText)
+            .should('have.attr', 'aria-disabled', 'true');
     },
 
-    clearTextInRowTitleWidthInputField: () => {
-        dragAndDropIntoCategoriesPage.rowTitleWidthInputField()
-            .clear();
+    /**
+    * @param {string} optionText aria label of the option to be selected
+    * @description this function selects an option from penalty scoring dropdown and verifies its enabled state
+    */
+    verifyPenaltyScoringDropdownOptionIsEnabled: (optionText) => {
+        autoScoredScoringSectionMultiResponseType.penaltyScoringDropdownListOptions(optionText)
+            .should('have.attr', 'aria-disabled', 'false');
     },
 
     /**
-     * Verifies the value of the row title width input field.
-     * @param {string} width - The expected width value to compare against.
-     * @returns {void}
+     * @param {number} points value of total points 
+     * @description this function verifies total points value when pre dropzone is selected
      */
-    verifyRowTitleWidthInputFieldValue: (width) => {
-        dragAndDropIntoCategoriesPage.rowTitleWidthInputField()
-            .should('have.attr', 'value', width)
+    verifyTotalPointsValue: (points) => {
+        utilities.verifyInnerText(dragAndDropIntoCategoriesPage.totalPointsValue(), points)
     },
 
-    /**
-     * 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)
-            .blur();
+    addRow: () => {
+        dragAndDropIntoCategoriesPage.addRowButton()
+            .click();
     },
 
-    clearTextInRowMinHeightInputField: () => {
-        dragAndDropIntoCategoriesPage.rowMinHeightInputField()
-            .clear();
+    addColumn: () => {
+        dragAndDropIntoCategoriesPage.addColumnButton()
+            .click();
     },
 
-    /**
-     * Verifies the value of the row minimum height input field.
-     * @param {string} value - The expected row minimum height value to compare against.
-     * @returns {void}
+    deleteRow: () => {
+        dragAndDropIntoCategoriesPage.deleteRowButton()
+            .click();
+    },
+
+    deleteColumn: () => {
+        dragAndDropIntoCategoriesPage.deleteColumnButton()
+            .click();
+    },
+
+    verifyPerCorrectOptionRadioButtonIsUnchecked: () => {
+        dragAndDropIntoCategoriesPage.perCorrectOptionRadioButton()
+            .should('not.be.checked');
+    },
+
+    verifyPerDropzoneRadioButtonIsUnchecked: () => {
+        dragAndDropIntoCategoriesPage.perDropzoneRadioButton()
+            .should('not.be.checked');
+    },
+
+    /*
+     * Allots penalty points for each incorrect dropzone by setting the specified points in the corresponding input field.
+     * @param {number} points - The penalty points to be allotted for each incorrect dropzone.
      */
-    verifyRowMinHeightInputFieldValue: (value) => {
-        dragAndDropIntoCategoriesPage.rowMinHeightInputField()
-            .should('have.attr', 'value', value)
+    allotPenaltyPointsForEachIncorrectDropzone: (points) => {
+        dragAndDropIntoCategoriesPage.penaltyPointsForIncorrectDropzoneInputField()
+            .clear()
+            .type(points)
+            .should('have.value', points)
     },
 
     /**
-     * Enters text into the row heading input field.
-     * @param {string} text - The text to be entered into the row heading input field.
-     * @returns {void}
+     * @description Verify penalty points for each incorrect dropzone input field value.
+     * @param {number} points - The penalty points for each incorrect dropzone input field
      */
-    enterTextInRowHeadingInputField: (text) => {
-        dragAndDropIntoCategoriesPage.rowHeadingInputField()
-            .type(text, { delay: 0 })
-            .blur();
+    verifyPenaltyPointsForEachIncorrectDropzone: (points) => {
+        dragAndDropIntoCategoriesPage.penaltyPointsForIncorrectDropzoneInputField()
+            .should('have.value', points)
     },
 
-    clearTextInRowHeadingInputField: () => {
-        dragAndDropIntoCategoriesPage.rowHeadingInputField()
-            .clear();
+    /**
+     * Allots penalty points for each incorrect option by setting the specified points in the corresponding input field.
+     * @param {number} points - The penalty points to be allotted for each incorrect option.
+     */
+    allotPenaltyPointsForEachIncorrectOption: (points) => {
+        dragAndDropIntoCategoriesPage.penaltyPointsForIncorrectOptionInputField()
+            .clear()
+            .type(points)
+            .should('have.value', points)
     },
 
     /**
-     * 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)
+    * @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
+    */
+    verifyDragHandleNotVisibleInFilledDropzoneCellOfSpecifyCorrectAnswerSection: (responseAreaIndex) => {
+        dragAndDropIntoCategoriesPage.dropzoneCellSpecifyCorrectAnswerSection()
+            .eq(responseAreaIndex)
+            .within(() => {
+                draggableOptionContainer.draggableOptionDragIcon()
+                    .should('not.be.visible');
+            });
     },
 
     /**
-     * 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);
+    * @param {number} responseAreaIndex Index of the stem response area in preview tab
+    * @description Verify drag handle is not visible in filled category cell in preview tab
+    */
+    verifyDragHandleNotVisibleInFilledDropzoneCellOfPreviewTab: (responseAreaIndex) => {
+        dragAndDropIntoCategoriesPage.dropzoneCellPreviewTab()
+            .eq(responseAreaIndex)
+            .within(() => {
+                draggableOptionContainer.draggableOptionDragIcon()
+                    .should('not.be.visible');
             });
     },
 
     /**
-     * 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);
+    * @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
+    */
+    verifyDraggableOptionInDropzoneCellOfSpecifyCorrectAnswerSection: (categoryIndex, responseArray) => {
+        dragAndDropIntoCategoriesPage.dropzoneCellSpecifyCorrectAnswerSection()
+            .eq(categoryIndex)
+            .within(() => {
+                responseArray.forEach((response, count) => {
+                    draggableOptionContainer.draggableOption()
+                        .eq(count)
+                        .verifyInnerText(response);
+                });
             });
     },
 
     /**
-     * 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}
+     * 
+     * @param { number } points - The penalty points for each incorrect option input field
      */
-    verifyRowMinHeightSetCorrectAnswerSection: (expectedMinHeight) => {
-        dragAndDropIntoCategoriesPage.setCorrectAnswerSectionCategoryCell()
-            .parents('[class*="RowContainer"]')
-            .should(($element) => {
-                const minHeight = parseFloat($element.css('min-height'));
-                expect(minHeight).to.be.equal(expectedMinHeight);
+    verifyPenaltyPointsForEachIncorrectOption: (points) => {
+        dragAndDropIntoCategoriesPage.penaltyPointsForIncorrectOptionInputField()
+            .should('have.value', points)
+    },
+
+    clickAndDropOptionFromDropzoneToOptionContainerSpecifyCorrectAnswerSection: (optionText) => {
+        dragAndDropIntoCategoriesPage.categoryGridSpecifyCorrectAnswerSection()
+            .within(() => {
+                draggableOptionContainer.draggableOption()
+                    .contains(optionText)
+                    .click();
             });
+        draggableOptionContainer.optionContainerItemListSpecifyCorrectAnswerSection().first()
+            .click({ force: true });
+    },
+
+    clickAndDropOptionFromDropzoneToOptionContainerPreviewTab: (optionText) => {
+        dragAndDropIntoCategoriesPage.categoryGridPreviewTab()
+            .within(() => {
+                draggableOptionContainer.draggableOption()
+                    .contains(optionText)
+                    .click();
+            });
+        draggableOptionContainer.optionContainerItemListPreviewTab().first()
+            .click({ force: true });
     },
 
     /**
-     * Verifies the minimum height of a row in the 'Preview tab'.
-     * @param {number} expectedMinHeight - The expected minimum height value to compare against.
-     * @returns {void}
+     * @param {number} categoryIndex optionIndex of the dropzone in set correct answer section
+     * @param {string[]} responseArray array of options set as correct responses in a dropzone
      */
-    verifyRowMinHeightPreviewTab: (expectedMinHeight) => {
-        dragAndDropIntoCategoriesPage.previewTabCategoryCell()
-            .parents('[class*="RowContainer"]')
-            .should(($element) => {
-                const minHeight = parseFloat($element.css('min-height'));
-                expect(minHeight).to.be.equal(expectedMinHeight);
+    verifyDraggableOptionInDropzoneOfSpecifyCorrectAnswerSection: (dropzoneIndex, responseArray) => {
+        dragAndDropIntoCategoriesPage.dropzoneCellSpecifyCorrectAnswerSection()
+            .eq(dropzoneIndex)
+            .within(() => {
+                responseArray.forEach((response, count) => {
+                    utilities.verifyTextContent(utilities.getNthElement(draggableOptionContainer.draggableOption(), count), response);
+                });
             });
     },
 
     /**
-     * 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();
+     * @param {string} optionName denotes the text content of the draggable option
+     * @param {number} dropzoneIndex - The index of the dropzone. 
+     * @description click on a draggable option present in the category cell of specify correct answer section
+    */
+    clickOnDraggableOptionInDropzoneCellOfSpecifyCorrectAnswerSection: (optionName, dropzoneIndex) => {
+        dragAndDropIntoCategoriesPage.dropzoneCellSpecifyCorrectAnswerSection()
+            .eq(dropzoneIndex)
+            .within(() => {
+                draggableOptionContainer.draggableOption()
+                    .contains(optionName)
+                    .click();
+            });
     },
 
-    clearMaxResponsePerCellInputField: () => {
-        dragAndDropIntoCategoriesPage.maxResponsePerCellInputField()
-            .clear()
-            .blur();
+    clickOnDropzoneCellInDropzoneOfPreviewTab: (categoryIndex) => {
+        dragAndDropIntoCategoriesPage.dropzoneCellPreviewTab()
+            .eq(categoryIndex)
+            .click({ force: true });
     },
 
     /**
-     * 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)
+     * @param {string} optionName denotes the text content of the draggable option 
+     * @param {number} dropzoneIndex - The index of the dropzone. 
+     * @description click on a draggable option present in the category cell of preview tab
+    */
+    clickOnDraggableOptionInDropzoneCellOfPreviewTab: (optionName, dropzoneIndex) => {
+        dragAndDropIntoCategoriesPage.dropzoneCellPreviewTab()
+            .eq(dropzoneIndex)
+            .within(() => {
+                draggableOptionContainer.draggableOption()
+                    .contains(optionName)
+                    .click();
+            });
     },
 
-    clickOnResponseOptionPlacementDropdown: () => {
-        dragAndDropIntoCategoriesPage.responseOptionPlacementDropdown()
-            .click();
+    clickOnDropzoneCellInDropzoneOfSpecifyCorrectAnswerSection: (categoryIndex) => {
+        dragAndDropIntoCategoriesPage.dropzoneCellSpecifyCorrectAnswerSection()
+            .eq(categoryIndex)
+            .click({ force: true });
     },
 
-    /**
-     * 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();
+    verifyEmptyStateOfDropzoneCellInSpecifyCorrectAnswerSection: (cellIndex) => {
+        dragAndDropIntoCategoriesPage.dropzoneCellSpecifyCorrectAnswerSection()
+            .eq(cellIndex)
+            .should('have.text', '');
     },
 
-    verifyResponseOptionPlacementDropdownOptions: () => {
-        let dropdownOptions = ['Top', 'Bottom', 'Left', 'Right'];
-        dragAndDropIntoCategoriesPage.responseOptionPlacementDropdownListOption()
-            .each(($el, index) => {
-                cy.wrap($el)
-                    .should('have.text', dropdownOptions[index]);
-            });
+    setGroupedOptions: () => {
+        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'];
+        draggableOptionsSectionComponent.steps.expandDraggableOptionsLayoutDropdown()
+        draggableOptionsSectionComponent.steps.selectOptionFromDraggableOptionsLayoutDropdown('Grouped')
+        draggableOptionsSectionComponent.steps.addGroupTitle(groupTitles[0]);
+        optionsWrapperComponent.steps.addMultipleOptionFields(2);
+        optionsWrapperComponent.steps.addInputToOptionsInputField(animals[0]);
+        draggableOptionsSectionComponent.steps.addGroupWithTitleAndOptionsInDraggableOptionsSection(groupTitles[1], animals[1]);
+        draggableOptionsSectionComponent.steps.addGroupWithTitleAndOptionsInDraggableOptionsSection(groupTitles[2], animals[2]);
+        draggableOptionsSectionComponent.steps.addGroupWithTitleAndOptionsInDraggableOptionsSection(groupTitles[3], animals[3]);
+    },
+
+    verifyInactiveStateOfAllDropzonesInSpecifyCorrectAnswerSection: () => {
+        dragAndDropIntoCategoriesPage.dropzoneGridSpecifyCorrectAnswerSection()
+            .should('not.have.class', 'active-area-on-tap');
     },
 
-    /**
-     * 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');
-        }
-    }
+    verifyActiveStateOfAllDropzonesInSpecifyCorrectAnswerSection: () => {
+        dragAndDropIntoCategoriesPage.dropzoneGridSpecifyCorrectAnswerSection()
+            .should('have.class', 'active-area-on-tap');
+    },
+
+    verifyInactiveStateOfAllDropzonesInPreviewTab: () => {
+        dragAndDropIntoCategoriesPage.dropzoneGridPreviewTab()
+            .should('not.have.class', 'active-area-on-tap');
+    },
+
+    verifyActiveStateOfAllDropzonesInPreviewTab: () => {
+        dragAndDropIntoCategoriesPage.dropzoneGridPreviewTab()
+            .should('have.class', 'active-area-on-tap');
+    },
 }
 
 const tests = {
+    ...autoScoredScoringPreviewTab.tests,
+    ...allowMultipleInstancesOfSameDraggableOptionComponent.tests,
+    ...randomizeOptionsComponent.tests,
+    ...studentViewSettingsLabelComponent.tests,
+    ...autoScoredStudentViewSettings.tests,
+    ...autoScoredSpecifyCorrectAnswerSection.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,
+    ...scoringSectionBaseEditTab.tests,
+    ...optionsWrapperComponent.tests,
+    ...draggableOptionsSectionComponent.tests,
+    ...draggableOptionContainer.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');
+    ...autoScoredScoringSectionMultiResponseType.tests,
+    ...enableOuterBorderComponent.tests,
+
+    verifyContentsOfSpecifyCorrectAnswerSection: (scoringType) => {
+        it(`When the user selects ${scoringType} from scoring type dropdown then the specify correct answer sections should be displayed`, () => {
+            dragAndDropIntoCategoriesPage.steps.verifyTableCellPropertySpecifyCorrectAnswer(0, 'None');
+            utilities.verifyInnerText(utilities.getNthElement(dragAndDropIntoCategoriesPage.cellContainerSpecifyCorrectAnswer(), 0), '');
+            dragAndDropIntoCategoriesPage.steps.verifyTableCellPropertySpecifyCorrectAnswer(1, 'Heading');
+            dragAndDropIntoCategoriesPage.steps.verifyTextContentOfTableCellSpecifyCorrectAnswer(1, 'Mammal');
+            dragAndDropIntoCategoriesPage.steps.verifyTextContentOfTableCellSpecifyCorrectAnswer(2, 'Not mammal');
+            dragAndDropIntoCategoriesPage.steps.verifyTextContentOfTableCellSpecifyCorrectAnswer(3, 'Can fly');
+            dragAndDropIntoCategoriesPage.steps.verifyTableCellPropertySpecifyCorrectAnswer(4, 'Dropzone');
+            dragAndDropIntoCategoriesPage.steps.verifyTableCellPropertySpecifyCorrectAnswer(6, 'Subheading');
+            dragAndDropIntoCategoriesPage.steps.verifyTextContentOfTableCellSpecifyCorrectAnswer(6, 'Can walk');
+            utilities.verifyInnerText(utilities.getNthElement(dragAndDropIntoCategoriesPage.cellContainerSpecifyCorrectAnswer(), 6), 'Can walk');
+            dragAndDropIntoCategoriesPage.steps.verifyTableCellPropertySpecifyCorrectAnswer(9, 'Text');
+            dragAndDropIntoCategoriesPage.steps.verifyTextContentOfTableCellSpecifyCorrectAnswer(9, 'Can swim');
         });
     },
 
     /**
-     * @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
+     * Verifies the contents and functionality of the 'Specify correct answer' accordion for multiple selection questions.
+     * @param {{'Correct' | 'Alternative'}} accordionName - The name of the accordion to be used in the validation.
+     * @example - verifySpecifyCorrectAnswerAccordionContentsAndFunctionality('Correct');
      */
-    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}`);
+    verifySpecifyCorrectAnswerAccordionContentsAndFunctionality: (accordionName) => {
+        it(`The user should be able to  drop an option in the dropzone in the ${accordionName} accordion`, () => {
+            dragAndDropIntoCategoriesPage.steps.clickAndDropOptionInDropzoneSpecifyCorrectAnswerSection({ 'Bat': 0 });
         });
-    },
 
-    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();
+        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`, () => {
+            dragAndDropIntoCategoriesPage.steps.clickAndDropOptionInOptionsContainerInSpecifyCorrectAnswerSection('Bat');
+            utilities.verifyElementVisibilityState(commonComponents.errorMessage(), 'visible')
+            utilities.verifyInnerText(commonComponents.errorMessage(), 'Error: Please set a correct answer.');
+            if (accordionName == 'Correct') {
+                autoScoredSpecifyCorrectAnswerSection.correctAnswerAccordion()
+                    .within(() => {
+                        utilities.verifyElementVisibilityState(autoScoredSpecifyCorrectAnswerSection.specifyCorrectAnswerErrorIcon(), 'visible');
+                    });
+            } else {
+                autoScoredSpecifyCorrectAnswerSection.alternativeAnswerAccordion()
+                    .eq(1)
+                    .within(() => {
+                        utilities.verifyElementVisibilityState(autoScoredSpecifyCorrectAnswerSection.specifyCorrectAnswerErrorIcon(), 'visible');
+                    });
+            };
         });
-    },
 
-    /**
-     * @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.expandMinimumScoringDropdown();
-            scoringSectionBase.steps.selectMinimumScoringTypeListOption('Award minimum score only if attempted');
-            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}`);
-        });
+        autoScoredSpecifyCorrectAnswerSection.tests.verifyAutoScoredCorrectAnswerErrorMessageCSSAndA11y();
 
-        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}`);
+        it('When the user drops an option in the dropzone, the error message should disappear', () => {
+            dragAndDropIntoCategoriesPage.steps.clickAndDropOptionInDropzoneSpecifyCorrectAnswerSection({ 'Eagle': 1 });
         });
-    },
 
-    /**
-     * @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}`);
-        });
-    },
+        autoScoredSpecifyCorrectAnswerSection.tests.verifyAutoScoredPointsErrorMessageWhenPointsFieldIsEmpty(accordionName);
 
-    /**
-     * @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}`);
+        it('When user clicks on right arrow navigation button, then the table should be scrolled to the right by 1 column and left arrow navigation button should be enabled', () => {
+            dragAndDropIntoCategoriesPage.steps.clickOnRightArrowNavigationButtonSpecifyCorrectAnswerSection();
+            dragAndDropIntoCategoriesPage.steps.verifyColumnIsVisibleInTableSpecifyCorrectAnswer(8);
+            utilities.verifyElementNotDisabled(dragAndDropIntoCategoriesPage.leftArrowNavigationButtonSpecifyCorrectAnswerSection());
         });
-    },
 
-    /**
-     * @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 user has scrolled to the rightmost column using the right arrow navigation button, then the table right arrow navigation button should be enabled', () => {
+            for (let index = 9; index < 15; index++) {
+                dragAndDropIntoCategoriesPage.steps.clickOnRightArrowNavigationButtonSpecifyCorrectAnswerSection();
+            }
+            utilities.verifyElementDisabled(dragAndDropIntoCategoriesPage.rightArrowNavigationButtonSpecifyCorrectAnswerSection());
         });
 
-        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.expandRoundingDropdown();
-            dragAndDropIntoCategoriesPage.steps.selectOptionFromRoundingDropdownOption('none');
-            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}`);
+        it('When user clicks on left arrow navigation button, then the table should be scrolled to the left by 1 column and right arrow navigation button should be enabled again', () => {
+            dragAndDropIntoCategoriesPage.steps.clickOnLeftArrowNavigationButtonSpecifyCorrectAnswerSection();
+            dragAndDropIntoCategoriesPage.steps.verifyColumnIsVisibleInTableSpecifyCorrectAnswer(8);
+            dragAndDropIntoCategoriesPage.steps.verifyColumnIsNotVisibleInSpecifyColumnsAndRowsTable(14);
+            utilities.verifyElementNotDisabled(dragAndDropIntoCategoriesPage.leftArrowNavigationButtonSpecifyCorrectAnswerSection());
         });
-    },
 
-    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();
+        it('CSS of \'Correct\' accordion contents', { tags: 'css' }, () => {
+            //Navigation button
+            utilities.verifyCSS(dragAndDropIntoCategoriesPage.leftArrowNavigationButtonSpecifyCorrectAnswerSection().find('path'), {
+                'fill': css.color.nextPreviousButtonFill
+            });
+            utilities.verifyCSS(utilities.getNthElement(dragAndDropIntoCategoriesPage.tableCellContainerSpecifyCorrectAnswerSection(), 15), {
+                'background-color': css.color.defaultBackground,
+                'border-color': css.color.matrixCellBorder
+            });
+            utilities.verifyCSS(utilities.getNthElement(dragAndDropIntoCategoriesPage.tableCellContainerSpecifyCorrectAnswerSection(), 15), {
+                'background-color': css.color.matrixHeadingCellBg,
+                'border-color': css.color.matrixCellBorder
+            });
+            utilities.verifyCSS(utilities.getNthElement(dragAndDropIntoCategoriesPage.tableCellContainerSpecifyCorrectAnswerSection(), 16), {
+                'background-color': css.color.matrixDropzoneCellBg,
+                'border': `1px dashed ${css.color.matrixCellBorder}`
+            });
+            utilities.verifyCSS(utilities.getNthElement(dragAndDropIntoCategoriesPage.tableCellContainerSpecifyCorrectAnswerSection(), 30), {
+                'background-color': css.color.matrixSubheadingCellBg,
+                'border-color': css.color.matrixCellBorder
+            });
+            utilities.verifyCSS(utilities.getNthElement(dragAndDropIntoCategoriesPage.tableCellContainerSpecifyCorrectAnswerSection(), 45), {
+                'background-color': css.color.defaultBackground,
+                'border-color': css.color.matrixCellBorder
+            });
+            utilities.verifyCSS(utilities.getNthElement(dragAndDropIntoCategoriesPage.tableCellLabel(), 16), {
+                'color': css.color.text,
+                'font-size': css.fontSize.heading,
+                'font-weight': css.fontWeight.bold
+            });
+            utilities.verifyCSS(utilities.getNthElement(dragAndDropIntoCategoriesPage.tableCellLabel(), 17), {
+                'color': css.color.text,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.semibold
+            });
+            utilities.verifyCSS(utilities.getNthElement(dragAndDropIntoCategoriesPage.tableCellLabel(), 18), {
+                'color': css.color.text,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
         });
-    },
 
-    //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()
+        it('Accessibility of \'Correct\' accordion contents', { tags: 'a11y' }, () => {
+            cy.checkAccessibility(dragAndDropIntoCategoriesPage.tableCellContainerSpecifyCorrectAnswerSection().parents('.correct-answer-accordion'))
         });
     },
-
-    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
-};
+}