Assignment6 #82
Assignment6 #82
Conversation
SummarySummary
CoverageCalculate - 86.8%
|
steeley21
left a comment
steeley21
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, 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, Multiple, 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, Multiple, 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
Do one of the following two options (or both if you want extra, extra credit) :)
Refactor the redirect portion of the Program class 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.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 ✔
Nice work!
| if (parts.Length != 3) | ||
| return false; | ||
|
|
||
| var leftText = parts[0]; |
There was a problem hiding this comment.
This is a nitpick, but I'd recommend not using vars here for better readability in tracking the calculation parts.
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, Multiple, 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, Multiple, 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
Do one of the following two options (or both if you want extra, extra credit) :)
Refactor the redirect portion of the Program class 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.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 ✔
The program and tests are well-structured. I like how the operations are separated into CalculatorOperations, which makes the code easier to read and maintain. One small improvement would be to reduce the use of var for better readability. You could also add an extra test for unsupported operators, negative numbers, extra spaces, or malformed expressions to strengthen coverage. Overall, good work!
|
Create a Console project called "Calculate.". ✔ Extra Credit Do one of the following two options (or both if you want extra, extra credit) :) Refactor the redirect portion of the Program class into 'ProgramBase` Fundamentals Place all shared project properties into a Directory.Build.props file. One point of praise I'd like to point out: your testing coverage. What methods do you use in ensuring testing coverage? I always feel like I end up missing something there... It'd help me out to pick your brain on this; cuz your coverage rate is pretty dang good! Keep up the good work! |
Joshua-Lester3
left a comment
Joshua-Lester3
left a comment
There was a problem hiding this comment.
Instructions
- Create a Console project called "Calculate". ❌ Doesn't explicitly specify this.
- 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. ❌ not empty
- 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. ✔ - 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 ✔
| public static int Main() | ||
| { | ||
| var prog = new Program(); | ||
| var calc = new Calculator<int>(); | ||
|
|
||
| int runResult = prog.Run<int>(calc); | ||
|
|
||
| return runResult; |
There was a problem hiding this comment.
Kind of a nit: I think return codes are supposed to be for status of finished application. I think code 0 is success and anything else is failure. Not something we grade on though :)
| public void TryCalculate_EvaluatingInvalidExpressions_ReturnsFalse() | ||
| { | ||
| var calc = new Calculator<int>(); | ||
|
|
||
| bool sum = calc.TryCalculate("6+ 7", out _); | ||
| bool difference = calc.TryCalculate("6-7", out _); | ||
| bool product = calc.TryCalculate("6 *7", out _); | ||
| bool quotient = calc.TryCalculate("six / 7", out _); | ||
|
|
||
| // Using 'IsFalse' here to avoid compiler warnings | ||
| Assert.IsFalse(sum); | ||
| Assert.IsFalse(difference); | ||
| Assert.IsFalse(product); | ||
| Assert.IsFalse(quotient); | ||
| } |
There was a problem hiding this comment.
I'd separate these out into different tests. Same goes for other similar unit tests. Unit tests should usually only have one reason to fail. This has quite a few
| { | ||
| ArgumentNullException.ThrowIfNull(calculator); | ||
|
|
||
| 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.
| public sealed class ProgramTests | ||
| { | ||
| [TestMethod] | ||
| public void Program_Constructor_DefinesNonNullDelegates() |
There was a problem hiding this comment.
nit: I'm not sure how useful this test is and could probably be removed. I think the other tests will reveal if the program defines the delegates correctly just by using them.
|
|
||
| var op = opText[0]; | ||
|
|
||
| if (!T.TryParse(leftText, CultureInfo.InvariantCulture, out var left)) |
There was a problem hiding this comment.
nit: The Essential C# guideline says "AVOID omitting braces, except for the simplest of single-line if statements." All these single line if statements make me think what does simplest mean? I mean these are pretty simple but is the one on line 35 simpler?
|
|
||
| namespace Calculate; | ||
|
|
||
| public static class CalculatorOperations |
There was a problem hiding this comment.
I wonder if we need this extra class or if putting this in the Calculator class itself makes more sense?
quattro004
left a comment
quattro004
left a comment
There was a problem hiding this comment.
This is looking good overall just a few minor comments and suggestions. Nice work.
6 participants
Worked by myself. Implemented the generics extra credit option.