itemengine-cypress-automation 1.0.2

package/cypress/pages/listSortingPage.js

@@ -0,0 +1,1201 @@
+import constants from "../fixtures/constants";
+import utilities from "../support/helpers/utilities";
+import { additionalSettingsPanel, answerNumerationComponent, autoScoredAdditionalSettings, autoScoredPreviewBase, autoScoredScoringSection, autoScoredScoringSectionMultipleResponsesType, autoScoredSetCorrectAnswerSection, ckEditorToolbar, commonComponents, createQuestionBasePage, equationEditorFlyout, mcqOptionsComponent, optionsWrapperComponent, previewScoringAndShowCorrectAnswerComponent, questionInstructionsComponent, scoringSectionBase, studentResponseAndLayoutComponent } from "./components"
+import { listSortingAndOrderingBase } from "./components/listSortingAndOrderingBase";
+const css = Cypress.env('css');
+
+const selectors = {
+    ...optionsWrapperComponent,
+    ...commonComponents,
+    ...scoringSectionBase,
+    ...autoScoredScoringSectionMultipleResponsesType,
+    ...autoScoredSetCorrectAnswerSection,
+    ...listSortingAndOrderingBase,
+    ...autoScoredAdditionalSettings,
+    ...listSortingAndOrderingBase,
+    ...answerNumerationComponent,
+    ...additionalSettingsPanel,
+    ...autoScoredPreviewBase,
+    setCorrectAnswerSectionOption: () => cy.get('.draggable-item-wrapper'),
+    //Update once https://redmine.zeuslearning.com/issues/518498 is resolved
+    setCorrectAnswerSectionSourceOptionWrapper: () => cy.get('[class*="SourceColumnHeader"]').parents('[class*="ContextWrapper"]').find('[class*="ListSortingResponsestyles__DroppableDiv"]'),
+    setCorrectAnswerSectionTargetOptionWrapper: () => cy.get('[class*="TargetColumnHeader"]').parents('[class*="ContextWrapper"]').find('[class*="ListSortingResponsestyles__DroppableDiv"]'),
+    previewTabOption: () => cy.get('.edit-question-preview-wrapper .draggable-item-wrapper'),
+    previewTabSourceOptionWrapper: () => cy.get('.edit-question-preview-wrapper [class*="SourceColumnHeader"]').parents('[class*="ContextWrapper"]').find('[class*="ListSortingResponsestyles__DroppableDiv"]'),
+    previewTabTargetOptionWrapper: () => cy.get('.edit-question-preview-wrapper [class*="TargetColumnHeader"]').parents('[class*="ContextWrapper"]').find('[class*="ListSortingResponsestyles__DroppableDiv"]'),
+    dragHandleButton: () => cy.get('[class*="DragIcon"]'),
+    pointsPerResponseLabel: () => cy.get('[class*="ListSortingResponsestyles__PointsPerResponseLabel"]'),
+    partialEqualWeightsPointsPerResponseScore: () => cy.get('[class*="ListSortingResponsestyles__EqualPoints"]'),
+    //Set Correct answer section
+    labelsLabel: () => cy.get('.label-header'),
+    unsortedColumnLabel: () => cy.get('.text-label').eq(0),
+    sortedColumnLabel: () => cy.get('.text-label').eq(1),
+    unsortedColumnInputField: () => cy.get('.short-text-response-input-field input').eq(0),
+    sortedColumnInputField: () => cy.get('.short-text-response-input-field input').eq(1),
+    setCorrectAnswerSectionUnsortedColumnHeader: () => cy.get('[class*="SourceColumnHeader"]'),
+    setCorrectAnswerSectionSortedColumnHeader: () => cy.get('[class*="TargetColumnHeader"]'),
+    previewTabUnsortedColumnHeader: () => cy.get('.edit-question-preview-wrapper [class*="SourceColumnHeader"]'),
+    previewTabSortedColumnHeader: () => cy.get('.edit-question-preview-wrapper [class*="TargetColumnHeader"]'),
+    setCorrectAnswerSectionButtonLeftArrow: () => cy.get('.icon-arrow-button-left'),
+    setCorrectAnswerSectionButtonRightArrow: () => cy.get('.icon-arrow-button-right'),
+    previewTabButtonLeftArrow: () => cy.get('.edit-question-preview-wrapper .icon-arrow-button-left'),
+    previewTabButtonRightArrow: () => cy.get('.edit-question-preview-wrapper .icon-arrow-button-right'),
+    //Additional Settings
+    setCorrectAnswerSectionTopLabel: () => cy.get('[class*="__TopLabel-"]'),
+    setCorrectAnswerSectionBottomLabel: () => cy.get('[class*="__BottomLabel-"]'),
+    previewTabTopLabel: () => cy.get('.edit-question-preview-wrapper [class*="__TopLabel-"]'),
+    previewTabBottomLabel: () => cy.get('.edit-question-preview-wrapper [class*="__BottomLabel-"]'),
+    optionStyleNumeration: () => cy.get('[class*="OptionIndexWrapper"]')
+}
+
+const steps = {
+    ...createQuestionBasePage.steps,
+    ...questionInstructionsComponent.steps,
+    ...optionsWrapperComponent.steps,
+    ...scoringSectionBase.steps,
+    ...autoScoredSetCorrectAnswerSection.steps,
+    ...mcqOptionsComponent.steps,
+    ...commonComponents.steps,
+    ...ckEditorToolbar.steps,
+    ...equationEditorFlyout.steps,
+    ...listSortingAndOrderingBase.steps,
+    ...previewScoringAndShowCorrectAnswerComponent.steps,
+    ...autoScoredScoringSection.steps,
+    ...additionalSettingsPanel.steps,
+    ...autoScoredAdditionalSettings.steps,
+    ...autoScoredPreviewBase.steps,
+    ...autoScoredScoringSectionMultipleResponsesType.steps,
+    ...answerNumerationComponent.steps,
+    /**
+     * @param {number} index set correct answer option index
+     * @description this function verfies contents of options
+     */
+    verifyDragHandleButtonOfOptionInSetCorrectAnswerSection: (index) => {
+        listSortingPage.setCorrectAnswerSectionOption()
+            .eq(index)
+            .within(() => {
+                listSortingPage.dragHandleButton()
+                    .should('exist');
+            });
+    },
+
+    /**
+     * @param {string[]} optionsTextArray options array for set correct answer option
+     * @description this function verifies options text content
+     */
+    verifySourceOptionsTextContentInSetCorrectAnswerSection: (optionsTextArray) => {
+        optionsTextArray.forEach((optionsText, index) => {
+            listSortingPage.setCorrectAnswerSectionSourceOptionWrapper()
+                .eq(index)
+                .verifyInnerText(optionsText);
+        });
+    },
+
+    /**
+    * @param {string[]} optionsTextArray options array for set correct answer option
+    * @description this function verifies options text content
+    */
+    verifyTargetOptionsTextContentInSetCorrectAnswerSection: (optionsTextArray) => {
+        optionsTextArray.forEach((optionsText, index) => {
+            listSortingPage.setCorrectAnswerSectionTargetOptionWrapper()
+                .eq(index)
+                .verifyInnerText(optionsText);
+        });
+    },
+
+    /**
+   * @param {string} optionsText text content of the option
+   * @param {number} targetIndex the position at which the options is being dropped in the target section
+   * @description click and drop a option into a position in the set correct answer section
+   */
+    clickAndDropOptionFromSourceToTargetInSetCorrectAnswerSection: (optionsText, targetIndex) => {
+        listSortingPage.setCorrectAnswerSectionSourceOptionWrapper()
+            .contains(optionsText)
+            .click();
+        listSortingPage.setCorrectAnswerSectionTargetOptionWrapper()
+            .eq(targetIndex)
+            .click();
+    },
+
+    /**
+    * @param {string} optionsText text content of the option
+    * @param {number} sourceIndex the position at which the options is being dropped in the source section
+    * @description click and drop a option into a position in the set correct answer section
+    */
+    clickAndDropOptionFromTargetToSourceInSetCorrectAnswerSection: (optionsText, sourceIndex) => {
+        listSortingPage.setCorrectAnswerSectionTargetOptionWrapper()
+            .contains(optionsText)
+            .click();
+        listSortingPage.setCorrectAnswerSectionSourceOptionWrapper()
+            .eq(sourceIndex)
+            .click();
+    },
+
+    /**
+     * @param {number} sourceIndex index of the source option wrapper
+     * @param {number} targetIndex index of the target option wrapper
+     * @description click and drop a option into a position in the set correct answer section
+     */
+    clickAndDropOptionFromSourceIndexToTargetIndexInSetCorrectAnswerSection: (sourceIndex, targetIndex) => {
+        listSortingPage.setCorrectAnswerSectionSourceOptionWrapper()
+            .eq(sourceIndex)
+            .click();
+        listSortingPage.setCorrectAnswerSectionTargetOptionWrapper()
+            .eq(targetIndex)
+            .click();
+    },
+
+    /**
+     * @param {number} index of option
+     * @description this function verifies image in set correct answer option input field
+     */
+    verifyImageOptionInSetCorrectAnswerSection: (index) => {
+        listSortingPage.setCorrectAnswerSectionOption()
+            .eq(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 in set correct answer option input field
+     */
+    verifyEquationOptionInSetCorrectAnswerSection: (index) => {
+        listSortingPage.setCorrectAnswerSectionOption()
+            .eq(index)
+            .contains(constants.CKEditorInputFieldEnteredEquationText)
+        listSortingPage.setCorrectAnswerSectionOption()
+            .find('[role="math"]')
+            .should('have.attr', 'aria-label', constants.CKEditorInputFieldEnteredEquationAriaLabel)
+    },
+
+    /**
+     * @param {number} index of option
+     * @description this function link in set correct answer option input field
+     */
+    verifyLinkOptionInSetCorrectAnswerSection: (index) => {
+        listSortingPage.setCorrectAnswerSectionOption()
+            .eq(index)
+            .should('have.text', 'lorem')
+            .find('a')
+            .should('have.attr', 'href', `${Cypress.config().baseUrl}`)
+    },
+
+    /**
+     * @param {number} index of option
+     * @description this function bold text in set correct answer option input field
+     */
+    verifyBoldTextOptionInSetCorrectAnswerSection: (index) => {
+        listSortingPage.setCorrectAnswerSectionOption()
+            .eq(index)
+            .find('strong')
+            .eq(0)
+            .should('have.text', 'This is a bold option');
+    },
+
+    verifyImageEquationLinkBoldTextInSetCorrectAnswerSectionSourceOption: () => {
+        listSortingPage.setCorrectAnswerSectionSourceOptionWrapper()
+            .eq(0)
+            .parents('[class*="ListSortingResponsestyles__ContextWrapper"]')
+            .within(() => {
+                steps.verifyImageOptionInSetCorrectAnswerSection(0)
+                steps.verifyEquationOptionInSetCorrectAnswerSection(1)
+                steps.verifyLinkOptionInSetCorrectAnswerSection(2)
+                steps.verifyBoldTextOptionInSetCorrectAnswerSection(3)
+            });
+    },
+
+    verifyImageEquationLinkBoldTextInSetCorrectAnswerSectionTargetOption: () => {
+        listSortingPage.setCorrectAnswerSectionTargetOptionWrapper()
+            .eq(0)
+            .parents('[class*="ListSortingResponsestyles__ContextWrapper"]')
+            .within(() => {
+                steps.verifyImageOptionInSetCorrectAnswerSection(0)
+                steps.verifyEquationOptionInSetCorrectAnswerSection(1)
+                steps.verifyLinkOptionInSetCorrectAnswerSection(2)
+                steps.verifyBoldTextOptionInSetCorrectAnswerSection(3)
+            });
+    },
+
+    verifyDefaultAndActiveStateOfOptionInSetCorrectAnswerSection: () => {
+        listSortingPage.setCorrectAnswerSectionOption()
+            .eq(0)
+            .realHover()
+            .should('have.css', 'border', `2px solid ${css.color.activeButtons}`)
+            .find('.question-text-wrapper')
+            .and('have.css', 'color', css.color.activeButtons);
+        listSortingPage.setCorrectAnswerSectionOption()
+            .eq(0)
+            .realHover({ position: 'topLeft' })
+            .should('have.css', 'border', `1px solid ${css.color.figDefaultComponentBorder}`);
+    },
+
+    //Preview tab
+    /**
+    * @param {number} index set correct answer option index
+    * @description this function verfies contents of options
+    */
+    verifyDragHandleButtonOfOptionInPreviewTab: (index) => {
+        listSortingPage.previewTabOption()
+            .eq(index)
+            .within(() => {
+                listSortingPage.dragHandleButton()
+                    .should('exist');
+            });
+    },
+
+
+    /**
+     * @param {string[]} optionsTextArray options array for set correct answer option
+     * @description this function verifies options text content
+     */
+    verifySourceOptionsTextContentInPreviewTab: (optionsTextArray) => {
+        optionsTextArray.forEach((optionsText, index) => {
+            listSortingPage.previewTabSourceOptionWrapper()
+                .eq(index)
+                .verifyInnerText(optionsText);
+        });
+    },
+
+    /**
+    * @param {string[]} optionsTextArray options array for set correct answer option
+    * @description this function verifies options text content
+    */
+    verifyTargetOptionsTextContentInPreviewTab: (optionsTextArray) => {
+        optionsTextArray.forEach((optionsText, index) => {
+            listSortingPage.previewTabTargetOptionWrapper()
+                .eq(index)
+                .verifyInnerText(optionsText);
+        });
+    },
+
+    /**
+    * @param {string} optionsText text content of the option
+    * @param {number} targetIndex the position at which the options is being dropped in the target section
+    * @description click and drop a option into a position in the previewTab
+    */
+    clickAndDropOptionFromSourceToTargetInPreviewTab: (optionsText, targetIndex) => {
+        listSortingPage.previewTabSourceOptionWrapper()
+            .contains(optionsText)
+            .click();
+        listSortingPage.previewTabTargetOptionWrapper()
+            .eq(targetIndex)
+            .click();
+    },
+
+    /**
+    * @param {string} optionsText text content of the option
+    * @param {number} sourceIndex the position at which the options is being dropped in the source section
+    * @description click and drop a option into a position in the set correct answer section
+    */
+    clickAndDropOptionFromTargetToSourceInPreviewTab: (optionsText, sourceIndex) => {
+        listSortingPage.previewTabTargetOptionWrapper()
+            .contains(optionsText)
+            .click();
+        listSortingPage.previewTabSourceOptionWrapper()
+            .eq(sourceIndex)
+            .click();
+    },
+
+    /**
+     * @param {number} sourceIndex index of the source option wrapper
+     * @param {number} targetIndex index of the target option wrapper
+     * @description click and drop a option into a position in the previewTab
+     */
+    clickAndDropOptionFromSourceIndexToTargetIndexInPreviewTab: (sourceIndex, targetIndex) => {
+        listSortingPage.previewTabSourceOptionWrapper()
+            .eq(sourceIndex)
+            .click();
+        listSortingPage.previewTabTargetOptionWrapper()
+            .eq(targetIndex)
+            .click();
+    },
+
+    verifyImageEquationLinkBoldTextInPreviewTabSourceOption: () => {
+        listSortingPage.previewTabSourceOptionWrapper()
+            .eq(0)
+            .parents('[class*="ListSortingResponsestyles__ContextWrapper"]')
+            .within(() => {
+                steps.verifyImageOptionInSetCorrectAnswerSection(0)
+                steps.verifyEquationOptionInSetCorrectAnswerSection(1)
+                steps.verifyLinkOptionInSetCorrectAnswerSection(2)
+                steps.verifyBoldTextOptionInSetCorrectAnswerSection(3)
+            });
+    },
+
+    verifyImageEquationLinkBoldTextInPreviewTabTargetOption: () => {
+        listSortingPage.previewTabTargetOptionWrapper()
+            .eq(0)
+            .parents('[class*="ListSortingResponsestyles__ContextWrapper"]')
+            .within(() => {
+                steps.verifyImageOptionInSetCorrectAnswerSection(0)
+                steps.verifyEquationOptionInSetCorrectAnswerSection(1)
+                steps.verifyLinkOptionInSetCorrectAnswerSection(2)
+                steps.verifyBoldTextOptionInSetCorrectAnswerSection(3)
+            });
+    },
+
+    verifyDefaultAndActiveStateOfOptionInPreviewTab: () => {
+        listSortingPage.previewTabOption()
+            .eq(0)
+            .realHover()
+            .should('have.css', 'border', `2px solid ${css.color.activeButtons}`)
+            .find('.question-text-wrapper')
+            .and('have.css', 'color', css.color.activeButtons);
+        listSortingPage.previewTabOption()
+            .eq(0)
+            .realHover({ position: 'topLeft' })
+            .should('have.css', 'border', `1px solid ${css.color.figDefaultComponentBorder}`);
+    },
+
+    /**
+    * @param {string} optionsText option to be checked for the correct icon
+    * @description This function verifies the correct icon in the preview tab
+    */
+    verifyCorrectOptionsCheckmarkIcon: (optionsText) => {
+        listSortingPage.previewTabTargetOptionWrapper()
+            .contains(optionsText)
+            .parents('[class*="ListSortingResponsestyles__TargetWrapper"]')
+            .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) => {
+        listSortingPage.previewTabTargetOptionWrapper()
+            .contains(optionsText)
+            .parents('[class*="ListSortingResponsestyles__TargetWrapper"]')
+            .within(() => {
+                autoScoredPreviewBase.incorrectIcon()
+                    .and('be.visible');
+            });
+    },
+
+    /**
+    * @param {number[]} pointsArray the array of points to be alloted to each option
+    * @description this function allots points to all the options
+    */
+    allotPartialDifferentWeightsToAllPointsFields: (pointsArray) => {
+        pointsArray.forEach((points, optionIndex) => {
+            scoringSectionBase.pointsInputField()
+                .eq(optionIndex)
+                .clear()
+                .type(points, { delay: 0 })
+                .should('have.value', points);
+        });
+    },
+
+    verifyPartialDifferentWeightsPointsInputFieldIsEmptyAndEnabled: () => {
+        scoringSectionBase.pointsInputField()
+            .each(($element) => {
+                cy.wrap($element)
+                    .should('have.value', '')
+                    .and('be.visible')
+                    .and('be.enabled');
+            });
+    },
+
+    /**
+    * @param {number} points points displayed in partial equal weights points per response
+    * @description Verify points displayed in partial equal weights points per response
+    */
+    verifyPartialEqualWeightsPointsPerResponseScore: (points) => {
+        listSortingPage.partialEqualWeightsPointsPerResponseScore()
+            .each(($element) => {
+                cy.wrap($element)
+                    .verifyInnerText(`${points}`);
+            });
+    },
+
+    verifyPointsInputFieldErrorMessage: () => {
+        commonComponents.errorMessage()
+            .eq(0)
+            .should('have.text', 'Error: Please enter points.');
+    },
+
+    verifySetCorrectAnswerErrorMessage: () => {
+        commonComponents.errorMessage()
+            .eq(1)
+            .should('have.text', 'Error: Please set a correct answer.');
+    },
+
+    clearUnsortedColumnInputField: () => {
+        listSortingPage.unsortedColumnInputField()
+            .clear();
+    },
+
+    clearSortedColumnInputField: () => {
+        listSortingPage.sortedColumnInputField()
+            .clear();
+    },
+
+    verifyUnsortedColumnInputFieldErrorMessage: () => {
+        listSortingPage.unsortedColumnInputField()
+            .parents('[class*="ListSortingstyle__InputFieldWrapper"]')
+            .within(() => {
+                commonComponents.errorMessage()
+                    .verifyInnerText('Error: Please enter label.')
+            });
+    },
+
+    verifySortedColumnInputFieldErrorMessage: () => {
+        listSortingPage.sortedColumnInputField()
+            .parents('[class*="ListSortingstyle__InputFieldWrapper"]')
+            .within(() => {
+                commonComponents.errorMessage()
+                    .verifyInnerText('Error: Please enter label.')
+            });
+    },
+
+    addInputToUnsortedColumnInputField: (inputText) => {
+        listSortingPage.unsortedColumnInputField()
+            .type(inputText)
+            .should('have.value', inputText);
+    },
+
+    addInputToSortedColumnInputField: (inputText) => {
+        listSortingPage.sortedColumnInputField()
+            .type(inputText)
+            .should('have.value', inputText);
+    },
+
+    verifyUnsortedColumnInputField: (inputText) => {
+        listSortingPage.unsortedColumnInputField()
+            .should('have.value', inputText);
+    },
+
+    verifySortedColumnInputField: (inputText) => {
+        listSortingPage.sortedColumnInputField()
+            .should('have.value', inputText);
+    },
+
+    getOptionsArray: () => {
+        const optionsArray = []
+        listSortingPage.previewTabOption()
+            .each(($el) => {
+                cy.wrap($el)
+                    .invoke('text')
+                    .then((text) => {
+                        optionsArray.push(text);
+                    });
+            });
+        return optionsArray;
+    },
+
+    /**
+     * @param {string[]} optionsArray array of options set in the options section
+     * @description this function verifies if the options are Randomized in the preview tab
+     */
+    verifyRandomizeOptionOrder: (optionsArray) => {
+        let currentOptionsArray = [...optionsArray]
+        for (let index = 0; index < currentOptionsArray.length; index++) {
+            listSortingPage.previewTabOption()
+                .eq(index)
+                .then(($element) => {
+                    expect($element.text()).to.be.oneOf(currentOptionsArray);
+                    currentOptionsArray = currentOptionsArray.filter((value) => value !== $element.text())
+                });
+        };
+        listSortingPage.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) => {
+        listSortingPage.previewTabOption()
+            .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) => {
+        listSortingPage.setCorrectAnswerSectionOption()
+            .eq(index)
+            .within(() => {
+                commonComponents.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) => {
+        listSortingPage.previewTabOption()
+            .eq(index)
+            .within(() => {
+                commonComponents.dragHandleButton()
+                    .should('not.exist');
+            });
+    },
+
+    //Click and drop
+    //Need to update functions once - https://redmine.zeuslearning.com/issues/541167 is resolved
+    /**
+     * @param {number} index of the source option
+     * @description this function verifies if the option is active or inactive
+     */
+    verifyActiveStateOfSourceOptionWrapperSetCorrectAnswerSection: (index) => {
+        listSortingPage.setCorrectAnswerSectionSourceOptionWrapper()
+            .eq(index)
+            .should('have.class', 'isActive')
+            .find('[class*="DroppableWrapper"]')
+            .should('have.attr', 'tabindex', '0')
+    },
+
+    /**
+    * @param {number} index of the source option
+    * @description this function verifies if the option is active or inactive
+    */
+    verifyActiveStateOfTargetOptionWrapperSetCorrectAnswerSection: (index) => {
+        listSortingPage.setCorrectAnswerSectionTargetOptionWrapper()
+            .eq(index)
+            .should('have.class', 'isActive')
+            .find('[class*="DroppableWrapper"]')
+            .should('have.attr', 'tabindex', '0')
+    },
+
+    /**
+    * @param {number} index of the source option
+    * @description this function verifies if the option is active or inactive
+    */
+    verifyInactiveStateOfSourceOptionWrapperSetCorrectAnswerSection: (index) => {
+        listSortingPage.setCorrectAnswerSectionSourceOptionWrapper()
+            .eq(index)
+            .find('[class*="DroppableWrapper"]')
+            .should('have.attr', 'tabindex', '-1')
+    },
+
+    /**
+    * @param {number} index of the source option
+    * @description this function verifies if the option is active or inactive
+    */
+    verifyInactiveStateOfTargetOptionWrapperSetCorrectAnswerSection: (index) => {
+        listSortingPage.setCorrectAnswerSectionTargetOptionWrapper()
+            .eq(index)
+            .find('[class*="DroppableWrapper"]')
+            .should('have.attr', 'tabindex', '-1')
+    },
+
+    /**
+    * @param {number} index of the source option
+    * @description verify inactive state of source option
+    */
+    verifyInactiveStateOfSourceOptionWrapperPreviewTab: (index) => {
+        listSortingPage.previewTabSourceOptionWrapper()
+            .eq(index)
+            .find('[class*="DroppableWrapper"]')
+            .should('have.attr', 'tabindex', '-1');
+    },
+
+    /**
+    * @param {number} index of the source option
+    * @description verify inactive state of target option
+    */
+    verifyInactiveStateOfTargetOptionWrapperPreviewTab: (index) => {
+        listSortingPage.previewTabTargetOptionWrapper()
+            .eq(index)
+            .find('[class*="DroppableWrapper"]')
+            .should('have.attr', 'tabindex', '-1');
+    },
+
+    /**
+    * @param {number} index of the source option
+    * @description verify active state of source option
+    */
+    verifyActiveStateOfSourceOptionWrapperPreviewTab: (index) => {
+        listSortingPage.previewTabSourceOptionWrapper()
+            .eq(index)
+            .should('have.class', 'isActive')
+            .find('[class*="DroppableWrapper"]')
+            .should('have.attr', 'tabindex', '0');
+    },
+
+    /**
+    * @param {number} index of the source option
+    * @description verify active state of target option
+    */
+    verifyActiveStateOfTargetOptionWrapperPreviewTab: (index) => {
+        listSortingPage.previewTabTargetOptionWrapper()
+            .eq(index)
+            .should('have.class', 'isActive')
+            .find('[class*="DroppableWrapper"]')
+            .should('have.attr', 'tabindex', '0');
+    },
+
+    /**
+    * @param index of set correct answer section option
+    * @description This function selects an option from set correct answer section
+    */
+    selectSourceOptionSetCorrectAnswerSection: (index) => {
+        listSortingPage.setCorrectAnswerSectionSourceOptionWrapper()
+            .eq(index)
+            .click();
+    },
+
+    /**
+   * @param index of set correct answer section option
+   * @description This function selects an option from set correct answer section
+   */
+    selectTargetOptionSetCorrectAnswerSection: (index) => {
+        listSortingPage.setCorrectAnswerSectionTargetOptionWrapper()
+            .eq(index)
+            .click();
+    },
+
+    /**
+     * @param {number} index of set correct answer section option
+     * @description this function verifies active state of source option wrapper
+     */
+    verifyActiveStateOfSourceOptionSetCorrectAnswerSection: (index) => {
+        listSortingPage.setCorrectAnswerSectionSourceOptionWrapper()
+            .eq(index)
+            .within(() => {
+                listSortingPage.setCorrectAnswerSectionOption()
+                    .should('have.class', 'isSelected')
+                    .should('have.css', 'border')
+                    .and('match', /2px solid/)
+            });
+        listSortingPage.setCorrectAnswerSectionSourceOptionWrapper()
+            .eq(index)
+            .within(() => {
+                listSortingPage.setCorrectAnswerSectionOption()
+                    .within(() => {
+                        listSortingPage.dragHandleButton()
+                            .find('svg')
+                            .should('have.css', 'border')
+                            .and('match', /2px solid/)
+                    });
+            });
+    },
+
+    /**
+     * @param {number} index of set correct answer section option
+     * @description this function verifies active state of target option wrapper
+     */
+    verifyActiveStateOfTargetOptionSetCorrectAnswerSection: (index) => {
+        listSortingPage.setCorrectAnswerSectionTargetOptionWrapper()
+            .eq(index)
+            .within(() => {
+                listSortingPage.setCorrectAnswerSectionOption()
+                    .eq(index)
+                    .should('have.class', 'isSelected')
+                    .should('have.css', 'border')
+                    .and('match', /2px solid/)
+            });
+        listSortingPage.setCorrectAnswerSectionTargetOptionWrapper()
+            .eq(index)
+            .within(() => {
+                listSortingPage.setCorrectAnswerSectionOption()
+                    .within(() => {
+                        listSortingPage.dragHandleButton()
+                            .find('svg')
+                            .should('have.css', 'border')
+                            .and('match', /2px solid/)
+                    });
+            });
+    },
+
+    /**
+     * @param {number} index of set correct answer section option
+     * @description this function verifies inactive state of source option wrapper
+     */
+    verifyInactiveStateOfSourceOptionSetCorrectAnswerSection: (index) => {
+        listSortingPage.setCorrectAnswerSectionSourceOptionWrapper()
+            .eq(index)
+            .within(() => {
+                listSortingPage.setCorrectAnswerSectionOption()
+                    .should('not.have.class', 'isSelected')
+                    .should('have.css', 'border', `1px solid ${css.color.figDefaultComponentBorder}`)
+                    .within(() => {
+                        listSortingPage.dragHandleButton()
+                            .find('svg')
+                            .should('have.css', 'border')
+                            .and('match', /0px none/);
+                    });
+            });
+    },
+
+    /**
+     * @param index of preview tab option
+     * @description this function clicks on preview source wrapper
+     */
+    selectSourceOptionPreviewTab: (index) => {
+        listSortingPage.previewTabSourceOptionWrapper()
+            .eq(index)
+            .click();
+    },
+
+    /**
+     * @param index of preview tab option
+     * @description this function clicks on preview target wrapper
+     */
+    selectTargetOptionPreviewTab: (index) => {
+        listSortingPage.previewTabTargetOptionWrapper()
+            .eq(index)
+            .click();
+    },
+
+    /**
+     * @param {number} index of preview tab option
+     * @description this function verifies active state of source wrapper
+     */
+    verifyActiveStateOfSourceOptionPreviewTab: (index) => {
+        listSortingPage.previewTabSourceOptionWrapper()
+            .eq(index)
+            .within(() => {
+                listSortingPage.setCorrectAnswerSectionOption()
+                    .should('have.class', 'isSelected')
+                    .should('have.css', 'border')
+                    .and('match', /2px solid/)
+            });
+        listSortingPage.previewTabSourceOptionWrapper()
+            .eq(index)
+            .within(() => {
+                listSortingPage.setCorrectAnswerSectionOption()
+                    .within(() => {
+                        listSortingPage.dragHandleButton()
+                            .find('svg')
+                            .should('have.css', 'border')
+                            .and('match', /2px solid/);
+                    });
+            });
+    },
+
+    /**
+    * @param {number} index of preview tab option
+    * @description this function verifies active state of target wrapper
+    */
+    verifyActiveStateOfTargetOptionPreviewTab: (index) => {
+        listSortingPage.previewTabTargetOptionWrapper()
+            .eq(index)
+            .within(() => {
+                listSortingPage.setCorrectAnswerSectionOption()
+                    .should('have.class', 'isSelected')
+                    .should('have.css', 'border')
+                    .and('match', /2px solid/)
+            });
+        listSortingPage.previewTabTargetOptionWrapper()
+            .eq(index)
+            .within(() => {
+                listSortingPage.dragHandleButton()
+                    .find('svg')
+                    .should('have.css', 'border')
+                    .and('match', /2px solid/)
+            });
+    },
+
+    /**
+    * @param {number} index of preview tab option
+    * @description this function verifies inactive state of source wrapper
+    */
+    verifyInactiveStateOfSourceOptionPreviewTab: (index) => {
+        listSortingPage.previewTabSourceOptionWrapper()
+            .eq(index)
+            .within(() => {
+                listSortingPage.setCorrectAnswerSectionOption()
+                    .should('not.have.class', 'isSelected')
+                    .should('have.css', 'border', `1px solid ${css.color.figDefaultComponentBorder}`)
+                    .within(() => {
+                        listSortingPage.dragHandleButton()
+                            .find('svg')
+                            .should('have.css', 'border')
+                            .and('match', /0px none/);
+                    });
+            });
+    },
+
+    clickOnRightArrowKeySetCorrectAnswerSection: () => {
+        listSortingPage.setCorrectAnswerSectionButtonRightArrow()
+            .click();
+    },
+
+    clickOnLeftArrowKeySetCorrectAnswerSection: () => {
+        listSortingPage.setCorrectAnswerSectionButtonLeftArrow()
+            .click();
+    },
+
+    clickOnRightArrowKeyPreviewTab: () => {
+        listSortingPage.previewTabButtonRightArrow()
+            .click();
+    },
+
+    clickOnLeftArrowKeyPreviewTab: () => {
+        listSortingPage.previewTabButtonLeftArrow()
+            .click();
+    },
+
+    verifyRightArrowEnabledSetCorrectAnswerSection: () => {
+        listSortingPage.setCorrectAnswerSectionButtonRightArrow()
+            .should('have.class', 'isActive');
+    },
+
+    verifyRightArrowDisabledSetCorrectAnswerSection: () => {
+        listSortingPage.setCorrectAnswerSectionButtonRightArrow()
+            .should('not.have.class', 'isActive');
+    },
+
+    verifyLeftArrowEnabledSetCorrectAnswerSection: () => {
+        listSortingPage.setCorrectAnswerSectionButtonLeftArrow()
+            .should('have.class', 'isActive');
+    },
+
+    verifyLeftArrowDisabledSetCorrectAnswerSection: () => {
+        listSortingPage.setCorrectAnswerSectionButtonLeftArrow()
+            .should('not.have.class', 'isActive');
+    },
+
+    verifyRightArrowEnabledPreviewTab: () => {
+        listSortingPage.previewTabButtonRightArrow()
+            .should('have.class', 'isActive');
+    },
+
+    verifyRightArrowDisabledPreviewTab: () => {
+        listSortingPage.previewTabButtonRightArrow()
+            .should('not.have.class', 'isActive');
+    },
+
+    verifyLeftArrowEnabledPreviewTab: () => {
+        listSortingPage.previewTabButtonLeftArrow()
+            .should('have.class', 'isActive');
+    },
+
+    verifyLeftArrowDisabledPreviewTab: () => {
+        listSortingPage.previewTabButtonLeftArrow()
+            .should('not.have.class', 'isActive');
+    },
+
+    /**
+   * @param {string[]} numerationArray array of numeration numbers, lowercase, uppercase
+   * @description this function verifies the numeration of options
+   */
+    verifyOptionsNumerationSetCorrectAnswerSection: (numerationArray) => {
+        numerationArray.forEach((optionNumeration, index) => {
+            listSortingPage.setCorrectAnswerSectionTargetOptionWrapper()
+                .eq(index)
+                .within(() => {
+                    listSortingPage.optionStyleNumeration()
+                        .should('have.text', optionNumeration);
+                });
+        });
+    },
+
+    /**
+   * @param {string[]} numerationArray array of numeration numbers, lowercase, uppercase
+   * @description this function verifies the numeration of options
+   */
+    verifyOptionsNumerationPreviewTab: (numerationArray) => {
+        numerationArray.forEach((optionNumeration, index) => {
+            listSortingPage.previewTabTargetOptionWrapper()
+                .eq(index)
+                .within(() => {
+                    listSortingPage.optionStyleNumeration()
+                        .should('have.text', optionNumeration);
+                });
+        });
+    },
+
+    //TODO: Need to remove once -https://redmine.zeuslearning.com/issues/518498 is resolved
+    /**
+     * @param {string} labelText Correct|Incorrect
+     * @description this function verifies the border label and icon
+     */
+    verifyCorrectIncorrectAnswerLabel: (labelText) => {
+        autoScoredPreviewBase.correctIncorectAnswerLabel()
+            .should('be.visible')
+            .verifyInnerText(`${labelText} answer`)
+            .parents('[class*="__AnswerStatusWrapper"]')
+            .find('[class*="__AnswerStatusIcon"]')
+            .should('be.visible')
+            .should('have.text', `${labelText}-Icon`)
+    }
+}
+
+const tests = {
+    ...createQuestionBasePage.tests,
+    ...commonComponents.tests,
+    ...questionInstructionsComponent.tests,
+    ...listSortingAndOrderingBase.tests,
+    ...autoScoredScoringSection.tests,
+    ...previewScoringAndShowCorrectAnswerComponent.tests,
+    ...scoringSectionBase.tests,
+    ...autoScoredSetCorrectAnswerSection.tests,
+    ...additionalSettingsPanel.tests,
+    ...studentResponseAndLayoutComponent.tests,
+    ...answerNumerationComponent.tests,
+    ...autoScoredAdditionalSettings.tests,
+    verifyAllContentsOfSetCorrectAnswerSectionForScoringType: (scoringType, optionsArray) => {
+        it(`When user has selected ${scoringType} scoring type then added options should be displayed in the set correct answer section`, () => {
+            listSortingPage.steps.verifySourceOptionsTextContentInSetCorrectAnswerSection(optionsArray);
+            for (let index = 0; index < 4; index++) {
+                listSortingPage.steps.verifyDragHandleButtonOfOptionInSetCorrectAnswerSection(index);
+            }
+        });
+    },
+
+    verifyImageEquationLinkBoldTextInSetCorrectAnswerSection: () => {
+        it('When user adds an image, equation, text and link to the options input they should be displayed in the \'Set correct answer\' section along with drag handles', () => {
+            for (let index = 0; index < 4; index++) {
+                listSortingPage.steps.verifyDragHandleButtonOfOptionInSetCorrectAnswerSection(index)
+            }
+            listSortingPage.steps.verifyImageEquationLinkBoldTextInSetCorrectAnswerSectionSourceOption();
+        });
+
+        it('When user hovers on the option it should be displayed in active state and on removing the focus the option should return to the default state', () => {
+            listSortingPage.steps.verifyDefaultAndActiveStateOfOptionInSetCorrectAnswerSection()
+        });
+
+        //Failing due to https://redmine.zeuslearning.com/issues/537907
+        it('CSS of \'Set correct answer\' section when image, equation, text and link are added', { tags: 'css' }, () => {
+            utilities.verifyCSS(listSortingPage.setCorrectAnswerSectionOption().eq(0).find('img'), {
+                'color': css.color.text,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(listSortingPage.setCorrectAnswerSectionOption().eq(1).find('.question-text-wrapper'), {
+                'color': css.color.text,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(listSortingPage.setCorrectAnswerSectionOption().eq(2).find('a'), {
+                'color': css.color.linkText,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(listSortingPage.setCorrectAnswerSectionOption().eq(3).find('.question-text-wrapper'), {
+                'color': css.color.text,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+        });
+
+        it('Accessibility of \'Set correct answer\' section when image, equation, text and link are added', { tags: 'a11y' }, () => {
+            cy.checkAccessibility(listSortingPage.setCorrectAnswerSectionOption().eq(0).parents('.list-sorting-response-container'))
+        });
+
+        it('When user sets the order in target section then the options should be displayed in the target section of the Set correct answer section', () => {
+            listSortingPage.steps.clickAndDropOptionFromSourceIndexToTargetIndexInSetCorrectAnswerSection(0, 0);
+            listSortingPage.steps.clickAndDropOptionFromSourceIndexToTargetIndexInSetCorrectAnswerSection(1, 1);
+            listSortingPage.steps.clickAndDropOptionFromSourceIndexToTargetIndexInSetCorrectAnswerSection(2, 2);
+            listSortingPage.steps.clickAndDropOptionFromSourceIndexToTargetIndexInSetCorrectAnswerSection(3, 3);
+            listSortingPage.steps.verifyImageEquationLinkBoldTextInSetCorrectAnswerSectionTargetOption();
+        });
+    },
+
+    /**
+     * @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.allotMinimumScoreAwardedIfAttempted('1')
+            createQuestionBasePage.steps.switchToPreviewTab()
+            listSortingPage.steps.clickAndDropOptionFromSourceToTargetInPreviewTab('sprout', 0);
+            listSortingPage.steps.clickAndDropOptionFromSourceToTargetInPreviewTab('plant', 1);
+            listSortingPage.steps.clickAndDropOptionFromSourceToTargetInPreviewTab('flower', 2);
+            listSortingPage.steps.clickAndDropOptionFromSourceToTargetInPreviewTab('seed', 3);
+            listSortingPage.steps.verifyTargetOptionsTextContentInPreviewTab(['sprout', 'plant', 'flower', 'seed']);
+            listSortingPage.steps.verifyPreviewTabScoreText(1, `${totalPoints}`)
+        });
+
+        it('When user removes minimum score awarded (if attempted) points, then in Preview tab on selecting any options other than correct answers, points should not be provided', () => {
+            cy.log('Switch to edit tab and remove minimum score if attempted points')
+            createQuestionBasePage.steps.switchToEditTab();
+            scoringSectionBase.steps.clearMinimumScoreIfAttemptedPointsField();
+            createQuestionBasePage.steps.switchToPreviewTab()
+            listSortingPage.steps.clickAndDropOptionFromSourceToTargetInPreviewTab('sprout', 0);
+            listSortingPage.steps.clickAndDropOptionFromSourceToTargetInPreviewTab('plant', 1);
+            listSortingPage.steps.clickAndDropOptionFromSourceToTargetInPreviewTab('flower', 2);
+            listSortingPage.steps.clickAndDropOptionFromSourceToTargetInPreviewTab('seed', 3);
+            listSortingPage.steps.verifyTargetOptionsTextContentInPreviewTab(['sprout', 'plant', 'flower', 'seed']);
+            listSortingPage.steps.verifyPreviewTabScoreText(0, `${totalPoints}`)
+        });
+    },
+
+    /**
+     * 
+     * @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();
+            listSortingPage.steps.clickAndDropOptionFromSourceToTargetInPreviewTab('sprout', 0);
+            listSortingPage.steps.clickAndDropOptionFromSourceToTargetInPreviewTab('plant', 1);
+            listSortingPage.steps.clickAndDropOptionFromSourceToTargetInPreviewTab('flower', 2);
+            listSortingPage.steps.clickAndDropOptionFromSourceToTargetInPreviewTab('seed', 3);
+            listSortingPage.steps.verifyTargetOptionsTextContentInPreviewTab(['sprout', 'plant', 'flower', 'seed']);
+            listSortingPage.steps.verifyPreviewTabScoreText(0, `${totalPoints}`)
+
+            cy.log('When user adds a partially correct answer input, the points should be updated accordingly with deducted penalty points');
+            listSortingPage.steps.resetQuestionPreview()
+            listSortingPage.steps.clickAndDropOptionFromSourceToTargetInPreviewTab('seed', 0);
+            listSortingPage.steps.clickAndDropOptionFromSourceToTargetInPreviewTab('plant', 1);
+            listSortingPage.steps.clickAndDropOptionFromSourceToTargetInPreviewTab('sprout', 2);
+            listSortingPage.steps.clickAndDropOptionFromSourceToTargetInPreviewTab('flower', 3);
+            listSortingPage.steps.verifyTargetOptionsTextContentInPreviewTab(['seed', 'plant', 'sprout', 'flower']);
+            listSortingPage.steps.verifyPreviewTabScoreText(`${scoredPoints}`, `${totalPoints}`);
+
+            cy.log('Post step: Clearing the Penalty points field')
+            createQuestionBasePage.steps.switchToEditTab();
+            autoScoredScoringSectionMultipleResponsesType.penaltyPointsInputField()
+                .clear();
+        });
+    },
+
+    /**
+  * @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', () => {
+            listSortingPage.steps.switchToEditTab()
+            listSortingPage.steps.allotPenaltyPoints(3);
+            listSortingPage.steps.switchToPreviewTab();
+            listSortingPage.steps.clickAndDropOptionFromSourceToTargetInPreviewTab('seed', 0);
+            listSortingPage.steps.clickAndDropOptionFromSourceToTargetInPreviewTab('flower', 1);
+            listSortingPage.steps.clickAndDropOptionFromSourceToTargetInPreviewTab('sprout', 2);
+            listSortingPage.steps.clickAndDropOptionFromSourceToTargetInPreviewTab('plant', 3);
+            listSortingPage.steps.verifyTargetOptionsTextContentInPreviewTab(['seed', 'flower', 'sprout', 'plant']);
+            listSortingPage.steps.verifyPreviewTabScoreText(`${totalPointsScored}`, `${totalPointsScored}`);
+            cy.log('Post step: Clearing the Penalty points field')
+            createQuestionBasePage.steps.switchToEditTab();
+            autoScoredScoringSectionMultipleResponsesType.penaltyPointsInputField()
+                .clear();
+        });
+    },
+
+    /**
+     * @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();
+            listSortingPage.steps.clickAndDropOptionFromSourceToTargetInPreviewTab('sprout', 0);
+            listSortingPage.steps.clickAndDropOptionFromSourceToTargetInPreviewTab('plant', 1);
+            listSortingPage.steps.clickAndDropOptionFromSourceToTargetInPreviewTab('flower', 2);
+            listSortingPage.steps.clickAndDropOptionFromSourceToTargetInPreviewTab('seed', 3);
+            listSortingPage.steps.verifyTargetOptionsTextContentInPreviewTab(['sprout', 'plant', 'flower', 'seed']);
+            listSortingPage.steps.verifyPreviewTabScoreText(`${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');
+            listSortingPage.steps.resetQuestionPreview();
+            listSortingPage.steps.clickAndDropOptionFromSourceToTargetInPreviewTab('seed', 0);
+            listSortingPage.steps.clickAndDropOptionFromSourceToTargetInPreviewTab('plant', 1);
+            listSortingPage.steps.clickAndDropOptionFromSourceToTargetInPreviewTab('sprout', 2);
+            listSortingPage.steps.clickAndDropOptionFromSourceToTargetInPreviewTab('flower', 3);
+            listSortingPage.steps.verifyTargetOptionsTextContentInPreviewTab(['seed', 'plant', 'sprout', 'flower']);
+            listSortingPage.steps.verifyPreviewTabScoreText(`${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();
+            listSortingPage.steps.clickAndDropOptionFromSourceToTargetInPreviewTab('plant', 0);
+            listSortingPage.steps.clickAndDropOptionFromSourceToTargetInPreviewTab('seed', 1);
+            listSortingPage.steps.clickAndDropOptionFromSourceToTargetInPreviewTab('sprout', 2);
+            listSortingPage.steps.clickAndDropOptionFromSourceToTargetInPreviewTab('flower', 3);
+            listSortingPage.steps.verifyTargetOptionsTextContentInPreviewTab(['plant', 'seed', 'sprout', 'flower']);
+            listSortingPage.steps.verifyPreviewTabScoreText(`${scoredPointsArray[2]}`, `${totalPoints}`);
+        });
+    },
+
+    //Additional settings
+    /**
+    * @param {string[]} numerationArray array of the numeration displayed with options numbers| lowercase| uppercase
+    * @description this function checks the numeration displayed for the options and correct answer container options when check answer is selected
+    */
+    verifyOptionStyleNumerationWhenCheckAnswerIsSelected: (optionNumerationArray) => {
+        it('When user clicks on \'Check answer\' button then the default \'Answer numeration\' should be displayed in the \'Correct answers:\' section', () => {
+            listSortingPage.steps.checkAnswer()
+            listSortingPage.steps.clickAndDropOptionFromSourceToTargetInPreviewTab('plant', 0)
+            listSortingPage.steps.clickAndDropOptionFromSourceToTargetInPreviewTab('flower', 1)
+            listSortingPage.steps.clickAndDropOptionFromSourceToTargetInPreviewTab('seed', 2)
+            listSortingPage.steps.clickAndDropOptionFromSourceToTargetInPreviewTab('sprout', 3)
+            steps.verifyOptionsNumerationPreviewTab(optionNumerationArray)
+        });
+    },
+
+    verifyCSSAndA11yOfIncorrectAnswerLabel: () => {
+        it('CSS of incorrect answer state', { tags: 'css' }, () => {
+            cy.log('Pre requisite: The user has attempted the question incorrectly')
+            cy.log('Pre step: Select show answer checkbox')
+            previewScoringAndShowCorrectAnswerComponent.showCorrectAnswerCheckbox()
+                .click()
+                .should('be.checked');
+            cy.log('Verifying CSS of incorrect crossmark icon')
+            autoScoredPreviewBase.incorrectIcon()
+                .eq(0)
+                .verifyPseudoClassBeforeProperty('color', css.color.incorrectAnswer);
+            autoScoredPreviewBase.correctIncorectAnswerLabel()
+                .verifyCSS(css.color.incorrectAnswer, css.fontSize.normal, css.fontWeight.bold)
+            autoScoredPreviewBase.steps.verifyIncorrectAttemptBorder();
+        });
+
+        it('Accessibility of incorrect answer state', { tags: 'a11y' }, () => {
+            cy.checkAccessibility(commonComponents.previewTabQuestionWrapper());
+            cy.log('Post step: Deselect show answer checkbox')
+            previewScoringAndShowCorrectAnswerComponent.showCorrectAnswerCheckbox()
+                .click()
+                .should('not.be.checked');
+        });
+    },
+
+    verifyCSSAndA11yOfFullScoreTextAndCorrectAnswerLabel: () => {
+        it('CSS of check score text full score state and Correct Answer label', { tags: 'css' }, () => {
+            previewScoringAndShowCorrectAnswerComponent.previewScoreText()
+                .should('have.css', 'color', css.color.primaryBtn)
+                .and('have.css', 'background-color', css.color.correctAnswer)
+            autoScoredPreviewBase.correctIncorectAnswerLabel()
+                .verifyCSS(css.color.correctAnswer, css.fontSize.normal, css.fontWeight.bold);
+            autoScoredPreviewBase.steps.verifyCorrectAttemptBorder();
+        });
+
+        it('Accessibility of check score text full score state and Correct Answer label', { tags: 'a11y' }, () => {
+            cy.checkAccessibility(commonComponents.previewTabQuestionWrapper());
+        });
+    },
+}
+
+export const listSortingPage = {
+    ...selectors,
+    steps,
+    tests
+}