From fef226808e29f093cea6c2d5776d9a461865c6a1 Mon Sep 17 00:00:00 2001 From: OsirisTerje Date: Fri, 6 Oct 2023 07:53:32 +0000 Subject: [PATCH] Merge pull request #800 from nunit/runningtests updating runners a1eeca73ba62c28f330c0e98484c0cf1a4fa45a9 --- .../dotnet-core-and-dotnet-standard.html | 24 +- articles/nunit/running-tests/Index.html | 50 +- .../Template-Based-Test-Naming.html | 5 +- .../Test-Selection-Language.html | 6 +- .../vs-test-adapter/Adapter-Installation.html | 2 +- index.json | 10 +- sitemap.xml | 710 +++++++++--------- 7 files changed, 428 insertions(+), 379 deletions(-) diff --git a/articles/nunit/getting-started/dotnet-core-and-dotnet-standard.html b/articles/nunit/getting-started/dotnet-core-and-dotnet-standard.html index 2789263fd..919475da6 100644 --- a/articles/nunit/getting-started/dotnet-core-and-dotnet-standard.html +++ b/articles/nunit/getting-started/dotnet-core-and-dotnet-standard.html @@ -87,18 +87,28 @@

.NET Core and .NET Standard

More information and getting started tutorials are available for NUnit and .NET Core targeting C#, F# and Visual Basic in the .NET Core documentation's Unit Testing in .NET Core and .NET Standard page.

The other information on this page is older documentation. If you follow the instructions in the Installation section your project will work with .NET Core and .NET Standard.

-

The test projects have to be .NET Core or .NET Framework; .NET Standard can't be used as a test project, since it can't be run on its own, but any code in a .NET Standard library can be tested from a .NET Core or .NET Framework test project.

+

The test projects have to be .NET (Core) or .NET Framework; .NET Standard can't be used as a test project, since it can't be run on its own, but any code in a .NET Standard library can be tested from a .NET (Core) or .NET Framework test project.

TL;DR

Adding the adapter and Microsoft.NET.Test.Sdk version 17.0.0 or greater to your NUnit test projects will also enable the dotnet test command for .NET Core projects.

Any tests using the new style CSPROJ format, either .NET Core or .NET 4.x, need to add a PackageReference to the NuGet package Microsoft.NET.Test.Sdk. Your test assemblies must also be .NET Core or .NET 4.x, not .NET Standard.

-
<ItemGroup>
-  <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
-  <PackageReference Include="NUnit" Version="3.13.3" />
-  <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
-</ItemGroup>
+
You can create a new NUnit test project using dotnet new nunit. It will create an ItemGroup in the csproj file with the necessary references.

+
  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.6.0" />
+    <PackageReference Include="NUnit" Version="3.13.3" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.2.1" />
+    <PackageReference Include="NUnit.Analyzers" Version="3.6.1" />
+    <PackageReference Include="coverlet.collector" Version="6.0.0" />
+  </ItemGroup>
 

 
.NET Core test can be run on the command line with dotnet test, for example,

-
> dotnet test .\test\NetCore10Tests\NetCore10Tests.csproj
+
From the solution root folder

+
  dotnet test
+

+
or from the test project folder

+
  dotnet test
+

+
Or you can specify the csproj file you want to test

+
  dotnet test .\test\NetCore10Tests\NetCore10Tests.csproj
 

 
For a more complete walk-through, please see Testing .NET Core with NUnit in Visual Studio 2017

 
Using the NUnit project templates

diff --git a/articles/nunit/running-tests/Index.html b/articles/nunit/running-tests/Index.html
index a30752ace..7d2365163 100644
--- a/articles/nunit/running-tests/Index.html
+++ b/articles/nunit/running-tests/Index.html
@@ -85,18 +85,52 @@
             

 
Running Tests

 
-
NUnit provides three different runners, which may be used to load and
-run your tests.

+
There are several ways to run your tests, depending on your needs.
+The most common way is to use one of the common IDEs, such as Visual Studio, Visual Studio Code or Rider, or to use dotnet test from the command line. All of these use different parts of the NUnit ecosystem to run your tests. The Microsoft tools use the NUnit3TestAdapter, whereas Jetbrains Rider use the NUnit.Engine.

+
To start using NUnit with these tools, see the Installation section.

+
Also see the information on the NUnit3TestAdapter for more detailed information on how to use it and configure it.

+
In addition to these NUnit provides two special runners, the NUnit.Console and the NUnitLite runners, which are described below.

 
    
 
  • The Console Runner, nunit-console.exe, is used for batch execution.
    • 
-
  • The Gui Runner, nunit.exe, provides interactive loading and running of tests.
    • 
+
  • The NUnitLite runner, nunitlite-runner.exe, is a light weight runner originally used internally in the team, but can be used by anyone who wants to have a simple way of running tests from the command line.
    • 
 

-
NUnit Agent

+
Just for fun, to see how the different runners are being used, we can look at the nuget.org download statistics for each of the runners, per Oct 2023:

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
RunnerDownloadsComment
NUnit3TestAdapter211.4 millionUsed by Visual Studio, VS Code and dotnet test
NUnit.Console22.5 million
NUnitLite4.6 million

+
Other runners

+
The VSTest.Console is also a Microsoft runner, but it is less used now as dotnet test has taken over.  It does use the NUnit3TestAdapter as well.

+
The Azure Pipelines have some tasks for running tests, like VSTest, which also use the NUnit3TestAdapter under the hood.

+
Some information on the internal working

+
NUnit.Engine

+
All runners except NUnitLite use the NUnit.Engine, including Rider.
+It should not be used alone, as the different runners have different requirements for how the engine is used and which version is being used.
+See Compatibility of the Test Adapter with the Test Engine for some more detailed information on this.

+
NUnit Agent

 
When running tests in a separate process, the console and gui runners make use of the NUnit Agent program, nunit-agent.exe. Although not directly run by users, nunit-agent does load and execute tests and users need to be aware of it, especially when debugging is involved.

-
Third-Party Runners

-
Various third-party applications are available for loading and running NUnit tests. Some of these actually use NUnit to load the tests, while others provide their own emulation and may not work in the same way that NUnit does.

-
Because the status of such projects may change from time to time, we don't discuss them individually here. For the latest information, consult the manufacturer of any third-party software or ask other users on our
-discussion list.

 
Additional Information

 
For additional general information on how tests are loaded and run, see

 
    
diff --git a/articles/nunit/running-tests/Template-Based-Test-Naming.html b/articles/nunit/running-tests/Template-Based-Test-Naming.html
index 23d7b596e..22d0d87a8 100644
--- a/articles/nunit/running-tests/Template-Based-Test-Naming.html
+++ b/articles/nunit/running-tests/Template-Based-Test-Naming.html
@@ -85,7 +85,10 @@
             
    
 
    Template-Based Test Naming
    
 
-
    NUnit uses a standard naming convention for all tests - however, this can be overridden by the user if required. TestName generation is driven by a name formatting string, which may contain any of the following format specifiers:
    
+
    NUnit uses a standard naming convention for all tests, which in the language described below corresponds to {m}{a}. The most used runners, Visual Studio and dotnet depends on this being the default, and trying to change this will cause display issues in these runners.
    
+
    We strongly recommend you to NOT change the test naming.
    
+
    If you still want to do it
    
+
    However, if you're out on your own, the naming can be overridden by the user if required. TestName generation is driven by a name formatting string, which may contain any of the following format specifiers:
    
 
      
 
    • {n} The namespace of the test or empty if there is no namespace. If empty, any immediately following '.' is ignored.
      
 
      • 
diff --git a/articles/nunit/running-tests/Test-Selection-Language.html b/articles/nunit/running-tests/Test-Selection-Language.html
index 21c58a12d..4ac557d77 100644
--- a/articles/nunit/running-tests/Test-Selection-Language.html
+++ b/articles/nunit/running-tests/Test-Selection-Language.html
@@ -86,10 +86,12 @@
 
      Test Selection Language
      
 
 
      The console command-line allows you to specify a filter, which will select which tests are executed. This is done using the --where option, followed by an expression in NUnit's Test Selection Language (TSL), a simple domain-specific language designed for this purpose.
      
+
      The --where option can be used with the dotnet test as -- NUnit.Where (note the space after the --). This will inject this into the runsettings. You can also add the same to a .runsettings file, see Adapter options and this blog post.
      
 
      Some of the characters used in the expression, such as space, | or &, may have a special meaning when entered on the command-line. In such a case, you should place the expression in quotation marks.
      
-
        nunit3-console mytest.dll --where "cat == Urgent || Priority == High"
+
        dotnet test -- NUnit.Where="cat == Urgent or Priority == High"
+  nunit3-console mytest.dll --where "cat == Urgent || Priority == High"
+
 
      
-
      Note that TSL is handled by the NUnit engine but requires framework support to actually select the tests. The NUnit 3.0 framework supports it fully. See below for support limitations in NUnit V2 tests.
      
 
      Simple Expressions
      
 
      Simple Expressions are essentially comparisons, consisting of a key word or property name on the left-hand side, an operator and some constant value on the right-hand side. Here are some examples:
      
 
        cat == Data
diff --git a/articles/vs-test-adapter/Adapter-Installation.html b/articles/vs-test-adapter/Adapter-Installation.html
index 4214af589..ba5f487bb 100644
--- a/articles/vs-test-adapter/Adapter-Installation.html
+++ b/articles/vs-test-adapter/Adapter-Installation.html
@@ -116,7 +116,7 @@ 
      Working with the Visual Studio Nuget manager
      
 
      If you have a legacy project type, or prefer working outside of the command line, you can also use the Visual Studio 'Manage NuGet packages in the solution' menu option. It can also be used for the new SDK projects, but you may find it faster to open the csproj and copy/paste the references in.
      
 
      With an active solution in Visual Studio, follow these steps:
      
diff --git a/index.json b/index.json
index 04d3af456..c0abed949 100644
--- a/index.json
+++ b/index.json
@@ -632,7 +632,7 @@
   "articles/nunit/getting-started/dotnet-core-and-dotnet-standard.html": {
     "href": "articles/nunit/getting-started/dotnet-core-and-dotnet-standard.html",
     "title": ".NET Core and .NET Standard | NUnit Docs",
-    "keywords": ".NET Core and .NET Standard More information and getting started tutorials are available for NUnit and .NET Core targeting C#, F# and Visual Basic in the .NET Core documentation's Unit Testing in .NET Core and .NET Standard page. The other information on this page is older documentation. If you follow the instructions in the Installation section your project will work with .NET Core and .NET Standard. The test projects have to be .NET Core or .NET Framework; .NET Standard can't be used as a test project, since it can't be run on its own, but any code in a .NET Standard library can be tested from a .NET Core or .NET Framework test project. TL;DR Adding the adapter and Microsoft.NET.Test.Sdk version 17.0.0 or greater to your NUnit test projects will also enable the dotnet test command for .NET Core projects. Any tests using the new style CSPROJ format, either .NET Core or .NET 4.x, need to add a PackageReference to the NuGet package Microsoft.NET.Test.Sdk. Your test assemblies must also be .NET Core or .NET 4.x, not .NET Standard.      .NET Core test can be run on the command line with dotnet test, for example, > dotnet test .\\test\\NetCore10Tests\\NetCore10Tests.csproj For a more complete walk-through, please see Testing .NET Core with NUnit in Visual Studio 2017 Using the NUnit project templates The NUnit test project templates come included with dotnet. You can run dotnet new nunit to create an NUnit test project. FAQ Why can't my tests target .NET Standard Visual Studio and VSTest require that the tests target a specific platform. .NET Standard is like a Portable library in that it does not target any specific platform, but can run on any supported platform. Microsoft decided that your tests should be compiled to target a platform so they know which platform to run your tests under and you get the behavior you expect for the platform you are targeting. You can however target multiple platforms in your tests and compile and run each from the command line. It still only runs one platform from Visual Studio, but I would hope that is being worked on. I haven't tested 15.3 yet. It is similar to a console application, it cannot be .NET Standard, it must target a platform, .NET Core or .NET Framework. This limitation is the same for all test adapters including xUnit and MSTest2. My tests aren't showing up in Visual Studio 2017 or later Are you using the NuGet adapter package? Are you using version 4.1.0 or newer of the NuGet package? Do your tests target .NET Core or the full .NET Framework? (see above) Have you added a Package Reference to Microsoft.NET.Test.Sdk? Have you restarted Visual Studio? It is still a bit temperamental. My tests multi-target .NET Core and .NET Framework, why can't I run both in Visual Studio This is a limitation of Visual Studio, hopefully it will be fixed in a future release. Meanwhile, you can run specific tests using the --framework command line option of dotnet test How do I produce a test results file dotnet test can generate an NUnit3 test result file by adding a runsettings property. The property to add is TestOutputXml. This generation is done using the NUnit Engine report service, and produce the same result as the NUnit3-console. This is available through the NUnit3TestAdapter. You run it by adding the setting on the command line (or in a runsettings file): dotnet test -- NUnit.TestOutputXml=yourfoldername The folder is relative to a base folder determined by the OutputXmlFolder settings, or you can use an absolute path. The latter is useful in CI scenarios. Alternatively, there is a 3rd party package, NUnitXml.TestLogger which also produces a NUnit3 xml format. Details for use see here. Note that this is a re-implementation of the NUnit3 format, and may differ."
+    "keywords": ".NET Core and .NET Standard More information and getting started tutorials are available for NUnit and .NET Core targeting C#, F# and Visual Basic in the .NET Core documentation's Unit Testing in .NET Core and .NET Standard page. The other information on this page is older documentation. If you follow the instructions in the Installation section your project will work with .NET Core and .NET Standard. The test projects have to be .NET (Core) or .NET Framework; .NET Standard can't be used as a test project, since it can't be run on its own, but any code in a .NET Standard library can be tested from a .NET (Core) or .NET Framework test project. TL;DR Adding the adapter and Microsoft.NET.Test.Sdk version 17.0.0 or greater to your NUnit test projects will also enable the dotnet test command for .NET Core projects. Any tests using the new style CSPROJ format, either .NET Core or .NET 4.x, need to add a PackageReference to the NuGet package Microsoft.NET.Test.Sdk. Your test assemblies must also be .NET Core or .NET 4.x, not .NET Standard. You can create a new NUnit test project using dotnet new nunit. It will create an ItemGroup in the csproj file with the necessary references.        .NET Core test can be run on the command line with dotnet test, for example, From the solution root folder dotnet test or from the test project folder dotnet test Or you can specify the csproj file you want to test dotnet test .\\test\\NetCore10Tests\\NetCore10Tests.csproj For a more complete walk-through, please see Testing .NET Core with NUnit in Visual Studio 2017 Using the NUnit project templates The NUnit test project templates come included with dotnet. You can run dotnet new nunit to create an NUnit test project. FAQ Why can't my tests target .NET Standard Visual Studio and VSTest require that the tests target a specific platform. .NET Standard is like a Portable library in that it does not target any specific platform, but can run on any supported platform. Microsoft decided that your tests should be compiled to target a platform so they know which platform to run your tests under and you get the behavior you expect for the platform you are targeting. You can however target multiple platforms in your tests and compile and run each from the command line. It still only runs one platform from Visual Studio, but I would hope that is being worked on. I haven't tested 15.3 yet. It is similar to a console application, it cannot be .NET Standard, it must target a platform, .NET Core or .NET Framework. This limitation is the same for all test adapters including xUnit and MSTest2. My tests aren't showing up in Visual Studio 2017 or later Are you using the NuGet adapter package? Are you using version 4.1.0 or newer of the NuGet package? Do your tests target .NET Core or the full .NET Framework? (see above) Have you added a Package Reference to Microsoft.NET.Test.Sdk? Have you restarted Visual Studio? It is still a bit temperamental. My tests multi-target .NET Core and .NET Framework, why can't I run both in Visual Studio This is a limitation of Visual Studio, hopefully it will be fixed in a future release. Meanwhile, you can run specific tests using the --framework command line option of dotnet test How do I produce a test results file dotnet test can generate an NUnit3 test result file by adding a runsettings property. The property to add is TestOutputXml. This generation is done using the NUnit Engine report service, and produce the same result as the NUnit3-console. This is available through the NUnit3TestAdapter. You run it by adding the setting on the command line (or in a runsettings file): dotnet test -- NUnit.TestOutputXml=yourfoldername The folder is relative to a base folder determined by the OutputXmlFolder settings, or you can use an absolute path. The latter is useful in CI scenarios. Alternatively, there is a 3rd party package, NUnitXml.TestLogger which also produces a NUnit3 xml format. Details for use see here. Note that this is a re-implementation of the NUnit3 format, and may differ."
   },
   "articles/nunit/getting-started/installation.html": {
     "href": "articles/nunit/getting-started/installation.html",
@@ -687,7 +687,7 @@
   "articles/nunit/running-tests/Index.html": {
     "href": "articles/nunit/running-tests/Index.html",
     "title": "Running Tests | NUnit Docs",
-    "keywords": "Running Tests NUnit provides three different runners, which may be used to load and run your tests. The Console Runner, nunit-console.exe, is used for batch execution. The Gui Runner, nunit.exe, provides interactive loading and running of tests. NUnit Agent When running tests in a separate process, the console and gui runners make use of the NUnit Agent program, nunit-agent.exe. Although not directly run by users, nunit-agent does load and execute tests and users need to be aware of it, especially when debugging is involved. Third-Party Runners Various third-party applications are available for loading and running NUnit tests. Some of these actually use NUnit to load the tests, while others provide their own emulation and may not work in the same way that NUnit does. Because the status of such projects may change from time to time, we don't discuss them individually here. For the latest information, consult the manufacturer of any third-party software or ask other users on our discussion list. Additional Information For additional general information on how tests are loaded and run, see Runtime Selection Assembly Isolation Configuration Files Visual Studio Support"
+    "keywords": "Running Tests There are several ways to run your tests, depending on your needs. The most common way is to use one of the common IDEs, such as Visual Studio, Visual Studio Code or Rider, or to use dotnet test from the command line. All of these use different parts of the NUnit ecosystem to run your tests. The Microsoft tools use the NUnit3TestAdapter, whereas Jetbrains Rider use the NUnit.Engine. To start using NUnit with these tools, see the Installation section. Also see the information on the NUnit3TestAdapter for more detailed information on how to use it and configure it. In addition to these NUnit provides two special runners, the NUnit.Console and the NUnitLite runners, which are described below. The Console Runner, nunit-console.exe, is used for batch execution. The NUnitLite runner, nunitlite-runner.exe, is a light weight runner originally used internally in the team, but can be used by anyone who wants to have a simple way of running tests from the command line. Just for fun, to see how the different runners are being used, we can look at the nuget.org download statistics for each of the runners, per Oct 2023: Runner Downloads Comment NUnit3TestAdapter 211.4 million Used by Visual Studio, VS Code and dotnet test NUnit.Console 22.5 million NUnitLite 4.6 million Other runners The VSTest.Console is also a Microsoft runner, but it is less used now as dotnet test has taken over. It does use the NUnit3TestAdapter as well. The Azure Pipelines have some tasks for running tests, like VSTest, which also use the NUnit3TestAdapter under the hood. Some information on the internal working NUnit.Engine All runners except NUnitLite use the NUnit.Engine, including Rider. It should not be used alone, as the different runners have different requirements for how the engine is used and which version is being used. See Compatibility of the Test Adapter with the Test Engine for some more detailed information on this. NUnit Agent When running tests in a separate process, the console and gui runners make use of the NUnit Agent program, nunit-agent.exe. Although not directly run by users, nunit-agent does load and execute tests and users need to be aware of it, especially when debugging is involved. Additional Information For additional general information on how tests are loaded and run, see Runtime Selection Assembly Isolation Configuration Files Visual Studio Support"
   },
   "articles/nunit/running-tests/NUnit-Test-Projects.html": {
     "href": "articles/nunit/running-tests/NUnit-Test-Projects.html",
@@ -707,12 +707,12 @@
   "articles/nunit/running-tests/Template-Based-Test-Naming.html": {
     "href": "articles/nunit/running-tests/Template-Based-Test-Naming.html",
     "title": "Template-Based Test Naming | NUnit Docs",
-    "keywords": "Template-Based Test Naming NUnit uses a standard naming convention for all tests - however, this can be overridden by the user if required. TestName generation is driven by a name formatting string, which may contain any of the following format specifiers: {n} The namespace of the test or empty if there is no namespace. If empty, any immediately following '.' is ignored. {c} The class name of the test or empty if there is no class. This name includes any type arguments, enclosed in angle braces and separated by commas. {C} The full name of the class. Equivalent to {n}.{c} {m} The method name of the test or empty if there is no method. The name includes any type arguments, enclosed in angle braces and separated by commas. {M} The full name of the method. {a} The full argument representation, enclosed in parentheses and separated by commas. Each argument is represented by the standard NUnit format for certain types, otherwise by the result of ToString(). {p} Same as {a} but with a parameter name before each argument in the same style as the named arguments C# language feature. {0}, {1}...{9}. An individual argument. This form is only useful when setting the name of an individual test case. If used in the default format string, any arguments not used will be ignored. {i} The test id, which is normally of the form mmm-nnn. Any text not included between curly braces is copied to the name as is. After the name is formatted, any leading or trailing '.' characters are removed. Otherwise, all non-format characters in the string are included as is. String arguments may be truncated to a maximum length. Either the {a} specifier or any of the individual argument specifiers may be followed by a colon and a length: {a:40} Truncate each string argument to 40 characters. All strings more than 37 characters are truncated to the first 37 followed by \"...\" {0:20} Truncate argument zero to 20 characters. Standard Name Formats Internally, NUnit uses certain standard formats unless overridden by the user. The standard format for generating a name from a test method and its arguments is: {m}{a} // Name This leads to test names like: Test1 Test2(5, 2) Test3(\"This is the argument\") Test4(\"This is quite long argument, so it is...\") Modifying the Name Format The SetName method of TestCaseData allows setting the name of an individual test case. In normal use, the provided string simply becomes the name of the test. However, if one of the template format specifiers is used in the argument to SetName, the name is regenerated using that format. For example, if the user wishes to specify only the argument portion of the name of a test method, while still retaining the method name, the name could be set to {m}(User argument) This would result in the display of the test name as SomeMethod(User Argument) Note that in this usage, it will generally only make sense to use {m}, {a} or {0} through {9} specifiers. However, NUnit will use whatever is provided."
+    "keywords": "Template-Based Test Naming NUnit uses a standard naming convention for all tests, which in the language described below corresponds to {m}{a}. The most used runners, Visual Studio and dotnet depends on this being the default, and trying to change this will cause display issues in these runners. We strongly recommend you to NOT change the test naming. If you still want to do it However, if you're out on your own, the naming can be overridden by the user if required. TestName generation is driven by a name formatting string, which may contain any of the following format specifiers: {n} The namespace of the test or empty if there is no namespace. If empty, any immediately following '.' is ignored. {c} The class name of the test or empty if there is no class. This name includes any type arguments, enclosed in angle braces and separated by commas. {C} The full name of the class. Equivalent to {n}.{c} {m} The method name of the test or empty if there is no method. The name includes any type arguments, enclosed in angle braces and separated by commas. {M} The full name of the method. {a} The full argument representation, enclosed in parentheses and separated by commas. Each argument is represented by the standard NUnit format for certain types, otherwise by the result of ToString(). {p} Same as {a} but with a parameter name before each argument in the same style as the named arguments C# language feature. {0}, {1}...{9}. An individual argument. This form is only useful when setting the name of an individual test case. If used in the default format string, any arguments not used will be ignored. {i} The test id, which is normally of the form mmm-nnn. Any text not included between curly braces is copied to the name as is. After the name is formatted, any leading or trailing '.' characters are removed. Otherwise, all non-format characters in the string are included as is. String arguments may be truncated to a maximum length. Either the {a} specifier or any of the individual argument specifiers may be followed by a colon and a length: {a:40} Truncate each string argument to 40 characters. All strings more than 37 characters are truncated to the first 37 followed by \"...\" {0:20} Truncate argument zero to 20 characters. Standard Name Formats Internally, NUnit uses certain standard formats unless overridden by the user. The standard format for generating a name from a test method and its arguments is: {m}{a} // Name This leads to test names like: Test1 Test2(5, 2) Test3(\"This is the argument\") Test4(\"This is quite long argument, so it is...\") Modifying the Name Format The SetName method of TestCaseData allows setting the name of an individual test case. In normal use, the provided string simply becomes the name of the test. However, if one of the template format specifiers is used in the argument to SetName, the name is regenerated using that format. For example, if the user wishes to specify only the argument portion of the name of a test method, while still retaining the method name, the name could be set to {m}(User argument) This would result in the display of the test name as SomeMethod(User Argument) Note that in this usage, it will generally only make sense to use {m}, {a} or {0} through {9} specifiers. However, NUnit will use whatever is provided."
   },
   "articles/nunit/running-tests/Test-Selection-Language.html": {
     "href": "articles/nunit/running-tests/Test-Selection-Language.html",
     "title": "Test Selection Language | NUnit Docs",
-    "keywords": "Test Selection Language The console command-line allows you to specify a filter, which will select which tests are executed. This is done using the --where option, followed by an expression in NUnit's Test Selection Language (TSL), a simple domain-specific language designed for this purpose. Some of the characters used in the expression, such as space, | or &, may have a special meaning when entered on the command-line. In such a case, you should place the expression in quotation marks. nunit3-console mytest.dll --where \"cat == Urgent || Priority == High\" Note that TSL is handled by the NUnit engine but requires framework support to actually select the tests. The NUnit 3.0 framework supports it fully. See below for support limitations in NUnit V2 tests. Simple Expressions Simple Expressions are essentially comparisons, consisting of a key word or property name on the left-hand side, an operator and some constant value on the right-hand side. Here are some examples: cat == Data test =~ /TestCaseAttributeTest/ method == SomeMethodName cat != Slow Priority == High namespace == My.Name.Space The following key words are recognized on the left-hand side of the comparison: test - The fully qualified test name as assigned by NUnit, e.g. My.Name.Space.TestFixture.TestMethod(5) name - The test name assigned by NUnit, e.g. TestMethod(5) class - The fully qualified name of the class containing the test, e.g. My.Name.Space.TestFixture namespace - The fully qualified name of the namespace containing the test(s), e.g. My.Name.Space method - The name of the method, e.g. TestMethod cat - A category assigned to the test, e.g. SmokeTests If the left-hand side of the comparison does not consist of a key word, it is treated as the name of a property on the test whose value is to be checked. See below for restrictions on use of properties. The following operators are supported == to test for equality - a single equal sign (=) may be used as well and has the same meaning != to test for inequality =~ to match a regular expression !~ to not match a regular expression The right-hand side of the comparison may be a sequence of non-blank, non-special characters or a quoted string. Quoted strings may be surrounded by single quotes ('), double quotes (\") or slashes (/) and may contain any character except the quote character used to delimit them. If it is necessary to include the quote character in the string, it may be escaped using a backslash () as may the backslash itself should you need to include one. The following expressions all do the same thing: test =~ /TestCaseAttributeTest/ test =~ \"TestCaseAttributeTest\" test =~ 'TestCaseAttributeTest' test =~ TestCaseAttributeTest test=~TestCaseAttributeTest For matching regular expressions, NUnit uses .NET's Regex.IsMatch method. For detailed information on the syntax of regular expressions in .NET, see Regular Expressions in .NET. For specifying qualified names, the same format as used for reflection should be used. For example My.Name.Space.TestFixture+NestedFixture can be used to select a nested fixture. For detailed information see: Specifying Special Characters Filtering By Namespace Using the namespace keyword with == will not match on sub-namespaces. For example by using the filter namespace == My.Name.Space, a test My.Name.Space.MyFixture will be selected but a test My.Name.Space.SubNamespace.MyFixture will not, since its namespace is not equal to the namespace provided. In order to inclusively select namespaces, a regular expression can be used. For example to match all namespaces under the root namespace My.Name.Space, the following filter can be used namespace =~ ^My\\.Name\\.Space($|\\.) Filtering Based on Properties Although the syntax will accept any property name - including names that don't actually exist - filtering will only work on existing, string-valued properties. The following properties are created by NUnit and have string values: Author Category Description SetCulture SetUICulture TestOf IgnoreUntilDate In general, these properties were not created with filtering in mind, but you can use them if it suits your needs. Using the Category property currently accomplishes the same thing as the cat keyword. You should be aware that the use of these properties by NUnit is considered an implementation detail and they may change in the future. We envision that most filtering by property will be based on user-defined properties, created for this purpose by inheriting from Property Attribute. When defining a property, you should keep the limitation to string values in mind. For example, a PriorityAttribute taking values of \"High\", \"Medium\" and \"Low\" could be used for filtering, while one that took the integers 1, 2 and 3 could not. Filtering by Test Id In addition to the left-hand-side items listed, NUnit supports filtering by the test id through the id keyword. The id may only be selected using the == operator and is intended only for use by programs that have explored the tests and cached the ids, not for general use by users. The reason for this restriction is that users have no way of predicting the id that will be assigned to a test. The id is not persistent across test runs and its format can differ between different framework drivers. Compound Expressions Simple expressions may be combined using logical and, logical or, parentheses or negation operators. Logical and is expressed as &&, & or and. Logical or is expressed as ||, |, or or. The negation operator is ! and may only appear before a left parenthesis. The letter variants, and and or, are provided for use on the command-line in systems that give & and | a special meaning. The following are valid compound expressions: test == \"My.Namespace\" and cat == Urgent test == \"My.Namespace\" and (cat == Urgent or Priority == High) test == \"My.Namespace\" and (cat == Urgent or Priority == High) method =~ /Source.*Test/ and class =~ \"My.Namespace.ClassName\" Usage on the Command Line Because TSL contains special characters and may contain blank spaces, you will usually want to put the expression in quotes on the command line. Consequently, any strings within the TSL expression will most likely need to use an alternate quote character. For example: nunit-console test.dll --where \"method =~ /Source.*Test/ && class =~ 'My.Namespace.Classname'\" Support in NUnit V2 The driver for NUnit V2 supports a subset of TSL. Because the V2 NUnit framework only allowed filtering on test names and categories, you may only use the cat and test keywords in comparisons. In addition, the regular expression operators =~ and !~ are not supported. If you use any of the unsupported keywords or operators with V2 tests, an error message is displayed and the tests are not run."
+    "keywords": "Test Selection Language The console command-line allows you to specify a filter, which will select which tests are executed. This is done using the --where option, followed by an expression in NUnit's Test Selection Language (TSL), a simple domain-specific language designed for this purpose. The --where option can be used with the dotnet test as -- NUnit.Where (note the space after the --). This will inject this into the runsettings. You can also add the same to a .runsettings file, see Adapter options and this blog post. Some of the characters used in the expression, such as space, | or &, may have a special meaning when entered on the command-line. In such a case, you should place the expression in quotation marks. dotnet test -- NUnit.Where=\"cat == Urgent or Priority == High\" nunit3-console mytest.dll --where \"cat == Urgent || Priority == High\" Simple Expressions Simple Expressions are essentially comparisons, consisting of a key word or property name on the left-hand side, an operator and some constant value on the right-hand side. Here are some examples: cat == Data test =~ /TestCaseAttributeTest/ method == SomeMethodName cat != Slow Priority == High namespace == My.Name.Space The following key words are recognized on the left-hand side of the comparison: test - The fully qualified test name as assigned by NUnit, e.g. My.Name.Space.TestFixture.TestMethod(5) name - The test name assigned by NUnit, e.g. TestMethod(5) class - The fully qualified name of the class containing the test, e.g. My.Name.Space.TestFixture namespace - The fully qualified name of the namespace containing the test(s), e.g. My.Name.Space method - The name of the method, e.g. TestMethod cat - A category assigned to the test, e.g. SmokeTests If the left-hand side of the comparison does not consist of a key word, it is treated as the name of a property on the test whose value is to be checked. See below for restrictions on use of properties. The following operators are supported == to test for equality - a single equal sign (=) may be used as well and has the same meaning != to test for inequality =~ to match a regular expression !~ to not match a regular expression The right-hand side of the comparison may be a sequence of non-blank, non-special characters or a quoted string. Quoted strings may be surrounded by single quotes ('), double quotes (\") or slashes (/) and may contain any character except the quote character used to delimit them. If it is necessary to include the quote character in the string, it may be escaped using a backslash () as may the backslash itself should you need to include one. The following expressions all do the same thing: test =~ /TestCaseAttributeTest/ test =~ \"TestCaseAttributeTest\" test =~ 'TestCaseAttributeTest' test =~ TestCaseAttributeTest test=~TestCaseAttributeTest For matching regular expressions, NUnit uses .NET's Regex.IsMatch method. For detailed information on the syntax of regular expressions in .NET, see Regular Expressions in .NET. For specifying qualified names, the same format as used for reflection should be used. For example My.Name.Space.TestFixture+NestedFixture can be used to select a nested fixture. For detailed information see: Specifying Special Characters Filtering By Namespace Using the namespace keyword with == will not match on sub-namespaces. For example by using the filter namespace == My.Name.Space, a test My.Name.Space.MyFixture will be selected but a test My.Name.Space.SubNamespace.MyFixture will not, since its namespace is not equal to the namespace provided. In order to inclusively select namespaces, a regular expression can be used. For example to match all namespaces under the root namespace My.Name.Space, the following filter can be used namespace =~ ^My\\.Name\\.Space($|\\.) Filtering Based on Properties Although the syntax will accept any property name - including names that don't actually exist - filtering will only work on existing, string-valued properties. The following properties are created by NUnit and have string values: Author Category Description SetCulture SetUICulture TestOf IgnoreUntilDate In general, these properties were not created with filtering in mind, but you can use them if it suits your needs. Using the Category property currently accomplishes the same thing as the cat keyword. You should be aware that the use of these properties by NUnit is considered an implementation detail and they may change in the future. We envision that most filtering by property will be based on user-defined properties, created for this purpose by inheriting from Property Attribute. When defining a property, you should keep the limitation to string values in mind. For example, a PriorityAttribute taking values of \"High\", \"Medium\" and \"Low\" could be used for filtering, while one that took the integers 1, 2 and 3 could not. Filtering by Test Id In addition to the left-hand-side items listed, NUnit supports filtering by the test id through the id keyword. The id may only be selected using the == operator and is intended only for use by programs that have explored the tests and cached the ids, not for general use by users. The reason for this restriction is that users have no way of predicting the id that will be assigned to a test. The id is not persistent across test runs and its format can differ between different framework drivers. Compound Expressions Simple expressions may be combined using logical and, logical or, parentheses or negation operators. Logical and is expressed as &&, & or and. Logical or is expressed as ||, |, or or. The negation operator is ! and may only appear before a left parenthesis. The letter variants, and and or, are provided for use on the command-line in systems that give & and | a special meaning. The following are valid compound expressions: test == \"My.Namespace\" and cat == Urgent test == \"My.Namespace\" and (cat == Urgent or Priority == High) test == \"My.Namespace\" and (cat == Urgent or Priority == High) method =~ /Source.*Test/ and class =~ \"My.Namespace.ClassName\" Usage on the Command Line Because TSL contains special characters and may contain blank spaces, you will usually want to put the expression in quotes on the command line. Consequently, any strings within the TSL expression will most likely need to use an alternate quote character. For example: nunit-console test.dll --where \"method =~ /Source.*Test/ && class =~ 'My.Namespace.Classname'\" Support in NUnit V2 The driver for NUnit V2 supports a subset of TSL. Because the V2 NUnit framework only allowed filtering on test names and categories, you may only use the cat and test keywords in comparisons. In addition, the regular expression operators =~ and !~ are not supported. If you use any of the unsupported keywords or operators with V2 tests, an error message is displayed and the tests are not run."
   },
   "articles/nunit/technical-notes/nunit-internals/Active-Attributes.html": {
     "href": "articles/nunit/technical-notes/nunit-internals/Active-Attributes.html",
@@ -1667,7 +1667,7 @@
   "articles/vs-test-adapter/Adapter-Installation.html": {
     "href": "articles/vs-test-adapter/Adapter-Installation.html",
     "title": "Adapter Installation | NUnit Docs",
-    "keywords": "Adapter Installation You'll need to install the adapter as a NuGet package for each of your test projects. Installing the NuGet Package You will most likely want to add a new NUnit Test Project to your solution. The easiest way is to use the dotnet command on the command line. Go to your project root and where you want to add your project. Create a folder for the project with a name matching what your new test project should be named. Then run the command dotnet new nunit. You will now get a complete nunit test project with the same name as the folder. You will also have a template unit test class there as a starter. If you have a Visual Studio solution file in the root folder, you can go there and add the new nunit csproj easily: Assume you are at a solution root, and you either have a solution file, or have just been adding it with dotnet new sln. md Whatever.Test cd Whatever.Test dotnet new nunit cd .. dotnet sln add Whatever.Test\\Whatever.Test.csproj And you're ready to go ! Manually Adding the Adapter as a Package Reference to Your Test Projects When adding packages manually, we recommended installing the framework, the adapter, and the analyzer for optimal out-of-the-box functionality. The adapter and the framework are required. The analyzer will help during development, but is not strictly required to make your project work. coverlet.collector is the recommended code coverage package you should go for. You should ensure you also reference Microsoft.NET.Test.Sdk as well; it is required for test discoverability. Open your test project csproj file Add the necessary package references as shown in the snippet example below (NOTE: these are the current versions at time of writing; you'll want to install the latest versions.)        Note: You don't need to add any nunit.console or any other runner package Working with the Visual Studio Nuget manager If you have a legacy project type, or prefer working outside of the command line, you can also use the Visual Studio 'Manage NuGet packages in the solution' menu option. It can also be used for the new SDK projects, but you may find it faster to open the csproj and copy/paste the references in. With an active solution in Visual Studio, follow these steps: From the Tools menu, use Library Package Manager and select Manage NuGet packages for solution In the left panel, select Online Locate (search for) NUnit3Test Adapter in the center panel and highlight it Click Install In the Select Projects dialog, select all test projects in your solution."
+    "keywords": "Adapter Installation You'll need to install the adapter as a NuGet package for each of your test projects. Installing the NuGet Package You will most likely want to add a new NUnit Test Project to your solution. The easiest way is to use the dotnet command on the command line. Go to your project root and where you want to add your project. Create a folder for the project with a name matching what your new test project should be named. Then run the command dotnet new nunit. You will now get a complete nunit test project with the same name as the folder. You will also have a template unit test class there as a starter. If you have a Visual Studio solution file in the root folder, you can go there and add the new nunit csproj easily: Assume you are at a solution root, and you either have a solution file, or have just been adding it with dotnet new sln. md Whatever.Test cd Whatever.Test dotnet new nunit cd .. dotnet sln add Whatever.Test\\Whatever.Test.csproj And you're ready to go ! Manually Adding the Adapter as a Package Reference to Your Test Projects When adding packages manually, we recommended installing the framework, the adapter, and the analyzer for optimal out-of-the-box functionality. The adapter and the framework are required. The analyzer will help during development, but is not strictly required to make your project work. coverlet.collector is the recommended code coverage package you should go for. You should ensure you also reference Microsoft.NET.Test.Sdk as well; it is required for test discoverability. Open your test project csproj file Add the necessary package references as shown in the snippet example below (NOTE: these are the current versions at time of writing; you'll want to install the latest versions.)        Note: You don't need to, nor should you, add any nunit.console or any other runner package Working with the Visual Studio Nuget manager If you have a legacy project type, or prefer working outside of the command line, you can also use the Visual Studio 'Manage NuGet packages in the solution' menu option. It can also be used for the new SDK projects, but you may find it faster to open the csproj and copy/paste the references in. With an active solution in Visual Studio, follow these steps: From the Tools menu, use Library Package Manager and select Manage NuGet packages for solution In the left panel, select Online Locate (search for) NUnit3Test Adapter in the center panel and highlight it Click Install In the Select Projects dialog, select all test projects in your solution."
   },
   "articles/vs-test-adapter/Adapter-License.html": {
     "href": "articles/vs-test-adapter/Adapter-License.html",
diff --git a/sitemap.xml b/sitemap.xml
index 6fabe0e58..7e409a9b4 100644
--- a/sitemap.xml
+++ b/sitemap.xml
@@ -2,2131 +2,2131 @@
 
   
     http://docs.nunit.org/404.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/developer-info/Best-practices-for-XML-documentation.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/developer-info/Coding-Standards.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/developer-info/Contributions.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/developer-info/Issue-Tracking.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/developer-info/Notes-Toward-NUnit-4.0.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/developer-info/Packaging-Extensions.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/developer-info/Packaging-the-Console-and-Engine.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/developer-info/Packaging-the-Framework.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/developer-info/Packaging-the-Installer.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/developer-info/Packaging-the-V2-Adapter.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/developer-info/Packaging-the-V3-and-V4-Adapter.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/developer-info/Team-Practices.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/developer-info/The-Teams.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit-Analyzers.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit1001.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit1002.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit1003.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit1004.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit1005.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit1006.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit1007.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit1008.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit1009.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit1010.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit1011.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit1012.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit1013.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit1014.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit1015.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit1016.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit1017.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit1018.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit1019.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit1020.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit1021.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit1022.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit1023.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit1024.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit1025.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit1026.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit1027.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit1028.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit1029.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit1030.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit1031.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit1032.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2001.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2002.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2003.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2004.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2005.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2006.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2007.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2008.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2009.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2010.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2011.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2012.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2013.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2014.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2015.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2016.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2017.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2018.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2019.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2020.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2021.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2022.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2023.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2024.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2025.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2026.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2027.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2028.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2029.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2030.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2031.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2032.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2033.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2034.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2035.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2036.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2037.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2038.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2039.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2040.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2041.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2042.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2043.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2044.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2045.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2046.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit2047.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit3001.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit3002.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit3003.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-analyzers/NUnit3004.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-engine/Getting-Started.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-engine/Index.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-engine/Test-Engine-API.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-engine/extensions/AvailableExtensions.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-engine/extensions/Index.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-engine/extensions/Installing-Extensions.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-engine/extensions/creating-extensions/Event-Listeners.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-engine/extensions/creating-extensions/Framework-Drivers.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-engine/extensions/creating-extensions/Index.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-engine/extensions/creating-extensions/Project-Loaders.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-engine/extensions/creating-extensions/Result-Writers.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-engine/extensions/creating-extensions/Writing-Engine-Extensions.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit-engine/release-notes.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/Towards-NUnit4.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/extending-nunit/Action-Attributes.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/extending-nunit/Custom-Attributes.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/extending-nunit/Custom-Constraints.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/extending-nunit/Framework-Extensibility.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/extending-nunit/IApplyToContext-Interface.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/extending-nunit/IApplyToTest-Interface.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/extending-nunit/ICommandWrapper-Interface.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/extending-nunit/IFixtureBuilder-Interface.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/extending-nunit/IImplyFixture-Interface.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/extending-nunit/IParameterDataSource-Interface.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/extending-nunit/ISimpleTestBuilder-Interface.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/extending-nunit/ITestBuilder-Interface.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/extending-nunit/Index.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/getting-started/dotnet-core-and-dotnet-standard.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/getting-started/installation.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/getting-started/samples.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/getting-started/upgrading.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/intro.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/license.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/release-notes/Pre-3.5-Release-Notes.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/release-notes/breaking-changes.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/release-notes/framework.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/running-tests/Console-Command-Line.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/running-tests/Console-Runner.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/running-tests/Index.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/running-tests/NUnit-Test-Projects.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/running-tests/NUnitLite-Options.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/running-tests/NUnitLite-Runner.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/running-tests/Template-Based-Test-Naming.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/running-tests/Test-Selection-Language.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/technical-notes/nunit-internals/Active-Attributes.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/technical-notes/nunit-internals/Architectural-Overview.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/technical-notes/nunit-internals/Attribute-Hierarchy.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/technical-notes/nunit-internals/Framework-Api.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/technical-notes/nunit-internals/Framework-Design.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/technical-notes/nunit-internals/NUnit-3.0-Architecture-(2009).html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/technical-notes/nunit-internals/NUnit-APIs.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/technical-notes/nunit-internals/NUnit-Internals.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/technical-notes/nunit-internals/Test-Discovery-And-Execution.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/technical-notes/nunit-internals/specs/Dynamic-Test-Cases-Spec.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/technical-notes/nunit-internals/specs/Engine-Addins-Spec.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/technical-notes/nunit-internals/specs/Extended-Constraint-Syntax-Spec.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/technical-notes/nunit-internals/specs/Include%20and%20Exclude%20Attributes%20(Alternatives).html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/technical-notes/nunit-internals/specs/Include-and-Exclude-Attributes-Spec.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/technical-notes/nunit-internals/specs/Internal-Trace-Spec.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/technical-notes/nunit-internals/specs/Parameterized-Test-Fixtures-Spec.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/technical-notes/nunit-internals/specs/Specifications.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/technical-notes/nunit-internals/specs/Test-Dependency-Attribute-Spec.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/technical-notes/usage/Addin-Replacement-in-the-Framework.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/technical-notes/usage/Assembly-Isolation.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/technical-notes/usage/Configuration-Files.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/technical-notes/usage/Counting-Tests.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/technical-notes/usage/Engine-Parallel-Test-Execution.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/technical-notes/usage/Framework-Parallel-Test-Execution.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/technical-notes/usage/NUnit-Project-XML-Format.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/technical-notes/usage/Parameterized-Tests.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/technical-notes/usage/Platform-Selection.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/technical-notes/usage/Runtime-Selection.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/technical-notes/usage/SetUp-and-TearDown.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/technical-notes/usage/Test-Filters.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/technical-notes/usage/Test-Result-XML-Format.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/technical-notes/usage/Usage-Notes.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/technical-notes/usage/Visual-Studio-Support.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/technical-notes/usage/XML-Formats.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/AssertionHelper.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/Assumptions.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/ListMapper.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/Randomizer-Methods.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/TestCaseData.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/TestContext.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/TestFixtureData.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/Warnings.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/assertion-models/classic.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/assertion-models/constraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/assertions.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Assert.AreEqual.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Assert.AreNotEqual.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Assert.AreNotSame.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Assert.AreSame.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Assert.Catch.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Assert.CatchAsync.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Assert.Contains.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Assert.DoesNotThrow.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Assert.DoesNotThrowAsync.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Assert.Fail.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Assert.False.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Assert.Greater.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Assert.GreaterOrEqual.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Assert.Ignore.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Assert.Inconclusive.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Assert.IsAssignableFrom.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Assert.IsEmpty.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Assert.IsInstanceOf.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Assert.IsNaN.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Assert.IsNotAssignableFrom.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Assert.IsNotEmpty.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Assert.IsNotInstanceOf.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Assert.Less.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Assert.LessOrEqual.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Assert.Negative.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Assert.NotNull.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Assert.NotZero.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Assert.Null.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Assert.Pass.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Assert.Positive.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Assert.Throws.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Assert.ThrowsAsync.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Assert.True.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Assert.Zero.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Collection-Assert.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Directory-Assert.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/File-Assert.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/String-Assert.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/assertions/multiple-asserts.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/apartment.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/author.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/category.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/combinatorial.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/culture.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/datapoint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/datapointsource.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/defaultfloatingpointtolerance.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/description.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/explicit.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/fixturelifecycle.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/ignore.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/levelofparallelism.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/maxtime.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/nonparallelizable.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/nontestassembly.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/onetimesetup.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/onetimeteardown.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/order.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/pairwise.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/parallelizable.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/platform.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/property.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/random.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/range.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/repeat.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/requiresthread.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/retry.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/sequential.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/setculture.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/setuiculture.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/setup.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/setupfixture.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/singlethreaded.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/teardown.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/test.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/testcase.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/testcasesource.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/testfixture.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/testfixturesetup.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/testfixturesource.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/testfixtureteardown.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/testof.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/theory.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/timeout.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/values.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/attributes/valuesource.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/AllItemsConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/AndConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/AnyOfConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/AssignableFromConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/AssignableToConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/AttributeConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/AttributeExistsConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/BinarySerializableConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/CollectionContainsConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/CollectionEquivalentConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/CollectionOrderedConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/CollectionSubsetConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/CollectionSupersetConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/Constraints.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/DelayedConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/DictionaryContainsKeyConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/DictionaryContainsKeyValuePairConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/DictionaryContainsValueConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/EmptyCollectionConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/EmptyConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/EmptyDirectoryConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/EmptyStringConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/EndsWithConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/EqualConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/ExactCountConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/ExactTypeConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/FalseConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/FileOrDirectoryExistsConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/GreaterThanConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/GreaterThanOrEqualConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/InstanceOfTypeConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/LessThanConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/LessThanOrEqualConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/NaNConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/NoItemConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/NotConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/NullConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/OrConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/PropertyConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/PropertyExistsConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/RangeConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/RegexConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/ReusableConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/SameAsConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/SamePathConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/SamePathOrUnderConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/SomeItemsConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/StartsWithConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/SubPathConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/SubstringConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/ThrowsConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/ThrowsNothingConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/TrueConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/UniqueItemsConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/constraints/XmlSerializableConstraint.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/setup-teardown/SetUp-and-TearDown-Changes.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/nunit/writing-tests/setup-teardown/index.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/vs-test-adapter/Adapter-Engine-Compatibility.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/vs-test-adapter/Adapter-Installation.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/vs-test-adapter/Adapter-License.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/vs-test-adapter/Adapter-Source-Stepping.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/vs-test-adapter/AdapterV2-Release-Notes.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/vs-test-adapter/AdapterV3-Release-Notes.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/vs-test-adapter/AdapterV4-Release-Notes.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/vs-test-adapter/Debugging.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/vs-test-adapter/Index.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/vs-test-adapter/Known-Problems.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/vs-test-adapter/Resources.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/vs-test-adapter/Supported-Frameworks.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/vs-test-adapter/Tips-And-Tricks.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/vs-test-adapter/Trace-and-Debug.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/vs-test-adapter/Usage.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/vs-test-generator/TestGenerator-Installation.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/vs-test-generator/TestGenerator-Release-Notes-VS2015.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/vs-test-generator/TestGenerator-Release-Notes-VS2017-VS2019.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/vs-test-generator/TestGenerator-Release-Notes.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/vs-test-generator/Visual-Studio-Test-Generator.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/xamarin-runners/Getting-Started-in-Visual-Studio-for-Mac.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/xamarin-runners/Getting-Started-in-Visual-Studio.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/articles/xamarin-runners/index.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5
   
   
     http://docs.nunit.org/index.html
-    2023-10-04T03:31:48+00:00
+    2023-10-06T07:53:07+00:00
     daily
     0.5