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

package/cypress/pages/components/fillInTheGapsTextCommonComponent.js

@@ -1,7 +1,13 @@
 import utilities from "../../support/helpers/utilities";
+import { acceptedStudentInputComponent } from "./acceptedStudentInputComponent";
+import { autoScoredScoringSectionMultiResponseType } from "./autoScoredScoringSectionMultiResponseType";
+import { autoScoredSpecifyCorrectAnswerSection } from "./autoScoredSpecifyCorrectAnswerSection";
 import { commonComponents } from "./commonComponents";
 import { createQuestionBasePage } from "./createQuestionBasePage";
+import { scoringSectionBaseEditTab } from "./scoringSectionBaseEditTab";
 const css = Cypress.env('css');
+const conditionalCheckboxes = ['Case sensitive', 'Validate if answer is included in the response', 'Ignore extra spaces', 'Ignore single letter mistake'];
+
 
 const selectors = {
     answerInputFieldSpecifyCorrectAnswerSection: () => cy.get('.label-image-text-inline-text-field input'),
@@ -26,6 +32,7 @@ const selectors = {
     noneLabel: () => cy.get('[aria-label="None"].ngie-radio-label'),
     limitReachedWarningMessage: () => cy.get('.disabled-wrapper-cls [class*="DisabledTextWrapper"]'),
     limitReachedWarningMessageContainer: () => cy.get('.disabled-wrapper-cls'),
+    penaltyPointsForEachIncorrectTextContainerInputField: () => cy.get('input[aria-label="Penalty points for each incorrect text container"]'),
 
     //response accordion
     responseAccordion: () => cy.get('.response-text-accordion'),
@@ -42,6 +49,42 @@ const selectors = {
     responseAccordionAddAlternateButtonLabel: () => cy.get('.add-alternate-btn p'),
     responseAreaNumeration: () => cy.get('.response-input-adornment'),
 
+    //Special characters section
+    specialCharactersLabel: () => cy.get('[class*="LabelImageWithTextstyles__CustomizedSpecialCharacterWrapper"]'),
+    enableSpecialCharactersCheckbox: () => cy.get('[data-ngie-testid="enable-special-characters-checkbox"] input'),
+    enableSpecialCharactersLabel: () => cy.get('[data-ngie-testid="enable-special-characters-checkbox"] [class*="MuiFormControlLabel-label"]'),
+    specialCharactersPopupTitle: () => cy.get('#alert-dialog-title'),
+    specialCharactersPopupCloseButton: () => cy.get('[class*="close-button"]'),
+    specialCharactersPopupCharactersCategoryWrapper: () => cy.get('.special-character-accordion'),
+    specialCharactersPopupCharacterSymbol: () => cy.get('.characters-button'),
+    specialCharactersPopupCategoryTitle: () => cy.get('.char-accordion-label'),
+    specialCharactersPopupCategoryAccordionIcon: () => cy.get('.special-math-content [class*="expandIconWrapper"]'),
+
+    //TODO: Shift all preview tab special characters popup related selectors/steps to a common component file once https://redmine.zeuslearning.com/issues/559296 is resolved
+    //preview tab special characters
+    specialCharactersPopupTitlePreviewTab: () => cy.get('[class*="Popupstyles__TitleWrapper"]'),
+    specialCharactersPopupCategoryAccordionLabelPreviewTab: () => cy.get('[class*="ResponseInputComponentstyles__AccordionLabel"]'),
+    specialCharactersPopupCategoryAccordionWrapperPreviewTab: () => cy.get('.special-character-accordion'),
+    specialCharactersPopupSymbolPreviewTab: () => cy.get('.ngie-accordion button'),
+    specialCharactersPopupCategoryAccordionChevronButtonPreviewTab: () => cy.get('[class*="MuiAccordionSummary-expandIconWrapper"]'),
+    specialCharactersPopupCategoryAccordionCloseButtonPreviewTab: () => cy.get('[data-at="close-button"]'),
+    specialCharactersCustomSymbolsPreviewTab: () => cy.get('[class*="ResponseInputComponentstyles__PopupContentWrapper"] button'),
+    specialCharactersButtonPreviewTab: () => cy.get('.cloze-with-text-special-character-button'),
+
+    //Conditional checkboxes
+    caseSensitiveCheckboxLabel: () => cy.get('[data-ngie-testid="case-sensitive-checkbox"] [class*="label"]'),
+    caseSensitiveCheckbox: () => cy.get('[data-ngie-testid="case-sensitive-checkbox"] input'),
+    validateIfAnswerIsIncludedCheckboxLabel: () => cy.get('[data-ngie-testid="validate-if-answer-is-included-in-the-response-checkbox"] [class*="label"]'),
+    validateIfAnswerIsIncludedCheckbox: () => cy.get('[data-ngie-testid="validate-if-answer-is-included-in-the-response-checkbox"] input'),
+    ignoreExtraSpacesCheckboxLabel: () => cy.get('[data-ngie-testid="ignore-extra-spaces-checkbox"] [class*="label"]'),
+    ignoreExtraSpacesCheckbox: () => cy.get('[data-ngie-testid="ignore-extra-spaces-checkbox"] input'),
+    ignoreSingleLetterMistakeCheckboxLabel: () => cy.get('[data-ngie-testid="ignore-single-letter-mistake-checkbox"] [class*="label"]'),
+    ignoreSingleLetterMistakeCheckbox: () => cy.get('[data-ngie-testid="ignore-single-letter-mistake-checkbox"] input'),
+
+    //Student view settings
+    spellCheckLabel: () => cy.get('[data-ngie-testid="spell-check-checkbox"] .MuiFormControlLabel-label'),
+    spellCheckCheckbox: () => cy.get('[data-ngie-testid="spell-check-checkbox"] input[type="checkbox"]'),
+
     //additional settings
     enterAriaLabelInputField: () => cy.get('input[aria-label*="Enter ARIA label"]')
 }
@@ -238,10 +281,11 @@ const steps = {
     },
 
     /**
-         * @param {number} responseIndex index of response container
-         * @param {number} maxlen value of maxlength attribute
-         * @description function verifies maxlength attribute of response container in preview tab
-         */
+     * 
+     * @param {number} responseIndex index of response container
+     * @param {number} maxlen value of maxlength attribute
+     * @description function verifies maxlength attribute of response container in preview tab
+     */
     verifyMaximumCharacterLimitInPreviewTab: (responseIndex, maxlen) => {
         utilities.getNthElement(fillInTheGapsTextCommonComponent.answerInputFieldPreviewTab(), responseIndex)
             .should('have.attr', 'maxlength', maxlen);
@@ -302,43 +346,429 @@ const steps = {
         utilities.getNthElement(fillInTheGapsTextCommonComponent.answerInputFieldPreviewTab(), responseIndex)
             .type(responseText);
     },
-}
 
-const tests = {
-    verifySetLimitSectionContents: () => {
-        it('\'Set limit\' label should be displayed', () => {
-            utilities.verifyInnerText(fillInTheGapsTextCommonComponent.setLimitLabel(), 'Set limit');
-            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.setLimitLabel(), 'visible');
-        });
+    verifyEnableSpecialCharactersCheckboxUnchecked: () => {
+        fillInTheGapsTextCommonComponent.enableSpecialCharactersCheckbox()
+            .should('not.be.checked');
+    },
 
-        it('\'Character\' and \'None\' labels and radio buttons should be displayed and by default \'Character\' should be selected', () => {
-            utilities.verifyInnerText(fillInTheGapsTextCommonComponent.characterLabel(), 'Character');
-            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.characterLabel(), 'visible');
-            fillInTheGapsTextCommonComponent.steps.verifyCharacterRadioButtonSelected();
-            utilities.verifyInnerText(fillInTheGapsTextCommonComponent.noneLabel(), 'None');
-            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.noneLabel(), 'visible');
-            fillInTheGapsTextCommonComponent.steps.verifyNoneRadioButtonNotSelected();
-        });
+    checkEnableSpecialCharactersCheckbox: () => {
+        fillInTheGapsTextCommonComponent.enableSpecialCharactersCheckbox()
+            .click()
+            .should('be.checked');
+    },
 
-        it('\'Minimum character limit\' and \'Maximum character limit\' labels should be displayed', () => {
-            utilities.verifyInnerText(fillInTheGapsTextCommonComponent.minimumCharacterLimitLabel(), 'Minimum character limit');
-            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.minimumCharacterLimitLabel(), 'visible');
-            utilities.verifyInnerText(fillInTheGapsTextCommonComponent.maximumCharacterLimitLabel(), 'Maximum character limit');
-            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.maximumCharacterLimitLabel(), 'visible');
-        });
+    uncheckEnableSpecialCharactersCheckbox: () => {
+        fillInTheGapsTextCommonComponent.enableSpecialCharactersCheckbox()
+            .click()
+            .should('not.be.checked');
+    },
 
-        it('\'Minimum character limit\' and \'Maximum character limit\' input fields should be displayed and have 0 and 50 value by default', () => {
-            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.minimumCharacterLimitInputField(), 'visible');
-            fillInTheGapsTextCommonComponent.steps.verifyMinimumCharacterLimitInputField(0);
-            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.maximumCharacterLimitInputField(), 'visible');
-            fillInTheGapsTextCommonComponent.steps.verifyMaximumCharacterLimitInputField(50);
-        });
+    openSpecialCharactersPopupPreviewTab: () => {
+        fillInTheGapsTextCommonComponent.specialCharactersButtonPreviewTab()
+            .click();
+    },
 
-        it('User should be able to update values in both the input fields', () => {
-            fillInTheGapsTextCommonComponent.steps.setMinimumLimit(10);
-            fillInTheGapsTextCommonComponent.steps.setMaximumLimit(40);
-        });
+    /**
+    * @description Verify symbols displayed in for a category in special characters popup
+    * @param {number} categoryIndex Index of the category
+    * @param {string[]} categorySymbolsArray Array of the symbols of the category
+    */
+    verifySpecialCharactersPopupCategorySymbolsInPreviewTab: (categoryIndex, categorySymbolsArray) => {
+        utilities.getNthElement(fillInTheGapsTextCommonComponent.specialCharactersPopupCategoryAccordionLabelPreviewTab(), categoryIndex)
+            .click();
+        utilities.getNthElement(fillInTheGapsTextCommonComponent.specialCharactersPopupCategoryAccordionWrapperPreviewTab(), categoryIndex)
+            .within(() => {
+                categorySymbolsArray[index].forEach((symbolARIALabel, index) => {
+                    fillInTheGapsTextCommonComponent.specialCharactersPopupSymbolPreviewTab()
+                        .eq(index)
+                        .find('svg')
+                        .should('have.attr', 'aria-label', `${symbolARIALabel}`);
+                });
+            });
+    },
+
+    closeSpecialCharactersPopupPreviewTab: () => {
+        fillInTheGapsTextCommonComponent.specialCharactersPopupCategoryAccordionCloseButtonPreviewTab()
+            .click();
+    },
+
+    /**
+     * @description Verify response accordion is collapsed in specify correct answer section
+     * @param {number} responseIndex index of response accordion
+     */
+    verifyResponseAccordionIsCollapsed: (responseIndex) => {
+        utilities.getNthElement(fillInTheGapsTextCommonComponent.responseAccordion(), responseIndex)
+            .find('.ngie-accordion-summary')
+            .should('have.attr', 'aria-expanded', 'false');
+    },
+
+    /**
+     * @description Verify response accordion is expanded in specify correct answer section
+     * @param {number} responseIndex index of response accordion
+     */
+    verifyResponseAccordionIsExpanded: (responseIndex) => {
+        utilities.getNthElement(fillInTheGapsTextCommonComponent.responseAccordion(), responseIndex)
+            .find('.ngie-accordion-summary')
+            .should('have.attr', 'aria-expanded', 'true');
+    },
+
+    /**
+     * @description Expand response accordion in specify correct answer section
+     * @param {number} responseIndex index of response accordion
+     */
+    expandResponseAccordionSpecifyCorrectAnswer: (responseIndex) => {
+        utilities.getNthElement(fillInTheGapsTextCommonComponent.responseAccordion(), responseIndex)
+            .click();
+        fillInTheGapsTextCommonComponent.steps.verifyResponseAccordionIsExpanded(responseIndex);
+    },
+
+    /**
+     * @description Collapse response accordion in specify correct answer section
+     * @param {number} responseIndex index of response accordion
+     */
+    collapseResponseAccordionSpecifyCorrectAnswer: (responseIndex) => {
+        utilities.getNthElement(fillInTheGapsTextCommonComponent.responseAccordionLabel(), responseIndex)
+            .click();
+        fillInTheGapsTextCommonComponent.steps.verifyResponseAccordionIsCollapsed(responseIndex);
+    },
+
+    /**
+     * Focus in and focus out of response accordion answer input field in specify correct answer section
+     * @param {number} answerFieldIndex answer input field index
+     */
+    focusInAndFocusOutOfResponseAnswerInputFieldSpecifyCorrectAnswer: (answerFieldIndex) => {
+        utilities.getNthElement(fillInTheGapsTextCommonComponent.answerInputFieldSpecifyCorrectAnswerSection(), answerFieldIndex)
+            .click()
+            .blur();
+    },
+
+    /**
+     * Focus in and focus out of response accordion answer input field in preview tab
+     * @param {number} answerFieldIndex answer input field index
+     */
+    focusInAndFocusOutOfResponseAnswerInputFieldPreviewTab: (answerFieldIndex) => {
+        utilities.getNthElement(fillInTheGapsTextCommonComponent.answerInputFieldPreviewTab(), answerFieldIndex)
+            .click()
+            .blur();
+    },
+
+    /**
+     * Focus out of response accordion answer input field in specify correct answer section
+     * @param {number} answerFieldIndex answer input field index
+     */
+    focusOutOfResponseAnswerInputFieldSpecifyCorrectAnswer: (answerFieldIndex) => {
+        utilities.getNthElement(fillInTheGapsTextCommonComponent.answerInputFieldSpecifyCorrectAnswerSection(), answerFieldIndex)
+            .blur();
+    },
+
+    /**
+     * Focus out of response accordion answer input field in preview tab
+     * @param {number} answerFieldIndex answer input field index
+     */
+    focusOutOfResponseAnswerInputFieldPreviewTab: (answerFieldIndex) => {
+        utilities.getNthElement(fillInTheGapsTextCommonComponent.answerInputFieldPreviewTab(), answerFieldIndex)
+            .blur();
+    },
+
+    /**
+     * Focus in response input field in preview tab
+     * @param {number} responseInputFieldIndex response input field index
+     */
+    focusInResponseInputFieldPreviewTab: (responseInputFieldIndex) => {
+        utilities.getNthElement(fillInTheGapsTextCommonComponent.answerInputFieldPreviewTab(), responseInputFieldIndex)
+            .click();
+    },
+
+    /**    
+     * Verify the points score displayed on response accordions
+     * @param {number} responseAccordionIndex index of response accordion
+     * @param {number} pointsPerResponse Points to be displayed on response accordion
+     */
+    verifyPointsDisplayedOnResponseAccordion: (responseAccordionIndex, pointsPerResponse) => {
+        utilities.verifyElementVisibilityState(utilities.getNthElement(fillInTheGapsTextCommonComponent.responseAccordionPointsLabel(), responseAccordionIndex), 'visible');
+        utilities.verifyInnerText(utilities.getNthElement(fillInTheGapsTextCommonComponent.responseAccordionPointsLabel(), responseAccordionIndex), 'Points:');
+        utilities.verifyElementVisibilityState(utilities.getNthElement(fillInTheGapsTextCommonComponent.responseAccordionPointsScore(), responseAccordionIndex), 'visible');
+        utilities.verifyInnerText(utilities.getNthElement(fillInTheGapsTextCommonComponent.responseAccordionPointsScore(), responseAccordionIndex), `${pointsPerResponse}`);
+    },
+
+    /**
+    * Click on response accordion add alternate button
+    * @param {number} responseAccordionIndex index of response accordion
+    */
+    addAlternateAnswerInResponseAccordion: (responseAccordionIndex) => {
+        utilities.getNthElement(fillInTheGapsTextCommonComponent.responseAccordionAddAlternateButton(), responseAccordionIndex)
+            .click();
+    },
+
+    /**
+     * Verify the points input field and label displayed in response accordions
+     * @param {number} responseAccordionIndex index of response accordion
+     * @param {number} pointsInputFieldValue Points input field value
+     */
+    verifyPointsLabelAndInputFieldInResponseAccordion: (responseAccordionIndex, pointsInputFieldValue) => {
+        utilities.getNthElement(fillInTheGapsTextCommonComponent.responseAccordionPointsInputFieldWrapper(), responseAccordionIndex)
+            .within(() => {
+                utilities.verifyElementVisibilityState(autoScoredScoringSectionMultiResponseType.pointsLabel(), 'visible');
+                utilities.verifyInnerText(autoScoredScoringSectionMultiResponseType.pointsLabel(), 'Points');
+                utilities.verifyElementVisibilityState(autoScoredScoringSectionMultiResponseType.pointsInputField(), 'visible');
+                scoringSectionBaseEditTab.steps.verifyPointsFieldValue(pointsInputFieldValue);
+            });
+    },
+
+    verifyDefaultUncheckedStateOfConditionalCheckboxes: () => {
+        fillInTheGapsTextCommonComponent.caseSensitiveCheckbox()
+            .should('not.be.checked');
+        fillInTheGapsTextCommonComponent.validateIfAnswerIsIncludedCheckbox()
+            .should('not.be.checked');
+        fillInTheGapsTextCommonComponent.ignoreExtraSpacesCheckbox()
+            .should('not.be.checked');
+        fillInTheGapsTextCommonComponent.ignoreSingleLetterMistakeCheckbox()
+            .should('not.be.checked');
+    },
+
+    /**
+     * Check the conditional checkbox in edit tab
+     * @param {string} conditionalCheckboxName Name of the conditional checkbox to be checked
+     */
+    checkConditionalCheckbox: (conditionalCheckboxName) => {
+        switch (conditionalCheckboxName) {
+            case 'Case sensitive':
+                fillInTheGapsTextCommonComponent.caseSensitiveCheckbox()
+                    .click()
+                    .should('be.checked');
+                break;
+            case 'Validate if answer is included in the response':
+                fillInTheGapsTextCommonComponent.validateIfAnswerIsIncludedCheckbox()
+                    .click()
+                    .should('be.checked');
+                break;
+            case 'Ignore extra spaces':
+                fillInTheGapsTextCommonComponent.ignoreExtraSpacesCheckbox()
+                    .click()
+                    .should('be.checked');
+                break;
+            case 'Ignore single letter mistake':
+                fillInTheGapsTextCommonComponent.ignoreSingleLetterMistakeCheckbox()
+                    .click()
+                    .should('be.checked');
+                break;
+            default:
+                throw new Error('invalid state string');
+        }
+    },
+
+    /**
+     * Uncheck the conditional checkbox in edit tab
+     * @param {string} conditionalCheckboxName Name of the conditional checkbox to be unchecked
+     */
+    uncheckConditionalCheckbox: (conditionalCheckboxName) => {
+        switch (conditionalCheckboxName) {
+            case 'Case sensitive':
+                fillInTheGapsTextCommonComponent.caseSensitiveCheckbox()
+                    .click()
+                    .should('not.be.checked');
+                break;
+            case 'Validate if answer is included in the response':
+                fillInTheGapsTextCommonComponent.validateIfAnswerIsIncludedCheckbox()
+                    .click()
+                    .should('not.be.checked');
+                break;
+            case 'Ignore extra spaces':
+                fillInTheGapsTextCommonComponent.ignoreExtraSpacesCheckbox()
+                    .click()
+                    .should('not.be.checked');
+                break;
+            case 'Ignore single letter mistake':
+                fillInTheGapsTextCommonComponent.ignoreSingleLetterMistakeCheckbox()
+                    .click()
+                    .should('not.be.checked');
+                break;
+            default:
+                throw new Error('invalid state string');
+        }
+    },
+
+    /**
+     * Allot points inside response accordion points input field
+     * @param {number} responseAccordionIndex index of response accordion
+     * @param {number} pointsInputFieldValue Points input field value to be allotted
+     */
+    allotPointsInResponseAccordion: (responseAccordionIndex, pointsInputFieldValue) => {
+        utilities.getNthElement(fillInTheGapsTextCommonComponent.responseAccordionPointsInputFieldWrapper(), responseAccordionIndex)
+            .within(() => {
+                scoringSectionBaseEditTab.steps.allotPoints(pointsInputFieldValue);
+            });
+    },
+
+    verifySpellCheckCheckboxUnchecked: () => {
+        fillInTheGapsTextCommonComponent.spellCheckCheckbox()
+            .should('not.be.checked');
+    },
+
+    verifySpellCheckCheckboxChecked: () => {
+        fillInTheGapsTextCommonComponent.spellCheckCheckbox()
+            .should('be.checked');
+    },
+
+    checkSpellCheckCheckbox: () => {
+        fillInTheGapsTextCommonComponent.spellCheckCheckbox()
+            .click()
+        steps.verifySpellCheckCheckboxChecked();
+    },
+
+    uncheckSpellCheckCheckbox: () => {
+        fillInTheGapsTextCommonComponent.spellCheckCheckbox()
+            .click();
+        steps.verifySpellCheckCheckboxUnchecked();
+    },
+
+    /**
+     * Verify that the spell check for a response field in the Preview Tab is disabled.
+     * @param {number} responseFieldIndex - The index of the response field to verify.
+     */
+    verifySpellCheckOfResponseFieldPreviewTabDisabled: (responseFieldIndex) => {
+        fillInTheGapsTextCommonComponent.answerInputFieldPreviewTab()
+            .eq(responseFieldIndex)
+            .should('have.attr', 'spellcheck', 'false');
+    },
+
+    /**
+     * Verify that the spell check for a response field in the Preview Tab is enabled.
+     * @param {number} responseFieldIndex - The index of the response field to verify.
+     */
+    verifySpellCheckOfResponseFieldPreviewTabEnabled: (responseFieldIndex) => {
+        fillInTheGapsTextCommonComponent.answerInputFieldPreviewTab()
+            .eq(responseFieldIndex)
+            .should('have.attr', 'spellcheck', 'true');
+    },
+
+    /**
+     *@description Verify numeration text for the answer input fields of the specify correct answer section.
+     * @param responseAccordionIndex denotes response accordion index
+     */
+    verifyResponseAccordionAnswerInputFieldNumeration: (responseAccordionIndex) => {
+        utilities.getNthElement(fillInTheGapsTextCommonComponent.responseAccordion(), responseAccordionIndex)
+            .within(() => {
+                fillInTheGapsTextCommonComponent.responseAccordionAnswerInputFieldWrapper()
+                    .each(($el, index) => {
+                        cy.wrap($el)
+                            .within(() => {
+                                fillInTheGapsTextCommonComponent.responseAccordionAnswerNumeration()
+                                    .should('have.text', `${index + 1}`);
+                            });
+                    });
+            });
+    },
+
+    /**
+     * @description Verify symbols displayed in for a category in special characters popup
+     * @param {number} categoryIndex Index of the category
+     * @param {string[]} categorySymbolsArray Array of the symbols of the category
+     */
+    verifySpecialCharactersPopupCategorySymbols: (categoryIndex, categorySymbolsArray) => {
+        fillInTheGapsTextCommonComponent.specialCharactersPopupCharactersCategoryWrapper()
+            .eq(categoryIndex)
+            .within(() => {
+                categorySymbolsArray[index].forEach((symbolARIALabel, index) => {
+                    fillInTheGapsTextCommonComponent.specialCharactersPopupCharacterSymbol()
+                        .eq(index)
+                        .find('svg')
+                        .should('have.attr', 'aria-label', `${symbolARIALabel}`);
+                });
+            });
+    },
+
+    /**
+     *@description Verify delete button for the answer input fields of the specify correct answer section.
+     * @param responseAccordionIndex denotes response accordion index
+     */
+    verifyResponseAccordionAnswerInputFieldDeleteButton: (responseAccordionIndex) => {
+        utilities.getNthElement(fillInTheGapsTextCommonComponent.responseAccordion(), responseAccordionIndex)
+            .within(() => {
+                fillInTheGapsTextCommonComponent.responseAccordionAnswerInputFieldWrapper()
+                    .each(($el) => {
+                        cy.wrap($el)
+                            .within(() => {
+                                fillInTheGapsTextCommonComponent.responseAccordionAnswerDeleteButton()
+                                    .should('be.visible');
+                            });
+                    });
+            });
+    },
+
+    /**
+    * Verify answer input field placeholder text
+    * @param {number} answerFieldIndex index of answer input field
+    */
+    verifyAnswerInputFieldPlaceholder: (answerFieldIndex) => {
+        utilities.getNthElement(fillInTheGapsTextCommonComponent.responseAccordionAnswerInputFieldWrapper(), answerFieldIndex)
+            .within(() => {
+                fillInTheGapsTextCommonComponent.answerInputFieldSpecifyCorrectAnswerSection()
+                    .should('have.attr', 'placeholder', 'Enter answer');
+            });
+    },
+
+    /**
+    *@description Clicks delete button for the answer input fields of the specify correct answer section.
+    * @param responseAccordionIndex denotes response accordion index
+    */
+    deleteResponseAccordionAnswerInputField: (responseAccordionIndex, responseAccordionAnswerInputFieldIndex) => {
+        utilities.getNthElement(fillInTheGapsTextCommonComponent.responseAccordion(), responseAccordionIndex)
+            .within(() => {
+                utilities.getNthElement(fillInTheGapsTextCommonComponent.responseAccordionAnswerInputFieldWrapper(), responseAccordionAnswerInputFieldIndex)
+                    .within(() => {
+                        fillInTheGapsTextCommonComponent.responseAccordionAnswerDeleteButton()
+                            .click();
+                    });
+            });
+    },
 
+    /**
+    * Clear answer input field
+    * @param {number} answerFieldIndex index of answer input field
+    */
+    clearAnswerInputField: (answerFieldIndex) => {
+        utilities.getNthElement(fillInTheGapsTextCommonComponent.responseAccordionAnswerInputFieldWrapper(), answerFieldIndex)
+            .within(() => {
+                fillInTheGapsTextCommonComponent.answerInputFieldSpecifyCorrectAnswerSection()
+                    .clear()
+                    .blur();
+            });
+    },
+
+    /**
+    * @description verify the displayed penalty points for each incorrect text container
+    * @param {number} penaltyPoints displayed penalty points 
+    */
+    verifyPenaltyPointsForEachIncorrectTextContainer: (penaltyPoints) => {
+        utilities.verifyInnerText(autoScoredScoringSectionMultiResponseType.penaltyPointsDetailsSectionAllottedPointsLabel(), `Penalty points for each incorrect text container: ${penaltyPoints}`);
+    },
+
+    /**
+    * @description Verifies the penalty points value for each incorrect text container
+    * @param {number} points - The expected penalty points value for each incorrect text container.
+    */
+    verifyPenaltyPointsForEachIncorrectTextContainerValue: (points) => {
+        fillInTheGapsTextCommonComponent.penaltyPointsForEachIncorrectTextContainerInputField()
+            .should('have.value', points);
+    },
+
+    /**
+     * @description Allots penalty points for each incorrect text container
+     * @param {number} points - The penalty points to be allotted for each text container.
+     */
+    allotPenaltyPointsForEachIncorrectTextContainer: (points) => {
+        fillInTheGapsTextCommonComponent.penaltyPointsForEachIncorrectTextContainerInputField()
+            .clear()
+            .type(`${points}`)
+            .should('have.value', points)
+            .blur();
+    },
+}
+
+const tests = {
+    verifySetLimitSectionErrorConditionsForMinAndMaxCharacterInputFields: () => {
         it('When the user clears the minimum character limit input field and focuses out of it, then error message \'Error: Minimum character limit is required\' should be displayed below the input field', () => {
             fillInTheGapsTextCommonComponent.steps.clearAndFocusOutOfMinimumCharacterLimitInputField();
             utilities.verifyInnerText(commonComponents.errorMessage(), 'Error: Minimum character limit is required.');
@@ -439,13 +869,13 @@ const tests = {
 
         it('When user enters zero in maximum limit input field, then error message \'Error: Maximum limit must be greater than 0.\' should be displayed', () => {
             fillInTheGapsTextCommonComponent.steps.setMaximumLimit(0);
-            utilities.verifyInnerText(fillInTheGapsTextCommonComponent.errorMessage(), 'Error: Maximum limit must be greater than 0.');
-            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.errorMessage(), 'visible');
+            utilities.verifyInnerText(commonComponents.errorMessage(), 'Error: Maximum limit must be greater than 0.');
+            utilities.verifyElementVisibilityState(commonComponents.errorMessage(), 'visible');
         });
 
         it('When user enters limit more than zero in maximum limit input field, then error message should disappear', () => {
             fillInTheGapsTextCommonComponent.steps.setMaximumLimit(50);
-            fillInTheGapsTextCommonComponent.steps.verifyErrorMessageIsNotDisplayed();
+            commonComponents.steps.verifyErrorMessageIsNotDisplayed();
         });
 
         it('When user should not be able to add limit more than 50 inside minimum and maximum limit input field', () => {
@@ -454,35 +884,58 @@ const tests = {
             fillInTheGapsTextCommonComponent.steps.setMaximumLimit(60);
             fillInTheGapsTextCommonComponent.steps.verifyMaximumLimit(6);
         });
+    },
 
-        it('When the user selects \'None\' radio button then the maximum and minimum character limit labels and input field should not be displayed', () => {
-            fillInTheGapsTextCommonComponent.steps.selectNoneRadioButton();
-            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.minMaxLabelAndInputFieldWrapper(), 'notExist');
+    verifySetLimitSectionContents: () => {
+        it('\'Set limit\' label should be displayed', () => {
+            utilities.verifyInnerText(fillInTheGapsTextCommonComponent.setLimitLabel(), 'Set limit');
+            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.setLimitLabel(), 'visible');
+        });
+
+        it('\'Character\' and \'None\' labels and radio buttons should be displayed and by default \'Character\' should be selected', () => {
+            utilities.verifyInnerText(fillInTheGapsTextCommonComponent.characterLabel(), 'Character');
+            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.characterLabel(), 'visible');
+            fillInTheGapsTextCommonComponent.steps.verifyCharacterRadioButtonSelected();
+            utilities.verifyInnerText(fillInTheGapsTextCommonComponent.noneLabel(), 'None');
+            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.noneLabel(), 'visible');
+            fillInTheGapsTextCommonComponent.steps.verifyNoneRadioButtonNotSelected();
+        });
+
+        it('\'Minimum character limit\' and \'Maximum character limit\' labels should be displayed', () => {
+            utilities.verifyInnerText(fillInTheGapsTextCommonComponent.minimumCharacterLimitLabel(), 'Minimum character limit');
+            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.minimumCharacterLimitLabel(), 'visible');
+            utilities.verifyInnerText(fillInTheGapsTextCommonComponent.maximumCharacterLimitLabel(), 'Maximum character limit');
+            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.maximumCharacterLimitLabel(), 'visible');
         });
-    },
 
-    verifySetLimitSectionEditTabFunctionality: () => {
-        it('When maximum character limit input field value is 50 then maximum character limit should be 50 in the specify correct answer section', () => {
+        it('\'Minimum character limit\' and \'Maximum character limit\' input fields should be displayed and have 0 and 50 value by default', () => {
+            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.minimumCharacterLimitInputField(), 'visible');
+            fillInTheGapsTextCommonComponent.steps.verifyMinimumCharacterLimitInputField(0);
+            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.maximumCharacterLimitInputField(), 'visible');
             fillInTheGapsTextCommonComponent.steps.verifyMaximumCharacterLimitInputField(50);
-            fillInTheGapsTextCommonComponent.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', () => {
-            fillInTheGapsTextCommonComponent.steps.setMaximumLimit(10);
-            fillInTheGapsTextCommonComponent.steps.verifyMaximumCharacterLimit(0, 10);
+        it('User should be able to update values in both the input fields', () => {
+            fillInTheGapsTextCommonComponent.steps.setMinimumLimit(10);
+            fillInTheGapsTextCommonComponent.steps.setMaximumLimit(40);
         });
+    },
 
-        it('User should able to enter characters in the answer input field', () => {
-            fillInTheGapsTextCommonComponent.steps.enterTextInAnswerInputFieldsSpecifyCorrectAnswerSection([{ responseIndex: 0, responseText: 'Flower' }]);
+    verifySetLimitSectionForNoneOption: () => {
+        it('When the user selects \'None\' radio button then the maximum and minimum character limit labels and input field should not be displayed', () => {
+            fillInTheGapsTextCommonComponent.steps.selectNoneRadioButton();
+            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.minMaxLabelAndInputFieldWrapper(), 'notExist');
         });
+    },
 
+    verifyMaximumCharacterLimitWarningConditionsSpecifyCorrectAnswerSection: () => {
         it('When the user reaches the character limit, then the warning message \'Maximum 10 characters have been entered\' should be displayed', () => {
             fillInTheGapsTextCommonComponent.steps.enterTextInAnswerInputFieldsSpecifyCorrectAnswerSection([{ responseIndex: 0, responseText: 'pots' }]);
             fillInTheGapsTextCommonComponent.steps.verifyTextInResponseAccordionAnswerInputField([{ responseIndex: 0, responseText: 'Flowerpots' }])
-            fillInTheGapsTextCommonComponent.steps.verifyLimitReachedWarningMessageExist('Maximum 10 words have been entered.');
+            fillInTheGapsTextCommonComponent.steps.verifyLimitReachedWarningMessageExist('Maximum 10 characters have been entered.');
         });
 
-        it('CSS of error message', { tags: 'css' }, () => {
+        it('CSS of warning message', { tags: 'css' }, () => {
             utilities.verifyCSS(fillInTheGapsTextCommonComponent.limitReachedWarningMessage(), {
                 'color': css.color.warningMessage,
                 'font-size': css.fontSize.normal,
@@ -499,20 +952,41 @@ const tests = {
             });
         });
 
-        it('Accessibility of error message', { tags: 'a11y' }, () => {
+        it('Accessibility of warning message', { tags: 'a11y' }, () => {
             cy.checkAccessibility(fillInTheGapsTextCommonComponent.limitReachedWarningMessage());
         });
 
+        it('The user should not be able to enter characters more than the maximum character limit and warning message should persist', () => {
+            fillInTheGapsTextCommonComponent.steps.enterTextInAnswerInputFieldsSpecifyCorrectAnswerSection([{ responseIndex: 0, responseText: 'From' }]);
+            fillInTheGapsTextCommonComponent.steps.verifyTextInResponseAccordionAnswerInputField([{ responseIndex: 0, responseText: 'Flowerpots' }])
+            fillInTheGapsTextCommonComponent.steps.verifyLimitReachedWarningMessageExist('Maximum 10 characters have been entered.');
+        });
+
         it('When the user removes/deletes some characters to make the number of characters less than the set maximum limit, the warning message should disappear', () => {
             fillInTheGapsTextCommonComponent.steps.enterTextInAnswerInputFieldsSpecifyCorrectAnswerSection([{ responseIndex: 0, responseText: '{backspace}' }]);
             fillInTheGapsTextCommonComponent.steps.verifyTextInResponseAccordionAnswerInputField([{ responseIndex: 0, responseText: 'Flowerpot' }])
             fillInTheGapsTextCommonComponent.steps.verifyLimitReachedWarningMessageNotExist();
         });
 
+        it('When the user reaches the maximum character limit, then the warning message \'Maximum 10 characters have been entered\' should be displayed and on focusing out of the answer input field, the warning message should disappear', () => {
+            fillInTheGapsTextCommonComponent.steps.enterTextInAnswerInputFieldsSpecifyCorrectAnswerSection([{ responseIndex: 0, responseText: 'Flowerpots' }]);
+            fillInTheGapsTextCommonComponent.steps.verifyTextInResponseAccordionAnswerInputField([{ responseIndex: 0, responseText: 'Flowerpots' }])
+            fillInTheGapsTextCommonComponent.steps.verifyLimitReachedWarningMessageExist('Maximum 10 characters have been entered.');
+            fillInTheGapsTextCommonComponent.steps.focusOutOfResponseAnswerInputFieldSpecifyCorrectAnswer(0);
+            fillInTheGapsTextCommonComponent.steps.verifyLimitReachedWarningMessageNotExist();
+        });
+    },
+
+    verifyMinimumCharacterLimitWarningConditionsSpecifyCorrectAnswerSection: () => {
+        it('When the minimum character limit is set as 0, then on focusing out of the answer input field, no warning message should be displayed', () => {
+            fillInTheGapsTextCommonComponent.steps.focusInAndFocusOutOfResponseAnswerInputFieldSpecifyCorrectAnswer();
+            fillInTheGapsTextCommonComponent.steps.verifyLimitReachedWarningMessageNotExist();
+        });
+
         it('When the user updates minimum character limit and enters character less than the minimum character limit value set and focus out of response field, then the warning message \'Minimum 6 characters are required\' should be displayed in specify correct answer', () => {
             fillInTheGapsTextCommonComponent.steps.setMinimumLimit(6);
             fillInTheGapsTextCommonComponent.steps.enterTextInAnswerInputFieldsSpecifyCorrectAnswerSection([{ responseIndex: 0, responseText: 'Air' }]);
-            fillInTheGapsTextCommonComponent.steps.verifyLimitReachedWarningMessageExist('Minimum 6 words are required.');
+            fillInTheGapsTextCommonComponent.steps.verifyLimitReachedWarningMessageExist('Minimum 6 characters are required.');
         });
 
         it('When the user enters the character greater than the minimum character limit value set by the user, then the warning message should disappear', () => {
@@ -521,7 +995,7 @@ const tests = {
             fillInTheGapsTextCommonComponent.steps.verifyLimitReachedWarningMessageNotExist();
         });
 
-        it('When the user selects \'None\' radio button then maximum limit should not be displayed in the preview tab and when user types anything in the response field then error message should not be displayed', () => {
+        it('When the user selects \'None\' radio button then maximum limit should not be displayed in the specify correct answer section and when user types anything in the response field then error message should not be displayed', () => {
             fillInTheGapsTextCommonComponent.steps.selectNoneRadioButton();
             fillInTheGapsTextCommonComponent.steps.verifyMaximumCharacterLimitNotExistInPreviewTab(0);
             fillInTheGapsTextCommonComponent.steps.addTextInAnswerInputFieldsPreviewTab(0, 'water');
@@ -529,31 +1003,14 @@ const tests = {
         });
     },
 
-    verifySetLimitSectionPreviewTabFunctionality: () => {
-        it('When maximum character limit input field value is 50 then maximum character limit should be 50 in the preview tab', () => {
-            fillInTheGapsTextCommonComponent.steps.verifyMaximumCharacterLimitInputField(50);
-            createQuestionBasePage.steps.switchToPreviewTab();
-            fillInTheGapsTextCommonComponent.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', () => {
-            createQuestionBasePage.steps.switchToEditTab();
-            fillInTheGapsTextCommonComponent.steps.setMaximumLimit(10);
-            createQuestionBasePage.steps.switchToPreviewTab();
-            fillInTheGapsTextCommonComponent.steps.verifyMaximumCharacterLimitInPreviewTab(0, 10);
-        });
-
-        it('User should able to enter characters in the response field', () => {
-            fillInTheGapsTextCommonComponent.steps.addTextInAnswerInputFieldsPreviewTab(0, 'Flower');
-        });
-
+    verifyMaximumCharacterLimitWarningConditionsPreviewTab: () => {
         it('When the user reaches the character limit, then the warning message \'Maximum 10 characters have been entered\' should be displayed', () => {
             fillInTheGapsTextCommonComponent.steps.addTextInAnswerInputFieldsPreviewTab(0, 'pots');
             fillInTheGapsTextCommonComponent.steps.verifyTextInAnswerInputFieldsPreviewTab([{ responseIndex: 0, responseText: 'Flowerpots' }])
-            fillInTheGapsTextCommonComponent.steps.verifyLimitReachedWarningMessageExist('Maximum 10 words have been entered.');
+            fillInTheGapsTextCommonComponent.steps.verifyLimitReachedWarningMessageExist('Maximum 10 characters have been entered.');
         });
 
-        it('CSS of error message', { tags: 'css' }, () => {
+        it('CSS of warning message', { tags: 'css' }, () => {
             utilities.verifyCSS(fillInTheGapsTextCommonComponent.limitReachedWarningMessage(), {
                 'color': css.color.warningMessage,
                 'font-size': css.fontSize.normal,
@@ -570,22 +1027,43 @@ const tests = {
             });
         });
 
-        it('Accessibility of error message', { tags: 'a11y' }, () => {
+        it('Accessibility of warning message', { tags: 'a11y' }, () => {
             cy.checkAccessibility(fillInTheGapsTextCommonComponent.limitReachedWarningMessage());
         });
 
+        it('The user should not be able to enter characters more than the maximum character limit and warning message should persist', () => {
+            fillInTheGapsTextCommonComponent.steps.addTextInAnswerInputFieldsPreviewTab([{ responseIndex: 0, responseText: 'From' }]);
+            fillInTheGapsTextCommonComponent.steps.verifyTextInAnswerInputFieldsPreviewTab([{ responseIndex: 0, responseText: 'Flowerpots' }])
+            fillInTheGapsTextCommonComponent.steps.verifyLimitReachedWarningMessageExist('Maximum 10 characters have been entered.');
+        });
+
         it('When the user removes/deletes some characters to make the number of characters less than the set maximum limit, the warning message should disappear', () => {
             fillInTheGapsTextCommonComponent.steps.addTextInAnswerInputFieldsPreviewTab(0, '{backspace}');
             fillInTheGapsTextCommonComponent.steps.verifyTextInAnswerInputFieldsPreviewTab([{ responseIndex: 0, responseText: 'Flowerpot' }])
             fillInTheGapsTextCommonComponent.steps.verifyLimitReachedWarningMessageNotExist();
         });
 
+        it('When the user reaches the maximum character limit, then the warning message \'Maximum 10 characters have been entered\' should be displayed and on focusing out of the answer input field, the warning message should disappear', () => {
+            fillInTheGapsTextCommonComponent.steps.addTextInAnswerInputFieldsPreviewTab('s');
+            fillInTheGapsTextCommonComponent.steps.verifyTextInResponseAccordionAnswerInputField([{ responseIndex: 0, responseText: 'Flowerpots' }])
+            fillInTheGapsTextCommonComponent.steps.verifyLimitReachedWarningMessageExist('Maximum 10 characters have been entered.');
+            fillInTheGapsTextCommonComponent.steps.focusOutOfResponseAnswerInputFieldPreviewTab(0);
+            fillInTheGapsTextCommonComponent.steps.verifyLimitReachedWarningMessageNotExist();
+        });
+    },
+
+    verifyMinimumCharacterLimitWarningConditionsPreviewTab: () => {
+        it('When the minimum character limit is set as 0, then on focusing out of the answer input field, no warning message should be displayed', () => {
+            fillInTheGapsTextCommonComponent.steps.focusInAndFocusOutOfResponseAnswerInputFieldPreviewTab();
+            fillInTheGapsTextCommonComponent.steps.verifyLimitReachedWarningMessageNotExist();
+        });
+        
         it('When the user updates minimum character limit in edit tab and enters character less than the minimum character limit value set and focus out of response field, then the warning message \'Minimum 6 characters are required\' should be displayed in preview tab', () => {
             createQuestionBasePage.steps.switchToEditTab();
             fillInTheGapsTextCommonComponent.steps.setMinimumLimit(6);
             createQuestionBasePage.steps.switchToPreviewTab();
             fillInTheGapsTextCommonComponent.steps.addTextInAnswerInputFieldsPreviewTab(0, 'Air');
-            fillInTheGapsTextCommonComponent.steps.verifyLimitReachedWarningMessageExist('Minimum 6 words are required.');
+            fillInTheGapsTextCommonComponent.steps.verifyLimitReachedWarningMessageExist('Minimum 6 characters are required.');
         });
 
         it('When the user enters the character greater than the minimum character limit value set by the user, then the warning message should disappear', () => {
@@ -602,6 +1080,405 @@ const tests = {
             fillInTheGapsTextCommonComponent.steps.addTextInAnswerInputFieldsPreviewTab(0, 'water');
             fillInTheGapsTextCommonComponent.steps.verifyLimitReachedWarningMessageNotExist();
         });
+    },
+
+    verifyEnableSpecialCharactersCheckboxDefaultState: () => {
+        it('\'Special characters\' section label and unchecked \'Enable special characters\' checkbox and label should be displayed', () => {
+            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.specialCharactersLabel(), 'visible');
+            utilities.verifyInnerText(fillInTheGapsTextCommonComponent.specialCharactersLabel(), 'Special characters');
+            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.enableSpecialCharactersLabel(), 'visible');
+            utilities.verifyInnerText(fillInTheGapsTextCommonComponent.enableSpecialCharactersLabel(), 'Enable special characters');
+            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.enableSpecialCharactersCheckbox(), 'exist');
+            fillInTheGapsTextCommonComponent.steps.verifyEnableSpecialCharactersCheckboxUnchecked();
+        });
+    },
+
+    /**
+    * Verifies the contents and functionality of the 'Specify correct answer' accordion for multiple selection questions.
+    * @param {{'Correct' | 'Alternative'}} accordionName - The name of the accordion to be used in the validation.
+    * @example - verifySpecifyCorrectAnswerAccordionContentsAndFunctionality('Correct');
+    */
+    verifySpecifyCorrectAnswerAccordionContentsAndFunctionality: (accordionName) => {
+        it(`Response accordions for the added response areas with label \'Response #\' should be displayed in the ${accordionName} accordion in expanded state`, () => {
+            utilities.verifyElementCount(fillInTheGapsTextCommonComponent.responseAccordion(), 2);
+            fillInTheGapsTextCommonComponent.steps.verifyResponseAccordionIsExpanded(0);
+            utilities.verifyInnerText(utilities.getNthElement(fillInTheGapsTextCommonComponent.responseAccordionLabel(), 0), 'Response 1');
+            utilities.verifyInnerText(utilities.getNthElement(fillInTheGapsTextCommonComponent.responseAccordionLabel(), 1), 'Response 2');
+        });
+
+        it('When user focuses in and out of the response accordion \'Answer\' input field, \'Error: Answer is required.\' error message should be displayed', () => {
+            fillInTheGapsTextCommonComponent.steps.focusInAndFocusOutOfResponseAnswerInputFieldSpecifyCorrectAnswer(0, 0);
+            utilities.verifyElementVisibilityState(commonComponents.errorMessage(), 'visible');
+            utilities.verifyInnerText(commonComponents.errorMessage(), 'Error: Answer is required.');
+        });
+
+        it('When gives an input to \'Answer\' input field, then error message should disappear', () => {
+            fillInTheGapsTextCommonComponent.steps.enterTextInAnswerInputFieldsSpecifyCorrectAnswerSection([{ responseIndex: 0, responseText: 'Petals' }, { responseIndex: 1, responseText: 'Flower' }]);
+            commonComponents.steps.verifyErrorMessageIsNotDisplayed();
+        });
+
+        it('\'Accepted student input\' label, menu and its options - \'Text\', \'Number\', \'Integer\' should be displayed and \'Text\' option should be active', () => {
+            utilities.verifyInnerText(acceptedStudentInputComponent.acceptedStudentInputLabel(), 'Accepted student input');
+            utilities.verifyElementVisibilityState(acceptedStudentInputComponent.acceptedStudentInputLabel(), 'visible');
+            acceptedStudentInputComponent.steps.verifyAcceptedStudentTypeMenuButtons(0);
+            acceptedStudentInputComponent.steps.verifyAcceptedStudentTypeActiveButton(0, 'Text');
+        });
+
+        it('User should be able to collapse response accordion', () => {
+            fillInTheGapsTextCommonComponent.steps.collapseResponseAccordionSpecifyCorrectAnswer(0);
+        });
+
+        autoScoredSpecifyCorrectAnswerSection.tests.verifyAutoScoredPointsErrorMessageWhenPointsFieldIsEmpty(accordionName);
+
+        it(`CSS of ${accordionName} accordion contents`, { tags: 'css' }, () => {
+            utilities.verifyCSS(utilities.getNthElement(fillInTheGapsTextCommonComponent.responseAccordionLabel(), 0), {
+                'color': css.color.text,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.bold
+            });
+        });
+
+        it(`Accessibility of ${accordionName} accordion contents`, { tags: 'a11y' }, () => {
+            cy.checkAccessibility(utilities.getNthElement(fillInTheGapsTextCommonComponent.responseAccordion(), 0).parents('[aria-label="Specify correct answer section"]'));
+        });
+    },
+
+    verifyContentsOfSpecifyCorrectAnswerSection: () => {
+        it('When user selects a scoring type then in the \'Correct\' accordion, all the contents should be displayed', () => {
+            utilities.verifyElementCount(fillInTheGapsTextCommonComponent.responseAccordion(), 2);
+            fillInTheGapsTextCommonComponent.steps.verifyResponseAccordionIsExpanded(0);
+            fillInTheGapsTextCommonComponent.steps.verifyResponseAccordionIsExpanded(1);
+            utilities.verifyInnerText(utilities.getNthElement(fillInTheGapsTextCommonComponent.responseAccordionLabel(), 0), 'Response 1');
+            utilities.verifyInnerText(utilities.getNthElement(fillInTheGapsTextCommonComponent.responseAccordionLabel(), 1), 'Response 2');
+        });
+    },
+
+    verifyConditionalCheckboxesSectionContents: () => {
+        it(`By default four conditional checkboxes ${conditionalCheckboxes.join(', ')} should be displayed in the scoring section and all of them should be unchecked`, () => {
+            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.caseSensitiveCheckbox(), 'exist');
+            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.caseSensitiveCheckboxLabel(), 'visible');
+            utilities.verifyInnerText(fillInTheGapsTextCommonComponent.caseSensitiveCheckboxLabel(), `${conditionalCheckboxes[0]}`);
+            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.validateIfAnswerIsIncludedCheckbox(), 'exist');
+            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.validateIfAnswerIsIncludedCheckboxLabel(), 'visible');
+            utilities.verifyInnerText(fillInTheGapsTextCommonComponent.validateIfAnswerIsIncludedCheckboxLabel(), `${conditionalCheckboxes[1]}`);
+            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.ignoreExtraSpacesCheckbox(), 'exist');
+            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.ignoreExtraSpacesCheckboxLabel(), 'visible');
+            utilities.verifyInnerText(fillInTheGapsTextCommonComponent.ignoreExtraSpacesCheckboxLabel(), `${conditionalCheckboxes[2]}`);
+            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.ignoreSingleLetterMistakeCheckbox(), 'exist');
+            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.ignoreSingleLetterMistakeCheckboxLabel(), 'visible');
+            utilities.verifyInnerText(fillInTheGapsTextCommonComponent.ignoreSingleLetterMistakeCheckboxLabel(), `${conditionalCheckboxes[3]}`);
+            fillInTheGapsTextCommonComponent.steps.verifyDefaultUncheckedStateOfConditionalCheckboxes();
+        });
+
+        it('User should be able to check a conditional checkbox', () => {
+            fillInTheGapsTextCommonComponent.steps.checkConditionalCheckbox(conditionalCheckboxes[0]);
+        });
+
+        it('When \'Validate if answer is included in the response\' checkbox is checked, then \'Ignore extra spaces\', \'Ignore single letter mistake\' checkboxes should be disabled', () => {
+            fillInTheGapsTextCommonComponent.steps.checkConditionalCheckbox(conditionalCheckboxes[1]);
+            utilities.verifyElementDisabled(fillInTheGapsTextCommonComponent.ignoreExtraSpacesCheckbox());
+            utilities.verifyElementDisabled(fillInTheGapsTextCommonComponent.ignoreSingleLetterMistakeCheckbox());
+        });
+
+        it('CSS of conditional checkboxes', () => {
+            utilities.verifyCSS(fillInTheGapsTextCommonComponent.caseSensitiveCheckboxLabel(), {
+                'color': css.color.checkboxLabel,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(fillInTheGapsTextCommonComponent.caseSensitiveCheckbox().parent().find('rect').eq(1), {
+                'fill': css.color.activeButtons,
+            });
+            //disabled state
+            utilities.verifyCSS(fillInTheGapsTextCommonComponent.ignoreExtraSpacesCheckboxLabel(), {
+                'color': css.color.labelText,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.regular
+            });
+        });
+
+        it('Accessibility of conditional checkboxes', () => {
+            cy.checkAccessibility(fillInTheGapsTextCommonComponent.caseSensitiveCheckboxLabel().parents('.scoring-type-checkbox-wrapper'));
+        });
+
+        it('When \'Validate if answer is included in the response\' checkbox is unchecked, then \'Ignore extra spaces\', \'Ignore single letter mistake\' checkboxes should be enabled', () => {
+            fillInTheGapsTextCommonComponent.steps.uncheckConditionalCheckbox(conditionalCheckboxes[1]);
+            utilities.verifyElementNotDisabled(fillInTheGapsTextCommonComponent.ignoreExtraSpacesCheckbox());
+            utilities.verifyElementNotDisabled(fillInTheGapsTextCommonComponent.ignoreSingleLetterMistakeCheckbox());
+        });
+    },
+
+    verifySpellCheckEditTabContents: () => {
+        it('\'Spell check\' functionality label and checkbox should be displayed and by default it should be unchecked', () => {
+            utilities.verifyInnerText(fillInTheGapsTextCommonComponent.spellCheckLabel(), 'Spell check');
+            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.spellCheckLabel(), 'visible');
+            fillInTheGapsTextCommonComponent.steps.verifySpellCheckCheckboxUnchecked();
+        });
+
+        it('CSS of \'Spell check\' section - unchecked state', { tags: 'css' }, () => {
+            utilities.verifyCSS(fillInTheGapsTextCommonComponent.spellCheckLabel(), {
+                'color': css.color.labelText,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(fillInTheGapsTextCommonComponent.spellCheckCheckbox().parent().find('svg'), {
+                'fill': css.color.uncheckedCheckbox
+            });
+        });
+
+        it('Accessibility of \'Spell check\' section - unchecked state', { tags: 'a11y' }, () => {
+            cy.checkAccessibility(fillInTheGapsTextCommonComponent.spellCheckLabel().parents('.student-view-settings-container'));
+        });
+
+        it('User should be able to check \'Spell check\' checkbox', () => {
+            fillInTheGapsTextCommonComponent.steps.checkSpellCheckCheckbox();
+        });
+
+        it('CSS of \'Spell check\' section - checked state', { tags: 'css' }, () => {
+            utilities.verifyCSS(fillInTheGapsTextCommonComponent.spellCheckCheckbox().parent('.icon-checkbox-selected').find('.checkbox-icon-border-rect'), {
+                'fill': css.color.activeButtons
+            });
+        });
+
+        it('Accessibility of \'Spell check\' section - checked state', { tags: 'a11y' }, () => {
+            cy.checkAccessibility(fillInTheGapsTextCommonComponent.spellCheckLabel());
+        });
+
+        it('User should be able to uncheck \'Spell check\' checkbox', () => {
+            fillInTheGapsTextCommonComponent.steps.uncheckSpellCheckCheckbox();
+        });
+    },
+
+    verifySpellCheckFunctionalityPreviewTab: () => {
+        it('When the \'Spell check\' functionality is disabled, the response field should have \'spellcheck\' attribute set as \'false\' in preview tab', () => {
+            fillInTheGapsTextCommonComponent.steps.verifySpellCheckOfResponseFieldPreviewTabDisabled(0);
+        });
+
+        it('When the \'Spell check\' functionality is enabled, the response field should have \'spellcheck\' attribute set as \'true\' in the preview tab', () => {
+            createQuestionBasePage.steps.switchToEditTab();
+            fillInTheGapsTextCommonComponent.steps.checkSpellCheckCheckbox();
+            createQuestionBasePage.steps.switchToPreviewTab();
+            fillInTheGapsTextCommonComponent.steps.verifySpellCheckOfResponseFieldPreviewTabEnabled(0);
+        });
+    },
+
+    verifyAnswerInputFieldEditTab: () => {
+        it('\'Answers\' label and one empty input field should be displayed', () => {
+            utilities.verifyInnerText(fillInTheGapsTextCommonComponent.responseAccordionAnswersLabel(), 'Answers');
+            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.responseAccordionAnswersLabel(), 'visible');
+            utilities.verifyInnerText(fillInTheGapsTextCommonComponent.answerInputFieldSpecifyCorrectAnswerSection(), '');
+            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.answerInputFieldSpecifyCorrectAnswerSection(), 'visible');
+            utilities.verifyElementCount(fillInTheGapsTextCommonComponent.answerInputFieldSpecifyCorrectAnswerSection(), 1);
+        });
+
+        it('When there is a single input field, then answer input field should not have numeration and delete button ', () => {
+            utilities.verifyElementCount(fillInTheGapsTextCommonComponent.responseAccordionAnswerInputFieldWrapper(), 1);
+            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.responseAccordionAnswerNumeration(), 'notExist');
+            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.responseAccordionAnswerDeleteButton(), 'notExist');
+        });
+
+        it('\'Add alternate\' button should be displayed', () => {
+            utilities.verifyInnerText(fillInTheGapsTextCommonComponent.responseAccordionAddAlternateButtonLabel(), 'Add alternate');
+            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.responseAccordionAddAlternateButtonLabel(), 'visible');
+        });
+
+        it('When user has not entered text inside answer input field and clicks on \'Add alternate\' answer then \'Error: Answer is required.\' error message should be displayed', () => {
+            fillInTheGapsTextCommonComponent.steps.addAlternateAnswerInResponseAccordion(0);
+            utilities.verifyInnerText(commonComponents.errorMessage(), 'Error: Answer is required.');
+            utilities.verifyElementVisibilityState(commonComponents.errorMessage(), 'visible');
+        });
+
+        it('When user enters text inside answer input field, then error message should disappear', () => {
+            fillInTheGapsTextCommonComponent.steps.enterTextInAnswerInputFieldsSpecifyCorrectAnswerSection([{ responseIndex: 0, responseText: 'Flower' }]);
+            commonComponents.steps.verifyErrorMessageIsNotDisplayed();
+        });
+
+        it('When the user clicks on the \'Add Alternate\' button, then one alternate answer input field should be displayed', () => {
+            fillInTheGapsTextCommonComponent.steps.addAlternateAnswerInResponseAccordion(0);
+            utilities.verifyElementCount(fillInTheGapsTextCommonComponent.answerInputFieldSpecifyCorrectAnswerSection(), 2);
+            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.responseAccordionAddAlternateButton(), 'visible');
+        });
+
+        it('Each input field should be appropriately numbered, and a delete button should be provided for each input field', () => {
+            fillInTheGapsTextCommonComponent.steps.verifyResponseAccordionAnswerInputFieldNumeration(0);
+            fillInTheGapsTextCommonComponent.steps.verifyResponseAccordionAnswerInputFieldDeleteButton(0);
+        });
+
+        it('When user hovers over delete button, then tooltip \'Delete\' should be displayed', () => {
+            utilities.getNthElement(fillInTheGapsTextCommonComponent.responseAccordionAnswerDeleteButton(), 0)
+                .verifyTooltip('Delete');
+        });
+
+        it('When no input is provided in answer input field, then placeholder text \'Enter answer\' should be displayed in the answer input field', () => {
+            fillInTheGapsTextCommonComponent.steps.verifyAnswerInputFieldPlaceholder(1);
+        });
+
+        it('When the user clicks on the \'Add Alternate\' button without entering text in the newly added alternate answer input field, then an error message should be displayed, indicating \'Error: Answer is required.\'', () => {
+            fillInTheGapsTextCommonComponent.steps.addAlternateAnswerInResponseAccordion(0);
+            utilities.verifyInnerText(commonComponents.errorMessage(), 'Error: Answer is required.');
+        });
+
+        it('When user adds text in alternate input field and clicks on \'Add alternate\' button, then then a third alternate answer input field should be displayed and error message should disappear', () => {
+            fillInTheGapsTextCommonComponent.steps.enterTextInAnswerInputFieldsSpecifyCorrectAnswerSection([{ responseIndex: 1, responseText: 'Leaf' }]);
+            commonComponents.steps.verifyErrorMessageIsNotDisplayed();
+            fillInTheGapsTextCommonComponent.steps.addAlternateAnswerInResponseAccordion(0);
+            utilities.verifyElementCount(fillInTheGapsTextCommonComponent.answerInputFieldSpecifyCorrectAnswerSection(), 3);
+        });
+
+        it('CSS of answer input field', { tags: 'css' }, () => {
+            utilities.verifyCSS(fillInTheGapsTextCommonComponent.responseAccordionAnswersLabel(), {
+                'color': css.color.labels,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.semibold,
+            });
+            utilities.verifyCSS(utilities.getNthElement(fillInTheGapsTextCommonComponent.answerInputFieldSpecifyCorrectAnswerSection(), 1), {
+                'color': css.color.text,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular,
+            });
+            utilities.verifyCSS(utilities.getNthElement(fillInTheGapsTextCommonComponent.responseAccordionAnswerNumeration(), 1), {
+                'color': css.color.labels,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.semibold,
+            });
+            utilities.getNthElement(fillInTheGapsTextCommonComponent.responseAccordionAnswerDeleteButton(), 1)
+                .find('button')
+                .verifyPseudoClassBeforeProperty('color', css.color.deleteIcon);
+        });
+
+        it('Accessibility of response accordion', { tags: 'a11y' }, () => {
+            cy.checkAccessibility(fillInTheGapsTextCommonComponent.responseAccordion());
+        });
+
+        it('When provided input is cleared from answer input field, then placeholder text should be displayed again in the answer input field', () => {
+            fillInTheGapsTextCommonComponent.steps.clearAnswerInputField(0);
+            fillInTheGapsTextCommonComponent.steps.verifyAnswerInputFieldPlaceholder(0);
+        });
+
+        it('When user deletes input field, then alternate answer field should be deleted and each input field should have appropriate numeration and delete button', () => {
+            fillInTheGapsTextCommonComponent.steps.deleteResponseAccordionAnswerInputField(0, 0);
+            fillInTheGapsTextCommonComponent.steps.verifyResponseAccordionAnswerInputFieldNumeration(0);
+            fillInTheGapsTextCommonComponent.steps.verifyResponseAccordionAnswerInputFieldDeleteButton(0);
+        });
+    },
+
+    verifyAcceptedStudentInputEditTabFunctionality: () => {
+        it('When \'Text\' is selected in accepted student input, then user should be able to enter alphanumeric characters and special symbols in the answer input field', () => {
+            acceptedStudentInputComponent.steps.verifyAcceptedStudentTypeActiveButton(0, 'Text');
+            fillInTheGapsTextCommonComponent.steps.enterTextInAnswerInputFieldsSpecifyCorrectAnswerSection([{ responseIndex: 0, responseText: 'Hi23(^^)' }]);
+            fillInTheGapsTextCommonComponent.steps.verifyTextInResponseAccordionAnswerInputField([{ responseIndex: 0, responseText: 'Hi23(^^)' }]);
+        });
+
+        it('When user selects \'Number\' in accepted student input, then text inside the answer input field should only include numbers part from the previously entered input', () => {
+            acceptedStudentInputComponent.steps.selectAcceptedStudentInputType(0, 'Number');
+            fillInTheGapsTextCommonComponent.steps.verifyTextInResponseAccordionAnswerInputField([{ responseIndex: 0, responseText: '23' }]);
+        });
+
+        it('User should not be able to enter characters or special symbols i.e. answer input field should only contain numbers', () => {
+            fillInTheGapsTextCommonComponent.steps.enterTextInAnswerInputFieldsSpecifyCorrectAnswerSection([{ responseIndex: 0, responseText: 'ABc^12' }]);
+            fillInTheGapsTextCommonComponent.steps.verifyTextInResponseAccordionAnswerInputField([{ responseIndex: 0, responseText: '12' }]);
+        });
+
+        it('User should be able to enter negative numbers in answer input field', () => {
+            fillInTheGapsTextCommonComponent.steps.enterTextInAnswerInputFieldsSpecifyCorrectAnswerSection([{ responseIndex: 0, responseText: '-5' }]);
+            fillInTheGapsTextCommonComponent.steps.verifyTextInResponseAccordionAnswerInputField([{ responseIndex: 0, responseText: '-5' }]);
+        });
+
+        it('User should be able to add zero in input field', () => {
+            fillInTheGapsTextCommonComponent.steps.enterTextInAnswerInputFieldsSpecifyCorrectAnswerSection([{ responseIndex: 0, responseText: '0' }]);
+            fillInTheGapsTextCommonComponent.steps.verifyTextInResponseAccordionAnswerInputField([{ responseIndex: 0, responseText: '0' }]);
+        });
+
+        it('User should be able to enter decimal numbers in answer input field', () => {
+            fillInTheGapsTextCommonComponent.steps.enterTextInAnswerInputFieldsSpecifyCorrectAnswerSection([{ responseIndex: 0, responseText: '29.54' }]);
+            fillInTheGapsTextCommonComponent.steps.verifyTextInResponseAccordionAnswerInputField([{ responseIndex: 0, responseText: '29.54' }]);
+        });
+
+        it('When user selects \'Integer\' in accepted student input, then text inside the answer input field should only include whole numbers part from the previously entered input', () => {
+            acceptedStudentInputComponent.steps.selectAcceptedStudentInputType(0, 'Integer');
+            fillInTheGapsTextCommonComponent.steps.verifyTextInResponseAccordionAnswerInputField([{ responseIndex: 0, responseText: '2954' }]);
+        });
+
+        it('When \'Integer\' is selected in accepted student input, then user should not be able to add characters or special symbols i.e. input field should only include whole numbers', () => {
+            fillInTheGapsTextCommonComponent.steps.enterTextInAnswerInputFieldsSpecifyCorrectAnswerSection([{ responseIndex: 0, responseText: '29hi*5k4.5' }]);
+            fillInTheGapsTextCommonComponent.steps.verifyTextInResponseAccordionAnswerInputField([{ responseIndex: 0, responseText: '29545' }]);
+        });
+
+        it('User should be able to add zero in input field', () => {
+            fillInTheGapsTextCommonComponent.steps.enterTextInAnswerInputFieldsSpecifyCorrectAnswerSection([{ responseIndex: 0, responseText: '0' }]);
+            fillInTheGapsTextCommonComponent.steps.verifyTextInResponseAccordionAnswerInputField([{ responseIndex: 0, responseText: '0' }]);
+        });
+
+        it('User should not be able to add negative number i.e. input field should only include positive whole numbers', () => {
+            fillInTheGapsTextCommonComponent.steps.enterTextInAnswerInputFieldsSpecifyCorrectAnswerSection([{ responseIndex: 0, responseText: '-44' }]);
+            fillInTheGapsTextCommonComponent.steps.verifyTextInResponseAccordionAnswerInputField([{ responseIndex: 0, responseText: '44' }]);
+        });
+
+        it('When user selects \'Text\' in accepted student input again, then answer input field should contain text from previously added input', () => {
+            acceptedStudentInputComponent.steps.selectAcceptedStudentInputType(0, 'Text');
+            fillInTheGapsTextCommonComponent.steps.verifyTextInResponseAccordionAnswerInputField([{ responseIndex: 0, responseText: '44' }]);
+        });
+
+        it('When user adds alternate answer input field, then accepted student input should be applied on both the response answer input fields in the response accordion', () => {
+            fillInTheGapsTextCommonComponent.steps.addAlternateAnswerInResponseAccordion(0);
+            fillInTheGapsTextCommonComponent.steps.enterTextInAnswerInputFieldsSpecifyCorrectAnswerSection([{ responseIndex: 1, responseText: 'Hi12' }]);
+            fillInTheGapsTextCommonComponent.steps.verifyTextInResponseAccordionAnswerInputField([{ responseIndex: 1, responseText: 'Hi12' }]);
+        });
+    },
+
+    verifyAcceptedStudentInputPreviewTabFunctionality: () => {
+        it('When \'Text\' is selected in accepted student input in edit tab, then user should be able to enter alphanumeric characters and special symbols in the preview tab', () => {
+            acceptedStudentInputComponent.steps.verifyAcceptedStudentTypeActiveButton(0, 'Text');
+            createQuestionBasePage.steps.switchToPreviewTab();
+            fillInTheGapsTextCommonComponent.steps.enterTextInAnswerInputFieldsPreviewTab([{ responseIndex: 0, responseText: 'Flower23^^' }]);
+            fillInTheGapsTextCommonComponent.steps.verifyTextInAnswerInputFieldsPreviewTab([{ responseIndex: 0, responseText: 'Flower23^^' }]);
+        });
+
+        it('When user selects \'Number\' in accepted student input in edit tab, then user should be able to enter only numbers inside text container in preview tab', () => {
+            createQuestionBasePage.steps.switchToEditTab();
+            acceptedStudentInputComponent.steps.selectAcceptedStudentInputType(0, 'Number');
+            createQuestionBasePage.steps.switchToPreviewTab();
+            fillInTheGapsTextCommonComponent.steps.enterTextInAnswerInputFieldsPreviewTab([{ responseIndex: 0, responseText: 'Flower232&' }]);
+            fillInTheGapsTextCommonComponent.steps.verifyTextInAnswerInputFieldsPreviewTab([{ responseIndex: 0, responseText: '232' }]);
+        });
+
+        it('User should be able to enter decimal numbers inside text container in preview tab', () => {
+            fillInTheGapsTextCommonComponent.steps.enterTextInAnswerInputFieldsPreviewTab([{ responseIndex: 0, responseText: '23.2' }]);
+            fillInTheGapsTextCommonComponent.steps.verifyTextInAnswerInputFieldsPreviewTab([{ responseIndex: 0, responseText: '23.2' }]);
+        });
+
+        it('User should be able to enter negative numbers inside text container in preview tab', () => {
+            fillInTheGapsTextCommonComponent.steps.enterTextInAnswerInputFieldsPreviewTab([{ responseIndex: 0, responseText: '-6' }]);
+            fillInTheGapsTextCommonComponent.steps.verifyTextInAnswerInputFieldsPreviewTab([{ responseIndex: 0, responseText: '-6' }]);
+        });
+
+        it('User should be able to enter zero inside text container in preview tab', () => {
+            fillInTheGapsTextCommonComponent.steps.enterTextInAnswerInputFieldsPreviewTab([{ responseIndex: 0, responseText: '0' }]);
+            fillInTheGapsTextCommonComponent.steps.verifyTextInAnswerInputFieldsPreviewTab([{ responseIndex: 0, responseText: '0' }]);
+        });
+
+        it('When user selects \'Integer\' in accepted student input in edit tab, then user should be able to add only whole numbers inside text container', () => {
+            createQuestionBasePage.steps.switchToEditTab();
+            acceptedStudentInputComponent.steps.selectAcceptedStudentInputType(0, 'Integer');
+            createQuestionBasePage.steps.switchToPreviewTab();
+            fillInTheGapsTextCommonComponent.steps.enterTextInAnswerInputFieldsPreviewTab([{ responseIndex: 0, responseText: 'Flower232&*' }]);
+            fillInTheGapsTextCommonComponent.steps.verifyTextInAnswerInputFieldsPreviewTab([{ responseIndex: 0, responseText: '232' }]);
+        });
+
+        it('When user has selected \'Integer\' in accepted student input, then user should not be able to add decimal numbers in the text container', () => {
+            fillInTheGapsTextCommonComponent.steps.enterTextInAnswerInputFieldsPreviewTab([{ responseIndex: 0, responseText: '22.4' }]);
+            fillInTheGapsTextCommonComponent.steps.verifyTextInAnswerInputFieldsPreviewTab([{ responseIndex: 0, responseText: '224' }]);
+        });
+
+        it('When user has selected \'Integer\' in accepted student input, then user should not be able to add negative number inside text container i.e. input field should only include positive whole numbers.', () => {
+            fillInTheGapsTextCommonComponent.steps.enterTextInAnswerInputFieldsPreviewTab([{ responseIndex: 0, responseText: '-5' }]);
+            fillInTheGapsTextCommonComponent.steps.verifyTextInAnswerInputFieldsPreviewTab([{ responseIndex: 0, responseText: '5' }]);
+        });
+
+        it('User should be able to enter zero inside text container in preview tab', () => {
+            fillInTheGapsTextCommonComponent.steps.enterTextInAnswerInputFieldsPreviewTab([{ responseIndex: 0, responseText: '0' }]);
+            fillInTheGapsTextCommonComponent.steps.verifyTextInAnswerInputFieldsPreviewTab([{ responseIndex: 0, responseText: '0' }]);
+        });
     }
 }