//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldNotAcceptUnsortedLabels() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldNotAcceptUnsortedLabels() { // GIVEN ControlledInserter inserter = new ControlledInserter(); bool failed = false; try { using (NativeLabelScanWriter writer = new NativeLabelScanWriter(1, NativeLabelScanWriter.EMPTY)) { writer.Initialize(inserter); // WHEN writer.Write(NodeLabelUpdate.labelChanges(0, EMPTY_LONG_ARRAY, new long[] { 2, 1 })); // we can't do the usual "fail( blabla )" here since the actual write will happen // when closing this writer, i.e. in the curly bracket below. } } catch (System.ArgumentException e) { // THEN assertTrue(e.Message.contains("unsorted")); failed = true; } assertTrue(failed); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void randomModifications(long[] expected, int count) throws java.io.IOException private void RandomModifications(long[] expected, int count) { BitArray editedNodes = new BitArray(); using (LabelScanWriter writer = _store.newWriter()) { for (int i = 0; i < count; i++) { int nodeId = _random.Next(NODE_COUNT); if (editedNodes.Get(nodeId)) { i--; continue; } int changeSize = _random.Next(3) + 1; long labels = expected[nodeId]; long[] labelsBefore = GetLabels(labels); for (int j = 0; j < changeSize; j++) { labels = FlipRandom(labels, LABEL_COUNT, _random.random()); } long[] labelsAfter = GetLabels(labels); editedNodes.Set(nodeId, true); NodeLabelUpdate labelChanges = labelChanges(nodeId, labelsBefore, labelsAfter); writer.Write(labelChanges); expected[nodeId] = labels; } } }
public override bool VisitNodeCommand(Command.NodeCommand command) { // for label store updates NodeRecord before = command.Before; NodeRecord after = command.After; NodeLabels labelFieldBefore = parseLabelsField(before); NodeLabels labelFieldAfter = parseLabelsField(after); if (!(labelFieldBefore.Inlined && labelFieldAfter.Inlined && before.LabelField == after.LabelField)) { long[] labelsBefore = labelFieldBefore.IfLoaded; long[] labelsAfter = labelFieldAfter.IfLoaded; if (labelsBefore != null && labelsAfter != null) { if (outerInstance.labelUpdates == null) { outerInstance.labelUpdates = new List <NodeLabelUpdate>(); } outerInstance.labelUpdates.Add(NodeLabelUpdate.labelChanges(command.Key, labelsBefore, labelsAfter, outerInstance.txId)); } } // for indexes return(IndexUpdatesExtractor.visitNodeCommand(command)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldAddLabels() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldAddLabels() { // GIVEN ControlledInserter inserter = new ControlledInserter(); long[] expected = new long[NODE_COUNT]; using (NativeLabelScanWriter writer = new NativeLabelScanWriter(max(5, NODE_COUNT / 100), NativeLabelScanWriter.EMPTY)) { writer.Initialize(inserter); // WHEN for (int i = 0; i < NODE_COUNT * 3; i++) { NodeLabelUpdate update = RandomUpdate(expected); writer.Write(update); } } // THEN for (int i = 0; i < LABEL_COUNT; i++) { long[] expectedNodeIds = nodesWithLabel(expected, i); long[] actualNodeIds = asArray(new LabelScanValueIterator(inserter.NodesFor(i), new List <RawCursor <Hit <LabelScanKey, LabelScanValue>, IOException> >(), NO_ID)); assertArrayEquals("For label " + i, expectedNodeIds, actualNodeIds); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldFailOnUnsortedLabelsFromFullStoreChangeStream() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldFailOnUnsortedLabelsFromFullStoreChangeStream() { // given PageCache pageCache = _pageCacheRule.getPageCache(_fileSystemRule.get()); IList <NodeLabelUpdate> existingData = new List <NodeLabelUpdate>(); existingData.Add(NodeLabelUpdate.labelChanges(1, new long[0], new long[] { 2, 1 })); FullStoreChangeStream changeStream = asStream(existingData); NativeLabelScanStore nativeLabelScanStore = null; try { nativeLabelScanStore = new NativeLabelScanStore(pageCache, _testDirectory.databaseLayout(), _fileSystemRule.get(), changeStream, false, new Monitors(), immediate()); nativeLabelScanStore.Init(); // when nativeLabelScanStore.Start(); fail("Expected native label scan store to fail on "); } catch (System.ArgumentException e) { // then assertThat(e.Message, Matchers.containsString("unsorted label")); assertThat(e.Message, Matchers.stringContainsInOrder(Iterables.asIterable("2", "1"))); } finally { if (nativeLabelScanStore != null) { nativeLabelScanStore.Shutdown(); } } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void prepareIndex() throws java.io.IOException private void PrepareIndex() { Start(); using (LabelScanWriter labelScanWriter = _store.newWriter()) { labelScanWriter.Write(NodeLabelUpdate.labelChanges(1, new long[] {}, new long[] { 1 })); } _store.shutdown(); }
/// <summary> /// Queues a <seealso cref="NodeLabelUpdate"/> to this writer for applying when batch gets full, /// or when <seealso cref="close() closing"/>. /// </summary> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public void write(org.neo4j.kernel.api.labelscan.NodeLabelUpdate update) throws java.io.IOException public override void Write(NodeLabelUpdate update) { if (_pendingUpdatesCursor == _pendingUpdates.Length) { FlushPendingChanges(); } _pendingUpdates[_pendingUpdatesCursor++] = update; PhysicalToLogicalLabelChanges.ConvertToAdditionsAndRemovals(update); CheckNextLabelId(update.LabelsBefore); CheckNextLabelId(update.LabelsAfter); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private static void checkLabelScanStoreAccessible(org.neo4j.kernel.api.labelscan.LabelScanStore labelScanStore) throws java.io.IOException private static void CheckLabelScanStoreAccessible(LabelScanStore labelScanStore) { int labelId = 1; using (LabelScanWriter labelScanWriter = labelScanStore.NewWriter()) { labelScanWriter.Write(NodeLabelUpdate.labelChanges(1, new long[] {}, new long[] { labelId })); } using (LabelScanReader labelScanReader = labelScanStore.NewReader()) { assertEquals(1, labelScanReader.NodesWithLabel(labelId).next()); } }
private NodeLabelUpdate RandomUpdate(long[] expected) { int nodeId = Random.Next(expected.Length); long labels = expected[nodeId]; long[] before = getLabels(labels); int changeCount = Random.Next(4) + 1; for (int i = 0; i < changeCount; i++) { labels = flipRandom(labels, LABEL_COUNT, Random.random()); } expected[nodeId] = labels; return(NodeLabelUpdate.labelChanges(nodeId, before, getLabels(labels))); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldWorkWithAFullRange() public virtual void ShouldWorkWithAFullRange() { // given long labelId = 0; IList <NodeLabelUpdate> updates = new List <NodeLabelUpdate>(); ISet <long> nodes = new HashSet <long>(); for (int i = 0; i < 34; i++) { updates.Add(NodeLabelUpdate.labelChanges(i, new long[] {}, new long[] { labelId })); nodes.Add(( long )i); } Start(updates); // when LabelScanReader reader = _store.newReader(); ISet <long> nodesWithLabel = PrimitiveLongCollections.toSet(reader.NodesWithLabel(( int )labelId)); // then assertEquals(nodes, nodesWithLabel); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldSeeEntriesWhenOnlyLowestIsPresent() public virtual void ShouldSeeEntriesWhenOnlyLowestIsPresent() { // given long labelId = 0; IList <NodeLabelUpdate> labelUpdates = new List <NodeLabelUpdate>(); labelUpdates.Add(NodeLabelUpdate.labelChanges(0L, new long[] {}, new long[] { labelId })); Start(labelUpdates); // when MutableInt count = new MutableInt(); AllEntriesLabelScanReader nodeLabelRanges = _store.allNodeLabelRanges(); nodeLabelRanges.forEach(nlr => { foreach (long nodeId in nlr.nodes()) { count.add(nlr.labels(nodeId).length); } }); assertThat(count.intValue(), @is(1)); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void flushPendingChanges() throws java.io.IOException private void FlushPendingChanges() { Arrays.sort(_pendingUpdates, 0, _pendingUpdatesCursor, _updateSorter); _monitor.flushPendingUpdates(); long currentLabelId = _lowestLabelId; _value.clear(); _key.clear(); while (currentLabelId != long.MaxValue) { long nextLabelId = long.MaxValue; for (int i = 0; i < _pendingUpdatesCursor; i++) { NodeLabelUpdate update = _pendingUpdates[i]; long nodeId = update.NodeId; nextLabelId = ExtractChange(update.LabelsAfter, currentLabelId, nodeId, nextLabelId, true, update.TxId); nextLabelId = ExtractChange(update.LabelsBefore, currentLabelId, nodeId, nextLabelId, false, update.TxId); } currentLabelId = nextLabelId; } FlushPendingRange(); _pendingUpdatesCursor = 0; }
public override void Write(NodeLabelUpdate update) { assertEquals(ExpectedNodeIds[Cursor], update.NodeId); Cursor++; }