//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldAddAndReadMultipleKeys() throws java.io.IOException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
internal virtual void ShouldAddAndReadMultipleKeys()
{
IList <GenericKey> keys = new List <GenericKey>();
int numberOfKeys = 1000;
for (int i = 0; i < numberOfKeys; i++)
{
keys.Add(RandomKey(i));
}
using (IndexKeyStorage <GenericKey> keyStorage = keyStorage())
{
foreach (GenericKey key in keys)
{
keyStorage.add(key);
}
keyStorage.doneAdding();
using (IndexKeyStorage.KeyEntryCursor <GenericKey> reader = keyStorage.reader())
{
foreach (GenericKey expected in keys)
{
assertTrue(reader.Next());
GenericKey actual = reader.Key();
assertEquals(0, _layout.compare(expected, actual), "Expected stored key to be equal to original.");
}
assertFalse(reader.Next(), "Expected reader to have no more entries, but had at least one additional " + reader.Key());
}
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void verifyUniqueKeys(IndexKeyStorage.KeyEntryCursor<KEY> allConflictingKeys) throws java.io.IOException, org.neo4j.kernel.api.exceptions.index.IndexEntryConflictException
private void VerifyUniqueKeys(IndexKeyStorage.KeyEntryCursor <KEY> allConflictingKeys)
{
while (allConflictingKeys.Next() && !_cancellation.cancelled())
{
KEY key = allConflictingKeys.Key();
key.CompareId = false;
VerifyUniqueSeek(tree.seek(key, key));
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldAddAndReadZeroKey() throws java.io.IOException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
internal virtual void ShouldAddAndReadZeroKey()
{
using (IndexKeyStorage <GenericKey> keyStorage = keyStorage())
{
keyStorage.doneAdding();
using (IndexKeyStorage.KeyEntryCursor <GenericKey> reader = keyStorage.reader())
{
assertFalse(reader.Next(), "Didn't expect reader to have any entries.");
}
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldAddAndReadOneKey() throws java.io.IOException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
internal virtual void ShouldAddAndReadOneKey()
{
using (IndexKeyStorage <GenericKey> keyStorage = keyStorage())
{
GenericKey expected = RandomKey(1);
keyStorage.add(expected);
keyStorage.doneAdding();
using (IndexKeyStorage.KeyEntryCursor <GenericKey> reader = keyStorage.reader())
{
assertTrue(reader.Next(), "Expected reader to have one entry");
GenericKey actual = reader.Key();
assertEquals(0, _layout.compare(expected, actual), "Expected stored key to be equal to original.");
assertFalse(reader.Next(), "Expected reader to have only one entry, second entry was " + reader.Key());
}
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public void scanCompleted(org.neo4j.kernel.impl.api.index.PhaseTracker phaseTracker) throws org.neo4j.kernel.api.exceptions.index.IndexEntryConflictException
public override void ScanCompleted(PhaseTracker phaseTracker)
{
if (!MarkMergeStarted())
{
// This populator has already been closed, either from an external cancel or drop call.
// Either way we're not supposed to do this merge.
return;
}
try
{
phaseTracker.EnterPhase(Org.Neo4j.Kernel.Impl.Api.index.PhaseTracker_Phase.Merge);
if (_allScanUpdates.Count > 0)
{
MergeScanUpdates();
}
_externalUpdates.doneAdding();
// don't merge and sort the external updates
// Build the tree from the scan updates
if (_cancellation.cancelled())
{
// Do one additional check before starting to write to the tree
return;
}
phaseTracker.EnterPhase(Org.Neo4j.Kernel.Impl.Api.index.PhaseTracker_Phase.Build);
File duplicatesFile = new File(storeFile.ParentFile, storeFile.Name + ".dup");
int readBufferSize = SmallerBufferSize();
using (Allocator allocator = _bufferFactory.newLocalAllocator(), IndexKeyStorage <KEY> indexKeyStorage = new IndexKeyStorage <KEY>(fileSystem, duplicatesFile, allocator, readBufferSize, layout))
{
RecordingConflictDetector <KEY, VALUE> recordingConflictDetector = new RecordingConflictDetector <KEY, VALUE>(!descriptor.Unique, indexKeyStorage);
WriteScanUpdatesToTree(recordingConflictDetector, allocator, readBufferSize);
// Apply the external updates
phaseTracker.EnterPhase(Org.Neo4j.Kernel.Impl.Api.index.PhaseTracker_Phase.ApplyExternal);
WriteExternalUpdatesToTree(recordingConflictDetector);
// Verify uniqueness
if (descriptor.Unique)
{
using (IndexKeyStorage.KeyEntryCursor <KEY> allConflictingKeys = recordingConflictDetector.AllConflicts())
{
VerifyUniqueKeys(allConflictingKeys);
}
}
}
}
catch (IOException e)
{
throw new UncheckedIOException(e);
}
catch (InterruptedException e)
{
Thread.CurrentThread.Interrupt();
throw new Exception("Got interrupted, so merge not completed", e);
}
catch (ExecutionException e)
{
// Propagating merge exception from other thread
Exception executionException = e.InnerException;
if (executionException is Exception)
{
throw ( Exception )executionException;
}
throw new Exception(executionException);
}
finally
{
_mergeOngoingLatch.Signal();
}
}
