itemengine-cypress-automation 1.0.151-28MarchRepoUpdate-4cfb82e.0 → 1.0.151

package/cypress/e2e/ILC/Matching/editTabScoring.js

@@ -0,0 +1,221 @@
+import { matchingPage } from "../../../pages";
+import abortEarlySetup from "../../../support/helpers/abortEarly";
+import utilities from "../../../support/helpers/utilities";
+const css = Cypress.env('css');
+const promptTextArray = ['Wild', 'Aquatic', 'Pet'];
+const optionsArray = ['Cat', 'Elephant', 'Fish', 'Bear', 'Eagle', 'Penguin'];
+
+describe('Create item page - Matching: Scoring section', () => {
+    before(() => {
+        cy.loginAs('admin');
+    });
+
+    describe('Scoring section contents', () => {
+        abortEarlySetup();
+        before(() => {
+            matchingPage.steps.navigateToCreateQuestion('matching');
+            cy.barsPreLoaderWait();
+        });
+
+        matchingPage.tests.verifyScoringTypeLabelAndDropdown('Auto scored');
+
+        matchingPage.tests.verifyScoringSubtypeContentsForMultipleResponseTypeQuestion();
+    });
+
+    describe('Auto scored: All or nothing scoring - Scoring section', () => {
+        abortEarlySetup();
+        before(() => {
+            matchingPage.steps.navigateToCreateQuestion('matching');
+            cy.barsPreLoaderWait();
+            matchingPage.steps.allotPoints(10);
+        });
+
+        it('When the user has selected \'All or nothing\' scoring subtype, minimum scoring dropdown should be displayed in the scoring section', () => {
+            matchingPage.steps.verifyMinimumScoringLabelAndDropdownDefaultState();
+        });
+    });
+
+    describe('Auto scored: All or nothing scoring - Specify correct answer section', () => {
+        abortEarlySetup();
+        before(() => {
+            matchingPage.steps.navigateToCreateQuestion('matching');
+            cy.barsPreLoaderWait();
+            matchingPage.steps.addTextInQuestionInstructionsInputField('Fill the categories with the right answer.');
+            matchingPage.steps.addMultipleOptionFields(3);
+            matchingPage.steps.enterTextInPromptInputField(promptTextArray);
+            matchingPage.steps.enterTextInOptionInputField(optionsArray);
+            matchingPage.steps.clickAndDropOptionInDropzoneSpecifyCorrectAnswerSection([{ optionText: 'Elephant', dropzoneIndex: 0 }, { optionText: 'Fish', dropzoneIndex: 1 }, { optionText: 'Cat', dropzoneIndex: 2 }]);
+        });
+
+        matchingPage.tests.verifyContentsOfSpecifyCorrectAnswerSection();
+
+        matchingPage.tests.verifyPointsLabelAndInputField();
+    });
+
+    describe('Auto scored: Partial - equal weights scoring - Scoring section', () => {
+        abortEarlySetup();
+        before(() => {
+            matchingPage.steps.navigateToCreateQuestion('matching');
+            cy.barsPreLoaderWait();
+            matchingPage.steps.addTextInQuestionInstructionsInputField('Fill the categories with the right answer.');
+            matchingPage.steps.addMultipleOptionFields(3);
+            matchingPage.steps.enterTextInPromptInputField(promptTextArray);
+            matchingPage.steps.enterTextInOptionInputField(optionsArray);
+            matchingPage.steps.clickAndDropOptionInDropzoneSpecifyCorrectAnswerSection([{ optionText: 'Elephant', dropzoneIndex: 0 }, { optionText: 'Fish', dropzoneIndex: 1 }, { optionText: 'Cat', dropzoneIndex: 2 }]);
+        });
+
+        it('User should be able to select \'Partial - equal weights\' scoring type', () => {
+            matchingPage.steps.selectAutoScoredScoringSubtype('Partial equal weights');
+        });
+
+        it('When the user has switched to \'Partial - equal weights\' scoring, then \'Penalty scoring\', \'Minimum scoring\' and \'Rounding\' label and dropdown should be displayed in the \'Scoring\' section, \'Round negative scores to zero\' label and checkbox should not be displayed in the \'Scoring\' section', () => {
+            matchingPage.steps.verifyPointsPerResponseLabel();
+            matchingPage.steps.verifyMinimumScoringLabelAndDropdownDefaultState();
+            matchingPage.steps.verifyPenaltyPointsLabelAndDropdownDefaultState();
+            matchingPage.steps.verifyRoundingLabelAndDropdownDefaultState();
+            utilities.verifyElementVisibilityState(matchingPage.roundNegativeScoresToZeroCheckbox(), 'notExist');
+        });
+    });
+
+    describe('Auto scored: Partial equal weights scoring - Specify correct answer section', () => {
+        abortEarlySetup();
+        before(() => {
+            matchingPage.steps.navigateToCreateQuestion('matching');
+            cy.barsPreLoaderWait();
+            matchingPage.steps.addTextInQuestionInstructionsInputField('Fill the categories with the right answer.');
+            matchingPage.steps.addMultipleOptionFields(3);
+            matchingPage.steps.enterTextInPromptInputField(promptTextArray);
+            matchingPage.steps.enterTextInOptionInputField(optionsArray);
+            matchingPage.steps.clickAndDropOptionInDropzoneSpecifyCorrectAnswerSection([{ optionText: 'Elephant', dropzoneIndex: 0 }, { optionText: 'Fish', dropzoneIndex: 1 }, { optionText: 'Cat', dropzoneIndex: 2 }]);
+            matchingPage.steps.selectAutoScoredScoringSubtype('Partial equal weights');
+        });
+
+        matchingPage.tests.verifyContentsOfSpecifyCorrectAnswerSection();
+
+        it('\'Points per response\' label should be displayed and a \'-\' should be displayed besides each response in the \'Specify correct answer\' section', () => {
+            matchingPage.steps.verifyPointsPerResponseLabel();
+        });
+
+        it('When the user gives a score input to \'Points\' input field, then the score should be equally divided among the dropzone \'Points per response\' label', () => {
+            matchingPage.steps.allotPoints(6);
+            matchingPage.steps.verifyPartialEqualWeightsPointsPerResponseScore('2');
+        });
+
+        it('When the user adds a prompt, then points per response should get updated accordingly', () => {
+            matchingPage.steps.addPrompt();
+            matchingPage.steps.verifyPartialEqualWeightsPointsPerResponseScore('1.5');
+        });
+
+        it('When the user deletes a prompt, then points per response should get updated accordingly', () => {
+            matchingPage.steps.deletePrompt(3);
+            matchingPage.steps.verifyPartialEqualWeightsPointsPerResponseScore('2');
+        });
+
+        it('When the user adds an option in the specify correct answer section, then points per response should remain the same', () => {
+            matchingPage.steps.addOption();
+            matchingPage.steps.verifyPartialEqualWeightsPointsPerResponseScore('2');
+        });
+
+        it('When the user deletes an option from the options section then the points should not change', () => {
+            matchingPage.steps.deleteOption(6);
+            matchingPage.steps.verifyPartialEqualWeightsPointsPerResponseScore('2');
+        });
+
+        it('When the user switches to \'All or nothing\' scoring, the \'Points per response\' label and the points displayed for individual responses should not be displayed and the points displayed in \'Points\' input field should remain unchanged', () => {
+            matchingPage.steps.selectAutoScoredScoringSubtype('All or nothing');
+            utilities.verifyElementVisibilityState(matchingPage.pointsPerResponseLabel(), 'notExist');
+            matchingPage.steps.verifyPointsFieldValue(6);
+        });
+
+        it('When the user updates the entered points in \'All or nothing\' scoring type and switches to \'Partial equal weights\' scoring type, then the points should be equally divided and displayed besides each correct option', () => {
+            matchingPage.steps.allotPoints(12);
+            matchingPage.steps.selectAutoScoredScoringSubtype('Partial equal weights');
+            matchingPage.steps.verifyPartialEqualWeightsPointsPerResponseScore('4');
+        });
+
+        it('CSS of \'Points per response\' label and its displayed score', { tags: 'css' }, () => {
+            utilities.verifyCSS(matchingPage.pointsPerResponseLabel(), {
+                'color': css.color.labels,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.semibold
+            });
+        });
+    });
+
+    describe('Auto scored: Partial - different weights scoring - Scoring section', () => {
+        abortEarlySetup();
+        before(() => {
+            matchingPage.steps.navigateToCreateQuestion('matching');
+            cy.barsPreLoaderWait();
+            matchingPage.steps.addTextInQuestionInstructionsInputField('Fill the categories with the right answer.');
+            matchingPage.steps.addMultipleOptionFields(3);
+            matchingPage.steps.enterTextInPromptInputField(promptTextArray);
+            matchingPage.steps.enterTextInOptionInputField(optionsArray);
+            matchingPage.steps.clickAndDropOptionInDropzoneSpecifyCorrectAnswerSection([{ optionText: 'Elephant', dropzoneIndex: 0 }, { optionText: 'Fish', dropzoneIndex: 1 }, { optionText: 'Cat', dropzoneIndex: 2 }]);
+        });
+
+        it('User should be able to select \'Partial - different weights\' scoring', () => {
+            matchingPage.steps.selectAutoScoredScoringSubtype('Partial different weights');
+        });
+
+        it('When the user has switched to \'Partial - different weights\' scoring, then \'Penalty scoring\', \'Minimum scoring\' and \'Rounding\' labels and dropdowns, \'Round negative scores to zero\' label and checkbox should not be displayed in the \'Scoring\' section', () => {
+            matchingPage.steps.verifyMinimumScoringLabelAndDropdownDefaultState();
+            matchingPage.steps.verifyPenaltyPointsLabelAndDropdownDefaultState();
+            matchingPage.steps.verifyRoundingLabelAndDropdownDefaultState();
+            utilities.verifyElementVisibilityState(matchingPage.roundNegativeScoresToZeroCheckbox(), 'notExist');
+        });
+    });
+
+    describe('Auto scored: Partial - different weights scoring - Specify correct answer section', () => {
+        abortEarlySetup();
+        before(() => {
+            matchingPage.steps.navigateToCreateQuestion('matching');
+            cy.barsPreLoaderWait();
+            matchingPage.steps.addTextInQuestionInstructionsInputField('Fill the categories with the right answer.');
+            matchingPage.steps.addMultipleOptionFields(3);
+            matchingPage.steps.enterTextInPromptInputField(promptTextArray);
+            matchingPage.steps.enterTextInOptionInputField(optionsArray);
+            matchingPage.steps.clickAndDropOptionInDropzoneSpecifyCorrectAnswerSection([{ optionText: 'Elephant', dropzoneIndex: 0 }, { optionText: 'Fish', dropzoneIndex: 1 }, { optionText: 'Cat', dropzoneIndex: 2 }]);
+            matchingPage.steps.selectAutoScoredScoringSubtype('Partial different weights');
+        });
+
+        matchingPage.tests.verifyContentsOfSpecifyCorrectAnswerSection();
+
+        it('When the user has switched to \'Partial - different weights\' scoring, then \'Points\' label should be displayed and a points input field should be displayed besides each option', () => {
+            utilities.verifyInnerText(matchingPage.partialDifferentWeightsPointsLabel(), 'Points');
+            utilities.verifyElementVisibilityState(matchingPage.partialDifferentWeightsPointsLabel(), 'visible');
+        });
+
+        it('By default the \'Points\' input field should be empty', () => {
+            matchingPage.steps.verifyPartialDifferentWeightsPointsInputFieldIsEmpty();
+        });
+
+        it('User should be able to set points in the \'Points\' input fields', () => {
+            matchingPage.steps.allotPartialDifferentWeightsPoints({ 0: 2.3, 1: 3.4 });
+        });
+
+        it('CSS of \'Points\' label and \'Points\' input fields', { tags: 'css' }, () => {
+            utilities.verifyCSS(matchingPage.partialDifferentWeightsPointsLabel(), {
+                'color': css.color.labels,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.semibold
+            });
+            utilities.verifyCSS(matchingPage.pointsInputField(), {
+                'color': css.color.text,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+        });
+
+        it('When the user switches to \'All or nothing\' scoring, the points added for individual responses in Partial - different weights scoring should get summed up in the \'All or nothing scoring\' points input field', () => {
+            matchingPage.steps.selectAutoScoredScoringSubtype('All or nothing');
+            matchingPage.steps.verifyPointsFieldValue(5.7);
+        });
+
+        it('When the user updates the entered points in \'All or nothing\' scoring type and switches to \'Partial different weights\' scoring type, then the points should be equally divided and displayed besides each correct option', () => {
+            matchingPage.steps.allotPoints(9);
+            matchingPage.steps.selectAutoScoredScoringSubtype('Partial different weights');
+            matchingPage.steps.verifyPartialDifferentWeightsPointsInputFieldValue([3, 3, 3]);
+        });
+    });
+});

package/cypress/e2e/ILC/Matching/manuallyAndNonScoredEditTab.js

@@ -0,0 +1,68 @@
+import { matchingPage } from "../../../pages";
+import abortEarlySetup from "../../../support/helpers/abortEarly";
+import utilities from "../../../support/helpers/utilities";
+const promptTextArray = ['Wild', 'Aquatic', 'Pet'];
+const optionsArray = ['Cat', 'Elephant', 'Fish', 'Bear', 'Eagle', 'Penguin'];
+
+describe('Create Item page - Matching: Scoring cases', () => {
+    before(() => {
+        cy.loginAs('admin');
+    });
+
+    describe('Manually Scored scoring - Edit tab', () => {
+        abortEarlySetup();
+        before(() => {
+            matchingPage.steps.navigateToCreateQuestion('matching');
+            cy.barsPreLoaderWait();
+            matchingPage.steps.addTextInQuestionInstructionsInputField('Fill the categories with the right answer.');
+        });
+
+        it('When the user selects \'Manually scored\' option from the scoring Type dropdown then the \'Specify correct answer\' section should not be displayed; \'Points\' and \'Minimum scoring\' label and dropdown should be displayed', () => {
+            matchingPage.steps.expandScoringTypeDropdown();
+            matchingPage.steps.selectOptionFromScoringTypeDropdown('Manually scored')
+            utilities.verifyElementVisibilityState(matchingPage.pointsLabel(), 'visible');
+            utilities.verifyElementVisibilityState(matchingPage.pointsInputField(), 'visible');
+            matchingPage.steps.verifyMinimumScoringLabelAndDropdownDefaultState();
+            utilities.verifyElementVisibilityState(matchingPage.specifyCorrectAnswerLabel(), 'notExist');
+            utilities.verifyElementVisibilityState(matchingPage.specifyCorrectAnswerSectionWrapper(), 'notExist');
+            utilities.verifyElementVisibilityState(matchingPage.dropzoneSpecifyCorrectAnswerSection(), 'notExist');
+            utilities.verifyElementVisibilityState(matchingPage.draggableOption(), 'notExist');
+        });
+
+        matchingPage.tests.verifyPointsFieldErrorState(10);
+    });
+
+    describe('Non scored scoring - Scoring section', () => {
+        abortEarlySetup();
+        before(() => {
+            matchingPage.steps.navigateToCreateQuestion('matching');
+            cy.barsPreLoaderWait();
+        });
+
+        it('User should be able to select \'Non scored\' scoring type from scoring type dropdown', () => {
+            matchingPage.steps.expandScoringTypeDropdown();
+            matchingPage.steps.selectOptionFromScoringTypeDropdown('Non scored');
+        });
+
+        matchingPage.tests.verifyScoringSectionContentsForNonScoredScoringType();
+    });
+
+    describe('Non scored scoring - Specify correct answer section', () => {
+        abortEarlySetup();
+        before(() => {
+            matchingPage.steps.navigateToCreateQuestion('matching');
+            cy.barsPreLoaderWait();
+            matchingPage.steps.addTextInQuestionInstructionsInputField('Fill the categories with the right answer.');
+            matchingPage.steps.addMultipleOptionFields(3);
+            matchingPage.steps.enterTextInPromptInputField(promptTextArray);
+            matchingPage.steps.enterTextInOptionInputField(optionsArray);
+            matchingPage.steps.clickAndDropOptionInDropzoneSpecifyCorrectAnswerSection([{ optionText: 'Elephant', dropzoneIndex: 0 }, { optionText: 'Fish', dropzoneIndex: 1 }, { optionText: 'Cat', dropzoneIndex: 2 }]);
+            matchingPage.steps.expandScoringTypeDropdown();
+            matchingPage.steps.selectOptionFromScoringTypeDropdown('Non scored');
+        });
+
+        matchingPage.tests.verifyContentsOfSpecifyCorrectAnswerSection();
+
+        matchingPage.tests.verifyPointsLabelAndInputFieldForNonScoredScoringType();
+    });
+});

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

@@ -0,0 +1,194 @@
+import { matchingPage } 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 dropzone'];
+
+describe('Create item page - Matching: Minimum scoring, Penalty scoring, Rounding - Edit tab', () => {
+    before(() => {
+        cy.loginAs('admin');
+    });
+
+    describe('Scoring section: Minimum scoring - Edit tab', () => {
+        abortEarlySetup();
+        before(() => {
+            matchingPage.steps.navigateToCreateQuestion('matching');
+            cy.barsPreLoaderWait();
+            matchingPage.steps.allotPoints(10);
+        });
+
+        matchingPage.tests.verifyMinimumScoringDropdown();
+
+        matchingPage.tests.verifyMinimumPointsLabelAndInputField();
+
+        matchingPage.tests.verifyMinimumPointsFieldErrorState();
+    });
+
+    describe('Scoring section: Penalty scoring - Edit tab', () => {
+        abortEarlySetup();
+        before(() => {
+            matchingPage.steps.navigateToCreateQuestion('matching');
+            cy.barsPreLoaderWait();
+            matchingPage.steps.allotPoints(10);
+            matchingPage.steps.selectAutoScoredScoringSubtype('Partial equal weights');
+        });
+
+        matchingPage.tests.verifyPenaltyScoringDropdown(penaltyScoringTypeArray);
+
+        matchingPage.tests.verifyPenaltyPointsLabelAndInputField();
+
+        matchingPage.tests.verifyPenaltyPointsErrorState();
+
+        it('When the user selects \'Penalty points for each incorrect dropzone\' from the penalty scoring dropdown, \'Automatically set penalty for each incorrect dropzone to total points / no. of incorrect dropzones\' 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', () => {
+            matchingPage.steps.expandPenaltyScoringDropdown();
+            matchingPage.steps.selectOptionFromPenaltyScoringDropdown('Penalty points for each incorrect dropzone');
+            utilities.verifyInnerText(matchingPage.automaticallySetPenaltyPointsCheckboxLabel(), 'Automatically set penalty for each incorrect dropzone to total points / no. of incorrect dropzones');
+            utilities.verifyInnerText(matchingPage.specifyTotalPenaltyPointsRadioButtonLabel(), 'Specify total penalty points');
+            utilities.verifyInnerText(matchingPage.specifyPointsForEachIncorrectOptionRadioButtonLabel(), 'Specify points for each incorrect dropzone');
+            matchingPage.steps.verifyAutomaticallySetPenaltyPointsCheckboxUncheckedState();
+            matchingPage.steps.verifySpecifyTotalPenaltyPointsRadioButtonCheckedState();
+            matchingPage.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 dropzone: -\' label should be displayed', () => {
+            utilities.verifyInnerText(matchingPage.penaltyPointsDetailsSectionInputFieldLabel(), 'Total penalty points');
+            matchingPage.steps.verifyTotalPenaltyPointsValue('');
+            utilities.verifyInnerText(matchingPage.penaltyPointsDetailsSectionAllottedPointsLabel(), 'Penalty points for each incorrect dropzone: -');
+        });
+
+        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', () => {
+            matchingPage.steps.allotTotalPenaltyPoints(5);
+            matchingPage.steps.verifyPenaltyPointsForEachIncorrectDropzone(1.67);
+        });
+
+        it('When the user deletes an option, then \'points for each incorrect option\' should get updated accordingly', () => {
+            matchingPage.steps.deleteOption(0);
+            matchingPage.steps.verifyPenaltyPointsForEachIncorrectDropzone(2.5);
+        });
+
+        it('When the user adds a new option, then \'points for each incorrect option\' should get updated accordingly', () => {
+            matchingPage.steps.addOption();
+            matchingPage.steps.verifyPenaltyPointsForEachIncorrectDropzone(1.67);
+        });
+
+        it('CSS of the penalty points section - Total penalty points', { tags: 'css' }, () => {
+            utilities.verifyCSS(matchingPage.automaticallySetPenaltyPointsCheckboxLabel(), {
+                'color': css.color.labelText,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(matchingPage.automaticallySetPenaltyPointsCheckbox().parent().find('svg'), {
+                'fill': css.color.uncheckedCheckbox
+            });
+            utilities.verifyCSS(matchingPage.specifyTotalPenaltyPointsRadioButton().parent().find('svg'), {
+                'fill': css.color.activeButtons
+            });
+            utilities.verifyCSS(matchingPage.specifyPointsForEachIncorrectOptionRadioButton().parent().find('svg path'), {
+                'fill': css.color.uncheckedCheckbox
+            });
+            utilities.verifyCSS(matchingPage.specifyTotalPenaltyPointsRadioButtonLabel(), {
+                'color': css.color.labelText,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(matchingPage.specifyPointsForEachIncorrectOptionRadioButtonLabel(), {
+                'color': css.color.labelText,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(matchingPage.penaltyPointsDetailsSectionInputFieldLabel(), {
+                'color': css.color.labelText,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(matchingPage.totalPenaltyPointsInputField(), {
+                'color': css.color.text,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(matchingPage.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(matchingPage.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 dropzone:\' label and empty input field, \'Total penalty points: -\' label should be displayed', () => {
+            cy.log('Pre-step: Clearing the total penalty points input field')
+            matchingPage.steps.clearTotalPenaltyPointsInputField();
+            matchingPage.steps.selectPenaltyPointsForEachIncorrectOptionType('Specify points for each incorrect option');
+            utilities.verifyInnerText(matchingPage.penaltyPointsDetailsSectionInputFieldLabel(), 'Penalty points for each incorrect dropzone');
+            matchingPage.steps.verifyPenaltyPointsForEachIncorrectDropzoneValue('');
+            utilities.verifyInnerText(matchingPage.penaltyPointsDetailsSectionAllottedPointsLabel(), 'Total penalty points: -');
+        });
+
+        it('When the user allots Penalty points for each incorrect dropzone, then \'Total penalty points\' should get updated as per the count of incorrect options available', () => {
+            matchingPage.steps.allotPenaltyPointsForEachIncorrectDropzone(1);
+            matchingPage.steps.verifyTotalPenaltyPoints(3);
+        });
+
+        it('When the user adds a new option, then \'Total penalty points\' should get updated accordingly', () => {
+            matchingPage.steps.addOption();
+            matchingPage.steps.verifyTotalPenaltyPoints(4);
+        });
+
+        it('When the user deletes an option, then \'points for each incorrect option\' should get updated accordingly', () => {
+            matchingPage.steps.deleteOption(0);
+            matchingPage.steps.verifyTotalPenaltyPoints(3);
+        });
+
+        it('CSS of the penalty points section - Penalty points for each incorrect dropzone', { tags: 'css' }, () => {
+            utilities.verifyCSS(matchingPage.penaltyPointsDetailsSectionInputFieldLabel(), {
+                'color': css.color.labelText,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(matchingPage.penaltyPointsForEachIncorrectOptionInputField(), {
+                'color': css.color.text,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(matchingPage.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 dropzone', { tags: 'a11y' }, () => {
+            cy.checkAccessibility(matchingPage.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\'', () => {
+            matchingPage.steps.selectPenaltyPointsForEachIncorrectOptionType('Specify total penalty points');
+            matchingPage.steps.verifyTotalPenaltyPointsValue(3);
+            utilities.verifyInnerText(matchingPage.penaltyPointsDetailsSectionAllottedPointsLabel(), 'Penalty points for each incorrect dropzone: 1');
+        });
+
+        it('When the user checks the \'Automatically set penalty for each incorrect dropzone to total points / no. of incorrect dropzones\' 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 dropzone: #\' and \'Total penalty points: #\' should be displayed as per the alloted points and available incorrect options', () => {
+            matchingPage.steps.checkAutomaticallySetPenaltyPointsCheckbox();
+            matchingPage.steps.verifySpecifyTotalPenaltyPointsDisabledState();
+            matchingPage.steps.verifySpecifyPointsForEachIncorrectOptionRadioButtonSelectedAndDisabledState();
+            utilities.verifyInnerText(utilities.getNthElement(matchingPage.penaltyPointsDetailsSectionAllottedPointsLabel(), 0), 'Penalty points for each incorrect dropzone: 3.33');
+            utilities.verifyInnerText(utilities.getNthElement(matchingPage.penaltyPointsDetailsSectionAllottedPointsLabel(), 1), 'Total penalty points: 9.99');
+        });
+    });
+
+    describe('Scoring section: Rounding - Edit tab', () => {
+        abortEarlySetup();
+        before(() => {
+            matchingPage.steps.navigateToCreateQuestion('matching');
+            cy.barsPreLoaderWait();
+            matchingPage.steps.allotPoints(10);
+            matchingPage.steps.selectAutoScoredScoringSubtype('Partial equal weights')
+        });
+
+        matchingPage.tests.verifyRoundingDropdown();
+
+        matchingPage.tests.verifyRoundNegativeScoreToZeroLabelAndCheckbox();
+    });
+});

package/cypress/e2e/ILC/Matching/switchingCasesBetweenOptionsLayout.js

@@ -0,0 +1,49 @@
+import { matchingPage } from "../../../pages";
+import abortEarlySetup from "../../../support/helpers/abortEarly";
+import utilities from "../../../support/helpers/utilities";
+const options1 = ['Flower', 'Petals', 'Roots'];
+const options2 = ['Seeds', 'Stem', 'Branch'];
+const options3 = options1.concat(options2);
+
+describe('Create Item Page: Matching: Switching cases between \'Standard\' and \'Grouped\' options layout', () => {
+    before(() => {
+        cy.loginAs('admin');
+    });
+
+    describe('Matching: Switching cases between \'Standard\' and \'Grouped\' options layout: \'Response Options section\'', () => {
+        abortEarlySetup();
+        before(() => {
+            matchingPage.steps.navigateToCreateQuestion('matching');
+            cy.barsPreLoaderWait();
+            matchingPage.steps.addTextInQuestionInstructionsInputField('Matching');
+            matchingPage.steps.enterTextInOptionInputField(options1);
+        });
+
+        it('When the user switches from \'Standard\' response layout to \'Grouped\', all the option input fields along with text should appear in the group options', () => {
+            matchingPage.steps.expandDraggableOptionsLayoutDropdown();
+            matchingPage.steps.selectOptionFromDraggableOptionsLayoutDropdown('Grouped');
+            matchingPage.steps.verifyTextInOptionInputField(options1);
+            cy.log('verifying draggable options in \'Specify correct answer\' section')
+            matchingPage.steps.verifyGroupedContainerContentsInSpecifyCorrectAnswerSection(0, options1);
+        });
+
+        it('When the user creates more than one group of options and switches to \'Standard\' response layout, all the option input fields along with text should appear in the standard options', () => {
+            cy.log('Adding a new group and adding input to the option fields')
+            matchingPage.steps.addGroupWithTitleAndOptionsInDraggableOptionsSection('Group B', options2);
+            matchingPage.steps.expandDraggableOptionsLayoutDropdown();
+            matchingPage.steps.selectOptionFromDraggableOptionsLayoutDropdown('Standard');
+            matchingPage.steps.verifyTextInOptionInputField(options3);
+            cy.log('verifying draggable options in \'Specify correct answer\' section')
+            matchingPage.steps.verifyDraggableOptionInOptionsContainerSpecifyCorrectAnswerSection(options3);
+        });
+
+        it('On switching back to \'Grouped\' response layout, all option input fields should be present under Group A and no other group should exist', () => {
+            matchingPage.steps.expandDraggableOptionsLayoutDropdown();
+            matchingPage.steps.selectOptionFromDraggableOptionsLayoutDropdown('Grouped');
+            utilities.verifyElementCount(matchingPage.groupTab(), 1);
+            matchingPage.steps.verifyTextInOptionInputField(options3);
+            cy.log('verifying draggable options in \'Specify correct answer\' section')
+            matchingPage.steps.verifyGroupedContainerContentsInSpecifyCorrectAnswerSection(0, options3);
+        });
+    });
+});

package/cypress/e2e/ILC/TextEntryMathWithImage/allOrNothingScoringForAllViews.smoke.js

@@ -59,7 +59,7 @@ describe('Create Item page - Text entry math: All or nothing ', () => {
 
     //Failing due to https://redmine.zeuslearning.com/issues/561708, https://redmine.zeuslearning.com/issues/561177 
     views.forEach((view) => {
-        describe.only(`Text entry math: all or nothing scoring - ${view}`, { tags: 'smoke' }, () => {
+        describe(`Text entry math: all or nothing scoring - ${view}`, { tags: 'smoke' }, () => {
             abortEarlySetup();
             before(() => {
                 switch (view) {

package/cypress/e2e/ILC/ToolSettings/toolSettingsPreviewContents.smoke.js

@@ -101,7 +101,7 @@ describe('Tool settings content for all views', () => {
             });
         });
 
-        describe.only(`Preview tab contents : Multiple tools selected - ${view}`, { tags: 'smoke' }, () => {
+        describe(`Preview tab contents : Multiple tools selected - ${view}`, { tags: 'smoke' }, () => {
             abortEarlySetup();
             before(() => {
                 switch (view) {

package/cypress/fixtures/theme/ilc.json

@@ -122,16 +122,22 @@
         "geoGebraCanvasBorder": "rgb(102, 102, 102)",
         "geoGebraHttpsBg": "rgb(233, 238, 255)",
         "enabledSwitchBg": "rgb(48, 160, 79)",
+        "disabledSwitchBg": "rgb(0, 0, 124)",
         "gridCellHoverStateBg": "rgba(186, 201, 255, 0.6)",
         "gridCellDefaultStateBg": "rgba(186, 201, 255, 0.2)",
         "gridCellSelectedStateBg": "rgba(107, 139, 255, 0.7)",
         "gridCellCorrectAnswerBg": "rgba(43, 120, 74, 0.4)",
-        "gridCellIncorrectAnswerBg": "rgba(209, 51, 51, 0.4)"
+        "gridCellIncorrectAnswerBg": "rgba(209, 51, 51, 0.4)",
+        "gridCellSelectedStateBorder": "rgb(41, 0, 128)",
+        "gridCellHiddenStateBorder": "rgb(117, 117, 154)",
+        "gridCellIcon": "rgb(41, 0, 128)",
+        "gridBorder": "rgb(0, 0, 124)"
     },
     "fontSize": {
         "extraSmall": "10px",
         "small": "12px",
         "normal": "14px",
+        "big": "15px",
         "default": "16px",
         "large": "17px",
         "heading": "18px",

package/cypress/pages/components/autoScoredStudentViewSettings.js

@@ -4,7 +4,7 @@ const css = Cypress.env('css');
 
 //Note: We need to work on this file, as disablePreviousIncorrectOptionLabel is not present for all auto scored question types, need to create different component files allowStudentsToCheckAnswerComponent, disablePreviousOptionComponent
 const selectors = {
-    allowStudentToCheckAnswerLabel: () => cy.get('[data-ngie-testid="allow-student-to-check-answer-checkbox"] .MuiFormControlLabel-label'),
+    allowStudentToCheckAnswerLabel: () => cy.get('[data-ngie-testid="allow-students-to-check-answer-checkbox"] .MuiFormControlLabel-label'),
     //Note: update after https://redmine.zeuslearning.com/issues/565666 gets resolved
     allowStudentToCheckAnswerCheckbox: () => cy.get('[data-ngie-testid="allow-students-to-check-answer-checkbox"] input'),
     maximumCheckAnswerAttemptsDropdownLabel: () => cy.get('#Maximum-check-answer-attempts-dropdown-label'),

package/cypress/pages/components/optionsWrapperComponent.js

@@ -441,7 +441,7 @@ const tests = {
             utilities.verifyElementVisibilityState(commonComponents.tooltipText(), 'visible')
             utilities.verifyCSS(commonComponents.tooltipText(), {
                 'color': css.color.whiteText,
-                'font-size': css.fontSize.small,
+                'font-size': css.fontSize.normal,
                 'font-weight': css.fontWeight.regular
             });
             utilities.getNthElement(optionsWrapperComponent.deleteOptionButton(), 0)

package/cypress/pages/contentBlocksPage.js

@@ -1,9 +1,11 @@
 import utilities from "../support/helpers/utilities";
 import { createQuestionBasePage, commonComponents } from "./components";
+import { createItemPage } from "./createItemPage";
 const css = Cypress.env('css');
 
 const selectors = {
     ...commonComponents,
+    ...createQuestionBasePage,
     headerLabel: () => cy.get('[class*="ContentBlocksstyles__LabelContent"]'),
     titleLabel: () => cy.get('.inline-text-property-label').eq(0),
     titleInputField: () => cy.get('.input-field input').eq(0),
@@ -565,7 +567,34 @@ const steps = {
                             .should('have.text', `${index + 1}`);
                     });
             });
-    }
+    },
+
+    createBasicContentBlockResourceAndTool: (inputHeadingText, inputBodyText) => {
+        contentBlocksPage.titleInputField()
+            .type(inputHeadingText);
+        contentBlocksPage.textBlockInputField()
+            .type(inputBodyText);
+        contentBlocksPage.saveQuestionButton()
+            .click();
+    },
+
+    /**
+    * @param {number} panel denotes panel number
+    * @param {number} questionNumber denotes question number
+    * @param {string} questionTitle denotes question title
+    * @param {string} questionInstruction denotes question instruction
+    * @description verify question content
+    */
+    verifyContentBlockContentsPreview: ({ questionIndex, questionTitle, questionInstructions, panel = 0 }) => {
+        createItemPage.panelWrapper()
+            .eq(panel)
+            .within(() => {
+                utilities.verifyInnerText(createItemPage.questionTitle().eq(questionIndex), questionTitle);
+                utilities.verifyElementVisibilityState(createItemPage.questionTitle().eq(questionIndex), 'visible');
+                utilities.verifyInnerText(contentBlocksPage.contentWrapperPreviewTab().eq(questionIndex), questionInstructions);
+                utilities.verifyElementVisibilityState(contentBlocksPage.contentWrapperPreviewTab().eq(questionIndex), 'visible');
+            });
+    },
 }
 
 export const contentBlocksPage = {