itemengine-cypress-automation 1.0.184 → 1.0.185

package/cypress/pages/listOrderingPage.js

@@ -1,297 +1,405 @@
 import constants from "../fixtures/constants";
 import utilities from "../support/helpers/utilities";
-import { autoScoredScoringPreviewTab, autoScoredScoringSectionMultiResponseType, autoScoredSpecifyCorrectAnswerSection, autoScoredStudentViewSettings, commonComponents, correctIncorrectAnswerLabelComponent, createQuestionBasePage, optionsWrapperComponent, questionInstructionsComponent, randomizeOptionsComponent, scoringSectionBaseEditTab, studentViewSettingsLabelComponent, additionalSettingsPanel, additionalSettingsAccessibilitySectionComponent } from "./components"
-const options = ['sprout', 'plant', 'flower', 'seed'];
+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";
 const css = Cypress.env('css');
 
 const selectors = {
-    ...optionsWrapperComponent,
-    ...questionInstructionsComponent,
     ...commonComponents,
-    ...autoScoredScoringSectionMultiResponseType,
-    ...randomizeOptionsComponent,
-    ...autoScoredScoringPreviewTab,
+    ...optionsWrapperComponent,
+    ...scoringSectionBase,
+    ...autoScoredScoringSectionMultipleResponsesType,
+    ...autoScoredSetCorrectAnswerSection,
+    ...autoScoredAdditionalSettings,
+    ...previewScoringAndShowCorrectAnswerComponent,
+    ...autoScoredPreviewBase,
     ...additionalSettingsPanel,
-    ...correctIncorrectAnswerLabelComponent,
-    //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'),
+    ...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"]'),
     //Preview Tab
-    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'),
-    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"]')
-        }
-    },
-    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"]')
+    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"]')
 }
 
 const steps = {
     ...createQuestionBasePage.steps,
     ...questionInstructionsComponent.steps,
-    ...scoringSectionBaseEditTab.steps,
-    ...optionsWrapperComponent.steps,
-    ...autoScoredScoringPreviewTab.steps,
-    ...correctIncorrectAnswerLabelComponent.steps,
-    ...autoScoredStudentViewSettings.steps,
-    ...autoScoredScoringSectionMultiResponseType.steps,
-    ...autoScoredSpecifyCorrectAnswerSection.steps,
-    ...randomizeOptionsComponent.steps,
+    ...scoringSectionBase.steps,
+    ...autoScoredSetCorrectAnswerSection.steps,
     ...commonComponents.steps,
+    ...optionsWrapperComponent.steps,
+    ...ckEditorToolbar.steps,
+    ...equationEditorFlyout.steps,
+    ...autoScoredScoringSectionMultipleResponsesType.steps,
     ...additionalSettingsPanel.steps,
-    /**
-     * @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
+    ...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
      */
-    clickAndReorderOptionInSpecifyCorrectAnswerSection: (optionsText, targetIndex) => {
-        listOrderingPage.optionSpecifyCorrectAnswerSection()
-            .contains(optionsText)
-            .click();
-        listOrderingPage.optionSpecifyCorrectAnswerSection()
-            .eq(targetIndex)
-            .click();
+    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 preview tab
+     * @param {string[]} optionsTextArray options array for set correct answer option
+     * @description this function verifies options text content
      */
-    clickAndReorderOptionInPreviewTab: (optionsText, targetIndex) => {
-        listOrderingPage.optionPreviewTab()
-            .contains(optionsText)
-            .click();
-        listOrderingPage.optionPreviewTab()
-            .eq(targetIndex)
-            .click();
+    verifyOptionsTextContentInSetCorrectAnswerSection: (optionsTextArray) => {
+        optionsTextArray.forEach((optionsText, index) => {
+            listOrderingPage.setCorrectAnswerSectionOption()
+                .eq(index)
+                .should('have.text', optionsText);
+        });
     },
 
     /**
-    * @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)
+     * @param {number} index of option
+     * @description this function verifies image in set correct answer option input field
+     */
+    verifyImageAddedToOptionInSetCorrectAnswerSection: (index) => {
+        listOrderingPage.setCorrectAnswerSectionOption()
+            .eq(index)
             .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.
+     * @param {number} index of option
+     * @description this function verifies equation in set correct answer option input field
      */
-    verifyOptionWithBoldTextInPreviewTab: (optionIndex) => {
-        listOrderingPage.optionWrapperPreviewTab()
-            .eq(optionIndex)
-            .find('strong')
-            .should('have.text', 'This is a bold option');
-    },
-
-    /**
-     * @description Verifies that the equation text in the Preview tab is correct.
-     * @param {number} optionIndex - The index of the option in the Preview tab.
-     */
-    verifyOptionWithEquationTextInPreviewTab: (optionIndex) => {
-        listOrderingPage.optionWrapperPreviewTab()
-            .eq(optionIndex)
+    verifyEquationAddedToOptionInSetCorrectAnswerSection: (index) => {
+        listOrderingPage.setCorrectAnswerSectionOption()
+            .eq(index)
+            .contains(constants.CKEditorInputFieldEnteredEquationText)
+        listOrderingPage.setCorrectAnswerSectionOption()
             .find('[role="math"]')
             .should('have.attr', 'aria-label', constants.CKEditorInputFieldEnteredEquationAriaLabel)
-            .contains(constants.CKEditorInputFieldEnteredEquationText);
     },
 
     /**
-     * @param {string[]} optionsTextArray options array for preview tab options
-     * @description this function verifies options text content
+     * @param {number} index of option
+     * @description this function link in set correct answer option input field
      */
-    verifyTextContentOfOptionInPreviewTab: (optionsText, index) => {
-        utilities.verifyTextContent(utilities.getNthElement(listOrderingPage.optionPreviewTab(), index), optionsText);
+    verifyLinkAddedToOptionInSetCorrectAnswerSection: (index) => {
+        listOrderingPage.setCorrectAnswerSectionOption()
+            .eq(index)
+            .should('have.text', 'lorem')
+            .find('a')
+            .should('have.attr', 'href', `${Cypress.config().baseUrl}`)
     },
 
     /**
-     * @param {string[]} optionsTextArray options array for set correct answer options
-     * @description this function verifies options text content
+     * @param {number} index of option
+     * @description this function bold text in set correct answer option input field
      */
-    verifyTextContentOfOptionInSpecifyCorrectAnswerSection: (optionsText, index) => {
-        utilities.verifyTextContent(utilities.getNthElement(listOrderingPage.optionSpecifyCorrectAnswerSection(), index), optionsText);
+    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)
     },
 
     /**
-    * @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()
+     * 
+     * @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
+     */
+    clickAndReorderOptionInSetCorrectAnswerSection: (optionsText, index) => {
+        listOrderingPage.setCorrectAnswerSectionOption()
             .contains(optionsText)
-            .parents('.orderlist-option-wrapper')
-            .within(() => {
-                utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.correctIcon(), 'exist');
-            });
+            .click();
+        listOrderingPage.setCorrectAnswerSectionOption()
+            .eq(index)
+            .click();
     },
 
+    verifyPointsInputFieldErrorMessage: () => {
+        commonComponents.errorMessage()
+            .eq(0)
+            .should('have.text', 'Error: Please enter points.');
+    },
+
+    //Preview tab
     /**
-    * @param {string} optionsText option to be checked for the correct icon
-    * @description This function verifies the correct icon in the preview tab
+    * @param {number} index set correct answer option index
+    * @description this function verfies contents of options
     */
-    verifyIncorrectOptionIcon: (optionsText) => {
-        listOrderingPage.optionWrapperPreviewTab()
-            .contains(optionsText)
-            .parents('.orderlist-option-wrapper')
+    verifyDragHandleButtonOfOptionInPreviewTab: (index) => {
+        listOrderingPage.previewTabOption()
+            .eq(index)
             .within(() => {
-                utilities.verifyElementVisibilityState(autoScoredScoringPreviewTab.incorrectIcon(), 'exist');
+                listOrderingPage.dragHandleButton()
+                    .should('exist');
             });
     },
 
-    verifyCorrectAnswerSectionNotExists: () => {
-        utilities.verifyElementVisibilityState(listOrderingPage.correctAnswersLabel(), 'notExist');
-        utilities.verifyElementVisibilityState(listOrderingPage.correctAnswerSectionAnswerWrapper(), 'notExist');
-    },
-
     /**
-     * @param {string[]} optionsTextArray array of options in the correct answer section
-     * @description this function verifies the correct order of options in correct answer section
+     * @param {string[]} optionsTextArray options array for set correct answer option
+     * @description this function verifies options text content
      */
-    verifyOptionsInCorrectAnswerSection: (optionsTextArray) => {
+    verifyTextContentOfOptionsInPreviewTab: (optionsTextArray) => {
         optionsTextArray.forEach((optionsText, index) => {
-            utilities.getNthElement(listOrderingPage.correctAnswerSectionAnswerWrapper(), index)
-                .within(() => {
-                    utilities.verifyTextContent(listOrderingPage.correctAnswerSectionAnswerText(), optionsText);
-                });
+            listOrderingPage.previewTabOption()
+                .eq(index)
+                .should('have.text', optionsText);
         });
     },
 
     /**
-    * @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.
+    * @param {number} index of option
+    * @description this function verifies image text in preview tab options
     */
-    verifyOptionWithImageInGradingView: (optionIndex) => {
-        listOrderingPage.optionGradingView()
-            .eq(optionIndex)
+    verifyImageAddedToOptionInPreviewTab: (index) => {
+        listOrderingPage.previewTabOption()
+            .eq(index)
             .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.
-     */
-    verifyOptionWithBoldTextInGradingView: (optionIndex) => {
-        listOrderingPage.optionGradingView()
-            .eq(optionIndex)
+    * @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)
             .find('strong')
-            .should('have.text', 'This is a bold option');
+            .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
     /**
-     * @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} 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);
+            });
     },
 
     /**
-     * @param {string[]} optionsTextArray options array for set correct answer option
-     * @description this function verifies options text content
+    * @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');
+            });
+    },
+
+    /**
+     * @param {number[]} pointsArray the array of points to be alloted to each option
+     * @description this function allots points to all the options
      */
-    verifyTextContentOfOptionInGradingView: (optionsText, index) => {
-        utilities.verifyTextContent(utilities.getNthElement(listOrderingPage.optionGradingView(), index), optionsText);
+    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');
     },
 
     /**
+     * 
      * @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
      */
-    clickAndReorderOptionInGradingView: (optionsText, index) => {
-        listOrderingPage.optionGradingView()
+    clickAndReorderOptionInPrevewTab: (optionsText, index) => {
+        listOrderingPage.previewTabOption()
             .contains(optionsText)
             .click();
-        listOrderingPage.optionGradingView()
+        listOrderingPage.previewTabOption()
             .eq(index)
             .click();
     },
 
     /**
-     * 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.
+     * 
+     * @param {string[]} optionsArray array of options set in options section
+     * @description this function resets the question preview
      */
-    verifyOptionsOrderInSpecifyCorrectAnswerSection: (optionsTextArray) => {
-        optionsTextArray.forEach((option, index) => {
-            utilities.verifyTextContent(utilities.getNthElement(listOrderingPage.optionSpecifyCorrectAnswerSection(), index), option);
-        });
+    resetQuestionPreview: (optionsArray) => {
+        createQuestionBasePage.steps.switchToEditTab();
+        createQuestionBasePage.steps.switchToPreviewTab();
+        listOrderingPage.steps.verifyTextContentOfOptionsInPreviewTab(optionsArray);
     },
 
     /**
-     * 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[]} 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);
+                });
         });
     },
 
     /**
-     * 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)
+    * @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');
+            });
+    },
+
+    /**
+    * @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()
     },
 
     getOptionsArray: () => {
         const optionsArray = []
-        listOrderingPage.optionPreviewTab()
+        listOrderingPage.previewTabOption()
             .each(($el) => {
                 cy.wrap($el)
                     .invoke('text')
@@ -309,325 +417,339 @@ const steps = {
     verifyRandomizeOptionOrder: (optionsArray) => {
         let currentOptionsArray = [...optionsArray]
         for (let index = 0; index < currentOptionsArray.length; index++) {
-            listOrderingPage.optionPreviewTab()
+            listOrderingPage.previewTabOption()
                 .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.optionPreviewTab()
+    verifyOptionsAreRerandomized: (previousOrderOfOptionsArray) => {
+        listOrderingPage.previewTabOption()
             .should('not.have.text', '')
             .and('not.have.text', previousOrderOfOptionsArray.join(''));
     },
 
-    verifyOuterBorderOfQuestionPreview: () => {
-        utilities.verifyCSS(listOrderingPage.questionBorderPreviewTab(), {
-            'border': `1px solid ${css.color.draggableOptionsContainerBorder}`
-        });
+    /**
+    * @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');
+            });
     },
 
-    verifyOuterBorderOfQuestionPreviewNotExists: () => {
-        listOrderingPage.questionBorderPreviewTab()
-            .should('have.css', 'border')
-            .and('match', /0px none/);
+    /**
+    * @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');
+            });
     },
 
-    verifyEnableOuterBorderForQuestionCheckboxCheckedState: () => {
-        listOrderingPage.enableOuterBorderForQuestionCheckbox()
-            .should('be.checked');
+    //Additional settings
+
+    verifyNoBorderForSetCorrectAnswerOption: () => {
+        listOrderingPage.setCorrectAnswerSectionOption()
+            .eq(0)
+            .should('have.css', 'border')
+            .and('match', /0px none/);
     },
 
-    verifyEnableOuterBorderForQuestionCheckboxUncheckedState: () => {
-        listOrderingPage.enableOuterBorderForQuestionCheckbox()
-            .should('not.be.checked');
+    verifyNoBorderForPreviewTabOption: () => {
+        listOrderingPage.previewTabOption()
+            .eq(0)
+            .should('have.css', 'border')
+            .and('match', /0px none/);
     },
 
-    checkEnableOuterBorderForQuestionCheckbox: () => {
-        listOrderingPage.enableOuterBorderForQuestionCheckbox()
-            .click()
-            .should('be.checked');
+    clickOnSetPointsButton: () => {
+        listOrderingPage.buttonSetPoints()
+            .click();
     },
 
-    uncheckEnableOuterBorderForQuestionCheckbox: () => {
-        listOrderingPage.enableOuterBorderForQuestionCheckbox()
-            .click()
-            .should('not.be.checked');
+    verifySetPointsButton: () => {
+        utilities.verifyInnerText(listOrderingPage.buttonSetPoints(), 'Set points');
+        utilities.verifyElementVisibilityState(listOrderingPage.setPointsIcon(), 'visible');
     },
 
     /**
-     * @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)
+       * @param {number} index of option
+       * @description this function verifies image in set points popup
+       */
+    verifyImageAddedToOptionInSetPointsPopup: (index) => {
+        setPointsPopupBase.setPointsPopupOptions()
+            .eq(index)
             .find('img')
             .should('have.attr', 'src', constants.foxImageLink)
             .and('have.attr', 'alt', constants.foxImageAltText);
     },
 
     /**
-     * @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)
+    * @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()
             .find('[role="math"]')
             .should('have.attr', 'aria-label', constants.CKEditorInputFieldEnteredEquationAriaLabel)
-            .contains(constants.CKEditorInputFieldEnteredEquationText);
-    },
-
-    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();
     },
 
     /**
-     * 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.
+     * @param {number} index of option
+     * @description this function link in set points popup
      */
-    expandPositionDropdownSpecifyCorrectAnswerSection: (dropdownIndex) => {
-        utilities.getNthElement(listOrderingPage.positionDropdownSpecifyCorrectAnswerSection(), dropdownIndex)
-            .click();
+    verifyLinkAddedToOptionInSetPointsPopup: (index) => {
+        setPointsPopupBase.setPointsPopupOptions()
+            .eq(index)
+            .should('have.text', 'lorem')
+            .find('a')
+            .should('have.attr', 'href', `${Cypress.config().baseUrl}`)
     },
 
     /**
-     * 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();
+    * @param {number} index of option
+    * @description this function bold text in in set points popup
+    */
+    verifyBoldTextAddedToOptionInSetPointsPopup: (index) => {
+        setPointsPopupBase.setPointsPopupOptions()
+            .eq(index)
+            .find('strong')
+            .eq(0)
+            .should('have.text', 'This is a bold option');
     },
 
     /**
-     * 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.
+     * @param {number[]} numerationArray numeration array for the option
+     * @description this function checks the numeration of options in set points popup
      */
-    selectPositionForAllOptionsSpecifyCorrectAnswerSection: (positionObject) => {
-        positionObject.forEach(({ optionIndex, position }) => {
-            steps.selectOptionPositionSpecifyCorrectAnswerSection(optionIndex, position)
+    verifySetPointsPopupOptionNumeration: (numerationArray) => {
+        numerationArray.forEach((optionNumeration, index) => {
+            setPointsPopupBase.dialogBox()
+                .within(() => {
+                    listOrderingPage.optionNumeration()
+                        .eq(index)
+                        .should('have.text', optionNumeration);
+                });
         });
     },
 
-    /**
-     * 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();
-    },
+    verifyCorrectIncorrectAnswerLabel: (labelText) => {
+        autoScoredPreviewBase.correctIncorrectAnswerLabel()
+            .should('be.visible')
+            .verifyInnerText(`${labelText} answer`)
+            .parents('[class*="__AnswerStatusWrapper"]')
+            .find('[class*="__AnswerStatusIcon"]')
+            .should('be.visible')
+            .should('have.text', `${labelText}-Icon`)
+    }
+}
 
-    /**
-     * 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();
+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);
+            }
+        });
     },
 
     /**
-     * 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.
+     * @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
      */
-    selectPositionForAllOptionsPreviewTab: (positionObject) => {
-        positionObject.forEach(({ optionIndex, position }) => {
-            steps.selectOptionPositionPreviewTab(optionIndex, position)
+    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 {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
-    */
-    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);
+        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}`);
+        });
     },
 
     /**
-     * @description Verifies that the bold text in the Preview tab is correct.
-     * @param {number} optionIndex - The index of the option in the Preview tab.
+     * 
+     * @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
      */
-    verifyOptionWithBoldTextDropdownLayoutInGradingView: (optionIndex) => {
-        listOrderingPage.dropdownOptionWrapperGradingView()
-            .eq(optionIndex)
-            .find('strong')
-            .should('have.text', 'This is a bold option');
+    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();
+        });
     },
 
     /**
-     * @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 {*} 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();
+        });
     },
 
     /**
-     * @param {string[]} optionsTextArray options array for set correct answer option
-     * @description this function verifies options text content
+     * @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
      */
-    verifyTextContentOfOptionDropdownLayoutInGradingView: (optionsText, index) => {
-        utilities.verifyTextContent(utilities.getNthElement(listOrderingPage.dropdownOptionWrapperGradingView(), index), optionsText);
+    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}`);
+        });
     },
 
+    //Additional settings
     /**
-     * @param {string[]} optionsTextArray array of options in the correct answer section
-     * @description this function verifies the correct order of options in correct answer section
+     * @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
      */
-    verifyOptionsPositionInCorrectAnswerSection: (optionsTextArray, positionArray) => {
-        optionsTextArray.forEach((optionsText, index) => {
-            utilities.getNthElement(listOrderingPage.correctAnswerSectionAnswerWrapper(), index)
-                .within(() => {
-                    utilities.verifyTextContent(listOrderingPage.correctAnswerSectionAnswerText(), optionsText);
-                });
-        });
-        positionArray.forEach((position, dropdownIndex) => {
-            utilities.verifyTextContent(utilities.getNthElement(listOrderingPage.positionDropdownCorrectAnswerSection(), dropdownIndex), position);
+    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()
         });
     },
 
     /**
-     * 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);
-                }
-            });
-    },
-
-    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');
-    }
-}
-
-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);
-            });
+    * @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
+    */
+    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)
         });
-    },
+    }
 }
 
 export const listOrderingPage = {