itemengine-cypress-automation 1.0.128 → 1.0.131-updateILCrepo6March-02c78d1.0

package/cypress/e2e/ILC/FillInTheGapsTextNew/editTabScoringSection.js

@@ -0,0 +1,265 @@
+import { fillInTheGapsTextPage } from "../../../pages";
+import abortEarlySetup from "../../../support/helpers/abortEarly";
+import utilities from "../../../support/helpers/utilities";
+const css = Cypress.env('css');
+
+describe('Create item page - Fill in the gaps with text: Scoring section', () => {
+    before(() => {
+        cy.loginAs('admin');
+    });
+
+    describe('Scoring section contents', () => {
+        abortEarlySetup();
+        before(() => {
+            fillInTheGapsTextPage.steps.navigateToCreateQuestion('fill in the gaps with text');
+            cy.barsPreLoaderWait();
+        });
+
+        fillInTheGapsTextPage.tests.verifyScoringTypeLabelAndDropdown('Auto scored');
+
+        fillInTheGapsTextPage.tests.verifyScoringSubtypeContentsForMultipleResponseTypeQuestion();
+    });
+
+    describe('Auto scored: All or nothing scoring - Scoring section', () => {
+        abortEarlySetup();
+        before(() => {
+            fillInTheGapsTextPage.steps.navigateToCreateQuestion('fill in the gaps with text');
+            cy.barsPreLoaderWait();
+        });
+
+        it('When the user has selected \'All or nothing\' scoring subtype, minimum scoring dropdown should be displayed in the scoring section', () => {
+            fillInTheGapsTextPage.steps.verifyMinimumScoringLabelAndDropdownDefaultState();
+        });
+    });
+
+    describe('Auto scored: All or nothing scoring - Specify correct answer section', () => {
+        abortEarlySetup();
+        before(() => {
+            fillInTheGapsTextPage.steps.navigateToCreateQuestion('fill in the gaps with text');
+            cy.barsPreLoaderWait();
+        });
+
+        fillInTheGapsTextPage.tests.verifyContentsOfSpecifyCorrectAnswerSection();
+
+        fillInTheGapsTextPage.tests.verifyPointsLabelAndInputField();
+    });
+
+    describe('Auto scored: Partial - equal weights scoring - Scoring section', () => {
+        abortEarlySetup();
+        before(() => {
+            fillInTheGapsTextPage.steps.navigateToCreateQuestion('fill in the gaps with text');
+            cy.barsPreLoaderWait();
+        });
+
+        it('User should be able to select \'Partial - equal weights\' scoring type', () => {
+            fillInTheGapsTextPage.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', () => {
+            fillInTheGapsTextPage.steps.verifyMinimumScoringLabelAndDropdownDefaultState();
+            fillInTheGapsTextPage.steps.verifyPenaltyPointsLabelAndDropdownDefaultState();
+            fillInTheGapsTextPage.steps.verifyRoundingLabelAndDropdownDefaultState();
+            utilities.verifyElementVisibilityState(fillInTheGapsTextPage.roundNegativeScoresToZeroCheckbox(), 'notExist');
+        });
+    });
+
+    describe('Auto scored: Partial - equal weights scoring - Specify correct answer section', () => {
+        abortEarlySetup();
+        before(() => {
+            fillInTheGapsTextPage.steps.navigateToCreateQuestion('fill in the gaps with text');
+            cy.barsPreLoaderWait();
+            fillInTheGapsTextPage.steps.selectAutoScoredScoringSubtype('Partial equal weights');
+        });
+
+        fillInTheGapsTextPage.tests.verifyContentsOfSpecifyCorrectAnswerSection();
+
+        it('When no points are entered in the points input field, then points per response should not be displayed on the response accordion', () => {
+            utilities.verifyElementVisibilityState(fillInTheGapsTextPage.responseAccordionPointsWrapper(), 'hidden');
+        });
+
+        it('When the user gives a score input to \'Points\' input field, then the score should be equally divided and displayed on each response tab with a \'Points:\' label', () => {
+            fillInTheGapsTextPage.steps.allotPoints(4);
+            fillInTheGapsTextPage.steps.verifyPointsDisplayedOnResponseAccordion(0, 2);
+            fillInTheGapsTextPage.steps.verifyPointsDisplayedOnResponseAccordion(1, 2);
+        });
+
+        it('When the user adds one more response area, then points per response should get updated accordingly', () => {
+            fillInTheGapsTextPage.steps.addResponseArea();
+            fillInTheGapsTextPage.steps.verifyPointsDisplayedOnResponseAccordion(0, 1.33);
+            fillInTheGapsTextPage.steps.verifyPointsDisplayedOnResponseAccordion(1, 1.33);
+            fillInTheGapsTextPage.steps.verifyPointsDisplayedOnResponseAccordion(2, 1.33);
+        });
+
+        it('When the user deletes a response token, then points per response should get updated accordingly', () => {
+            fillInTheGapsTextPage.steps.deleteAResponseArea(0);
+            fillInTheGapsTextPage.steps.verifyPointsDisplayedOnResponseAccordion(0, 2);
+            fillInTheGapsTextPage.steps.verifyPointsDisplayedOnResponseAccordion(1, 2);
+        });
+
+        it('When user adds an alternate answer field in a response accordion, then the points per response accordion should not be updated', () => {
+            fillInTheGapsTextPage.steps.expandResponseAccordionSpecifyCorrectAnswer(0);
+            fillInTheGapsTextPage.steps.addAlternateAnswerInResponseAccordion(0);
+            fillInTheGapsTextPage.steps.verifyPointsDisplayedOnResponseAccordion(0, 2);
+            fillInTheGapsTextPage.steps.verifyPointsDisplayedOnResponseAccordion(1, 2);
+        });
+
+        it('When the user switches to \'All or nothing\' scoring, then the points on each response accordion should not be displayed and the points displayed in \'Points\' input field should remain unchanged', () => {
+            fillInTheGapsTextPage.steps.selectAutoScoredScoringSubtype('All or nothing');
+            utilities.verifyElementVisibilityState(fillInTheGapsTextPage.responseAccordionPointsWrapper(), 'notExist');
+            fillInTheGapsTextPage.steps.verifyPointsFieldValue(4);
+        });
+
+        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 on each response accordion', () => {
+            fillInTheGapsTextPage.steps.allotPoints(9);
+            fillInTheGapsTextPage.steps.selectAutoScoredScoringSubtype('Partial equal weights');
+            fillInTheGapsTextPage.steps.verifyPointsDisplayedOnResponseAccordion(0, 4.5);
+            fillInTheGapsTextPage.steps.verifyPointsDisplayedOnResponseAccordion(1, 4.5);
+        });
+
+        it('CSS of \'Points:\' label and its displayed score', { tags: 'css' }, () => {
+            utilities.verifyCSS(fillInTheGapsTextPage.responseAccordionPointsLabel(), {
+                'color': css.color.labels,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.semibold
+            });
+            utilities.verifyCSS(fillInTheGapsTextPage.responseAccordionPointsScore(), {
+                'color': css.color.text,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+        });
+    });
+
+    describe('Auto scored: Partial - different weights scoring - Scoring section', () => {
+        abortEarlySetup();
+        before(() => {
+            fillInTheGapsTextPage.steps.navigateToCreateQuestion('fill in the gaps with text');
+            cy.barsPreLoaderWait();
+        });
+
+        it('User should be able to select \'Partial - different weights\' scoring', () => {
+            fillInTheGapsTextPage.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', () => {
+            fillInTheGapsTextPage.steps.verifyMinimumScoringLabelAndDropdownDefaultState();
+            fillInTheGapsTextPage.steps.verifyPenaltyPointsLabelAndDropdownDefaultState();
+            fillInTheGapsTextPage.steps.verifyRoundingLabelAndDropdownDefaultState();
+            utilities.verifyElementVisibilityState(fillInTheGapsTextPage.roundNegativeScoresToZeroCheckbox(), 'notExist');
+        });
+    });
+
+    describe('Auto scored: Partial - different weights scoring - Specify correct answer section', () => {
+        abortEarlySetup();
+        before(() => {
+            fillInTheGapsTextPage.steps.navigateToCreateQuestion('fill in the gaps with text');
+            cy.barsPreLoaderWait();
+            fillInTheGapsTextPage.steps.selectAutoScoredScoringSubtype('Partial different weights');
+        });
+
+        fillInTheGapsTextPage.tests.verifyContentsOfSpecifyCorrectAnswerSection();
+
+        it('When the user has switched to \'Partial - different weights\' scoring, then the correct answer tab points input field should not be displayed and individual empty points input field should be displayed in each response accordion', () => {
+            utilities.verifyElementCount(fillInTheGapsTextPage.pointsInputField(), 2);
+            fillInTheGapsTextPage.steps.verifyPointsLabelAndInputFieldInResponseAccordion(0, '');
+            fillInTheGapsTextPage.steps.verifyPointsLabelAndInputFieldInResponseAccordion(1, '');
+        });
+
+        it('User should be able to set points in the \'Points\' input fields', () => {
+            fillInTheGapsTextPage.steps.allotPointsInResponseAccordion(0, 1);
+            fillInTheGapsTextPage.steps.allotPointsInResponseAccordion(1, 3);
+            fillInTheGapsTextPage.steps.verifyPointsLabelAndInputFieldInResponseAccordion(0, 1);
+            fillInTheGapsTextPage.steps.verifyPointsLabelAndInputFieldInResponseAccordion(1, 3);
+        });
+
+        it('CSS of \'Points\' label and \'Points\' input field in response accordion', { tags: 'css' }, () => {
+            utilities.verifyCSS(utilities.getNthElement(fillInTheGapsTextPage.pointsLabel(), 0), {
+                'color': css.color.labels,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.semibold
+            });
+            utilities.verifyCSS(utilities.getNthElement(fillInTheGapsTextPage.pointsInputField(), 0), {
+                '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', () => {
+            fillInTheGapsTextPage.steps.selectAutoScoredScoringSubtype('All or nothing');
+            fillInTheGapsTextPage.steps.verifyPointsFieldValue(4);
+        });
+
+        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', () => {
+            fillInTheGapsTextPage.steps.allotPoints(9);
+            fillInTheGapsTextPage.steps.selectAutoScoredScoringSubtype('Partial different weights');
+            fillInTheGapsTextPage.steps.verifyPointsLabelAndInputFieldInResponseAccordion(0, 4.5);
+            fillInTheGapsTextPage.steps.verifyPointsLabelAndInputFieldInResponseAccordion(1, 4.5);
+        });
+    });
+
+    describe('Manually scored scoring - Scoring section', () => {
+        abortEarlySetup();
+        before(() => {
+            fillInTheGapsTextPage.steps.navigateToCreateQuestion('fill in the gaps with text');
+            cy.barsPreLoaderWait();
+        });
+
+        it('User should be able to select \'Manually scored\' scoring type from scoring type dropdown', () => {
+            fillInTheGapsTextPage.steps.expandScoringTypeDropdown();
+            fillInTheGapsTextPage.steps.selectOptionFromScoringTypeDropdown('Manually scored');
+        });
+
+        it('When the user has selected \'Manually scored\' scoring type, then the specify correct answer section should not be displayed', () => {
+            utilities.verifyElementVisibilityState(fillInTheGapsTextPage.specifyCorrectAnswerLabel(), 'notExist');
+            utilities.verifyElementVisibilityState(fillInTheGapsTextPage.specifyCorrectAnswerSectionWrapper(), 'notExist');
+        });
+
+        fillInTheGapsTextPage.tests.verifyScoringSectionContentsForManuallyScoredScoringType();
+
+        fillInTheGapsTextPage.tests.verifyPointsFieldErrorState();
+
+        it('When user has selected \'Manually scored\' scoring type, then in scoring section \'Minimum scoring\' label and dropdown should be visible', () => {
+            fillInTheGapsTextPage.steps.verifyMinimumScoringLabelAndDropdownDefaultState();
+        });
+    });
+
+    describe('Non scored scoring - Scoring section', () => {
+        abortEarlySetup();
+        before(() => {
+            fillInTheGapsTextPage.steps.navigateToCreateQuestion('fill in the gaps with text');
+            cy.barsPreLoaderWait();
+        });
+
+        it('User should be able to select \'Non scored\' scoring type from scoring type dropdown', () => {
+            fillInTheGapsTextPage.steps.expandScoringTypeDropdown();
+            fillInTheGapsTextPage.steps.selectOptionFromScoringTypeDropdown('Non scored');
+        });
+
+        fillInTheGapsTextPage.tests.verifyScoringSectionContentsForNonScoredScoringType();
+    });
+
+    describe('Non scored scoring - Specify correct answer section', () => {
+        abortEarlySetup();
+        before(() => {
+            fillInTheGapsTextPage.steps.navigateToCreateQuestion('fill in the gaps with text');
+            cy.barsPreLoaderWait();
+            fillInTheGapsTextPage.steps.expandScoringTypeDropdown();
+            fillInTheGapsTextPage.steps.selectOptionFromScoringTypeDropdown('Non scored');
+        });
+
+        fillInTheGapsTextPage.tests.verifyContentsOfSpecifyCorrectAnswerSection();
+
+        fillInTheGapsTextPage.tests.verifyPointsLabelAndInputFieldForNonScoredScoringType();
+    });
+
+    describe('Conditional checkboxes - Content', () => {
+        abortEarlySetup();
+        before(() => {
+            fillInTheGapsTextPage.steps.navigateToCreateQuestion('fill in the gaps with text');
+            cy.barsPreLoaderWait();
+        });
+
+        fillInTheGapsTextPage.tests.verifyConditionalCheckboxesSectionContents();
+    });
+});

package/cypress/e2e/ILC/FillInTheGapsTextNew/headerSection.js

@@ -0,0 +1,75 @@
+import abortEarlySetup from "../../../support/helpers/abortEarly";
+import { dialogBoxBase, fillInTheGapsTextPage } from "../../../pages";
+import utilities from "../../../support/helpers/utilities";
+const options = ['Flower', 'Leaves'];
+
+describe('Create item page - Fill in the gaps with text: Header section and saving question', () => {
+    before(() => {
+        cy.loginAs('admin');
+    });
+
+    describe('Header section contents', () => {
+        abortEarlySetup();
+        before(() => {
+            fillInTheGapsTextPage.steps.navigateToCreateQuestion('fill in the gaps with text');
+            cy.barsPreLoaderWait();
+        });
+
+        fillInTheGapsTextPage.tests.verifyCreateQuestionPageQuestionTypeHeader('Fill in the gaps with text');
+    });
+
+    describe('Tabs section', () => {
+        abortEarlySetup();
+        before(() => {
+            fillInTheGapsTextPage.steps.navigateToCreateQuestion('fill in the gaps with text');
+            cy.barsPreLoaderWait();
+        });
+
+        fillInTheGapsTextPage.tests.verifyTabsSection();
+    });
+
+    describe('Cancel button', () => {
+        abortEarlySetup();
+        before(() => {
+            fillInTheGapsTextPage.steps.navigateToCreateQuestion('fill in the gaps with text');
+            cy.barsPreLoaderWait();
+        });
+
+        fillInTheGapsTextPage.tests.verifyCancelButton('fill in the gaps with text')
+    });
+
+    describe('Save Question button', () => {
+        abortEarlySetup();
+        before(() => {
+            fillInTheGapsTextPage.steps.navigateToCreateQuestion('fill in the gaps with text');
+            cy.barsPreLoaderWait();
+        });
+
+        describe('Validation error messages', () => {
+            dialogBoxBase.tests.verifyRequiredFieldsWarningPopupOnClickingSaveButton();
+
+            it('Validation error messages should be displayed below required input fields', () => {
+                fillInTheGapsTextPage.steps.verifyQuestionInstructionsErrorMessage();
+                fillInTheGapsTextPage.steps.verifyPointsFieldErrorMessage();
+                utilities.verifyInnerText(utilities.getNthElement(fillInTheGapsTextPage.errorMessage(), 2), 'Error: Answer is required.');
+            });
+
+            it('Validation error messages should disappear when required input fields are filled', () => {
+                fillInTheGapsTextPage.steps.addTextInQuestionInstructionsInputField('Question instruction');
+                fillInTheGapsTextPage.steps.allotPoints(10);
+                fillInTheGapsTextPage.steps.verifyErrorMessageIsNotDisplayed();
+                fillInTheGapsTextPage.steps.verifySpecifyCorrectAnswerErrorIconNotExists();
+            });
+
+            fillInTheGapsTextPage.tests.verifyCreateItemWrapperContentsA11y();
+        });
+
+        describe('Saving a question', () => {
+            it('Clicking on Save Question button the question should get saved and a snackbar with text \'Saved successfully!\' should be displayed', () => {
+                fillInTheGapsTextPage.steps.saveAQuestionAndVerifySnackbar();
+            });
+            
+            fillInTheGapsTextPage.tests.verifySavedSuccessfullySnackbarCSSAndA11y();
+        });
+    });
+});

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

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

package/cypress/e2e/ILC/FillInTheGapsTextNew/responseAnswersAndAcceptedStudentInput.js

@@ -0,0 +1,56 @@
+import { fillInTheGapsTextPage } from "../../../pages";
+import abortEarlySetup from "../../../support/helpers/abortEarly";
+const css = Cypress.env('css');
+
+describe('Create Item page - Fill in the gaps with text: ', () => {
+    before(() => {
+        cy.loginAs('admin');
+    });
+
+    describe('Answer input field verification: Edit tab functionality', () => {
+        abortEarlySetup();
+        before(() => {
+            fillInTheGapsTextPage.steps.navigateToCreateQuestion('fill in the gaps with text');
+            cy.barsPreLoaderWait();
+            fillInTheGapsTextPage.steps.deleteAResponseArea(1);
+        });
+
+        fillInTheGapsTextPage.tests.verifyAnswerInputFieldEditTab();
+    });
+
+    describe('Accepted student input - Edit tab functionality', () => {
+        abortEarlySetup();
+        before(() => {
+            fillInTheGapsTextPage.steps.navigateToCreateQuestion('fill in the gaps with text');
+            cy.barsPreLoaderWait();
+        });
+
+        fillInTheGapsTextPage.tests.verifyAcceptedStudentInputEditTabFunctionality();
+
+        it('When user adds multiple text container and set different accepted student input then it should be applied appropriately', () => {
+            fillInTheGapsTextPage.steps.addResponseArea();
+            fillInTheGapsTextPage.steps.enterTextInAnswerInputFieldsSpecifyCorrectAnswerSection([{ responseIndex: 2, responseText: 'Answer12' }]);
+            fillInTheGapsTextPage.steps.verifyTextInResponseAccordionAnswerInputField([{ responseIndex: 2, responseText: 'Answer12' }]);
+        });
+    });
+
+    describe('Accepted student input - Preview tab functionality', () => {
+        abortEarlySetup();
+        before(() => {
+            fillInTheGapsTextPage.steps.navigateToCreateQuestion('fill in the gaps with text');
+            cy.barsPreLoaderWait();
+        });
+
+        fillInTheGapsTextPage.tests.verifyAcceptedStudentInputPreviewTabFunctionality();
+
+        it('When user adds multiple text container and sets different accepted student input in edit tab then it should be applied appropriately in preview tab', () => {
+            fillInTheGapsTextPage.steps.switchToEditTab();
+            fillInTheGapsTextPage.steps.addResponseArea();
+            fillInTheGapsTextPage.steps.switchToPreviewTab();
+            fillInTheGapsTextPage.steps.enterTextInAnswerInputFieldsPreviewTab([{ responseIndex: 0, responseText: 'Flower232&*' }]);
+            fillInTheGapsTextPage.steps.verifyTextInAnswerInputFieldsPreviewTab([{ responseIndex: 0, responseText: '232' }]);
+            fillInTheGapsTextPage.steps.enterTextInAnswerInputFieldsPreviewTab([{ responseIndex: 1, responseText: 'Flower232&*' }]);
+            fillInTheGapsTextPage.steps.verifyTextInAnswerInputFieldsPreviewTab([{ responseIndex: 1, responseText: 'Flower232&*' }]);
+        });
+    });
+});

package/cypress/e2e/ILC/FillInTheGapsTextNew/setLimitSection.js

@@ -15,6 +15,10 @@ describe('Create item page - Fill in the gaps with text: Set limit section', ()
         });
 
         fillInTheGapsTextPage.tests.verifySetLimitSectionContents();
+
+        fillInTheGapsTextPage.tests.verifySetLimitSectionErrorConditionsForMinAndMaxCharacterInputFields();
+
+        fillInTheGapsTextPage.tests.verifySetLimitSectionForNoneOption();
     });
 
     describe('Fill in the gaps with text: Set limit section : Edit tab functionality', () => {
@@ -24,7 +28,23 @@ describe('Create item page - Fill in the gaps with text: Set limit section', ()
             cy.barsPreLoaderWait();
         });
 
-        fillInTheGapsTextPage.tests.verifySetLimitSectionEditTabFunctionality();
+        it('When maximum character limit input field value is 50 then maximum character limit should be 50 in the specify correct answer section', () => {
+            fillInTheGapsTextPage.steps.verifyMaximumCharacterLimitInputField(50);
+            fillInTheGapsTextPage.steps.verifyMaximumCharacterLimit(0, 50);
+        });
+
+        it('When the user updates the maximum character limit input field value then maximum character limit should update in the specify correct answer section', () => {
+            fillInTheGapsTextPage.steps.setMaximumLimit(10);
+            fillInTheGapsTextPage.steps.verifyMaximumCharacterLimit(0, 10);
+        });
+
+        it('User should able to enter characters in the answer input field', () => {
+            fillInTheGapsTextPage.steps.enterTextInAnswerInputFieldsSpecifyCorrectAnswerSection([{ responseIndex: 0, responseText: 'Flower' }]);
+        });
+
+        fillInTheGapsTextPage.tests.verifyMaximumCharacterLimitWarningConditionsSpecifyCorrectAnswerSection();
+
+        fillInTheGapsTextPage.tests.verifyMinimumCharacterLimitWarningConditionsSpecifyCorrectAnswerSection();
     });
 
     describe('Fill in the gaps with text: Set limit section : Preview tab functionality', () => {
@@ -32,8 +52,26 @@ describe('Create item page - Fill in the gaps with text: Set limit section', ()
         before(() => {
             fillInTheGapsTextPage.steps.navigateToCreateQuestion('fill in the gaps with text');
             cy.barsPreLoaderWait();
+            fillInTheGapsTextPage.steps.switchToPreviewTab();
+        });
+
+        it('When maximum character limit input field value is 50 then maximum character limit should be 50 in the preview tab', () => {
+            fillInTheGapsTextPage.steps.verifyMaximumCharacterLimitInPreviewTab(0, 50);
+        });
+
+        it('When the user updates the maximum character limit input field value then maximum character limit should update in the preview tab', () => {
+            fillInTheGapsTextPage.steps.switchToEditTab();
+            fillInTheGapsTextPage.steps.setMaximumLimit(10);
+            fillInTheGapsTextPage.steps.switchToPreviewTab();
+            fillInTheGapsTextPage.steps.verifyMaximumCharacterLimitInPreviewTab(0, 10);
+        });
+
+        it('User should able to enter characters in the response field', () => {
+            fillInTheGapsTextPage.steps.addTextInAnswerInputFieldsPreviewTab(0, 'Flower');
         });
 
-        fillInTheGapsTextPage.tests.verifySetLimitSectionPreviewTabFunctionality();
+        fillInTheGapsTextPage.tests.verifyMaximumCharacterLimitWarningConditionsPreviewTab();
+
+        fillInTheGapsTextPage.tests.verifyMinimumCharacterLimitWarningConditionsPreviewTab();
     });
 });