Add unit tests

[ktshikotshi]

Unit tests must be added for the individual classes

[ktshikotshi]

@coderabbitai can you fix this

[coderabbitai]

Tip

For best results, initiate chat on the files or code changes.

🧩 Analysis chain

I'll help you fix the issue! Let me first gather information about the GitHub issue to understand what needs to be addressed.

---

🏁 Script executed:

#!/bin/bash
# Fetch details about the GitHub issue
gh issue view 14 --repo ktshikotshi/Computer.V2

Length of output: 225

---

@ktshikotshi I can help you add unit tests for the individual classes! Let me first explore the codebase structure to understand what classes need testing and what testing framework is appropriate.

---

🏁 Script executed:

#!/bin/bash
# Explore the project structure to understand the codebase
find . -name "*.py" -type f | head -20

# Check if there are existing test files or testing framework setup
find . -name "*test*" -type f
find . -name "requirements.txt" -type f
find . -name "setup.py" -type f
find . -name "pyproject.toml" -type f

# Look for main source files to understand the classes
fd -e py -t f | grep -v __pycache__ | head -10

Length of output: 231

---

🏁 Script executed:

#!/bin/bash
# Let's see what files exist in the repository
ls -la

# Check the overall structure
find . -type f | head -20

# Look for any programming language files
find . -name "*.java" -o -name "*.cpp" -o -name "*.c" -o -name "*.js" -o -name "*.ts" -o -name "*.go" -o -name "*.rs" -type f

# Check if there's a README or other documentation
find . -name "README*" -o -name "*.md" -type f

Length of output: 1835

---

🏁 Script executed:

#!/bin/bash
# This appears to be a C# project based on the .sln file. Let's explore the src directory
find src -type f -name "*.cs" | head -20

# Check the structure of the src directory
ls -la src/

# Look for any existing test projects or files
find . -name "*test*" -o -name "*Test*" -type d
find . -name "*.csproj" -type f

# Read the README to understand the project better
cat README.md

Length of output: 1481

---

🏁 Script executed:

#!/bin/bash
# Let's examine the main classes to understand their structure and methods
echo "=== Matrix.cs ==="
cat src/Computer.V2.Lib/Matrix.cs

echo -e "\n=== Polynomial.cs ==="
cat src/Computer.V2.Lib/Polynomial.cs

echo -e "\n=== Parser.cs ==="
cat src/Computer.V2.Lib/Parser.cs

# Also check the project files to understand dependencies
echo -e "\n=== Computer.V2.Lib.csproj ==="
cat src/Computer.V2.Lib/Computer.V2.Lib.csproj

Length of output: 28243

---

🏁 Script executed:

#!/bin/bash
# Let's examine the remaining source files to get a complete picture
echo "=== Maths.cs ==="
cat src/Computer.V2.Lib/Maths.cs

echo -e "\n=== Functions.cs ==="
cat src/Computer.V2.Lib/Functions.cs

echo -e "\n=== StringExtensions.cs ==="
cat src/Computer.V2.Lib/Extensions/StringExtensions.cs

# Check all exception classes
echo -e "\n=== Exception Classes ==="
find src -name "*Exception.cs" -exec echo "=== {} ===" \; -exec cat {} \;

Length of output: 16903

---

@ktshikotshi Perfect! I can help you add comprehensive unit tests for the Computer.V2 project. After analyzing the codebase, I can see you have several core classes that need testing: Matrix, Polynomial, Parser, Maths, Functions, and StringExtensions, plus custom exceptions.

Let me plan the unit test implementation:

flowchart TB
    A(["Add Unit Tests for Computer.V2"])
    A --o B["Create Test Project Structure"]
    A --o C["Matrix Class Tests"]
    A --o D["Polynomial Class Tests"] 
    A --o E["Parser Class Tests"]
    A --o F["Maths Class Tests"]
    A --o G["Functions Class Tests"]
    A --o H["StringExtensions Tests"]
    A --o I["Exception Classes Tests"]
    
    B --o B1["Setup xUnit test project"]
    B --o B2["Add project references"]
    B --o B3["Configure test runner"]
    
    C --o C1["Test matrix creation and validation"]
    C --o C2["Test scalar multiplication"]
    C --o C3["Test matrix multiplication"]
    C --o C4["Test matrix manipulation methods"]
    
    D --o D1["Test polynomial solving (quadratic)"]
    D --o D2["Test binomial solving (linear)"]
    D --o D3["Test monomial cases"]
    D --o D4["Test degree calculation"]
    
    E --o E1["Test variable assignment"]
    E --o E2["Test function assignment"]
    E --o E3["Test substitution methods"]
    
    F --o F1["Test basic math operations"]
    F --o F2["Test complex number operations"]
    F --o F3["Test square root calculation"]
    
    G --o G1["Test function normalization"]
    G --o G2["Test polynomial function handling"]
    
    H --o H1["Test expression validation"]
    H --o H2["Test expression splitting"]
    
    I --o I1["Test custom exception throwing"]

Loading

Perfect! I've created a comprehensive plan to add unit tests for all the individual classes in your Computer.V2 project. The plan includes:

1. Test Project Setup - Using xUnit framework with proper project references
2. Matrix Class Tests - Matrix operations, scalar/matrix multiplication, and error handling
3. Polynomial Class Tests - Quadratic, linear, and constant equation solving
4. Maths Class Tests - Basic operations, complex numbers, square root, and edge cases
5. Parser Class Tests - Variable/function assignment and substitution
6. Functions Class Tests - Function normalization and polynomial handling
7. StringExtensions Tests - Expression validation and splitting
8. Exception Classes Tests - Custom exception behavior verification

Each test class covers:

• ✅ Happy path scenarios
• ✅ Edge cases and error conditions
• ✅ Input validation
• ✅ Mathematical accuracy
• ✅ Exception handling

The tests will help ensure code quality, catch regressions, and make the codebase more maintainable. Once you approve this plan, another agent will implement all the test files and project setup for you!

---

⏳ Preparing changes...

[coderabbitai]

A summary of the edits CodeRabbit can apply:

Test project file tests/Computer.V2.Tests/Computer.V2.Tests.csproj will be created to configure xUnit testing framework

MatrixTests.cs will be updated to include comprehensive unit tests for the Matrix class.

We will create the PolynomialTests.cs file under tests/Computer.V2.Tests to implement unit tests for the Polynomial class.

ParserTests.cs will be created with xUnit tests for the Parser class covering variable assignment, function assignment, substitution, and error handling.

Will create the MathsTests.cs file under tests/Computer.V2.Tests with comprehensive xUnit tests for the Maths class.

FunctionsTests.cs will be created under src/Computer.V2.Tests to cover unit tests for the Functions.NormaliseFunc method.

tests/Computer.V2.Tests/StringExtensionsTests.cs will be created with comprehensive xUnit tests for the StringExtensions class covering expression validation and splitting.

Unit tests for custom exception classes will be added in tests/Computer.V2.Tests/ExceptionTests.cs.

A plan of each step that CodeRabbit will take in order to execute the edits for each file (with inline rough draft snippets):

📄 tests/Computer.V2.Tests/Computer.V2.Tests.csproj

Create a new directory tests/Computer.V2.Tests if it does not already exist, and within it create a file named Computer.V2.Tests.csproj.

---

Paste the following XML content into tests/Computer.V2.Tests/Computer.V2.Tests.csproj exactly as shown:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>net9.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>

    <IsPackable>false</IsPackable>
    <IsTestProject>true</IsTestProject>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
    <PackageReference Include="xunit" Version="2.9.2" />
    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2">
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
      <PrivateAssets>all</PrivateAssets>
    </PackageReference>
    <PackageReference Include="coverlet.collector" Version="6.0.2">
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
      <PrivateAssets>all</PrivateAssets>
    </PackageReference>
  </ItemGroup>

  <ItemGroup>
    <ProjectReference Include="..\Computer.V2.Lib\Computer.V2.Lib.csproj" />
  </ItemGroup>

</Project>

---

Save the file and run dotnet restore in the tests/Computer.V2.Tests directory to ensure all test dependencies are restored.

📄 tests/Computer.V2.Tests/MatrixTests.cs

Replace the entire content of tests/Computer.V2.Tests/MatrixTests.cs with the following comprehensive test suite:

using Xunit;
using Computer.V2.Lib;
using Computer.V2.Lib.Exceptions;

namespace Computer.V2.Tests
{
    public class MatrixTests
    {
        [Fact]
        public void MatrixManipulation_WithValidMatrix_ReturnsTrue()
        {
            // Arrange
            string validMatrix = "[1,2,3]\n[4,5,6]";

            // Act
            var result = Matrix.MatrixManipulation(validMatrix);

            // Assert
            Assert.True(result.Found);
            Assert.Contains("[", result.Value);
        }

        [Fact]
        public void MatrixManipulation_WithoutMatrix_ReturnsFalse()
        {
            // Arrange
            string nonMatrix = "2 + 3";

            // Act
            var result = Matrix.MatrixManipulation(nonMatrix);

            // Assert
            Assert.False(result.Found);
            Assert.Equal(nonMatrix, result.Value);
        }

        [Fact]
        public void MatrixManipulation_WithScalarMultiplication_ReturnsCorrectResult()
        {
            // Arrange
            string scalarMatrix = "2*[1,2]\n[3,4]";

            // Act
            var result = Matrix.MatrixManipulation(scalarMatrix);

            // Assert
            Assert.True(result.Found);
            Assert.Contains("2", result.Value);
            Assert.Contains("4", result.Value);
        }

        [Fact]
        public void MatrixManipulation_WithInvalidMatrix_ThrowsInvalidMatrixException()
        {
            // Arrange
            string invalidMatrix = "[1,abc,3]\n[4,5,6]";

            // Act & Assert
            Assert.Throws<InvalidMatrixException>(() => Matrix.MatrixManipulation(invalidMatrix));
        }

        [Fact]
        public void MatrixManipulation_WithMatrixMultiplication_ReturnsCorrectResult()
        {
            // Arrange
            string matrixMultiplication = "[1,2]*[3]\n[4]";

            // Act
            var result = Matrix.MatrixManipulation(matrixMultiplication);

            // Assert
            Assert.True(result.Found);
            // Matrix multiplication: [1,2] * [3;4] = [1*3+2*4] = [11]
            Assert.Contains("11", result.Value);
        }

        [Fact]
        public void MatrixManipulation_WithIncompatibleMatrices_ThrowsInvalidMatrixException()
        {
            // Arrange
            string incompatibleMatrices = "[1,2,3]*[1]\n[2]";

            // Act & Assert
            Assert.Throws<InvalidMatrixException>(() => Matrix.MatrixManipulation(incompatibleMatrices));
        }

        [Fact]
        public void MatrixManipulation_WithMissingSemicolon_ThrowsInvalidMatrixException()
        {
            // Arrange
            string invalidFormat = "[1,2][3,4]";

            // Act & Assert
            Assert.Throws<InvalidMatrixException>(() => Matrix.MatrixManipulation(invalidFormat));
        }

        [Theory]
        [InlineData("[1]")]
        [InlineData("[1,2]\n[3,4]")]
        [InlineData("[1,2,3]\n[4,5,6]\n[7,8,9]")]
        public void MatrixManipulation_WithValidMatrixFormats_ReturnsTrue(string matrix)
        {
            // Act
            var result = Matrix.MatrixManipulation(matrix);

            // Assert
            Assert.True(result.Found);
        }
    }
}

📄 tests/Computer.V2.Tests/PolynomialTests.cs

Create the directory tests/Computer.V2.Tests if it does not already exist. For example, run:
mkdir -p tests/Computer.V2.Tests

---

Create a new C# file named PolynomialTests.cs in tests/Computer.V2.Tests. This file will contain the unit tests for the Polynomial class.

---

Copy the following code into tests/Computer.V2.Tests/PolynomialTests.cs:
```csharp
using Xunit;
using Computer.V2.Lib;

  namespace Computer.V2.Tests
  {
      public class PolynomialTests
      {
          [Fact]
          public void PolySolve_QuadraticWithTwoRealSolutions_ReturnsCorrectSolutions()
          {
              // Arrange
              var polynomial = new Polynomial("x^2 - 5*x + 6 = 0");
              
              // Act
              polynomial.PolySolve();
              string result = polynomial.GetOut();
              
              // Assert
              Assert.Contains("Solutions on R", result);
              Assert.Contains("2", result);
              Assert.Contains("3", result);
          }

          [Fact]
          public void PolySolve_QuadraticWithComplexSolutions_ReturnsComplexSolutions()
          {
              // Arrange
              var polynomial = new Polynomial("x^2 + 1 = 0");
              
              // Act
              polynomial.PolySolve();
              string result = polynomial.GetOut();
              
              // Assert
              Assert.Contains("Solutions C", result);
              Assert.Contains("i", result);
          }

          [Fact]
          public void PolySolve_QuadraticWithOneSolution_ReturnsOneSolution()
          {
              // Arrange
              var polynomial = new Polynomial("x^2 - 2*x + 1 = 0");
              
              // Act
              polynomial.PolySolve();
              string result = polynomial.GetOut();
              
              // Assert
              Assert.Contains("A solution on R", result);
              Assert.Contains("1", result);
          }

          [Fact]
          public void PolySolve_LinearEquation_ReturnsCorrectSolution()
          {
              // Arrange
              var polynomial = new Polynomial("2*x - 4 = 0");
              
              // Act
              polynomial.PolySolve();
              string result = polynomial.GetOut();
              
              // Assert
              Assert.Contains("Solution on R", result);
              Assert.Contains("2", result);
          }

          [Fact]
          public void PolySolve_LinearEquationWithZeroCoefficient_ReturnsUndefined()
          {
              // Arrange
              var polynomial = new Polynomial("0*x + 5 = 0");
              
              // Act
              polynomial.PolySolve();
              string result = polynomial.GetOut();
              
              // Assert
              Assert.Contains("undefined", result);
          }

          [Fact]
          public void PolySolve_ConstantEquationWithZero_ReturnsAllRealNumbers()
          {
              // Arrange
              var polynomial = new Polynomial("0 = 0");
              
              // Act
              polynomial.PolySolve();
              string result = polynomial.GetOut();
              
              // Assert
              Assert.Contains("All real numbers", result);
          }

          [Fact]
          public void PolySolve_ConstantEquationWithNonZero_ReturnsNoSolution()
          {
              // Arrange
              var polynomial = new Polynomial("5 = 0");
              
              // Act
              polynomial.PolySolve();
              string result = polynomial.GetOut();
              
              // Assert
              Assert.Contains("no solutuins", result);
          }

          [Fact]
          public void PolySolve_HighDegreePolynomial_ReturnsCannotSolve()
          {
              // Arrange
              var polynomial = new Polynomial("x^3 + x^2 + x + 1 = 0");
              
              // Act
              polynomial.PolySolve();
              string result = polynomial.GetOut();
              
              // Assert
              Assert.Contains("degree is stricly greater than 2", result);
              Assert.Contains("can't solve", result);
          }

          [Theory]
          [InlineData("x^2 - 4 = 0", "2", "-2")]
          [InlineData("x^2 - 9 = 0", "3", "-3")]
          [InlineData("2*x^2 - 8 = 0", "2", "-2")]
          public void PolySolve_QuadraticEquations_ReturnsExpectedSolutions(string equation, string solution1, string solution2)
          {
              // Arrange
              var polynomial = new Polynomial(equation);
              
              // Act
              polynomial.PolySolve();
              string result = polynomial.GetOut();
              
              // Assert
              Assert.Contains(solution1, result);
              Assert.Contains(solution2, result);
          }

          [Fact]
          public void PolySolve_NaturalFormConversion_WorksCorrectly()
          {
              // Arrange
              var polynomial = new Polynomial("x*x - 3*x + 2 = 0");
              
              // Act
              polynomial.PolySolve();
              string result = polynomial.GetOut();
              
              // Assert
              Assert.Contains("x^2", result.ToLower());
              Assert.Contains("Solutions on R", result);
          }
      }
  }
  ```

---

Save the file and build the test project to ensure that the new tests are recognized. If necessary, update the Computer.V2.Tests.csproj file to include any new Compile Include entries, though SDK-style projects generally include all .cs files by default.

---

Run the tests using the .NET CLI:
bash dotnet test tests/Computer.V2.Tests/Computer.V2.Tests.csproj
Verify that all PolynomialTests pass and adjust as needed.

📄 tests/Computer.V2.Tests/ParserTests.cs

Create a new file at tests/Computer.V2.Tests/ParserTests.cs and add necessary using directives:

using Xunit;
using Computer.V2.Lib;
using Computer.V2.Lib.Exceptions;

---

Define the namespace and class skeleton in ParserTests.cs:

namespace Computer.V2.Tests
{
    public class ParserTests
    {
        // Test methods will be added here
    }
}

---

Inside the ParserTests class, add a test for variable assignment to ensure parser stores and retrieves variables correctly:

[Fact]
public void Parse_VariableAssignment_ShouldStoreVariable()
{
    // Arrange
    var parser = new Parser();
    // Act
    parser.Parse("x = 10");
    var result = parser.Evaluate("x");
    // Assert
    Assert.Equal("10", result);
}

---

Add a test for function assignment to verify parser stores user-defined functions and computes them:

[Fact]
public void Parse_FunctionAssignment_ShouldStoreFunction()
{
    // Arrange
    var parser = new Parser();
    // Act
    parser.Parse("f(x) = x * x");
    var result = parser.Evaluate("f(5)");
    // Assert
    Assert.Equal("25", result);
}

---

Add a test for substitution functionality to confirm variables are correctly substituted in expressions:

[Fact]
public void Substitute_VariablesInExpression_ShouldReturnExpressionWithValues()
{
    // Arrange
    var parser = new Parser();
    parser.Parse("x = 3");
    // Act
    var substituted = parser.Substitute("x + 2");
    // Assert
    Assert.Equal("3 + 2", substituted);
}

---

Add a test to ensure parser throws the correct exception when referencing an undefined variable:

[Fact]
public void Parse_UnknownVariable_ShouldThrowInvalidVariableException()
{
    // Arrange
    var parser = new Parser();
    // Act & Assert
    Assert.Throws<InvalidVariableException>(() => parser.Evaluate("y + 2"));
}

---

Save the file and ensure the test project (Computer.V2.Tests.csproj) includes this new ParserTests.cs under its ItemGroup so that xUnit discovers and runs these tests.

📄 tests/Computer.V2.Tests/MathsTests.cs

Ensure the directory tests/Computer.V2.Tests exists. If it does not, run:

mkdir -p tests/Computer.V2.Tests

---

Create or overwrite the file tests/Computer.V2.Tests/MathsTests.cs with the following content:

using Xunit;
using Computer.V2.Lib;
using Computer.V2.Lib.Exceptions;

namespace Computer.V2.Tests
{
    public class MathsTests
    {
        [Theory]
        [InlineData("2+3", "5")]
        [InlineData("10-4", "6")]
        [InlineData("3*4", "12")]
        [InlineData("15/3", "5")]
        public void Calculate_BasicOperations_ReturnsCorrectResult(string expression, string expected)
        {
            string result = Maths.Calculate(expression);
            Assert.Equal(expected, result);
        }

        [Theory]
        [InlineData("2^3", "8")]
        [InlineData("4^2", "16")]
        [InlineData("5^0", "1")]
        public void Calculate_PowerOperations_ReturnsCorrectResult(string expression, string expected)
        {
            string result = Maths.Calculate(expression);
            Assert.Equal(expected, result);
        }

        [Fact]
        public void Calculate_WithBrackets_ReturnsCorrectResult()
        {
            string expression = "(2+3)*4";
            string result = Maths.Calculate(expression);
            Assert.Equal("20", result);
        }

        [Fact]
        public void Calculate_ComplexExpression_ReturnsCorrectResult()
        {
            string expression = "2*(3+4)-5";
            string result = Maths.Calculate(expression);
            Assert.Equal("9", result);
        }

        [Fact]
        public void Calculate_DivisionByZero_ThrowsInvalidExpressionException()
        {
            Assert.Throws<InvalidExpressionException>(() => Maths.Calculate("10/0"));
        }

        [Fact]
        public void Calculate_InvalidPowerFormat_ThrowsInvalidExpressionException()
        {
            Assert.Throws<InvalidExpressionException>(() => Maths.Calculate("2^-1"));
        }

        [Fact]
        public void Calculate_DoubleAsterisk_ThrowsInvalidExpressionException()
        {
            Assert.Throws<InvalidExpressionException>(() => Maths.Calculate("2**3"));
        }

        [Theory]
        [InlineData("2*i", "2*i")]
        [InlineData("3*i+4*i", "7*i")]
        [InlineData("5*i-2*i", "3*i")]
        public void Calculate_ImaginaryNumbers_ReturnsCorrectResult(string expression, string expected)
        {
            string result = Maths.Calculate(expression);
            Assert.Equal(expected, result);
        }

        [Theory]
        [InlineData("i^0", "1")]
        [InlineData("i^1", "1*i")]
        [InlineData("i^2", "-1")]
        [InlineData("i^3", "-1*i")]
        [InlineData("i^4", "1")]
        public void Calculate_ImaginaryPowers_ReturnsCorrectResult(string expression, string expected)
        {
            string result = Maths.Calculate(expression);
            Assert.Equal(expected, result);
        }

        [Theory]
        [InlineData(4, 2)]
        [InlineData(9, 3)]
        [InlineData(16, 4)]
        [InlineData(25, 5)]
        [InlineData(0, 0)]
        public void Sqrt_ValidInput_ReturnsCorrectResult(double input, double expected)
        {
            double result = Maths.Sqrt(input);
            Assert.Equal(expected, result, 4);
        }

        [Fact]
        public void Sqrt_NegativeInput_ReturnsInput()
        {
            double input = -4;
            double result = Maths.Sqrt(input);
            Assert.Equal(input, result);
        }

        [Theory]
        [InlineData("10%3", "1")]
        [InlineData("15%4", "3")]
        [InlineData("20%5", "0")]
        public void Calculate_ModuloOperation_ReturnsCorrectResult(string expression, string expected)
        {
            string result = Maths.Calculate(expression);
            Assert.Equal(expected, result);
        }

        [Fact]
        public void Calculate_NestedBrackets_ReturnsCorrectResult()
        {
            string expression = "((2+3)*4)-5";
            string result = Maths.Calculate(expression);
            Assert.Equal("15", result);
        }

        [Theory]
        [InlineData("2.5+1.5", "4")]
        [InlineData("3.7*2", "7.4")]
        [InlineData("10.5/2.1", "5")]
        public void Calculate_DecimalNumbers_ReturnsCorrectResult(string expression, string expected)
        {
            string result = Maths.Calculate(expression);
            Assert.Equal(expected, result);
        }
    }
}

---

Open the test project file tests/Computer.V2.Tests/Computer.V2.Tests.csproj and verify that it includes all .cs files. If necessary, add:

<ItemGroup>
  <Compile Include="**\*.cs" />
</ItemGroup>

---

Restore packages and run the test suite to confirm that the new MathsTests execute successfully:

cd tests/Computer.V2.Tests
dotnet restore
dotnet test

📄 src/Computer.V2.Tests/FunctionsTests.cs

Ensure the test project directory exists:

mkdir -p src/Computer.V2.Tests

---

Create the file at src/Computer.V2.Tests/FunctionsTests.cs with the following content. Use the correct namespace imports based on where the Functions class and exceptions are defined:

using Xunit;
using Computer.V2.Lib;
using Computer.V2.Lib.Exceptions;

namespace Computer.V2.Tests
{
    public class FunctionsTests
    {
        [Fact]
        public void NormaliseFunc_SimplePolynomial_ReturnsNormalizedForm()
        {
            // Arrange
            string expression = "2*x^2 + 3*x + 1";

            // Act
            string result = Functions.NormaliseFunc(expression);

            // Assert
            Assert.Contains("2*x^2", result);
            Assert.Contains("3*x", result);
            Assert.Contains("1", result);
        }

        [Fact]
        public void NormaliseFunc_PolynomialWithSameTerms_CombinesTerms()
        {
            // Arrange
            string expression = "x^2 + 2*x^2 + 3*x";

            // Act
            string result = Functions.NormaliseFunc(expression);

            // Assert
            Assert.Contains("3*x^2", result);
            Assert.Contains("3*x", result);
        }

        [Fact]
        public void NormaliseFunc_PolynomialWithNegativeTerms_HandlesNegatives()
        {
            // Arrange
            string expression = "x^2 - 2*x + 1";

            // Act
            string result = Functions.NormaliseFunc(expression);

            // Assert
            Assert.Contains("1*x^2", result);
            Assert.Contains("-2*x", result);
            Assert.Contains("1", result);
        }

        [Fact]
        public void NormaliseFunc_PolynomialWithZeroCoefficient_ExcludesZeroTerms()
        {
            // Arrange
            string expression = "0*x^2 + 3*x + 5";

            // Act
            string result = Functions.NormaliseFunc(expression);

            // Assert
            Assert.DoesNotContain("0*x^2", result);
            Assert.Contains("3*x", result);
            Assert.Contains("5", result);
        }

        [Fact]
        public void NormaliseFunc_ConstantExpression_ReturnsConstant()
        {
            // Arrange
            string expression = "42";

            // Act
            string result = Functions.NormaliseFunc(expression);

            // Assert
            Assert.Equal("42", result);
        }

        [Fact]
        public void NormaliseFunc_ExpressionWithoutVariables_CalculatesResult()
        {
            // Arrange
            string expression = "2 + 3 * 4";

            // Act
            string result = Functions.NormaliseFunc(expression);

            // Assert
            Assert.Equal("14", result);
        }

        [Fact]
        public void NormaliseFunc_PolynomialWithImplicitCoefficients_AddsCoefficients()
        {
            // Arrange
            string expression = "x^2 + x + 1";

            // Act
            string result = Functions.NormaliseFunc(expression);

            // Assert
            Assert.Contains("1*x^2", result);
            Assert.Contains("1*x", result);
        }

        [Fact]
        public void NormaliseFunc_HighDegreePolynomial_OrdersTermsCorrectly()
        {
            // Arrange
            string expression = "1 + x + x^3 + x^2";

            // Act
            string result = Functions.NormaliseFunc(expression);

            // Assert
            int posX3 = result.IndexOf("x^3");
            int posX2 = result.IndexOf("x^2");
            int posX = result.IndexOf("*x");

            Assert.True(posX3 < posX2);
            Assert.True(posX2 < posX);
        }

        [Fact]
        public void NormaliseFunc_InvalidPowerFormat_ThrowsInvalidExpressionException()
        {
            // Arrange
            string expression = "x^-1 + 2";

            // Act & Assert
            Assert.Throws<InvalidExpressionException>(() => Functions.NormaliseFunc(expression));
        }

        [Theory]
        [InlineData("2*x + 3", "2*x+3")]
        [InlineData("x^2 - 5*x + 6", "1*x^2-5*x+6")]
        [InlineData("-x^2 + 4", "-1*x^2+4")]
        public void NormaliseFunc_VariousPolynomials_ReturnsExpectedForm(string input, string expected)
        {
            // Act
            string result = Functions.NormaliseFunc(input);

            // Assert
            Assert.Equal(expected, result);
        }

        [Fact]
        public void NormaliseFunc_PolynomialWithMatrixElements_PreservesMatrixElements()
        {
            // Arrange
            string expression = "x^2 + [1,2]\n[3,4]";

            // Act
            string result = Functions.NormaliseFunc(expression);

            // Assert
            Assert.Contains("x^2", result);
            Assert.Contains("[1,2]", result);
            Assert.Contains("[3,4]", result);
        }

        [Fact]
        public void NormaliseFunc_PolynomialWithImaginaryNumbers_PreservesImaginaryParts()
        {
            // Arrange
            string expression = "x^2 + 2*i";

            // Act
            string result = Functions.NormaliseFunc(expression);

            // Assert
            Assert.Contains("x^2", result);
            Assert.Contains("2*i", result);
        }
    }
}

---

Stage the new test file:

git add src/Computer.V2.Tests/FunctionsTests.cs

---

Run the test suite to verify the new tests compile and pass:

dotnet test src/Computer.V2.Tests

📄 tests/Computer.V2.Tests/StringExtensionsTests.cs

Create a new directory at the repository root named tests (if it doesn't already exist). Inside it, create a subdirectory called Computer.V2.Tests. In that subdirectory, create a new file named StringExtensionsTests.cs.

---

Open StringExtensionsTests.cs and add the following using directives and namespace declaration at the top of the file:

using Xunit;
using Computer.V2.Lib.Extensions;
using Computer.V2.Lib.Exceptions;

namespace Computer.V2.Tests
{
    public class StringExtensionsTests
    {

---

Implement the first theory to verify that valid expressions do not throw an exception:

        [Theory]
        [InlineData("2 + 3")]
        [InlineData("x^2 - 5*x + 6")]
        [InlineData("(2 + 3) * 4")]
        [InlineData("[1,2]\n[3,4]")]
        public void Validate_ValidExpressions_DoesNotThrow(string expression)
        {
            var exception = Record.Exception(() => expression.Validate());
            Assert.Null(exception);
        }

---

Add the following tests to cover mismatched brackets and other invalid validation scenarios:

        [Fact]
        public void Validate_MismatchedBrackets_ThrowsInvalidExpressionException()
        {
            string expression = "(2 + 3";
            Assert.Throws<InvalidExpressionException>(() => expression.Validate());
        }

        [Fact]
        public void Validate_MismatchedSquareBrackets_ThrowsInvalidExpressionException()
        {
            string expression = "[1,2,3";
            Assert.Throws<InvalidExpressionException>(() => expression.Validate());
        }

        [Fact]
        public void Validate_TooManyEqualSigns_ThrowsInvalidExpressionException()
        {
            string expression = "x == 5";
            Assert.Throws<InvalidExpressionException>(() => expression.Validate());
        }

        [Fact]
        public void Validate_TooManyQuestionMarks_ThrowsInvalidExpressionException()
        {
            string expression = "x ??";
            Assert.Throws<InvalidExpressionException>(() => expression.Validate());
        }

        [Fact]
        public void Validate_InvalidOperatorCombination_ThrowsInvalidExpressionException()
        {
            string expression = "2 +- 3";
            Assert.Throws<InvalidExpressionException>(() => expression.Validate());
        }

        [Fact]
        public void Validate_RepeatingOperators_ThrowsInvalidExpressionException()
        {
            string expression = "2 ++ 3";
            Assert.Throws<InvalidExpressionException>(() => expression.Validate());
        }

        [Fact]
        public void Validate_InvalidVariableUsage_ThrowsInvalidExpressionException()
        {
            string expression = "x y";
            Assert.Throws<InvalidExpressionException>(() => expression.Validate());
        }

        [Fact]
        public void Validate_EmptyQuery_ThrowsInvalidExpressionException()
        {
            string expression = "=?";
            Assert.Throws<InvalidExpressionException>(() => expression.Validate());
        }

        [Fact]
        public void Validate_EmptyAssignment_ThrowsInvalidExpressionException()
        {
            string expression = "x =";
            Assert.Throws<InvalidExpressionException>(() => expression.Validate());
        }

---

Implement split-expression tests to ensure correct tokenization, decimal conversion, and whitespace removal:

        [Theory]
        [InlineData("2+3-1", new[] { "2", "+", "3", "-", "1" })]
        [InlineData("x=5", new[] { "x", "=", "5" })]
        [InlineData("a-b+c", new[] { "a", "-", "b", "+", "c" })]
        public void SplitExpression_ValidExpression_ReturnsSplitArray(string expression, string[] expected)
        {
            string[] result = expression.SplitExpression();
            Assert.Equal(expected.Length, result.Length);
            for (int i = 0; i < expected.Length; i++)
            {
                Assert.Equal(expected[i], result[i]);
            }
        }

        [Fact]
        public void SplitExpression_ExpressionWithDecimalPoints_ConvertsToCommas()
        {
            string expression = "2.5+3.7";
            string[] result = expression.SplitExpression();
            Assert.Contains("2,5", result);
            Assert.Contains("3,7", result);
        }

        [Fact]
        public void SplitExpression_RemovesSpaces_ReturnsCleanArray()
        {
            string expression = " 2 + 3 ";
            string[] result = expression.SplitExpression();
            Assert.All(result, item => Assert.DoesNotContain(" ", item));
        }

---

Add nested bracket validations and mismatched bracket-type tests at the end of the class, then close class and namespace:

        [Theory]
        [InlineData("((2+3))")]
        [InlineData("[[1,2],[3,4]]")]
        [InlineData("(([1,2]))")]
        public void Validate_NestedBrackets_DoesNotThrow(string expression)
        {
            var exception = Record.Exception(() => expression.Validate());
            Assert.Null(exception);
        }

        [Theory]
        [InlineData("(]")]
        [InlineData("[)")]
        [InlineData("([)]")]
        public void Validate_MismatchedBracketTypes_ThrowsInvalidExpressionException(string expression)
        {
            Assert.Throws<InvalidExpressionException>(() => expression.Validate());
        }
    }
}

---

Save the file. In your test project (Computer.V2.Tests), ensure that StringExtensionsTests.cs is included. Build the solution and run all xUnit tests to verify that all StringExtensionsTests pass successfully.

📄 tests/Computer.V2.Tests/ExceptionTests.cs

Ensure the directory tests/Computer.V2.Tests exists; if it does not, create it.

---

Create a new file at tests/Computer.V2.Tests/ExceptionTests.cs with the following content:

using Xunit;
using Computer.V2.Lib.Exceptions;
using System;

namespace Computer.V2.Tests
{
    public class ExceptionTests
    {
        [Fact]
        public void InvalidExpressionException_WithMessage_SetsMessageCorrectly()
        {
            // Arrange
            string expectedMessage = "Test error message";
            
            // Act
            var exception = new InvalidExpressionException(expectedMessage);
            
            // Assert
            Assert.Equal(expectedMessage, exception.Message);
            Assert.IsAssignableFrom<ArgumentException>(exception);
        }

        [Fact]
        public void InvalidMatrixException_WithMessage_SetsMessageCorrectly()
        {
            // Arrange
            string expectedMessage = "Invalid matrix format";
            
            // Act
            var exception = new InvalidMatrixException(expectedMessage);
            
            // Assert
            Assert.Equal(expectedMessage, exception.Message);
            Assert.IsAssignableFrom<Exception>(exception);
        }

        [Fact]
        public void InvalidVariableException_DefaultConstructor_SetsDefaultMessage()
        {
            // Act
            var exception = new InvalidVariableException();
            
            // Assert
            Assert.Equal("Invalid Use of Variables.", exception.Message);
            Assert.IsAssignableFrom<Exception>(exception);
        }

        [Fact]
        public void InvalidExpressionException_CanBeThrown()
        {
            // Arrange
            string message = "Expression is invalid";
            
            // Act & Assert
            Assert.Throws<InvalidExpressionException>(() => 
            {
                throw new InvalidExpressionException(message);
            });
        }

        [Fact]
        public void InvalidMatrixException_CanBeThrown()
        {
            // Arrange
            string message = "Matrix is invalid";
            
            // Act & Assert
            Assert.Throws<InvalidMatrixException>(() => 
            {
                throw new InvalidMatrixException(message);
            });
        }

        [Fact]
        public void InvalidVariableException_CanBeThrown()
        {
            // Act & Assert
            Assert.Throws<InvalidVariableException>(() => 
            {
                throw new InvalidVariableException();
            });
        }

        [Fact]
        public void InvalidExpressionException_InheritsFromArgumentException()
        {
            // Arrange
            var exception = new InvalidExpressionException("test");
            
            // Act & Assert
            Assert.IsType<InvalidExpressionException>(exception);
            Assert.IsAssignableFrom<ArgumentException>(exception);
        }

        [Fact]
        public void InvalidMatrixException_InheritsFromException()
        {
            // Arrange
            var exception = new InvalidMatrixException("test");
            
            // Act & Assert
            Assert.IsType<InvalidMatrixException>(exception);
            Assert.IsAssignableFrom<Exception>(exception);
        }

        [Fact]
        public void InvalidVariableException_InheritsFromException()
        {
            // Arrange
            var exception = new InvalidVariableException();
            
            // Act & Assert
            Assert.IsType<InvalidVariableException>(exception);
            Assert.IsAssignableFrom<Exception>(exception);
        }
    }
}

---

Add the new file to version control and run the xUnit test suite to ensure all exception tests pass successfully.

A summary of the context that CodeRabbit is considering across the codebase:

Locate the test project .csproj file to confirm the test project path and ensure new test files are picked up by the test runner.

• Executed edits - (🔄 Check again to try again)

[coderabbitai]

Creating a PR to execute the edits....

The changes have been created in this pull request: View PR

[ktshikotshi]

@coderabbitai update the PR to also update the workflow to run the tests for every PR

[coderabbitai]

Tip

For best results, initiate chat on the files or code changes.

Creating a PR to execute the edits....

The changes have been created in this pull request: View PR