github/msft-calculator
1
0
Fork 0
mirror of https://github.com/Microsoft/calculator.git synced 2025-07-15 01:32:51 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

refactor HistoryTest.cpp to test the history using HistoryViewModel (#784)

Browse source 
* refactor HistoryTest

* modify MultiWindowUnitTests to not use m_standardCalcManager

* rebase

Co-authored-by: Rudy Huyn <rudy.huyn@microsoft.com>
This commit is contained in:
Rudy Huyn 2020-04-07 17:08:02 -07:00 • committed by GitHub
parent 0ed876db43
commit 825b42ad46
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
13 changed files with 245 additions and 248 deletions
Download patch file Download diff file Expand all files Collapse all files

11
src/CalcViewModel/Common/Utils.cpp
View file

@ -36,17 +36,6 @@ void Utils::IFTPlatformException(HRESULT hr)
} }
} }
String ^ Utils::GetStringValue(String ^ input)
{
// Remove first and last " characters
if (input->Length() >= 3)
{
wstring out(input->Begin() + 1, input->End() - 1);
return ref new String(out.c_str());
}
return input;
}
double Utils::GetDoubleFromWstring(wstring input) double Utils::GetDoubleFromWstring(wstring input)
{ {
constexpr wchar_t unWantedChars[] = { L' ', L',', 8234, 8235, 8236, 8237 }; constexpr wchar_t unWantedChars[] = { L' ', L',', 8234, 8235, 8236, 8237 };

5
src/CalcViewModel/Common/Utils.h
View file

@ -98,7 +98,7 @@ public:
#define OBSERVABLE_NAMED_PROPERTY_R(t, n) \ #define OBSERVABLE_NAMED_PROPERTY_R(t, n) \
OBSERVABLE_PROPERTY_R(t, n) \ OBSERVABLE_PROPERTY_R(t, n) \
internal: \ public: \
static property Platform::String ^ n##PropertyName \ static property Platform::String ^ n##PropertyName \
{ \ { \
Platform::String ^ get() { return Platform::StringReference(L#n); } \ Platform::String ^ get() { return Platform::StringReference(L#n); } \
@ -108,7 +108,7 @@ public:
#define OBSERVABLE_NAMED_PROPERTY_RW(t, n) \ #define OBSERVABLE_NAMED_PROPERTY_RW(t, n) \
OBSERVABLE_PROPERTY_RW(t, n) \ OBSERVABLE_PROPERTY_RW(t, n) \
internal: \ public: \
static property Platform::String ^ n##PropertyName \ static property Platform::String ^ n##PropertyName \
{ \ { \
Platform::String ^ get() { return Platform::StringReference(L#n); } \ Platform::String ^ get() { return Platform::StringReference(L#n); } \
@ -373,7 +373,6 @@ namespace Utils
} }
void IFTPlatformException(HRESULT hr); void IFTPlatformException(HRESULT hr);
Platform::String ^ GetStringValue(Platform::String ^ input);
bool IsLastCharacterTarget(std::wstring const& input, wchar_t target); bool IsLastCharacterTarget(std::wstring const& input, wchar_t target);
// Return wstring after removing characters specified by unwantedChars array // Return wstring after removing characters specified by unwantedChars array

6
src/CalcViewModel/HistoryViewModel.cpp
View file

@ -6,6 +6,7 @@
#include "Common/TraceLogger.h" #include "Common/TraceLogger.h"
#include "Common/LocalizationStringUtil.h" #include "Common/LocalizationStringUtil.h"
#include "Common/LocalizationSettings.h" #include "Common/LocalizationSettings.h"
#include "StandardCalculatorViewModel.h"
using namespace CalculatorApp; using namespace CalculatorApp;
using namespace CalculatorApp::Common; using namespace CalculatorApp::Common;
@ -258,6 +259,11 @@ void HistoryViewModel::ClearHistory()
ClearHistoryContainer(CalculationManager::CalculatorMode::Scientific); ClearHistoryContainer(CalculationManager::CalculatorMode::Scientific);
} }
unsigned long long HistoryViewModel::GetMaxItemSize()
{
return static_cast<unsigned long long>(m_calculatorManager->MaxHistorySize());
}
void HistoryViewModel::SaveHistory() void HistoryViewModel::SaveHistory()
{ {
ApplicationDataContainer ^ historyContainer = GetHistoryContainer(m_currentMode); ApplicationDataContainer ^ historyContainer = GetHistoryContainer(m_currentMode);

3
src/CalcViewModel/HistoryViewModel.h
View file

@ -15,6 +15,8 @@ namespace CalculatorApp
namespace ViewModel namespace ViewModel
{ {
ref class StandardCalculatorViewModel;
public public
delegate void HideHistoryClickedHandler(); delegate void HideHistoryClickedHandler();
public public
@ -45,6 +47,7 @@ namespace CalculatorApp
internal : HistoryViewModel(_In_ CalculationManager::CalculatorManager* calculatorManager); internal : HistoryViewModel(_In_ CalculationManager::CalculatorManager* calculatorManager);
void SetCalculatorDisplay(CalculatorDisplay& calculatorDisplay); void SetCalculatorDisplay(CalculatorDisplay& calculatorDisplay);
void ReloadHistory(_In_ CalculatorApp::Common::ViewMode currentMode); void ReloadHistory(_In_ CalculatorApp::Common::ViewMode currentMode);
unsigned long long GetMaxItemSize();
void DeleteItem(_In_ CalculatorApp::ViewModel::HistoryItemViewModel ^ e); void DeleteItem(_In_ CalculatorApp::ViewModel::HistoryItemViewModel ^ e);

10
src/CalcViewModel/StandardCalculatorViewModel.cpp
View file

@ -1812,3 +1812,13 @@ void StandardCalculatorViewModel::SelectHistoryItem(HistoryItemViewModel ^ item)
SetPrimaryDisplay(item->Result, false); SetPrimaryDisplay(item->Result, false);
IsFToEEnabled = false; IsFToEEnabled = false;
} }
void StandardCalculatorViewModel::ResetCalcManager(bool clearMemory)
{
m_standardCalculatorManager.Reset(clearMemory);
}
void StandardCalculatorViewModel::SendCommandToCalcManager(int commandId)
{
m_standardCalculatorManager.SendCommand(static_cast<Command>(commandId));
}

12
src/CalcViewModel/StandardCalculatorViewModel.h
View file

@ -12,11 +12,6 @@
#include "Common/BitLength.h" #include "Common/BitLength.h"
#include "Common/NumberBase.h" #include "Common/NumberBase.h"
namespace CalculatorFunctionalTests
{
class HistoryTests;
}
namespace CalculatorUnitTests namespace CalculatorUnitTests
{ {
class MultiWindowUnitTests; class MultiWindowUnitTests;
@ -247,7 +242,11 @@ namespace CalculatorApp
} }
} }
internal : // Used by unit tests
void ResetCalcManager(bool clearMemory);
void SendCommandToCalcManager(int command);
internal:
void OnPaste(Platform::String ^ pastedString); void OnPaste(Platform::String ^ pastedString);
void OnCopyCommand(Platform::Object ^ parameter); void OnCopyCommand(Platform::Object ^ parameter);
void OnPasteCommand(Platform::Object ^ parameter); void OnPasteCommand(Platform::Object ^ parameter);
@ -373,7 +372,6 @@ namespace CalculatorApp
CalculatorApp::Common::ViewMode GetCalculatorMode(); CalculatorApp::Common::ViewMode GetCalculatorMode();
friend class CalculatorDisplay; friend class CalculatorDisplay;
friend class CalculatorFunctionalTests::HistoryTests;
friend class CalculatorUnitTests::MultiWindowUnitTests; friend class CalculatorUnitTests::MultiWindowUnitTests;
}; };
} }

1
src/CalculatorUnitTests/CalculatorUnitTests.vcxproj
View file

@ -237,6 +237,7 @@
<ClCompile Include="CopyPasteManagerTest.cpp" /> <ClCompile Include="CopyPasteManagerTest.cpp" />
<ClCompile Include="CurrencyConverterUnitTests.cpp" /> <ClCompile Include="CurrencyConverterUnitTests.cpp" />
<ClCompile Include="DateCalculatorUnitTests.cpp" /> <ClCompile Include="DateCalculatorUnitTests.cpp" />
<ClCompile Include="Helper.cpp" />
<ClCompile Include="HistoryTests.cpp" /> <ClCompile Include="HistoryTests.cpp" />
<ClCompile Include="LocalizationServiceUnitTests.cpp" /> <ClCompile Include="LocalizationServiceUnitTests.cpp" />
<ClCompile Include="LocalizationSettingsUnitTests.cpp" /> <ClCompile Include="LocalizationSettingsUnitTests.cpp" />

1
src/CalculatorUnitTests/CalculatorUnitTests.vcxproj.filters
View file

@ -30,6 +30,7 @@
<ClCompile Include="LocalizationServiceUnitTests.cpp" /> <ClCompile Include="LocalizationServiceUnitTests.cpp" />
<ClCompile Include="RationalTest.cpp" /> <ClCompile Include="RationalTest.cpp" />
<ClCompile Include="LocalizationSettingsUnitTests.cpp" /> <ClCompile Include="LocalizationSettingsUnitTests.cpp" />
<ClCompile Include="Helper.cpp" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ClInclude Include="DateUtils.h" /> <ClInclude Include="DateUtils.h" />

14
src/CalculatorUnitTests/Helper.cpp Normal file
View file

@ -0,0 +1,14 @@
#include "pch.h"
#include "Helpers.h"
using namespace Platform;
using namespace std;
String ^ GetStringValue(String ^ input) {
// Remove first and last " characters
if (input->Length() >= 3)
{
wstring out(input->Begin() + 1, input->End() - 1);
return ref new String(out.c_str());
}
return input;
}

2
src/CalculatorUnitTests/Helpers.h
View file

@ -108,3 +108,5 @@ void VERIFY_VECTORS_ARE_EQUAL(Windows::Foundation::Collections::IVector<T> ^ vec
VERIFY_ARE_EQUAL(vecA->GetAt(i), vecB->GetAt(i), __VA_ARGS__); VERIFY_ARE_EQUAL(vecA->GetAt(i), vecB->GetAt(i), __VA_ARGS__);
} }
}; };
Platform::String ^ GetStringValue(Platform::String ^ input);

343
src/CalculatorUnitTests/HistoryTests.cpp
View file

@ -46,17 +46,16 @@ namespace CalculatorFunctionalTests
{ {
m_standardViewModel = ref new StandardCalculatorViewModel(); m_standardViewModel = ref new StandardCalculatorViewModel();
m_standardViewModel->IsStandard = true; m_standardViewModel->IsStandard = true;
m_historyViewModel = ref new HistoryViewModel(&(m_standardViewModel->m_standardCalculatorManager)); m_historyViewModel = m_standardViewModel->HistoryVM;
m_historyViewModel->SetCalculatorDisplay(m_standardViewModel->m_calculatorDisplay);
} }
void Cleanup() void Cleanup()
{ {
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::ModeBasic); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::ModeBasic));
m_historyViewModel->OnClearCommand(nullptr); m_historyViewModel->OnClearCommand(nullptr);
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::ModeScientific); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::ModeScientific));
m_historyViewModel->OnClearCommand(nullptr); m_historyViewModel->OnClearCommand(nullptr);
m_standardViewModel->m_standardCalculatorManager.Reset(); m_standardViewModel->ResetCalcManager(false);
} }
bool IsHistoryContainerEmpty(_In_ String ^ historyContainerKey) bool IsHistoryContainerEmpty(_In_ String ^ historyContainerKey)
@ -71,64 +70,54 @@ namespace CalculatorFunctionalTests
return String::Concat(modeValue->ToString(), L"_History"); return String::Concat(modeValue->ToString(), L"_History");
} }
void MockOnHistoryItemClicked(CalculatorApp::ViewModel::HistoryItemViewModel^ e)
{
m_standardViewModel->SetHistoryExpressionDisplay(e->GetTokens(), e->GetCommands());
m_standardViewModel->SetExpressionDisplay(e->GetTokens(), e->GetCommands());
m_standardViewModel->SetPrimaryDisplay(e->Result, false /*IsError*/);
m_standardViewModel->IsFToEEnabled = false;
}
void AddSingleHistoryItem() void AddSingleHistoryItem()
{ {
Initialize(); Initialize();
int initialSize = m_historyViewModel->ItemSize; int initialSize = m_historyViewModel->ItemSize;
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command1); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command1));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandADD); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandADD));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command8); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command8));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandEQU); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandEQU));
int sizeAfterItemAdd = m_historyViewModel->ItemSize; int sizeAfterItemAdd = m_historyViewModel->ItemSize;
auto historyItem = m_standardViewModel->m_standardCalculatorManager.GetHistoryItem(0); auto historyItem = static_cast<HistoryItemViewModel ^>(m_historyViewModel->Items->GetAt(0));
String ^ expression = UtfUtils::LRO + L"1 + 8 =" + UtfUtils::PDF; String ^ expression = UtfUtils::LRO + L"1 + 8 =" + UtfUtils::PDF;
String ^ result = StringReference(L"9");
VERIFY_ARE_EQUAL(initialSize + 1, sizeAfterItemAdd); VERIFY_ARE_EQUAL(initialSize + 1, sizeAfterItemAdd);
VERIFY_ARE_EQUAL(expression, StringReference(historyItem->historyItemVector.expression.c_str())); VERIFY_ARE_EQUAL(historyItem->Expression, expression);
VERIFY_ARE_EQUAL(result, StringReference(historyItem->historyItemVector.result.c_str())); VERIFY_ARE_EQUAL(historyItem->Result, L"9");
Cleanup(); Cleanup();
} }
void AddMaxHistoryItems() void AddMaxHistoryItems()
{ {
Initialize(); Initialize();
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command1); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command1));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandADD); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandADD));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command1); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command1));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandEQU); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandEQU));
for (size_t i = 1; i < m_standardViewModel->m_standardCalculatorManager.MaxHistorySize(); i++) for (unsigned long long i = 1; i < m_historyViewModel->GetMaxItemSize(); i++)
{ {
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command1); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command1));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandADD); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandADD));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command2); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command2));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandEQU); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandEQU));
} }
VERIFY_ARE_EQUAL((size_t)m_historyViewModel->ItemSize, m_standardViewModel->m_standardCalculatorManager.MaxHistorySize()); VERIFY_ARE_EQUAL((size_t)m_historyViewModel->ItemSize, m_historyViewModel->GetMaxItemSize());
String ^ expression = UtfUtils::LRO + L"1 + 1 =" + UtfUtils::PDF; String ^ expression = UtfUtils::LRO + L"1 + 1 =" + UtfUtils::PDF;
int output = 2; int output = 2;
String ^ result = output.ToString(); String ^ result = output.ToString();
auto historyItem = m_standardViewModel->m_standardCalculatorManager.GetHistoryItem(0); auto historyItem = static_cast<HistoryItemViewModel ^>(m_historyViewModel->Items->GetAt(m_historyViewModel->ItemSize - 1));
VERIFY_ARE_EQUAL(expression, StringReference(historyItem->historyItemVector.expression.c_str())); VERIFY_ARE_EQUAL(historyItem->Expression, expression);
VERIFY_ARE_EQUAL(result, StringReference(historyItem->historyItemVector.result.c_str())); VERIFY_ARE_EQUAL(historyItem->Result, result);
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command1); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command1));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandADD); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandADD));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command5); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command5));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandEQU); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandEQU));
VERIFY_ARE_EQUAL((size_t)m_historyViewModel->ItemSize, m_standardViewModel->m_standardCalculatorManager.MaxHistorySize());
expression = UtfUtils::LRO + L"1 + 2 =" + UtfUtils::PDF; expression = UtfUtils::LRO + L"1 + 2 =" + UtfUtils::PDF;
output = 3; output = 3;
result = output.ToString(); result = output.ToString();
historyItem = m_standardViewModel->m_standardCalculatorManager.GetHistoryItem(0); historyItem = static_cast<HistoryItemViewModel ^>(m_historyViewModel->Items->GetAt(m_historyViewModel->ItemSize - 1));
VERIFY_ARE_EQUAL(expression, StringReference(historyItem->historyItemVector.expression.c_str())); VERIFY_ARE_EQUAL(historyItem->Expression, expression);
VERIFY_ARE_EQUAL(result, StringReference(historyItem->historyItemVector.result.c_str())); VERIFY_ARE_EQUAL(historyItem->Result, result);
Cleanup(); Cleanup();
} }
@ -136,30 +125,30 @@ namespace CalculatorFunctionalTests
{ {
Initialize(); Initialize();
m_standardViewModel->m_standardCalculatorManager.Reset(); m_standardViewModel->ResetCalcManager(false);
int scientificItems = 5; int scientificItems = 5;
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::ModeScientific); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::ModeScientific));
for (int i = 0; i < scientificItems; i++) for (int i = 0; i < scientificItems; i++)
{ {
Command nextCommand = Command(130 + i); Command nextCommand = Command(130 + i);
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command1); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command1));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandADD); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandADD));
m_standardViewModel->m_standardCalculatorManager.SendCommand(nextCommand); m_standardViewModel->SendCommandToCalcManager((int)nextCommand);
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandEQU); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandEQU));
} }
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::ModeBasic); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::ModeBasic));
int standardItems = 2; int standardItems = 2;
for (int i = 0; i < standardItems; i++) for (int i = 0; i < standardItems; i++)
{ {
Command nextCommand = Command(130 + i); Command nextCommand = Command(130 + i);
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command1); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command1));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandADD); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandADD));
m_standardViewModel->m_standardCalculatorManager.SendCommand(nextCommand); m_standardViewModel->SendCommandToCalcManager((int)nextCommand);
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandEQU); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandEQU));
} }
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::ModeScientific); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::ModeScientific));
m_historyViewModel->ReloadHistory(ViewMode::Scientific); m_historyViewModel->ReloadHistory(ViewMode::Scientific);
VERIFY_ARE_EQUAL(scientificItems, m_historyViewModel->ItemSize); VERIFY_ARE_EQUAL(scientificItems, m_historyViewModel->ItemSize);
for (int i = 0; i < scientificItems; i++) for (int i = 0; i < scientificItems; i++)
@ -168,13 +157,13 @@ namespace CalculatorFunctionalTests
expr = UtfUtils::LRO + expr + UtfUtils::PDF; expr = UtfUtils::LRO + expr + UtfUtils::PDF;
int output = 1 + i; int output = 1 + i;
String ^ result = output.ToString(); String ^ result = output.ToString();
auto historyItem = m_standardViewModel->m_standardCalculatorManager.GetHistoryItem(i); auto historyItem = static_cast<HistoryItemViewModel ^>(m_historyViewModel->Items->GetAt(m_historyViewModel->ItemSize - 1 - i));
VERIFY_ARE_EQUAL(expr, historyItem->historyItemVector.expression); VERIFY_ARE_EQUAL(historyItem->Expression, StringReference(expr.c_str()));
VERIFY_ARE_EQUAL(result, StringReference(historyItem->historyItemVector.result.c_str())); VERIFY_ARE_EQUAL(historyItem->Result, result);
} }
m_historyViewModel->ReloadHistory(ViewMode::Standard); m_historyViewModel->ReloadHistory(ViewMode::Standard);
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::ModeBasic); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::ModeBasic));
VERIFY_ARE_EQUAL(standardItems, m_historyViewModel->ItemSize); VERIFY_ARE_EQUAL(standardItems, m_historyViewModel->ItemSize);
for (int i = 0; i < standardItems; i++) for (int i = 0; i < standardItems; i++)
{ {
@ -182,9 +171,9 @@ namespace CalculatorFunctionalTests
expr = UtfUtils::LRO + expr + UtfUtils::PDF; expr = UtfUtils::LRO + expr + UtfUtils::PDF;
int output = 1 + i; int output = 1 + i;
String ^ result = output.ToString(); String ^ result = output.ToString();
auto historyItem = m_standardViewModel->m_standardCalculatorManager.GetHistoryItem(i); auto historyItem = static_cast<HistoryItemViewModel ^>(m_historyViewModel->Items->GetAt(m_historyViewModel->ItemSize - 1 - i));
VERIFY_ARE_EQUAL(expr, historyItem->historyItemVector.expression); VERIFY_ARE_EQUAL(historyItem->Expression, StringReference(expr.c_str()));
VERIFY_ARE_EQUAL(result, StringReference(historyItem->historyItemVector.result.c_str())); VERIFY_ARE_EQUAL(historyItem->Result, result);
} }
Cleanup(); Cleanup();
} }
@ -192,16 +181,16 @@ namespace CalculatorFunctionalTests
void ClearHistory() void ClearHistory()
{ {
Initialize(); Initialize();
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::ModeScientific); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::ModeScientific));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command1); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command1));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandADD); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandADD));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command2); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command2));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandEQU); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandEQU));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::ModeBasic); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::ModeBasic));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command1); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command1));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandADD); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandADD));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command2); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command2));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandEQU); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandEQU));
m_historyViewModel->OnClearCommand(nullptr); m_historyViewModel->OnClearCommand(nullptr);
VERIFY_ARE_EQUAL(0, m_historyViewModel->ItemSize); VERIFY_ARE_EQUAL(0, m_historyViewModel->ItemSize);
VERIFY_IS_TRUE(IsHistoryContainerEmpty(GetHistoryContainerKeyHelper(CalculatorMode::Standard))); VERIFY_IS_TRUE(IsHistoryContainerEmpty(GetHistoryContainerKeyHelper(CalculatorMode::Standard)));
@ -212,53 +201,51 @@ namespace CalculatorFunctionalTests
void SerializeDeSerializeHistoryItem() void SerializeDeSerializeHistoryItem()
{ {
Initialize(); Initialize();
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::ModeScientific); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::ModeScientific));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command1); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command1));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandADD); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandADD));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command2); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command2));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandEQU); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandEQU));
auto itemBeforeSerializeDeserialize = m_standardViewModel->m_standardCalculatorManager.GetHistoryItem(0); auto itemBeforeSerializeDeserialize = static_cast<HistoryItemViewModel ^>(m_historyViewModel->Items->GetAt(0));
m_historyViewModel->SaveHistory(); m_historyViewModel->SaveHistory();
m_historyViewModel->ReloadHistory(ViewMode::Scientific); m_historyViewModel->ReloadHistory(ViewMode::Scientific);
auto itemAfterSerializeDeserialize = m_standardViewModel->m_standardCalculatorManager.GetHistoryItem(0); auto itemAfterSerializeDeserialize = static_cast<HistoryItemViewModel ^>(m_historyViewModel->Items->GetAt(0));
VERIFY_IS_TRUE( VERIFY_IS_TRUE(
(itemBeforeSerializeDeserialize->historyItemVector.expression == itemAfterSerializeDeserialize->historyItemVector.expression) itemBeforeSerializeDeserialize->Expression == itemAfterSerializeDeserialize->Expression
&& (itemBeforeSerializeDeserialize->historyItemVector.result == itemAfterSerializeDeserialize->historyItemVector.result) && itemBeforeSerializeDeserialize->Result == itemAfterSerializeDeserialize->Result);
&& (itemBeforeSerializeDeserialize->historyItemVector.spCommands == itemAfterSerializeDeserialize->historyItemVector.spCommands)
&& (itemBeforeSerializeDeserialize->historyItemVector.spTokens == itemAfterSerializeDeserialize->historyItemVector.spTokens));
Cleanup(); Cleanup();
} }
void SaveAndReloadHistory() void SaveAndReloadHistory()
{ {
Initialize(); Initialize();
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::ModeScientific); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::ModeScientific));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command1); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command1));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandADD); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandADD));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command8); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command8));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandEQU); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandEQU));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command1); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command1));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandADD); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandADD));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command2); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command2));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandEQU); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandEQU));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::ModeBasic); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::ModeBasic));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command1); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command1));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandADD); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandADD));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command6); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command6));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandEQU); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandEQU));
int itemsBeforeSaveAndReload = m_historyViewModel->ItemSize; int itemsBeforeSaveAndReload = m_historyViewModel->ItemSize;
m_historyViewModel->SaveHistory(); m_historyViewModel->SaveHistory();
m_historyViewModel->ReloadHistory(ViewMode::Scientific); m_historyViewModel->ReloadHistory(ViewMode::Scientific);
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::ModeScientific); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::ModeScientific));
wstring expr = L"1 + 8 ="; wstring expr = L"1 + 8 =";
// add double quotes around the expression // add double quotes around the expression
expr = UtfUtils::LRO + expr + UtfUtils::PDF; expr = UtfUtils::LRO + expr + UtfUtils::PDF;
String ^ result = StringReference(L"9"); String ^ result = StringReference(L"9");
int itemsAfterSaveAndReload = m_historyViewModel->ItemSize; int itemsAfterSaveAndReload = m_historyViewModel->ItemSize;
auto historyItem = m_standardViewModel->m_standardCalculatorManager.GetHistoryItem(0);
VERIFY_ARE_EQUAL(expr, historyItem->historyItemVector.expression); auto historyItem = static_cast<HistoryItemViewModel ^>(m_historyViewModel->Items->GetAt(m_historyViewModel->ItemSize - 1));
VERIFY_ARE_EQUAL(result, StringReference(historyItem->historyItemVector.result.c_str())); VERIFY_ARE_EQUAL(historyItem->Expression, StringReference(expr.c_str()));
VERIFY_ARE_EQUAL(historyItem->Result, result);
VERIFY_ARE_NOT_EQUAL(itemsBeforeSaveAndReload, itemsAfterSaveAndReload); VERIFY_ARE_NOT_EQUAL(itemsBeforeSaveAndReload, itemsAfterSaveAndReload);
VERIFY_ARE_EQUAL(itemsBeforeSaveAndReload, itemsAfterSaveAndReload + 1); VERIFY_ARE_EQUAL(itemsBeforeSaveAndReload, itemsAfterSaveAndReload + 1);
Cleanup(); Cleanup();
@ -275,21 +262,21 @@ namespace CalculatorFunctionalTests
ResourceLoader ^ m_uiResourceLoader = ResourceLoader::GetForViewIndependentUse(L"CEngineStrings"); ResourceLoader ^ m_uiResourceLoader = ResourceLoader::GetForViewIndependentUse(L"CEngineStrings");
int itemIndex = 0; int itemIndex = 0;
int commandResource = 67; int commandResource = 67;
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::ModeScientific); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::ModeScientific));
for (int index = 0; index < modes; index++) for (int index = 0; index < modes; index++)
{ {
m_standardViewModel->m_standardCalculatorManager.SendCommand(mode[index]); m_standardViewModel->SendCommandToCalcManager((int)mode[index]);
for (int command = 0; command < commandsSize; command++) for (int command = 0; command < commandsSize; command++)
{ {
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command1); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command1));
m_standardViewModel->m_standardCalculatorManager.SendCommand(commands[command]); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(commands[command]));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandEQU); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandEQU));
auto historyItem = m_standardViewModel->m_standardCalculatorManager.GetHistoryItem(itemIndex); auto historyItem = static_cast<HistoryItemViewModel ^>(m_historyViewModel->Items->GetAt(m_historyViewModel->ItemSize - 1 - itemIndex));
String ^ expression = m_uiResourceLoader->GetString(commandResource.ToString()); String ^ expression = m_uiResourceLoader->GetString(commandResource.ToString());
expression += L"( 1 ) ="; expression += L"( 1 ) =";
wstring expr = wstring(expression->Data()); wstring expr = wstring(expression->Data());
expr = UtfUtils::LRO + expr + UtfUtils::PDF; expr = UtfUtils::LRO + expr + UtfUtils::PDF;
VERIFY_ARE_EQUAL(historyItem->historyItemVector.expression, expr); VERIFY_ARE_EQUAL(historyItem->Expression, StringReference(expr.c_str()));
commandResource++; commandResource++;
itemIndex++; itemIndex++;
} }
@ -301,20 +288,20 @@ namespace CalculatorFunctionalTests
{ {
Initialize(); Initialize();
ResourceLoader ^ m_uiResourceLoader = ResourceLoader::GetForViewIndependentUse(L"CEngineStrings"); ResourceLoader ^ m_uiResourceLoader = ResourceLoader::GetForViewIndependentUse(L"CEngineStrings");
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::ModeScientific); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::ModeScientific));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandDEG); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandDEG));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command1); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command1));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandSIN); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandSIN));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandADD); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandADD));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandRAD); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandRAD));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command1); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command1));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandSIN); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandSIN));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandADD); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandADD));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandGRAD); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandGRAD));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command1); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command1));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandSIN); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandSIN));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandEQU); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandEQU));
auto historyItem = m_standardViewModel->m_standardCalculatorManager.GetHistoryItem(0); auto historyItem = static_cast<HistoryItemViewModel ^>(m_historyViewModel->Items->GetAt(m_historyViewModel->ItemSize - 1));
String ^ expression = m_uiResourceLoader->GetString(L"67"); String ^ expression = m_uiResourceLoader->GetString(L"67");
expression += L"( 1 ) + "; expression += L"( 1 ) + ";
expression += m_uiResourceLoader->GetString(L"73"); expression += m_uiResourceLoader->GetString(L"73");
@ -323,7 +310,7 @@ namespace CalculatorFunctionalTests
expression += L"( 1 ) ="; expression += L"( 1 ) =";
wstring expr = wstring(expression->Data()); wstring expr = wstring(expression->Data());
expr = UtfUtils::LRO + expr + UtfUtils::PDF; expr = UtfUtils::LRO + expr + UtfUtils::PDF;
VERIFY_ARE_EQUAL(historyItem->historyItemVector.expression, expr); VERIFY_ARE_EQUAL(historyItem->Expression, StringReference(expr.c_str()));
Cleanup(); Cleanup();
} }
@ -331,19 +318,15 @@ namespace CalculatorFunctionalTests
void HistoryItemClicked() void HistoryItemClicked()
{ {
Initialize(); Initialize();
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::ModeScientific); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::ModeScientific));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command1); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command1));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandADD); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandADD));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command5); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command5));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandADD); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandADD));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command3); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command3));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandEQU); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandEQU));
auto historyItem = m_standardViewModel->m_standardCalculatorManager.GetHistoryItem(0); auto historyItem = static_cast<HistoryItemViewModel ^>(m_historyViewModel->Items->GetAt(m_historyViewModel->ItemSize - 1));
String ^ expression = StringReference(historyItem->historyItemVector.expression.c_str()); m_standardViewModel->SelectHistoryItem(historyItem);
String ^ result = StringReference(historyItem->historyItemVector.result.c_str());
HistoryItemViewModel ^ item =
ref new HistoryItemViewModel(expression, result, historyItem->historyItemVector.spTokens, historyItem->historyItemVector.spCommands);
MockOnHistoryItemClicked(item);
VERIFY_ARE_EQUAL(StringReference(L"9"), m_standardViewModel->DisplayValue); VERIFY_ARE_EQUAL(StringReference(L"9"), m_standardViewModel->DisplayValue);
VERIFY_ARE_EQUAL(StringReference(L"1"), m_standardViewModel->ExpressionTokens->GetAt(0)->Token); VERIFY_ARE_EQUAL(StringReference(L"1"), m_standardViewModel->ExpressionTokens->GetAt(0)->Token);
VERIFY_ARE_EQUAL(StringReference(L" "), m_standardViewModel->ExpressionTokens->GetAt(1)->Token); VERIFY_ARE_EQUAL(StringReference(L" "), m_standardViewModel->ExpressionTokens->GetAt(1)->Token);
@ -359,37 +342,27 @@ namespace CalculatorFunctionalTests
void HistoryItemLoadAndContinueCalculation() void HistoryItemLoadAndContinueCalculation()
{ {
Initialize(); Initialize();
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::ModeBasic); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::ModeBasic));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command1); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command1));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandADD); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandADD));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command5); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command5));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandADD); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandADD));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command3); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command3));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandEQU); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandEQU));
auto historyItem = m_standardViewModel->m_standardCalculatorManager.GetHistoryItem(0); auto historyItem = static_cast<HistoryItemViewModel ^>(m_historyViewModel->Items->GetAt(m_historyViewModel->ItemSize - 1));
String ^ expression = StringReference(historyItem->historyItemVector.expression.c_str()); m_standardViewModel->SelectHistoryItem(historyItem);
String ^ result = StringReference(historyItem->historyItemVector.result.c_str());
HistoryItemViewModel ^ item =
ref new HistoryItemViewModel(expression, result, historyItem->historyItemVector.spTokens, historyItem->historyItemVector.spCommands);
MockOnHistoryItemClicked(item);
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandADD); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandADD));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command5); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command5));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandEQU); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandEQU));
VERIFY_ARE_EQUAL(StringReference(L"14"), m_standardViewModel->DisplayValue); VERIFY_ARE_EQUAL(StringReference(L"14"), m_standardViewModel->DisplayValue);
historyItem = m_standardViewModel->m_standardCalculatorManager.GetHistoryItem(0); historyItem = static_cast<HistoryItemViewModel ^>(m_historyViewModel->Items->GetAt(m_historyViewModel->ItemSize - 1));
expression = StringReference(historyItem->historyItemVector.expression.c_str()); m_standardViewModel->SelectHistoryItem(historyItem);
result = StringReference(historyItem->historyItemVector.result.c_str());
item = ref new HistoryItemViewModel(expression, result, historyItem->historyItemVector.spTokens, historyItem->historyItemVector.spCommands);
MockOnHistoryItemClicked(item);
VERIFY_ARE_EQUAL(StringReference(L"9"), m_standardViewModel->DisplayValue); VERIFY_ARE_EQUAL(StringReference(L"9"), m_standardViewModel->DisplayValue);
historyItem = m_standardViewModel->m_standardCalculatorManager.GetHistoryItem(1); historyItem = static_cast<HistoryItemViewModel ^>(m_historyViewModel->Items->GetAt(m_historyViewModel->ItemSize - 2));
expression = StringReference(historyItem->historyItemVector.expression.c_str()); m_standardViewModel->SelectHistoryItem(historyItem);
result = StringReference(historyItem->historyItemVector.result.c_str());
item = ref new HistoryItemViewModel(expression, result, historyItem->historyItemVector.spTokens, historyItem->historyItemVector.spCommands);
MockOnHistoryItemClicked(item);
VERIFY_ARE_EQUAL(StringReference(L"14"), m_standardViewModel->DisplayValue); VERIFY_ARE_EQUAL(StringReference(L"14"), m_standardViewModel->DisplayValue);
Cleanup(); Cleanup();
} }
@ -397,26 +370,26 @@ namespace CalculatorFunctionalTests
void DisplayValueAutomationNames() void DisplayValueAutomationNames()
{ {
Initialize(); Initialize();
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command1); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command1));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandADD); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandADD));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command8); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command8));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandEQU); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandEQU));
String ^ expression = StringReference(L"Display is 9"); String ^ expression = StringReference(L"Display is 9");
VERIFY_ARE_EQUAL(expression, m_standardViewModel->CalculationResultAutomationName); VERIFY_ARE_EQUAL(expression, m_standardViewModel->CalculationResultAutomationName);
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::ModeScientific); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::ModeScientific));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command1); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command1));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandADD); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandADD));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command5); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command5));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandEQU); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandEQU));
expression = StringReference(L"Display is 6"); expression = StringReference(L"Display is 6");
VERIFY_ARE_EQUAL(expression, m_standardViewModel->CalculationResultAutomationName); VERIFY_ARE_EQUAL(expression, m_standardViewModel->CalculationResultAutomationName);
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::ModeProgrammer); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::ModeProgrammer));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command1); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command1));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandADD); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandADD));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command2); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command2));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandEQU); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandEQU));
expression = StringReference(L"Display is 3"); expression = StringReference(L"Display is 3");
VERIFY_ARE_EQUAL(expression, m_standardViewModel->CalculationResultAutomationName); VERIFY_ARE_EQUAL(expression, m_standardViewModel->CalculationResultAutomationName);
@ -426,20 +399,20 @@ namespace CalculatorFunctionalTests
void RadixAutomationName() void RadixAutomationName()
{ {
Initialize(); Initialize();
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::ModeProgrammer); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::ModeProgrammer));
m_standardViewModel->IsProgrammer = true; m_standardViewModel->IsProgrammer = true;
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command1); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command1));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandADD); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandADD));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::Command7); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::Command7));
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::CommandEQU); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::CommandEQU));
String ^ expression = L"HexaDecimal" + L" 8"; String ^ expression = L"HexaDecimal" + L" 8";
String ^ result = L"HexaDecimal " + Utils::GetStringValue(m_standardViewModel->HexDisplayValue); String ^ result = L"HexaDecimal " + GetStringValue(m_standardViewModel->HexDisplayValue);
VERIFY_ARE_EQUAL(expression, result); VERIFY_ARE_EQUAL(expression, result);
expression = StringReference(L"Octal 10"); expression = StringReference(L"Octal 10");
result = L"Octal " + Utils::GetStringValue(m_standardViewModel->OctalDisplayValue); result = L"Octal " + GetStringValue(m_standardViewModel->OctalDisplayValue);
VERIFY_ARE_EQUAL(expression, result); VERIFY_ARE_EQUAL(expression, result);
expression = StringReference(L"Binary 1000"); expression = StringReference(L"Binary 1000");
result = L"Binary " + Utils::GetStringValue(m_standardViewModel->BinaryDisplayValue); result = L"Binary " + GetStringValue(m_standardViewModel->BinaryDisplayValue);
VERIFY_ARE_EQUAL(expression, result); VERIFY_ARE_EQUAL(expression, result);
Cleanup(); Cleanup();
} }
@ -448,7 +421,7 @@ namespace CalculatorFunctionalTests
{ {
Initialize(); Initialize();
VERIFY_ARE_EQUAL(0, m_historyViewModel->ItemSize); VERIFY_ARE_EQUAL(0, m_historyViewModel->ItemSize);
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::ModeScientific); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::ModeScientific));
VERIFY_ARE_EQUAL(0, m_historyViewModel->ItemSize); VERIFY_ARE_EQUAL(0, m_historyViewModel->ItemSize);
Cleanup(); Cleanup();
} }
@ -457,7 +430,7 @@ namespace CalculatorFunctionalTests
{ {
Initialize(); Initialize();
VERIFY_ARE_EQUAL(0, m_historyViewModel->ItemSize); VERIFY_ARE_EQUAL(0, m_historyViewModel->ItemSize);
m_standardViewModel->m_standardCalculatorManager.SendCommand(Command::ModeScientific); m_standardViewModel->SendCommandToCalcManager(static_cast<int>(Command::ModeScientific));
m_historyViewModel->OnClearCommand(nullptr); m_historyViewModel->OnClearCommand(nullptr);
VERIFY_ARE_EQUAL(0, m_historyViewModel->ItemSize); VERIFY_ARE_EQUAL(0, m_historyViewModel->ItemSize);
Cleanup(); Cleanup();

38
src/CalculatorUnitTests/MultiWindowUnitTests.cpp
View file

@ -369,7 +369,7 @@ TEST_METHOD(MultipleModesHistoryAddItemTest)
ChangeMode(viewModels[i], i); ChangeMode(viewModels[i], i);
// Validate that the history items list is initially empty // Validate that the history items list is initially empty
VERIFY_IS_TRUE(0 == viewModels[i]->m_standardCalculatorManager.GetHistoryItems().size()); VERIFY_IS_TRUE(0 == viewModels[i]->HistoryVM->ItemSize);
} }
// Perform Calculations on both the instances and check that the History items work independently // Perform Calculations on both the instances and check that the History items work independently
@ -390,24 +390,24 @@ TEST_METHOD(MultipleModesHistoryAddItemTest)
ValidateViewModelByCommands(viewModels[1], scientificModeTestItems, true); ValidateViewModelByCommands(viewModels[1], scientificModeTestItems, true);
// Assert for the history list items of 1st instance // Assert for the history list items of 1st instance
VERIFY_IS_TRUE(1 == viewModels[0]->m_standardCalculatorManager.GetHistoryItems().size()); VERIFY_IS_TRUE(1 == viewModels[0]->HistoryVM->ItemSize);
auto item1 = viewModels[0]->m_standardCalculatorManager.GetHistoryItem(0); auto item1 = static_cast<HistoryItemViewModel^>(viewModels[0]->HistoryVM->Items->GetAt(0));
String ^ expression1 = UtfUtils::LRO + L"1 + 2 =" + UtfUtils::PDF; String ^ expression1 = UtfUtils::LRO + L"1 + 2 =" + UtfUtils::PDF;
String ^ result1 = L"3"; String ^ result1 = L"3";
VERIFY_ARE_EQUAL(expression1, StringReference(item1->historyItemVector.expression.c_str())); VERIFY_ARE_EQUAL(expression1, item1->Expression);
VERIFY_ARE_EQUAL(result1, StringReference(item1->historyItemVector.result.c_str())); VERIFY_ARE_EQUAL(result1, item1->Result);
// Assert for the history list items of 2nd instance // Assert for the history list items of 2nd instance
VERIFY_IS_TRUE(1 == viewModels[1]->m_standardCalculatorManager.GetHistoryItems().size()); VERIFY_IS_TRUE(1 == viewModels[1]->HistoryVM->ItemSize);
auto item2 = viewModels[1]->m_standardCalculatorManager.GetHistoryItem(0); auto item2 = static_cast<HistoryItemViewModel^>(viewModels[1]->HistoryVM->Items->GetAt(0));
String ^ expression2 = UtfUtils::LRO + L"1 + 2 " + UtfUtils::MUL + L" 3 =" + UtfUtils::PDF; String ^ expression2 = UtfUtils::LRO + L"1 + 2 " + UtfUtils::MUL + L" 3 =" + UtfUtils::PDF;
String ^ result2 = L"7"; String ^ result2 = L"7";
VERIFY_ARE_EQUAL(expression2, StringReference(item2->historyItemVector.expression.c_str())); VERIFY_ARE_EQUAL(expression2, item2->Expression);
VERIFY_ARE_EQUAL(result2, StringReference(item2->historyItemVector.result.c_str())); 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 // Perform calculations on 2 separate instances of Standard Modes and verify that their History list items are maintained separately
@ -424,7 +424,7 @@ TEST_METHOD(MultipleStandardModesHistoryAddItemTest)
ChangeMode(viewModels[i], 0); ChangeMode(viewModels[i], 0);
// Validate that the history items list is initially empty // Validate that the history items list is initially empty
VERIFY_IS_TRUE(0 == viewModels[i]->m_standardCalculatorManager.GetHistoryItems().size()); VERIFY_IS_TRUE(0 == viewModels[i]->HistoryVM->ItemSize);
} }
// Perform Calculations on both the instances and check that the History items work independently // Perform Calculations on both the instances and check that the History items work independently
@ -457,12 +457,12 @@ TEST_METHOD(MultipleStandardModesHistoryAddItemTest)
// Assert for the history list items of the instances // Assert for the history list items of the instances
for (int i = 0; i < 2; i++) for (int i = 0; i < 2; i++)
{ {
VERIFY_IS_TRUE(1 == viewModels[i]->m_standardCalculatorManager.GetHistoryItems().size()); VERIFY_IS_TRUE(1 == viewModels[i]->HistoryVM->ItemSize);
auto item = viewModels[i]->m_standardCalculatorManager.GetHistoryItem(0); auto item = static_cast<HistoryItemViewModel ^>(viewModels[i]->HistoryVM->Items->GetAt(0));
VERIFY_ARE_EQUAL(expression[i], StringReference(item->historyItemVector.expression.c_str())); VERIFY_ARE_EQUAL(expression[i], item->Expression);
VERIFY_ARE_EQUAL(result[i], StringReference(item->historyItemVector.result.c_str())); VERIFY_ARE_EQUAL(result[i], item->Result);
} }
} }
@ -480,7 +480,7 @@ TEST_METHOD(MultipleScientificModesHistoryAddItemTest)
ChangeMode(viewModels[i], 1); ChangeMode(viewModels[i], 1);
// Validate that the history items list is initially empty // Validate that the history items list is initially empty
VERIFY_IS_TRUE(0 == viewModels[i]->m_standardCalculatorManager.GetHistoryItems().size()); VERIFY_IS_TRUE(0 == viewModels[i]->HistoryVM->ItemSize);
} }
// Perform Calculations on both the instances and check that the History items work independently // Perform Calculations on both the instances and check that the History items work independently
@ -513,12 +513,12 @@ TEST_METHOD(MultipleScientificModesHistoryAddItemTest)
// Assert for the history list items of the instances // Assert for the history list items of the instances
for (int i = 0; i < 2; i++) for (int i = 0; i < 2; i++)
{ {
VERIFY_IS_TRUE(1 == viewModels[i]->m_standardCalculatorManager.GetHistoryItems().size()); VERIFY_IS_TRUE(1 == viewModels[i]->HistoryVM->ItemSize);
auto item = viewModels[i]->m_standardCalculatorManager.GetHistoryItem(0); auto item = static_cast<HistoryItemViewModel^>(viewModels[i]->HistoryVM->Items->GetAt(0));
VERIFY_ARE_EQUAL(expression[i], StringReference(item->historyItemVector.expression.c_str())); VERIFY_ARE_EQUAL(expression[i], item->Expression);
VERIFY_ARE_EQUAL(result[i], StringReference(item->historyItemVector.result.c_str())); VERIFY_ARE_EQUAL(result[i], item->Result);
} }
} }

47
src/CalculatorUnitTests/StandardViewModelUnitTests.cpp
View file

@ -9,6 +9,7 @@
#include "CalcViewModel/StandardCalculatorViewModel.h" #include "CalcViewModel/StandardCalculatorViewModel.h"
#include "CalcViewModel/Common/CalculatorButtonPressedEventArgs.h" #include "CalcViewModel/Common/CalculatorButtonPressedEventArgs.h"
#include "Helpers.h"
using namespace CalculationManager; using namespace CalculationManager;
using namespace CalculatorApp; using namespace CalculatorApp;
@ -494,10 +495,10 @@ namespace CalculatorUnitTests
{ NumbersAndOperatorsEnum::F, L"F", L"" }, { NumbersAndOperatorsEnum::F, L"F", L"" },
{ NumbersAndOperatorsEnum::None, L"", L"" } }; { NumbersAndOperatorsEnum::None, L"", L"" } };
ValidateViewModelByCommands(m_viewModel, items, false); ValidateViewModelByCommands(m_viewModel, items, false);
VERIFY_ARE_EQUAL(Utils::GetStringValue(m_viewModel->HexDisplayValue), StringReference(L"F")); VERIFY_ARE_EQUAL(GetStringValue(m_viewModel->HexDisplayValue), StringReference(L"F"));
VERIFY_ARE_EQUAL(Utils::GetStringValue(m_viewModel->DecimalDisplayValue), StringReference(L"15")); VERIFY_ARE_EQUAL(GetStringValue(m_viewModel->DecimalDisplayValue), StringReference(L"15"));
VERIFY_ARE_EQUAL(Utils::GetStringValue(m_viewModel->OctalDisplayValue), StringReference(L"17")); VERIFY_ARE_EQUAL(GetStringValue(m_viewModel->OctalDisplayValue), StringReference(L"17"));
VERIFY_ARE_EQUAL(Utils::GetStringValue(m_viewModel->BinaryDisplayValue), StringReference(L"1111")); VERIFY_ARE_EQUAL(GetStringValue(m_viewModel->BinaryDisplayValue), StringReference(L"1111"));
auto val = ref new Platform::Collections::Vector<bool>(64, false); auto val = ref new Platform::Collections::Vector<bool>(64, false);
val->SetAt(0, true); val->SetAt(0, true);
val->SetAt(1, true); val->SetAt(1, true);
@ -547,10 +548,10 @@ namespace CalculatorUnitTests
{ NumbersAndOperatorsEnum::None, L"1", L"" }, { NumbersAndOperatorsEnum::None, L"1", L"" },
}; };
ValidateViewModelByCommands(m_viewModel, items, true); ValidateViewModelByCommands(m_viewModel, items, true);
VERIFY_ARE_EQUAL(Utils::GetStringValue(m_viewModel->HexDisplayValue), StringReference(L"75B CD15")); VERIFY_ARE_EQUAL(GetStringValue(m_viewModel->HexDisplayValue), StringReference(L"75B CD15"));
VERIFY_ARE_EQUAL(Utils::GetStringValue(m_viewModel->DecimalDisplayValue), StringReference(L"123,456,789")); VERIFY_ARE_EQUAL(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(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")); VERIFY_ARE_EQUAL(GetStringValue(m_viewModel->BinaryDisplayValue), StringReference(L"0111 0101 1011 1100 1101 0001 0101"));
auto val = ref new Platform::Collections::Vector<bool>(64, false); auto val = ref new Platform::Collections::Vector<bool>(64, false);
val->SetAt(0, true); val->SetAt(0, true);
val->SetAt(2, true); val->SetAt(2, true);
@ -581,11 +582,11 @@ namespace CalculatorUnitTests
{ NumbersAndOperatorsEnum::Not, L"-2", L"~(1)" }, { NumbersAndOperatorsEnum::Not, L"-2", L"~(1)" },
{ NumbersAndOperatorsEnum::None, L"N/A", L"N/A" } }; { NumbersAndOperatorsEnum::None, L"N/A", L"N/A" } };
ValidateViewModelByCommands(m_viewModel, items, false); ValidateViewModelByCommands(m_viewModel, items, false);
VERIFY_ARE_EQUAL(Utils::GetStringValue(m_viewModel->HexDisplayValue), StringReference(L"FFFF FFFF FFFF FFFE")); VERIFY_ARE_EQUAL(GetStringValue(m_viewModel->HexDisplayValue), StringReference(L"FFFF FFFF FFFF FFFE"));
VERIFY_ARE_EQUAL(Utils::GetStringValue(m_viewModel->DecimalDisplayValue), StringReference(L"-2")); VERIFY_ARE_EQUAL(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(GetStringValue(m_viewModel->OctalDisplayValue), StringReference(L"1 777 777 777 777 777 777 776"));
VERIFY_ARE_EQUAL( VERIFY_ARE_EQUAL(
Utils::GetStringValue(m_viewModel->BinaryDisplayValue), GetStringValue(m_viewModel->BinaryDisplayValue),
StringReference(L"1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1110")); 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")); VERIFY_ARE_EQUAL(m_viewModel->DisplayValue, StringReference(L"-2"));
auto val = ref new Platform::Collections::Vector<bool>(64, true); auto val = ref new Platform::Collections::Vector<bool>(64, true);
@ -775,13 +776,13 @@ namespace CalculatorUnitTests
m_viewModel->OnMemoryItemPressed(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); VERIFY_ARE_EQUAL(Platform::StringReference(L"-1,001"), m_viewModel->DisplayValue);
MemoryItemViewModel ^ memorySlotStandard = (MemoryItemViewModel ^) m_viewModel->MemorizedNumbers->GetAt(0); MemoryItemViewModel ^ memorySlotStandard = (MemoryItemViewModel ^) m_viewModel->MemorizedNumbers->GetAt(0);
VERIFY_ARE_EQUAL(Platform::StringReference(L"-1,001"), Utils::GetStringValue(memorySlotStandard->Value)); VERIFY_ARE_EQUAL(Platform::StringReference(L"-1,001"), GetStringValue(memorySlotStandard->Value));
ChangeMode(m_viewModel, 1 /*scientific*/); ChangeMode(m_viewModel, 1 /*scientific*/);
MemoryItemViewModel ^ memorySlotScientific = (MemoryItemViewModel ^) m_viewModel->MemorizedNumbers->GetAt(0); MemoryItemViewModel ^ memorySlotScientific = (MemoryItemViewModel ^) m_viewModel->MemorizedNumbers->GetAt(0);
VERIFY_ARE_EQUAL(Platform::StringReference(L"-1,001"), Utils::GetStringValue(memorySlotScientific->Value)); VERIFY_ARE_EQUAL(Platform::StringReference(L"-1,001"), GetStringValue(memorySlotScientific->Value));
ChangeMode(m_viewModel, 2 /*Programmer*/); ChangeMode(m_viewModel, 2 /*Programmer*/);
MemoryItemViewModel ^ memorySlotProgrammer = (MemoryItemViewModel ^) m_viewModel->MemorizedNumbers->GetAt(0); MemoryItemViewModel ^ memorySlotProgrammer = (MemoryItemViewModel ^) m_viewModel->MemorizedNumbers->GetAt(0);
VERIFY_ARE_EQUAL(Platform::StringReference(L"-1,001"), Utils::GetStringValue(memorySlotProgrammer->Value)); VERIFY_ARE_EQUAL(Platform::StringReference(L"-1,001"), GetStringValue(memorySlotProgrammer->Value));
} }
// When decimal number is saved in memory // When decimal number is saved in memory
@ -799,13 +800,13 @@ namespace CalculatorUnitTests
m_viewModel->OnMemoryItemPressed(ref new Platform::Box<int>(0)); m_viewModel->OnMemoryItemPressed(ref new Platform::Box<int>(0));
VERIFY_ARE_EQUAL(Platform::StringReference(L"1,001.1"), m_viewModel->DisplayValue); VERIFY_ARE_EQUAL(Platform::StringReference(L"1,001.1"), m_viewModel->DisplayValue);
MemoryItemViewModel ^ memorySlotStandard = (MemoryItemViewModel ^) m_viewModel->MemorizedNumbers->GetAt(0); MemoryItemViewModel ^ memorySlotStandard = (MemoryItemViewModel ^) m_viewModel->MemorizedNumbers->GetAt(0);
VERIFY_ARE_EQUAL(Platform::StringReference(L"1,001.1"), Utils::GetStringValue(memorySlotStandard->Value)); VERIFY_ARE_EQUAL(Platform::StringReference(L"1,001.1"), GetStringValue(memorySlotStandard->Value));
ChangeMode(m_viewModel, 1 /*Scientific*/); ChangeMode(m_viewModel, 1 /*Scientific*/);
MemoryItemViewModel ^ memorySlotScientific = (MemoryItemViewModel ^) m_viewModel->MemorizedNumbers->GetAt(0); MemoryItemViewModel ^ memorySlotScientific = (MemoryItemViewModel ^) m_viewModel->MemorizedNumbers->GetAt(0);
VERIFY_ARE_EQUAL(Platform::StringReference(L"1,001.1"), Utils::GetStringValue(memorySlotScientific->Value)); VERIFY_ARE_EQUAL(Platform::StringReference(L"1,001.1"), GetStringValue(memorySlotScientific->Value));
ChangeMode(m_viewModel, 2 /*Programmer*/); ChangeMode(m_viewModel, 2 /*Programmer*/);
MemoryItemViewModel ^ memorySlotProgrammer = (MemoryItemViewModel ^) m_viewModel->MemorizedNumbers->GetAt(0); MemoryItemViewModel ^ memorySlotProgrammer = (MemoryItemViewModel ^) m_viewModel->MemorizedNumbers->GetAt(0);
VERIFY_ARE_EQUAL(Platform::StringReference(L"1,001"), Utils::GetStringValue(memorySlotProgrammer->Value)); VERIFY_ARE_EQUAL(Platform::StringReference(L"1,001"), GetStringValue(memorySlotProgrammer->Value));
} }
// When negative decimal number is saved in memory // When negative decimal number is saved in memory
@ -864,7 +865,7 @@ namespace CalculatorUnitTests
m_viewModel->OnMemoryItemPressed(ref new Box<int>(0)); m_viewModel->OnMemoryItemPressed(ref new Box<int>(0));
VERIFY_ARE_EQUAL(Platform::StringReference(L"255"), m_viewModel->DisplayValue); VERIFY_ARE_EQUAL(Platform::StringReference(L"255"), m_viewModel->DisplayValue);
MemoryItemViewModel ^ memorySlot = (MemoryItemViewModel ^) m_viewModel->MemorizedNumbers->GetAt(0); MemoryItemViewModel ^ memorySlot = (MemoryItemViewModel ^) m_viewModel->MemorizedNumbers->GetAt(0);
VERIFY_ARE_EQUAL(Platform::StringReference(L"255"), Utils::GetStringValue(memorySlot->Value)); VERIFY_ARE_EQUAL(Platform::StringReference(L"255"), GetStringValue(memorySlot->Value));
} }
TEST_METHOD(OnMemorySavedInHexRadixAndRadixChanges) TEST_METHOD(OnMemorySavedInHexRadixAndRadixChanges)
@ -880,13 +881,13 @@ namespace CalculatorUnitTests
m_viewModel->OnMemoryButtonPressed(); m_viewModel->OnMemoryButtonPressed();
m_viewModel->SwitchProgrammerModeBase(NumberBase::OctBase); m_viewModel->SwitchProgrammerModeBase(NumberBase::OctBase);
MemoryItemViewModel ^ memorySlotOct = (MemoryItemViewModel ^) m_viewModel->MemorizedNumbers->GetAt(0); MemoryItemViewModel ^ memorySlotOct = (MemoryItemViewModel ^) m_viewModel->MemorizedNumbers->GetAt(0);
VERIFY_ARE_EQUAL(Platform::StringReference(L"377"), Utils::GetStringValue(memorySlotOct->Value)); VERIFY_ARE_EQUAL(Platform::StringReference(L"377"), GetStringValue(memorySlotOct->Value));
m_viewModel->SwitchProgrammerModeBase(NumberBase::DecBase); m_viewModel->SwitchProgrammerModeBase(NumberBase::DecBase);
MemoryItemViewModel ^ memorySlotDec = (MemoryItemViewModel ^) m_viewModel->MemorizedNumbers->GetAt(0); MemoryItemViewModel ^ memorySlotDec = (MemoryItemViewModel ^) m_viewModel->MemorizedNumbers->GetAt(0);
VERIFY_ARE_EQUAL(Platform::StringReference(L"255"), Utils::GetStringValue(memorySlotDec->Value)); VERIFY_ARE_EQUAL(Platform::StringReference(L"255"), GetStringValue(memorySlotDec->Value));
m_viewModel->SwitchProgrammerModeBase(NumberBase::BinBase); m_viewModel->SwitchProgrammerModeBase(NumberBase::BinBase);
MemoryItemViewModel ^ memorySlotBin = (MemoryItemViewModel ^) m_viewModel->MemorizedNumbers->GetAt(0); MemoryItemViewModel ^ memorySlotBin = (MemoryItemViewModel ^) m_viewModel->MemorizedNumbers->GetAt(0);
VERIFY_ARE_EQUAL(Platform::StringReference(L"1111 1111"), Utils::GetStringValue(memorySlotBin->Value)); VERIFY_ARE_EQUAL(Platform::StringReference(L"1111 1111"), GetStringValue(memorySlotBin->Value));
} }
// When memory button is pressed more than max number of slots allowed, // When memory button is pressed more than max number of slots allowed,
@ -965,7 +966,7 @@ namespace CalculatorUnitTests
m_viewModel->OnMemoryItemPressed(1); m_viewModel->OnMemoryItemPressed(1);
m_viewModel->OnMemoryAdd(ref new Platform::Box<int>(0)); m_viewModel->OnMemoryAdd(ref new Platform::Box<int>(0));
MemoryItemViewModel ^ memorySlot = (MemoryItemViewModel ^) m_viewModel->MemorizedNumbers->GetAt(0); MemoryItemViewModel ^ memorySlot = (MemoryItemViewModel ^) m_viewModel->MemorizedNumbers->GetAt(0);
VERIFY_ARE_EQUAL(Platform::StringReference(L"3,003"), Utils::GetStringValue(memorySlot->Value)); VERIFY_ARE_EQUAL(Platform::StringReference(L"3,003"), GetStringValue(memorySlot->Value));
} }
// Verify that raw, unformatted numbers are provided correctly // Verify that raw, unformatted numbers are provided correctly