Organize workspace: Frontend, Backend, and Tests in one repo

.nuget/packages/coverlet.collector/6.0.2/.nupkg.metadata

@@ -0,0 +1,5 @@
+{
+  "version": 2,
+  "contentHash": "bJShQ6uWRTQ100ZeyiMqcFlhP7WJ+bCuabUs885dJiBEzMsJMSFr7BOyeCw4rgvQokteGi5rKQTlkhfQPUXg2A==",
+  "source": "https://api.nuget.org/v3/index.json"
+}

.nuget/packages/coverlet.collector/6.0.2/VSTestIntegration.md

@@ -0,0 +1,175 @@
+# Coverlet integration with VSTest (a.k.a. Visual Studio Test Platform)
+
+**Supported runtime versions**:
+
+Since version `6.0.0`
+
+* .NET Core >= 6.0
+* .NET Framework >= 4.6.2
+
+As explained in quick start section, to use collectors you need to run *SDK v6.0.100* (LTS) or newer and your project file must reference `coverlet.collector` and a minimum version of `Microsoft.NET.Test.Sdk`.
+
+A sample project file looks like:
+
+```xml
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFrameworks>net6.0;net48</TargetFrameworks>
+  </PropertyGroup>
+  <ItemGroup>
+    <!-- Minimum version 17.7.0 -->
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
+    <!-- Update this reference when new version is released -->
+    <PackageReference Include="coverlet.collector" Version="6.0.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  ...
+  </ItemGroup>
+...
+</Project>
+```
+
+The reference to `coverlet.collector` package is included by default with xunit template test (`dotnet new xunit`), you only need to update the package for new versions like any other package reference.
+
+With correct reference in place you can run coverage through default dotnet test CLI verbs:
+
+```shell
+dotnet test --collect:"XPlat Code Coverage"
+```
+
+or
+
+```text
+dotnet publish
+...
+  ... -> C:\project\bin\Debug\netcoreapp3.0\testdll.dll
+  ... -> C:\project\bin\Debug\netcoreapp3.0\publish\
+...
+dotnet vstest C:\project\bin\Debug\netcoreapp3.0\publish\testdll.dll --collect:"XPlat Code Coverage"
+```
+
+As you can see in case of `vstest` verb you **must** publish project before.
+
+At the end of tests you'll find the coverage file data under default VSTest platform directory `TestResults`
+
+```text
+Attachments:
+  C:\git\coverlet\Documentation\Examples\VSTest\HelloWorld\XUnitTestProject1\TestResults\bc5e983b-d7a8-4f17-8c0a-8a8831a4a891\coverage.cobertura.xml
+Test Run Successful.
+Total tests: 1
+     Passed: 1
+ Total time: 2,5451 Seconds
+```
+
+You can change the output directory using the standard `dotnet test` switch `--results-directory`
+
+>*NB: By design VSTest platform will create your file under a random named folder(guid string) so if you need stable path to load file to some gui report system(i.e. coveralls, codecov, reportgenerator etc..) that doesn't support glob patterns or hierarchical  search, you'll need to manually move resulting file to a predictable folder*
+
+## Coverlet options supported by VSTest integration
+
+:warning:At the moment VSTest integration **doesn't support all features** of msbuild and .NET tool, for instance show result on console, report merging and threshold validation.
+We're working to fill the gaps.
+>*PS: if you don't have any other way to merge reports(for instance your report generator doesn't support multi coverage file) you can for the moment exploit a trick reported by one of our contributor Daniel Paz(@p4p3) <https://github.com/tonerdo/coverlet/pull/225#issuecomment-573896446>*
+
+### Default option (if you don't specify a runsettings file)
+
+Without specifying a runsettings file and calling coverlet by just the name of the collector, the result of the generated coverage output is by default in cobertura format.
+
+```shell
+dotnet test --collect:"XPlat Code Coverage"
+```
+
+The output format of the coverage report can also be changed without a runsettings file by specifying it in a parameter. The supported formats are lcov, opencover, cobertura, teamcity, json (default coverlet proprietary format).
+
+```shell
+dotnet test --collect:"XPlat Code Coverage;Format=json"
+```
+
+It is even possible to specify the coverage output in multiple formats.
+
+```shell
+dotnet test --collect:"XPlat Code Coverage;Format=json,lcov,cobertura"
+```
+
+### Advanced Options (Supported via runsettings)
+
+These are a list of options that are supported by coverlet. These can be specified as datacollector configurations in the runsettings.
+
+| Option                   | Summary                                                                                                                                                         |
+|:-------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| Format                   | Coverage output format. These are either cobertura, json, lcov, opencover or teamcity as well as combinations of these formats.                                 |
+| Exclude                  | Exclude from code coverage analysing using filter expressions.                                                                                                  |
+| ExcludeByAttribute       | Exclude a method, an entire class or assembly from code coverage decorated by an attribute.    |
+| ExcludeByFile            | Ignore specific source files from code coverage.                                                                                                                |
+| Include                  | Explicitly set what to include in code coverage analysis using filter expressions.                                                                              |
+| IncludeDirectory         | Explicitly set which directories to include in code coverage analysis.                                                                                          |
+| SingleHit                | Specifies whether to limit code coverage hit reporting to a single hit for each location.                                                                       |
+| UseSourceLink            | Specifies whether to use SourceLink URIs in place of file system paths.                                                                                         |
+| IncludeTestAssembly      | Include coverage of the test assembly.                                                                                                                          |
+| SkipAutoProps            | Neither track nor record auto-implemented properties.                                                                                                           |
+| DoesNotReturnAttribute   | Methods marked with these attributes are known not to return, statements following them will be excluded from coverage                                          |
+| DeterministicReport      | Generates deterministic report in context of deterministic build. Take a look at [documentation](DeterministicBuild.md) for further informations.
+| ExcludeAssembliesWithoutSources |  Specifies whether to exclude assemblies without source. Options are either MissingAll, MissingAny or None. Default is MissingAll.|
+
+How to specify these options via runsettings?
+
+```xml
+<?xml version="1.0" encoding="utf-8" ?>
+<RunSettings>
+  <DataCollectionRunSettings>
+    <DataCollectors>
+      <DataCollector friendlyName="XPlat code coverage">
+        <Configuration>
+          <Format>json,cobertura,lcov,teamcity,opencover</Format>
+          <Exclude>[coverlet.*.tests?]*,[*]Coverlet.Core*</Exclude> <!-- [Assembly-Filter]Type-Filter -->
+          <Include>[coverlet.*]*,[*]Coverlet.Core*</Include> <!-- [Assembly-Filter]Type-Filter -->
+          <ExcludeByAttribute>Obsolete,GeneratedCodeAttribute,CompilerGeneratedAttribute</ExcludeByAttribute>
+          <ExcludeByFile>**/dir1/class1.cs,**/dir2/*.cs,**/dir3/**/*.cs,</ExcludeByFile> <!-- Globbing filter -->
+          <IncludeDirectory>../dir1/,../dir2/,</IncludeDirectory>
+          <SingleHit>false</SingleHit>
+          <UseSourceLink>true</UseSourceLink>
+          <IncludeTestAssembly>true</IncludeTestAssembly>
+          <SkipAutoProps>true</SkipAutoProps>
+          <DeterministicReport>false</DeterministicReport>
+          <ExcludeAssembliesWithoutSources>MissingAll,MissingAny,None</ExcludeAssembliesWithoutSources>
+        </Configuration>
+      </DataCollector>
+    </DataCollectors>
+  </DataCollectionRunSettings>
+</RunSettings>
+```
+
+Filtering details are present on [msbuild guide](MSBuildIntegration.md#excluding-from-coverage).
+
+This runsettings file can easily be provided using command line option as given :
+
+* `dotnet test --collect:"XPlat Code Coverage" --settings coverlet.runsettings`
+* `dotnet vstest C:\project\bin\Debug\netcoreapp3.0\publish\testdll.dll --collect:"XPlat Code Coverage" --settings coverlet.runsettings`
+
+Take a look at our [`HelloWorld`](Examples/VSTest/HelloWorld/HowTo.md) sample.
+
+### Passing runsettings arguments through commandline
+
+You can avoid passing a `runsettings` file to `dotnet test` driver by using the xml flat syntax in the command line.
+
+For instance if you want to set the `Format` element as a runsettings option you can use this syntax:
+
+```shell
+dotnet test --collect:"XPlat Code Coverage" -- DataCollectionRunSettings.DataCollectors.DataCollector.Configuration.Format=json,cobertura,lcov,teamcity,opencover
+```
+
+Take a look here for further information:<https://github.com/microsoft/vstest/blob/main/docs/RunSettingsArguments.md>
+
+## How it works
+
+Coverlet integration is implemented with the help of [datacollectors](https://github.com/microsoft/vstest/blob/main/docs/extensions/datacollector.md).
+When we specify `--collect:"XPlat Code Coverage"` VSTest platform tries to load coverlet collectors inside `coverlet.collector.dll`
+
+1. Out-of-proc Datacollector: The outproc collector run in a separate process(datacollector.exe/datacollector.dll) than the process in which tests are being executed(testhost*.exe/testhost.dll). This datacollector is responsible for calling into Coverlet APIs for instrumenting dlls, collecting coverage results and sending the coverage output file back to test platform.
+
+1. In-proc Datacollector: The in-proc collector is loaded in the testhost process executing the tests. This collector will be needed to remove the dependency on the process exit handler to flush the hit files and avoid to hit this [serious known issue](KnownIssues.md#1-vstest-stops-process-execution-earlydotnet-test)
+
+## Known Issues
+
+For a comprehensive list of known issues check the detailed documentation [KnownIssues.md](KnownIssues.md)

.nuget/packages/coverlet.collector/6.0.2/build/netstandard2.0/coverlet.collector.deps.json

@@ -0,0 +1,544 @@
+{
+  "runtimeTarget": {
+    "name": ".NETStandard,Version=v2.0/",
+    "signature": ""
+  },
+  "compilationOptions": {},
+  "targets": {
+    ".NETStandard,Version=v2.0": {},
+    ".NETStandard,Version=v2.0/": {
+      "coverlet.collector/6.0.2": {
+        "dependencies": {
+          "Microsoft.SourceLink.GitHub": "8.0.0",
+          "Microsoft.TestPlatform.ObjectModel": "17.8.0",
+          "NETStandard.Library": "2.0.3",
+          "Nerdbank.GitVersioning": "3.6.133",
+          "NuGet.Frameworks": "6.8.0",
+          "coverlet.core": "1.0.0"
+        },
+        "runtime": {
+          "coverlet.collector.dll": {}
+        }
+      },
+      "Microsoft.Bcl.AsyncInterfaces/6.0.0": {
+        "dependencies": {
+          "System.Threading.Tasks.Extensions": "4.5.4"
+        },
+        "runtime": {
+          "lib/netstandard2.0/Microsoft.Bcl.AsyncInterfaces.dll": {
+            "assemblyVersion": "6.0.0.0",
+            "fileVersion": "6.0.21.52210"
+          }
+        }
+      },
+      "Microsoft.Build.Tasks.Git/8.0.0": {},
+      "Microsoft.Extensions.DependencyInjection/6.0.1": {
+        "dependencies": {
+          "Microsoft.Bcl.AsyncInterfaces": "6.0.0",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "6.0.0",
+          "System.Runtime.CompilerServices.Unsafe": "6.0.0",
+          "System.Threading.Tasks.Extensions": "4.5.4"
+        },
+        "runtime": {
+          "lib/netstandard2.0/Microsoft.Extensions.DependencyInjection.dll": {
+            "assemblyVersion": "6.0.0.0",
+            "fileVersion": "6.0.1022.47605"
+          }
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection.Abstractions/6.0.0": {
+        "dependencies": {
+          "Microsoft.Bcl.AsyncInterfaces": "6.0.0",
+          "System.Threading.Tasks.Extensions": "4.5.4"
+        },
+        "runtime": {
+          "lib/netstandard2.0/Microsoft.Extensions.DependencyInjection.Abstractions.dll": {
+            "assemblyVersion": "6.0.0.0",
+            "fileVersion": "6.0.21.52210"
+          }
+        }
+      },
+      "Microsoft.Extensions.DependencyModel/6.0.0": {
+        "dependencies": {
+          "System.Buffers": "4.5.1",
+          "System.Memory": "4.5.4",
+          "System.Runtime.CompilerServices.Unsafe": "6.0.0",
+          "System.Text.Encodings.Web": "6.0.0",
+          "System.Text.Json": "6.0.0"
+        },
+        "runtime": {
+          "lib/netstandard2.0/Microsoft.Extensions.DependencyModel.dll": {
+            "assemblyVersion": "6.0.0.0",
+            "fileVersion": "6.0.21.52210"
+          }
+        }
+      },
+      "Microsoft.Extensions.FileSystemGlobbing/6.0.0": {
+        "runtime": {
+          "lib/netstandard2.0/Microsoft.Extensions.FileSystemGlobbing.dll": {
+            "assemblyVersion": "6.0.0.0",
+            "fileVersion": "6.0.21.52210"
+          }
+        }
+      },
+      "Microsoft.NETCore.Platforms/1.1.0": {},
+      "Microsoft.SourceLink.Common/8.0.0": {},
+      "Microsoft.SourceLink.GitHub/8.0.0": {
+        "dependencies": {
+          "Microsoft.Build.Tasks.Git": "8.0.0",
+          "Microsoft.SourceLink.Common": "8.0.0"
+        }
+      },
+      "Microsoft.TestPlatform.ObjectModel/17.8.0": {
+        "dependencies": {
+          "NuGet.Frameworks": "6.8.0",
+          "System.Reflection.Metadata": "1.6.0"
+        },
+        "runtime": {
+          "lib/netstandard2.0/Microsoft.TestPlatform.CoreUtilities.dll": {
+            "assemblyVersion": "15.0.0.0",
+            "fileVersion": "17.800.23.55801"
+          },
+          "lib/netstandard2.0/Microsoft.TestPlatform.PlatformAbstractions.dll": {
+            "assemblyVersion": "15.0.0.0",
+            "fileVersion": "17.800.23.55801"
+          },
+          "lib/netstandard2.0/Microsoft.VisualStudio.TestPlatform.ObjectModel.dll": {
+            "assemblyVersion": "15.0.0.0",
+            "fileVersion": "17.800.23.55801"
+          }
+        },
+        "resources": {
+          "lib/netstandard2.0/cs/Microsoft.TestPlatform.CoreUtilities.resources.dll": {
+            "locale": "cs"
+          },
+          "lib/netstandard2.0/cs/Microsoft.VisualStudio.TestPlatform.ObjectModel.resources.dll": {
+            "locale": "cs"
+          },
+          "lib/netstandard2.0/de/Microsoft.TestPlatform.CoreUtilities.resources.dll": {
+            "locale": "de"
+          },
+          "lib/netstandard2.0/de/Microsoft.VisualStudio.TestPlatform.ObjectModel.resources.dll": {
+            "locale": "de"
+          },
+          "lib/netstandard2.0/es/Microsoft.TestPlatform.CoreUtilities.resources.dll": {
+            "locale": "es"
+          },
+          "lib/netstandard2.0/es/Microsoft.VisualStudio.TestPlatform.ObjectModel.resources.dll": {
+            "locale": "es"
+          },
+          "lib/netstandard2.0/fr/Microsoft.TestPlatform.CoreUtilities.resources.dll": {
+            "locale": "fr"
+          },
+          "lib/netstandard2.0/fr/Microsoft.VisualStudio.TestPlatform.ObjectModel.resources.dll": {
+            "locale": "fr"
+          },
+          "lib/netstandard2.0/it/Microsoft.TestPlatform.CoreUtilities.resources.dll": {
+            "locale": "it"
+          },
+          "lib/netstandard2.0/it/Microsoft.VisualStudio.TestPlatform.ObjectModel.resources.dll": {
+            "locale": "it"
+          },
+          "lib/netstandard2.0/ja/Microsoft.TestPlatform.CoreUtilities.resources.dll": {
+            "locale": "ja"
+          },
+          "lib/netstandard2.0/ja/Microsoft.VisualStudio.TestPlatform.ObjectModel.resources.dll": {
+            "locale": "ja"
+          },
+          "lib/netstandard2.0/ko/Microsoft.TestPlatform.CoreUtilities.resources.dll": {
+            "locale": "ko"
+          },
+          "lib/netstandard2.0/ko/Microsoft.VisualStudio.TestPlatform.ObjectModel.resources.dll": {
+            "locale": "ko"
+          },
+          "lib/netstandard2.0/pl/Microsoft.TestPlatform.CoreUtilities.resources.dll": {
+            "locale": "pl"
+          },
+          "lib/netstandard2.0/pl/Microsoft.VisualStudio.TestPlatform.ObjectModel.resources.dll": {
+            "locale": "pl"
+          },
+          "lib/netstandard2.0/pt-BR/Microsoft.TestPlatform.CoreUtilities.resources.dll": {
+            "locale": "pt-BR"
+          },
+          "lib/netstandard2.0/pt-BR/Microsoft.VisualStudio.TestPlatform.ObjectModel.resources.dll": {
+            "locale": "pt-BR"
+          },
+          "lib/netstandard2.0/ru/Microsoft.TestPlatform.CoreUtilities.resources.dll": {
+            "locale": "ru"
+          },
+          "lib/netstandard2.0/ru/Microsoft.VisualStudio.TestPlatform.ObjectModel.resources.dll": {
+            "locale": "ru"
+          },
+          "lib/netstandard2.0/tr/Microsoft.TestPlatform.CoreUtilities.resources.dll": {
+            "locale": "tr"
+          },
+          "lib/netstandard2.0/tr/Microsoft.VisualStudio.TestPlatform.ObjectModel.resources.dll": {
+            "locale": "tr"
+          },
+          "lib/netstandard2.0/zh-Hans/Microsoft.TestPlatform.CoreUtilities.resources.dll": {
+            "locale": "zh-Hans"
+          },
+          "lib/netstandard2.0/zh-Hans/Microsoft.VisualStudio.TestPlatform.ObjectModel.resources.dll": {
+            "locale": "zh-Hans"
+          },
+          "lib/netstandard2.0/zh-Hant/Microsoft.TestPlatform.CoreUtilities.resources.dll": {
+            "locale": "zh-Hant"
+          },
+          "lib/netstandard2.0/zh-Hant/Microsoft.VisualStudio.TestPlatform.ObjectModel.resources.dll": {
+            "locale": "zh-Hant"
+          }
+        }
+      },
+      "Mono.Cecil/0.11.5": {
+        "runtime": {
+          "lib/netstandard2.0/Mono.Cecil.Mdb.dll": {
+            "assemblyVersion": "0.11.5.0",
+            "fileVersion": "0.11.5.0"
+          },
+          "lib/netstandard2.0/Mono.Cecil.Pdb.dll": {
+            "assemblyVersion": "0.11.5.0",
+            "fileVersion": "0.11.5.0"
+          },
+          "lib/netstandard2.0/Mono.Cecil.Rocks.dll": {
+            "assemblyVersion": "0.11.5.0",
+            "fileVersion": "0.11.5.0"
+          },
+          "lib/netstandard2.0/Mono.Cecil.dll": {
+            "assemblyVersion": "0.11.5.0",
+            "fileVersion": "0.11.5.0"
+          }
+        }
+      },
+      "Nerdbank.GitVersioning/3.6.133": {},
+      "NETStandard.Library/2.0.3": {
+        "dependencies": {
+          "Microsoft.NETCore.Platforms": "1.1.0"
+        }
+      },
+      "Newtonsoft.Json/13.0.3": {
+        "runtime": {
+          "lib/netstandard2.0/Newtonsoft.Json.dll": {
+            "assemblyVersion": "13.0.0.0",
+            "fileVersion": "13.0.3.27908"
+          }
+        }
+      },
+      "NuGet.Frameworks/6.8.0": {
+        "runtime": {
+          "lib/netstandard2.0/NuGet.Frameworks.dll": {
+            "assemblyVersion": "6.8.0.131",
+            "fileVersion": "6.8.0.131"
+          }
+        }
+      },
+      "NuGet.Versioning/6.8.0": {
+        "runtime": {
+          "lib/netstandard2.0/NuGet.Versioning.dll": {
+            "assemblyVersion": "6.8.0.131",
+            "fileVersion": "6.8.0.131"
+          }
+        }
+      },
+      "System.Buffers/4.5.1": {
+        "runtime": {
+          "lib/netstandard2.0/System.Buffers.dll": {
+            "assemblyVersion": "4.0.3.0",
+            "fileVersion": "4.6.28619.1"
+          }
+        }
+      },
+      "System.Collections.Immutable/1.5.0": {
+        "runtime": {
+          "lib/netstandard2.0/System.Collections.Immutable.dll": {
+            "assemblyVersion": "1.2.3.0",
+            "fileVersion": "4.6.26515.6"
+          }
+        }
+      },
+      "System.Memory/4.5.4": {
+        "dependencies": {
+          "System.Buffers": "4.5.1",
+          "System.Numerics.Vectors": "4.5.0",
+          "System.Runtime.CompilerServices.Unsafe": "6.0.0"
+        },
+        "runtime": {
+          "lib/netstandard2.0/System.Memory.dll": {
+            "assemblyVersion": "4.0.1.1",
+            "fileVersion": "4.6.28619.1"
+          }
+        }
+      },
+      "System.Numerics.Vectors/4.5.0": {
+        "runtime": {
+          "lib/netstandard2.0/System.Numerics.Vectors.dll": {
+            "assemblyVersion": "4.1.4.0",
+            "fileVersion": "4.6.26515.6"
+          }
+        }
+      },
+      "System.Reflection.Metadata/1.6.0": {
+        "dependencies": {
+          "System.Collections.Immutable": "1.5.0"
+        },
+        "runtime": {
+          "lib/netstandard2.0/System.Reflection.Metadata.dll": {
+            "assemblyVersion": "1.4.3.0",
+            "fileVersion": "4.6.26515.6"
+          }
+        }
+      },
+      "System.Runtime.CompilerServices.Unsafe/6.0.0": {
+        "runtime": {
+          "lib/netstandard2.0/System.Runtime.CompilerServices.Unsafe.dll": {
+            "assemblyVersion": "6.0.0.0",
+            "fileVersion": "6.0.21.52210"
+          }
+        }
+      },
+      "System.Text.Encodings.Web/6.0.0": {
+        "dependencies": {
+          "System.Buffers": "4.5.1",
+          "System.Memory": "4.5.4",
+          "System.Runtime.CompilerServices.Unsafe": "6.0.0"
+        },
+        "runtime": {
+          "lib/netstandard2.0/System.Text.Encodings.Web.dll": {
+            "assemblyVersion": "6.0.0.0",
+            "fileVersion": "6.0.21.52210"
+          }
+        }
+      },
+      "System.Text.Json/6.0.0": {
+        "dependencies": {
+          "Microsoft.Bcl.AsyncInterfaces": "6.0.0",
+          "System.Buffers": "4.5.1",
+          "System.Memory": "4.5.4",
+          "System.Numerics.Vectors": "4.5.0",
+          "System.Runtime.CompilerServices.Unsafe": "6.0.0",
+          "System.Text.Encodings.Web": "6.0.0",
+          "System.Threading.Tasks.Extensions": "4.5.4"
+        },
+        "runtime": {
+          "lib/netstandard2.0/System.Text.Json.dll": {
+            "assemblyVersion": "6.0.0.0",
+            "fileVersion": "6.0.21.52210"
+          }
+        }
+      },
+      "System.Threading.Tasks.Extensions/4.5.4": {
+        "dependencies": {
+          "System.Runtime.CompilerServices.Unsafe": "6.0.0"
+        },
+        "runtime": {
+          "lib/netstandard2.0/System.Threading.Tasks.Extensions.dll": {
+            "assemblyVersion": "4.2.0.1",
+            "fileVersion": "4.6.28619.1"
+          }
+        }
+      },
+      "coverlet.core/1.0.0": {
+        "dependencies": {
+          "Microsoft.Bcl.AsyncInterfaces": "6.0.0",
+          "Microsoft.Extensions.DependencyInjection": "6.0.1",
+          "Microsoft.Extensions.DependencyModel": "6.0.0",
+          "Microsoft.Extensions.FileSystemGlobbing": "6.0.0",
+          "Mono.Cecil": "0.11.5",
+          "Newtonsoft.Json": "13.0.3",
+          "NuGet.Versioning": "6.8.0",
+          "System.Collections.Immutable": "1.5.0",
+          "System.Reflection.Metadata": "1.6.0"
+        },
+        "runtime": {
+          "coverlet.core.dll": {}
+        }
+      }
+    }
+  },
+  "libraries": {
+    "coverlet.collector/6.0.2": {
+      "type": "project",
+      "serviceable": false,
+      "sha512": ""
+    },
+    "Microsoft.Bcl.AsyncInterfaces/6.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-UcSjPsst+DfAdJGVDsu346FX0ci0ah+lw3WRtn18NUwEqRt70HaOQ7lI72vy3+1LxtqI3T5GWwV39rQSrCzAeg==",
+      "path": "microsoft.bcl.asyncinterfaces/6.0.0",
+      "hashPath": "microsoft.bcl.asyncinterfaces.6.0.0.nupkg.sha512"
+    },
+    "Microsoft.Build.Tasks.Git/8.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-bZKfSIKJRXLTuSzLudMFte/8CempWjVamNUR5eHJizsy+iuOuO/k2gnh7W0dHJmYY0tBf+gUErfluCv5mySAOQ==",
+      "path": "microsoft.build.tasks.git/8.0.0",
+      "hashPath": "microsoft.build.tasks.git.8.0.0.nupkg.sha512"
+    },
+    "Microsoft.Extensions.DependencyInjection/6.0.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-vWXPg3HJQIpZkENn1KWq8SfbqVujVD7S7vIAyFXXqK5xkf1Vho+vG0bLBCHxU36lD1cLLtmGpfYf0B3MYFi9tQ==",
+      "path": "microsoft.extensions.dependencyinjection/6.0.1",
+      "hashPath": "microsoft.extensions.dependencyinjection.6.0.1.nupkg.sha512"
+    },
+    "Microsoft.Extensions.DependencyInjection.Abstractions/6.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-xlzi2IYREJH3/m6+lUrQlujzX8wDitm4QGnUu6kUXTQAWPuZY8i+ticFJbzfqaetLA6KR/rO6Ew/HuYD+bxifg==",
+      "path": "microsoft.extensions.dependencyinjection.abstractions/6.0.0",
+      "hashPath": "microsoft.extensions.dependencyinjection.abstractions.6.0.0.nupkg.sha512"
+    },
+    "Microsoft.Extensions.DependencyModel/6.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-TD5QHg98m3+QhgEV1YVoNMl5KtBw/4rjfxLHO0e/YV9bPUBDKntApP4xdrVtGgCeQZHVfC2EXIGsdpRNrr87Pg==",
+      "path": "microsoft.extensions.dependencymodel/6.0.0",
+      "hashPath": "microsoft.extensions.dependencymodel.6.0.0.nupkg.sha512"
+    },
+    "Microsoft.Extensions.FileSystemGlobbing/6.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-ip8jnL1aPiaPeKINCqaTEbvBFDmVx9dXQEBZ2HOBRXPD1eabGNqP/bKlsIcp7U2lGxiXd5xIhoFcmY8nM4Hdiw==",
+      "path": "microsoft.extensions.filesystemglobbing/6.0.0",
+      "hashPath": "microsoft.extensions.filesystemglobbing.6.0.0.nupkg.sha512"
+    },
+    "Microsoft.NETCore.Platforms/1.1.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-kz0PEW2lhqygehI/d6XsPCQzD7ff7gUJaVGPVETX611eadGsA3A877GdSlU0LRVMCTH/+P3o2iDTak+S08V2+A==",
+      "path": "microsoft.netcore.platforms/1.1.0",
+      "hashPath": "microsoft.netcore.platforms.1.1.0.nupkg.sha512"
+    },
+    "Microsoft.SourceLink.Common/8.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw==",
+      "path": "microsoft.sourcelink.common/8.0.0",
+      "hashPath": "microsoft.sourcelink.common.8.0.0.nupkg.sha512"
+    },
+    "Microsoft.SourceLink.GitHub/8.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-G5q7OqtwIyGTkeIOAc3u2ZuV/kicQaec5EaRnc0pIeSnh9LUjj+PYQrJYBURvDt7twGl2PKA7nSN0kz1Zw5bnQ==",
+      "path": "microsoft.sourcelink.github/8.0.0",
+      "hashPath": "microsoft.sourcelink.github.8.0.0.nupkg.sha512"
+    },
+    "Microsoft.TestPlatform.ObjectModel/17.8.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-AYy6vlpGMfz5kOFq99L93RGbqftW/8eQTqjT9iGXW6s9MRP3UdtY8idJ8rJcjeSja8A18IhIro5YnH3uv1nz4g==",
+      "path": "microsoft.testplatform.objectmodel/17.8.0",
+      "hashPath": "microsoft.testplatform.objectmodel.17.8.0.nupkg.sha512"
+    },
+    "Mono.Cecil/0.11.5": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-fxfX+0JGTZ8YQeu1MYjbBiK2CYTSzDyEeIixt+yqKKTn7FW8rv7JMY70qevup4ZJfD7Kk/VG/jDzQQTpfch87g==",
+      "path": "mono.cecil/0.11.5",
+      "hashPath": "mono.cecil.0.11.5.nupkg.sha512"
+    },
+    "Nerdbank.GitVersioning/3.6.133": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-VZWMd5YAeDxpjWjAP/X6bAxnRMiEf6tES/ITN0X5CHJgkWLLeHGmEALivmTAfYM6P+P/3Szy6VCITUAkqjcHVw==",
+      "path": "nerdbank.gitversioning/3.6.133",
+      "hashPath": "nerdbank.gitversioning.3.6.133.nupkg.sha512"
+    },
+    "NETStandard.Library/2.0.3": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-st47PosZSHrjECdjeIzZQbzivYBJFv6P2nv4cj2ypdI204DO+vZ7l5raGMiX4eXMJ53RfOIg+/s4DHVZ54Nu2A==",
+      "path": "netstandard.library/2.0.3",
+      "hashPath": "netstandard.library.2.0.3.nupkg.sha512"
+    },
+    "Newtonsoft.Json/13.0.3": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-HrC5BXdl00IP9zeV+0Z848QWPAoCr9P3bDEZguI+gkLcBKAOxix/tLEAAHC+UvDNPv4a2d18lOReHMOagPa+zQ==",
+      "path": "newtonsoft.json/13.0.3",
+      "hashPath": "newtonsoft.json.13.0.3.nupkg.sha512"
+    },
+    "NuGet.Frameworks/6.8.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-cN9NyahKgYYScioH4CKn+TYj1eSODxd0RECFnQt6ZmzT6z7PfXlbYpVzbiPsxNgY23iNDMOVkSmOqNZyYxNlQA==",
+      "path": "nuget.frameworks/6.8.0",
+      "hashPath": "nuget.frameworks.6.8.0.nupkg.sha512"
+    },
+    "NuGet.Versioning/6.8.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-WBu15cdv1lqKkPKXDQOEmEzwKemwrczKYlc2jtuZgRYiZ8TG8F4QzPYiE0Q9eVIpMSk8Aky7mUephf19HjBPOw==",
+      "path": "nuget.versioning/6.8.0",
+      "hashPath": "nuget.versioning.6.8.0.nupkg.sha512"
+    },
+    "System.Buffers/4.5.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-Rw7ijyl1qqRS0YQD/WycNst8hUUMgrMH4FCn1nNm27M4VxchZ1js3fVjQaANHO5f3sN4isvP4a+Met9Y4YomAg==",
+      "path": "system.buffers/4.5.1",
+      "hashPath": "system.buffers.4.5.1.nupkg.sha512"
+    },
+    "System.Collections.Immutable/1.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-EXKiDFsChZW0RjrZ4FYHu9aW6+P4MCgEDCklsVseRfhoO0F+dXeMSsMRAlVXIo06kGJ/zv+2w1a2uc2+kxxSaQ==",
+      "path": "system.collections.immutable/1.5.0",
+      "hashPath": "system.collections.immutable.1.5.0.nupkg.sha512"
+    },
+    "System.Memory/4.5.4": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-1MbJTHS1lZ4bS4FmsJjnuGJOu88ZzTT2rLvrhW7Ygic+pC0NWA+3hgAen0HRdsocuQXCkUTdFn9yHJJhsijDXw==",
+      "path": "system.memory/4.5.4",
+      "hashPath": "system.memory.4.5.4.nupkg.sha512"
+    },
+    "System.Numerics.Vectors/4.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-QQTlPTl06J/iiDbJCiepZ4H//BVraReU4O4EoRw1U02H5TLUIT7xn3GnDp9AXPSlJUDyFs4uWjWafNX6WrAojQ==",
+      "path": "system.numerics.vectors/4.5.0",
+      "hashPath": "system.numerics.vectors.4.5.0.nupkg.sha512"
+    },
+    "System.Reflection.Metadata/1.6.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-COC1aiAJjCoA5GBF+QKL2uLqEBew4JsCkQmoHKbN3TlOZKa2fKLz5CpiRQKDz0RsAOEGsVKqOD5bomsXq/4STQ==",
+      "path": "system.reflection.metadata/1.6.0",
+      "hashPath": "system.reflection.metadata.1.6.0.nupkg.sha512"
+    },
+    "System.Runtime.CompilerServices.Unsafe/6.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-/iUeP3tq1S0XdNNoMz5C9twLSrM/TH+qElHkXWaPvuNOt+99G75NrV0OS2EqHx5wMN7popYjpc8oTjC1y16DLg==",
+      "path": "system.runtime.compilerservices.unsafe/6.0.0",
+      "hashPath": "system.runtime.compilerservices.unsafe.6.0.0.nupkg.sha512"
+    },
+    "System.Text.Encodings.Web/6.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-Vg8eB5Tawm1IFqj4TVK1czJX89rhFxJo9ELqc/Eiq0eXy13RK00eubyU6TJE6y+GQXjyV5gSfiewDUZjQgSE0w==",
+      "path": "system.text.encodings.web/6.0.0",
+      "hashPath": "system.text.encodings.web.6.0.0.nupkg.sha512"
+    },
+    "System.Text.Json/6.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-zaJsHfESQvJ11vbXnNlkrR46IaMULk/gHxYsJphzSF+07kTjPHv+Oc14w6QEOfo3Q4hqLJgStUaYB9DBl0TmWg==",
+      "path": "system.text.json/6.0.0",
+      "hashPath": "system.text.json.6.0.0.nupkg.sha512"
+    },
+    "System.Threading.Tasks.Extensions/4.5.4": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-zteT+G8xuGu6mS+mzDzYXbzS7rd3K6Fjb9RiZlYlJPam2/hU7JCBZBVEcywNuR+oZ1ncTvc/cq0faRr3P01OVg==",
+      "path": "system.threading.tasks.extensions/4.5.4",
+      "hashPath": "system.threading.tasks.extensions.4.5.4.nupkg.sha512"
+    },
+    "coverlet.core/1.0.0": {
+      "type": "project",
+      "serviceable": false,
+      "sha512": ""
+    }
+  }
+}

.nuget/packages/coverlet.collector/6.0.2/build/netstandard2.0/coverlet.collector.targets

@@ -0,0 +1,58 @@
+<!--
+***********************************************************************************************
+coverlet.collector.targets
+
+WARNING:  DO NOT MODIFY this file unless you are knowledgeable about MSBuild and have
+          created a backup copy.  Incorrect changes to this file will make it
+          impossible to load or build your projects from the command-line or the IDE.
+***********************************************************************************************
+-->
+
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+
+  <Target Name="CopyCoverletDataCollectorFiles" AfterTargets="ComputeFilesToPublish">
+    <ItemGroup>
+      <CoverletDataCollectorFiles Include="$(MSBuildThisFileDirectory)\**\*.*" />
+      <CoverletDataCollectorFiles Remove="@(ResolvedFileToPublish->'$(MSBuildThisFileDirectory)%(Filename)%(Extension)')" />
+    </ItemGroup>
+    <Copy SourceFiles="@(CoverletDataCollectorFiles)" DestinationFolder="$(PublishDir)%(RecursiveDir)" />
+  </Target>
+  
+  <Target Name="SetXPlatDataCollectorPath" BeforeTargets="VSTest">
+    <PropertyGroup>
+      <VSTestTestAdapterPath>$(VSTestTestAdapterPath);$(MSBuildThisFileDirectory)</VSTestTestAdapterPath>
+    </PropertyGroup>
+  </Target>
+
+  <PropertyGroup>
+    <_CoverletSdkNETCoreSdkVersion>$(NETCoreSdkVersion)</_CoverletSdkNETCoreSdkVersion>
+    <_CoverletSdkNETCoreSdkVersion Condition="$(_CoverletSdkNETCoreSdkVersion.Contains('-'))">$(_CoverletSdkNETCoreSdkVersion.Split('-')[0])</_CoverletSdkNETCoreSdkVersion>
+    <_CoverletSdkMinVersionWithDependencyTarget>6.0.100</_CoverletSdkMinVersionWithDependencyTarget>
+    <_CoverletSourceRootTargetName>CoverletGetPathMap</_CoverletSourceRootTargetName>
+    <_CoverletSourceRootTargetName Condition="'$([System.Version]::Parse($(_CoverletSdkNETCoreSdkVersion)).CompareTo($([System.Version]::Parse($(_CoverletSdkMinVersionWithDependencyTarget)))))' &gt;= '0' ">InitializeSourceRootMappedPaths</_CoverletSourceRootTargetName>
+  </PropertyGroup>
+
+  <Target Name="ReferencedPathMaps" BeforeTargets="CoreCompile" DependsOnTargets="ResolveProjectReferences" >
+    <MSBuild Projects="@(AnnotatedProjects->'%(FullPath)')"
+             Targets="$(_CoverletSourceRootTargetName)"
+             Properties="TargetFramework=%(AnnotatedProjects.NearestTargetFramework)"
+             SkipNonexistentTargets="true">
+      <Output TaskParameter="TargetOutputs"
+              ItemName="_LocalTopLevelSourceRoot" />
+    </MSBuild>
+    <ItemGroup>
+      <_byProject Include="@(_LocalTopLevelSourceRoot->'%(MSBuildSourceProjectFile)')" OriginalPath="%(Identity)" />
+      <_mapping Include="@(_byProject->'%(Identity)|%(OriginalPath)=%(MappedPath)')" />
+    </ItemGroup>
+    <PropertyGroup>
+      <_sourceRootMappingFilePath>$([MSBuild]::EnsureTrailingSlash('$(OutputPath)'))CoverletSourceRootsMapping_$(AssemblyName)</_sourceRootMappingFilePath>
+    </PropertyGroup>
+    <WriteLinesToFile File="$(_sourceRootMappingFilePath)" Lines="@(_mapping)"
+                      Overwrite="true" Encoding="Unicode"
+                      Condition="'@(_mapping)'!=''"
+                      WriteOnlyWhenDifferent="true" />
+    <ItemGroup>
+      <FileWrites Include="$(_sourceRootMappingFilePath)" Condition="'@(_mapping)'!=''" />
+    </ItemGroup>
+  </Target>
+</Project>

.nuget/packages/coverlet.collector/6.0.2/build/netstandard2.0/coverlet.core.xml

@@ -0,0 +1,309 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>coverlet.core</name>
+    </assembly>
+    <members>
+        <member name="M:Coverlet.Core.Helpers.RetryHelper.Retry(System.Action,System.Func{System.TimeSpan},System.Int32)">
+            <summary>
+            Retry a void method.
+            </summary>
+            <param name="action">The action to perform</param>
+            <param name="backoffStrategy">A function returning a Timespan defining the backoff strategy to use.</param>
+            <param name="maxAttemptCount">The maximum number of retries before bailing out. Defaults to 3.</param>
+        </member>
+        <member name="M:Coverlet.Core.Helpers.RetryHelper.Do``1(System.Func{``0},System.Func{System.TimeSpan},System.Int32)">
+            <summary>
+            Retry a method returning type T.
+            </summary>
+            <typeparam name="T">The type of the object to return</typeparam>
+            <param name="action">The action to perform</param>
+            <param name="backoffStrategy">A function returning a Timespan defining the backoff strategy to use.</param>
+            <param name="maxAttemptCount">The maximum number of retries before bailing out. Defaults to 3.</param>
+        </member>
+        <member name="T:Coverlet.Core.Instrumentation.NetstandardAwareAssemblyResolver">
+             <summary>
+             In case of testing different runtime i.e. netfx we could find netstandard.dll in folder.
+             netstandard.dll is a forward only lib, there is no IL but only forwards to "runtime" implementation.
+             For some classes implementation are in different assembly for different runtime for instance:
+            
+             For NetFx 4.7
+             // Token: 0x2700072C RID: 1836
+             .class extern forwarder System.Security.Cryptography.X509Certificates.StoreName
+             {
+                .assembly extern System
+             }
+            
+             For netcoreapp2.2
+             Token: 0x2700072C RID: 1836
+             .class extern forwarder System.Security.Cryptography.X509Certificates.StoreName
+             {
+                .assembly extern System.Security.Cryptography.X509Certificates
+             }
+            
+             There is a concrete possibility that Cecil cannot find implementation and throws StackOverflow exception https://github.com/jbevain/cecil/issues/575
+             This custom resolver check if requested lib is a "official" netstandard.dll and load once of "current runtime" with
+             correct forwards.
+             Check compares 'assembly name' and 'public key token', because versions could differ between runtimes.
+             </summary>
+        </member>
+        <member name="M:Coverlet.Core.Instrumentation.NetstandardAwareAssemblyResolver.TryWithCustomResolverOnDotNetCore(Mono.Cecil.AssemblyNameReference)">
+             <summary>
+            
+             We try to manually load assembly.
+             To work test project needs to use
+            
+             <PropertyGroup>
+                 <PreserveCompilationContext>true</PreserveCompilationContext>
+             </PropertyGroup>
+            
+             Runtime configuration file doc https://github.com/dotnet/cli/blob/master/Documentation/specs/runtime-configuration-file.md
+            
+             </summary>
+        </member>
+        <member name="M:Coverlet.Core.Instrumentation.Instrumenter.InstrumentIL(Mono.Cecil.MethodDefinition)">
+            <summary>
+            The base idea is to inject an int placeholder for every sequence point. We register source+placeholder+lines(from sequence point) for final accounting.
+            Instrumentation alg(current instruction: instruction we're analyzing):
+            1) We get all branches for the method
+            2) We get the sequence point of every instruction of method(start line/end line)
+            3) We check if current instruction is reachable and coverable
+            4) For every sequence point of an instruction we put load(int hint placeholder)+call opcode above current instruction
+            5) We patch all jump to current instruction with first injected instruction(load)
+            6) If current instruction is a target for a branch we inject again load(int hint placeholder)+call opcode above current instruction
+            7) We patch all jump to current instruction with first injected instruction(load)
+            </summary>
+        </member>
+        <member name="T:Coverlet.Core.Instrumentation.Instrumenter.CoreLibMetadataImporterProvider">
+            <summary>
+            A custom importer created specifically to allow the instrumentation of System.Private.CoreLib by
+            removing the external references to netstandard that are generated when instrumenting a typical
+            assembly.
+            </summary>
+        </member>
+        <member name="T:Coverlet.Core.Instrumentation.ModuleTrackerTemplate">
+            <summary>
+            This static class will be injected on a module being instrumented in order to direct on module hits
+            to a single location.
+            </summary>
+            <remarks>
+            As this type is going to be customized for each instrumented module it doesn't follow typical practices
+            regarding visibility of members, etc.
+            </remarks>
+        </member>
+        <member name="T:Coverlet.Core.Instrumentation.Reachability.ReachabilityHelper">
+            <summary>
+            Helper for find unreachable IL instructions.
+            </summary>
+        </member>
+        <member name="P:Coverlet.Core.Instrumentation.Reachability.ReachabilityHelper.UnreachableRange.StartOffset">
+            <summary>
+            Offset of first unreachable instruction.
+            </summary>
+        </member>
+        <member name="P:Coverlet.Core.Instrumentation.Reachability.ReachabilityHelper.UnreachableRange.EndOffset">
+            <summary>
+            Offset of last unreachable instruction.
+            </summary>
+        </member>
+        <member name="P:Coverlet.Core.Instrumentation.Reachability.ReachabilityHelper.BasicBlock.StartOffset">
+            <summary>
+            Offset of the instruction that starts the block
+            </summary>
+        </member>
+        <member name="P:Coverlet.Core.Instrumentation.Reachability.ReachabilityHelper.BasicBlock.TailReachable">
+            <summary>
+            Whether it is possible for control to flow past the end of the block,
+            ie. whether it's tail is reachable
+            </summary>
+        </member>
+        <member name="P:Coverlet.Core.Instrumentation.Reachability.ReachabilityHelper.BasicBlock.BranchesTo">
+            <summary>
+            If control flows to the end of the block, where it can flow to
+            </summary>
+        </member>
+        <member name="P:Coverlet.Core.Instrumentation.Reachability.ReachabilityHelper.BasicBlock.UnreachableAfter">
+            <summary>
+            If this block contains a call(i) to a method that does not return
+            this will be the first such call.
+            </summary>
+        </member>
+        <member name="P:Coverlet.Core.Instrumentation.Reachability.ReachabilityHelper.BasicBlock.ExceptionBranchesTo">
+            <summary>
+            If an exception is raised in this block, where control might branch to.
+            
+            Note that this can happen even if the block's end is unreachable.
+            </summary>
+        </member>
+        <member name="P:Coverlet.Core.Instrumentation.Reachability.ReachabilityHelper.BasicBlock.HeadReachable">
+            <summary>
+            Mutable, records whether control can flow into the block,
+            ie. whether it's head is reachable
+            </summary>
+        </member>
+        <member name="T:Coverlet.Core.Instrumentation.Reachability.ReachabilityHelper.BranchInstruction">
+            <summary>
+            Represents an Instruction that transitions control flow (ie. branches).
+            
+            This is _different_ from other branch types, like Branch and BranchPoint
+            because it includes unconditional branches too.
+            </summary>
+        </member>
+        <member name="P:Coverlet.Core.Instrumentation.Reachability.ReachabilityHelper.BranchInstruction.Offset">
+            <summary>
+            Location of the branching instruction
+            </summary>
+        </member>
+        <member name="P:Coverlet.Core.Instrumentation.Reachability.ReachabilityHelper.BranchInstruction.HasMultiTargets">
+            <summary>
+            Returns true if this branch has multiple targets.
+            </summary>
+        </member>
+        <member name="P:Coverlet.Core.Instrumentation.Reachability.ReachabilityHelper.BranchInstruction.TargetOffset">
+            <summary>
+            Target of the branch, assuming it has a single target.
+            
+            It is illegal to access this if there are multiple targets.
+            </summary>
+        </member>
+        <member name="P:Coverlet.Core.Instrumentation.Reachability.ReachabilityHelper.BranchInstruction.TargetOffsets">
+            <summary>
+            Targets of the branch, assuming it has multiple targets.
+            
+            It is illegal to access this if there is a single target.
+            </summary>
+        </member>
+        <member name="F:Coverlet.Core.Instrumentation.Reachability.ReachabilityHelper.s_branchOpCodes">
+            <summary>
+            OpCodes that transfer control code, even if they do not
+            introduce branch points.
+            </summary>
+        </member>
+        <member name="F:Coverlet.Core.Instrumentation.Reachability.ReachabilityHelper.s_unconditionalBranchOpCodes">
+            <summary>
+            OpCodes that unconditionally transfer control, so there
+            is not "fall through" branch target.
+            </summary>
+        </member>
+        <member name="M:Coverlet.Core.Instrumentation.Reachability.ReachabilityHelper.CreateForModule(Mono.Cecil.ModuleDefinition,System.String[],Coverlet.Core.Abstractions.ILogger)">
+            <summary>
+            Build a ReachabilityHelper for the given module.
+            
+            Predetermines methods that will not return, as 
+            indicated by the presense of the given attributes.
+            </summary>
+        </member>
+        <member name="M:Coverlet.Core.Instrumentation.Reachability.ReachabilityHelper.FindUnreachableIL(Mono.Collections.Generic.Collection{Mono.Cecil.Cil.Instruction},Mono.Collections.Generic.Collection{Mono.Cecil.Cil.ExceptionHandler})">
+            <summary>
+            Calculates which IL instructions are reachable given an instruction stream and branch points extracted from a method.
+            
+            The algorithm works like so:
+             1. determine the "blocks" that make up a function
+                * A block starts with either the start of the method, or a branch _target_
+                * blocks are "where some other code might jump to"
+                * blocks end with either another branch, another branch target, or the end of the method
+                * this means blocks contain no control flow, except (maybe) as the very last instruction
+             2. blocks have head and tail reachability
+                * a block has head reachablility if some other block that is reachable can branch to it 
+                * a block has tail reachability if it contains no calls to methods that never return
+             4. push the first block onto a stack
+             5. while the stack is not empty
+                a. pop a block off the stack
+                b. give it head reachability
+                c. if the pop'd block is tail reachable, push the blocks it can branch to onto the stack
+             6. consider each block
+                * if it is head and tail reachable, all instructions in it are reachable
+                * if it is not head reachable (regardless of tail reachability), no instructions in it are reachable
+                * if it is only head reachable, all instructions up to and including the first call to a method that does not return are reachable
+            </summary>
+        </member>
+        <member name="M:Coverlet.Core.Instrumentation.Reachability.ReachabilityHelper.AnalyzeInstructions(Mono.Collections.Generic.Collection{Mono.Cecil.Cil.Instruction},Mono.Collections.Generic.Collection{Mono.Cecil.Cil.ExceptionHandler})">
+            <summary>
+            Analyzes the instructiona and exception handlers provided to find branches and determine if
+              it is possible for their to be unreachable code.
+            </summary>
+        </member>
+        <member name="M:Coverlet.Core.Instrumentation.Reachability.ReachabilityHelper.GetInstructionTargets(Mono.Cecil.Cil.Instruction,Mono.Collections.Generic.Collection{Mono.Cecil.Cil.ExceptionHandler})">
+            <summary>
+            For a single instruction, determines all the places it might branch to.
+            </summary>
+        </member>
+        <member name="M:Coverlet.Core.Instrumentation.Reachability.ReachabilityHelper.DetermineUnreachableRanges(System.Collections.Immutable.ImmutableArray{Coverlet.Core.Instrumentation.Reachability.ReachabilityHelper.BasicBlock},System.Int32)">
+            <summary>
+            Calculates which ranges of IL are unreachable, given blocks which have head and tail reachability calculated.
+            </summary>
+        </member>
+        <member name="M:Coverlet.Core.Instrumentation.Reachability.ReachabilityHelper.DetermineHeadReachability(System.Collections.Immutable.ImmutableArray{Coverlet.Core.Instrumentation.Reachability.ReachabilityHelper.BasicBlock})">
+            <summary>
+            Process all the blocks and determine if their first instruction is reachable,
+            that is if they have "head reachability".
+            
+            "Tail reachability" will have already been determined in CreateBlocks.
+            </summary>
+        </member>
+        <member name="M:Coverlet.Core.Instrumentation.Reachability.ReachabilityHelper.CreateBasicBlocks(Mono.Collections.Generic.Collection{Mono.Cecil.Cil.Instruction},Mono.Collections.Generic.Collection{Mono.Cecil.Cil.ExceptionHandler},System.Collections.Immutable.ImmutableArray{Coverlet.Core.Instrumentation.Reachability.ReachabilityHelper.BranchInstruction})">
+            <summary>
+            Create BasicBlocks from an instruction stream, exception blocks, and branches.
+            
+            Each block starts either at the start of the method, immediately after a branch or at a target for a branch,
+            and ends with another branch, another branch target, or the end of the method.
+            
+            "Tail reachability" is also calculated, which is whether the block can ever actually get past its last instruction.
+            </summary>
+        </member>
+        <member name="M:Coverlet.Core.Instrumentation.Reachability.ReachabilityHelper.DoesNotReturn(Mono.Cecil.Cil.Instruction)">
+            <summary>
+            Returns true if the given instruction will never return, 
+            and thus subsequent instructions will never be run.
+            </summary>
+        </member>
+        <member name="M:Coverlet.Core.Instrumentation.Reachability.ReachabilityHelper.IsCall(Mono.Cecil.Cil.Instruction,Mono.Cecil.MethodReference@)">
+            <summary>
+            Returns true if the given instruction is a Call or Callvirt.
+            
+            If it is a call, extracts the MethodReference that is being called.
+            </summary>
+        </member>
+        <member name="T:Coverlet.Core.Symbols.BranchPoint">
+            <summary>
+            a branch point
+            </summary>
+        </member>
+        <member name="P:Coverlet.Core.Symbols.BranchPoint.StartLine">
+            <summary>
+            Line of the branching instruction
+            </summary>
+        </member>
+        <member name="P:Coverlet.Core.Symbols.BranchPoint.Path">
+            <summary>
+            A path that can be taken
+            </summary>
+        </member>
+        <member name="P:Coverlet.Core.Symbols.BranchPoint.Ordinal">
+            <summary>
+            An order of the point within the method
+            </summary>
+        </member>
+        <member name="P:Coverlet.Core.Symbols.BranchPoint.OffsetPoints">
+            <summary>
+            List of OffsetPoints between Offset and EndOffset (exclusive)
+            </summary>
+        </member>
+        <member name="P:Coverlet.Core.Symbols.BranchPoint.Offset">
+            <summary>
+            The IL offset of the point
+            </summary>
+        </member>
+        <member name="P:Coverlet.Core.Symbols.BranchPoint.EndOffset">
+            <summary>
+            Last Offset == EndOffset.
+            Can be same as Offset
+            </summary>
+        </member>
+        <member name="P:Coverlet.Core.Symbols.BranchPoint.Document">
+            <summary>
+            The url to the document if an entry was not mapped to an id
+            </summary>
+        </member>
+    </members>
+</doc>

.nuget/packages/coverlet.collector/6.0.2/coverlet.collector.6.0.2.nupkg.sha512

@@ -0,0 +1 @@
+kGDsWGkGmSqpBhVNBeivBZKxRdRrQM+7/AlyNugfr0jZ7GpDfFZCzAlPfq/yZC3QNtWPeCPGXN8Q4TcF4aPZBA==

.nuget/packages/coverlet.collector/6.0.2/coverlet.collector.nuspec

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<package xmlns="http://schemas.microsoft.com/packaging/2011/08/nuspec.xsd">
+  <metadata>
+    <id>coverlet.collector</id>
+    <version>6.0.2</version>
+    <title>coverlet.collector</title>
+    <authors>tonerdo</authors>
+    <developmentDependency>true</developmentDependency>
+    <license type="expression">MIT</license>
+    <licenseUrl>https://licenses.nuget.org/MIT</licenseUrl>
+    <icon>coverlet-icon.png</icon>
+    <readme>VSTestIntegration.md</readme>
+    <projectUrl>https://github.com/coverlet-coverage/coverlet</projectUrl>
+    <iconUrl>https://raw.githubusercontent.com/tonerdo/coverlet/master/_assets/coverlet-icon.svg?sanitize=true</iconUrl>
+    <description>Coverlet is a cross platform code coverage library for .NET, with support for line, branch and method coverage.</description>
+    <releaseNotes>https://github.com/coverlet-coverage/coverlet/blob/master/Documentation/Changelog.md</releaseNotes>
+    <tags>coverage testing unit-test lcov opencover quality</tags>
+    <repository type="git" url="https://github.com/coverlet-coverage/coverlet.git" commit="04ba205b93e57ebc02bd61ce57a790ec983de3e3" />
+  </metadata>
+</package>