updated third party nugets

Jani Giannoudis · Jani Giannoudis · commit 087766b19e59 · 2025-02-12T07:39:21.000+01:00
udapted to .net 9
updated version to 0.9.0-beta.1
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
@@ -12,7 +12,9 @@ jobs:
     - name: Checkout
       uses: actions/checkout@v2
     - name: Setup .NET SDK
-      uses: actions/setup-dotnet@v1
+      uses: actions/setup-dotnet@v4
+      with:
+        dotnet-version: 9.0.x
     - name: Build
       run: dotnet build -c Release
     - name: Test
diff --git a/Client.Test/Case/CaseAvailableTest.cs b/Client.Test/Case/CaseAvailableTest.cs
@@ -3,7 +3,7 @@
 
 namespace PayrollEngine.Client.Test.Case;
 
-/// <summary>Case available function test
+/// <summary>Case available function test.
 /// Test input: case change setup
 /// Test output: bool indicates the case available state
 /// </summary>
diff --git a/Client.Test/Case/CaseAvailableTestRunner.cs b/Client.Test/Case/CaseAvailableTestRunner.cs
@@ -29,7 +29,7 @@ public virtual async Task<IList<CaseScriptTestResult>> Test(CaseAvailableTest te
         }
         if (string.IsNullOrWhiteSpace(test.CaseName))
         {
-            throw new ArgumentException("Available test without case name");
+            throw new ArgumentException("Available test without case name.");
         }
 
         var results = new List<CaseScriptTestResult>();
diff --git a/Client.Test/Case/CaseCustomTest.cs b/Client.Test/Case/CaseCustomTest.cs
@@ -82,7 +82,7 @@ protected CaseSet GetCase(string caseName, string clusterSetName = null, string
     /// <param name="caseFieldName">The case field name</param>
     /// <returns>The case values</returns>
     protected List<CaseFieldValue> GetCasePeriodValues(string caseFieldName) =>
-        GetCasePeriodValues(new[] { caseFieldName });
+        GetCasePeriodValues([caseFieldName]);
 
     /// <summary>Get case period values</summary>
     /// <param name="caseFieldNames">The case field names</param>
@@ -120,7 +120,7 @@ protected List<CaseFieldValue> GetCaseValues(string caseFieldName, string caseSl
         var period = Context.EvaluationPeriod;
         var caseValues = new PayrollService(HttpClient).GetCaseValuesAsync(
             new(Tenant.Id, Payroll.Id), period.Start, period.End,
-            new[] { caseFieldName }, Employee?.Id, caseSlot).Result;
+            [caseFieldName], Employee?.Id, caseSlot).Result;
         return caseValues;
     }
 
diff --git a/Client.Test/Case/CaseScriptTestRunner.cs b/Client.Test/Case/CaseScriptTestRunner.cs
@@ -114,8 +114,8 @@ protected CaseScriptTestResult NewResult(HttpRequestException exception, string
             TestName = testName,
             TestType = CaseTestType.Http,
             ErrorCode = statusCode,
-            HttpStatusCode = statusCode != 0 ? statusCode : default,
-            Expected = expected != null ? DefaultJsonSerializer.Serialize(expected) : default,
+            HttpStatusCode = statusCode != 0 ? statusCode : 0,
+            Expected = expected != null ? DefaultJsonSerializer.Serialize(expected) : null,
             Message = exception.GetBaseMessage()
         };
     }
@@ -143,14 +143,14 @@ protected virtual async Task<CaseSet> GetAvailableCaseAsync(string caseName)
         var @case = await GetCaseAsync(caseName);
         if (@case == null)
         {
-            throw new PayrollException($"Unknown case {caseName}");
+            throw new PayrollException($"Unknown case {caseName}.");
         }
 
         var cases = await new PayrollService(HttpClient).GetAvailableCasesAsync<CaseSet>(
             new(Tenant.Id, Payroll.Id),
             userId: User.Id,
             caseType: @case.CaseType,
-            caseNames: new[] { caseName },
+            caseNames: [caseName],
             employeeId: Employee?.Id,
             evaluationDate: EvaluationDate,
             regulationDate: RegulationDate);
diff --git a/Client.Test/Case/CaseTestRunner.cs b/Client.Test/Case/CaseTestRunner.cs
@@ -237,7 +237,7 @@ protected virtual void InitTest(CaseTest caseTest, CaseTestContext context)
                             division = GetDivisionAsync(context.Tenant.Id, divisionName).Result;
                             if (division == null)
                             {
-                                throw new PayrollException($"Unknown division {divisionName}");
+                                throw new PayrollException($"Unknown division {divisionName}.");
                             }
                             divisions.Add(divisionName, division);
                         }
@@ -273,7 +273,7 @@ protected virtual async Task SetupInitCases(List<CaseChangeSetup> initCases, Cas
                 var division = await GetDivisionAsync(testContext.Tenant.Id, initCase.DivisionName);
                 if (division == null)
                 {
-                    throw new PayrollException($"Unknown division {initCase.DivisionName}");
+                    throw new PayrollException($"Unknown division {initCase.DivisionName}.");
                 }
 
                 initCase.DivisionId = division.Id;
@@ -364,28 +364,28 @@ protected virtual async Task<CaseTestContext> CreateTestContext(CaseTest caseTes
         };
         if (context.Tenant == null)
         {
-            throw new PayrollException($"Missing tenant {caseTest.TenantIdentifier}");
+            throw new PayrollException($"Missing tenant {caseTest.TenantIdentifier}.");
         }
 
         // user
         context.User = await GetUserAsync(context.Tenant.Id, caseTest.UserIdentifier);
         if (context.User == null)
         {
-            throw new PayrollException($"Missing user {caseTest.UserIdentifier}");
+            throw new PayrollException($"Missing user {caseTest.UserIdentifier}.");
         }
 
         // payroll
         context.Payroll = await GetPayrollAsync(context.Tenant.Id, caseTest.PayrollName);
         if (context.Payroll == null)
         {
-            throw new PayrollException($"Missing payroll {caseTest.PayrollName}");
+            throw new PayrollException($"Missing payroll {caseTest.PayrollName}.");
         }
 
         // division
         context.Division = await GetDivisionAsync(context.Tenant.Id, context.Payroll.DivisionId);
         if (context.Division == null)
         {
-            throw new PayrollException($"Missing division {context.Payroll.DivisionName} in payroll {caseTest.PayrollName}");
+            throw new PayrollException($"Missing division {context.Payroll.DivisionName} in payroll {caseTest.PayrollName}.");
         }
 
         // employee
@@ -394,7 +394,7 @@ protected virtual async Task<CaseTestContext> CreateTestContext(CaseTest caseTes
             context.Employee = await GetEmployeeAsync(context.Tenant.Id, caseTest.EmployeeIdentifier);
             if (context.Employee == null)
             {
-                throw new PayrollException($"Missing employee {caseTest.EmployeeIdentifier}");
+                throw new PayrollException($"Missing employee {caseTest.EmployeeIdentifier}.");
             }
         }
 
diff --git a/Client.Test/Case/CaseValidateTestRunner.cs b/Client.Test/Case/CaseValidateTestRunner.cs
@@ -32,7 +32,7 @@ public virtual async Task<IList<CaseScriptTestResult>> Test(CaseValidateTest tes
         var caseName = test.Input?.Case?.CaseName;
         if (string.IsNullOrWhiteSpace(caseName))
         {
-            throw new ArgumentException("Validate test without case name");
+            throw new ArgumentException("Validate test without case name.");
         }
 
         var results = new List<CaseScriptTestResult>();
diff --git a/Client.Test/PayrollEngine.CaseTest.schema.json b/Client.Test/PayrollEngine.CaseTest.schema.json
@@ -866,7 +866,7 @@
         },
         {
           "type": "object",
-          "description": "Case available function test\n            Test input: case change setup\n            Test output: bool indicates the case available state\n            ",
+          "description": "Case available function test.\n            Test input: case change setup\n            Test output: bool indicates the case available state\n            ",
           "required": [
             "caseName"
           ],
diff --git a/Client.Test/PayrollEngine.Client.Test.csproj b/Client.Test/PayrollEngine.Client.Test.csproj
@@ -16,8 +16,8 @@
 	</PropertyGroup>
 
 	<ItemGroup>
-		<PackageReference Include="Microsoft.CodeAnalysis.Compilers" Version="4.10.0" />
-		<PackageReference Include="PayrollEngine.Client.Core" Version="0.8.0-beta.2" />
+		<PackageReference Include="Microsoft.CodeAnalysis.Compilers" Version="4.12.0" />
+		<PackageReference Include="PayrollEngine.Client.Core" Version="0.9.0-beta.1" />
 	</ItemGroup>
 
 	<!-- include xml documention files and json schemas to the nuget package -->
diff --git a/Client.Test/PayrollEngine.Client.Test.xml b/Client.Test/PayrollEngine.Client.Test.xml
diff --git a/Client.Test/PayrollEngine.ReportTest.schema.json b/Client.Test/PayrollEngine.ReportTest.schema.json
@@ -468,7 +468,7 @@
         },
         {
           "type": "object",
-          "description": "Report execute test\n            Test input: report request\n            Test output: report data set\n            "
+          "description": "Report execute test.\n            Test input: report request\n            Test output: report data set\n            "
         }
       ]
     },
diff --git a/Client.Test/Payrun/CollectorTestResults.cs b/Client.Test/Payrun/CollectorTestResults.cs
@@ -24,7 +24,7 @@ public CollectorTestResult(TestPrecision testPrecision, CollectorResultSet expec
 
     /// <summary>Test for invalid result</summary>
     public bool IsInvalidResult() =>
-        ActualResult == null && ExpectedResult.Value != default ||
+        ActualResult == null && ExpectedResult.Value != 0 ||
         ActualResult != null && !ActualResult.AlmostEqualValue(ExpectedResult.Value, TestPrecision.GetDecimals()) ||
         !ValidAttributes();
 
diff --git a/Client.Test/Payrun/PayrunEmployeeTestRunner.cs b/Client.Test/Payrun/PayrunEmployeeTestRunner.cs
@@ -57,7 +57,7 @@ public override async Task<Dictionary<Tenant, List<PayrollTestResult>>> TestAllA
             var existingTenant = await GetTenantAsync(tenant.Identifier);
             if (existingTenant == null)
             {
-                throw new PayrollException($"Missing tenant {tenant.Identifier}");
+                throw new PayrollException($"Missing tenant {tenant.Identifier}.");
             }
 
             // duplicate test employee
@@ -102,7 +102,7 @@ protected virtual async Task DuplicateTestEmployee(int tenantId, ExchangeTenant
 
         if (!employeeIdentifiers.Any())
         {
-            throw new PayrollException($"Missing test employees in tenant {tenant.Identifier}");
+            throw new PayrollException($"Missing test employees in tenant {tenant.Identifier}.");
         }
 
         // insert new test employees
@@ -114,7 +114,7 @@ protected virtual async Task DuplicateTestEmployee(int tenantId, ExchangeTenant
                 var employee = await GetEmployeeAsync(tenantId, employeeIdentifier);
                 if (employee == null)
                 {
-                    throw new PayrollException($"Missing test employee {employeeIdentifier}");
+                    throw new PayrollException($"Missing test employee {employeeIdentifier}.");
                 }
 
                 // find next available employee identifier
@@ -133,7 +133,7 @@ protected virtual async Task DuplicateTestEmployee(int tenantId, ExchangeTenant
                 }
                 if (string.IsNullOrWhiteSpace(testEmployeeIdentifier))
                 {
-                    throw new PayrollException($"Invalid identifier on test employee {employeeIdentifier}");
+                    throw new PayrollException($"Invalid identifier on test employee {employeeIdentifier}.");
                 }
 
                 // create test employee
diff --git a/Client.Test/Payrun/PayrunTestRunner.cs b/Client.Test/Payrun/PayrunTestRunner.cs
@@ -116,19 +116,19 @@ protected virtual void ValidateTenant(ExchangeTenant tenant)
         // employees
         if (tenant.Employees == null || tenant.Employees.Count == 0)
         {
-            throw new PayrollException($"Tenant {tenant.Identifier} without employees");
+            throw new PayrollException($"Tenant {tenant.Identifier} without employees.");
         }
 
         // payrun job invocations
         if (tenant.PayrunJobInvocations == null || tenant.PayrunJobInvocations.Count == 0)
         {
-            throw new PayrollException($"Tenant {tenant.Identifier} without payrun job invocations");
+            throw new PayrollException($"Tenant {tenant.Identifier} without payrun job invocations.");
         }
 
         // payroll results
         if (tenant.PayrollResults == null || !tenant.PayrollResults.Any() || !tenant.PayrollResults[0].HasResults())
         {
-            throw new PayrollException($"Tenant {tenant.Identifier} without payroll result");
+            throw new PayrollException($"Tenant {tenant.Identifier} without payroll result.");
         }
     }
 
diff --git a/Client.Test/Payrun/PayrunTestRunnerBase.cs b/Client.Test/Payrun/PayrunTestRunnerBase.cs
@@ -59,26 +59,26 @@ protected virtual async Task<IList<PayrollTestResult>> TestPayrunJobAsync(Exchan
             // employee
             if (string.IsNullOrWhiteSpace(payrollResult.EmployeeIdentifier))
             {
-                throw new PayrollException("Missing payrun job employee in payroll result");
+                throw new PayrollException("Missing payrun job employee in payroll result.");
             }
             var employee = await GetEmployeeAsync(tenant.Id, payrollResult.EmployeeIdentifier);
             if (employee == null)
             {
-                throw new PayrollException($"Missing payroll result employee with identifier {payrollResult.EmployeeIdentifier}");
+                throw new PayrollException($"Missing payroll result employee with identifier {payrollResult.EmployeeIdentifier}.");
             }
 
             // payrun job
             PayrunJob payrunJob;
             if (string.IsNullOrWhiteSpace(payrollResult.PayrunJobName))
             {
-                throw new PayrollException("Missing payrun job name in payroll result");
+                throw new PayrollException("Missing payrun job name in payroll result.");
             }
             if (jobResultMode == JobResultMode.Single)
             {
                 var invocation = tenant.PayrunJobInvocations.FirstOrDefault(x => string.Equals(x.Name, payrollResult.PayrunJobName));
                 if (invocation == null || !invocation.PayrunJobId.HasValue)
                 {
-                    throw new PayrollException($"Missing payrun job {payrollResult.PayrunJobName}");
+                    throw new PayrollException($"Missing payrun job {payrollResult.PayrunJobName}.");
                 }
 
                 var retroPeriodStart = payrollResult.RetroPeriodStart;
@@ -92,7 +92,7 @@ protected virtual async Task<IList<PayrollTestResult>> TestPayrunJobAsync(Exchan
                                                       x.PeriodStart.Equals(retroPeriodStart.Value)).MaxBy(x => x.Created);
                     if (payrunJob == null)
                     {
-                        throw new PayrollException($"Unknown retro payrun job on period {payrollResult.RetroPeriodStart.Value}");
+                        throw new PayrollException($"Unknown retro payrun job on period {payrollResult.RetroPeriodStart.Value}.");
                     }
                 }
                 else
@@ -106,7 +106,7 @@ protected virtual async Task<IList<PayrollTestResult>> TestPayrunJobAsync(Exchan
                 var employeePayrunJobs = await GetEmployeePayrunJobsAsync(tenant.Id, employee.Id);
                 if (employeePayrunJobs == null || !employeePayrunJobs.Any())
                 {
-                    throw new PayrollException($"Missing payrun job {payrollResult.PayrunJobName}");
+                    throw new PayrollException($"Missing payrun job {payrollResult.PayrunJobName}.");
                 }
 
                 var retroPeriodStart = payrollResult.RetroPeriodStart;
@@ -119,7 +119,7 @@ protected virtual async Task<IList<PayrollTestResult>> TestPayrunJobAsync(Exchan
                                                              x.PeriodStart.Equals(retroPeriodStart.Value)).MaxBy(x => x.Created);
                     if (payrunJob == null)
                     {
-                        throw new PayrollException($"Unknown retro payrun job on period {payrollResult.RetroPeriodStart.Value}");
+                        throw new PayrollException($"Unknown retro payrun job on period {payrollResult.RetroPeriodStart.Value}.");
                     }
                 }
                 else
@@ -129,7 +129,7 @@ protected virtual async Task<IList<PayrollTestResult>> TestPayrunJobAsync(Exchan
                                                                   string.Equals(x.Name, payrollResult.PayrunJobName)).ToList();
                     if (!payrunJobs.Any())
                     {
-                        throw new PayrollException($"Missing payrun job {payrollResult.PayrunJobName}");
+                        throw new PayrollException($"Missing payrun job {payrollResult.PayrunJobName}.");
                     }
                     payrunJob = payrunJobs.OrderByDescending(x => x.Created).First();
                 }
@@ -138,7 +138,7 @@ protected virtual async Task<IList<PayrollTestResult>> TestPayrunJobAsync(Exchan
             // aborted job
             if (payrunJob.JobStatus == PayrunJobStatus.Abort)
             {
-                throw new PayrollException($"Job abort [{payrunJob.Name}]: {payrunJob.Message}");
+                throw new PayrollException($"Job abort [{payrunJob.Name}]: {payrunJob.Message}.");
             }
 
             // prepare result
@@ -155,7 +155,7 @@ protected virtual async Task<IList<PayrollTestResult>> TestPayrunJobAsync(Exchan
                     testResults.Add(testResult);
                     return testResults;
                 }
-                throw new PayrollException($"Missing results for payrun job {payrunJob.Name}");
+                throw new PayrollException($"Missing results for payrun job {payrunJob.Name}.");
             }
 
             // wage type results
diff --git a/Client.Test/Payrun/WageTypeTestResults.cs b/Client.Test/Payrun/WageTypeTestResults.cs
@@ -24,7 +24,7 @@ public WageTypeTestResult(TestPrecision testPrecision, WageTypeResultSet expecte
 
     /// <summary>Test for invalid result</summary>
     public bool IsInvalidResult() =>
-        ActualResult == null && ExpectedResult.Value != default ||
+        ActualResult == null && ExpectedResult.Value != 0 ||
         ActualResult != null && !ActualResult.AlmostEqualValue(ExpectedResult.Value, TestPrecision.GetDecimals()) ||
         !ValidAttributes();
 
diff --git a/Client.Test/Report/ReportBuildTestRunner.cs b/Client.Test/Report/ReportBuildTestRunner.cs
@@ -33,7 +33,7 @@ public virtual async Task<IList<ReportScriptTestResult>> Test(ReportBuildTest te
         try
         {
             // user
-            if (test.Input.UserId == default && !string.IsNullOrWhiteSpace(test.Input.UserIdentifier))
+            if (test.Input.UserId == 0 && !string.IsNullOrWhiteSpace(test.Input.UserIdentifier))
             {
                 var user = await GetUserAsync(Context.Tenant.Id, test.Input.UserIdentifier);
                 test.Input.UserId = user.Id;
diff --git a/Client.Test/Report/ReportExecuteTest.cs b/Client.Test/Report/ReportExecuteTest.cs
@@ -3,7 +3,7 @@
 
 namespace PayrollEngine.Client.Test.Report;
 
-/// <summary>Report execute test
+/// <summary>Report execute test.
 /// Test input: report request
 /// Test output: report data set
 /// </summary>
diff --git a/Client.Test/Report/ReportExecuteTestRunner.cs b/Client.Test/Report/ReportExecuteTestRunner.cs
@@ -36,7 +36,7 @@ public virtual async Task<IList<ReportScriptTestResult>> Test(ReportExecuteTest
         try
         {
             // user
-            if (test.Input.UserId == default && !string.IsNullOrWhiteSpace(test.Input.UserIdentifier))
+            if (test.Input.UserId == 0 && !string.IsNullOrWhiteSpace(test.Input.UserIdentifier))
             {
                 var user = await GetUserAsync(Context.Tenant.Id, test.Input.UserIdentifier);
                 test.Input.UserId = user.Id;
diff --git a/Client.Test/Report/ReportScriptTestRunner.cs b/Client.Test/Report/ReportScriptTestRunner.cs
@@ -101,8 +101,8 @@ protected ReportScriptTestResult NewResult(HttpRequestException exception, strin
             Failed = !success,
             TestName = testName,
             TestType = ReportTestType.Http,
-            HttpStatusCode = exception.StatusCode.HasValue ? (int)exception.StatusCode.Value : default,
-            Expected = expected != null ? DefaultJsonSerializer.Serialize(expected) : default,
+            HttpStatusCode = exception.StatusCode.HasValue ? (int)exception.StatusCode.Value : 0,
+            Expected = expected != null ? DefaultJsonSerializer.Serialize(expected) : null,
             Message = exception.GetBaseMessage()
         };
     }
diff --git a/Client.Test/Report/ReportTestRunner.cs b/Client.Test/Report/ReportTestRunner.cs
diff --git a/Directory.Build.props b/Directory.Build.props

Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ public virtual async Task<IList<CaseScriptTestResult>> Test(CaseAvailableTest te`
`29`	`29`	`}`
`30`	`30`	`if (string.IsNullOrWhiteSpace(test.CaseName))`
`31`	`31`	`{`
`32`		`- throw new ArgumentException("Available test without case name");`
	`32`	`+ throw new ArgumentException("Available test without case name.");`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`var results = new List<CaseScriptTestResult>();`
Original file line number	Diff line number	Diff line change
`@@ -237,7 +237,7 @@ protected virtual void InitTest(CaseTest caseTest, CaseTestContext context)`
`237`	`237`	`division = GetDivisionAsync(context.Tenant.Id, divisionName).Result;`
`238`	`238`	`if (division == null)`
`239`	`239`	`{`
`240`		`- throw new PayrollException($"Unknown division {divisionName}");`
	`240`	`+ throw new PayrollException($"Unknown division {divisionName}.");`
`241`	`241`	`}`
`242`	`242`	`divisions.Add(divisionName, division);`
`243`	`243`	`}`
`@@ -273,7 +273,7 @@ protected virtual async Task SetupInitCases(List<CaseChangeSetup> initCases, Cas`
`273`	`273`	`var division = await GetDivisionAsync(testContext.Tenant.Id, initCase.DivisionName);`
`274`	`274`	`if (division == null)`
`275`	`275`	`{`
`276`		`- throw new PayrollException($"Unknown division {initCase.DivisionName}");`
	`276`	`+ throw new PayrollException($"Unknown division {initCase.DivisionName}.");`
`277`	`277`	`}`
`278`	`278`
`279`	`279`	`initCase.DivisionId = division.Id;`
`@@ -364,28 +364,28 @@ protected virtual async Task<CaseTestContext> CreateTestContext(CaseTest caseTes`
`364`	`364`	`};`
`365`	`365`	`if (context.Tenant == null)`
`366`	`366`	`{`
`367`		`- throw new PayrollException($"Missing tenant {caseTest.TenantIdentifier}");`
	`367`	`+ throw new PayrollException($"Missing tenant {caseTest.TenantIdentifier}.");`
`368`	`368`	`}`
`369`	`369`
`370`	`370`	`// user`
`371`	`371`	`context.User = await GetUserAsync(context.Tenant.Id, caseTest.UserIdentifier);`
`372`	`372`	`if (context.User == null)`
`373`	`373`	`{`
`374`		`- throw new PayrollException($"Missing user {caseTest.UserIdentifier}");`
	`374`	`+ throw new PayrollException($"Missing user {caseTest.UserIdentifier}.");`
`375`	`375`	`}`
`376`	`376`
`377`	`377`	`// payroll`
`378`	`378`	`context.Payroll = await GetPayrollAsync(context.Tenant.Id, caseTest.PayrollName);`
`379`	`379`	`if (context.Payroll == null)`
`380`	`380`	`{`
`381`		`- throw new PayrollException($"Missing payroll {caseTest.PayrollName}");`
	`381`	`+ throw new PayrollException($"Missing payroll {caseTest.PayrollName}.");`
`382`	`382`	`}`
`383`	`383`
`384`	`384`	`// division`
`385`	`385`	`context.Division = await GetDivisionAsync(context.Tenant.Id, context.Payroll.DivisionId);`
`386`	`386`	`if (context.Division == null)`
`387`	`387`	`{`
`388`		`- throw new PayrollException($"Missing division {context.Payroll.DivisionName} in payroll {caseTest.PayrollName}");`
	`388`	`+ throw new PayrollException($"Missing division {context.Payroll.DivisionName} in payroll {caseTest.PayrollName}.");`
`389`	`389`	`}`
`390`	`390`
`391`	`391`	`// employee`
`@@ -394,7 +394,7 @@ protected virtual async Task<CaseTestContext> CreateTestContext(CaseTest caseTes`
`394`	`394`	`context.Employee = await GetEmployeeAsync(context.Tenant.Id, caseTest.EmployeeIdentifier);`
`395`	`395`	`if (context.Employee == null)`
`396`	`396`	`{`
`397`		`- throw new PayrollException($"Missing employee {caseTest.EmployeeIdentifier}");`
	`397`	`+ throw new PayrollException($"Missing employee {caseTest.EmployeeIdentifier}.");`
`398`	`398`	`}`
`399`	`399`	`}`
`400`	`400`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ public virtual async Task<IList<CaseScriptTestResult>> Test(CaseValidateTest tes`
`32`	`32`	`var caseName = test.Input?.Case?.CaseName;`
`33`	`33`	`if (string.IsNullOrWhiteSpace(caseName))`
`34`	`34`	`{`
`35`		`- throw new ArgumentException("Validate test without case name");`
	`35`	`+ throw new ArgumentException("Validate test without case name.");`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`var results = new List<CaseScriptTestResult>();`
Original file line number	Diff line number	Diff line change
`@@ -866,7 +866,7 @@`
`866`	`866`	`},`
`867`	`867`	`{`
`868`	`868`	`"type": "object",`
`869`		`- "description": "Case available function test\n Test input: case change setup\n Test output: bool indicates the case available state\n ",`
	`869`	`+ "description": "Case available function test.\n Test input: case change setup\n Test output: bool indicates the case available state\n ",`
`870`	`870`	`"required": [`
`871`	`871`	`"caseName"`
`872`	`872`	`],`