Ensuring Safe Parallel Execution of Tests with Shared Object Initialization in Base Class

I'm working on a .NET project using NUnit for testing. I have a base test class BaseA that initializes a shared object in its constructor. My derived class A contains several test methods. I'm using the [Parallelizable(ParallelScope.Self)] attribute to allow parallel execution of tests within this class. Here is a simplified version of my setup:

public class BaseA
{
    protected IMyInterface sharedObject;

    public BaseA()
    {
        sharedObject = new MyClass(); // Initialization in the base constructor
    }
}

[TestFixture]
[Parallelizable(ParallelScope.Self)]
public class A : BaseA
{
    [Test]
    public void Test1()
    {
        sharedObject.Method1();
        // Other operations with sharedObject
    }

    [Test]
    public void Test2()
    {
        sharedObject.Method2();
        // Other operations with sharedObject
    }

    // Additional tests
}

I want to ensure that each test method receives its own instance of sharedObject to avoid conflicts during parallel execution. My questions are:

1. Will each test method get a new instance of sharedObject with the current setup?

2. If not, what is the best way to modify the setup to ensure each test method gets a separate instance?

I considered using the [SetUp] method to initialize sharedObject, but I'm not sure if this is the best approach. Here is what I think might work:

public class BaseA
{
    protected IMyInterface sharedObject;

    [SetUp]
    public void BaseSetup()
    {
        sharedObject = new MyClass(); // Initialization before each test
    }
}

[TestFixture]
[Parallelizable(ParallelScope.Self)]
public class A : BaseA
{
    [Test]
    public void Test1()
    {
        sharedObject.Method1();
        // Other operations with sharedObject
    }

    [Test]
    public void Test2()
    {
        sharedObject.Method2();
        // Other operations with sharedObject
    }

    // Additional tests
}

Will this approach ensure that each test method gets a separate instance of sharedObject, making the tests safe for parallel execution? Are there any other recommended practices for this scenario?

Thank you for your help!

Since [SetUp] methods run before each test case, each of your test cases will get a separate instance of sharedObject. If sharedObject is holding any unmanaged resources you should dispose it in a [TearDown] method.

However, your Parallelizable attribute is not allowing the methods to run in parallel. ParallelScope.Self (which is the default) means the attribute applies to the test on which it appears, in this case your fixture. So it says that your fixture may run in parallel with other fixtures, while the individual methods are left at their defaults.