itemengine-cypress-automation 1.0.119 → 1.0.121

package/cypress/pages/components/fillInTheGapsTextCommonComponent.js

@@ -1,878 +1,606 @@
 import utilities from "../../support/helpers/utilities";
-import { additionalSettingsPanel } from "./additionalSettingsPanel";
-import { autoScoredAdditionalSettings } from "./autoScoredAdditionalSettings";
-import { autoScoredScoringSectionMultipleResponsesType } from "./autoScoredScoringSectionMultipleResponsesType";
-import { autoScoredSetCorrectAnswerSection } from "./autoScoredSetCorrectAnswerSection";
 import { commonComponents } from "./commonComponents";
-import { figOverImageCommonComponent } from "./figOverImageCommonComponent";
-import { scoringSectionBase } from "./scoringSectionBase";
-import { specialAndCustomSpecialCharactersComponent } from "./specialAndCustomSpecialCharactersComponent";
+import { createQuestionBasePage } from "./createQuestionBasePage";
 const css = Cypress.env('css');
 
 const selectors = {
-    responseFieldSetCorrectAnswerSection: () => cy.get('.response-input-field input[type="text"]'),
-    responseFieldWrapperSetCorrectAnswerSection: () => cy.get('.response-input-field'),
-    responseFieldLabelSetCorrectAnswerSection: () => cy.get('.response-label'),
-    caseSensitiveLabel: () => cy.get('.ngie-checkbox-control-label').eq(0),
-    caseSensitiveCheckbox: () => cy.get('.ngie-checkbox input').eq(0),
-    ignoreSpacesBeforeAndAfterLabel: () => cy.get('.ngie-checkbox-control-label').eq(1),
-    ignoreSpacesBeforeAndAfterCheckbox: () => cy.get('.ngie-checkbox input').eq(1),
-    matchFromAllResponsesLabel: () => cy.get('.ngie-checkbox-control-label').eq(2),
-    matchFromAllResponsesCheckbox: () => cy.get('.ngie-checkbox input').eq(2),
-    responseFieldPreviewTab: () => cy.get('[class*="ClozeWithTextResponsestyles__ContentWrapper"] .response-input-field input[type="text"]'),
-    responseFieldWrapperPreviewTab: () => cy.get('[class*="question-preview-wrapper"] .response-input-field'),
-    previewTabCorrectAnswerContainer: () => cy.get('[class*="ClozeWithTextResponsestyles__CorrectAnswerWrapper"]'),
-    previewTabCorrectAnswerResponseWrapper: () => cy.get('[class*="ClozeWithTextResponsestyles__CorrectResponseWrapper"] [aria-label*="Add answer for response"]'),
-    previewTabResponseWrapper: () => cy.get('.draggable-input .cloze-with-text-answer-status-response-preview-wrapper'),
-    previewTabCorrectAnswerLabel: () => cy.get('[class*="ClozeWithTextResponsestyles__CorrectAnswerLabel"]'),
-    responseNumeration: () => cy.get('.response-input-adornment'),
-    setCharacterLimitLabel: () => cy.get('[aria-labelledby="Set character limit"]'),
-    setCharacterLimitInputField: () => cy.get('input[aria-label="Set character limit"]'),
-    typeOfAnswerInputLabel: () => cy.get('[id*="Type-of-Answer-input"][id*="dropdown-label"]'),
-    typeOfAnswerInputDropdown: () => cy.get('[id*="Type-of-Answer-input"][id*="select"]'),
-    typeOfAnswerInputDropdownListOptions: (ariaLabel = null) => {
-        if (ariaLabel) {
-            return cy.get(`[aria-labelledby*="Type-of-Answer-input"][aria-labelledby*="dropdown-label"] li[role="option"][aria-label*="${ariaLabel}"]`)
-        } else {
-            return cy.get('[aria-labelledby*="Type-of-Answer-input"][aria-labelledby*="dropdown-label"] li[role="option"]')
-        }
-    },
-    multilineResponseLabel: () => cy.get('[data-ngie-testid="multiline-response-checkbox"] .MuiFormControlLabel-label'),
-    multilineResponseCheckbox: () => cy.get('[data-ngie-testid="multiline-response-checkbox"] input'),
-    multilineResponseAreaSetCorrectAnswerSection: () => cy.get('.response-multiline-input-field textarea'),
-    multilineResponseAreaPreviewTab: () => cy.get('.cloze-with-text-response-preview-wrapper .response-multiline-input-field textarea'),
-    spellCheckLabel: () => cy.get('[data-ngie-testid="spell-check-checkbox"] .MuiFormControlLabel-label'),
-    spellCheckCheckbox: () => cy.get('[data-ngie-testid="spell-check-checkbox"] input[type="checkbox"]'),
-    previewTabResponseFieldSpecialCharactersButton: () => cy.get('.cloze-with-text-response-preview-wrapper .custon-special-character-button'),
+    answerInputFieldSpecifyCorrectAnswerSection: () => cy.get('.label-image-text-inline-text-field input'),
+    answerInputFieldPreviewTab: () => cy.get('[class*="question-preview-wrapper"] .response-input-field input'),
+    responseAreaNumeration: () => cy.get('.response-input-adornment'),
+    correctAnswerSectionWrapper: () => cy.get('.cloze-with-text-correct-answer-wrapper'),
+    correctAnswersLabel: () => cy.get('[class*="question-preview-wrapper"] [class*="correct-answer-label"]'),
+    responseStatusWrapper: () => cy.get('.cloze-with-text-answer-status-response-preview-wrapper:visible'),
+    correctAnswerResponseNumeration: () => cy.get('.answer-numeration-number-box'),
+    correctAnswerResponseWrapper: () => cy.get('[class*="ClozeWithTextResponsestyles__AnswerCell"]'),
+    correctAnswerResponse: () => cy.get('[class*="AnswerWrapperForLabel"]'),
+
+    setLimitLabel: () => cy.get('[class*="SetLimitWrapper"] .text-label'),
+    minimumCharacterLimitLabel: () => cy.get('.label-image-min-max-container .additional-settings-label').eq(0),
+    maximumCharacterLimitLabel: () => cy.get('.label-image-min-max-container .additional-settings-label').eq(1),
+    minMaxLabelAndInputFieldWrapper: () => cy.get('.label-image-min-max-container'),
+    minimumCharacterLimitInputField: () => cy.get('.label-image-min-max-container input').eq(0),
+    maximumCharacterLimitInputField: () => cy.get('.label-image-min-max-container input').eq(1),
+    characterRadioButton: () => cy.get('input[aria-label="Character"]'),
+    characterLabel: () => cy.get('[aria-label="Character"].ngie-radio-label'),
+    noneRadioButton: () => cy.get('input[aria-label="None"]'),
+    noneLabel: () => cy.get('[aria-label="None"].ngie-radio-label'),
+    limitReachedWarningMessage: () => cy.get('.disabled-wrapper-cls [class*="DisabledTextWrapper"]'),
+    limitReachedWarningMessageContainer: () => cy.get('.disabled-wrapper-cls'),
+
+    //response accordion
+    responseAccordion: () => cy.get('.response-text-accordion'),
+    responseAccordionLabel: () => cy.get('[class*="ResponseComponentstyles__Label"]'),
+    responseAccordionAnswersLabel: () => cy.get('.correct-response-answer-wrapper-cls .points-label'),
+    responseAccordionAnswerInputFieldWrapper: () => cy.get('.label-image-text-answer-label'),
+    responseAccordionAnswerNumeration: () => cy.get('.additional-option-placeholder-input .start-adornment'),
+    responseAccordionAnswerDeleteButton: () => cy.get('.delete-button'),
+    responseAccordionPointsWrapper: () => cy.get('[class*="ResponseComponentstyles__PointsDiv"]'),
+    responseAccordionPointsLabel: () => cy.get('[class*="ResponseComponentstyles__PointsLabel"]'),
+    responseAccordionPointsScore: () => cy.get('[class*="ResponseComponentstyles__Points-"]'),
+    responseAccordionPointsInputFieldWrapper: () => cy.get('[class*="ResponseComponentstyles__PointsWrapper"]'),
+    responseAccordionAddAlternateButton: () => cy.get('.add-alternate-btn'),
+    responseAccordionAddAlternateButtonLabel: () => cy.get('.add-alternate-btn p'),
+    responseAreaNumeration: () => cy.get('.response-input-adornment'),
+
+    //additional settings
+    enterAriaLabelInputField: () => cy.get('input[aria-label*="Enter ARIA label"]')
 }
 
 const steps = {
     /**
-     * Enters text into a response field in the 'Set correct answer' section.
-     * @param {number} index - The index of the response field to target.
-     * @param {string} text - The text to be entered into the response field.
-     * @returns {void}
-     */
-    enterTextInResponseFieldSetCorrectAnswerSection: (index, text) => {
-        fillInTheGapsTextCommonComponent.responseFieldSetCorrectAnswerSection()
-            .eq(index)
-            .clear()
-            .type(text)
-            .blur();
+     * Enter text in the answer input fields of the specify correct answer section.
+     * @param {Object[]} responses - An array of objects containing the responseIndex and responseText.
+     * @param {number} responses[].responseIndex - The index of the answer input field for each response.
+     * @param {string} responses[].responseText - The text to be entered in the respective answer input field.
+     * @example - enterTextInAnswerInputFieldsSpecifyCorrectAnswerSection([
+     *   { responseIndex: 0, responseText: "Answer 1" },
+     *   { responseIndex: 1, responseText: "Answer 2" },
+     * ]);
+     */
+    enterTextInAnswerInputFieldsSpecifyCorrectAnswerSection: (responses) => {
+        responses.forEach(({ responseIndex, responseText }) => {
+            utilities.getNthElement(fillInTheGapsTextCommonComponent.answerInputFieldSpecifyCorrectAnswerSection(), responseIndex)
+                .clear()
+                .type(responseText)
+                .blur();
+        });
     },
 
     /**
-     * Clears the response field in the correct answer section at the specified index.
-     * @param {number} index - The index of the response field to clear.
+     * Verify text in the answer input fields of the preview tab.
+     * @param {Object[]} responses - An array of objects containing the responseIndex and responseText.
+     * @param {number} responses[].responseIndex - The index of the answer input field for each response.
+     * @param {string} responses[].responseText - The text to be verified in the respective answer input field.
      */
-    clearResponseFieldSetCorrectAnswerSection: (index) => {
-        fillInTheGapsTextCommonComponent.responseFieldSetCorrectAnswerSection()
-            .eq(index)
-            .clear();
+    verifyTextInAnswerInputFieldsPreviewTab: (responses) => {
+        responses.forEach(({ responseIndex, responseText }) => {
+            utilities.getNthElement(fillInTheGapsTextCommonComponent.answerInputFieldPreviewTab(), responseIndex)
+                .should('have.value', responseText)
+        });
     },
 
     /**
-     * Clears the response field in the preview tab at the specified index.
-     * @param {number} index - The index of the response field to clear.
+     * Enter text in the answer input fields of the preview tab.
+     * @param {Object[]} responses - An array of objects containing the responseIndex and responseText.
+     * @param {number} responses[].responseIndex - The index of the answer input field for each response.
+     * @param {string} responses[].responseText - The text to be entered in the respective answer input field.
      */
-    clearResponseFieldPreviewTab: (index) => {
-        fillInTheGapsTextCommonComponent.responseFieldPreviewTab()
-            .eq(index)
-            .clear();
+    enterTextInAnswerInputFieldsPreviewTab: (responses) => {
+        responses.forEach(({ responseIndex, responseText }) => {
+            utilities.getNthElement(fillInTheGapsTextCommonComponent.answerInputFieldPreviewTab(), responseIndex)
+                .clear()
+                .type(responseText)
+                .blur();
+        });
     },
 
     /**
-     * Verifies the text value in a response field in the 'Set Correct Answer' section.
-     * @param {number} index - The index of the response field to target.
-     * @param {string} value - The expected text value to compare against.
-     * @returns {void}
+     * Verify that a specific answer input field is disabled on the preview tab.
+     * @param {number} inputFieldIndex - The index of the disabled answer input field.
      */
-    verifyTextInResponseFieldSetCorrectAnswerSection: (index, value) => {
-        fillInTheGapsTextCommonComponent.responseFieldSetCorrectAnswerSection()
-            .eq(index)
-            .should('have.attr', 'value', value);
+    verifyAnswerInputFieldDisabled: (inputFieldIndex) => {
+        utilities.verifyElementDisabled(utilities.getNthElement(fillInTheGapsTextCommonComponent.answerInputFieldPreviewTab(), inputFieldIndex));
     },
 
-    /**
-     * Enters text into a response field in the preview tab
-     * @param {number} index - The index of the response field to target.
-     * @param {string} text - The text to be entered into the response field.
-     * @returns {void}
-     */
-    enterTextInResponseFieldPreviewTab: (index, text) => {
-        fillInTheGapsTextCommonComponent.responseFieldPreviewTab()
-            .eq(index)
-            .clear()
-            .type(text)
-            .blur();
+    verifyResponseAreaNumeration: () => {
+        fillInTheGapsTextCommonComponent.answerInputFieldPreviewTab()
+            .each(($element, index) => {
+                cy.wrap($element)
+                    .parents('.cloze-with-text-response-field-wrapper')
+                    .within(() => {
+                        utilities.verifyTextContent(fillInTheGapsTextCommonComponent.responseAreaNumeration(), `${index + 1}`);
+                    });
+            });
     },
 
     /**
-     * Verifies the text value in a response field in the 'Set Correct Answer' section.
-     * @param {number} index - The index of the response field to target.
-     * @param {string} value - The expected text value to compare against.
-     * @returns {void}
+     * Verify correct answer responses in the correct answer section and count.
+     * @param {string[]} correctAnswerArray - An array containing the expected correct answer responses.
+     * @example verifyCorrectAnswerResponsesInCorrectAnswerSectionAndCount(['Flower', 'Petals', 'Stem']);
      */
-    verifyTextInResponseFieldPreviewTab: (index, value) => {
-        fillInTheGapsTextCommonComponent.responseFieldPreviewTab()
-            .eq(index)
-            .should('have.attr', 'value', value);
-    },
-
-    verifyMatchFromAllResponsesLabelAndCheckboxEnabledState: () => {
-        fillInTheGapsTextCommonComponent.matchFromAllResponsesLabel()
-            .should('not.have.class', 'Mui-disabled');
-        fillInTheGapsTextCommonComponent.matchFromAllResponsesCheckbox()
-            .and('not.be.disabled');
-    },
-
-    verifyCaseSensitiveCheckboxNotChecked: () => {
-        fillInTheGapsTextCommonComponent.caseSensitiveCheckbox()
-            .should('not.be.checked');
+    verifyCorrectAnswerResponsesInCorrectAnswerSectionAndCount: (correctAnswerArray) => {
+        utilities.verifyElementCount(fillInTheGapsTextCommonComponent.correctAnswerResponseWrapper(), correctAnswerArray.length);
+        correctAnswerArray.forEach((correctAnswer, index) => {
+            fillInTheGapsTextCommonComponent.correctAnswerResponseWrapper()
+                .eq(index)
+                .within(() => {
+                    utilities.verifyInnerText(fillInTheGapsTextCommonComponent.correctAnswerResponseNumeration(), `${index + 1}`);
+                    fillInTheGapsTextCommonComponent.correctAnswerResponse()
+                        .should('have.text', correctAnswer);
+                });
+        });
     },
 
-    verifyCaseSensitiveCheckBoxChecked: () => {
-        fillInTheGapsTextCommonComponent.caseSensitiveCheckbox()
-            .should('be.checked')
+    verifyCorrectAnswerSectionNotExists: () => {
+        utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.correctAnswerSectionWrapper(), 'notExist');
     },
 
-    verifyIgnoreSpacesBeforeAndAfterCheckboxChecked: () => {
-        fillInTheGapsTextCommonComponent.ignoreSpacesBeforeAndAfterCheckbox()
+    verifyCharacterRadioButtonSelected: () => {
+        fillInTheGapsTextCommonComponent.characterRadioButton()
             .should('be.checked');
     },
 
-    verifyIgnoreSpacesBeforeAndAfterCheckboxNotChecked: () => {
-        fillInTheGapsTextCommonComponent.ignoreSpacesBeforeAndAfterCheckbox()
+    verifyNoneRadioButtonNotSelected: () => {
+        fillInTheGapsTextCommonComponent.noneRadioButton()
             .should('not.be.checked');
     },
 
-    verifyMatchFromAllResponsesLabelAndCheckboxDisabledState: () => {
-        fillInTheGapsTextCommonComponent.matchFromAllResponsesLabel()
-            .should('have.class', 'Mui-disabled');
-        fillInTheGapsTextCommonComponent.matchFromAllResponsesCheckbox()
-            .and('be.disabled');
-    },
-
-    //Note: Need to move this in figOverImageCommonComponent file along with the selectors once the checkbox enhancement build is uploaded
-    checkMatchFromAllResponsesCheckbox: () => {
-        fillInTheGapsTextCommonComponent.matchFromAllResponsesCheckbox()
+    selectCharacterRadioButton: () => {
+        fillInTheGapsTextCommonComponent.characterRadioButton()
             .click()
             .should('be.checked');
     },
 
-    /**
-     * @param {string[]} correctAnswerArray array of correct answer response
-     * @param {number[]} optionNumerationArray numeration of the correct answer response
-     * @description verify the correct answer responses in the correct answer container
-     */
-    verifyCorrectAnswerResponsesInCorrectAnswerContainerAndCount: (correctAnswerArray, optionNumerationArray) => {
-        fillInTheGapsTextCommonComponent.previewTabCorrectAnswerContainer()
-            .should('be.visible')
-            .within(() => {
-                correctAnswerArray.forEach((responseFieldText, count) => {
-                    fillInTheGapsTextCommonComponent.previewTabCorrectAnswerResponseWrapper()
-                        .eq(count)
-                        .should('have.value', responseFieldText);
-                });
-                optionNumerationArray.forEach((optionNumeration, count) => {
-                    fillInTheGapsTextCommonComponent.responseNumeration()
-                        .eq(count)
-                        .should('have.text', `${optionNumeration}`);
-                });
-            });
-        fillInTheGapsTextCommonComponent.previewTabCorrectAnswerResponseWrapper()
-            .should('have.length', optionNumerationArray.length);
-    },
-
-    /**
-     * Verify that the incorrect option at the specified index has a cross-mark icon and is visible.
-     * @param {number} index - The index of the incorrect option to verify.
-     */
-    verifyIncorrectOptionCrossmarkIcon: (index) => {
-        fillInTheGapsTextCommonComponent.previewTabResponseWrapper()
-            .eq(index)
-            .find('.tick-icon-wrapper')
-            .should('have.class', 'icon-incorrect')
-            .and('be.visible');
-    },
-
-    /**
-     * Verify that the correct option at the specified index has a check-mark icon and is visible.
-     * @param {number} index - The index of the correct option to verify.
-     */
-    verifyCorrectOptionCheckmarkIcon: (index) => {
-        fillInTheGapsTextCommonComponent.previewTabResponseWrapper()
-            .eq(index)
-            .find('.tick-icon-wrapper')
-            .should('have.class', 'icon-correct')
-            .and('be.visible');
-    },
-
-    verifyPreviewTabCorrectAnswerContainerNotExist: () => {
-        utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.previewTabCorrectAnswerContainer(), 'notExist');
-    },
-
-    checkCaseSensitiveCheckbox: () => {
-        fillInTheGapsTextCommonComponent.caseSensitiveCheckbox()
+    selectNoneRadioButton: () => {
+        fillInTheGapsTextCommonComponent.noneRadioButton()
             .click()
-            .should('be.checked');
-    },
-
-    uncheckIgnoreSpacesBeforeAndAfterCheckbox: () => {
-        fillInTheGapsTextCommonComponent.ignoreSpacesBeforeAndAfterCheckbox()
-            .click()
-            .should('not.be.checked');
-    },
-
-    uncheckMatchFromAllResponsesCheckbox: () => {
-        fillInTheGapsTextCommonComponent.matchFromAllResponsesCheckbox()
-            .click()
-            .should('not.be.checked')
-    },
-
-    /**
-     * @param {number} index - The index of the option to verify.
-     * @description Verify that the option at the specified index does not have a check-mark or cross-mark.
-     */
-    verifyCheckmarkOrCrossmarkNotVisible: (index) => {
-        utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.previewTabResponseWrapper().eq(index).find('.tick-icon-wrapper'), 'notExist');
     },
 
     /**
-     * Verify the character limit input field value.
-     * @param {string} value - The expected character limit value to match the input field value.
+     * @param {number} minLimit value of minimum input field
+     * @description this function verifies the value in minimum limit input field
      */
-    verifySetCharacterLimitInputFieldValue: (value) => {
-        fillInTheGapsTextCommonComponent.setCharacterLimitInputField()
-            .should('have.value', value)
+    verifyMinimumCharacterLimitInputField: (minLimit) => {
+        fillInTheGapsTextCommonComponent.minimumCharacterLimitInputField()
+            .should('have.value', minLimit);
     },
 
     /**
-     * Verify that the placeholder attribute does not exist in a response field in the Correct Answer section.
-     * @param {number} responseFieldIndex - The index of the response field to verify.
+     * @param {number} maxLimit value of maximum input field
+     * @description this function verifies the value in maximum limit input field
      */
-    verifyPlaceholderAttributeInSetCorrectAnswerSectionResponseFieldNotExists: (responseFieldIndex) => {
-        fillInTheGapsTextCommonComponent.responseFieldSetCorrectAnswerSection()
-            .eq(responseFieldIndex)
-            .should('not.have.attr', 'placeholder');
+    verifyMaximumCharacterLimitInputField: (maxLimit) => {
+        fillInTheGapsTextCommonComponent.maximumCharacterLimitInputField()
+            .should('have.value', maxLimit);
     },
 
     /**
-     * Verify that the placeholder attribute does not exist in a response field in the Preview Tab.
-     * @param {number} responseFieldIndex - The index of the response field to verify.
+     * @param {number} maxLimit value to be entered in maximum limit input field
+     * @description this function enters the value in maximum limit input field
      */
-    verifyPlaceholderAttributeInPreviewTabResponseFieldNotExists: (responseFieldIndex) => {
-        fillInTheGapsTextCommonComponent.responseFieldPreviewTab()
-            .eq(responseFieldIndex)
-            .should('not.have.attr', 'placeholder');
-    },
-
-    /**
-     * Verify the placeholder attribute in a response field in the Correct Answer section.
-     * @param {number} responseFieldIndex - The index of the response field to verify.
-     * @param {string} placeholderText - The expected placeholder text to match the attribute.
-     */
-    verifyPlaceholderAttributeInSetCorrectAnswerSectionResponseField: (responseFieldIndex, placeholderText) => {
-        fillInTheGapsTextCommonComponent.responseFieldSetCorrectAnswerSection()
-            .eq(responseFieldIndex)
-            .should('have.attr', 'placeholder', placeholderText);
-    },
-
-    /**
-     * Verify the placeholder attribute in a response field in the Preview Tab.
-     * @param {number} responseFieldIndex - The index of the response field to verify.
-     * @param {string} placeholderText - The expected placeholder text to match the attribute.
-     */
-    verifyPlaceholderAttributeInPreviewTabResponseField: (responseFieldIndex, placeholderText) => {
-        fillInTheGapsTextCommonComponent.responseFieldPreviewTab()
-            .eq(responseFieldIndex)
-            .should('have.attr', 'placeholder', placeholderText);
+    setMaximumLimit: (maxLimit) => {
+        fillInTheGapsTextCommonComponent.maximumCharacterLimitInputField()
+            .clear()
+            .type(maxLimit)
+            .blur();
     },
 
     /**
-     * @param {index} responseIndex Index of response field
-     * @param {string} ariaLabel Aria-label of response field
-     * @description Verify Aria-label of response field in set correct answer section
-     * @param {number} index of response field in preview tab
-     * @description this function focuses in the preview atb response field
+     * @param {number} maxLimit value to be entered in maximum limit input field
+     * @description this function verifies the value in maximum limit input field
      */
-    focusInResponseFieldPreviewTab: (index) => {
-        fillInTheGapsTextCommonComponent.responseFieldPreviewTab()
-            .eq(index)
-            .click();
-    },
-
-    /**
-    * @param {index} responseIndex Index of response
-    * @param {string} ariaLabel Aria-label of response
-    * @description Verify aria-label of response in set correct answer section
-    */
-    verifyResponseFieldAriaLabelAttributeInSetCorrectAnswerSection: (responseIndex, ariaLabel) => {
-        fillInTheGapsTextCommonComponent.responseFieldSetCorrectAnswerSection()
-            .eq(responseIndex)
-            .should('have.attr', 'aria-label', ariaLabel);
-    },
-
-    /**
-   * @param {index} responseIndex Index of response field
-   * @param {string} ariaLabel Aria-label of response field
-   * @description Verify Aria-label of response field in preview tab
-   */
-    verifyResponseFieldAriaLabelAttributeInPreviewTab: (responseIndex, ariaLabel) => {
-        fillInTheGapsTextCommonComponent.responseFieldPreviewTab()
-            .eq(responseIndex)
-            .should('have.attr', 'aria-label', ariaLabel);
-    },
+    verifyMaximumLimit: (maxLimit) => {
+        fillInTheGapsTextCommonComponent.maximumCharacterLimitInputField()
+            .should('have.value', maxLimit);
 
-    /**
-     * @param {number} responseIndex Index of response field
-     * @description Verify response is displayed in set correct answer section
-     */
-    verifyResponseFieldIsDisplayedInSetCorrectAnswerSection: (responseIndex) => {
-        utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.responseFieldSetCorrectAnswerSection().eq(responseIndex), 'visible');
     },
 
     /**
-     * @param {array} dropdownOptionsArray array of type of answer dropdown options 
-     * @description This function is used to verify the type of answer dropdown options 
+     * @param {number} minLimit value to be entered in minimum limit input field
+     * @description this function enters and verifies the value in minimum limit input field
      */
-    verifyTypeOfAnswerDropdownOptions: (dropdownOptionsArray) => {
-        dropdownOptionsArray.forEach((option, count) => {
-            fillInTheGapsTextCommonComponent.typeOfAnswerInputDropdownListOptions()
-                .eq(count)
-                .should('have.text', option);
-        });
-    },
-
-    clickOnTypeOfAnswerDropdown: () => {
-        fillInTheGapsTextCommonComponent.typeOfAnswerInputDropdown()
-            .eq(0)
-            .click();
+    setMinimumLimit: (minLimit) => {
+        fillInTheGapsTextCommonComponent.minimumCharacterLimitInputField()
+            .clear()
+            .type(minLimit)
+            .blur();
     },
 
     /**
-     * Select a specific option from the "Type of Answer" dropdown.
-     * @param {("Text" | "Number")} option - The option to select from the dropdown.
+     * @param {number} minLimit value to be entered in minimum limit input field
+     * @description this function verifies the value in minimum limit input field
      */
-    selectTypeOfAnswerDropdownOption: (option) => {
-        fillInTheGapsTextCommonComponent.typeOfAnswerInputDropdownListOptions(option)
-            .click();
+    verifyMinimumLimit: (minLimit) => {
+        fillInTheGapsTextCommonComponent.minimumCharacterLimitInputField()
+            .should('have.value', minLimit)
     },
 
-    setCharacterLimit: (value) => {
-        fillInTheGapsTextCommonComponent.setCharacterLimitInputField()
+    clearAndFocusOutOfMaximumCharacterLimitInputField: () => {
+        fillInTheGapsTextCommonComponent.maximumCharacterLimitInputField()
             .clear()
-            .type(value)
             .blur();
     },
 
-    verifySetCharacterLimitInputFieldMinimumValue: () => {
-        fillInTheGapsTextCommonComponent.setCharacterLimitInputField()
-            .should('not.have.value', '0')
-            .and('have.value', '1');
-    },
-
-    clearSetCharacterLimitInputField: () => {
-        fillInTheGapsTextCommonComponent.setCharacterLimitInputField()
+    clearAndFocusOutOfMinimumCharacterLimitInputField: () => {
+        fillInTheGapsTextCommonComponent.minimumCharacterLimitInputField()
             .clear()
             .blur();
     },
 
-    /**
-     * Verify the height attribute of a response field in the Correct Answer section.
-     * @param {number} responseFieldIndex - The index of the response field to verify.
-     * @param {string} height - The expected height value to match the attribute.
-     */
-    verifyHeightResponseFieldSetCorrectAnswerSection: (responseFieldIndex, height) => {
-        fillInTheGapsTextCommonComponent.responseFieldWrapperSetCorrectAnswerSection()
-            .eq(responseFieldIndex)
-            .should('have.attr', 'height', height);
+    verifyMaximumLimitErrorMessage: () => {
+        utilities.verifyInnerText(utilities.getNthElement(commonComponents.errorMessage(), 1), 'Error: Maximum limit must be greater than or equal to Minimum limit.');
+        utilities.verifyElementVisibilityState(utilities.getNthElement(commonComponents.errorMessage(), 1), 'visible');
+    },
+
+    verifyMinimumLimitErrorMessage: () => {
+        utilities.verifyInnerText(utilities.getNthElement(commonComponents.errorMessage(), 0), 'Error: Minimum limit must be less than or equal to Maximum limit.');
+        utilities.verifyElementVisibilityState(utilities.getNthElement(commonComponents.errorMessage(), 0), 'visible');
     },
 
     /**
-     * Verify the width attribute of a response field in the Correct Answer section.
-     * @param {number} responseFieldIndex - The index of the response field to verify.
-     * @param {string} width - The expected width value to match the attribute.
-     */
-    verifyWidthResponseFieldSetCorrectAnswerSection: (responseFieldIndex, width) => {
-        fillInTheGapsTextCommonComponent.responseFieldWrapperSetCorrectAnswerSection()
-            .eq(responseFieldIndex)
-            .should('have.attr', 'width', width);
+         * @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);
     },
 
     /**
-     * Verify the height attribute of a response field in the Preview Tab.
-     * @param {number} responseFieldIndex - The index of the response field to verify.
-     * @param {string} height - The expected height value to match the attribute.
+     * @param {number} responseIndex index of input field in specify correct answer
+     * @param {number} maxlen value of maxlength attribute
+     * @description function verifies maxlength attribute of input field in specify correct answer
      */
-    verifyHeightResponseFieldPreviewTab: (responseFieldIndex, height) => {
-        fillInTheGapsTextCommonComponent.responseFieldWrapperPreviewTab()
-            .eq(responseFieldIndex)
-            .should('have.attr', 'height', height);
+    verifyMaximumCharacterLimit: (responseIndex, maxlen) => {
+        utilities.getNthElement(fillInTheGapsTextCommonComponent.answerInputFieldSpecifyCorrectAnswerSection(), responseIndex)
+            .should('have.attr', 'maxlength', maxlen);
     },
 
     /**
-     * Verify the width attribute of a response field in the Preview Tab.
-     * @param {number} responseFieldIndex - The index of the response field to verify.
-     * @param {string} width - The expected width value to match the attribute.
+     * @param {number} responseIndex index of response container in preview tab
+     * @description function verifies maxlength attribute of input field in preview tab
      */
-    verifyWidthResponseFieldPreviewTab: (responseFieldIndex, width) => {
-        fillInTheGapsTextCommonComponent.responseFieldWrapperPreviewTab()
-            .eq(responseFieldIndex)
-            .should('have.attr', 'width', width);
+    verifyMaximumCharacterLimitNotExistInPreviewTab: (responseIndex) => {
+        utilities.getNthElement(fillInTheGapsTextCommonComponent.answerInputFieldPreviewTab(), responseIndex)
+            .should('not.have.attr', 'maxlength');
     },
 
-    verifyTypeOfAnswerLabelAndDropdownResponseAccordion: () => {
-        figOverImageCommonComponent.responseAccordionWrapper()
-            .within(() => {
-                utilities.verifyInnerText(fillInTheGapsTextCommonComponent.typeOfAnswerInputLabel(), 'Type of answer input');
-                utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.typeOfAnswerInputLabel(), 'visible');
-                utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.typeOfAnswerInputDropdown(), 'visible');
-                utilities.verifyInnerText(fillInTheGapsTextCommonComponent.typeOfAnswerInputDropdown(), 'Text');
-            });
+    verifyLimitReachedWarningMessageNotExist: () => {
+        utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.limitReachedWarningMessage(), 'notExist');
     },
 
     /**
-     * Click on the "Type of Answer" dropdown in a response accordion.
-     * @param {number} responseIndex - The index of the response accordion to click the dropdown in.
+     * @description this function verifies warning text for limit reached
+     * @param {string} warningText warning message displayed
      */
-    clickOnTypeOfAnswerDropdownInResponseAccordion: (responseIndex) => {
-        figOverImageCommonComponent.responseAccordionWrapper()
-            .eq(responseIndex)
-            .within(() => {
-                fillInTheGapsTextCommonComponent.typeOfAnswerInputDropdown()
-                    .click();
-            });
+    verifyLimitReachedWarningMessageExist: (warningText) => {
+        utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.limitReachedWarningMessage(), 'visible');
+        utilities.verifyInnerText(fillInTheGapsTextCommonComponent.limitReachedWarningMessage(), warningText);
     },
 
     /**
-     * Verify the selected option in the "Type of Answer" dropdown in a response accordion.
-     * @param {number} responseIndex - The index of the response accordion to verify.
-     * @param {string} option - The expected option to be selected in the dropdown.
+     *@description Verify text in the answer input fields of the specify correct answer section.
+     * @param {Object[]} responses - An array of objects containing the responseIndex and responseText.
+     * @param {number} responses[].responseIndex - The index of the answer input field for each response.
+     * @param {string} responses[].responseText - The text to be verified for the respective answer input field.
      */
-    verifySelectedOptionInTypeOfAnswerDropdownInResponseAccordion: (responseIndex, option) => {
-        figOverImageCommonComponent.responseAccordionWrapper()
-            .eq(responseIndex)
-            .within(() => {
-                utilities.verifyInnerText(fillInTheGapsTextCommonComponent.typeOfAnswerInputDropdown(), option);
-            });
+    verifyTextInResponseAccordionAnswerInputField: (responses) => {
+        responses.forEach(({ responseIndex, responseText }) => {
+            utilities.getNthElement(fillInTheGapsTextCommonComponent.answerInputFieldSpecifyCorrectAnswerSection(), responseIndex)
+                .should('have.value', responseText);
+        });
     },
 
-    verifyMultilineResponseCheckboxNotChecked: () => {
-        fillInTheGapsTextCommonComponent.multilineResponseCheckbox()
-            .should('not.be.checked');
+    //Used in setLimitSection.js only. 
+    /**
+     * @param {number} responseIndex index number of text container
+     * @param {string} responseText text to be added in text container
+     * @description function enters text in the answer input fields of the preview tab
+     */
+    addTextInAnswerInputFieldsPreviewTab: (responseIndex, responseText) => {
+        utilities.getNthElement(fillInTheGapsTextCommonComponent.answerInputFieldPreviewTab(), responseIndex)
+            .type(responseText);
     },
+}
 
-    verifyMultilineResponseForResponseFieldSetCorrectAnswerSectionDisabled: () => {
-        fillInTheGapsTextCommonComponent.responseFieldWrapperSetCorrectAnswerSection()
-            .each(($el) => {
-                cy.wrap($el)
-                    .should('not.have.class', 'response-multiline-input-field');
-                // Assert that textarea does not exist
-                cy.wrap($el)
-                    .find('textarea')
-                    .should('not.exist');
-            });
-    },
+const tests = {
+    verifySetLimitSectionContents: () => {
+        it('\'Set limit\' label should be displayed', () => {
+            utilities.verifyInnerText(fillInTheGapsTextCommonComponent.setLimitLabel(), 'Set limit');
+            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.setLimitLabel(), 'visible');
+        });
 
-    verifyMultilineResponseForResponseFieldPreviewTabDisabled: () => {
-        fillInTheGapsTextCommonComponent.responseFieldWrapperPreviewTab()
-            .each(($el) => {
-                cy.wrap($el)
-                    .should('not.have.class', 'response-multiline-input-field')
-                // Assert that textarea does not exist
-                cy.wrap($el)
-                    .find('textarea')
-                    .should('not.exist');
-            });
-    },
+        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();
+        });
 
-    checkMultilineResponseCheckbox: () => {
-        fillInTheGapsTextCommonComponent.multilineResponseCheckbox()
-            .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');
+        });
 
-    uncheckMultilineResponseCheckbox: () => {
-        fillInTheGapsTextCommonComponent.multilineResponseCheckbox()
-            .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);
+        });
 
-    /**
-     * Enter text in a multiline response area in the set correct answer section.
-     * @param {number} responseFieldIndex - The index of the response field to enter text in.
-     * @param {string} text - The text to enter in the multiline response area.
-     */
-    enterTextInMultilineResponseAreaSetCorrectAnswerSection: (responseFieldIndex, text) => {
-        fillInTheGapsTextCommonComponent.multilineResponseAreaSetCorrectAnswerSection()
-            .eq(responseFieldIndex)
-            .clear()
-            .type(text);
-    },
+        it('User should be able to update values in both the input fields', () => {
+            fillInTheGapsTextCommonComponent.steps.setMinimumLimit(10);
+            fillInTheGapsTextCommonComponent.steps.setMaximumLimit(40);
+        });
 
-    /**
-     * Verify the text in a multiline response area in the set correct answer section.
-     * @param {number} responseFieldIndex - The index of the response field to verify.
-     * @param {string} text - The expected text to be present in the multiline response area.
-     */
-    verifyTextInMultilineResponseAreaSetCorrectAnswerSection: (responseFieldIndex, text) => {
-        fillInTheGapsTextCommonComponent.multilineResponseAreaSetCorrectAnswerSection()
-            .eq(responseFieldIndex)
-            .should('have.text', text);
-    },
+        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.');
+            utilities.verifyElementVisibilityState(commonComponents.errorMessage(), 'visible');
+        });
 
-    /**
-     * Enter text in a multiline response area in the Preview Tab.
-     * @param {number} responseFieldIndex - The index of the response field to enter text in.
-     * @param {string} text - The text to enter in the multiline response area.
-     */
-    enterTextInMultilineResponseAreaPreviewTab: (responseFieldIndex, text) => {
-        fillInTheGapsTextCommonComponent.multilineResponseAreaPreviewTab()
-            .eq(responseFieldIndex)
-            .clear()
-            .type(text);
-    },
+        commonComponents.tests.verifyErrorMessageCSSAndA11y();
 
-    /**
-     * Verify the text in a multiline response area in the Preview Tab.
-     * @param {number} responseFieldIndex - The index of the response field to verify.
-     * @param {string} text - The expected text to be present in the multiline response area.
-     */
-    verifyTextInMultilineResponseAreaPreviewTab: (responseFieldIndex, text) => {
-        fillInTheGapsTextCommonComponent.multilineResponseAreaPreviewTab()
-            .eq(responseFieldIndex)
-            .should('have.text', text);
-    },
+        it('When the user enters value in minimum character limit input field then the error message should disappear', () => {
+            fillInTheGapsTextCommonComponent.steps.setMinimumLimit(0);
+            commonComponents.steps.verifyErrorMessageIsNotDisplayed();
+        });
 
-    verifySpellCheckCheckboxNotChecked: () => {
-        fillInTheGapsTextCommonComponent.spellCheckCheckbox()
-            .should('not.be.checked');
-    },
+        it('When the user clears the maximum character limit input field and focuses out of it, then error message \'Error: Maximum character limit is required.\' should be displayed below the input field', () => {
+            fillInTheGapsTextCommonComponent.steps.clearAndFocusOutOfMaximumCharacterLimitInputField();
+            utilities.verifyInnerText(commonComponents.errorMessage(), 'Error: Maximum character limit is required.');
+            utilities.verifyElementVisibilityState(commonComponents.errorMessage(), 'visible');
+        });
 
-    /**
-     * Verify that the spell check for a response field in the Correct Answer section is disabled.
-     * @param {number} responseFieldIndex - The index of the response field to verify.
-     */
-    verifySpellCheckOfResponseFieldSetCorrectAnswerSectionDisabled: (responseFieldIndex) => {
-        fillInTheGapsTextCommonComponent.responseFieldSetCorrectAnswerSection()
-            .eq(responseFieldIndex)
-            .should('have.attr', 'spellcheck', 'false');
-    },
+        it('When the user enters value in maximum character limit input field then the error message should disappear', () => {
+            fillInTheGapsTextCommonComponent.steps.setMaximumLimit(40);
+            commonComponents.steps.verifyErrorMessageIsNotDisplayed();
+        });
 
-    /**
-     * Verify that the spell check for a response field in the Correct Answer section is enabled.
-     * @param {number} responseFieldIndex - The index of the response field to verify.
-     */
-    verifySpellCheckOfResponseFieldSetCorrectAnswerSectionEnabled: (responseFieldIndex) => {
-        fillInTheGapsTextCommonComponent.responseFieldSetCorrectAnswerSection()
-            .eq(responseFieldIndex)
-            .should('have.attr', 'spellcheck', 'true');
-    },
+        it('When the user sets minimum limit input field value greater than maximum limit input field value then error message \'Error: Minimum limit must be less than or equal to maximum limit.\' and \'Error: Maximum limit must be greater than or equal to minimum limit.\'should be displayed below the minimum and maximum input field respectively', () => {
+            fillInTheGapsTextCommonComponent.steps.setMinimumLimit(45);
+            fillInTheGapsTextCommonComponent.steps.verifyMaximumLimitErrorMessage();
+            fillInTheGapsTextCommonComponent.steps.verifyMinimumLimitErrorMessage();
+        });
 
-    /**
-     * 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.responseFieldPreviewTab()
-            .eq(responseFieldIndex)
-            .should('have.attr', 'spellcheck', 'false');
-    },
+        commonComponents.tests.verifyErrorMessageCSSAndA11y();
 
-    /**
-     * 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.responseFieldPreviewTab()
-            .eq(responseFieldIndex)
-            .should('have.attr', 'spellcheck', 'true');
-    },
+        it('When the user sets minimum limit input field value less than or equal to maximum limit input field value then error message should disappear', () => {
+            fillInTheGapsTextCommonComponent.steps.setMinimumLimit(30);
+            commonComponents.steps.verifyErrorMessageIsNotDisplayed();
+        });
 
-    checkSpellCheckCheckbox: () => {
-        fillInTheGapsTextCommonComponent.spellCheckCheckbox()
-            .click()
-            .should('be.checked');
-    },
+        it('When the user sets maximum limit input field value less than minimum limit input field value then error message \'Error: Minimum limit must be less than or equal to maximum limit.\' and \'Error: Maximum limit must be greater than or equal to minimum limit.\'should be displayed below the minimum and maximum input field respectively', () => {
+            fillInTheGapsTextCommonComponent.steps.setMaximumLimit(26);
+            fillInTheGapsTextCommonComponent.steps.verifyMaximumLimitErrorMessage();
+            fillInTheGapsTextCommonComponent.steps.verifyMinimumLimitErrorMessage();
+        });
 
-    /**
-     * Verify the numeration of response fields in the Preview Tab and Correct Answer section.
-     * @param {string[]} numerationArray - An array of expected numeration strings to verify.
-     */
-    verifyPreviewTabResponseFieldAndCorrectAnswerNumeration: (numerationArray) => {
-        numerationArray.forEach((optionNumeration, index) => {
-            fillInTheGapsTextCommonComponent.previewTabResponseWrapper()
-                .eq(index)
-                .within(() => {
-                    fillInTheGapsTextCommonComponent.responseNumeration()
-                        .should('have.text', optionNumeration);
-                });
-            fillInTheGapsTextCommonComponent.previewTabCorrectAnswerResponseWrapper()
-                .eq(index)
-                .parent()
-                .within(() => {
-                    fillInTheGapsTextCommonComponent.responseNumeration()
-                        .should('have.text', optionNumeration);
-                });
+        it('When the user sets maximum limit input field value greater than or equal to minimum limit input field value then error message should disappear', () => {
+            fillInTheGapsTextCommonComponent.steps.setMaximumLimit(45);
+            commonComponents.steps.verifyErrorMessageIsNotDisplayed();
         });
-    },
 
-    /**
-     * @param {number} responseIndex Index of response field in preview tab
-     * @description Verify response field is displayed in preview tab
-     */
-    verifyResponseFieldIsDisplayedInPreviewTab: (responseIndex) => {
-        utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.responseFieldPreviewTab().eq(responseIndex), 'visible');
-    },
+        it('CSS of \'Set character limit\' sections', { tags: 'css' }, () => {
+            utilities.verifyCSS(fillInTheGapsTextCommonComponent.setLimitLabel(), {
+                'color': css.color.labels,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.semibold
+            });
+            utilities.verifyCSS(fillInTheGapsTextCommonComponent.characterLabel(), {
+                'color': css.color.labelText,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(fillInTheGapsTextCommonComponent.characterLabel(), {
+                'color': css.color.labelText,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(fillInTheGapsTextCommonComponent.noneLabel(), {
+                'color': css.color.labelText,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(fillInTheGapsTextCommonComponent.minimumCharacterLimitLabel(), {
+                'color': css.color.labels,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.semibold
+            });
+            utilities.verifyCSS(fillInTheGapsTextCommonComponent.minimumCharacterLimitLabel(), {
+                'color': css.color.labels,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.semibold
+            });
+            utilities.verifyCSS(fillInTheGapsTextCommonComponent.minimumCharacterLimitInputField(), {
+                'color': css.color.text,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(fillInTheGapsTextCommonComponent.maximumCharacterLimitInputField(), {
+                'color': css.color.text,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(fillInTheGapsTextCommonComponent.characterRadioButton().parent().find('svg'), {
+                'fill': css.color.activeButtons
+            });
+        });
 
-    /**
-     * Verify that the special character button is not visible in a response field in the Correct Answer section.
-     * @param {number} responseFieldIndex - The index of the response field to verify.
-     */
-    verifySpecialCharacterButtonNotVisibleInResponseFieldSetCorrectAnswerSection: (responseFieldIndex) => {
-        specialAndCustomSpecialCharactersComponent.setCorrectAnsResponseFieldSpecialCharactersButton()
-            .eq(responseFieldIndex)
-            .should('not.have.class', 'active-response-input-field')
-            .should('not.be.visible');
-    },
+        it('Accessibility of \'Set limit\' section', { tags: 'a11y' }, () => {
+            cy.checkAccessibility(fillInTheGapsTextCommonComponent.setLimitLabel().parents('[class*="SetLimitWrapper"]'));
+        });
 
-    /**
-     * Focus and verify the special characters button in a response field in the Correct Answer section.
-     * @param {number} responseFieldIndex - The index of the response field to focus and verify.
-     */
-    focusAndVerifySpecialCharactersButtonInResponseFieldSetCorrectAnswerSection: (responseFieldIndex) => {
-        fillInTheGapsTextCommonComponent.responseFieldSetCorrectAnswerSection()
-            .eq(responseFieldIndex)
-            .click();
-        specialAndCustomSpecialCharactersComponent.setCorrectAnsResponseFieldSpecialCharactersButton()
-            .eq(responseFieldIndex)
-            .should('have.class', 'active-response-input-field')
-            .should('be.visible');
-    },
+        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');
+        });
 
-    /**
-     * Verify that the special character button is not visible in a response field in the Preview Tab.
-     * @param {number} responseFieldIndex - The index of the response field to verify.
-     */
-    verifySpecialCharacterButtonNotVisibleInResponseFieldPreviewTab: (responseFieldIndex) => {
-        fillInTheGapsTextCommonComponent.previewTabResponseFieldSpecialCharactersButton()
-            .eq(responseFieldIndex)
-            .should('not.have.class', 'active-response-input-field')
-            .should('not.be.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();
+        });
 
-    /**
-     * Focus and verify the special characters button in a response field in the Preview Tab.
-     * @param {number} responseFieldIndex - The index of the response field to focus and verify.
-     */
-    focusAndVerifySpecialCharactersButtonInResponseFieldPreviewTab: (responseFieldIndex) => {
-        fillInTheGapsTextCommonComponent.responseFieldPreviewTab()
-            .eq(responseFieldIndex)
-            .click();
-        fillInTheGapsTextCommonComponent.previewTabResponseFieldSpecialCharactersButton()
-            .eq(responseFieldIndex)
-            .should('have.class', 'active-response-input-field')
-            .should('be.visible');
-    },
+        it('When user should not be able to add limit more than 50 inside minimum and maximum limit input field', () => {
+            fillInTheGapsTextCommonComponent.steps.setMinimumLimit(60);
+            fillInTheGapsTextCommonComponent.steps.verifyMinimumLimit(6);
+            fillInTheGapsTextCommonComponent.steps.setMaximumLimit(60);
+            fillInTheGapsTextCommonComponent.steps.verifyMaximumLimit(6);
+        });
 
-    /**
-     * Click on the special characters button in a response field in the Preview Tab.
-     * @param {number} responseFieldIndex - The index of the response field to click the button.
-     */
-    clickOnSpecialCharactersButtonPreviewTab: (responseFieldIndex) => {
-        fillInTheGapsTextCommonComponent.previewTabResponseFieldSpecialCharactersButton()
-            .eq(responseFieldIndex)
-            .click();
+        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');
+        });
     },
 
-    /**
-     * Verify the numeration of response fields in the Preview Tab.
-     * @param {string[]} optionNumerationArray - An array of expected numeration strings to verify.
-     */
-    verifyResponseFieldNumeration: (optionNumerationArray) => {
-        optionNumerationArray.forEach((optionNumeration, count) => {
-            fillInTheGapsTextCommonComponent.previewTabResponseWrapper()
-                .eq(count)
-                .should('be.visible')
-                .within(() => {
-                    fillInTheGapsTextCommonComponent.responseNumeration()
-                        .should('have.text', `${optionNumeration}`);
-                });
+    verifySetLimitSectionEditTabFunctionality: () => {
+        it('When maximum character limit input field value is 50 then maximum character limit should be 50 in the specify correct answer section', () => {
+            fillInTheGapsTextCommonComponent.steps.verifyMaximumCharacterLimitInputField(50);
+            fillInTheGapsTextCommonComponent.steps.verifyMaximumCharacterLimit(0, 50);
         });
-    }
-}
 
-const tests = {
-    ...autoScoredSetCorrectAnswerSection.tests,
-    /**
-     * @param {string} tabName Correct or Alternate tab
-     * @description This function verifies the input field and error states of set correct answer section
-     */
-    verifySetCorrectAnswerTabContentsAndFunctionality: (tabName) => {
-        it('An empty points input field and two empty response fields with labels \'Response 1\' and \'Response 2\' should be present', () => {
-            scoringSectionBase.steps.verifyPointsFieldValue('');
-            for (let index = 0; index < 2; index++) {
-                utilities.verifyInnerText(fillInTheGapsTextCommonComponent.responseFieldLabelSetCorrectAnswerSection().eq(index), `Response ${index + 1}`)
-                utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.responseFieldSetCorrectAnswerSection().eq(index), 'visible');
-            };
+        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 enter text in the empty response field', () => {
-            fillInTheGapsTextCommonComponent.steps.enterTextInResponseFieldSetCorrectAnswerSection(0, 'Flower');
-            fillInTheGapsTextCommonComponent.steps.verifyTextInResponseFieldSetCorrectAnswerSection(0, 'Flower');
+        it('User should able to enter characters in the answer input field', () => {
+            fillInTheGapsTextCommonComponent.steps.enterTextInAnswerInputFieldsSpecifyCorrectAnswerSection([{ responseIndex: 0, responseText: 'Flower' }]);
         });
 
-        it(`When the user has only partially filled response fields out of the available response fields, \'Error: Please set a correct answer.\' validation error message should be thrown along with an error icon on the \'${tabName}\'`, () => {
-            fillInTheGapsTextCommonComponent.responseFieldSetCorrectAnswerSection()
-                .eq(1)
-                .focus()
-                .blur();
-            utilities.verifyInnerText(commonComponents.errorMessage(), 'Error: Please set a correct answer.');
-            if (tabName == 'Correct tab') {
-                autoScoredSetCorrectAnswerSection.correctTab()
-                    .within(() => {
-                        utilities.verifyElementVisibilityState(autoScoredSetCorrectAnswerSection.setCorrectAnswerErrorIcon(), 'visible');
-                    });
-            } else {
-                autoScoredSetCorrectAnswerSection.alternateAnswerTab(1)
-                    .within(() => {
-                        utilities.verifyElementVisibilityState(autoScoredSetCorrectAnswerSection.setCorrectAnswerErrorIcon(), 'visible');
-                    });
-            };
+        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.');
         });
 
-        autoScoredSetCorrectAnswerSection.tests.verifyCSSAndA11yOfAutoScoredSetCorrectAnswerErrorMessage();
-
-        it('CSS of response field error state', { tags: 'css' }, () => {
-            utilities.verifyCSS(fillInTheGapsTextCommonComponent.responseFieldWrapperSetCorrectAnswerSection().eq(1), {
-                'background-color': css.color.errorFieldBg
+        it('CSS of error message', { tags: 'css' }, () => {
+            utilities.verifyCSS(fillInTheGapsTextCommonComponent.limitReachedWarningMessage(), {
+                'color': css.color.warningMessage,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.regular
             });
-            utilities.verifyCSS(fillInTheGapsTextCommonComponent.responseFieldWrapperSetCorrectAnswerSection().eq(1).find('fieldset'), {
-                'border': `1px solid ${css.color.errorFieldBorder}`
+            utilities.verifyCSS(fillInTheGapsTextCommonComponent.limitReachedWarningMessageContainer().find('svg'), {
+                'color': css.color.warningMessage,
+            });
+            utilities.verifyCSS(fillInTheGapsTextCommonComponent.limitReachedWarningMessageContainer(), {
+                'border': `1px solid ${css.color.warningContainerBorder}`
+            });
+            utilities.verifyCSS(fillInTheGapsTextCommonComponent.limitReachedWarningMessageContainer(), {
+                'background-color': css.color.warningContainerBackground
             });
         });
 
-        it('Accessibility of response field error state', { tags: 'a11y' }, () => {
-            cy.checkAccessibility(fillInTheGapsTextCommonComponent.responseFieldSetCorrectAnswerSection().parents('.cloze-with-text-response-form-controls-wrapper'));
+        it('Accessibility of error message', { tags: 'a11y' }, () => {
+            cy.checkAccessibility(fillInTheGapsTextCommonComponent.limitReachedWarningMessage());
         });
 
-        it('When the user has added text in all the available response fields, the error message should disappear', () => {
-            fillInTheGapsTextCommonComponent.steps.enterTextInResponseFieldSetCorrectAnswerSection(1, 'Leaf');
-            fillInTheGapsTextCommonComponent.steps.verifyTextInResponseFieldSetCorrectAnswerSection(1, 'Leaf');
-            utilities.verifyElementVisibilityState(commonComponents.errorMessage(), 'notExist');
+        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();
         });
 
-        autoScoredSetCorrectAnswerSection.tests.verifyAutoScoredPointsErrorMessageWhenPointsFieldIsEmpty(tabName);
+        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.');
+        });
 
-        it(`CSS of ${tabName} contents`, { tags: 'css' }, () => {
-            utilities.verifyCSS(fillInTheGapsTextCommonComponent.responseFieldLabelSetCorrectAnswerSection(), {
-                'color': css.color.labels,
-                'font-size': css.fontSize.default,
-                'font-weight': css.fontWeight.regular
-            });
-            utilities.verifyCSS(fillInTheGapsTextCommonComponent.responseFieldSetCorrectAnswerSection(), {
-                'color': css.color.text,
-                'font-size': css.fontSize.default,
-                'font-weight': css.fontWeight.regular
-            });
+        it('When the user enters the character greater than the minimum character limit value set by the user, then the warning message should disappear', () => {
+            fillInTheGapsTextCommonComponent.steps.enterTextInAnswerInputFieldsSpecifyCorrectAnswerSection([{ responseIndex: 0, responseText: 'Airwater' }]);
+            fillInTheGapsTextCommonComponent.steps.verifyTextInResponseAccordionAnswerInputField([{ responseIndex: 0, responseText: 'Airwater' }])
+            fillInTheGapsTextCommonComponent.steps.verifyLimitReachedWarningMessageNotExist();
         });
 
-        it(`Accessibility of ${tabName} contents`, { tags: 'a11y' }, () => {
-            cy.checkAccessibility(fillInTheGapsTextCommonComponent.responseFieldSetCorrectAnswerSection().parents('.cloze-with-text-authoring-mode-response-wrapper'));
+        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', () => {
+            fillInTheGapsTextCommonComponent.steps.selectNoneRadioButton();
+            fillInTheGapsTextCommonComponent.steps.verifyMaximumCharacterLimitNotExistInPreviewTab(0);
+            fillInTheGapsTextCommonComponent.steps.addTextInAnswerInputFieldsPreviewTab(0, 'water');
+            fillInTheGapsTextCommonComponent.steps.verifyLimitReachedWarningMessageNotExist();
         });
     },
 
-    verifyCorrectResponseConditionSectionDefaultState: () => {
-        it('\'Case sensitive\' functionality label and checkbox should be displayed and by default it should be unchecked', () => {
-            utilities.verifyInnerText(fillInTheGapsTextCommonComponent.caseSensitiveLabel(), 'Case sensitive');
-            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.caseSensitiveLabel(), 'visible');
-            fillInTheGapsTextCommonComponent.steps.verifyCaseSensitiveCheckboxNotChecked();
+    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('\'Ignore spaces before and after\' functionality label and checkbox should be displayed and by default it should be checked', () => {
-            utilities.verifyInnerText(fillInTheGapsTextCommonComponent.ignoreSpacesBeforeAndAfterLabel(), 'Ignore spaces before and after');
-            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.ignoreSpacesBeforeAndAfterLabel(), 'visible');
-            fillInTheGapsTextCommonComponent.steps.verifyIgnoreSpacesBeforeAndAfterCheckboxChecked();
+        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('\'Match from all responses\' functionality label and checkbox should be displayed and by default it should be unchecked and disabled', () => {
-            utilities.verifyInnerText(fillInTheGapsTextCommonComponent.matchFromAllResponsesLabel(), 'Match from all responses');
-            fillInTheGapsTextCommonComponent.steps.verifyMatchFromAllResponsesLabelAndCheckboxDisabledState();
+        it('User should able to enter characters in the response field', () => {
+            fillInTheGapsTextCommonComponent.steps.addTextInAnswerInputFieldsPreviewTab(0, 'Flower');
         });
 
-        it('When the user hovers over the \'Match from all responses\' label, \'Feature available for only alternate correct answers\' text should appear on a tooltip, on hovering away from the label, the tooltip should disappear', () => {
-            fillInTheGapsTextCommonComponent.matchFromAllResponsesLabel()
-                .verifyTooltip('Feature available for only alternate correct answers');
+        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.');
         });
 
-        it('CSS of correct response conditions section', { tags: 'css' }, () => {
-            const labels = [fillInTheGapsTextCommonComponent.caseSensitiveLabel, fillInTheGapsTextCommonComponent.ignoreSpacesBeforeAndAfterLabel, fillInTheGapsTextCommonComponent.matchFromAllResponsesLabel]
-            const uncheckedCheckboxes = [fillInTheGapsTextCommonComponent.caseSensitiveCheckbox, fillInTheGapsTextCommonComponent.matchFromAllResponsesCheckbox]
-            labels.forEach((checkingLabel) => {
-                utilities.verifyCSS(checkingLabel(), {
-                    'color': css.color.labelText,
-                    'font-size': css.fontSize.normal,
-                    'font-weight': css.fontWeight.regular
-                });
+        it('CSS of error message', { tags: 'css' }, () => {
+            utilities.verifyCSS(fillInTheGapsTextCommonComponent.limitReachedWarningMessage(), {
+                'color': css.color.warningMessage,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.regular
             });
-            uncheckedCheckboxes.forEach((uncheckedCheckbox) => {
-                utilities.verifyCSS(uncheckedCheckbox().parent().find('svg'), {
-                    'fill': css.color.uncheckedCheckbox
-                });
+            utilities.verifyCSS(fillInTheGapsTextCommonComponent.limitReachedWarningMessageContainer().find('svg'), {
+                'color': css.color.warningMessage,
             });
-            utilities.verifyCSS(fillInTheGapsTextCommonComponent.ignoreSpacesBeforeAndAfterCheckbox().parent().find('svg'), {
-                'fill': css.color.activeButtons
+            utilities.verifyCSS(fillInTheGapsTextCommonComponent.limitReachedWarningMessageContainer(), {
+                'border': `1px solid ${css.color.warningContainerBorder}`
             });
-            cy.log('Checking CSS of match from all responses tooltip')
-            utilities.hoverOverElement(fillInTheGapsTextCommonComponent.matchFromAllResponsesLabel());
-            utilities.verifyElementVisibilityState(commonComponents.tooltipText(), 'visible');
-            utilities.verifyCSS(commonComponents.tooltipText(), {
-                'color': css.color.whiteText,
-                'font-size': css.fontSize.normal,
-                'font-weight': css.fontWeight.regular,
-                'background-color': css.color.tooltipBg
+            utilities.verifyCSS(fillInTheGapsTextCommonComponent.limitReachedWarningMessageContainer(), {
+                'background-color': css.color.warningContainerBackground
             });
-            utilities.verifyElementVisibilityState(commonComponents.tooltipText(), 'notExist');
         });
 
-        it(`Accessibility of correct response conditions section`, { tags: 'a11y' }, () => {
-            cy.checkAccessibility(fillInTheGapsTextCommonComponent.ignoreSpacesBeforeAndAfterCheckbox().parents('.ngie-checkbox-form-group'));
-            cy.log('Checking a11y of match from all responses tooltip')
-            utilities.hoverOverElement(fillInTheGapsTextCommonComponent.matchFromAllResponsesLabel());
-            utilities.verifyElementVisibilityState(commonComponents.tooltipText(), 'visible');
-            cy.checkAccessibility(commonComponents.tooltipText());
-            utilities.verifyElementVisibilityState(commonComponents.tooltipText(), 'notExist');
+        it('Accessibility of error message', { tags: 'a11y' }, () => {
+            cy.checkAccessibility(fillInTheGapsTextCommonComponent.limitReachedWarningMessage());
         });
-    },
 
-    verifyResponseContentsOfSetCorrectAnswerSection: () => {
-        it('Response option contents should be displayed in the set correct answer section', () => {
-            for (let index = 0; index < 2; index++) {
-                utilities.verifyInnerText(fillInTheGapsTextCommonComponent.responseFieldLabelSetCorrectAnswerSection().eq(index), `Response ${index + 1}`)
-                utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.responseFieldSetCorrectAnswerSection().eq(index), 'visible');
-            };
+        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 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.');
+        });
+
+        it('When the user enters the character greater than the minimum character limit value set by the user, then the warning message should disappear', () => {
+            fillInTheGapsTextCommonComponent.steps.addTextInAnswerInputFieldsPreviewTab(0, 'water');
+            fillInTheGapsTextCommonComponent.steps.verifyTextInAnswerInputFieldsPreviewTab([{ responseIndex: 0, responseText: 'Airwater' }])
+            fillInTheGapsTextCommonComponent.steps.verifyLimitReachedWarningMessageNotExist();
         });
-    },
 
-    verifyManualScoringEditTabFunctionality: () => {
-        it('When the user has selected \'Manually scored\' option from the \'Scoring type\' dropdown then the \'Set correct answer\' section should not be displayed; \'All or nothing\', \'Partial - equal weights\' and \'Partial - different weights\' radio buttons should not be displayed; \'Points\' and \'Minimum score awarded (if attempted)\' labels and input fields should be displayed and inside additional settings accordion, Check answer section i.e. \'Allow student to check answer\' checkbox should not be displayed', () => {
-            utilities.verifyElementVisibilityState(autoScoredSetCorrectAnswerSection.setCorrectAnswerLabel(), 'notExist');
-            utilities.verifyElementVisibilityState(autoScoredScoringSectionMultipleResponsesType.allOrNothingCheckbox(), 'notExist');
-            utilities.verifyElementVisibilityState(autoScoredScoringSectionMultipleResponsesType.partialEqualWeightsCheckbox(), 'notExist');
-            utilities.verifyElementVisibilityState(autoScoredScoringSectionMultipleResponsesType.partialDifferentWeightsCheckbox(), 'notExist');
-            utilities.verifyElementVisibilityState(autoScoredScoringSectionMultipleResponsesType.penaltyPointsInputField(), 'notExist');
-            utilities.verifyElementVisibilityState(autoScoredScoringSectionMultipleResponsesType.penaltyPointsLabel(), 'notExist');
-            utilities.verifyElementVisibilityState(autoScoredScoringSectionMultipleResponsesType.rounddownScoreCheckbox(), 'notExist');
-            utilities.verifyElementVisibilityState(autoScoredScoringSectionMultipleResponsesType.rounddownScoreCheckboxLabel(), 'notExist');
-            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.caseSensitiveCheckbox(), 'notExist');
-            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.ignoreSpacesBeforeAndAfterCheckbox(), 'notExist');
-            utilities.verifyElementVisibilityState(fillInTheGapsTextCommonComponent.matchFromAllResponsesCheckbox(), 'notExist');
-            scoringSectionBase.steps.verifyDefaultMinimumScoreIfAttemptedLabelAndPointsField();
-            additionalSettingsPanel.steps.expandAdditonalSettings();
-            utilities.verifyElementVisibilityState(autoScoredAdditionalSettings.checkAnswerLabel(), 'notExist');
-            utilities.verifyElementVisibilityState(autoScoredAdditionalSettings.allowStudentsToCheckAnswerLabel(), 'notExist');
-            utilities.verifyElementVisibilityState(autoScoredAdditionalSettings.allowStudentsToCheckAnswerCheckbox(), 'notExist');
+        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', () => {
+            createQuestionBasePage.steps.switchToEditTab();
+            fillInTheGapsTextCommonComponent.steps.selectNoneRadioButton();
+            createQuestionBasePage.steps.switchToPreviewTab();
+            fillInTheGapsTextCommonComponent.steps.verifyMaximumCharacterLimitNotExistInPreviewTab(0);
+            fillInTheGapsTextCommonComponent.steps.addTextInAnswerInputFieldsPreviewTab(0, 'water');
+            fillInTheGapsTextCommonComponent.steps.verifyLimitReachedWarningMessageNotExist();
         });
     }
 }