itemengine-cypress-automation 1.0.189-e2e-execution-crash-fbb0d92.0 → 1.0.189

package/cypress/e2e/ILC/ListOrderingDropdown/minimumScoringPenaltyPointsAndRoundingDropdown.js

@@ -0,0 +1,197 @@
+import { listOrderingPage } from "../../../pages";
+import abortEarlySetup from "../../../support/helpers/abortEarly";
+import utilities from "../../../support/helpers/utilities";
+const css = Cypress.env('css');
+const penaltyScoringTypeArray = ['No penalty points', 'Penalty points for the entire question', 'Penalty points for each incorrect option'];
+
+describe('Create item page - List ordering: Minimum scoring, Penalty scoring, Rounding - Edit tab', () => {
+    before(() => {
+        cy.loginAs('admin');
+    });
+
+    describe('Scoring section: Minimum scoring - Edit tab', () => {
+        abortEarlySetup();
+        before(() => {
+            listOrderingPage.steps.navigateToCreateQuestion('list ordering');
+            cy.barsPreLoaderWait();
+            listOrderingPage.steps.selectOrderingLayoutOption('Dropdown menu');
+            listOrderingPage.steps.allotPoints(10);
+        });
+
+        listOrderingPage.tests.verifyMinimumScoringDropdown();
+
+        listOrderingPage.tests.verifyMinimumPointsLabelAndInputField();
+
+        listOrderingPage.tests.verifyMinimumPointsFieldErrorState();
+    });
+
+    describe('Scoring section: Penalty scoring - Edit tab', () => {
+        abortEarlySetup();
+        before(() => {
+            listOrderingPage.steps.navigateToCreateQuestion('list ordering');
+            cy.barsPreLoaderWait();
+            listOrderingPage.steps.allotPoints(10);
+            listOrderingPage.steps.selectOrderingLayoutOption('Dropdown menu');
+            listOrderingPage.steps.selectAutoScoredScoringSubtype('Partial equal weights');
+        });
+
+        listOrderingPage.tests.verifyPenaltyScoringDropdown(penaltyScoringTypeArray);
+
+        listOrderingPage.tests.verifyPenaltyPointsLabelAndInputField();
+
+        listOrderingPage.tests.verifyPenaltyPointsErrorState();
+
+        it('When the user selects \'Penalty points for each incorrect option\' from the penalty scoring dropdown, \'Automatically set penalty for each incorrect option to total points / no. of incorrect options\' label and checkbox should be displayed, by default the checkbox should be unchecked. Two radio buttons with labels - \'Specify total penalty points\' and \'Specify points for each incorrect option\' should be displayed. By default, \'Specify total penalty points\' radio button should be checked', () => {
+            listOrderingPage.steps.expandPenaltyScoringDropdown();
+            listOrderingPage.steps.selectOptionFromPenaltyScoringDropdown('Penalty points for each incorrect option');
+            utilities.verifyInnerText(listOrderingPage.automaticallySetPenaltyPointsCheckboxLabel(), 'Automatically set penalty for each incorrect option to total points / no. of incorrect options');
+            utilities.verifyInnerText(listOrderingPage.specifyTotalPenaltyPointsRadioButtonLabel(), 'Specify total penalty points');
+            utilities.verifyInnerText(listOrderingPage.specifyPointsForEachIncorrectOptionRadioButtonLabel(), 'Specify points for each incorrect option');
+            listOrderingPage.steps.verifyAutomaticallySetPenaltyPointsCheckboxUncheckedState();
+            listOrderingPage.steps.verifySpecifyTotalPenaltyPointsRadioButtonCheckedState();
+            listOrderingPage.steps.verifySpecifyPointsForEachIncorrectOptionRadioButtonUncheckedState();
+        });
+
+        it('When \'Specify total penalty points\' is selected, a penalty points detail section with \'Total penalty points\' label and empty input field, \'Penalty points for each incorrect option: -\' label should be displayed', () => {
+            utilities.verifyInnerText(listOrderingPage.penaltyPointsDetailsSectionInputFieldLabel(), 'Total penalty points');
+            listOrderingPage.steps.verifyTotalPenaltyPointsValue('');
+            utilities.verifyInnerText(listOrderingPage.penaltyPointsDetailsSectionAllottedPointsLabel(), 'Penalty points for each incorrect option: -');
+        });
+
+        it('When the user allots total penalty points, then \'points for each incorrect option\' should get updated as per the count of incorrect options available', () => {
+            listOrderingPage.steps.allotTotalPenaltyPoints(5);
+            listOrderingPage.steps.verifyPenaltyPointsForEachIncorrectOption(1.67);
+        });
+
+        it('When the user deletes an option, then \'points for each incorrect option\' should get updated accordingly', () => {
+            listOrderingPage.steps.deleteOption(0);
+            listOrderingPage.steps.verifyPenaltyPointsForEachIncorrectOption(2.5);
+        });
+
+        it('When the user adds a new option, then \'points for each incorrect option\' should get updated accordingly', () => {
+            listOrderingPage.steps.addOption();
+            listOrderingPage.steps.verifyPenaltyPointsForEachIncorrectOption(1.67);
+        });
+
+        it('CSS of the penalty points section - Total penalty points', { tags: 'css' }, () => {
+            utilities.verifyCSS(listOrderingPage.automaticallySetPenaltyPointsCheckboxLabel(), {
+                'color': css.color.labelText,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(listOrderingPage.automaticallySetPenaltyPointsCheckbox().parent().find('svg'), {
+                'fill': css.color.uncheckedCheckbox
+            });
+            utilities.verifyCSS(listOrderingPage.specifyTotalPenaltyPointsRadioButton().parent().find('svg'), {
+                'fill': css.color.activeButtons
+            });
+            utilities.verifyCSS(listOrderingPage.specifyPointsForEachIncorrectOptionRadioButton().parent().find('svg path'), {
+                'fill': css.color.uncheckedCheckbox
+            });
+            utilities.verifyCSS(listOrderingPage.specifyTotalPenaltyPointsRadioButtonLabel(), {
+                'color': css.color.labelText,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(listOrderingPage.specifyPointsForEachIncorrectOptionRadioButtonLabel(), {
+                'color': css.color.labelText,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(listOrderingPage.penaltyPointsDetailsSectionInputFieldLabel(), {
+                'color': css.color.labelText,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(listOrderingPage.totalPenaltyPointsInputField(), {
+                'color': css.color.text,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(listOrderingPage.penaltyPointsDetailsSectionAllottedPointsLabel(), {
+                'color': css.color.labelText,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+        });
+
+        it('Accessibility of the penalty points section - Total penalty points', { tags: 'a11y' }, () => {
+            cy.checkAccessibility(listOrderingPage.automaticallySetPenaltyPointsCheckboxLabel().parents('.penalty-score-for-each-incorrect-wrapper'));
+        });
+
+        it('When the user selects \'Specify points for each incorrect answer\', a penalty points detail section with \'Penalty points for each incorrect option:\' label and empty input field, \'Total penalty points: -\' label should be displayed', () => {
+            cy.log('Pre-step: Clearing the total penalty points input field')
+            listOrderingPage.steps.clearTotalPenaltyPointsInputField();
+            listOrderingPage.steps.selectPenaltyPointsForEachIncorrectOptionType('Specify points for each incorrect option');
+            utilities.verifyInnerText(listOrderingPage.penaltyPointsDetailsSectionInputFieldLabel(), 'Penalty points for each incorrect option');
+            listOrderingPage.steps.verifyPenaltyPointsForEachIncorrectOptionValue('');
+            utilities.verifyInnerText(listOrderingPage.penaltyPointsDetailsSectionAllottedPointsLabel(), 'Total penalty points: -');
+        });
+
+        it('When the user allots Penalty points for each incorrect option, then \'Total penalty points\' should get updated as per the count of incorrect options available', () => {
+            listOrderingPage.steps.allotPenaltyPointsForEachIncorrectOption(1);
+            listOrderingPage.steps.verifyTotalPenaltyPoints(3);
+        });
+
+        it('When the user adds a new option, then \'Total penalty points\' should get updated accordingly', () => {
+            listOrderingPage.steps.addOption();
+            listOrderingPage.steps.verifyTotalPenaltyPoints(4);
+        });
+
+        it('When the user deletes an option, then \'points for each incorrect option\' should get updated accordingly', () => {
+            listOrderingPage.steps.deleteOption(0);
+            listOrderingPage.steps.verifyTotalPenaltyPoints(3);
+        });
+
+        it('CSS of the penalty points section - Penalty points for each incorrect option', { tags: 'css' }, () => {
+            utilities.verifyCSS(listOrderingPage.penaltyPointsDetailsSectionInputFieldLabel(), {
+                'color': css.color.labelText,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(listOrderingPage.penaltyPointsForEachIncorrectOptionInputField(), {
+                'color': css.color.text,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(listOrderingPage.penaltyPointsDetailsSectionAllottedPointsLabel(), {
+                'color': css.color.labelText,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+        });
+
+        it('Accessibility of the penalty points section - Penalty points for each incorrect option', { tags: 'a11y' }, () => {
+            cy.checkAccessibility(listOrderingPage.automaticallySetPenaltyPointsCheckboxLabel().parents('.penalty-score-for-each-incorrect-wrapper'));
+        });
+
+        it('When the user switches to the \'Specify total penalty points\' option, the total penalty points input field should be filled as per the total penalty points in \'Specify points for each incorrect option\'', () => {
+            listOrderingPage.steps.selectPenaltyPointsForEachIncorrectOptionType('Specify total penalty points');
+            listOrderingPage.steps.verifyTotalPenaltyPointsValue(3);
+            utilities.verifyInnerText(listOrderingPage.penaltyPointsDetailsSectionAllottedPointsLabel(), 'Penalty points for each incorrect option: 1');
+        });
+
+        it('When the user checks the \'Automatically set penalty for each incorrect option to total points / no. of incorrect options\' checkbox, both radio buttons should get disabled, \'Specify points for each incorrect option\' should get checked, in the penalty points details section, \'Penalty points for each incorrect option: #\' and \'Total penalty points: #\' should be displayed as per the alloted points and available incorrect options', () => {
+            listOrderingPage.steps.checkAutomaticallySetPenaltyPointsCheckbox();
+            listOrderingPage.steps.verifySpecifyTotalPenaltyPointsDisabledState();
+            listOrderingPage.steps.verifySpecifyPointsForEachIncorrectOptionRadioButtonSelectedAndDisabledState();
+            utilities.verifyInnerText(utilities.getNthElement(listOrderingPage.penaltyPointsDetailsSectionAllottedPointsLabel(), 0), 'Penalty points for each incorrect option: 3.33');
+            utilities.verifyInnerText(utilities.getNthElement(listOrderingPage.penaltyPointsDetailsSectionAllottedPointsLabel(), 1), 'Total penalty points: 9.99');
+        });
+    });
+
+    describe('Scoring section: Rounding - Edit tab', () => {
+        abortEarlySetup();
+        before(() => {
+            listOrderingPage.steps.navigateToCreateQuestion('list ordering');
+            cy.barsPreLoaderWait();
+            listOrderingPage.steps.allotPoints(10);
+            listOrderingPage.steps.selectOrderingLayoutOption('Dropdown menu');
+            listOrderingPage.steps.selectAutoScoredScoringSubtype('Partial equal weights')
+        });
+
+        listOrderingPage.tests.verifyRoundingDropdown();
+
+        listOrderingPage.tests.verifyRoundNegativeScoreToZeroLabelAndCheckbox();
+    });
+});

package/cypress/e2e/ILC/ListOrderingDropdown/previewContentsForAllViews.smoke.js

@@ -0,0 +1,201 @@
+import { listOrderingPage, itemPreviewPage, studentViewPage } from "../../../pages";
+import { ckEditorToolbar, equationEditorFlyout } from "../../../pages/components";
+import abortEarlySetup from "../../../support/helpers/abortEarly";
+import utilities from "../../../support/helpers/utilities";
+const previewContentViews = ['Question preview', 'Item view', 'Item preview', 'Student view', 'Grading view', 'Correct answer view'];
+const views = utilities.getViews(previewContentViews);
+var itemReferenceID = "";
+const css = Cypress.env('css');
+
+describe('Create item page - List ordering - Preview contents in all views', () => {
+    before(() => {
+        cy.loginAs('admin');
+    });
+
+    views.forEach((view) => {
+        describe(`Preview tab contents - ${view}`, { tags: 'smoke' }, () => {
+            abortEarlySetup();
+            before(() => {
+                switch (view) {
+                    case 'Question preview':
+                        listOrderingPage.steps.navigateToCreateQuestion('list ordering');
+                        cy.barsPreLoaderWait();
+                        listOrderingPage.steps.addTextInQuestionInstructionsInputField('Arrange options in correct order.');
+                        listOrderingPage.steps.selectOrderingLayoutOption('Dropdown menu');
+                        listOrderingPage.steps.allotPoints(10);
+                        cy.log('Add image to option input field')
+                        listOrderingPage.steps.focusInOptionsInputField(0);
+                        ckEditorToolbar.steps.selectImageOptionFromCKEditorToolbar();
+                        ckEditorToolbar.steps.addImageToInputField();
+                        listOrderingPage.steps.enterTextInOptionInputField(0, 'Fox');
+                        cy.log('Add bold text to option input field')
+                        listOrderingPage.steps.focusInOptionsInputField(1);
+                        ckEditorToolbar.steps.selectBoldOptionFromCKEditorToolbar();
+                        listOrderingPage.steps.enterTextInOptionInputField(1, 'This is a bold option');
+                        cy.log('Add equation to option input field')
+                        listOrderingPage.steps.enterTextInOptionInputField(2, 'Solve the following');
+                        listOrderingPage.steps.focusInOptionsInputField(2);
+                        ckEditorToolbar.steps.selectEquationEditorOptionFromCKEditorToolbar();
+                        equationEditorFlyout.steps.addGenericEquationUsingEquationEditorToCKEditorInputField();
+                        listOrderingPage.steps.enterTextInOptionInputField(3, 'alpha');
+                        listOrderingPage.steps.selectPositionForAllOptionsSpecifyCorrectAnswerSection([{ optionIndex: 0, position: '2' }, { optionIndex: 1, position: '1' }, { optionIndex: 2, position: '3' }, { optionIndex: 3, position: '4' }])
+                        listOrderingPage.steps.switchToPreviewTab();
+                        break;
+                    case 'Item view':
+                        cy.visit(`/item-engine/demo/edit-item/${utilities.base64Encoding(itemReferenceID)}`);
+                        break;
+                    case 'Item preview':
+                        cy.visit(`/item-engine/demo/edit-item/${utilities.base64Encoding(itemReferenceID)}`);
+                        listOrderingPage.steps.switchToPreviewTab();
+                        break;
+                    case 'Student view':
+                        cy.visit(`/item-engine/demo/render-item/student-view/${utilities.base64Encoding(itemReferenceID)}`);
+                        break;
+                    case 'Grading view':
+                        cy.visit(`/item-engine/demo/render-item/grading-view/${utilities.base64Encoding(itemReferenceID)}`);
+                        break;
+                    case 'Correct answer view':
+                        cy.visit(`/item-engine/demo/render-item/correct-answer-view/${utilities.base64Encoding(itemReferenceID)}`);
+                        break;
+                    default:
+                        throw new Error('Invalid view');
+                }
+            });
+
+            after(() => {
+                if (view === 'Question preview') {
+                    listOrderingPage.steps.clickOnSaveQuestionButton();
+                    utilities.verifyElementVisibilityState(itemPreviewPage.referenceID(), 'visible');
+                    itemReferenceID = itemPreviewPage.steps.getItemReferenceID();
+                }
+                if (view === 'Student view') {
+                    studentViewPage.steps.submitResponse();
+                    utilities.verifyElementVisibilityState(studentViewPage.buttonGoToGradingView(), 'visible');
+                }
+            });
+
+            it('Question instructions should be visible', () => {
+                utilities.verifyInnerText(listOrderingPage.questionInstructionsText(), 'Arrange options in correct order.');
+                utilities.verifyElementVisibilityState(listOrderingPage.questionInstructionsText(), 'visible');
+            });
+
+            if (view !== 'Grading view' && view !== 'Correct answer view') {
+                it(`When the user has added image, equation, bold text to the options input fields, then they should be displayed in the options container in ${view}`, () => {
+                    listOrderingPage.steps.verifyOptionWithImageInPreviewTab(0);
+                    listOrderingPage.steps.verifyOptionWithBoldTextInPreviewTab(1);
+                    listOrderingPage.steps.verifyOptionWithEquationTextInPreviewTab(2);
+                });
+
+                it('When the user expands a position dropdown, based on the number of options in the list to order, a list of  dropdown options to place the particular option in the list order should be displayed', () => {
+                    listOrderingPage.steps.expandPositionDropdownPreviewTab(0);
+                    utilities.verifyElementVisibilityState(listOrderingPage.dropdownList(), 'visible');
+                    for (let index = 0; index < 4; index++) {
+                        utilities.verifyInnerText(utilities.getNthElement(listOrderingPage.positionDropdownListOption(), index), `${index + 1}`);
+                    }
+                });
+
+                it('The user should be able to select an option from the position dropdown. When the user has not set position in all dropdowns, an alert message "All options need to have a value assigned to them from the dropdown." should be displayed', () => {
+                    listOrderingPage.steps.selectOptionPositionPreviewTab(0, 2);
+                    utilities.verifyElementVisibilityState(listOrderingPage.dropdownList(), 'notExist');
+                    listOrderingPage.steps.verifyAssignValueToAllDropdownAlertMessage();
+                });
+
+                it('When the user tries to set position of an option such that the same position has already been assigned to another option, then the selected position from the previous option dropdown should reset', () => {
+                    listOrderingPage.steps.selectOptionPositionPreviewTab(1, 2);
+                    listOrderingPage.steps.verifySelectedOptionPositionDropdown(0, '');
+                });
+
+                it('User should be able to reorder options containing image, bold text and equation options in the list using position dropdowns. On setting position for all options, the alert message should get removed', () => {
+                    listOrderingPage.steps.selectPositionForAllOptionsPreviewTab([{ optionIndex: 0, position: '2' }, { optionIndex: 1, position: '1' }, { optionIndex: 2, position: '3' }, { optionIndex: 3, position: '4' }])
+                    listOrderingPage.steps.verifyAlertMessageNotExists();
+                });
+            } else if (view === 'Grading view') {
+                it(`The order of the responses should be as per the submitted response`, () => {
+                    listOrderingPage.steps.verifyOptionWithImageDropdownLayoutInGradingView(0);
+                    listOrderingPage.steps.verifyOptionWithBoldTextDropdownLayoutInGradingView(1);
+                    listOrderingPage.steps.verifyOptionWithEquationTextDropdownLayoutInGradingView(2);
+                    listOrderingPage.steps.verifyTextContentOfOptionDropdownLayoutInGradingView('alpha', 3);
+                    listOrderingPage.steps.verifyCorrectOptionIconDropdownLayout(0);
+                    listOrderingPage.steps.verifyCorrectOptionIconDropdownLayout(1);
+                    listOrderingPage.steps.verifyCorrectOptionIconDropdownLayout(2);
+                    listOrderingPage.steps.verifyCorrectOptionIconDropdownLayout(3);
+                    listOrderingPage.steps.verifyCorrectIncorrectAnswerLabel('correct');
+                    listOrderingPage.steps.verifyCorrectAnswerSectionNotExists();
+                });
+
+                it('The order of the responses should not be editable', () => {
+                    listOrderingPage.steps.expandPositionDropdownPreviewTab(2);
+                    utilities.verifyElementVisibilityState(listOrderingPage.dropdownList(), 'notExist');
+                });
+            } else {
+                it('The order of the options should be as per the correct answer order', () => {
+                    listOrderingPage.steps.verifySelectedOptionPositionDropdown(0, '2');
+                    listOrderingPage.steps.verifySelectedOptionPositionDropdown(1, '1');
+                    listOrderingPage.steps.verifySelectedOptionPositionDropdown(2, '3');
+                    listOrderingPage.steps.verifySelectedOptionPositionDropdown(3, '4');
+                    listOrderingPage.steps.verifyCorrectOptionIconDropdownLayout(0);
+                    listOrderingPage.steps.verifyCorrectOptionIconDropdownLayout(1);
+                    listOrderingPage.steps.verifyCorrectOptionIconDropdownLayout(2);
+                    listOrderingPage.steps.verifyCorrectOptionIconDropdownLayout(3);
+                });
+            }
+
+            it('CSS of preview contents', { tags: 'css' }, () => {
+                switch (view) {
+                    case 'Question preview':
+                    case 'Item preview':
+                    case 'Item view':
+                    case 'Item preview':
+                    case 'Student view':
+                        utilities.verifyCSS(utilities.getNthElement(listOrderingPage.positionDropdownPreviewTab(), 0), {
+                            'background-color': css.color.optionsBg,
+                            'border': `1px solid ${css.color.draggableOptionBorder}`
+                        });
+                        utilities.verifyCSS(utilities.getNthElement(listOrderingPage.positionDropdownPreviewTab(), 0), {
+                            'background-color': css.color.defaultBackground,
+                            'border': `1px solid ${css.color.correctAnswer}`
+                        });
+                        utilities.verifyCSS(listOrderingPage.dropdownOptionWrapperPreviewTab(), {
+                            'background-color': css.color.defaultBackground,
+                            'border': `1px solid ${css.color.draggableOptionBorder}`
+                        });
+                        utilities.verifyCSS(listOrderingPage.dropdownOptionWrapperPreviewTab().find('.question-text-wrapper'), {
+                            'color': css.color.text,
+                            'font-size': css.fontSize.default,
+                            'font-weight': css.fontWeight.regular
+                        });
+                        utilities.verifyCSS(listOrderingPage.dropdownWrapperPreviewTab().find('.dropdown-label-text'), {
+                            'color': css.color.liText,
+                            'font-size': css.fontSize.default,
+                            'font-weight': css.fontWeight.regular
+                        });
+                        break;
+                    case 'Grading view':
+                    case 'Correct answer view':
+                        utilities.verifyCSS(utilities.getNthElement(listOrderingPage.positionDropdownPreviewTab(), 0), {
+                            'background-color': css.color.optionsBg,
+                            'border': `1px solid ${css.color.correctAnswer}`
+                        });
+                        utilities.verifyCSS(listOrderingPage.dropdownOptionWrapperGradingView(), {
+                            'background-color': css.color.defaultBackground,
+                            'border': `1px solid ${css.color.draggableOptionBorder}`
+                        });
+                        utilities.verifyCSS(utilities.getNthElement(listOrderingPage.dropdownOptionWrapperGradingView(), 3).find('.question-text-wrapper'), {
+                            'color': css.color.text,
+                            'font-size': css.fontSize.default,
+                            'font-weight': css.fontWeight.regular
+                        });
+                        utilities.verifyCSS(listOrderingPage.dropdownWrapperPreviewTab().find('.dropdown-label-text'), {
+                            'color': css.color.liText,
+                            'font-size': css.fontSize.default,
+                            'font-weight': css.fontWeight.regular
+                        });
+                }
+            });
+
+            it('Accessibility of preview contents', { tags: 'a11y' }, () => {
+                cy.checkAccessibility(listOrderingPage.optionWrapperPreviewTab().parents('[class*="question-preview-wrapper"]'));
+            });
+        });
+    });
+});

package/cypress/e2e/ILC/ListOrderingDropdown/specifyCorrectAnswerSection.js

@@ -0,0 +1,115 @@
+import { dialogBoxBase, listOrderingPage } from "../../../pages";
+import abortEarlySetup from "../../../support/helpers/abortEarly";
+import utilities from "../../../support/helpers/utilities";
+const options = ['sprout', 'plant', 'flower', 'seed'];
+
+describe('Create item page - List ordering: Specify correct answer, Alternative correct answer', () => {
+    before(() => {
+        cy.loginAs('admin');
+    });
+
+    describe('Specify correct answer section - Header and \'Correct\' accordion', () => {
+        abortEarlySetup();
+        before(() => {
+            listOrderingPage.steps.navigateToCreateQuestion('list ordering');
+            cy.barsPreLoaderWait();
+            listOrderingPage.steps.selectOrderingLayoutOption('Dropdown menu');
+            listOrderingPage.steps.addInputToOptionsInputField(options);
+        });
+
+        listOrderingPage.tests.verifyAutoScoredSpecifyCorrectAnswerHeaderSectionContents('list ordering');
+
+        it('By default, 4 options should be displayed with dropdowns in the correct accordion', () => {
+            utilities.verifyElementCount(listOrderingPage.positionDropdownSpecifyCorrectAnswerSection(), 4);
+            options.forEach((optionText, index) => {
+                listOrderingPage.steps.verifyTextContentOfOptionDropdownLayoutInSpecifyCorrectAnswerSection(optionText, index);
+            });
+        });
+
+        it('When the user expands a position dropdown, based on the number of options in the list to order, a list of dropdown options to place the particular option in the list order should be displayed', () => {
+            listOrderingPage.steps.expandPositionDropdownSpecifyCorrectAnswerSection(0);
+            utilities.verifyElementVisibilityState(listOrderingPage.dropdownList(), 'visible');
+            for (let index = 0; index < 4; index++) {
+                utilities.verifyInnerText(utilities.getNthElement(listOrderingPage.positionDropdownListOption(), index), `${index + 1}`);
+            };
+            listOrderingPage.steps.selectListOptionPositionDropdown('1');
+        });
+
+        it('The user should be able to select an option from the position dropdown.', () => {
+            listOrderingPage.steps.selectOptionPositionSpecifyCorrectAnswerSection(0, '2');
+            listOrderingPage.steps.verifySelectedOptionPositionDropdownInSpecifyCorrectAnswerSection(0, '2');
+            utilities.verifyElementVisibilityState(listOrderingPage.dropdownList(), 'notExist');
+        });
+
+        listOrderingPage.tests.verifyAutoScoredPointsErrorMessageWhenPointsFieldIsEmpty('Correct');
+    });
+
+    describe('Specify correct answer section - \'Alternative\' accordion', () => {
+        abortEarlySetup();
+        before(() => {
+            listOrderingPage.steps.navigateToCreateQuestion('list ordering');
+            cy.barsPreLoaderWait();
+            listOrderingPage.steps.selectOrderingLayoutOption('Dropdown menu');
+            listOrderingPage.steps.addInputToOptionsInputField(options);
+        });
+
+        listOrderingPage.tests.verifyAutoScoredAddAlternativeAnswerButtonAndValidation('list ordering');
+
+        it('When user tries to \'+Add alternative answer\' after allotting points without re-ordering the options then the warning popup should appear and on closing the warning popup, an error message should be displayed in the \'Specify correct answer\' section', () => {
+            listOrderingPage.steps.clickOnAddAlternativeAnswerButton();
+            dialogBoxBase.steps.closeWarningPopup();
+            utilities.verifyElementVisibilityState(dialogBoxBase.dialogBox(), 'notExist');
+            utilities.verifyInnerText(listOrderingPage.errorMessage(), 'Error: All options need to have a value assigned to them from the dropdown.');
+            utilities.verifyElementVisibilityState(listOrderingPage.errorMessage(), 'visible');
+        });
+
+        listOrderingPage.tests.verifyErrorMessageCSSAndA11y();
+
+        it('When the user checks \'Randomize options\' then the error message should persist', () => {
+            listOrderingPage.steps.checkRandomizeOptionsCheckbox();
+            utilities.verifyElementVisibilityState(listOrderingPage.errorMessage(), 'visible');
+        });
+
+        it('When the user sets options order in the dropdowns, then the error message should disappear', () => {
+            listOrderingPage.steps.selectPositionForAllOptionsSpecifyCorrectAnswerSection([{ optionIndex: 0, position: '2' }, { optionIndex: 1, position: '3' }, { optionIndex: 2, position: '4' }, { optionIndex: 3, position: '1' }]);
+            utilities.verifyElementVisibilityState(listOrderingPage.errorMessage(), 'notExist');
+        });
+
+        it('When the user has set correct answer order, then the user should be able to add alternative answer for the question using \'Add alternative answer\' button', () => {
+            listOrderingPage.steps.addAlternativeAnswerAccordion(1);
+        });
+
+        it('When user has added an alternative answer accordion, then the newly added alternative answer accordion should be in expanded state and the correct answer accordion should be in collapsed state', () => {
+            listOrderingPage.steps.verifyCorrectAnswerAccordionIsCollapsed();
+            listOrderingPage.steps.verifyAlternateAnswerAccordionIsExpanded(0);
+        });
+
+        it('By default, 4 options along with dropdowns should be displayed in the alternative accordion', () => {
+            utilities.verifyElementCount(listOrderingPage.dropdownOptionWrapperPreviewTab(), 4);
+            options.forEach((optionText, index) => {
+                listOrderingPage.steps.verifyTextContentOfOptionDropdownLayoutInPreviewTab(optionText, index);
+            });
+        });
+
+        it('User should be able to add another alternative answer for the question using \'Add alternative answer\' button and the name for this new accordion should be \'Alternative 2\'', () => {
+            cy.log('Set correct answer in alternative 1 accordion');
+            listOrderingPage.steps.selectPositionForAllOptionsSpecifyCorrectAnswerSection([{ optionIndex: 0, position: '2' }, { optionIndex: 1, position: '3' }, { optionIndex: 2, position: '4' }, { optionIndex: 3, position: '1' }]);
+            listOrderingPage.steps.addAlternativeAnswerAccordion(2);
+        });
+
+        listOrderingPage.tests.verifyWarningPopupAndAccordionNavigationWhenNoPointsAddedInAlternativeAccordion();
+
+        it('User should be able to remove alternative correct answer by clicking on the \'Delete\' icon button alongside alternative answer accordion and the name of the alternative answer accordions should get updated accordingly', () => {
+            cy.log('Set correct answer in alternative 2 accordion, then switch to alternative 1 accordion and click delete icon button');
+            listOrderingPage.steps.selectPositionForAllOptionsSpecifyCorrectAnswerSection([{ optionIndex: 0, position: '2' }, { optionIndex: 1, position: '3' }, { optionIndex: 2, position: '4' }, { optionIndex: 3, position: '1' }]);
+            listOrderingPage.steps.deleteAlternativeAnswerAccordion(1);
+            listOrderingPage.steps.verifyAlternativeAnswerAccordionNotExists(2);
+            listOrderingPage.steps.verifyAlternativeAnswerAccordionLabel(0);
+        });
+
+        it('When correct answers and points are set in alternative answer and user clicks on correct answer accordion, then correct answer accordion should be expanded and the alternative answer accordion should be collapsed', () => {
+            listOrderingPage.steps.expandCorrectAnswerAccordion();
+            listOrderingPage.steps.verifyAlternateAnswerAccordionIsCollapsed(0);
+        });
+    });
+});