Raise.With does not work properly in release mode

Just try to execute this code in release and in debug mode. Debug works, release fails. Tried with FakeItEasy version 1.25.3

public interface ITestA
{
    event EventHandler Closed;
    event EventHandler Loaded;

    void DoStuff ();

    void Wicked ();
}

public interface ITestB
{
    void DoStuff ();

    void Wicked ();

    void Wicked1 (ITestA a);
}

public class TestB
{
    private readonly ITestA _a;
    private readonly ITestB _b;

    public TestB (ITestA a, ITestB b)
    {
        _a = a;
        _b = b;
    }

    public void Attach ()
    {
        WeakEventManager<ITestA, EventArgs>.AddHandler(_a, EventNames.Closed, Closed);
        WeakEventManager<ITestA, EventArgs>.AddHandler(_a, EventNames.Loaded, Loaded);
        _a.Wicked();
        _b.Wicked();
    }

    private void Loaded (object sender, EventArgs e)
    {
        _b.DoStuff();
    }

    private void Closed (object sender, EventArgs e)
    {
        _a.DoStuff();

        // _b.Wicked1(_a.Value);
    }
}

[TestFixture]
public class MyTest
{
    [Test]
    [Repeat (1000)]
    public void Test ()
    {
        var a = A.Fake<ITestA>();
        var b = A.Fake<ITestB>();

        var inst = new TestB(a, b);
        inst.Attach();
        A.CallTo(() => a.Wicked()).MustHaveHappened(Repeated.Exactly.Once);
        A.CallTo(() => b.Wicked()).MustHaveHappened(Repeated.Exactly.Once);

        a.Closed += Raise.With(null, new EventArgs()).Now;

        A.CallTo(() => a.DoStuff()).MustHaveHappened(Repeated.Exactly.Once);

        // A.CallTo(() => b.Wicked1(a)).MustHaveHappened(Repeated.Exactly.Once);
        a.Loaded += Raise.With(null, new EventArgs()).Now;
        A.CallTo(() => b.DoStuff()).MustHaveHappened(Repeated.Exactly.Once);
    }
}

[blairconrad]

@MrVermond, it doesn’t appear to be Raise. I sloppily rewrote the test so we could raise the events via a public method:

public class ITestA
{
    event EventHandler Closed;
    event EventHandler Loaded;

    public virtual void DoStuff() { }

    public virtual void Wicked() { }

    public void RaiseLoaded()
    {
        Loaded(this, EventArgs.Empty);
    }

    public void RaiseClosed()
    {
        Closed(this, EventArgs.Empty);
    }
}

public class ITestB
{
    public virtual void DoStuff() { }

    public virtual void Wicked() { }
}

public class TestB
{
    private readonly ITestA _a;
    private readonly ITestB _b;

    public TestB(ITestA a, ITestB b)
    {
        _a = a;
        _b = b;
    }

    public void Attach()
    {
        WeakEventManager<ITestA, EventArgs>.AddHandler(_a, "Closed", Closed);
        WeakEventManager<ITestA, EventArgs>.AddHandler(_a, "Loaded", Loaded);
        _a.Wicked();
        _b.Wicked();
    }

    private void Loaded(object sender, EventArgs e)
    {
        _b.DoStuff();
    }

    private void Closed(object sender, EventArgs e)
    {
        _a.DoStuff();
    }
}

[TestFixture]
public class MyTest
{
    [Test]
    [Repeat(1000)]
    public void Test()
    {
        var a = A.Fake<ITestA>();
        var b = A.Fake<ITestB>();

        var inst = new TestB(a, b);
        inst.Attach();
        A.CallTo(() => a.Wicked()).MustHaveHappened(Repeated.Exactly.Once);
        A.CallTo(() => b.Wicked()).MustHaveHappened(Repeated.Exactly.Once);

        a.RaiseClosed();
        A.CallTo(() => a.DoStuff()).MustHaveHappened(Repeated.Exactly.Once);

        a.RaiseLoaded();
        A.CallTo(() => b.DoStuff()).MustHaveHappened(Repeated.Exactly.Once);
    }
}

and got this failure:

Errors and Failures:                                                     
1) Test Error : LessFaking.MyTest.Test                                   
   FakeItEasy.ExpectationException :                                     

  Assertion failed for the following call:                               
    LessFaking.ITestB.DoStuff()                                      
  Expected to find it exactly once but found it #0 times among the calls:
    1: LessFaking.ITestB.Wicked()

This lead me to believe that the problem is that the runtime thinks we’re done with some objects so we can start unhooking events.

Indeed, adding this line to the bottom either of my new test or your original test causes them to pass:

Assert.That(inst, Is.Not.Null);

So I think we may just be seeing normal WeakEventManager behaviour.

[blairconrad]

@MrVermond, I’m glad to have been of assistance.