Hello GitHub

docs/ApplicationArchitecture.md

@@ -0,0 +1,188 @@
+# Application Architecture
+
+Windows Calculator is a [C++/CX][C++/CX] application, built for the Universal Windows Platform ([UWP][What is UWP?]).
+Calculator uses the [XAML][XAML Overview] UI framework, and the project follows the Model-View-ViewModel ([MVVM][MVVM])
+design pattern. This document discusses each of the layers and how they are related to the three Visual Studio projects
+that build into the final Calculator application.
+
+--------------------
+## Table of Contents
+
+* [View](#view)
+    * [VisualStates](#visualstates)
+    * [Data-Binding](#data-binding)
+* [ViewModel](#viewmodel)
+    * [PropertyChanged Events](#propertychanged-events)
+* [Model](#model)
+
+--------------------
+
+## View
+
+The View layer is contained in the [Calculator project][Calculator folder]. This project contains mostly XAML files
+and various custom controls that support the UI. [App.xaml][App.xaml] contains many of the [static][StaticResource] and
+[theme][ThemeResource] resources that the other XAML files will reference. Its code-behind file, [App.xaml.cpp][App.xaml.cpp],
+contains the main entry point to the application. On startup, it navigates to the main page.
+
+```C++
+rootFrame->Navigate(MainPage::typeid, argument)
+```
+
+In Calculator, there is only one concrete [Page][Page] class: [MainPage.xaml][MainPage.xaml]. `MainPage` is the root
+container for all the other application UI elements.  As you can see, there's not much content. `MainPage` uses a
+`NavigationView` control to display the toggleable navigation menu, and empty containers for delay-loaded UI elements.
+Of the many modes that Calculator shows in its menu, there are actually only three XAML files that `MainPage` needs to
+manage in order to support all modes. They are:
+
+* [Calculator.xaml][Calculator.xaml]: This [UserControl] is itself a container for the [Standard][CalculatorStandardOperators.xaml],
+  [Scientific][CalculatorScientificOperators.xaml], and [Programmer][CalculatorProgrammerOperators.xaml] modes.
+* [DateCalculator.xaml][DateCalculator.xaml]: Everything needed for the DateCalculator mode.
+* [UnitConverter.xaml][UnitConverter.xaml]: One `UserControl` to support every Converter mode.
+
+### VisualStates
+
+[VisualStates][VisualState] are used to change the size, position, and appearance ([Style][Style]) of UI elements
+in order to create an adaptive, responsive UI. A transition to a new `VisualState` is often triggered by specific
+window sizes. Here are a few important examples of `VisualStates` in Calculator. Note that it is not a
+complete list. When making UI changes, make sure you are considering the various `VisualStates` and layouts that
+Calculator defines.
+
+#### History/Memory Dock Panel expansion
+
+In the Standard, Scientific, and Programmer modes, the History/Memory panel is exposed as a flyout in small window sizes.
+Once the window is resized to have enough space, the panel becomes docked along the edge of the window.
+
+<img src="Images\VisualStates\Standard1.gif" height="400" />
+
+#### Scientific mode, inverse function button presence
+
+In the Scientific mode, for small window sizes there is not enough room to show all the function buttons. The mode
+hides some of the buttons and provides a Shift (↑) button to toggle the visibility of the collapsed rows. When the
+window size is large enough, the buttons are re-arranged to display all function buttons at the same time.
+
+<img src="Images\VisualStates\Scientific1.gif" height="400" />
+
+#### Unit Converter aspect ratio adjustment
+
+In the Unit Converter mode, the converter inputs and the numberpad will re-arrange depending on if the window is in
+a Portrait or Landscape aspect ratio.
+
+<img src="Images\VisualStates\Converter1.gif" height="400" />
+
+### Data-Binding
+
+Calculator uses [data binding][Data Binding] to dynamically update the properties of UI elements. If this concept
+is new for you, it's also worth reading about [data binding in depth][Data binding in depth].
+
+The [x:Bind][x:Bind] markup extension is a newer replacement for the older [Binding][Binding] style. You may see both
+styles in the Calculator codebase. Prefer `x:Bind` in new contributions because it has better performance. If you need
+to add or modify an existing `Binding`, updating to `x:Bind` is a great first step. Make sure to read and understand
+the difference between the two styles, as there are some subtle behavioral changes. Refer to the
+[binding feature comparison][BindingComparison] to learn more.
+
+------------
+## ViewModel
+
+The ViewModel layer is contained in the [CalcViewModel][CalcViewModel folder] project. ViewModels provide a source of
+data for the UI to bind against and act as the intermediary separating pure business logic from UI components that
+should not care about the model's implementation. Just as the View layer consists of a hierarchy of XAML files, the
+ViewModel consists of a hierarchy of ViewModel files. The relationship between XAML and ViewModel files is often 1:1.
+Here are the noteable ViewModel files to start exploring with:
+
+* [ApplicationViewModel.h][ApplicationViewModel.h]: The ViewModel for [MainPage.xaml][MainPage.xaml]. This ViewModel
+  is the root of the other mode-specific ViewModels. The application changes between modes by updating the `Mode` property
+  of the `ApplicationViewModel`. The ViewModel will make sure the appropriate ViewModel for the new mode is initialized.
+* [StandardCalculatorViewModel.h][StandardCalculatorViewModel.h]: The ViewModel for [Calculator.xaml][Calculator.xaml].
+  This ViewModel exposes functionality for the main three Calculator modes: Standard, Scientific, and Programmer.
+* [DateCalculatorViewModel.h][DateCalculatorViewModel.h]: The ViewModel for [DateCalculator.xaml][DateCalculator.xaml].
+* [UnitConverterViewModel.h][UnitConverterViewModel.h]: The ViewModel for [UnitConverter.xaml][UnitConverter.xaml].
+  This ViewModel implements the logic to support every converter mode, including Currency Converter.
+
+### PropertyChanged Events
+
+In order for [data binding](#data-binding) to work, ViewModels need a way to inform the XAML framework about
+updates to their member properties. Most ViewModels in the project do so by implementing the
+[INotifyPropertyChanged][INotifyPropertyChanged] interface. The interface requires that the class provides a
+[PropertyChanged event][PropertyChanged]. Clients of the ViewModel (such as the UI), can register for the
+`PropertyChanged` event from the ViewModel, then re-evaluate bindings or handle the event in code-behind when the
+ViewModel decides to raise the event. ViewModels in the Calculator codebase generally uses a macro, defined in the
+[Utils.h][Utils.h] utility file, to implement the `INotifyPropertyChanged` interface. Here is a standard
+implementation, taken from [ApplicationViewModel.h][ApplicationViewModel.h].
+
+```C++
+[Windows::UI::Xaml::Data::Bindable]
+public ref class ApplicationViewModel sealed : public Windows::UI::Xaml::Data::INotifyPropertyChanged
+{
+public:
+    ApplicationViewModel();
+
+    OBSERVABLE_OBJECT();
+```
+
+The `OBSERVABLE_OBJECT()` macro defines the required `PropertyChanged` event. It also defines a private
+`RaisePropertyChanged` helper function for the class. The function takes a property name and raises a
+`PropertyChanged` event for that property.
+
+Properties that are intended to be the source for a data binding are also typically implemented with a macro. Here is
+one such property from `ApplicationViewModel`:
+
+```C++
+OBSERVABLE_PROPERTY_RW(Platform::String^, CategoryName);
+```
+
+The `OBSERVABLE_PROPERTY_RW` macro defines a Read/Write property that will raise a `PropertyChanged` event if its value
+changes. Read/Write means the property exposes both a public getter and setter. For efficiency and to avoid raising
+unnecessary `PropertyChanged` events, the setter for these types of properties will check if the new value is
+different from the previous value before raising the event.
+
+From this example, either `ApplicationViewModel` or clients of the class can simply assign to the `CategoryName`
+property and a `PropertyChanged` event will be raised, allowing the UI to respond to the new `CategoryName` value.
+
+--------
+## Model
+
+The Model for the Calculator modes is contained in the [CalcManager][CalcManager folder] project.
+<!-- TODO joshuako: Add the docs -->
+
+[References]:####################################################################################################
+
+[C++/CX]:                             https://docs.microsoft.com/en-us/cpp/cppcx/visual-c-language-reference-c-cx
+[What is UWP?]:                       https://docs.microsoft.com/en-us/windows/uwp/get-started/universal-application-platform-guide
+[XAML Overview]:                      https://docs.microsoft.com/en-us/windows/uwp/xaml-platform/xaml-overview
+[MVVM]:                               https://docs.microsoft.com/en-us/windows/uwp/data-binding/data-binding-and-mvvm
+
+[Calculator folder]:                  ..\src\Calculator
+[App.xaml]:                           ..\src\Calculator\App.xaml
+[App.xaml.cpp]:                       ..\src\Calculator\App.xaml.cpp
+[StaticResource]:                     https://docs.microsoft.com/en-us/windows/uwp/xaml-platform/staticresource-markup-extension
+[ThemeResource]:                      https://docs.microsoft.com/en-us/windows/uwp/xaml-platform/themeresource-markup-extension
+[Page]:                               https://docs.microsoft.com/en-us/uwp/api/Windows.UI.Xaml.Controls.Page
+[UserControl]:                        https://docs.microsoft.com/en-us/uwp/api/Windows.UI.Xaml.Controls.UserControl
+[MainPage.xaml]:                      ..\src\Calculator\Views\MainPage.xaml
+[Calculator.xaml]:                    ..\src\Calculator\Views\Calculator.xaml
+[CalculatorStandardOperators.xaml]:   ..\src\Calculator\Views\CalculatorStandardOperators.xaml
+[CalculatorScientificOperators.xaml]: ..\src\Calculator\Views\CalculatorScientificOperators.xaml
+[CalculatorProgrammerOperators.xaml]: ..\src\Calculator\Views\CalculatorProgrammerOperators.xaml
+[DateCalculator.xaml]:                ..\src\Calculator\Views\DateCalculator.xaml
+[UnitConverter.xaml]:                 ..\src\Calculator\Views\UnitConverter.xaml
+
+[VisualState]:                        https://docs.microsoft.com/en-us/windows/uwp/design/layout/layouts-with-xaml#adaptive-layouts-with-visual-states-and-state-triggers
+[Style]:                              https://docs.microsoft.com/en-us/windows/uwp/design/controls-and-patterns/xaml-styles
+
+[Data Binding]:                       https://docs.microsoft.com/en-us/windows/uwp/data-binding/data-binding-quickstart
+[Data binding in depth]:              https://docs.microsoft.com/en-us/windows/uwp/data-binding/data-binding-in-depth
+[x:Bind]:                             https://docs.microsoft.com/en-us/windows/uwp/xaml-platform/x-bind-markup-extension
+[Binding]:                            https://docs.microsoft.com/en-us/windows/uwp/xaml-platform/binding-markup-extension
+[BindingComparison]:                  https://docs.microsoft.com/en-us/windows/uwp/data-binding/data-binding-in-depth#xbind-and-binding-feature-comparison
+
+[CalcViewModel folder]:               ..\src\CalcViewModel
+[ApplicationViewModel.h]:             ..\src\CalcViewModel\ApplicationViewModel.h
+[StandardCalculatorViewModel.h]:      ..\src\CalcViewModel\StandardCalculatorViewModel.h
+[DateCalculatorViewModel.h]:          ..\src\CalcViewModel\DateCalculatorViewModel.h
+[UnitConverterViewModel.h]:           ..\src\CalcViewModel\UnitConverterViewModel.h
+
+[INotifyPropertyChanged]:             https://docs.microsoft.com/en-us/uwp/api/windows.ui.xaml.data.inotifypropertychanged
+[PropertyChanged]:                    https://docs.microsoft.com/en-us/uwp/api/windows.ui.xaml.data.inotifypropertychanged.propertychanged
+[Utils.h]:                            ..\src\CalcViewModel\Common\Utils.h
+
+[CalcManager folder]:                 ..\src\CalcManager

docs/ManualTests.md

@@ -0,0 +1,353 @@
+# Calculator Manual Tests
+These manual tests are run before every release of the Calculator app.
+
+## Smoke Tests
+
+### Calculators
+
+### Math in Standard Calculator 
+
+**Test 1**
+Steps:
+1. From the Standard Calculator page, input “3”, “+”, “3”, “Enter” on the keyboard 
+Expected: “6” shows up in the display 
+2. Input “4”, “-“, “2”, “=” using the in-app buttons 
+*Expected: “2” shows up in the display*
+ 
+ **Test 2**
+ Steps:
+1. From the Standard Calculator page, input “3”, “+”, “3”, “Enter” on the keyboard 
+2. Navigate to the History pane, and verify that “3 + 3 = 6” shows up in the pane 
+3. Input “MS” using the in-app buttons 
+4. Navigate to the Memory pane
+*Expected: “6” shows up in the pane*
+
+### Math in Scientific Calculator
+
+**Test 1**
+Steps: 
+1. From the Scientific Calculator page, input “3”, “^”, “3”, “Enter” on the keyboard 
+*Expected: “27” shows up in the display*
+
+**Test 2**
+Steps:
+1. Input “5”, “n!“, “=” using the in-app buttons 
+*Expected: “120” shows up in the display*
+
+### Math in Programmer Calculator 
+
+**Test 1**
+Steps:
+1. From the Programmer Calculator page, input “1”, “&”, “0”, “Enter” on the keyboard 
+*Expected: “0” shows up in the display*
+
+**Test 2**
+Steps:
+1. Input “15” using the in-app buttons and select “HEX” 
+*Expected: “F” shows up in the display and the letters A-F show up as in-app buttons*
+
+### Converters 
+
+**Converter Usage**
+Steps:
+1. From the Length Converter page, select “kilometers” as the unit type in the input field and input “5” using the keyboard 
+2. Select “miles” as the unit type in the output field 
+*Expected: The output starts with is “3.106856”*
+
+
+## Basic Verification Tests
+
+**Launch App Test**
+Steps:
+1.	Press the Windows key.
+2.	Navigate to "all apps".
+3.	Look for "Calculator".
+4.	Click to launch the "Calculator" app.
+*Expected: The calculator app launches gracefully.*
+
+
+**All Calculators Test: Verify All Numbers & Input Methods**
+Steps:
+1.	Launch the "Calculator" app.
+2.	Navigate to "Standard" Calculator.
+3.	Mouse Input
+*Expected: All numbers work via mouse click.*
+4.	Keyboard Input:
+*Expected: All numbers work via number pad.*
+5.	Navigate to "Scientific" Calculator and Repeat Steps 3-5
+*Expected: Steps 3-5 pass in Scientific mode*
+6.	Navigate to "Programmer" Calculator and Repeat Steps 3-5
+*Expected: Steps 3-5 pass in Programmer mode*
+
+
+**All Calculators Test: Verify Basic Arithmetic Functions**
+Steps:
+1.	Launch the "Calculator" app.
+2.	Navigate to "Standard" Calculator.
+3.	Using the Number Pad and Mouse perform the following arithmetic functions and verify the result.
+    a.	(+) Addition
+    b.	(-) Subtraction
+    c.	(x) Multiplication
+    d.	(÷) Division
+    e.	(1/x) Reciprocal
+    f.	(√) Square Root
+    g.	(x²) Squared
+    h.	(x³) Cubed
+    i.	(%) Percent
+    j.	(±) Positive / Negative
+    k.	(=) Equals
+    l.	Delete Button (flag with x in it)
+    m.	[CE] Clear
+    n.	[C] Global Clear
+    o.	(.) Decimal
+4.	Navigate to "Scientific" Calculator and Repeat Steps 3-19.
+5.	Navigate to "Programmer" Calculator and Repeat Steps 3-18 (No Decimal in Programming Calc).
+
+
+**Scientific Calculator Test: Verify advanced arithmetic functions**
+Steps:
+1.	Launch the "Calculator" app.
+2.	Navigate to "Scientific" Calculator.
+3.	Using the Number Pad and Mouse perform the following arithmetic functions and verify the result.
+    a.	(xʸ) Xth Power of Y
+    b.	(y√x) Y Root of X
+    c.	(10ˣ) 10 Power of X
+    d.	(ex) E Power of X
+    e.	(π) Pi
+    f.	(n!) Factorial
+    g.	(Ln) Natural Logarithm
+    h.	(Log) Logarithm
+    i.	(Exp) Exponential
+    j.	(dms) Degrees, Minutes, Seconds
+    k.	(deg) Degrees
+    l.	(Mod) Modulo
+    m.	“( )" Parenthesis
+
+
+**All Calulators Test: Verify memory functions**
+Steps:
+1.	Launch the "Calculator" app.
+2.	Navigate to "Standard" Calculator.
+3.	Perform a calculation and press the MS button.
+4.	If small scale, Select the (M) with the drop down arrow
+*Expected: Calculation from previous step is present.*
+5.	Click the (M+) Add to Memory.
+*Expected: Previous calculation is added to itself.*
+6.	Click the (M-) Subtract from Memory.
+*Expected: Previous calculation is subtracted from the base calculation.*
+7.	Click the (MR) Memory Recall.
+*Expected: Previous calculation is made primary (This is not available in the Programmer mode).*
+8.	Check the MC button.
+*Expected: The stored information is cleared.*
+9.	Navigate to "Scientific" Calculator and Repeat Steps 3-8.
+*Expected: All in "Scientific" mode.*
+10.	Navigate to "Programmer" Calculator and Repeat Steps 3-8.
+*Expected: All in "Programmer" mode.*
+
+
+**Scientific Calculator Test: Verify trigonometric functions**
+Steps:
+1.	Launch the "Calculator" app.
+2.	Navigate to "Scientific" Calculator.
+3.  Using the Number Pad and Mouse perform the following trigonometric functions and verify the result.
+3.	Sine (sin)
+4.	Cosine (cos)
+5.	Tangent (tan)
+6.	Inverse Sine (sin-1)
+7.	Inverse Cosine (cos-1)
+8.	Inverse Tangent (tan-1) Inverse Tangent:
+9.	Press (HYP) for Hyperbolic trig functions: 
+*Expected: Trig function buttons show hyperbolic trig functions.*
+10.	Hyperbolic Sine (sinh)
+11.	Hyperbolic Tangent (tanh) 
+12.	Hyperbolic Cosine (cosh) 
+13.	Inverse Hyperbolic Sine (sinh-1) 
+14.	Inverse Hyperbolic Tangent (tanh-1) 
+15.	Inverse Hyperbolic Cosine (cosh-1) 
+
+
+**Programmer Calculator Test: Verify logical functions**
+Steps:
+1.	Launch the "Calculator" app
+2.	Navigate to "Programmer" Calculator.
+3.  Using the Number Pad and Mouse perform the following trigonometric functions and verify the result.
+4.	Rotate Left (RoL) Logical Operator:
+    01011001 rol 3 = 11001010.
+5.	Rotate Right (RoR) Logical Operator:
+    01011001 RoR 3 = 00101011.
+6.	(Lsh) Logical Operator:
+    (10 multiplied by 2 three times)
+    10 Lsh 3 = gives 80.
+    10.345 Lsh 3 = also gives 80.
+7.	(Rsh) Logical Operator:
+    (16 divided by 2 twice)
+    16 Rsh 2 = gives 4.
+    16.999 Rsh 2 = also gives 4.
+7.	(Or) Logical Operator
+    101 OR 110 = gives 111.
+9.	Exclusive Or (Xor) Logical Operator:
+    101 XOR 110 = gives 11.
+9.	(Not) Logical Operator
+    NOT 1001100111001001 =
+    0110011000110110.
+10.	(And) Logical Operator
+    101 AND 110 = gives 100.
+11.	(Mod) Logical Operator
+    Remainder of integer division (Modulo x)
+12.	"( )" Parenthesis
+
+
+**All Calculators and Converters Test: Verify scaling functions and languages**
+Steps:
+1.	Launch the "Calculator" app.
+2.	For All Modes: While scaling in both directions to capacity
+*Expected: Elements like Memory and History are shifted or integrated appropriately.*
+3.	In Any Mode: While at the Smallest scale, Select the Menu Button
+*Expected: The menu items are scrollable with nothing overlapping.*
+4.	While in the Menu: Check the About Page
+*Expected:  Everything in the about page fits into its window*
+5.	For Scientific Mode: At a Larger Scale
+*Expected: All buttons are present and the up arrow is grayed out.*
+6.	For Scientific Mode: At a Smaller Scale
+*Expected: All buttons are present and the up arrow is able to be toggled.*
+7.	For Programmer Mode: At a Any Scale
+*Expected: All buttons are present and the up arrow is able to be toggled.*
+8.	For Converter Mode: While Scaling
+*Expected: The number pad and input areas move around each other gracefully.*
+9.	Changing Language: Open Settings app > Time & language > Region & language > Add a language > Select a Right to Left (RTL) language such as Hebrew > Install the associated files> Set it to the system default.
+10.	Set the system number format preference: Open a Run dialog (WIN + R) > type ‘intl.cpl’ > Enter > In the format dropdown list > Select Hebrew > Apply.
+11.	Initiating the change: Package has completed installing > Sign out > Sign in. (This change to the app may also require a reinstallation of the build)
+12.	Repeat Steps 2-6 again in a (RTL) language.
+*Expected: No elements fall out of intended boundaries.*
+
+
+**All Calculators Test: Verify toggling functions**
+Steps:
+1.	Launch the "Calculator" app.
+2.	For Standard & Scientific Modes: While in the Smallest scale, verify that the History Icon brings up the history panel gracefully and is displayed appropriately.
+For Scientific Mode: At a Smaller Scale
+Verify the following:
+3.	Grad / Deg / Rad
+    Perform a trig function
+*Expected: The answer to the function is in the selected grad/deg/rad. Repeat for each of the modes.*
+4.	(Hyp) Hyperbolic
+*Expected: Sin toggles to Sinh, Cos toggles to Cosh, Tan toggles to Tanh.*
+5.	(F-E key) Floating Point Notation & Scientific Notation.
+*Expected: Display toggles between floating point and Scientific notation.*
+For Programmer Mode
+Verify the following:
+6.	"Bit Toggling Keypad":
+*Expected: In app keypad changes to represent Bits (1s and 0s).*
+7.	"QWORD / DWORD / WORD / BYTE":
+*Expected: Toggles as expected.*
+8.	"Hex" Hexadecimal:
+*Expected: A B C D E F become active and user can use them. A maximum of 16 characters can be entered.*
+9.	"Dec" Decimal:
+*Expected: A B C D E F are inactive. A maximum of 19 characters can be entered.*
+10.	"Oct" Octal:
+*Expected: A B C D E F 8 9 are inactive. A maximum of 22 characters can be entered.*
+11.	"Bin" Binary:
+*Expected: A B C D E F 2 3 4 5 6 7 8 9 are inactive. A maximum of 64 characters can be entered.*
+
+
+**Date Calculation Test: Verify dates can be calculated.**
+Steps:
+1.	Launch the "Calculator" app.
+2.	Navigate to "Date Calculation" Calculator.
+3.  With "Difference between dates" Selected
+    Change the various date input fields
+*Expected: From and To reflect dates input respectively.*
+5.	With "Add or Subtract days" Selected
+    Change the various date input fields
+*Expected: Verify changes made to both add and subtract reflect input respectively.*
+
+
+**Currency Converter Test: Verify conversion & updating current currency rates.**
+Steps:
+1.	Launch the "Calculator" app.
+2.	Navigate to "Currency Converter" Calculator.
+3.	Select 2 Currency types from the dropdowns & enter a "1" into a conversion slot.
+*Expected: The currency is slotted properly and converted rate matches the ratio provided under the selected currency types.*
+4.	Click "Updated"
+*Expected: Display matches PC's date and time.*
+5.	After at least a minute: Select "Update rates" & Check "Updated" again:
+*Expected: The "Update Rates" button changes the date and time to match the computer's current date and time.*
+
+
+**All Calculators Test: Hotkeys: Verify Hot Key function.**
+Steps:
+1.	Launch the "Calculator" app.
+For All Applicable Modes:
+Verify the following:
+2.	Press **Alt +1** to Enter "Standard" mode
+*Expected: Move to "Standard" screen.*
+3.	Press **Alt +2** to Enter "Scientific" mode
+*Expected: Move to "Scientific" screen.*
+4.	Press **Alt +3** to Enter "Programmer" mode
+*Expected: Move to "Programming" screen.*
+5.	Press **Alt +4** to Enter "Date Calculation" mode
+*Expected: Move to "Date Calculation" screen.*
+6.	Press **Ctrl +M** to Store in Memory
+7.	Press **Ctrl +P** to Add to Active Memory
+8.	Press **Ctrl +Q** to Subtract form Active Memory
+9.	Press **Ctrl +R** to Recall from Memory
+10.	Press **Ctrl +L** to Clear from Memory
+11.	Press **Delete** to Clear Current Input 'CE'
+12.	Press **Esc** to Full Clear Input 'C'
+13.	Press **F9** to Toggle '±'
+14.	Press **R** to Select '1/x'
+15.	Press **@** to Select '√'
+16.	Press **Ctrl + H** to Toggle History Panel
+*Expected: Function when in small scale window.*
+17.	Press **Up arrow** to Move up History Panel
+*Expected: Function when in small scale window.*
+18.	Press **Down arrow** to Move Down History Panel
+*Expected: Function when in small scale window.*
+19.	Press **Ctrl + Shift + D** to Clear History Panel
+*Expected: Function when in small scale window.*
+20.	Press **Spacebar** to Repeat Last Input:
+Verify the following in Scientific Mode
+21.	Press **F3** to Select 'DEG'
+22.	Press **F4** to Select 'RAD'
+23.	Press **F5** to Select 'GRAD'
+24.	Press **Ctrl +G** to Select '10ˣ'
+25.	Press **Ctrl +Y** to Select 'y√x'
+26.	Press **Shift +O** to Select 'sin-1'
+27.	Press **Shift + S** to Select 'cos-1'
+28.	Press **Shift +T** to Select 'tan-1'
+29.	Press **Ctrl +O** to Select 'Cosh'
+30.	Press **Ctrl +S** to Select 'Sinh'
+31.	Press **Ctrl +T** to Select 'Tanh'
+32.	Press **D** to Select 'Mod'
+33.	Press **L** to Select 'log'
+34.	Press **M** to Select 'dms'
+35.	Press **N** to Select 'ln'
+36.	Press **Ctrl +N** to Select 'ex'
+37.	Press **O** to Select 'Cos'
+38.	Press **P** to Select 'π'
+39.	Press **Q** to Select 'x²'
+40.	Press **S** to Select 'Sin'
+41.	Press **T** to Select 'Tan'
+42.	Press **V** to Toggle 'F-E'
+43.	Press **X** to Select 'Exp'
+44.	Press **Y** or **^** to Select 'xʸ'
+45.	Press **#** to Select 'x³'
+46.	Press **!** to Select 'n!'
+Verify the following in Programmer Mode
+47.	Press **F2** to Select 'DWORD'
+48.	Press **F3** to Select 'WORD'
+49.	Press **F4** to Select 'BYTE'
+50.	Press **F5** to Select 'HEX'
+51.	Press **F6** to Select 'DEC'
+52.	Press **F7** to Select 'OCT'
+53.	Press **F8** to Select 'BIN'
+54.	Press **F12** to Select 'QWORD'
+55.	Press **A-F** to Input in HEX
+56.	Press **J** to Select 'RoL'
+57.	Press **K** to Select 'RoR'
+58.	Press **<** to Select 'Lsh'
+59.	Press **>** to Select 'Rsh'
+60.	Press **%** to Select 'Mod'
+61.	Press ** | ** to Select 'Or'
+62.	Press **~** to Select 'Not'
+63.	Press **&** to Select 'And'

docs/NewFeatureProcess.md

@@ -0,0 +1,149 @@
+# New feature process
+
+## When should I follow this process?
+You need to follow this process for any change which "users will notice". This applies especially
+to new features and major visual changes.
+
+You do not need to follow this process for bug fixes, performance improvements, or changes to the
+development tools. To contribute these changes, discuss the issue with the team and then submit a
+pull request.
+
+## Step 1: Create an issue and discuss with the community
+New features are submitted in Feedback Hub. In Feedback Hub you can upvote existing feedback or
+submit your own. We also encourage discussion on open issues in Feedback Hub and in GitHub.
+
+## Step 2: Wait for Microsoft product team sponsorship
+New features must have a sponsor from the Microsoft product team. We can only work on a few ideas
+at a time, so some good feature ideas might remain open but unassigned to a sponsor.
+
+## Step 3: Scoping and feature pitch
+Once we've decided to sponsor a feature, a member of the Microsoft team will write a
+*feature pitch*. The feature pitch concisely describes our point of view on the problem and will
+typically include these sections:
+
+* **Problem Statement**: What problem are we trying to solve? Who’s the customer? Is there a
+  customer need or pain point we need to remedy? Is there a business goal or metric we are trying
+  to improve? Do we have a hypothesis we want to prove or disprove?
+* **Evidence or User Insights**: Why should we do this? Potential sources of data: Feedback Hub,
+  GitHub, request from another team, telemetry data, anecdotes from listening to customers in
+  person, user research, market or competitive research
+* **Proposal**: How will the solution/feature help us solve the problem? How will the
+  solution/feature meet the customer’s needs? How will the solution/feature improve the metrics?
+  Who’s the target audience?
+* **Risks**: This section may not be necessary if covered by the problem statement. What is the
+  risk if we don’t do this work? What is the risk if we do?
+* **Goals**: What you want to accomplish with this feature. Typical examples include
+  “User Can *perform some task*”
+* **Non-Goals**: Things we are explicitly not doing or supporting or that are out of scope,
+  including any reasoning to why.
+
+The feature pitch may also include a low-fidelity concept which will be refined during the
+prototyping process.
+
+We will edit the issue description on GitHub to include the feature pitch.
+
+## Step 4: Prototyping
+After the goals are written, we think of a variety of ways to address these goals and build
+*prototypes* to try them out. We welcome community participation in this process.
+
+Prototypes can take many forms. For many ideas, making changes directly to the app code (without
+spending too much time making the code robust or maintainable) can be a fast and effective way to
+try out new ideas. Or you might prefer to use design software, or even pencil and paper. Work from
+low-fidelity to high-fidelity—try a few ideas for the overall approach before making your
+preferred design pixel-perfect.
+
+An important part of the prototyping process is sharing our work along the way, getting feedback,
+and iterating on the design. Drawings, links to code, and other work-in-progress can be added to
+the wiki for this project. Progress updates will be posted in the issues section.
+
+During the investigation phase, we might discover that the idea isn't feasible or doesn't align
+with our product roadmap. If this happens, we'll document what we learned and close the issue.
+
+## Step 5: Prototype review
+Once there is a high-fidelity design which addresses the goals described in the original pitch, the
+Microsoft product team will review the prototype and ensure all items on this checklist are
+addressed:
+
+- [ ] Is there a high-fidelity design which gives reviewers a clear idea of how the feature will
+  look and function when implemented?
+- [ ] Has the plan been shared with the community (documented on the wiki and updates posted in the
+  original issue) and have others been given an opportunity to provide suggestions?
+- [ ] Are [Fluent design principles](https://docs.microsoft.com/en-us/windows/uwp/design/fluent-design-system/)
+  followed? If we do something which deviates from the guidelines, do we have a good reason?
+- [ ] Does the design include provisions for [all users](https://docs.microsoft.com/en-us/windows/uwp/design/accessibility/designing-inclusive-software)
+  and [all cultures](https://docs.microsoft.com/en-us/windows/uwp/design/globalizing/guidelines-and-checklist-for-globalizing-your-app)?
+- [ ] Is it technically feasible to build this feature? Take a look at the "before committing"
+  checklist below and identify any issues which are likely to be blockers.
+
+## Step 6: Implementation
+A feature can be implemented by the original proposer, the Microsoft team sponsor, or by other
+community members. Code contributions and testing help are greatly appreciated. Please let us know
+in the issue comments if you're actively working on a feature so we can ensure it's assigned to
+you.
+
+You might be able to reuse code written during the prototype process, although there will typically
+be more work required to make the solution robust. Once the code is ready, you can begin
+[submitting pull requests](../CONTRIBUTING.md).
+
+## Step 7: Technical review
+As with all changes, the code for new features will be reviewed by a member of the Microsoft team
+before being checked in to the master branch.
+
+New features often need a more thorough technical review than bug fixes. When reviewing code for
+new features, the Microsoft team considers at least these items:
+
+- [ ] All items on the [Accessibility checklist](https://docs.microsoft.com/en-us/windows/uwp/design/accessibility/accessibility-checklist)
+  should be addressed.
+- [ ] All items on the [Globalization checklist](https://docs.microsoft.com/en-us/windows/uwp/design/globalizing/guidelines-and-checklist-for-globalizing-your-app)
+  should be addressed.
+- [ ] The change should be tested on the oldest version of Windows that the app supports. You can
+  find this version number in AppxManifest.xml. Any calls to APIs newer than that version should be
+  [conditionally enabled](https://docs.microsoft.com/en-us/windows/uwp/debug-test-perf/version-adaptive-apps).
+- [ ] The change should use only supported APIs. If there are any questions about whether legacy or
+  undocumented APIs are in use, the [Windows App Certification Kit](https://docs.microsoft.com/en-us/windows/uwp/debug-test-perf/windows-app-certification-kit)
+  should be run to check.
+- [ ] The change should save the user's progress if the app is
+  [suspended and resumed](https://docs.microsoft.com/en-us/windows/uwp/debug-test-perf/optimize-suspend-resume).
+  Code to handle these cases should be
+  [tested in the Visual Studio debugger](https://docs.microsoft.com/en-us/visualstudio/debugger/how-to-trigger-suspend-resume-and-background-events-for-windows-store-apps-in-visual-studio).
+- [ ] If the change [has customizations for particular device families](https://docs.microsoft.com/en-us/uwp/extension-sdks/device-families-overview),
+  it should be tested on those device families.
+- [ ] The change should be tested with the app window resized to the smallest possible size.
+- [ ] The change should be tested with light, dark, and high contrast themes. It should honor the
+  user's preferred [accent color](https://docs.microsoft.com/en-us/windows/uwp/design/style/color#accent-color-palette).
+- [ ] If the change adds new libraries or other dependencies:
+    - [ ] If the library is packaged with the app, the increased size of the binaries should be
+      measured.
+    - [ ] If the library is not maintained by Microsoft, the Microsoft team will need to set up a
+      plan to monitor the upstream library for changes like security fixes.
+    - [ ] If the library is being used under an open-source license, we must comply with the license
+      and credit third parties appropriately.
+- [ ] If the change adds code which runs during the app's startup path, or adds new XAML elements
+  which are loaded at startup:
+    - [ ] Run the perf tests to measure any increase in startup time. Move work out of the startup
+      path if possible.
+- [ ] If the change adds additional logging:
+    - [ ] All logging should use [TraceLogging](https://docs.microsoft.com/en-us/windows/desktop/tracelogging/trace-logging-about).
+    - [ ] Unnecessary log events should be removed, or configured so that they are collected only when
+      needed to debug issues or measure feature usage.
+- [ ] If the change reads user data from files or app settings:
+    - [ ] Verify that state saved in a previous version of the app can be used with the new version.
+- [ ] If the change makes network requests:
+    - [ ] Microsoft must plan to keep these dependencies secure and functional for the lifetime of
+      the app (which might be several years).
+    - [ ] The app should be fully functional if some network requests are slow or fail. Tools like
+      [Fiddler](http://docs.telerik.com/fiddler/knowledgebase/fiddlerscript/perftesting)
+      can be used to simulate slow or failed requests.
+
+## Step 8: Final product review and merge to master
+After the technical review is complete, the product team will review the finished product to make
+sure the final implementation is ready to release to Windows customers.
+
+## Step 9: Release
+The release process is handled internally by the Microsoft team. When we release, we create a
+`servicing` branch from master. We merge changes into servicing branches only to fix severe bugs.
+
+Releases are distributed through the Microsoft Store, first to Windows Insiders and then to all
+supported Windows 10 devices once we are confident in the update's quality. We usually ship an
+update every month. After the app has been released to the Microsoft Store, it will be part of
+the next major update to Windows 10 (especially for new devices).