Fire events inside DoInstead block

public class FooClass
{
    public event EventHandler<EventArgs> FooEvent;

    public void Foo()
    {
        if (FooEvent != null)
        {
            FooEvent(this, EventArgs.Empty);
        }
    }
}

public class FooClassSwapper
{
    private readonly FooClass obj;

    public FooClassSwapper(FooClass obj)
    {
        this.obj = obj;
    }

    public void Foo()
    {
        Isolate.Invoke.Event(() => { obj.FooEvent += null; }, this, EventArgs.Empty);
    }
}

[TestMethod]
[Isolated]
public void TestMockesFailure()
{
    bool invoked = false;
    FooClass obj = new FooClass();
    obj.FooEvent += (s, a) => invoked = true;

    var swapper = new FooClassSwapper(obj);
    Isolate.Swap.CallsOn(obj).WithCallsTo(swapper);

    obj.Foo();

    Assert.IsTrue(invoked);
}

[TestMethod]
[Isolated]
public void TestMockesFailure()
{
    bool invoked = false;
    FooClass obj = new FooClass();
    FooSubClass subObj = new FooSubClass();
    obj.subClass = subObj;

    obj.FooEvent += (s, a) => invoked = true;

    Isolate.WhenCalled(() => subObj.DoSomeInnerTaskAndNotifyMeUponCompletionViaFooInnerEvent()).DoInstead((c) =>
        {
            Isolate.Invoke.Event(() => { subObj.FooInnerEvent += null; }, this, EventArgs.Empty);
        });

    obj.Foo();

    Assert.IsTrue(invoked);
}

//classes
public class FooClass
{
    public event EventHandler<EventArgs> FooEvent;

    public FooSubClass subClass;

    public FooClass()
    {
        subClass = new FooSubClass();
    }

    public void Foo()
    {
        subClass.FooInnerEvent += new EventHandler<EventArgs>(subClass_FooInnerEvent);
        subClass.DoSomeInnerTaskAndNotifyMeUponCompletionViaFooInnerEvent();
    }

    private void subClass_FooInnerEvent(object sender, EventArgs e)
    {
        if (FooEvent != null)
        {
            FooEvent(this, EventArgs.Empty);
        }
    }
}

public class FooSubClass
{
    public event EventHandler<EventArgs> FooInnerEvent;

    public void DoSomeInnerTaskAndNotifyMeUponCompletionViaFooInnerEvent()
    {
        //doo some task
        if (FooInnerEvent != null)
        {
            FooInnerEvent(this, EventArgs.Empty);
        }
    }
}

It seems that the best way for you would be to use Invoke.Event from within DoInstead.

I'll create a patch that allows invoking events from DoInstead you can use.