itemengine-cypress-automation 1.0.86 → 1.0.88

package/cypress/e2e/ILC/TextEntryMath/responseEvaluationMethodsAndCustomSettings.js

@@ -0,0 +1,613 @@
+import { textEntryMathPage } from "../../../pages";
+import { customSettingsIds, evaluationMethods, syntaxDropdown, thousandsSeparatorForCommaDecimalSeparator, thousandsSeparatorForDotDecimalSeparator, typeOfExpression } from "../../../fixtures/evaluationMethodsAndCustomSettings";
+import utilities from "../../../support/helpers/utilities";
+import abortEarlySetup from "../../../support/helpers/abortEarly";
+import { commonComponents } from "../../../pages/components";
+const css = Cypress.env('css');
+
+describe('Create Item page - Text entry math: Response evaluation methods and custom settings', () => {
+    before(() => {
+        cy.loginAs('admin');
+    });
+
+    describe('Evaluation method blocks - Contents', () => {
+        abortEarlySetup();
+        before(() => {
+            textEntryMathPage.steps.navigateToCreateQuestion('Text Entry Math');
+            cy.barsPreLoaderWait();
+            textEntryMathPage.steps.deleteAResponseToken(1);
+            textEntryMathPage.steps.expandResponseAccordionSpecifyCorrectAnswer(0);
+        });
+
+        textEntryMathPage.tests.verifyEvaluationTabEvaluationMethodContainers();
+
+        it('CSS of evaluation method blocks', { tags: 'css' }, () => {
+            utilities.verifyCSS(utilities.getNthElement(textEntryMathPage.evaluationContainerTitle(), 0), {
+                'color': css.color.unSelectedEvaluationMethodTitle,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.semibold
+            });
+            utilities.verifyCSS(utilities.getNthElement(textEntryMathPage.evaluationContainerContent(), 0), {
+                'color': css.color.text,
+                'font-size': css.fontSize.small,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(utilities.getNthElement(textEntryMathPage.evaluationContainer(), 0), {
+                'background-color': css.color.defaultBackground,
+                'border': `1px solid ${css.color.evaluationMethodContainerBorder}`
+            });
+            utilities.verifyCSS(utilities.getNthElement(textEntryMathPage.evaluationContainerTitle(), 3), {
+                'color': css.color.whiteText,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.semibold
+            });
+            utilities.verifyCSS(utilities.getNthElement(textEntryMathPage.evaluationContainerContent(), 3), {
+                'color': css.color.whiteText,
+                'font-size': css.fontSize.small,
+                'font-weight': css.fontWeight.regular
+            });
+            utilities.verifyCSS(utilities.getNthElement(textEntryMathPage.evaluationContainer(), 3), {
+                'background-color': css.color.selectedEvaluationMethodContainerBg,
+                'border': `1px solid ${css.color.evaluationMethodContainerBorder}`
+            });
+        });
+    });
+
+    describe('Evaluation method blocks - Add and delete evaluation method tabs', () => {
+        abortEarlySetup();
+        before(() => {
+            textEntryMathPage.steps.navigateToCreateQuestion('Text Entry Math');
+            cy.barsPreLoaderWait();
+            textEntryMathPage.steps.deleteAResponseToken(1);
+            textEntryMathPage.steps.expandResponseAccordionSpecifyCorrectAnswer(0);
+        });
+
+        it('In response 1 accordion, only one evaluation tab i.e. \'Evaluation 1\' should be in active state and should be displayed without a close button', () => {
+            utilities.verifyInnerText(textEntryMathPage.evaluationTab(), 'Evaluation 1');
+            utilities.verifyElementVisibilityState(textEntryMathPage.evaluationTab(), 'visible');
+            utilities.verifyElementCount(textEntryMathPage.evaluationTab(), 1);
+            textEntryMathPage.steps.verifyEvaluationTabActiveState(0);
+        });
+
+        it('Add evaluation button should be displayed in the response accordion in specify correct answer section', () => {
+            utilities.verifyElementVisibilityState(textEntryMathPage.addEvaluationButton(), 'visible');
+            utilities.verifyInnerText(textEntryMathPage.addEvaluationButton(), 'Add evaluation');
+        });
+
+        it('When user clicks on \'Add evaluation\' button, then a tab \'Evaluation 2\' should be added in the response accordion', () => {
+            textEntryMathPage.steps.clickOnAddEvaluationButton();
+            utilities.verifyInnerText(utilities.getNthElement(textEntryMathPage.evaluationTab(), 1), 'Evaluation 2');
+            utilities.verifyElementCount(textEntryMathPage.evaluationTab(), 2);
+            utilities.verifyElementVisibilityState(utilities.getNthElement(textEntryMathPage.evaluationTab(), 1), 'visible');
+        });
+
+        it('When user has added a new evaluation tab \'Evaluation 2\', then the newly added evaluation tab should be displayed in active state with a close button and Evaluation 1 tab should be in inactive state', () => {
+            textEntryMathPage.steps.verifyEvaluationTabActiveState(1);
+            textEntryMathPage.steps.verifyEvaluationTabInactiveState(0);
+            textEntryMathPage.steps.verifyCloseButtonIsDisplayedInEvaluationTab(1);
+        });
+
+        textEntryMathPage.tests.verifyEvaluationTabEvaluationMethodContainers();
+
+        it('User should be able to add another evaluation method for the response using \'Add evaluation\' button and the name for this new evaluation tab should be \'Evaluation 3\'', () => {
+            textEntryMathPage.steps.clickOnAddEvaluationButton();
+            utilities.verifyInnerText(utilities.getNthElement(textEntryMathPage.evaluationTab(), 2), 'Evaluation 3');
+            utilities.verifyElementCount(textEntryMathPage.evaluationTab(), 3);
+        });
+
+        it('When user clicks on the Evaluation 2 tab close button, then evaluation 2 tab should be removed and the numeration of remaining evaluation tabs should be updated', () => {
+            textEntryMathPage.steps.navigateToEvaluationTab(1);
+            textEntryMathPage.steps.clickOnEvaluationTabCloseButton();
+            utilities.verifyElementCount(textEntryMathPage.evaluationTab(), 2);
+            utilities.verifyInnerText(utilities.getNthElement(textEntryMathPage.evaluationTab(), 0), 'Evaluation 1');
+            utilities.verifyInnerText(utilities.getNthElement(textEntryMathPage.evaluationTab(), 1), 'Evaluation 2');
+        });
+
+        it('When user selects a new evaluation method in \'Evaluation 2\' tab and switches to \'Evaluation 1\' tab then in \'Evaluation 1\' tab the previously selected evaluation method should persist', () => {
+            textEntryMathPage.steps.navigateToEvaluationTab(1);
+            textEntryMathPage.steps.selectEvaluationMethod(evaluationMethods[4].name);
+            textEntryMathPage.steps.navigateToEvaluationTab(0);
+            textEntryMathPage.steps.verifyEvaluationMethodActiveState(evaluationMethods[1].name);
+        });
+
+        it('CSS of evaluation tabs', { tags: 'css' }, () => {
+            cy.log('Pre-step: Navigate to evaluation tab 2');
+            textEntryMathPage.steps.navigateToEvaluationTab(1);
+            utilities.verifyCSS(utilities.getNthElement(textEntryMathPage.evaluationTab(), 1), {
+                'color': css.color.activeButtons,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.bold,
+            });
+            utilities.verifyCSS(utilities.getNthElement(textEntryMathPage.evaluationTab(), 1).parent().find('[class*="MuiTabs-indicator"]'), {
+                'background-color': css.color.activeComponentBorder
+            });
+            utilities.verifyCSS(textEntryMathPage.evaluationTabCloseButton().find('svg'), {
+                'fill': css.color.activeButtons
+            });
+            utilities.verifyCSS(utilities.getNthElement(textEntryMathPage.evaluationTab(), 0), {
+                'color': css.color.labels,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.bold,
+            });
+            utilities.verifyCSS(textEntryMathPage.addEvaluationButton(), {
+                'color': css.color.activeButtons,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.medium,
+            });
+            textEntryMathPage.addEvaluationButton()
+                .verifyPseudoClassBeforeProperty('color', css.color.activeButtons);
+        });
+
+        it('Accessibility of evaluation tabs', { tags: 'a11y' }, () => {
+            cy.checkAccessibility(textEntryMathPage.responseAccordion());
+        });
+    });
+
+    describe('Evaluation methods - Answer input field and \'Add alternate\' button', () => {
+        abortEarlySetup();
+        before(() => {
+            textEntryMathPage.steps.navigateToCreateQuestion('Text Entry Math');
+            cy.barsPreLoaderWait();
+            textEntryMathPage.steps.deleteAResponseToken(1);
+            textEntryMathPage.steps.expandResponseAccordionSpecifyCorrectAnswer(0);
+        });
+
+        it('In response accordion \'Answers\' label and one empty answer input field should be displayed', () => {
+            utilities.verifyInnerText(textEntryMathPage.answersLabel(), 'Answers');
+            utilities.verifyElementVisibilityState(textEntryMathPage.answersLabel(), 'visible');
+            utilities.verifyInnerText(textEntryMathPage.answersInputField(), '\n');
+            utilities.verifyElementVisibilityState(textEntryMathPage.answersInputField(), 'visible');
+            utilities.verifyElementCount(textEntryMathPage.answersInputField(), 1);
+        });
+
+        it('When there is a single answer input field, then input field numeration and its delete button should not be displayed', () => {
+            textEntryMathPage.steps.verifyAnswerInputFieldNumerationAndDeleteButtonNotExists();
+        });
+
+        it('\'Add alternate\' button should be displayed', () => {
+            utilities.verifyElementVisibilityState(textEntryMathPage.responseAccordionAddAlternateButton(), 'visible');
+            utilities.verifyElementVisibilityState(textEntryMathPage.responseAccordionAddAlternateButton(), 'Add alternate');
+        });
+
+        it('When single answer input field is present in blank state and user clicks on \'Add alternate\' button, then error message \'Error: Answer is required.\' should be displayed and new answer field should not be added', () => {
+            textEntryMathPage.steps.addAlternateAnswerInResponseAccordion(0);
+            utilities.verifyInnerText(commonComponents.errorMessage(), 'Error: Answer is required.');
+            utilities.verifyElementVisibilityState(commonComponents.errorMessage(), 'visible');
+            utilities.verifyElementCount(textEntryMathPage.answersInputField(), 1);
+        });
+
+        it('When user gives an input to \'Answer\' input field,then error message should disappear', () => {
+            textEntryMathPage.steps.addInputToResponseAnswerInputFieldSpecifyCorrectAnswer(0, '(a+b)(a-b)');
+            commonComponents.steps.verifyErrorMessageIsNotDisplayed();
+        });
+
+        it('When user clicks on \'Add alternate\' button, then one more answer input field should be displayed', () => {
+            textEntryMathPage.steps.addAlternateAnswerInResponseAccordion(0);
+            utilities.verifyElementCount(textEntryMathPage.answersInputField(), 2);
+        });
+
+        it('When more than one answer input fields are present, then answer field numeration and input field delete buttons should be displayed for both input fields', () => {
+            textEntryMathPage.steps.verifyAnswerInputFieldNumerationAndDeleteButtonIsVisible(0);
+            textEntryMathPage.steps.verifyAnswerInputFieldNumerationAndDeleteButtonIsVisible(1);
+        });
+
+        it('When no input is provided in answer input field, then placeholder text \'Enter text #\' should be displayed in the answer input field', () => {
+            textEntryMathPage.steps.verifyAnswerInputFieldPlaceholder(0);
+        });
+
+        it('When input is provided in answer input field, then placeholder text should not be displayed in the answer input field', () => {
+            textEntryMathPage.steps.addInputToAnswerInputField(0, '(a+b)*2');
+            textEntryMathPage.steps.verifyAnswerInputFieldPlaceholderNotExists(0);
+        });
+
+        it('CSS of answer input field', { tags: 'css' }, () => {
+            utilities.verifyCSS(textEntryMathPage.answersLabel(), {
+                'color': css.color.labels,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.semibold,
+            });
+            utilities.verifyCSS(utilities.getNthElement(textEntryMathPage.answersInputField(), 1), {
+                'color': css.color.text,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular,
+            });
+            utilities.verifyCSS(utilities.getNthElement(textEntryMathPage.answersInputFieldNumeration(), 1), {
+                'color': css.color.labels,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.semibold,
+            });
+            utilities.getNthElement(textEntryMathPage.answersInputFieldDeleteButton(), 1)
+                .find('button')
+                .verifyPseudoClassBeforeProperty('color', css.color.deleteIcon);
+        });
+
+        //Accessibility covered in previous describes
+
+        it('When provided input is cleared from answer input field, then placeholder text should be displayed again in the answer input field', () => {
+            textEntryMathPage.steps.clearAnswerInputField(0);
+            textEntryMathPage.steps.verifyAnswerInputFieldPlaceholder(0);
+        });
+
+        it('When user clicks on answer input field delete button, then the respective answer field should be deleted and the numeration of remaining answer input fields should be updated accordingly', () => {
+            cy.log('Pre-step: Add one more answer input field');
+            textEntryMathPage.steps.addAlternateAnswerInResponseAccordion(0);
+            textEntryMathPage.steps.clickOnAnswerInputDeleteButton(0);
+            utilities.verifyElementCount(textEntryMathPage.answersInputField(), 2);
+            textEntryMathPage.steps.verifyAnswerInputFieldNumerationAndDeleteButtonIsVisible(0);
+            textEntryMathPage.steps.verifyAnswerInputFieldNumerationAndDeleteButtonIsVisible(1);
+        });
+
+        it('When number of answer input fields is reduced to 1, then input field numeration and its delete button should not be displayed', () => {
+            cy.log('Pre-step: Reduce number of answer input fields to 1');
+            textEntryMathPage.steps.clickOnAnswerInputDeleteButton(0);
+            utilities.verifyElementCount(textEntryMathPage.answersInputField(), 1);
+            textEntryMathPage.steps.verifyAnswerInputFieldNumerationAndDeleteButtonNotExists();
+        });
+    });
+
+    describe('Evaluation methods - Custom settings for each evaluation method', () => {
+        abortEarlySetup();
+        before(() => {
+            textEntryMathPage.steps.navigateToCreateQuestion('Text Entry Math');
+            cy.barsPreLoaderWait();
+            textEntryMathPage.steps.deleteAResponseToken(1);
+            textEntryMathPage.steps.expandResponseAccordionSpecifyCorrectAnswer(0);
+        });
+
+        it('By default for the custom settings accordion should be in collapsed state', () => {
+            textEntryMathPage.steps.verifyCustomSettingsAccordionIsCollapsed();
+        });
+
+        evaluationMethods.forEach((evaluationMethod) => {
+            it(`When user clicks on the custom settings accordion for ${evaluationMethod.name}, then the custom settings accordion should be expanded`, () => {
+                cy.log(`Pre-step: Selecting ${evaluationMethod.name} evaluation method`);
+                textEntryMathPage.steps.selectEvaluationMethod(evaluationMethod.name);
+                textEntryMathPage.steps.clickOnCustomSettingsAccordion();
+                textEntryMathPage.steps.verifyCustomSettingsAccordionIsExpanded();
+            });
+
+            it(`For ${evaluationMethod.name} evaluation method, the following custom settings should be displayed - ${evaluationMethod.customSettings.join(', ')}`, () => {
+                if (evaluationMethod.answerInputField === 'true') {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.answerInputFieldWrapper(), 'visible');
+                } else {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.answerInputFieldWrapper(), 'notExist');
+                }
+                if (evaluationMethod.customSettings.includes('Case sensitive')) {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.customSettingsCheckboxContainer(customSettingsIds.caseSensitive), 'visible');
+                    textEntryMathPage.steps.verifyCustomSettingsCheckboxIsUnchecked(customSettingsIds.caseSensitive);
+                    textEntryMathPage.steps.verifyCustomSettingsCheckboxLabel(customSettingsIds.caseSensitive, 'Case sensitive');
+                } else {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.customSettingsCheckboxContainer(customSettingsIds.caseSensitive), 'notExist');
+                }
+                if (evaluationMethod.customSettings.includes('Accept interval notation')) {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.customSettingsCheckboxContainer(customSettingsIds.acceptIntervalNotation), 'visible');
+                    textEntryMathPage.steps.verifyCustomSettingsCheckboxIsUnchecked(customSettingsIds.acceptIntervalNotation);
+                    textEntryMathPage.steps.verifyCustomSettingsCheckboxLabel(customSettingsIds.acceptIntervalNotation, 'Accept interval notation');
+                } else {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.customSettingsCheckboxContainer(customSettingsIds.acceptIntervalNotation), 'notExist');
+                }
+                if (evaluationMethod.customSettings.includes('Exclude LaTeX text from validation')) {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.customSettingsCheckboxContainer(customSettingsIds.excludeLatexTextFromValidation), 'visible');
+                    textEntryMathPage.steps.verifyCustomSettingsCheckboxIsUnchecked(customSettingsIds.excludeLatexTextFromValidation);
+                    textEntryMathPage.steps.verifyCustomSettingsCheckboxLabel(customSettingsIds.excludeLatexTextFromValidation, 'Exclude LaTeX text from validation');
+                } else {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.customSettingsCheckboxContainer(customSettingsIds.excludeLatexTextFromValidation), 'notExist');
+                }
+                if (evaluationMethod.customSettings.includes('Check for equality across sides')) {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.customSettingsCheckboxContainer(customSettingsIds.checkForEqualityAcrossSides), 'visible');
+                    textEntryMathPage.steps.verifyCustomSettingsCheckboxIsUnchecked(customSettingsIds.checkForEqualityAcrossSides);
+                    textEntryMathPage.steps.verifyCustomSettingsCheckboxLabel(customSettingsIds.checkForEqualityAcrossSides, 'Check for equality across sides');
+                } else {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.customSettingsCheckboxContainer(customSettingsIds.checkForEqualityAcrossSides), 'notExist');
+                }
+                if (evaluationMethod.customSettings.includes('Interpret alphabets as variables')) {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.customSettingsCheckboxContainer(customSettingsIds.interpretAlphabetsAsVariables), 'visible');
+                    textEntryMathPage.steps.verifyCustomSettingsCheckboxIsUnchecked(customSettingsIds.interpretAlphabetsAsVariables);
+                    textEntryMathPage.steps.verifyCustomSettingsCheckboxLabel(customSettingsIds.interpretAlphabetsAsVariables, 'Interpret alphabets as variables');
+                } else {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.customSettingsCheckboxContainer(customSettingsIds.interpretAlphabetsAsVariables), 'notExist');
+                }
+                if (evaluationMethod.customSettings.includes('Interpret e as Euler\'s number')) {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.customSettingsCheckboxContainer(customSettingsIds.interpretEAsEulerNumber), 'visible');
+                    textEntryMathPage.steps.verifyCustomSettingsCheckboxIsUnchecked(customSettingsIds.interpretEAsEulerNumber);
+                    textEntryMathPage.steps.verifyCustomSettingsCheckboxLabel(customSettingsIds.interpretEAsEulerNumber, 'Interpret e as Euler\'s number');
+                } else {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.customSettingsCheckboxContainer(customSettingsIds.interpretEAsEulerNumber), 'notExist');
+                }
+                if (evaluationMethod.customSettings.includes('Interpret i as imaginary')) {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.customSettingsCheckboxContainer(customSettingsIds.interpretIAsImaginary), 'visible');
+                    textEntryMathPage.steps.verifyCustomSettingsCheckboxIsUnchecked(customSettingsIds.interpretIAsImaginary);
+                    textEntryMathPage.steps.verifyCustomSettingsCheckboxLabel(customSettingsIds.interpretIAsImaginary, 'Interpret i as imaginary');
+                } else {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.customSettingsCheckboxContainer(customSettingsIds.interpretIAsImaginary), 'notExist');
+                }
+                if (evaluationMethod.customSettings.includes('Interpret i as imaginary')) {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.customSettingsCheckboxContainer(customSettingsIds.interpretIAsImaginary), 'visible');
+                    textEntryMathPage.steps.verifyCustomSettingsCheckboxIsUnchecked(customSettingsIds.interpretIAsImaginary);
+                    textEntryMathPage.steps.verifyCustomSettingsCheckboxLabel(customSettingsIds.interpretIAsImaginary, 'Interpret i as imaginary');
+                } else {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.customSettingsCheckboxContainer(customSettingsIds.interpretIAsImaginary), 'notExist');
+                }
+                if (evaluationMethod.customSettings.includes('Ignore order')) {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.customSettingsCheckboxContainer(customSettingsIds.acceptExpressionsInAnyOrder), 'visible');
+                    textEntryMathPage.steps.verifyCustomSettingsCheckboxIsUnchecked(customSettingsIds.acceptExpressionsInAnyOrder);
+                    textEntryMathPage.steps.verifyCustomSettingsCheckboxLabel(customSettingsIds.acceptExpressionsInAnyOrder, 'Ignore order');
+                } else {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.customSettingsCheckboxContainer(customSettingsIds.acceptExpressionsInAnyOrder), 'notExist');
+                }
+                if (evaluationMethod.customSettings.includes('Inverse result')) {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.customSettingsCheckboxContainer(customSettingsIds.excludeFromPossibleCorrectAnswers), 'visible');
+                    textEntryMathPage.steps.verifyCustomSettingsCheckboxIsUnchecked(customSettingsIds.excludeFromPossibleCorrectAnswers);
+                    textEntryMathPage.steps.verifyCustomSettingsCheckboxLabel(customSettingsIds.excludeFromPossibleCorrectAnswers, 'Inverse result');
+                } else {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.customSettingsCheckboxContainer(customSettingsIds.excludeFromPossibleCorrectAnswers), 'notExist');
+                }
+                if (evaluationMethod.customSettings.includes('Ignore trailing zeros')) {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.customSettingsCheckboxContainer(customSettingsIds.ignoreZerosAfterDecimal), 'visible');
+                    textEntryMathPage.steps.verifyCustomSettingsCheckboxIsUnchecked(customSettingsIds.ignoreZerosAfterDecimal);
+                    textEntryMathPage.steps.verifyCustomSettingsCheckboxLabel(customSettingsIds.ignoreZerosAfterDecimal, 'Ignore trailing zeros');
+                } else {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.customSettingsCheckboxContainer(customSettingsIds.ignoreZerosAfterDecimal), 'notExist');
+                }
+                if (evaluationMethod.customSettings.includes('Ignore coefficient of 1')) {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.customSettingsCheckboxContainer(customSettingsIds.ignoreUnitCoefficient), 'visible');
+                    textEntryMathPage.steps.verifyCustomSettingsCheckboxIsUnchecked(customSettingsIds.ignoreUnitCoefficient);
+                    textEntryMathPage.steps.verifyCustomSettingsCheckboxLabel(customSettingsIds.ignoreUnitCoefficient, 'Ignore coefficient of 1');
+                } else {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.customSettingsCheckboxContainer(customSettingsIds.ignoreUnitCoefficient), 'notExist');
+                }
+                if (evaluationMethod.customSettings.includes('Check for parenthesis grouping')) {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.customSettingsCheckboxContainer(customSettingsIds.checkForParenthesisGrouping), 'visible');
+                    textEntryMathPage.steps.verifyCustomSettingsCheckboxIsUnchecked(customSettingsIds.checkForParenthesisGrouping);
+                    textEntryMathPage.steps.verifyCustomSettingsCheckboxLabel(customSettingsIds.checkForParenthesisGrouping, 'Check for parenthesis grouping');
+                } else {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.customSettingsCheckboxContainer(customSettingsIds.checkForParenthesisGrouping), 'notExist');
+                }
+                if (evaluationMethod.customSettings.includes('Ignore spaces before and after')) {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.customSettingsCheckboxContainer(customSettingsIds.ignoreSpacesBeforeAndAfter), 'visible');
+                    textEntryMathPage.steps.verifyCustomSettingsCheckboxIsUnchecked(customSettingsIds.ignoreSpacesBeforeAndAfter);
+                    textEntryMathPage.steps.verifyCustomSettingsCheckboxLabel(customSettingsIds.ignoreSpacesBeforeAndAfter, 'Ignore spaces before and after');
+                } else {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.customSettingsCheckboxContainer(customSettingsIds.ignoreSpacesBeforeAndAfter), 'notExist');
+                }
+                if (evaluationMethod.customSettings.includes('Ignore extra spaces')) {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.customSettingsCheckboxContainer(customSettingsIds.ignoreExtraSpaces), 'visible');
+                    textEntryMathPage.steps.verifyCustomSettingsCheckboxIsUnchecked(customSettingsIds.ignoreExtraSpaces);
+                    textEntryMathPage.steps.verifyCustomSettingsCheckboxLabel(customSettingsIds.ignoreExtraSpaces, 'Ignore extra spaces');
+                } else {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.customSettingsCheckboxContainer(customSettingsIds.ignoreExtraSpaces), 'notExist');
+                }
+                if (evaluationMethod.customSettings.includes('Decimal separator')) {
+                    textEntryMathPage.steps.verifyDecimalSeparatorsContents();
+                } else {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.decimalSeparatorWrapper(), 'notExist');
+                }
+                if (evaluationMethod.customSettings.includes('Thousands separator')) {
+                    textEntryMathPage.steps.verifyThousandsSeparatorsContents(thousandsSeparatorForDotDecimalSeparator);
+                } else {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.thousandsSeparatorWrapper(), 'notExist');
+                }
+                if (evaluationMethod.customSettings.includes('Decimal places to be compared')) {
+                    textEntryMathPage.steps.verifyDecimalPlacesToBeComparedSectionContents();
+                } else {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.decimalPlacesToBeComparedInputField(), 'notExist');
+                    utilities.verifyElementVisibilityState(textEntryMathPage.decimalPlacesToBeComparedLabel(), 'notExist');
+                }
+                if (evaluationMethod.customSettings.includes('Tolerance')) {
+                    textEntryMathPage.steps.verifyToleranceSectionContents();
+                } else {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.toleranceInputField(), 'notExist');
+                    utilities.verifyElementVisibilityState(textEntryMathPage.toleranceLabel(), 'notExist');
+                }
+                if (evaluationMethod.customSettings.includes('Type of expression')) {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.typeOfExpressionLabel(), 'visible');
+                    utilities.verifyInnerText(textEntryMathPage.typeOfExpressionLabel(), 'Type of expression');
+                    utilities.verifyElementVisibilityState(textEntryMathPage.typeOfExpressionDropdown(), 'visible');
+                    utilities.verifyInnerText(textEntryMathPage.typeOfExpressionDropdown(), 'Integer');
+                    cy.log(`When user expands \'Type of Expression\' dropdown, then the followings options should be displayed ${typeOfExpression.join(', ')}`);
+                    cy.log('Pre-step: Expanding \'Type of Expression\' dropdown');
+                    textEntryMathPage.steps.expandTypeOfExpressionDropdown();
+                    typeOfExpression.forEach((type, index) => {
+                        utilities.verifyInnerText(utilities.getNthElement(textEntryMathPage.typeOfExpressionDropdownOption(), index), type);
+                    });
+                    textEntryMathPage.steps.verifyTypeOfExpressionDropdownListOptionActiveState(0);
+                    textEntryMathPage.steps.verifyTypeOfExpressionDropdownListOptionInactiveState(1);
+                    textEntryMathPage.steps.verifyTypeOfExpressionDropdownListOptionInactiveState(2);
+                    cy.log('When user selects a different option in \'Type of Expression\' dropdown, then the dropdown should be collapsed and the selected option should be displayed in the dropdown');
+                    textEntryMathPage.steps.selectTypeOfExpressionDropdownListOption(1);
+                    textEntryMathPage.steps.verifyTypeOfExpressionDropdownIsCollapsed();
+                    utilities.verifyInnerText(textEntryMathPage.typeOfExpressionDropdown(), 'Real');
+                } else {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.typeOfExpressionLabel(), 'notExist');
+                    utilities.verifyElementVisibilityState(textEntryMathPage.typeOfExpressionDropdown(), 'notExist');
+                }
+                if (evaluationMethod.customSettings.includes('Syntax')) {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.syntaxLabel(), 'visible');
+                    utilities.verifyInnerText(textEntryMathPage.syntaxLabel(), 'Type of expression');
+                    utilities.verifyElementVisibilityState(textEntryMathPage.syntaxDropdown(), 'visible');
+                    utilities.verifyInnerText(textEntryMathPage.syntaxDropdown(), 'Number');
+                    cy.log(`When user expands \'Syntax\' dropdown, then the followings options should be displayed ${syntaxDropdown.join(', ')}`);
+                    cy.log('Pre-step: Expanding \'Type of Expression\' dropdown');
+                    textEntryMathPage.steps.expandSyntaxDropdown();
+                    syntaxDropdown.forEach((type, index) => {
+                        utilities.verifyInnerText(utilities.getNthElement(textEntryMathPage.syntaxDropdownOption(), index), type);
+                    });
+                    textEntryMathPage.steps.verifySyntaxDropdownListOptionActiveState(0);
+                    for (let index = 0; index < syntaxDropdown.length; index++) {
+                        textEntryMathPage.steps.verifySyntaxDropdownListOptionInactiveState(index);
+                    };
+                    cy.log('When user selects a different option in \'Syntax\' dropdown, then the dropdown should be collapsed and the selected option should be displayed in the dropdown');
+                    textEntryMathPage.steps.selectSyntaxDropdownListOption(1);
+                    textEntryMathPage.steps.verifySyntaxDropdownIsCollapsed();
+                    utilities.verifyInnerText(textEntryMathPage.syntaxDropdown(), 'Integer');
+                } else {
+                    utilities.verifyElementVisibilityState(textEntryMathPage.syntaxLabel(), 'notExist');
+                    utilities.verifyElementVisibilityState(textEntryMathPage.syntaxDropdown(), 'notExist');
+                }
+            });
+
+            it(`When user clicks on the expanded custom settings accordion for ${evaluationMethod.name}, then the custom settings accordion should be collpased`, () => {
+                textEntryMathPage.steps.clickOnCustomSettingsAccordion();
+                textEntryMathPage.steps.verifyCustomSettingsAccordionIsCollapsed();
+            });
+        });
+
+        it('CSS of custom settings accordion and contents', { tags: 'css' }, () => {
+            utilities.verifyCSS(textEntryMathPage.customSettingsLabel(), {
+                'color': css.color.accordionLabel,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.bold,
+            });
+            utilities.verifyCSS(textEntryMathPage.customSettingsChevronButton().find('svg'), {
+                'fill': css.color.activeButtons
+            });
+            cy.log('Pre-step: Selecting \'Value is equivalent\' evaluation method');
+            textEntryMathPage.steps.selectEvaluationMethod(evaluationMethods[1].name);
+            utilities.verifyCSS(textEntryMathPage.customSettingsCheckboxContainer(customSettingsIds.caseSensitive).find('[class*="MuiFormControlLabel-label"]'), {
+                'color': css.color.customSettingsCheckboxLabel,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.regular,
+            });
+            utilities.verifyCSS(textEntryMathPage.decimalPlacesToBeComparedLabel, {
+                'color': css.color.labels,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.semibold,
+            });
+            utilities.verifyCSS(textEntryMathPage.decimalPlacesToBeComparedInputField, {
+                'color': css.color.text,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular,
+            });
+            cy.log('Pre-step: Selecting \'Equivalent structure\' evaluation method');
+            textEntryMathPage.steps.selectEvaluationMethod(evaluationMethods[3].name);
+            utilities.verifyCSS(textEntryMathPage.syntaxLabel(), {
+                'color': css.color.labels,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.semibold,
+            });
+            utilities.verifyCSS(textEntryMathPage.syntaxDropdown(), {
+                'color': css.color.liText,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular,
+            });
+            cy.log('Expand syntax dropdown');
+            textEntryMathPage.steps.expandSyntaxDropdown();
+            utilities.verifyCSS(utilities.getNthElement(textEntryMathPage.syntaxDropdownOption(), 0), {
+                'color': css.color.labels,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.semibold,
+                'background-color': css.color.liTextSelectedBg
+            });
+            utilities.verifyCSS(utilities.getNthElement(textEntryMathPage.syntaxDropdownOption(), 1), {
+                'color': css.color.liText,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+            cy.log('Post-step: Collapse dropdown');
+            textEntryMathPage.steps.selectSyntaxDropdownListOption(1);
+            cy.log('Pre-step: Selecting \'Factored form\' evaluation method');
+            textEntryMathPage.steps.selectEvaluationMethod(evaluationMethods[6].name);
+            utilities.verifyCSS(textEntryMathPage.typeOfExpressionLabel(), {
+                'color': css.color.labels,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.semibold,
+            });
+            utilities.verifyCSS(textEntryMathPage.typeOfExpressionDropdown(), {
+                'color': css.color.liText,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular,
+            });
+            cy.log('Expand type of expression dropdown');
+            textEntryMathPage.steps.expandTypeOfExpressionDropdown();
+            utilities.verifyCSS(utilities.getNthElement(textEntryMathPage.typeOfExpressionDropdownOption(), 0), {
+                'color': css.color.labels,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.semibold,
+                'background-color': css.color.liTextSelectedBg
+            });
+            utilities.verifyCSS(utilities.getNthElement(textEntryMathPage.typeOfExpressionDropdownOption(), 1), {
+                'color': css.color.liText,
+                'font-size': css.fontSize.default,
+                'font-weight': css.fontWeight.regular
+            });
+            cy.log('Post-step: Collapse dropdown');
+            textEntryMathPage.steps.selectTypeOfExpressionDropdownListOption(1);
+        });
+
+        it('Accessibility of custom settings accordion and contents', { tags: 'a11y' }, () => {
+            cy.checkAccessibility(textEntryMathPage.responseAccordion());
+            cy.log('Expand type of expression dropdown');
+            textEntryMathPage.steps.expandTypeOfExpressionDropdown();
+            cy.checkAccessibility(utilities.getNthElement(textEntryMathPage.typeOfExpressionDropdownOption(), 0).parents('ul'));
+            cy.log('Post-step: Collapse dropdown');
+            textEntryMathPage.steps.selectTypeOfExpressionDropdownListOption(1);
+            cy.log('Expand syntax dropdown');
+            textEntryMathPage.steps.expandSyntaxDropdown();
+            cy.checkAccessibility(utilities.getNthElement(textEntryMathPage.syntaxDropdownOption(), 0).parents('ul'));
+            cy.log('Post-step: Collapse dropdown');
+            textEntryMathPage.steps.selectSyntaxDropdownListOption(1);
+        });
+    });
+
+    describe('Evaluation methods - Decimal separator and Thousand separator', () => {
+        abortEarlySetup();
+        before(() => {
+            textEntryMathPage.steps.navigateToCreateQuestion('Text Entry Math');
+            cy.barsPreLoaderWait();
+            textEntryMathPage.steps.deleteAResponseToken(1);
+            textEntryMathPage.steps.expandResponseAccordionSpecifyCorrectAnswer(0);
+            textEntryMathPage.steps.clickOnCustomSettingsAccordion();
+        });
+
+        it('For \'Decimal separator\' custom settings by default \'Dot\' should be selected', () => {
+            textEntryMathPage.steps.verifyDecimalSeparatorOptionActive(0);
+        });
+
+        it(`When decimal separator is set to \'Dot\', then the following should be the displayed options for thousands separator - ${thousandsSeparatorForDotDecimalSeparator.join(', ')}`, () => {
+            textEntryMathPage.steps.verifyThousandsSeparatorsContents(thousandsSeparatorForDotDecimalSeparator);
+        });
+
+        it('User should be able to select \'Comma\' as \'Decimal separator\'', () => {
+            textEntryMathPage.steps.selectDecimalSeparatorOption(1);
+            textEntryMathPage.steps.verifyDecimalSeparatorOptionActive(1);
+            textEntryMathPage.steps.verifyDecimalSeparatorOptionInactive(0);
+        });
+
+        it(`When decimal separator is set to \'Comma\', then the following should be the displayed options for thousands separator - ${thousandsSeparatorForCommaDecimalSeparator.join(', ')}`, () => {
+            textEntryMathPage.steps.verifyThousandsSeparatorsContents(thousandsSeparatorForCommaDecimalSeparator);
+        });
+
+        it('For \'Thousands separator\' custom settings by default \'None\' should be selected', () => {
+            textEntryMathPage.steps.verifyThousandSeparatorOptionActive(0);
+        });
+
+        it('User should be able to select a different \'Thousands separator\'', () => {
+            textEntryMathPage.steps.selectThousandSeparatorOption(1);
+            textEntryMathPage.steps.verifyThousandSeparatorOptionActive(1);
+            textEntryMathPage.steps.verifyThousandSeparatorOptionInactive(0);
+            textEntryMathPage.steps.verifyThousandSeparatorOptionInactive(2);
+            textEntryMathPage.steps.verifyThousandSeparatorOptionInactive(3);
+        });
+
+        it('CSS of custom settings accordion and contents', { tags: 'css' }, () => {
+            utilities.verifyCSS(utilities.getNthElement(textEntryMathPage.separatorsTitle(), 0), {
+                'color': css.color.labels,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.semibold
+            });
+            utilities.verifyCSS(utilities.getNthElement(textEntryMathPage.separatorsOptionsMenuOptions(), 0), {
+                'color': css.color.separatorsUnselectedOption,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.bold
+            });
+            utilities.verifyCSS(utilities.getNthElement(textEntryMathPage.separatorsOptionsMenuOptions(), 1), {
+                'color': css.color.whiteText,
+                'font-size': css.fontSize.normal,
+                'font-weight': css.fontWeight.bold,
+                'background-color': css.color.activeButtons
+            });
+        });
+
+        //Accessibility already covered in above describes
+    });
+});