github/msft-calculator
1
0
Fork 0
mirror of https://github.com/Microsoft/calculator.git synced 2025-08-22 14:13:30 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

resolve comments

Browse source
This commit is contained in:
tian-lt 2022-04-13 11:52:48 +08:00
commit e82ae9c887
3 changed files with 444 additions and 575 deletions
Download patch file Download diff file Expand all files Collapse all files

148
src/CalcViewModel/Common/NavCategory.cpp
View file

@ -47,23 +47,11 @@ static constexpr int CURRENCY_ID = 16;
static constexpr int GRAPHING_ID = 17; static constexpr int GRAPHING_ID = 17;
// ^^^ THESE CONSTANTS SHOULD NEVER CHANGE ^^^ // ^^^ THESE CONSTANTS SHOULD NEVER CHANGE ^^^
namespace namespace // put the utils within this TU
{ {
Platform::Agile<Windows::System::User^> CurrentUser; Platform::Agile<Windows::System::User^> CurrentUser;
std::mutex GraphingModeCheckMutex; std::mutex GraphingModeCheckMutex;
wchar_t* towchar_t(int number)
{
auto wstr = std::to_wstring(number);
return _wcsdup(wstr.c_str());
}
bool IsGraphingModeAvailable()
{
static bool supportGraph = Windows::Foundation::Metadata::ApiInformation::IsMethodPresent("Windows.UI.Text.RichEditTextDocument", "GetMath");
return supportGraph;
}
bool IsGraphingModeEnabled() bool IsGraphingModeEnabled()
{ {
static bool isChecked = false; static bool isChecked = false;
@ -75,29 +63,20 @@ namespace
return isEnabled; return isEnabled;
} }
else else
{
if (IsGraphingModeAvailable())
{ {
auto namedPolicyData = NamedPolicy::GetPolicyFromPathForUser( auto namedPolicyData = NamedPolicy::GetPolicyFromPathForUser(
CurrentUser.Get(), CurrentUser.Get(),
L"Education", L"Education",
L"AllowGraphingCalculator"); L"AllowGraphingCalculator");
isEnabled = namedPolicyData->GetBoolean(); isEnabled = namedPolicyData->GetBoolean();
}
else
{
isEnabled = false;
}
isChecked = true; isChecked = true;
return isEnabled; return isEnabled;
} }
} }
}
// The order of items in this list determines the order of items in the menu.
// The order of items in this list determines the order of items in the menu. const std::vector<NavCategoryInitializer> s_categoryManifest {
static std::vector<NavCategoryInitializer> s_categoryManifest = [] { NavCategoryInitializer{ ViewMode::Standard,
auto res = std::vector<NavCategoryInitializer>{ NavCategoryInitializer{ ViewMode::Standard,
STANDARD_ID, STANDARD_ID,
L"Standard", L"Standard",
L"StandardMode", L"StandardMode",
@ -105,8 +84,7 @@ static std::vector<NavCategoryInitializer> s_categoryManifest = [] {
CategoryGroupType::Calculator, CategoryGroupType::Calculator,
MyVirtualKey::Number1, MyVirtualKey::Number1,
L"1", L"1",
SUPPORTS_ALL, SUPPORTS_ALL },
true },
NavCategoryInitializer{ ViewMode::Scientific, NavCategoryInitializer{ ViewMode::Scientific,
SCIENTIFIC_ID, SCIENTIFIC_ID,
L"Scientific", L"Scientific",
@ -115,14 +93,8 @@ static std::vector<NavCategoryInitializer> s_categoryManifest = [] {
CategoryGroupType::Calculator, CategoryGroupType::Calculator,
MyVirtualKey::Number2, MyVirtualKey::Number2,
L"2", L"2",
SUPPORTS_ALL, SUPPORTS_ALL },
true } }; NavCategoryInitializer{ ViewMode::Graphing,
int currentIndex = 3;
bool supportGraphingCalculator = IsGraphingModeAvailable();
if (supportGraphingCalculator)
{
res.emplace_back(NavCategoryInitializer{ ViewMode::Graphing,
GRAPHING_ID, GRAPHING_ID,
L"Graphing", L"Graphing",
L"GraphingCalculatorMode", L"GraphingCalculatorMode",
@ -130,32 +102,25 @@ static std::vector<NavCategoryInitializer> s_categoryManifest = [] {
CategoryGroupType::Calculator, CategoryGroupType::Calculator,
MyVirtualKey::Number3, MyVirtualKey::Number3,
L"3", L"3",
SUPPORTS_ALL, SUPPORTS_ALL },
false}); NavCategoryInitializer{ ViewMode::Programmer,
++currentIndex;
}
res.insert(
res.cend(),
{ NavCategoryInitializer{ ViewMode::Programmer,
PROGRAMMER_ID, PROGRAMMER_ID,
L"Programmer", L"Programmer",
L"ProgrammerMode", L"ProgrammerMode",
L"\uECCE", L"\uECCE",
CategoryGroupType::Calculator, CategoryGroupType::Calculator,
supportGraphingCalculator ? MyVirtualKey::Number4 : MyVirtualKey::Number3, MyVirtualKey::Number4,
towchar_t(currentIndex++), L"4",
SUPPORTS_ALL, SUPPORTS_ALL },
true },
NavCategoryInitializer{ ViewMode::Date, NavCategoryInitializer{ ViewMode::Date,
DATE_ID, DATE_ID,
L"Date", L"Date",
L"DateCalculationMode", L"DateCalculationMode",
L"\uE787", L"\uE787",
CategoryGroupType::Calculator, CategoryGroupType::Calculator,
supportGraphingCalculator ? MyVirtualKey::Number5 : MyVirtualKey::Number4, MyVirtualKey::Number5,
towchar_t(currentIndex++), L"5",
SUPPORTS_ALL, SUPPORTS_ALL },
true },
NavCategoryInitializer{ ViewMode::Currency, NavCategoryInitializer{ ViewMode::Currency,
CURRENCY_ID, CURRENCY_ID,
L"Currency", L"Currency",
@ -163,9 +128,8 @@ static std::vector<NavCategoryInitializer> s_categoryManifest = [] {
L"\uEB0D", L"\uEB0D",
CategoryGroupType::Converter, CategoryGroupType::Converter,
MyVirtualKey::None, MyVirtualKey::None,
nullptr, std::nullopt,
POSITIVE_ONLY, POSITIVE_ONLY },
true },
NavCategoryInitializer{ ViewMode::Volume, NavCategoryInitializer{ ViewMode::Volume,
VOLUME_ID, VOLUME_ID,
L"Volume", L"Volume",
@ -173,9 +137,8 @@ static std::vector<NavCategoryInitializer> s_categoryManifest = [] {
L"\uF1AA", L"\uF1AA",
CategoryGroupType::Converter, CategoryGroupType::Converter,
MyVirtualKey::None, MyVirtualKey::None,
nullptr, std::nullopt,
POSITIVE_ONLY, POSITIVE_ONLY },
true },
NavCategoryInitializer{ ViewMode::Length, NavCategoryInitializer{ ViewMode::Length,
LENGTH_ID, LENGTH_ID,
L"Length", L"Length",
@ -183,9 +146,8 @@ static std::vector<NavCategoryInitializer> s_categoryManifest = [] {
L"\uECC6", L"\uECC6",
CategoryGroupType::Converter, CategoryGroupType::Converter,
MyVirtualKey::None, MyVirtualKey::None,
nullptr, std::nullopt,
POSITIVE_ONLY, POSITIVE_ONLY },
true },
NavCategoryInitializer{ ViewMode::Weight, NavCategoryInitializer{ ViewMode::Weight,
WEIGHT_ID, WEIGHT_ID,
L"Weight and Mass", L"Weight and Mass",
@ -193,9 +155,8 @@ static std::vector<NavCategoryInitializer> s_categoryManifest = [] {
L"\uF4C1", L"\uF4C1",
CategoryGroupType::Converter, CategoryGroupType::Converter,
MyVirtualKey::None, MyVirtualKey::None,
nullptr, std::nullopt,
POSITIVE_ONLY, POSITIVE_ONLY },
true },
NavCategoryInitializer{ ViewMode::Temperature, NavCategoryInitializer{ ViewMode::Temperature,
TEMPERATURE_ID, TEMPERATURE_ID,
L"Temperature", L"Temperature",
@ -203,9 +164,8 @@ static std::vector<NavCategoryInitializer> s_categoryManifest = [] {
L"\uE7A3", L"\uE7A3",
CategoryGroupType::Converter, CategoryGroupType::Converter,
MyVirtualKey::None, MyVirtualKey::None,
nullptr, std::nullopt,
SUPPORTS_NEGATIVE, SUPPORTS_NEGATIVE },
true },
NavCategoryInitializer{ ViewMode::Energy, NavCategoryInitializer{ ViewMode::Energy,
ENERGY_ID, ENERGY_ID,
L"Energy", L"Energy",
@ -213,9 +173,8 @@ static std::vector<NavCategoryInitializer> s_categoryManifest = [] {
L"\uECAD", L"\uECAD",
CategoryGroupType::Converter, CategoryGroupType::Converter,
MyVirtualKey::None, MyVirtualKey::None,
nullptr, std::nullopt,
POSITIVE_ONLY, POSITIVE_ONLY },
true },
NavCategoryInitializer{ ViewMode::Area, NavCategoryInitializer{ ViewMode::Area,
AREA_ID, AREA_ID,
L"Area", L"Area",
@ -223,9 +182,8 @@ static std::vector<NavCategoryInitializer> s_categoryManifest = [] {
L"\uE809", L"\uE809",
CategoryGroupType::Converter, CategoryGroupType::Converter,
MyVirtualKey::None, MyVirtualKey::None,
nullptr, std::nullopt,
POSITIVE_ONLY, POSITIVE_ONLY },
true },
NavCategoryInitializer{ ViewMode::Speed, NavCategoryInitializer{ ViewMode::Speed,
SPEED_ID, SPEED_ID,
L"Speed", L"Speed",
@ -233,9 +191,8 @@ static std::vector<NavCategoryInitializer> s_categoryManifest = [] {
L"\uEADA", L"\uEADA",
CategoryGroupType::Converter, CategoryGroupType::Converter,
MyVirtualKey::None, MyVirtualKey::None,
nullptr, std::nullopt,
POSITIVE_ONLY, POSITIVE_ONLY },
true },
NavCategoryInitializer{ ViewMode::Time, NavCategoryInitializer{ ViewMode::Time,
TIME_ID, TIME_ID,
L"Time", L"Time",
@ -243,9 +200,8 @@ static std::vector<NavCategoryInitializer> s_categoryManifest = [] {
L"\uE917", L"\uE917",
CategoryGroupType::Converter, CategoryGroupType::Converter,
MyVirtualKey::None, MyVirtualKey::None,
nullptr, std::nullopt,
POSITIVE_ONLY, POSITIVE_ONLY },
true },
NavCategoryInitializer{ ViewMode::Power, NavCategoryInitializer{ ViewMode::Power,
POWER_ID, POWER_ID,
L"Power", L"Power",
@ -253,9 +209,8 @@ static std::vector<NavCategoryInitializer> s_categoryManifest = [] {
L"\uE945", L"\uE945",
CategoryGroupType::Converter, CategoryGroupType::Converter,
MyVirtualKey::None, MyVirtualKey::None,
nullptr, std::nullopt,
SUPPORTS_NEGATIVE, SUPPORTS_NEGATIVE },
true },
NavCategoryInitializer{ ViewMode::Data, NavCategoryInitializer{ ViewMode::Data,
DATA_ID, DATA_ID,
L"Data", L"Data",
@ -263,9 +218,8 @@ static std::vector<NavCategoryInitializer> s_categoryManifest = [] {
L"\uF20F", L"\uF20F",
CategoryGroupType::Converter, CategoryGroupType::Converter,
MyVirtualKey::None, MyVirtualKey::None,
nullptr, std::nullopt,
POSITIVE_ONLY, POSITIVE_ONLY },
true },
NavCategoryInitializer{ ViewMode::Pressure, NavCategoryInitializer{ ViewMode::Pressure,
PRESSURE_ID, PRESSURE_ID,
L"Pressure", L"Pressure",
@ -273,9 +227,8 @@ static std::vector<NavCategoryInitializer> s_categoryManifest = [] {
L"\uEC4A", L"\uEC4A",
CategoryGroupType::Converter, CategoryGroupType::Converter,
MyVirtualKey::None, MyVirtualKey::None,
nullptr, std::nullopt,
POSITIVE_ONLY, POSITIVE_ONLY },
true },
NavCategoryInitializer{ ViewMode::Angle, NavCategoryInitializer{ ViewMode::Angle,
ANGLE_ID, ANGLE_ID,
L"Angle", L"Angle",
@ -283,11 +236,11 @@ static std::vector<NavCategoryInitializer> s_categoryManifest = [] {
L"\uF515", L"\uF515",
CategoryGroupType::Converter, CategoryGroupType::Converter,
MyVirtualKey::None, MyVirtualKey::None,
nullptr, std::nullopt,
SUPPORTS_NEGATIVE, SUPPORTS_NEGATIVE },
true } }); };
return res; } // namespace unnamed
}();
bool NavCategory::IsCalculatorViewMode(ViewModeType mode) bool NavCategory::IsCalculatorViewMode(ViewModeType mode)
{ {
@ -347,12 +300,12 @@ NavCategoryGroup::NavCategoryGroup(const NavCategoryGroupInitializer& groupIniti
categoryName, categoryName,
categoryAutomationName, categoryAutomationName,
StringReference(categoryInitializer.glyph), StringReference(categoryInitializer.glyph),
categoryInitializer.accessKey != nullptr ? ref new String(categoryInitializer.accessKey) categoryInitializer.accessKey.has_value() ? ref new String(categoryInitializer.accessKey->c_str())
: resProvider->GetResourceString(nameResourceKey + "AccessKey"), : resProvider->GetResourceString(nameResourceKey + "AccessKey"),
groupMode, groupMode,
categoryInitializer.viewMode, categoryInitializer.viewMode,
categoryInitializer.supportsNegative, categoryInitializer.supportsNegative,
categoryInitializer.isEnabled)); categoryInitializer.viewMode != ViewMode::Graphing));
} }
} }
} }
@ -559,16 +512,13 @@ bool NavCategoryStates::IsValidViewMode(ViewMode mode)
bool NavCategoryStates::IsViewModeEnabled(ViewMode mode) bool NavCategoryStates::IsViewModeEnabled(ViewMode mode)
{ {
if (mode == ViewMode::Graphing) if (mode != ViewMode::Graphing)
{ {
return IsGraphingModeEnabled(); return true;
} }
else else
{ {
return std::any_of( return IsGraphingModeEnabled();
s_categoryManifest.cbegin(),
s_categoryManifest.cend(),
[mode](const auto& initializer) { return initializer.viewMode == mode && initializer.isEnabled; });
} }
} }

3
src/CalcViewModel/Common/NavCategory.h
View file

@ -66,9 +66,8 @@ namespace CalculatorApp::ViewModel
const wchar_t* glyph; const wchar_t* glyph;
CategoryGroupType groupType; CategoryGroupType groupType;
MyVirtualKey virtualKey; MyVirtualKey virtualKey;
const wchar_t* accessKey; std::optional<std::wstring> accessKey;
bool supportsNegative; bool supportsNegative;
bool isEnabled;
}; };
private private

390
src/CalculatorUnitTests/NavCategoryUnitTests.cpp
View file

@ -17,28 +17,138 @@ namespace CalculatorUnitTests
TEST_CLASS(NavCategoryUnitTests) TEST_CLASS(NavCategoryUnitTests)
{ {
public: public:
TEST_METHOD(Serialize);
TEST_METHOD(Deserialize_AllValid);
TEST_METHOD(Deserialize_AllInvalid);
TEST_METHOD(IsValidViewMode_AllValid);
TEST_METHOD(IsValidViewMode_AllInvalid);
TEST_METHOD(IsCalculatorViewMode); TEST_METHOD(IsCalculatorViewMode);
TEST_METHOD(IsDateCalculatorViewMode); TEST_METHOD(IsDateCalculatorViewMode);
TEST_METHOD(IsConverterViewMode); TEST_METHOD(IsConverterViewMode);
TEST_METHOD(GetFriendlyName);
TEST_METHOD(GetGroupType);
TEST_METHOD(GetIndex);
TEST_METHOD(GetPosition);
TEST_METHOD(GetIndex_GetPosition_Relationship);
TEST_METHOD(GetIndexInGroup);
TEST_METHOD(GetViewModeForVirtualKey);
}; };
void NavCategoryUnitTests::Serialize() void NavCategoryUnitTests::IsCalculatorViewMode()
{
VERIFY_IS_TRUE(NavCategory::IsCalculatorViewMode(ViewMode::Standard));
VERIFY_IS_TRUE(NavCategory::IsCalculatorViewMode(ViewMode::Scientific));
VERIFY_IS_TRUE(NavCategory::IsCalculatorViewMode(ViewMode::Programmer));
VERIFY_IS_FALSE(NavCategory::IsCalculatorViewMode(ViewMode::Date));
VERIFY_IS_FALSE(NavCategory::IsCalculatorViewMode(ViewMode::Graphing));
VERIFY_IS_FALSE(NavCategory::IsCalculatorViewMode(ViewMode::Currency));
VERIFY_IS_FALSE(NavCategory::IsCalculatorViewMode(ViewMode::Volume));
VERIFY_IS_FALSE(NavCategory::IsCalculatorViewMode(ViewMode::Length));
VERIFY_IS_FALSE(NavCategory::IsCalculatorViewMode(ViewMode::Weight));
VERIFY_IS_FALSE(NavCategory::IsCalculatorViewMode(ViewMode::Temperature));
VERIFY_IS_FALSE(NavCategory::IsCalculatorViewMode(ViewMode::Energy));
VERIFY_IS_FALSE(NavCategory::IsCalculatorViewMode(ViewMode::Area));
VERIFY_IS_FALSE(NavCategory::IsCalculatorViewMode(ViewMode::Speed));
VERIFY_IS_FALSE(NavCategory::IsCalculatorViewMode(ViewMode::Time));
VERIFY_IS_FALSE(NavCategory::IsCalculatorViewMode(ViewMode::Power));
VERIFY_IS_FALSE(NavCategory::IsCalculatorViewMode(ViewMode::Data));
VERIFY_IS_FALSE(NavCategory::IsCalculatorViewMode(ViewMode::Pressure));
VERIFY_IS_FALSE(NavCategory::IsCalculatorViewMode(ViewMode::Angle));
}
void NavCategoryUnitTests::IsDateCalculatorViewMode()
{
VERIFY_IS_FALSE(NavCategory::IsDateCalculatorViewMode(ViewMode::Standard));
VERIFY_IS_FALSE(NavCategory::IsDateCalculatorViewMode(ViewMode::Scientific));
VERIFY_IS_FALSE(NavCategory::IsDateCalculatorViewMode(ViewMode::Programmer));
VERIFY_IS_TRUE(NavCategory::IsDateCalculatorViewMode(ViewMode::Date));
VERIFY_IS_FALSE(NavCategory::IsDateCalculatorViewMode(ViewMode::Graphing));
VERIFY_IS_FALSE(NavCategory::IsDateCalculatorViewMode(ViewMode::Currency));
VERIFY_IS_FALSE(NavCategory::IsDateCalculatorViewMode(ViewMode::Volume));
VERIFY_IS_FALSE(NavCategory::IsDateCalculatorViewMode(ViewMode::Length));
VERIFY_IS_FALSE(NavCategory::IsDateCalculatorViewMode(ViewMode::Weight));
VERIFY_IS_FALSE(NavCategory::IsDateCalculatorViewMode(ViewMode::Temperature));
VERIFY_IS_FALSE(NavCategory::IsDateCalculatorViewMode(ViewMode::Energy));
VERIFY_IS_FALSE(NavCategory::IsDateCalculatorViewMode(ViewMode::Area));
VERIFY_IS_FALSE(NavCategory::IsDateCalculatorViewMode(ViewMode::Speed));
VERIFY_IS_FALSE(NavCategory::IsDateCalculatorViewMode(ViewMode::Time));
VERIFY_IS_FALSE(NavCategory::IsDateCalculatorViewMode(ViewMode::Power));
VERIFY_IS_FALSE(NavCategory::IsDateCalculatorViewMode(ViewMode::Data));
VERIFY_IS_FALSE(NavCategory::IsDateCalculatorViewMode(ViewMode::Pressure));
VERIFY_IS_FALSE(NavCategory::IsDateCalculatorViewMode(ViewMode::Angle));
}
void NavCategoryUnitTests::IsConverterViewMode()
{
VERIFY_IS_FALSE(NavCategory::IsConverterViewMode(ViewMode::Standard));
VERIFY_IS_FALSE(NavCategory::IsConverterViewMode(ViewMode::Scientific));
VERIFY_IS_FALSE(NavCategory::IsConverterViewMode(ViewMode::Programmer));
VERIFY_IS_FALSE(NavCategory::IsConverterViewMode(ViewMode::Date));
VERIFY_IS_FALSE(NavCategory::IsConverterViewMode(ViewMode::Graphing));
VERIFY_IS_TRUE(NavCategory::IsConverterViewMode(ViewMode::Currency));
VERIFY_IS_TRUE(NavCategory::IsConverterViewMode(ViewMode::Volume));
VERIFY_IS_TRUE(NavCategory::IsConverterViewMode(ViewMode::Length));
VERIFY_IS_TRUE(NavCategory::IsConverterViewMode(ViewMode::Weight));
VERIFY_IS_TRUE(NavCategory::IsConverterViewMode(ViewMode::Temperature));
VERIFY_IS_TRUE(NavCategory::IsConverterViewMode(ViewMode::Energy));
VERIFY_IS_TRUE(NavCategory::IsConverterViewMode(ViewMode::Area));
VERIFY_IS_TRUE(NavCategory::IsConverterViewMode(ViewMode::Speed));
VERIFY_IS_TRUE(NavCategory::IsConverterViewMode(ViewMode::Time));
VERIFY_IS_TRUE(NavCategory::IsConverterViewMode(ViewMode::Power));
VERIFY_IS_TRUE(NavCategory::IsConverterViewMode(ViewMode::Data));
VERIFY_IS_TRUE(NavCategory::IsConverterViewMode(ViewMode::Pressure));
VERIFY_IS_TRUE(NavCategory::IsConverterViewMode(ViewMode::Angle));
}
TEST_CLASS(NavCategoryGroupUnitTests)
{
public:
TEST_METHOD(CreateNavCategoryGroup)
{
IObservableVector<NavCategoryGroup ^> ^ menuOptions = NavCategoryStates::CreateMenuOptions();
VERIFY_ARE_EQUAL(2, menuOptions->Size);
NavCategoryGroup ^ calculatorGroup = menuOptions->GetAt(0);
VERIFY_ARE_EQUAL(CategoryGroupType::Calculator, calculatorGroup->GroupType);
IObservableVector<NavCategory ^> ^ calculatorCategories = calculatorGroup->Categories;
ValidateNavCategory(calculatorCategories, 0u, ViewMode::Standard);
ValidateNavCategory(calculatorCategories, 1u, ViewMode::Scientific);
ValidateNavCategory(calculatorCategories, 2u, ViewMode::Graphing);
ValidateNavCategory(calculatorCategories, 3u, ViewMode::Programmer);
ValidateNavCategory(calculatorCategories, 4u, ViewMode::Date);
VERIFY_ARE_EQUAL(5, calculatorCategories->Size);
NavCategoryGroup ^ converterGroup = menuOptions->GetAt(1);
VERIFY_ARE_EQUAL(CategoryGroupType::Converter, converterGroup->GroupType);
IObservableVector<NavCategory ^> ^ converterCategories = converterGroup->Categories;
VERIFY_ARE_EQUAL(13, converterCategories->Size);
ValidateNavCategory(converterCategories, 0u, ViewMode::Currency);
ValidateNavCategory(converterCategories, 1u, ViewMode::Volume);
ValidateNavCategory(converterCategories, 2u, ViewMode::Length);
ValidateNavCategory(converterCategories, 3u, ViewMode::Weight);
ValidateNavCategory(converterCategories, 4u, ViewMode::Temperature);
ValidateNavCategory(converterCategories, 5u, ViewMode::Energy);
ValidateNavCategory(converterCategories, 6u, ViewMode::Area);
ValidateNavCategory(converterCategories, 7u, ViewMode::Speed);
ValidateNavCategory(converterCategories, 8u, ViewMode::Time);
ValidateNavCategory(converterCategories, 9u, ViewMode::Power);
ValidateNavCategory(converterCategories, 10u, ViewMode::Data);
ValidateNavCategory(converterCategories, 11u, ViewMode::Pressure);
ValidateNavCategory(converterCategories, 12u, ViewMode::Angle);
}
private:
void ValidateNavCategory(IObservableVector<NavCategory ^> ^ categories, unsigned int index, ViewMode expectedMode)
{
VERIFY_IS_LESS_THAN(0u, categories->Size);
VERIFY_IS_GREATER_THAN(categories->Size, index);
NavCategory ^ category = categories->GetAt(index);
VERIFY_ARE_EQUAL(expectedMode, category->ViewMode);
VERIFY_ARE_EQUAL(category->IsEnabled, (expectedMode != ViewMode::Graphing) ? true : false);
}
};
TEST_CLASS(NavCategoryStatesUnitTests)
{
public:
TEST_METHOD(Serialize)
{ {
// While values in other tests may change (for example, the order // While values in other tests may change (for example, the order
// of a navigation item might change), these values should NEVER // of a navigation item might change), these values should NEVER
@ -65,7 +175,7 @@ namespace CalculatorUnitTests
VERIFY_ARE_EQUAL(-1, NavCategoryStates::Serialize(ViewMode::None)); VERIFY_ARE_EQUAL(-1, NavCategoryStates::Serialize(ViewMode::None));
} }
void NavCategoryUnitTests::Deserialize_AllValid() TEST_METHOD(Deserialize_AllValid)
{ {
// While values in other tests may change (for example, the order // While values in other tests may change (for example, the order
// of a navigation item might change), these values should NEVER // of a navigation item might change), these values should NEVER
@ -90,7 +200,7 @@ namespace CalculatorUnitTests
VERIFY_ARE_EQUAL(ViewMode::Angle, NavCategoryStates::Deserialize(ref new Box<int>(15))); VERIFY_ARE_EQUAL(ViewMode::Angle, NavCategoryStates::Deserialize(ref new Box<int>(15)));
} }
void NavCategoryUnitTests::Deserialize_AllInvalid() TEST_METHOD(Deserialize_AllInvalid)
{ {
VERIFY_ARE_EQUAL(ViewMode::None, NavCategoryStates::Deserialize(nullptr)); VERIFY_ARE_EQUAL(ViewMode::None, NavCategoryStates::Deserialize(nullptr));
VERIFY_ARE_EQUAL(ViewMode::None, NavCategoryStates::Deserialize(ref new String(L"fail"))); VERIFY_ARE_EQUAL(ViewMode::None, NavCategoryStates::Deserialize(ref new String(L"fail")));
@ -100,16 +210,13 @@ namespace CalculatorUnitTests
VERIFY_ARE_EQUAL(ViewMode::None, NavCategoryStates::Deserialize(ref new Box<int>(18))); VERIFY_ARE_EQUAL(ViewMode::None, NavCategoryStates::Deserialize(ref new Box<int>(18)));
} }
void NavCategoryUnitTests::IsValidViewMode_AllValid() TEST_METHOD(IsValidViewMode_AllValid)
{ {
VERIFY_IS_TRUE(NavCategoryStates::IsValidViewMode(ViewMode::Standard)); VERIFY_IS_TRUE(NavCategoryStates::IsValidViewMode(ViewMode::Standard));
VERIFY_IS_TRUE(NavCategoryStates::IsValidViewMode(ViewMode::Scientific)); VERIFY_IS_TRUE(NavCategoryStates::IsValidViewMode(ViewMode::Scientific));
VERIFY_IS_TRUE(NavCategoryStates::IsValidViewMode(ViewMode::Programmer)); VERIFY_IS_TRUE(NavCategoryStates::IsValidViewMode(ViewMode::Programmer));
VERIFY_IS_TRUE(NavCategoryStates::IsValidViewMode(ViewMode::Date)); VERIFY_IS_TRUE(NavCategoryStates::IsValidViewMode(ViewMode::Date));
if (Windows::Foundation::Metadata::ApiInformation::IsMethodPresent("Windows.UI.Text.RichEditTextDocument", "GetMath"))
{
VERIFY_IS_TRUE(NavCategoryStates::IsValidViewMode(ViewMode::Graphing)); VERIFY_IS_TRUE(NavCategoryStates::IsValidViewMode(ViewMode::Graphing));
}
VERIFY_IS_TRUE(NavCategoryStates::IsValidViewMode(ViewMode::Currency)); VERIFY_IS_TRUE(NavCategoryStates::IsValidViewMode(ViewMode::Currency));
VERIFY_IS_TRUE(NavCategoryStates::IsValidViewMode(ViewMode::Volume)); VERIFY_IS_TRUE(NavCategoryStates::IsValidViewMode(ViewMode::Volume));
VERIFY_IS_TRUE(NavCategoryStates::IsValidViewMode(ViewMode::Length)); VERIFY_IS_TRUE(NavCategoryStates::IsValidViewMode(ViewMode::Length));
@ -125,118 +232,24 @@ namespace CalculatorUnitTests
VERIFY_IS_TRUE(NavCategoryStates::IsValidViewMode(ViewMode::Angle)); VERIFY_IS_TRUE(NavCategoryStates::IsValidViewMode(ViewMode::Angle));
} }
void NavCategoryUnitTests::IsValidViewMode_AllInvalid() TEST_METHOD(IsValidViewMode_AllInvalid)
{ {
VERIFY_IS_FALSE(NavCategoryStates::IsValidViewMode(ViewMode::None)); VERIFY_IS_FALSE(NavCategoryStates::IsValidViewMode(ViewMode::None));
if (Windows::Foundation::Metadata::ApiInformation::IsMethodPresent("Windows.UI.Text.RichEditTextDocument", "GetMath"))
{
// There are 18 total options so int 18 should be the first invalid
VERIFY_IS_TRUE(NavCategoryStates::IsValidViewMode(static_cast<ViewMode>(17))); VERIFY_IS_TRUE(NavCategoryStates::IsValidViewMode(static_cast<ViewMode>(17)));
VERIFY_IS_FALSE(NavCategoryStates::IsValidViewMode(static_cast<ViewMode>(18))); VERIFY_IS_FALSE(NavCategoryStates::IsValidViewMode(static_cast<ViewMode>(18)));
}
else
{
// There are 17 total options when graphing calculator is not present, so int 17 should be the first invalid
VERIFY_IS_TRUE(NavCategoryStates::IsValidViewMode(static_cast<ViewMode>(16)));
VERIFY_IS_FALSE(NavCategoryStates::IsValidViewMode(static_cast<ViewMode>(17)));
}
// Also verify the lower bound // Also verify the lower bound
VERIFY_IS_TRUE(NavCategoryStates::IsValidViewMode(static_cast<ViewMode>(0))); VERIFY_IS_TRUE(NavCategoryStates::IsValidViewMode(static_cast<ViewMode>(0)));
VERIFY_IS_FALSE(NavCategoryStates::IsValidViewMode(static_cast<ViewMode>(-1))); VERIFY_IS_FALSE(NavCategoryStates::IsValidViewMode(static_cast<ViewMode>(-1)));
} }
void NavCategoryUnitTests::IsCalculatorViewMode() TEST_METHOD(GetFriendlyName)
{
VERIFY_IS_TRUE(NavCategory::IsCalculatorViewMode(ViewMode::Standard));
VERIFY_IS_TRUE(NavCategory::IsCalculatorViewMode(ViewMode::Scientific));
VERIFY_IS_TRUE(NavCategory::IsCalculatorViewMode(ViewMode::Programmer));
VERIFY_IS_FALSE(NavCategory::IsCalculatorViewMode(ViewMode::Date));
if (Windows::Foundation::Metadata::ApiInformation::IsMethodPresent("Windows.UI.Text.RichEditTextDocument", "GetMath"))
{
VERIFY_IS_FALSE(NavCategory::IsCalculatorViewMode(ViewMode::Graphing));
}
VERIFY_IS_FALSE(NavCategory::IsCalculatorViewMode(ViewMode::Currency));
VERIFY_IS_FALSE(NavCategory::IsCalculatorViewMode(ViewMode::Volume));
VERIFY_IS_FALSE(NavCategory::IsCalculatorViewMode(ViewMode::Length));
VERIFY_IS_FALSE(NavCategory::IsCalculatorViewMode(ViewMode::Weight));
VERIFY_IS_FALSE(NavCategory::IsCalculatorViewMode(ViewMode::Temperature));
VERIFY_IS_FALSE(NavCategory::IsCalculatorViewMode(ViewMode::Energy));
VERIFY_IS_FALSE(NavCategory::IsCalculatorViewMode(ViewMode::Area));
VERIFY_IS_FALSE(NavCategory::IsCalculatorViewMode(ViewMode::Speed));
VERIFY_IS_FALSE(NavCategory::IsCalculatorViewMode(ViewMode::Time));
VERIFY_IS_FALSE(NavCategory::IsCalculatorViewMode(ViewMode::Power));
VERIFY_IS_FALSE(NavCategory::IsCalculatorViewMode(ViewMode::Data));
VERIFY_IS_FALSE(NavCategory::IsCalculatorViewMode(ViewMode::Pressure));
VERIFY_IS_FALSE(NavCategory::IsCalculatorViewMode(ViewMode::Angle));
}
void NavCategoryUnitTests::IsDateCalculatorViewMode()
{
VERIFY_IS_FALSE(NavCategory::IsDateCalculatorViewMode(ViewMode::Standard));
VERIFY_IS_FALSE(NavCategory::IsDateCalculatorViewMode(ViewMode::Scientific));
VERIFY_IS_FALSE(NavCategory::IsDateCalculatorViewMode(ViewMode::Programmer));
VERIFY_IS_TRUE(NavCategory::IsDateCalculatorViewMode(ViewMode::Date));
if (Windows::Foundation::Metadata::ApiInformation::IsMethodPresent("Windows.UI.Text.RichEditTextDocument", "GetMath"))
{
VERIFY_IS_FALSE(NavCategory::IsDateCalculatorViewMode(ViewMode::Graphing));
}
VERIFY_IS_FALSE(NavCategory::IsDateCalculatorViewMode(ViewMode::Currency));
VERIFY_IS_FALSE(NavCategory::IsDateCalculatorViewMode(ViewMode::Volume));
VERIFY_IS_FALSE(NavCategory::IsDateCalculatorViewMode(ViewMode::Length));
VERIFY_IS_FALSE(NavCategory::IsDateCalculatorViewMode(ViewMode::Weight));
VERIFY_IS_FALSE(NavCategory::IsDateCalculatorViewMode(ViewMode::Temperature));
VERIFY_IS_FALSE(NavCategory::IsDateCalculatorViewMode(ViewMode::Energy));
VERIFY_IS_FALSE(NavCategory::IsDateCalculatorViewMode(ViewMode::Area));
VERIFY_IS_FALSE(NavCategory::IsDateCalculatorViewMode(ViewMode::Speed));
VERIFY_IS_FALSE(NavCategory::IsDateCalculatorViewMode(ViewMode::Time));
VERIFY_IS_FALSE(NavCategory::IsDateCalculatorViewMode(ViewMode::Power));
VERIFY_IS_FALSE(NavCategory::IsDateCalculatorViewMode(ViewMode::Data));
VERIFY_IS_FALSE(NavCategory::IsDateCalculatorViewMode(ViewMode::Pressure));
VERIFY_IS_FALSE(NavCategory::IsDateCalculatorViewMode(ViewMode::Angle));
}
void NavCategoryUnitTests::IsConverterViewMode()
{
VERIFY_IS_FALSE(NavCategory::IsConverterViewMode(ViewMode::Standard));
VERIFY_IS_FALSE(NavCategory::IsConverterViewMode(ViewMode::Scientific));
VERIFY_IS_FALSE(NavCategory::IsConverterViewMode(ViewMode::Programmer));
VERIFY_IS_FALSE(NavCategory::IsConverterViewMode(ViewMode::Date));
if (Windows::Foundation::Metadata::ApiInformation::IsMethodPresent("Windows.UI.Text.RichEditTextDocument", "GetMath"))
{
VERIFY_IS_FALSE(NavCategory::IsConverterViewMode(ViewMode::Graphing));
}
VERIFY_IS_TRUE(NavCategory::IsConverterViewMode(ViewMode::Currency));
VERIFY_IS_TRUE(NavCategory::IsConverterViewMode(ViewMode::Volume));
VERIFY_IS_TRUE(NavCategory::IsConverterViewMode(ViewMode::Length));
VERIFY_IS_TRUE(NavCategory::IsConverterViewMode(ViewMode::Weight));
VERIFY_IS_TRUE(NavCategory::IsConverterViewMode(ViewMode::Temperature));
VERIFY_IS_TRUE(NavCategory::IsConverterViewMode(ViewMode::Energy));
VERIFY_IS_TRUE(NavCategory::IsConverterViewMode(ViewMode::Area));
VERIFY_IS_TRUE(NavCategory::IsConverterViewMode(ViewMode::Speed));
VERIFY_IS_TRUE(NavCategory::IsConverterViewMode(ViewMode::Time));
VERIFY_IS_TRUE(NavCategory::IsConverterViewMode(ViewMode::Power));
VERIFY_IS_TRUE(NavCategory::IsConverterViewMode(ViewMode::Data));
VERIFY_IS_TRUE(NavCategory::IsConverterViewMode(ViewMode::Pressure));
VERIFY_IS_TRUE(NavCategory::IsConverterViewMode(ViewMode::Angle));
}
void NavCategoryUnitTests::GetFriendlyName()
{ {
VERIFY_ARE_EQUAL(StringReference(L"Standard"), NavCategoryStates::GetFriendlyName(ViewMode::Standard)); VERIFY_ARE_EQUAL(StringReference(L"Standard"), NavCategoryStates::GetFriendlyName(ViewMode::Standard));
VERIFY_ARE_EQUAL(StringReference(L"Scientific"), NavCategoryStates::GetFriendlyName(ViewMode::Scientific)); VERIFY_ARE_EQUAL(StringReference(L"Scientific"), NavCategoryStates::GetFriendlyName(ViewMode::Scientific));
VERIFY_ARE_EQUAL(StringReference(L"Programmer"), NavCategoryStates::GetFriendlyName(ViewMode::Programmer)); VERIFY_ARE_EQUAL(StringReference(L"Programmer"), NavCategoryStates::GetFriendlyName(ViewMode::Programmer));
VERIFY_ARE_EQUAL(StringReference(L"Date"), NavCategoryStates::GetFriendlyName(ViewMode::Date)); VERIFY_ARE_EQUAL(StringReference(L"Date"), NavCategoryStates::GetFriendlyName(ViewMode::Date));
if (Windows::Foundation::Metadata::ApiInformation::IsMethodPresent("Windows.UI.Text.RichEditTextDocument", "GetMath"))
{
VERIFY_ARE_EQUAL(StringReference(L"Graphing"), NavCategoryStates::GetFriendlyName(ViewMode::Graphing)); VERIFY_ARE_EQUAL(StringReference(L"Graphing"), NavCategoryStates::GetFriendlyName(ViewMode::Graphing));
}
VERIFY_ARE_EQUAL(StringReference(L"Currency"), NavCategoryStates::GetFriendlyName(ViewMode::Currency)); VERIFY_ARE_EQUAL(StringReference(L"Currency"), NavCategoryStates::GetFriendlyName(ViewMode::Currency));
VERIFY_ARE_EQUAL(StringReference(L"Volume"), NavCategoryStates::GetFriendlyName(ViewMode::Volume)); VERIFY_ARE_EQUAL(StringReference(L"Volume"), NavCategoryStates::GetFriendlyName(ViewMode::Volume));
VERIFY_ARE_EQUAL(StringReference(L"Length"), NavCategoryStates::GetFriendlyName(ViewMode::Length)); VERIFY_ARE_EQUAL(StringReference(L"Length"), NavCategoryStates::GetFriendlyName(ViewMode::Length));
@ -254,16 +267,13 @@ namespace CalculatorUnitTests
VERIFY_ARE_EQUAL(StringReference(L"None"), NavCategoryStates::GetFriendlyName(ViewMode::None)); VERIFY_ARE_EQUAL(StringReference(L"None"), NavCategoryStates::GetFriendlyName(ViewMode::None));
} }
void NavCategoryUnitTests::GetGroupType() TEST_METHOD(GetGroupType)
{ {
VERIFY_ARE_EQUAL(CategoryGroupType::Calculator, NavCategoryStates::GetGroupType(ViewMode::Standard)); VERIFY_ARE_EQUAL(CategoryGroupType::Calculator, NavCategoryStates::GetGroupType(ViewMode::Standard));
VERIFY_ARE_EQUAL(CategoryGroupType::Calculator, NavCategoryStates::GetGroupType(ViewMode::Scientific)); VERIFY_ARE_EQUAL(CategoryGroupType::Calculator, NavCategoryStates::GetGroupType(ViewMode::Scientific));
VERIFY_ARE_EQUAL(CategoryGroupType::Calculator, NavCategoryStates::GetGroupType(ViewMode::Programmer)); VERIFY_ARE_EQUAL(CategoryGroupType::Calculator, NavCategoryStates::GetGroupType(ViewMode::Programmer));
VERIFY_ARE_EQUAL(CategoryGroupType::Calculator, NavCategoryStates::GetGroupType(ViewMode::Date)); VERIFY_ARE_EQUAL(CategoryGroupType::Calculator, NavCategoryStates::GetGroupType(ViewMode::Date));
if (Windows::Foundation::Metadata::ApiInformation::IsMethodPresent("Windows.UI.Text.RichEditTextDocument", "GetMath"))
{
VERIFY_ARE_EQUAL(CategoryGroupType::Calculator, NavCategoryStates::GetGroupType(ViewMode::Graphing)); VERIFY_ARE_EQUAL(CategoryGroupType::Calculator, NavCategoryStates::GetGroupType(ViewMode::Graphing));
}
VERIFY_ARE_EQUAL(CategoryGroupType::Converter, NavCategoryStates::GetGroupType(ViewMode::Currency)); VERIFY_ARE_EQUAL(CategoryGroupType::Converter, NavCategoryStates::GetGroupType(ViewMode::Currency));
VERIFY_ARE_EQUAL(CategoryGroupType::Converter, NavCategoryStates::GetGroupType(ViewMode::Volume)); VERIFY_ARE_EQUAL(CategoryGroupType::Converter, NavCategoryStates::GetGroupType(ViewMode::Volume));
@ -280,63 +290,33 @@ namespace CalculatorUnitTests
VERIFY_ARE_EQUAL(CategoryGroupType::Converter, NavCategoryStates::GetGroupType(ViewMode::Angle)); VERIFY_ARE_EQUAL(CategoryGroupType::Converter, NavCategoryStates::GetGroupType(ViewMode::Angle));
} }
void NavCategoryUnitTests::GetIndex() TEST_METHOD(GetIndex)
{ {
// Index is the 0-based ordering of modes // Index is the 0-based ordering of modes
vector<ViewMode> orderedModes; const auto orderedModesSize = _orderedModes.size();
if (Windows::Foundation::Metadata::ApiInformation::IsMethodPresent("Windows.UI.Text.RichEditTextDocument", "GetMath"))
{
orderedModes = { ViewMode::Standard, ViewMode::Scientific, ViewMode::Graphing, ViewMode::Programmer, ViewMode::Date, 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 };
}
else
{
orderedModes = { ViewMode::Standard, ViewMode::Scientific, ViewMode::Programmer, ViewMode::Date, 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 index = 0; index < orderedModesSize; index++) for (size_t index = 0; index < orderedModesSize; index++)
{ {
ViewMode mode = orderedModes[index]; ViewMode mode = _orderedModes[index];
VERIFY_ARE_EQUAL(index, (size_t)NavCategoryStates::GetIndex(mode)); VERIFY_ARE_EQUAL(index, (size_t)NavCategoryStates::GetIndex(mode));
} }
VERIFY_ARE_EQUAL(-1, NavCategoryStates::GetIndex(ViewMode::None)); VERIFY_ARE_EQUAL(-1, NavCategoryStates::GetIndex(ViewMode::None));
} }
void NavCategoryUnitTests::GetPosition() TEST_METHOD(GetPosition)
{ {
// Position is the 1-based ordering of modes // Position is the 1-based ordering of modes
vector<ViewMode> orderedModes; const auto orderedModesSize = _orderedModes.size();
if (Windows::Foundation::Metadata::ApiInformation::IsMethodPresent("Windows.UI.Text.RichEditTextDocument", "GetMath"))
{
orderedModes = { ViewMode::Standard, ViewMode::Scientific, ViewMode::Graphing, ViewMode::Programmer, ViewMode::Date, 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 };
}
else
{
orderedModes = { ViewMode::Standard, ViewMode::Scientific, ViewMode::Programmer, ViewMode::Date, 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++) for (size_t pos = 1; pos <= orderedModesSize; pos++)
{ {
ViewMode mode = orderedModes[pos - 1]; ViewMode mode = _orderedModes[pos - 1];
VERIFY_ARE_EQUAL(pos, (size_t)NavCategoryStates::GetPosition(mode)); VERIFY_ARE_EQUAL(pos, (size_t)NavCategoryStates::GetPosition(mode));
} }
VERIFY_ARE_EQUAL(-1, NavCategoryStates::GetPosition(ViewMode::None)); VERIFY_ARE_EQUAL(-1, NavCategoryStates::GetPosition(ViewMode::None));
} }
void NavCategoryUnitTests::GetIndex_GetPosition_Relationship() TEST_METHOD(GetIndex_GetPosition_Relationship)
{ {
// Index should be 1 less than Position. // Index should be 1 less than Position.
// The other checks verify the order of Index and Position. // The other checks verify the order of Index and Position.
@ -345,21 +325,13 @@ namespace CalculatorUnitTests
VERIFY_ARE_EQUAL(NavCategoryStates::GetPosition(ViewMode::Volume) - 1, NavCategoryStates::GetIndex(ViewMode::Volume)); VERIFY_ARE_EQUAL(NavCategoryStates::GetPosition(ViewMode::Volume) - 1, NavCategoryStates::GetIndex(ViewMode::Volume));
} }
void NavCategoryUnitTests::GetIndexInGroup() TEST_METHOD(GetIndexInGroup)
{ {
VERIFY_ARE_EQUAL(0, NavCategoryStates::GetIndexInGroup(ViewMode::Standard, CategoryGroupType::Calculator)); VERIFY_ARE_EQUAL(0, NavCategoryStates::GetIndexInGroup(ViewMode::Standard, CategoryGroupType::Calculator));
VERIFY_ARE_EQUAL(1, NavCategoryStates::GetIndexInGroup(ViewMode::Scientific, CategoryGroupType::Calculator)); VERIFY_ARE_EQUAL(1, NavCategoryStates::GetIndexInGroup(ViewMode::Scientific, CategoryGroupType::Calculator));
if (Windows::Foundation::Metadata::ApiInformation::IsMethodPresent("Windows.UI.Text.RichEditTextDocument", "GetMath"))
{
VERIFY_ARE_EQUAL(2, NavCategoryStates::GetIndexInGroup(ViewMode::Graphing, CategoryGroupType::Calculator)); VERIFY_ARE_EQUAL(2, NavCategoryStates::GetIndexInGroup(ViewMode::Graphing, CategoryGroupType::Calculator));
VERIFY_ARE_EQUAL(3, NavCategoryStates::GetIndexInGroup(ViewMode::Programmer, CategoryGroupType::Calculator)); VERIFY_ARE_EQUAL(3, NavCategoryStates::GetIndexInGroup(ViewMode::Programmer, CategoryGroupType::Calculator));
VERIFY_ARE_EQUAL(4, NavCategoryStates::GetIndexInGroup(ViewMode::Date, CategoryGroupType::Calculator)); VERIFY_ARE_EQUAL(4, NavCategoryStates::GetIndexInGroup(ViewMode::Date, CategoryGroupType::Calculator));
}
else
{
VERIFY_ARE_EQUAL(2, NavCategoryStates::GetIndexInGroup(ViewMode::Programmer, CategoryGroupType::Calculator));
VERIFY_ARE_EQUAL(3, NavCategoryStates::GetIndexInGroup(ViewMode::Date, CategoryGroupType::Calculator));
}
VERIFY_ARE_EQUAL(0, NavCategoryStates::GetIndexInGroup(ViewMode::Currency, CategoryGroupType::Converter)); VERIFY_ARE_EQUAL(0, NavCategoryStates::GetIndexInGroup(ViewMode::Currency, CategoryGroupType::Converter));
VERIFY_ARE_EQUAL(1, NavCategoryStates::GetIndexInGroup(ViewMode::Volume, CategoryGroupType::Converter)); VERIFY_ARE_EQUAL(1, NavCategoryStates::GetIndexInGroup(ViewMode::Volume, CategoryGroupType::Converter));
VERIFY_ARE_EQUAL(2, NavCategoryStates::GetIndexInGroup(ViewMode::Length, CategoryGroupType::Converter)); VERIFY_ARE_EQUAL(2, NavCategoryStates::GetIndexInGroup(ViewMode::Length, CategoryGroupType::Converter));
@ -378,82 +350,30 @@ namespace CalculatorUnitTests
VERIFY_ARE_EQUAL(-1, NavCategoryStates::GetIndexInGroup(ViewMode::None, CategoryGroupType::Converter)); VERIFY_ARE_EQUAL(-1, NavCategoryStates::GetIndexInGroup(ViewMode::None, CategoryGroupType::Converter));
} }
void NavCategoryUnitTests::GetViewModeForVirtualKey() TEST_METHOD(GetViewModeForVirtualKey)
{ {
VERIFY_ARE_EQUAL(ViewMode::Standard, NavCategoryStates::GetViewModeForVirtualKey(MyVirtualKey::Number1)); VERIFY_ARE_EQUAL(ViewMode::Standard, NavCategoryStates::GetViewModeForVirtualKey(MyVirtualKey::Number1));
VERIFY_ARE_EQUAL(ViewMode::Scientific, NavCategoryStates::GetViewModeForVirtualKey(MyVirtualKey::Number2)); VERIFY_ARE_EQUAL(ViewMode::Scientific, NavCategoryStates::GetViewModeForVirtualKey(MyVirtualKey::Number2));
if (Windows::Foundation::Metadata::ApiInformation::IsMethodPresent("Windows.UI.Text.RichEditTextDocument", "GetMath"))
{
VERIFY_ARE_EQUAL(ViewMode::Graphing, NavCategoryStates::GetViewModeForVirtualKey(MyVirtualKey::Number3)); VERIFY_ARE_EQUAL(ViewMode::Graphing, NavCategoryStates::GetViewModeForVirtualKey(MyVirtualKey::Number3));
VERIFY_ARE_EQUAL(ViewMode::Programmer, NavCategoryStates::GetViewModeForVirtualKey(MyVirtualKey::Number4)); VERIFY_ARE_EQUAL(ViewMode::Programmer, NavCategoryStates::GetViewModeForVirtualKey(MyVirtualKey::Number4));
VERIFY_ARE_EQUAL(ViewMode::Date, NavCategoryStates::GetViewModeForVirtualKey(MyVirtualKey::Number5)); VERIFY_ARE_EQUAL(ViewMode::Date, NavCategoryStates::GetViewModeForVirtualKey(MyVirtualKey::Number5));
} }
else
{
VERIFY_ARE_EQUAL(ViewMode::Programmer, NavCategoryStates::GetViewModeForVirtualKey(MyVirtualKey::Number3));
VERIFY_ARE_EQUAL(ViewMode::Date, NavCategoryStates::GetViewModeForVirtualKey(MyVirtualKey::Number4));
}
}
TEST_CLASS(NavCategoryGroupUnitTests) TEST_METHOD(IsViewModeEnabled_ShouldBeTrue_ExceptGraphingMode)
{ {
public: for (const auto& mode : _orderedModes)
TEST_METHOD(CreateNavCategoryGroup); {
if (mode != ViewMode::Graphing)
{
VERIFY_IS_TRUE(NavCategoryStates::IsViewModeEnabled(mode));
}
}
}
private: private:
void ValidateNavCategory(IObservableVector<NavCategory ^> ^ categories, unsigned int index, ViewMode expectedMode) const static inline std::vector<ViewMode> _orderedModes {
{ ViewMode::Standard, ViewMode::Scientific, ViewMode::Graphing, ViewMode::Programmer, ViewMode::Date, ViewMode::Currency,
VERIFY_IS_LESS_THAN(0u, categories->Size); ViewMode::Volume, ViewMode::Length, ViewMode::Weight, ViewMode::Temperature, ViewMode::Energy, ViewMode::Area,
VERIFY_IS_GREATER_THAN(categories->Size, index); ViewMode::Speed, ViewMode::Time, ViewMode::Power, ViewMode::Data, ViewMode::Pressure, ViewMode::Angle };
NavCategory ^ category = categories->GetAt(index);
VERIFY_ARE_EQUAL(expectedMode, category->ViewMode);
}
}; };
void NavCategoryGroupUnitTests::CreateNavCategoryGroup()
{
IObservableVector<NavCategoryGroup ^> ^ menuOptions = NavCategoryStates::CreateMenuOptions();
VERIFY_ARE_EQUAL(2, menuOptions->Size);
NavCategoryGroup ^ calculatorGroup = menuOptions->GetAt(0);
VERIFY_ARE_EQUAL(CategoryGroupType::Calculator, calculatorGroup->GroupType);
IObservableVector<NavCategory ^> ^ calculatorCategories = calculatorGroup->Categories;
ValidateNavCategory(calculatorCategories, 0u, ViewMode::Standard);
ValidateNavCategory(calculatorCategories, 1u, ViewMode::Scientific);
if (Windows::Foundation::Metadata::ApiInformation::IsMethodPresent("Windows.UI.Text.RichEditTextDocument", "GetMath"))
{
ValidateNavCategory(calculatorCategories, 2u, ViewMode::Graphing);
ValidateNavCategory(calculatorCategories, 3u, ViewMode::Programmer);
ValidateNavCategory(calculatorCategories, 4u, ViewMode::Date);
VERIFY_ARE_EQUAL(5, calculatorCategories->Size);
}
else
{
ValidateNavCategory(calculatorCategories, 2u, ViewMode::Programmer);
ValidateNavCategory(calculatorCategories, 3u, ViewMode::Date);
VERIFY_ARE_EQUAL(4, calculatorCategories->Size);
}
NavCategoryGroup ^ converterGroup = menuOptions->GetAt(1);
VERIFY_ARE_EQUAL(CategoryGroupType::Converter, converterGroup->GroupType);
IObservableVector<NavCategory ^> ^ converterCategories = converterGroup->Categories;
VERIFY_ARE_EQUAL(13, converterCategories->Size);
ValidateNavCategory(converterCategories, 0u, ViewMode::Currency);
ValidateNavCategory(converterCategories, 1u, ViewMode::Volume);
ValidateNavCategory(converterCategories, 2u, ViewMode::Length);
ValidateNavCategory(converterCategories, 3u, ViewMode::Weight);
ValidateNavCategory(converterCategories, 4u, ViewMode::Temperature);
ValidateNavCategory(converterCategories, 5u, ViewMode::Energy);
ValidateNavCategory(converterCategories, 6u, ViewMode::Area);
ValidateNavCategory(converterCategories, 7u, ViewMode::Speed);
ValidateNavCategory(converterCategories, 8u, ViewMode::Time);
ValidateNavCategory(converterCategories, 9u, ViewMode::Power);
ValidateNavCategory(converterCategories, 10u, ViewMode::Data);
ValidateNavCategory(converterCategories, 11u, ViewMode::Pressure);
ValidateNavCategory(converterCategories, 12u, ViewMode::Angle);
}
} }