public virtual void TestStorageReportHasStorageTypeAndState()
{
// Make sure we are not testing with the default type, that would not
// be a very good test.
NUnit.Framework.Assert.AreNotSame(storageType, StorageType.Default);
NameNode nn = cluster.GetNameNode();
DataNode dn = cluster.GetDataNodes()[0];
// Insert a spy object for the NN RPC.
DatanodeProtocolClientSideTranslatorPB nnSpy = DataNodeTestUtils.SpyOnBposToNN(dn
, nn);
// Trigger a heartbeat so there is an interaction with the spy
// object.
DataNodeTestUtils.TriggerHeartbeat(dn);
// Verify that the callback passed in the expected parameters.
ArgumentCaptor <StorageReport[]> captor = ArgumentCaptor.ForClass <StorageReport[]>
();
Org.Mockito.Mockito.Verify(nnSpy).SendHeartbeat(Matchers.Any <DatanodeRegistration
>(), captor.Capture(), Matchers.AnyLong(), Matchers.AnyLong(), Matchers.AnyInt()
, Matchers.AnyInt(), Matchers.AnyInt(), Org.Mockito.Mockito.Any <VolumeFailureSummary
>());
StorageReport[] reports = captor.GetValue();
foreach (StorageReport report in reports)
{
Assert.AssertThat(report.GetStorage().GetStorageType(), IS.Is(storageType));
Assert.AssertThat(report.GetStorage().GetState(), IS.Is(DatanodeStorage.State.Normal
));
}
}
private Callable <Void> SharedClientStarter(CoreTopologyService topologyService, ISet <MemberId> expectedTargetSet)
{
return(() =>
{
try
{
RaftMachine raftMock = mock(typeof(RaftMachine));
RaftCoreTopologyConnector tc = new RaftCoreTopologyConnector(topologyService, raftMock, CausalClusteringSettings.database.DefaultValue);
topologyService.init();
topologyService.start();
tc.start();
assertEventually("should discover complete target set", () =>
{
ArgumentCaptor <ISet <MemberId> > targetMembers = ArgumentCaptor.forClass((Type <ISet <MemberId> >)expectedTargetSet.GetType());
verify(raftMock, atLeastOnce()).TargetMembershipSet = targetMembers.capture();
return targetMembers.Value;
}, equalTo(expectedTargetSet), TIMEOUT_MS, MILLISECONDS);
}
catch (Exception throwable)
{
fail(throwable.Message);
}
return null;
});
}
public void SendGetRequestAsync_Error()
{
var response = new HttpResponseMessage
{
StatusCode = HttpStatusCode.NotFound,
Content = new StringContent("Error")
};
var handler = new Mock <HttpMessageHandler>(MockBehavior.Strict);
handler.Protected()
.Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>())
.ReturnsAsync(response);
var httpClientFactory = new Mock <IHttpClientFactory>();
httpClientFactory.Setup(h => h.CreateClient(SoundCloudClient.HttpClientName)).Returns(new HttpClient(handler.Object));
// Act
var uri = new Uri("http://localhost:5000");
var exception = Assert.ThrowsAsync <SoundCloudApiException>(async() =>
await new SoundCloudApiGateway(httpClientFactory.Object).SendGetRequestAsync <Comment>(uri));
// Assert
Assert.That(exception.HttpStatusCode, Is.EqualTo(response.StatusCode));
Assert.That(exception.HttpContent, Is.EqualTo(response.Content));
var captor = new ArgumentCaptor <HttpRequestMessage>();
handler.Protected().Verify("SendAsync", Times.Once(), captor.CaptureExpr(), ItExpr.IsAny <CancellationToken>());
Assert.That(captor.Value.RequestUri, Is.EqualTo(uri));
Assert.That(captor.Value.Method, Is.EqualTo(HttpMethod.Get));
}
public virtual void TestPutMetrics2()
{
GraphiteSink sink = new GraphiteSink();
IList <MetricsTag> tags = new AList <MetricsTag>();
tags.AddItem(new MetricsTag(MsInfo.Context, "all"));
tags.AddItem(new MetricsTag(MsInfo.Hostname, null));
ICollection <AbstractMetric> metrics = new HashSet <AbstractMetric>();
metrics.AddItem(MakeMetric("foo1", 1));
metrics.AddItem(MakeMetric("foo2", 2));
MetricsRecord record = new MetricsRecordImpl(MsInfo.Context, (long)10000, tags, metrics
);
ArgumentCaptor <string> argument = ArgumentCaptor.ForClass <string>();
GraphiteSink.Graphite mockGraphite = MakeGraphite();
Whitebox.SetInternalState(sink, "graphite", mockGraphite);
sink.PutMetrics(record);
try
{
Org.Mockito.Mockito.Verify(mockGraphite).Write(argument.Capture());
}
catch (IOException e)
{
Runtime.PrintStackTrace(e);
}
string result = argument.GetValue();
Assert.Equal(true, result.Equals("null.all.Context.Context=all.foo1 1 10\n"
+ "null.all.Context.Context=all.foo2 2 10\n") || result.Equals("null.all.Context.Context=all.foo2 2 10\n"
+ "null.all.Context.Context=all.foo1 1 10\n"));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldClearSlavesWhenNewMasterElected()
public virtual void ShouldClearSlavesWhenNewMasterElected()
{
// given
Cluster cluster = mock(typeof(Cluster));
ClusterMembers clusterMembers = mock(typeof(ClusterMembers));
when(clusterMembers.AliveMembers).thenReturn(Iterables.option((new ClusterMember(_instanceId)).availableAs(SLAVE, _haUri, StoreId.DEFAULT)));
SlaveFactory slaveFactory = mock(typeof(SlaveFactory));
Slave slave1 = mock(typeof(Slave));
Slave slave2 = mock(typeof(Slave));
when(slaveFactory.NewSlave(any(typeof(LifeSupport)), any(typeof(ClusterMember)), any(typeof(string)), any(typeof(Integer)))).thenReturn(slave1, slave2);
HighAvailabilitySlaves slaves = new HighAvailabilitySlaves(clusterMembers, cluster, slaveFactory, new HostnamePort("localhost", 0));
slaves.Init();
ArgumentCaptor <ClusterListener> listener = ArgumentCaptor.forClass(typeof(ClusterListener));
verify(cluster).addClusterListener(listener.capture());
// when
Slave actualSlave1 = slaves.Slaves.GetEnumerator().next();
listener.Value.elected(ClusterConfiguration.COORDINATOR, _instanceId, _clusterUri);
Slave actualSlave2 = slaves.Slaves.GetEnumerator().next();
// then
assertThat(actualSlave2, not(sameInstance(actualSlave1)));
}
public async Task NewBrandCommandHandler_Works()
{
var repository = new Mock <IRepository>();
var brand = new Brand {
Id = 1, Name = "a", ImageUri = "uri"
};
var captor = new ArgumentCaptor <Brand>();
repository.Setup(x => x.InsertAsync(captor.Capture()))
.ReturnsAsync(brand);
var handler = new NewBrandCommandHandler(repository.Object);
var result = await handler
.Handle(new NewBrandCommand(brand.Name, brand.ImageUri), It.IsAny <CancellationToken>())
.ConfigureAwait(false);
result.Should().BeOfType <BrandDto>();
result.Id.Should().Equals(brand.Id);
result.ImageUri.Should().Equals(brand.ImageUri);
result.Name.Should().Equals(brand.Name);
captor.Value.Name.Should().Be(brand.Name);
captor.Value.ImageUri.Should().Be(brand.ImageUri);
repository.Verify(x => x.InsertAsync(captor.Value), Times.Once);
repository.VerifyNoOtherCalls();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldResumeWhenWritabilityChanged() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldResumeWhenWritabilityChanged()
{
TestThrottleLock lockOverride = new TestThrottleLock();
// given
TransportThrottle throttle = NewThrottleAndInstall(_channel, lockOverride);
when(_channel.Writable).thenReturn(false);
Future <Void> completionFuture = OtherThread.execute(state =>
{
throttle.Acquire(_channel);
return(null);
});
OtherThread.get().waitUntilWaiting();
// when
when(_channel.Writable).thenReturn(true);
ArgumentCaptor <ChannelInboundHandler> captor = ArgumentCaptor.forClass(typeof(ChannelInboundHandler));
verify(_channel.pipeline()).addLast(captor.capture());
captor.Value.channelWritabilityChanged(_context);
OtherThread.get().awaitFuture(completionFuture);
assertThat(lockOverride.LockCallCount(), greaterThan(0));
assertThat(lockOverride.UnlockCallCount(), @is(1));
}
public async Task SendDeleteRequestAsync()
{
var response = new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(JsonConvert.SerializeObject(new Comment {
Body = "My Comment"
}))
};
var handler = new Mock <HttpMessageHandler>(MockBehavior.Strict);
handler.Protected()
.Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>())
.ReturnsAsync(response);
var httpClientFactory = new Mock <IHttpClientFactory>();
httpClientFactory.Setup(h => h.CreateClient(SoundCloudClient.HttpClientName)).Returns(new HttpClient(handler.Object));
// Act
var uri = new Uri("http://localhost:5000");
var result = await new SoundCloudApiGateway(httpClientFactory.Object).SendDeleteRequestAsync <Comment>(uri);
// Assert
Assert.That(result.Body, Is.EqualTo("My Comment"));
var captor = new ArgumentCaptor <HttpRequestMessage>();
handler.Protected().Verify("SendAsync", Times.Once(), captor.CaptureExpr(), ItExpr.IsAny <CancellationToken>());
Assert.That(captor.Value.RequestUri, Is.EqualTo(uri));
Assert.That(captor.Value.Method, Is.EqualTo(HttpMethod.Delete));
}
public _Supplier_457(DatanodeProtocolClientSideTranslatorPB mockNN, string fakeBlockPoolId
, ArgumentCaptor <StorageReceivedDeletedBlocks[]> captor)
{
this.mockNN = mockNN;
this.fakeBlockPoolId = fakeBlockPoolId;
this.captor = captor;
}
private static void AssertMessageHexDumpLogged(Log logMock, sbyte[] messageBytes)
{
ArgumentCaptor <string> captor = ArgumentCaptor.forClass(typeof(string));
verify(logMock).error(captor.capture());
assertThat(captor.Value, containsString(hexDump(messageBytes)));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test @SuppressWarnings("unchecked") public void shouldOnlySummarizeStatisticsWhenAllReferencesAreChecked()
public virtual void ShouldOnlySummarizeStatisticsWhenAllReferencesAreChecked()
{
// given
ConsistencySummaryStatistics summary = mock(typeof(ConsistencySummaryStatistics));
RecordAccess records = mock(typeof(RecordAccess));
ConsistencyReporter.ReportHandler handler = new ConsistencyReporter.ReportHandler(new InconsistencyReport(mock(typeof(InconsistencyLogger)), summary), mock(typeof(ConsistencyReporter.ProxyFactory)), RecordType.PROPERTY, records, new PropertyRecord(0), NO_MONITOR);
RecordReference <PropertyRecord> reference = mock(typeof(RecordReference));
ComparativeRecordChecker <PropertyRecord, PropertyRecord, ConsistencyReport_PropertyConsistencyReport> checker = mock(typeof(ComparativeRecordChecker));
handler.comparativeCheck(reference, checker);
ArgumentCaptor <PendingReferenceCheck <PropertyRecord> > captor = ( ArgumentCaptor )ArgumentCaptor.forClass(typeof(PendingReferenceCheck));
verify(reference).dispatch(captor.capture());
PendingReferenceCheck pendingRefCheck = captor.Value;
// when
handler.updateSummary();
// then
verifyZeroInteractions(summary);
// when
pendingRefCheck.skip();
// then
verify(summary).update(RecordType.PROPERTY, 0, 0);
verifyNoMoreInteractions(summary);
}
public static float GetFloatGauge(string name, MetricsRecordBuilder rb)
{
ArgumentCaptor <float> captor = ArgumentCaptor.ForClass <float>();
Org.Mockito.Mockito.Verify(rb, Org.Mockito.Mockito.AtLeast(0)).AddGauge(EqName(Interns.Info
(name, string.Empty)), captor.Capture());
CheckCaptured(captor, name);
return(captor.GetValue());
}
public static long GetLongCounter(string name, MetricsRecordBuilder rb)
{
ArgumentCaptor <long> captor = ArgumentCaptor.ForClass <long>();
Org.Mockito.Mockito.Verify(rb, Org.Mockito.Mockito.AtLeast(0)).AddCounter(EqName(
Interns.Info(name, string.Empty)), captor.Capture());
CheckCaptured(captor, name);
return(captor.GetValue());
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void verifyVerifyUniqueness(org.neo4j.kernel.api.impl.schema.SchemaIndex index, org.neo4j.internal.kernel.api.schema.SchemaDescriptor descriptor, Object... values) throws java.io.IOException, org.neo4j.kernel.api.exceptions.index.IndexEntryConflictException
private void VerifyVerifyUniqueness(SchemaIndex index, SchemaDescriptor descriptor, params object[] values)
{
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("unchecked") org.mockito.ArgumentCaptor<java.util.List<org.neo4j.values.storable.Value[]>> captor = org.mockito.ArgumentCaptor.forClass(java.util.List.class);
ArgumentCaptor <IList <Value[]> > captor = ArgumentCaptor.forClass(typeof(System.Collections.IList));
verify(index).verifyUniqueness(any(), eq(descriptor.PropertyIds), captor.capture());
assertThat(captor.Value, containsInAnyOrder(valueTupleList(values).toArray()));
}
public void TestAssignSlotOffsetLength()
{
var placedArrayCaptor = new ArgumentCaptor <byte[]>();
var random = new Random(0);
var data = new byte[100].With(random.NextBytes);
testObj.AssignSlot(SLOT_INDEX, data, 10, 80);
Verify(slotDestination).SetSlot(Eq(SLOT_INDEX), placedArrayCaptor.GetParameter(), Eq(10), Eq(80));
VerifyNoMoreInteractions();
AssertTrue(placedArrayCaptor.Value == data);
}
/// <exception cref="System.Exception"/>
private ReceivedDeletedBlockInfo[] WaitForBlockReceived(ExtendedBlock fakeBlock,
DatanodeProtocolClientSideTranslatorPB mockNN)
{
string fakeBlockPoolId = fakeBlock.GetBlockPoolId();
ArgumentCaptor <StorageReceivedDeletedBlocks[]> captor = ArgumentCaptor.ForClass <StorageReceivedDeletedBlocks
[]>();
GenericTestUtils.WaitFor(new _Supplier_457(mockNN, fakeBlockPoolId, captor), 100,
10000);
return(captor.GetValue()[0].GetBlocks());
}
public void TestWriteBytesOffsetLength()
{
var placedArrayCaptor = new ArgumentCaptor <byte[]>();
var random = new Random(0);
var data = new byte[100].With(random.NextBytes);
testObj.WriteBytes(SLOT_INDEX, data, 10, 80);
Verify(slotDestination).SetSlot(Eq(SLOT_INDEX), placedArrayCaptor.GetParameter());
VerifyNoMoreInteractions();
AssertTrue(placedArrayCaptor.Value != data);
AssertTrue(placedArrayCaptor.Value.SequenceEqual(data.Skip(10).Take(80)));
}
public async Task NewRecordCommandHandler_Verify_Dependencies()
{
var repository = new Mock <IRepository>();
var record = GetRecord();
var flavors = new string[] { "a", "b", "c" };
var flavorPredicateCaptor = new ExpressionCaptor <Flavor, bool>();
repository.Setup(x => x.ListAsync(flavorPredicateCaptor.Capture()))
.ReturnsAsync(new List <Flavor> {
new Flavor {
Id = 1, Name = "a",
}
});
var recordCaptor = new ArgumentCaptor <Record>();
repository.Setup(x => x.InsertAsync(recordCaptor.Capture()))
.ReturnsAsync(record);
var flavorCaptor = new ArgumentCaptor <List <Flavor> >();
repository.Setup(x => x.InsertRangeAsync(flavorCaptor.Capture()))
.ReturnsAsync(
new List <Flavor> {
new Flavor {
Id = 2, Name = "b",
},
new Flavor {
Id = 3, Name = "c",
}
});
var recordFlavorCaptor = new ArgumentCaptor <List <RecordFlavor> >();
repository.Setup(x => x.InsertRangeAsync(recordFlavorCaptor.Capture()));
var handler = new NewRecordCommandHandler(repository.Object);
var result = await handler
.Handle(new NewRecordCommand(record.CoffeeId, record.DoseIn, record.DoseOut, record.Time, flavors, record.Rating),
It.IsAny <CancellationToken>())
.ConfigureAwait(false);
repository.Verify(x => x.InsertAsync(recordCaptor.Value), Times.Once);
repository.Verify(x => x.InsertRangeAsync(flavorCaptor.Value), Times.Once);
repository.Verify(x => x.InsertRangeAsync(recordFlavorCaptor.Value), Times.Once);
repository.Verify(x => x.ListAsync(flavorPredicateCaptor.Value), Times.Once);
repository.VerifyNoOtherCalls();
}
private void VerifyFailedStatus(MRAppMasterTest appMaster, string expectedJobState
)
{
ArgumentCaptor<JobHistoryEvent> captor = ArgumentCaptor.ForClass<JobHistoryEvent>
();
// handle two events: AMStartedEvent and JobUnsuccessfulCompletionEvent
Org.Mockito.Mockito.Verify(appMaster.spyHistoryService, Org.Mockito.Mockito.Times
(2)).HandleEvent(captor.Capture());
HistoryEvent @event = captor.GetValue().GetHistoryEvent();
NUnit.Framework.Assert.IsTrue(@event is JobUnsuccessfulCompletionEvent);
NUnit.Framework.Assert.AreEqual(((JobUnsuccessfulCompletionEvent)@event).GetStatus
(), expectedJobState);
}
public void ReadTypeTest()
{
var int32TypeId = (int)ReservedTypeId.TYPE_S32;
var typeDescriptionCaptor = new ArgumentCaptor <PofTypeDescription>();
When(context.GetTypeOrNull(int32TypeId)).ThenReturn(typeof(int));
When(context.GetTypeFromDescription(typeDescriptionCaptor.GetParameter())).ThenReturn(typeof(int));
When(slotSource[kSlotIndex]).ThenReturn(BitConverter.GetBytes(int32TypeId));
AssertEquals(typeof(int), testObj.ReadType(kSlotIndex));
var typeDescription = typeDescriptionCaptor.Value;
AssertEquals(1, typeDescription.All().Length);
AssertEquals(typeof(int), typeDescription.All()[0]);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldResumeAsyncResponseDueToTooManyRequests()
public virtual void shouldResumeAsyncResponseDueToTooManyRequests()
{
// given
// when
AsyncResponse asyncResponse = mock(typeof(AsyncResponse));
handler.errorTooManyRequests(asyncResponse);
// then
ArgumentCaptor <InvalidRequestException> argumentCaptor = ArgumentCaptor.forClass(typeof(InvalidRequestException));
verify(asyncResponse).resume(argumentCaptor.capture());
assertThat(argumentCaptor.Value.Message, @is("At the moment the server has to handle too " + "many requests at the same time. Please try again later."));
}
public void TestType()
{
var type = typeof(int);
var int32TypeId = (int)ReservedTypeId.TYPE_S32;
When(context.GetTypeIdByType(typeof(int))).ThenReturn(int32TypeId);
testObj.WriteType(SLOT_INDEX, type);
var streamCaptor = new ArgumentCaptor <MemoryStream>();
Verify(context).GetTypeIdByType(typeof(int));
Verify(slotDestination).SetSlot(Eq(SLOT_INDEX), streamCaptor.GetParameter());
VerifyNoMoreInteractions();
var slotStream = streamCaptor.Value;
AssertEquals(slotStream.ToArray(), BitConverter.GetBytes(int32TypeId));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Ignore @Test public void shouldSetAuthenticationProperly()
public virtual void shouldSetAuthenticationProperly()
{
when(identityServiceMock.CurrentAuthentication).thenReturn(new Authentication(MockProvider.EXAMPLE_USER_ID, groupIds, tenantIds));
FetchExternalTasksExtendedDto fetchExternalTasksDto = createDto(500L);
given().contentType(ContentType.JSON).body(fetchExternalTasksDto).pathParam("name", "default").when().post(FETCH_EXTERNAL_TASK_URL_NAMED_ENGINE);
ArgumentCaptor <Authentication> argumentCaptor = ArgumentCaptor.forClass(typeof(Authentication));
verify(identityServiceMock, atLeastOnce()).Authentication = argumentCaptor.capture();
assertThat(argumentCaptor.Value.UserId, @is(MockProvider.EXAMPLE_USER_ID));
assertThat(argumentCaptor.Value.GroupIds, @is(groupIds));
assertThat(argumentCaptor.Value.TenantIds, @is(tenantIds));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void databasePanicIsRaisedWhenTxApplicationFails() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void DatabasePanicIsRaisedWhenTxApplicationFails()
{
RecordStorageEngine engine = BuildRecordStorageEngine();
Exception applicationError = ExecuteFailingTransaction(engine);
ArgumentCaptor <Exception> captor = ArgumentCaptor.forClass(typeof(Exception));
verify(_databaseHealth).panic(captor.capture());
Exception exception = captor.Value;
if (exception is KernelException)
{
assertThat((( KernelException )exception).status(), @is(Org.Neo4j.Kernel.Api.Exceptions.Status_General.UnknownError));
exception = exception.InnerException;
}
assertThat(exception, @is(applicationError));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void appliesDefaultTuningConfigurationForConsistencyChecker() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void AppliesDefaultTuningConfigurationForConsistencyChecker()
{
// given
string[] args = new string[] { "-host", "localhost", "-to", "my_backup" };
BackupProtocolService service = mock(typeof(BackupProtocolService));
PrintStream systemOut = mock(typeof(PrintStream));
// when
(new BackupTool(service, systemOut)).Run(args);
// then
ArgumentCaptor <Config> config = ArgumentCaptor.forClass(typeof(Config));
verify(service).doIncrementalBackupOrFallbackToFull(anyString(), anyInt(), eq(DatabaseLayout.of(Paths.get("my_backup").toFile())), any(typeof(ConsistencyCheck)), config.capture(), eq(BackupClient.BIG_READ_TIMEOUT), eq(false));
assertFalse(config.Value.get(ConsistencyCheckSettings.consistency_check_property_owners));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldSetWriteBufferWatermarkOnChannelConfigWhenInstalled()
public virtual void ShouldSetWriteBufferWatermarkOnChannelConfigWhenInstalled()
{
// given
TransportThrottle throttle = NewThrottle();
// when
throttle.Install(_channel);
// expect
ArgumentCaptor <WriteBufferWaterMark> argument = ArgumentCaptor.forClass(typeof(WriteBufferWaterMark));
verify(_config, times(1)).WriteBufferWaterMark = argument.capture();
assertEquals(64, argument.Value.low());
assertEquals(256, argument.Value.high());
}
private void VerifyCapturedArguments(ArgumentCaptor <StorageBlockReport[]> captor,
int expectedReportsPerCall, int expectedTotalBlockCount)
{
IList <StorageBlockReport[]> listOfReports = captor.GetAllValues();
int numBlocksReported = 0;
foreach (StorageBlockReport[] reports in listOfReports)
{
Assert.AssertThat(reports.Length, IS.Is(expectedReportsPerCall));
foreach (StorageBlockReport report in reports)
{
BlockListAsLongs blockList = report.GetBlocks();
numBlocksReported += blockList.GetNumberOfBlocks();
}
}
System.Diagnostics.Debug.Assert((numBlocksReported >= expectedTotalBlockCount));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void appliesDefaultTuningConfigurationForConsistencyChecker() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void AppliesDefaultTuningConfigurationForConsistencyChecker()
{
// given
DatabaseLayout databaseLayout = _testDirectory.databaseLayout();
string[] args = new string[] { databaseLayout.DatabaseDirectory().AbsolutePath };
ConsistencyCheckService service = mock(typeof(ConsistencyCheckService));
// when
RunConsistencyCheckToolWith(service, args);
// then
ArgumentCaptor <Config> config = ArgumentCaptor.forClass(typeof(Config));
verify(service).runFullConsistencyCheck(eq(databaseLayout), config.capture(), any(typeof(ProgressMonitorFactory)), any(typeof(LogProvider)), any(typeof(FileSystemAbstraction)), anyBoolean(), any(typeof(ConsistencyFlags)));
assertFalse(config.Value.get(ConsistencyCheckSettings.ConsistencyCheckPropertyOwners));
}
public void RegisterHandler_Generic_Test()
{
object parameterObject = new object();
bool handlerExecuted = false;
var handler = new Action <object>(o => { handlerExecuted = o == parameterObject; });
testObj.RegisterHandler(handler);
var captor = new ArgumentCaptor <Action <object> >();
Verify(handlersByType).TryAdd(Eq(typeof(object)), captor.GetParameter());
VerifyNoMoreInteractions();
AssertFalse(handlerExecuted);
captor.Value(parameterObject);
AssertTrue(handlerExecuted);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void lockResultMustHaveMessageWhenAcquiringSharedLockWithoutConversation() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void LockResultMustHaveMessageWhenAcquiringSharedLockWithoutConversation()
{
MasterImpl.SPI spi = MockedSpi();
ConversationManager conversationManager = mock(typeof(ConversationManager));
Config config = config();
MasterImpl master = new MasterImpl(spi, conversationManager, null, config);
RequestContext context = CreateRequestContext(master);
when(conversationManager.Acquire(context)).thenThrow(new NoSuchEntryException(""));
master.AcquireSharedLock(context, ResourceTypes.NODE, 1);
ArgumentCaptor <LockResult> captor = ArgumentCaptor.forClass(typeof(LockResult));
verify(spi).packTransactionObligationResponse(MockitoHamcrest.argThat(@is(context)), captor.capture());
assertThat(captor.Value.Message, @is(not(nullValue())));
}
