//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void execute(java.util.List<Action> load, GBPTree<KEY,VALUE> index) throws java.io.IOException private void Execute(IList <Action> load, GBPTree <KEY, VALUE> index) { foreach (Action action in load) { action.Execute(index); } }
internal NativeIndexReader(GBPTree <KEY, VALUE> tree, IndexLayout <KEY, VALUE> layout, IndexDescriptor descriptor) { this.Tree = tree; this.Layout = layout; this.Descriptor = descriptor; this.OpenSeekers = new HashSet <RawCursor <Hit <KEY, VALUE>, IOException> >(); }
internal virtual void InstantiateTree(RecoveryCleanupWorkCollector recoveryCleanupWorkCollector, System.Action <PageCursor> headerWriter) { EnsureDirectoryExist(); GBPTree.Monitor monitor = TreeMonitor(); Tree = new GBPTree <KEY, VALUE>(PageCache, StoreFile, Layout, 0, monitor, NO_HEADER_READER, headerWriter, recoveryCleanupWorkCollector, _readOnly); AfterTreeInstantiation(Tree); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: void verifyUpdates(org.neo4j.kernel.api.index.IndexEntryUpdate<org.neo4j.storageengine.api.schema.IndexDescriptor>[] updates) throws java.io.IOException internal virtual void VerifyUpdates(IndexEntryUpdate <IndexDescriptor>[] updates) { Hit <KEY, VALUE>[] expectedHits = ConvertToHits(updates, Layout); IList <Hit <KEY, VALUE> > actualHits = new List <Hit <KEY, VALUE> >(); using (GBPTree <KEY, VALUE> tree = Tree, RawCursor <Hit <KEY, VALUE>, IOException> scan = scan(tree)) { while (scan.Next()) { actualHits.Add(DeepCopy(scan.get())); } } IComparer <Hit <KEY, VALUE> > hitComparator = (h1, h2) => { int keyCompare = Layout.compare(h1.key(), h2.key()); if (keyCompare == 0) { return(ValueCreatorUtil.compareIndexedPropertyValue(h1.key(), h2.key())); } else { return(keyCompare); } }; AssertSameHits(expectedHits, actualHits.ToArray(), hitComparator); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldCloseUnexhaustedCursorsOnReaderClose() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldCloseUnexhaustedCursorsOnReaderClose() { // GIVEN GBPTree <LabelScanKey, LabelScanValue> index = mock(typeof(GBPTree)); RawCursor <Hit <LabelScanKey, LabelScanValue>, IOException> cursor1 = mock(typeof(RawCursor)); when(cursor1.Next()).thenReturn(false); RawCursor <Hit <LabelScanKey, LabelScanValue>, IOException> cursor2 = mock(typeof(RawCursor)); when(cursor2.Next()).thenReturn(false); when(index.Seek(any(typeof(LabelScanKey)), any(typeof(LabelScanKey)))).thenReturn(cursor1, cursor2); // WHEN using (NativeLabelScanReader reader = new NativeLabelScanReader(index)) { // first check test invariants reader.NodesWithLabel(LABEL_ID); reader.NodesWithLabel(LABEL_ID); verify(cursor1, never()).close(); verify(cursor2, never()).close(); } // THEN verify(cursor1, times(1)).close(); verify(cursor2, times(1)).close(); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void randomlyModifyIndex(GBPTree<KEY,VALUE> index, java.util.Map<KEY,VALUE> data, java.util.Random random, double removeProbability) throws java.io.IOException private void RandomlyModifyIndex(GBPTree <KEY, VALUE> index, IDictionary <KEY, VALUE> data, Random random, double removeProbability) { int changeCount = random.Next(10) + 10; using (Writer <KEY, VALUE> writer = CreateWriter(index)) { for (int i = 0; i < changeCount; i++) { if (random.NextDouble() < removeProbability && data.Count > 0) { // remove KEY key = RandomKey(data, random); VALUE value = data.Remove(key); VALUE removedValue = writer.Remove(key); AssertEqualsValue(value, removedValue); } else { // put KEY key = RandomKey(random); VALUE value = RandomValue(random); writer.Put(key, value); data[key] = value; } } } }
// Timeout because test verify no infinite loop //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test(timeout = 10_000L) public void shouldHandleDescendingWithEmptyRange() throws java.io.IOException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldHandleDescendingWithEmptyRange() { long[] seeds = new long[] { 0, 1, 4 }; using (GBPTree <KEY, VALUE> index = CreateIndex()) { // Write using (Writer <KEY, VALUE> writer = CreateWriter(index)) { foreach (long seed in seeds) { KEY key = _layout.key(seed); VALUE value = _layout.value(0); writer.Put(key, value); } } KEY from = _layout.key(3); KEY to = _layout.key(1); using (RawCursor <Hit <KEY, VALUE>, IOException> seek = index.Seek(from, to)) { assertFalse(seek.Next()); } index.Checkpoint(Org.Neo4j.Io.pagecache.IOLimiter_Fields.Unlimited); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: static String readFailureMessage(org.neo4j.io.pagecache.PageCache pageCache, java.io.File indexFile) throws java.io.IOException internal static string ReadFailureMessage(PageCache pageCache, File indexFile) { NativeIndexHeaderReader headerReader = new NativeIndexHeaderReader(NO_HEADER_READER); GBPTree.readHeader(pageCache, indexFile, headerReader); return(headerReader.FailureMessage); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private GBPTree<KEY,VALUE> createIndex() throws java.io.IOException private GBPTree <KEY, VALUE> CreateIndex() { // some random padding _layout = GetLayout(Random); PageCache pageCache = _pageCacheRule.getPageCache(_fs.get(), config().withPageSize(512).withAccessChecks(true)); return(_index = (new GBPTreeBuilder <KEY, VALUE>(pageCache, _directory.file("index"), _layout)).build()); }
/// <summary> /// Shuts down this store so that no more queries or updates can be accepted. /// </summary> /// <exception cref="IOException"> on <seealso cref="PageCache"/> exceptions. </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public void shutdown() throws java.io.IOException public override void Shutdown() { if (_index != null) { _index.Dispose(); _index = null; _writeMonitor.close(); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void dropStrict() throws java.io.IOException private void DropStrict() { if (_index != null) { _index.Dispose(); _index = null; } _fileSystem.deleteFileOrThrow(_storeFile); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void setupIndex() throws java.io.IOException private void SetupIndex() { RecoveryCleanupWorkCollector recoveryCleanupWorkCollector = RecoveryCleanupWorkCollector.Immediate(); bool readOnly = true; // tree = new GBPTree<>( pageCache, indexFile, layout, pageSize, NO_MONITOR, NO_HEADER_READER, NO_HEADER_WRITER, // RecoveryCleanupWorkCollector.immediate() ); _tree = new GBPTree <MutableLong, MutableLong>(_pageCache, _indexFile, _layout, _pageSize, NO_MONITOR, NO_HEADER_READER, NO_HEADER_WRITER, recoveryCleanupWorkCollector, readOnly); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public static SpaceFillingCurveSettings fromGBPTree(java.io.File indexFile, org.neo4j.io.pagecache.PageCache pageCache, System.Func<ByteBuffer,String> onError) throws java.io.IOException public static SpaceFillingCurveSettings FromGBPTree(File indexFile, PageCache pageCache, System.Func <ByteBuffer, string> onError) { SpaceFillingCurveSettings.SettingsFromIndexHeader settings = new SpaceFillingCurveSettings.SettingsFromIndexHeader(); GBPTree.readHeader(pageCache, indexFile, settings.HeaderReader(onError)); if (settings.Failed) { throw new IOException(settings.FailureMessage); } return(settings); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public void execute(GBPTree<KEY,VALUE> index) throws java.io.IOException public override void Execute(GBPTree <KEY, VALUE> index) { using (Writer <KEY, VALUE> writer = index.Writer()) { for (int i = 0; i < DataConflict.Length;) { writer.Put(outerInstance.key(DataConflict[i++]), outerInstance.value(DataConflict[i++])); } } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public void execute(GBPTree<KEY,VALUE> index) throws java.io.IOException public override void Execute(GBPTree <KEY, VALUE> index) { using (Writer <KEY, VALUE> writer = index.Writer()) { for (int i = 0; i < DataConflict.Length;) { KEY key = key(DataConflict[i++]); i++; // value writer.Remove(key); } } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private org.neo4j.cursor.RawCursor<org.neo4j.index.internal.gbptree.Hit<KEY,VALUE>, java.io.IOException> scan(org.neo4j.index.internal.gbptree.GBPTree<KEY,VALUE> tree) throws java.io.IOException private RawCursor <Hit <KEY, VALUE>, IOException> Scan(GBPTree <KEY, VALUE> tree) { KEY lowest = Layout.newKey(); lowest.initialize(long.MinValue); lowest.initValueAsLowest(0, ValueGroup.UNKNOWN); KEY highest = Layout.newKey(); highest.initialize(long.MaxValue); highest.initValueAsHighest(0, ValueGroup.UNKNOWN); return(tree.Seek(lowest, highest)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldHandleRemoveEntireTree() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldHandleRemoveEntireTree() { // given using (GBPTree <KEY, VALUE> index = CreateIndex()) { int numberOfNodes = 200_000; using (Writer <KEY, VALUE> writer = CreateWriter(index)) { for (int i = 0; i < numberOfNodes; i++) { writer.Put(Key(i), Value(i)); } } // when BitArray removed = new BitArray(); using (Writer <KEY, VALUE> writer = CreateWriter(index)) { for (int i = 0; i < numberOfNodes - numberOfNodes / 10; i++) { int candidate; do { candidate = Random.Next(max(1, Random.Next(numberOfNodes))); } while (removed.Get(candidate)); removed.Set(candidate, true); writer.Remove(Key(candidate)); } } int next = 0; using (Writer <KEY, VALUE> writer = CreateWriter(index)) { for (int i = 0; i < numberOfNodes / 10; i++) { next = removed.nextClearBit(next); removed.Set(next, true); writer.Remove(Key(next)); } } // then using (RawCursor <Hit <KEY, VALUE>, IOException> seek = index.Seek(Key(0), Key(numberOfNodes))) { assertFalse(seek.Next()); } // and finally index.ConsistencyCheck(); } }
/// <summary> /// Throws <seealso cref="FormatViolationException"/> if format has changed. /// </summary> //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @SuppressWarnings("EmptyTryBlock") @Override protected void verifyFormat(java.io.File storeFile) throws java.io.IOException, FormatViolationException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: protected internal override void VerifyFormat( File storeFile ) { PageCache pageCache = _pageCacheRule.getPageCache( GlobalFs.get() ); try { using ( GBPTree<MutableLong, MutableLong> ignored = ( new GBPTreeBuilder<MutableLong, MutableLong>( pageCache, storeFile, Layout ) ).build() ) { } } catch ( MetadataMismatchException e ) { throw new FormatViolationException( this, e ); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void mustStayCorrectWhenInsertingValuesOfIncreasingLength() throws java.io.IOException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void MustStayCorrectWhenInsertingValuesOfIncreasingLength() { Layout <RawBytes, RawBytes> layout = layout(); using (GBPTree <RawBytes, RawBytes> index = CreateIndex(layout), Writer <RawBytes, RawBytes> writer = index.Writer()) { RawBytes emptyValue = layout.NewValue(); emptyValue.Bytes = new sbyte[0]; for (int keySize = 1; keySize < index.KeyValueSizeCap(); keySize++) { RawBytes key = layout.NewKey(); key.Bytes = new sbyte[keySize]; writer.Put(key, emptyValue); } } }
private static LayoutBootstrapper GenericLayout() { return((indexFile, pageCache, meta, targetLayout) => { if (targetLayout.contains("generic")) { string numberOfSlotsString = targetLayout.replace("generic", ""); int numberOfSlots = int.Parse(numberOfSlotsString); IDictionary <CoordinateReferenceSystem, SpaceFillingCurveSettings> settings = new Dictionary <CoordinateReferenceSystem, SpaceFillingCurveSettings>(); GBPTree.readHeader(pageCache, indexFile, new NativeIndexHeaderReader(new SpaceFillingCurveSettingsReader(settings))); ConfiguredSpaceFillingCurveSettingsCache configuredSettings = new ConfiguredSpaceFillingCurveSettingsCache(Config.defaults()); return new GenericLayout(numberOfSlots, new IndexSpecificSpaceFillingCurveSettingsCache(configuredSettings, settings)); } return null; }); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: protected void createStoreFile(java.io.File storeFile) throws java.io.IOException protected internal override void CreateStoreFile( File storeFile ) { IList<long> initialKeys = initialKeys(); PageCache pageCache = _pageCacheRule.getPageCache( GlobalFs.get() ); using ( GBPTree<MutableLong, MutableLong> tree = ( new GBPTreeBuilder<MutableLong, MutableLong>( pageCache, storeFile, Layout ) ).build() ) { using ( Writer<MutableLong, MutableLong> writer = tree.Writer() ) { foreach ( long? key in initialKeys ) { Put( writer, key.Value ); } } tree.Checkpoint( Org.Neo4j.Io.pagecache.IOLimiter_Fields.Unlimited ); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void shouldReadCorrectlyWithConcurrentUpdates(TestCoordinator testCoordinator) throws Throwable private void ShouldReadCorrectlyWithConcurrentUpdates(TestCoordinator testCoordinator) { // Readers config int readers = max(1, Runtime.Runtime.availableProcessors() - 1); // Thread communication System.Threading.CountdownEvent readerReadySignal = new System.Threading.CountdownEvent(readers); System.Threading.CountdownEvent readerStartSignal = new System.Threading.CountdownEvent(1); AtomicBoolean endSignal = testCoordinator.EndSignal(); AtomicBoolean failHalt = new AtomicBoolean(); // Readers signal to writer that there is a failure AtomicReference <Exception> readerError = new AtomicReference <Exception>(); // GIVEN _index = CreateIndex(); testCoordinator.Prepare(_index); // WHEN starting the readers RunnableReader readerTask = new RunnableReader(this, testCoordinator, readerReadySignal, readerStartSignal, endSignal, failHalt, readerError); for (int i = 0; i < readers; i++) { _threadPool.submit(readerTask); } // and starting the checkpointer _threadPool.submit(CheckpointThread(endSignal, readerError, failHalt)); // and starting the writer try { Write(testCoordinator, readerReadySignal, readerStartSignal, endSignal, failHalt); } finally { // THEN no reader should have failed by the time we have finished all the scheduled updates. // A successful read means that all results were ordered and we saw all inserted values and // none of the removed values at the point of making the seek call. endSignal.set(true); _threadPool.shutdown(); _threadPool.awaitTermination(10, TimeUnit.SECONDS); if (readerError.get() != null) { //noinspection ThrowFromFinallyBlock throw readerError.get(); } } }
/* Randomized tests */ //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldSplitCorrectly() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldSplitCorrectly() { // GIVEN using (GBPTree <KEY, VALUE> index = index()) { // WHEN int count = 1_000; IList <KEY> seen = new List <KEY>(count); using (Writer <KEY, VALUE> writer = index.Writer()) { for (int i = 0; i < count; i++) { KEY key; do { key = key(_random.Next(100_000)); } while (ListContains(seen, key)); VALUE value = value(i); writer.Put(key, value); seen.Add(key); } } // THEN using (RawCursor <Hit <KEY, VALUE>, IOException> cursor = index.Seek(Key(0), Key(long.MaxValue))) { long prev = -1; while (cursor.Next()) { KEY hit = cursor.get().key(); long hitSeed = _layout.keySeed(hit); if (hitSeed < prev) { fail(hit + " smaller than prev " + prev); } prev = hitSeed; assertTrue(RemoveFromList(seen, hit)); } if (seen.Count > 0) { fail("expected hits " + seen); } } } }
/// <returns> true if instantiated tree needs to be rebuilt. </returns> private bool InstantiateTree() { _monitors.addMonitorListener(TreeMonitor()); GBPTree.Monitor monitor = _monitors.newMonitor(typeof(GBPTree.Monitor)); MutableBoolean isRebuilding = new MutableBoolean(); Header.Reader readRebuilding = headerData => isRebuilding.setValue(headerData.get() == _needsRebuilding); try { _index = new GBPTree <LabelScanKey, LabelScanValue>(_pageCache, _storeFile, new LabelScanLayout(), _pageSize, monitor, readRebuilding, _needsRebuildingWriter, _recoveryCleanupWorkCollector, _readOnly); return(isRebuilding.Value); } catch (TreeFileNotFoundException e) { throw new System.InvalidOperationException("Label scan store file could not be found, most likely this database needs to be recovered, file:" + _storeFile, e); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void shouldWriteAndReadEntriesOfRandomSizes(int minKeySize, int maxKeySize, int minValueSize, int maxValueSize) throws java.io.IOException private void ShouldWriteAndReadEntriesOfRandomSizes(int minKeySize, int maxKeySize, int minValueSize, int maxValueSize) { // given using (GBPTree <RawBytes, RawBytes> tree = CreateIndex(Layout())) { // when ISet <string> generatedStrings = new HashSet <string>(); IList <Pair <RawBytes, RawBytes> > entries = new List <Pair <RawBytes, RawBytes> >(); using (Writer <RawBytes, RawBytes> writer = tree.Writer()) { for (int i = 0; i < 1_000; i++) { // value, based on i RawBytes value = new RawBytes(); value.Bytes = new sbyte[Random.Next(minValueSize, maxValueSize)]; Random.NextBytes(value.Bytes); // key, randomly generated string @string; do { @string = Random.nextAlphaNumericString(minKeySize, maxKeySize); } while (!generatedStrings.Add(@string)); RawBytes key = new RawBytes(); key.Bytes = UTF8.encode(@string); entries.Add(Pair.of(key, value)); // write writer.Put(key, value); } } // then foreach (Pair <RawBytes, RawBytes> entry in entries) { using (RawCursor <Hit <RawBytes, RawBytes>, IOException> seek = tree.Seek(entry.First(), entry.First())) { assertTrue(seek.Next()); assertArrayEquals(entry.First().Bytes, seek.get().key().bytes); assertArrayEquals(entry.Other().Bytes, seek.get().value().bytes); assertFalse(seek.Next()); } } } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @SuppressWarnings("unchecked") @Test public void shouldFindMultipleNodesInEachRange() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldFindMultipleNodesInEachRange() { // GIVEN GBPTree <LabelScanKey, LabelScanValue> index = mock(typeof(GBPTree)); RawCursor <Hit <LabelScanKey, LabelScanValue>, IOException> cursor = mock(typeof(RawCursor)); when(cursor.Next()).thenReturn(true, true, true, false); when(cursor.get()).thenReturn(Hit(0, 0b1000_1000__1100_0010L), Hit(1, 0b0000_0010__0000_1000L), Hit(3, 0b0010_0000__1010_0001L), null); when(index.Seek(any(typeof(LabelScanKey)), any(typeof(LabelScanKey)))).thenReturn(cursor); using (NativeLabelScanReader reader = new NativeLabelScanReader(index)) { // WHEN LongIterator iterator = reader.NodesWithLabel(LABEL_ID); // THEN assertArrayEquals(new long[] { 1, 6, 7, 11, 15, 64 + 3, 64 + 9, 192 + 0, 192 + 5, 192 + 7, 192 + 13 }, asArray(iterator)); } }
internal override GenericLayout Layout(StoreIndexDescriptor descriptor, File storeFile) { try { int numberOfSlots = descriptor.Properties().Length; IDictionary <CoordinateReferenceSystem, SpaceFillingCurveSettings> settings = new Dictionary <CoordinateReferenceSystem, SpaceFillingCurveSettings>(); if (storeFile != null && Fs.fileExists(storeFile)) { // The index file exists and is sane so use it to read header information from. GBPTree.readHeader(PageCache, storeFile, new NativeIndexHeaderReader(new SpaceFillingCurveSettingsReader(settings))); } return(new GenericLayout(numberOfSlots, new IndexSpecificSpaceFillingCurveSettingsCache(_configuredSettings, settings))); } catch (IOException e) { throw new UncheckedIOException(e); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldStartFromGivenId() throws java.io.IOException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldStartFromGivenId() { // given GBPTree <LabelScanKey, LabelScanValue> index = mock(typeof(GBPTree)); RawCursor <Hit <LabelScanKey, LabelScanValue>, IOException> cursor = mock(typeof(RawCursor)); when(cursor.Next()).thenReturn(true, true, false); when(cursor.get()).thenReturn(Hit(1, 0b0001_1000__0101_1110L), Hit(3, 0b0010_0000__1010_0001L), null); when(index.Seek(any(typeof(LabelScanKey)), any(typeof(LabelScanKey)))).thenReturn(cursor); // when long fromId = LabelScanValue.RangeSize + 3; using (NativeLabelScanReader reader = new NativeLabelScanReader(index), PrimitiveLongResourceIterator iterator = reader.NodesWithAnyOfLabels(fromId, LABEL_ID)) { // then assertArrayEquals(new long[] { 64 + 4, 64 + 6, 64 + 11, 64 + 12, 192 + 0, 192 + 5, 192 + 7, 192 + 13 }, asArray(iterator)); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public static org.neo4j.internal.kernel.api.InternalIndexState readState(org.neo4j.io.pagecache.PageCache pageCache, java.io.File indexFile) throws java.io.IOException public static InternalIndexState ReadState(PageCache pageCache, File indexFile) { NativeIndexHeaderReader headerReader = new NativeIndexHeaderReader(NO_HEADER_READER); GBPTree.readHeader(pageCache, indexFile, headerReader); switch (headerReader.State) { case BYTE_FAILED: return(InternalIndexState.FAILED); case BYTE_ONLINE: return(InternalIndexState.ONLINE); case BYTE_POPULATING: return(InternalIndexState.POPULATING); default: throw new System.InvalidOperationException("Unexpected initial state byte value " + headerReader.State); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldIncludeAllValuesInTree() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldIncludeAllValuesInTree() { // GIVEN Value[] values = GenerateNumberValues(); BuildTree(values); // WHEN IndexSample sample; using (GBPTree <NumberIndexKey, NativeIndexValue> gbpTree = Tree) { FullScanNonUniqueIndexSampler <NumberIndexKey, NativeIndexValue> sampler = new FullScanNonUniqueIndexSampler <NumberIndexKey, NativeIndexValue>(gbpTree, Layout); sample = sampler.Result(); } // THEN assertEquals(values.Length, sample.SampleSize()); assertEquals(countUniqueValues(values), sample.UniqueValues()); assertEquals(values.Length, sample.IndexSize()); }