//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldPerformSuccessfulStoreCopyProcess() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldPerformSuccessfulStoreCopyProcess()
{
// given
StoreStreamingProcess process = new StoreStreamingProcess(_protocol, _checkPointerSupplier, _mutex, _resourceStream);
// mocked behaviour
ImmediateEventExecutor eventExecutor = ImmediateEventExecutor.INSTANCE;
Promise <Void> completionPromise = eventExecutor.newPromise();
long lastCheckpointedTxId = 1000L;
RawCursor <StoreResource, IOException> resources = rawCursorOf();
when(_checkPointer.tryCheckPoint(any())).thenReturn(lastCheckpointedTxId);
when(_checkPointer.lastCheckPointedTransactionId()).thenReturn(lastCheckpointedTxId);
when(_protocol.end(_ctx, SUCCESS)).thenReturn(completionPromise);
when(_resourceStream.create()).thenReturn(resources);
// when
process.Perform(_ctx);
// then
InOrder inOrder = Mockito.inOrder(_protocol, _checkPointer);
inOrder.verify(_checkPointer).tryCheckPoint(any());
inOrder.verify(_protocol).end(_ctx, SUCCESS);
inOrder.verifyNoMoreInteractions();
assertEquals(1, @lock.ReadLockCount);
// when
completionPromise.Success = null;
// then
assertEquals(0, @lock.ReadLockCount);
}
/// <summary>
/// Chains a channel future to a promise. Used when the returned promise
/// was not allocated through the channel and cannot be used as the
/// first-hand promise for the I/O operation.
/// </summary>
private static void Chain(ChannelFuture when, Promise <Void> then)
{
when.addListener(f =>
{
if (f.Success)
{
then.Success = when.get();
}
else
{
then.Failure = when.cause();
}
});
}
/// <summary>
/// Will try to reconnect once before giving up on a send. The reconnection *must* happen
/// after write was scheduled. This is necessary to provide proper ordering when a message
/// is sent right after the non-blocking channel was setup and before the server is ready
/// to accept a connection. This happens frequently in tests.
/// </summary>
private void DeferredWrite(object msg, ChannelFuture channelFuture, Promise <Void> promise, bool firstAttempt, System.Action <io.netty.channel.Channel, object> writer)
{
channelFuture.addListener((ChannelFutureListener)f =>
{
if (f.Success)
{
writer(f.channel(), msg);
}
else if (firstAttempt)
{
TryConnect();
DeferredWrite(msg, _fChannel, promise, false, writer);
}
else
{
promise.Failure = f.cause();
}
});
}
private Future <Void> Write(object msg, bool flush)
{
if (_disposed)
{
throw new System.InvalidOperationException("sending on disposed channel");
}
if (_channel.Active)
{
if (flush)
{
return(_channel.writeAndFlush(msg));
}
else
{
return(_channel.write(msg));
}
}
else
{
Promise <Void> promise = _eventLoop.newPromise();
System.Action <io.netty.channel.Channel, object> writer;
if (flush)
{
writer = (_channel, message) => chain(_channel.writeAndFlush(msg), promise);
}
else
{
writer = (_channel, message) => chain(_channel.write(msg), promise);
}
DeferredWrite(msg, _fChannel, promise, true, writer);
return(promise);
}
}
