NUnit

https://docs.nunit.org/
Admin
NUnit is an open-source unit testing framework for .NET applications that uses custom attributes and...
Tokens:1,463,794
Snippets:12,036
Trust Score:10
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### SetUp and Test example

Source: https://docs.nunit.org/articles/nunit/writing-tests/attributes/setup.html

Example of a SetUp method initializing a field and a test method using it. The SetUp method runs before each test, resetting the counter to zero.

```csharp
[SetUp]
public void Init()
{
    _counter = 0;
}

[Test]
public void TestMethod()
{
    _counter++;
    Assert.That(_counter, Is.EqualTo(1));
}

```

--------------------------------

### SetUp and TearDown inheritance example

Source: https://docs.nunit.org/articles/nunit/technical-notes/usage/SetUp-and-TearDown.html

Shows a base class with [SetUp] and [TearDown] methods and a derived test fixture with its own [SetUp], [TearDown], and a [Test] method. When the base setup throws an exception, only the base setup and base teardown run, not the derived teardown.

```csharp
public class BaseClass
{
   [SetUp]
   public void BaseSetUp() { /* ... */ } // Exception thrown!

   [TearDown]
   public void BaseTearDown() { /* ... */ }
}

[TestFixture]
public class DerivedClass : BaseClass
{
   [SetUp]
   public void DerivedSetUp() { /* ... */ }

   [TearDown]
   public void DerivedTearDown() { /* ... */ }

   [Test]
   public void TestMethod() { /* ... */ }
}
```

--------------------------------

### OneTimeSetUp initialization example

Source: https://docs.nunit.org/articles/nunit/writing-tests/attributes/onetimesetup.html

Example of a OneTimeSetUp method initializing a shared field and a test that uses it. The setup runs once before all tests in the fixture.

```csharp
[OneTimeSetUp]
public void Init()
{
    _sharedValue = 42;
}

[Test]
public void UsesInitializedState()
{
    Assert.That(_sharedValue, Is.EqualTo(42));
}

```

--------------------------------

### SetUp Attribute

Source: https://docs.nunit.org/articles/nunit/writing-tests/attributes/setup.html

Documentation for the NUnit SetUpAttribute, including its syntax, behavior, inheritance rules, and usage example.

```APIDOC
## [SetUp] Attribute

### Description
Marks a method that NUnit calls immediately before each test method in the fixture. Use it to reset or prepare per-test instance state.

### Syntax
```csharp
[SetUp]
public void MethodName() { }
```

### Parameters
None. The attribute is parameterless.

### Applies To
- Lifecycle Methods: ✅
- Test Methods: ❌
- Test Fixtures (Classes): ❌
- Assembly: ❌

### Behavior
- Called before each `[Test]`, `[TestCase]`, `[Theory]`, etc.
- May be static or instance method.
- May be async (`Task` / `Task<T>`).
- If the method throws or an assertion fails, the test body is not run; the result is a setup failure.
- `TearDown` still runs after a setup failure unless the run is aborted.
- If `Assume.That(...)` fails in `SetUp`, the test body is not run.

### Inheritance
- The attribute is inherited from base classes.
- Base class `SetUp` methods run before derived class `SetUp` methods.
- If a base class `SetUp` method is overridden in the derived class, NUnit will not call the base class method.

### Notes
- `SetUp` runs in per-test context; most `TestContext` APIs reflect the about-to-run test.
- Multiple `SetUp` methods on the same class have no guaranteed relative order.
- Base-class `SetUp` runs before derived-class `SetUp`.

### Example
```csharp
[SetUp]
public void Init()
{
    _counter = 0;
}

[Test]
public void TestMethod()
{
    _counter++;
    Assert.That(_counter, Is.EqualTo(1));
}
```
```

--------------------------------

### Addin example: MyAddin implementing IAddin

Source: https://docs.nunit.org/articles/nunit/technical-notes/nunit-internals/specs/Engine-Addins-Spec.html

Shows an Addin class that installs an extension point for the driver factory. The factory class lacks an ExtensionAttribute to avoid double installation. This approach is for complex scenarios where simple extensions are insufficient.

```csharp
[Addin]
public class MyAddin : IAddin
{
    public bool Install(IExtensionHost host)
    {
        var ep = host.GetExtensionPoint("/NUnit/Engine/DriverFactory");
        ep.Install(new NUnit2DriverFactory());
    }
}

public class NUnit2DriverFactory : IDriverFactory
{
    /* ... */
}

```

--------------------------------

### Measure Time for Setup with TimeMeasurementHook

Source: https://docs.nunit.org/articles/nunit/extending-nunit/Execution-Hooks.html

Measures the duration of each setup method by recording a start time in BeforeEverySetUpHook and computing the elapsed time in AfterEverySetUpHook. The usage example shows applying the [TimeMeasurementHook] attribute to a test fixture.

```csharp
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Class)]
public sealed class TimeMeasurementHookAttribute : ExecutionHookAttribute
{
    private readonly Dictionary<string, DateTime> _starts = new();

    public override void BeforeEverySetUpHook(HookData hookData)
    {
        _starts[hookData.Context.Test.FullName] = DateTime.UtcNow;
    }

    public override void AfterEverySetUpHook(HookData hookData)
    {
        var key = hookData.Context.Test.FullName;
        if (_starts.TryGetValue(key, out var start))
        {
            var elapsed = DateTime.UtcNow - start;
            TestContext.Progress.WriteLine($"[Timing] " +
                $"{hookData.Context.Test.MethodName} " +
                $"took {elapsed.TotalMilliseconds:F1} ms");
        }
    }
}

```

```csharp
[TestFixture]
[TimeMeasurementHook]
public class SampleTests
{
    [SetUp]
    public void HeavySetUp() { /* ... */ }

    [Test]
    public void FastTest() { /* ... */ }
}

```

--------------------------------

### StartsWithConstraint Examples

Source: https://docs.nunit.org/articles/nunit/writing-tests/constraints/StartsWithConstraint.html

Example test method demonstrating StartsWithConstraint with default, IgnoreCase, and Not variants.

```csharp
[Test]
public void StartsWithConstraint_Examples()
{
    string phrase = "Make your tests fail before passing!";

    Assert.That(phrase, Does.StartWith("Make"));
    Assert.That(phrase, Does.StartWith("MAKE").IgnoreCase);
    Assert.That(phrase, Does.Not.StartWith("Break"));
}

```

--------------------------------

### Use TestContext.ActiveTests to conditionally start a database in a SetUpFixture

Source: https://docs.nunit.org/articles/nunit/writing-tests/TestContext.html

Use TestContext.CurrentContext.ActiveTests in a SetUpFixture's OneTimeSetUp to conditionally start expensive resources (like a database) only when at least one active test requires them. ActiveTests is available only in OneTimeSetUp and OneTimeTearDown; it returns null elsewhere. The example also shows a OneTimeTearDown that stops the resource if it was started.

```csharp
[SetUpFixture]
public class DatabaseSetUp
{
    private bool _databaseStarted;

    [OneTimeSetUp]
    public void StartDatabaseIfNeeded()
    {
        // ActiveTests lists the test cases under this namespace that passed the filter
        var activeTests = TestContext.CurrentContext.ActiveTests ?? [];

        // Only do the expensive setup if at least one active test needs it
        if (activeTests.Any(test => test.Properties["Category"].Contains("Database")))
        {
            _databaseStarted = true; // Start the database here
        }
    }

    [OneTimeTearDown]
    public void StopDatabase()
    {
        if (_databaseStarted)
        {
            _databaseStarted = false; // Stop the database here
        }
    }
}

[TestFixture]
public class CustomerTests
{
    [Test, Category("Database")]
    public void CanSaveCustomer() => Assert.Pass();

    [Test]
    public void CanFormatCustomerName() => Assert.Pass();
}
```

--------------------------------

### Set and retrieve single-valued properties with IPropertyBag

Source: https://docs.nunit.org/api/NUnit.Framework.Interfaces.IPropertyBag.html

Shows how to set a single value for a key using the Set method, which replaces any existing values, and retrieve it with Get or GetSetting. The example demonstrates that Set replaces the previous value and that GetSetting returns the value or a default if not found.

```csharp
bag.Set("Priority", "low");
bag.Set("Priority", "high"); // replaces value
Assert.That(bag.Get("Priority"),
  Is.EqualTo("high"));
Assert.That(bag.GetSetting("Priority", "low"),
  Is.EqualTo("high"));

```

--------------------------------

### NUnit 3.0 Setup and Teardown Inheritance Example

Source: https://docs.nunit.org/articles/nunit/writing-tests/setup-teardown/SetUp-and-TearDown-Changes.html

Illustrates the inheritance behavior of setup and teardown methods in NUnit 3.0. When an exception is thrown in BaseSetUp, only BaseTearDown is called, not DerivedTearDown, because teardown methods are only invoked if a setup method at the same level was called.

```csharp
public class BaseClass
{
   [SetUp]
   public void BaseSetUp() { /* ... */ } // Exception thrown!

   [TearDown]
   public void BaseTearDown() { /* ... */ }
}

[TestFixture]
public class DerivedClass : BaseClass
{
   [SetUp]
   public void DerivedSetUp() { /* ... */ }

   [TearDown]
   public void DerivedTearDown() { /* ... */ }

   [Test]
   public void TestMethod() { /* ... */ }
}

```

--------------------------------

### Named Parameter Syntax Example

Source: https://docs.nunit.org/articles/nunit/writing-tests/attributes/description.html

Example using named parameter syntax on both [TestFixture] and [Test] attributes to set descriptions.

```csharp
[TestFixture(Description = "Integration tests for the user registration flow")]
public class UserRegistrationTests
{
    [Test(Description = "Tests complete registration with all required fields")]
    public void Register_AllFieldsValid_CreatesUser()
    {
        Assert.Pass();
    }
}

```

--------------------------------

### AfterEverySetUpHook(HookData)

Source: https://docs.nunit.org/api/NUnit.Framework.ExecutionHookMethodsAttribute.html

Method that is called immediately after every [SetUp] or [OneTimeSetUp] method is executed. Override this to implement custom logic to run after the setup.

```APIDOC
## AfterEverySetUpHook(HookData)

### Description
Method that is called immediately after every [SetUp] or [OneTimeSetUp] method is executed. Override this to implement custom logic to run after the setup.

### Declaration
```csharp
public virtual void AfterEverySetUpHook(HookData hookData)
```

### Parameters
- **hookData** (HookData) - The current NUnit.Framework.Internal.ExecutionHooks.HookData for the test.
```

--------------------------------

### AndConstraint examples

Source: https://docs.nunit.org/articles/nunit/writing-tests/constraints/AndConstraint.html

Demonstrates combining constraints with And for numeric, string, nullable, and collection assertions. Includes a null-check pattern and an example mixing And with Or.

```csharp
[Test]
public void AndConstraint_Examples()
{
    int value = 42;

    // Both conditions must be true
    Assert.That(value, Is.GreaterThan(0).And.LessThan(100));
    Assert.That(value, Is.Positive.And.LessThanOrEqualTo(50).Or.GreaterThanOrEqualTo(40));

    // String constraints
    Assert.That("Hello World", Does.StartWith("Hello").And.EndWith("World"));
    Assert.That("test@example.com", Does.Contain("@").And.EndWith(".com"));

    // Null checking pattern (check null first!)
    int? nullable = 42;
    Assert.That(nullable, Is.Not.Null.And.GreaterThan(0));

    // Collection constraints
    Assert.That(new[] { 1, 2, 3 }, Is.Not.Empty.And.All.Positive);
}

```

--------------------------------

### PropertyConstraint Examples

Source: https://docs.nunit.org/articles/nunit/writing-tests/constraints/PropertyConstraint.html

Complete example showing how to test property values with Has.Property and its shortcuts, including exception properties and custom object properties.

```csharp
public class Person
{
    public string Name { get; set; } = "";
    public int Age { get; set; }
}

[Test]
public void PropertyConstraint_Examples()
{
    // Test property values
    Assert.That("Hello", Has.Property("Length").EqualTo(5));
    Assert.That(new int[] { 1, 2, 3 }, Has.Property("Length").EqualTo(3));

    // Common properties have shortcuts
    Assert.That("Hello", Has.Length.EqualTo(5));
    Assert.That(new List<int> { 1, 2, 3 }, Has.Count.EqualTo(3));

    // Exception properties
    var ex = new InvalidOperationException("Test error", new ArgumentException());
    Assert.That(ex, Has.Message.EqualTo("Test error"));
    Assert.That(ex, Has.InnerException.InstanceOf<ArgumentException>());

    // Custom object properties
    var person = new Person { Name = "Alice", Age = 30 };
    Assert.That(person, Has.Property("Name").EqualTo("Alice"));
    Assert.That(person, Has.Property("Age").GreaterThan(18));
}
```

--------------------------------

### NoItemConstraint Examples

Source: https://docs.nunit.org/articles/nunit/writing-tests/constraints/NoItemConstraint.html

Example test method demonstrating various uses of Has.None with arrays, including property-based constraints and multiple conditions.

```csharp
[Test]
public void NoItemConstraint_Examples()
{
    int[] numbers = { 1, 2, 3, 4, 5 };
    string[] names = { "Alice", "Bob", "Carol" };

    // No items should satisfy the constraint
    Assert.That(numbers, Has.None.LessThan(0));         // No negatives
    Assert.That(numbers, Has.None.GreaterThan(100));    // None > 100
    Assert.That(names, Has.None.Null);                  // No nulls
    Assert.That(names, Has.None.Empty);                 // No empty strings
    Assert.That(names, Has.None.EqualTo("Dave"));       // "Dave" not in list

    // Property-based constraints
    Assert.That(names, Has.None.Length.GreaterThan(10)); // No name > 10 chars

    // Multiple conditions
    Assert.That(numbers, Has.None.LessThanOrEqualTo(0));
}

```

--------------------------------

### Example: Fixed code with method call

Source: https://docs.nunit.org/articles/nunit-analyzers/NUnit2057.html

Shows the corrected version of the previous example, where the method is called and its return value is passed.

```csharp
Assert.That(instance.Method2(), Is.EqualTo(expected));
```

--------------------------------

### SetUpFixture class with OneTimeSetUp and OneTimeTearDown methods

Source: https://docs.nunit.org/articles/nunit/writing-tests/attributes/setupfixture.html

Example of a SetUpFixture class. The OneTimeSetUp method runs before any tests in the namespace, and the OneTimeTearDown method runs after all tests and teardowns complete. The class must be public and have a default constructor.

```csharp
[SetUpFixture]
public class MySetUpClass
{
    [OneTimeSetUp]
    public void RunBeforeAnyTests()
    {
    }

    [OneTimeTearDown]
    public void RunAfterAnyTests()
    {
    }
}

```

--------------------------------

### RandomAttribute Random GUIDs Example

Source: https://docs.nunit.org/articles/nunit/writing-tests/attributes/random.html

Demonstrates generating random Guid values using the count-only constructor. Guid does not support min/max ranges. Guid support was added in NUnit 4.0.

```csharp
[TestFixture]
public class RandomGuidTests
{
    [Test]
    public void TestWithRandomGuid([Random(3)] Guid value)
    {
        // Generates 3 random GUIDs
        // Note: Guid does not support min/max range
        Assert.That(value, Is.Not.EqualTo(Guid.Empty));
    }
}
```

--------------------------------

### Build and test release version

Source: https://docs.nunit.org/articles/developer-info/Packaging-the-V3-and-V4-Adapter.html

Use the build command to build and test a release version. Run from the solution root folder.

```text
build -t Test
build -t Acceptance

```

--------------------------------

### StartTime

Source: https://docs.nunit.org/api/NUnitLite.ResultSummary.html

Property that gets the time the test started running.

```APIDOC
## StartTime

### Description
Gets or sets the time the test started running.

### Property
`public DateTime StartTime { get; }`

### Property Value
- **DateTime** - The time the test started.
```

--------------------------------

### Create packages

Source: https://docs.nunit.org/articles/developer-info/Packaging-the-V3-and-V4-Adapter.html

Use the build command to create packages. Run from the solution root folder. The resulting files can be found in the "package" folder.

```text
build -t Package

```

--------------------------------

### ITestResult.StartTime

Source: https://docs.nunit.org/api/NUnit.Framework.Interfaces.ITestResult.html

Gets or sets the time the test started running.

```APIDOC
## Property: StartTime

### Description
Gets or sets the time the test started running.

### Declaration
```csharp
DateTime StartTime { get; }
```

### Property Value
| Type     | Description |
|----------|-------------|
| DateTime |             |
```

--------------------------------

### Example .addins file

Source: https://docs.nunit.org/articles/nunit-engine/extensions/Installing-Extensions.html

Example .addins file showing comment lines, wildcard entries, relative paths, and an absolute directory entry. Relative paths are resolved from the .addins file location; absolute paths are allowed but discouraged.

```text
# This line is a comment and is ignored. The next (blank) line is ignored as well.

*.dll                   # include all dlls in the same directory
addins/*.dll            # include all dlls in the addins directory too
special/myassembly.dll  # include a specific dll in a special directory
/some/other/directory/  # process another directory, which may contain its own addins file
                        # note that an absolute path is allowed, but is probably not a good idea
                        # in most cases

```

--------------------------------

### RegexConstraint Common Pattern Examples

Source: https://docs.nunit.org/articles/nunit/writing-tests/constraints/RegexConstraint.html

Example test method showing common regular expression patterns for email, phone number, digit start, letters and spaces, and ISO date validation.

```csharp
[Test]
public void RegexConstraint_Pattern_Examples()
{
    // Email validation (simplified)
    Assert.That("user@example.com", Does.Match(@"^[\w.-]+@[\w.-]+\.\w+$"));

    // Phone number format
    Assert.That("555-123-4567", Does.Match(@"^\d{3}-\d{3}-\d{4}$"));

    // Starts with digit
    Assert.That("42 is the answer", Does.Match(@"^\d"));

    // Contains only letters and spaces
    Assert.That("Hello World", Does.Match(@"^[a-zA-Z\s]+$"));

    // ISO date format
    Assert.That("2024-01-15", Does.Match(@"^\d{4}-\d{2}-\d{2}$"));
}

```

--------------------------------

### XmlExampleElement(SyntaxList<XmlNodeSyntax>)

Source: https://docs.nunit.org/api/Microsoft.CodeAnalysis.CSharp.SyntaxFactory.html

Creates an XML example element syntax node with a content list.

```APIDOC
## XmlExampleElement(SyntaxList<XmlNodeSyntax>)

### Description
Creates a new XmlElementSyntax for an example element with the specified content list.

### Method
XmlExampleElement

### Parameters
- **content** (SyntaxList<XmlNodeSyntax>) - The content list of the example element.

### Returns
- **XmlElementSyntax** - The created XmlElementSyntax instance.
```

--------------------------------

### Example fixture with non-nullable field initialized in SetUp

Source: https://docs.nunit.org/articles/nunit-analyzers/NUnit3002.html

Shows a test fixture where the compiler would warn about the non-nullable field 'instance' not being initialized in the constructor. The rule suppresses the warning because the field is set in the SetUp method.

```csharp
[TestFixture]
internal sealed class SomeClassFixture
{
    private SomeClass instance;

    [SetUp]
    public void Setup()
    {
        instance = new SomeClass();
    }

    [Test]
    public void Test()
    {
        Assert.That(instance.MethodUnderTest(), Is.True)
    }
}

```

--------------------------------

### XmlExampleElement(params XmlNodeSyntax[])

Source: https://docs.nunit.org/api/Microsoft.CodeAnalysis.CSharp.SyntaxFactory.html

Creates an XML example element syntax node with content nodes.

```APIDOC
## XmlExampleElement(params XmlNodeSyntax[])

### Description
Creates a new XmlElementSyntax for an example element with the specified content nodes.

### Method
XmlExampleElement

### Parameters
- **content** (XmlNodeSyntax[]) - The content nodes of the example element.

### Returns
- **XmlElementSyntax** - The created XmlElementSyntax instance.
```

--------------------------------

### SetUp attribute usage

Source: https://docs.nunit.org/articles/nunit/writing-tests/attributes/setup.html

Shows the attribute applied to a method. The attribute is parameterless and can only be applied to methods.

```csharp
[SetUp]

```

--------------------------------

### NUnit1026 Fixed Example

Source: https://docs.nunit.org/articles/nunit-analyzers/NUnit1026.html

Shows the fixed version after applying the NUnit1026 code fix, which changes the access modifier to `public` for the test and setup methods.

```csharp
private int Value;

[SetUp]
public void NUnit1026SetUp()
{
    Value = 42;
}

[Test]
public void NUnit1026SampleTest()
{
    Assert.That(Value, Is.GreaterThan(0));
}

[TestCase(1)]
public static void NUnit1026SampleTest2(int i)
{
    Assert.Pass();
}

```

--------------------------------

### Clean build and test on Windows

Source: https://docs.nunit.org/articles/developer-info/Packaging-the-Framework.html

Run a clean build and all tests on Windows before releasing. If errors occur at any stage, the release is not ready.

```bash
build --target clean
build --target test

```

--------------------------------

### SetUpFixtureAttribute Constructor

Source: https://docs.nunit.org/api/NUnit.Framework.SetUpFixtureAttribute.html

Initializes a new instance of the SetUpFixtureAttribute class.

```APIDOC
## SetUpFixtureAttribute Constructor

### Description
Initializes a new instance of the SetUpFixtureAttribute class.

### Declaration
```csharp
public SetUpFixtureAttribute()
```

### Parameters
None.

### Returns
None.
```

--------------------------------

### Interface-Aware Action Attribute Example 3

Source: https://docs.nunit.org/articles/nunit/extending-nunit/Action-Attributes.html

Defines a custom TestActionAttribute that uses the Fixture property to cast to an interface and set a property, providing data to tests. The attribute is applied to the interface, so any implementing class gets the data.

```csharp
[AttributeUsage(AttributeTargets.Interface)]
public class InterfaceAwareActionAttribute : TestActionAttribute
{
    private readonly string _Message;

    public InterfaceAwareActionAttribute(string message) { _Message = message; }

    public override void BeforeTest(ITest details)
    {
        IHaveAnAction obj = details.Fixture as IHaveAnAction;
        if(obj != null)
            obj.Message = _Message;
    }

    public override ActionTargets Targets
    {
        get { return ActionTargets.Test; }
    }
}

[InterfaceAwareAction("Hello")]
public interface IHaveAnAction { string Message { get; set; } }

[TestFixture]
public class ActionAttributeSampleTests : IHaveAnAction
{
    [Test]
    public void SimpleTest()
    {
        Console.WriteLine("{0}, World!", Message);
    }

    public string Message { get; set; }
}

```

```text
  Hello, World!

```

--------------------------------

### DictionaryContainsKeyConstraint examples

Source: https://docs.nunit.org/articles/nunit/writing-tests/constraints/DictionaryContainsKeyConstraint.html

Demonstrates basic key checks and key-value checks using Contains.Key and Does.ContainKey.

```csharp
[Test]
public void DictionaryContainsKeyConstraint_Examples()
{
    var dictionary = new Dictionary<string, int>
    {
        ["Alice"] = 30,
        ["Bob"] = 25
    };

    // Basic key checks
    Assert.That(dictionary, Contains.Key("Alice"));
    Assert.That(dictionary, Does.ContainKey("Bob"));
    Assert.That(dictionary, Does.Not.ContainKey("Carol"));

    // Check key with corresponding value
    Assert.That(dictionary, Does.ContainKey("Alice").WithValue(30));
    Assert.That(dictionary, Does.ContainKey("Bob").WithValue(25));
}
```

--------------------------------

### SubPathConstraint Examples

Source: https://docs.nunit.org/articles/nunit/writing-tests/constraints/SubPathConstraint.html

Examples of using SubPathConstraint in tests.

```APIDOC
## SubPathConstraint Examples

### Description
Examples of using SubPathConstraint in tests.

### Example Code
```csharp
[Test]
public void SubPathConstraint_Examples()
{
    Assert.That("/folder1/./junk/../folder2", Is.SubPathOf("/folder1/"));
    Assert.That("/folder1/junk/folder2", Is.Not.SubPathOf("/folder1/folder2"));

    Assert.That(@"C:\folder1\folder2\Folder3", Is.SubPathOf(@"C:\Folder1\Folder2").IgnoreCase);
    Assert.That("/folder1/folder2/folder3", Is.Not.SubPathOf("/Folder1/Folder2/Folder3").RespectCase);
}
```

```

--------------------------------

### EmitOptions(bool, DebugInformationFormat, string?, string?, int, ulong, bool, SubsystemVersion, string?, bool, bool, ImmutableArray<InstrumentationKind>, HashAlgorithmName?, Encoding?, Encoding?)

Source: https://docs.nunit.org/api/Microsoft.CodeAnalysis.Emit.EmitOptions.html

Initializes a new instance of the EmitOptions class with the specified parameters, including instrumentation kinds, PDB checksum algorithm, and source file encodings.

```APIDOC
## Constructor: EmitOptions(bool, DebugInformationFormat, string?, string?, int, ulong, bool, SubsystemVersion, string?, bool, bool, ImmutableArray<InstrumentationKind>, HashAlgorithmName?, Encoding?, Encoding?)

### Description
Initializes a new instance of the EmitOptions class with the specified parameters, including instrumentation kinds, PDB checksum algorithm, and source file encodings.

### Parameters
- **metadataOnly** (bool) - Required - Indicates whether to emit metadata only.
- **debugInformationFormat** (DebugInformationFormat) - Required - The format of debug information.
- **pdbFilePath** (string?) - Required - The path to the PDB file.
- **outputNameOverride** (string?) - Required - The output name override.
- **fileAlignment** (int) - Required - The file alignment.
- **baseAddress** (ulong) - Required - The base address.
- **highEntropyVirtualAddressSpace** (bool) - Required - Whether to use high entropy virtual address space.
- **subsystemVersion** (SubsystemVersion) - Required - The subsystem version.
- **runtimeMetadataVersion** (string?) - Required - The runtime metadata version.
- **tolerateErrors** (bool) - Required - Whether to tolerate errors.
- **includePrivateMembers** (bool) - Required - Whether to include private members.
- **instrumentationKinds** (ImmutableArray<InstrumentationKind>) - Required - The kinds of instrumentation to apply.
- **pdbChecksumAlgorithm** (HashAlgorithmName?) - Required - The PDB checksum algorithm.
- **defaultSourceFileEncoding** (Encoding?) - Required - The default source file encoding.
- **fallbackSourceFileEncoding** (Encoding?) - Required - The fallback source file encoding.

### Remarks
This constructor is used to configure emission options for the compiler.

```

--------------------------------

### EmitOptions(bool, DebugInformationFormat, string?, string?, int, ulong, bool, SubsystemVersion, string?, bool, bool, ImmutableArray<InstrumentationKind>, HashAlgorithmName?)

Source: https://docs.nunit.org/api/Microsoft.CodeAnalysis.Emit.EmitOptions.html

Initializes a new instance of the EmitOptions class with the specified parameters, including instrumentation kinds and PDB checksum algorithm.

```APIDOC
## Constructor: EmitOptions(bool, DebugInformationFormat, string?, string?, int, ulong, bool, SubsystemVersion, string?, bool, bool, ImmutableArray<InstrumentationKind>, HashAlgorithmName?)

### Description
Initializes a new instance of the EmitOptions class with the specified parameters, including instrumentation kinds and PDB checksum algorithm.

### Parameters
- **metadataOnly** (bool) - Required - Indicates whether to emit metadata only.
- **debugInformationFormat** (DebugInformationFormat) - Required - The format of debug information.
- **pdbFilePath** (string?) - Required - The path to the PDB file.
- **outputNameOverride** (string?) - Required - The output name override.
- **fileAlignment** (int) - Required - The file alignment.
- **baseAddress** (ulong) - Required - The base address.
- **highEntropyVirtualAddressSpace** (bool) - Required - Whether to use high entropy virtual address space.
- **subsystemVersion** (SubsystemVersion) - Required - The subsystem version.
- **runtimeMetadataVersion** (string?) - Required - The runtime metadata version.
- **tolerateErrors** (bool) - Required - Whether to tolerate errors.
- **includePrivateMembers** (bool) - Required - Whether to include private members.
- **instrumentationKinds** (ImmutableArray<InstrumentationKind>) - Required - The kinds of instrumentation to apply.
- **pdbChecksumAlgorithm** (HashAlgorithmName?) - Required - The PDB checksum algorithm.

### Remarks
This constructor is used to configure emission options for the compiler.

```

--------------------------------

### Get(string)

Source: https://docs.nunit.org/api/NUnit.Framework.TestParameters.html

Method that gets the value of a parameter by name.

```APIDOC
## Get(string)

### Description
Get method is a simple alternative to the indexer.

### Declaration
```csharp
public string? Get(string name)
```

### Parameters
| Type | Name | Description |
|------|------|-------------|
| string | name | Name of the parameter |

### Returns
| Type | Description |
|------|-------------|
| string | Value of the parameter or null if not present |

```

--------------------------------

### Normal sequence for acquiring ITestEngine

Source: https://docs.nunit.org/articles/nunit-engine/Test-Engine-API.html

Shows the typical initialization: create the engine, set WorkDirectory (defaults to current directory), and set InternalTraceLevel (defaults to off).

```csharp
ITestEngine engine = TestEngineActivator.CreateInstance(...);
engine.WorkDirectory = ...;         // Defaults to the current directory
engine.InternalTraceLevel = ...;    // Defaults to off

```

--------------------------------

### Examples

Source: https://docs.nunit.org/articles/nunit/writing-tests/constraints/GreaterThanOrEqualConstraint.html

Examples demonstrating the usage of GreaterThanOrEqualConstraint with various types and modifiers.

```APIDOC
## Examples

### Description
Examples demonstrating the usage of GreaterThanOrEqualConstraint with various types and modifiers.

### Example 1: Basic Usage
```csharp
[Test]
public void GreaterThanOrEqualConstraint_Examples()
{
    Assert.That(7, Is.GreaterThanOrEqualTo(7));
    Assert.That(7, Is.GreaterThanOrEqualTo(3));
    Assert.That(7, Is.AtLeast(7));
}
```

### Example 2: DateTime
```csharp
Assert.That(DateTime.Now, Is.GreaterThanOrEqualTo(DateTime.Today));
```

### Example 3: With Tolerance
```csharp
Assert.That(10.1, Is.GreaterThanOrEqualTo(10.0).Within(0.5));
```

### Example 4: Using Custom Comparers
```csharp
public class MyOwnObject(int age)
{
    public int Age => age;
}

public class MyComparerUntyped : IComparer
{
    public int Compare(object? x, object? y)
    {
        if (ReferenceEquals(x, y)) return 0;
        if (x is null) return -1;
        if (y is null) return 1;
        int actualAge = x is MyOwnObject obj ? obj.Age : (int)x;
        int expectedAge = y is MyOwnObject objY ? objY.Age : (int)y;
        return actualAge.CompareTo(expectedAge);
    }
}

public class MyComparerTyped : IComparer<MyOwnObject>
{
    public int Compare(MyOwnObject? x, MyOwnObject? y)
    {
        if (ReferenceEquals(x, y)) return 0;
        if (x is null) return -1;
        if (y is null) return 1;
        return x.Age.CompareTo(y.Age);
    }
}
```
```

--------------------------------

### C# example: EmptyDirectoryConstraint_Examples

Source: https://docs.nunit.org/articles/nunit/writing-tests/constraints/EmptyDirectoryConstraint.html

C# test method demonstrating how to assert that a directory is empty using Is.Empty and then not empty after adding a file using Is.Not.Empty. It creates a temporary directory, cleans it up in a finally block, and notes that the directory must exist.

```csharp
[Test]
public void EmptyDirectoryConstraint_Examples()
{
    var tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
    Directory.CreateDirectory(tempDir);

    try
    {
        // Test directory is empty
        Assert.That(new DirectoryInfo(tempDir), Is.Empty);

        // Add a file and verify not empty
        File.WriteAllText(Path.Combine(tempDir, "test.txt"), "content");
        Assert.That(new DirectoryInfo(tempDir), Is.Not.Empty);
    }
    finally
    {
        Directory.Delete(tempDir, recursive: true);
    }
}

```

--------------------------------

### StartsWithConstraint with CultureInfo

Source: https://docs.nunit.org/articles/nunit/writing-tests/constraints/StartsWithConstraint.html

Example assertions using the Using(CultureInfo) modifier for culture-specific comparisons, including a combined IgnoreCase example with Turkish culture and a German culture example without case-insensitivity.

```csharp
// Using Turkish culture where 'i' and 'I' have special casing rules
Assert.That("TITLE text", Does.StartWith("title").IgnoreCase.Using(new CultureInfo("tr-TR")));

// Culture-specific comparison without case-insensitivity
Assert.That("Straße Street", Does.StartWith("Straße").Using(new CultureInfo("de-DE")));

```

--------------------------------

### Apply SetUpFixture attribute to a class

Source: https://docs.nunit.org/articles/nunit/writing-tests/attributes/setupfixture.html

Shows the minimal usage of the SetUpFixture attribute, which is a parameterless attribute that can only be applied to classes.

```csharp
[SetUpFixture]

```

--------------------------------

### IPropertyBag Get method declaration

Source: https://docs.nunit.org/api/NUnit.Framework.Interfaces.IPropertyBag.html

Declaration of the Get method that gets a single value for a key, using the first one if multiple values are present and returning null if the value is not found.

```csharp
object? Get(string key)

```

--------------------------------

### WithSyntaxTreeOptionsProvider(SyntaxTreeOptionsProvider?)

Source: https://docs.nunit.org/api/Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions.html

Creates a new CSharpCompilationOptions instance with the specified syntax tree options provider.

```APIDOC
## WithSyntaxTreeOptionsProvider(SyntaxTreeOptionsProvider?)

### Description
Creates a new CSharpCompilationOptions instance with the specified syntax tree options provider.

### Method
WithSyntaxTreeOptionsProvider

### Parameters
- **provider** (SyntaxTreeOptionsProvider) - Required - The syntax tree options provider to set.

### Returns
CSharpCompilationOptions - A new CSharpCompilationOptions instance with the updated syntax tree options provider.
```

--------------------------------

### Get<T>(string, T)

Source: https://docs.nunit.org/api/NUnit.Framework.TestParameters.html

Generic method that gets the value of a parameter or returns a default.

```APIDOC
## Get<T>(string, T)

### Description
Get the value of a parameter or return a default.

### Declaration
```csharp
public T Get<T>(string name, T defaultValue)
```

### Parameters
| Type | Name | Description |
|------|------|-------------|
| string | name | Name of the parameter |
| T | defaultValue | Default value of the parameter |

### Type Parameters
| Name | Description |
|------|-------------|
| T | The return Type |

### Returns
| Type | Description |
|------|-------------|
| T | Value of the parameter or default value if not present |

```

--------------------------------

### Example: Basic test with [Test]

Source: https://docs.nunit.org/articles/nunit/writing-tests/attributes/test.html

A simple test fixture with a test method that asserts 2+2 equals 4.

```csharp
[TestFixture]
public sealed class BasicTests
{
    [Test]
    public void Add()
    {
        Assert.That(2 + 2, Is.EqualTo(4));
    }
}

```

--------------------------------

### Get(string, string?)

Source: https://docs.nunit.org/api/NUnit.Framework.TestParameters.html

Method that gets the value of a parameter or a default string.

```APIDOC
## Get(string, string?)

### Description
Get the value of a parameter or a default string.

### Declaration
```csharp
public string? Get(string name, string? defaultValue)
```

### Parameters
| Type | Name | Description |
|------|------|-------------|
| string | name | Name of the parameter |
| string | defaultValue | Default value of the parameter |

### Returns
| Type | Description |
|------|-------------|
| string | Value of the parameter or default value if not present |

```

--------------------------------

### RandomAttribute with Guid

Source: https://docs.nunit.org/articles/nunit/writing-tests/attributes/random.html

Demonstrates using RandomAttribute with Guid parameters, which only supports count-only constructor.

```APIDOC
## RandomAttribute with Guid

### Description
Demonstrates using RandomAttribute with Guid parameters, which only supports count-only constructor.

### Supported Types
- Guid (count-only only)

### Example
```csharp
[Test]
public void TestWithRandomGuid([Random(3)] Guid value)
{
    // Generates 3 random GUIDs
    // Note: Guid does not support min/max range
    Assert.That(value, Is.Not.EqualTo(Guid.Empty));
}
```
```

--------------------------------

### Timeout attribute example (.NET Framework)

Source: https://docs.nunit.org/articles/nunit/writing-tests/attributes/timeout.html

Example usage of the Timeout attribute on a test method and a test fixture. The fixture-level timeout is inherited by tests unless overridden by a method-level attribute. This example is for .NET Framework only.

```csharp
[Test, Timeout(2000)]
public void PotentiallyLongRunningTest()
{
    // Test will be cancelled if it runs longer than 2 seconds
}

[TestFixture, Timeout(5000)]
public class TimeSensitiveTests
{
    [Test]
    public void Test1()
    {
        // Inherits 5 second timeout from fixture
    }

    [Test, Timeout(1000)]
    public void QuickTest()
    {
        // Overrides fixture timeout with 1 second
    }
}

```

--------------------------------

### Assert.True usage example

Source: https://docs.nunit.org/articles/nunit/writing-tests/assertions/classic-assertions/Assert.True.html

Example test method demonstrating Assert.True and Assert.IsTrue with various conditions. The example uses the 4.5.0 syntax; for earlier 4.x versions, replace Assert with ClassicAssert and include the NUnit.Framework.Legacy namespace.

```csharp
[Test]
public void True_Examples()
{
    Assert.True(2 + 2 == 4);
    Assert.IsTrue(true);
    Assert.True("Hello".StartsWith("H"));
    
}

```

--------------------------------

### BeforeEverySetUpHook(HookData)

Source: https://docs.nunit.org/api/NUnit.Framework.ExecutionHookMethodsAttribute.html

Method that is called immediately before every [SetUp] or [OneTimeSetUp] method is executed. Override this to implement custom logic to run before the test.

```APIDOC
## BeforeEverySetUpHook(HookData)

### Description
Method that is called immediately before every [SetUp] or [OneTimeSetUp] method is executed. Override this to implement custom logic to run before the test.

### Declaration
```csharp
public virtual void BeforeEverySetUpHook(HookData hookData)
```

### Parameters
- **hookData** (HookData) - The current NUnit.Framework.Internal.ExecutionHooks.HookData for the test.
```

--------------------------------

### Comparing Numerics Example

Source: https://docs.nunit.org/articles/nunit/writing-tests/constraints/EqualConstraint.html

Example demonstrating numeric comparisons with EqualConstraint, including tolerance usage.

```APIDOC
## Comparing Numerics with EqualConstraint

### Description
Shows how to use EqualConstraint to compare numeric values, including with tolerance.

### Example
```csharp
[Test]
public void EqualConstraint_Numerics()
{
    Assert.That(2 + 2, Is.EqualTo(4.0));
    Assert.That(2 + 2 == 4);
    Assert.That(2 + 2, Is.Not.EqualTo(5));
    Assert.That(2 + 2 != 5);
    Assert.That(5.0, Is.EqualTo(5));
    Assert.That(5.5, Is.EqualTo(5).Within(0.5));
    Assert.That(5.5, Is.EqualTo(5).Within(10).Percent);
}
```
```

--------------------------------

### Assert XmlSerializable Example

Source: https://docs.nunit.org/articles/nunit/writing-tests/constraints/XmlSerializableConstraint.html

Example of using the XmlSerializable constraint to assert that an object is XML serializable.

```csharp
Assert.That(someObject, Is.XmlSerializable));
```

--------------------------------

### SomeItemsConstraint Examples

Source: https://docs.nunit.org/articles/nunit/writing-tests/constraints/SomeItemsConstraint.html

Example test methods demonstrating the use of SomeItemsConstraint with various constraints and modifiers.

```APIDOC
## SomeItemsConstraint Examples

### Description
Example test methods showing how to use SomeItemsConstraint with various constraints and modifiers.

### Example Code
```csharp
[Test]
public void SomeItemsConstraint_Examples()
{
    int[] numbers = { 1, 2, 3, 4, 5 };
    string[] names = { "Alice", "Bob", "Carol" };

    // At least one item must satisfy the constraint
    Assert.That(numbers, Has.Some.GreaterThan(3));      // At least one > 3
    Assert.That(numbers, Has.Some.EqualTo(3));          // Contains 3
    Assert.That(names, Has.Some.Length.EqualTo(3));     // At least one 3-char name

    // Collection membership (all equivalent)
    Assert.That(numbers, Has.Member(3));
    Assert.That(numbers, Contains.Item(3));
    Assert.That(numbers, Does.Contain(3));
    Assert.That(numbers, Has.Some.EqualTo(3));

    // Custom comparison for membership
    Assert.That(names, Has.Some.EqualTo("alice").IgnoreCase);
    Assert.That(names, Has.Some.EqualTo("bob").Using(StringComparer.OrdinalIgnoreCase));
}
```
```

--------------------------------

### SamePathOrUnderConstraint examples

Source: https://docs.nunit.org/articles/nunit/writing-tests/constraints/SamePathOrUnderConstraint.html

Example test method demonstrating the use of SamePathOrUnderConstraint with various paths and modifiers.

```csharp
[Test]
public void SamePathOrUnderConstraint_Examples()
{
    Assert.That("/folder1/./junk/../folder2", Is.SamePathOrUnder("/folder1/folder2"));
    Assert.That("/folder1/junk/../folder2/./folder3", Is.SamePathOrUnder("/folder1/folder2"));
    Assert.That("/folder1/junk/folder2/folder3", Is.Not.SamePathOrUnder("/folder1/folder2"));

    Assert.That(@"C:\folder1\folder2\folder3", Is.SamePathOrUnder(@"C:\Folder1\Folder2").IgnoreCase);
    Assert.That("/folder1/folder2/folder3", Is.Not.SamePathOrUnder("/Folder1/Folder2").RespectCase);
}
```

--------------------------------

### Enable ProgressTraceListener with SetUpFixture

Source: https://docs.nunit.org/articles/nunit/technical-notes/usage/Trace-and-Debug-Output.html

Place this class inside a namespace to enable immediate Trace and Debug output for all tests in that namespace and below. It adds a ProgressTraceListener only if one is not already present, and does not require a final Trace.Flush(). Placing it outside any namespace applies it to the whole assembly, or you can add the StartTest and EndTest methods to a specific test fixture or class.

```csharp
[SetUpFixture]
public class SetupTrace
{
    [OneTimeSetUp]
    public void StartTest()
    {
        if (!Trace.Listeners.OfType<ProgressTraceListener>().Any())
            Trace.Listeners.Add(new ProgressTraceListener());
    }
}

```

--------------------------------

### ClassicAssert.AreEqual violation example

Source: https://docs.nunit.org/articles/nunit-analyzers/NUnit2005.html

An example of code that triggers the NUnit2005 warning by using the classic assertion model.

```csharp
[Test]
public void Test()
{
    ClassicAssert.AreEqual(expression1, expression2);
}
```

--------------------------------

### SetUpAttribute

Source: https://docs.nunit.org/api/NUnit.Framework.html

Identifies a method to be called immediately before each test is run.

```APIDOC
## [Attribute] SetUpAttribute

### Description
Identifies a method to be called immediately before each test is run.

### Usage
Apply the attribute to a method in a test fixture.

### Example
```csharp
[SetUp]
public void Setup() { }
```
```

--------------------------------

### EmitOptions(bool, DebugInformationFormat, string, string, int, ulong, bool, SubsystemVersion, string, bool, bool)

Source: https://docs.nunit.org/api/Microsoft.CodeAnalysis.Emit.EmitOptions.html

Initializes a new instance of the EmitOptions class with the specified parameters for metadata-only output, debug information format, PDB file path, output name override, file alignment, base address, high entropy virtual address space, subsystem version, runtime metadata version, error tolerance, and inclusion of private members.

```APIDOC
## Constructor: EmitOptions(bool, DebugInformationFormat, string, string, int, ulong, bool, SubsystemVersion, string, bool, bool)

### Description
Initializes a new instance of the EmitOptions class with the specified parameters.

### Parameters
- **metadataOnly** (bool) - Required - Indicates whether to emit metadata only.
- **debugInformationFormat** (DebugInformationFormat) - Required - The format of debug information.
- **pdbFilePath** (string) - Required - The path to the PDB file.
- **outputNameOverride** (string) - Required - The output name override.
- **fileAlignment** (int) - Required - The file alignment.
- **baseAddress** (ulong) - Required - The base address.
- **highEntropyVirtualAddressSpace** (bool) - Required - Whether to use high entropy virtual address space.
- **subsystemVersion** (SubsystemVersion) - Required - The subsystem version.
- **runtimeMetadataVersion** (string) - Required - The runtime metadata version.
- **tolerateErrors** (bool) - Required - Whether to tolerate errors.
- **includePrivateMembers** (bool) - Required - Whether to include private members.

### Remarks
This constructor is used to configure emission options for the compiler.

```

--------------------------------

### SubPathConstraint Examples of Use

Source: https://docs.nunit.org/articles/nunit/writing-tests/constraints/SubPathConstraint.html

Example test method demonstrating the use of SubPathConstraint with IgnoreCase and RespectCase modifiers.

```csharp
[Test]
public void SubPathConstraint_Examples()
{
    Assert.That("/folder1/./junk/../folder2", Is.SubPathOf("/folder1/"));
    Assert.That("/folder1/junk/folder2", Is.Not.SubPathOf("/folder1/folder2"));

    Assert.That(@"C:\folder1\folder2\Folder3", Is.SubPathOf(@"C:\Folder1\Folder2").IgnoreCase);
    Assert.That("/folder1/folder2/folder3", Is.Not.SubPathOf("/Folder1/Folder2/Folder3").RespectCase);
}
```

--------------------------------

### Contains Examples

Source: https://docs.nunit.org/articles/nunit/writing-tests/constraints/SomeItemsConstraint.html

Example test methods demonstrating collection containment using Has.Member, Contains.Item, and Does.Contain.

```APIDOC
## Contains Examples

### Description
Example test methods demonstrating collection containment using Has.Member, Contains.Item, and Does.Contain.

### Example Code
```csharp
[Test]
public void CollectionContains_Examples()
{
    int[] intArray = [1, 2, 3];
    string[] stringArray = ["a", "b", "c"];

    Assert.That(intArray, Has.Member(3));
    Assert.That(stringArray, Has.Member("b"));
    Assert.That(stringArray, Contains.Item("c"));
    Assert.That(stringArray, Has.No.Member("x"));
    Assert.That(intArray, Does.Contain(3));
}
```
```

--------------------------------

### CreateDefaultWin32Resources(bool, bool, Stream?, Stream?)

Source: https://docs.nunit.org/api/Microsoft.CodeAnalysis.Compilation.html

Creates the default Win32 resources for the compilation.

```APIDOC
## CreateDefaultWin32Resources(bool, bool, Stream?, Stream?)

### Description
Creates the default Win32 resources for the compilation.

### Method
CreateDefaultWin32Resources

### Parameters
- **versionResource** (bool) - Required - Whether to include version resources.
- **noManifest** (bool) - Required - Whether to omit the manifest.
- **manifestContents** (Stream) - Optional - The manifest contents.
- **iconInIcoFormat** (Stream) - Optional - The icon in ICO format.

### Returns
- **Stream** - The stream containing the Win32 resources.
```

--------------------------------

### SamePathConstraint Usage Example

Source: https://docs.nunit.org/articles/nunit/writing-tests/constraints/SamePathConstraint.html

Example test method demonstrating the use of SamePathConstraint with IgnoreCase and RespectCase modifiers.

```csharp
[Test]
public void SamePathConstraint_Examples()
{
    Assert.That("/folder1/./junk/../folder2", Is.SamePath("/folder1/folder2"));
    Assert.That("/folder1/./junk/../folder2/x", Is.Not.SamePath("/folder1/folder2"));

    Assert.That(@"C:\folder1\folder2", Is.SamePath(@"C:\Folder1\Folder2").IgnoreCase);
    Assert.That("/folder1/folder2", Is.Not.SamePath("/Folder1/Folder2").RespectCase);
}
```

--------------------------------

### Package extension

Source: https://docs.nunit.org/articles/developer-info/Packaging-Extensions.html

Creates the NuGet packages for the extension release.

```text
build -Target Package
```
Tokens:
Raw