public IDisposable RegisterChangeCallback(Action <object> callback, object state)
{
var disposable = new MockDisposable();
_callback = () => callback(state);
return(disposable);
}
public void TestMock()
{
var d1 = new MockDisposable();
Assert.IsFalse(d1.Disposed);
d1.Dispose();
Assert.IsTrue(d1.Disposed);
}
public void DisposingOwned_CallsDisposeOnLifetimeToken()
{
var o = new MockDisposable();
var owned = new Owned <string>("unused", o);
owned.Dispose();
Assert.AreEqual(1, o.disposed);
}
public void DisposeCalled()
{
var disposable = new MockDisposable();
Assert.AreEqual(0, disposable.DisposeCalled);
disposable.Dispose();
Assert.AreEqual(1, disposable.DisposeCalled);
disposable.Dispose();
Assert.AreEqual(1, disposable.DisposeCalled);
}
public void DisposeCalled()
{
var disposable = new MockDisposable();
Assert.AreEqual(0, disposable.DisposeCalled);
disposable.Dispose();
Assert.AreEqual(1, disposable.DisposeCalled);
disposable.Dispose();
Assert.AreEqual(1, disposable.DisposeCalled);
}
public void ShouldDispose_Func()
{
var mock = new MockDisposable();
Assert.False(mock.Disposed);
var x = Disposable.Using(() => mock, _ => 42);
Assert.True(mock.Disposed);
Assert.Equal(42, x);
}
public void ShouldDispose_Action()
{
var mock = new MockDisposable();
Assert.False(mock.Disposed);
var x = 41;
Disposable.Using(() => mock, _ => { x = x + 1; });
Assert.True(mock.Disposed);
Assert.Equal(42, x);
}
public void Using_Error()
{
var scheduler = new TestScheduler();
var disposeInvoked = 0;
var createInvoked = 0;
var xs = default(ITestableObservable <long>);
var disposable = default(MockDisposable);
var _d = default(MockDisposable);
var ex = new Exception();
var res = scheduler.Start(() =>
Observable.Using(
() =>
{
disposeInvoked++;
disposable = new MockDisposable(scheduler);
return(disposable);
},
d =>
{
_d = d;
createInvoked++;
xs = scheduler.CreateColdObservable(
OnNext(100, scheduler.Clock),
OnError <long>(200, ex));
return(xs);
}
)
);
Assert.Same(disposable, _d);
res.Messages.AssertEqual(
OnNext(300, 200L),
OnError <long>(400, ex)
);
Assert.Equal(1, createInvoked);
Assert.Equal(1, disposeInvoked);
xs.Subscriptions.AssertEqual(
Subscribe(200, 400)
);
disposable.AssertEqual(
200,
400
);
}
public void TestInvalidOperations()
{
var c = new DisposableCollection();
var d1 = new MockDisposable();
// adding a reference to the same object twice
c.Add(d1);
Assert.ThrowsException <ArgumentException>(() =>
c.Add(d1));
// adding a null reference
Assert.ThrowsException <ArgumentNullException>(() =>
c.Add(null));
}
public void TestBasicDisposal()
{
var d1 = new MockDisposable();
var d2 = new MockDisposable();
Assert.IsFalse(d1.Disposed);
Assert.IsFalse(d2.Disposed);
var coll = new DisposableCollection {
d1, d2
};
coll.Dispose();
Assert.IsTrue(d1.Disposed);
Assert.IsTrue(d2.Disposed);
}
public void Using_ThrowResourceUsage()
{
var scheduler = new TestScheduler();
var ex = new Exception();
var disposeInvoked = 0;
var createInvoked = 0;
var disposable = default(MockDisposable);
var res = scheduler.Start(() =>
Observable.Using <int, IDisposable>(
() =>
{
disposeInvoked++;
disposable = new MockDisposable(scheduler);
return(disposable);
},
d =>
{
createInvoked++;
throw ex;
}
)
);
res.Messages.AssertEqual(
OnError <int>(200, ex)
);
Assert.Equal(1, createInvoked);
Assert.Equal(1, disposeInvoked);
disposable.AssertEqual(
200,
200
);
}
public void TestDisposeOnRemove()
{
(DisposableCollection, MockDisposable) prepareSet()
{
var d = new MockDisposable();
var c = new DisposableCollection {
d
};
return(c, d);
}
var(c1, d1) = prepareSet();
c1.Remove(d1);
Assert.IsTrue(d1.Disposed);
(c1, d1) = prepareSet();
c1.Remove(d1, true);
Assert.IsTrue(d1.Disposed);
(c1, d1) = prepareSet();
c1.Remove(d1, false);
Assert.IsFalse(d1.Disposed);
}
public void Using_ThrowResourceUsage()
{
var scheduler = new TestScheduler();
var ex = new Exception();
var disposeInvoked = 0;
var createInvoked = 0;
var disposable = default(MockDisposable);
var res = scheduler.Start(() =>
Observable.Using<int, IDisposable>(
() =>
{
disposeInvoked++;
disposable = new MockDisposable(scheduler);
return disposable;
},
d =>
{
createInvoked++;
throw ex;
}
)
);
res.Messages.AssertEqual(
OnError<int>(200, ex)
);
Assert.AreEqual(1, createInvoked);
Assert.AreEqual(1, disposeInvoked);
disposable.AssertEqual(
200,
200
);
}
public void Using_Dispose()
{
var scheduler = new TestScheduler();
var disposeInvoked = 0;
var createInvoked = 0;
var xs = default(ITestableObservable<long>);
var disposable = default(MockDisposable);
var _d = default(MockDisposable);
var res = scheduler.Start(() =>
Observable.Using(
() =>
{
disposeInvoked++;
disposable = new MockDisposable(scheduler);
return disposable;
},
d =>
{
_d = d;
createInvoked++;
xs = scheduler.CreateColdObservable(
OnNext<long>(100, scheduler.Clock),
OnNext<long>(1000, scheduler.Clock + 1));
return xs;
}
)
);
Assert.AreSame(disposable, _d);
res.Messages.AssertEqual(
OnNext(300, 200L)
);
Assert.AreEqual(1, createInvoked);
Assert.AreEqual(1, disposeInvoked);
xs.Subscriptions.AssertEqual(
Subscribe(200, 1000)
);
disposable.AssertEqual(
200,
1000
);
}
public void Use(MockDisposable disposable)
{
}
