DevWiki/calculator
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove Serialize/Deserialize functions never used in StandardCalculatorViewModel, UnitConverter, UnitConverterViewModel and CalculatorManager (#392)

Browse Source 
* remove unused serializer

* remove all unused serialization/deserialization from StandardCalculatorViewModel and UnitConverterViewModel

* formatting
This commit is contained in:
Rudy Huyn
2019-05-09 11:01:43 -07:00
committed by Pepe Rivera
parent 750130c2bc
commit 28888d8df1
13 changed files with 12 additions and 771 deletions
Download Patch File Download Diff File Expand all files Collapse all files

210
src/CalculatorUnitTests/CalculatorManagerTest.cpp
View File

@@ -181,12 +181,6 @@ namespace CalculatorManagerTest
TEST_METHOD(CalculatorManagerTestMemory);
TEST_METHOD(CalculatorManagerTestSerialize);
TEST_METHOD(CalculatorManagerTestSerializePrecision);
TEST_METHOD(CalculatorManagerTestSerializeMultiple);
TEST_METHOD(CalculatorManagerTestSerializeDegreeMode);
TEST_METHOD(CalculatorManagerTestSerializeMemory);
TEST_METHOD(CalculatorManagerTestMaxDigitsReached);
TEST_METHOD(CalculatorManagerTestMaxDigitsReached_LeadingDecimal);
TEST_METHOD(CalculatorManagerTestMaxDigitsReached_TrailingDecimal);
@@ -263,35 +257,6 @@ namespace CalculatorManagerTest
// MaxDigitsReached should have been called once
VERIFY_IS_LESS_THAN(0, pCalculatorDisplay->GetMaxDigitsCalledCount());
}
void SerializeAndDeSerialize()
{
auto serializedCommands = m_calculatorManager->SerializeCommands();
auto serializedMemory = m_calculatorManager->GetSerializedMemory();
auto serializedDisplay = m_calculatorManager->GetSerializedPrimaryDisplay();
Cleanup();
m_calculatorManager->DeSerializePrimaryDisplay(serializedDisplay);
m_calculatorManager->DeSerializeMemory(serializedMemory);
m_calculatorManager->DeSerializeCommands(serializedCommands);
}
void VerifyPersistence()
{
auto savedPrimary = m_calculatorDisplayTester->GetPrimaryDisplay();
auto savedExpression = m_calculatorDisplayTester->GetExpression();
auto savedMemory = m_calculatorDisplayTester->GetMemorizedNumbers();
SerializeAndDeSerialize();
VERIFY_ARE_EQUAL(savedPrimary, m_calculatorDisplayTester->GetPrimaryDisplay());
VERIFY_ARE_EQUAL(savedExpression, m_calculatorDisplayTester->GetExpression());
auto loadedMemory = m_calculatorDisplayTester->GetMemorizedNumbers();
VERIFY_ARE_EQUAL(savedMemory.size(), loadedMemory.size());
for (unsigned int i = 0; i < savedMemory.size(); i++)
{
VERIFY_ARE_EQUAL(savedMemory.at(i), loadedMemory.at(i));
}
}
};
std::shared_ptr<CalculatorManager> CalculatorManagerTest::m_calculatorManager;
@@ -826,181 +791,6 @@ namespace CalculatorManagerTest
m_calculatorManager->MemorizeNumber();
}
void CalculatorManagerTest::CalculatorManagerTestSerializeMemory()
{
Cleanup();
Command commands[] = { Command::Command1, Command::CommandNULL };
ExecuteCommands(commands);
for (int i = 0; i < 110; i++)
{
m_calculatorManager->MemorizeNumber();
}
VerifyPersistence();
}
void CalculatorManagerTest::CalculatorManagerTestSerializeDegreeMode()
{
Cleanup();
Command commands[] = { Command::Command1, Command::CommandRAD, Command::CommandSIN, Command::CommandADD, Command::Command1,
Command::CommandGRAD, Command::CommandCOS, Command::CommandADD, Command::Command1, Command::CommandDEG,
Command::CommandTAN, Command::CommandADD, Command::CommandNULL };
ExecuteCommands(commands);
VerifyPersistence();
}
// 1 + 2 then serialize and deserialize 3 times
// Check if the values are persisted correctly
void CalculatorManagerTest::CalculatorManagerTestSerializeMultiple()
{
Cleanup();
Command commands[] = { Command::Command1, Command::CommandADD, Command::Command2, Command::CommandNULL };
ExecuteCommands(commands);
VerifyPersistence();
VerifyPersistence();
VerifyPersistence();
}
// Calculate 1/3 then serialize and deserialize
// Multiply by 3 and check if the result is 1 not 0.999999999999999999...
void CalculatorManagerTest::CalculatorManagerTestSerializePrecision()
{
CalculatorManagerDisplayTester* pCalculatorDisplay = (CalculatorManagerDisplayTester*)m_calculatorDisplayTester.get();
wstring resultPrimary = L"";
wstring resultExpression = L"";
Cleanup();
Command commands[] = { Command::Command1, Command::CommandDIV, Command::Command3, Command::CommandEQU, Command::CommandNULL };
ExecuteCommands(commands);
SerializeAndDeSerialize();
Command commands2[] = { Command::CommandMUL, Command::Command3, Command::CommandEQU, Command::CommandNULL };
ExecuteCommands(commands2);
VERIFY_ARE_EQUAL(StringReference(L"1"), ref new String(pCalculatorDisplay->GetPrimaryDisplay().c_str()));
}
void CalculatorManagerTest::CalculatorManagerTestSerialize()
{
CalculatorManagerDisplayTester* pCalculatorDisplay = (CalculatorManagerDisplayTester*)m_calculatorDisplayTester.get();
wstring resultPrimary = L"";
wstring resultExpression = L"";
Cleanup();
m_calculatorManager->SendCommand(Command::ModeScientific);
m_calculatorManager->SendCommand(Command::Command1);
m_calculatorManager->SendCommand(Command::CommandADD);
m_calculatorManager->SendCommand(Command::Command2);
m_calculatorManager->SendCommand(Command::CommandMUL);
m_calculatorManager->SendCommand(Command::Command2);
m_calculatorManager->MemorizeNumber();
m_calculatorManager->SendCommand(Command::CommandEQU);
m_calculatorManager->MemorizeNumber();
vector<wstring> memorizedNumbers = pCalculatorDisplay->GetMemorizedNumbers();
wstring primaryDisplay = pCalculatorDisplay->GetPrimaryDisplay();
wstring expressionDisplay = pCalculatorDisplay->GetExpression();
SerializeAndDeSerialize();
vector<wstring> memorizedNumbersAfterDeSerialize = pCalculatorDisplay->GetMemorizedNumbers();
wstring primaryDisplayAfterDeSerialize = pCalculatorDisplay->GetPrimaryDisplay();
wstring expressionDisplayAfterDeSerialize = pCalculatorDisplay->GetExpression();
VERIFY_ARE_EQUAL(primaryDisplay, primaryDisplayAfterDeSerialize);
VERIFY_ARE_EQUAL(expressionDisplay, expressionDisplayAfterDeSerialize);
bool isEqual = false;
if (memorizedNumbers.size() < memorizedNumbersAfterDeSerialize.size())
{
isEqual = std::equal(memorizedNumbers.begin(), memorizedNumbers.end(), memorizedNumbersAfterDeSerialize.begin());
}
else
{
isEqual = std::equal(memorizedNumbersAfterDeSerialize.begin(), memorizedNumbersAfterDeSerialize.end(), memorizedNumbers.begin());
}
VERIFY_IS_TRUE(isEqual);
m_calculatorManager->SendCommand(Command::CommandGRAD);
m_calculatorManager->SendCommand(Command::Command5);
m_calculatorManager->SendCommand(Command::Command0);
m_calculatorManager->SendCommand(Command::CommandSIGN);
m_calculatorManager->SendCommand(Command::CommandMUL);
memorizedNumbers = pCalculatorDisplay->GetMemorizedNumbers();
primaryDisplay = pCalculatorDisplay->GetPrimaryDisplay();
expressionDisplay = pCalculatorDisplay->GetExpression();
SerializeAndDeSerialize();
memorizedNumbersAfterDeSerialize = pCalculatorDisplay->GetMemorizedNumbers();
primaryDisplayAfterDeSerialize = pCalculatorDisplay->GetPrimaryDisplay();
expressionDisplayAfterDeSerialize = pCalculatorDisplay->GetExpression();
VERIFY_ARE_EQUAL(primaryDisplay, primaryDisplayAfterDeSerialize);
VERIFY_ARE_EQUAL(expressionDisplay, expressionDisplayAfterDeSerialize);
isEqual = false;
if (memorizedNumbers.size() < memorizedNumbersAfterDeSerialize.size())
{
isEqual = std::equal(memorizedNumbers.begin(), memorizedNumbers.end(), memorizedNumbersAfterDeSerialize.begin());
}
else
{
isEqual = std::equal(memorizedNumbersAfterDeSerialize.begin(), memorizedNumbersAfterDeSerialize.end(), memorizedNumbers.begin());
}
VERIFY_IS_TRUE(isEqual);
m_calculatorManager->SendCommand(Command::Command1);
m_calculatorManager->SendCommand(Command::Command2);
m_calculatorManager->SendCommand(Command::Command3);
m_calculatorManager->SendCommand(Command::CommandPNT);
m_calculatorManager->SendCommand(Command::Command8);
m_calculatorManager->SendCommand(Command::CommandSIGN);
m_calculatorManager->MemorizeNumber();
m_calculatorManager->SendCommand(Command::Command2);
m_calculatorManager->SendCommand(Command::Command3);
m_calculatorManager->MemorizedNumberAdd(0);
m_calculatorManager->SendCommand(Command::CommandCENTR);
m_calculatorManager->SendCommand(Command::Command3);
m_calculatorManager->SendCommand(Command::Command1);
m_calculatorManager->SendCommand(Command::CommandSIN);
m_calculatorManager->MemorizedNumberSubtract(2);
m_calculatorManager->MemorizedNumberLoad(2);
memorizedNumbers = pCalculatorDisplay->GetMemorizedNumbers();
primaryDisplay = pCalculatorDisplay->GetPrimaryDisplay();
expressionDisplay = pCalculatorDisplay->GetExpression();
SerializeAndDeSerialize();
memorizedNumbersAfterDeSerialize = pCalculatorDisplay->GetMemorizedNumbers();
primaryDisplayAfterDeSerialize = pCalculatorDisplay->GetPrimaryDisplay();
expressionDisplayAfterDeSerialize = pCalculatorDisplay->GetExpression();
VERIFY_ARE_EQUAL(primaryDisplay, primaryDisplayAfterDeSerialize);
VERIFY_ARE_EQUAL(expressionDisplay, expressionDisplayAfterDeSerialize);
isEqual = false;
if (memorizedNumbers.size() < memorizedNumbersAfterDeSerialize.size())
{
isEqual = std::equal(memorizedNumbers.begin(), memorizedNumbers.end(), memorizedNumbersAfterDeSerialize.begin());
}
else
{
isEqual = std::equal(memorizedNumbersAfterDeSerialize.begin(), memorizedNumbersAfterDeSerialize.end(), memorizedNumbers.begin());
}
VERIFY_IS_TRUE(isEqual);
}
// Send 12345678910111213 and verify MaxDigitsReached
void CalculatorManagerTest::CalculatorManagerTestMaxDigitsReached()
{

1
src/CalculatorUnitTests/StandardViewModelUnitTests.cpp
View File

@@ -75,7 +75,6 @@ namespace CalculatorUnitTests
viewModel->ButtonPressed->Execute(NumbersAndOperatorsEnum::Clear);
viewModel->ButtonPressed->Execute(NumbersAndOperatorsEnum::ClearEntry);
viewModel->ClearMemoryCommand->Execute(nullptr);
viewModel->Deserialize(ref new Platform::Array<unsigned char>(0));
}
TESTITEM* currentItem = item;

33
src/CalculatorUnitTests/UnitConverterTest.cpp
View File

@@ -199,8 +199,6 @@ namespace UnitConverterUnitTests
TEST_METHOD(UnitConverterTestGetters);
TEST_METHOD(UnitConverterTestGetCategory);
TEST_METHOD(UnitConverterTestUnitTypeSwitching);
TEST_METHOD(UnitConverterTestSerialization);
TEST_METHOD(UnitConverterTestDeSerialization);
TEST_METHOD(UnitConverterTestQuote);
TEST_METHOD(UnitConverterTestUnquote);
TEST_METHOD(UnitConverterTestBackspace);
@@ -253,7 +251,7 @@ namespace UnitConverterUnitTests
// Resets calculator state to start state after each test
void UnitConverterTest::Cleanup()
{
s_unitConverter->DeSerialize(wstring());
s_unitConverter->SendCommand(Command::Reset);
s_testVMCallback->Reset();
}
@@ -325,22 +323,6 @@ namespace UnitConverterUnitTests
VERIFY_IS_TRUE(s_testVMCallback->CheckSuggestedValues(vector<tuple<wstring, Unit>>()));
}
// Test serialization
void UnitConverterTest::UnitConverterTestSerialization()
{
wstring test1 = wstring(L"4;Kilograms;Kg;0;0;0;|3;Pounds;Lb;1;1;0;|2;0;Weight;|1;1;0;52.8;116.4039;|1;1;Length;,2;0;Weight;,|1;1;Length;[1;Inches;In;1;"
L"1;0;,2;Feet;Ft;0;0;0;,[]2;0;Weight;[3;Pounds;Lb;1;1;0;,4;Kilograms;Kg;0;0;0;,[]|1;Inches;In;1;1;0;[1;Inches;In;1;1;0;:1;0;0;:"
L",2;Feet;Ft;0;0;0;:0.08333333333333332870740406406185;0;0;:,[]2;Feet;Ft;0;0;0;[1;Inches;In;1;1;0;:12;0;0;:,2;Feet;Ft;0;0;0;:1;"
L"0;0;:,[]3;Pounds;Lb;1;1;0;[3;Pounds;Lb;1;1;0;:1;0;0;:,4;Kilograms;Kg;0;0;0;:0.45359199999999999519673110626172;0;0;:,[]4;"
L"Kilograms;Kg;0;0;0;[3;Pounds;Lb;1;1;0;:2.20461999999999980204279381723609;0;0;:,4;Kilograms;Kg;0;0;0;:1;0;0;:,[]|");
s_unitConverter->SendCommand(Command::Five);
s_unitConverter->SendCommand(Command::Two);
s_unitConverter->SendCommand(Command::Decimal);
s_unitConverter->SendCommand(Command::Eight);
s_unitConverter->SetCurrentCategory(s_testWeight);
s_unitConverter->SetCurrentUnitTypes(s_testKilograms, s_testPounds);
VERIFY_IS_TRUE(s_unitConverter->Serialize().compare(test1) == 0);
}
// Test input escaping
void UnitConverterTest::UnitConverterTestQuote()
@@ -368,19 +350,6 @@ namespace UnitConverterUnitTests
VERIFY_IS_TRUE(UnitConverter::Unquote(UnitConverter::Quote(input3)) == input3);
}
// Test de-serialization
void UnitConverterTest::UnitConverterTestDeSerialization()
{
wstring test1 = wstring(L"4;Kilograms;Kg;0;0;0;|3;Pounds;Lb;1;1;0;|2;0;Weight;|1;1;0;52.8;116.4039;|1;1;Length;,2;0;Weight;,|1;1;Length;[1;Inches;In;1;"
L"1;0;,2;Feet;Ft;0;0;0;,[]2;0;Weight;[3;Pounds;Lb;1;1;0;,4;Kilograms;Kg;0;0;0;,[]|1;Inches;In;1;1;0;[1;Inches;In;1;1;0;:1;0;0;:"
L",2;Feet;Ft;0;0;0;:0.08333333333333332870740406406185;0;0;:,[]2;Feet;Ft;0;0;0;[1;Inches;In;1;1;0;:12;0;0;:,2;Feet;Ft;0;0;0;:1;"
L"0;0;:,[]3;Pounds;Lb;1;1;0;[3;Pounds;Lb;1;1;0;:1;0;0;:,4;Kilograms;Kg;0;0;0;:0.45359199999999999519673110626172;0;0;:,[]4;"
L"Kilograms;Kg;0;0;0;[3;Pounds;Lb;1;1;0;:2.20461999999999980204279381723609;0;0;:,4;Kilograms;Kg;0;0;0;:1;0;0;:,[]|");
s_unitConverter->DeSerialize(test1);
VERIFY_IS_TRUE(s_testVMCallback->CheckDisplayValues(wstring(L"52.8"), wstring(L"116.4039")));
VERIFY_IS_TRUE(s_testVMCallback->CheckSuggestedValues(vector<tuple<wstring, Unit>>()));
}
// Test backspace commands
void UnitConverterTest::UnitConverterTestBackspace()
{

52
src/CalculatorUnitTests/UnitConverterViewModelUnitTests.cpp
View File

@@ -129,8 +129,6 @@ UnitConverterMock::UnitConverterMock()
, m_switchActiveCallCount(0)
, m_sendCommandCallCount(0)
, m_setVMCallbackCallCount(0)
, m_serializeCallCount(0)
, m_deSerializeCallCount(0)
{
}
@@ -224,21 +222,10 @@ void UnitConverterMock::SwitchActive(const std::wstring& newValue)
m_curValue = newValue;
}
wstring UnitConverterMock::Serialize()
{
m_serializeCallCount++;
return wstring(L"");
}
void UnitConverterMock::DeSerialize(const wstring& /*serializedData*/)
{
m_deSerializeCallCount++;
}
std::wstring UnitConverterMock::SaveUserPreferences()
{
return L"TEST";
};
std::wstring UnitConverterMock::SaveUserPreferences()
{
return L"TEST";
};
void UnitConverterMock::RestoreUserPreferences(_In_ const std::wstring& /*userPreferences*/){};
@@ -858,37 +845,6 @@ TEST_METHOD(TestSupplementaryResultsWhimsicalUnits)
VERIFY_IS_TRUE(vm.SupplementaryResults->GetAt(0)->Unit->GetModelUnit() == UNITWHIMSY);
}
// Test deserialization
TEST_METHOD(TestUnitConverterViewModelDeserialization)
{
String ^ serializedTest = L"0[;;;]0[;;;]0[;;;]1[;;;]1.5[;;;]25[;;;]1.5[;;;]25[;;;][###][###]";
shared_ptr<UnitConverterMock> mock = make_shared<UnitConverterMock>();
VM::UnitConverterViewModel vm(mock);
vm.Deserialize(serializedTest);
VERIFY_IS_TRUE(vm.Value1 == L"1.5");
VERIFY_IS_TRUE(vm.Value2 == L"25");
VERIFY_IS_TRUE(vm.GetValueFromUnlocalized() == L"1.5");
VERIFY_IS_TRUE(vm.GetValueToUnlocalized() == L"25");
VERIFY_ARE_EQUAL(vm.Value1Active, false);
VERIFY_ARE_EQUAL(vm.Value2Active, true);
VERIFY_IS_TRUE(mock->m_deSerializeCallCount == 1);
}
// Test serialization
/*TEST_METHOD(TestUnitConverterViewModelSerialization)
{
String ^ serializedTest = L"0[;;;]0[;;;]0[;;;]1[;;;];;;]1.5[;;;[;;;]25[###[;;;]0[;;;]0[;;;][###][###]";
shared_ptr<UnitConverterMock> mock = make_shared<UnitConverterMock>();
VM::UnitConverterViewModel vm(mock);
vm.Value1 = L";;;]1.5[;;;";
vm.Value2 = L"25[###";
vm.Value1Active = false;
vm.Value2Active = true;
String ^ test = vm.Serialize();
VERIFY_IS_TRUE(serializedTest == test);
VERIFY_IS_TRUE(mock->m_serializeCallCount == 1);
}*/
TEST_METHOD(TestOnPaste)
{
shared_ptr<UnitConverterMock> mock = make_shared<UnitConverterMock>();

4
src/CalculatorUnitTests/UnitConverterViewModelUnitTests.h
View File

@@ -34,8 +34,6 @@ namespace CalculatorUnitTests
UCM::Category GetCurrentCategory();
void SetCurrentUnitTypes(const UCM::Unit& fromType, const UCM::Unit& toType) override;
void SwitchActive(const std::wstring& newValue);
std::wstring Serialize() override;
void DeSerialize(const std::wstring& serializedData) override;
std::wstring SaveUserPreferences() override;
void RestoreUserPreferences(_In_ const std::wstring& userPreferences) override;
void SendCommand(UCM::Command command) override;
@@ -61,8 +59,6 @@ namespace CalculatorUnitTests
UINT m_switchActiveCallCount;
UINT m_sendCommandCallCount;
UINT m_setVMCallbackCallCount;
UINT m_serializeCallCount;
UINT m_deSerializeCallCount;
UCM::Category m_curCategory;
UCM::Unit m_curFrom;