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

Merge master into feature/GraphingCalculator branch (#660)

Browse Source
This commit is contained in:
Pepe Rivera
2019-09-05 15:01:12 -07:00
committed by GitHub
parent 1c9755d38a
commit 41fbcfe9c5
199 changed files with 5809 additions and 2925 deletions
Download Patch File Download Diff File Expand all files Collapse all files

103
src/CalculatorUnitTests/CalculatorManagerTest.cpp
View File

@@ -7,9 +7,11 @@
#include "CalcManager/CalculatorHistory.h"
#include "CalcViewModel/Common/EngineResourceProvider.h"
#include "CalcManager/NumberFormattingUtils.h"
using namespace CalculatorApp;
using namespace CalculationManager;
using namespace CalcManager::NumberFormattingUtils;
using namespace Platform;
using namespace std;
using namespace Microsoft::VisualStudio::CppUnitTestFramework;
@@ -185,6 +187,11 @@ namespace CalculatorManagerTest
TEST_METHOD(CalculatorManagerTestMaxDigitsReached_LeadingDecimal);
TEST_METHOD(CalculatorManagerTestMaxDigitsReached_TrailingDecimal);
TEST_METHOD(CalculatorManagerNumberFormattingUtils_TrimTrailingZeros);
TEST_METHOD(CalculatorManagerNumberFormattingUtils_GetNumberDigits);
TEST_METHOD(CalculatorManagerNumberFormattingUtils_GetNumberDigitsWholeNumberPart);
TEST_METHOD(CalculatorManagerNumberFormattingUtils_RoundSignificantDigits);
TEST_METHOD(CalculatorManagerNumberFormattingUtils_ToScientificNumber);
// TODO re-enable when cause of failure is determined. Bug 20226670
// TEST_METHOD(CalculatorManagerTestBinaryOperatorReceived);
// TEST_METHOD(CalculatorManagerTestBinaryOperatorReceived_Multiple);
@@ -807,6 +814,102 @@ namespace CalculatorManagerTest
TestMaxDigitsReachedScenario(L"123,456,789,101,112.13");
}
void CalculatorManagerTest::CalculatorManagerNumberFormattingUtils_TrimTrailingZeros()
{
wstring number = L"2.1032100000000";
TrimTrailingZeros(number);
VERIFY_ARE_EQUAL(number, L"2.10321");
number = L"-122.123200";
TrimTrailingZeros(number);
VERIFY_ARE_EQUAL(number, L"-122.1232");
number = L"0.0001200";
TrimTrailingZeros(number);
VERIFY_ARE_EQUAL(number, L"0.00012");
number = L"12.000";
TrimTrailingZeros(number);
VERIFY_ARE_EQUAL(number, L"12");
number = L"-12.00000";
TrimTrailingZeros(number);
VERIFY_ARE_EQUAL(number, L"-12");
number = L"0.000";
TrimTrailingZeros(number);
VERIFY_ARE_EQUAL(number, L"0");
number = L"322423";
TrimTrailingZeros(number);
VERIFY_ARE_EQUAL(number, L"322423");
}
void CalculatorManagerTest::CalculatorManagerNumberFormattingUtils_GetNumberDigits()
{
wstring number = L"2.10321";
unsigned int digitsCount = GetNumberDigits(number);
VERIFY_ARE_EQUAL(digitsCount, 6);
number = L"-122.1232";
digitsCount = GetNumberDigits(number);
VERIFY_ARE_EQUAL(digitsCount, 7);
number = L"-3432";
digitsCount = GetNumberDigits(number);
VERIFY_ARE_EQUAL(digitsCount, 4);
number = L"0";
digitsCount = GetNumberDigits(number);
VERIFY_ARE_EQUAL(digitsCount, 1);
number = L"0.0001223";
digitsCount = GetNumberDigits(number);
VERIFY_ARE_EQUAL(digitsCount, 8);
}
void CalculatorManagerTest::CalculatorManagerNumberFormattingUtils_GetNumberDigitsWholeNumberPart()
{
unsigned int digitsCount = GetNumberDigitsWholeNumberPart(2.10321);
VERIFY_ARE_EQUAL(digitsCount, 1);
digitsCount = GetNumberDigitsWholeNumberPart(-122.1232);
VERIFY_ARE_EQUAL(digitsCount, 3);
digitsCount = GetNumberDigitsWholeNumberPart(-3432);
VERIFY_ARE_EQUAL(digitsCount, 4);
digitsCount = GetNumberDigitsWholeNumberPart(0);
VERIFY_ARE_EQUAL(digitsCount, 1);
digitsCount = GetNumberDigitsWholeNumberPart(324328412837382);
VERIFY_ARE_EQUAL(digitsCount, 15);
digitsCount = GetNumberDigitsWholeNumberPart(324328412837382.232213214324234);
VERIFY_ARE_EQUAL(digitsCount, 15);
}
void CalculatorManagerTest::CalculatorManagerNumberFormattingUtils_RoundSignificantDigits()
{
wstring result = RoundSignificantDigits(12.342343242, 3);
VERIFY_ARE_EQUAL(result, L"12.342");
result = RoundSignificantDigits(12.3429999, 3);
VERIFY_ARE_EQUAL(result, L"12.343");
result = RoundSignificantDigits(12.342500001, 3);
VERIFY_ARE_EQUAL(result, L"12.343");
result = RoundSignificantDigits(-2312.1244243346454345, 5);
VERIFY_ARE_EQUAL(result, L"-2312.12442");
result = RoundSignificantDigits(0.3423432423, 5);
VERIFY_ARE_EQUAL(result, L"0.34234");
result = RoundSignificantDigits(0.3423, 7);
VERIFY_ARE_EQUAL(result, L"0.3423000");
}
void CalculatorManagerTest::CalculatorManagerNumberFormattingUtils_ToScientificNumber()
{
wstring result = ToScientificNumber(3423);
VERIFY_ARE_EQUAL(result, L"3.423000e+03");
result = ToScientificNumber(-21);
VERIFY_ARE_EQUAL(result, L"-2.100000e+01");
result = ToScientificNumber(0.0232);
VERIFY_ARE_EQUAL(result, L"2.320000e-02");
result = ToScientificNumber(-0.00921);
VERIFY_ARE_EQUAL(result, L"-9.210000e-03");
result = ToScientificNumber(2343243345677);
VERIFY_ARE_EQUAL(result, L"2.343243e+12");
result = ToScientificNumber(-3432474247332942);
VERIFY_ARE_EQUAL(result, L"-3.432474e+15");
result = ToScientificNumber(0.000000003432432);
VERIFY_ARE_EQUAL(result, L"3.432432e-09");
result = ToScientificNumber(-0.000000003432432);
VERIFY_ARE_EQUAL(result, L"-3.432432e-09");
}
// TODO re-enable when cause of failure is determined. Bug 20226670
// void CalculatorManagerTest::CalculatorManagerTestBinaryOperatorReceived()
// {

11
src/CalculatorUnitTests/CalculatorUnitTests.vcxproj
View File

@@ -7,8 +7,8 @@
<MinimumVisualStudioVersion>15.0</MinimumVisualStudioVersion>
<AppContainerApplication>true</AppContainerApplication>
<ApplicationType>Windows Store</ApplicationType>
<WindowsTargetPlatformVersion Condition=" '$(WindowsTargetPlatformVersion)' == '' ">10.0</WindowsTargetPlatformVersion>
<WindowsTargetPlatformMinVersion>10.0.18362.0</WindowsTargetPlatformMinVersion>
<WindowsTargetPlatformVersion Condition=" '$(WindowsTargetPlatformVersion)' == '' ">10.0.18362.0</WindowsTargetPlatformVersion>
<WindowsTargetPlatformMinVersion>10.0.17134.0</WindowsTargetPlatformMinVersion>
<ApplicationTypeRevision>10.0</ApplicationTypeRevision>
<UnitTestPlatformVersion Condition="'$(UnitTestPlatformVersion)' == ''">15.0</UnitTestPlatformVersion>
<ProjectSubType>NativeUnitTestProject</ProjectSubType>
@@ -16,6 +16,8 @@
<!-- We want to automatic replace of MinVersion/MaxVersionTested for unit tests. -->
<AppxOSMinVersionReplaceManifestVersion>true</AppxOSMinVersionReplaceManifestVersion>
<AppxOSMaxVersionTestedReplaceManifestVersion>true</AppxOSMaxVersionTestedReplaceManifestVersion>
<PackageCertificateKeyFile>CalculatorUnitTests_TemporaryKey.pfx</PackageCertificateKeyFile>
<PackageCertificateThumbprint>be776c83699dbce4969de9ee730aeaf66c5d5182</PackageCertificateThumbprint>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<ItemGroup Label="ProjectConfigurations">
@@ -128,10 +130,6 @@
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros">
<PackageCertificateKeyFile>CalculatorUnitTests_TemporaryKey.pfx</PackageCertificateKeyFile>
<PackageCertificateThumbprint>3F0C32266A4D995CC08C9AEC3960CFF3EF0D1853</PackageCertificateThumbprint>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">
<ClCompile>
<AdditionalOptions>/bigobj /await /std:c++17 /permissive- /Zc:twoPhase- /utf-8 %(AdditionalOptions)</AdditionalOptions>
@@ -244,6 +242,7 @@
<ClCompile Include="CurrencyConverterUnitTests.cpp" />
<ClCompile Include="DateCalculatorUnitTests.cpp" />
<ClCompile Include="HistoryTests.cpp" />
<ClCompile Include="LocalizationServiceUnitTests.cpp" />
<ClCompile Include="Mocks\CurrencyHttpClient.cpp" />
<ClCompile Include="Module.cpp" />
<ClCompile Include="MultiWindowUnitTests.cpp" />

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

@@ -29,6 +29,7 @@
<ClCompile Include="Mocks\CurrencyHttpClient.cpp">
<Filter>Mocks</Filter>
</ClCompile>
<ClCompile Include="LocalizationServiceUnitTests.cpp" />
<ClCompile Include="RationalTest.cpp" />
</ItemGroup>
<ItemGroup>

149
src/CalculatorUnitTests/CopyPasteManagerTest.cpp
View File

@@ -59,27 +59,30 @@ namespace CalculatorUnitTests
exp_TooLong += L"-1234567";
}
VERIFY_ARE_EQUAL(
m_CopyPasteManager.ValidatePasteExpression(StringReference(exp_TooLong.c_str()), ViewMode::Standard, CategoryGroupType::Calculator, -1, -1),
m_CopyPasteManager.ValidatePasteExpression(StringReference(exp_TooLong.c_str()), ViewMode::Standard, CategoryGroupType::Calculator, -1, BitLength::BitLengthUnknown),
StringReference(exp_TooLong.c_str()),
L"Verify ValidatePasteExpression handles expressions up to max length");
exp_TooLong += L"1";
VERIFY_ARE_EQUAL(
m_CopyPasteManager.ValidatePasteExpression(StringReference(exp_TooLong.c_str()), ViewMode::Standard, CategoryGroupType::Calculator, -1, -1),
m_CopyPasteManager.ValidatePasteExpression(
StringReference(exp_TooLong.c_str()), ViewMode::Standard, CategoryGroupType::Calculator, -1, BitLength::BitLengthUnknown),
StringReference(L"NoOp"),
L"Verify ValidatePasteExpression returns NoOp for strings over max length");
VERIFY_ARE_EQUAL(
m_CopyPasteManager.ValidatePasteExpression(StringReference(L""), ViewMode::Standard, CategoryGroupType::Calculator, -1, -1),
m_CopyPasteManager.ValidatePasteExpression(
StringReference(L""), ViewMode::Standard, CategoryGroupType::Calculator, -1, BitLength::BitLengthUnknown),
StringReference(L"NoOp"),
L"Verify empty string is invalid");
VERIFY_ARE_EQUAL(
m_CopyPasteManager.ValidatePasteExpression(StringReference(L"123e456"), ViewMode::Standard, CategoryGroupType::Calculator, -1, -1),
m_CopyPasteManager.ValidatePasteExpression(
StringReference(L"123e456"), ViewMode::Standard, CategoryGroupType::Calculator, -1, BitLength::BitLengthUnknown),
StringReference(L"NoOp"),
L"Verify pasting unsupported strings for the current mode is invalid");
VERIFY_ARE_EQUAL(
m_CopyPasteManager.ValidatePasteExpression(StringReference(L"123"), ViewMode::None, CategoryGroupType::None, -1, -1),
m_CopyPasteManager.ValidatePasteExpression(StringReference(L"123"), ViewMode::None, CategoryGroupType::None, -1, BitLength::BitLengthUnknown),
StringReference(L"NoOp"),
L"Verify pasting without a ViewMode or Category is invalid");
};
@@ -137,54 +140,60 @@ namespace CalculatorUnitTests
TEST_METHOD(ValidateExpressionRegExMatch)
{
VERIFY_IS_FALSE(
m_CopyPasteManager.ExpressionRegExMatch(vector<wstring>{}, ViewMode::Standard, CategoryGroupType::Calculator, -1, -1),
m_CopyPasteManager.ExpressionRegExMatch(vector<wstring>{}, ViewMode::Standard, CategoryGroupType::Calculator, -1, BitLength::BitLengthUnknown),
L"Verify empty list of operands returns false.");
VERIFY_IS_FALSE(
m_CopyPasteManager.ExpressionRegExMatch(vector<wstring>{ L"123" }, ViewMode::None, CategoryGroupType::Calculator, -1, -1),
m_CopyPasteManager.ExpressionRegExMatch(
vector<wstring>{ L"123" }, ViewMode::None, CategoryGroupType::Calculator, -1, BitLength::BitLengthUnknown),
L"Verify invalid ViewMode/CategoryGroups return false.");
VERIFY_IS_FALSE(
m_CopyPasteManager.ExpressionRegExMatch(vector<wstring>{ L"123" }, ViewMode::Currency, CategoryGroupType::None, -1, -1),
m_CopyPasteManager.ExpressionRegExMatch(
vector<wstring>{ L"123" }, ViewMode::Currency, CategoryGroupType::None, -1, BitLength::BitLengthUnknown),
L"Verify invalid ViewMode/CategoryGroups return false.");
Logger::WriteMessage(L"Verify operand lengths > max return false.");
VERIFY_IS_FALSE(
m_CopyPasteManager.ExpressionRegExMatch(vector<wstring>{ L"12345678901234567" }, ViewMode::Standard, CategoryGroupType::Calculator, -1, -1));
VERIFY_IS_FALSE(m_CopyPasteManager.ExpressionRegExMatch(
vector<wstring>{ L"123456789012345678901234567890123" }, ViewMode::Scientific, CategoryGroupType::Calculator, -1, -1));
VERIFY_IS_FALSE(
m_CopyPasteManager.ExpressionRegExMatch(vector<wstring>{ L"12345678901234567" }, ViewMode::None, CategoryGroupType::Converter, -1, -1));
vector<wstring>{ L"12345678901234567" }, ViewMode::Standard, CategoryGroupType::Calculator, -1, BitLength::BitLengthUnknown));
VERIFY_IS_FALSE(m_CopyPasteManager.ExpressionRegExMatch(
vector<wstring>{ L"11111111111111111" }, ViewMode::Programmer, CategoryGroupType::Calculator, HexBase, QwordType));
vector<wstring>{ L"123456789012345678901234567890123" }, ViewMode::Scientific, CategoryGroupType::Calculator, -1, BitLength::BitLengthUnknown));
VERIFY_IS_FALSE(m_CopyPasteManager.ExpressionRegExMatch(
vector<wstring>{ L"12345678901234567890" }, ViewMode::Programmer, CategoryGroupType::Calculator, DecBase, QwordType));
vector<wstring>{ L"12345678901234567" }, ViewMode::None, CategoryGroupType::Converter, -1, BitLength::BitLengthUnknown));
VERIFY_IS_FALSE(m_CopyPasteManager.ExpressionRegExMatch(
vector<wstring>{ L"11111111111111111111111" }, ViewMode::Programmer, CategoryGroupType::Calculator, OctBase, QwordType));
vector<wstring>{ L"11111111111111111" }, ViewMode::Programmer, CategoryGroupType::Calculator, HexBase, BitLength::BitLengthQWord));
VERIFY_IS_FALSE(m_CopyPasteManager.ExpressionRegExMatch(
vector<wstring>{ L"12345678901234567890" }, ViewMode::Programmer, CategoryGroupType::Calculator, DecBase, BitLength::BitLengthQWord));
VERIFY_IS_FALSE(m_CopyPasteManager.ExpressionRegExMatch(
vector<wstring>{ L"11111111111111111111111" }, ViewMode::Programmer, CategoryGroupType::Calculator, OctBase, BitLength::BitLengthQWord));
VERIFY_IS_FALSE(m_CopyPasteManager.ExpressionRegExMatch(
vector<wstring>{ L"10000000000000000000000000000000000000000000000000000000000000000" },
ViewMode::Programmer,
CategoryGroupType::Calculator,
BinBase,
QwordType));
BitLength::BitLengthQWord));
VERIFY_IS_FALSE(
m_CopyPasteManager.ExpressionRegExMatch(
vector<wstring>{ L"9223372036854775808" }, ViewMode::Programmer, CategoryGroupType::Calculator, DecBase, QwordType),
vector<wstring>{ L"9223372036854775808" }, ViewMode::Programmer, CategoryGroupType::Calculator, DecBase, BitLength::BitLengthQWord),
L"Verify operand values > max return false.");
VERIFY_IS_TRUE(
m_CopyPasteManager.ExpressionRegExMatch(
vector<wstring>{ L"((((((((((((((((((((123))))))))))))))))))))" }, ViewMode::Scientific, CategoryGroupType::Calculator, -1, -1),
vector<wstring>{ L"((((((((((((((((((((123))))))))))))))))))))" },
ViewMode::Scientific,
CategoryGroupType::Calculator,
-1,
BitLength::BitLengthUnknown),
L"Verify sanitized operand is detected as within max length.");
VERIFY_IS_TRUE(
m_CopyPasteManager.ExpressionRegExMatch(
vector<wstring>{ L"9223372036854775807" }, ViewMode::Programmer, CategoryGroupType::Calculator, DecBase, QwordType),
vector<wstring>{ L"9223372036854775807" }, ViewMode::Programmer, CategoryGroupType::Calculator, DecBase, BitLength::BitLengthQWord),
L"Verify operand values == max return true.");
Logger::WriteMessage(L"Verify all operands must match patterns.");
VERIFY_IS_TRUE(
m_CopyPasteManager.ExpressionRegExMatch(vector<wstring>{ L"123", L"456" }, ViewMode::Standard, CategoryGroupType::Calculator, -1, -1));
VERIFY_IS_FALSE(
m_CopyPasteManager.ExpressionRegExMatch(vector<wstring>{ L"123", L"1e23" }, ViewMode::Standard, CategoryGroupType::Calculator, -1, -1));
VERIFY_IS_TRUE(m_CopyPasteManager.ExpressionRegExMatch(
vector<wstring>{ L"123", L"456" }, ViewMode::Standard, CategoryGroupType::Calculator, -1, BitLength::BitLengthUnknown));
VERIFY_IS_FALSE(m_CopyPasteManager.ExpressionRegExMatch(
vector<wstring>{ L"123", L"1e23" }, ViewMode::Standard, CategoryGroupType::Calculator, -1, BitLength::BitLengthUnknown));
VERIFY_IS_TRUE(
m_CopyPasteManager.ExpressionRegExMatch(
@@ -192,16 +201,20 @@ namespace CalculatorUnitTests
ViewMode::Scientific,
CategoryGroupType::Calculator,
-1,
-1),
BitLength::BitLengthUnknown),
L"Verify exponents are accepted in scientific mode.");
VERIFY_IS_FALSE(
m_CopyPasteManager.ExpressionRegExMatch(
vector<wstring>{ L"123", L"12345678901234567" }, ViewMode::Standard, CategoryGroupType::Calculator, -1, -1),
vector<wstring>{ L"123", L"12345678901234567" }, ViewMode::Standard, CategoryGroupType::Calculator, -1, BitLength::BitLengthUnknown),
L"Verify all operands must be within maxlength");
VERIFY_IS_FALSE(
m_CopyPasteManager.ExpressionRegExMatch(
vector<wstring>{ L"123", L"9223372036854775808" }, ViewMode::Programmer, CategoryGroupType::Calculator, DecBase, QwordType),
vector<wstring>{ L"123", L"9223372036854775808" },
ViewMode::Programmer,
CategoryGroupType::Calculator,
DecBase,
BitLength::BitLengthQWord),
L"Verify all operand must be within max value.");
};
@@ -211,15 +224,15 @@ namespace CalculatorUnitTests
pair<size_t, unsigned long long int> scientificModeMaximums = make_pair(m_CopyPasteManager.MaxScientificOperandLength, 0);
pair<size_t, unsigned long long int> converterModeMaximums = make_pair(m_CopyPasteManager.MaxConverterInputLength, 0);
VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Standard, CategoryGroupType::None, -1, -1),
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Standard, CategoryGroupType::None, -1, BitLength::BitLengthUnknown),
standardModeMaximums,
L"Verify Standard mode maximum values");
VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Scientific, CategoryGroupType::None, -1, -1),
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Scientific, CategoryGroupType::None, -1, BitLength::BitLengthUnknown),
scientificModeMaximums,
L"Verify Scientific mode maximum values");
VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::None, CategoryGroupType::Converter, -1, -1),
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::None, CategoryGroupType::Converter, -1, BitLength::BitLengthUnknown),
converterModeMaximums,
L"Verify Converter mode maximum values");
@@ -229,62 +242,64 @@ namespace CalculatorUnitTests
unsigned long long int ullByteMax = UINT8_MAX;
Logger::WriteMessage(L"Verify Programmer Mode HexBase maximum values");
VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, HexBase, QwordType),
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, HexBase, BitLength::BitLengthQWord),
make_pair((size_t)16u, ullQwordMax));
VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, HexBase, DwordType),
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, HexBase, BitLength::BitLengthDWord),
make_pair((size_t)8u, ullDwordMax));
VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, HexBase, WordType),
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, HexBase, BitLength::BitLengthWord),
make_pair((size_t)4u, ullWordMax));
VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, HexBase, ByteType),
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, HexBase, BitLength::BitLengthByte),
make_pair((size_t)2u, ullByteMax));
Logger::WriteMessage(L"Verify Programmer Mode DecBase maximum values");
VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, DecBase, QwordType),
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, DecBase, BitLength::BitLengthQWord),
make_pair((size_t)19u, ullQwordMax >> 1));
VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, DecBase, DwordType),
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, DecBase, BitLength::BitLengthDWord),
make_pair((size_t)10u, ullDwordMax >> 1));
VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, DecBase, WordType),
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, DecBase, BitLength::BitLengthWord),
make_pair((size_t)5u, ullWordMax >> 1));
VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, DecBase, ByteType),
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, DecBase, BitLength::BitLengthByte),
make_pair((size_t)3u, ullByteMax >> 1));
Logger::WriteMessage(L"Verify Programmer Mode OctBase maximum values");
VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, OctBase, QwordType),
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, OctBase, BitLength::BitLengthQWord),
make_pair((size_t)22u, ullQwordMax));
VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, OctBase, DwordType),
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, OctBase, BitLength::BitLengthDWord),
make_pair((size_t)11u, ullDwordMax));
VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, OctBase, WordType),
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, OctBase, BitLength::BitLengthWord),
make_pair((size_t)6u, ullWordMax));
VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, OctBase, ByteType),
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, OctBase, BitLength::BitLengthByte),
make_pair((size_t)3u, ullByteMax));
Logger::WriteMessage(L"Verify Programmer Mode BinBase maximum values");
VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, BinBase, QwordType),
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, BinBase, BitLength::BitLengthQWord),
make_pair((size_t)64u, ullQwordMax));
VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, BinBase, DwordType),
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, BinBase, BitLength::BitLengthDWord),
make_pair((size_t)32u, ullDwordMax));
VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, BinBase, WordType),
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, BinBase, BitLength::BitLengthWord),
make_pair((size_t)16u, ullWordMax));
VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, BinBase, ByteType),
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::Programmer, CategoryGroupType::None, BinBase, BitLength::BitLengthByte),
make_pair((size_t)8u, ullByteMax));
Logger::WriteMessage(L"Verify invalid ViewModes/Categories return 0 for max values");
VERIFY_ARE_EQUAL(m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::None, CategoryGroupType::None, -1, -1), make_pair((size_t)0u, 0ull));
VERIFY_ARE_EQUAL(
m_CopyPasteManager.GetMaxOperandLengthAndValue(ViewMode::None, CategoryGroupType::None, - 1, BitLength::BitLengthUnknown),
make_pair((size_t)0u, 0ull));
};
TEST_METHOD(ValidateSanitizeOperand)
@@ -438,97 +453,97 @@ namespace CalculatorUnitTests
CopyPasteManager m_CopyPasteManager;
String^ ValidateStandardPasteExpression(_In_ String^ pastedText)
{
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::Standard, -1/*number base*/, -1/*bitlength Type*/);
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::Standard, -1/*number base*/, BitLength::BitLengthUnknown);
}
String^ ValidateScientificPasteExpression(_In_ String^ pastedText)
{
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::Scientific, -1/*number base*/, -1/*bitlength Type*/);
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::Scientific, -1/*number base*/, BitLength::BitLengthUnknown);
}
String^ ValidateConverterPasteExpression(_In_ String^ pastedText)
{
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::None, CategoryGroupType::Converter, -1/*number base*/, -1/*bitlength Type*/);
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::None, CategoryGroupType::Converter, -1/*number base*/, BitLength::BitLengthUnknown);
}
String^ ValidateProgrammerHexQwordPasteExpression(_In_ String^ pastedText)
{
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::Programmer, HexBase/*number base*/, QwordType/*bitlength Type*/);
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::Programmer, HexBase/*number base*/, BitLength::BitLengthQWord);
}
String^ ValidateProgrammerHexDwordPasteExpression(_In_ String^ pastedText)
{
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::Programmer, HexBase/*number base*/, DwordType/*bitlength Type*/);
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::Programmer, HexBase/*number base*/, BitLength::BitLengthDWord);
}
String^ ValidateProgrammerHexWordPasteExpression(_In_ String^ pastedText)
{
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::Programmer, HexBase/*number base*/, WordType/*bitlength Type*/);
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::Programmer, HexBase/*number base*/, BitLength::BitLengthWord);
}
String^ ValidateProgrammerHexBytePasteExpression(_In_ String^ pastedText)
{
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::Programmer, HexBase/*number base*/, ByteType/*bitlength Type*/);
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::Programmer, HexBase/*number base*/, BitLength::BitLengthByte);
}
String^ ValidateProgrammerDecQwordPasteExpression(_In_ String^ pastedText)
{
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::Programmer, DecBase/*number base*/, QwordType/*bitlength Type*/);
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::Programmer, DecBase/*number base*/, BitLength::BitLengthQWord);
}
String^ ValidateProgrammerDecDwordPasteExpression(_In_ String^ pastedText)
{
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::Programmer, DecBase/*number base*/, DwordType/*bitlength Type*/);
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::Programmer, DecBase/*number base*/, BitLength::BitLengthDWord);
}
String^ ValidateProgrammerDecWordPasteExpression(_In_ String^ pastedText)
{
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::Programmer, DecBase/*number base*/, WordType/*bitlength Type*/);
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::Programmer, DecBase/*number base*/, BitLength::BitLengthWord);
}
String^ ValidateProgrammerDecBytePasteExpression(_In_ String^ pastedText)
{
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::Programmer, DecBase/*number base*/, ByteType/*bitlength Type*/);
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::Programmer, DecBase/*number base*/, BitLength::BitLengthByte);
}
String^ ValidateProgrammerOctQwordPasteExpression(_In_ String^ pastedText)
{
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::Programmer, OctBase/*number base*/, QwordType/*bitlength Type*/);
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::Programmer, OctBase/*number base*/, BitLength::BitLengthQWord);
}
String^ ValidateProgrammerOctDwordPasteExpression(_In_ String^ pastedText)
{
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::Programmer, OctBase/*number base*/, DwordType/*bitlength Type*/);
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::Programmer, OctBase/*number base*/, BitLength::BitLengthDWord);
}
String^ ValidateProgrammerOctWordPasteExpression(_In_ String^ pastedText)
{
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::Programmer, OctBase/*number base*/, WordType/*bitlength Type*/);
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::Programmer, OctBase/*number base*/, BitLength::BitLengthWord);
}
String^ ValidateProgrammerOctBytePasteExpression(_In_ String^ pastedText)
{
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::Programmer, OctBase/*number base*/, ByteType/*bitlength Type*/);
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::Programmer, OctBase/*number base*/, BitLength::BitLengthByte);
}
String^ ValidateProgrammerBinQwordPasteExpression(_In_ String^ pastedText)
{
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::Programmer, BinBase/*number base*/, QwordType/*bitlength Type*/);
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::Programmer, BinBase/*number base*/, BitLength::BitLengthQWord);
}
String^ ValidateProgrammerBinDwordPasteExpression(_In_ String^ pastedText)
{
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::Programmer, BinBase/*number base*/, DwordType/*bitlength Type*/);
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::Programmer, BinBase/*number base*/, BitLength::BitLengthDWord);
}
String^ ValidateProgrammerBinWordPasteExpression(_In_ String^ pastedText)
{
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::Programmer, BinBase/*number base*/, WordType/*bitlength Type*/);
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::Programmer, BinBase/*number base*/, BitLength::BitLengthWord);
}
String^ ValidateProgrammerBinBytePasteExpression(_In_ String^ pastedText)
{
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::Programmer, BinBase/*number base*/, ByteType/*bitlength Type*/);
return m_CopyPasteManager.ValidatePasteExpression(pastedText, ViewMode::Programmer, BinBase/*number base*/, BitLength::BitLengthByte);
}
};
@@ -576,7 +591,7 @@ namespace CalculatorUnitTests
for (String ^ &input : inputs)
{
// paste number in standard mode and then validate the pastability of displayed number for other modes
scvm->OnPaste(input, ViewMode::Standard);
scvm->OnPaste(input);
VERIFY_ARE_EQUAL(ValidateStandardPasteExpression(scvm->DisplayValue), scvm->DisplayValue);
VERIFY_ARE_EQUAL(ValidateScientificPasteExpression(scvm->DisplayValue), scvm->DisplayValue);
VERIFY_ARE_EQUAL(ValidateProgrammerHexQwordPasteExpression(scvm->DisplayValue), scvm->DisplayValue);

32
src/CalculatorUnitTests/CurrencyConverterUnitTests.cpp
View File

@@ -590,6 +590,38 @@ TEST_METHOD(Loaded_GetCurrencyRatioEquality_Invalid)
VERIFY_ARE_EQUAL(wstring(L""), ratio.first);
VERIFY_ARE_EQUAL(wstring(L""), ratio.second);
}
TEST_METHOD(Test_RoundCurrencyRatio)
{
CurrencyDataLoader loader{ nullptr };
VERIFY_ARE_EQUAL(CurrencyDataLoader::RoundCurrencyRatio(1234567), 1234567);
VERIFY_ARE_EQUAL(CurrencyDataLoader::RoundCurrencyRatio(0), 0);
VERIFY_ARE_EQUAL(CurrencyDataLoader::RoundCurrencyRatio(9999.999), 9999.999);
VERIFY_ARE_EQUAL(CurrencyDataLoader::RoundCurrencyRatio(8765.4321), 8765.4321);
VERIFY_ARE_EQUAL(CurrencyDataLoader::RoundCurrencyRatio(4815.162342), 4815.1623);
VERIFY_ARE_EQUAL(CurrencyDataLoader::RoundCurrencyRatio(4815.162358), 4815.1624);
VERIFY_ARE_EQUAL(CurrencyDataLoader::RoundCurrencyRatio(4815.162388934723), 4815.1624);
VERIFY_ARE_EQUAL(CurrencyDataLoader::RoundCurrencyRatio(0.12), 0.12);
VERIFY_ARE_EQUAL(CurrencyDataLoader::RoundCurrencyRatio(0.123), 0.123);
VERIFY_ARE_EQUAL(CurrencyDataLoader::RoundCurrencyRatio(0.1234), 0.1234);
VERIFY_ARE_EQUAL(CurrencyDataLoader::RoundCurrencyRatio(0.12343), 0.1234);
VERIFY_ARE_EQUAL(CurrencyDataLoader::RoundCurrencyRatio(0.0321), 0.0321);
VERIFY_ARE_EQUAL(CurrencyDataLoader::RoundCurrencyRatio(0.03211), 0.03211);
VERIFY_ARE_EQUAL(CurrencyDataLoader::RoundCurrencyRatio(0.032119), 0.03212);
VERIFY_ARE_EQUAL(CurrencyDataLoader::RoundCurrencyRatio(0.00322119), 0.003221);
VERIFY_ARE_EQUAL(CurrencyDataLoader::RoundCurrencyRatio(0.00123269), 0.001233);
VERIFY_ARE_EQUAL(CurrencyDataLoader::RoundCurrencyRatio(0.00076269), 0.0007627);
VERIFY_ARE_EQUAL(CurrencyDataLoader::RoundCurrencyRatio(0.000069), 0.000069);
VERIFY_ARE_EQUAL(CurrencyDataLoader::RoundCurrencyRatio(0.000061), 0.000061);
VERIFY_ARE_EQUAL(CurrencyDataLoader::RoundCurrencyRatio(0.000054612), 0.00005461);
VERIFY_ARE_EQUAL(CurrencyDataLoader::RoundCurrencyRatio(0.000054616), 0.00005462);
VERIFY_ARE_EQUAL(CurrencyDataLoader::RoundCurrencyRatio(0.000005416), 0.000005416);
VERIFY_ARE_EQUAL(CurrencyDataLoader::RoundCurrencyRatio(0.0000016134324), 0.000001613);
VERIFY_ARE_EQUAL(CurrencyDataLoader::RoundCurrencyRatio(0.0000096134324), 0.000009613);
VERIFY_ARE_EQUAL(CurrencyDataLoader::RoundCurrencyRatio(0.0000032169348392), 0.000003217);
VERIFY_ARE_EQUAL(CurrencyDataLoader::RoundCurrencyRatio(0.000000002134987218), 0.000000002135);
VERIFY_ARE_EQUAL(CurrencyDataLoader::RoundCurrencyRatio(0.000000000000087231445), 0.00000000000008723);
}
}
;
}

143
src/CalculatorUnitTests/LocalizationServiceUnitTests.cpp Normal file
View File

@@ -0,0 +1,143 @@
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
#include "pch.h"
#include <CppUnitTest.h>
#include "CalcViewModel/Common/LocalizationService.h"
using namespace CalculatorApp::Common;
using namespace Platform;
using namespace std;
using namespace Microsoft::VisualStudio::CppUnitTestFramework;
namespace CalculatorUnitTests
{
TEST_CLASS(LocalizationServiceUnitTests)
{
public:
TEST_METHOD(TestSortStrings)
{
auto localizationService = LocalizationService::GetInstance();
vector<String^> stringsToSort =
{
L"Zebra",
L"Alpha",
L"beta1",
L"Gamma",
L"Beta",
L"alpha1",
L"États-Unis",
L"Epsilon",
L"Etude",
};
vector<String^> expectedResult =
{
L"Alpha",
L"alpha1",
L"Beta",
L"beta1",
L"Epsilon",
L"États-Unis",
L"Etude",
L"Gamma",
L"Zebra",
};
VERIFY_ARE_EQUAL(stringsToSort.size(), expectedResult.size());
VERIFY_IS_FALSE(equal(stringsToSort.begin(), stringsToSort.end(), expectedResult.begin()));
localizationService->Sort(stringsToSort);
VERIFY_IS_TRUE(equal(stringsToSort.begin(), stringsToSort.end(), expectedResult.begin()));
}
TEST_METHOD(TestSortEmptyStrings)
{
//Verify if LocalizationService::Sort doesn't crash when the vector is empty or null
auto localizationService = LocalizationService::GetInstance();
vector<String^> stringsToSort = {};
localizationService->Sort(stringsToSort);
stringsToSort = { L"" };
localizationService->Sort(stringsToSort);
stringsToSort = { L"",L"",L"" };
localizationService->Sort(stringsToSort);
stringsToSort = { nullptr,L"",L"" };
localizationService->Sort(stringsToSort);
}
TEST_METHOD(TestSortGeneric)
{
vector<String^> stringsToSort =
{
L"fermentum",
L"fringilla",
L"Curabitur",
L"rhoncus",
L"Aenean",
L"Fusce",
L"sollicitudin",
L"empor",
L"edapibus",
L"édapibas",
L"édapîbos",
L"édapîbÉs",
};
vector<String^> expectedResult =
{
L"Aenean",
L"Curabitur",
L"édapibas",
L"édapîbÉs",
L"édapîbos",
L"edapibus",
L"empor",
L"fermentum",
L"fringilla",
L"Fusce",
L"rhoncus",
L"sollicitudin",
};
auto sortFunction = [](String^ s) {
return ref new String(L"CAL:") + s + L"TEST";
};
VERIFY_ARE_EQUAL(stringsToSort.size(), expectedResult.size());
VERIFY_IS_FALSE(equal(stringsToSort.begin(), stringsToSort.end(), expectedResult.begin()));
auto localizationService = LocalizationService::GetInstance();
localizationService->Sort<String^>(stringsToSort, sortFunction);
VERIFY_IS_TRUE(equal(stringsToSort.begin(), stringsToSort.end(), expectedResult.begin()));
vector<String^> expected2Result =
{
L"édapibas",
L"édapîbÉs",
L"édapîbos",
L"edapibus",
L"Aenean",
L"fermentum",
L"rhoncus",
L"empor",
L"sollicitudin",
L"fringilla",
L"Curabitur",
L"Fusce",
};
auto sort2Function = [](String^ s) {
return ref new String(s->Begin()+1);
};
VERIFY_ARE_EQUAL(stringsToSort.size(), expected2Result.size());
VERIFY_IS_FALSE(equal(stringsToSort.begin(), stringsToSort.end(), expected2Result.begin()));
localizationService->Sort<String^>(stringsToSort, sort2Function);
VERIFY_IS_TRUE(equal(stringsToSort.begin(), stringsToSort.end(), expected2Result.begin()));
}
};
}

49
src/CalculatorUnitTests/NavCategoryUnitTests.cpp
View File

@@ -257,26 +257,9 @@ namespace CalculatorUnitTests
void NavCategoryUnitTests::GetIndex()
{
// Index is the 0-based ordering of modes
ViewMode orderedModes[] = {
ViewMode::Standard,
ViewMode::Scientific,
ViewMode::Programmer,
ViewMode::Date,
ViewMode::Graphing,
ViewMode::Currency,
ViewMode::Volume,
ViewMode::Length,
ViewMode::Weight,
ViewMode::Temperature,
ViewMode::Energy,
ViewMode::Area,
ViewMode::Speed,
ViewMode::Time,
ViewMode::Power,
ViewMode::Data,
ViewMode::Pressure,
ViewMode::Angle
};
vector<ViewMode> orderedModes = { ViewMode::Standard, ViewMode::Scientific, ViewMode::Programmer, ViewMode::Date, ViewMode::Graphing,
ViewMode::Currency, ViewMode::Area, ViewMode::Speed, ViewMode::Time, ViewMode::Power,
ViewMode::Data, ViewMode::Pressure, ViewMode::Angle };
auto orderedModesSize = size(orderedModes);
for (size_t index = 0; index < orderedModesSize; index++)
@@ -291,26 +274,10 @@ namespace CalculatorUnitTests
void NavCategoryUnitTests::GetPosition()
{
// Position is the 1-based ordering of modes
ViewMode orderedModes[] = {
ViewMode::Standard,
ViewMode::Scientific,
ViewMode::Programmer,
ViewMode::Date,
ViewMode::Graphing,
ViewMode::Currency,
ViewMode::Volume,
ViewMode::Length,
ViewMode::Weight,
ViewMode::Temperature,
ViewMode::Energy,
ViewMode::Area,
ViewMode::Speed,
ViewMode::Time,
ViewMode::Power,
ViewMode::Data,
ViewMode::Pressure,
ViewMode::Angle
};
vector<ViewMode> orderedModes = { ViewMode::Standard, ViewMode::Scientific, ViewMode::Programmer, ViewMode::Date, ViewMode::Graphing
ViewMode::Currency, ViewMode::Volume, ViewMode::Length, ViewMode::Weight, ViewMode::Temperature,
ViewMode::Energy, ViewMode::Area, ViewMode::Speed, ViewMode::Time, ViewMode::Power,
ViewMode::Data, ViewMode::Pressure, ViewMode::Angle };
auto orderedModesSize = size(orderedModes);
for (size_t pos = 1; pos <= orderedModesSize; pos++)
@@ -392,7 +359,7 @@ namespace CalculatorUnitTests
NavCategoryGroup ^ calculatorGroup = menuOptions->GetAt(0);
VERIFY_ARE_EQUAL(CategoryGroupType::Calculator, calculatorGroup->GroupType);
IObservableVector<NavCategory^>^ calculatorCategories = calculatorGroup->Categories;
IObservableVector<NavCategory ^> ^ calculatorCategories = calculatorGroup->Categories;
VERIFY_ARE_EQUAL(5, calculatorCategories->Size);
ValidateNavCategory(calculatorCategories, 0u, ViewMode::Standard, 1);
ValidateNavCategory(calculatorCategories, 1u, ViewMode::Scientific, 2);

64
src/CalculatorUnitTests/StandardViewModelUnitTests.cpp
View File

@@ -16,9 +16,22 @@ using namespace CalculatorApp::Common;
using namespace CalculatorApp::ViewModel;
using namespace Platform;
using namespace Microsoft::VisualStudio::CppUnitTestFramework;
using namespace Windows::Foundation::Collections;
namespace CalculatorUnitTests
{
template <typename T>
void CompareVector(IVector<T> ^ vecA, IVector<T> ^ vecB)
{
if (vecA->Size != vecB->Size)
Assert::Fail();
for (unsigned int i = 0; i < vecA->Size; ++i)
{
VERIFY_ARE_EQUAL(vecA->GetAt(i), vecB->GetAt(i));
}
}
void ChangeMode(StandardCalculatorViewModel ^ viewModel, int mode)
{
if (mode == 0)
@@ -387,26 +400,26 @@ namespace CalculatorUnitTests
{
m_viewModel->IsScientific = false;
m_viewModel->OnPaste("-0.99", ViewMode::Standard);
m_viewModel->OnPaste("-0.99");
ValidateViewModelValueAndExpression("-0" + m_decimalSeparator + "99", "");
m_viewModel->OnPaste("1+1=", ViewMode::Standard);
m_viewModel->OnPaste("1+1=");
ValidateViewModelValueAndExpression("2", "");
// This result is not obvious: it's the result of the previous operation
m_viewModel->OnPaste("0=", ViewMode::Standard);
m_viewModel->OnPaste("0=");
ValidateViewModelValueAndExpression("1", "");
// Negative value
m_viewModel->OnPaste("-1", ViewMode::Standard);
m_viewModel->OnPaste("-1");
ValidateViewModelValueAndExpression("-1", "");
// Negated expression
m_viewModel->OnPaste("-(1+1)", ViewMode::Standard);
m_viewModel->OnPaste("-(1+1)");
ValidateViewModelValueAndSecondaryExpression("-2", "negate(1 + 1)");
// More complicated Negated expression
m_viewModel->OnPaste("-(-(-1))", ViewMode::Standard);
m_viewModel->OnPaste("-(-(-1))");
ValidateViewModelValueAndSecondaryExpression("-1", "negate(0 - (0 - 1))");
// Switch to scientific mode
@@ -415,24 +428,24 @@ namespace CalculatorUnitTests
VERIFY_IS_FALSE(m_viewModel->IsFToEChecked);
//// Positive exponent
m_viewModel->OnPaste("1.23e+10", ViewMode::Scientific);
m_viewModel->OnPaste("1.23e+10");
ValidateViewModelValueAndExpression("1" + m_decimalSeparator + "23e+10", "");
m_viewModel->OnPaste("1.23e10", ViewMode::Scientific);
m_viewModel->OnPaste("1.23e10");
ValidateViewModelValueAndExpression("1" + m_decimalSeparator + "23e+10", "");
m_viewModel->OnPaste("135e10", ViewMode::Scientific);
m_viewModel->OnPaste("135e10");
ValidateViewModelValueAndExpression("135" + m_decimalSeparator + "e+10", "");
//// Negative exponent
m_viewModel->OnPaste("1.23e-10", ViewMode::Scientific);
m_viewModel->OnPaste("1.23e-10");
ValidateViewModelValueAndExpression("1" + m_decimalSeparator + "23e-10", "");
//// Uppercase E (for exponent)
m_viewModel->OnPaste("1.23E-10", ViewMode::Scientific);
m_viewModel->OnPaste("1.23E-10");
ValidateViewModelValueAndExpression("1" + m_decimalSeparator + "23e-10", "");
m_viewModel->OnPaste("135E10", ViewMode::Scientific);
m_viewModel->OnPaste("135E10");
ValidateViewModelValueAndExpression("135" + m_decimalSeparator + "e+10", "");
}
@@ -496,6 +509,12 @@ namespace CalculatorUnitTests
VERIFY_ARE_EQUAL(Utils::GetStringValue(m_viewModel->DecimalDisplayValue), StringReference(L"15"));
VERIFY_ARE_EQUAL(Utils::GetStringValue(m_viewModel->OctalDisplayValue), StringReference(L"17"));
VERIFY_ARE_EQUAL(Utils::GetStringValue(m_viewModel->BinaryDisplayValue), StringReference(L"1111"));
auto val = ref new PC::Vector<bool>(64, false);
val->SetAt(0, true);
val->SetAt(1, true);
val->SetAt(2, true);
val->SetAt(3, true);
CompareVector<bool>(m_viewModel->BinaryDigits, val);
}
// Test Button disabling in different Radixes
@@ -543,6 +562,24 @@ namespace CalculatorUnitTests
VERIFY_ARE_EQUAL(Utils::GetStringValue(m_viewModel->DecimalDisplayValue), StringReference(L"123,456,789"));
VERIFY_ARE_EQUAL(Utils::GetStringValue(m_viewModel->OctalDisplayValue), StringReference(L"726 746 425"));
VERIFY_ARE_EQUAL(Utils::GetStringValue(m_viewModel->BinaryDisplayValue), StringReference(L"0111 0101 1011 1100 1101 0001 0101"));
auto val = ref new PC::Vector<bool>(64, false);
val->SetAt(0, true);
val->SetAt(2, true);
val->SetAt(4, true);
val->SetAt(8, true);
val->SetAt(10, true);
val->SetAt(11, true);
val->SetAt(14, true);
val->SetAt(15, true);
val->SetAt(16, true);
val->SetAt(17, true);
val->SetAt(19, true);
val->SetAt(20, true);
val->SetAt(22, true);
val->SetAt(24, true);
val->SetAt(25, true);
val->SetAt(26, true);
CompareVector<bool>(m_viewModel->BinaryDigits, val);
}
// Test Not functionality
@@ -562,6 +599,9 @@ namespace CalculatorUnitTests
Utils::GetStringValue(m_viewModel->BinaryDisplayValue),
StringReference(L"1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1110"));
VERIFY_ARE_EQUAL(m_viewModel->DisplayValue, StringReference(L"-2"));
auto val = ref new PC::Vector<bool>(64, true);
val->SetAt(0, false);
CompareVector<bool>(m_viewModel->BinaryDigits, val);
}
// Test And Or functionality

2
src/CalculatorUnitTests/UnitConverterTest.cpp
View File

@@ -441,7 +441,7 @@ namespace UnitConverterUnitTests
s_unitConverter->SendCommand(Command::Six);
s_unitConverter->SendCommand(Command::Seven);
s_unitConverter->SendCommand(Command::Eight);
VERIFY_IS_TRUE(s_testVMCallback->CheckDisplayValues(wstring(L"12345678"), wstring(L"27217528.63236")));
VERIFY_IS_TRUE(s_testVMCallback->CheckDisplayValues(wstring(L"12345678"), wstring(L"27217529")));
}
// Test large values

29
src/CalculatorUnitTests/UnitConverterViewModelUnitTests.cpp
View File

@@ -852,69 +852,68 @@ TEST_METHOD(TestOnPaste)
// Call count is being set to 1 because we send 'CE' command as the first call in OnPaste method of the ViewModel
UINT callCount = 1;
ViewMode mode = ViewMode::Volume; // Some temp mode for UnitConverter
// Paste an invalid character - verify that call count doesn't increment
vm.OnPaste("z", mode);
vm.OnPaste("z");
VERIFY_ARE_EQUAL(callCount, mock->m_sendCommandCallCount);
// Test all valid characters. Verify that two commands are sent for each character
vm.OnPaste("0", mode);
vm.OnPaste("0");
callCount += 2;
VERIFY_ARE_EQUAL(callCount, mock->m_sendCommandCallCount);
VERIFY_IS_TRUE(UCM::Command::Zero == mock->m_lastCommand);
vm.OnPaste("1", mode);
vm.OnPaste("1");
callCount += 2;
VERIFY_ARE_EQUAL(callCount, mock->m_sendCommandCallCount);
VERIFY_IS_TRUE(UCM::Command::One == mock->m_lastCommand);
vm.OnPaste("2", mode);
vm.OnPaste("2");
callCount += 2;
VERIFY_ARE_EQUAL(callCount, mock->m_sendCommandCallCount);
VERIFY_IS_TRUE(UCM::Command::Two == mock->m_lastCommand);
vm.OnPaste("3", mode);
vm.OnPaste("3");
callCount += 2;
VERIFY_ARE_EQUAL(callCount, mock->m_sendCommandCallCount);
VERIFY_IS_TRUE(UCM::Command::Three == mock->m_lastCommand);
vm.OnPaste("4", mode);
vm.OnPaste("4");
callCount += 2;
VERIFY_ARE_EQUAL(callCount, mock->m_sendCommandCallCount);
VERIFY_IS_TRUE(UCM::Command::Four == mock->m_lastCommand);
vm.OnPaste("5", mode);
vm.OnPaste("5");
callCount += 2;
VERIFY_ARE_EQUAL(callCount, mock->m_sendCommandCallCount);
VERIFY_IS_TRUE(UCM::Command::Five == mock->m_lastCommand);
vm.OnPaste("6", mode);
vm.OnPaste("6");
callCount += 2;
VERIFY_ARE_EQUAL(callCount, mock->m_sendCommandCallCount);
VERIFY_IS_TRUE(UCM::Command::Six == mock->m_lastCommand);
vm.OnPaste("7", mode);
vm.OnPaste("7");
callCount += 2;
VERIFY_ARE_EQUAL(callCount, mock->m_sendCommandCallCount);
VERIFY_IS_TRUE(UCM::Command::Seven == mock->m_lastCommand);
vm.OnPaste("8", mode);
vm.OnPaste("8");
callCount += 2;
VERIFY_ARE_EQUAL(callCount, mock->m_sendCommandCallCount);
VERIFY_IS_TRUE(UCM::Command::Eight == mock->m_lastCommand);
vm.OnPaste("9", mode);
vm.OnPaste("9");
callCount += 2;
VERIFY_ARE_EQUAL(callCount, mock->m_sendCommandCallCount);
VERIFY_IS_TRUE(UCM::Command::Nine == mock->m_lastCommand);
vm.OnPaste(".", mode);
vm.OnPaste(".");
callCount += 2;
VERIFY_ARE_EQUAL(callCount, mock->m_sendCommandCallCount);
VERIFY_IS_TRUE(UCM::Command::Decimal == mock->m_lastCommand);
vm.OnPaste("-", mode);
vm.OnPaste("-");
// Call count should increment by one (the Clear command) since negate isn't
// sent by itself, only after another legal character
++callCount;
@@ -922,7 +921,7 @@ TEST_METHOD(TestOnPaste)
// Send an invalid character
vm.OnPaste("a", mode);
vm.OnPaste("a");
// Count should remain the same
VERIFY_ARE_EQUAL(callCount, mock->m_sendCommandCallCount);
// Last command should remain the same