Scientific and Programmer tests (#779)

* Maximize window during setup, and added divide by zero error test

* Added Error_CubedNegativeNumber test and AOT buttons

* Made Added AoT Tests and test are faster

* Hotkey and Mouse Input BVT Test added, Memory Test started

* Started Aligning BVTs with manual tests.  Added TC23466694, TC17416429, and TC17416884, and a test to switching mode test

* Basic Scientific Mode Functional Test Tests

* Added history panel test, and history flyout test for Standard calculator, and added the supporting framework

* Added some functional tests for Scientific mode.

* Basic Scientific Mode functional tests, added solution to set Angle Operator button correctly.

* Created functions to resize the app to display history panel, to display history button, display memory panel, and memory button.  Then I applied them to reduce areas with rewritten code, and to help with over all test stability and speed.

* I added the trigonometry functional tests

* Pull from latetest master, and retargeted solution

* Added a GetCalculatorWindowPostion function, when resizing window to show history/memory label, set window position to (0,0), and the same when resizing KOT calculator.  This will make tests more stable by keeping calculator on screen. It will also help with any testing that may require tracking the apps postion. To fix a test failure, changed function from ResizeToDiplayHistoryButton to ResizeToNotDisplayHistoryLabel.

* Sorted Using Statements, modified .gitignore to ignore **src/out, etc...

* Merged CalcMemoryFlyout into MemoryPanel, and deleted CalcMemoryFlyout. Merged CalcHistoryFlyout in HistoryPanel, and deleted CalcMemory.  Created GlobalCalculatorUI.cs.  Updated tests to work with these changes.

* hold on to changes

* Changed all KOT to Aot,
Removed equal button click in Test Cleanup/History method uses page source,
Removed extra line in Calculator.vcxproj.filters, Removed Try/Catch in the ClearHistory method

* Removed unused elses
Added CalculatorResults class
Added StandardAoTCalculatorPage
Removed manual test case info in the comments

* - In test framework, where it worked,
made some elements private
- Created EnsureCalculatorHasFocus() in GlobalCalculatorUI.cs
- Due to new classes, moved some methods to more correct classes
- Moved "page.MemoryPanel.ResizeWindowToDiplayMemoryLabel();" from
SetupCalculatorSession() to ClassInitialize()

* Sorted Using

* Updating fork from latest master

* Don't stand so

* Minor edits, fixing things from PR comments

* Merging scientific and standard mode tests, minor merge conflict fixes

* Method work
- Created ResizeAoTWindowToDiplayInvertButton()
    - Applied to test method AoT_ErrorMessage()
- Added page.ScientificOperators.ResetFEButton(fEButtonState.Normal);
to TestIniT in ScientificModeFunctionalTests
- Fixed if statement in public void ResetFEButton(fEButtonState value)

* Added StandardOperatorsPanel and removed duplicated code

* Created tests for Programmer mode, fixed a typo that appeared in multiple locations

* Fixed clear entry not working in Scientific test

* This time I really fixed the problem with clear memory not being found every time

* Revert shared changes

* Rebased onto master and resolved conflicts

* Fixed the 15 second delay on every scientific mode test

* Greatly shortened bitflipkeypad test

Co-authored-by: Crystal Edwards (Insight Global Inc) <v-credwa@microsoft.com>
Co-authored-by: Crystal Edwards <45952655+v-credwa@users.noreply.github.com>
This commit is contained in:
Daniel-Parker
2020-04-28 10:54:55 -07:00
committed by GitHub
parent fcbea550c8
commit 2cafb0dc88
16 changed files with 2047 additions and 21 deletions

View File

@@ -1,22 +1,19 @@
<Project Sdk="Microsoft.NET.Sdk">
<Project Sdk="Microsoft.NET.Sdk" ToolsVersion="Current">
<PropertyGroup>
<TargetFramework>netcoreapp2.1</TargetFramework>
<IsPackable>false</IsPackable>
<UpgradeBackupLocation>C:\Users\v-dapark\Source\Repos\Daniel-Parker\calculator\src\Backup\CalculatorUITests\</UpgradeBackupLocation>
<OldToolsVersion>2.0</OldToolsVersion>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.0.1" />
<PackageReference Include="MSTest.TestAdapter" Version="1.4.0" />
<PackageReference Include="MSTest.TestFramework" Version="1.4.0" />
<PackageReference Include="Appium.WebDriver" Version="4.0.0.6-beta" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\CalculatorUITestFramework\CalculatorUITestFramework.csproj" />
</ItemGroup>
<ItemGroup>
<None Update="CalculatorUITests.release.runsettings">
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
@@ -25,5 +22,4 @@
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</None>
</ItemGroup>
</Project>
</Project>

View File

@@ -0,0 +1,892 @@
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
using CalculatorUITestFramework;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using OpenQA.Selenium;
using OpenQA.Selenium.Appium.Windows;
using System;
using System.Collections.Generic;
namespace CalculatorUITests
{
[TestClass]
public class ProgrammerModeFunctionalTests
{
private static ProgrammerCalculatorPage page = new ProgrammerCalculatorPage();
/// <summary>
/// Initializes the WinAppDriver web driver session.
/// </summary>
/// <param name="context"></param>
[ClassInitialize]
public static void ClassInitialize(TestContext context)
{
// Create session to launch a Calculator window
WinAppDriver.Instance.SetupCalculatorSession(context);
// Ensure that calculator is in programmer mode
page.NavigateToProgrammerCalculator();
// Ensure that calculator window is large enough to display the memory/history panel; a good size for most tests
page.MemoryPanel.ResizeWindowToDisplayMemoryLabel();
}
/// <summary>
/// Closes the app and WinAppDriver web driver session.
/// </summary>
[ClassCleanup]
public static void ClassCleanup()
{
// Tear down Calculator session.
WinAppDriver.Instance.TearDownCalculatorSession();
}
/// <summary>
/// Ensures the calculator is in a cleared state with the correct default options
/// </summary>
[TestInitialize]
public void TestInit()
{
if ("0" != page.CalculatorResults.GetCalculatorResultText())
{
page.ClearAll();
}
CalculatorApp.EnsureCalculatorHasFocus();
page.ProgrammerOperators.SetArithmeticShift();
page.ProgrammerOperators.ResetWordSize();
page.ProgrammerOperators.ResetNumberSystem();
}
[TestCleanup]
public void TestCleanup()
{
page.ClearAll();
}
/// <summary>
/// Arithmetic shift, decimal notation, QWord
/// </summary>
#region Smoke Tests
[TestMethod]
[Priority(0)]
public void SmokeTest_Arithmetic_Decimal_LeftShift()
{
page.StandardOperators.NumberPad.Input(5);
page.ProgrammerOperators.LeftShiftButton.Click();
page.StandardOperators.NumberPad.Input(1);
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("10", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(0)]
public void SmokeTest_Arithmetic_Decimal_RightShift()
{
page.StandardOperators.NumberPad.Input(25);
page.StandardOperators.NegateButton.Click();
page.ProgrammerOperators.RightShiftButton.Click();
page.StandardOperators.NumberPad.Input(1);
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("-13", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(0)]
public void SmokeTest_Arithmetic_Decimal_And()
{
page.StandardOperators.NumberPad.Input(25);
page.ProgrammerOperators.BitwiseButton.Click();
page.ProgrammerOperators.AndButton.Click();
page.StandardOperators.NumberPad.Input(7);
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("1", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(0)]
public void SmokeTest_Arithmetic_Decimal_Nand()
{
page.StandardOperators.NumberPad.Input(25);
page.ProgrammerOperators.BitwiseButton.Click();
page.ProgrammerOperators.NandButton.Click();
page.StandardOperators.NumberPad.Input(7);
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("-2", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(0)]
public void SmokeTest_Arithmetic_Decimal_Or()
{
page.StandardOperators.NumberPad.Input(25);
page.ProgrammerOperators.BitwiseButton.Click();
page.ProgrammerOperators.OrButton.Click();
page.StandardOperators.NumberPad.Input(7);
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("31", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(0)]
public void SmokeTest_Arithmetic_Decimal_Nor()
{
page.StandardOperators.NumberPad.Input(25);
page.ProgrammerOperators.BitwiseButton.Click();
page.ProgrammerOperators.NorButton.Click();
page.StandardOperators.NumberPad.Input(7);
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("-32", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(0)]
public void SmokeTest_Arithmetic_Decimal_Not()
{
page.StandardOperators.NumberPad.Input(25);
page.ProgrammerOperators.BitwiseButton.Click();
page.ProgrammerOperators.NotButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("-26", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(0)]
public void SmokeTest_Arithmetic_Decimal_Xor()
{
page.StandardOperators.NumberPad.Input(25);
page.ProgrammerOperators.BitwiseButton.Click();
page.ProgrammerOperators.XorButton.Click();
page.StandardOperators.NumberPad.Input(7);
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("30", page.CalculatorResults.GetCalculatorResultText());
}
/// <summary>
/// Checks for the highest value bit that should be enabled according to the Word size setting
/// </summary>
[TestMethod]
[Priority(0)]
public void SmokeTest_WordSize()
{
page.ProgrammerOperators.BitFlip.Click();
if (page.ProgrammerOperators.Bit63.GetAttribute("IsEnabled") != "True")
{
throw new NotFoundException("According to the current Word size setting, some bits that should be enabled are disabled");
}
else
{
page.ProgrammerOperators.QWordButton.Click();
if (page.ProgrammerOperators.Bit31.GetAttribute("IsEnabled") != "True")
{
throw new NotFoundException("According to the current Word size setting, some bits that should be enabled are disabled");
}
else
{
page.ProgrammerOperators.DWordButton.Click();
if (page.ProgrammerOperators.Bit15.GetAttribute("IsEnabled") != "True")
{
throw new NotFoundException("According to the current Word size setting, some bits that should be enabled are disabled");
}
else
{
page.ProgrammerOperators.WordButton.Click();
if (page.ProgrammerOperators.Bit7.GetAttribute("IsEnabled") != "True")
{
throw new NotFoundException("According to the current Word size setting, some bits that should be enabled are disabled");
}
else
{
page.ProgrammerOperators.ByteButton.Click();
if (page.ProgrammerOperators.Bit63.GetAttribute("IsEnabled") != "True")
{
throw new NotFoundException("According to the current Word size setting, some bits that should be enabled are disabled");
}
}
}
}
page.ProgrammerOperators.FullKeypad.Click();
}
}
/// <summary>
/// Toggles each bit on and off
/// </summary>
[TestMethod]
[Priority(0)]
public void SmokeTest_BitFlipKeypad()
{
page.ProgrammerOperators.BitFlip.Click();
page.ProgrammerOperators.Bit63.Click();
Assert.AreEqual("-9,223,372,036,854,775,808", page.CalculatorResults.GetCalculatorResultText());
page.ProgrammerOperators.FullKeypad.Click();
}
#endregion
/// <summary>
/// Arithmetic shift, octal notation, QWord
/// </summary>
#region Arithmetic logic operators
[TestMethod]
[Priority(1)]
public void Arithmetic_Operator_Octal_LeftShift()
{
page.ProgrammerOperators.OctButton.Click();
page.StandardOperators.NumberPad.Input(7);
page.ProgrammerOperators.LeftShiftButton.Click();
page.StandardOperators.NumberPad.Input(1);
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("1 6", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Arithmetic_Operator_Octal_RightShift()
{
page.ProgrammerOperators.OctButton.Click();
page.StandardOperators.NumberPad.Input(25);
page.StandardOperators.NegateButton.Click();
page.ProgrammerOperators.RightShiftButton.Click();
page.StandardOperators.NumberPad.Input(1);
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("1 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 6 5", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Arithmetic_Operator_Octal_And()
{
page.ProgrammerOperators.OctButton.Click();
page.StandardOperators.NumberPad.Input(16);
page.ProgrammerOperators.BitwiseButton.Click();
page.ProgrammerOperators.AndButton.Click();
page.StandardOperators.NumberPad.Input(7);
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("6", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Arithmetic_Operator_Octal_Nand()
{
page.ProgrammerOperators.OctButton.Click();
page.StandardOperators.NumberPad.Input(16);
page.ProgrammerOperators.BitwiseButton.Click();
page.ProgrammerOperators.NandButton.Click();
page.StandardOperators.NumberPad.Input(7);
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("1 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 1", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Arithmetic_Operator_Octal_Or()
{
page.ProgrammerOperators.OctButton.Click();
page.StandardOperators.NumberPad.Input(16);
page.ProgrammerOperators.BitwiseButton.Click();
page.ProgrammerOperators.OrButton.Click();
page.StandardOperators.NumberPad.Input(7);
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("1 7", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Arithmetic_Operator_Octal_Nor()
{
page.ProgrammerOperators.OctButton.Click();
page.StandardOperators.NumberPad.Input(16);
page.ProgrammerOperators.BitwiseButton.Click();
page.ProgrammerOperators.NorButton.Click();
page.StandardOperators.NumberPad.Input(7);
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("1 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 6 0", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Arithmetic_Operator_Octal_Not()
{
page.ProgrammerOperators.OctButton.Click();
page.StandardOperators.NumberPad.Input(16);
page.ProgrammerOperators.BitwiseButton.Click();
page.ProgrammerOperators.NotButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("1 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 6 1", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Arithmetic_Operator_Octal_Xor()
{
page.ProgrammerOperators.OctButton.Click();
page.StandardOperators.NumberPad.Input(16);
page.ProgrammerOperators.BitwiseButton.Click();
page.ProgrammerOperators.XorButton.Click();
page.StandardOperators.NumberPad.Input(7);
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("1 1", page.CalculatorResults.GetCalculatorResultText());
}
/// <summary>
/// Arithmetic shift, binary notation, QWord
/// </summary>
[TestMethod]
[Priority(1)]
public void Arithmetic_Operator_Binary_LeftShift()
{
page.ProgrammerOperators.BinButton.Click();
page.StandardOperators.NumberPad.Input(1010);
page.ProgrammerOperators.LeftShiftButton.Click();
page.StandardOperators.NumberPad.Input(1);
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("1 0 1 0 0", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Arithmetic_Operator_Binary_RightShift()
{
page.ProgrammerOperators.BinButton.Click();
page.StandardOperators.NumberPad.Input(1010);
page.ProgrammerOperators.RightShiftButton.Click();
page.StandardOperators.NumberPad.Input(1);
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("1 0 1", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Arithmetic_Operator_Binary_And()
{
page.ProgrammerOperators.BinButton.Click();
page.StandardOperators.NumberPad.Input(1010);
page.ProgrammerOperators.BitwiseButton.Click();
page.ProgrammerOperators.AndButton.Click();
page.StandardOperators.NumberPad.Input(1000);
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("1 0 0 0", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Arithmetic_Operator_Binary_Nand()
{
page.ProgrammerOperators.BinButton.Click();
page.StandardOperators.NumberPad.Input(1010);
page.ProgrammerOperators.BitwiseButton.Click();
page.ProgrammerOperators.NandButton.Click();
page.StandardOperators.NumberPad.Input(1000);
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Arithmetic_Operator_Binary_Or()
{
page.ProgrammerOperators.BinButton.Click();
page.StandardOperators.NumberPad.Input(1010);
page.ProgrammerOperators.BitwiseButton.Click();
page.ProgrammerOperators.OrButton.Click();
page.StandardOperators.NumberPad.Input(1100);
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("1 1 1 0", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Arithmetic_Operator_Binary_Nor()
{
page.ProgrammerOperators.BinButton.Click();
page.StandardOperators.NumberPad.Input(1010);
page.ProgrammerOperators.BitwiseButton.Click();
page.ProgrammerOperators.NorButton.Click();
page.StandardOperators.NumberPad.Input(1100);
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 1", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Arithmetic_Operator_Binary_Not()
{
page.ProgrammerOperators.BinButton.Click();
page.StandardOperators.NumberPad.Input(1010);
page.ProgrammerOperators.BitwiseButton.Click();
page.ProgrammerOperators.NotButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 1", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Arithmetic_Operator_Binary_Xor()
{
page.ProgrammerOperators.BinButton.Click();
page.StandardOperators.NumberPad.Input(1010);
page.ProgrammerOperators.BitwiseButton.Click();
page.ProgrammerOperators.XorButton.Click();
page.StandardOperators.NumberPad.Input(1100);
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("1 1 0", page.CalculatorResults.GetCalculatorResultText());
}
/// <summary>
/// Arithmetic shift, hexadecimal notation, QWord
/// </summary>
[TestMethod]
[Priority(1)]
public void Arithmetic_Operator_Hex_LeftShift()
{
page.ProgrammerOperators.HexButton.Click();
page.ProgrammerOperators.AButton.Click();
page.ProgrammerOperators.LeftShiftButton.Click();
page.ProgrammerOperators.BButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("5 0 0 0", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Arithmetic_Operator_Hex_RightShift()
{
page.ProgrammerOperators.HexButton.Click();
page.ProgrammerOperators.FButton.Click();
page.ProgrammerOperators.RightShiftButton.Click();
page.StandardOperators.NumberPad.Input(2);
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("3", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Arithmetic_Operator_Hex_And()
{
page.ProgrammerOperators.HexButton.Click();
page.ProgrammerOperators.AButton.Click();
page.ProgrammerOperators.BButton.Click();
page.ProgrammerOperators.CButton.Click();
page.ProgrammerOperators.BitwiseButton.Click();
page.ProgrammerOperators.AndButton.Click();
page.ProgrammerOperators.FButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("C", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Arithmetic_Operator_Hex_Nand()
{
page.ProgrammerOperators.HexButton.Click();
page.ProgrammerOperators.AButton.Click();
page.ProgrammerOperators.BButton.Click();
page.ProgrammerOperators.CButton.Click();
page.ProgrammerOperators.BitwiseButton.Click();
page.ProgrammerOperators.NandButton.Click();
page.ProgrammerOperators.FButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("F F F F F F F F F F F F F F F 3", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Arithmetic_Operator_Hex_Or()
{
page.ProgrammerOperators.HexButton.Click();
page.ProgrammerOperators.AButton.Click();
page.ProgrammerOperators.BButton.Click();
page.ProgrammerOperators.CButton.Click();
page.ProgrammerOperators.BitwiseButton.Click();
page.ProgrammerOperators.OrButton.Click();
page.ProgrammerOperators.FButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("A B F", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Arithmetic_Operator_Hex_Nor()
{
page.ProgrammerOperators.HexButton.Click();
page.ProgrammerOperators.AButton.Click();
page.ProgrammerOperators.BButton.Click();
page.ProgrammerOperators.CButton.Click();
page.ProgrammerOperators.BitwiseButton.Click();
page.ProgrammerOperators.NorButton.Click();
page.ProgrammerOperators.FButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("F F F F F F F F F F F F F 5 4 0", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Arithmetic_Operator_Hex_Not()
{
page.ProgrammerOperators.HexButton.Click();
page.ProgrammerOperators.AButton.Click();
page.ProgrammerOperators.BButton.Click();
page.ProgrammerOperators.CButton.Click();
page.ProgrammerOperators.BitwiseButton.Click();
page.ProgrammerOperators.NotButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("F F F F F F F F F F F F F 5 4 3", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Arithmetic_Operator_Hex_Xor()
{
page.ProgrammerOperators.HexButton.Click();
page.ProgrammerOperators.AButton.Click();
page.ProgrammerOperators.BButton.Click();
page.ProgrammerOperators.CButton.Click();
page.ProgrammerOperators.BitwiseButton.Click();
page.ProgrammerOperators.XorButton.Click();
page.ProgrammerOperators.FButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("A B 3", page.CalculatorResults.GetCalculatorResultText());
}
#endregion
/// <summary>
/// Logical shift, decimal notation, QWord - AND/NAND/OR/NOR/NOT/XOR will always be the same regardless of what shift setting is selected, so the previous section should have those covered
/// </summary>
#region Logical-shift operators
[TestMethod]
[Priority(1)]
public void Logical_Operator_Decimal_LeftShift()
{
page.ProgrammerOperators.SetLogicalShift();
page.StandardOperators.NumberPad.Input(7);
page.ProgrammerOperators.LeftShiftLogicalButton.Click();
page.StandardOperators.NumberPad.Input(1);
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("14", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Logical_Operator_Decimal_RightShift()
{
page.ProgrammerOperators.SetLogicalShift();
page.StandardOperators.NumberPad.Input(16);
page.StandardOperators.NegateButton.Click();
page.ProgrammerOperators.RightShiftLogicalButton.Click();
page.StandardOperators.NumberPad.Input(1);
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("9,223,372,036,854,775,800", page.CalculatorResults.GetCalculatorResultText());
}
/// <summary>
/// Logical shift, octal notation, QWord
/// </summary>
[TestMethod]
[Priority(1)]
public void Logical_Operator_Octal_LeftShift()
{
page.ProgrammerOperators.OctButton.Click();
page.ProgrammerOperators.SetLogicalShift();
page.StandardOperators.NumberPad.Input(7);
page.ProgrammerOperators.LeftShiftLogicalButton.Click();
page.StandardOperators.NumberPad.Input(1);
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("1 6", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Logical_Operator_Octal_RightShift()
{
page.ProgrammerOperators.OctButton.Click();
page.ProgrammerOperators.SetLogicalShift();
page.StandardOperators.NumberPad.Input(16);
page.StandardOperators.NegateButton.Click();
page.ProgrammerOperators.RightShiftLogicalButton.Click();
page.StandardOperators.NumberPad.Input(1);
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 1", page.CalculatorResults.GetCalculatorResultText());
}
/// <summary>
/// Logical shift, binary notation, QWord
/// </summary>
[TestMethod]
[Priority(1)]
public void Logical_Operator_Binary_LeftShift()
{
page.ProgrammerOperators.BinButton.Click();
page.ProgrammerOperators.SetLogicalShift();
page.StandardOperators.NumberPad.Input(1010);
page.ProgrammerOperators.LeftShiftLogicalButton.Click();
page.StandardOperators.NumberPad.Input(1);
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("1 0 1 0 0", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Logical_Operator_Binary_RightShift()
{
page.ProgrammerOperators.BinButton.Click();
page.ProgrammerOperators.SetLogicalShift();
page.StandardOperators.NumberPad.Input(1010);
page.StandardOperators.NegateButton.Click();
page.ProgrammerOperators.RightShiftLogicalButton.Click();
page.StandardOperators.NumberPad.Input(1);
page.StandardOperators.EqualButton.Click();
Assert.IsTrue(String.Equals(page.CalculatorResults.GetCalculatorResultText(), "1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1", StringComparison.OrdinalIgnoreCase));
}
/// <summary>
/// Logical shift, hexadecimal notation, QWord
/// </summary>
[TestMethod]
[Priority(1)]
public void Logical_Operator_Hex_LeftShift()
{
page.ProgrammerOperators.HexButton.Click();
page.ProgrammerOperators.SetLogicalShift();
page.ProgrammerOperators.AButton.Click();
page.ProgrammerOperators.LeftShiftLogicalButton.Click();
page.ProgrammerOperators.BButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("5 0 0 0", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Logical_Operator_Hex_RightShift()
{
page.ProgrammerOperators.HexButton.Click();
page.ProgrammerOperators.SetLogicalShift();
page.ProgrammerOperators.FButton.Click();
page.StandardOperators.NegateButton.Click();
page.ProgrammerOperators.RightShiftLogicalButton.Click();
page.StandardOperators.NumberPad.Input(1);
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("7 F F F F F F F F F F F F F F 8", page.CalculatorResults.GetCalculatorResultText());
}
#endregion
/// <summary>
/// Rotate circular shift, decimal notation, QWord
/// </summary>
#region Rotate-Circular-shift operators
[TestMethod]
[Priority(1)]
public void Circular_Operator_Decimal_LeftShift()
{
page.ProgrammerOperators.SetRotateCircularShift();
page.StandardOperators.NumberPad.Input(7);
page.ProgrammerOperators.RoLButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("14", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Circular_Operator_Decimal_RightShift()
{
page.ProgrammerOperators.SetRotateCircularShift();
page.StandardOperators.NumberPad.Input(16);
page.StandardOperators.NegateButton.Click();
page.ProgrammerOperators.RoRButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("9,223,372,036,854,775,800", page.CalculatorResults.GetCalculatorResultText());
}
/// <summary>
/// Rotate circular shift, octal notation, QWord
/// </summary>
[TestMethod]
[Priority(1)]
public void Circular_Operator_Octal_LeftShift()
{
page.ProgrammerOperators.OctButton.Click();
page.ProgrammerOperators.SetRotateCircularShift();
page.StandardOperators.NumberPad.Input(25);
page.ProgrammerOperators.RoLButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("5 2", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Circular_Operator_Octal_RightShift()
{
page.ProgrammerOperators.OctButton.Click();
page.ProgrammerOperators.SetRotateCircularShift();
page.StandardOperators.NumberPad.Input(25);
page.ProgrammerOperators.RoRButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 2", page.CalculatorResults.GetCalculatorResultText());
}
/// <summary>
/// Rotate circular shift, binary notation, QWord
/// </summary>
[TestMethod]
[Priority(1)]
public void Circular_Operator_Binary_LeftShift()
{
page.ProgrammerOperators.BinButton.Click();
page.ProgrammerOperators.SetRotateCircularShift();
page.StandardOperators.NumberPad.Input(1011);
page.ProgrammerOperators.RoLButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("1 0 1 1 0", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Circular_Operator_Binary_RightShift()
{
page.ProgrammerOperators.BinButton.Click();
page.ProgrammerOperators.SetRotateCircularShift();
page.StandardOperators.NumberPad.Input(1011);
page.ProgrammerOperators.RoRButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1", page.CalculatorResults.GetCalculatorResultText());
}
/// <summary>
/// Rotate circular shift, hexadecimal notation, QWord
/// </summary>
[TestMethod]
[Priority(1)]
public void Circular_Operator_Hex_LeftShift()
{
page.ProgrammerOperators.HexButton.Click();
page.ProgrammerOperators.SetRotateCircularShift();
page.ProgrammerOperators.AButton.Click();
page.ProgrammerOperators.RoLButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("1 4", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Circular_Operator_Hex_RightShift()
{
page.ProgrammerOperators.HexButton.Click();
page.ProgrammerOperators.SetRotateCircularShift();
page.ProgrammerOperators.FButton.Click();
page.ProgrammerOperators.RoRButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("8 0 0 0 0 0 0 0 0 0 0 0 0 0 0 7", page.CalculatorResults.GetCalculatorResultText());
}
#endregion
/// <summary>
/// Rotate through carry circular shift, decimal notation, QWord
/// </summary>
#region Rotate-Through-Carry-Circular-shift operators
[TestMethod]
[Priority(1)]
public void ThroughCarry_Operator_Decimal_LeftShift()
{
page.ProgrammerOperators.SetRotateThroughCarryCircularShift();
page.StandardOperators.NumberPad.Input(7);
page.StandardOperators.NegateButton.Click();
page.ProgrammerOperators.RoLButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("-14", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void ThroughCarry_Operator_Decimal_RightShift()
{
page.ProgrammerOperators.SetRotateThroughCarryCircularShift();
page.StandardOperators.NumberPad.Input(17);
page.ProgrammerOperators.RoRCarryButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("8", page.CalculatorResults.GetCalculatorResultText());
}
/// <summary>
/// Rotate through carry circular shift, octal notation, QWord
/// </summary>
[TestMethod]
[Priority(1)]
public void ThroughCarry_Operator_Octal_LeftShift()
{
page.ProgrammerOperators.OctButton.Click();
page.ProgrammerOperators.SetRotateThroughCarryCircularShift();
page.StandardOperators.NumberPad.Input(111);
page.ProgrammerOperators.RoLButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("2 2 2", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void ThroughCarry_Operator_Octal_RightShift()
{
page.ProgrammerOperators.OctButton.Click();
page.ProgrammerOperators.SetRotateThroughCarryCircularShift();
page.StandardOperators.NumberPad.Input(111);
page.ProgrammerOperators.RoRCarryButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("4 4", page.CalculatorResults.GetCalculatorResultText());
}
/// <summary>
/// Rotate through carry circular shift, binary notation, QWord
/// </summary>
[TestMethod]
[Priority(1)]
public void ThroughCarry_Operator_Binary_LeftShift()
{
page.ProgrammerOperators.BinButton.Click();
page.ProgrammerOperators.SetRotateThroughCarryCircularShift();
page.StandardOperators.NumberPad.Input(1010);
page.ProgrammerOperators.RoLButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("1 0 1 0 0", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void ThroughCarry_Operator_Binary_RightShift()
{
page.ProgrammerOperators.BinButton.Click();
page.ProgrammerOperators.SetRotateThroughCarryCircularShift();
page.StandardOperators.NumberPad.Input(1011);
page.ProgrammerOperators.RoRCarryButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("1 0 1", page.CalculatorResults.GetCalculatorResultText());
}
/// <summary>
/// Rotate through carry circular shift, hexadecimal notation, QWord
/// </summary>
[TestMethod]
[Priority(1)]
public void ThroughCarry_Operator_Hex_LeftShift()
{
page.ProgrammerOperators.HexButton.Click();
page.ProgrammerOperators.SetRotateThroughCarryCircularShift();
page.StandardOperators.NumberPad.Input(1010);
page.ProgrammerOperators.RoLButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("2 0 2 0", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void ThroughCarry_Operator_Hex_RightShift()
{
page.ProgrammerOperators.HexButton.Click();
page.ProgrammerOperators.SetRotateThroughCarryCircularShift();
page.StandardOperators.NumberPad.Input(1010);
page.ProgrammerOperators.RoRCarryButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("8 0 8", page.CalculatorResults.GetCalculatorResultText());
}
#endregion
}
}

View File

@@ -0,0 +1,621 @@
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
using CalculatorUITestFramework;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using OpenQA.Selenium;
using OpenQA.Selenium.Appium.Windows;
using System;
using System.Collections.Generic;
namespace CalculatorUITests
{
[TestClass]
public class ScientificModeFunctionalTests
{
private static ScientificCalculatorPage page = new ScientificCalculatorPage();
/// <summary>
/// Initializes the WinAppDriver web driver session.
/// </summary>
/// <param name="context"></param>
[ClassInitialize]
public static void ClassInitialize(TestContext context)
{
// Create session to launch a Calculator window
WinAppDriver.Instance.SetupCalculatorSession(context);
// Ensure that calculator is in scientific mode
page.NavigateToScientificCalculator();
// Ensure that calculator window is large enough to display the memory/history panel; a good size for most tests
page.MemoryPanel.ResizeWindowToDisplayMemoryLabel();
}
/// <summary>
/// Closes the app and WinAppDriver web driver session.
/// </summary>
[ClassCleanup]
public static void ClassCleanup()
{
// Tear down Calculator session.
WinAppDriver.Instance.TearDownCalculatorSession();
}
/// <summary>
/// Ensures the calculator is in a cleared state
/// </summary>
[TestInitialize]
public void TestInit()
{
if ("0" != page.CalculatorResults.GetCalculatorResultText())
{
page.ClearAll();
}
CalculatorApp.EnsureCalculatorHasFocus();
page.ScientificOperators.SetAngleOperator(AngleOperatorState.Degrees);
page.ScientificOperators.ResetFEButton(fEButtonState.Normal);
}
[TestCleanup]
public void TestCleanup()
{
page.ClearAll();
}
#region Smoke Tests
[TestMethod]
[Priority(0)]
public void SmokeTest_Cube()
{
page.StandardOperators.NumberPad.Input(3);
page.ScientificOperators.XPower3Button.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("27", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(0)]
public void SmokeTest_Sin()
{
page.StandardOperators.NumberPad.Input(90);
page.ScientificOperators.TrigButton.Click();
page.ScientificOperators.SinButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("1", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(0)]
public void SmokeTest_Tanh()
{
page.StandardOperators.NumberPad.Input(90);
page.ScientificOperators.TrigButton.Click();
page.ScientificOperators.HypShiftButton.Click();
page.ScientificOperators.TanhButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("1", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(0)]
public void SmokeTest_InvCos()
{
page.StandardOperators.NumberPad.Input(1);
page.ScientificOperators.TrigButton.Click();
page.ScientificOperators.TrigShiftButton.Click();
page.ScientificOperators.InvCosButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("0", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(0)]
public void SmokeTest_Floor()
{
page.StandardOperators.NumberPad.Input(5.9);
page.ScientificOperators.FuncButton.Click();
page.ScientificOperators.FloorButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("5", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(0)]
public void SmokeTest_Parentheses()
{
page.StandardOperators.NumberPad.Input(3);
page.StandardOperators.MultiplyButton.Click();
page.ScientificOperators.ParenthesisLeftButton.Click();
page.StandardOperators.NumberPad.Input(2);
page.StandardOperators.PlusButton.Click();
page.StandardOperators.NumberPad.Input(2);
page.ScientificOperators.ParenthesisRightButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("12", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(0)]
public void SmokeTest_RadianAngleOperator()
{
page.ScientificOperators.SetAngleOperator(AngleOperatorState.Radians);
page.ScientificOperators.PiButton.Click();
page.ScientificOperators.TrigButton.Click();
page.ScientificOperators.CosButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("-1", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(0)]
public void SmokeTest_GradianAngleOperator()
{
page.ScientificOperators.SetAngleOperator(AngleOperatorState.Gradians);
page.StandardOperators.NumberPad.Input(100);
page.ScientificOperators.TrigButton.Click();
page.ScientificOperators.SinButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("1", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(0)]
public void SmokeTest_FixedToExponential()
{
page.ScientificOperators.FixedToExponentialButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("0.e+0", page.CalculatorResults.GetCalculatorResultText());
}
#endregion
#region Advanced Arithmetic Tests
[TestMethod]
[Priority(1)]
public void Operator_XPowerY()
{
page.StandardOperators.NumberPad.Input(3);
page.ScientificOperators.XPowerYButton.Click();
page.StandardOperators.NumberPad.Input(5);
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("243", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Operator_PowerOf10Button()
{
page.StandardOperators.NumberPad.Input(5);
page.ScientificOperators.PowerOf10Button.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("100,000", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Operator_LogButton()
{
page.StandardOperators.NumberPad.Input(10000);
page.ScientificOperators.LogButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("4", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Operator_LnButton()
{
page.ScientificOperators.EulerButton.Click();
page.ScientificOperators.LnButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("1", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Operator_AbsButton()
{
page.StandardOperators.NumberPad.Input(25);
page.ScientificOperators.NegateButton.Click();
page.ScientificOperators.AbsButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("25", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Operator_ExpButton()
{
page.StandardOperators.NumberPad.Input(4);
page.ScientificOperators.ExpButton.Click();
page.StandardOperators.NumberPad.Input(4);
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("40,000", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Operator_ModButton()
{
page.StandardOperators.NumberPad.Input(53);
page.ScientificOperators.ModButton.Click();
page.StandardOperators.NumberPad.Input(10);
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("3", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Operator_FactorialButton()
{
page.StandardOperators.NumberPad.Input(4);
page.ScientificOperators.FactorialButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("24", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Operator_CeilingButton()
{
page.StandardOperators.NumberPad.Input(4.1);
page.ScientificOperators.FuncButton.Click();
page.ScientificOperators.CeilButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("5", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Operator_RandomButton()
{
page.ScientificOperators.FuncButton.Click();
page.ScientificOperators.RandButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.IsTrue(page.CalculatorResults.GetCalculatorResultText().StartsWith("0."));
}
[TestMethod]
[Priority(1)]
public void Operator_DmsButton()
{
page.StandardOperators.NumberPad.Input(2.999);
page.ScientificOperators.FuncButton.Click();
page.ScientificOperators.DmsButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("2.59564", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(1)]
public void Operator_DegreesButton()
{
page.StandardOperators.NumberPad.Input(2.59564);
page.ScientificOperators.FuncButton.Click();
page.ScientificOperators.DegreesButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("2.999", page.CalculatorResults.GetCalculatorResultText());
}
#endregion
#region Trigonometry Tests
[TestMethod]
[Priority(2)]
public void Trig_CosButton()
{
page.StandardOperators.NumberPad.Input(180);
page.ScientificOperators.TrigButton.Click();
page.ScientificOperators.CosButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("-1", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(2)]
public void Trig_TanButton()
{
page.ScientificOperators.SetAngleOperator(AngleOperatorState.Degrees);
page.StandardOperators.NumberPad.Input(45);
page.ScientificOperators.TrigButton.Click();
page.ScientificOperators.TanButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("1", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(2)]
public void Trig_SecButton()
{
page.ScientificOperators.SetAngleOperator(AngleOperatorState.Degrees);
page.StandardOperators.NumberPad.Input(180);
page.ScientificOperators.TrigButton.Click();
page.ScientificOperators.SecButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("-1", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(2)]
public void Trig_CscButton()
{
page.ScientificOperators.SetAngleOperator(AngleOperatorState.Degrees);
page.StandardOperators.NumberPad.Input(90);
page.ScientificOperators.TrigButton.Click();
page.ScientificOperators.CscButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("1", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(2)]
public void Trig_CotButton()
{
page.ScientificOperators.SetAngleOperator(AngleOperatorState.Degrees);
page.StandardOperators.NumberPad.Input(45);
page.ScientificOperators.TrigButton.Click();
page.ScientificOperators.CotButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("1", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(2)]
public void Trig_InvSinButton()
{
page.ScientificOperators.SetAngleOperator(AngleOperatorState.Degrees);
page.StandardOperators.NumberPad.Input(1);
page.ScientificOperators.TrigButton.Click();
page.ScientificOperators.TrigShiftButton.Click();
page.ScientificOperators.InvSinButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("90", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(2)]
public void Trig_InvTanButton()
{
page.ScientificOperators.SetAngleOperator(AngleOperatorState.Degrees);
page.StandardOperators.NumberPad.Input(1);
page.ScientificOperators.TrigButton.Click();
page.ScientificOperators.TrigShiftButton.Click();
page.ScientificOperators.InvTanButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("45", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(2)]
public void Trig_InvSecButton()
{
page.ScientificOperators.SetAngleOperator(AngleOperatorState.Degrees);
page.StandardOperators.NumberPad.Input(1);
page.ScientificOperators.NegateButton.Click();
page.ScientificOperators.TrigButton.Click();
page.ScientificOperators.TrigShiftButton.Click();
page.ScientificOperators.InvSecButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("180", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(2)]
public void Trig_InvCscButton()
{
page.ScientificOperators.SetAngleOperator(AngleOperatorState.Degrees);
page.StandardOperators.NumberPad.Input(1);
page.ScientificOperators.TrigButton.Click();
page.ScientificOperators.TrigShiftButton.Click();
page.ScientificOperators.InvCscButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("90", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(2)]
public void Trig_InvCotButton()
{
page.ScientificOperators.SetAngleOperator(AngleOperatorState.Degrees);
page.StandardOperators.NumberPad.Input(1);
page.ScientificOperators.TrigButton.Click();
page.ScientificOperators.TrigShiftButton.Click();
page.ScientificOperators.InvCotButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("45", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(2)]
public void Trig_SinhButton()
{
page.ScientificOperators.SetAngleOperator(AngleOperatorState.Degrees);
page.StandardOperators.NumberPad.Input(1);
page.ScientificOperators.TrigButton.Click();
page.ScientificOperators.HypShiftButton.Click();
page.ScientificOperators.SinhButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.IsTrue(page.CalculatorResults.GetCalculatorResultText().StartsWith("1.175201"));
}
[TestMethod]
[Priority(2)]
public void Trig_CoshButton()
{
page.ScientificOperators.SetAngleOperator(AngleOperatorState.Degrees);
page.StandardOperators.NumberPad.Input(1);
page.ScientificOperators.TrigButton.Click();
page.ScientificOperators.HypShiftButton.Click();
page.ScientificOperators.CoshButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.IsTrue(page.CalculatorResults.GetCalculatorResultText().StartsWith("1.54308"));
}
[TestMethod]
[Priority(2)]
public void Trig_SechButton()
{
page.ScientificOperators.SetAngleOperator(AngleOperatorState.Degrees);
page.StandardOperators.NumberPad.Input(1);
page.ScientificOperators.TrigButton.Click();
page.ScientificOperators.HypShiftButton.Click();
page.ScientificOperators.SechButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.IsTrue(page.CalculatorResults.GetCalculatorResultText().StartsWith("0.64805"));
}
[TestMethod]
[Priority(2)]
public void Trig_CschButton()
{
page.ScientificOperators.SetAngleOperator(AngleOperatorState.Degrees);
page.StandardOperators.NumberPad.Input(1);
page.ScientificOperators.TrigButton.Click();
page.ScientificOperators.HypShiftButton.Click();
page.ScientificOperators.CschButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.IsTrue(page.CalculatorResults.GetCalculatorResultText().StartsWith("0.850918"));
}
[TestMethod]
[Priority(2)]
public void Trig_CothButton()
{
page.ScientificOperators.SetAngleOperator(AngleOperatorState.Degrees);
page.StandardOperators.NumberPad.Input(45);
page.ScientificOperators.TrigButton.Click();
page.ScientificOperators.HypShiftButton.Click();
page.ScientificOperators.CothButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("1", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(2)]
public void Trig_InvSinhButton()
{
page.ScientificOperators.SetAngleOperator(AngleOperatorState.Degrees);
page.StandardOperators.NumberPad.Input(1);
page.ScientificOperators.TrigButton.Click();
page.ScientificOperators.TrigShiftButton.Click();
page.ScientificOperators.HypShiftButton.Click();
page.ScientificOperators.InvSinhButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.IsTrue(page.CalculatorResults.GetCalculatorResultText().StartsWith("0.881373"));
}
[TestMethod]
[Priority(2)]
public void Trig_InvCoshButton()
{
page.ScientificOperators.SetAngleOperator(AngleOperatorState.Degrees);
page.StandardOperators.NumberPad.Input(1);
page.ScientificOperators.TrigButton.Click();
page.ScientificOperators.TrigShiftButton.Click();
page.ScientificOperators.HypShiftButton.Click();
page.ScientificOperators.InvCoshButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("0", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(2)]
public void Trig_InvTanhButton()
{
page.ScientificOperators.SetAngleOperator(AngleOperatorState.Degrees);
page.StandardOperators.NumberPad.Input(0.0);
page.ScientificOperators.TrigButton.Click();
page.ScientificOperators.TrigShiftButton.Click();
page.ScientificOperators.HypShiftButton.Click();
page.ScientificOperators.InvTanhButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("0", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(2)]
public void Trig_InvSechButton()
{
page.ScientificOperators.SetAngleOperator(AngleOperatorState.Degrees);
page.StandardOperators.NumberPad.Input(1);
page.ScientificOperators.TrigButton.Click();
page.ScientificOperators.TrigShiftButton.Click();
page.ScientificOperators.HypShiftButton.Click();
page.ScientificOperators.InvSechButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.AreEqual("0", page.CalculatorResults.GetCalculatorResultText());
}
[TestMethod]
[Priority(2)]
public void Trig_InvCschButton()
{
page.ScientificOperators.SetAngleOperator(AngleOperatorState.Degrees);
page.StandardOperators.NumberPad.Input(1);
page.ScientificOperators.TrigButton.Click();
page.ScientificOperators.TrigShiftButton.Click();
page.ScientificOperators.HypShiftButton.Click();
page.ScientificOperators.InvCschButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.IsTrue(page.CalculatorResults.GetCalculatorResultText().StartsWith("0.881373"));
}
[TestMethod]
[Priority(2)]
public void Trig_InvCothButton()
{
page.ScientificOperators.SetAngleOperator(AngleOperatorState.Degrees);
page.StandardOperators.NumberPad.Input(2);
page.ScientificOperators.TrigButton.Click();
page.ScientificOperators.TrigShiftButton.Click();
page.ScientificOperators.HypShiftButton.Click();
page.ScientificOperators.InvCothButton.Click();
page.StandardOperators.EqualButton.Click();
Assert.IsTrue(page.CalculatorResults.GetCalculatorResultText().StartsWith("0.549306"));
}
#endregion
}
}