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

package/cypress/e2e/ILC/SimpleCalculator/calculatorFunctionality.js

@@ -0,0 +1,349 @@
+import { simpleCalculatorPage } from "../../../pages";
+import abortEarlySetup from "../../../support/helpers/abortEarly";
+import utilities from "../../../support/helpers/utilities";
+const css = Cypress.env('css');
+
+describe('Simple calculator - Functionality cases, Undo/Redo Controls, Edge cases', () => {
+    before(() => {
+        cy.loginAs('admin');
+    });
+
+    describe('Simple calculator - Functionality cases', () => {
+        abortEarlySetup();
+        before(() => {
+            simpleCalculatorPage.steps.navigateToCreateResource('simple calculator');
+            simpleCalculatorPage.steps.selectCustomizeCalculatorSettingsParenthesesButton();
+            simpleCalculatorPage.steps.selectCustomizeCalculatorSettingsPiButton();
+            simpleCalculatorPage.steps.selectCustomizeCalculatorSettingsSquareButton();
+            simpleCalculatorPage.steps.selectCustomizeCalculatorSettingsReciprocalButton();
+            simpleCalculatorPage.steps.selectCustomizeCalculatorSettingsPercentageButton();
+            simpleCalculatorPage.steps.selectCustomizeCalculatorSettingsSquareRootButton();
+            simpleCalculatorPage.steps.selectCustomizeCalculatorSettingsExponentButton();
+            simpleCalculatorPage.steps.selectCustomizeCalculatorSettingsSignChangeButton();
+            simpleCalculatorPage.steps.switchToPreviewTab();
+        });
+
+        it('The user should be able to perform addition operation correctly', () => {
+            simpleCalculatorPage.steps.clickOnACalculatorButton('one');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('addition');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('two');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('equal to');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayInputEquationValue('1+2 =');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayResultValue('3');
+        });
+
+        it('When the user clicks on the "All clear" button, the calculator display should reset', () => {
+            simpleCalculatorPage.steps.clickOnACalculatorButton('all clear');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayInputEquationValue('');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayResultValue('');
+        });
+
+        it('When the user adds any number or mathematical operator and clicks on the "delete" button, the latest added symbol should get deleted', ()=> {
+            simpleCalculatorPage.steps.clickOnACalculatorButton('two');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('subtraction');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('delete');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayResultValue('2');
+        });
+
+        it('The user should be able to perform subtraction operation correctly', () => {
+            simpleCalculatorPage.steps.resetCalculator();
+            simpleCalculatorPage.steps.clickOnACalculatorButton('two');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('subtraction');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('one');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('equal to');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayInputEquationValue('2-1 =');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayResultValue('1');
+        });
+
+        it('The user should be able to perform multiplication operation correctly', () => {
+            simpleCalculatorPage.steps.resetCalculator();
+            simpleCalculatorPage.steps.clickOnACalculatorButton('two');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('multiplication');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('four');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('equal to');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayInputEquationValue('2×4 =');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayResultValue('8');
+        });
+
+        it('The user should be able to perform division operation correctly', () => {
+            simpleCalculatorPage.steps.resetCalculator();
+            simpleCalculatorPage.steps.clickOnACalculatorButton('two');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('division');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('four');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('equal to');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayInputEquationValue('2÷4 =');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayResultValue('0.5');
+        });
+
+        it('When the user performs a mathematical operation that contains parentheses, the calculator should handle parenthesis correctly', () => {
+            simpleCalculatorPage.steps.resetCalculator();
+            simpleCalculatorPage.steps.clickOnACalculatorButton('three');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('multiplication');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('left parenthesis');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('four');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('addition');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('two');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('right parenthesis');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('division');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('two');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('subtraction');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('five');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('equal to');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayInputEquationValue('3×(4+2)÷2-5 =');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayResultValue('4');
+        });
+
+        it('When the user performs a mathematical operation that contains pi, the calculator should handle pi correctly', () => {
+            simpleCalculatorPage.steps.resetCalculator();
+            simpleCalculatorPage.steps.clickOnACalculatorButton('two');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('multiplication');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('pi');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('equal to');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayInputEquationValue('2×π =');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayResultValue('6.283185');
+        });
+
+        it('When the user performs a mathematical operation that contains square of a number, the calculator should handle square correctly', () => {
+            simpleCalculatorPage.steps.resetCalculator();
+            simpleCalculatorPage.steps.clickOnACalculatorButton('two');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('square');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('equal to');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayInputEquationValue('2² =');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayResultValue('4');
+        });
+
+        it('When the user performs a mathematical operation that contains reciprocal of a number, the calculator should handle reciprocal correctly', () => {
+            simpleCalculatorPage.steps.resetCalculator();
+            simpleCalculatorPage.steps.clickOnACalculatorButton('two');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('reciprocal');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('equal to');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayInputEquationValue('2⁻¹ =');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayResultValue('0.5');
+        });
+
+        it('When the user performs a mathematical operation that contains percentage of a number, the calculator should handle percentage correctly', () => {
+            simpleCalculatorPage.steps.resetCalculator();
+            simpleCalculatorPage.steps.clickOnACalculatorButton('one');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('zero');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('zero');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('addition');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('one');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('zero');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('percentage');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('equal to');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayInputEquationValue('100+10% =');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayResultValue('110');
+        });
+
+        it('When the user performs a mathematical operation that contains square root of a number, the calculator should handle square root correctly', () => {
+            simpleCalculatorPage.steps.resetCalculator();
+            simpleCalculatorPage.steps.clickOnACalculatorButton('two');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('square root');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('three');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('equal to');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayInputEquationValue('2√(3) =');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayResultValue('3.464102');
+        });
+
+        it('When the user performs a mathematical operation that contains exponent of a number, the calculator should handle exponent correctly', () => {
+            simpleCalculatorPage.steps.resetCalculator();
+            simpleCalculatorPage.steps.clickOnACalculatorButton('two');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('exponent');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('three');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('equal to');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayInputEquationValue('2^3 =');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayResultValue('8');
+        });
+
+        it('When the user performs a mathematical operation that contains sign change, the calculator should handle sign change correctly', () => {
+            simpleCalculatorPage.steps.resetCalculator();
+            simpleCalculatorPage.steps.clickOnACalculatorButton('two');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('sign change');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayResultValue('(-2)');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('equal to');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayInputEquationValue('(-2) =');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayResultValue('-2');
+        });
+
+        it('When the user resets the calculator and then clicks on the "Check history" button, the button should be in selected state and a side panel should open with all the last performed calculations', () => {
+            simpleCalculatorPage.steps.resetCalculator();
+            simpleCalculatorPage.steps.selectCheckHistoryButton();
+            utilities.verifyElementVisibilityState(simpleCalculatorPage.calculatorHistoryPanel(), 'visible');
+            simpleCalculatorPage.steps.verifyCalculatorHistory(0, '1+2 =', '3');
+            simpleCalculatorPage.steps.verifyCalculatorHistory(1, '2-1 =', '1');
+            simpleCalculatorPage.steps.verifyCalculatorHistory(2, '2×4 =', '8');
+            simpleCalculatorPage.steps.verifyCalculatorHistory(3, '2÷4 =', '0.5');
+            simpleCalculatorPage.steps.verifyCalculatorHistory(4, '3×(4+2)÷2-5 =', '4');
+            simpleCalculatorPage.steps.verifyCalculatorHistory(5, '2×π =', '6.283185');
+            simpleCalculatorPage.steps.verifyCalculatorHistory(6, '2² =', '4');
+            simpleCalculatorPage.steps.verifyCalculatorHistory(7, '2⁻¹ =', '0.5');
+            simpleCalculatorPage.steps.verifyCalculatorHistory(8, '100+10% =', '110');
+            simpleCalculatorPage.steps.verifyCalculatorHistory(9, '2√(3) =', '3.464102');
+            simpleCalculatorPage.steps.verifyCalculatorHistory(10, '2^3 =', '8');
+            simpleCalculatorPage.steps.verifyCalculatorHistory(11, '(-2) =', '-2');
+        });
+
+        it('CSS of the history panel', { tags: 'css' }, () => {
+            utilities.verifyCSS(simpleCalculatorPage.calculatorWrapper(), {
+                'background-color': css.color.darkThemeBg,
+                'border': `1px solid ${css.color.activeComponentBorder}`
+            });
+            utilities.verifyCSS(simpleCalculatorPage.historyPanelResult(), {
+                'color': css.color.whiteText,
+                'font-size': css.fontSize.heading,
+                'font-weight': css.fontWeight.bold
+            });
+            utilities.verifyCSS(simpleCalculatorPage.historyPanelEquation(), {
+                'color': css.color.liTextSelectedBg,
+                'font-size': css.fontSize.small,
+                'font-weight': css.fontWeight.regular
+            });
+        });
+
+        it('When the user clicks on the "Check history" button again, the history panel should collapse', () => {
+            simpleCalculatorPage.steps.unselectCheckHistoryButton();
+            utilities.verifyElementVisibilityState(simpleCalculatorPage.calculatorHistoryPanel(), 'notExist');
+        });
+    });
+
+    describe('Simple calculator - Undo/Redo Controls', () => {
+        abortEarlySetup();
+        before(() => {
+            simpleCalculatorPage.steps.navigateToCreateResource('simple calculator');
+            simpleCalculatorPage.steps.switchToPreviewTab();
+        });
+
+        it('When the user has not made any actions, the \'Undo\' and \'Redo\' buttons should be in disabled state', () => {
+            simpleCalculatorPage.steps.verifyUndoButtonDisabled();
+            simpleCalculatorPage.steps.verifyRedoButtonDisabled();
+        });
+
+        it('When the user makes any actions, the \'Undo\' button should get enabled but the \'Redo\' button should continue to stay in disabled state', () => {
+            simpleCalculatorPage.steps.clickOnACalculatorButton('one');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('addition');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('two');
+            simpleCalculatorPage.steps.verifyUndoButtonEnabled();
+            simpleCalculatorPage.steps.verifyRedoButtonDisabled();
+        });
+
+        it('When the user clicks on the \'Undo\' button, it should undo the latest action and when the user performs any undo action, the redo button should get enabled', () => {
+            simpleCalculatorPage.steps.clickOnACalculatorButton('undo');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayResultValue('1+');
+            simpleCalculatorPage.steps.verifyRedoButtonEnabled();
+        });
+
+        it('When the user has performed an undo action, the user should be able to redo it by clicking on the \'Redo\' button', () => {
+            simpleCalculatorPage.steps.clickOnACalculatorButton('redo');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayResultValue('1+2');
+        });
+
+        it('When the user reaches the initial state by performing undo actions, the \'Undo\' button should get disabled and when the user reaches the latest state by performing redo actions, the \'Redo\' button should get disabled', () => {
+            simpleCalculatorPage.steps.clickOnACalculatorButton('undo');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('undo');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('undo');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayResultValue('');
+            simpleCalculatorPage.steps.verifyUndoButtonDisabled();
+            simpleCalculatorPage.steps.clickOnACalculatorButton('redo');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('redo');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('redo');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayResultValue('1+2');
+        });
+
+        it('The undo button should get disabled after a certain number of undo actions (10 times)', () => {
+            simpleCalculatorPage.steps.resetQuestionPreview();
+            cy.log('Pre step: Performing 11 actions first')
+            simpleCalculatorPage.steps.clickOnACalculatorButton('one');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('addition');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('two');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('addition');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('three');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('addition');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('four');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('addition');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('five');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('addition');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('six');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('addition');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('seven');
+            for (var index = 0; index < 10; index++) {
+                simpleCalculatorPage.steps.clickOnACalculatorButton('undo');
+            };
+            simpleCalculatorPage.steps.verifyUndoButtonDisabled();
+        });
+    });
+
+    describe('Simple calculator - Edge cases', () => {
+        abortEarlySetup();
+        before(() => {
+            simpleCalculatorPage.steps.navigateToCreateResource('simple calculator');
+            simpleCalculatorPage.steps.switchToPreviewTab();
+        });
+
+        it('When the user performs a mathematical operation that contains an equation that contains division by zero, then the calculator should throw a "SyntaxError"', () => {
+            simpleCalculatorPage.steps.resetCalculator();
+            simpleCalculatorPage.steps.clickOnACalculatorButton('two');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('division');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('zero');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('equal to');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayInputEquationValue('');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayResultValue('Syntax Error');
+        });
+
+        it('When the user performs a mathematical operation that contains an equation with large numbers, the calculator should handle large numbers correctly', () => {
+            simpleCalculatorPage.steps.resetCalculator();
+            for (var index = 0; index < 16; index++) {
+                simpleCalculatorPage.steps.clickOnACalculatorButton('nine');
+            };
+            simpleCalculatorPage.steps.clickOnACalculatorButton('multiplication');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('nine');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('three');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('two');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('equal to');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayInputEquationValue('999999999999999×932 =');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayResultValue('9.32(10^17)');
+        });
+
+        it('When the user performs a mathematical operation that contains an invalid input, then the calculator should throw a "SyntaxError"', () => {
+            simpleCalculatorPage.steps.resetCalculator();
+            simpleCalculatorPage.steps.clickOnACalculatorButton('multiplication');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('equal to');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayInputEquationValue('');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayResultValue('Syntax Error');
+        });
+
+        it('When the user performs a mathematical operation that contains an equation with decimal points, the calculator should handle decimal inputs correctly', () => {
+            simpleCalculatorPage.steps.resetCalculator();
+            simpleCalculatorPage.steps.clickOnACalculatorButton('nine');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('decimal');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('three');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('addition');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('two');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('equal to');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayInputEquationValue('9.3+2 =');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayResultValue('11.3');
+        });
+
+        it('When the user performs a mathematical operation that contains an equation with consecutive operations without parentheses, the calculator should handle consecutive operations correctly', () => {
+            simpleCalculatorPage.steps.resetCalculator();
+            simpleCalculatorPage.steps.clickOnACalculatorButton('five');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('addition');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('three');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('multiplication');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('two');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('subtraction');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('four');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('division');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('two');
+            simpleCalculatorPage.steps.clickOnACalculatorButton('equal to');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayInputEquationValue('5+3×2-4÷2 =');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayResultValue('9');
+        });
+
+        it('When the user performs a mathematical operation that contains empty input, then the calculator should handle empty input gracefully', () => {
+            simpleCalculatorPage.steps.resetCalculator();
+            simpleCalculatorPage.steps.clickOnACalculatorButton('equal to');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayInputEquationValue('');
+            simpleCalculatorPage.steps.verifyCalculatorDisplayResultValue('Syntax Error');
+        });
+    });
+});

package/cypress/e2e/ILC/SimpleCalculator/previewContents.smoke.js

@@ -0,0 +1,132 @@
+import { simpleCalculatorPage, itemPreviewPage, studentViewPage } from "../../../pages";
+import abortEarlySetup from "../../../support/helpers/abortEarly";
+import utilities from "../../../support/helpers/utilities";
+let previewContentViews = ['Question preview', 'Item view', 'Item preview', 'Student view', 'Grading view', 'Correct answer view'];
+const views = utilities.getViews(previewContentViews);
+var itemReferenceID = "";
+const css = Cypress.env('css');
+//Failing due to https://redmine.zeuslearning.com/issues/563762
+describe('Preview tab contents for all views for Simple calculator', () => {
+    before(() => {
+        cy.loginAs('admin');
+    });
+
+    views.forEach((view) => {
+        describe(`Preview tab contents - ${view}`, { tags: 'smoke' }, () => {
+            abortEarlySetup();
+            before(() => {
+                switch (view) {
+                    case 'Question preview':
+                        simpleCalculatorPage.steps.navigateToCreateResource('simple calculator');
+                        simpleCalculatorPage.steps.switchToPreviewTab();
+                        break;
+                    case 'Item view':
+                        cy.visit(`/item-engine/demo/edit-item/${utilities.base64Encoding(itemReferenceID)}`);
+                        break;
+                    case 'Item preview':
+                        cy.visit(`/item-engine/demo/edit-item/${utilities.base64Encoding(itemReferenceID)}`);
+                        simpleCalculatorPage.steps.switchToPreviewTab();
+                        break;
+                    case 'Student view':
+                        cy.visit(`/item-engine/demo/render-item/student-view/${utilities.base64Encoding(itemReferenceID)}`);
+                        break;
+                    case 'Grading view':
+                        cy.visit(`/item-engine/demo/render-item/grading-view/${utilities.base64Encoding(itemReferenceID)}`);
+                        break;
+                    case 'Correct answer view':
+                        cy.visit(`/item-engine/demo/render-item/correct-answer-view/${utilities.base64Encoding(itemReferenceID)}`);
+                        break;
+                    default:
+                        throw new Error('Invalid view');
+                }
+            });
+
+            after(() => {
+                if (view === 'Question preview') {
+                    simpleCalculatorPage.steps.clickOnSaveQuestionButton();
+                    utilities.verifyElementVisibilityState(itemPreviewPage.referenceID(), 'visible');
+                    itemReferenceID = itemPreviewPage.steps.getItemReferenceID();
+                }
+                if (view === 'Student view') {
+                    studentViewPage.steps.submitResponse();
+                    utilities.verifyElementVisibilityState(studentViewPage.buttonGoToGradingView(), 'visible');
+                }
+            });
+
+            it('Calculator should be displayed with an empty display and all the basic buttons along with a drag handle button', () => {
+                utilities.verifyElementVisibilityState(simpleCalculatorPage.calculatorDragHandleButton(), 'visible');
+                simpleCalculatorPage.steps.verifyCalculatorDisplayResultValue('');
+                utilities.verifyElementVisibilityState(simpleCalculatorPage.checkHistoryButton(), 'visible');
+                simpleCalculatorPage.steps.verifyUndoButtonDisabled();
+                simpleCalculatorPage.steps.verifyRedoButtonDisabled();
+                utilities.verifyElementVisibilityState(simpleCalculatorPage.allClearButton(), 'visible');
+                utilities.verifyElementVisibilityState(simpleCalculatorPage.deleteButton(), 'visible');
+                utilities.verifyElementVisibilityState(simpleCalculatorPage.divisionButton(), 'visible');
+                utilities.verifyElementVisibilityState(simpleCalculatorPage.additionButton(), 'visible');
+                utilities.verifyElementVisibilityState(simpleCalculatorPage.multiplicationButton(), 'visible');
+                utilities.verifyElementVisibilityState(simpleCalculatorPage.subtractionButton(), 'visible');
+                utilities.verifyElementVisibilityState(simpleCalculatorPage.equalToButton(), 'visible');
+                utilities.verifyElementVisibilityState(simpleCalculatorPage.leftArrowButton(), 'visible');
+                utilities.verifyElementVisibilityState(simpleCalculatorPage.rightArrowButton(), 'visible');
+                utilities.verifyElementVisibilityState(simpleCalculatorPage.decimalButton(), 'visible');
+                utilities.verifyElementVisibilityState(simpleCalculatorPage.zeroButton(), 'visible');
+                utilities.verifyElementVisibilityState(simpleCalculatorPage.oneButton(), 'visible');
+                utilities.verifyElementVisibilityState(simpleCalculatorPage.twoButton(), 'visible');
+                utilities.verifyElementVisibilityState(simpleCalculatorPage.threeButton(), 'visible');
+                utilities.verifyElementVisibilityState(simpleCalculatorPage.fourButton(), 'visible');
+                utilities.verifyElementVisibilityState(simpleCalculatorPage.fiveButton(), 'visible');
+                utilities.verifyElementVisibilityState(simpleCalculatorPage.sixButton(), 'visible');
+                utilities.verifyElementVisibilityState(simpleCalculatorPage.sevenButton(), 'visible');
+                utilities.verifyElementVisibilityState(simpleCalculatorPage.eightButton(), 'visible');
+                utilities.verifyElementVisibilityState(simpleCalculatorPage.nineButton(), 'visible');
+            });
+
+            it('The user should be able to perform basic mathematical operations', () => {
+                simpleCalculatorPage.steps.clickOnACalculatorButton('one');
+                simpleCalculatorPage.steps.clickOnACalculatorButton('addition');
+                simpleCalculatorPage.steps.clickOnACalculatorButton('two');
+                simpleCalculatorPage.steps.verifyCalculatorDisplayResultValue('1+2');
+                simpleCalculatorPage.steps.clickOnACalculatorButton('equal to');
+                simpleCalculatorPage.steps.verifyCalculatorDisplayInputEquationValue('1+2 =');
+                simpleCalculatorPage.steps.verifyCalculatorDisplayResultValue('3');
+            });
+
+            it('CSS of preview contents', { tags: 'css' }, () => {
+                const darkThemeButtons = [simpleCalculatorPage.allClearButton, simpleCalculatorPage.deleteButton, simpleCalculatorPage.divisionButton, simpleCalculatorPage.additionButton, simpleCalculatorPage.multiplicationButton, simpleCalculatorPage.subtractionButton, simpleCalculatorPage.leftArrowButton, simpleCalculatorPage.rightArrowButton, simpleCalculatorPage.decimalButton];
+                const lightThemeButtons = [simpleCalculatorPage.oneButton, simpleCalculatorPage.twoButton, simpleCalculatorPage.threeButton, simpleCalculatorPage.fourButton, simpleCalculatorPage.fiveButton, simpleCalculatorPage.sixButton, simpleCalculatorPage.sevenButton, simpleCalculatorPage.eightButton, simpleCalculatorPage.nineButton];
+                const darkThemeCSS = {
+                    'background-color': css.color.darkThemeBtnBg,
+                    'border': `1px solid ${css.color.darkThemeBtnBorder}`
+                };
+                const lightThemeCSS = {
+                    'background-color': css.color.lightThemeBtnBg,
+                    'border': `1px solid ${css.color.lightThemeBtnBorder}`
+                }
+                utilities.verifyCSS(simpleCalculatorPage.calculatorWrapper(), {
+                    'background-color': css.color.darkThemeBg,
+                    'border': `1px solid ${css.color.activeComponentBorder}`
+                });
+                darkThemeButtons.forEach((button) => {
+                    utilities.verifyCSS(button(), darkThemeCSS);
+                });
+                lightThemeButtons.forEach((button) => {
+                    utilities.verifyCSS(button(), lightThemeCSS);
+                });
+                utilities.verifyCSS(simpleCalculatorPage.calculatorDisplay().find('.display-span'), {
+                    'color': css.color.whiteText,
+                    'font-size': '36px',
+                    'font-weight': css.fontWeight.bold
+                });
+                utilities.verifyCSS(simpleCalculatorPage.calculatorDisplayEquation(), {
+                    'color': css.color.liTextSelectedBg,
+                    'font-size': css.fontSize.small,
+                    'font-weight': css.fontWeight.regular
+                });
+            });
+
+            it('Accessibility of preview contents', {tags: 'a11y'}, () => {
+                cy.checkAccessibility(simpleCalculatorPage.calculatorWrapper());
+            });
+        });
+    });
+});

package/cypress/e2e/ILC/UploadResponse/previewContentsForAllViews.smoke.js

@@ -5,6 +5,9 @@ const css = Cypress.env('css');
 let previewContentViews = ['Question preview', 'Item view', 'Item preview', 'Student view'];
 const views = utilities.getViews(previewContentViews);
 var itemReferenceID = "";
+const fileTypes = ['CSV', 'Excel', 'GIF', 'JPG', 'Open Office', 'PDF', 'PNG', 'Powerpoint', 'Publisher', 'RTF', 'TXT', 'Word', 'XPS', 'ZIP'];
+const fileTypesString = fileTypes.toString().replaceAll(',', ', ')
+const infoIconTooltipText = 'Supported file formats:  ' + fileTypesString + '.';
 
 describe('Create item page - Upload response : Preview contents', () => {
     before(() => {
@@ -51,7 +54,32 @@ describe('Create item page - Upload response : Preview contents', () => {
                 utilities.verifyElementVisibilityState(uploadResponsePage.questionInstructionsText(), 'visible');
             });
 
-            it('File limit label be visible', () => {
+            it('Upload response area should have a Cloud icon and text \'Drag & Drop files here or browse files on your device, Google Drive or capture an image\' should be displayed', () => {
+                utilities.verifyElementVisibilityState(uploadResponsePage.uploadCloudIcon(), 'visible');
+                utilities.verifyInnerText(uploadResponsePage.dragAndDropFilesText(), 'Drag & Drop files here');
+                utilities.verifyTextContent(uploadResponsePage.fileUploadOptionsLabel(), 'or browse files on your device, Google Drive or capture an image');
+            });
+    
+            it('Computer and Google Drive icons should be displayed before link texts \'device\' and \'Google Drive\' respectively', () => {
+                uploadResponsePage.deviceLink()
+                    .verifyPseudoClassBeforeProperty('content', '""');
+                utilities.verifyElementVisibilityState(uploadResponsePage.googleDriveLink().find('svg'), 'visible');
+            });
+    
+            it('\'Supported file formats\' label should be displayed along with an info icon, hovering over the Supported file formats info icon a tooltip should be displayed with list of all the selected supported file types', () => {
+                utilities.verifyInnerText(uploadResponsePage.supportedFileFormatLabel(), 'Supported file formats');
+                utilities.verifyElementVisibilityState(uploadResponsePage.supportedFileInfoIcon(), 'visible');
+                uploadResponsePage.supportedFileInfoIcon()
+                    .verifyTooltip(infoIconTooltipText);
+            });
+
+            it('Accessibility of \'Supported file formats\' tooltip', { tags: 'a11y' }, () => {
+                utilities.triggerMouseover(uploadResponsePage.supportedFileInfoIcon());
+                cy.checkAccessibility(uploadResponsePage.supportedFilesTooltip());
+                utilities.triggerMouseout(uploadResponsePage.supportedFileInfoIcon());
+            });
+
+            it('Uploaded file limit should be displayed on the bottom right corner of the response section and by default it should be 0', () => {
                 uploadResponsePage.steps.verifyUploadedFileLimitCount(0, 3);
             });
 
@@ -64,14 +92,14 @@ describe('Create item page - Upload response : Preview contents', () => {
 
             it('When user deletes the uploaded file then uploaded file name, edit icon and delete button should disappear and file limit should be updated accordingly', () => {
                 uploadResponsePage.steps.deleteFile();
-                uploadResponsePage.steps.deleteFileButtonInDeleteFilePopup();
+                uploadResponsePage.steps.clickAcceptButtonInPopup();
                 uploadResponsePage.steps.uploadedFileContentsNotExistPreviewTab();
             });
 
             it('When user uploads multiple files, then uploaded files should be visible in the uploaded file section and file limit should be updated accordingly', () => {
-                uploadResponsePage.steps.uploadFile(['uploads/sample.pdf', 'uploads/sample.jpg']);
-                uploadResponsePage.steps.verifyUploadedFileNameVisible('sample.pdf');
-                uploadResponsePage.steps.verifyUploadedFileNameVisible('sample.jpg');
+                uploadResponsePage.steps.fileUploadAndVerify(['highlightImage.jpg', 'sample.xlsx'], 'drag and drop');
+                uploadResponsePage.steps.uploadedFileContentsPreviewTab(0, 'highlightImage.jpg');
+                uploadResponsePage.steps.uploadedFileContentsPreviewTab(1, 'sample.xlsx');
                 uploadResponsePage.steps.verifyUploadedFileLimitCount(2, 3);
                 utilities.verifyElementCount(uploadResponsePage.fileName(), 2);
             });
@@ -81,7 +109,7 @@ describe('Create item page - Upload response : Preview contents', () => {
                 utilities.verifyElementVisibilityState(uploadResponsePage.dialogBox(), 'exist');
                 uploadResponsePage.steps.enterTextInEditDisplayTextPopupInputField('image.csv');
                 uploadResponsePage.steps.verifyTextInEditDisplayTextPopupInputField('image.csv');
-                uploadResponsePage.steps.deleteFileButtonInDeleteFilePopup();
+                uploadResponsePage.steps.clickAcceptButtonInPopup();
                 uploadResponsePage.steps.verifyUploadedFileName(0, 'image.csv');
             });
 
@@ -146,7 +174,7 @@ describe('Create item page - Upload response : Preview contents', () => {
 
             if (view != 'Question preview') {
                 it('On clicking on the file name, user should be able to download the file', () => {
-                    cy.verifyUploadFilePreviewDownload('sample.jpg');
+                    cy.verifyUploadFilePreviewDownload('highlightImage.jpg');
                     cy.log('Added wait here to pause till the file download is complete');
                     cy.wait(5000);
                 });