itemengine-cypress-automation 1.0.189-e2e-execution-crash-83cdbd4.0 → 1.0.190-repoUpdate3May-f180558.0

package/cypress/pages/listOrderingPage.js

@@ -1,405 +1,300 @@
 import constants from "../fixtures/constants";
 import utilities from "../support/helpers/utilities";
-import { additionalSettingsPanel, autoScoredAdditionalSettings, autoScoredPreviewBase, autoScoredScoringSection, autoScoredScoringSectionMultipleResponsesType, autoScoredSetCorrectAnswerSection, ckEditorToolbar, commonComponents, createQuestionBasePage, equationEditorFlyout, optionsWrapperComponent, previewScoringAndShowCorrectAnswerComponent, questionInstructionsComponent, scoringSectionBase } from "./components"
-import { answerNumerationComponent } from "./components/answerNumerationComponent";
-import { listSortingAndOrderingBase } from "./components/listSortingAndOrderingBase";
-import { setPointsPopupBase } from "./components/setPointsPopupBase";
-import { studentResponseAndLayoutComponent } from "./components/studentResponseAreaAndLayoutComponent";
+import { autoScoredScoringPreviewTab, autoScoredScoringSectionMultiResponseType, autoScoredSpecifyCorrectAnswerSection, autoScoredStudentViewSettings, commonComponents, correctIncorrectAnswerLabelComponent, createQuestionBasePage, optionsWrapperComponent, questionInstructionsComponent, randomizeOptionsComponent, scoringSectionBaseEditTab, studentViewSettingsLabelComponent, additionalSettingsPanel, additionalSettingsAccessibilitySectionComponent } from "./components"
+const options = ['sprout', 'plant', 'flower', 'seed'];
 const css = Cypress.env('css');
 
 const selectors = {
-    ...commonComponents,
     ...optionsWrapperComponent,
-    ...scoringSectionBase,
-    ...autoScoredScoringSectionMultipleResponsesType,
-    ...autoScoredSetCorrectAnswerSection,
-    ...autoScoredAdditionalSettings,
-    ...previewScoringAndShowCorrectAnswerComponent,
-    ...autoScoredPreviewBase,
-    ...additionalSettingsPanel,
     ...questionInstructionsComponent,
-    ...answerNumerationComponent,
-    ...setPointsPopupBase,
-    ...listSortingAndOrderingBase,
-    //Set correct answer section
-    setCorrectAnswerSectionOption: () => cy.get('.list-ordering-set-correct-answer .draggable-item-wrapper[role="button"]'),
-    setCorrectAnswerSectionOptionsWrapper: () => cy.get('[class*="ListOrderingResponsestyles__DroppableWrapper"]'),
+    ...commonComponents,
+    ...autoScoredScoringSectionMultiResponseType,
+    ...randomizeOptionsComponent,
+    ...autoScoredScoringPreviewTab,
+    ...additionalSettingsPanel,
+    ...correctIncorrectAnswerLabelComponent,
+    ...autoScoredSpecifyCorrectAnswerSection,
+    //Specify correct answer section
+    optionSpecifyCorrectAnswerSection: () => cy.get('.list-ordering-set-correct-answer .draggable-item-wrapper[role="button"]'),
+    optionWrapperSpecifyCorrectAnswerSection: () => cy.get('[class*="ListOrderingResponsestyles__DroppableWrapper"]'),
+    partialDifferentWeightsPointsLabel: () => cy.get('.partial-points-per-response-label'),
+    pointsPerResponseValue: () => cy.get('.alternate-points-points-per-value-span'),
+    //Student view settings
+    enableOuterBorderForQuestionLabel: () => cy.get('[data-ngie-testid*="enable-outer-border-for-question-checkbox"] .MuiFormControlLabel-label'),
+    enableOuterBorderForQuestionCheckbox: () => cy.get('[data-ngie-testid*="enable-outer-border-for-question-checkbox"] input'),
     //Preview Tab
-    pointsPerResponseLabel: () => cy.get('.list-ordering-points-text'),
-    previewTabOption: () => cy.get('.edit-question-preview-wrapper .draggable-item-wrapper[role="button"]'),
-    previewTabOptionsWrapper: () => cy.get('.edit-question-preview-wrapper [class*="ListOrderingResponsestyles__DroppableWrapper"]'),
-    partialEqualWeightsPointsPerResponseScore: () => cy.get('.orderlist-points-wrapper'),
-    partialDifferentWeightsPointsInputField: () => cy.get('.orderlist-points-wrapper input'),
-    partialDifferentWeightsPointsPerResponseLabel: () => cy.get('.list-ordering-points-wrapper'),
-    //Additional Settings
-    optionNumeration: () => cy.get('[class*="__IndexWrapper"]'),
-    setCorrectAnswerSectionTopLabel: () => cy.get('[class*="TopLabelWrapper"].top-bottom-label'),
-    setCorrectAnswerSectionBottomLabel: () => cy.get('[class*="BottomLabelWrapper"].top-bottom-label'),
-    previewTabTopLabel: () => cy.get('.edit-question-preview-wrapper [class*="TopLabelWrapper"].top-bottom-label'),
-    previewTabBottomLabel: () => cy.get('.edit-question-preview-wrapper  [class*="BottomLabelWrapper"].top-bottom-label'),
-    pointsPerResponseLabelForInlineOption: () => cy.get('[class*="ListOrderingstyles__EqualPointsWrapper"]'),
-    pointsPerResponseScoreForInlineOption: () => cy.get('[class*="ListOrderingstyles__EqualPointsWrapper"] span'),
-    //Set points popup
-    buttonSetPoints: () => cy.get('[class*="SetPointsstyle__Button"]'),
-    setPointsIcon: () => cy.get('[class*="SetPointsstyle__Button"] svg'),
-    //Remove after https://redmine.zeuslearning.com/issues/518498 is fixed
-    dragHandleButton: () => cy.get('[class*="DragIcon"]')
+    optionPreviewTab: () => cy.get('[class*="question-preview-wrapper"] .draggable-item-wrapper[role="button"]'),
+    optionWrapperPreviewTab: () => cy.get('[class*="question-preview-wrapper"] .orderlist-option-wrapper'),
+    correctAnswersLabel: () => cy.get('.check-answer-and-status-wrapper [class*="CorrectAnswerLabel"]'),
+    correctAnswerSectionAnswerWrapper: () => cy.get('[class*="CorrectAnswers"] [class*="__OptionsWrapper"]'),
+    correctAnswerSectionWrapper: () => cy.get('[class*="ListOrderingResponsestyles__CorrectAnswers"]'),
+    correctAnswerSectionAnswerText: () => cy.get('.question-text-wrapper'),
+    questionBorderPreviewTab: () => cy.get('[class*="ListOrderingResponsestyles__DroppableDiv"]'),
+    //grading view and correct answer view
+    optionGradingView: () => cy.get('[class*="DraggableItemsWrapper"] [class*="OptionTextWrapper"]'),
+    optionWrapperGradingView: () => cy.get('[class*="DraggableItemsWrapper"] [class*="OptionsWrapper"]'),
+    //Orientation and layout
+    orderingLayoutLabel: () => cy.get('.list-ordering-order-layout .options-label'),
+    reorderInTheSameListButton: () => cy.get('[data-ngie-testid="reorder-in-the-same-list-toggle-button"]'),
+    reorderAsSeparateListButton: () => cy.get('[data-ngie-testid="reorder-as-a-separate-list-toggle-button"]'),
+    dropdownMenuButton: () => cy.get('[data-ngie-testid="dropdown-menu-toggle-button"]'),
+    optionOrientationLabel: () => cy.get('.option-orientation-toggle-button-wrapper .options-label'),
+    verticalButton: () => cy.get('button[aria-label*="Vertical"]'),
+    horizontalButton: () => cy.get('button[aria-label*="Horizontal"]'),
+
+    //Dropdown menu selectors
+    dropdownMenuOptionsDropdown: () => cy.get('#Dropdown-menu-options-select'),
+    dropdownMenuOptionsDropdownLabel: () => cy.get('#Dropdown-menu-options-dropdown-label'),
+    dropdownMenuListOptions: (ariaLabel = null) => {
+        if (ariaLabel) {
+            return cy.get(`[aria-labelledby*="Dropdown-menu-options-dropdown-label"] [role="option"][aria-label*="${ariaLabel}"]`)
+        } else {
+            return cy.get('[aria-labelledby*="Dropdown-menu-options-dropdown-label"] [role="option"]')
+        }
+    },
+    dropdownOptionWrapperSpecifyCorrectAnswerSection: () => cy.get('.dropdown-menu-wrapper [class*="DropdownLayoutstyles__OptionsWrapper"]'),
+    positionDropdownSpecifyCorrectAnswerSection: () => cy.get('.response-dropdown-wrapper [role="combobox"]'),
+    positionDropdownListOption: (ariaLabel = null) => {
+        if (ariaLabel) {
+            return cy.get(`[aria-labelledby*="-dropdown-label"] [role="option"][aria-label*="${ariaLabel}"]`)
+        } else {
+            return cy.get('[aria-labelledby*="-dropdown-label"] [role="option"]')
+        }
+    },
+    dropdownSelectedOptionLabel: () => cy.get('.dropdown-label-text'),
+    dropdownOptionWrapperGradingView: () => cy.get('[class*="DropdownLayoutstyles__OptionsWrapper"]'),
+    dropdownWrapperPreviewTab: () => cy.get('[class*="ListOrderingResponsestyles__DroppableDiv"] [class*="DropdownLayoutstyles__ResponseWrapper"]'),
+    dropdownOptionWrapperPreviewTab: () => cy.get('[class*="DropdownLayoutstyles__OptionsWrapper"]'),
+    positionDropdownPreviewTab: () => cy.get('[class*="question-preview-wrapper"] .response-dropdown-wrapper [role="combobox"]'),
+    positionDropdownCorrectAnswerSection: () => cy.get('[class*="ListOrderingResponsestyles__CorrectAnswers"] .response-dropdown-wrapper [role="combobox"]'),
+    dropdownWrapperCorrectAnswerSection: () => cy.get('[class*="ListOrderingResponsestyles__CorrectAnswers"] [class*="DropdownLayoutstyles__ResponseWrapper"]'),
+    alertMessage: () => cy.get('[class*="ListOrderingResponsestyles__DisabledWrapper"]')
 }
 
 const steps = {
     ...createQuestionBasePage.steps,
     ...questionInstructionsComponent.steps,
-    ...scoringSectionBase.steps,
-    ...autoScoredSetCorrectAnswerSection.steps,
-    ...commonComponents.steps,
+    ...scoringSectionBaseEditTab.steps,
     ...optionsWrapperComponent.steps,
-    ...ckEditorToolbar.steps,
-    ...equationEditorFlyout.steps,
-    ...autoScoredScoringSectionMultipleResponsesType.steps,
+    ...autoScoredScoringPreviewTab.steps,
+    ...correctIncorrectAnswerLabelComponent.steps,
+    ...autoScoredStudentViewSettings.steps,
+    ...autoScoredScoringSectionMultiResponseType.steps,
+    ...autoScoredSpecifyCorrectAnswerSection.steps,
+    ...randomizeOptionsComponent.steps,
+    ...commonComponents.steps,
     ...additionalSettingsPanel.steps,
-    ...previewScoringAndShowCorrectAnswerComponent.steps,
-    ...autoScoredPreviewBase.steps,
-    ...autoScoredAdditionalSettings.steps,
-    ...autoScoredScoringSection.steps,
-    ...answerNumerationComponent.steps,
-    ...setPointsPopupBase.steps,
-    ...listSortingAndOrderingBase.steps,
-    /**
-     * @param {number} index set correct answer option index
-     * @description this function verfies contents of options
-     */
-    verifyDragHandleButtonOfOptionInSetCorrectAnswerSection: (index) => {
-        listOrderingPage.setCorrectAnswerSectionOption()
-            .eq(index)
-            .within(() => {
-                listOrderingPage.dragHandleButton()
-                    .should('exist');
-            });
+    /**
+     * @param {string} optionsText text content of the option
+     * @param {number} targetIndex the position at which the options is being dropped
+     * @description click and drop a option into a position in the specify correct answer section
+     */
+    clickAndReorderOptionInSpecifyCorrectAnswerSection: (optionsText, targetIndex) => {
+        listOrderingPage.optionSpecifyCorrectAnswerSection()
+            .contains(optionsText)
+            .click();
+        listOrderingPage.optionSpecifyCorrectAnswerSection()
+            .eq(targetIndex)
+            .click();
     },
 
     /**
-     * @param {string[]} optionsTextArray options array for set correct answer option
-     * @description this function verifies options text content
+     * @param {string} optionsText text content of the option
+     * @param {number} targetIndex the position at which the options is being dropped
+     * @description click and drop a option into a position in the preview tab
      */
-    verifyOptionsTextContentInSetCorrectAnswerSection: (optionsTextArray) => {
-        optionsTextArray.forEach((optionsText, index) => {
-            listOrderingPage.setCorrectAnswerSectionOption()
-                .eq(index)
-                .should('have.text', optionsText);
-        });
+    clickAndReorderOptionInPreviewTab: (optionsText, targetIndex) => {
+        listOrderingPage.optionPreviewTab()
+            .contains(optionsText)
+            .click();
+        listOrderingPage.optionPreviewTab()
+            .eq(targetIndex)
+            .click();
     },
 
     /**
-     * @param {number} index of option
-     * @description this function verifies image in set correct answer option input field
-     */
-    verifyImageAddedToOptionInSetCorrectAnswerSection: (index) => {
-        listOrderingPage.setCorrectAnswerSectionOption()
-            .eq(index)
+    * @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.
+    */
+    verifyOptionWithImageInPreviewTab: (optionIndex) => {
+        listOrderingPage.optionWrapperPreviewTab()
+            .eq(optionIndex)
             .find('img')
             .should('have.attr', 'src', constants.foxImageLink)
             .and('have.attr', 'alt', constants.foxImageAltText);
     },
 
     /**
-     * @param {number} index of option
-     * @description this function verifies equation in set correct answer option input field
+     * @description Verifies that the bold text in the Preview tab is correct.
+     * @param {number} optionIndex - The index of the option in the Preview tab.
      */
-    verifyEquationAddedToOptionInSetCorrectAnswerSection: (index) => {
-        listOrderingPage.setCorrectAnswerSectionOption()
-            .eq(index)
-            .contains(constants.CKEditorInputFieldEnteredEquationText)
-        listOrderingPage.setCorrectAnswerSectionOption()
-            .find('[role="math"]')
-            .should('have.attr', 'aria-label', constants.CKEditorInputFieldEnteredEquationAriaLabel)
+    verifyOptionWithBoldTextInPreviewTab: (optionIndex) => {
+        listOrderingPage.optionWrapperPreviewTab()
+            .eq(optionIndex)
+            .find('strong')
+            .should('have.text', 'This is a bold option');
     },
 
     /**
-     * @param {number} index of option
-     * @description this function link in set correct answer option input field
+     * @description Verifies that the equation text in the Preview tab is correct.
+     * @param {number} optionIndex - The index of the option in the Preview tab.
      */
-    verifyLinkAddedToOptionInSetCorrectAnswerSection: (index) => {
-        listOrderingPage.setCorrectAnswerSectionOption()
-            .eq(index)
-            .should('have.text', 'lorem')
-            .find('a')
-            .should('have.attr', 'href', `${Cypress.config().baseUrl}`)
+    verifyOptionWithEquationTextInPreviewTab: (optionIndex) => {
+        listOrderingPage.optionWrapperPreviewTab()
+            .eq(optionIndex)
+            .find('[role="math"]')
+            .should('have.attr', 'aria-label', constants.CKEditorInputFieldEnteredEquationAriaLabel)
+            .contains(constants.CKEditorInputFieldEnteredEquationText);
     },
 
     /**
-     * @param {number} index of option
-     * @description this function bold text in set correct answer option input field
+     * @param {string[]} optionsTextArray options array for preview tab options
+     * @description this function verifies options text content
      */
-    verifyBoldTextAddedToOptionInSetCorrectAnswerSection: (index) => {
-        listOrderingPage.setCorrectAnswerSectionOption()
-            .eq(index)
-            .find('strong')
-            .eq(0)
-            .should('have.text', 'This is a bold option');
-    },
-
-    verifyDefaultAndActiveStateOfOptionInSetCorrectAnswerSection: () => {
-        listOrderingPage.setCorrectAnswerSectionOption()
-            .eq(0)
-            .realHover()
-            .should('have.css', 'border', `2px solid ${css.color.activeButtons}`)
-            .find('.question-text-wrapper')
-            .and('have.css', 'color', css.color.activeButtons);
-        listOrderingPage.setCorrectAnswerSectionOption()
-            .eq(0)
-            .realHover({ position: 'topLeft' })
-            .should('have.css', 'border', `1px solid ${css.color.figDefaultComponentBorder}`)
-            .find('.question-text-wrapper')
-            .and('have.css', 'color', css.color.text)
+    verifyTextContentOfOptionInPreviewTab: (optionsText, index) => {
+        utilities.verifyTextContent(utilities.getNthElement(listOrderingPage.optionPreviewTab(), index), optionsText);
     },
 
     /**
-     * 
-     * @param {string} optionsText text content of the option
-     * @param {number} index the position at which the options is being dropped
-     * @description click and drop a option into a position in the set correct answer section
+     * @param {string[]} optionsTextArray options array for set correct answer options
+     * @description this function verifies options text content
      */
-    clickAndReorderOptionInSetCorrectAnswerSection: (optionsText, index) => {
-        listOrderingPage.setCorrectAnswerSectionOption()
-            .contains(optionsText)
-            .click();
-        listOrderingPage.setCorrectAnswerSectionOption()
-            .eq(index)
-            .click();
+    verifyTextContentOfOptionInSpecifyCorrectAnswerSection: (optionsText, index) => {
+        utilities.verifyTextContent(utilities.getNthElement(listOrderingPage.optionSpecifyCorrectAnswerSection(), index), optionsText);
     },
 
-    verifyPointsInputFieldErrorMessage: () => {
-        commonComponents.errorMessage()
-            .eq(0)
-            .should('have.text', 'Error: Please enter points.');
+    /**
+    * @param {string} optionsText option to be checked for the correct icon
+    * @description This function verifies the correct icon in the preview tab
+    */
+    verifyCorrectOptionIcon: (optionsText) => {
+        listOrderingPage.optionWrapperPreviewTab()
+            .contains(optionsText)
+            .parents('.orderlist-option-wrapper')
+            .within(() => {
+                utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.correctIcon(), 'exist');
+            });
     },
 
-    //Preview tab
     /**
-    * @param {number} index set correct answer option index
-    * @description this function verfies contents of options
+    * @param {string} optionsText option to be checked for the correct icon
+    * @description This function verifies the correct icon in the preview tab
     */
-    verifyDragHandleButtonOfOptionInPreviewTab: (index) => {
-        listOrderingPage.previewTabOption()
-            .eq(index)
+    verifyIncorrectOptionIcon: (optionsText) => {
+        listOrderingPage.optionWrapperPreviewTab()
+            .contains(optionsText)
+            .parents('.orderlist-option-wrapper')
             .within(() => {
-                listOrderingPage.dragHandleButton()
-                    .should('exist');
+                utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.incorrectIcon(), 'exist');
             });
     },
 
+    verifyCorrectAnswerSectionNotExists: () => {
+        utilities.verifyElementVisibilityState(listOrderingPage.correctAnswersLabel(), 'notExist');
+        utilities.verifyElementVisibilityState(listOrderingPage.correctAnswerSectionAnswerWrapper(), 'notExist');
+    },
+
     /**
-     * @param {string[]} optionsTextArray options array for set correct answer option
-     * @description this function verifies options text content
+     * @param {string[]} optionsTextArray array of options in the correct answer section
+     * @description this function verifies the correct order of options in correct answer section
      */
-    verifyTextContentOfOptionsInPreviewTab: (optionsTextArray) => {
+    verifyOptionsInCorrectAnswerSection: (optionsTextArray) => {
         optionsTextArray.forEach((optionsText, index) => {
-            listOrderingPage.previewTabOption()
-                .eq(index)
-                .should('have.text', optionsText);
+            utilities.getNthElement(listOrderingPage.correctAnswerSectionAnswerWrapper(), index)
+                .within(() => {
+                    utilities.verifyTextContent(listOrderingPage.correctAnswerSectionAnswerText(), optionsText);
+                });
         });
     },
 
     /**
-    * @param {number} index of option
-    * @description this function verifies image text in preview tab options
+    * @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.
     */
-    verifyImageAddedToOptionInPreviewTab: (index) => {
-        listOrderingPage.previewTabOption()
-            .eq(index)
+    verifyOptionWithImageInGradingView: (optionIndex) => {
+        listOrderingPage.optionGradingView()
+            .eq(optionIndex)
             .find('img')
             .should('have.attr', 'src', constants.foxImageLink)
             .and('have.attr', 'alt', constants.foxImageAltText);
     },
 
     /**
-    * @param {number} index of option
-    * @description this function verifies equation text in preview tab options
-    */
-    verifyEquationAddedToOptionInPreviewTab: (index) => {
-        listOrderingPage.previewTabOption()
-            .eq(index)
-            .contains(constants.CKEditorInputFieldEnteredEquationText)
-        listOrderingPage.previewTabOption()
-            .find('[role="math"]')
-            .should('have.attr', 'aria-label', constants.CKEditorInputFieldEnteredEquationAriaLabel)
-    },
-
-    /**
-    * @param {number} index of option
-    * @description this function verifies link in preview tab options
-    */
-    verifyLinkAddedToOptionInPreviewTab: (index) => {
-        listOrderingPage.previewTabOption()
-            .eq(index)
-            .should('have.text', 'lorem')
-            .find('a')
-            .should('have.attr', 'href', `${Cypress.config().baseUrl}`)
-    },
-
-    /**
-    * @param {number} index of option
-    * @description this function verifies bold text in preview tab options
-    */
-    verifyBoldTextAddedToOptionInPreviewTab: (index) => {
-        listOrderingPage.previewTabOption()
-            .eq(index)
+     * @description Verifies that the bold text in the Preview tab is correct.
+     * @param {number} optionIndex - The index of the option in the Preview tab.
+     */
+    verifyOptionWithBoldTextInGradingView: (optionIndex) => {
+        listOrderingPage.optionGradingView()
+            .eq(optionIndex)
             .find('strong')
-            .should('exist')
-            .should('have.text', 'This is a bold option')
-    },
-
-    verifyDefaultAndActiveStateOfOptionInPreviewTab: () => {
-        listOrderingPage.previewTabOption()
-            .eq(0)
-            .realHover()
-            .should('have.css', 'border', `2px solid ${css.color.activeButtons}`)
-            .find('.question-text-wrapper')
-            .and('have.css', 'color', css.color.activeButtons);
-        listOrderingPage.previewTabOption()
-            .eq(0)
-            .realHover({ position: 'topLeft' })
-            .should('have.css', 'border', `1px solid ${css.color.figDefaultComponentBorder}`)
-            .find('.question-text-wrapper')
-            .and('have.css', 'color', css.color.text)
-    },
-
-    //Scoring
-    /**
-    * @param {number} points the points to be displayed in the partial equal weights points field
-    * @description this function checks the points per response in partial equal weights
-    */
-    verifyPartialEqualWeightsPointsPerResponseScore: (points) => {
-        listOrderingPage.partialEqualWeightsPointsPerResponseScore()
-            .each(($element) => {
-                cy.wrap($element)
-                    .verifyInnerText(points);
-            });
+            .should('have.text', 'This is a bold option');
     },
 
     /**
-    * @description this function checks if the partial different weights points field is empty and visible
-    */
-    verifyPartialDifferentWeightsPointsInputFieldIsEmptyAndEnabled: () => {
-        listOrderingPage.partialDifferentWeightsPointsInputField()
-            .each(($element) => {
-                cy.wrap($element)
-                    .should('have.value', '')
-                    .and('be.visible')
-                    .and('be.enabled');
-            });
+     * @description Verifies that the equation text in the Preview tab is correct.
+     * @param {number} optionIndex - The index of the option in the Preview tab.
+     */
+    verifyOptionWithEquationTextInGradingView: (optionIndex) => {
+        listOrderingPage.optionGradingView()
+            .eq(optionIndex)
+            .find('[role="math"]')
+            .should('have.attr', 'aria-label', constants.CKEditorInputFieldEnteredEquationAriaLabel)
+            .contains(constants.CKEditorInputFieldEnteredEquationText);
     },
 
     /**
-     * @param {number[]} pointsArray the array of points to be alloted to each option
-     * @description this function allots points to all the options
+     * @param {string[]} optionsTextArray options array for set correct answer option
+     * @description this function verifies options text content
      */
-    allotPartialDifferentWeightsToAllPointsFields: (pointsArray) => {
-        pointsArray.forEach((points, columnIndex) => {
-            listOrderingPage.partialDifferentWeightsPointsInputField()
-                .eq(columnIndex)
-                .clear()
-                .type(points, { delay: 0 })
-                .should('have.value', points);
-        });
-    },
-
-    verifyPartialDifferentWeightsPointsPerResponseLabel: () => {
-        listOrderingPage.partialDifferentWeightsPointsPerResponseLabel()
-            .verifyInnerText('Points per response')
-            .should('be.visible');
-    },
-
-    verifyPointsPerResponseLabel: () => {
-        listOrderingPage.pointsPerResponseLabel()
-            .verifyInnerText('Points per response')
-            .should('be.visible');
+    verifyTextContentOfOptionInGradingView: (optionsText, index) => {
+        utilities.verifyTextContent(utilities.getNthElement(listOrderingPage.optionGradingView(), index), optionsText);
     },
 
     /**
-     * 
      * @param {string} optionsText text content of the option
      * @param {number} index the position at which the options is being dropped
      * @description click and drop a option into a position in the set correct answer section
      */
-    clickAndReorderOptionInPrevewTab: (optionsText, index) => {
-        listOrderingPage.previewTabOption()
+    clickAndReorderOptionInGradingView: (optionsText, index) => {
+        listOrderingPage.optionGradingView()
             .contains(optionsText)
             .click();
-        listOrderingPage.previewTabOption()
+        listOrderingPage.optionGradingView()
             .eq(index)
             .click();
     },
 
     /**
-     * 
-     * @param {string[]} optionsArray array of options set in options section
-     * @description this function resets the question preview
+     * Verifies the order of options in the "Specify Correct Answer" section.
+     * @param {string[]} optionsTextArray - An array containing the text of options in the expected order.
      */
-    resetQuestionPreview: (optionsArray) => {
-        createQuestionBasePage.steps.switchToEditTab();
-        createQuestionBasePage.steps.switchToPreviewTab();
-        listOrderingPage.steps.verifyTextContentOfOptionsInPreviewTab(optionsArray);
-    },
-
-    /**
-    * @param {string[]} numerationArray array of numeration numbers, lowercase, uppercase
-    * @description this function verifies the numeration of options
-    */
-    verifyOptionsNumeration: (numerationArray) => {
-        numerationArray.forEach((optionNumeration, index) => {
-            listOrderingPage.previewTabOption()
-                .eq(index)
-                .within(() => {
-                    listOrderingPage.optionNumeration()
-                        .should('have.text', optionNumeration);
-                });
+    verifyOptionsOrderInSpecifyCorrectAnswerSection: (optionsTextArray) => {
+        optionsTextArray.forEach((option, index) => {
+            utilities.verifyTextContent(utilities.getNthElement(listOrderingPage.optionSpecifyCorrectAnswerSection(), index), option);
         });
     },
 
     /**
-    * @param {string} optionsText option to be checked for the correct icon
-    * @description This function verifies the correct icon in the preview tab
-    */
-    verifyCorrectOptionsCheckmarkIcon: (optionsText) => {
-        listOrderingPage.previewTabOption()
-            .contains(optionsText)
-            .parents('.orderlist-option-wrapper')
-            .within(() => {
-                autoScoredPreviewBase.correctIcon()
-                    .and('be.visible');
-            });
+     * Verifies the order of options in the preview tab
+     * @param {string[]} optionsTextArray - An array containing the text of options in the expected order.
+     */
+    verifyOptionsOrderInPreviewTab: (optionsTextArray) => {
+        optionsTextArray.forEach((option, index) => {
+            utilities.verifyTextContent(utilities.getNthElement(listOrderingPage.optionPreviewTab(), index), option);
+        });
     },
 
     /**
-    * @param {string} optionsText option to be checked for the correct icon
-    * @description This function verifies the correct icon in the preview tab
-    */
-    verifyIncorrectOptionsCrossmarkIcon: (optionsText) => {
-        listOrderingPage.previewTabOption()
-            .contains(optionsText)
-            .parents('.orderlist-option-wrapper')
-            .within(() => {
-                autoScoredPreviewBase.incorrectIcon()
-                    .and('be.visible');
-            });
-    },
-
-    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');
-        autoScoredPreviewBase.correctIncorrectAnswerLabel()
-            .should('not.exist');
-        autoScoredPreviewBase.steps.verifyCorrectIncorrectBorderNotVisible()
+     * Verifies the points per response score against a given value.
+     * @param {number} value - The expected points per response score.
+     */
+    verifyPointsPerResponseScore: (value) => {
+        utilities.verifyTextContent(listOrderingPage.pointsPerResponseValue(), value)
     },
 
     getOptionsArray: () => {
         const optionsArray = []
-        listOrderingPage.previewTabOption()
+        listOrderingPage.optionPreviewTab()
             .each(($el) => {
                 cy.wrap($el)
                     .invoke('text')
@@ -417,339 +312,450 @@ const steps = {
     verifyRandomizeOptionOrder: (optionsArray) => {
         let currentOptionsArray = [...optionsArray]
         for (let index = 0; index < currentOptionsArray.length; index++) {
-            listOrderingPage.previewTabOption()
+            listOrderingPage.optionPreviewTab()
                 .eq(index)
                 .then(($element) => {
                     expect($element.text()).to.be.oneOf(currentOptionsArray);
                     currentOptionsArray = currentOptionsArray.filter((value) => value !== $element.text())
                 });
         };
-        listOrderingPage.steps.verifyOptionsAreRerandomized(optionsArray)
+        listOrderingPage.steps.verifyOptionsAreReRandomized(optionsArray)
     },
 
     /**
     * @param {string[]} previousOrderOfOptionsArray array of previous order of options
     * @description this function verifies that the order of the options is different from the previous order
     */
-    verifyOptionsAreRerandomized: (previousOrderOfOptionsArray) => {
-        listOrderingPage.previewTabOption()
+    verifyOptionsAreReRandomized: (previousOrderOfOptionsArray) => {
+        listOrderingPage.optionPreviewTab()
             .should('not.have.text', '')
             .and('not.have.text', previousOrderOfOptionsArray.join(''));
     },
 
-    /**
-    * @param {number} index set correct answer option index
-    * @description this function verfies drag handle of options does not exist
-    */
-    verifyDragHandleButtonDoesNotExistInSetCorrectAnswerSection: (index) => {
-        listOrderingPage.setCorrectAnswerSectionOption()
-            .eq(index)
-            .within(() => {
-                listOrderingPage.dragHandleButton()
-                    .should('not.exist');
-            });
-    },
-
-    /**
-    * @param {number} index set correct answer option index
-    * @description this function verfies drag handle of options does not exist
-    */
-    verifyDragHandleButtonDoesNotExistInPreviewTab: (index) => {
-        listOrderingPage.previewTabOption()
-            .eq(index)
-            .within(() => {
-                listOrderingPage.dragHandleButton()
-                    .should('not.exist');
-            });
+    verifyOuterBorderOfQuestionPreview: () => {
+        utilities.verifyCSS(listOrderingPage.questionBorderPreviewTab(), {
+            'border': `1px solid ${css.color.draggableOptionsContainerBorder}`
+        });
     },
 
-    //Additional settings
-
-    verifyNoBorderForSetCorrectAnswerOption: () => {
-        listOrderingPage.setCorrectAnswerSectionOption()
-            .eq(0)
+    verifyOuterBorderOfQuestionPreviewNotExists: () => {
+        listOrderingPage.questionBorderPreviewTab()
             .should('have.css', 'border')
             .and('match', /0px none/);
     },
 
-    verifyNoBorderForPreviewTabOption: () => {
-        listOrderingPage.previewTabOption()
-            .eq(0)
-            .should('have.css', 'border')
-            .and('match', /0px none/);
+    verifyEnableOuterBorderForQuestionCheckboxCheckedState: () => {
+        listOrderingPage.enableOuterBorderForQuestionCheckbox()
+            .should('be.checked');
     },
 
-    clickOnSetPointsButton: () => {
-        listOrderingPage.buttonSetPoints()
-            .click();
+    verifyEnableOuterBorderForQuestionCheckboxUncheckedState: () => {
+        listOrderingPage.enableOuterBorderForQuestionCheckbox()
+            .should('not.be.checked');
     },
 
-    verifySetPointsButton: () => {
-        utilities.verifyInnerText(listOrderingPage.buttonSetPoints(), 'Set points');
-        utilities.verifyElementVisibilityState(listOrderingPage.setPointsIcon(), 'visible');
+    checkEnableOuterBorderForQuestionCheckbox: () => {
+        listOrderingPage.enableOuterBorderForQuestionCheckbox()
+            .click()
+            .should('be.checked');
+    },
+
+    uncheckEnableOuterBorderForQuestionCheckbox: () => {
+        listOrderingPage.enableOuterBorderForQuestionCheckbox()
+            .click()
+            .should('not.be.checked');
     },
 
     /**
-       * @param {number} index of option
-       * @description this function verifies image in set points popup
-       */
-    verifyImageAddedToOptionInSetPointsPopup: (index) => {
-        setPointsPopupBase.setPointsPopupOptions()
-            .eq(index)
+     * @description Verifies that the image in the Specify Correct Answer section has the correct source and alt text.
+     * @param {number} index - The index of the option in the Specify Correct Answer section.
+     */
+    verifyImageInSpecifyCorrectAnswerSection: (index) => {
+        utilities.getNthElement(listOrderingPage.optionSpecifyCorrectAnswerSection(), index)
             .find('img')
             .should('have.attr', 'src', constants.foxImageLink)
             .and('have.attr', 'alt', constants.foxImageAltText);
     },
 
     /**
-    * @param {number} index of option
-    * @description this function verifies equation text in set points popup
-    */
-    verifyEquationAddedToOptionInSetPointsPopup: (index) => {
-        setPointsPopupBase.setPointsPopupOptions()
-            .eq(index)
-            .contains(constants.CKEditorInputFieldEnteredEquationText)
-        setPointsPopupBase.setPointsPopupOptions()
+     * @description Verifies that the bold text in the Specify Correct Answer section is correct.
+     * @param {number} index - The index of the option in the Specify Correct Answer section.
+     */
+    verifyBoldTextInSpecifyCorrectAnswerSection: (index) => {
+        utilities.getNthElement(listOrderingPage.optionSpecifyCorrectAnswerSection(), index)
+            .find('strong')
+            .should('have.text', 'This is a bold option');
+    },
+
+    /**
+     * @description Verifies that the equation text in the Specify Correct Answer section is correct.
+     * @param {number} index - The index of the option in the Specify Correct Answer section.
+     */
+    verifyEquationTextInSpecifyCorrectAnswerSection: (index) => {
+        utilities.getNthElement(listOrderingPage.optionSpecifyCorrectAnswerSection(), index)
             .find('[role="math"]')
             .should('have.attr', 'aria-label', constants.CKEditorInputFieldEnteredEquationAriaLabel)
+            .contains(constants.CKEditorInputFieldEnteredEquationText);
     },
 
     /**
-     * @param {number} index of option
-     * @description this function link in set points popup
+     * Selects an ordering layout option on the list ordering page.
+     * @param {('Reorder in the same list' | 'Reorder as a separate list' | 'Dropdown menu')} layoutOption - The layout option to select.
+     * @throws {Error} If an invalid layout option is provided.
      */
-    verifyLinkAddedToOptionInSetPointsPopup: (index) => {
-        setPointsPopupBase.setPointsPopupOptions()
-            .eq(index)
-            .should('have.text', 'lorem')
-            .find('a')
-            .should('have.attr', 'href', `${Cypress.config().baseUrl}`)
+    selectOrderingLayoutOption: (layoutOption) => {
+        switch (layoutOption) {
+            case 'Reorder in the same list':
+                listOrderingPage.reorderInTheSameListButton()
+                    .click()
+                    .should('have.class', 'ngie-toggle-button-selected');
+                break;
+            case 'Reorder as a separate list':
+                listOrderingPage.reorderAsSeparateListButton()
+                    .click()
+                    .should('have.class', 'ngie-toggle-button-selected');
+                break;
+            case 'Dropdown menu':
+                listOrderingPage.dropdownMenuButton()
+                    .click()
+                    .should('have.class', 'ngie-toggle-button-selected');
+                break;
+            default:
+                throw new Error('Invalid layout option');
+        }
+    },
+
+    ///Dropdown menu steps
+    expandDropdownMenuOptionsDropdown: () => {
+        listOrderingPage.dropdownMenuOptionsDropdown()
+            .click();
+    },
+
+    /**
+     * Selects an option from a dropdown menu on the list ordering page.
+     * @param {('Numerical' | 'Uppercase alphabet' | 'Lowercase alphabet' | 'Uppercase roman numeral' | 'Lowercase roman numeral')} dropdownOption - The option to select from the dropdown menu.
+     */
+    selectListOptionFromDropdownMenuOptionsDropdown: (dropdownOption) => {
+        listOrderingPage.dropdownMenuListOptions(dropdownOption)
+            .click();
+    },
+
+    /**
+     * Expands the position dropdown in the specify correct answer section and selects the specified dropdown index.
+     * @param {number} dropdownIndex - The index of the dropdown to expand and select.
+     */
+    expandPositionDropdownSpecifyCorrectAnswerSection: (dropdownIndex) => {
+        utilities.getNthElement(listOrderingPage.positionDropdownSpecifyCorrectAnswerSection(), dropdownIndex)
+            .click();
     },
 
     /**
-    * @param {number} index of option
-    * @description this function bold text in in set points popup
+     * Selects the specified option from the position dropdown in the specify correct answer section.
+     * @param {number} optionIndex - The index of the option in the dropdown.
+     * @param {string} position - The position to select.
+     */
+    selectOptionPositionSpecifyCorrectAnswerSection: (optionIndex, position) => {
+        steps.expandPositionDropdownSpecifyCorrectAnswerSection(optionIndex);
+        listOrderingPage.positionDropdownListOption(position)
+            .click();
+    },
+
+    /**
+     * Selects positions for all options in the specify correct answer section according to the provided position object.
+     * @param {Object[]} positionObject - An array of objects where each object contains optionIndex and position properties.
+     * @param {number} positionObject[].optionIndex - The index of the option.
+     * @param {string} positionObject[].position - The position to select.
+     */
+    selectPositionForAllOptionsSpecifyCorrectAnswerSection: (positionObject) => {
+        positionObject.forEach(({ optionIndex, position }) => {
+            steps.selectOptionPositionSpecifyCorrectAnswerSection(optionIndex, position)
+        });
+    },
+
+    /**
+     * Expands the position dropdown in the specify correct answer section and selects the specified dropdown index.
+     * @param {number} dropdownIndex - The index of the dropdown to expand and select.
+     */
+    expandPositionDropdownPreviewTab: (dropdownIndex) => {
+        utilities.getNthElement(listOrderingPage.positionDropdownPreviewTab(), dropdownIndex)
+            .click();
+    },
+
+    /**
+     * Selects a list option from the position dropdown.
+     * @param {number} position The list option to select.
+     * @returns {void}
+     */
+    selectListOptionPositionDropdown: (position) => {
+        listOrderingPage.positionDropdownListOption(position)
+            .click();
+    },
+
+    /**
+     * Selects the specified option from the position dropdown in the specify correct answer section.
+     * @param {number} optionIndex - The index of the option in the dropdown.
+     * @param {string} position - The position to select.
+     */
+    selectOptionPositionPreviewTab: (optionIndex, position) => {
+        steps.expandPositionDropdownPreviewTab(optionIndex);
+        listOrderingPage.positionDropdownListOption(position)
+            .click();
+    },
+
+    /**
+     * Selects positions for all options in the specify correct answer section according to the provided position object.
+     * @param {Object[]} positionObject - An array of objects where each object contains optionIndex and position properties.
+     * @param {number} positionObject[].optionIndex - The index of the option.
+     * @param {string} positionObject[].position - The position to select.
+     */
+    selectPositionForAllOptionsPreviewTab: (positionObject) => {
+        positionObject.forEach(({ optionIndex, position }) => {
+            steps.selectOptionPositionPreviewTab(optionIndex, position)
+        });
+    },
+
+    /**
+    * @param {number} optionIndex option to be checked for the correct icon
+    * @description This function verifies the correct icon in the preview tab for the dropdown order layout
     */
-    verifyBoldTextAddedToOptionInSetPointsPopup: (index) => {
-        setPointsPopupBase.setPointsPopupOptions()
-            .eq(index)
+    verifyCorrectOptionIconDropdownLayout: (optionIndex) => {
+        utilities.getNthElement(listOrderingPage.dropdownWrapperPreviewTab(), optionIndex)
+            .within(() => {
+                utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.correctIcon(), 'visible');
+            });
+    },
+
+    /**
+    * @param {number} optionIndex option to be checked for the correct icon
+    * @description This function verifies the correct icon in the preview tab for the dropdown order layout
+    */
+    verifyIncorrectOptionIconDropdownLayout: (optionIndex) => {
+        utilities.getNthElement(listOrderingPage.dropdownWrapperPreviewTab(), optionIndex)
+            .within(() => {
+                utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.incorrectIcon(), 'visible');
+            });
+    },
+
+    /**
+    * @param {number} optionIndex option to be checked for the correct/incorrect icon to not exist
+    * @description This function verifies the correct/incorrect icon to not exist in the preview tab for the dropdown order layout
+    */
+    verifyCorrectIncorrectOptionIconDropdownLayoutNotExists: (optionIndex) => {
+        utilities.getNthElement(listOrderingPage.dropdownWrapperPreviewTab(), optionIndex)
+            .within(() => {
+                utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.incorrectIcon(), 'notExist');
+                utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.correctIcon(), 'notExist');
+            });
+    },
+
+    /**
+    * @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.
+    */
+    verifyOptionWithImageDropdownLayoutInGradingView: (optionIndex) => {
+        listOrderingPage.dropdownOptionWrapperGradingView()
+            .eq(optionIndex)
+            .find('img')
+            .should('have.attr', 'src', constants.foxImageLink)
+            .and('have.attr', 'alt', constants.foxImageAltText);
+    },
+
+    /**
+     * @description Verifies that the bold text in the Preview tab is correct.
+     * @param {number} optionIndex - The index of the option in the Preview tab.
+     */
+    verifyOptionWithBoldTextDropdownLayoutInGradingView: (optionIndex) => {
+        listOrderingPage.dropdownOptionWrapperGradingView()
+            .eq(optionIndex)
             .find('strong')
-            .eq(0)
             .should('have.text', 'This is a bold option');
     },
 
     /**
-     * @param {number[]} numerationArray numeration array for the option
-     * @description this function checks the numeration of options in set points popup
+     * @description Verifies that the equation text in the Preview tab is correct.
+     * @param {number} optionIndex - The index of the option in the Preview tab.
+     */
+    verifyOptionWithEquationTextDropdownLayoutInGradingView: (optionIndex) => {
+        listOrderingPage.dropdownOptionWrapperGradingView()
+            .eq(optionIndex)
+            .find('[role="math"]')
+            .should('have.attr', 'aria-label', constants.CKEditorInputFieldEnteredEquationAriaLabel)
+            .contains(constants.CKEditorInputFieldEnteredEquationText);
+    },
+
+    /**
+     * @param {string[]} optionsTextArray options array for set correct answer option
+     * @description this function verifies options text content
+     */
+    verifyTextContentOfOptionDropdownLayoutInGradingView: (optionsText, index) => {
+        utilities.verifyTextContent(utilities.getNthElement(listOrderingPage.dropdownOptionWrapperGradingView(), index), optionsText);
+    },
+
+    /**
+     * @param {string[]} optionsTextArray array of options in the correct answer section
+     * @description this function verifies the correct order of options in correct answer section
      */
-    verifySetPointsPopupOptionNumeration: (numerationArray) => {
-        numerationArray.forEach((optionNumeration, index) => {
-            setPointsPopupBase.dialogBox()
+    verifyOptionsPositionInCorrectAnswerSection: (optionsTextArray, positionArray) => {
+        optionsTextArray.forEach((optionsText, index) => {
+            utilities.getNthElement(listOrderingPage.correctAnswerSectionAnswerWrapper(), index)
                 .within(() => {
-                    listOrderingPage.optionNumeration()
-                        .eq(index)
-                        .should('have.text', optionNumeration);
+                    utilities.verifyTextContent(listOrderingPage.correctAnswerSectionAnswerText(), optionsText);
                 });
         });
+        positionArray.forEach((position, dropdownIndex) => {
+            utilities.verifyTextContent(utilities.getNthElement(listOrderingPage.positionDropdownCorrectAnswerSection(), dropdownIndex), position);
+        });
     },
 
-    verifyCorrectIncorrectAnswerLabel: (labelText) => {
-        autoScoredPreviewBase.correctIncorrectAnswerLabel()
-            .should('be.visible')
-            .verifyInnerText(`${labelText} answer`)
-            .parents('[class*="__AnswerStatusWrapper"]')
-            .find('[class*="__AnswerStatusIcon"]')
-            .should('be.visible')
-            .should('have.text', `${labelText}-Icon`)
-    }
-}
+    /**
+     * Verifies the selected option position in the dropdown for the specified dropdown index.
+     * @param {number} dropdownIndex - The index of the dropdown to verify.
+     * @param {string} position - The expected position of the selected option.
+     */
+    verifySelectedOptionPositionDropdown: (dropdownIndex, position) => {
+        utilities.getNthElement(listOrderingPage.positionDropdownPreviewTab(), dropdownIndex)
+            .within(() => {
+                if (position === '') {
+                    utilities.verifyElementVisibilityState(listOrderingPage.dropdownSelectedOptionLabel(), 'notExist');
+                } else {
+                    utilities.verifyInnerText(listOrderingPage.dropdownSelectedOptionLabel(), position);
+                }
+            });
+    },
 
-const tests = {
-    ...createQuestionBasePage.tests,
-    ...commonComponents.tests,
-    ...questionInstructionsComponent.tests,
-    ...autoScoredScoringSection.tests,
-    ...scoringSectionBase.tests,
-    ...autoScoredSetCorrectAnswerSection.tests,
-    ...previewScoringAndShowCorrectAnswerComponent.tests,
-    ...additionalSettingsPanel.tests,
-    ...autoScoredAdditionalSettings.tests,
-    ...answerNumerationComponent.tests,
-    ...studentResponseAndLayoutComponent.tests,
-    ...listSortingAndOrderingBase.tests,
-    verifyAllContentsOfSetCorrectAnswerSectionForScoringType: (scoringType, optionsArray) => {
-        it(`When user has selected ${scoringType} scoring type then added options should be displayed in the set correct answer section`, () => {
-            listOrderingPage.steps.verifyOptionsTextContentInSetCorrectAnswerSection(optionsArray);
-            for (let index = 0; index < 4; index++) {
-                listOrderingPage.steps.verifyDragHandleButtonOfOptionInSetCorrectAnswerSection(index);
-            }
-        });
+    verifyAssignValueToAllDropdownAlertMessage: () => {
+        utilities.verifyInnerText(listOrderingPage.alertMessage(), 'All options need to have a value assigned to them from the dropdown.');
+        utilities.verifyElementVisibilityState(listOrderingPage.alertMessage(), 'visible');
+    },
+
+    verifyAlertMessageNotExists: () => {
+        utilities.verifyElementVisibilityState(listOrderingPage.alertMessage(), 'notExist');
     },
 
     /**
-     * @param {number} totalPoints the maximum points that can be scored by the user
-     * @description this function verifies 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()
-            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('plant', 0);
-            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('seed', 1);
-            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('flower', 2);
-            listOrderingPage.steps.verifyTextContentOfOptionsInPreviewTab(['plant', 'seed', 'flower', 'sprout']);
-            listOrderingPage.previewScoreText()
-                .verifyInnerText(`1/${totalPoints}`);
-        });
+     * @param {string[]} optionsTextArray options array for preview tab options
+     * @description this function verifies options text content for "dropdown menu" ordering layout
+     */
+    verifyTextContentOfOptionDropdownLayoutInPreviewTab: (optionsText, index) => {
+        utilities.verifyTextContent(utilities.getNthElement(listOrderingPage.dropdownOptionWrapperPreviewTab(), index), optionsText);
+    },
 
-        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();
-            scoringSectionBase.steps.clearMinimumScoreIfAttemptedPointsField();
-            createQuestionBasePage.steps.switchToPreviewTab()
-            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('plant', 0);
-            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('seed', 1);
-            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('flower', 2);
-            listOrderingPage.steps.verifyTextContentOfOptionsInPreviewTab(['plant', 'seed', 'flower', 'sprout']);
-            listOrderingPage.previewScoreText()
-                .verifyInnerText(`0/${totalPoints}`);
-        });
+    /**
+     * @param {string[]} optionsTextArray options array for specify correct answer section options
+     * @description this function verifies options text content for "dropdown menu" ordering layout
+     */
+    verifyTextContentOfOptionDropdownLayoutInSpecifyCorrectAnswerSection: (optionsText, index) => {
+        utilities.verifyTextContent(utilities.getNthElement(listOrderingPage.dropdownOptionWrapperSpecifyCorrectAnswerSection(), index), optionsText);
     },
 
     /**
-     * 
-     * @param {number} scoredPoints the points scored by the user when penalty points are reduced
-     * @param {number} totalPoints the maximum points that can be scored by the user
-     * @description this function verifies 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();
-            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('plant', 1);
-            listOrderingPage.steps.verifyTextContentOfOptionsInPreviewTab(['sprout', 'plant', 'flower', 'seed']);
-            listOrderingPage.previewScoreText()
-                .verifyInnerText(`0/${totalPoints}`);
-
-            cy.log('When user adds a partially correct answer input, the points should be updated accordingly with deducted penalty points');
-            listOrderingPage.steps.resetQuestionPreview(['sprout', 'plant', 'flower', 'seed'])
-            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('seed', 0);
-            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('plant', 1);
-            listOrderingPage.steps.verifyTextContentOfOptionsInPreviewTab(['seed', 'plant', 'sprout', 'flower']);
-            listOrderingPage.previewScoreText()
-                .verifyInnerText(`${scoredPoints}/${totalPoints}`);
-
-            cy.log('Post step: Clearing the Penalty points field')
-            createQuestionBasePage.steps.switchToEditTab();
-            autoScoredScoringSectionMultipleResponsesType.penaltyPointsInputField()
-                .clear();
-        });
+     * Verifies the selected option position in the dropdown for the specified dropdown index.
+     * @param {number} dropdownIndex - The index of the dropdown to verify.
+     * @param {string} position - The expected position of the selected option.
+     */
+    verifySelectedOptionPositionDropdownInSpecifyCorrectAnswerSection: (dropdownIndex, position) => {
+        utilities.getNthElement(listOrderingPage.positionDropdownSpecifyCorrectAnswerSection(), dropdownIndex)
+            .within(() => {
+                if (position === '') {
+                    utilities.verifyElementVisibilityState(listOrderingPage.dropdownSelectedOptionLabel(), 'notExist');
+                } else {
+                    utilities.verifyInnerText(listOrderingPage.dropdownSelectedOptionLabel(), position);
+                }
+            });
     },
 
     /**
-   * @param {*} totalPointsScored the maximum points that can be achieved by the user
-   * @description this function verifies the functionality of penalty points when penalty points are set and user attempts alternate tab answers
-   */
-    verifyPenaltyPointsFunctionalityForAlternateTabAnswers: (totalPointsScored) => {
-        it('When the user has alloted penalty points and attempts the question according to the alternate tab then user should be awarded with full points of the alternate tab and penalty points should not be deducted', () => {
-            listOrderingPage.steps.switchToEditTab()
-            listOrderingPage.steps.allotPenaltyPoints(3);
-            listOrderingPage.steps.switchToPreviewTab();
-            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('seed', 0);
-            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('plant', 3);
-            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('flower', 1);
-            listOrderingPage.steps.verifyTextContentOfOptionsInPreviewTab(['seed', 'flower', 'sprout', 'plant']);
-            listOrderingPage.steps.verifyPreviewTabScoreText(`${totalPointsScored}`, `${totalPointsScored}`);
-            cy.log('Post step: Clearing the Penalty points field')
-            createQuestionBasePage.steps.switchToEditTab();
-            autoScoredScoringSectionMultipleResponsesType.penaltyPointsInputField()
-                .clear();
+     * Verifies the order of options in the "Specify Correct Answer" section.
+     * @param {string[]} optionsTextArray - An array containing the text of options in the expected order.
+     */
+    verifyOptionsOrderDropdownLayoutInSpecifyCorrectAnswerSection: (optionsTextArray) => {
+        optionsTextArray.forEach((option, index) => {
+            steps.verifyTextContentOfOptionDropdownLayoutInSpecifyCorrectAnswerSection(option, index);
         });
     },
 
     /**
-     * @param {number[]} scoredPointsArray 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 this function verifies the functionality of Minimum score if attempted points when penalty points are set and user attempts incorrect answer
-     * - 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: (scoredPointsArray, 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 and Penalty points');
-            createQuestionBasePage.steps.switchToEditTab();
-            scoringSectionBase.steps.allotMinimumScoreAwardedIfAttempted(1);
-            autoScoredScoringSectionMultipleResponsesType.steps.allotPenaltyPoints(3);
-
-            cy.log('Switch to preview tab and give incorrect answer input to check that minimum points are displayed');
-            createQuestionBasePage.steps.switchToPreviewTab();
-            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('flower', 0);
-            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('sprout', 3);
-            listOrderingPage.steps.verifyTextContentOfOptionsInPreviewTab(['flower', 'plant', 'seed', 'sprout']);
-            listOrderingPage.previewScoreText()
-                .verifyInnerText(`${scoredPointsArray[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');
-            listOrderingPage.steps.resetQuestionPreview(['sprout', 'plant', 'flower', 'seed']);
-            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('seed', 0);
-            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('plant', 1);
-            listOrderingPage.steps.verifyTextContentOfOptionsInPreviewTab(['seed', 'plant', 'sprout', 'flower']);
-            listOrderingPage.previewScoreText()
-                .verifyInnerText(`${scoredPointsArray[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();
-            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('seed', 0);
-            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('plant', 1);
-            listOrderingPage.steps.clickAndReorderOptionInPrevewTab('flower', 2);
-            listOrderingPage.steps.verifyTextContentOfOptionsInPreviewTab(['seed', 'plant', 'flower', 'sprout']);
-            listOrderingPage.previewScoreText()
-                .verifyInnerText(`${scoredPointsArray[2]}/${totalPoints}`);
+     * Verifies the order of options in the preview tab
+     * @param {string[]} optionsTextArray - An array containing the text of options in the expected order.
+     */
+    verifyOptionsOrderDropdownLayoutInPreviewTab: (optionsTextArray) => {
+        optionsTextArray.forEach((option, index) => {
+            steps.verifyTextContentOfOptionDropdownLayoutInPreviewTab(option, index)
         });
     },
 
-    //Additional settings
+    getOptionsArrayForDropdownLayout: () => {
+        const optionsArray = []
+        listOrderingPage.dropdownOptionWrapperPreviewTab()
+            .each(($el) => {
+                cy.wrap($el)
+                    .invoke('text')
+                    .then((text) => {
+                        optionsArray.push(text);
+                    });
+            });
+        return optionsArray;
+    },
+
     /**
-     * @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
+     * @param {string[]} optionsArray array of options set in the options section
+     * @description this function verifies if the options are Randomized in the preview tab
      */
-    verifyOptionsAndCorrectAnswerContainerNumerationWhenShowCorrectAnswerCheckboxIsChecked: (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', () => {
-            listOrderingPage.steps.checkShowCorrectAnswerCheckbox()
-            steps.verifyOptionsNumeration(numerationArray)
-            steps.verifyCorrectAnswerContainerNumeration(numerationArray)
-            cy.log('Post step: Uncheck \'Show correct answer\' checkbox')
-            listOrderingPage.steps.uncheckShowCorrectAnswerCheckbox()
-        });
+    verifyRandomizeOptionOrderDropdownLayout: (optionsArray) => {
+        let currentOptionsArray = [...optionsArray]
+        for (let index = 0; index < currentOptionsArray.length; index++) {
+            listOrderingPage.dropdownOptionWrapperPreviewTab()
+                .eq(index)
+                .then(($element) => {
+                    expect($element.text()).to.be.oneOf(currentOptionsArray);
+                    currentOptionsArray = currentOptionsArray.filter((value) => value !== $element.text())
+                });
+        };
+        listOrderingPage.steps.verifyOptionsAreReRandomizedDropdownLayout(optionsArray)
     },
 
     /**
-    * @param {string[]} numerationArray array of the numeration displayed with options numbers| lowercase| uppercase
-    * @description this function checks the numeration displayed for the options and correct answer container options when check answer is selected
+    * @param {string[]} previousOrderOfOptionsArray array of previous order of options
+    * @description this function verifies that the order of the options is different from the previous order
     */
-    verifyOptionsNumerationWhenCheckAnswerIsSelected: (numerationArray) => {
-        it('When user clicks on \'Check answer\' button then the numeration should be displayed in the options', () => {
-            listOrderingPage.steps.checkAnswer()
-            steps.verifyOptionsNumeration(numerationArray)
+    verifyOptionsAreReRandomizedDropdownLayout: (previousOrderOfOptionsArray) => {
+        listOrderingPage.dropdownOptionWrapperPreviewTab()
+            .should('not.have.text', '')
+            .and('not.have.text', previousOrderOfOptionsArray.join(''));
+    },
+}
+
+const tests = {
+    ...autoScoredScoringPreviewTab.tests,
+    ...scoringSectionBaseEditTab.tests,
+    ...autoScoredScoringSectionMultiResponseType.tests,
+    ...autoScoredSpecifyCorrectAnswerSection.tests,
+    ...commonComponents.tests,
+    ...studentViewSettingsLabelComponent.tests,
+    ...randomizeOptionsComponent.tests,
+    ...autoScoredStudentViewSettings.tests,
+    ...questionInstructionsComponent.tests,
+    ...optionsWrapperComponent.tests,
+    ...additionalSettingsPanel.tests,
+    ...additionalSettingsAccessibilitySectionComponent.tests,
+    ...createQuestionBasePage.tests,
+    verifyContentsOfSpecifyCorrectAnswerSection: () => {
+        it('When user selects a scoring type then in the \'Correct\' accordion, all the contents should be displayed', () => {
+            utilities.verifyElementCount(listOrderingPage.optionSpecifyCorrectAnswerSection(), 4);
+            options.forEach((optionText, index) => {
+                listOrderingPage.steps.verifyTextContentOfOptionInSpecifyCorrectAnswerSection(optionText, index);
+            });
         });
-    }
+    },
+
+    verifyContentsOfSpecifyCorrectAnswerSectionDropdownLayout: () => {
+        it('By default, 4 options should be displayed with dropdowns in the specify correct answer section', () => {
+            utilities.verifyElementCount(listOrderingPage.positionDropdownSpecifyCorrectAnswerSection(), 4);
+            options.forEach((optionText, index) => {
+                listOrderingPage.steps.verifyTextContentOfOptionDropdownLayoutInSpecifyCorrectAnswerSection(optionText, index);
+            });
+        });
+    },
 }
 
 export const listOrderingPage = {