public void should_not_call_action_multiple_times_on_multiple_dispose() { var callCount = 0; var disposableObject = new DisposableAction(() => callCount++); disposableObject.Dispose(); disposableObject.Dispose(); disposableObject.Dispose(); callCount.ShouldEqual(1); }
public void DisposeActionOnlyExecutedOnceWhenCallingDisposeMultipleTimes() { var invokeCount = 0; var action = new DisposableAction(() => { }, () => invokeCount++); action.Dispose(); action.Dispose(); action.Dispose(); action.Dispose(); action.Dispose(); Assert.That(invokeCount, Is.EqualTo(1)); }
public void DisposableActionTest() { var a = 0; var disposal = new DisposableAction(() => a++); disposal.Dispose(); Assert.Equal(1, a); }
public void Dispose() { if (!_isDisposed) { _disposeAction.Dispose(); _isDisposed = true; } }
public void DisposalActionRunsWhenDisposeIsCalled() { var disposeActionRan = false; var action = new DisposableAction(() => {}, () => disposeActionRan = true); Assert.That(disposeActionRan, Is.False); action.Dispose(); Assert.That(disposeActionRan, Is.True); }
public void Dispose_ActionExecuted() { bool executed = false; IDisposable subject = new DisposableAction(() => executed = true); Assert.That(executed, Is.False); subject.Dispose(); Assert.That(executed, Is.True); }
public void DisposableActionParallelTest() { var a = 0; var disposal = new DisposableAction(() => a++); Parallel.For(1, 10, _ => { disposal.Dispose(); }); Assert.Equal(1, a); }
public void ActionIsExecutedOnDispose() { // Arrange bool called = false; DisposableAction action = new DisposableAction(() => { called = true; }); // Act action.Dispose(); // Assert Assert.True(called, "The action was not run when the DisposableAction was disposed"); }
public void ActionIsExecutedOnDispose() { // Arrange bool called = false; DisposableAction action = new DisposableAction(() => { called = true; }); // Act action.Dispose(); // Assert Assert.True(called, "The action was not run when the DisposableAction was disposed"); }
public void DisposableActionGetsCorrectParameterFromCtor() { int expected = 4543; int actual = 0; DisposableAction <int> action = new DisposableAction <int>(delegate(int i) { actual = i; }, expected); action.Dispose(); Assert.AreEqual(expected, actual); }
public virtual IDisposable OverrideCurrentTenantId(int?overriddenTenantId, bool disableMustHaveTenantBaseFilter = true) { var previousTenantId = CurrentTenantId; CurrentTenantId = overriddenTenantId; IDisposable restoreDisabledMustHaveTenantBaseFilter = new DisposableAction(() => { }); if (disableMustHaveTenantBaseFilter && IsMustHaveTenantBaseFilterEnabled) { restoreDisabledMustHaveTenantBaseFilter = DisableMustHaveTenantBaseFilter(); } return(new DisposableAction(() => { restoreDisabledMustHaveTenantBaseFilter.Dispose(); CurrentTenantId = previousTenantId; })); }
public void ActionIsCalledOnlyOnce() { int calls = 0; void callMe() => calls++; var disposable = new DisposableAction(callMe); disposable.Dispose(); disposable.Dispose(); disposable.Dispose(); disposable.Dispose(); disposable.Dispose(); disposable.Dispose(); disposable.Dispose(); Assert.AreEqual(1, calls); }
public void ReceiveDisconnectBeforeCancellationSetup() { var testContext = new TestContext("/test/echo/connect"); var counters = new Mock <IPerformanceCounterManager>(); var heartBeat = new Mock <ITransportHeartbeat>(); var json = JsonUtility.CreateDefaultSerializer(); var transportConnection = new Mock <ITransportConnection>(); var loggerFactory = new Mock <ILoggerFactory>(); var memoryPool = new Mock <IMemoryPool>(); counters.SetupGet(m => m.ConnectionsConnected).Returns(new NoOpPerformanceCounter()); counters.SetupGet(m => m.ConnectionsDisconnected).Returns(new NoOpPerformanceCounter()); var applicationLifetime = new Mock <IApplicationLifetime>(); applicationLifetime.SetupGet(m => m.ApplicationStopping).Returns(CancellationToken.None); var logger = new Mock <ILogger>(); loggerFactory.Setup(m => m.Create(It.IsAny <string>())).Returns(logger.Object); Func <PersistentResponse, object, Task <bool> > callback = null; object state = null; var disposable = new DisposableAction(() => { callback(new PersistentResponse() { Terminal = true }, state); }); transportConnection.Setup(m => m.Receive(It.IsAny <string>(), It.IsAny <Func <PersistentResponse, object, Task <bool> > >(), It.IsAny <int>(), It.IsAny <object>())).Callback <string, Func <PersistentResponse, object, Task <bool> >, int, object>(async(id, cb, max, st) => { callback = cb; state = st; bool result = await cb(new PersistentResponse() { Aborted = true }, st); if (!result) { disposable.Dispose(); } }) .Returns(disposable); transportConnection.Setup(m => m.Send(It.IsAny <ConnectionMessage>())).Returns(TaskAsyncHelper.Empty); var transport = new Mock <ForeverTransport>(testContext.MockHttpContext.Object, json, heartBeat.Object, counters.Object, applicationLifetime.Object, loggerFactory.Object, memoryPool.Object) { CallBase = true }; transport.Setup(m => m.Send(It.IsAny <PersistentResponse>())).Returns(TaskAsyncHelper.Empty); bool ended = false; transport.Object.Connected = () => TaskAsyncHelper.Empty; transport.Object.AfterRequestEnd = (ex) => { Assert.Null(ex); ended = true; }; // Act transport.Object.ProcessRequest(transportConnection.Object); // Assert Assert.True(ended); }
public void ReceiveDisconnectBeforeCancellationSetup() { var response = new Mock <IResponse>(); response.Setup(m => m.CancellationToken).Returns(CancellationToken.None); var request = new Mock <IRequest>(); var qs = new NameValueCollection(); qs["connectionId"] = "1"; request.Setup(m => m.QueryString).Returns(new NameValueCollectionWrapper(qs)); request.Setup(m => m.LocalPath).Returns("/test/echo/connect"); var counters = new Mock <IPerformanceCounterManager>(); var heartBeat = new Mock <ITransportHeartbeat>(); var json = JsonUtility.CreateDefaultSerializer(); var hostContext = new HostContext(request.Object, response.Object); var transportConnection = new Mock <ITransportConnection>(); var traceManager = new Mock <ITraceManager>(); counters.SetupGet(m => m.ConnectionsConnected).Returns(new NoOpPerformanceCounter()); traceManager.Setup(m => m[It.IsAny <string>()]).Returns(new System.Diagnostics.TraceSource("foo")); Func <PersistentResponse, object, Task <bool> > callback = null; object state = null; var disposable = new DisposableAction(() => { callback(new PersistentResponse() { Terminal = true }, state); }); transportConnection.Setup(m => m.Receive(It.IsAny <string>(), It.IsAny <Func <PersistentResponse, object, Task <bool> > >(), It.IsAny <int>(), It.IsAny <object>())).Callback <string, Func <PersistentResponse, object, Task <bool> >, int, object>(async(id, cb, max, st) => { callback = cb; state = st; bool result = await cb(new PersistentResponse() { Disconnect = true }, st); if (!result) { disposable.Dispose(); } }) .Returns(disposable); transportConnection.Setup(m => m.Send(It.IsAny <ConnectionMessage>())).Returns(TaskAsyncHelper.Empty); var transport = new Mock <ForeverTransport>(hostContext, json, heartBeat.Object, counters.Object, traceManager.Object) { CallBase = true }; transport.Setup(m => m.Send(It.IsAny <PersistentResponse>())).Returns(TaskAsyncHelper.Empty); bool ended = false; transport.Object.Connected = () => TaskAsyncHelper.Empty; transport.Object.AfterRequestEnd = (ex) => { Assert.Null(ex); ended = true; }; // Act transport.Object.ProcessRequest(transportConnection.Object); // Assert Assert.True(ended); }
public virtual void TearDown() { _teardown.Dispose(); Out = null; }
public void ReceiveAbortBeforeCancellationSetup() { var response = new Mock<IResponse>(); response.Setup(m => m.CancellationToken).Returns(CancellationToken.None); var request = new Mock<IRequest>(); var qs = new NameValueCollection(); qs["connectionId"] = "1"; request.Setup(m => m.QueryString).Returns(new NameValueCollectionWrapper(qs)); request.Setup(m => m.LocalPath).Returns("/test/echo/connect"); var counters = new Mock<IPerformanceCounterManager>(); var heartBeat = new Mock<ITransportHeartbeat>(); var json = JsonUtility.CreateDefaultSerializer(); var hostContext = new HostContext(request.Object, response.Object); var transportConnection = new Mock<ITransportConnection>(); var traceManager = new Mock<ITraceManager>(); counters.SetupGet(m => m.ConnectionsConnected).Returns(new NoOpPerformanceCounter()); counters.SetupGet(m => m.ConnectionsDisconnected).Returns(new NoOpPerformanceCounter()); traceManager.Setup(m => m[It.IsAny<string>()]).Returns(new System.Diagnostics.TraceSource("foo")); Func<PersistentResponse, object, Task<bool>> callback = null; object state = null; var disposable = new DisposableAction(() => { callback(new PersistentResponse() { Terminal = true }, state); }); transportConnection.Setup(m => m.Receive(It.IsAny<string>(), It.IsAny<Func<PersistentResponse, object, Task<bool>>>(), It.IsAny<int>(), It.IsAny<object>())).Callback<string, Func<PersistentResponse, object, Task<bool>>, int, object>(async (id, cb, max, st) => { callback = cb; state = st; bool result = await cb(new PersistentResponse() { Aborted = true } , st); if (!result) { disposable.Dispose(); } }) .Returns(disposable); transportConnection.Setup(m => m.Send(It.IsAny<ConnectionMessage>())).Returns(TaskAsyncHelper.Empty); var transport = new Mock<ForeverTransport>(hostContext, json, heartBeat.Object, counters.Object, traceManager.Object) { CallBase = true }; transport.Setup(m => m.Send(It.IsAny<PersistentResponse>())).Returns(TaskAsyncHelper.Empty); bool ended = false; transport.Object.Connected = () => TaskAsyncHelper.Empty; transport.Object.AfterRequestEnd = (ex) => { Assert.Null(ex); ended = true; }; // Act transport.Object.ProcessRequest(transportConnection.Object); // Assert Assert.True(ended); }
public void Dispose() => _disposableAction.Dispose();
public void ReceiveDisconnectBeforeCancellationSetup() { var testContext = new TestContext("/test/echo/connect"); var counters = new Mock<IPerformanceCounterManager>(); var heartBeat = new Mock<ITransportHeartbeat>(); var json = JsonUtility.CreateDefaultSerializer(); var transportConnection = new Mock<ITransportConnection>(); var loggerFactory = new Mock<ILoggerFactory>(); var memoryPool = new Mock<IMemoryPool>(); counters.SetupGet(m => m.ConnectionsConnected).Returns(new NoOpPerformanceCounter()); counters.SetupGet(m => m.ConnectionsDisconnected).Returns(new NoOpPerformanceCounter()); var applicationLifetime = new Mock<IApplicationLifetime>(); applicationLifetime.SetupGet(m => m.ApplicationStopping).Returns(CancellationToken.None); var logger = new Mock<ILogger>(); loggerFactory.Setup(m => m.CreateLogger(It.IsAny<string>())).Returns(logger.Object); Func<PersistentResponse, object, Task<bool>> callback = null; object state = null; var disposable = new DisposableAction(() => { callback(new PersistentResponse() { Terminal = true }, state); }); transportConnection.Setup(m => m.Receive(It.IsAny<string>(), It.IsAny<Func<PersistentResponse, object, Task<bool>>>(), It.IsAny<int>(), It.IsAny<object>())).Callback<string, Func<PersistentResponse, object, Task<bool>>, int, object>(async (id, cb, max, st) => { callback = cb; state = st; bool result = await cb(new PersistentResponse() { Aborted = true }, st); if (!result) { disposable.Dispose(); } }) .Returns(disposable); transportConnection.Setup(m => m.Send(It.IsAny<ConnectionMessage>())).Returns(TaskAsyncHelper.Empty); var transport = new Mock<ForeverTransport>(testContext.MockHttpContext.Object, json, heartBeat.Object, counters.Object, applicationLifetime.Object, loggerFactory.Object, memoryPool.Object) { CallBase = true }; transport.Setup(m => m.Send(It.IsAny<PersistentResponse>())).Returns(TaskAsyncHelper.Empty); bool ended = false; transport.Object.Connected = () => TaskAsyncHelper.Empty; transport.Object.AfterRequestEnd = (ex) => { Assert.Null(ex); ended = true; }; // Act transport.Object.ProcessRequest(transportConnection.Object); // Assert Assert.True(ended); }