1145 lines
53 KiB
C++
1145 lines
53 KiB
C++
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// Licensed under the MIT License.
|
|
|
|
#include "pch.h"
|
|
#include <WexTestClass.h>
|
|
|
|
#include "CalcViewModel/StandardCalculatorViewModel.h"
|
|
#include "CalcViewModel/Common/CalculatorButtonPressedEventArgs.h"
|
|
|
|
#include "CalcViewModel/StandardCalculatorViewModel.h"
|
|
#include "CalcViewModel/Common/CalculatorButtonPressedEventArgs.h"
|
|
|
|
using namespace CalculationManager;
|
|
using namespace CalculatorApp;
|
|
using namespace CalculatorApp::Common;
|
|
using namespace CalculatorApp::ViewModel;
|
|
using namespace Platform;
|
|
|
|
namespace CalculatorUnitTests
|
|
{
|
|
|
|
void ChangeMode(StandardCalculatorViewModel^ viewModel, int mode)
|
|
{
|
|
if (mode == 0)
|
|
{
|
|
viewModel->IsStandard = true;
|
|
viewModel->IsScientific = false;
|
|
viewModel->IsProgrammer = false;
|
|
viewModel->ResetDisplay();
|
|
viewModel->SetPrecision(StandardModePrecision);
|
|
}
|
|
else if (mode == 1)
|
|
{
|
|
viewModel->IsScientific = true;
|
|
viewModel->IsProgrammer = false;
|
|
viewModel->IsStandard = false;
|
|
viewModel->ResetDisplay();
|
|
viewModel->SetPrecision(ScientificModePrecision);
|
|
}
|
|
else if (mode == 2)
|
|
{
|
|
viewModel->IsProgrammer = true;
|
|
viewModel->IsScientific = false;
|
|
viewModel->IsStandard = false;
|
|
viewModel->ResetDisplay();
|
|
viewModel->SetPrecision(ProgrammerModePrecision);
|
|
}
|
|
}
|
|
|
|
Object^ CommandParameterFromTestItem(TESTITEM* item)
|
|
{
|
|
// Need to wrap Binary Operators with their feedback
|
|
static const std::vector<std::pair<NumbersAndOperatorsEnum, String^>> binOps = {
|
|
{ NumbersAndOperatorsEnum::Add, L"plus" },
|
|
{ NumbersAndOperatorsEnum::Subtract, L"minus" },
|
|
{ NumbersAndOperatorsEnum::Multiply, L"times" },
|
|
{ NumbersAndOperatorsEnum::Divide, L"divided by" }
|
|
};
|
|
|
|
for (auto& binOp : binOps)
|
|
{
|
|
if (item->command == binOp.first)
|
|
{
|
|
return ref new CalculatorButtonPressedEventArgs(binOp.second, binOp.first);
|
|
}
|
|
}
|
|
|
|
return item->command;
|
|
}
|
|
|
|
void ValidateViewModelByCommands(StandardCalculatorViewModel^ viewModel, TESTITEM item[], bool doReset = false)
|
|
{
|
|
if (doReset)
|
|
{
|
|
viewModel->ButtonPressed->Execute(NumbersAndOperatorsEnum::Clear);
|
|
viewModel->ButtonPressed->Execute(NumbersAndOperatorsEnum::ClearEntry);
|
|
viewModel->ClearMemoryCommand->Execute(nullptr);
|
|
viewModel->Deserialize(ref new Platform::Array<unsigned char>(0));
|
|
}
|
|
|
|
TESTITEM* currentItem = item;
|
|
|
|
while (currentItem->command != NumbersAndOperatorsEnum::None)
|
|
{
|
|
Object^ commandParam = CommandParameterFromTestItem(currentItem);
|
|
viewModel->ButtonPressed->Execute(commandParam);
|
|
|
|
if (currentItem->expectedPrimaryDisplay != L"N/A")
|
|
{
|
|
VERIFY_ARE_EQUAL(Platform::StringReference(currentItem->expectedPrimaryDisplay.c_str()), viewModel->DisplayValue);
|
|
}
|
|
if (currentItem->expectedExpressions != L"N/A" && viewModel->DisplayStringExpression != nullptr)
|
|
{
|
|
VERIFY_ARE_EQUAL(Platform::StringReference(currentItem->expectedExpressions.c_str()), viewModel->DisplayStringExpression);
|
|
}
|
|
currentItem++;
|
|
}
|
|
}
|
|
|
|
class StandardViewModelUnitTests
|
|
{
|
|
public:
|
|
TEST_CLASS(StandardViewModelUnitTests);
|
|
|
|
TEST_METHOD_SETUP(InitializeViewModel)
|
|
{
|
|
m_viewModel = ref new StandardCalculatorViewModel();
|
|
m_viewModel->IsStandard = true;
|
|
m_engineResourceProvider = std::make_shared<EngineResourceProvider>();
|
|
m_decimalSeparator = ref new Platform::String(m_engineResourceProvider->GetCEngineString(L"sDecimal").c_str());
|
|
return true;
|
|
}
|
|
|
|
void ValidateViewModelValueAndExpression(String ^ value, String ^expression = nullptr)
|
|
{
|
|
String^ displayValue = m_viewModel->DisplayValue;
|
|
String^ displayExpression = m_viewModel->DisplayStringExpression;
|
|
if (value != nullptr)
|
|
{
|
|
VERIFY_ARE_EQUAL(value, displayValue);
|
|
}
|
|
|
|
if (expression != nullptr)
|
|
{
|
|
VERIFY_ARE_EQUAL(expression, displayExpression);
|
|
}
|
|
}
|
|
|
|
void ValidateViewModelValueAndSecondaryExpression(String ^ value, String ^expression = nullptr)
|
|
{
|
|
String^ displayValue = m_viewModel->DisplayValue;
|
|
|
|
unsigned int nTokens = m_viewModel->ExpressionTokens->Size;
|
|
String^ displaySecondaryExpression = ref new String();
|
|
|
|
for (unsigned int i = 0; i < nTokens; ++i)
|
|
{
|
|
DisplayExpressionToken^ currentToken;
|
|
currentToken = m_viewModel->ExpressionTokens->GetAt(i);
|
|
displaySecondaryExpression = String::Concat(displaySecondaryExpression, currentToken->Token);
|
|
}
|
|
|
|
if (value != nullptr)
|
|
{
|
|
VERIFY_ARE_EQUAL(value, displayValue);
|
|
}
|
|
|
|
if (expression != nullptr)
|
|
{
|
|
VERIFY_ARE_EQUAL(expression, displaySecondaryExpression);
|
|
}
|
|
}
|
|
|
|
TEST_METHOD(ViewModelConstructorDisplayValueAndExpressionInitializedTest)
|
|
{
|
|
StandardCalculatorViewModel^ vmconstructortest = ref new StandardCalculatorViewModel();
|
|
vmconstructortest->IsStandard = true;
|
|
String^ displayValue = vmconstructortest->DisplayValue;
|
|
String^ displayExpression = vmconstructortest->DisplayStringExpression;
|
|
String^ calculationResultAutomationName = vmconstructortest->CalculationResultAutomationName;
|
|
|
|
VERIFY_ARE_EQUAL(StringReference(L"0"), displayValue);
|
|
VERIFY_ARE_EQUAL(StringReference(L"Display is 0"), calculationResultAutomationName);
|
|
}
|
|
|
|
TEST_METHOD(ViewModelConstructorButtonPressedInitializedTest)
|
|
{
|
|
StandardCalculatorViewModel^ vmconstructortest = ref new StandardCalculatorViewModel();
|
|
vmconstructortest->IsStandard = true;
|
|
VERIFY_IS_NOT_NULL(vmconstructortest->ButtonPressed);
|
|
}
|
|
|
|
/// Expression : 135
|
|
TEST_METHOD(ButtonPressedLeftHandOperandEnteredTest)
|
|
{
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::One, L"1", L"" },
|
|
{ NumbersAndOperatorsEnum::Three, L"13", L"" },
|
|
{ NumbersAndOperatorsEnum::Five, L"135", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, true);
|
|
}
|
|
|
|
/// Expression : 13.
|
|
TEST_METHOD(ButtonPressedLeftHandOperandAndDecimalEnteredTest)
|
|
{
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::One, L"1", L"" },
|
|
{ NumbersAndOperatorsEnum::Three, L"13", L"" },
|
|
{ NumbersAndOperatorsEnum::Decimal, L"13" + std::wstring(m_decimalSeparator->Data()), L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, true);
|
|
}
|
|
|
|
/// Expression : 13==
|
|
TEST_METHOD(ButtonPressedLeftHandOperandAndEqualsEnteredTest)
|
|
{
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::One, L"1", L"" },
|
|
{ NumbersAndOperatorsEnum::Three, L"13", L"" },
|
|
{ NumbersAndOperatorsEnum::Equals, L"13", L"" },
|
|
{ NumbersAndOperatorsEnum::Equals, L"13", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, true);
|
|
}
|
|
|
|
/// Expression : 13+
|
|
TEST_METHOD(ButtonPressedLeftHandOperandAndOperationEnteredTest)
|
|
{
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::One, L"1", L"" },
|
|
{ NumbersAndOperatorsEnum::Three, L"13", L"" },
|
|
{ NumbersAndOperatorsEnum::Add, L"13", L"13 + " },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, true);
|
|
}
|
|
|
|
/// Expression : 13+801
|
|
TEST_METHOD(ButtonPressedRightHandOperandEnteredTest)
|
|
{
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::One, L"1", L"" },
|
|
{ NumbersAndOperatorsEnum::Three, L"13", L"" },
|
|
{ NumbersAndOperatorsEnum::Add, L"13", L"13 + " },
|
|
{ NumbersAndOperatorsEnum::Eight, L"8", L"13 + " },
|
|
{ NumbersAndOperatorsEnum::Zero, L"80", L"13 + " },
|
|
{ NumbersAndOperatorsEnum::One, L"801", L"13 + " },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, true);
|
|
}
|
|
|
|
/// Expression : 1+2=
|
|
TEST_METHOD(ButtonPressedAdditionWithEqualsTest)
|
|
{
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::One, L"1", L"" },
|
|
{ NumbersAndOperatorsEnum::Add, L"1", L"1 + " },
|
|
{ NumbersAndOperatorsEnum::Two, L"2", L"1 + " },
|
|
{ NumbersAndOperatorsEnum::Equals, L"3", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, true);
|
|
}
|
|
|
|
/// Expression : 1-2=
|
|
TEST_METHOD(ButtonPressedSubtractionWithEqualsTest)
|
|
{
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::One, L"1", L"" },
|
|
{ NumbersAndOperatorsEnum::Subtract, L"1", L"1 - " },
|
|
{ NumbersAndOperatorsEnum::Two, L"2", L"1 - " },
|
|
{ NumbersAndOperatorsEnum::Equals, L"-1", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, true);
|
|
}
|
|
|
|
/// Expression : 3*5=
|
|
TEST_METHOD(ButtonPressedMultiplyWithEqualsTest)
|
|
{
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::Three, L"3", L"" },
|
|
{ NumbersAndOperatorsEnum::Multiply, L"3", L"3 * " },
|
|
{ NumbersAndOperatorsEnum::Five, L"5", L"3 * " },
|
|
{ NumbersAndOperatorsEnum::Equals, L"15", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, true);
|
|
}
|
|
|
|
/// Expression : 9/3=
|
|
TEST_METHOD(ButtonPressedDivideTest)
|
|
{
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::Nine, L"9", L"" },
|
|
{ NumbersAndOperatorsEnum::Divide, L"9", L"9 / " },
|
|
{ NumbersAndOperatorsEnum::Three, L"3", L"9 / " },
|
|
{ NumbersAndOperatorsEnum::Equals, L"3", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, true);
|
|
}
|
|
|
|
/// Expression : 7.555*3=
|
|
TEST_METHOD(ButtonPressedDecimalOperationTest)
|
|
{
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::Seven, L"7", L"" },
|
|
{ NumbersAndOperatorsEnum::Decimal, L"7" + std::wstring(m_decimalSeparator->Data()), L"" },
|
|
{ NumbersAndOperatorsEnum::Five, L"7" + std::wstring(m_decimalSeparator->Data()) + L"5", L"" },
|
|
{ NumbersAndOperatorsEnum::Five, L"7" + std::wstring(m_decimalSeparator->Data()) + L"55", L"" },
|
|
{ NumbersAndOperatorsEnum::Five, L"7" + std::wstring(m_decimalSeparator->Data()) + L"555", L"" },
|
|
{ NumbersAndOperatorsEnum::Multiply, L"7" + std::wstring(m_decimalSeparator->Data()) + L"555", L"7" + std::wstring(m_decimalSeparator->Data()) + L"555 * " },
|
|
{ NumbersAndOperatorsEnum::Three, L"3", L"7" + std::wstring(m_decimalSeparator->Data()) + L"555 * " },
|
|
{ NumbersAndOperatorsEnum::Equals, L"22" + std::wstring(m_decimalSeparator->Data()) + L"665", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, true);
|
|
}
|
|
|
|
/// Expression : 7/0
|
|
TEST_METHOD(ButtonPressedDivideByZeroNegativeTest)
|
|
{
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::Seven, L"7", L"" },
|
|
{ NumbersAndOperatorsEnum::Divide, L"7", L"7 / " },
|
|
{ NumbersAndOperatorsEnum::Zero, L"0", L"7 / " },
|
|
{ NumbersAndOperatorsEnum::Equals, L"Cannot divide by zero", L"7 / " },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, true);
|
|
}
|
|
|
|
/// Expression : 8/2*
|
|
TEST_METHOD(ButtonPressedExpressionWithMultipleOperatorsTest)
|
|
{
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::Eight, L"8", L"" },
|
|
{ NumbersAndOperatorsEnum::Divide, L"8", L"8 / " },
|
|
{ NumbersAndOperatorsEnum::Two, L"2", L"8 / " },
|
|
{ NumbersAndOperatorsEnum::Multiply, L"4", L"8 / 2 * " },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, true);
|
|
}
|
|
|
|
/// Expression : 8/+*2*
|
|
TEST_METHOD(ButtonPressedExpressionWithMultipleOperatorsInSuccessionTest)
|
|
{
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::Eight, L"8", L"" },
|
|
{ NumbersAndOperatorsEnum::Divide, L"8", L"8 / " },
|
|
{ NumbersAndOperatorsEnum::Add, L"8", L"8 + " },
|
|
{ NumbersAndOperatorsEnum::Multiply, L"8", L"8 * " },
|
|
{ NumbersAndOperatorsEnum::Two, L"2", L"8 * " },
|
|
{ NumbersAndOperatorsEnum::Multiply, L"16", L"8 * 2 * " },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, true);
|
|
}
|
|
|
|
/// Expression : 8*2==
|
|
TEST_METHOD(ButtonPressedExpressionWithMultipleEqualsAfterEvaluateTest)
|
|
{
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::Eight, L"8", L"" },
|
|
{ NumbersAndOperatorsEnum::Multiply, L"8", L"8 * " },
|
|
{ NumbersAndOperatorsEnum::Two, L"2", L"8 * " },
|
|
{ NumbersAndOperatorsEnum::Equals, L"16", L"" },
|
|
{ NumbersAndOperatorsEnum::Equals, L"32", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, true);
|
|
}
|
|
|
|
/// Expression : 7-6 and Backspace
|
|
TEST_METHOD(ButtonPressedExpressionWithBackSpaceTest)
|
|
{
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::Seven, L"7", L"" },
|
|
{ NumbersAndOperatorsEnum::Subtract, L"7", L"7 - " },
|
|
{ NumbersAndOperatorsEnum::Six, L"6", L"7 - " },
|
|
{ NumbersAndOperatorsEnum::Backspace, L"0", L"7 - " },
|
|
{ NumbersAndOperatorsEnum::Backspace, L"0", L"7 - " },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, true);
|
|
}
|
|
|
|
/// Expression : 91-68 and Clear
|
|
TEST_METHOD(ButtonPressedExpressionWithClearTest)
|
|
{
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::Nine, L"9", L"" },
|
|
{ NumbersAndOperatorsEnum::One, L"91", L"" },
|
|
{ NumbersAndOperatorsEnum::Subtract, L"91", L"91 - " },
|
|
{ NumbersAndOperatorsEnum::Six, L"6", L"91 - " },
|
|
{ NumbersAndOperatorsEnum::Eight, L"68", L"91 - " },
|
|
{ NumbersAndOperatorsEnum::Clear, L"0", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, true);
|
|
}
|
|
|
|
///
|
|
/// Paste tests
|
|
///
|
|
template <typename T, typename Base>
|
|
void ValidateIntegralsAreEqual(NumbersAndOperatorsEnum a, NumbersAndOperatorsEnum b)
|
|
{
|
|
VERIFY_ARE_EQUAL(static_cast<Base>(a), static_cast<Base>(b));
|
|
}
|
|
|
|
void ValidateNumbersAndOperatorsAreEqual(NumbersAndOperatorsEnum a, NumbersAndOperatorsEnum b)
|
|
{
|
|
ValidateIntegralsAreEqual<NumbersAndOperatorsEnum, int>(a, b);
|
|
}
|
|
|
|
/// Low-level test of character mapping
|
|
TEST_METHOD(VerifyCorrectCharacterMapping)
|
|
{
|
|
bool canSendNegate = false;
|
|
|
|
// Valid numbers
|
|
NumbersAndOperatorsEnum n = m_viewModel->MapCharacterToButtonId(L'0', canSendNegate);
|
|
ValidateNumbersAndOperatorsAreEqual(n, NumbersAndOperatorsEnum::Zero);
|
|
|
|
n = m_viewModel->MapCharacterToButtonId(L'1', canSendNegate);
|
|
ValidateNumbersAndOperatorsAreEqual(n, NumbersAndOperatorsEnum::One);
|
|
|
|
// Valid operators
|
|
n = m_viewModel->MapCharacterToButtonId(L'+', canSendNegate);
|
|
ValidateNumbersAndOperatorsAreEqual(n, NumbersAndOperatorsEnum::Add);
|
|
|
|
n = m_viewModel->MapCharacterToButtonId(L'=', canSendNegate);
|
|
ValidateNumbersAndOperatorsAreEqual(n, NumbersAndOperatorsEnum::Equals);
|
|
|
|
n = m_viewModel->MapCharacterToButtonId(L'a', canSendNegate);
|
|
ValidateNumbersAndOperatorsAreEqual(n, NumbersAndOperatorsEnum::A);
|
|
|
|
// Invalid character
|
|
n = m_viewModel->MapCharacterToButtonId(L'$', canSendNegate);
|
|
ValidateNumbersAndOperatorsAreEqual(n, NumbersAndOperatorsEnum::None);
|
|
}
|
|
|
|
/// Various strings get pasted
|
|
TEST_METHOD(PasteExpressions)
|
|
{
|
|
m_viewModel->IsScientific = false;
|
|
|
|
m_viewModel->OnPaste("-0.99", ViewMode::Standard);
|
|
ValidateViewModelValueAndExpression("-0" + m_decimalSeparator + "99", "");
|
|
|
|
m_viewModel->OnPaste("1+1=", ViewMode::Standard);
|
|
ValidateViewModelValueAndExpression("2", "");
|
|
|
|
// This result is not obvious: it's the result of the previous operation
|
|
m_viewModel->OnPaste("0=", ViewMode::Standard);
|
|
ValidateViewModelValueAndExpression("1", "");
|
|
|
|
// Negative value
|
|
m_viewModel->OnPaste("-1", ViewMode::Standard);
|
|
ValidateViewModelValueAndExpression("-1", "");
|
|
|
|
// Negated expression
|
|
m_viewModel->OnPaste("-(1+1)", ViewMode::Standard);
|
|
ValidateViewModelValueAndSecondaryExpression("-2", "negate(1 + 1)");
|
|
|
|
// More complicated Negated expression
|
|
m_viewModel->OnPaste("-(-(-1))", ViewMode::Standard);
|
|
ValidateViewModelValueAndSecondaryExpression("-1", "negate(0 - (0 - 1))");
|
|
|
|
// Switch to scientific mode
|
|
m_viewModel->IsScientific = true;
|
|
|
|
VERIFY_IS_FALSE(m_viewModel->IsFToEChecked);
|
|
|
|
//// Positive exponent
|
|
m_viewModel->OnPaste("1.23e+10", ViewMode::Scientific);
|
|
ValidateViewModelValueAndExpression("1" + m_decimalSeparator + "23e+10", "");
|
|
|
|
//// Negative exponent
|
|
m_viewModel->OnPaste("1.23e-10", ViewMode::Scientific);
|
|
ValidateViewModelValueAndExpression("1" + m_decimalSeparator + "23e-10", "");
|
|
|
|
//// Uppercase E (for exponent)
|
|
m_viewModel->OnPaste("1.23E-10", ViewMode::Scientific);
|
|
ValidateViewModelValueAndExpression("1" + m_decimalSeparator + "23e-10", "");
|
|
}
|
|
|
|
// Verify Calculator CalculationResultAutomationName is set correctly
|
|
TEST_METHOD(CalculationResultAutomationNameVerification)
|
|
{
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::IsStandardMode, L"0", L"" },
|
|
{ NumbersAndOperatorsEnum::One, L"1", L"" },
|
|
{ NumbersAndOperatorsEnum::Two, L"12", L"" },
|
|
{ NumbersAndOperatorsEnum::Three, L"123", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, true);
|
|
VERIFY_ARE_EQUAL(StringReference(L"Display is 123"), m_viewModel->CalculationResultAutomationName);
|
|
|
|
TESTITEM items2[] = {
|
|
{ NumbersAndOperatorsEnum::IsScientificMode, L"0", L"" },
|
|
{ NumbersAndOperatorsEnum::One, L"1", L"" },
|
|
{ NumbersAndOperatorsEnum::Add, L"1", L"1 + " },
|
|
{ NumbersAndOperatorsEnum::Two, L"2", L"1 + " },
|
|
{ NumbersAndOperatorsEnum::Multiply, L"2", L"1 + 2 * " },
|
|
{ NumbersAndOperatorsEnum::Three, L"3", L"1 + 2 * " },
|
|
{ NumbersAndOperatorsEnum::Equals, L"7", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items2, true);
|
|
VERIFY_ARE_EQUAL(StringReference(L"Display is 7"), m_viewModel->CalculationResultAutomationName);
|
|
|
|
TESTITEM items3[] = {
|
|
{ NumbersAndOperatorsEnum::Clear, L"0", L"" },
|
|
{ NumbersAndOperatorsEnum::IsScientificMode, L"0", L"" },
|
|
{ NumbersAndOperatorsEnum::Five, L"5", L"" },
|
|
{ NumbersAndOperatorsEnum::InvSin, L"Invalid input", L"asind(5)" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items3, false);
|
|
VERIFY_ARE_EQUAL(StringReference(L"Display is Invalid input"), m_viewModel->CalculationResultAutomationName);
|
|
}
|
|
|
|
// Switch Calculator Mode and verify if mode switch is happening as expected.
|
|
// Test precendence to check if mode switch is happening
|
|
// Standard mode 1+2*3 = 9; Scientific mode 1+2*3 = 7
|
|
// Intermediate value is also different. after 1 + 2 * , standard shows 3, scientific shows 2
|
|
TEST_METHOD(ButtonPressedCalculatorModeSwitch)
|
|
{
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::IsStandardMode, L"0", L"" },
|
|
{ NumbersAndOperatorsEnum::One, L"1", L"" },
|
|
{ NumbersAndOperatorsEnum::Add, L"1", L"1 + " },
|
|
{ NumbersAndOperatorsEnum::Two, L"2", L"1 + " },
|
|
{ NumbersAndOperatorsEnum::Multiply, L"3", L"1 + 2 * " },
|
|
{ NumbersAndOperatorsEnum::Three, L"3", L"1 + 2 * " },
|
|
{ NumbersAndOperatorsEnum::Equals, L"9", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, true);
|
|
|
|
TESTITEM items2[] = {
|
|
{ NumbersAndOperatorsEnum::IsScientificMode, L"0", L"" },
|
|
{ NumbersAndOperatorsEnum::One, L"1", L"" },
|
|
{ NumbersAndOperatorsEnum::Add, L"1", L"1 + " },
|
|
{ NumbersAndOperatorsEnum::Two, L"2", L"1 + " },
|
|
{ NumbersAndOperatorsEnum::Multiply, L"2", L"1 + 2 * " },
|
|
{ NumbersAndOperatorsEnum::Three, L"3", L"1 + 2 * " },
|
|
{ NumbersAndOperatorsEnum::Equals, L"7", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items2, true);
|
|
}
|
|
|
|
// Test AutoConvertedValue
|
|
TEST_METHOD(ProgrammerModeAutoConvertedValue)
|
|
{
|
|
TESTITEM none[] = {
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, none, true);
|
|
m_viewModel->IsProgrammer = true;
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::HexButton, L"0", L"" },
|
|
{ NumbersAndOperatorsEnum::F, L"F", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, false);
|
|
VERIFY_ARE_EQUAL(Utils::GetStringValue(m_viewModel->HexDisplayValue), StringReference(L"F"));
|
|
VERIFY_ARE_EQUAL(Utils::GetStringValue(m_viewModel->DecimalDisplayValue), StringReference(L"15"));
|
|
VERIFY_ARE_EQUAL(Utils::GetStringValue(m_viewModel->OctalDisplayValue), StringReference(L"17"));
|
|
VERIFY_ARE_EQUAL(Utils::GetStringValue(m_viewModel->BinaryDisplayValue), StringReference(L"1111"));
|
|
}
|
|
|
|
// Test Button disabling in different Radixes
|
|
TEST_METHOD(ProgrammerModeButtonsDisable)
|
|
{
|
|
/* m_viewModel->IsProgrammer = true;
|
|
m_viewModel->SwitchProgrammerModeBase(OCT_RADIX);
|
|
VERIFY_IS_TRUE(m_viewModel->AreOCTButtonsEnabled);
|
|
VERIFY_IS_FALSE(m_viewModel->AreHEXButtonsEnabled);
|
|
VERIFY_IS_FALSE(m_viewModel->AreDECButtonsEnabled);
|
|
m_viewModel->SwitchProgrammerModeBase(DEC_RADIX);
|
|
VERIFY_IS_FALSE(m_viewModel->AreHEXButtonsEnabled);
|
|
VERIFY_IS_TRUE(m_viewModel->AreDECButtonsEnabled);
|
|
VERIFY_IS_TRUE(m_viewModel->AreOCTButtonsEnabled);
|
|
m_viewModel->SwitchProgrammerModeBase(HEX_RADIX);
|
|
VERIFY_IS_TRUE(m_viewModel->AreHEXButtonsEnabled);
|
|
VERIFY_IS_TRUE(m_viewModel->AreDECButtonsEnabled);
|
|
VERIFY_IS_TRUE(m_viewModel->AreOCTButtonsEnabled);
|
|
m_viewModel->SwitchProgrammerModeBase(BIN_RADIX);
|
|
VERIFY_IS_FALSE(m_viewModel->AreHEXButtonsEnabled);
|
|
VERIFY_IS_FALSE(m_viewModel->AreDECButtonsEnabled);
|
|
VERIFY_IS_FALSE(m_viewModel->AreOCTButtonsEnabled);*/
|
|
|
|
}
|
|
|
|
// Test digit grouping for different radix in programmer mode
|
|
TEST_METHOD(ProgrammerModeRadixGrouping)
|
|
{
|
|
TESTITEM none[] = {
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, none, true);
|
|
m_viewModel->IsProgrammer = true;
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::One, L"1", L"" },
|
|
{ NumbersAndOperatorsEnum::Two, L"12", L"" },
|
|
{ NumbersAndOperatorsEnum::Three, L"123", L"" },
|
|
{ NumbersAndOperatorsEnum::Four, L"1,234", L"" },
|
|
{ NumbersAndOperatorsEnum::Five, L"12,345", L"" },
|
|
{ NumbersAndOperatorsEnum::Six, L"123,456", L"" },
|
|
{ NumbersAndOperatorsEnum::Seven, L"1,234,567", L"" },
|
|
{ NumbersAndOperatorsEnum::Eight, L"12,345,678", L"" },
|
|
{ NumbersAndOperatorsEnum::Nine, L"123,456,789", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"1", L"" },
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, true);
|
|
VERIFY_ARE_EQUAL(Utils::GetStringValue(m_viewModel->HexDisplayValue), StringReference(L"75B CD15"));
|
|
VERIFY_ARE_EQUAL(Utils::GetStringValue(m_viewModel->DecimalDisplayValue), StringReference(L"123,456,789"));
|
|
VERIFY_ARE_EQUAL(Utils::GetStringValue(m_viewModel->OctalDisplayValue), StringReference(L"726 746 425"));
|
|
VERIFY_ARE_EQUAL(Utils::GetStringValue(m_viewModel->BinaryDisplayValue), StringReference(L"0111 0101 1011 1100 1101 0001 0101"));
|
|
}
|
|
|
|
// Test Not functionality
|
|
TEST_METHOD(ProgrammerModeNot)
|
|
{
|
|
TESTITEM none[] = {
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, none, true);
|
|
m_viewModel->IsProgrammer = true;
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::One, L"1", L"" },
|
|
{ NumbersAndOperatorsEnum::Not, L"-2", L"~(1)" },
|
|
{ NumbersAndOperatorsEnum::None, L"N/A", L"N/A" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, false);
|
|
VERIFY_ARE_EQUAL(Utils::GetStringValue(m_viewModel->HexDisplayValue), StringReference(L"FFFF FFFF FFFF FFFE"));
|
|
VERIFY_ARE_EQUAL(Utils::GetStringValue(m_viewModel->DecimalDisplayValue), StringReference(L"-2"));
|
|
VERIFY_ARE_EQUAL(Utils::GetStringValue(m_viewModel->OctalDisplayValue), StringReference(L"1 777 777 777 777 777 777 776"));
|
|
VERIFY_ARE_EQUAL(Utils::GetStringValue(m_viewModel->BinaryDisplayValue), StringReference(L"1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1110"));
|
|
VERIFY_ARE_EQUAL(m_viewModel->DisplayValue, StringReference(L"-2"));
|
|
}
|
|
|
|
// Test And Or functionality
|
|
TEST_METHOD(ProgrammerModeAndOr)
|
|
{
|
|
TESTITEM none[] = {
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, none, true);
|
|
m_viewModel->IsProgrammer = true;
|
|
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::One, L"1", L"" },
|
|
{ NumbersAndOperatorsEnum::Or, L"1", L"1 ||" },
|
|
{ NumbersAndOperatorsEnum::Two, L"2", L"1 ||" },
|
|
{ NumbersAndOperatorsEnum::Equals, L"3", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"3", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, false);
|
|
|
|
TESTITEM items2[] = {
|
|
{ NumbersAndOperatorsEnum::One, L"1", L"" },
|
|
{ NumbersAndOperatorsEnum::And, L"1", L"1 &" },
|
|
{ NumbersAndOperatorsEnum::Two, L"2", L"1 &" },
|
|
{ NumbersAndOperatorsEnum::Equals, L"0", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"0", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items2, false);
|
|
}
|
|
|
|
// Test CE and C buttons functionality
|
|
TEST_METHOD(ProgrammerModeClear)
|
|
{
|
|
TESTITEM none[] = {
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, none, true);
|
|
m_viewModel->IsProgrammer = true;
|
|
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::One, L"1", L"" },
|
|
{ NumbersAndOperatorsEnum::Or, L"1", L"1 ||" },
|
|
{ NumbersAndOperatorsEnum::Two, L"2", L"1 ||" },
|
|
{ NumbersAndOperatorsEnum::ClearEntry, L"0", L"1 ||" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"1 ||" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, false);
|
|
|
|
TESTITEM items2[] = {
|
|
{ NumbersAndOperatorsEnum::One, L"1", L"" },
|
|
{ NumbersAndOperatorsEnum::And, L"1", L"1 &" },
|
|
{ NumbersAndOperatorsEnum::Two, L"2", L"1 &" },
|
|
{ NumbersAndOperatorsEnum::Clear, L"0", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"0", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items2, false);
|
|
}
|
|
|
|
// Test unary operators
|
|
TEST_METHOD(ButtonPressedUnaryOperatorTest)
|
|
{
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::IsStandardMode, L"0", L"" },
|
|
{ NumbersAndOperatorsEnum::Five, L"5", L"" },
|
|
{ NumbersAndOperatorsEnum::Invert, L"0" + std::wstring(m_decimalSeparator->Data()) + L"2", L"reciproc(5)" },
|
|
{ NumbersAndOperatorsEnum::Equals, L"0" + std::wstring(m_decimalSeparator->Data()) + L"2", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, true);
|
|
|
|
TESTITEM items2[] = {
|
|
{ NumbersAndOperatorsEnum::One, L"1", L"" },
|
|
{ NumbersAndOperatorsEnum::Six, L"16", L"" },
|
|
{ NumbersAndOperatorsEnum::Sqrt, L"4", L"sqrt(16)" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items2, false);
|
|
|
|
TESTITEM items3[] = {
|
|
{ NumbersAndOperatorsEnum::Six, L"6", L"" },
|
|
{ NumbersAndOperatorsEnum::Negate, L"-6", L"" },
|
|
{ NumbersAndOperatorsEnum::Nine, L"-69", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items3, false);
|
|
|
|
TESTITEM items4[] = {
|
|
{ NumbersAndOperatorsEnum::Clear, L"0", L"" },
|
|
{ NumbersAndOperatorsEnum::IsScientificMode, L"0", L"" },
|
|
{ NumbersAndOperatorsEnum::Five, L"5", L"" },
|
|
{ NumbersAndOperatorsEnum::InvSin, L"Invalid input", L"asind(5)" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items4, false);
|
|
|
|
TESTITEM items5[] = {
|
|
{ NumbersAndOperatorsEnum::Clear, L"0", L"" },
|
|
{ NumbersAndOperatorsEnum::Four, L"4", L"" },
|
|
{ NumbersAndOperatorsEnum::Factorial, L"24", L"fact(4)" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items5, false);
|
|
}
|
|
|
|
// IsMemoryEmpty Property
|
|
TEST_METHOD(IsMemoryEmptyTest)
|
|
{
|
|
StandardCalculatorViewModel^ viewModel = ref new StandardCalculatorViewModel();
|
|
viewModel->IsStandard = true;
|
|
VERIFY_ARE_EQUAL(static_cast<unsigned int>(0), viewModel->MemorizedNumbers->Size);
|
|
viewModel->OnMemoryButtonPressed();
|
|
VERIFY_ARE_EQUAL(static_cast<unsigned int>(1), viewModel->MemorizedNumbers->Size);
|
|
viewModel->ClearMemoryCommand->Execute(nullptr);
|
|
VERIFY_ARE_EQUAL(static_cast<unsigned int>(0), viewModel->MemorizedNumbers->Size);
|
|
}
|
|
|
|
// IsOperatorCommand Property
|
|
TEST_METHOD(IsOperatorCommandTest)
|
|
{
|
|
StandardCalculatorViewModel^ viewModel = ref new StandardCalculatorViewModel();
|
|
viewModel->IsStandard = true;
|
|
viewModel->ButtonPressed->Execute(NumbersAndOperatorsEnum::One);
|
|
VERIFY_ARE_EQUAL(viewModel->IsOperatorCommand, false);
|
|
viewModel->ButtonPressed->Execute(NumbersAndOperatorsEnum::Two);
|
|
VERIFY_ARE_EQUAL(viewModel->IsOperatorCommand, false);
|
|
viewModel->ButtonPressed->Execute(NumbersAndOperatorsEnum::Three);
|
|
VERIFY_ARE_EQUAL(viewModel->IsOperatorCommand, false);
|
|
viewModel->ButtonPressed->Execute(NumbersAndOperatorsEnum::Four);
|
|
VERIFY_ARE_EQUAL(viewModel->IsOperatorCommand, false);
|
|
viewModel->ButtonPressed->Execute(NumbersAndOperatorsEnum::Five);
|
|
VERIFY_ARE_EQUAL(viewModel->IsOperatorCommand, false);
|
|
viewModel->ButtonPressed->Execute(NumbersAndOperatorsEnum::Six);
|
|
VERIFY_ARE_EQUAL(viewModel->IsOperatorCommand, false);
|
|
viewModel->ButtonPressed->Execute(NumbersAndOperatorsEnum::Seven);
|
|
VERIFY_ARE_EQUAL(viewModel->IsOperatorCommand, false);
|
|
viewModel->ButtonPressed->Execute(NumbersAndOperatorsEnum::Eight);
|
|
VERIFY_ARE_EQUAL(viewModel->IsOperatorCommand, false);
|
|
viewModel->ButtonPressed->Execute(NumbersAndOperatorsEnum::Nine);
|
|
VERIFY_ARE_EQUAL(viewModel->IsOperatorCommand, false);
|
|
viewModel->ButtonPressed->Execute(NumbersAndOperatorsEnum::Decimal);
|
|
VERIFY_ARE_EQUAL(viewModel->IsOperatorCommand, false);
|
|
viewModel->ButtonPressed->Execute(NumbersAndOperatorsEnum::Zero);
|
|
VERIFY_ARE_EQUAL(viewModel->IsOperatorCommand, false);
|
|
viewModel->ButtonPressed->Execute(NumbersAndOperatorsEnum::Multiply);
|
|
VERIFY_ARE_EQUAL(viewModel->IsOperatorCommand, true);
|
|
viewModel->ButtonPressed->Execute(NumbersAndOperatorsEnum::Add);
|
|
VERIFY_ARE_EQUAL(viewModel->IsOperatorCommand, true);
|
|
viewModel->ButtonPressed->Execute(NumbersAndOperatorsEnum::Zero);
|
|
VERIFY_ARE_EQUAL(viewModel->IsOperatorCommand, false);
|
|
}
|
|
|
|
//When memory button is pressed - verify if display value is being stored in vector
|
|
TEST_METHOD(OnMemoryButtonPressed)
|
|
{
|
|
StandardCalculatorViewModel^ viewModel = ref new StandardCalculatorViewModel();
|
|
viewModel->IsStandard = true;
|
|
viewModel->DisplayValue = L"1001";
|
|
viewModel->OnMemoryButtonPressed();
|
|
viewModel->OnMemoryButtonPressed();
|
|
VERIFY_ARE_EQUAL((int)viewModel->MemorizedNumbers->Size, 2);
|
|
}
|
|
|
|
//when memory list is empty and M+ is pressed
|
|
TEST_METHOD(OnMemoryAddWhenMemoryEmpty)
|
|
{
|
|
m_viewModel->IsStandard = true;
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::One, L"1", L"" },
|
|
{ NumbersAndOperatorsEnum::Zero, L"10", L"" },
|
|
{ NumbersAndOperatorsEnum::Zero, L"100", L"" },
|
|
{ NumbersAndOperatorsEnum::One, L"1,001", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, true);
|
|
m_viewModel->OnMemoryAdd(ref new Platform::Box<int>(0));
|
|
m_viewModel->OnMemoryItemPressed(ref new Platform::Box<int>(0));
|
|
VERIFY_ARE_EQUAL(Platform::StringReference(L"1,001"), m_viewModel->DisplayValue);
|
|
}
|
|
|
|
|
|
//when memory list is empty and M- is pressed
|
|
TEST_METHOD(OnMemorySubtractWhenMemoryEmpty)
|
|
{
|
|
m_viewModel->IsStandard = true;
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::One, L"1", L"" },
|
|
{ NumbersAndOperatorsEnum::Zero, L"10", L"" },
|
|
{ NumbersAndOperatorsEnum::Zero, L"100", L"" },
|
|
{ NumbersAndOperatorsEnum::One, L"1,001", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, true);
|
|
m_viewModel->OnMemorySubtract(ref new Platform::Box<int>(0));
|
|
m_viewModel->OnMemoryItemPressed(ref new Platform::Box<int>(0));
|
|
VERIFY_ARE_EQUAL(Platform::StringReference(L"-1,001"), m_viewModel->DisplayValue);
|
|
}
|
|
|
|
//when negative number is saved in memory
|
|
TEST_METHOD(OnNegativeEntryInMemory)
|
|
{
|
|
ChangeMode(m_viewModel, 0/*Standard*/);
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::One, L"1", L"" },
|
|
{ NumbersAndOperatorsEnum::Zero, L"10", L"" },
|
|
{ NumbersAndOperatorsEnum::Zero, L"100", L"" },
|
|
{ NumbersAndOperatorsEnum::One, L"1,001", L"" },
|
|
{ NumbersAndOperatorsEnum::Negate, L"N/A", L"N/A" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" },
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, true);
|
|
m_viewModel->OnMemoryButtonPressed();
|
|
m_viewModel->OnMemoryItemPressed(ref new Platform::Box<int>(0));
|
|
VERIFY_ARE_EQUAL(Platform::StringReference(L"-1,001"), m_viewModel->DisplayValue);
|
|
MemoryItemViewModel^ memorySlotStandard = (MemoryItemViewModel^)m_viewModel->MemorizedNumbers->GetAt(0);
|
|
VERIFY_ARE_EQUAL(Platform::StringReference(L"-1,001"), Utils::GetStringValue(memorySlotStandard->Value));
|
|
ChangeMode(m_viewModel, 1/*scientific*/);
|
|
MemoryItemViewModel^ memorySlotScientific = (MemoryItemViewModel^)m_viewModel->MemorizedNumbers->GetAt(0);
|
|
VERIFY_ARE_EQUAL(Platform::StringReference(L"-1,001"), Utils::GetStringValue(memorySlotScientific->Value));
|
|
ChangeMode(m_viewModel, 2/*Programmer*/);
|
|
MemoryItemViewModel^ memorySlotProgrammer = (MemoryItemViewModel^)m_viewModel->MemorizedNumbers->GetAt(0);
|
|
VERIFY_ARE_EQUAL(Platform::StringReference(L"-1,001"), Utils::GetStringValue(memorySlotProgrammer->Value));
|
|
}
|
|
|
|
//when decimal number is saved in memory
|
|
TEST_METHOD(OnDecimalEntryInMemory)
|
|
{
|
|
ChangeMode(m_viewModel, 0/*Standard*/);
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::One, L"1", L"" },
|
|
{ NumbersAndOperatorsEnum::Zero, L"10", L"" },
|
|
{ NumbersAndOperatorsEnum::Zero, L"100", L"" },
|
|
{ NumbersAndOperatorsEnum::One, L"1,001", L"" },
|
|
{ NumbersAndOperatorsEnum::Decimal, L"1,001.", L"" },
|
|
{ NumbersAndOperatorsEnum::One, L"1,001.1", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" },
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, true);
|
|
m_viewModel->OnMemoryButtonPressed();
|
|
m_viewModel->OnMemoryItemPressed(ref new Platform::Box<int>(0));
|
|
VERIFY_ARE_EQUAL(Platform::StringReference(L"1,001.1"), m_viewModel->DisplayValue);
|
|
MemoryItemViewModel^ memorySlotStandard = (MemoryItemViewModel^)m_viewModel->MemorizedNumbers->GetAt(0);
|
|
VERIFY_ARE_EQUAL(Platform::StringReference(L"1,001.1"), Utils::GetStringValue(memorySlotStandard->Value));
|
|
ChangeMode(m_viewModel, 1/*Scientific*/);
|
|
MemoryItemViewModel^ memorySlotScientific = (MemoryItemViewModel^)m_viewModel->MemorizedNumbers->GetAt(0);
|
|
VERIFY_ARE_EQUAL(Platform::StringReference(L"1,001.1"), Utils::GetStringValue(memorySlotScientific->Value));
|
|
ChangeMode(m_viewModel, 2/*Programmer*/);
|
|
MemoryItemViewModel^ memorySlotProgrammer = (MemoryItemViewModel^)m_viewModel->MemorizedNumbers->GetAt(0);
|
|
VERIFY_ARE_EQUAL(Platform::StringReference(L"1,001"), Utils::GetStringValue(memorySlotProgrammer->Value));
|
|
}
|
|
|
|
//when negative decimal number is saved in memory
|
|
TEST_METHOD(OnNegativeDecimalInMemory)
|
|
{
|
|
m_viewModel->IsStandard = true;
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::One, L"1", L"" },
|
|
{ NumbersAndOperatorsEnum::Zero, L"10", L"" },
|
|
{ NumbersAndOperatorsEnum::Zero, L"100", L"" },
|
|
{ NumbersAndOperatorsEnum::One, L"1,001", L"" },
|
|
{ NumbersAndOperatorsEnum::Decimal, L"1,001.", L"" },
|
|
{ NumbersAndOperatorsEnum::One, L"1,001.1", L"" },
|
|
{ NumbersAndOperatorsEnum::Negate, L"N/A", L"N/A" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" },
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, true);
|
|
m_viewModel->OnMemoryButtonPressed();
|
|
m_viewModel->OnMemoryItemPressed(ref new Platform::Box<int>(0));
|
|
VERIFY_ARE_EQUAL(Platform::StringReference(L"-1,001.1"), m_viewModel->DisplayValue);
|
|
}
|
|
|
|
//when decimal number is added to the memory
|
|
TEST_METHOD(OnDecimalAddedToMemory)
|
|
{
|
|
m_viewModel->IsStandard = true;
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::One, L"1", L"" },
|
|
{ NumbersAndOperatorsEnum::Zero, L"10", L"" },
|
|
{ NumbersAndOperatorsEnum::Zero, L"100", L"" },
|
|
{ NumbersAndOperatorsEnum::One, L"1,001", L"" },
|
|
{ NumbersAndOperatorsEnum::Decimal, L"1,001.", L"" },
|
|
{ NumbersAndOperatorsEnum::One, L"1,001.1", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" },
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, true);
|
|
m_viewModel->OnMemoryButtonPressed();
|
|
TESTITEM items2[] = {
|
|
{ NumbersAndOperatorsEnum::One, L"1", L"" },
|
|
{ NumbersAndOperatorsEnum::Zero, L"10", L"" },
|
|
{ NumbersAndOperatorsEnum::Zero, L"100", L"" },
|
|
{ NumbersAndOperatorsEnum::One, L"1,001", L"" },
|
|
{ NumbersAndOperatorsEnum::Decimal, L"1,001.", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" },
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items2, false);
|
|
m_viewModel->OnMemoryButtonPressed();
|
|
m_viewModel->OnMemoryAdd(1);
|
|
m_viewModel->OnMemoryItemPressed(1);
|
|
VERIFY_ARE_EQUAL(Platform::StringReference(L"2,002.1"), m_viewModel->DisplayValue);
|
|
}
|
|
|
|
//when memory is saved in programmer as Hex value and then we switch to standard mode, test to see that memory gets converted to decimal
|
|
TEST_METHOD(OnMemorySavedInHexRadixAndSwitchedToStandardMode)
|
|
{
|
|
ChangeMode(m_viewModel, 2/*programmer*/);
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::HexButton, L"0", L"" },
|
|
{ NumbersAndOperatorsEnum::F, L"F", L"" },
|
|
{ NumbersAndOperatorsEnum::F, L"FF", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"FF", L"" },
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, true);
|
|
m_viewModel->OnMemoryButtonPressed();
|
|
ChangeMode(m_viewModel, 1/*Scientific*/);
|
|
m_viewModel->OnMemoryItemPressed(ref new Box<int>(0));
|
|
VERIFY_ARE_EQUAL(Platform::StringReference(L"255"), m_viewModel->DisplayValue);
|
|
MemoryItemViewModel^ memorySlot = (MemoryItemViewModel^)m_viewModel->MemorizedNumbers->GetAt(0);
|
|
VERIFY_ARE_EQUAL(Platform::StringReference(L"255"), Utils::GetStringValue(memorySlot->Value));
|
|
}
|
|
|
|
|
|
TEST_METHOD(OnMemorySavedInHexRadixAndRadixChanges)
|
|
{
|
|
ChangeMode(m_viewModel, 2/*programmer*/);
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::HexButton, L"0", L"" },
|
|
{ NumbersAndOperatorsEnum::F, L"F", L"" },
|
|
{ NumbersAndOperatorsEnum::F, L"FF", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"FF", L"" },
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, true);
|
|
m_viewModel->OnMemoryButtonPressed();
|
|
m_viewModel->SwitchProgrammerModeBase(RADIX_TYPE::OCT_RADIX);
|
|
MemoryItemViewModel^ memorySlotOct = (MemoryItemViewModel^)m_viewModel->MemorizedNumbers->GetAt(0);
|
|
VERIFY_ARE_EQUAL(Platform::StringReference(L"377"), Utils::GetStringValue(memorySlotOct->Value));
|
|
m_viewModel->SwitchProgrammerModeBase(RADIX_TYPE::DEC_RADIX);
|
|
MemoryItemViewModel^ memorySlotDec = (MemoryItemViewModel^)m_viewModel->MemorizedNumbers->GetAt(0);
|
|
VERIFY_ARE_EQUAL(Platform::StringReference(L"255"), Utils::GetStringValue(memorySlotDec->Value));
|
|
m_viewModel->SwitchProgrammerModeBase(RADIX_TYPE::BIN_RADIX);
|
|
MemoryItemViewModel^ memorySlotBin = (MemoryItemViewModel^)m_viewModel->MemorizedNumbers->GetAt(0);
|
|
VERIFY_ARE_EQUAL(Platform::StringReference(L"1111 1111"), Utils::GetStringValue(memorySlotBin->Value));
|
|
|
|
}
|
|
|
|
//When memory button is pressed more than max number of slots allowed,
|
|
//the MemorizedNumbers vector size should not increase.
|
|
TEST_METHOD(OnMemoryButtonPressedMaxTimes)
|
|
{
|
|
StandardCalculatorViewModel^ viewModel = ref new StandardCalculatorViewModel();
|
|
viewModel->IsStandard = true;
|
|
viewModel->DisplayValue = L"1001";
|
|
for (int i = 0; i < 110; i++)
|
|
{
|
|
viewModel->OnMemoryButtonPressed();
|
|
}
|
|
VERIFY_ARE_EQUAL((int)viewModel->MemorizedNumbers->Size, 100);
|
|
}
|
|
|
|
// When memory slot is pressed verify if the display value is updated correctly
|
|
TEST_METHOD(OnMemoryItemPressed)
|
|
{
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::One, L"1", L"" },
|
|
{ NumbersAndOperatorsEnum::Zero, L"10", L"" },
|
|
{ NumbersAndOperatorsEnum::Zero, L"100", L"" },
|
|
{ NumbersAndOperatorsEnum::One, L"1,001", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, true);
|
|
|
|
m_viewModel->OnMemoryButtonPressed();
|
|
|
|
TESTITEM items2[] = {
|
|
{ NumbersAndOperatorsEnum::Two, L"2", L"" },
|
|
{ NumbersAndOperatorsEnum::Zero, L"20", L"" },
|
|
{ NumbersAndOperatorsEnum::Zero, L"200", L"" },
|
|
{ NumbersAndOperatorsEnum::Two, L"2,002", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items2, false);
|
|
|
|
m_viewModel->OnMemoryButtonPressed();
|
|
m_viewModel->OnMemoryItemPressed(1);
|
|
|
|
VERIFY_ARE_EQUAL(Platform::StringReference(L"1,001"), m_viewModel->DisplayValue);
|
|
}
|
|
|
|
// verify nothing happens if there is no memory and the memory slot pressed action is taken
|
|
TEST_METHOD(OnMemoryItemPressedNoMemory)
|
|
{
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::One, L"1", L"" },
|
|
{ NumbersAndOperatorsEnum::Two, L"12", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, true);
|
|
|
|
m_viewModel->OnMemoryItemPressed(ref new Platform::Box<int>(0));
|
|
|
|
VERIFY_ARE_EQUAL(StringReference(L"12"), m_viewModel->DisplayValue);
|
|
VERIFY_ARE_EQUAL((UINT)0, m_viewModel->MemorizedNumbers->Size);
|
|
}
|
|
|
|
// When memory slot is pressed verify if the display value is updated correctly
|
|
TEST_METHOD(OnMemoryItemAddAndSubtract)
|
|
{
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::One, L"1", L"" },
|
|
{ NumbersAndOperatorsEnum::Zero, L"10", L"" },
|
|
{ NumbersAndOperatorsEnum::Zero, L"100", L"" },
|
|
{ NumbersAndOperatorsEnum::One, L"1,001", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, true);
|
|
|
|
m_viewModel->OnMemoryButtonPressed();
|
|
|
|
TESTITEM items2[] = {
|
|
{ NumbersAndOperatorsEnum::Two, L"2", L"" },
|
|
{ NumbersAndOperatorsEnum::Zero, L"20", L"" },
|
|
{ NumbersAndOperatorsEnum::Zero, L"200", L"" },
|
|
{ NumbersAndOperatorsEnum::Two, L"2,002", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items2, false);
|
|
|
|
m_viewModel->OnMemoryButtonPressed();
|
|
m_viewModel->OnMemoryItemPressed(1);
|
|
m_viewModel->OnMemoryAdd(ref new Platform::Box<int>(0));
|
|
MemoryItemViewModel^ memorySlot = (MemoryItemViewModel^)m_viewModel->MemorizedNumbers->GetAt(0);
|
|
VERIFY_ARE_EQUAL(Platform::StringReference(L"3,003"), Utils::GetStringValue(memorySlot->Value));
|
|
}
|
|
|
|
// Verify that raw, unformatted numbers are provided correctly
|
|
TEST_METHOD(VerifyRawFormatting)
|
|
{
|
|
m_viewModel->DisplayValue = L"1,001";
|
|
VERIFY_ARE_EQUAL(StringReference(L"1001"), m_viewModel->GetRawDisplayValue());
|
|
|
|
m_viewModel->DisplayValue = L"999";
|
|
VERIFY_ARE_EQUAL(StringReference(L"999"), m_viewModel->GetRawDisplayValue());
|
|
|
|
m_viewModel->DisplayValue = L"1,001,001";
|
|
VERIFY_ARE_EQUAL(StringReference(L"1001001"), m_viewModel->GetRawDisplayValue());
|
|
|
|
m_viewModel->DisplayValue = L"1,001, 001";
|
|
VERIFY_ARE_EQUAL(StringReference(L"1001001"), m_viewModel->GetRawDisplayValue());
|
|
|
|
}
|
|
|
|
TEST_METHOD(VerifyAnnouncementAfterBinaryOperatorReceived)
|
|
{
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::One, L"1", L"" },
|
|
{ NumbersAndOperatorsEnum::Zero, L"10", L"" },
|
|
{ NumbersAndOperatorsEnum::Zero, L"100", L"" },
|
|
{ NumbersAndOperatorsEnum::One, L"1,001", L"" },
|
|
{ NumbersAndOperatorsEnum::Multiply, L"1,001", L"1001 x" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, true);
|
|
|
|
VERIFY_ARE_EQUAL(StringReference(L"Display is 1,001 times"), m_viewModel->Announcement->Announcement);
|
|
}
|
|
|
|
TEST_METHOD(VerifyAnnouncementAfterMultipleBinaryOperatorsReceived)
|
|
{
|
|
TESTITEM items[] = {
|
|
{ NumbersAndOperatorsEnum::One, L"1", L"" },
|
|
{ NumbersAndOperatorsEnum::Zero, L"10", L"" },
|
|
{ NumbersAndOperatorsEnum::Zero, L"100", L"" },
|
|
{ NumbersAndOperatorsEnum::One, L"1,001", L"" },
|
|
{ NumbersAndOperatorsEnum::Multiply, L"1,001", L"1001 x" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items, true);
|
|
|
|
VERIFY_ARE_EQUAL(StringReference(L"Display is 1,001 times"), m_viewModel->Announcement->Announcement);
|
|
|
|
|
|
TESTITEM items2[] = {
|
|
{ NumbersAndOperatorsEnum::Divide, L"1,001", L"1001 ÷" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items2, false /*reset*/);
|
|
|
|
VERIFY_ARE_EQUAL(StringReference(L"Display is 1,001 divided by"), m_viewModel->Announcement->Announcement);
|
|
|
|
TESTITEM items3[] = {
|
|
{ NumbersAndOperatorsEnum::Add, L"1,001", L"1001 +" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items3, false /*reset*/);
|
|
|
|
VERIFY_ARE_EQUAL(StringReference(L"Display is 1,001 plus"), m_viewModel->Announcement->Announcement);
|
|
|
|
|
|
TESTITEM items4[] = {
|
|
{ NumbersAndOperatorsEnum::Subtract, L"1,001", L"1001 x" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" }
|
|
};
|
|
ValidateViewModelByCommands(m_viewModel, items4, false /*reset*/);
|
|
|
|
VERIFY_ARE_EQUAL(StringReference(L"Display is 1,001 minus"), m_viewModel->Announcement->Announcement);
|
|
}
|
|
|
|
private:
|
|
StandardCalculatorViewModel^ m_viewModel;
|
|
std::shared_ptr<EngineResourceProvider> m_engineResourceProvider;
|
|
Platform::String^ m_decimalSeparator;
|
|
};
|
|
}
|
|
|