Test 2: When Dispose() is called all unmanaged resources are released

[Fact]
public void ReleasesUnmanagedResourcesFromDispose()
{
    var spy = new ResourceSpy();
    spy.Dispose();
    spy.UnmanagedResourcesHaveBeenReleased.Should().BeTrue();
    GC.SuppressFinalize(spy);
}

To make it compile we add:

public class ResourceOwner
{
    ...
    public void Dispose(){}
}

The test fails. To make it pass we release the unmanaged resources:

public class ResourceOwner
{
    ...
    public void Dispose()
    {
        Marshal.FreeCoTaskMem(AnUnmanagedResource);
    }
}

This introduces some duplication, but we will hold off refactoring until we have a clearer picture of the shape of the code.
The test passes but the test suite crashes again. This time we do need to modify the ResourceOwner so that the finalizer will not be called after Dispose(), which leads to the next test…

Test 3: The Dispose() method must suppress finalization

Once Dispose() has been called by the client and the unmanaged resources have been released, we need to inform the GC that finalization is no longer required. The reference to the ResourceOwner will then be removed from the Finalization Queue (and consequenntly the GC will no longer initiate finalization). The ResourceOwner will be now be Garbage Collected at the first Generational GC after it goes out of scope as it will no longer have any other root references, thus avoiding an unnecessary generational promotion and further delays to reclaiming the unused heap space.
Unfortunately there is no way to test this that I can think of as GC is a static class, death for testing. We must simply implement it:

public class ResourceOwner
{
    ...
    public void Dispose()
    {
        Marshal.FreeCoTaskMem(AnUnmanagedResource);
        GC.SuppressFinalize(this);
    }
}

Test 4: The ResourceOwner implements IDisposable

Now that we have a Dispose() method, the simplest next step is to implement IDisposable:

[Fact]
public void ImplementsIDisposable()
{
    var resourceOwner = new ResourceOwner() as IDisposable;
    resourceOwner.Should().NotBeNull();
}

The test fails. To make it pass we implement IDisposable:

public class ResourceOwner : IDisposable
    {
        ...
    }

The test passes.