565e3e2714
* Implemented feature & added unit tests * Fixed more unit/ui tests * Refactored tests * Update HistoryTests.cpp * Update HistoryTests.cpp * Update HistoryTests.cpp * Update HistoryTests.cpp * Update HistoryTests.cpp * Update HistoryTests.cpp * Update HistoryTests.cpp * Update HistoryTests.cpp
941 lines
46 KiB
C++
941 lines
46 KiB
C++
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// Licensed under the MIT License.
|
|
|
|
#include "pch.h"
|
|
#include <CppUnitTest.h>
|
|
#include "UnitConverterViewModelUnitTests.h"
|
|
#include "DateUtils.h"
|
|
|
|
#include "CalcViewModel/StandardCalculatorViewModel.h"
|
|
#include "CalcViewModel/UnitConverterViewModel.h"
|
|
#include "CalcViewModel/DateCalculatorViewModel.h"
|
|
#include "CalcViewModel/DataLoaders/UnitConverterDataLoader.h"
|
|
|
|
using namespace Platform;
|
|
using namespace Platform::Collections;
|
|
using namespace CalculatorApp;
|
|
using namespace CalculatorApp::Common;
|
|
using namespace CalculatorApp::ViewModel;
|
|
using namespace CalculationManager;
|
|
using namespace Windows::ApplicationModel::Resources;
|
|
using namespace Windows::Devices::Input;
|
|
using namespace Windows::Foundation::Collections;
|
|
using namespace Windows::Globalization;
|
|
using namespace Utils;
|
|
using namespace DateCalculationUnitTests;
|
|
using namespace Microsoft::VisualStudio::CppUnitTestFramework;
|
|
|
|
namespace CalculatorUnitTests
|
|
{
|
|
extern void ChangeMode(StandardCalculatorViewModel ^ viewModel, int mode);
|
|
extern void ValidateViewModelByCommands(StandardCalculatorViewModel ^ viewModel, TESTITEM item[], bool doReset = false);
|
|
|
|
// Validated the Mode set for a given instance of Standard Calculator View Model
|
|
void ValidateViewModelMode(StandardCalculatorViewModel ^ viewModel, int mode)
|
|
{
|
|
// Standard
|
|
if (mode == 0)
|
|
{
|
|
VERIFY_IS_TRUE(viewModel->IsStandard);
|
|
VERIFY_IS_FALSE(viewModel->IsScientific);
|
|
VERIFY_IS_FALSE(viewModel->IsProgrammer);
|
|
}
|
|
// Scientific
|
|
else if (mode == 1)
|
|
{
|
|
VERIFY_IS_FALSE(viewModel->IsStandard);
|
|
VERIFY_IS_TRUE(viewModel->IsScientific);
|
|
VERIFY_IS_FALSE(viewModel->IsProgrammer);
|
|
}
|
|
// Programmer
|
|
else if (mode == 2)
|
|
{
|
|
VERIFY_IS_FALSE(viewModel->IsStandard);
|
|
VERIFY_IS_FALSE(viewModel->IsScientific);
|
|
VERIFY_IS_TRUE(viewModel->IsProgrammer);
|
|
}
|
|
}
|
|
|
|
// Test class containing Test Methods to validate Multi Window
|
|
TEST_CLASS(MultiWindowUnitTests){ public:
|
|
// Create 3 instances of StandardCalculatorViewModel
|
|
TEST_METHOD(InitializeMultipleInstancesTest){ std::vector<StandardCalculatorViewModel ^> viewModels(3);
|
|
|
|
// Create 3 instances of StandardCalculatorViewModel
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
viewModels[i] = ref new StandardCalculatorViewModel();
|
|
viewModels[i]->IsStandard = true;
|
|
}
|
|
|
|
// Assert that the Display Value is "0" for all instances
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
VERIFY_IS_TRUE("0" == viewModels[i]->DisplayValue);
|
|
}
|
|
}
|
|
|
|
// Create 3 separate instances of Calculator in different modes
|
|
TEST_METHOD(InitializeMultipleModeInstancesTest)
|
|
{
|
|
std::vector<StandardCalculatorViewModel ^> viewModels(3);
|
|
|
|
// Create 3 instances of StandardCalculatorViewModel in different modes
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
viewModels[i] = ref new StandardCalculatorViewModel();
|
|
|
|
ChangeMode(viewModels[i], i);
|
|
}
|
|
|
|
// Assert for the Modes and DisplayValues
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
ValidateViewModelMode(viewModels[i], i);
|
|
|
|
VERIFY_IS_TRUE("0" == viewModels[i]->DisplayValue);
|
|
}
|
|
}
|
|
|
|
// Perform calculations on different calculator modes and verify that they work independently
|
|
TEST_METHOD(MultipleModesCalculationTest)
|
|
{
|
|
std::vector<StandardCalculatorViewModel ^> viewModels(3);
|
|
|
|
// Create 3 instances of StandardCalculatorViewModel in different modes
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
viewModels[i] = ref new StandardCalculatorViewModel();
|
|
|
|
ChangeMode(viewModels[i], i);
|
|
}
|
|
|
|
// Perform Calculations on all instances and check that they work independently
|
|
|
|
// Standard Mode: Expression 1+2=
|
|
TESTITEM standardModeTestItems[] = { { 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(viewModels[0], standardModeTestItems, true);
|
|
|
|
// Scientific Mode: Expression 1+2*3
|
|
TESTITEM scientificModeTestItems[] = { { 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(viewModels[1], scientificModeTestItems, true);
|
|
|
|
// Programmer Mode: Expression F
|
|
TESTITEM programmerModeTestItems[] = { { NumbersAndOperatorsEnum::HexButton, L"0", L"" },
|
|
{ NumbersAndOperatorsEnum::F, L"F", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" } };
|
|
ValidateViewModelByCommands(viewModels[2], programmerModeTestItems, false);
|
|
VERIFY_ARE_EQUAL(viewModels[2]->HexDisplayValue, StringReference(L"F"));
|
|
VERIFY_ARE_EQUAL(viewModels[2]->DecimalDisplayValue, StringReference(L"15"));
|
|
VERIFY_ARE_EQUAL(viewModels[2]->OctalDisplayValue, StringReference(L"17"));
|
|
VERIFY_ARE_EQUAL(viewModels[2]->BinaryDisplayValue, StringReference(L"1111"));
|
|
|
|
// Assert that Standard and Scientific mode Display Values are unchanged
|
|
VERIFY_ARE_EQUAL(viewModels[0]->DisplayValue, StringReference(L"3"));
|
|
VERIFY_ARE_EQUAL(viewModels[1]->DisplayValue, StringReference(L"7"));
|
|
}
|
|
|
|
// Perform calculations on 2 instances of Calculator in Standard Mode and verify that they work independently
|
|
TEST_METHOD(MultipleStandardModeCalculationTest)
|
|
{
|
|
// Create 2 instances of Standard Mode
|
|
StandardCalculatorViewModel ^ standardViewModel1 = ref new StandardCalculatorViewModel();
|
|
StandardCalculatorViewModel ^ standardViewModel2 = ref new StandardCalculatorViewModel();
|
|
|
|
ChangeMode(standardViewModel1, 0);
|
|
ChangeMode(standardViewModel2, 0);
|
|
|
|
ValidateViewModelMode(standardViewModel1, 0);
|
|
ValidateViewModelMode(standardViewModel2, 0);
|
|
|
|
// Perform Calculations on the 2 instances and check that they work independently
|
|
|
|
// Standard Mode 1: Expression 3-2=
|
|
TESTITEM standardModeTestItems1[] = { { NumbersAndOperatorsEnum::Three, L"3", L"" },
|
|
{ NumbersAndOperatorsEnum::Subtract, L"3", L"3 - " },
|
|
{ NumbersAndOperatorsEnum::Two, L"2", L"3 - " },
|
|
{ NumbersAndOperatorsEnum::Equals, L"1", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" } };
|
|
ValidateViewModelByCommands(standardViewModel1, standardModeTestItems1, true);
|
|
|
|
// Standard Mode 2: Expression 4*5=
|
|
TESTITEM standardModeTestItems2[] = { { NumbersAndOperatorsEnum::Four, L"4", L"" },
|
|
{ NumbersAndOperatorsEnum::Multiply, L"4", L"4 * " },
|
|
{ NumbersAndOperatorsEnum::Five, L"5", L"4 * " },
|
|
{ NumbersAndOperatorsEnum::Equals, L"20", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" } };
|
|
ValidateViewModelByCommands(standardViewModel2, standardModeTestItems2, true);
|
|
|
|
// Assert that the Display Value of 1st instance is unchanged
|
|
VERIFY_ARE_EQUAL(standardViewModel1->DisplayValue, StringReference(L"1"));
|
|
}
|
|
|
|
// Perform calculations on 2 instances of Calculator in Scientific Mode and verify that they work independently
|
|
TEST_METHOD(MultipleScientificModeCalculationTest)
|
|
{
|
|
// Create 2 instances of Standard Mode
|
|
StandardCalculatorViewModel ^ scientificViewModel1 = ref new StandardCalculatorViewModel();
|
|
StandardCalculatorViewModel ^ scientificViewModel2 = ref new StandardCalculatorViewModel();
|
|
|
|
ChangeMode(scientificViewModel1, 1);
|
|
ChangeMode(scientificViewModel2, 1);
|
|
|
|
ValidateViewModelMode(scientificViewModel1, 1);
|
|
ValidateViewModelMode(scientificViewModel2, 1);
|
|
|
|
// Perform Calculations on the 2 instances and check that they work independently
|
|
|
|
// Standard Mode 1: Expression 3-2=
|
|
TESTITEM scientificModeTestItems1[] = { { NumbersAndOperatorsEnum::Three, L"3", L"" },
|
|
{ NumbersAndOperatorsEnum::Subtract, L"3", L"3 - " },
|
|
{ NumbersAndOperatorsEnum::Two, L"2", L"3 - " },
|
|
{ NumbersAndOperatorsEnum::Equals, L"1", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" } };
|
|
ValidateViewModelByCommands(scientificViewModel1, scientificModeTestItems1, true);
|
|
|
|
// Standard Mode 2: Expression 4*5=
|
|
TESTITEM scientificModeTestItems2[] = { { NumbersAndOperatorsEnum::Four, L"4", L"" },
|
|
{ NumbersAndOperatorsEnum::Multiply, L"4", L"4 * " },
|
|
{ NumbersAndOperatorsEnum::Five, L"5", L"4 * " },
|
|
{ NumbersAndOperatorsEnum::Equals, L"20", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" } };
|
|
ValidateViewModelByCommands(scientificViewModel2, scientificModeTestItems2, true);
|
|
|
|
// Assert that the Display Value of 1st instance is unchanged
|
|
VERIFY_ARE_EQUAL(scientificViewModel1->DisplayValue, StringReference(L"1"));
|
|
}
|
|
|
|
// Perform calculations on 2 instances of Calculator in Scientific Mode
|
|
// (with different Angle types, HYP and F-E settings) and verify that they work independently
|
|
TEST_METHOD(MultipleScientificModeWithDifferentSettingsTest)
|
|
{
|
|
// Create 2 instances of Standard Mode
|
|
StandardCalculatorViewModel ^ scientificViewModel1 = ref new StandardCalculatorViewModel();
|
|
StandardCalculatorViewModel ^ scientificViewModel2 = ref new StandardCalculatorViewModel();
|
|
|
|
ChangeMode(scientificViewModel1, 1);
|
|
ChangeMode(scientificViewModel2, 1);
|
|
|
|
ValidateViewModelMode(scientificViewModel1, 1);
|
|
ValidateViewModelMode(scientificViewModel2, 1);
|
|
|
|
// Perform Calculations on the 2 instances and check that they work independently
|
|
|
|
// Scientific Mode 1: Degrees with HYP checked
|
|
TESTITEM scientificModeInitializeItems1[] = { { NumbersAndOperatorsEnum::Degree, L"0", L"" },
|
|
{ NumbersAndOperatorsEnum::Hyp, L"0", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" } };
|
|
ValidateViewModelByCommands(scientificViewModel1, scientificModeInitializeItems1, true);
|
|
|
|
// Scientific Mode 2: Radians with F-E checked
|
|
TESTITEM scientificModeInitializeItems2[] = { { NumbersAndOperatorsEnum::Radians, L"0", L"" },
|
|
{ NumbersAndOperatorsEnum::FToE, L"0.e+0", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" } };
|
|
ValidateViewModelByCommands(scientificViewModel2, scientificModeInitializeItems2, true);
|
|
|
|
// Scientific Mode 1: Expression CosH(0 degrees)
|
|
TESTITEM scientificModeTestItems1[] = { { NumbersAndOperatorsEnum::Zero, L"0", L"" },
|
|
{ NumbersAndOperatorsEnum::Cosh, L"1", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" } };
|
|
ValidateViewModelByCommands(scientificViewModel1, scientificModeTestItems1, true);
|
|
|
|
// Scientific Mode 2: Expression Cos(pi radians)
|
|
TESTITEM scientificModeTestItems2[] = { { NumbersAndOperatorsEnum::Pi, L"3.1415926535897932384626433832795e+0", L"" },
|
|
{ NumbersAndOperatorsEnum::Cos, L"-1.e+0", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" } };
|
|
ValidateViewModelByCommands(scientificViewModel2, scientificModeTestItems2, true);
|
|
}
|
|
|
|
// Perform calculations on 2 instances of Calculator in Programmer Mode and verify that they work independently
|
|
TEST_METHOD(MultipleProgrammerModeCalculationTest)
|
|
{
|
|
// Create 2 instances of Standard Mode
|
|
StandardCalculatorViewModel ^ programmerViewModel1 = ref new StandardCalculatorViewModel();
|
|
StandardCalculatorViewModel ^ programmerViewModel2 = ref new StandardCalculatorViewModel();
|
|
|
|
ChangeMode(programmerViewModel1, 2);
|
|
ChangeMode(programmerViewModel2, 2);
|
|
|
|
ValidateViewModelMode(programmerViewModel1, 2);
|
|
ValidateViewModelMode(programmerViewModel2, 2);
|
|
|
|
// Perform Calculations on the 2 instances and check that they work independently
|
|
|
|
// Radix Type: Hexadecimal, Expression: F
|
|
TESTITEM programmerModeTestItems1[] = { { NumbersAndOperatorsEnum::HexButton, L"0", L"" },
|
|
{ NumbersAndOperatorsEnum::F, L"F", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" } };
|
|
|
|
ValidateViewModelByCommands(programmerViewModel1, programmerModeTestItems1, false);
|
|
VERIFY_ARE_EQUAL(programmerViewModel1->HexDisplayValue, StringReference(L"F"));
|
|
VERIFY_ARE_EQUAL(programmerViewModel1->DecimalDisplayValue, StringReference(L"15"));
|
|
VERIFY_ARE_EQUAL(programmerViewModel1->OctalDisplayValue, StringReference(L"17"));
|
|
VERIFY_ARE_EQUAL(programmerViewModel1->BinaryDisplayValue, StringReference(L"1111"));
|
|
|
|
// Radix Type: Octal, Expression: 7
|
|
TESTITEM programmerModeTestItems2[] = { { NumbersAndOperatorsEnum::OctButton, L"0", L"" },
|
|
{ NumbersAndOperatorsEnum::Seven, L"7", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" } };
|
|
|
|
ValidateViewModelByCommands(programmerViewModel2, programmerModeTestItems2, false);
|
|
VERIFY_ARE_EQUAL(programmerViewModel2->HexDisplayValue, StringReference(L"7"));
|
|
VERIFY_ARE_EQUAL(programmerViewModel2->DecimalDisplayValue, StringReference(L"7"));
|
|
VERIFY_ARE_EQUAL(programmerViewModel2->OctalDisplayValue, StringReference(L"7"));
|
|
VERIFY_ARE_EQUAL(programmerViewModel2->BinaryDisplayValue, StringReference(L"0111"));
|
|
|
|
// Assert that displayed values of 1st instance are unchanged
|
|
VERIFY_ARE_EQUAL(programmerViewModel1->DisplayValue, StringReference(L"F"));
|
|
VERIFY_ARE_EQUAL(programmerViewModel1->HexDisplayValue, StringReference(L"F"));
|
|
VERIFY_ARE_EQUAL(programmerViewModel1->DecimalDisplayValue, StringReference(L"15"));
|
|
VERIFY_ARE_EQUAL(programmerViewModel1->OctalDisplayValue, StringReference(L"17"));
|
|
VERIFY_ARE_EQUAL(programmerViewModel1->BinaryDisplayValue, StringReference(L"1111"));
|
|
}
|
|
|
|
// Perform calculations on 2 instances of Calculator in Programmer Mode
|
|
// (with different Bit lengths and Radix types) and verify that they work independently
|
|
TEST_METHOD(MultipleProgrammerModeWithDifferentSettingsTest)
|
|
{
|
|
// Create 2 instances of Standard Mode
|
|
StandardCalculatorViewModel ^ programmerViewModel1 = ref new StandardCalculatorViewModel();
|
|
StandardCalculatorViewModel ^ programmerViewModel2 = ref new StandardCalculatorViewModel();
|
|
|
|
ChangeMode(programmerViewModel1, 2);
|
|
ChangeMode(programmerViewModel2, 2);
|
|
|
|
ValidateViewModelMode(programmerViewModel1, 2);
|
|
ValidateViewModelMode(programmerViewModel2, 2);
|
|
|
|
// Perform Calculations on the 2 instances and check that they work independently
|
|
|
|
// Bit length: Byte & Radix Type: Hex
|
|
TESTITEM programmerModeInitializeItems1[] = { { NumbersAndOperatorsEnum::Byte, L"0", L"" },
|
|
{ NumbersAndOperatorsEnum::HexButton, L"0", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" } };
|
|
|
|
ValidateViewModelByCommands(programmerViewModel1, programmerModeInitializeItems1, false);
|
|
|
|
// Bit Length: Word & Radix Type: Oct
|
|
TESTITEM programmerModeInitializeItems2[] = { { NumbersAndOperatorsEnum::Word, L"0", L"" },
|
|
{ NumbersAndOperatorsEnum::OctButton, L"0", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" } };
|
|
|
|
ValidateViewModelByCommands(programmerViewModel2, programmerModeInitializeItems2, false);
|
|
|
|
TESTITEM programmerModeTestItems1[] = { { NumbersAndOperatorsEnum::F, L"F", L"" },
|
|
{ NumbersAndOperatorsEnum::F, L"FF", L"" },
|
|
// One more F shouldn't have any effect, testing for precision
|
|
{ NumbersAndOperatorsEnum::F, L"FF", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" } };
|
|
|
|
ValidateViewModelByCommands(programmerViewModel1, programmerModeTestItems1, false);
|
|
VERIFY_ARE_EQUAL(programmerViewModel1->HexDisplayValue, StringReference(L"FF"));
|
|
VERIFY_ARE_EQUAL(programmerViewModel1->DecimalDisplayValue, StringReference(L"-1"));
|
|
VERIFY_ARE_EQUAL(programmerViewModel1->OctalDisplayValue, StringReference(L"377"));
|
|
VERIFY_ARE_EQUAL(programmerViewModel1->BinaryDisplayValue, StringReference(L"1111 1111"));
|
|
|
|
TESTITEM programmerModeTestItems2[] = { { NumbersAndOperatorsEnum::Seven, L"7", L"" },
|
|
{ NumbersAndOperatorsEnum::Seven, L"77", L"" },
|
|
{ NumbersAndOperatorsEnum::Seven, L"777", L"" },
|
|
{ NumbersAndOperatorsEnum::Seven, L"7 777", L"" },
|
|
{ NumbersAndOperatorsEnum::Seven, L"77 777", L"" },
|
|
// One more '7' shouldn't have any effect, testing for precision
|
|
{ NumbersAndOperatorsEnum::Seven, L"77 777", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" } };
|
|
|
|
ValidateViewModelByCommands(programmerViewModel2, programmerModeTestItems2, false);
|
|
VERIFY_ARE_EQUAL(programmerViewModel2->HexDisplayValue, StringReference(L"7FFF"));
|
|
VERIFY_ARE_EQUAL(programmerViewModel2->DecimalDisplayValue, StringReference(L"32,767"));
|
|
VERIFY_ARE_EQUAL(programmerViewModel2->OctalDisplayValue, StringReference(L"77 777"));
|
|
VERIFY_ARE_EQUAL(programmerViewModel2->BinaryDisplayValue, StringReference(L"0111 1111 1111 1111"));
|
|
}
|
|
|
|
// Perform calculations on 2 separate instances of Calculator and verify that their History list items are maintained separately
|
|
TEST_METHOD(MultipleModesHistoryAddItemTest)
|
|
{
|
|
std::vector<StandardCalculatorViewModel ^> viewModels(2);
|
|
|
|
// Create 3 instances of StandardCalculatorViewModel in Standard and Scientific mode
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
viewModels[i] = ref new StandardCalculatorViewModel();
|
|
|
|
ChangeMode(viewModels[i], i);
|
|
|
|
// Validate that the history items list is initially empty
|
|
VERIFY_IS_TRUE(0 == viewModels[i]->HistoryVM->ItemsCount);
|
|
}
|
|
|
|
// Perform Calculations on both the instances and check that the History items work independently
|
|
|
|
// Standard Mode: Expression 1+2=
|
|
TESTITEM standardModeTestItems[] = { { 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(viewModels[0], standardModeTestItems, true);
|
|
|
|
// Scientific Mode: Expression 1+2*3
|
|
TESTITEM scientificModeTestItems[] = { { 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(viewModels[1], scientificModeTestItems, true);
|
|
|
|
// Assert for the history list items of 1st instance
|
|
VERIFY_IS_TRUE(1 == viewModels[0]->HistoryVM->ItemsCount);
|
|
|
|
auto item1 = static_cast<HistoryItemViewModel ^>(viewModels[0]->HistoryVM->Items->GetAt(0));
|
|
String ^ expression1 = L"1 + 2 =";
|
|
String ^ result1 = L"3";
|
|
|
|
VERIFY_ARE_EQUAL(expression1, item1->Expression);
|
|
VERIFY_ARE_EQUAL(result1, item1->Result);
|
|
|
|
// Assert for the history list items of 2nd instance
|
|
VERIFY_IS_TRUE(1 == viewModels[1]->HistoryVM->ItemsCount);
|
|
|
|
auto item2 = static_cast<HistoryItemViewModel ^>(viewModels[1]->HistoryVM->Items->GetAt(0));
|
|
String ^ expression2 = L"1 + 2 " + UtfUtils::MUL + L" 3 =";
|
|
String ^ result2 = L"7";
|
|
|
|
VERIFY_ARE_EQUAL(expression2, item2->Expression);
|
|
VERIFY_ARE_EQUAL(result2, item2->Result);
|
|
}
|
|
|
|
// Perform calculations on 2 separate instances of Standard Modes and verify that their History list items are maintained separately
|
|
TEST_METHOD(MultipleStandardModesHistoryAddItemTest)
|
|
{
|
|
std::vector<StandardCalculatorViewModel ^> viewModels(2);
|
|
|
|
// Create 2 instances of StandardCalculatorViewModel in Standard mode
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
viewModels[i] = ref new StandardCalculatorViewModel();
|
|
|
|
// Standard Mode
|
|
ChangeMode(viewModels[i], 0);
|
|
|
|
// Validate that the history items list is initially empty
|
|
VERIFY_IS_TRUE(0 == viewModels[i]->HistoryVM->ItemsCount);
|
|
}
|
|
|
|
// Perform Calculations on both the instances and check that the History items work independently
|
|
|
|
TESTITEM standardModeTestItems[2][8] = { { { NumbersAndOperatorsEnum::IsStandardMode, L"0", L"" },
|
|
{ NumbersAndOperatorsEnum::Three, L"3", L"" },
|
|
{ NumbersAndOperatorsEnum::Add, L"3", L"3 + " },
|
|
{ NumbersAndOperatorsEnum::Two, L"2", L"3 + " },
|
|
{ NumbersAndOperatorsEnum::Multiply, L"5", L"5 * " },
|
|
{ NumbersAndOperatorsEnum::One, L"1", L"5 * " },
|
|
{ NumbersAndOperatorsEnum::Equals, L"5", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" } },
|
|
{ { 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"3 * " },
|
|
{ NumbersAndOperatorsEnum::Three, L"3", L"3 * " },
|
|
{ NumbersAndOperatorsEnum::Equals, L"9", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" } } };
|
|
|
|
// Run the commands
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
ValidateViewModelByCommands(viewModels[i], standardModeTestItems[i], true);
|
|
}
|
|
|
|
String ^ expression[2][2] = { { L"5 " + UtfUtils::MUL + L" 1 =", L"3 + 2 =" }, { L"3 " + UtfUtils::MUL + L" 3 =", L"1 + 2 =" } };
|
|
String ^ result[2][2] = { { L"5", L"5" }, { L"9", L"3" } };
|
|
|
|
// Assert for the history list items of the instances
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
VERIFY_IS_TRUE(2 == viewModels[i]->HistoryVM->ItemsCount);
|
|
|
|
for (int j = 0; j < 2 ; j++)
|
|
{
|
|
auto item = static_cast<HistoryItemViewModel ^>(viewModels[i]->HistoryVM->Items->GetAt(j));
|
|
|
|
VERIFY_ARE_EQUAL(expression[i][j], item->Expression);
|
|
VERIFY_ARE_EQUAL(result[i][j], item->Result);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Perform calculations on 2 separate instances of Scientific Modes and verify that their History list items are maintained separately
|
|
TEST_METHOD(MultipleScientificModesHistoryAddItemTest)
|
|
{
|
|
std::vector<StandardCalculatorViewModel ^> viewModels(2);
|
|
|
|
// Create 2 instances of StandardCalculatorViewModel in Scientific mode
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
viewModels[i] = ref new StandardCalculatorViewModel();
|
|
|
|
// Scientific Mode
|
|
ChangeMode(viewModels[i], 1);
|
|
|
|
// Validate that the history items list is initially empty
|
|
VERIFY_IS_TRUE(0 == viewModels[i]->HistoryVM->ItemsCount);
|
|
}
|
|
|
|
// Perform Calculations on both the instances and check that the History items work independently
|
|
|
|
TESTITEM scientificModeTestItems[2][8] = { { { NumbersAndOperatorsEnum::IsScientificMode, L"0", L"" },
|
|
{ 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"" } },
|
|
{ { 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"" } } };
|
|
|
|
// Run the commands
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
ValidateViewModelByCommands(viewModels[i], scientificModeTestItems[i], true);
|
|
}
|
|
|
|
String ^ expression[] = { L"1 + 2 =", L"1 + 2 " + UtfUtils::MUL + L" 3 =" };
|
|
String ^ result[] = { L"3", L"7" };
|
|
|
|
// Assert for the history list items of the instances
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
VERIFY_IS_TRUE(1 == viewModels[i]->HistoryVM->ItemsCount);
|
|
|
|
auto item = static_cast<HistoryItemViewModel ^>(viewModels[i]->HistoryVM->Items->GetAt(0));
|
|
|
|
VERIFY_ARE_EQUAL(expression[i], item->Expression);
|
|
VERIFY_ARE_EQUAL(result[i], item->Result);
|
|
}
|
|
}
|
|
|
|
// Perform calculations on 3 separate instances of Calculator and verify that their Memory List items are maintained separately
|
|
TEST_METHOD(MultipleModesMemoryAddItemTest)
|
|
{
|
|
std::vector<StandardCalculatorViewModel ^> viewModels(3);
|
|
|
|
// Create 3 instances of StandardCalculatorViewModel in Standard and Scientific mode
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
viewModels[i] = ref new StandardCalculatorViewModel();
|
|
|
|
ChangeMode(viewModels[i], i);
|
|
|
|
// Validate that the history items list is initially empty
|
|
VERIFY_IS_TRUE(0 == viewModels[i]->MemorizedNumbers->Size);
|
|
}
|
|
|
|
// Perform Calculations on both the instances and check that the Memory items work independently
|
|
|
|
// Standard Mode: Expression 1+2=
|
|
TESTITEM standardModeTestItems[] = { { 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(viewModels[0], standardModeTestItems, true);
|
|
|
|
// Scientific Mode: Expression 1+2*3
|
|
TESTITEM scientificModeTestItems[] = { { 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(viewModels[1], scientificModeTestItems, true);
|
|
|
|
// Programmer Mode: Expression F
|
|
TESTITEM programmerModeTestItems[] = { { NumbersAndOperatorsEnum::HexButton, L"0", L"" },
|
|
{ NumbersAndOperatorsEnum::F, L"F", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" } };
|
|
ValidateViewModelByCommands(viewModels[2], programmerModeTestItems, false);
|
|
|
|
// Press the Memory Button to save Values to Memory
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
viewModels[i]->ButtonPressed->Execute(NumbersAndOperatorsEnum::Memory);
|
|
}
|
|
|
|
String ^ expectedMemoryValues[] = { L"3", L"7", L"F" };
|
|
|
|
// Validate that only one item is present in the memory
|
|
// Also assert for their value
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
VERIFY_IS_TRUE(1 == viewModels[i]->MemorizedNumbers->Size);
|
|
auto memorySlot = viewModels[i]->MemorizedNumbers->GetAt(0);
|
|
VERIFY_ARE_EQUAL(expectedMemoryValues[i], memorySlot->Value);
|
|
}
|
|
}
|
|
|
|
TEST_METHOD(MultipleDateCalculatorTest)
|
|
{
|
|
// TODO - MSFT 10331900, fix this test
|
|
// This test mostly passes, but the last set of VERIFYs succeeds for
|
|
// the check of viewModels[2]->StrDateResult when in a UTC- time,
|
|
// however, both the expected and actual results are incorrect. Test
|
|
// needs to be updated with correct expected value and viewmodel needs
|
|
// to be updated to calculate correct value.
|
|
|
|
// DateCalculatorViewModel^ viewModels[4];
|
|
|
|
//// Initialize the view models
|
|
// for (int i = 0; i < 4; i++)
|
|
//{
|
|
// auto vm = ref new DateCalculatorViewModel();
|
|
// vm->Initialize();
|
|
|
|
// viewModels[i] = vm;
|
|
//}
|
|
|
|
// viewModels[2]->IsDateDiffMode = false;
|
|
// viewModels[3]->IsDateDiffMode = false;
|
|
|
|
// viewModels[2]->IsAddMode = true;
|
|
// viewModels[3]->IsAddMode = false;
|
|
|
|
//// Verify the initialization
|
|
// for (int i = 0; i < 2; i++)
|
|
//{
|
|
// VERIFY_IS_TRUE(viewModels[i]->IsDateDiffMode);
|
|
// VERIFY_IS_TRUE(viewModels[i]->FromDate.UniversalTime != 0);
|
|
// VERIFY_IS_TRUE(viewModels[i]->ToDate.UniversalTime != 0);
|
|
// VERIFY_ARE_EQUAL(StringReference(L"Same dates"), viewModels[i]->StrDateDiffResult);
|
|
// VERIFY_IS_NULL(viewModels[i]->StrDateDiffResultInDays);
|
|
//}
|
|
|
|
// for (int i = 2; i < 4; i++)
|
|
//{
|
|
// VERIFY_IS_FALSE(viewModels[i]->IsDateDiffMode);
|
|
// VERIFY_IS_TRUE(viewModels[i]->DaysOffset == 0);
|
|
// VERIFY_IS_TRUE(viewModels[i]->MonthsOffset == 0);
|
|
// VERIFY_IS_TRUE(viewModels[i]->YearsOffset == 0);
|
|
// VERIFY_IS_NOT_NULL(viewModels[i]->StrDateResult);
|
|
// VERIFY_IS_TRUE(StringReference(L"") != viewModels[i]->StrDateResult);
|
|
//}
|
|
|
|
// VERIFY_IS_TRUE(viewModels[2]->IsAddMode);
|
|
// VERIFY_IS_FALSE(viewModels[3]->IsAddMode);
|
|
|
|
//// Perform some calculations
|
|
//// Diff in viewModels[0]
|
|
// SYSTEMTIME date1, date2, resultDate;
|
|
///* 01-10-2015 */ date1.wDay = 1; date1.wMonth = 10; date1.wYear = 2015; date1.wDayOfWeek = 4; date1.wHour = 0; date1.wMinute = 0; date1.wSecond = 0;
|
|
/// date1.wMilliseconds = 0;
|
|
///* 15-02-2016 */ date2.wDay = 15; date2.wMonth = 2; date2.wYear = 2016; date2.wDayOfWeek = 1; date2.wHour = 0; date2.wMinute = 0; date2.wSecond = 0;
|
|
/// date2.wMilliseconds = 0;
|
|
|
|
// viewModels[0]->FromDate = DateUtils::SystemTimeToDateTime(date1);
|
|
// viewModels[0]->ToDate = DateUtils::SystemTimeToDateTime(date2);
|
|
|
|
//// Diff in viewModels[1]
|
|
///* 12-12-2015 */ date1.wDay = 12; date1.wMonth = 12; date1.wYear = 2015; date1.wDayOfWeek = 6;
|
|
///* 15-12-2015 */ date2.wDay = 15; date2.wMonth = 12; date2.wYear = 2015; date2.wDayOfWeek = 2;
|
|
///* 17-01-2018 */ resultDate.wDay = 17; resultDate.wMonth = 1; resultDate.wYear = 2018; resultDate.wDayOfWeek = 3; resultDate.wHour = 0; resultDate.wMinute
|
|
///= 0; resultDate.wSecond = 0; resultDate.wMilliseconds = 0;
|
|
|
|
// viewModels[1]->FromDate = DateUtils::SystemTimeToDateTime(date1);
|
|
// viewModels[1]->ToDate = DateUtils::SystemTimeToDateTime(date2);
|
|
|
|
//// Add in viewModels[2]
|
|
// viewModels[2]->StartDate = DateUtils::SystemTimeToDateTime(date1);
|
|
// viewModels[2]->DaysOffset = 5;
|
|
// viewModels[2]->MonthsOffset = 1;
|
|
// viewModels[2]->YearsOffset = 2;
|
|
|
|
//// Subtract OOB in viewModels[3]
|
|
// viewModels[3]->StartDate = DateUtils::SystemTimeToDateTime(date2);
|
|
// viewModels[3]->DaysOffset = 5;
|
|
// viewModels[3]->MonthsOffset = 1;
|
|
// viewModels[3]->YearsOffset = 500;
|
|
|
|
//// Assert for the result
|
|
// VERIFY_IS_FALSE(viewModels[0]->IsDiffInDays);
|
|
// VERIFY_ARE_EQUAL(StringReference(L"137 days"), viewModels[0]->StrDateDiffResultInDays);
|
|
// VERIFY_ARE_EQUAL(StringReference(L"4 months, 2 weeks"), viewModels[0]->StrDateDiffResult);
|
|
|
|
// VERIFY_IS_TRUE(viewModels[1]->IsDiffInDays);
|
|
// VERIFY_ARE_EQUAL(StringReference(L"3 days"), viewModels[1]->StrDateDiffResult);
|
|
// VERIFY_IS_NULL(viewModels[1]->StrDateDiffResultInDays);
|
|
|
|
//// TODO - MSFT 10331900 : both GetLongDate and viewmodel return incorrect values!
|
|
// VERIFY_ARE_EQUAL(DateUtils::GetLongDate(resultDate), viewModels[2]->StrDateResult);
|
|
// VERIFY_ARE_EQUAL(StringReference(L"Date out of Bound"), viewModels[3]->StrDateResult);
|
|
}
|
|
|
|
TEST_METHOD(InitializeMultipleConverterTest)
|
|
{
|
|
std::shared_ptr<UnitConverterMock> unitConverterMocks[3];
|
|
UnitConverterViewModel ^ viewModels[3];
|
|
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
unitConverterMocks[i] = std::make_shared<UnitConverterMock>();
|
|
viewModels[i] = ref new UnitConverterViewModel(unitConverterMocks[i]);
|
|
IObservableVector<Category ^> ^ cats = viewModels[i]->Categories;
|
|
VERIFY_ARE_EQUAL((UINT)1, unitConverterMocks[i]->m_getCategoriesCallCount);
|
|
VERIFY_ARE_EQUAL((UINT)4, cats->Size);
|
|
// Verify that we match current category
|
|
VERIFY_IS_TRUE(CAT2 == viewModels[i]->CurrentCategory->GetModelCategory());
|
|
}
|
|
|
|
// Change category of 1st instance to CAT1 and that of 2nd instance to CAT2
|
|
viewModels[0]->CurrentCategory = viewModels[0]->Categories->GetAt(0);
|
|
viewModels[2]->CurrentCategory = viewModels[1]->Categories->GetAt(2);
|
|
|
|
// Verify that the instance properties were set independently
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
VERIFY_ARE_EQUAL((UINT)4, viewModels[i]->Categories->Size);
|
|
VERIFY_ARE_EQUAL((UINT)3, viewModels[i]->Units->Size);
|
|
}
|
|
|
|
VERIFY_IS_TRUE(CAT1 == viewModels[0]->CurrentCategory->GetModelCategory());
|
|
VERIFY_IS_TRUE(CAT2 == viewModels[1]->CurrentCategory->GetModelCategory());
|
|
VERIFY_IS_TRUE(CAT3 == viewModels[2]->CurrentCategory->GetModelCategory());
|
|
|
|
VERIFY_IS_TRUE(UNIT1 == viewModels[0]->Unit1->GetModelUnit());
|
|
VERIFY_IS_TRUE(UNIT2 == viewModels[0]->Unit2->GetModelUnit());
|
|
|
|
VERIFY_IS_TRUE(UNIT4 == viewModels[1]->Unit1->GetModelUnit());
|
|
VERIFY_IS_TRUE(UNIT6 == viewModels[1]->Unit2->GetModelUnit());
|
|
|
|
VERIFY_IS_TRUE(UNIT9 == viewModels[2]->Unit1->GetModelUnit());
|
|
VERIFY_IS_TRUE(UNIT7 == viewModels[2]->Unit2->GetModelUnit());
|
|
}
|
|
|
|
TEST_METHOD(MultipleConverterModeCalculationTest)
|
|
{
|
|
UnitConverterViewModel ^ viewModels[3];
|
|
ResourceLoader ^ resLoader = ResourceLoader::GetForViewIndependentUse("Test");
|
|
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
viewModels[i] = ref new UnitConverterViewModel(
|
|
std::make_shared<UnitConversionManager::UnitConverter>(std::make_shared<UnitConverterDataLoader>(ref new GeographicRegion()), nullptr));
|
|
IObservableVector<Category ^> ^ categories = viewModels[i]->Categories;
|
|
VERIFY_ARE_EQUAL((UINT)13, categories->Size);
|
|
}
|
|
|
|
IObservableVector<Category ^> ^ categoryList = viewModels[0]->Categories;
|
|
IObservableVector<Unit ^> ^ unitsList[3];
|
|
|
|
// viewModels 0 & 1 have same category(Volume) and viewModel 2 has different category(Length)
|
|
int volumeIndex = NavCategory::GetIndexInGroup(ViewMode::Volume, CategoryGroupType::Converter);
|
|
int lengthIndex = NavCategory::GetIndexInGroup(ViewMode::Length, CategoryGroupType::Converter);
|
|
viewModels[0]->CurrentCategory = categoryList->GetAt(volumeIndex);
|
|
viewModels[1]->CurrentCategory = categoryList->GetAt(volumeIndex);
|
|
viewModels[2]->CurrentCategory = categoryList->GetAt(lengthIndex);
|
|
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
unitsList[i] = viewModels[i]->Units;
|
|
}
|
|
|
|
// Milliliters
|
|
viewModels[0]->Unit1 = unitsList[0]->GetAt(0);
|
|
// Cubic centimeters
|
|
viewModels[0]->Unit2 = unitsList[0]->GetAt(1);
|
|
|
|
// Liters
|
|
viewModels[1]->Unit1 = unitsList[1]->GetAt(2);
|
|
// Cubic meters
|
|
viewModels[1]->Unit2 = unitsList[1]->GetAt(3);
|
|
|
|
// Nanometers
|
|
viewModels[2]->Unit1 = unitsList[2]->GetAt(0);
|
|
// Microns
|
|
viewModels[2]->Unit2 = unitsList[2]->GetAt(1);
|
|
|
|
// Check that the units in multiple instances got set correctly
|
|
VERIFY_IS_TRUE(unitsList[0]->GetAt(0) == viewModels[0]->Unit1);
|
|
VERIFY_IS_TRUE(unitsList[0]->GetAt(1) == viewModels[0]->Unit2);
|
|
|
|
VERIFY_IS_TRUE(unitsList[1]->GetAt(2) == viewModels[1]->Unit1);
|
|
VERIFY_IS_TRUE(unitsList[1]->GetAt(3) == viewModels[1]->Unit2);
|
|
|
|
VERIFY_IS_TRUE(unitsList[2]->GetAt(0) == viewModels[2]->Unit1);
|
|
VERIFY_IS_TRUE(unitsList[2]->GetAt(1) == viewModels[2]->Unit2);
|
|
|
|
// Perform conversions
|
|
viewModels[0]->ButtonPressed->Execute(NumbersAndOperatorsEnum::One);
|
|
|
|
viewModels[1]->ButtonPressed->Execute(NumbersAndOperatorsEnum::Two);
|
|
|
|
viewModels[2]->ButtonPressed->Execute(NumbersAndOperatorsEnum::Three);
|
|
|
|
// Validate Value1 and Value2 which is the result
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
auto expectedValue1 = (i + 1).ToString();
|
|
auto actualValue1 = viewModels[i]->Value1;
|
|
|
|
VERIFY_ARE_EQUAL(expectedValue1, actualValue1);
|
|
|
|
std::wstring unit1Name = viewModels[i]->Unit1->Name->Data();
|
|
std::wstring unit2Name = viewModels[i]->Unit2->Name->Data();
|
|
|
|
auto resKey = String::Concat(ref new String((unit1Name + L"-" + unit2Name + L"-").c_str()), expectedValue1);
|
|
String ^ expectedResult = resLoader->GetString(resKey);
|
|
|
|
String ^ actualResult = viewModels[i]->Value2;
|
|
|
|
VERIFY_ARE_EQUAL(expectedResult, actualResult);
|
|
}
|
|
}
|
|
|
|
TEST_METHOD(TestStandardUnitConverterAndDateViewModels)
|
|
{
|
|
// Create instances of SCVM in Standard Mode and UnitConverterViewModel
|
|
StandardCalculatorViewModel ^ standardViewModel = ref new StandardCalculatorViewModel();
|
|
UnitConverterViewModel ^ unitConverterViewModel = ref new UnitConverterViewModel(
|
|
std::make_shared<UnitConversionManager::UnitConverter>(std::make_shared<UnitConverterDataLoader>(ref new GeographicRegion()), nullptr));
|
|
DateCalculatorViewModel ^ dateCalcViewModel = ref new DateCalculatorViewModel();
|
|
|
|
// Initialize Standard Calculator
|
|
ChangeMode(standardViewModel, 0);
|
|
|
|
// Initialize Date Calculator
|
|
dateCalcViewModel->IsDateDiffMode = false;
|
|
dateCalcViewModel->IsAddMode = true;
|
|
|
|
// Initialize Unit Converter
|
|
int volumeCategoryIndex = NavCategory::GetIndexInGroup(ViewMode::Volume, CategoryGroupType::Converter);
|
|
IObservableVector<Category ^> ^ categories = unitConverterViewModel->Categories;
|
|
unitConverterViewModel->CurrentCategory = categories->GetAt(volumeCategoryIndex);
|
|
unitConverterViewModel->Unit1 = unitConverterViewModel->Units->GetAt(2);
|
|
unitConverterViewModel->Unit2 = unitConverterViewModel->Units->GetAt(3);
|
|
|
|
// Validate Calculator mode and UC Category and Units
|
|
ValidateViewModelMode(standardViewModel, 0);
|
|
|
|
VERIFY_ARE_EQUAL(categories->GetAt(volumeCategoryIndex), unitConverterViewModel->CurrentCategory);
|
|
VERIFY_ARE_EQUAL(unitConverterViewModel->Units->GetAt(2), unitConverterViewModel->Unit1);
|
|
VERIFY_ARE_EQUAL(unitConverterViewModel->Units->GetAt(3), unitConverterViewModel->Unit2);
|
|
|
|
// Perform Calculations on these instances and check that they work independently
|
|
|
|
// Standard Mode 1: Expression 3-2=
|
|
TESTITEM standardModeTestItems1[] = { { NumbersAndOperatorsEnum::Three, L"3", L"" },
|
|
{ NumbersAndOperatorsEnum::Subtract, L"3", L"3 - " },
|
|
{ NumbersAndOperatorsEnum::Two, L"2", L"3 - " },
|
|
{ NumbersAndOperatorsEnum::Equals, L"1", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" } };
|
|
ValidateViewModelByCommands(standardViewModel, standardModeTestItems1, true);
|
|
|
|
SYSTEMTIME startDate, endDate;
|
|
/* 01-10-2015 */ startDate.wDay = 1;
|
|
startDate.wMonth = 10;
|
|
startDate.wYear = 2015;
|
|
startDate.wDayOfWeek = 4;
|
|
startDate.wHour = 0;
|
|
startDate.wMinute = 0;
|
|
startDate.wSecond = 0;
|
|
startDate.wMilliseconds = 0;
|
|
/* 02-12-2018 */ endDate.wDay = 2;
|
|
endDate.wMonth = 12;
|
|
endDate.wYear = 2018;
|
|
endDate.wDayOfWeek = 0;
|
|
endDate.wHour = 0;
|
|
endDate.wMinute = 0;
|
|
endDate.wSecond = 0;
|
|
endDate.wMilliseconds = 0;
|
|
|
|
dateCalcViewModel->StartDate = DateUtils::SystemTimeToDateTime(startDate);
|
|
dateCalcViewModel->DaysOffset = 1;
|
|
dateCalcViewModel->MonthsOffset = 2;
|
|
dateCalcViewModel->YearsOffset = 3;
|
|
|
|
unitConverterViewModel->ButtonPressed->Execute(NumbersAndOperatorsEnum::Two);
|
|
|
|
// Validate the Result
|
|
VERIFY_ARE_EQUAL(StringReference(L"2"), unitConverterViewModel->Value1);
|
|
VERIFY_ARE_EQUAL(StringReference(L"0.002"), unitConverterViewModel->Value2);
|
|
|
|
// Assert that the Display Value of Standard Calc instance is unchanged
|
|
VERIFY_ARE_EQUAL(standardViewModel->DisplayValue, StringReference(L"1"));
|
|
|
|
// Again perform calculations on Standard Calc instance and validate that the Converter remains unaffected
|
|
|
|
// Standard Mode: Expression 1+2=
|
|
TESTITEM standardModeTestItems2[] = { { 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(standardViewModel, standardModeTestItems2, true);
|
|
VERIFY_ARE_EQUAL(StringReference(L"3"), standardViewModel->DisplayValue);
|
|
|
|
// Validate the Date Calculator
|
|
VERIFY_ARE_EQUAL(DateUtils::GetLongDate(endDate), dateCalcViewModel->StrDateResult);
|
|
|
|
// Validate the Unit Converter
|
|
VERIFY_ARE_EQUAL(StringReference(L"2"), unitConverterViewModel->Value1);
|
|
VERIFY_ARE_EQUAL(StringReference(L"0.002"), unitConverterViewModel->Value2);
|
|
}
|
|
|
|
// Change the radix in programmer mode and check that other modes are not affected
|
|
TEST_METHOD(MultipleModesWithChangeInProgrammerRadix)
|
|
{
|
|
std::vector<StandardCalculatorViewModel ^> viewModels(3);
|
|
|
|
// Create 2 instances of StandardCalculatorViewModel in Standard and Programmer modes
|
|
viewModels[0] = ref new StandardCalculatorViewModel();
|
|
ChangeMode(viewModels[0], 0);
|
|
|
|
viewModels[1] = ref new StandardCalculatorViewModel();
|
|
ChangeMode(viewModels[1], 2);
|
|
|
|
// Change the programmer mode radix to hex
|
|
TESTITEM programmerModeTestItems[] = { { NumbersAndOperatorsEnum::HexButton, L"0", L"" },
|
|
{ NumbersAndOperatorsEnum::F, L"F", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" } };
|
|
ValidateViewModelByCommands(viewModels[1], programmerModeTestItems, false /*doReset*/);
|
|
VERIFY_ARE_EQUAL(viewModels[1]->HexDisplayValue, StringReference(L"F"));
|
|
|
|
// Standard Mode: Expression 10+2=
|
|
// Radix should be decimal, not hex
|
|
TESTITEM standardModeTestItems[] = { { NumbersAndOperatorsEnum::One, L"1", L"" }, { NumbersAndOperatorsEnum::Zero, L"10", L"" },
|
|
{ NumbersAndOperatorsEnum::Add, L"10", L"10 + " }, { NumbersAndOperatorsEnum::Two, L"2", L"10 + " },
|
|
{ NumbersAndOperatorsEnum::Equals, L"12", L"" }, { NumbersAndOperatorsEnum::None, L"", L"" } };
|
|
ValidateViewModelByCommands(viewModels[0], standardModeTestItems, false /*doReset*/);
|
|
|
|
// Launch a new instance in standard mode
|
|
viewModels[2] = ref new StandardCalculatorViewModel();
|
|
ChangeMode(viewModels[2], 0);
|
|
|
|
// Standard Mode: Expression 10+2=
|
|
// Radix will be decimal by default
|
|
TESTITEM standardModeTestItemsNew[] = { { NumbersAndOperatorsEnum::One, L"1", L"" }, { NumbersAndOperatorsEnum::Zero, L"10", L"" },
|
|
{ NumbersAndOperatorsEnum::Add, L"10", L"10 + " }, { NumbersAndOperatorsEnum::Two, L"2", L"10 + " },
|
|
{ NumbersAndOperatorsEnum::Equals, L"12", L"" }, { NumbersAndOperatorsEnum::None, L"", L"" } };
|
|
ValidateViewModelByCommands(viewModels[2], standardModeTestItemsNew, false /*doReset*/);
|
|
|
|
// Radix in the programmer mode launched should still be hex.
|
|
// A + 1 = B
|
|
TESTITEM programmerModeTestItemsNew[] = { { NumbersAndOperatorsEnum::A, L"A", L"" },
|
|
{ NumbersAndOperatorsEnum::Add, L"A", L"A + " },
|
|
{ NumbersAndOperatorsEnum::One, L"1", L"" },
|
|
{ NumbersAndOperatorsEnum::Equals, L"B", L"" },
|
|
{ NumbersAndOperatorsEnum::None, L"", L"" } };
|
|
ValidateViewModelByCommands(viewModels[1], programmerModeTestItemsNew, true /*doReset*/);
|
|
VERIFY_ARE_EQUAL(viewModels[1]->HexDisplayValue, StringReference(L"B"));
|
|
}
|
|
}
|
|
;
|
|
}
|