itemengine-cypress-automation 1.0.119 → 1.0.121

package/cypress/pages/components/fillInTheGapsDropdownCommonComponent.js

@@ -1,65 +1,66 @@
-import utilities from "../../support/helpers/utilities"
-import { commonComponents } from "./commonComponents"
-import { optionsWrapperComponent } from "./optionsWrapperComponent"
-import { scoringSectionBase } from "./scoringSectionBase"
-import { autoScoredSetCorrectAnswerSection } from "./autoScoredSetCorrectAnswerSection"
-import { autoScoredScoringSectionMultipleResponsesType } from "./autoScoredScoringSectionMultipleResponsesType"
-import { additionalSettingsPanel } from "./additionalSettingsPanel"
-import { autoScoredAdditionalSettings } from "./autoScoredAdditionalSettings"
+import utilities from "../../support/helpers/utilities";
+import { autoScoredScoringSectionMultiResponseType } from "./autoScoredScoringSectionMultiResponseType";
+import { autoScoredSpecifyCorrectAnswerSection } from "./autoScoredSpecifyCorrectAnswerSection";
+import { commonComponents } from "./commonComponents";
+import { optionsWrapperComponent } from "./optionsWrapperComponent";
+import { createQuestionBasePage } from "./createQuestionBasePage";
 const css = Cypress.env('css');
 
-let optionsForResponse = ['changing', 'progressively', 'healthy', 'new'];
-
 const selectors = {
-    ...commonComponents,
-    ...optionsWrapperComponent,
-    ...scoringSectionBase,
-    optionsForResponseContainer: () => cy.get('.edit-mcq-options-wrapper'),
-    optionsForResponseLabel: () => cy.get('.options-label'),
-    responseDropdownOptions: (ariaLabel = null) => {
+    //Dropdown options section
+    dropdownOptionsLabel: () => cy.get('.dropdown-options-label'),
+    dropdownOptionsTab: () => cy.get('.ngie-tablist-tab-button[data-ngie-testid*="dropdown"]'),
+    dropdownOptionsInputField: () => cy.get('.input-editable  input[type*="text"]'),
+    dropdownOptionsInputFieldNumeration: () => cy.get('[class*="MuiInputAdornment"]'),
+
+    //Specify correct answer dropdown
+    dropdownWrapperSpecifyCorrectAnswerSection: () => cy.get('.response-dropdown-wrapper'),
+    dropdownSpecifyCorrectAnswerSection: () => cy.get('.response-dropdown [role="combobox"]'),
+    dropdownLabelSpecifyCorrectAnswerSection: () => cy.get('.response-label'),
+
+    //Dropdown list
+    dropdownList: () => cy.get('.dropdown-list-ul'),
+    dropdownListOptions: (ariaLabel = null) => {
         if (ariaLabel) {
             return cy.get(`[role="listbox"] .dropdown-menu-item[aria-label*="${ariaLabel}"]`)
         } else {
             return cy.get('[role="listbox"] .dropdown-menu-item')
         }
     },
-    responseDropdownOptionText: () => cy.get('[role="listbox"] .dropdown-menu-item .dropdown-label-text'),
-    responseDropdownSetCorrectAnswerSection: () => cy.get('.response-dropdown [role="combobox"]'),
-    responseFieldLabelSetCorrectAnswerSection: () => cy.get('.cloze-with-text-form-control-wrapper .input-field-label'),
-    responseDropdownWrapperSetCorrectAnswerSection: () => cy.get('.response-dropdown-wrapper .dropdown-form-control'),
-    optionsForResponseInputField: () => cy.get('.input-editable  input[type*="text"]'),
-    //TODO: Update class name once https://redmine.zeuslearning.com/issues/518498 is resolved
-    optionIsRequiredErrorMessage: () => cy.get('.Mui-error.Mui-required'),
-    optionNumeration: () => cy.get('.MuiInputAdornment-positionStart'),
-    responseDropdownPlaceholderText: () => cy.get('.cloze-with-dropdown-placeholder'),
-    randomizeOptionsCheckbox: () => cy.get('[data-ngie-testid="randomize-options-checkbox"] input'),
-    matchFromAllResponsesCheckbox: () => cy.get('[data-ngie-testid="match-from-all-responses-checkbox"] input'),
-    randomizeOptionsLabel: () => cy.get('[data-ngie-testid="randomize-options-checkbox"] .MuiFormControlLabel-label'),
-    matchFromAllResponsesLabel: () => cy.get('[data-ngie-testid="match-from-all-responses-checkbox"] .MuiFormControlLabel-label'),
+
+    //Dropdown and Dropdown menu section
+    dropdownLabel: () => cy.get('.single-select-toggle-group-title'),
+    userSpecifiedWidthToggleButton: () => cy.get('[class*="SingleSelectToggleGroupstyles__ButtonContainer"] button').eq(0),
+    AutoScaleToggleButton: () => cy.get('[class*="SingleSelectToggleGroupstyles__ButtonContainer"] button').eq(1),
+    displayMultilineTextCheckbox: () => cy.get('[data-ngie-testid="display-multiline-text-in-dropdown-checkbox"] input'),
+    displayMultilineTextCheckboxLabel: () => cy.get('[data-ngie-testid="display-multiline-text-in-dropdown-checkbox"] [class*="label"]'),
+    dropdownMenuLabel: () => cy.get('[class*="StudentOptionstyles__SubLabel"]'),
+    wordWrapCheckbox: () => cy.get('[data-ngie-testid="word-wrap-for-dropdown-menu-checkbox"] input'),
+    wordWrapCheckboxLabel: () => cy.get('[data-ngie-testid="word-wrap-for-dropdown-menu-checkbox"] [class*="label"]'),
+
+    //Preview tab
+    dropdownWrapperPreviewTab: () => cy.get('[class*="question-preview-wrapper"] .response-dropdown-wrapper'),
+    dropdownPreviewTab: () => cy.get('[class*="question-preview-wrapper"] [aria-haspopup="listbox"]'),
+    dropdownNumerationPreviewTab: () => cy.get('.answer-numeration-number-box'),
+    correctAnswersLabel: () => cy.get('[class*="question-preview-wrapper"] [class*="correct-answer-label"]'),
+    correctAnswerResponseNumeration: () => cy.get('.answer-numeration-number-box'),
+    tickIconWrapper: () => cy.get('.tick-icon-wrapper [data-name*="Rectangle"]'),
 }
 
 const steps = {
-    ...scoringSectionBase.steps,
-    /**
-     * @param {number} responseIndex index of the response token/container
-     * @description Verify that options for response label and its section is displayed for the response token 
-     */
-    verifyOptionsForResponseLabelAndSectionIsDisplayed: (responseIndex) => {
-        utilities.verifyElementVisibilityState(fillInTheGapsDropdownCommonComponent.optionsForResponseContainer().eq(responseIndex), 'visible');
-        utilities.verifyInnerText(fillInTheGapsDropdownCommonComponent.optionsForResponseLabel().eq(responseIndex), `Options for response ${responseIndex + 1}`);
-    },
-
     /**
-     * @param {number} optionsForResponseIndex Index of the options for response section
+     * @param {number} dropdownOptionsTabIndex Index of the dropdown options tab
      * @param {string[]} responseTextArray Array of text to be given as input in options input field
-     * @description Add input to options input fields
+     * @description Add input to dropdown options input fields
      */
-    addInputToResponseOptionFields: (optionsForResponseIndex, responseTextArray) => {
-        fillInTheGapsDropdownCommonComponent.optionsSectionWrapper()
-            .eq(optionsForResponseIndex)
+    addInputToDropdownOptionFields: (dropdownOptionsTabIndex, responseTextArray) => {
+        utilities.getNthElement(fillInTheGapsDropdownCommonComponent.dropdownOptionsTab(), dropdownOptionsTabIndex)
+            .click();
+        fillInTheGapsDropdownCommonComponent.steps.verifyDropdownOptionsTabIsSelected(dropdownOptionsTabIndex);
+        optionsWrapperComponent.optionsSectionWrapper()
             .within(() => {
                 responseTextArray.forEach((responseFieldText, optionIndex) => {
-                    fillInTheGapsDropdownCommonComponent.steps.addInputToResponseOptionInputField(optionIndex, responseFieldText);
+                    fillInTheGapsDropdownCommonComponent.steps.addInputToDropdownOptionInputField(optionIndex, responseFieldText);
                 });
             });
     },
@@ -69,77 +70,199 @@ const steps = {
      * @param {string} responseText text to be given as input in option input field
      * @description Add input to options input fields
      */
-    addInputToResponseOptionInputField: (optionIndex, responseFieldText) => {
-        fillInTheGapsDropdownCommonComponent.optionsForResponseInputField()
-            .eq(optionIndex)
+    addInputToDropdownOptionInputField: (optionIndex, responseFieldText) => {
+        utilities.getNthElement(fillInTheGapsDropdownCommonComponent.dropdownOptionsInputField(), optionIndex)
             .clear()
             .type(responseFieldText, { delay: 0 })
             .should('have.value', responseFieldText);
     },
 
+    /**
+     * @param {number} dropdownOptionsTabIndex Index of the dropdown options tab
+     * @description Navigate to dropdown options tab
+     */
+    navigateToDropdownOptionsTab: (dropdownOptionsTabIndex) => {
+        utilities.getNthElement(fillInTheGapsDropdownCommonComponent.dropdownOptionsTab(), dropdownOptionsTabIndex)
+            .click();
+    },
+
+    /**
+    * @param {number} dropdownOptionsTabIndex Index of the dropdown options tab
+    * @description Verify dropdown options tab is selected
+    */
+    verifyDropdownOptionsTabIsSelected: (dropdownOptionsTabIndex) => {
+        utilities.getNthElement(fillInTheGapsDropdownCommonComponent.dropdownOptionsTab(), dropdownOptionsTabIndex)
+            .should('have.class', 'Mui-selected');
+    },
+
+    /**
+    * @param {number} dropdownOptionsTabIndex Index of the dropdown options tab
+    * @description Verify dropdown options tab is not selected
+    */
+    verifyDropdownOptionsTabIsNotSelected: (dropdownOptionsTabIndex) => {
+        utilities.getNthElement(fillInTheGapsDropdownCommonComponent.dropdownOptionsTab(), dropdownOptionsTabIndex)
+            .should('not.have.class', 'Mui-selected');
+    },
+
+    /**
+    * @param {number} dropdownIndex Index of the dropdown
+    * @param {string} dropdownOption Option to be selected in the dropdown
+    * @description Select option from dropdown in specify correct answer section
+    */
+    selectResponseFromDropdownSpecifyCorrectAnswerSection: (dropdownIndex, dropdownOption) => {
+        fillInTheGapsDropdownCommonComponent.steps.expandDropdownInSpecifyCorrectAnswerSection(dropdownIndex)
+        fillInTheGapsDropdownCommonComponent.steps.selectOptionFromDropdownList(dropdownOption);
+        utilities.verifyInnerText(utilities.getNthElement(fillInTheGapsDropdownCommonComponent.dropdownSpecifyCorrectAnswerSection(), dropdownIndex), dropdownOption);
+    },
+
     /**
      * @param {string} dropdownOption Option to be selected from dropdown
      * @description Select option from dropdown
      */
-    selectOptionFromResponseDropdown: (dropdownOption) => {
-        fillInTheGapsDropdownCommonComponent.responseDropdownOptions(dropdownOption)
+    selectOptionFromDropdownList: (dropdownOption) => {
+        fillInTheGapsDropdownCommonComponent.dropdownListOptions(dropdownOption)
             .click();
-        fillInTheGapsDropdownCommonComponent.dropdownList()
-            .should('not.exist');
+        utilities.verifyElementVisibilityState(commonComponents.dropdownList(), 'notExist');
+    },
+
+    /**
+    * @param {number} dropdownIndex Index of dropdown in specify correct answer section
+    * @description Expand dropdown in specify correct answer section
+    */
+    expandDropdownInSpecifyCorrectAnswerSection: (dropdownIndex) => {
+        utilities.getNthElement(fillInTheGapsDropdownCommonComponent.dropdownSpecifyCorrectAnswerSection(), dropdownIndex)
+            .click({ position: "right" });
+        utilities.getNthElement(fillInTheGapsDropdownCommonComponent.dropdownSpecifyCorrectAnswerSection(), dropdownIndex)
+            .should('have.attr', 'aria-expanded', 'true');
     },
 
     /**
-     * @param {number} dropdownIndex Index of the dropdown
-     * @param {string} dropdownOption Option to be selected in the dropdown
-     * @description Select option from dropdown in set correct answer section
+    * @param {Object[]} CorrectAnswerArray - An array of objects containing the dropdownIndex and dropdownOption to be selected.
+    * @param {number} CorrectAnswerArray[].dropdownIndex - The index of dropdown in preview tab
+    * @param {string} CorrectAnswerArray[].dropdownOption - The dropdown option to be selected from dropdown list
+    * @description Select option from dropdown in preview tab
+    */
+    selectResponseFromDropdownInPreviewTab: (CorrectAnswerArray) => {
+        CorrectAnswerArray.forEach(({ dropdownIndex, dropdownOption }) => {
+            fillInTheGapsDropdownCommonComponent.steps.expandDropdownInPreviewTab(dropdownIndex);
+            fillInTheGapsDropdownCommonComponent.steps.selectOptionFromDropdownList(dropdownOption);
+            fillInTheGapsDropdownCommonComponent.steps.verifyTextDisplayedInDropdownPreviewTab(dropdownIndex, dropdownOption);
+        });
+    },
+
+    /**
+     * @param {number} dropdownIndex Index of dropdown in preview tab
+     * @description Expand dropdown in preview tab
      */
-    selectResponseFromSetCorrectAnswerSectionResponseDropdown: (dropdownIndex, dropdownOption) => {
-        fillInTheGapsDropdownCommonComponent.steps.expandResponseDropdownInSetCorrectAnswerSection(dropdownIndex)
-        fillInTheGapsDropdownCommonComponent.steps.selectOptionFromResponseDropdown(dropdownOption);
-        fillInTheGapsDropdownCommonComponent.responseDropdownSetCorrectAnswerSection()
-            .eq(dropdownIndex)
-            .verifyInnerText(dropdownOption);
+    expandDropdownInPreviewTab: (dropdownIndex) => {
+        utilities.getNthElement(fillInTheGapsDropdownCommonComponent.dropdownPreviewTab(), dropdownIndex)
+            .click();
+        utilities.getNthElement(fillInTheGapsDropdownCommonComponent.dropdownPreviewTab(), dropdownIndex)
+            .should('have.attr', 'aria-expanded', 'true');
+    },
+
+    /**
+     * Verifies if the specified text is displayed in the dropdown preview tab.
+     * @param {number} dropdownIndex - The index of the dropdown.
+     * @param {string} dropdownText - The text expected to be displayed in the dropdown preview tab.
+     */
+    verifyTextDisplayedInDropdownPreviewTab: (dropdownIndex, dropdownText) => {
+        utilities.verifyInnerText(utilities.getNthElement(fillInTheGapsDropdownCommonComponent.dropdownPreviewTab(), dropdownIndex), dropdownText);
+    },
+
+    /**
+     * Verify text displayed in the dropdowns of the preview tab.
+     * @param {Object[]} dropdownTextArray - An array of objects containing the dropdownIndex and dropdownText.
+     * @param {number} dropdownTextArray[].dropdownIndex - The index of the dropdown.
+     * @param {string} dropdownTextArray[].dropdownText - The text to be verified in the respective dropdown.
+     */
+    verifyTextInDropdownsInPreviewTab: (dropdownTextArray) => {
+        dropdownTextArray.forEach(({ dropdownIndex, dropdownText }) => {
+            fillInTheGapsDropdownCommonComponent.steps.verifyTextDisplayedInDropdownPreviewTab(dropdownIndex, dropdownText);
+        });
+    },
+
+    /**
+     * Verify that a specific dropdown is disabled in the preview tab.
+     * @param {number} dropdownIndex - The index of the disabled dropdown.
+     */
+    verifyDropdownIsDisabled: (dropdownIndex) => {
+        utilities.verifyElementDisabledClass(utilities.getNthElement(fillInTheGapsDropdownCommonComponent.dropdownPreviewTab(), dropdownIndex));
+    },
+
+    verifyPointsPerResponseLabel: () => {
+        utilities.verifyInnerText(autoScoredScoringSectionMultiResponseType.pointsPerResponseLabel(), 'Points per response: -');
+        utilities.verifyElementVisibilityState(autoScoredScoringSectionMultiResponseType.pointsPerResponseLabel(), 'visible');
+    },
+
+    /**
+     * @description Verify points per response score displayed for partial equal weights
+     * @param {number} pointsPerResponse points per response score 
+     */
+    verifyPartialEqualWeightsPointsPerResponseScore: (pointsPerResponse) => {
+        utilities.verifyInnerText(autoScoredScoringSectionMultiResponseType.pointsPerResponseLabel(), `Points per response: ${pointsPerResponse}`);
+    },
+
+    /**
+    * @param {number} index of the option input field
+    * @description verify the enter option input field, drag handle, delete button and option numeration
+    */
+    verifyOptionsContents: (index) => {
+        optionsWrapperComponent.optionWrapper()
+            .eq(index)
+            .within(() => {
+                fillInTheGapsDropdownCommonComponent.dropdownOptionsInputField()
+                    .should('have.attr', 'placeholder', 'Enter option');
+                utilities.verifyElementVisibilityState(commonComponents.dragHandleButton(), 'exist');
+                utilities.verifyElementVisibilityState(commonComponents.deleteButton(), 'visible');
+                utilities.verifyTextContent(fillInTheGapsDropdownCommonComponent.dropdownOptionsInputFieldNumeration(), `${index + 1}`);
+            });
+    },
+
+    /**
+     * Verify dropdown is disabled in the specify correct answer section.
+     * @param {number} dropdownIndex - The index of the disabled dropdown.
+     */
+    verifyDisabledDropdownInSpecifyCorrectAnswerSection: (dropdownIndex) => {
+        utilities.verifyElementDisabledClass(utilities.getNthElement(fillInTheGapsDropdownCommonComponent.dropdownSpecifyCorrectAnswerSection(), dropdownIndex));
+    },
+
+    /**
+    * Verify dropdown is disabled in the preview tab.
+    * @param {number} dropdownIndex - The index of the disabled dropdown.
+    */
+    verifyDisabledDropdownInPreviewTab: (dropdownIndex) => {
+        utilities.verifyElementDisabledClass(utilities.getNthElement(fillInTheGapsDropdownCommonComponent.dropdownPreviewTab(), dropdownIndex));
     },
 
     /**
      * @param {string[]} dropdownOptionsArray Array of dropdown options
      * @description Verify the options displayed in dropdown
      */
-    verifyResponseDropdownOptions: (dropdownOptionsArray) => {
+    verifyDropdownOptionsSpecifyCorrectAnswer: (dropdownOptionsArray) => {
         dropdownOptionsArray.forEach((dropdownOption, optionIndex) => {
-            fillInTheGapsDropdownCommonComponent.responseDropdownOptions()
+            fillInTheGapsDropdownCommonComponent.dropdownListOptions()
                 .eq(optionIndex)
                 .should('have.attr', 'data-value', dropdownOption)
-            fillInTheGapsDropdownCommonComponent.responseDropdownOptions()
-                .eq(dropdownOptionsArray.length)
-                .should('not.exist');
         });
+        fillInTheGapsDropdownCommonComponent.dropdownListOptions()
+            .eq(dropdownOptionsArray.length)
+            .should('not.exist');
     },
 
     /**
-     * @param {number} responseTokenIndex Index of the response token 
-     * @description Verify the contents of options for response section displayed for a response token
+     * @param {string[]} dropdownOptionsArray Array of dropdown options
+     * @description Verify the options displayed in dropdown
      */
-    verifyOptionsForResponseContents: (responseTokenIndex) => {
-        fillInTheGapsDropdownCommonComponent.optionsSectionWrapper()
-            .eq(responseTokenIndex)
-            .should('exist')
-            .within(() => {
-                fillInTheGapsDropdownCommonComponent.optionWrapper()
-                    .each(($el, index) => {
-                        cy.wrap($el)
-                            .within(() => {
-                                fillInTheGapsDropdownCommonComponent.optionsForResponseInputField()
-                                    .should('have.attr', 'placeholder', 'Enter option');
-                                commonComponents.dragHandleButton()
-                                    .should('exist');
-                                commonComponents.deleteButton()
-                                    .should('be.visible');
-                                fillInTheGapsDropdownCommonComponent.optionNumeration()
-                                    .should('have.text', index + 1)
-                            });
-                    });
-            });
+    verifyDropdownOptionsPreviewTab: (dropdownOptionsArray) => {
+        dropdownOptionsArray.forEach((dropdownOption, optionIndex) => {
+            fillInTheGapsDropdownCommonComponent.dropdownListOptions()
+                .eq(optionIndex)
+                .should('have.attr', 'data-value', dropdownOption)
+        });
+        fillInTheGapsDropdownCommonComponent.dropdownListOptions()
+            .eq(dropdownOptionsArray.length)
+            .should('not.exist');
     },
 
     /**
@@ -151,7 +274,7 @@ const steps = {
         commonComponents.dropdownList()
             .within(() => {
                 for (let index = 0; index < currentOptions.length; index++) {
-                    fillInTheGapsDropdownCommonComponent.responseDropdownOptions()
+                    fillInTheGapsDropdownCommonComponent.dropdownListOptions()
                         .eq(index)
                         .then(($element) => {
                             expect($element.text()).to.be.oneOf(currentOptions);
@@ -163,9 +286,9 @@ const steps = {
     },
 
     /**
-    * @param {string[]} previousOrderOfOptions Array of options displayed in preview tab
-    * @description Verify that dropdown options are re-randomized in preview tab
-    */
+   * @param {string[]} previousOrderOfOptions Array of dropdown options displayed in preview tab
+   * @description Verify that dropdown options are re-randomized in preview tab
+   */
     verifyRerandomizedOptionsOrder: (previousOrderOfOptions) => {
         commonComponents.dropdownList()
             .should('not.have.text', '')
@@ -174,7 +297,7 @@ const steps = {
 
     getDropdownOptionsArray: () => {
         const dropdownOptionsArray = []
-        fillInTheGapsDropdownCommonComponent.responseDropdownOptions()
+        fillInTheGapsDropdownCommonComponent.dropdownListOptions()
             .each(($el) => {
                 cy.wrap($el)
                     .invoke('text')
@@ -186,310 +309,295 @@ const steps = {
     },
 
     /**
-     * @param {number} responseDropdownIndex Index of response dropdown
-     * @description Verify response dropdown is displayed in set correct answer section
+     * @param {number} dropdownIndex Index of dropdown in specify correct answer section
+     * @description Verify dropdown is collapsed in specify correct answer section
      */
-    verifyResponseDropdownIsDisplayedInSetCorrectAnswerSection: (responseDropdownIndex) => {
-        utilities.verifyElementVisibilityState(fillInTheGapsDropdownCommonComponent.responseDropdownSetCorrectAnswerSection().eq(responseDropdownIndex), 'visible');
+    verifyDropdownIsCollapsedInSpecifyCorrectAnswerSection: (dropdownIndex) => {
+        utilities.getNthElement(fillInTheGapsDropdownCommonComponent.dropdownSpecifyCorrectAnswerSection(), dropdownIndex)
+            .should('have.attr', 'aria-expanded', 'false');
+        utilities.verifyElementVisibilityState(commonComponents.dropdownList(), 'notExist');
     },
 
-    verifyDisabledResponseDropdownInSetCorrectAnswerSection: () => {
-        fillInTheGapsDropdownCommonComponent.responseDropdownSetCorrectAnswerSection()
-            .should('have.class', 'Mui-disabled');
-        fillInTheGapsDropdownCommonComponent.responseDropdownSetCorrectAnswerSection()
+    /**
+    * @param {number} dropdownIndex Index of dropdown in specify correct answer section
+    * @description Expand and collapse dropdown in specify correct answer section
+    */
+    expandAndCollapseDropdownInSpecifyCorrectAnswerSection: (dropdownIndex) => {
+        utilities.getNthElement(fillInTheGapsDropdownCommonComponent.dropdownSpecifyCorrectAnswerSection(), dropdownIndex)
+            .click({ position: "right" });
+        cy.get('body')
             .click();
-        fillInTheGapsDropdownCommonComponent.dropdownList()
-            .should('not.exist');
     },
 
     /**
-     * @param {number} responseDropdownIndex Index of response dropdown in set correct answer section
-     * @description Expand response dropdown in set correct answer section
+     * @param {number} optionIndex index of the option input field 
+     * @description Focus in and focus out of options input field
      */
-    expandResponseDropdownInSetCorrectAnswerSection: (responseDropdownIndex) => {
-        fillInTheGapsDropdownCommonComponent.responseDropdownSetCorrectAnswerSection()
-            .eq(responseDropdownIndex)
-            .click({ position: "right" });
-        fillInTheGapsDropdownCommonComponent.responseDropdownSetCorrectAnswerSection()
-            .eq(responseDropdownIndex)
-            .should('have.attr', 'aria-expanded', 'true');
+    focusInAndFocusOutOfDropdownOptionInputField: (optionIndex) => {
+        utilities.getNthElement(fillInTheGapsDropdownCommonComponent.dropdownOptionsInputField(), optionIndex)
+            .click()
+            .blur();
     },
 
-    verifyOptionsForResponseInputFieldDeleteButtonTooltip: () => {
-        fillInTheGapsDropdownCommonComponent.deleteButton()
-            .eq(1)
-            .verifyTooltip('Delete option');
+    verifyUserSpecifiedToggleButtonIsSelected: () => {
+        fillInTheGapsDropdownCommonComponent.userSpecifiedWidthToggleButton()
+            .should('have.class', 'Mui-selected');
     },
 
-    verifyOptionsForResponseInputFieldDisabledDeleteButtonTooltip: () => {
-        fillInTheGapsDropdownCommonComponent.deleteButton()
-            .eq(1)
-            .trigger('mouseover', { force: true })
-        fillInTheGapsDropdownCommonComponent.tooltipText()
-            .should('have.text', 'Minimum two options are required');
-        fillInTheGapsDropdownCommonComponent.deleteButton()
-            .eq(1)
-            .trigger('mouseout', { force: true });
-        fillInTheGapsDropdownCommonComponent.tooltipText()
-            .should('not.exist');
+    verifyAutoScaleToggleButtonNotSelected: () => {
+        fillInTheGapsDropdownCommonComponent.AutoScaleToggleButton()
+            .should('not.have.class', 'Mui-selected');
     },
 
-    /**
-     * @param {number} index of the option input field
-     * @description this function focuses in and out of options input fields
-     */
-    focusInAndFocusOutOfOptionsForResponseInputField: (index) => {
-        fillInTheGapsDropdownCommonComponent.optionsForResponseInputField()
-            .eq(index)
-            .focus();
-        fillInTheGapsDropdownCommonComponent.optionsForResponseInputField()
-            .eq(index)
-            .blur();
+    verifyAutoScaleToggleButtonIsSelected: () => {
+        fillInTheGapsDropdownCommonComponent.AutoScaleToggleButton()
+            .should('have.class', 'Mui-selected');
     },
 
-    /**
-     * @param {number} index of option input field
-     * @description this function verifies error message of option input field
-     */
-    verifyOptionsForResponseInputFieldErrorMessage: (index) => {
-        fillInTheGapsDropdownCommonComponent.optionWrapper()
-            .eq(index)
-            .within(() => {
-                fillInTheGapsDropdownCommonComponent.optionIsRequiredErrorMessage()
-                    .should('have.text', 'Error: Option is required.');
-            });
+    verifyDisplayMultilineCheckboxIsNotChecked: () => {
+        fillInTheGapsDropdownCommonComponent.displayMultilineTextCheckbox()
+            .should('not.be.checked');
     },
 
-    /**
-    * @param {number} index of option input field
-    * @description this function verifies error message does not exist for option input field
-    */
-    verifyOptionsForResponseInputFieldErrorMessageDoesNotExist: (index) => {
-        fillInTheGapsDropdownCommonComponent.optionWrapper()
-            .eq(index)
-            .within(() => {
-                fillInTheGapsDropdownCommonComponent.optionIsRequiredErrorMessage()
-                    .should('not.exist');
-            });
-    },
-    verifyMatchFromAllResponsesLabelAndCheckboxEnabledState: () => {
-        fillInTheGapsDropdownCommonComponent.matchFromAllResponsesLabel()
-            .should('not.have.class', 'Mui-disabled');
-        fillInTheGapsDropdownCommonComponent.matchFromAllResponsesCheckbox()
-            .and('not.be.disabled');
+    checkDisplayMultilineCheckbox: () => {
+        fillInTheGapsDropdownCommonComponent.displayMultilineTextCheckbox()
+            .click()
+            .should('be.checked');
     },
 
-    checkRandomizeOptionsCheckbox: () => {
-        fillInTheGapsDropdownCommonComponent.randomizeOptionsCheckbox()
-            .click()
+    verifyWordWrapForDropdownMenuCheckboxIsChecked: () => {
+        fillInTheGapsDropdownCommonComponent.wordWrapCheckbox()
             .should('be.checked');
     },
 
-    uncheckRandomizeOptionsCheckbox: () => {
-        fillInTheGapsDropdownCommonComponent.randomizeOptionsCheckbox()
+    uncheckWordWrapForDropdownMenuCheckbox: () => {
+        fillInTheGapsDropdownCommonComponent.wordWrapCheckbox()
             .click()
             .should('not.be.checked');
     },
 
-    checkMatchFromAllResponsesCheckbox: () => {
-        fillInTheGapsDropdownCommonComponent.matchFromAllResponsesCheckbox()
-            .click()
-            .should('be.checked');
+    selectUserSpecifiedWidthToggleButton: () => {
+        fillInTheGapsDropdownCommonComponent.userSpecifiedWidthToggleButton()
+            .click();
     },
 
-    uncheckMatchFromAllResponsesCheckbox: () => {
-        fillInTheGapsDropdownCommonComponent.matchFromAllResponsesCheckbox()
-            .click()
-            .should('not.be.checked');
+    selectAutoScaleToggleButton: () => {
+        fillInTheGapsDropdownCommonComponent.AutoScaleToggleButton()
+            .click();
     },
 
-    verifyRandomizeOptionsCheckboxNotChecked: () => {
-        fillInTheGapsDropdownCommonComponent.randomizeOptionsCheckbox()
-            .should('not.be.checked');
+    compareDropdownMenuAndDropdownWidthForUserSpecifiedWidth: () => {
+        let dropdownWidth
+        utilities.getNthElement(fillInTheGapsDropdownCommonComponent.dropdownSpecifyCorrectAnswerSection(), 0)
+            .then(($originalDropdownWidth) => {
+                dropdownWidth = $originalDropdownWidth.css('width'); //Storing original dropdown width
+            });
+        fillInTheGapsDropdownCommonComponent.steps.expandDropdownInSpecifyCorrectAnswerSection(0);
+        fillInTheGapsDropdownCommonComponent.dropdownList()
+            .then(($dropdownMenuWidth) => {
+                let dropdownMenuWidth = $dropdownMenuWidth.css('max-width');
+                expect(dropdownMenuWidth).to.be.eq(dropdownWidth);  //Comparing dropdown menu and dropdown width
+            });
     },
 
-    verifyMatchFromAllResponsesLabelAndCheckboxDisabledState: () => {
-        fillInTheGapsDropdownCommonComponent.matchFromAllResponsesLabel()
-            .should('have.class', 'Mui-disabled');
-        fillInTheGapsDropdownCommonComponent.matchFromAllResponsesCheckbox()
-            .and('be.disabled');
+    compareDropdownMenuAndDropdownWidthForAutoScaled: () => {
+        let originalDropdownWidth
+        utilities.getNthElement(fillInTheGapsDropdownCommonComponent.dropdownSpecifyCorrectAnswerSection(), 0)
+            .then(($originalDropdownWidth) => {
+                originalDropdownWidth = $originalDropdownWidth.width(); //Storing original dropdown width
+            });
+        fillInTheGapsDropdownCommonComponent.steps.selectAutoScaleToggleButton();
+        fillInTheGapsDropdownCommonComponent.steps.verifyAutoScaleToggleButtonIsSelected();
+        utilities.getNthElement(fillInTheGapsDropdownCommonComponent.dropdownSpecifyCorrectAnswerSection(), 0)
+            .then(($modifiedDropdownWidth) => {
+                let modifiedDropdownWidth = $modifiedDropdownWidth.width(); //Storing auto scaled dropdown width
+                expect(modifiedDropdownWidth).to.be.gt(originalDropdownWidth);
+            });
+        fillInTheGapsDropdownCommonComponent.steps.expandDropdownInSpecifyCorrectAnswerSection(0);
+        fillInTheGapsDropdownCommonComponent.dropdownList()
+            .then(($dropdownMenuWidth) => {
+                let dropdownMenuWidth = $dropdownMenuWidth.width();
+                expect(dropdownMenuWidth).to.be.gt(originalDropdownWidth);  //Comparing auto scaled dropdown menu width and original dropdown width
+            });
     },
 
-    /**
-     * @param {index} responseDropdownIndex Index of response dropdown
-     * @param {string} ariaLabel Aria-label of response dropdown
-     * @description Verify aria-label of response dropdown in set correct answer section
-     */
-    verifyDropdownAriaLabelAttributeInSetCorrectAnswerSection: (responseDropdownIndex, ariaLabel) => {
-        fillInTheGapsDropdownCommonComponent.responseDropdownSetCorrectAnswerSection()
-            .eq(responseDropdownIndex)
-            .should('have.attr', 'aria-label', ariaLabel);
+    verifyDropdownDefaultWidthInSpecifyCorrectAnswer: () => {
+        utilities.verifyCSS(utilities.getNthElement(fillInTheGapsDropdownCommonComponent.dropdownSpecifyCorrectAnswerSection(), 0), {
+            'width': '120px'
+        });
+        fillInTheGapsDropdownCommonComponent.steps.expandDropdownInSpecifyCorrectAnswerSection(0);
+        utilities.verifyCSS(fillInTheGapsDropdownCommonComponent.dropdownList(), {
+            'max-width': '120px'
+        });
+    },
+
+    compareDropdownMenuAndDropdownWidthForUserSpecifiedWidthInPreviewTab: () => {
+        let dropdownWidth
+        utilities.getNthElement(fillInTheGapsDropdownCommonComponent.dropdownPreviewTab(), 0)
+            .then(($originalDropdownWidth) => {
+                dropdownWidth = $originalDropdownWidth.css('width'); //Storing original dropdown width
+            });
+        fillInTheGapsDropdownCommonComponent.steps.expandDropdownInPreviewTab(0);
+        fillInTheGapsDropdownCommonComponent.dropdownList()
+            .parent()
+            .then(($dropdownMenuWidth) => {
+                let dropdownMenuWidth = $dropdownMenuWidth.css('max-width');
+                expect(dropdownMenuWidth).to.be.eq(dropdownWidth);  //Comparing dropdown menu and dropdown width
+            });
+    },
+
+    compareDropdownMenuAndDropdownWidthForAutoScaledInPreviewTab: () => {
+        let originalDropdownWidth
+        utilities.getNthElement(fillInTheGapsDropdownCommonComponent.dropdownPreviewTab(), 0)
+            .then(($originalDropdownWidth) => {
+                originalDropdownWidth = $originalDropdownWidth.width(); //Storing original dropdown width
+            });
+        createQuestionBasePage.steps.switchToEditTab();
+        fillInTheGapsDropdownCommonComponent.steps.selectAutoScaleToggleButton();
+        fillInTheGapsDropdownCommonComponent.steps.verifyAutoScaleToggleButtonIsSelected();
+        createQuestionBasePage.steps.switchToPreviewTab();
+        utilities.getNthElement(fillInTheGapsDropdownCommonComponent.dropdownPreviewTab(), 0)
+            .then(($modifiedDropdownWidth) => {
+                let modifiedDropdownWidth = $modifiedDropdownWidth.width(); //Storing auto scaled dropdown width
+                expect(modifiedDropdownWidth).to.be.gt(originalDropdownWidth);
+            });
+        fillInTheGapsDropdownCommonComponent.steps.expandDropdownInPreviewTab(0);
+        fillInTheGapsDropdownCommonComponent.dropdownList()
+            .then(($dropdownMenuWidth) => {
+                let dropdownMenuWidth = $dropdownMenuWidth.width();
+                expect(dropdownMenuWidth).to.be.gt(originalDropdownWidth);  //Comparing auto scaled dropdown menu width and original dropdown width
+            });
+    },
+
+    verifyDropdownDefaultWidthInPreviewTab: () => {
+        utilities.verifyCSS(utilities.getNthElement(fillInTheGapsDropdownCommonComponent.dropdownPreviewTab(), 0), {
+            'width': '120px'
+        });
+        fillInTheGapsDropdownCommonComponent.steps.expandDropdownInPreviewTab(0);
+        utilities.verifyCSS(fillInTheGapsDropdownCommonComponent.dropdownList(), {
+            'max-width': '120px'
+        });
     },
 
     /**
-     * @param {number} responseDropdownIndex Index of response dropdown
-     * @description Verify placeholder for response dropdown in set correct answer section does not exist
+     * @param {number} dropdownIndex Index of dropdown in specify correct answer section
+     * @description Verify multi-line text is not displayed in dropdown in specify correct answer section
      */
-    verifyPlaceholderAttributeInSetCorrectAnswerSectionResponseDropdownNotExists: (responseDropdownIndex) => {
-        fillInTheGapsDropdownCommonComponent.responseDropdownWrapperSetCorrectAnswerSection()
-            .eq(responseDropdownIndex)
-            .within(() => {
-                utilities.verifyElementVisibilityState(fillInTheGapsDropdownCommonComponent.responseDropdownPlaceholderText(), 'notExist');
-            });
+    verifyMultilineTextNotDisplayedInDropdownSpecifyCorrectAnswerSection: (dropdownIndex) => {
+        utilities.getNthElement(fillInTheGapsDropdownCommonComponent.dropdownWrapperSpecifyCorrectAnswerSection(), dropdownIndex)
+            .should('not.have.class', 'multiline-dropdown-text');
     },
 
     /**
-     * @param {number} responseDropdownIndex Index of response dropdown
-     * @param {string} placeholderText Placeholder for dropdown
-     * @description Verify placeholder text displayed for response dropdown in set correct answer section
+     * @param {number} dropdownIndex Index of dropdown in specify correct answer section
+     * @description Verify multi-line text is displayed in dropdown in specify correct answer section
      */
-    verifyPlaceholderAttributeInSetCorrectAnswerSectionResponseDropdown: (responseDropdownIndex, placeholderText) => {
-        fillInTheGapsDropdownCommonComponent.responseDropdownWrapperSetCorrectAnswerSection()
-            .eq(responseDropdownIndex)
-            .within(() => {
-                utilities.verifyTextContent(fillInTheGapsDropdownCommonComponent.responseDropdownPlaceholderText(), placeholderText);
-            });
+    verifyMultilineTextIsDisplayedInDropdownSpecifyCorrectAnswerSection: (dropdownIndex) => {
+        utilities.getNthElement(fillInTheGapsDropdownCommonComponent.dropdownWrapperSpecifyCorrectAnswerSection(), dropdownIndex)
+            .should('have.class', 'multiline-dropdown-text');
     },
 
     /**
-     * @param {number} responseDropdownIndex Index of response dropdown
-     * @param {number} height Height of response dropdown in set correct answer section
-     * @description Verify height of response dropdown in set correct answer section
+     * @param {number} dropdownIndex Index of dropdown in specify correct answer section
+     * @description Verify multi-line text is not displayed in dropdown in specify correct answer section
      */
-    verifyHeightOfResponseDropdownInSetCorrectAnswerSection: (responseDropdownIndex, height) => {
-        fillInTheGapsDropdownCommonComponent.responseDropdownWrapperSetCorrectAnswerSection()
-            .eq(responseDropdownIndex)
-            .should('have.attr', 'height', `${height}px`);
+    verifyMultilineTextNotDisplayedInDropdownPreviewTab: (dropdownIndex) => {
+        utilities.getNthElement(fillInTheGapsDropdownCommonComponent.dropdownWrapperPreviewTab(), dropdownIndex)
+            .should('not.have.class', 'multiline-dropdown-text');
     },
 
     /**
-     * @param {number} responseDropdownIndex Index of response dropdown
-     * @param {number} width Width of response dropdown in set correct answer section
-     * @description Verify width of response dropdown in set correct answer section
+     * @param {number} dropdownIndex Index of dropdown in specify correct answer section
+     * @description Verify multi-line text is displayed in dropdown in specify correct answer section
      */
-    verifyWidthOfResponseDropdownInSetCorrectAnswerSection: (responseDropdownIndex, width) => {
-        fillInTheGapsDropdownCommonComponent.responseDropdownWrapperSetCorrectAnswerSection()
-            .eq(responseDropdownIndex)
-            .should('have.attr', 'width', `${width}px`);
+    verifyMultilineTextIsDisplayedInDropdownPreviewTab: (dropdownIndex) => {
+        utilities.getNthElement(fillInTheGapsDropdownCommonComponent.dropdownWrapperPreviewTab(), dropdownIndex)
+            .should('have.class', 'multiline-dropdown-text');
     },
-}
 
-const tests = {
-    verifyCorrectResponseConditionSectionDefaultState: () => {
-        it('\'Randomize options\' functionality label and checkbox should be displayed and by default it should be unchecked', () => {
-            utilities.verifyInnerText(fillInTheGapsDropdownCommonComponent.randomizeOptionsLabel(), 'Randomize options');
-            utilities.verifyElementVisibilityState(fillInTheGapsDropdownCommonComponent.randomizeOptionsLabel(), 'visible');
-            fillInTheGapsDropdownCommonComponent.steps.verifyRandomizeOptionsCheckboxNotChecked();
-        });
+    verifyDropdownMenuOptionsWordWrappedSpecifyCorrectAnswerSection: () => {
+        fillInTheGapsDropdownCommonComponent.dropdownList()
+            .should('have.class', 'wordwrap-dropdown-menu');
+    },
 
-        it('\'Match from all responses\' functionality label and checkbox should be displayed and by default it should be unchecked and disabled', () => {
-            utilities.verifyInnerText(fillInTheGapsDropdownCommonComponent.matchFromAllResponsesLabel(), 'Match from all responses');
-            utilities.verifyElementVisibilityState(fillInTheGapsDropdownCommonComponent.matchFromAllResponsesLabel(), 'visible');
-            fillInTheGapsDropdownCommonComponent.steps.verifyMatchFromAllResponsesLabelAndCheckboxDisabledState();
-        });
+    verifyDropdownMenuOptionsNotWordWrappedSpecifyCorrectAnswerSection: () => {
+        fillInTheGapsDropdownCommonComponent.dropdownList()
+            .should('not.have.class', 'wordwrap-dropdown-menu');
+    },
 
-        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', () => {
-            fillInTheGapsDropdownCommonComponent.matchFromAllResponsesLabel()
-                .verifyTooltip('Feature available for only alternate correct answers');
-        });
+    verifyDropdownMenuOptionsWordWrappedPreviewTab: () => {
+        fillInTheGapsDropdownCommonComponent.dropdownList()
+            .should('have.class', 'wordwrap-dropdown-menu');
+    },
 
-        it('CSS of correct response conditions section', { tags: 'css' }, () => {
-            const labels = [fillInTheGapsDropdownCommonComponent.randomizeOptionsLabel, fillInTheGapsDropdownCommonComponent.matchFromAllResponsesLabel]
-            const uncheckedCheckboxes = [fillInTheGapsDropdownCommonComponent.randomizeOptionsCheckbox, fillInTheGapsDropdownCommonComponent.matchFromAllResponsesCheckbox]
-            labels.forEach((checkingLabel) => {
-                utilities.verifyCSS(checkingLabel(), {
-                    'color': css.color.labelText,
-                    'font-size': css.fontSize.normal,
-                    'font-weight': css.fontWeight.regular
-                });
-            });
-            uncheckedCheckboxes.forEach((uncheckedCheckbox) => {
-                utilities.verifyCSS(uncheckedCheckbox().parent().find('svg'), {
-                    'fill': css.color.uncheckedCheckbox
-                });
-            });
-        });
+    verifyDropdownMenuOptionsNotWordWrappedPreviewTab: () => {
+        fillInTheGapsDropdownCommonComponent.dropdownList()
+            .should('not.have.class', 'wordwrap-dropdown-menu');
+    }
+}
 
-        it(`Accessibility of correct response conditions section`, { tags: 'a11y' }, () => {
-            cy.checkAccessibility(fillInTheGapsDropdownCommonComponent.randomizeOptionsLabel().parents('.ngie-checkbox-form-group'));
+const tests = {
+    /**
+    * Verifies the contents and functionality of the 'Specify correct answer' accordion for fill in the gaps over image dropdown question.
+    * @param {{'Correct' | 'Alternative'}} accordionName - The name of the accordion to be used in the validation.
+    * @example - verifySpecifyCorrectAnswerAccordionContentsAndFunctionality('Correct');
+    */
+    verifySpecifyCorrectAnswerAccordionContentsAndFunctionality: (accordionName) => {
+        it(`When user has added a response token in image, then its corresponding dropdown \'Dropdown 1\' should be displayed in the ${accordionName} accordion in collapsed state`, () => {
+            utilities.verifyElementCount(fillInTheGapsDropdownCommonComponent.dropdownSpecifyCorrectAnswerSection(), 1);
+            fillInTheGapsDropdownCommonComponent.steps.verifyDropdownIsCollapsedInSpecifyCorrectAnswerSection(0);
+            utilities.verifyInnerText(utilities.getNthElement(fillInTheGapsDropdownCommonComponent.dropdownLabelSpecifyCorrectAnswerSection(), 0), 'Dropdown 1');
         });
-    },
 
-    /**
-     * @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 dropdowns with labels \'Response 1\' and \'Response 2\' should be present', () => {
-            fillInTheGapsDropdownCommonComponent.steps.verifyPointsFieldValue('');
-            for (let index = 0; index < 2; index++) {
-                utilities.verifyInnerText(fillInTheGapsDropdownCommonComponent.responseFieldLabelSetCorrectAnswerSection().eq(index), `Response ${index + 1}`)
-                utilities.verifyElementVisibilityState(fillInTheGapsDropdownCommonComponent.responseDropdownSetCorrectAnswerSection().eq(index), 'visible');
-            };
+        it('When user expands and collapses the dropdown without selecting any option, \'Error: Please set a correct answer.\' error message should be displayed', () => {
+            fillInTheGapsDropdownCommonComponent.steps.expandAndCollapseDropdownInSpecifyCorrectAnswerSection(0);
+            utilities.verifyElementVisibilityState(commonComponents.errorMessage(), 'visible');
+            utilities.verifyInnerText(commonComponents.errorMessage(), 'Error: Please set a correct answer.');
         });
 
-        it('When the user selects any option from the dropdown, that option should get set as correct answer option and it should get displayed on the dropdown', () => {
-            fillInTheGapsDropdownCommonComponent.steps.selectResponseFromSetCorrectAnswerSectionResponseDropdown(0, optionsForResponse[0]);
-            fillInTheGapsDropdownCommonComponent.steps.selectResponseFromSetCorrectAnswerSectionResponseDropdown(1, optionsForResponse[1]);
+        it('When the user selects any option from the dropdown, then error message should disappear and that option should be displayed on the dropdown', () => {
+            fillInTheGapsDropdownCommonComponent.steps.selectResponseFromDropdownSpecifyCorrectAnswerSection(0, optionsForDropdown[0]);
+            commonComponents.steps.verifyErrorMessageIsNotDisplayed();
         });
 
-        autoScoredSetCorrectAnswerSection.tests.verifyAutoScoredPointsErrorMessageWhenPointsFieldIsEmpty(tabName);
+        autoScoredSpecifyCorrectAnswerSection.tests.verifyAutoScoredPointsErrorMessageWhenPointsFieldIsEmpty(accordionName);
 
-        it(`CSS of ${tabName} contents`, { tags: 'css' }, () => {
-            utilities.verifyCSS(fillInTheGapsDropdownCommonComponent.responseFieldLabelSetCorrectAnswerSection(), {
+        it(`CSS of ${accordionName} accordion contents`, { tags: 'css' }, () => {
+            utilities.verifyCSS(fillInTheGapsDropdownCommonComponent.dropdownLabelSpecifyCorrectAnswerSection(), {
                 'color': css.color.labels,
                 'font-size': css.fontSize.default,
                 'font-weight': css.fontWeight.regular
             });
-            utilities.verifyCSS(fillInTheGapsDropdownCommonComponent.responseDropdownSetCorrectAnswerSection(), {
-                'opacity': '1',
-                'border': `1px solid ${css.color.figDefaultComponentBorder}`,
+            utilities.verifyCSS(fillInTheGapsDropdownCommonComponent.dropdownSpecifyCorrectAnswerSection(), {
+                'background-color': css.color.figActiveComponentBg,
+                'border': `1px solid ${css.color.activeComponentBorder}`
             });
             //CSS of selected dropdown option which appears on dropdown
-            utilities.verifyCSS(fillInTheGapsDropdownCommonComponent.responseDropdownSetCorrectAnswerSection(), {
+            utilities.verifyCSS(fillInTheGapsDropdownCommonComponent.dropdownSpecifyCorrectAnswerSection(), {
                 'color': css.color.liText,
                 'font-size': css.fontSize.default,
                 'font-weight': css.fontWeight.regular
             });
         });
 
-        it(`Accessibility of ${tabName} contents`, { tags: 'a11y' }, () => {
-            cy.checkAccessibility(fillInTheGapsDropdownCommonComponent.responseDropdownSetCorrectAnswerSection().parents('.cloze-with-text-authoring-mode-response-wrapper'));
-        });
-    },
-
-    verifyResponseContentsOfSetCorrectAnswerSection: () => {
-        it('Response dropdown contents should be displayed in the set correct answer section', () => {
-            for (let index = 0; index < 2; index++) {
-                utilities.verifyInnerText(fillInTheGapsDropdownCommonComponent.responseFieldLabelSetCorrectAnswerSection().eq(index), `Response ${index + 1}`)
-                utilities.verifyElementVisibilityState(fillInTheGapsDropdownCommonComponent.responseDropdownSetCorrectAnswerSection().eq(index), 'visible');
-            };
+        it(`Accessibility of ${accordionName} accordion contents`, { tags: 'a11y' }, () => {
+            cy.checkAccessibility(utilities.getNthElement(fillInTheGapsDropdownCommonComponent.dropdownSpecifyCorrectAnswerSection(), 0).parents('[aria-label="Specify correct answer section"]'));
         });
     },
 
-    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(fillInTheGapsDropdownCommonComponent.randomizeOptionsCheckbox(), 'notExist');
-            utilities.verifyElementVisibilityState(fillInTheGapsDropdownCommonComponent.matchFromAllResponsesCheckbox(), 'notExist');
-            scoringSectionBase.steps.verifyDefaultMinimumScoreIfAttemptedLabelAndPointsField();
-            additionalSettingsPanel.steps.expandAdditonalSettings();
-            utilities.verifyElementVisibilityState(autoScoredAdditionalSettings.checkAnswerLabel(), 'notExist');
-            utilities.verifyElementVisibilityState(autoScoredAdditionalSettings.allowStudentsToCheckAnswerLabel(), 'notExist');
-            utilities.verifyElementVisibilityState(autoScoredAdditionalSettings.allowStudentsToCheckAnswerCheckbox(), 'notExist');
+    verifyContentsOfSpecifyCorrectAnswerSection: () => {
+        it('When user selects a scoring type then in the \'Correct\' accordion, all the contents should be displayed', () => {
+            fillInTheGapsDropdownCommonComponent.dropdownSpecifyCorrectAnswerSection()
+                .each(($element, index) => {
+                    utilities.verifyElementVisibilityState(cy.wrap($element), 'visible');
+                    utilities.verifyInnerText(utilities.getNthElement(fillInTheGapsDropdownCommonComponent.dropdownLabelSpecifyCorrectAnswerSection(), index), `Dropdown ${index + 1}`);
+                    utilities.verifyElementVisibilityState(utilities.getNthElement(fillInTheGapsDropdownCommonComponent.dropdownLabelSpecifyCorrectAnswerSection(), index), 'visible');
+                })
         });
     }
 }
 
 export const fillInTheGapsDropdownCommonComponent = {
     ...selectors,
-    steps,
-    tests
+    steps
 }