itemengine-cypress-automation 1.0.78 → 1.0.80

package/cypress/pages/textEntryMathPage.js

@@ -0,0 +1,689 @@
+import { decimalSeparator, evaluationMethods } from "../fixtures/evaluationMethodsAndCustomSettings"
+import utilities from "../support/helpers/utilities"
+import { questionInstructionsComponent, questionInputFieldComponent, createQuestionBasePage, commonComponents, additionalSettingsPanel, autoScoredSpecifyCorrectAnswerSection, scoringSectionBaseEditTab, autoScoredScoringSectionMultiResponseType } from "./components"
+
+const selectors = {
+    ...questionInstructionsComponent,
+    ...questionInputFieldComponent,
+    ...createQuestionBasePage,
+    ...autoScoredScoringSectionMultiResponseType,
+    ...autoScoredSpecifyCorrectAnswerSection,
+
+    addStructureTab: () => cy.get('[data-ngie-testid="add-structure-tab"]'),
+
+    //TODO: Update below selectors after https://redmine.zeuslearning.com/issues/557945 is resolved
+    //Response accordion
+    responseAccordion: () => cy.get('.response-accordion [class*="ResponseAccordionstyles__ResponsePanel"]'),
+    responseAccordionLabel: () => cy.get('[class*="ResponseAccordionstyles__Label"]'),
+    responseAccordionAnswerInputField: () => cy.get('[title*="Enter answer"]'),
+    responseAccordionPointsWrapper: () => cy.get('[class*="ResponseAccordionstyles__PointsDiv"]'),
+    responseAccordionPointsLabel: () => cy.get('[class*="ResponseAccordionstyles__PointsLabel"]'),
+    responseAccordionPointsScore: () => cy.get('[class*="ResponseAccordionstyles__Points-"]'),
+    responseAccordionPointsInputFieldWrapper: () => cy.get('[class*="ResponseEvaluationstyles__PartialPointsWrapper"]'),
+
+    //Evaluation tab
+    evaluationTab: () => cy.get('[data-ngie-testid*="evaluation"][data-ngie-testid*="tab"]'),
+    evaluationTabCloseButton: () => cy.get('.styled-close-button[aria-label*="Evaluation"]'),
+    evaluationContainer: (evaluationMethodTitle = null) => {
+        if (evaluationMethodTitle) {
+            return cy.get(`.evaluation-styled-card[title*="${evaluationMethodTitle}"]`)
+        } else {
+            return cy.get('.evaluation-styled-card')
+        }
+    },
+    evaluationContainerTitle: () => cy.get('.widget-card-text-label'),
+    evaluationContainerContent: () => cy.get('.widget-card-description-label'),
+    addEvaluationButton: () => cy.get('.ngie-tablist-add-tab-button'),
+    answersLabel: () => cy.get('[class*="ResponseEvaluationstyles__AnswersWrapper"] .options-label'),
+    responseAccordionAddAlternateButton: () => cy.get('[class*="ResponseEvaluationstyles__AnswersWrapper"] .add-option-wrapper-cls button'),
+    answerInputFieldWrapper: () => cy.get('.cloze-math-answer-option-input'),
+    answersInputField: () => cy.get('[title*="Enter answer"]'),
+    answersInputFieldDeleteButton: () => cy.get('.option-delete-button-wrapper'),
+    answersInputFieldNumeration: () => cy.get('[class*="SingleOptionstyle__AdornmentDiv"]'),
+
+    //custom settings
+    customSettingsAccordionWrapper: () => cy.get('.custom-settings-option-wrapper .ngie-accordion'),
+    customSettingsLabel: () => cy.get('.custom-settings-accordion-label'),
+    customSettingsChevronButton: () => cy.get('.custom-settings-option-wrapper [class*="MuiAccordionSummary-expandIconWrapper"]'),
+    customSettingsCheckboxContainer: (customSettingCheckboxId = null) => {
+        if (customSettingCheckboxId) {
+            return cy.get(`[class*="CustomSettingsstyles__CheckboxContainer"] label[data-ngie-testid="${customSettingCheckboxId}"]`)
+        } else {
+            return cy.get('[class*="CustomSettingsstyles__CheckboxContainer"] label')
+        }
+    },
+    decimalSeparatorWrapper: () => cy.get('[class*="SingleSelectToggleGroupstyles__ToggleButtonWrapper"]').eq(0),
+    thousandsSeparatorWrapper: () => cy.get('[class*="SingleSelectToggleGroupstyles__ToggleButtonWrapper"]').eq(1),
+    separatorsTitle: () => cy.get('.single-select-toggle-group-title'),
+    separatorsOptionsMenu: () => cy.get('[class*="single-select-toggle-group"][role="group"]'),
+    separatorsOptionsMenuOptions: () => cy.get('[class*="single-select-toggle-group"][role="group"] button'),
+    decimalPlacesToBeComparedLabel: () => cy.get('label[class*="CustomSettingsstyles__TextFieldLabel"]').eq(0),
+    decimalPlacesToBeComparedInputField: () => cy.get('input[id*="dec-places-label"]'),
+    toleranceLabel: () => cy.get('label[class*="CustomSettingsstyles__TextFieldLabel"]').eq(1),
+    toleranceInputField: () => cy.get('input[id*="tolerance-label"]'),
+    typeOfExpressionLabel: () => cy.get('#Type-dropdown-label'),
+    typeOfExpressionDropdown: () => cy.get('#Type-select'),
+    typeOfExpressionDropdownOption: () => cy.get('[aria-labelledby*="Type-dropdown-label"] li'),
+    syntaxLabel: () => cy.get('#Syntax-dropdown-label'),
+    syntaxDropdown: () => cy.get('#Syntax-select'),
+    syntaxDropdownOption: () => cy.get('[aria-labelledby*="Syntax-dropdown-label"] li'),
+
+    //preview tab, TODO: Update selectors once preview is finalized
+    responseFieldPreviewTab: () => cy.get('.cloze-with-text-response-preview-wrapper [role="textbox"]'),
+    questionContainerPreviewTab: () => cy.get('[class*="ClozeWithTextPreviewstyle__QuestionPreviewWrapper"]'),
+
+    //Additional settings
+    textContainersAriaLabelInputField: () => cy.get('[class*="ClozeMathstyle__SingleAriaLabelContainer"]'),
+    textContainersAriaLabelInputFieldNumeration: () => cy.get('[class*="ClozeMathstyle__Numeration"]'),
+}
+
+const steps = {
+    ...questionInputFieldComponent.steps,
+    ...createQuestionBasePage.steps,
+    ...additionalSettingsPanel.steps,
+    ...autoScoredSpecifyCorrectAnswerSection.steps,
+    ...scoringSectionBaseEditTab.steps,
+    ...autoScoredScoringSectionMultiResponseType.steps,
+
+    verifyAddStructureTabIsSelected: () => {
+        textEntryMathPage.addStructureTab()
+            .should('have.attr', 'aria-selected', 'true');
+    },
+
+    /**
+     * @description Verify response accordion is collapsed in specify correct answer section
+     * @param {number} responseIndex index of response accordion
+     */
+    verifyResponseAccordionIsCollapsed: (responseIndex) => {
+        utilities.getNthElement(textEntryMathPage.responseAccordion(), responseIndex)
+            .find('.ngie-accordion-summary')
+            .should('have.attr', 'aria-expanded', 'false');
+    },
+
+    /**
+     * @description Verify response accordion is expanded in specify correct answer section
+     * @param {number} responseIndex index of response accordion
+     */
+    verifyResponseAccordionIsExpanded: (responseIndex) => {
+        utilities.getNthElement(textEntryMathPage.responseAccordion(), responseIndex)
+            .find('.ngie-accordion-summary')
+            .should('have.attr', 'aria-expanded', 'true');
+    },
+
+    /**
+     * @description Verify the Aria label for text container input fields in additional settings accordion
+     * @param {number} countOfInputFields number of Aria label for text container input fields
+     */
+    verifyTextContainerAriaLabelInputFieldCountAndNumeration: (countOfInputFields) => {
+        utilities.verifyElementVisibilityState(textEntryMathPage.textContainersAriaLabelInputField(), 'visible');
+        utilities.verifyElementCount(textEntryMathPage.textContainersAriaLabelInputField(), countOfInputFields);
+        for (let index = 0; index < countOfInputFields; index++) {
+            utilities.verifyTextContent(utilities.getNthElement(textEntryMathPage.textContainersAriaLabelInputFieldNumeration(), index), `${index + 1}`);
+        }
+    },
+
+    /**
+     * @description Expand response accordion in specify correct answer section
+     * @param {number} responseIndex index of response accordion
+     */
+    expandResponseAccordionSpecifyCorrectAnswer: (responseIndex) => {
+        utilities.getNthElement(textEntryMathPage.responseAccordion(), responseIndex)
+            .click();
+        textEntryMathPage.steps.verifyResponseAccordionIsExpanded(responseIndex);
+    },
+
+    /**
+     * @description Collapse response accordion in specify correct answer section
+     * @param {number} responseIndex index of response accordion
+     */
+    collapseResponseAccordionSpecifyCorrectAnswer: (responseIndex) => {
+        utilities.getNthElement(textEntryMathPage.responseAccordion(), responseIndex)
+            .click();
+        textEntryMathPage.steps.verifyResponseAccordionIsCollapsed(responseIndex);
+    },
+
+    /**
+     * Focus in and focus out of response accordion answer input field in specify correct answer section
+     * @param {number} answerFieldIndex answer input field index
+     */
+    focusInAndFocusOutOfResponseAnswerInputFieldSpecifyCorrectAnswer: (answerFieldIndex) => {
+        utilities.getNthElement(textEntryMathPage.responseAccordionAnswerInputField(), answerFieldIndex)
+            .click()
+            .blur();
+    },
+
+    /**
+     * Add input to response accordion answer input field in specify correct answer section
+     * @param {string} input input to be given in answer input field
+     * @param {number} answerFieldIndex answer input field index
+     */
+    addInputToResponseAnswerInputFieldSpecifyCorrectAnswer: (answerFieldIndex, input) => {
+        utilities.getNthElement(textEntryMathPage.responseAccordionAnswerInputField(), answerFieldIndex)
+            .type(`${input}`);
+        utilities.verifyInnerText(utilities.getNthElement(textEntryMathPage.responseAccordionAnswerInputField(), answerFieldIndex), `${input}`);
+    },
+
+    /**
+     * Verify evaluation tab is selected
+     * @param {number} evaluationTabIndex Index of evaluation tab
+     */
+    verifyEvaluationTabActiveState: (evaluationTabIndex) => {
+        utilities.getNthElement(textEntryMathPage.evaluationTab(), evaluationTabIndex)
+            .should('have.attr', 'aria-selected', 'true');
+    },
+
+    /**
+     * Verify evaluation tab is not selected
+     * @param {number} evaluationTabIndex Index of evaluation tab
+     */
+    verifyEvaluationTabInactiveState: (evaluationTabIndex) => {
+        utilities.getNthElement(textEntryMathPage.evaluationTab(), evaluationTabIndex)
+            .should('have.attr', 'aria-selected', 'false');
+    },
+
+    /**
+     * Verify evaluation method is selected
+     * @param {string} evaluationMethodTitle Title of evaluation method
+     */
+    verifyEvaluationMethodActiveState: (evaluationMethodTitle) => {
+        textEntryMathPage.evaluationContainer(evaluationMethodTitle)
+            .should('have.class', 'evaluation-selected-styled-card');
+    },
+
+    /**
+     * Select evaluation method
+     * @param {string} evaluationMethodTitle Title of evaluation method
+     */
+    selectEvaluationMethod: (evaluationMethodTitle) => {
+        textEntryMathPage.evaluationContainer(evaluationMethodTitle)
+            .click();
+        textEntryMathPage.steps.verifyEvaluationMethodActiveState(evaluationMethodTitle);
+    },
+
+    clickOnAddEvaluationButton: () => {
+        textEntryMathPage.addEvaluationButton()
+            .click();
+    },
+
+    /**
+     * Verify close button is displayed in evaluation tab
+     * @param {number} evaluationTabIndex Index of evaluation tab
+     */
+    verifyCloseButtonIsDisplayedInEvaluationTab: (evaluationTabIndex) => {
+        utilities.getNthElement(textEntryMathPage.evaluationTab(), evaluationTabIndex)
+            .within(() => {
+                utilities.verifyElementVisibilityState(textEntryMathPage.evaluationTabCloseButton(), 'visible');
+            });
+    },
+
+    /**
+     * Navigate to evaluation tab
+     * @param {number} evaluationTabIndex Index of evaluation tab
+     */
+    navigateToEvaluationTab: (evaluationTabIndex) => {
+        utilities.getNthElement(textEntryMathPage.evaluationTab(), evaluationTabIndex)
+            .click();
+        textEntryMathPage.steps.verifyEvaluationTabActiveState(evaluationTabIndex);
+    },
+
+    clickOnEvaluationTabCloseButton: () => {
+        textEntryMathPage.evaluationTabCloseButton()
+            .click();
+    },
+
+    verifyAnswerInputFieldNumerationAndDeleteButtonNotExists: () => {
+        textEntryMathPage.answerInputFieldWrapper()
+            .within(() => {
+                utilities.verifyElementVisibilityState(textEntryMathPage.answersInputFieldDeleteButton(), 'notExist');
+                utilities.verifyElementVisibilityState(textEntryMathPage.answersInputFieldNumeration(), 'notExist');
+            });
+    },
+
+    /**
+     * Verify answer input field numeration and delete button is visible
+     * @param {number} answerFieldIndex index of answer input field
+     */
+    verifyAnswerInputFieldNumerationAndDeleteButtonIsVisible: (answerFieldIndex) => {
+        utilities.getNthElement(textEntryMathPage.answerInputFieldWrapper(), answerFieldIndex)
+            .within(() => {
+                utilities.verifyElementVisibilityState(textEntryMathPage.answersInputFieldDeleteButton(), 'visible');
+                utilities.verifyElementVisibilityState(textEntryMathPage.answersInputFieldNumeration(), 'visible');
+                utilities.verifyInnerText(textEntryMathPage.answersInputFieldNumeration(), `${answerFieldIndex + 1}`);
+            });
+    },
+
+    /**
+     * Click on response accordion add alternate button
+     * @param {number} responseAccordionIndex index of response accordion
+     */
+    addAlternateAnswerInResponseAccordion: (responseAccordionIndex) => {
+        utilities.getNthElement(textEntryMathPage.responseAccordionAddAlternateButton(), responseAccordionIndex)
+            .click();
+    },
+
+    /**
+    * Verify answer input field placeholder text
+    * @param {number} answerFieldIndex index of answer input field
+    */
+    verifyAnswerInputFieldPlaceholder: (answerFieldIndex) => {
+        utilities.getNthElement(textEntryMathPage.answerInputFieldWrapper(), answerFieldIndex)
+            .within(() => {
+                textEntryMathPage.answersInputField()
+                    .should('have.attr', 'data-cke-editorplaceholder', `Enter answer ${answerFieldIndex + 1}`);
+            });
+    },
+
+    /**
+     * Add input to answer input field
+     * @param {number} answerFieldIndex index of answer input field
+     * @param {string} answerFieldInput 
+     */
+    addInputToAnswerInputField: (answerFieldIndex, answerFieldInput) => {
+        utilities.getNthElement(textEntryMathPage.answerInputFieldWrapper(), answerFieldIndex)
+            .within(() => {
+                textEntryMathPage.answersInputField()
+                    .type(`${answerFieldInput}`)
+                    .blur();
+                utilities.verifyInnerText(textEntryMathPage.answersInputField(), `${answerFieldInput}`);
+            });
+    },
+
+    /**    
+     * Verify the points score displayed on response accordions
+     * @param {number} responseAccordionIndex index of response accordion
+     * @param {number} pointsPerResponse Points to be displayed on response accordion
+     */
+    verifyPointsDisplayedOnResponseAccordion: (responseAccordionIndex, pointsPerResponse) => {
+        utilities.verifyElementVisibilityState(utilities.getNthElement(textEntryMathPage.responseAccordionPointsLabel(), responseAccordionIndex), 'visible');
+        utilities.verifyInnerText(utilities.getNthElement(textEntryMathPage.responseAccordionPointsLabel(), responseAccordionIndex), 'Points:');
+        utilities.verifyElementVisibilityState(utilities.getNthElement(textEntryMathPage.responseAccordionPointsScore(), responseAccordionIndex), 'visible');
+        utilities.verifyInnerText(utilities.getNthElement(textEntryMathPage.responseAccordionPointsScore(), responseAccordionIndex), `${pointsPerResponse}`);
+    },
+
+    /**
+     * Verify the points input field and label displayed in response accordions
+     * @param {number} responseAccordionIndex index of response accordion
+     * @param {number} pointsInputFieldValue Points input field value
+     */
+    verifyPointsLabelAndInputFieldInResponseAccordion: (responseAccordionIndex, pointsInputFieldValue) => {
+        utilities.getNthElement(textEntryMathPage.responseAccordionPointsInputFieldWrapper(), responseAccordionIndex)
+            .within(() => {
+                utilities.verifyElementVisibilityState(textEntryMathPage.pointsLabel(), 'visible');
+                utilities.verifyInnerText(textEntryMathPage.pointsLabel(), 'Points');
+                utilities.verifyElementVisibilityState(textEntryMathPage.pointsInputField(), 'visible');
+                scoringSectionBaseEditTab.steps.verifyPointsFieldValue(pointsInputFieldValue);
+            });
+    },
+
+    /**
+     * Clear answer input field
+     * @param {number} answerFieldIndex index of answer input field
+     */
+    clearAnswerInputField: (answerFieldIndex) => {
+        utilities.getNthElement(textEntryMathPage.answerInputFieldWrapper(), answerFieldIndex)
+            .within(() => {
+                textEntryMathPage.answersInputField()
+                    .clear()
+                    .blur();
+            });
+    },
+
+    /**
+    * Verify answer input field placeholder text not exists
+    * @param {number} answerFieldIndex index of answer input field
+    */
+    verifyAnswerInputFieldPlaceholderNotExists: (answerFieldIndex) => {
+        utilities.getNthElement(textEntryMathPage.answerInputFieldWrapper(), answerFieldIndex)
+            .within(() => {
+                textEntryMathPage.answersInputField()
+                    .should('have.not.attr', 'data-cke-editorplaceholder');
+            });
+    },
+
+    /**
+    * Click on answer input field delete button
+    * @param {number} answerFieldIndex index of answer input field
+    */
+    clickOnAnswerInputDeleteButton: (answerFieldIndex) => {
+        utilities.getNthElement(textEntryMathPage.answerInputFieldWrapper(), answerFieldIndex)
+            .within(() => {
+                textEntryMathPage.answersInputFieldDeleteButton()
+                    .click();
+            });
+    },
+
+    verifyCustomSettingsAccordionIsCollapsed: () => {
+        textEntryMathPage.customSettingsAccordionWrapper()
+            .should('not.have.class', 'Mui-expanded');
+    },
+
+    verifyCustomSettingsAccordionIsExpanded: () => {
+        textEntryMathPage.customSettingsAccordionWrapper()
+            .should('have.class', 'Mui-expanded');
+    },
+
+    clickOnCustomSettingsAccordion: () => {
+        textEntryMathPage.customSettingsLabel()
+            .click();
+    },
+
+    /**
+     * Verify that custom setting checkbox is unchecked
+     * @param {string} customSetting custom setting id
+     */
+    verifyCustomSettingsCheckboxIsUnchecked: (customSetting) => {
+        textEntryMathPage.customSettingsCheckboxContainer(customSetting)
+            .find('input')
+            .should('not.be.checked');
+    },
+
+    /**
+     * Verify custom setting checkbox label
+     * @param {string} customSettingID custom setting id
+     */
+    verifyCustomSettingsCheckboxLabel: (customSetting, customSettingName) => {
+        utilities.verifyInnerText(textEntryMathPage.customSettingsCheckboxContainer(customSetting).find('[class*="MuiFormControlLabel-label"]'), `${customSettingName}`);
+    },
+
+    verifyDecimalSeparatorsContents: () => {
+        textEntryMathPage.decimalSeparatorWrapper()
+            .within(() => {
+                utilities.verifyElementVisibilityState(textEntryMathPage.separatorsTitle(), 'visible');
+                utilities.verifyInnerText(textEntryMathPage.separatorsTitle(), 'Decimal separator');
+                decimalSeparator.forEach((decimalSeparatorName, index) => {
+                    utilities.verifyInnerText(utilities.getNthElement(textEntryMathPage.separatorsOptionsMenuOptions(), index), `${decimalSeparatorName}`);
+                    utilities.verifyElementVisibilityState(utilities.getNthElement(textEntryMathPage.separatorsOptionsMenuOptions(), index), 'visible');
+                });
+                utilities.verifyElementCount(textEntryMathPage.separatorsOptionsMenuOptions(), decimalSeparator.length);
+            });
+    },
+
+    /**
+     * verify that decimal separator menu option is selected
+    * @param {number} optionIndex index of decimal separator menu option
+     */
+    verifyDecimalSeparatorOptionActive: (optionIndex) => {
+        textEntryMathPage.decimalSeparatorWrapper()
+            .within(() => {
+                utilities.getNthElement(textEntryMathPage.separatorsOptionsMenuOptions(), optionIndex)
+                    .should('have.attr', 'aria-pressed', 'true');
+            });
+    },
+
+    /**
+    * verify that decimal separator menu option is not selected
+    * @param {number} optionIndex index of decimal separator menu option
+    */
+    verifyDecimalSeparatorOptionInactive: (optionIndex) => {
+        textEntryMathPage.decimalSeparatorWrapper()
+            .within(() => {
+                utilities.getNthElement(textEntryMathPage.separatorsOptionsMenuOptions(), optionIndex)
+                    .should('have.attr', 'aria-pressed', 'false');
+            });
+    },
+
+    /**
+    * select decimal separator menu option
+    * @param {number} optionIndex index of decimal separator menu option
+    */
+    selectDecimalSeparatorOption: (optionIndex) => {
+        textEntryMathPage.decimalSeparatorWrapper()
+            .within(() => {
+                utilities.getNthElement(textEntryMathPage.separatorsOptionsMenuOptions(), optionIndex)
+                    .click();
+            });
+    },
+
+    /**
+     * Verify contents on thousands separators
+     * @param {string[]} thousandsSeparatorsOptionArray Array of options in thousands separator
+     */
+    verifyThousandsSeparatorsContents: (thousandsSeparatorsOptionArray) => {
+        textEntryMathPage.thousandsSeparatorWrapper()
+            .within(() => {
+                utilities.verifyElementVisibilityState(textEntryMathPage.separatorsTitle(), 'visible');
+                utilities.verifyInnerText(textEntryMathPage.separatorsTitle(), 'Thousands separator');
+                thousandsSeparatorsOptionArray.forEach((thousandsSeparatorName, index) => {
+                    utilities.verifyInnerText(utilities.getNthElement(textEntryMathPage.separatorsOptionsMenuOptions(), index), `${thousandsSeparatorName}`);
+                    utilities.verifyElementVisibilityState(utilities.getNthElement(textEntryMathPage.separatorsOptionsMenuOptions(), index), 'visible');
+                });
+                utilities.verifyElementCount(textEntryMathPage.separatorsOptionsMenuOptions(), thousandsSeparatorsOptionArray.length);
+            });
+    },
+
+    /**
+     * verify that thousand separator menu option is selected
+    * @param {number} optionIndex index of thousand separator menu option
+     */
+    verifyThousandSeparatorOptionActive: (optionIndex) => {
+        textEntryMathPage.thousandsSeparatorWrapper()
+            .within(() => {
+                utilities.getNthElement(textEntryMathPage.separatorsOptionsMenuOptions(), optionIndex)
+                    .should('have.attr', 'aria-pressed', 'true');
+            });
+    },
+
+    /**
+    * verify that thousand separator menu option is not selected
+    * @param {number} optionIndex index of thousand separator menu option
+    */
+    verifyThousandSeparatorOptionInactive: (optionIndex) => {
+        textEntryMathPage.thousandsSeparatorWrapper()
+            .within(() => {
+                utilities.getNthElement(textEntryMathPage.separatorsOptionsMenuOptions(), optionIndex)
+                    .should('have.attr', 'aria-pressed', 'false');
+            });
+    },
+
+    /**
+    * select thousand separator menu option
+    * @param {number} optionIndex index of thousand separator menu option
+    */
+    selectThousandSeparatorOption: (optionIndex) => {
+        textEntryMathPage.thousandsSeparatorWrapper()
+            .within(() => {
+                utilities.getNthElement(textEntryMathPage.separatorsOptionsMenuOptions(), optionIndex)
+                    .click();
+            });
+    },
+
+    expandTypeOfExpressionDropdown: () => {
+        textEntryMathPage.typeOfExpressionDropdown()
+            .click();
+    },
+
+    verifyDecimalPlacesToBeComparedSectionContents: () => {
+        utilities.verifyElementVisibilityState(textEntryMathPage.decimalPlacesToBeComparedLabel(), 'visible');
+        utilities.verifyInnerText(textEntryMathPage.decimalPlacesToBeComparedLabel(), 'Decimal places to be compared');
+        utilities.verifyElementVisibilityState(textEntryMathPage.decimalPlacesToBeComparedInputField(), 'visible');
+        textEntryMathPage.decimalPlacesToBeComparedInputField()
+            .should('have.attr', 'value', '');
+    },
+
+    verifyToleranceSectionContents: () => {
+        utilities.verifyElementVisibilityState(textEntryMathPage.toleranceLabel(), 'visible');
+        utilities.verifyInnerText(textEntryMathPage.toleranceLabel(), 'Tolerance');
+        utilities.verifyElementVisibilityState(textEntryMathPage.toleranceInputField(), 'visible');
+        textEntryMathPage.toleranceInputField()
+            .should('have.attr', 'value', '');
+    },
+
+    /**
+    * verify type of expression dropdown option is selected
+    * @param {number} optionIndex index of type of expression dropdown option
+    */
+    verifyTypeOfExpressionDropdownListOptionActiveState: (optionIndex) => {
+        utilities.getNthElement(textEntryMathPage.typeOfExpressionDropdownOption(), optionIndex)
+            .should('have.attr', 'aria-selected', 'true');
+    },
+
+    /**
+    * verify type of expression dropdown option is not selected
+    * @param {number} optionIndex index of type of expression dropdown option
+    */
+    verifyTypeOfExpressionDropdownListOptionInactiveState: (optionIndex) => {
+        utilities.getNthElement(textEntryMathPage.typeOfExpressionDropdownOption(), optionIndex)
+            .should('have.attr', 'aria-selected', 'false');
+    },
+
+    /**
+    * select type of expression dropdown option
+    * @param {number} optionIndex index of type of expression dropdown option
+    */
+    selectTypeOfExpressionDropdownListOption: (optionIndex) => {
+        utilities.getNthElement(textEntryMathPage.typeOfExpressionDropdownOption(), optionIndex)
+            .click();
+    },
+
+    verifyTypeOfExpressionDropdownIsCollapsed: () => {
+        textEntryMathPage.typeOfExpressionDropdown()
+            .should('have.attr', 'aria-expanded', 'false');
+    },
+
+    expandSyntaxDropdown: () => {
+        textEntryMathPage.syntaxDropdown()
+            .click();
+    },
+
+    /**
+    * verify syntax dropdown option is selected
+    * @param {number} optionIndex index of syntax dropdown option
+    */
+    verifySyntaxDropdownListOptionActiveState: (optionIndex) => {
+        utilities.getNthElement(textEntryMathPage.syntaxDropdownOption(), optionIndex)
+            .should('have.attr', 'aria-selected', 'true');
+    },
+
+    /**
+    * verify syntax dropdown option is not selected
+    * @param {number} optionIndex index of syntax dropdown option
+    */
+    verifySyntaxDropdownListOptionInactiveState: (optionIndex) => {
+        utilities.getNthElement(textEntryMathPage.syntaxDropdownOption(), optionIndex)
+            .should('have.attr', 'aria-selected', 'false');
+    },
+
+    /**
+   * select syntax dropdown option
+   * @param {number} optionIndex index of syntax dropdown option
+   */
+    selectSyntaxDropdownListOption: (optionIndex) => {
+        utilities.getNthElement(textEntryMathPage.syntaxDropdownOption(), optionIndex)
+            .click();
+    },
+
+    verifySyntaxDropdownIsCollapsed: () => {
+        textEntryMathPage.syntaxDropdown()
+            .should('have.attr', 'aria-expanded', 'false');
+    },
+
+    /**
+    * allot points inside response accordion points input field
+    * @param {number} responseAccordionIndex index of response accordion
+    * @param {number} pointsInputFieldValue Points input field value to be allotted
+    */
+    allotPointsInResponseAccordion: (responseAccordionIndex, pointsInputFieldValue) => {
+        utilities.getNthElement(textEntryMathPage.responseAccordionPointsInputFieldWrapper(), responseAccordionIndex)
+            .within(() => {
+                scoringSectionBaseEditTab.steps.allotPoints(pointsInputFieldValue);
+            });
+    }
+}
+
+const tests = {
+    ...questionInstructionsComponent.tests,
+    ...commonComponents.tests,
+    ...questionInputFieldComponent.tests,
+    ...autoScoredSpecifyCorrectAnswerSection.tests,
+    ...scoringSectionBaseEditTab.tests,
+    ...autoScoredScoringSectionMultiResponseType.tests,
+
+    /**
+     * Verifies the contents and functionality of the 'Specify correct answer' accordion for multiple selection questions.
+     * @param {{'Correct' | 'Alternative'}} accordionName - The name of the accordion to be used in the validation.
+     * @example - verifySpecifyCorrectAnswerAccordionContentsAndFunctionality('Correct');
+     */
+    verifySpecifyCorrectAnswerAccordionContentsAndFunctionality: (accordionName) => {
+        it(`By default, two response accordions \'Response #\' should be displayed in the ${accordionName} accordion in collapsed state`, () => {
+            utilities.verifyElementCount(textEntryMathPage.responseAccordion(), 2);
+            textEntryMathPage.steps.verifyResponseAccordionIsCollapsed(0);
+            textEntryMathPage.steps.verifyResponseAccordionIsCollapsed(1);
+            utilities.verifyInnerText(utilities.getNthElement(textEntryMathPage.responseAccordionLabel(), 0), 'Response 1');
+            utilities.verifyInnerText(utilities.getNthElement(textEntryMathPage.responseAccordionLabel(), 1), 'Response 2');
+        });
+
+        it('When the user clicks on the response accordion, then the response accordion should be expanded', () => {
+            textEntryMathPage.steps.expandResponseAccordionSpecifyCorrectAnswer(0);
+        });
+
+        it('When user focuses in and out of the response accordion \'Answer\' input field, \'Error: Answer is required.\' error message should be displayed', () => {
+            textEntryMathPage.steps.focusInAndFocusOutOfResponseAnswerInputFieldSpecifyCorrectAnswer(0, 0);
+            utilities.verifyElementVisibilityState(commonComponents.errorMessage(), 'visible');
+            utilities.verifyInnerText(commonComponents.errorMessage(), 'Error: Answer is required.');
+        });
+
+        it('When gives an input to \'Answer\' input field,then error message should disappear', () => {
+            textEntryMathPage.steps.addInputToResponseAnswerInputFieldSpecifyCorrectAnswer(0, '(a+b)(a-b)');
+            commonComponents.steps.verifyErrorMessageIsNotDisplayed();
+        });
+
+        it('User should be able to expand multiple response accordions simultaneously', () => {
+            textEntryMathPage.steps.expandResponseAccordionSpecifyCorrectAnswer(1);
+            textEntryMathPage.steps.verifyResponseAccordionIsExpanded(0);
+        });
+
+        it('User should be able to collapse response accordion', () => {
+            textEntryMathPage.steps.collapseResponseAccordionSpecifyCorrectAnswer(1);
+        });
+
+        autoScoredSpecifyCorrectAnswerSection.tests.verifyAutoScoredPointsErrorMessageWhenPointsFieldIsEmpty(accordionName);
+
+        it(`CSS of ${accordionName} accordion contents`, { tags: 'css' }, () => {
+            utilities.verifyCSS(utilities.getNthElement(textEntryMathPage.responseAccordionLabel(), 0), {
+                'color': css.color.text,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.bold
+            });
+        });
+
+        it(`Accessibility of ${accordionName} accordion contents`, { tags: 'a11y' }, () => {
+            cy.checkAccessibility(utilities.getNthElement(textEntryMathPage.responseAccordion(), 0).parents('[aria-label="Specify correct answer section"]'));
+        });
+    },
+
+    verifyContentsOfSpecifyCorrectAnswerSection: () => {
+        it('By default, for the two response token in question input field, two response accordions \'Response 1\' and \'Response 2\' should be present in collapsed state in the \'Specify correct answer section\'', () => {
+            utilities.verifyElementCount(textEntryMathPage.responseAccordion(), 2);
+            textEntryMathPage.steps.verifyResponseAccordionIsCollapsed(0);
+            textEntryMathPage.steps.verifyResponseAccordionIsCollapsed(1);
+            utilities.verifyInnerText(utilities.getNthElement(textEntryMathPage.responseAccordionLabel(), 0), 'Response 1');
+            utilities.verifyInnerText(utilities.getNthElement(textEntryMathPage.responseAccordionLabel(), 1), 'Response 2');
+        });
+    },
+
+    verifyEvaluationTabEvaluationMethodContainers: () => {
+        it('A total of 9 evaluation method blocks should be displayed with their corresponding descriptions in the evaluation tab', () => {
+            utilities.verifyElementCount(textEntryMathPage.evaluationContainer(), 9);
+            evaluationMethods.forEach((evaluationMethod, index) => {
+                utilities.verifyInnerText(utilities.getNthElement(textEntryMathPage.evaluationContainerTitle(), index), `${evaluationMethod.name}`);
+                utilities.verifyElementVisibilityState(utilities.getNthElement(textEntryMathPage.evaluationContainerTitle(), index), 'visible');
+                utilities.verifyInnerText(utilities.getNthElement(textEntryMathPage.evaluationContainerContent(), index), `${evaluationMethod.description}`);
+                utilities.verifyElementVisibilityState(utilities.getNthElement(textEntryMathPage.evaluationContainerContent(), index), 'visible');
+            });
+        });
+
+        it('By default \'Value is equivalent\' evaluation method should be in active state', () => {
+            textEntryMathPage.steps.verifyEvaluationMethodActiveState(evaluationMethods[1].name);
+        });
+
+        it('User should be able to select a different evaluation method', () => {
+            textEntryMathPage.steps.selectEvaluationMethod(evaluationMethods[3].name);
+        });
+    }
+}
+
+export const textEntryMathPage = {
+    ...selectors,
+    steps,
+    tests
+}