如何对终结器进行单元测试？

Question

我有以下类，它是 IDisposable 对象的装饰器（我省略了它添加的内容），它本身使用通用模式实现了 IDisposable ：

public class DisposableDecorator : IDisposable
{
    private readonly IDisposable _innerDisposable;

    public DisposableDecorator(IDisposable innerDisposable)
    {
        _innerDisposable = innerDisposable;
    }

    #region IDisposable Members

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    #endregion

    ~DisposableDecorator()
    {
        Dispose(false);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (disposing)
            _innerDisposable.Dispose();
    }
}

我可以轻松测试innerDisposable 在调用 Dispose() 时被释放：

[Test]
public void Dispose__DisposesInnerDisposable()
{
    var mockInnerDisposable = new Mock<IDisposable>();

    new DisposableDecorator(mockInnerDisposable.Object).Dispose();

    mockInnerDisposable.Verify(x => x.Dispose());
}

但是我如何编写一个测试来确保 innerDisposable 不不 被终结器处理掉？我想写这样的东西，但它失败了，大概是因为 GC 线程尚未调用终结器：

[Test]
public void Finalizer__DoesNotDisposeInnerDisposable()
{
    var mockInnerDisposable = new Mock<IDisposable>();

    new DisposableDecorator(mockInnerDisposable.Object);
    GC.Collect();

    mockInnerDisposable.Verify(x => x.Dispose(), Times.Never());
}

Answer 1

我可能会误解，但是：

GC.WaitForPendingFinalizers();

可能会成功 - http:// /msdn.microsoft.com/en-us/library/system.gc.waitforpendingfinalizers.aspx

Answer 2

在编写单元测试时，您应该始终尝试测试外部可见行为，而不是实现细节。有人可能会说抑制终结确实是不可见的行为，但另一方面，您可能无法（也不应该）模拟垃圾收集器。

在您的情况下，您试图确保遵循“最佳实践”或编码实践。应通过为此目的而制作的工具来强制执行，例如

Answer 3

我使用 Appdomain（参见下面的示例）。
TemporaryFile 类在构造函数中创建临时文件，并在 Dispose 或终结器 ~TemporaryFile() 中删除它。

不幸的是，GC.WaitForPendingFinalizers()；不能帮助我测试终结器。

    [Test]
    public void TestTemporaryFile_without_Dispose()
    {
        const string DOMAIN_NAME = "testDomain";
        const string FILENAME_KEY = "fileName";

        string testRoot = Directory.GetCurrentDirectory();

        AppDomainSetup info = new AppDomainSetup
                                  {
                                      ApplicationBase = testRoot
        };
        AppDomain testDomain = AppDomain.CreateDomain(DOMAIN_NAME, null, info);
        testDomain.DoCallBack(delegate
        {
            TemporaryFile temporaryFile = new TemporaryFile();
            Assert.IsTrue(File.Exists(temporaryFile.FileName));
            AppDomain.CurrentDomain.SetData(FILENAME_KEY, temporaryFile.FileName);
        });
        string createdTemporaryFileName = (string)testDomain.GetData(FILENAME_KEY);
        Assert.IsTrue(File.Exists(createdTemporaryFileName));
        AppDomain.Unload(testDomain);

        Assert.IsFalse(File.Exists(createdTemporaryFileName));
    }

Answer 4

测试终结并不容易，但测试对象是否是垃圾收集的对象可能会更容易。

这可以通过弱引用来完成。

在测试中，在调用 GC.Collect() 之前让局部变量超出范围非常重要。最简单的确定方法是函数作用域。

    class Stuff
    {
        ~Stuff()
        {
        }
    }

    WeakReference CreateWithWeakReference<T>(Func<T> factory)
    {
        return new WeakReference(factory());
    }

    [Test]
    public void TestEverythingOutOfScopeIsReleased()
    {
        var tracked = new List<WeakReference>();

        var referer = new List<Stuff>();

        tracked.Add(CreateWithWeakReference(() => { var stuff = new Stuff(); referer.Add(stuff); return stuff; }));

        // Run some code that is expected to release the references
        referer.Clear();

        GC.Collect();

        Assert.IsFalse(tracked.Any(o => o.IsAlive), "All objects should have been released");
    }

    [Test]
    public void TestLocalVariableIsStillInScope()
    {
        var tracked = new List<WeakReference>();

        var referer = new List<Stuff>();

        for (var i = 0; i < 10; i++)
        {
            var stuff = new Stuff();
            tracked.Add(CreateWithWeakReference(() => { referer.Add(stuff); return stuff; }));
        }

        // Run some code that is expected to release the references
        referer.Clear();

        GC.Collect();

        // Following holds because of the stuff variable is still on stack!
        Assert.IsTrue(tracked.Count(o => o.IsAlive) == 1, "Should still have a reference to the last one from the for loop");
    }

Answer 5

我在我的单元测试项目中找到了一种使用反射来做到这一点的方法：

var myObj = new MyType();
var finalizer = typeof(MyType).GetMethod("Finalize", BindingFlags.Instance | BindingFlags.NonPublic);
finalizer.Invoke(myObj, null);