diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 0000000..a76d146 --- /dev/null +++ b/.editorconfig @@ -0,0 +1,205 @@ +# EditorConfig helps developers define and +# maintain consistent coding styles between +# different editors and IDEs + +# https://editorconfig.org + +# top-most EditorConfig file +root = true + +[*] +indent_style = space +insert_final_newline = true +charset = utf-8 + +[*.{sln,slnx,*proj,props}] +charset = utf-8-bom +indent_style = space +indent_size = 2 +tab_width = 2 + +[*.{cs,cake}] +indent_style = space +indent_size = 4 +tab_width = 4 + +[*] +file_header_template = Copyright (c) Charlie Poole, Rob Prouse and Contributors. MIT License - see LICENSE.txt + +# https://github.com/nunit/docs/wiki/Coding-Standards#namespace-class-structure-interface-enumeration-and-method-definitions +csharp_indent_braces = false +csharp_new_line_before_catch = true +csharp_new_line_before_else = true +csharp_new_line_before_finally = true + +# https://github.com/nunit/docs/wiki/Coding-Standards#spaces +csharp_space_after_cast = false +csharp_space_after_comma = true +csharp_space_after_keywords_in_control_flow_statements = true +csharp_space_around_binary_operators = before_and_after +csharp_space_around_declaration_statements = do_not_ignore +csharp_space_before_open_square_brackets = false +csharp_space_before_semicolon_in_for_statement = false +csharp_space_between_empty_square_brackets = false +csharp_space_between_method_call_empty_parameter_list_parentheses = false +csharp_space_between_method_call_name_and_opening_parenthesis = false +csharp_space_between_method_call_parameter_list_parentheses = false +csharp_space_between_method_declaration_empty_parameter_list_parentheses = false +csharp_space_between_method_declaration_name_and_open_parenthesis = false +csharp_space_between_method_declaration_parameter_list_parentheses = false +csharp_space_between_parentheses = none +csharp_space_between_square_brackets = false + +# https://github.com/nunit/docs/wiki/Coding-Standards#indentation +csharp_indent_block_contents = true +csharp_indent_case_contents = true +csharp_indent_switch_labels = true + +csharp_prefer_braces = when_multiline:silent + +# https://github.com/nunit/docs/wiki/Coding-Standards#naming +dotnet_style_predefined_type_for_locals_parameters_members = true:suggestion +dotnet_style_predefined_type_for_member_access = true:suggestion + +# The first matching rule wins, more specific rules at the top + +# dotnet_naming_rule.*.symbols does not yet support a comma-separated list https://github.com/dotnet/roslyn/issues/20891 +# dotnet_naming_symbols.*.applicable_kinds does not yet support namespace, type_parameter or local https://github.com/dotnet/roslyn/issues/18121 + +dotnet_naming_style.pascal_case.capitalization = pascal_case + +dotnet_naming_symbols.namespaces_types_and_non_field_members.applicable_kinds = namespace, class, struct, enum, interface, delegate, type_parameter, method, property, event +dotnet_naming_rule.namespaces_types_and_non_field_members.severity = error +dotnet_naming_rule.namespaces_types_and_non_field_members.symbols = namespaces_types_and_non_field_members +dotnet_naming_rule.namespaces_types_and_non_field_members.style = pascal_case + +dotnet_naming_symbols.visible_fields.applicable_kinds = field +dotnet_naming_symbols.visible_fields.applicable_accessibilities = public, protected, protected_internal +dotnet_naming_rule.visible_fields.severity = error +dotnet_naming_rule.visible_fields.symbols = visible_fields +dotnet_naming_rule.visible_fields.style = pascal_case + +dotnet_naming_symbols.internal_fields.applicable_kinds = field +dotnet_naming_symbols.internal_fields.applicable_accessibilities = internal +dotnet_naming_rule.internal_fields.severity = error +dotnet_naming_rule.internal_fields.symbols = internal_fields +dotnet_naming_rule.internal_fields.style = pascal_case + +dotnet_naming_symbols.static_readonly_fields.applicable_kinds = field +dotnet_naming_symbols.static_readonly_fields.required_modifiers = static, readonly +dotnet_naming_rule.static_readonly_fields.severity = error +dotnet_naming_rule.static_readonly_fields.symbols = static_readonly_fields +dotnet_naming_rule.static_readonly_fields.style = pascal_case + +dotnet_naming_symbols.constant_fields.applicable_kinds = field +dotnet_naming_symbols.constant_fields.required_modifiers = const +dotnet_naming_rule.constant_fields.severity = error +dotnet_naming_rule.constant_fields.symbols = constant_fields +dotnet_naming_rule.constant_fields.style = pascal_case + +dotnet_naming_style.underscore_camel_case.capitalization = camel_case +dotnet_naming_style.underscore_camel_case.required_prefix = _ + +dotnet_naming_symbols.remaining_fields.applicable_kinds = field +dotnet_naming_rule.remaining_fields.severity = error +dotnet_naming_rule.remaining_fields.symbols = remaining_fields +dotnet_naming_rule.remaining_fields.style = underscore_camel_case + +dotnet_naming_style.camel_case.capitalization = camel_case + +dotnet_naming_symbols.parameters_and_locals.applicable_kinds = parameter, local +dotnet_naming_rule.parameters_and_locals.severity = error +dotnet_naming_rule.parameters_and_locals.symbols = parameters_and_locals +dotnet_naming_rule.parameters_and_locals.style = camel_case + +# https://github.com/nunit/docs/wiki/Coding-Standards#file-organization +dotnet_sort_system_directives_first = true + +# https://github.com/nunit/docs/wiki/Coding-Standards#use-of-the-var-keyword +# Would be true:warning, except that that so much existing code is not consistent with the coding standard. +csharp_style_var_when_type_is_apparent = true:suggestion + +# DOC100: Place text in paragraphs +dotnet_diagnostic.DOC100.severity = silent + + +# Expression-bodied members +csharp_style_expression_bodied_accessors = when_on_single_line:warning +csharp_style_expression_bodied_constructors = false:none +csharp_style_expression_bodied_indexers = when_on_single_line:warning +csharp_style_expression_bodied_lambdas = when_on_single_line:suggestion +csharp_style_expression_bodied_local_functions = when_on_single_line:suggestion +csharp_style_expression_bodied_methods = false:none +csharp_style_expression_bodied_operators = when_on_single_line:suggestion +csharp_style_expression_bodied_properties = when_on_single_line:suggestion + +############################################################################################ +# CSharp Analysis +############################################################################################ + + +# CS3016: Arrays as attribute arguments is not CLS-compliant +# Microsofts own MemberNotNull attribute expects an array +dotnet_diagnostic.CS3016.severity = none + +# CA1512: Use ArgumentOutOfRangeException throw helper +dotnet_diagnostic.CA1512.severity = warning +# CA1510: Use ArgumentNullException throw helper +dotnet_diagnostic.CA1510.severity = warning + +############################################################################################ +# IDE Analysis +############################################################################################ + +# IDE0003: Remove qualification +dotnet_diagnostic.IDE0003.severity = warning + +# IDE0005: Remove unnecessary usings/imports +dotnet_diagnostic.IDE0005.severity = error + +# IDE0011: Add braces +dotnet_diagnostic.IDE0011.severity = warning + +# IDE0044: Add readonly modifier +dotnet_diagnostic.IDE0044.severity = warning + +# IDE0055: Fix formatting (Skipping this as it doesnt say WHAT is wrong. Rely on StyleCop instead) +dotnet_diagnostic.IDE0055.severity = none + +# IDE1006: Naming Styles +dotnet_diagnostic.IDE1006.severity = warning + +# IDE0036: Order modifiers +dotnet_diagnostic.IDE0036.severity = warning + +# IDE0290: Use primary constructor +dotnet_diagnostic.IDE0290.severity = none + +################################################################################## +# CSharpIsNull Analyzers + +dotnet_style_prefer_is_null_check_over_reference_equality_method = true:warning + +# CSIsNull001: Use `is null` for null checks +dotnet_diagnostic.CSIsNull001.severity = warning + +# CSIsNull002: Use `is object` for non-null checks +dotnet_diagnostic.CSIsNull002.severity = warning +dotnet_style_operator_placement_when_wrapping = beginning_of_line +tab_width = 4 +indent_size = 4 +end_of_line = crlf +csharp_indent_labels = one_less_than_current +dotnet_style_coalesce_expression = true:suggestion +dotnet_style_null_propagation = true:suggestion +dotnet_style_prefer_auto_properties = true:silent +dotnet_style_object_initializer = true:suggestion +dotnet_style_collection_initializer = true:suggestion +dotnet_style_prefer_simplified_boolean_expressions = true:suggestion +csharp_using_directive_placement = outside_namespace:silent +csharp_prefer_simple_using_statement = true:suggestion +csharp_style_namespace_declarations = block_scoped:silent +csharp_style_prefer_method_group_conversion = true:silent +csharp_style_prefer_top_level_statements = true:silent +csharp_style_prefer_primary_constructors = true:suggestion +dotnet_style_prefer_conditional_expression_over_assignment = true:silent diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..241a2cf --- /dev/null +++ b/.gitattributes @@ -0,0 +1,5 @@ +* text=auto eol=lf +*.cs text eol=crlf +*.py text eol=lf +*.yml text eol=lf +*.json text eol=lf diff --git a/.github/workflows/compatibility.yml b/.github/workflows/compatibility.yml new file mode 100644 index 0000000..5fe0b6b --- /dev/null +++ b/.github/workflows/compatibility.yml @@ -0,0 +1,75 @@ +name: Adapter compatibility + +on: + push: + pull_request: + workflow_dispatch: + inputs: + profile: + description: Reviewed package and lock profile + type: choice + options: + - historical-alpha + default: historical-alpha + require_cooperative_stop: + description: Also require token delivery, finally and teardown for every runner-stop probe + type: boolean + default: false + +permissions: + contents: read + +concurrency: + group: compatibility-${{ github.ref }} + cancel-in-progress: false + +jobs: + compatibility: + name: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: [windows-2025, ubuntu-24.04, macos-15] + runs-on: ${{ matrix.os }} + timeout-minutes: 25 + defaults: + run: + shell: bash + env: + VALIDATION_PROFILE: ${{ inputs.profile || 'historical-alpha' }} + REQUIRE_STOP: ${{ inputs.require_cooperative_stop || false }} + DOTNET_CLI_TELEMETRY_OPTOUT: '1' + DOTNET_NOLOGO: '1' + PYTHONDONTWRITEBYTECODE: '1' + steps: + - name: Checkout + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + persist-credentials: false + - name: Set up Python + uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6 + with: + python-version: '3.13' + - name: Check reporting and profile guards + run: python -m unittest discover -s tests -v + - name: Read reviewed SDK selection + id: profile + run: python run.py profile --profile "profiles/$VALIDATION_PROFILE.json" --github-output "$GITHUB_OUTPUT" + - name: Install SDK and target runtimes + uses: actions/setup-dotnet@a98b56852c35b8e3190ac28c8c2271da59106c68 # v6 + with: + dotnet-version: ${{ steps.profile.outputs.dotnet-versions }} + cache: false + - name: Run compatibility checks and observe runner stop + run: python run.py run --profile "profiles/$VALIDATION_PROFILE.json" --output artifacts/run + - name: Publish separate statuses and apply selected stop policy + if: ${{ always() }} + run: python ci_summary.py --results artifacts/run/results.json --summary "$GITHUB_STEP_SUMMARY" --require-stop "$REQUIRE_STOP" + - name: Retain reports, failures and process evidence + if: ${{ always() }} + uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7 + with: + name: compatibility-${{ matrix.os }}-${{ github.run_id }}-${{ github.run_attempt }} + path: artifacts/run + if-no-files-found: warn + retention-days: 14 diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..c0c1831 --- /dev/null +++ b/.gitignore @@ -0,0 +1,9 @@ +artifacts/ +**/bin/ +**/obj/ +__pycache__/ +*.pyc +.packages/ +.http-cache/ +.cli-home/ +reviewed-packages/ diff --git a/Directory.Build.props b/Directory.Build.props new file mode 100644 index 0000000..30c7f34 --- /dev/null +++ b/Directory.Build.props @@ -0,0 +1,14 @@ + + + 14 + enable + disable + false + true + true + true + 4.6.1 + 5.1.0-alpha.0.50 + 6.4.0-alpha.0.46 + + diff --git a/EscapedNames.json b/EscapedNames.json new file mode 100644 index 0000000..e07cd8f --- /dev/null +++ b/EscapedNames.json @@ -0,0 +1,12 @@ +[ + { + "uid": "NUnit.AdapterCompatibility.CompatibilityCases.Named case (with space)", + "displayName": "Named case (with space)", + "escaped": "NUnit.AdapterCompatibility.CompatibilityCases.Named case \\(with space\\)" + }, + { + "uid": "NUnit.AdapterCompatibility.CompatibilityCases.ParameterizedIdentity(\"a \\\"quoted\\\" value\")", + "displayName": "ParameterizedIdentity(\"a \\\"quoted\\\" value\")", + "escaped": "NUnit.AdapterCompatibility.CompatibilityCases.ParameterizedIdentity\\(\"a \\\\\"quoted\\\\\" value\"\\)" + } +] diff --git a/Harness/Harness.csproj b/Harness/Harness.csproj new file mode 100644 index 0000000..dfc491d --- /dev/null +++ b/Harness/Harness.csproj @@ -0,0 +1,9 @@ + + + net10.0 + Exe + + + + + diff --git a/Harness/Program.cs b/Harness/Program.cs new file mode 100644 index 0000000..36fcea3 --- /dev/null +++ b/Harness/Program.cs @@ -0,0 +1,497 @@ +// Copyright (c) Charlie Poole, Rob Prouse and Contributors. MIT License - see LICENSE.txt + +using System; +using System.Collections.Concurrent; +using System.Collections.Generic; +using System.Diagnostics; +using System.IO; +using System.Linq; +using System.Text; +using System.Text.Json; +using System.Threading.Tasks; +using System.Xml.Linq; + +using Microsoft.TestPlatform.VsTestConsole.TranslationLayer; +using Microsoft.VisualStudio.TestPlatform.ObjectModel; +using Microsoft.VisualStudio.TestPlatform.ObjectModel.Client; +using Microsoft.VisualStudio.TestPlatform.ObjectModel.Logging; + +namespace NUnit.AdapterCompatibility.Harness +{ + /// + /// Drives the public VSTest protocol and MTP executable without modifying either adapter. + /// + internal static class Program + { + private static readonly JsonSerializerOptions JsonOptions = new() { WriteIndented = true }; + private static bool _negativeParameter; + + private static async Task Main(string[] args) + { + if (args.Length is < 4 or > 5 || (args.Length == 5 && args[4] != "--baseline-only" && args[4] != "--negative-parameter")) + { + Console.Error.WriteLine("Usage: Harness [--baseline-only|--negative-parameter]"); + return 2; + } + + var evidence = Path.GetFullPath(args[3]); + if (Directory.Exists(evidence)) + throw new IOException("Use a fresh evidence directory; previous results must remain intact."); + + Directory.CreateDirectory(evidence); + _negativeParameter = args.Length == 5 && args[4] == "--negative-parameter"; + try + { + object receipt = args[0] switch + { + "vstest" => await RunVSTest(Path.GetFullPath(args[1]), args[2], evidence, args.Length == 5), + "mtp" => await RunMtp(Path.GetFullPath(args[1]), args[2], evidence, args.Length == 5), + _ => throw new ArgumentException("Unknown execution path.") + }; + var json = JsonSerializer.Serialize(receipt, JsonOptions); + File.WriteAllText(Path.Combine(evidence, "receipt.json"), json); + Console.WriteLine("Compatibility checks completed: " + evidence); + using var document = JsonDocument.Parse(json); + if (document.RootElement.TryGetProperty("ContractGaps", out var gaps) && gaps.GetArrayLength() != 0) + return 1; + return 0; + } + catch (Exception exception) + { + File.WriteAllText(Path.Combine(evidence, "failure.txt"), exception.ToString()); + Console.Error.WriteLine(exception); + return 1; + } + } + + private static async Task RunVSTest(string assembly, string consolePath, string evidence, bool baselineOnly) + { + var wrapper = new VsTestConsoleWrapper(consolePath, + new ConsoleParameters { LogFilePath = Path.Combine(evidence, "vstest.log") }); + wrapper.StartSession(); + try + { + wrapper.InitializeExtensions(new[] { Path.Combine(Path.GetDirectoryName(assembly)!, "NUnit3.TestAdapter.dll") }); + var discoveries = new List(); + for (int index = 0; index < 2; index++) + { + var handler = new DiscoveryEvents(); + wrapper.DiscoverTests(new[] { assembly }, Settings(Path.Combine(evidence, "discovery")), handler); + Require(!handler.Aborted && handler.Tests.Count == 10, "Expected all ten discovered cases."); + discoveries.Add(handler.Tests.ToArray()); + } + + var tests = discoveries[0]; + Require(tests.OrderBy(item => item.Id).Select(item => (item.Id, item.FullyQualifiedName, item.DisplayName)) + .SequenceEqual(discoveries[1].OrderBy(item => item.Id).Select(item => (item.Id, item.FullyQualifiedName, item.DisplayName))), + "Discovery identities changed between requests in the same session."); + Save(Path.Combine(evidence, "discovery.json"), tests.Select(Identity)); + + var runDirectory = Path.Combine(evidence, "all"); + var ordinary = tests.Where(item => !item.FullyQualifiedName.EndsWith("Cancellation", StringComparison.Ordinal)).ToArray(); + var all = new RunEvents(); + wrapper.RunTests(ordinary, Settings(runDirectory), all); + SaveRun(Path.Combine(evidence, "all-results.json"), all); + Require(all.Results.Count == 8 && all.Results.Count(item => item.Outcome == TestOutcome.Passed) == 6 + && all.Results.Count(item => item.Outcome == TestOutcome.Failed) == 1 + && all.Results.Count(item => item.Outcome == TestOutcome.Skipped) == 1, + "Unexpected ordinary pass/fail/ignore results."); + Require(all.Results.All(item => ordinary.Any(test => test.Id == item.TestCase.Id)), "Result identity did not match discovery."); + Require(all.Results.Single(item => item.Outcome == TestOutcome.Failed).ErrorMessage?.Contains("compatibility-intentional-failure", StringComparison.Ordinal) == true, + "Expected failure message was lost."); + Require(all.Results.Single(item => item.Outcome == TestOutcome.Failed).ErrorStackTrace?.Contains("IntentionalFailure", StringComparison.Ordinal) == true, + "Expected failure stack trace was lost."); + Require(all.Results.SelectMany(item => item.Messages).Any(item => item.Text?.Contains("compatibility-standard-output", StringComparison.Ordinal) == true), + "Expected test output was lost."); + ValidateObservations(runDirectory, assembly, expectEntryAssembly: false); + + var selections = tests.Where(item => item.FullyQualifiedName.Contains("ParameterizedIdentity", StringComparison.Ordinal) + || item.DisplayName == "Named case (with space)").ToArray(); + Require(selections.Length == 4, "Expected four parameterized/custom identity probes."); + for (int index = 0; index < selections.Length; index++) + { + var selected = new RunEvents(); + wrapper.RunTests(new[] { selections[index] }, Settings(Path.Combine(evidence, "selected-" + index)), selected); + SaveRun(Path.Combine(evidence, "selected-" + index + ".json"), selected); + Require(selected.Results.Count == 1 && selected.Results.Single().TestCase.Id == selections[index].Id + && selected.Results.Single().Outcome == TestOutcome.Passed, "Exact selected identity was not preserved."); + } + + var timerDirectory = Path.Combine(evidence, "per-test-timer"); + var timer = new RunEvents(); + wrapper.RunTests(tests.Where(item => item.FullyQualifiedName.EndsWith(".PerTestCancellation", StringComparison.Ordinal)), + Settings(timerDirectory), timer); + SaveRun(Path.Combine(evidence, "per-test-timer.json"), timer); + Require(timer.Results.Count == 1 && timer.Results.Single().Outcome == TestOutcome.Failed + && HasObservation(timerDirectory, "token-cancelled") && HasObservation(timerDirectory, "finally"), + "The framework's per-test cancellation positive control did not execute as expected."); + + var baseline = new + { + Path = "VSTest protocol", + Assembly = assembly, + Host = consolePath, + Discovered = tests.Length, + OrdinaryPassed = 6, + ExpectedFailed = 1, + ExpectedSkipped = 1, + ExactSelections = selections.Length, + PerTestTimerTokenAndCleanup = true, + ContractGaps = Array.Empty(), + CancellationExecuted = false, + TypedSettingsScope = "String run parameters and framework conversions only; arbitrary typed settings are not proved." + }; + Save(Path.Combine(evidence, "baseline.json"), baseline); + if (baselineOnly) + return baseline; + + var cancellationDirectory = Path.Combine(evidence, "cancellation"); + var cancellation = new RunEvents(); + var runTask = Task.Run(() => wrapper.RunTests( + tests.Where(item => item.FullyQualifiedName.EndsWith(".CooperativeCancellation", StringComparison.Ordinal)), + Settings(cancellationDirectory), cancellation)); + await WaitForObservation(cancellationDirectory, "started", runTask); + wrapper.CancelTestRun(); + bool timedOut = false; + try + { + await runTask.WaitAsync(TimeSpan.FromSeconds(20)); + } + catch (TimeoutException) + { + timedOut = true; + throw; + } + finally + { + SaveRun(Path.Combine(evidence, "cancellation-results.json"), cancellation); + Save(Path.Combine(evidence, "cancellation-probe.json"), new + { + TimedOut = timedOut, + cancellation.Completed, + cancellation.Cancelled, + cancellation.Aborted, + TokenDelivered = HasObservation(cancellationDirectory, "token-cancelled"), + FinallyExecuted = HasObservation(cancellationDirectory, "finally") + }); + } + var tokenDelivered = HasObservation(cancellationDirectory, "token-cancelled"); + var finallyExecuted = HasObservation(cancellationDirectory, "finally"); + Require(cancellation.Completed && (cancellation.Cancelled || cancellation.Aborted), "VSTest did not acknowledge cancellation."); + Require(tokenDelivered && finallyExecuted, "The runner stopped without cooperative token delivery and finally cleanup."); + + return new + { + Path = "VSTest protocol", + Assembly = assembly, + Host = consolePath, + Discovered = tests.Length, + OrdinaryPassed = 6, + ExpectedFailed = 1, + ExpectedSkipped = 1, + ExactSelections = selections.Length, + CancellationAcknowledged = true, + CancellationTokenDelivered = tokenDelivered, + CancellationFinallyExecuted = finallyExecuted, + CancellationResultCount = cancellation.Results.Count, + TypedSettingsScope = "String run parameters and framework conversions only; arbitrary typed settings are not proved." + }; + } + finally + { + wrapper.EndSession(); + } + } + + private static async Task RunMtp(string assembly, string dotnet, string evidence, bool baselineOnly) + { + var discovery = await InvokeMtp(dotnet, assembly, evidence, "discovery", "--list-tests", "json"); + Require(discovery.ExitCode == 0, "MTP discovery failed."); + var repeat = await InvokeMtp(dotnet, assembly, evidence, "discovery-repeat", "--list-tests", "json"); + var identities = DiscoveryIdentities(discovery.Output); + Require(identities.Length == 10 && identities.OrderBy(item => item.Uid, StringComparer.Ordinal) + .SequenceEqual(DiscoveryIdentities(repeat.Output).OrderBy(item => item.Uid, StringComparer.Ordinal)), "MTP discovery identities changed or cases were lost."); + Require(identities.Any(item => item.DisplayName == "ParameterizedIdentity(\"café λ\")"), "MTP discovery lost the Unicode identity."); + Save(Path.Combine(evidence, "discovery.json"), identities); + + var all = await InvokeMtp(dotnet, assembly, evidence, "all", "--report-trx", "--report-trx-filename", "results.trx"); + var results = ReadTrx(Path.Combine(evidence, "all")); + Require(all.ExitCode != 0 && results.Length == 10 && results.Count(item => item.Attribute("outcome")?.Value == "Passed") == 6 + && results.Count(item => item.Attribute("outcome")?.Value == "Failed") == 1 + && results.Count(item => item.Attribute("outcome")?.Value == "NotExecuted") == 3, + "Unexpected MTP pass/fail results."); + Require(results.Any(item => item.Value.Contains("compatibility-intentional-failure", StringComparison.Ordinal)), "MTP failure message was lost."); + Require(results.Any(item => item.Value.Contains("compatibility-standard-output", StringComparison.Ordinal)), "MTP test output was lost."); + Require(results.Select(item => item.Attribute("testName")!.Value).OrderBy(item => item, StringComparer.Ordinal) + .SequenceEqual(identities.Select(item => item.DisplayName).OrderBy(item => item, StringComparer.Ordinal)), + "MTP ordinary results did not retain their discovered display identities."); + ValidateObservations(Path.Combine(evidence, "all", "observations"), assembly, expectEntryAssembly: true); + + var filtered = await InvokeMtp(dotnet, assembly, evidence, "selected", "--filter", + "FullyQualifiedName=NUnit.AdapterCompatibility.CompatibilityCases.OutputAndPass", + "--report-trx", "--report-trx-filename", "results.trx"); + var selected = ReadTrx(Path.Combine(evidence, "selected")); + Require(filtered.ExitCode == 0 && selected.Length == 1 && selected[0].Attribute("outcome")?.Value == "Passed", + "MTP exact method filter did not select one passing test."); + + var selections = identities.Where(item => item.Uid.Contains("ParameterizedIdentity", StringComparison.Ordinal) + || item.DisplayName == "Named case (with space)").ToArray(); + Require(selections.Length == 4, "Expected four MTP parameterized/custom identities."); + var identitySelections = new List(); + var contractGaps = new List(); + for (int index = 0; index < selections.Length; index++) + { + var run = await InvokeMtp(dotnet, assembly, evidence, "uid-" + index, "--filter-uid", selections[index].Uid, + "--report-trx", "--report-trx-filename", "results.trx"); + var result = ReadTrx(Path.Combine(evidence, "uid-" + index)); + bool passed = run.ExitCode == 0 && result.Length == 1 && result[0].Attribute("outcome")?.Value == "Passed" + && result[0].Attribute("testName")?.Value == selections[index].DisplayName; + identitySelections.Add(new { selections[index].Uid, selections[index].DisplayName, run.ExitCode, ResultCount = result.Length, Passed = passed }); + if (!passed) + contractGaps.Add("MTP selected UID: " + selections[index].Uid); + } + Save(Path.Combine(evidence, "uid-results.json"), identitySelections); + + var timer = await InvokeMtp(dotnet, assembly, evidence, "per-test-timer", "--filter-uid", + identities.Single(item => item.Uid.EndsWith(".PerTestCancellation", StringComparison.Ordinal)).Uid, + "--report-trx", "--report-trx-filename", "results.trx"); + var timerDirectory = Path.Combine(evidence, "per-test-timer", "observations"); + var timerResults = ReadTrx(Path.Combine(evidence, "per-test-timer")); + Require(timer.ExitCode != 0 && timerResults.Length == 1 && timerResults[0].Attribute("outcome")?.Value == "Failed" + && HasObservation(timerDirectory, "token-cancelled") && HasObservation(timerDirectory, "finally"), + "MTP per-test cancellation positive control did not execute as expected."); + + var baseline = new + { + Path = "MTP executable", + Assembly = assembly, + Host = dotnet, + Discovered = identities.Length, + OrdinaryPassed = 6, + ExpectedFailed = 1, + ReportedResults = results.Length, + ExactSelectionAttempts = 5, + ExactSelectionsPassed = 5 - contractGaps.Count, + PerTestTimerTokenAndCleanup = true, + ContractGaps = contractGaps.ToArray(), + CancellationExecuted = false, + TypedSettingsScope = "String run parameters and framework conversions only; arbitrary typed settings are not proved." + }; + Save(Path.Combine(evidence, "baseline.json"), baseline); + if (baselineOnly) + return baseline; + + var cancellation = await InvokeMtp(dotnet, assembly, evidence, "cancellation", "--filter", + "FullyQualifiedName=NUnit.AdapterCompatibility.CompatibilityCases.CooperativeCancellation", "--timeout", "5s", + "--report-trx", "--report-trx-filename", "results.trx"); + var cancellationDirectory = Path.Combine(evidence, "cancellation", "observations"); + Require(HasObservation(cancellationDirectory, "started"), "MTP cancellation case never started."); + Require(cancellation.ExitCode != 0, "MTP did not report the bounded session timeout."); + Require(HasObservation(cancellationDirectory, "token-cancelled") && HasObservation(cancellationDirectory, "finally"), + "MTP session stop did not reach the test cancellation token and finally cleanup."); + + return new + { + Path = "MTP executable", + Assembly = assembly, + Host = dotnet, + Discovered = identities.Length, + OrdinaryPassed = 6, + ExpectedFailed = 1, + ReportedResults = results.Length, + ExactSelectionAttempts = 5, + ExactSelectionsPassed = 5 - contractGaps.Count, + CancellationExit = cancellation.ExitCode, + CancellationTokenDelivered = HasObservation(cancellationDirectory, "token-cancelled"), + CancellationFinallyExecuted = HasObservation(cancellationDirectory, "finally"), + CancellationResultFiles = Directory.GetFiles(Path.Combine(evidence, "cancellation"), "*.trx", SearchOption.AllDirectories).Length, + ContractGaps = contractGaps.ToArray(), + TypedSettingsScope = "String run parameters and framework conversions only; arbitrary typed settings are not proved." + }; + } + + private static async Task<(int ExitCode, string Output)> InvokeMtp(string dotnet, string assembly, string evidence, string name, params string[] arguments) + { + var directory = Path.Combine(evidence, name); + Directory.CreateDirectory(directory); + var settingsPath = Path.Combine(directory, "test.runsettings"); + File.WriteAllText(settingsPath, Settings(Path.Combine(directory, "observations"))); + var start = new ProcessStartInfo(dotnet) + { + UseShellExecute = false, + RedirectStandardOutput = true, + RedirectStandardError = true, + StandardOutputEncoding = Encoding.UTF8, + StandardErrorEncoding = Encoding.UTF8, + CreateNoWindow = true, + WorkingDirectory = directory + }; + start.ArgumentList.Add(assembly); + start.ArgumentList.Add("--settings"); + start.ArgumentList.Add(settingsPath); + start.ArgumentList.Add("--results-directory"); + start.ArgumentList.Add(directory); + foreach (var argument in arguments) + start.ArgumentList.Add(argument); + Save(Path.Combine(directory, "command.json"), new { Executable = dotnet, Arguments = start.ArgumentList.ToArray() }); + using var process = Process.Start(start) ?? throw new InvalidOperationException("MTP process did not start."); + var stdout = process.StandardOutput.ReadToEndAsync(); + var stderr = process.StandardError.ReadToEndAsync(); + try + { + await process.WaitForExitAsync().WaitAsync(TimeSpan.FromSeconds(35)); + } + catch (TimeoutException) + { + process.Kill(entireProcessTree: true); + await process.WaitForExitAsync(); + Save(Path.Combine(directory, "timeout.json"), new { ProcessId = process.Id, BoundSeconds = 35, OwnedTreeKilled = true }); + throw; + } + finally + { + File.WriteAllText(Path.Combine(directory, "stdout.txt"), await stdout); + File.WriteAllText(Path.Combine(directory, "stderr.txt"), await stderr); + } + return (process.ExitCode, await stdout); + } + + private static TestIdentity[] DiscoveryIdentities(string output) + { + using var document = JsonDocument.Parse(output); + Require(document.RootElement.GetProperty("schemaVersion").GetInt32() == 1, "Unknown MTP discovery schema."); + return document.RootElement.GetProperty("tests").EnumerateArray().Select(item => new TestIdentity( + item.GetProperty("uid").GetString()!, item.GetProperty("displayName").GetString()!)).ToArray(); + } + + private static XElement[] ReadTrx(string directory) + { + var paths = Directory.GetFiles(directory, "*.trx", SearchOption.AllDirectories); + Require(paths.Length == 1, "Expected exactly one MTP TRX result."); + return XDocument.Load(paths[0]).Descendants().Where(item => item.Name.LocalName == "UnitTestResult").ToArray(); + } + + private static void ValidateObservations(string directory, string assembly, bool expectEntryAssembly) + { + var observations = Directory.GetFiles(directory, "started-*.xml").Select(path => XElement.Load(path)).ToArray(); + Require(observations.Length == 7, "Expected seven executed test bodies; ignored tests must not execute."); + Require(observations.All(item => string.Equals(item.Attribute("assembly")?.Value, assembly, StringComparison.OrdinalIgnoreCase)), + "Tests ran from an unexpected assembly location."); + if (expectEntryAssembly) + { + Require(observations.All(item => string.Equals(item.Attribute("entry-assembly")?.Value, assembly, StringComparison.OrdinalIgnoreCase)), + "MTP did not retain the project executable as its entry assembly."); + } + } + + private static async Task WaitForObservation(string directory, string phase, Task runTask) + { + var deadline = Stopwatch.StartNew(); + while (!HasObservation(directory, phase)) + { + Require(!runTask.IsCompleted, "The cancellation run completed before its test started."); + Require(deadline.Elapsed < TimeSpan.FromSeconds(20), "The cancellation test did not start within its bound."); + await Task.Delay(50); + } + } + + private static bool HasObservation(string directory, string phase) => Directory.Exists(directory) + && Directory.GetFiles(directory, phase + "-*.xml").Length != 0; + + /// + /// Creates run settings for the native harness architecture and isolated evidence. + /// + private static string Settings(string evidence) => new XElement("RunSettings", + new XElement("RunConfiguration", new XElement("TargetPlatform", System.Runtime.InteropServices.RuntimeInformation.ProcessArchitecture.ToString().ToLowerInvariant())), + new XElement("NUnit", new XElement("NumberOfTestWorkers", 0), new XElement("ShadowCopyFiles", false)), + new XElement("TestRunParameters", + new XElement("Parameter", new XAttribute("name", "evidence"), new XAttribute("value", evidence)), + new XElement("Parameter", new XAttribute("name", "text"), new XAttribute("value", "alpha; beta = café & λ")), + new XElement("Parameter", new XAttribute("name", "integer"), new XAttribute("value", _negativeParameter ? "41" : "42")), + new XElement("Parameter", new XAttribute("name", "boolean"), new XAttribute("value", "true")))) + .ToString(); + + private static object Identity(TestCase test) => new { test.Id, test.FullyQualifiedName, test.DisplayName, test.Source }; + + private static void SaveRun(string path, RunEvents handler) => Save(path, new + { + handler.Completed, + handler.Cancelled, + handler.Aborted, + Error = handler.Error?.ToString(), + handler.Logs, + Results = handler.Results.Select(item => new + { + Test = Identity(item.TestCase), + Outcome = item.Outcome.ToString(), + item.ErrorMessage, + item.ErrorStackTrace, + Messages = item.Messages.Select(message => new { message.Category, message.Text }) + }) + }); + + private static void Save(string path, object value) => File.WriteAllText(path, JsonSerializer.Serialize(value, JsonOptions)); + + private static void Require(bool condition, string message) + { + if (!condition) + throw new InvalidOperationException(message); + } + + private sealed record TestIdentity(string Uid, string DisplayName); + + private sealed class DiscoveryEvents : ITestDiscoveryEventsHandler + { + internal List Tests { get; } = new(); + internal bool Aborted { get; private set; } + + public void HandleDiscoveredTests(IEnumerable? discoveredTestCases) + { + if (discoveredTestCases != null) + Tests.AddRange(discoveredTestCases); + } + + public void HandleDiscoveryComplete(long totalTests, IEnumerable? lastChunk, bool isAborted) + { + Aborted = isAborted; + HandleDiscoveredTests(lastChunk); + } + + public void HandleLogMessage(TestMessageLevel level, string? message) => Console.WriteLine(level + ": " + message); + public void HandleRawMessage(string rawMessage) { } + } + + private sealed class RunEvents : ITestRunEventsHandler + { + internal ConcurrentQueue Results { get; } = new(); + internal ConcurrentQueue Logs { get; } = new(); + internal bool Completed { get; private set; } + internal bool Cancelled { get; private set; } + internal bool Aborted { get; private set; } + internal Exception? Error { get; private set; } + + public void HandleTestRunStatsChange(TestRunChangedEventArgs? args) + { + if (args?.NewTestResults != null) + { + foreach (var result in args.NewTestResults) + Results.Enqueue(result); + } + } + + public void HandleTestRunComplete(TestRunCompleteEventArgs args, TestRunChangedEventArgs? lastChunk, + ICollection? runContextAttachments, ICollection? executorUris) + { + HandleTestRunStatsChange(lastChunk); + Cancelled = args.IsCanceled; + Aborted = args.IsAborted; + Error = args.Error; + Completed = true; + } + + public void HandleLogMessage(TestMessageLevel level, string? message) => Logs.Enqueue(level + ": " + message); + public void HandleRawMessage(string rawMessage) { } + public int LaunchProcessWithDebuggerAttached(TestProcessStartInfo testProcessStartInfo) => throw new NotSupportedException("No debugger is used by this fixture."); + } + } +} diff --git a/LICENSE.txt b/LICENSE.txt new file mode 100644 index 0000000..e0b1a39 --- /dev/null +++ b/LICENSE.txt @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2026 Neil Colvin + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/NuGet.Config b/NuGet.Config new file mode 100644 index 0000000..8c1a7ac --- /dev/null +++ b/NuGet.Config @@ -0,0 +1,5 @@ + + + + + diff --git a/PROVENANCE.md b/PROVENANCE.md new file mode 100644 index 0000000..31d2ab8 --- /dev/null +++ b/PROVENANCE.md @@ -0,0 +1,26 @@ +# Source provenance + +The starting specimen, scripts and dependency locks are in the previously posted +[validation bundle](https://github.com/user-attachments/files/34986913/NUnit51AdapterValidationRepro2026-11-17.zip). +Its SHA-256 is `50dbf739298370b334b2b22eb0b071036de3186b9d3e0a1c263517aa032856a9`. + +`Shared/CompatibilityCases.cs` and `Harness/Program.cs` retain the validated C# logic, with NUnit's copyright header, block namespaces, +private-field naming and line endings applied. The framework-slot directories are +now called `baseline` and `candidate`. Their package versions are explicit profile +properties. The helper scripts use the selected target matrix/SDK, retain original +raw failures, and do not retry tests automatically. + +The new runner replaces bundle-specific immutable manifests with a per-run source +snapshot, selected-profile receipt, package hashes and locked dependency restore. +Profiles and dependency locks are maintained source; run evidence is an artifact. +New locks are proposed separately and require review before adoption. + +The original public bundle and its Windows/macOS/Linux evidence are unchanged. +This prepared repository is not itself evidence that hosted Actions have executed. + +Conventions and workflow references checked during preparation: + +- [NUnit coding configuration](https://github.com/nunit/nunit/blob/main/.editorconfig) +- [Existing internal-tool CI](https://github.com/nunit/NUnit.Tools.TestExplorerDump/blob/main/.github/workflows/TestExplorerDump.CI.yml) +- [GitHub setup-dotnet action](https://github.com/actions/setup-dotnet) +- [GitHub-hosted runner labels](https://docs.github.com/en/actions/reference/runners/github-hosted-runners) diff --git a/README.md b/README.md index 29afe9b..240e8fd 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,120 @@ -# NUnit.Tools.AdapterCompatibility - -Cross-platform compatibility checks for NUnit framework candidates through the NUnit adapter's VSTest and Microsoft Testing Platform execution paths. - -The initial implementation will be reviewed in a draft pull request. +# NUnit.Tools.AdapterCompatibility + +Checks NUnit framework behavior through the NUnit adapter's direct Microsoft +Testing Platform (MTP) executable and VSTest CLI/TranslationLayer paths. + +The supplied workflow targets GitHub-hosted Windows, Linux and macOS workers. +The same command-line entry point runs locally without those workflows. + +## Run locally + +Use Python 3.9+ and the exact SDK named by the selected profile, with the matching +architecture's .NET 8, 10 and 11 runtimes for the initial profile. Nothing uses a +desktop, device, processor, SSH connection or remote test backend. + +```sh +python -m unittest discover -s tests -v +python run.py run --profile profiles/historical-alpha.json --output artifacts/run +``` + +Use `python3` on systems where `python` is not available. `--dotnet` accepts an +explicit existing executable. The output directory must be new. A short, owned +working directory is created under the system temporary directory and retained +for inspection. The runner snapshots maintained source, downloads pinned public +packages, verifies SHA-256, restores in locked mode with dedicated caches, and +builds/runs the fixtures. No SDK or runtime is installed by the local command. + +Do not run the fixture projects directly to interpret their exit code as an +overall pass. The specimen includes an intentional assertion failure, an ignored +case and explicit cancellation cases. The runner checks their expected results. + +## Two independent results + +`results.json` and the job summary distinguish: + +- **Compatibility checks:** exact-name discovery/selection, VSTest escaping, + per-test cancellation controls, exact target runtime, and complete evidence. + A failure makes the run fail. +- **Cooperative runner stop:** actual started/token-callback/finally/teardown + observations. The historical profile has an unresolved stop gap. It is recorded + as **INCOMPLETE**, not converted into a passing product check. + +The default command gates compatibility and reports stop observations. To require +complete cooperative stop as well: + +```sh +python run.py run --profile profiles/historical-alpha.json --output artifacts/strict --require-cooperative-stop +``` + +Exit codes are 0 for the selected requirements being met, 1 for unmet product +contracts, and 2 for input/infrastructure/audit failure. A zero exit under the +default reporting policy does not claim complete runner cancellation. Missing or +duplicate observations, an absent started test, and an invalid/missing report +cannot be treated as the known gap. + +## GitHub Actions + +The workflow runs on `windows-2025`, `ubuntu-24.04` and `macos-15`. Each worker +installs the profile's exact SDK and .NET 8/10 SDKs to supply those target runtimes. +Actual architecture and runtime patches are recorded; labels do not imply identical +hardware or runtime patch levels. The initial profile selects SDK 11.0.100. + +Pull requests and pushes run the compatibility requirements and report stop +observations. Manual dispatch can additionally require cooperative stop. All +jobs retain text/XML/JSON/TRX evidence, including failures and the native process +audit. Package caches and compiled binaries are excluded. The workflow uses +read-only repository permissions, does not persist checkout credentials, and has +no publishing/deployment step or `continue-on-error` escape. + +The initial historical profile uses NUnit 4.6.1, NUnit 5.1.0-alpha.0.50 and +NUnit3TestAdapter 6.4.0-alpha.0.46. Its package contains engine core 3.22.0, so its +stop observations do not establish behavior of later engine/adapter corrections. + +## Select a candidate reproducibly + +Versions, download hashes, SDK, targets and dependency locks are selected by a +reviewed profile. No command resolves a moving `latest` version or rewrites the +maintained lock files during an ordinary run. + +1. Copy `profiles/historical-alpha.json` to a new profile filename. +2. Set its name, candidate/adapter versions, exact official public download URLs + and independently reviewed SHA-256 values. Set a new lock-directory name. + Keep or deliberately change the baseline, SDK and target list. +3. Propose a new lock set without running a test: + + ```sh + python run.py prepare-locks --profile profiles/candidate.json --output artifacts/lock-proposal + ``` + +4. Review `lock-proposal.json`, package downloads and the proposed dependency + differences. Copy `proposed-locks` into the profile's named directory under + `profiles/`. The command does not overwrite source or adopt its proposal. +5. Run the candidate with `run.py run`. Include the profile and reviewed locks in + a PR. Add its name to the workflow's manual-dispatch choices when appropriate. + +The alpha remains available as a recorded baseline; no old expectation requires +a new candidate to reproduce a bug. Use the strict-stop policy when checking a +candidate intended to fix cancellation. If a historical package disappears from +its public feed, report the restore failure rather than substitute other bytes. + +## Scope and maintenance + +The initial matrix targets modern .NET 8/10/11. It does not establish IDE UI, +remote execution, engine-v4 adapter integration, x86, .NET Framework/Mono behavior, +or the framework's numeric/parallel-dispatch regression coverage. This complements +the framework suite rather than replacing it. There is no NuGet release or new +public NUnit API in this proposal. + +The fixture and VSTest harness retain the validated specimen logic; orchestration +has been adapted for explicit profiles, separate result policies and CI artifacts. +NUnit's framework `.editorconfig` supplies C# formatting conventions. The C# +sources use C# 14. No historical logs or private machine configuration are part +of the source candidate. See [PROVENANCE.md](PROVENANCE.md). + +Cancellation deadlines contain only spawned test processes. They do not prove +test teardown occurred. If an independent audit finds remaining process references, +the run fails and retains its work directory; it does not kill unrelated processes. +Apply normal resource coordination if using a shared machine. The hosted workflow +uses disposable GitHub workers rather than any private test machines. + +MIT licensed. Prepared jointly by Neil Colvin and OpenAI Codex. diff --git a/Shared/CompatibilityCases.cs b/Shared/CompatibilityCases.cs new file mode 100644 index 0000000..d385db4 --- /dev/null +++ b/Shared/CompatibilityCases.cs @@ -0,0 +1,189 @@ +// Copyright (c) Charlie Poole, Rob Prouse and Contributors. MIT License - see LICENSE.txt + +using System; +using System.Diagnostics; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Threading.Tasks; +using System.Xml.Linq; + +using NUnit.Framework; + +namespace NUnit.AdapterCompatibility +{ + /// + /// Small shared contract suite for comparing adapter execution paths without device access. + /// + [TestFixture] + [NonParallelizable] + public sealed class CompatibilityCases + { + /// + /// Records the actual test host, assembly identity and context for each executed case. + /// + [SetUp] + public void RecordExecutionContext() + { + WriteReceipt("started"); + } + + /// + /// Records cleanup independently of the runner's final result delivery. + /// + [TearDown] + public void RecordCleanup() + { + WriteReceipt("teardown"); + } + + /// + /// Establishes a passing case with recognizable output on each NUnit output channel. + /// + [Test] + public void OutputAndPass() + { + TestContext.Out.WriteLine("compatibility-standard-output"); + TestContext.Error.WriteLine("compatibility-standard-error"); + TestContext.Progress.WriteLine("compatibility-progress-output"); + Assert.That(2 + 2, Is.EqualTo(4)); + } + + /// + /// Checks parameterized discovery identities containing spaces, quotes and Unicode. + /// + /// The exact value retained through discovery and execution. + [TestCase("alpha beta")] + [TestCase("a \"quoted\" value")] + [TestCase("café λ")] + public void ParameterizedIdentity(string value) + { + Assert.That(TestContext.CurrentContext.Test.Arguments, Is.EqualTo(new object[] { value })); + } + + /// + /// Exercises a display name that differs from the CLR method name. + /// + [TestCase(TestName = "Named case (with space)")] + public void CustomIdentity() + { + Assert.That(TestContext.CurrentContext.Test.Name, Is.EqualTo("Named case (with space)")); + } + + /// + /// Confirms string test-run parameters and NUnit's explicit conversion API. + /// This does not demonstrate preservation of arbitrary typed package settings. + /// + [Test] + public void RunParameters() + { + Assert.Multiple(() => + { + Assert.That(TestContext.Parameters["text"], Is.EqualTo("alpha; beta = café & λ")); + Assert.That(TestContext.Parameters["integer"], Is.EqualTo("42")); + Assert.That(TestContext.Parameters["boolean"], Is.EqualTo("true")); + Assert.That(TestContext.Parameters.Get("integer", 0), Is.EqualTo(42)); + Assert.That(TestContext.Parameters.Get("boolean", false), Is.True); + }); + } + + /// + /// Supplies a recognizable failure to check failure delivery and stack traces. + /// + [Test] + [Category("ExpectedFailure")] + public void IntentionalFailure() + { + Assert.Fail("compatibility-intentional-failure"); + } + + /// + /// Supplies a recognizable ignored result without executing a test body. + /// + [Test] + [Ignore("compatibility-intentional-ignore")] + public void IntentionalIgnore() + { + Assert.Fail("An ignored test must not execute."); + } + + /// + /// Waits for a real runner cancellation, recording token delivery and finally execution. + /// The explicit attribute prevents accidental waits in ordinary test runs. + /// + /// A task completed or cancelled by the NUnit execution token. + [Test] + [Explicit("Selected only by the bounded cancellation probe.")] + public async Task CooperativeCancellation() + { + await ObserveCancellation(); + } + + /// + /// Positive control demonstrating framework token delivery from its per-test timer. + /// This must not be confused with cancellation requested by the test runner. + /// + /// A task cancelled by NUnit's per-test timer. + [Test] + [Explicit("Selected only as the per-test cancellation control.")] + [CancelAfter(250)] + public async Task PerTestCancellation() + { + await ObserveCancellation(); + } + + private static async Task ObserveCancellation() + { + var token = TestContext.CurrentContext.CancellationToken; + var callbackCompleted = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + using (token.Register(() => + { + WriteReceipt("token-cancelled"); + callbackCompleted.TrySetResult(true); + })) + { + try + { + await Task.Delay(TimeSpan.FromSeconds(60), token); + Assert.Fail("The runner failed to cancel the explicitly selected test."); + } + finally + { + WriteReceipt("finally"); + // Cancellation may resume this method before dispatch reaches our callback. + // Keep its registration alive until the real callback has written its receipt. + if (token.IsCancellationRequested) + await callbackCompleted.Task.WaitAsync(TimeSpan.FromSeconds(5)); + } + } + } + + private static void WriteReceipt(string phase) + { + var directory = TestContext.Parameters["evidence"]; + if (string.IsNullOrEmpty(directory)) + throw new InvalidOperationException("The harness must provide an owned evidence directory."); + + Directory.CreateDirectory(directory); + var context = TestContext.CurrentContext; + var assembly = typeof(CompatibilityCases).Assembly; + var document = new XElement("observation", + new XAttribute("phase", phase), + new XAttribute("test", context.Test.FullName), + new XAttribute("id", context.Test.ID), + new XAttribute("pid", Process.GetCurrentProcess().Id), + new XAttribute("runtime", Environment.Version), + new XAttribute("assembly", assembly.Location), + new XAttribute("framework", typeof(TestAttribute).Assembly.GetName().Version!), + new XElement("assemblies", AppDomain.CurrentDomain.GetAssemblies() + .Where(item => item.GetName().Name!.StartsWith("nunit", StringComparison.OrdinalIgnoreCase)) + .Select(item => new XElement("assembly", item.FullName)))); + #if !NETFRAMEWORK + document.Add(new XAttribute("load-context", + System.Runtime.Loader.AssemblyLoadContext.GetLoadContext(assembly)?.Name ?? "")); + document.Add(new XAttribute("entry-assembly", Assembly.GetEntryAssembly()?.Location ?? "")); + #endif + document.Save(Path.Combine(directory, phase + "-" + Guid.NewGuid().ToString("N") + ".xml")); + } + } +} diff --git a/baseline/MTP/MTP.csproj b/baseline/MTP/MTP.csproj new file mode 100644 index 0000000..1dd51f5 --- /dev/null +++ b/baseline/MTP/MTP.csproj @@ -0,0 +1,15 @@ + + + net8.0;net10.0;net11.0 + AdapterCompatibility.MTP + Exe + true + true + + + + + + + + diff --git a/baseline/VSTest/VSTest.csproj b/baseline/VSTest/VSTest.csproj new file mode 100644 index 0000000..e7c54ee --- /dev/null +++ b/baseline/VSTest/VSTest.csproj @@ -0,0 +1,14 @@ + + + net8.0;net10.0;net11.0 + AdapterCompatibility.VSTest + true + + + + + + + + + diff --git a/candidate/MTP/MTP.csproj b/candidate/MTP/MTP.csproj new file mode 100644 index 0000000..8347cb2 --- /dev/null +++ b/candidate/MTP/MTP.csproj @@ -0,0 +1,15 @@ + + + net8.0;net10.0;net11.0 + AdapterCompatibility.MTP + Exe + true + true + + + + + + + + diff --git a/candidate/VSTest/VSTest.csproj b/candidate/VSTest/VSTest.csproj new file mode 100644 index 0000000..d7f153e --- /dev/null +++ b/candidate/VSTest/VSTest.csproj @@ -0,0 +1,14 @@ + + + net8.0;net10.0;net11.0 + AdapterCompatibility.VSTest + true + + + + + + + + + diff --git a/ci_summary.py b/ci_summary.py new file mode 100644 index 0000000..77be509 --- /dev/null +++ b/ci_summary.py @@ -0,0 +1,46 @@ +"""Fail closed on absent/invalid reports and publish independent compatibility/stop statuses.""" +import argparse +import json +from pathlib import Path +import sys + +from compatibility import require, summary + + +def policy(result, strict): + """An infrastructure or compatibility failure always fails; strict mode also requires completed stop observations.""" + require(type(result['contracts']['passed']) is bool and type(result['runnerStop']['passed']) is bool, + 'Result statuses must be Boolean.') + require(type(result['exitCode']) is int and result['exitCode'] in [0, 1, 2], 'Invalid producer exit code.') + require(bool(result['contracts']['failures']) == (not result['contracts']['passed']), 'Compatibility status contradicts its failures.') + require(bool(result['runnerStop']['incomplete']) == (not result['runnerStop']['passed']), 'Stop status contradicts its observations.') + if result['exitCode'] == 2: + return 2 + if result['exitCode'] == 1 or not result['contracts']['passed'] or (strict and not result['runnerStop']['passed']): + return 1 + return 0 + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--results', type=Path, required=True) + parser.add_argument('--summary', type=Path, required=True) + parser.add_argument('--require-stop', choices=['true', 'false'], default='false') + args = parser.parse_args() + try: + result = json.loads(args.results.read_text(encoding='utf-8')) + code = policy(result, args.require_stop == 'true') + text = summary(result) + '\nStrict cooperative-stop requirement: ' + args.require_stop + '\n' + if code == 2: + text = '# Infrastructure verification FAILED\n\n' + text + except Exception as error: + code = 2 + text = '# Adapter compatibility: infrastructure failure\n\nNo valid complete result was available: ' + type(error).__name__ + '\n' + with args.summary.open('a', encoding='utf-8') as output: + output.write(text) + print(text) + return code + + +if __name__ == '__main__': + sys.exit(main()) diff --git a/compare_hosts.py b/compare_hosts.py new file mode 100644 index 0000000..69fcca7 --- /dev/null +++ b/compare_hosts.py @@ -0,0 +1,115 @@ +"""Compare exact-name filtering and genuine runner stop across NUnit 4 and 5.""" + +from concurrent.futures import ThreadPoolExecutor +import platform +import json +import os +from pathlib import Path +import sys +import xml.etree.ElementTree as ET + +root = Path(__file__).resolve().parent +TARGETS = json.loads(os.environ["NUNIT_COMPAT_TARGETS"]) + +from fixture_common import execute, observations, results, save, settings + +dotnet = str(Path(sys.argv[1]).resolve()) +evidence = root / "evidence" +evidence.mkdir(exist_ok=False) +environment = dict(os.environ, DOTNET_CLI_TELEMETRY_OPTOUT="1", DOTNET_NOLOGO="1", + TESTINGPLATFORM_TELEMETRY_OPTOUT="1", MSBUILDDISABLENODEREUSE="1", + DOTNET_CLI_HOME=str(root / ".cli-home"), + DOTNET_ROOT=str(Path(dotnet).parent), NUGET_PACKAGES=str(root / ".packages")) +environment.pop("DOTNET_TEST_RUNNER", None) +environment["PATH"] = str(Path(dotnet).parent) + os.pathsep + environment.get("PATH", "") + +for project in ["Harness/Harness.csproj"] + [version + "/" + host + "/" + host + ".csproj" + for version in ["baseline", "candidate"] for host in ["VSTest", "MTP"]]: + name = "build-" + project.replace("/", "-") + record = execute([dotnet, "build", project, "-c", "Release", "--disable-build-servers", + "--no-restore", "-v", "minimal"], + evidence / name, root, environment, timeout=240) + assert record["exit"] == 0, project + " build failed" + +identities = json.loads((root / "identities.json").read_text()) +selections = [identity for identity in identities + if identity[1] in ["Named case (with space)", 'ParameterizedIdentity("a \\"quoted\\" value")']] +assert len(selections) == 2, selections +selections.insert(0, ["NUnit.AdapterCompatibility.CompatibilityCases.OutputAndPass", "OutputAndPass"]) +rows = [] +for version in ["baseline", "candidate"]: + for target in TARGETS: + for host in ["VSTest", "MTP"]: + assembly = root / version / host / "bin/Release" / target / ("AdapterCompatibility." + host + ".dll") + for index, (uid, display) in enumerate(selections): + name = "-".join([version, target, host, "filter", str(index)]) + directory = evidence / name + configuration = evidence / (name + ".runsettings") + configuration.write_text(settings(directory), encoding="utf-8") + if host == "VSTest": + command = [dotnet, "test", str(assembly), "--filter", "FullyQualifiedName=" + uid, + "--settings", str(configuration), "--results-directory", str(directory), + "--logger", "trx;LogFileName=results.trx"] + else: + command = [dotnet, str(assembly), "--filter-uid", uid, "--settings", str(configuration), + "--results-directory", str(directory), "--report-trx", "--report-trx-filename", "results.trx"] + record = execute(command, directory, root, environment) + row = {"name": name, "framework": version, "target": target, "host": host, + "uid": uid, "displayName": display, "process": record} + try: + tests = results(directory) + row["results"] = [{"name": test.get("testName"), "outcome": test.get("outcome")} for test in tests] + row["selectedExactlyOnePassingTest"] = (record["exit"] == 0 and not record["timedOut"] + and len(tests) == 1 and tests[0].get("outcome") == "Passed") + except AssertionError as error: + row.update(resultError=str(error), selectedExactlyOnePassingTest=False) + rows.append(row) + save(evidence / "filters.json", rows) + print(json.dumps({key: row[key] for key in ["name", "selectedExactlyOnePassingTest"]}), flush=True) + + +def stop_probe(specification): + version, target, host = specification + name = "-".join([version, target, host, "runner-stop"]) + directory = evidence / name + assembly = root / version / host / "bin/Release" / target / ("AdapterCompatibility." + host + ".dll") + if host == "VSTest": + harness = root / "Harness/bin/Release/net10.0/Harness.dll" + console = Path(dotnet).parent / ("sdk/" + os.environ["NUNIT_COMPAT_SDK"] + "/vstest.console.dll") + child_evidence = evidence / (name + "-harness") + command = [dotnet, str(harness), "vstest", str(assembly), str(console), str(child_evidence)] + observed = child_evidence / "cancellation" + else: + configuration = evidence / (name + ".runsettings") + configuration.write_text(settings(directory), encoding="utf-8") + command = [dotnet, str(assembly), "--settings", str(configuration), "--results-directory", str(directory), + "--filter", "FullyQualifiedName=NUnit.AdapterCompatibility.CompatibilityCases.CooperativeCancellation", + "--timeout", "5s", "--report-trx", "--report-trx-filename", "results.trx"] + observed = directory + record = execute(command, directory, root, environment, timeout=45) + observation_root = observed / "observations" if host == "MTP" else observed + counts = {phase: len(list(observation_root.glob(phase + "-*.xml"))) + for phase in ["started", "token-cancelled", "finally", "teardown"]} + logs = "\n".join(path.read_text(encoding="utf-8", errors="replace") for path in + list(directory.glob("*.txt")) + (list(child_evidence.glob("*.json")) + list(child_evidence.glob("*.txt")) + if host == "VSTest" else [])) + row = {"name": name, "framework": version, "target": target, "host": host, + "process": record, "observations": counts, + "parameterCountMismatch": "TargetParameterCountException" in logs} + if host == "VSTest": + p = child_evidence / "cancellation-probe.json" + if p.exists(): + row["vstestCancellation"] = json.loads(p.read_text()) + save(directory / "stop-observations.json", row) + print(json.dumps({key: row[key] for key in ["name", "observations", "parameterCountMismatch"]}), flush=True) + return row + + +specifications = [(version, target, host) for version in ["baseline", "candidate"] + for target in TARGETS for host in ["VSTest", "MTP"]] +with ThreadPoolExecutor(max_workers=2) as executor: + stop_rows = list(executor.map(stop_probe, specifications)) +save(evidence / "stops.json", stop_rows) +save(evidence / "summary.json", {"sdk": os.environ["NUNIT_COMPAT_SDK"], "scope": platform.platform() + " " + platform.machine(), "filters": rows, "stops": stop_rows, + "allProductContractsPassed": False}) +print("Comparison completed; product failures retained in evidence.", flush=True) diff --git a/compatibility.py b/compatibility.py new file mode 100644 index 0000000..4854efb --- /dev/null +++ b/compatibility.py @@ -0,0 +1,110 @@ +"""Validated input profiles and separate compatibility/runner-stop results.""" +import itertools +import json +from pathlib import Path +import re +import urllib.parse +import xml.etree.ElementTree as ET + + +PROJECTS = ['Harness/Harness.csproj'] + [version + '/' + host + '/' + host + '.csproj' + for version in ['baseline', 'candidate'] for host in ['MTP', 'VSTest']] +PHASES = ['started', 'token-cancelled', 'finally', 'teardown'] + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def save(path, value): + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(json.dumps(value, indent=2, ensure_ascii=True) + '\n', encoding='utf-8') + + +def profile(path): + """Reject missing, ambiguous or unsafe profile values before starting a process.""" + data = json.loads(path.read_text(encoding='utf-8-sig')) + require(set(data) == {'name', 'sdk', 'targets', 'baselineFramework', 'candidateFramework', 'adapter', 'locks', 'packages'}, + 'Unexpected or missing profile fields.') + require(re.fullmatch(r'[a-z0-9][a-z0-9-]{0,63}', data['name']), 'Invalid profile name.') + require(re.fullmatch(r'\d+\.\d+\.\d+', data['sdk']), 'Select an exact SDK version.') + require(isinstance(data['targets'], list) and data['targets'] and len(set(data['targets'])) == len(data['targets']) + and all(re.fullmatch(r'net(?:[8-9]|[1-9][0-9])\.0', target) for target in data['targets']), 'Invalid target matrix.') + for field in ['baselineFramework', 'candidateFramework', 'adapter']: + require(re.fullmatch(r'\d+\.\d+\.\d+(?:-[a-zA-Z0-9.-]+)?', data[field]), 'Select an explicit package version.') + require(re.fullmatch(r'[a-z0-9][a-z0-9-]{0,63}', data['locks']), 'Locks must name one profile directory.') + expected = {('NUnit', data['baselineFramework']), ('NUnit', data['candidateFramework']), ('NUnit3TestAdapter', data['adapter'])} + require(len(data['packages']) == len(expected) and {(p['id'], p['version']) for p in data['packages']} == expected, + 'Package identities do not match the selected versions.') + for package in data['packages']: + require(set(package) == {'id', 'version', 'sha256', 'url'} and re.fullmatch(r'[0-9a-f]{64}', package['sha256']), + 'A SHA-256 and public download URL are required for each package.') + url = urllib.parse.urlparse(package['url']) + require(url.scheme == 'https' and url.hostname in {'api.nuget.org', 'www.myget.org'} + and url.username is None and url.password is None and not url.query and not url.fragment, + 'Use an explicit unauthenticated official public package URL.') + require(url.path.lower().endswith('/' + package['id'].lower() + '.' + package['version'].lower() + '.nupkg'), + 'Download URL does not identify the selected package.') + return data + + +def matrix_rows(rows, versions, targets, hosts, suffixes, label): + """Check exact row identities, including duplicates and omissions, before reading totals.""" + expected = {'-'.join(parts) for parts in itertools.product(versions, targets, hosts, suffixes)} + names = [row['name'] for row in rows] + require(len(names) == len(expected) and set(names) == expected, label + ' matrix has missing, duplicate or unexpected rows.') + + +def assess(work, selected): + """Keep known stop failures visible without turning them into passing compatibility cases.""" + filters = json.loads((work / 'evidence/filters.json').read_text()) + escaped = json.loads((work / 'control-evidence/escaped-results.json').read_text()) + stops = json.loads((work / 'evidence/stops.json').read_text()) + versions, targets = ['baseline', 'candidate'], selected['targets'] + matrix_rows(filters, versions, targets, ['VSTest', 'MTP'], ['filter-0', 'filter-1', 'filter-2'], 'Filter') + matrix_rows(escaped, versions, targets, ['escaped'], ['0', '1'], 'Escaped filter') + matrix_rows(stops, versions, targets, ['VSTest', 'MTP'], ['runner-stop'], 'Stop') + failures, runtime_rows = [], [] + for row in filters: + # The raw quoted VSTest expression is deliberately invalid; all other selections must pass. + invalid = row['host'] == 'VSTest' and row['name'].endswith('-filter-2') + if invalid: + logs = '\n'.join(path.read_text(encoding='utf-8', errors='replace') + for path in (work / 'evidence' / row['name']).glob('*.txt')) + valid = not row['selectedExactlyOnePassingTest'] and not row['process']['timedOut'] and 'escape' in logs.lower() + else: + valid = row['selectedExactlyOnePassingTest'] and row['process']['exit'] == 0 and not row['process']['timedOut'] + if not valid: + failures.append(row['name']) + failures.extend(row['name'] for row in escaped if not row['selectedExactlyOnePassingTest'] + or row['process']['exit'] != 0 or row['process']['timedOut']) + for version, target in itertools.product(versions, targets): + directory = work / 'control-evidence' / (version + '-' + target + '-timer/observations') + require(all(len(list(directory.glob(phase + '-*.xml'))) == 1 for phase in PHASES), 'Missing timer-control evidence.') + started = ET.parse(next(directory.glob('started-*.xml'))).getroot() + require(started.get('runtime', '').split('.')[0] == target[3:].split('.')[0], 'Target runtime rolled forward unexpectedly.') + runtime_rows.append({'framework': version, 'target': target, 'runtime': started.get('runtime')}) + # An absent start or duplicated phase is an incomplete probe, not evidence of the known stop gap. + for row in stops: + require(set(row['observations']) == set(PHASES) and row['observations']['started'] == 1 + and all(type(value) is int and value in [0, 1] for value in row['observations'].values()), + 'Runner-stop probe did not produce an unambiguous observed start.') + missing = [row['name'] for row in stops if not all(row['observations'][phase] == 1 for phase in PHASES)] + return {'profile': selected['name'], 'versions': {key: selected[key] for key in ['baselineFramework', 'candidateFramework', 'adapter']}, + 'contracts': {'passed': not failures, 'failures': failures, 'filterSelections': len(filters) - 2 * len(targets), + 'escapedSelections': len(escaped), 'invalidRawFilters': 2 * len(targets), 'timerControls': len(runtime_rows)}, + 'runnerStop': {'passed': not missing, 'incomplete': missing, 'observations': stops}, 'actualRuntimes': runtime_rows} + + +def summary(result): + """Produce a human-readable CI summary which explicitly names incomplete stop behavior.""" + lines = ['# Adapter compatibility: ' + result['profile'], '', + 'Compatibility checks: **' + ('passed' if result['contracts']['passed'] else 'FAILED') + '**', '', + 'Cooperative runner stop: **' + ('passed' if result['runnerStop']['passed'] else 'INCOMPLETE') + '**', '', + 'These statuses are independent. A compatibility pass does not establish complete runner cancellation.', '', + '| Target | Framework | Actual runtime |', '| --- | --- | --- |'] + lines.extend('| ' + row['target'] + ' | ' + row['framework'] + ' | ' + row['runtime'] + ' |' for row in result['actualRuntimes']) + if result['runnerStop']['incomplete']: + lines += ['', 'Incomplete stop observations:'] + ['- `' + name + '`' for name in result['runnerStop']['incomplete']] + return '\n'.join(lines) + '\n' diff --git a/fixture_common.py b/fixture_common.py new file mode 100644 index 0000000..98cfd0f --- /dev/null +++ b/fixture_common.py @@ -0,0 +1,83 @@ +"""Run bounded, independent MTP contracts against an unchanged NUnit specimen. + +Evidence is append-only by run directory. Expected assertion failures are checked +as outcomes; missing results, process termination and token delivery are distinct. +""" + +import argparse +import hashlib +import json +import os +from pathlib import Path +import platform +import re +import signal +import subprocess +import time +import xml.etree.ElementTree as ET + + +def save(path, value): + path.write_text(json.dumps(value, indent=2, ensure_ascii=False), encoding="utf-8") + + +def execute(command, directory, cwd, environment, timeout=45): + directory.mkdir(parents=True, exist_ok=False) + started = time.monotonic() + with (directory / "stdout.txt").open("w", encoding="utf-8") as stdout, \ + (directory / "stderr.txt").open("w", encoding="utf-8") as stderr: + child = subprocess.Popen(command, cwd=cwd, env=environment, stdout=stdout, + stderr=stderr, start_new_session=os.name != "nt") + timed_out = False + try: + child.wait(timeout=timeout) + except subprocess.TimeoutExpired: + timed_out = True + if os.name == "nt": + subprocess.run(["taskkill", "/PID", str(child.pid), "/T", "/F"], + stdout=stderr, stderr=stderr, check=False) + else: + os.killpg(child.pid, signal.SIGKILL) + child.wait() + result = {"command": command, "cwd": str(cwd), "pid": child.pid, + "exit": child.returncode, "timedOut": timed_out, + "seconds": round(time.monotonic() - started, 3)} + save(directory / "process.json", result) + return result + + +def discovered(directory): + value = json.loads((directory / "stdout.txt").read_text(encoding="utf-8-sig")) + if "testContainers" in value: + assert value["version"] == "1.0" and len(value["testContainers"]) == 1 + value = value["testContainers"][0] + else: + assert value["schemaVersion"] == 1 + return sorted([(test["uid"], test["displayName"]) for test in value["tests"]]) + + +def results(directory): + files = list(directory.rglob("*.trx")) + assert len(files) == 1, "Expected exactly one TRX report, found " + str(len(files)) + return [item for item in ET.parse(files[0]).iter() + if item.tag.split("}")[-1] == "UnitTestResult"] + + +def observations(directory, phase): + return [ET.parse(path).getroot() for path in + (directory / "observations").glob(phase + "-*.xml")] + + +def settings(directory, negative=False): + document = ET.Element("RunSettings") + nunit = ET.SubElement(document, "NUnit") + ET.SubElement(nunit, "NumberOfTestWorkers").text = "0" + parameters = ET.SubElement(document, "TestRunParameters") + values = {"evidence": str(directory / "observations"), + "text": "alpha; beta = café & λ", "integer": "41" if negative else "42", + "boolean": "true"} + for key, value in values.items(): + ET.SubElement(parameters, "Parameter", {"name": key, "value": value}) + return ET.tostring(document, encoding="unicode") + + diff --git a/global.json b/global.json new file mode 100644 index 0000000..7fe1f6f --- /dev/null +++ b/global.json @@ -0,0 +1 @@ +{"sdk":{"version":"11.0.100","rollForward":"disable"},"test":{"runner":"VSTest"}} diff --git a/identities.json b/identities.json new file mode 100644 index 0000000..279043b --- /dev/null +++ b/identities.json @@ -0,0 +1,42 @@ +[ + [ + "NUnit.AdapterCompatibility.CompatibilityCases.CooperativeCancellation", + "CooperativeCancellation" + ], + [ + "NUnit.AdapterCompatibility.CompatibilityCases.IntentionalFailure", + "IntentionalFailure" + ], + [ + "NUnit.AdapterCompatibility.CompatibilityCases.IntentionalIgnore", + "IntentionalIgnore" + ], + [ + "NUnit.AdapterCompatibility.CompatibilityCases.Named case (with space)", + "Named case (with space)" + ], + [ + "NUnit.AdapterCompatibility.CompatibilityCases.OutputAndPass", + "OutputAndPass" + ], + [ + "NUnit.AdapterCompatibility.CompatibilityCases.ParameterizedIdentity(\"a \\\"quoted\\\" value\")", + "ParameterizedIdentity(\"a \\\"quoted\\\" value\")" + ], + [ + "NUnit.AdapterCompatibility.CompatibilityCases.ParameterizedIdentity(\"alpha beta\")", + "ParameterizedIdentity(\"alpha beta\")" + ], + [ + "NUnit.AdapterCompatibility.CompatibilityCases.ParameterizedIdentity(\"café λ\")", + "ParameterizedIdentity(\"café λ\")" + ], + [ + "NUnit.AdapterCompatibility.CompatibilityCases.PerTestCancellation", + "PerTestCancellation" + ], + [ + "NUnit.AdapterCompatibility.CompatibilityCases.RunParameters", + "RunParameters" + ] +] \ No newline at end of file diff --git a/profiles/historical-alpha.json b/profiles/historical-alpha.json new file mode 100644 index 0000000..dacc3f6 --- /dev/null +++ b/profiles/historical-alpha.json @@ -0,0 +1,33 @@ +{ + "name": "historical-alpha", + "sdk": "11.0.100", + "targets": [ + "net8.0", + "net10.0", + "net11.0" + ], + "baselineFramework": "4.6.1", + "candidateFramework": "5.1.0-alpha.0.50", + "adapter": "6.4.0-alpha.0.46", + "locks": "historical-alpha", + "packages": [ + { + "id": "NUnit3TestAdapter", + "version": "6.4.0-alpha.0.46", + "sha256": "6981b6d1f927a73704b096ce2a02344295ecb1d082bfe6cb411a1124119d0cd5", + "url": "https://www.myget.org/F/nunit/api/v3/flatcontainer/nunit3testadapter/6.4.0-alpha.0.46/nunit3testadapter.6.4.0-alpha.0.46.nupkg" + }, + { + "id": "NUnit", + "version": "4.6.1", + "sha256": "30b7225b4723f4e3b7809e858ea0ff2a9a744b9c8f62c4e9496b514d81b43efa", + "url": "https://api.nuget.org/v3-flatcontainer/nunit/4.6.1/nunit.4.6.1.nupkg" + }, + { + "id": "NUnit", + "version": "5.1.0-alpha.0.50", + "sha256": "c3ff5061d6e016b75217186ca6fa8b674b415c297499bc57e3d272c9cec7bec6", + "url": "https://www.myget.org/F/nunit/api/v3/flatcontainer/nunit/5.1.0-alpha.0.50/nunit.5.1.0-alpha.0.50.nupkg" + } + ] +} diff --git a/profiles/historical-alpha/Harness/packages.lock.json b/profiles/historical-alpha/Harness/packages.lock.json new file mode 100644 index 0000000..eac4c7d --- /dev/null +++ b/profiles/historical-alpha/Harness/packages.lock.json @@ -0,0 +1,21 @@ +{ + "version": 1, + "dependencies": { + "net10.0": { + "Microsoft.TestPlatform.TranslationLayer": { + "type": "Direct", + "requested": "[18.11.0, )", + "resolved": "18.11.0", + "contentHash": "PQk9INK5qLjQWzTuJCIDAah8AorDJatkBsCH/fDRTsENRqsAXBwzzY//Sqz5DuH7fQOyWTG+FHVO7FzLxNwCVQ==", + "dependencies": { + "Microsoft.TestPlatform.ObjectModel": "18.11.0" + } + }, + "Microsoft.TestPlatform.ObjectModel": { + "type": "Transitive", + "resolved": "18.11.0", + "contentHash": "BXBHYnwSOljKute8UYCMXOLAdB7awxEMppPSpqOF1ZxLD/W/OH+vTBgFaXA7q0aditJTVXSMVenel+wOkEIyNg==" + } + } + } +} \ No newline at end of file diff --git a/profiles/historical-alpha/baseline/MTP/packages.lock.json b/profiles/historical-alpha/baseline/MTP/packages.lock.json new file mode 100644 index 0000000..32d2c20 --- /dev/null +++ b/profiles/historical-alpha/baseline/MTP/packages.lock.json @@ -0,0 +1,278 @@ +{ + "version": 1, + "dependencies": { + "net10.0": { + "Microsoft.Testing.Extensions.TrxReport": { + "type": "Direct", + "requested": "[2.4.1, )", + "resolved": "2.4.1", + "contentHash": "KGAvJKRqhod45ecH4L1cCKIjGrzziUcLo3L4hRlfOg/Ww2Q7MnA30qHY2rnKzGyLVWf91tc2VleGe8c33FmPaQ==", + "dependencies": { + "Microsoft.Testing.Extensions.TrxReport.Abstractions": "2.4.1", + "Microsoft.Testing.Platform": "[2.4.1, 3.0.0)" + } + }, + "NUnit": { + "type": "Direct", + "requested": "[4.6.1, )", + "resolved": "4.6.1", + "contentHash": "xS4+YaBFUv1r8bcAbjitSfYaRZGfMwUiMdiaRziBXZpKgVxKDSHhjUn0mV5mObHGZRZq6eNa+WFWr3g8grj66A==" + }, + "NUnit3TestAdapter": { + "type": "Direct", + "requested": "[6.4.0-alpha.0.46, )", + "resolved": "6.4.0-alpha.0.46", + "contentHash": "ijzs+CHgmmACU4B9IfLcaikS9ZcuKbFGjus2Q0OGIRq0GcaC+Mh5CSsZ5PoCJnVh69ENlcCK5Ei86lsFPwlX/g==", + "dependencies": { + "Microsoft.Extensions.DependencyModel": "8.0.2", + "Microsoft.TestPlatform.AdapterUtilities": "18.11.0", + "Microsoft.Testing.Extensions.VSTestBridge": "2.5.2", + "Microsoft.Testing.Platform.MSBuild": "2.5.2" + } + }, + "Microsoft.ApplicationInsights": { + "type": "Transitive", + "resolved": "2.23.0", + "contentHash": "nWArUZTdU7iqZLycLKWe0TDms48KKGE6pONH2terYNa8REXiqixrMOkf1sk5DHGMaUTqONU2YkS4SAXBhLStgw==" + }, + "Microsoft.Extensions.DependencyModel": { + "type": "Transitive", + "resolved": "8.0.2", + "contentHash": "mUBDZZRgZrSyFOsJ2qJJ9fXfqd/kXJwf3AiDoqLD9m6TjY5OO/vLNOb9fb4juC0487eq4hcGN/M2Rh/CKS7QYw==" + }, + "Microsoft.Testing.Extensions.Telemetry": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "j1XGKCBrmfNm0tmotMa05GlqVtb2cW5UaMkKCFHPyyFHz5rdOy7TD0SVXnZJ+QMrjPAHjRoRqn5qcsUjICSWwg==", + "dependencies": { + "Microsoft.ApplicationInsights": "2.23.0", + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.Testing.Extensions.TrxReport.Abstractions": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "+xTIaIU9H44GxOyjrfieMSZnxltGvleA3jCRtdEAzlXKb85pMmVYMLUv2JS8KwD+U2wQHUgvy5YfQfWoPEfVdQ==", + "dependencies": { + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.Testing.Extensions.VSTestBridge": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "YRaP50aBAYMvw9g3NmQNmBYMPO5OiBT67vJgg5YQWdbuUA0m9ETmNikfEGKoiZX8A2rDuo8Bm4CWj0FKiw16og==", + "dependencies": { + "Microsoft.TestPlatform.ObjectModel": "18.10.1", + "Microsoft.Testing.Extensions.Telemetry": "2.5.2", + "Microsoft.Testing.Extensions.TrxReport.Abstractions": "2.5.2", + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.Testing.Platform": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "ocX0rgGY78dKfmZlZe4hB0/dvlh7wJgUAWS+KfwrqxB9DpNsjshnne9dppCKnFNEOkX4QYsrdUU++NInFPiCBw==" + }, + "Microsoft.Testing.Platform.MSBuild": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "Jey2v0hd7WHHa7pr6MRNKtA07FvxcOMTCtIhTI7uBZ/qR5m1mgCVCo5L1rtVAtqgMhGA205bUwq9+is4LiCzpw==", + "dependencies": { + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.TestPlatform.AdapterUtilities": { + "type": "Transitive", + "resolved": "18.11.0", + "contentHash": "fJG8ZYZtlUWR0AUG7FMZvYEGnumibFJDW9pmrbo9SQQnlRyXIHucBNKue+HsHjzIEDLIPPbn3sPn99/0fdwcGw==" + }, + "Microsoft.TestPlatform.ObjectModel": { + "type": "Transitive", + "resolved": "18.10.1", + "contentHash": "o+PuLDRVp1iwiVAPBADZItXgm9Ck23XtPhE4kZtZVi0uYnMiiz1Dx9Cjh75kJ+ijfqnORL3VOTOaQVKi0f/ixg==" + } + }, + "net11.0": { + "Microsoft.Testing.Extensions.TrxReport": { + "type": "Direct", + "requested": "[2.4.1, )", + "resolved": "2.4.1", + "contentHash": "KGAvJKRqhod45ecH4L1cCKIjGrzziUcLo3L4hRlfOg/Ww2Q7MnA30qHY2rnKzGyLVWf91tc2VleGe8c33FmPaQ==", + "dependencies": { + "Microsoft.Testing.Extensions.TrxReport.Abstractions": "2.4.1", + "Microsoft.Testing.Platform": "[2.4.1, 3.0.0)" + } + }, + "NUnit": { + "type": "Direct", + "requested": "[4.6.1, )", + "resolved": "4.6.1", + "contentHash": "xS4+YaBFUv1r8bcAbjitSfYaRZGfMwUiMdiaRziBXZpKgVxKDSHhjUn0mV5mObHGZRZq6eNa+WFWr3g8grj66A==" + }, + "NUnit3TestAdapter": { + "type": "Direct", + "requested": "[6.4.0-alpha.0.46, )", + "resolved": "6.4.0-alpha.0.46", + "contentHash": "ijzs+CHgmmACU4B9IfLcaikS9ZcuKbFGjus2Q0OGIRq0GcaC+Mh5CSsZ5PoCJnVh69ENlcCK5Ei86lsFPwlX/g==", + "dependencies": { + "Microsoft.Extensions.DependencyModel": "8.0.2", + "Microsoft.TestPlatform.AdapterUtilities": "18.11.0", + "Microsoft.Testing.Extensions.VSTestBridge": "2.5.2", + "Microsoft.Testing.Platform.MSBuild": "2.5.2" + } + }, + "Microsoft.ApplicationInsights": { + "type": "Transitive", + "resolved": "2.23.0", + "contentHash": "nWArUZTdU7iqZLycLKWe0TDms48KKGE6pONH2terYNa8REXiqixrMOkf1sk5DHGMaUTqONU2YkS4SAXBhLStgw==" + }, + "Microsoft.Extensions.DependencyModel": { + "type": "Transitive", + "resolved": "8.0.2", + "contentHash": "mUBDZZRgZrSyFOsJ2qJJ9fXfqd/kXJwf3AiDoqLD9m6TjY5OO/vLNOb9fb4juC0487eq4hcGN/M2Rh/CKS7QYw==" + }, + "Microsoft.Testing.Extensions.Telemetry": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "j1XGKCBrmfNm0tmotMa05GlqVtb2cW5UaMkKCFHPyyFHz5rdOy7TD0SVXnZJ+QMrjPAHjRoRqn5qcsUjICSWwg==", + "dependencies": { + "Microsoft.ApplicationInsights": "2.23.0", + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.Testing.Extensions.TrxReport.Abstractions": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "+xTIaIU9H44GxOyjrfieMSZnxltGvleA3jCRtdEAzlXKb85pMmVYMLUv2JS8KwD+U2wQHUgvy5YfQfWoPEfVdQ==", + "dependencies": { + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.Testing.Extensions.VSTestBridge": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "YRaP50aBAYMvw9g3NmQNmBYMPO5OiBT67vJgg5YQWdbuUA0m9ETmNikfEGKoiZX8A2rDuo8Bm4CWj0FKiw16og==", + "dependencies": { + "Microsoft.TestPlatform.ObjectModel": "18.10.1", + "Microsoft.Testing.Extensions.Telemetry": "2.5.2", + "Microsoft.Testing.Extensions.TrxReport.Abstractions": "2.5.2", + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.Testing.Platform": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "ocX0rgGY78dKfmZlZe4hB0/dvlh7wJgUAWS+KfwrqxB9DpNsjshnne9dppCKnFNEOkX4QYsrdUU++NInFPiCBw==" + }, + "Microsoft.Testing.Platform.MSBuild": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "Jey2v0hd7WHHa7pr6MRNKtA07FvxcOMTCtIhTI7uBZ/qR5m1mgCVCo5L1rtVAtqgMhGA205bUwq9+is4LiCzpw==", + "dependencies": { + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.TestPlatform.AdapterUtilities": { + "type": "Transitive", + "resolved": "18.11.0", + "contentHash": "fJG8ZYZtlUWR0AUG7FMZvYEGnumibFJDW9pmrbo9SQQnlRyXIHucBNKue+HsHjzIEDLIPPbn3sPn99/0fdwcGw==" + }, + "Microsoft.TestPlatform.ObjectModel": { + "type": "Transitive", + "resolved": "18.10.1", + "contentHash": "o+PuLDRVp1iwiVAPBADZItXgm9Ck23XtPhE4kZtZVi0uYnMiiz1Dx9Cjh75kJ+ijfqnORL3VOTOaQVKi0f/ixg==" + } + }, + "net8.0": { + "Microsoft.Testing.Extensions.TrxReport": { + "type": "Direct", + "requested": "[2.4.1, )", + "resolved": "2.4.1", + "contentHash": "KGAvJKRqhod45ecH4L1cCKIjGrzziUcLo3L4hRlfOg/Ww2Q7MnA30qHY2rnKzGyLVWf91tc2VleGe8c33FmPaQ==", + "dependencies": { + "Microsoft.Testing.Extensions.TrxReport.Abstractions": "2.4.1", + "Microsoft.Testing.Platform": "[2.4.1, 3.0.0)" + } + }, + "NUnit": { + "type": "Direct", + "requested": "[4.6.1, )", + "resolved": "4.6.1", + "contentHash": "xS4+YaBFUv1r8bcAbjitSfYaRZGfMwUiMdiaRziBXZpKgVxKDSHhjUn0mV5mObHGZRZq6eNa+WFWr3g8grj66A==" + }, + "NUnit3TestAdapter": { + "type": "Direct", + "requested": "[6.4.0-alpha.0.46, )", + "resolved": "6.4.0-alpha.0.46", + "contentHash": "ijzs+CHgmmACU4B9IfLcaikS9ZcuKbFGjus2Q0OGIRq0GcaC+Mh5CSsZ5PoCJnVh69ENlcCK5Ei86lsFPwlX/g==", + "dependencies": { + "Microsoft.Extensions.DependencyModel": "8.0.2", + "Microsoft.TestPlatform.AdapterUtilities": "18.11.0", + "Microsoft.Testing.Extensions.VSTestBridge": "2.5.2", + "Microsoft.Testing.Platform.MSBuild": "2.5.2" + } + }, + "Microsoft.ApplicationInsights": { + "type": "Transitive", + "resolved": "2.23.0", + "contentHash": "nWArUZTdU7iqZLycLKWe0TDms48KKGE6pONH2terYNa8REXiqixrMOkf1sk5DHGMaUTqONU2YkS4SAXBhLStgw==" + }, + "Microsoft.Extensions.DependencyModel": { + "type": "Transitive", + "resolved": "8.0.2", + "contentHash": "mUBDZZRgZrSyFOsJ2qJJ9fXfqd/kXJwf3AiDoqLD9m6TjY5OO/vLNOb9fb4juC0487eq4hcGN/M2Rh/CKS7QYw==" + }, + "Microsoft.Testing.Extensions.Telemetry": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "j1XGKCBrmfNm0tmotMa05GlqVtb2cW5UaMkKCFHPyyFHz5rdOy7TD0SVXnZJ+QMrjPAHjRoRqn5qcsUjICSWwg==", + "dependencies": { + "Microsoft.ApplicationInsights": "2.23.0", + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.Testing.Extensions.TrxReport.Abstractions": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "+xTIaIU9H44GxOyjrfieMSZnxltGvleA3jCRtdEAzlXKb85pMmVYMLUv2JS8KwD+U2wQHUgvy5YfQfWoPEfVdQ==", + "dependencies": { + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.Testing.Extensions.VSTestBridge": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "YRaP50aBAYMvw9g3NmQNmBYMPO5OiBT67vJgg5YQWdbuUA0m9ETmNikfEGKoiZX8A2rDuo8Bm4CWj0FKiw16og==", + "dependencies": { + "Microsoft.TestPlatform.ObjectModel": "18.10.1", + "Microsoft.Testing.Extensions.Telemetry": "2.5.2", + "Microsoft.Testing.Extensions.TrxReport.Abstractions": "2.5.2", + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.Testing.Platform": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "ocX0rgGY78dKfmZlZe4hB0/dvlh7wJgUAWS+KfwrqxB9DpNsjshnne9dppCKnFNEOkX4QYsrdUU++NInFPiCBw==" + }, + "Microsoft.Testing.Platform.MSBuild": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "Jey2v0hd7WHHa7pr6MRNKtA07FvxcOMTCtIhTI7uBZ/qR5m1mgCVCo5L1rtVAtqgMhGA205bUwq9+is4LiCzpw==", + "dependencies": { + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.TestPlatform.AdapterUtilities": { + "type": "Transitive", + "resolved": "18.11.0", + "contentHash": "fJG8ZYZtlUWR0AUG7FMZvYEGnumibFJDW9pmrbo9SQQnlRyXIHucBNKue+HsHjzIEDLIPPbn3sPn99/0fdwcGw==" + }, + "Microsoft.TestPlatform.ObjectModel": { + "type": "Transitive", + "resolved": "18.10.1", + "contentHash": "o+PuLDRVp1iwiVAPBADZItXgm9Ck23XtPhE4kZtZVi0uYnMiiz1Dx9Cjh75kJ+ijfqnORL3VOTOaQVKi0f/ixg==" + } + } + } +} \ No newline at end of file diff --git a/profiles/historical-alpha/baseline/VSTest/packages.lock.json b/profiles/historical-alpha/baseline/VSTest/packages.lock.json new file mode 100644 index 0000000..181ca1a --- /dev/null +++ b/profiles/historical-alpha/baseline/VSTest/packages.lock.json @@ -0,0 +1,317 @@ +{ + "version": 1, + "dependencies": { + "net10.0": { + "Microsoft.NET.Test.Sdk": { + "type": "Direct", + "requested": "[18.11.0, )", + "resolved": "18.11.0", + "contentHash": "xf/bR0LNkhK0SnadDRlZIQmC4sac5Wk0e1WAdiQjRN3MSo6gQ9M2c4c1XRNnVGjfOvckh704W5CJ19AL0/Xsdg==", + "dependencies": { + "Microsoft.CodeCoverage": "18.11.0", + "Microsoft.TestPlatform.TestHost": "18.11.0" + } + }, + "NUnit": { + "type": "Direct", + "requested": "[4.6.1, )", + "resolved": "4.6.1", + "contentHash": "xS4+YaBFUv1r8bcAbjitSfYaRZGfMwUiMdiaRziBXZpKgVxKDSHhjUn0mV5mObHGZRZq6eNa+WFWr3g8grj66A==" + }, + "NUnit3TestAdapter": { + "type": "Direct", + "requested": "[6.4.0-alpha.0.46, )", + "resolved": "6.4.0-alpha.0.46", + "contentHash": "ijzs+CHgmmACU4B9IfLcaikS9ZcuKbFGjus2Q0OGIRq0GcaC+Mh5CSsZ5PoCJnVh69ENlcCK5Ei86lsFPwlX/g==", + "dependencies": { + "Microsoft.Extensions.DependencyModel": "8.0.2", + "Microsoft.TestPlatform.AdapterUtilities": "18.11.0", + "Microsoft.Testing.Extensions.VSTestBridge": "2.5.2", + "Microsoft.Testing.Platform.MSBuild": "2.5.2" + } + }, + "Microsoft.ApplicationInsights": { + "type": "Transitive", + "resolved": "2.23.0", + "contentHash": "nWArUZTdU7iqZLycLKWe0TDms48KKGE6pONH2terYNa8REXiqixrMOkf1sk5DHGMaUTqONU2YkS4SAXBhLStgw==" + }, + "Microsoft.CodeCoverage": { + "type": "Transitive", + "resolved": "18.11.0", + "contentHash": "MhN9wpvL1Es4hfIYslrsVgIsUdDFxuOBTbAl9mGIMvFo8PP5CLf4DrGdNrfwWSyn0lqi6sssm+I/qkkLL3MU+g==" + }, + "Microsoft.Extensions.DependencyModel": { + "type": "Transitive", + "resolved": "8.0.2", + "contentHash": "mUBDZZRgZrSyFOsJ2qJJ9fXfqd/kXJwf3AiDoqLD9m6TjY5OO/vLNOb9fb4juC0487eq4hcGN/M2Rh/CKS7QYw==" + }, + "Microsoft.Testing.Extensions.Telemetry": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "j1XGKCBrmfNm0tmotMa05GlqVtb2cW5UaMkKCFHPyyFHz5rdOy7TD0SVXnZJ+QMrjPAHjRoRqn5qcsUjICSWwg==", + "dependencies": { + "Microsoft.ApplicationInsights": "2.23.0", + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.Testing.Extensions.TrxReport.Abstractions": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "+xTIaIU9H44GxOyjrfieMSZnxltGvleA3jCRtdEAzlXKb85pMmVYMLUv2JS8KwD+U2wQHUgvy5YfQfWoPEfVdQ==", + "dependencies": { + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.Testing.Extensions.VSTestBridge": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "YRaP50aBAYMvw9g3NmQNmBYMPO5OiBT67vJgg5YQWdbuUA0m9ETmNikfEGKoiZX8A2rDuo8Bm4CWj0FKiw16og==", + "dependencies": { + "Microsoft.TestPlatform.ObjectModel": "18.10.1", + "Microsoft.Testing.Extensions.Telemetry": "2.5.2", + "Microsoft.Testing.Extensions.TrxReport.Abstractions": "2.5.2", + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.Testing.Platform": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "ocX0rgGY78dKfmZlZe4hB0/dvlh7wJgUAWS+KfwrqxB9DpNsjshnne9dppCKnFNEOkX4QYsrdUU++NInFPiCBw==" + }, + "Microsoft.Testing.Platform.MSBuild": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "Jey2v0hd7WHHa7pr6MRNKtA07FvxcOMTCtIhTI7uBZ/qR5m1mgCVCo5L1rtVAtqgMhGA205bUwq9+is4LiCzpw==", + "dependencies": { + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.TestPlatform.AdapterUtilities": { + "type": "Transitive", + "resolved": "18.11.0", + "contentHash": "fJG8ZYZtlUWR0AUG7FMZvYEGnumibFJDW9pmrbo9SQQnlRyXIHucBNKue+HsHjzIEDLIPPbn3sPn99/0fdwcGw==" + }, + "Microsoft.TestPlatform.ObjectModel": { + "type": "Transitive", + "resolved": "18.11.0", + "contentHash": "BXBHYnwSOljKute8UYCMXOLAdB7awxEMppPSpqOF1ZxLD/W/OH+vTBgFaXA7q0aditJTVXSMVenel+wOkEIyNg==" + }, + "Microsoft.TestPlatform.TestHost": { + "type": "Transitive", + "resolved": "18.11.0", + "contentHash": "AKjwKpyRBwoQFQmpcchtoYlfJEBlaY/40uxBRi+qXP4NR7xT8t+XTJtOyEyumfvfJcH5pASs75LwNdXYRr4XNA==", + "dependencies": { + "Microsoft.TestPlatform.ObjectModel": "18.11.0" + } + } + }, + "net11.0": { + "Microsoft.NET.Test.Sdk": { + "type": "Direct", + "requested": "[18.11.0, )", + "resolved": "18.11.0", + "contentHash": "xf/bR0LNkhK0SnadDRlZIQmC4sac5Wk0e1WAdiQjRN3MSo6gQ9M2c4c1XRNnVGjfOvckh704W5CJ19AL0/Xsdg==", + "dependencies": { + "Microsoft.CodeCoverage": "18.11.0", + "Microsoft.TestPlatform.TestHost": "18.11.0" + } + }, + "NUnit": { + "type": "Direct", + "requested": "[4.6.1, )", + "resolved": "4.6.1", + "contentHash": "xS4+YaBFUv1r8bcAbjitSfYaRZGfMwUiMdiaRziBXZpKgVxKDSHhjUn0mV5mObHGZRZq6eNa+WFWr3g8grj66A==" + }, + "NUnit3TestAdapter": { + "type": "Direct", + "requested": "[6.4.0-alpha.0.46, )", + "resolved": "6.4.0-alpha.0.46", + "contentHash": "ijzs+CHgmmACU4B9IfLcaikS9ZcuKbFGjus2Q0OGIRq0GcaC+Mh5CSsZ5PoCJnVh69ENlcCK5Ei86lsFPwlX/g==", + "dependencies": { + "Microsoft.Extensions.DependencyModel": "8.0.2", + "Microsoft.TestPlatform.AdapterUtilities": "18.11.0", + "Microsoft.Testing.Extensions.VSTestBridge": "2.5.2", + "Microsoft.Testing.Platform.MSBuild": "2.5.2" + } + }, + "Microsoft.ApplicationInsights": { + "type": "Transitive", + "resolved": "2.23.0", + "contentHash": "nWArUZTdU7iqZLycLKWe0TDms48KKGE6pONH2terYNa8REXiqixrMOkf1sk5DHGMaUTqONU2YkS4SAXBhLStgw==" + }, + "Microsoft.CodeCoverage": { + "type": "Transitive", + "resolved": "18.11.0", + "contentHash": "MhN9wpvL1Es4hfIYslrsVgIsUdDFxuOBTbAl9mGIMvFo8PP5CLf4DrGdNrfwWSyn0lqi6sssm+I/qkkLL3MU+g==" + }, + "Microsoft.Extensions.DependencyModel": { + "type": "Transitive", + "resolved": "8.0.2", + "contentHash": "mUBDZZRgZrSyFOsJ2qJJ9fXfqd/kXJwf3AiDoqLD9m6TjY5OO/vLNOb9fb4juC0487eq4hcGN/M2Rh/CKS7QYw==" + }, + "Microsoft.Testing.Extensions.Telemetry": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "j1XGKCBrmfNm0tmotMa05GlqVtb2cW5UaMkKCFHPyyFHz5rdOy7TD0SVXnZJ+QMrjPAHjRoRqn5qcsUjICSWwg==", + "dependencies": { + "Microsoft.ApplicationInsights": "2.23.0", + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.Testing.Extensions.TrxReport.Abstractions": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "+xTIaIU9H44GxOyjrfieMSZnxltGvleA3jCRtdEAzlXKb85pMmVYMLUv2JS8KwD+U2wQHUgvy5YfQfWoPEfVdQ==", + "dependencies": { + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.Testing.Extensions.VSTestBridge": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "YRaP50aBAYMvw9g3NmQNmBYMPO5OiBT67vJgg5YQWdbuUA0m9ETmNikfEGKoiZX8A2rDuo8Bm4CWj0FKiw16og==", + "dependencies": { + "Microsoft.TestPlatform.ObjectModel": "18.10.1", + "Microsoft.Testing.Extensions.Telemetry": "2.5.2", + "Microsoft.Testing.Extensions.TrxReport.Abstractions": "2.5.2", + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.Testing.Platform": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "ocX0rgGY78dKfmZlZe4hB0/dvlh7wJgUAWS+KfwrqxB9DpNsjshnne9dppCKnFNEOkX4QYsrdUU++NInFPiCBw==" + }, + "Microsoft.Testing.Platform.MSBuild": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "Jey2v0hd7WHHa7pr6MRNKtA07FvxcOMTCtIhTI7uBZ/qR5m1mgCVCo5L1rtVAtqgMhGA205bUwq9+is4LiCzpw==", + "dependencies": { + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.TestPlatform.AdapterUtilities": { + "type": "Transitive", + "resolved": "18.11.0", + "contentHash": "fJG8ZYZtlUWR0AUG7FMZvYEGnumibFJDW9pmrbo9SQQnlRyXIHucBNKue+HsHjzIEDLIPPbn3sPn99/0fdwcGw==" + }, + "Microsoft.TestPlatform.ObjectModel": { + "type": "Transitive", + "resolved": "18.11.0", + "contentHash": "BXBHYnwSOljKute8UYCMXOLAdB7awxEMppPSpqOF1ZxLD/W/OH+vTBgFaXA7q0aditJTVXSMVenel+wOkEIyNg==" + }, + "Microsoft.TestPlatform.TestHost": { + "type": "Transitive", + "resolved": "18.11.0", + "contentHash": "AKjwKpyRBwoQFQmpcchtoYlfJEBlaY/40uxBRi+qXP4NR7xT8t+XTJtOyEyumfvfJcH5pASs75LwNdXYRr4XNA==", + "dependencies": { + "Microsoft.TestPlatform.ObjectModel": "18.11.0" + } + } + }, + "net8.0": { + "Microsoft.NET.Test.Sdk": { + "type": "Direct", + "requested": "[18.11.0, )", + "resolved": "18.11.0", + "contentHash": "xf/bR0LNkhK0SnadDRlZIQmC4sac5Wk0e1WAdiQjRN3MSo6gQ9M2c4c1XRNnVGjfOvckh704W5CJ19AL0/Xsdg==", + "dependencies": { + "Microsoft.CodeCoverage": "18.11.0", + "Microsoft.TestPlatform.TestHost": "18.11.0" + } + }, + "NUnit": { + "type": "Direct", + "requested": "[4.6.1, )", + "resolved": "4.6.1", + "contentHash": "xS4+YaBFUv1r8bcAbjitSfYaRZGfMwUiMdiaRziBXZpKgVxKDSHhjUn0mV5mObHGZRZq6eNa+WFWr3g8grj66A==" + }, + "NUnit3TestAdapter": { + "type": "Direct", + "requested": "[6.4.0-alpha.0.46, )", + "resolved": "6.4.0-alpha.0.46", + "contentHash": "ijzs+CHgmmACU4B9IfLcaikS9ZcuKbFGjus2Q0OGIRq0GcaC+Mh5CSsZ5PoCJnVh69ENlcCK5Ei86lsFPwlX/g==", + "dependencies": { + "Microsoft.Extensions.DependencyModel": "8.0.2", + "Microsoft.TestPlatform.AdapterUtilities": "18.11.0", + "Microsoft.Testing.Extensions.VSTestBridge": "2.5.2", + "Microsoft.Testing.Platform.MSBuild": "2.5.2" + } + }, + "Microsoft.ApplicationInsights": { + "type": "Transitive", + "resolved": "2.23.0", + "contentHash": "nWArUZTdU7iqZLycLKWe0TDms48KKGE6pONH2terYNa8REXiqixrMOkf1sk5DHGMaUTqONU2YkS4SAXBhLStgw==" + }, + "Microsoft.CodeCoverage": { + "type": "Transitive", + "resolved": "18.11.0", + "contentHash": "MhN9wpvL1Es4hfIYslrsVgIsUdDFxuOBTbAl9mGIMvFo8PP5CLf4DrGdNrfwWSyn0lqi6sssm+I/qkkLL3MU+g==" + }, + "Microsoft.Extensions.DependencyModel": { + "type": "Transitive", + "resolved": "8.0.2", + "contentHash": "mUBDZZRgZrSyFOsJ2qJJ9fXfqd/kXJwf3AiDoqLD9m6TjY5OO/vLNOb9fb4juC0487eq4hcGN/M2Rh/CKS7QYw==" + }, + "Microsoft.Testing.Extensions.Telemetry": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "j1XGKCBrmfNm0tmotMa05GlqVtb2cW5UaMkKCFHPyyFHz5rdOy7TD0SVXnZJ+QMrjPAHjRoRqn5qcsUjICSWwg==", + "dependencies": { + "Microsoft.ApplicationInsights": "2.23.0", + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.Testing.Extensions.TrxReport.Abstractions": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "+xTIaIU9H44GxOyjrfieMSZnxltGvleA3jCRtdEAzlXKb85pMmVYMLUv2JS8KwD+U2wQHUgvy5YfQfWoPEfVdQ==", + "dependencies": { + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.Testing.Extensions.VSTestBridge": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "YRaP50aBAYMvw9g3NmQNmBYMPO5OiBT67vJgg5YQWdbuUA0m9ETmNikfEGKoiZX8A2rDuo8Bm4CWj0FKiw16og==", + "dependencies": { + "Microsoft.TestPlatform.ObjectModel": "18.10.1", + "Microsoft.Testing.Extensions.Telemetry": "2.5.2", + "Microsoft.Testing.Extensions.TrxReport.Abstractions": "2.5.2", + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.Testing.Platform": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "ocX0rgGY78dKfmZlZe4hB0/dvlh7wJgUAWS+KfwrqxB9DpNsjshnne9dppCKnFNEOkX4QYsrdUU++NInFPiCBw==" + }, + "Microsoft.Testing.Platform.MSBuild": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "Jey2v0hd7WHHa7pr6MRNKtA07FvxcOMTCtIhTI7uBZ/qR5m1mgCVCo5L1rtVAtqgMhGA205bUwq9+is4LiCzpw==", + "dependencies": { + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.TestPlatform.AdapterUtilities": { + "type": "Transitive", + "resolved": "18.11.0", + "contentHash": "fJG8ZYZtlUWR0AUG7FMZvYEGnumibFJDW9pmrbo9SQQnlRyXIHucBNKue+HsHjzIEDLIPPbn3sPn99/0fdwcGw==" + }, + "Microsoft.TestPlatform.ObjectModel": { + "type": "Transitive", + "resolved": "18.11.0", + "contentHash": "BXBHYnwSOljKute8UYCMXOLAdB7awxEMppPSpqOF1ZxLD/W/OH+vTBgFaXA7q0aditJTVXSMVenel+wOkEIyNg==" + }, + "Microsoft.TestPlatform.TestHost": { + "type": "Transitive", + "resolved": "18.11.0", + "contentHash": "AKjwKpyRBwoQFQmpcchtoYlfJEBlaY/40uxBRi+qXP4NR7xT8t+XTJtOyEyumfvfJcH5pASs75LwNdXYRr4XNA==", + "dependencies": { + "Microsoft.TestPlatform.ObjectModel": "18.11.0" + } + } + } + } +} \ No newline at end of file diff --git a/profiles/historical-alpha/candidate/MTP/packages.lock.json b/profiles/historical-alpha/candidate/MTP/packages.lock.json new file mode 100644 index 0000000..bb7c187 --- /dev/null +++ b/profiles/historical-alpha/candidate/MTP/packages.lock.json @@ -0,0 +1,278 @@ +{ + "version": 1, + "dependencies": { + "net10.0": { + "Microsoft.Testing.Extensions.TrxReport": { + "type": "Direct", + "requested": "[2.4.1, )", + "resolved": "2.4.1", + "contentHash": "KGAvJKRqhod45ecH4L1cCKIjGrzziUcLo3L4hRlfOg/Ww2Q7MnA30qHY2rnKzGyLVWf91tc2VleGe8c33FmPaQ==", + "dependencies": { + "Microsoft.Testing.Extensions.TrxReport.Abstractions": "2.4.1", + "Microsoft.Testing.Platform": "[2.4.1, 3.0.0)" + } + }, + "NUnit": { + "type": "Direct", + "requested": "[5.1.0-alpha.0.50, )", + "resolved": "5.1.0-alpha.0.50", + "contentHash": "D1quOSRFXxFM1zQ9esp0/J+z3TSWg51CCL7InL0VoiaojcrqmqopMYq43fkXQbz6qMqmJnJatytsPNIlJzPFVA==" + }, + "NUnit3TestAdapter": { + "type": "Direct", + "requested": "[6.4.0-alpha.0.46, )", + "resolved": "6.4.0-alpha.0.46", + "contentHash": "ijzs+CHgmmACU4B9IfLcaikS9ZcuKbFGjus2Q0OGIRq0GcaC+Mh5CSsZ5PoCJnVh69ENlcCK5Ei86lsFPwlX/g==", + "dependencies": { + "Microsoft.Extensions.DependencyModel": "8.0.2", + "Microsoft.TestPlatform.AdapterUtilities": "18.11.0", + "Microsoft.Testing.Extensions.VSTestBridge": "2.5.2", + "Microsoft.Testing.Platform.MSBuild": "2.5.2" + } + }, + "Microsoft.ApplicationInsights": { + "type": "Transitive", + "resolved": "2.23.0", + "contentHash": "nWArUZTdU7iqZLycLKWe0TDms48KKGE6pONH2terYNa8REXiqixrMOkf1sk5DHGMaUTqONU2YkS4SAXBhLStgw==" + }, + "Microsoft.Extensions.DependencyModel": { + "type": "Transitive", + "resolved": "8.0.2", + "contentHash": "mUBDZZRgZrSyFOsJ2qJJ9fXfqd/kXJwf3AiDoqLD9m6TjY5OO/vLNOb9fb4juC0487eq4hcGN/M2Rh/CKS7QYw==" + }, + "Microsoft.Testing.Extensions.Telemetry": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "j1XGKCBrmfNm0tmotMa05GlqVtb2cW5UaMkKCFHPyyFHz5rdOy7TD0SVXnZJ+QMrjPAHjRoRqn5qcsUjICSWwg==", + "dependencies": { + "Microsoft.ApplicationInsights": "2.23.0", + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.Testing.Extensions.TrxReport.Abstractions": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "+xTIaIU9H44GxOyjrfieMSZnxltGvleA3jCRtdEAzlXKb85pMmVYMLUv2JS8KwD+U2wQHUgvy5YfQfWoPEfVdQ==", + "dependencies": { + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.Testing.Extensions.VSTestBridge": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "YRaP50aBAYMvw9g3NmQNmBYMPO5OiBT67vJgg5YQWdbuUA0m9ETmNikfEGKoiZX8A2rDuo8Bm4CWj0FKiw16og==", + "dependencies": { + "Microsoft.TestPlatform.ObjectModel": "18.10.1", + "Microsoft.Testing.Extensions.Telemetry": "2.5.2", + "Microsoft.Testing.Extensions.TrxReport.Abstractions": "2.5.2", + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.Testing.Platform": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "ocX0rgGY78dKfmZlZe4hB0/dvlh7wJgUAWS+KfwrqxB9DpNsjshnne9dppCKnFNEOkX4QYsrdUU++NInFPiCBw==" + }, + "Microsoft.Testing.Platform.MSBuild": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "Jey2v0hd7WHHa7pr6MRNKtA07FvxcOMTCtIhTI7uBZ/qR5m1mgCVCo5L1rtVAtqgMhGA205bUwq9+is4LiCzpw==", + "dependencies": { + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.TestPlatform.AdapterUtilities": { + "type": "Transitive", + "resolved": "18.11.0", + "contentHash": "fJG8ZYZtlUWR0AUG7FMZvYEGnumibFJDW9pmrbo9SQQnlRyXIHucBNKue+HsHjzIEDLIPPbn3sPn99/0fdwcGw==" + }, + "Microsoft.TestPlatform.ObjectModel": { + "type": "Transitive", + "resolved": "18.10.1", + "contentHash": "o+PuLDRVp1iwiVAPBADZItXgm9Ck23XtPhE4kZtZVi0uYnMiiz1Dx9Cjh75kJ+ijfqnORL3VOTOaQVKi0f/ixg==" + } + }, + "net11.0": { + "Microsoft.Testing.Extensions.TrxReport": { + "type": "Direct", + "requested": "[2.4.1, )", + "resolved": "2.4.1", + "contentHash": "KGAvJKRqhod45ecH4L1cCKIjGrzziUcLo3L4hRlfOg/Ww2Q7MnA30qHY2rnKzGyLVWf91tc2VleGe8c33FmPaQ==", + "dependencies": { + "Microsoft.Testing.Extensions.TrxReport.Abstractions": "2.4.1", + "Microsoft.Testing.Platform": "[2.4.1, 3.0.0)" + } + }, + "NUnit": { + "type": "Direct", + "requested": "[5.1.0-alpha.0.50, )", + "resolved": "5.1.0-alpha.0.50", + "contentHash": "D1quOSRFXxFM1zQ9esp0/J+z3TSWg51CCL7InL0VoiaojcrqmqopMYq43fkXQbz6qMqmJnJatytsPNIlJzPFVA==" + }, + "NUnit3TestAdapter": { + "type": "Direct", + "requested": "[6.4.0-alpha.0.46, )", + "resolved": "6.4.0-alpha.0.46", + "contentHash": "ijzs+CHgmmACU4B9IfLcaikS9ZcuKbFGjus2Q0OGIRq0GcaC+Mh5CSsZ5PoCJnVh69ENlcCK5Ei86lsFPwlX/g==", + "dependencies": { + "Microsoft.Extensions.DependencyModel": "8.0.2", + "Microsoft.TestPlatform.AdapterUtilities": "18.11.0", + "Microsoft.Testing.Extensions.VSTestBridge": "2.5.2", + "Microsoft.Testing.Platform.MSBuild": "2.5.2" + } + }, + "Microsoft.ApplicationInsights": { + "type": "Transitive", + "resolved": "2.23.0", + "contentHash": "nWArUZTdU7iqZLycLKWe0TDms48KKGE6pONH2terYNa8REXiqixrMOkf1sk5DHGMaUTqONU2YkS4SAXBhLStgw==" + }, + "Microsoft.Extensions.DependencyModel": { + "type": "Transitive", + "resolved": "8.0.2", + "contentHash": "mUBDZZRgZrSyFOsJ2qJJ9fXfqd/kXJwf3AiDoqLD9m6TjY5OO/vLNOb9fb4juC0487eq4hcGN/M2Rh/CKS7QYw==" + }, + "Microsoft.Testing.Extensions.Telemetry": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "j1XGKCBrmfNm0tmotMa05GlqVtb2cW5UaMkKCFHPyyFHz5rdOy7TD0SVXnZJ+QMrjPAHjRoRqn5qcsUjICSWwg==", + "dependencies": { + "Microsoft.ApplicationInsights": "2.23.0", + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.Testing.Extensions.TrxReport.Abstractions": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "+xTIaIU9H44GxOyjrfieMSZnxltGvleA3jCRtdEAzlXKb85pMmVYMLUv2JS8KwD+U2wQHUgvy5YfQfWoPEfVdQ==", + "dependencies": { + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.Testing.Extensions.VSTestBridge": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "YRaP50aBAYMvw9g3NmQNmBYMPO5OiBT67vJgg5YQWdbuUA0m9ETmNikfEGKoiZX8A2rDuo8Bm4CWj0FKiw16og==", + "dependencies": { + "Microsoft.TestPlatform.ObjectModel": "18.10.1", + "Microsoft.Testing.Extensions.Telemetry": "2.5.2", + "Microsoft.Testing.Extensions.TrxReport.Abstractions": "2.5.2", + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.Testing.Platform": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "ocX0rgGY78dKfmZlZe4hB0/dvlh7wJgUAWS+KfwrqxB9DpNsjshnne9dppCKnFNEOkX4QYsrdUU++NInFPiCBw==" + }, + "Microsoft.Testing.Platform.MSBuild": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "Jey2v0hd7WHHa7pr6MRNKtA07FvxcOMTCtIhTI7uBZ/qR5m1mgCVCo5L1rtVAtqgMhGA205bUwq9+is4LiCzpw==", + "dependencies": { + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.TestPlatform.AdapterUtilities": { + "type": "Transitive", + "resolved": "18.11.0", + "contentHash": "fJG8ZYZtlUWR0AUG7FMZvYEGnumibFJDW9pmrbo9SQQnlRyXIHucBNKue+HsHjzIEDLIPPbn3sPn99/0fdwcGw==" + }, + "Microsoft.TestPlatform.ObjectModel": { + "type": "Transitive", + "resolved": "18.10.1", + "contentHash": "o+PuLDRVp1iwiVAPBADZItXgm9Ck23XtPhE4kZtZVi0uYnMiiz1Dx9Cjh75kJ+ijfqnORL3VOTOaQVKi0f/ixg==" + } + }, + "net8.0": { + "Microsoft.Testing.Extensions.TrxReport": { + "type": "Direct", + "requested": "[2.4.1, )", + "resolved": "2.4.1", + "contentHash": "KGAvJKRqhod45ecH4L1cCKIjGrzziUcLo3L4hRlfOg/Ww2Q7MnA30qHY2rnKzGyLVWf91tc2VleGe8c33FmPaQ==", + "dependencies": { + "Microsoft.Testing.Extensions.TrxReport.Abstractions": "2.4.1", + "Microsoft.Testing.Platform": "[2.4.1, 3.0.0)" + } + }, + "NUnit": { + "type": "Direct", + "requested": "[5.1.0-alpha.0.50, )", + "resolved": "5.1.0-alpha.0.50", + "contentHash": "D1quOSRFXxFM1zQ9esp0/J+z3TSWg51CCL7InL0VoiaojcrqmqopMYq43fkXQbz6qMqmJnJatytsPNIlJzPFVA==" + }, + "NUnit3TestAdapter": { + "type": "Direct", + "requested": "[6.4.0-alpha.0.46, )", + "resolved": "6.4.0-alpha.0.46", + "contentHash": "ijzs+CHgmmACU4B9IfLcaikS9ZcuKbFGjus2Q0OGIRq0GcaC+Mh5CSsZ5PoCJnVh69ENlcCK5Ei86lsFPwlX/g==", + "dependencies": { + "Microsoft.Extensions.DependencyModel": "8.0.2", + "Microsoft.TestPlatform.AdapterUtilities": "18.11.0", + "Microsoft.Testing.Extensions.VSTestBridge": "2.5.2", + "Microsoft.Testing.Platform.MSBuild": "2.5.2" + } + }, + "Microsoft.ApplicationInsights": { + "type": "Transitive", + "resolved": "2.23.0", + "contentHash": "nWArUZTdU7iqZLycLKWe0TDms48KKGE6pONH2terYNa8REXiqixrMOkf1sk5DHGMaUTqONU2YkS4SAXBhLStgw==" + }, + "Microsoft.Extensions.DependencyModel": { + "type": "Transitive", + "resolved": "8.0.2", + "contentHash": "mUBDZZRgZrSyFOsJ2qJJ9fXfqd/kXJwf3AiDoqLD9m6TjY5OO/vLNOb9fb4juC0487eq4hcGN/M2Rh/CKS7QYw==" + }, + "Microsoft.Testing.Extensions.Telemetry": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "j1XGKCBrmfNm0tmotMa05GlqVtb2cW5UaMkKCFHPyyFHz5rdOy7TD0SVXnZJ+QMrjPAHjRoRqn5qcsUjICSWwg==", + "dependencies": { + "Microsoft.ApplicationInsights": "2.23.0", + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.Testing.Extensions.TrxReport.Abstractions": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "+xTIaIU9H44GxOyjrfieMSZnxltGvleA3jCRtdEAzlXKb85pMmVYMLUv2JS8KwD+U2wQHUgvy5YfQfWoPEfVdQ==", + "dependencies": { + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.Testing.Extensions.VSTestBridge": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "YRaP50aBAYMvw9g3NmQNmBYMPO5OiBT67vJgg5YQWdbuUA0m9ETmNikfEGKoiZX8A2rDuo8Bm4CWj0FKiw16og==", + "dependencies": { + "Microsoft.TestPlatform.ObjectModel": "18.10.1", + "Microsoft.Testing.Extensions.Telemetry": "2.5.2", + "Microsoft.Testing.Extensions.TrxReport.Abstractions": "2.5.2", + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.Testing.Platform": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "ocX0rgGY78dKfmZlZe4hB0/dvlh7wJgUAWS+KfwrqxB9DpNsjshnne9dppCKnFNEOkX4QYsrdUU++NInFPiCBw==" + }, + "Microsoft.Testing.Platform.MSBuild": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "Jey2v0hd7WHHa7pr6MRNKtA07FvxcOMTCtIhTI7uBZ/qR5m1mgCVCo5L1rtVAtqgMhGA205bUwq9+is4LiCzpw==", + "dependencies": { + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.TestPlatform.AdapterUtilities": { + "type": "Transitive", + "resolved": "18.11.0", + "contentHash": "fJG8ZYZtlUWR0AUG7FMZvYEGnumibFJDW9pmrbo9SQQnlRyXIHucBNKue+HsHjzIEDLIPPbn3sPn99/0fdwcGw==" + }, + "Microsoft.TestPlatform.ObjectModel": { + "type": "Transitive", + "resolved": "18.10.1", + "contentHash": "o+PuLDRVp1iwiVAPBADZItXgm9Ck23XtPhE4kZtZVi0uYnMiiz1Dx9Cjh75kJ+ijfqnORL3VOTOaQVKi0f/ixg==" + } + } + } +} \ No newline at end of file diff --git a/profiles/historical-alpha/candidate/VSTest/packages.lock.json b/profiles/historical-alpha/candidate/VSTest/packages.lock.json new file mode 100644 index 0000000..49079dd --- /dev/null +++ b/profiles/historical-alpha/candidate/VSTest/packages.lock.json @@ -0,0 +1,317 @@ +{ + "version": 1, + "dependencies": { + "net10.0": { + "Microsoft.NET.Test.Sdk": { + "type": "Direct", + "requested": "[18.11.0, )", + "resolved": "18.11.0", + "contentHash": "xf/bR0LNkhK0SnadDRlZIQmC4sac5Wk0e1WAdiQjRN3MSo6gQ9M2c4c1XRNnVGjfOvckh704W5CJ19AL0/Xsdg==", + "dependencies": { + "Microsoft.CodeCoverage": "18.11.0", + "Microsoft.TestPlatform.TestHost": "18.11.0" + } + }, + "NUnit": { + "type": "Direct", + "requested": "[5.1.0-alpha.0.50, )", + "resolved": "5.1.0-alpha.0.50", + "contentHash": "D1quOSRFXxFM1zQ9esp0/J+z3TSWg51CCL7InL0VoiaojcrqmqopMYq43fkXQbz6qMqmJnJatytsPNIlJzPFVA==" + }, + "NUnit3TestAdapter": { + "type": "Direct", + "requested": "[6.4.0-alpha.0.46, )", + "resolved": "6.4.0-alpha.0.46", + "contentHash": "ijzs+CHgmmACU4B9IfLcaikS9ZcuKbFGjus2Q0OGIRq0GcaC+Mh5CSsZ5PoCJnVh69ENlcCK5Ei86lsFPwlX/g==", + "dependencies": { + "Microsoft.Extensions.DependencyModel": "8.0.2", + "Microsoft.TestPlatform.AdapterUtilities": "18.11.0", + "Microsoft.Testing.Extensions.VSTestBridge": "2.5.2", + "Microsoft.Testing.Platform.MSBuild": "2.5.2" + } + }, + "Microsoft.ApplicationInsights": { + "type": "Transitive", + "resolved": "2.23.0", + "contentHash": "nWArUZTdU7iqZLycLKWe0TDms48KKGE6pONH2terYNa8REXiqixrMOkf1sk5DHGMaUTqONU2YkS4SAXBhLStgw==" + }, + "Microsoft.CodeCoverage": { + "type": "Transitive", + "resolved": "18.11.0", + "contentHash": "MhN9wpvL1Es4hfIYslrsVgIsUdDFxuOBTbAl9mGIMvFo8PP5CLf4DrGdNrfwWSyn0lqi6sssm+I/qkkLL3MU+g==" + }, + "Microsoft.Extensions.DependencyModel": { + "type": "Transitive", + "resolved": "8.0.2", + "contentHash": "mUBDZZRgZrSyFOsJ2qJJ9fXfqd/kXJwf3AiDoqLD9m6TjY5OO/vLNOb9fb4juC0487eq4hcGN/M2Rh/CKS7QYw==" + }, + "Microsoft.Testing.Extensions.Telemetry": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "j1XGKCBrmfNm0tmotMa05GlqVtb2cW5UaMkKCFHPyyFHz5rdOy7TD0SVXnZJ+QMrjPAHjRoRqn5qcsUjICSWwg==", + "dependencies": { + "Microsoft.ApplicationInsights": "2.23.0", + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.Testing.Extensions.TrxReport.Abstractions": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "+xTIaIU9H44GxOyjrfieMSZnxltGvleA3jCRtdEAzlXKb85pMmVYMLUv2JS8KwD+U2wQHUgvy5YfQfWoPEfVdQ==", + "dependencies": { + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.Testing.Extensions.VSTestBridge": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "YRaP50aBAYMvw9g3NmQNmBYMPO5OiBT67vJgg5YQWdbuUA0m9ETmNikfEGKoiZX8A2rDuo8Bm4CWj0FKiw16og==", + "dependencies": { + "Microsoft.TestPlatform.ObjectModel": "18.10.1", + "Microsoft.Testing.Extensions.Telemetry": "2.5.2", + "Microsoft.Testing.Extensions.TrxReport.Abstractions": "2.5.2", + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.Testing.Platform": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "ocX0rgGY78dKfmZlZe4hB0/dvlh7wJgUAWS+KfwrqxB9DpNsjshnne9dppCKnFNEOkX4QYsrdUU++NInFPiCBw==" + }, + "Microsoft.Testing.Platform.MSBuild": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "Jey2v0hd7WHHa7pr6MRNKtA07FvxcOMTCtIhTI7uBZ/qR5m1mgCVCo5L1rtVAtqgMhGA205bUwq9+is4LiCzpw==", + "dependencies": { + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.TestPlatform.AdapterUtilities": { + "type": "Transitive", + "resolved": "18.11.0", + "contentHash": "fJG8ZYZtlUWR0AUG7FMZvYEGnumibFJDW9pmrbo9SQQnlRyXIHucBNKue+HsHjzIEDLIPPbn3sPn99/0fdwcGw==" + }, + "Microsoft.TestPlatform.ObjectModel": { + "type": "Transitive", + "resolved": "18.11.0", + "contentHash": "BXBHYnwSOljKute8UYCMXOLAdB7awxEMppPSpqOF1ZxLD/W/OH+vTBgFaXA7q0aditJTVXSMVenel+wOkEIyNg==" + }, + "Microsoft.TestPlatform.TestHost": { + "type": "Transitive", + "resolved": "18.11.0", + "contentHash": "AKjwKpyRBwoQFQmpcchtoYlfJEBlaY/40uxBRi+qXP4NR7xT8t+XTJtOyEyumfvfJcH5pASs75LwNdXYRr4XNA==", + "dependencies": { + "Microsoft.TestPlatform.ObjectModel": "18.11.0" + } + } + }, + "net11.0": { + "Microsoft.NET.Test.Sdk": { + "type": "Direct", + "requested": "[18.11.0, )", + "resolved": "18.11.0", + "contentHash": "xf/bR0LNkhK0SnadDRlZIQmC4sac5Wk0e1WAdiQjRN3MSo6gQ9M2c4c1XRNnVGjfOvckh704W5CJ19AL0/Xsdg==", + "dependencies": { + "Microsoft.CodeCoverage": "18.11.0", + "Microsoft.TestPlatform.TestHost": "18.11.0" + } + }, + "NUnit": { + "type": "Direct", + "requested": "[5.1.0-alpha.0.50, )", + "resolved": "5.1.0-alpha.0.50", + "contentHash": "D1quOSRFXxFM1zQ9esp0/J+z3TSWg51CCL7InL0VoiaojcrqmqopMYq43fkXQbz6qMqmJnJatytsPNIlJzPFVA==" + }, + "NUnit3TestAdapter": { + "type": "Direct", + "requested": "[6.4.0-alpha.0.46, )", + "resolved": "6.4.0-alpha.0.46", + "contentHash": "ijzs+CHgmmACU4B9IfLcaikS9ZcuKbFGjus2Q0OGIRq0GcaC+Mh5CSsZ5PoCJnVh69ENlcCK5Ei86lsFPwlX/g==", + "dependencies": { + "Microsoft.Extensions.DependencyModel": "8.0.2", + "Microsoft.TestPlatform.AdapterUtilities": "18.11.0", + "Microsoft.Testing.Extensions.VSTestBridge": "2.5.2", + "Microsoft.Testing.Platform.MSBuild": "2.5.2" + } + }, + "Microsoft.ApplicationInsights": { + "type": "Transitive", + "resolved": "2.23.0", + "contentHash": "nWArUZTdU7iqZLycLKWe0TDms48KKGE6pONH2terYNa8REXiqixrMOkf1sk5DHGMaUTqONU2YkS4SAXBhLStgw==" + }, + "Microsoft.CodeCoverage": { + "type": "Transitive", + "resolved": "18.11.0", + "contentHash": "MhN9wpvL1Es4hfIYslrsVgIsUdDFxuOBTbAl9mGIMvFo8PP5CLf4DrGdNrfwWSyn0lqi6sssm+I/qkkLL3MU+g==" + }, + "Microsoft.Extensions.DependencyModel": { + "type": "Transitive", + "resolved": "8.0.2", + "contentHash": "mUBDZZRgZrSyFOsJ2qJJ9fXfqd/kXJwf3AiDoqLD9m6TjY5OO/vLNOb9fb4juC0487eq4hcGN/M2Rh/CKS7QYw==" + }, + "Microsoft.Testing.Extensions.Telemetry": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "j1XGKCBrmfNm0tmotMa05GlqVtb2cW5UaMkKCFHPyyFHz5rdOy7TD0SVXnZJ+QMrjPAHjRoRqn5qcsUjICSWwg==", + "dependencies": { + "Microsoft.ApplicationInsights": "2.23.0", + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.Testing.Extensions.TrxReport.Abstractions": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "+xTIaIU9H44GxOyjrfieMSZnxltGvleA3jCRtdEAzlXKb85pMmVYMLUv2JS8KwD+U2wQHUgvy5YfQfWoPEfVdQ==", + "dependencies": { + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.Testing.Extensions.VSTestBridge": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "YRaP50aBAYMvw9g3NmQNmBYMPO5OiBT67vJgg5YQWdbuUA0m9ETmNikfEGKoiZX8A2rDuo8Bm4CWj0FKiw16og==", + "dependencies": { + "Microsoft.TestPlatform.ObjectModel": "18.10.1", + "Microsoft.Testing.Extensions.Telemetry": "2.5.2", + "Microsoft.Testing.Extensions.TrxReport.Abstractions": "2.5.2", + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.Testing.Platform": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "ocX0rgGY78dKfmZlZe4hB0/dvlh7wJgUAWS+KfwrqxB9DpNsjshnne9dppCKnFNEOkX4QYsrdUU++NInFPiCBw==" + }, + "Microsoft.Testing.Platform.MSBuild": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "Jey2v0hd7WHHa7pr6MRNKtA07FvxcOMTCtIhTI7uBZ/qR5m1mgCVCo5L1rtVAtqgMhGA205bUwq9+is4LiCzpw==", + "dependencies": { + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.TestPlatform.AdapterUtilities": { + "type": "Transitive", + "resolved": "18.11.0", + "contentHash": "fJG8ZYZtlUWR0AUG7FMZvYEGnumibFJDW9pmrbo9SQQnlRyXIHucBNKue+HsHjzIEDLIPPbn3sPn99/0fdwcGw==" + }, + "Microsoft.TestPlatform.ObjectModel": { + "type": "Transitive", + "resolved": "18.11.0", + "contentHash": "BXBHYnwSOljKute8UYCMXOLAdB7awxEMppPSpqOF1ZxLD/W/OH+vTBgFaXA7q0aditJTVXSMVenel+wOkEIyNg==" + }, + "Microsoft.TestPlatform.TestHost": { + "type": "Transitive", + "resolved": "18.11.0", + "contentHash": "AKjwKpyRBwoQFQmpcchtoYlfJEBlaY/40uxBRi+qXP4NR7xT8t+XTJtOyEyumfvfJcH5pASs75LwNdXYRr4XNA==", + "dependencies": { + "Microsoft.TestPlatform.ObjectModel": "18.11.0" + } + } + }, + "net8.0": { + "Microsoft.NET.Test.Sdk": { + "type": "Direct", + "requested": "[18.11.0, )", + "resolved": "18.11.0", + "contentHash": "xf/bR0LNkhK0SnadDRlZIQmC4sac5Wk0e1WAdiQjRN3MSo6gQ9M2c4c1XRNnVGjfOvckh704W5CJ19AL0/Xsdg==", + "dependencies": { + "Microsoft.CodeCoverage": "18.11.0", + "Microsoft.TestPlatform.TestHost": "18.11.0" + } + }, + "NUnit": { + "type": "Direct", + "requested": "[5.1.0-alpha.0.50, )", + "resolved": "5.1.0-alpha.0.50", + "contentHash": "D1quOSRFXxFM1zQ9esp0/J+z3TSWg51CCL7InL0VoiaojcrqmqopMYq43fkXQbz6qMqmJnJatytsPNIlJzPFVA==" + }, + "NUnit3TestAdapter": { + "type": "Direct", + "requested": "[6.4.0-alpha.0.46, )", + "resolved": "6.4.0-alpha.0.46", + "contentHash": "ijzs+CHgmmACU4B9IfLcaikS9ZcuKbFGjus2Q0OGIRq0GcaC+Mh5CSsZ5PoCJnVh69ENlcCK5Ei86lsFPwlX/g==", + "dependencies": { + "Microsoft.Extensions.DependencyModel": "8.0.2", + "Microsoft.TestPlatform.AdapterUtilities": "18.11.0", + "Microsoft.Testing.Extensions.VSTestBridge": "2.5.2", + "Microsoft.Testing.Platform.MSBuild": "2.5.2" + } + }, + "Microsoft.ApplicationInsights": { + "type": "Transitive", + "resolved": "2.23.0", + "contentHash": "nWArUZTdU7iqZLycLKWe0TDms48KKGE6pONH2terYNa8REXiqixrMOkf1sk5DHGMaUTqONU2YkS4SAXBhLStgw==" + }, + "Microsoft.CodeCoverage": { + "type": "Transitive", + "resolved": "18.11.0", + "contentHash": "MhN9wpvL1Es4hfIYslrsVgIsUdDFxuOBTbAl9mGIMvFo8PP5CLf4DrGdNrfwWSyn0lqi6sssm+I/qkkLL3MU+g==" + }, + "Microsoft.Extensions.DependencyModel": { + "type": "Transitive", + "resolved": "8.0.2", + "contentHash": "mUBDZZRgZrSyFOsJ2qJJ9fXfqd/kXJwf3AiDoqLD9m6TjY5OO/vLNOb9fb4juC0487eq4hcGN/M2Rh/CKS7QYw==" + }, + "Microsoft.Testing.Extensions.Telemetry": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "j1XGKCBrmfNm0tmotMa05GlqVtb2cW5UaMkKCFHPyyFHz5rdOy7TD0SVXnZJ+QMrjPAHjRoRqn5qcsUjICSWwg==", + "dependencies": { + "Microsoft.ApplicationInsights": "2.23.0", + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.Testing.Extensions.TrxReport.Abstractions": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "+xTIaIU9H44GxOyjrfieMSZnxltGvleA3jCRtdEAzlXKb85pMmVYMLUv2JS8KwD+U2wQHUgvy5YfQfWoPEfVdQ==", + "dependencies": { + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.Testing.Extensions.VSTestBridge": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "YRaP50aBAYMvw9g3NmQNmBYMPO5OiBT67vJgg5YQWdbuUA0m9ETmNikfEGKoiZX8A2rDuo8Bm4CWj0FKiw16og==", + "dependencies": { + "Microsoft.TestPlatform.ObjectModel": "18.10.1", + "Microsoft.Testing.Extensions.Telemetry": "2.5.2", + "Microsoft.Testing.Extensions.TrxReport.Abstractions": "2.5.2", + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.Testing.Platform": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "ocX0rgGY78dKfmZlZe4hB0/dvlh7wJgUAWS+KfwrqxB9DpNsjshnne9dppCKnFNEOkX4QYsrdUU++NInFPiCBw==" + }, + "Microsoft.Testing.Platform.MSBuild": { + "type": "Transitive", + "resolved": "2.5.2", + "contentHash": "Jey2v0hd7WHHa7pr6MRNKtA07FvxcOMTCtIhTI7uBZ/qR5m1mgCVCo5L1rtVAtqgMhGA205bUwq9+is4LiCzpw==", + "dependencies": { + "Microsoft.Testing.Platform": "[2.5.2, 3.0.0)" + } + }, + "Microsoft.TestPlatform.AdapterUtilities": { + "type": "Transitive", + "resolved": "18.11.0", + "contentHash": "fJG8ZYZtlUWR0AUG7FMZvYEGnumibFJDW9pmrbo9SQQnlRyXIHucBNKue+HsHjzIEDLIPPbn3sPn99/0fdwcGw==" + }, + "Microsoft.TestPlatform.ObjectModel": { + "type": "Transitive", + "resolved": "18.11.0", + "contentHash": "BXBHYnwSOljKute8UYCMXOLAdB7awxEMppPSpqOF1ZxLD/W/OH+vTBgFaXA7q0aditJTVXSMVenel+wOkEIyNg==" + }, + "Microsoft.TestPlatform.TestHost": { + "type": "Transitive", + "resolved": "18.11.0", + "contentHash": "AKjwKpyRBwoQFQmpcchtoYlfJEBlaY/40uxBRi+qXP4NR7xT8t+XTJtOyEyumfvfJcH5pASs75LwNdXYRr4XNA==", + "dependencies": { + "Microsoft.TestPlatform.ObjectModel": "18.11.0" + } + } + } + } +} \ No newline at end of file diff --git a/run.py b/run.py new file mode 100644 index 0000000..de2d831 --- /dev/null +++ b/run.py @@ -0,0 +1,219 @@ +"""Build and run one explicitly pinned local compatibility profile.""" +import argparse +import hashlib +import json +import os +from pathlib import Path +import platform +import shutil +import subprocess +import sys +import tempfile +import urllib.request +import uuid +import xml.etree.ElementTree as ET + +from compatibility import PROJECTS, assess, profile, require, save, summary + + +ROOT = Path(__file__).resolve().parent + + +def invoke(command, log, work, environment, timeout=1000): + """Retain command failure and fail the orchestration instead of interpreting it as a test result.""" + with log.open('x', encoding='utf-8') as output: + result = subprocess.run(command, cwd=work, env=environment, stdout=output, + stderr=subprocess.STDOUT, timeout=timeout) + save(log.with_suffix('.exit.json'), {'exitCode': result.returncode, 'command': command}) + require(result.returncode == 0, 'Command failed; inspect ' + str(log)) + + +def stage(work, selected, selected_path, prepare_locks): + """Snapshot only maintained source and the chosen lock set, never historical results or caches.""" + sources = list(ROOT.glob('*.py')) + list(ROOT.glob('*.props')) + [ROOT / name for name in [ + '.editorconfig', 'global.json', 'NuGet.Config', 'identities.json', 'EscapedNames.json']] + sources += list((ROOT / 'Shared').glob('*.cs')) + list((ROOT / 'Harness').glob('*.cs')) + sources += [ROOT / project for project in PROJECTS] + identities = [] + for source in sources: + destination = work / source.relative_to(ROOT) + destination.parent.mkdir(parents=True, exist_ok=True) + data = source.read_bytes() + destination.write_bytes(data) + identities.append({'file': source.relative_to(ROOT).as_posix(), 'sha256': hashlib.sha256(data).hexdigest()}) + # Version selection is serialized as XML, never inserted into shell source. + props = ET.Element('Project') + group = ET.SubElement(props, 'PropertyGroup') + for name, value in [('LangVersion', '14'), ('Nullable', 'enable'), ('ImplicitUsings', 'disable'), + ('IsPackable', 'false'), ('TreatWarningsAsErrors', 'true'), ('GenerateDocumentationFile', 'true'), + ('RestorePackagesWithLockFile', 'true'), ('BaselineFrameworkVersion', selected['baselineFramework']), + ('CandidateFrameworkVersion', selected['candidateFramework']), ('AdapterVersion', selected['adapter'])]: + ET.SubElement(group, name).text = value + (work / 'Directory.Build.props').write_bytes(ET.tostring(props, encoding='utf-8')) + for project in PROJECTS[1:]: + path = work / project + document = ET.parse(path) + document.find('.//TargetFrameworks').text = ';'.join(selected['targets']) + document.write(path, encoding='utf-8', xml_declaration=True) + save(work / 'global.json', {'sdk': {'version': selected['sdk'], 'rollForward': 'disable'}, 'test': {'runner': 'VSTest'}}) + if not prepare_locks: + locks = selected_path.parent / selected['locks'] + for project in PROJECTS: + relative = Path(project).parent / 'packages.lock.json' + source = locks / relative + require(source.is_file(), 'Reviewed dependency lock missing: ' + str(relative)) + shutil.copyfile(source, work / relative) + save(work / 'InputSources.json', identities) + save(work / 'SelectedProfile.json', selected) + + +def download(work, selected): + """Fetch exactly the approved public inputs and reject any changed bytes.""" + directory = work / 'reviewed-packages' + directory.mkdir() + rows = [] + for item in selected['packages']: + target = directory / (item['id'] + '.' + item['version'] + '.nupkg') + with urllib.request.urlopen(item['url'], timeout=90) as response, target.open('xb') as output: + require(response.geturl().startswith('https://'), 'Package download left HTTPS.') + shutil.copyfileobj(response, output) + digest = hashlib.sha256(target.read_bytes()).hexdigest() + require(digest == item['sha256'], 'Package hash mismatch: ' + target.name) + rows.append(dict(item, bytes=target.stat().st_size)) + save(work / 'PackageDownloads.json', rows) + + +def audit(work): + """Independently reject remaining native process references to this owned run.""" + if os.name == 'nt': + command = [str(Path(os.environ['SystemRoot']) / 'System32/WindowsPowerShell/v1.0/powershell.exe'), + '-NoProfile', '-NonInteractive', '-Command', + '$ErrorActionPreference="Stop"; $p=@(Get-CimInstance Win32_Process | Where-Object { ' + '$_.ProcessId -ne [int]$env:NUNIT_AUDIT_PID -and $_.CommandLine -and ' + '$_.CommandLine.Replace("/","\\").IndexOf($env:NUNIT_AUDIT_ROOT+"\\",[StringComparison]::OrdinalIgnoreCase) -ge 0 ' + '} | Select-Object ProcessId,Name); ConvertTo-Json -InputObject $p -Compress'] + environment = dict(os.environ, NUNIT_AUDIT_ROOT=str(work), NUNIT_AUDIT_PID=str(os.getpid())) + matches = json.loads(subprocess.check_output(command, env=environment, text=True, timeout=30)) + else: + output = subprocess.check_output(['/bin/ps', '-axo', 'pid=,comm=,args='], text=True, timeout=30) + matches = [line for line in output.splitlines() if str(work) + '/' in line and int(line.split(None, 1)[0]) != os.getpid()] + save(work / 'NativeProcessAudit.json', {'references': matches, 'passed': not matches}) + require(not matches, 'Native processes still reference this run; retain its work directory for inspection.') + + +def collect(work, output): + """Copy allowlisted text evidence for CI artifacts, excluding package caches and compiled outputs.""" + blocked = {'.packages', '.http-cache', '.cli-home', 'bin', 'obj', '__pycache__', 'reviewed-packages'} + for path in work.rglob('*'): + relative = path.relative_to(work) + if path.is_file() and not blocked.intersection(relative.parts) and path.suffix in { + '.txt', '.log', '.json', '.xml', '.trx', '.runsettings'}: + destination = output / 'evidence' / relative + destination.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(path, destination) + + +def execute(args, selected, selected_path): + """Run a fresh profile, retaining infrastructure, assertion and stop outcomes separately.""" + output = args.output.resolve() + output.mkdir(parents=True, exist_ok=False) + work = Path(tempfile.gettempdir()) / 'nunit-adapter-compatibility' / uuid.uuid4().hex + work.mkdir(parents=True, exist_ok=False) + save(output / 'run-location.json', {'workDirectory': str(work)}) + print('Work: ' + str(work), flush=True) + dotnet = str(Path(shutil.which(args.dotnet) or args.dotnet).resolve()) + environment = dict(os.environ, DOTNET_CLI_TELEMETRY_OPTOUT='1', DOTNET_NOLOGO='1', + TESTINGPLATFORM_TELEMETRY_OPTOUT='1', MSBUILDDISABLENODEREUSE='1', + DOTNET_ROOT=str(Path(dotnet).parent), DOTNET_CLI_HOME=str(work / '.cli-home'), + NUGET_PACKAGES=str(work / '.packages'), NUGET_HTTP_CACHE_PATH=str(work / '.http-cache'), + NUNIT_COMPAT_TARGETS=json.dumps(selected['targets']), NUNIT_COMPAT_SDK=selected['sdk']) + environment['PATH'] = str(Path(dotnet).parent) + os.pathsep + environment.get('PATH', '') + environment.pop('DOTNET_TEST_RUNNER', None) + exit_code, result = 2, None + try: + stage(work, selected, selected_path, args.command == 'prepare-locks') + sdk = subprocess.check_output([dotnet, '--version'], cwd=work, env=environment, text=True).strip() + require(sdk == selected['sdk'], 'Selected SDK not available: ' + selected['sdk']) + runtimes = subprocess.check_output([dotnet, '--list-runtimes'], env=environment, text=True) + if args.command == 'run': + require(all('Microsoft.NETCore.App ' + target[3:].split('.')[0] + '.' in runtimes for target in selected['targets']), + 'Matching-architecture target runtimes must be installed before execution.') + (work / 'runtime-inventory.txt').write_text(runtimes, encoding='utf-8') + invoke([dotnet, '--info'], work / 'sdk-info.txt', work, environment) + download(work, selected) + before = {project: hashlib.sha256((work / Path(project).parent / 'packages.lock.json').read_bytes()).hexdigest() + for project in PROJECTS} if args.command != 'prepare-locks' else {} + for index, project in enumerate(PROJECTS): + command = [dotnet, 'restore', project, '--no-http-cache', '--configfile', str(work / 'NuGet.Config')] + if args.command != 'prepare-locks': + command.append('--locked-mode') + invoke(command, work / ('restore-' + str(index) + '.txt'), work, environment, timeout=300) + if args.command == 'prepare-locks': + for project in PROJECTS: + relative = Path(project).parent / 'packages.lock.json' + destination = output / 'proposed-locks' / relative + destination.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(work / relative, destination) + save(output / 'lock-proposal.json', {'profile': selected, 'reviewRequired': True, 'testsExecuted': False}) + exit_code = 0 + else: + require(all(hashlib.sha256((work / Path(project).parent / 'packages.lock.json').read_bytes()).hexdigest() == digest + for project, digest in before.items()), 'Locked restore changed its inputs.') + for index, project in enumerate(['Harness/Harness.csproj', 'baseline/MTP/MTP.csproj']): + invoke([dotnet, 'format', 'style', project, '--no-restore', '--verify-no-changes', '--severity', 'warn'], + work / ('style-' + str(index) + '.txt'), work, environment, timeout=180) + invoke([sys.executable, str(work / 'compare_hosts.py'), dotnet], work / 'comparison.stdout.txt', work, environment) + invoke([sys.executable, str(work / 'verify_controls.py'), dotnet, '--include-candidate-timer'], + work / 'controls.stdout.txt', work, environment) + result = assess(work, selected) + result.update(platform=platform.platform(), architecture=platform.machine(), sdk=sdk, + strictStopRequired=args.require_cooperative_stop) + exit_code = 0 if result['contracts']['passed'] and (result['runnerStop']['passed'] or not args.require_cooperative_stop) else 1 + except Exception as exception: + save(output / 'infrastructure-failure.json', {'type': type(exception).__name__, 'error': str(exception), 'exitCode': 2}) + print(str(exception), file=sys.stderr) + finally: + try: + audit(work) + except Exception as exception: + save(output / 'audit-failure.json', {'error': str(exception)}) + exit_code = 2 + collect(work, output) + if result is not None: + result['exitCode'] = exit_code + save(output / 'results.json', result) + (output / 'summary.md').write_text(summary(result), encoding='utf-8') + print(summary(result), flush=True) + return exit_code + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('command', choices=['run', 'profile', 'prepare-locks']) + parser.add_argument('--profile', type=Path, default=ROOT / 'profiles/historical-alpha.json') + parser.add_argument('--output', type=Path, default=ROOT / 'artifacts/run') + parser.add_argument('--dotnet', default='dotnet') + parser.add_argument('--github-output', type=Path) + parser.add_argument('--require-cooperative-stop', action='store_true', help='Fail for any incomplete runner-stop observation.') + args = parser.parse_args() + path = args.profile.resolve() + selected = profile(path) + if args.command == 'profile': + print(json.dumps(selected, indent=2)) + if args.github_output: + with args.github_output.open('a', encoding='utf-8') as output: + output.write('sdk=' + selected['sdk'] + '\nname=' + selected['name'] + '\n') + sdk_major = selected['sdk'].split('.')[0] + installs = [target[3:] + '.x' for target in selected['targets'] if target[3:].split('.')[0] != sdk_major] + output.write('dotnet-versions<') + + def result(self): + save(self.work / 'evidence/filters.json', self.filters) + save(self.work / 'evidence/stops.json', self.stops) + save(self.work / 'control-evidence/escaped-results.json', self.escaped) + result = assess(self.work, self.selected) + result['exitCode'] = 0 if result['contracts']['passed'] else 1 + return result + + def test_known_stop_gap_is_visible_and_strict_policy_fails(self): + result = self.result() + self.assertTrue(result['contracts']['passed']) + self.assertFalse(result['runnerStop']['passed']) + self.assertEqual(4, len(result['runnerStop']['incomplete'])) + self.assertEqual(0, policy(result, False)) + self.assertEqual(1, policy(result, True)) + + def test_complete_stop_evidence_passes_both_policies(self): + for row in self.stops: + row['observations'] = dict.fromkeys(PHASES, 1) + result = self.result() + self.assertTrue(result['runnerStop']['passed']) + self.assertEqual(0, policy(result, True)) + + def test_ordinary_selection_failure_fails_compatibility(self): + self.filters[0]['selectedExactlyOnePassingTest'] = False + result = self.result() + self.assertFalse(result['contracts']['passed']) + self.assertEqual(1, policy(result, False)) + + def test_escaped_filter_failure_fails_compatibility(self): + self.escaped[0]['process']['exit'] = 1 + self.assertFalse(self.result()['contracts']['passed']) + + def test_wrong_raw_filter_error_is_not_an_expected_rejection(self): + folder = self.work / 'evidence/baseline-net10.0-VSTest-filter-2' + (folder / 'stderr.txt').write_text('Failed to load adapter.') + self.assertFalse(self.result()['contracts']['passed']) + + def test_duplicate_filter_row_cannot_hide_an_omission(self): + self.filters[-1] = copy.deepcopy(self.filters[0]) + with self.assertRaisesRegex(ValueError, 'matrix'): + self.result() + + def test_missing_stop_row_is_infrastructure_failure(self): + self.stops.pop() + with self.assertRaisesRegex(ValueError, 'matrix'): + self.result() + + def test_stop_that_never_started_is_not_a_known_gap(self): + self.stops[0]['observations']['started'] = 0 + with self.assertRaisesRegex(ValueError, 'observed start'): + self.result() + + def test_duplicate_cleanup_is_rejected(self): + self.stops[0]['observations']['finally'] = 2 + with self.assertRaisesRegex(ValueError, 'observed start'): + self.result() + + def test_missing_timer_cleanup_is_rejected(self): + (self.work / 'control-evidence/candidate-net10.0-timer/observations/teardown-case.xml').unlink() + with self.assertRaisesRegex(ValueError, 'timer-control'): + self.result() + + def test_runtime_rollforward_is_rejected(self): + path = self.work / 'control-evidence/baseline-net10.0-timer/observations/started-case.xml' + path.write_text('') + with self.assertRaisesRegex(ValueError, 'rolled forward'): + self.result() + + def test_contradictory_pass_report_is_rejected(self): + result = self.result() + result['contracts']['failures'].append('hidden failure') + with self.assertRaisesRegex(ValueError, 'contradicts'): + policy(result, False) + + def test_prior_infrastructure_error_cannot_become_a_pass(self): + result = self.result() + result['exitCode'] = 2 + self.assertEqual(2, policy(result, False)) + + def test_missing_ci_report_fails_and_writes_summary(self): + summary = self.work / 'summary.md' + result = subprocess.run([sys.executable, str(ROOT / 'ci_summary.py'), '--results', str(self.work / 'missing.json'), + '--summary', str(summary)], capture_output=True, text=True) + self.assertEqual(2, result.returncode) + self.assertIn('infrastructure failure', summary.read_text()) + + def test_profile_rejects_floating_version_and_credential_url(self): + for field, value in [('adapter', 'latest'), ('sdk', '11.0.x')]: + data = copy.deepcopy(self.selected) + data[field] = value + path = self.work / 'profile.json' + save(path, data) + with self.assertRaises(ValueError): + profile(path) + data = copy.deepcopy(self.selected) + data['packages'][0]['url'] = 'https://name:password@www.myget.org/package.nupkg' + save(self.work / 'profile.json', data) + with self.assertRaisesRegex(ValueError, 'unauthenticated'): + profile(self.work / 'profile.json') + + def test_workflow_installs_the_selected_target_runtime_channels(self): + data = copy.deepcopy(self.selected) + data['targets'] = ['net9.0', 'net11.0'] + path = self.work / 'profile.json' + output = self.work / 'github-output.txt' + save(path, data) + result = subprocess.run([sys.executable, str(ROOT / 'run.py'), 'profile', '--profile', str(path), + '--github-output', str(output)], capture_output=True, text=True) + self.assertEqual(0, result.returncode, result.stderr) + self.assertIn('dotnet-versions<