Assignment 6 #81
Assignment 6 #81
Conversation
Created project structure
Unit test to set properties at construction time, invoking the properties
Merge to A6
Added Program.cs testing
ColtonKnopik
left a comment
ColtonKnopik
left a comment
There was a problem hiding this comment.
Create a Console project called "Calculate". ✔
Define a Program Class
Define two init-only setter properties, WriteLine and ReadLine, that contain delegates for writing a line of text and reading a line of text respectively ✔
Write a test that sets these properties at construction time and then invokes the properties and verifies the expected behavior occurs. ✔
Set the default behavior for the WriteLine and ReadLine properties to invoke System.Console versions of the methods and add an empty default constructor. ✔
Define a Calculator class ✔
Define static Add, Subtract, Multiply, and Divide methods that have two parameters and return a third parameter. ✔
Define a read-only property, MathematicalOperations, of type System.Collections.Generics.IReadOnlyDictionary<TKey,TValue> that:
is initialized to a System.Collections.Generics.Dictionary<<TKey,TValue> instance that. ✔
Uses char for the key corresponding to the operators +, -, *, and /. ✔
Has values that correspond with the Add, Subtract, Multiply, and Divide methods. ✔
Implement a TryCalculate method following "TryParse" pattern ✔
Valid calculation expressions include such strings as "3 + 4", "42 - 2", etc. ✔
If there is no whitespace around the operator, you can assume the calculation is invalid and return false. Similarly if the operands are not integers. ✔
Use string.Split(), pattern matching, logical and operators to parse the string in their entirety ✔
Index into the MathematicalOperations method using the operator parsed during pattern matching to find the corresponding implementation and invoke it. ✔
Implement the Program class to instantiate the calculator and invoke it based on user input from the console. ✔
Be sure to use the WriteLine/ReadLine properties on Program for testing the input and output of your program. ✔
RyanHirte
left a comment
RyanHirte
left a comment
There was a problem hiding this comment.
Create a Console project called "Calculate". ✔
Define a Program Class
Define two init-only setter properties, WriteLine and ReadLine, that contain delegates for writing a line of text and reading a line of text respectively ✔
Write a test that sets these properties at construction time and then invokes the properties and verifies the expected behavior occurs. ✔
Set the default behavior for the WriteLine and ReadLine properties to invoke System.Console versions of the methods and add an empty default constructor. ❌
Define a Calculator class ✔
Define static Add, Subtract, Multiply, and Divide methods that have two parameters and return a third parameter. ✔
Define a read-only property, MathematicalOperations, of type System.Collections.Generics.IReadOnlyDictionary<TKey,TValue> that:
is initialized to a System.Collections.Generics.Dictionary<<TKey,TValue> instance that. ✔
Uses char for the key corresponding to the operators +, -, *, and /. ✔
Has values that correspond with the Add, Subtract, Multiply, and Divide methods. ✔
Implement a TryCalculate method following "TryParse" pattern ✔
Valid calculation expressions include such strings as "3 + 4", "42 - 2", etc. ✔
If there is no whitespace around the operator, you can assume the calculation is invalid and return false. Similarly if the operands are not integers. ✔
Use string.Split(), pattern matching, logical and operators to parse the string in their entirety ✔
Index into the MathematicalOperations method using the operator parsed during pattern matching to find the corresponding implementation and invoke it. ✔
Implement the Program class to instantiate the calculator and invoke it based on user input from the console. ✔
Be sure to use the WriteLine/ReadLine properties on Program for testing the input and output of your program. ✔
Extra credit not implemented
Place all shared project properties into a Directory.Build.props file.
Place all shared project items into a Directory.Build.targets file. (optional)
nullable reference types is enabled ✔
Ensure that you turn on code analysis for all projects(EnableNETAnalyzers) ✔
Set LangVersion and the TargetFramework to the latest released versions available (preview versions optional) ✔
and enabled .NET analyzers for both projects ✔
For this assignment, always use Assert.AreEqual() (the generic version) ✔
All of the above should be unit tested ✔
Choose simplicity over complexity ✔
Overall great job! Just change the behavior of Program to default to the console implementations of writeline and readline.
KorbinWeiler
left a comment
KorbinWeiler
left a comment
There was a problem hiding this comment.
Create a Console project called "Calculate". ✔
Define a Program Class
Define two init-only setter properties, WriteLine and ReadLine, that contain delegates for writing a line of text and reading a line of text respectively ✔
Write a test that sets these properties at construction time and then invokes the properties and verifies the expected behavior occurs. ✔
Set the default behavior for the WriteLine and ReadLine properties to invoke System.Console versions of the methods and add an empty default constructor. ❌
Define a Calculator class ✔
Define static Add, Subtract, Multiply, and Divide methods that have two parameters and return a third parameter. ✔
Define a read-only property, MathematicalOperations, of type System.Collections.Generics.IReadOnlyDictionary<TKey,TValue> that:
is initialized to a System.Collections.Generics.Dictionary<<TKey,TValue> instance that. ✔
Uses char for the key corresponding to the operators +, -, *, and /. ✔
Has values that correspond with the Add, Subtract, Multiply, and Divide methods. ✔
Implement a TryCalculate method following "TryParse" pattern ✔
Valid calculation expressions include such strings as "3 + 4", "42 - 2", etc. ✔
If there is no whitespace around the operator, you can assume the calculation is invalid and return false. Similarly if the operands are not integers. ✔
Use string.Split(), pattern matching, logical and operators to parse the string in their entirety ✔
Index into the MathematicalOperations method using the operator parsed during pattern matching to find the corresponding implementation and invoke it. ✔
Implement the Program class to instantiate the calculator and invoke it based on user input from the console. ✔
Be sure to use the WriteLine/ReadLine properties on Program for testing the input and output of your program. ✔
Fundamentals
Place all shared project properties into a Directory.Build.props file.
Place all shared project items into a Directory.Build.targets file. (optional)
nullable reference types is enabled ✔
Ensure that you turn on code analysis for all projects(EnableNETAnalyzers) ✔
Set LangVersion and the TargetFramework to the latest released versions available (preview versions optional) ✔
and enabled .NET analyzers for both projects ✔
For this assignment, always use Assert.AreEqual() (the generic version) ❌
All of the above should be unit tested ✔
Choose simplicity over complexity ✔
Added <string> generic to tests that were missing that, took out duplicated proj lines that were already in the directory props file, changed divide method to simply divide and not check if it is 0, changed write and readline to set default behaviors
Fixed peer recommendations
used DataTestMethod for MathmaticalOperations unit test
PigPig-SDK
left a comment
PigPig-SDK
left a comment
There was a problem hiding this comment.
Create a Console project called "Calculate". ✔
Define two init-only setter properties, WriteLine and ReadLine, that contain delegates for writing a line of text and reading a line of text respectively ✔
Write a test that sets these properties at construction time and then invokes the properties and verifies the expected behavior occurs. ✔
Set the default behavior for the WriteLine and ReadLine properties to invoke System.Console versions of the methods and add an empty default constructor. ✔
Define a Calculator class ✔
Define static Add, Subtract, Multiply, and Divide methods that have two parameters and return a third parameter. ✔
Define a read-only property, MathematicalOperations, of type System.Collections.Generics.IReadOnlyDictionary<TKey,TValue> that:
is initialized to a System.Collections.Generics.Dictionary<<TKey,TValue> instance that. ✔
Uses char for the key corresponding to the operators +, -, *, and /. ✔
Has values that correspond with the Add, Subtract, Multiply, and Divide methods. ✔
Implement a TryCalculate method following "TryParse" pattern
Valid calculation expressions include such strings as "3 + 4", "42 - 2", etc. ✔
If there is no whitespace around the operator, you can assume the calculation is invalid and return false. Similarly if the operands are not integers. ✔
Use string.Split(), pattern matching, logical and operators to parse the string in their entirety ✔
Index into the MathematicalOperations method using the operator parsed during pattern matching to find the corresponding implementation and invoke it. ✔
Implement the Program class to instantiate the calculator and invoke it based on user input from the console. ✔
Be sure to use the WriteLine/ReadLine properties on Program for testing the input and output of your program. ✔
Fundamentals
Place all shared project properties into a Directory.Build.props file.
Place all shared project items into a Directory.Build.targets file. (optional)
nullable reference types is enabled ✔
Ensure that you turn on code analysis for all projects(EnableNETAnalyzers) ✔
Set LangVersion and the TargetFramework to the latest released versions available (preview versions optional) ✔
and enabled .NET analyzers for both projects ✔
For this assignment, always use Assert.AreEqual() (the generic version) ✔
All of the above should be unit tested ✔
Choose simplicity over complexity ✔
| public static bool TryCalculate(string expression, out double result) | ||
| { | ||
| result = 0; | ||
| string[] parts = expression.Split(' ', StringSplitOptions.RemoveEmptyEntries); |
There was a problem hiding this comment.
Be sure to null check 'expression' before calling Split().
|
|
||
| public Func<string?> ReadLine { get; init; } = Console.ReadLine; | ||
|
|
||
| public Program() |
There was a problem hiding this comment.
Could remove this constructor as it doesn't do anything. (Will be generated anyway)
There was a problem hiding this comment.
Thank you for the recommendation, but Ill leave that there just for assignment specs.
added nullorWhitespace recommended by peers
Added final Peer recommendations/corrections
SummarySummary
CoverageCalculate - 86.3%
|
Joshua-Lester3
left a comment
Joshua-Lester3
left a comment
There was a problem hiding this comment.
Instructions
- Create a Console project called "Calculate". ✔
- Define a Program Class
- Define two init-only setter properties,
WriteLineandReadLine, that contain delegates for writing a line of text and reading a line of text respectively ✔ - Write a test that sets these properties at construction time and then invokes the properties and verifies the expected behavior occurs. ✔
- Set the default behavior for the
WriteLineandReadLineproperties to invokeSystem.Consoleversions of the methods and add an empty default constructor. ✔
- Define two init-only setter properties,
- Define a Calculator class ✔
- Define static
Add,Subtract,Multiply, andDividemethods that have two parameters and return a third parameter. ❌ nit: doesn't return a third parameter (my interpretation of this is usingoutparam) - Define a read-only property,
MathematicalOperations, of typeSystem.Collections.Generics.IReadOnlyDictionary<TKey,TValue>that:- is initialized to a
System.Collections.Generics.Dictionary<<TKey,TValue>instance that. ✔- Uses
charfor the key corresponding to the operators +, -, *, and /. ✔ - Has values that correspond with the Add, Subtract, Multiply, and Divide methods. ✔
- Uses
- is initialized to a
- Implement a
TryCalculatemethod following "TryParse" pattern ✔- Valid
calculationexpressions include such strings as "3 + 4", "42 - 2", etc. ✔ - If there is no whitespace around the operator, you can assume the
calculationis invalid and return false. Similarly if the operands are not integers. ✔ - Use
string.Split(), pattern matching, logical and operators to parse the string in their entirety ✔ - Index into the
MathematicalOperationsmethod using the operator parsed during pattern matching to find the corresponding implementation and invoke it. ✔
- Valid
- Define static
- Implement the Program class to instantiate the calculator and invoke it based on user input from the console. ✔
- Be sure to use the
WriteLine/ReadLineproperties onProgramfor testing the input and output of your program. ✔
Extra Credit
Do one of the following two options (or both if you want extra, extra credit) :)
- Refactor the redirect portion of the
Programclass into 'ProgramBase` ❌- Move ProgramBase into a ConsoleUtilities assembly to be used in other console-based projects
- Use generics the mathematical operations methods and consider using generic constraints (requires .NET 7.0) ❌
Fundamentals
- Place all shared project properties into a
Directory.Build.propsfile. - Place all shared project items into a
Directory.Build.targetsfile. (optional) - nullable reference types is enabled ✔
- Ensure that you turn on code analysis for all projects(EnableNETAnalyzers) ✔
- Set LangVersion and the TargetFramework to the latest released versions available (preview versions optional) ✔
- and enabled .NET analyzers for both projects ✔
- For this assignment, always use
Assert.AreEqual<T>()(the generic version) ✔ - All of the above should be unit tested ❌ Not fully unit tested.
- Choose simplicity over complexity ✔
| String[] inputs = | ||
| { | ||
| "10 + 5", | ||
| "20 - 4", | ||
| "3 * 7", | ||
| "16 / 2", | ||
| "" | ||
| }; | ||
|
|
||
| int Index = 0; | ||
| var outputs = new List<string>(); | ||
|
|
||
| var program = new Program | ||
| { | ||
| ReadLine = () => inputs[Index++], | ||
| WriteLine = s => outputs.Add(s) | ||
| }; | ||
|
|
||
| //Act | ||
| program.Run(); | ||
|
|
||
| //Assert | ||
| Assert.AreEqual<string>("Result: 15", outputs[2]); | ||
| Assert.AreEqual<string>("Result: 16", outputs[4]); | ||
| Assert.AreEqual<string>("Result: 21", outputs[6]); | ||
| Assert.AreEqual<string>("Result: 8", outputs[8]); |
There was a problem hiding this comment.
I'd remove logic from your tests. Make them only have one reason to fail.
| { | ||
| WriteLine("Calculator Program! Press Enter to exit."); | ||
|
|
||
| while (true) |
There was a problem hiding this comment.
Consider that having an infinite loop creates a certain kind of interactive experience like a REPL vs if you did not have the loop the app would exit on each invocation and could be used like in an automated tool call fashion.
There was a problem hiding this comment.
In the instructions under the "Define a Program class" regarding the "two init-only setter properties" it mentions to "Write a test that sets these properties at construction time and then invokes the properties and verifies the expected behavior occurs."
|
|
||
| if (MathematicalOperations.TryGetValue(op, out var operation)) | ||
| { | ||
| if (op == '/' && number2 == 0) |
There was a problem hiding this comment.
I wonder if you could use the MathematicalOperations divide char instead of hard coding the op here?
| return false; | ||
| } | ||
|
|
||
| if (MathematicalOperations.TryGetValue(op, out var operation)) |
There was a problem hiding this comment.
In the instructions under "Define a Calculator class" it mentions to "Index into the MathematicalOperations method using the operator parsed during pattern matching to find the corresponding implementation and invoke it."
| } | ||
|
|
||
| [TestMethod] | ||
| public void Run_Completes_Successfully() |
There was a problem hiding this comment.
I wonder if this could be written as a data test since there's so many assertions. Typically you want one assertion per test.
8 participants
Worked with @Al3xramirez