private void ReportNodeLabelNotInIndex(REPORT report, NodeRecord nodeRecord, long storeLabel) { if (_checkStoreToIndex) { report.nodeLabelNotInIndex(nodeRecord, storeLabel); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void rebuildReplicatedIdGeneratorsOnRecovery() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void RebuildReplicatedIdGeneratorsOnRecovery() { DefaultFileSystemAbstraction fileSystem = FileSystemRule.get(); File stickyGenerator = new File(TestDirectory.databaseDir(), "stickyGenerator"); File nodeStoreIdGenerator = TestDirectory.databaseLayout().idNodeStore(); StoreFactory storeFactory = new StoreFactory(TestDirectory.databaseLayout(), Config.defaults(), GetIdGenerationFactory(fileSystem), PageCacheRule.getPageCache(fileSystem), fileSystem, NullLogProvider.Instance, EmptyVersionContextSupplier.EMPTY); using (NeoStores neoStores = storeFactory.OpenAllNeoStores(true)) { NodeStore nodeStore = neoStores.NodeStore; for (int i = 0; i < 50; i++) { NodeRecord nodeRecord = nodeStore.NewRecord(); nodeRecord.InUse = true; nodeRecord.Id = nodeStore.NextId(); if (i == 47) { FileUtils.copyFile(nodeStoreIdGenerator, stickyGenerator); } nodeStore.UpdateRecord(nodeRecord); } } FileUtils.copyFile(stickyGenerator, nodeStoreIdGenerator); using (NeoStores reopenedStores = storeFactory.OpenAllNeoStores()) { reopenedStores.MakeStoreOk(); assertEquals(51L, reopenedStores.NodeStore.nextId()); } }
protected internal override void Process(RelationshipGroupRecord[] batch, BatchSender sender) { foreach (RelationshipGroupRecord group in batch) { if (!group.InUse()) { continue; } long nodeId = group.OwningNode; if (_cache.getByte(nodeId, 0) == 0) { _cache.setByte(nodeId, 0, ( sbyte )1); NodeRecord nodeRecord = _nodeStore.newRecord(); _nodeStore.getRecordByCursor(nodeId, nodeRecord, NORMAL, _nodeCursor); nodeRecord.NextRel = group.Id; nodeRecord.Dense = true; _current[_cursor++] = nodeRecord; if (_cursor == _batchSize) { sender.Send(_current); NewBatch(); } } } control.recycle(batch); }
public override void CheckReference(RECORD record, NodeRecord nodeRecord, CheckerEngine <RECORD, REPORT> engine, RecordAccess records) { if (nodeRecord.InUse()) { NodeLabels nodeLabels = NodeLabelsField.parseLabelsField(nodeRecord); if (nodeLabels is DynamicNodeLabels) { DynamicNodeLabels dynamicNodeLabels = ( DynamicNodeLabels )nodeLabels; long firstRecordId = dynamicNodeLabels.FirstDynamicRecordId; RecordReference <DynamicRecord> firstRecordReference = records.NodeLabels(firstRecordId); ExpectedNodeLabelsChecker expectedNodeLabelsChecker = new ExpectedNodeLabelsChecker(this, nodeRecord); LabelChainWalker <RECORD, REPORT> checker = new LabelChainWalker <RECORD, REPORT>(expectedNodeLabelsChecker); engine.ComparativeCheck(firstRecordReference, checker); nodeRecord.DynamicLabelRecords; // I think this is empty in production } else { long[] storeLabels = nodeLabels.Get(null); REPORT report = engine.Report(); ValidateLabelIds(nodeRecord, storeLabels, report); } } else if (_indexLabels.Length != 0) { engine.Report().nodeNotInUse(nodeRecord); } }
private static NodeRecord Node(long nextId) { NodeRecord node = new NodeRecord(nextId); node.InUse = true; return(node); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void scanForHighIdOnlyOnceWhenProcessCache() internal virtual void ScanForHighIdOnlyOnceWhenProcessCache() { NeoStores neoStores = mock(typeof(NeoStores), Mockito.RETURNS_MOCKS); NodeStore nodeStore = mock(typeof(NodeStore)); NodeRecord nodeRecord = mock(typeof(NodeRecord)); StoreProcessor storeProcessor = mock(typeof(StoreProcessor)); when(neoStores.NodeStore).thenReturn(nodeStore); when(nodeStore.HighId).thenReturn(10L); when(nodeStore.GetRecord(anyLong(), any(typeof(NodeRecord)), any(typeof(RecordLoad)))).thenReturn(nodeRecord); when(nodeStore.NewRecord()).thenReturn(nodeRecord); StoreAccess storeAccess = new StoreAccess(neoStores); storeAccess.Initialize(); DefaultCacheAccess cacheAccess = new DefaultCacheAccess(Counts.NONE, 1); CacheTask.CheckNextRel cacheTask = new CacheTask.CheckNextRel(Org.Neo4j.Consistency.checking.full.Stage_Fields.SequentialForward, cacheAccess, storeAccess, storeProcessor); cacheAccess.CacheSlotSizes = CheckStage.Stage5_Check_NextRel.CacheSlotSizes; cacheTask.ProcessCache(); verify(nodeStore, times(1)).HighId; }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldTrackSecondaryUnitIdsAsWell() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldTrackSecondaryUnitIdsAsWell() { // GIVEN NeoStores neoStores = NeoStoresRule.builder().build(); HighIdTransactionApplier tracker = new HighIdTransactionApplier(neoStores); NodeRecord node = (new NodeRecord(5)).initialize(true, 123, true, 456, 0); node.SecondaryUnitId = 6; node.RequiresSecondaryUnit = true; RelationshipRecord relationship = (new RelationshipRecord(10)).initialize(true, 1, 2, 3, 4, 5, 6, 7, 8, true, true); relationship.SecondaryUnitId = 12; relationship.RequiresSecondaryUnit = true; RelationshipGroupRecord relationshipGroup = (new RelationshipGroupRecord(8)).initialize(true, 0, 1, 2, 3, 4, 5); relationshipGroup.SecondaryUnitId = 20; relationshipGroup.RequiresSecondaryUnit = true; // WHEN tracker.VisitNodeCommand(new NodeCommand(new NodeRecord(node.Id), node)); tracker.VisitRelationshipCommand(new RelationshipCommand(new RelationshipRecord(relationship.Id), relationship)); tracker.VisitRelationshipGroupCommand(new RelationshipGroupCommand(new RelationshipGroupRecord(relationshipGroup.Id), relationshipGroup)); tracker.Close(); // THEN assertEquals(node.SecondaryUnitId + 1, neoStores.NodeStore.HighId); assertEquals(relationship.SecondaryUnitId + 1, neoStores.RelationshipStore.HighId); assertEquals(relationshipGroup.SecondaryUnitId + 1, neoStores.RelationshipGroupStore.HighId); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void recordWithReservedIdIsSkipped() public virtual void RecordWithReservedIdIsSkipped() { RecordStore <NodeRecord> store = mock(typeof(NodeStore)); StageControl stageControl = mock(typeof(StageControl)); UpdateRecordsStep <NodeRecord> step = new UpdateRecordsStep <NodeRecord>(stageControl, Configuration.DEFAULT, store, new StorePrepareIdSequence()); NodeRecord node1 = new NodeRecord(1); node1.InUse = true; NodeRecord node2 = new NodeRecord(2); node2.InUse = true; NodeRecord nodeWithReservedId = new NodeRecord(IdGeneratorImpl.INTEGER_MINUS_ONE); NodeRecord[] batch = new NodeRecord[] { node1, node2, nodeWithReservedId }; step.Process(batch, mock(typeof(BatchSender))); verify(store).prepareForCommit(eq(node1), any(typeof(IdSequence))); verify(store).updateRecord(node1); verify(store).prepareForCommit(eq(node2), any(typeof(IdSequence))); verify(store).updateRecord(node2); verify(store, never()).prepareForCommit(eq(nodeWithReservedId), any(typeof(IdSequence))); verify(store, never()).updateRecord(nodeWithReservedId); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void writeReadRecord(org.neo4j.kernel.impl.store.record.NodeRecord source, org.neo4j.kernel.impl.store.record.NodeRecord target, int recordSize) throws java.io.IOException private void WriteReadRecord(NodeRecord source, NodeRecord target, int recordSize) { _recordFormat.prepare(source, recordSize, _idSequence); _recordFormat.write(source, _pageCursor, recordSize); _pageCursor.Offset = 0; _recordFormat.read(target, _pageCursor, RecordLoad.NORMAL, recordSize); }
public override void Run(StoreAccess store, PrintStream @out) { RecordStore <NodeRecord> nodeStore = store.NodeStore; NodeRecord node = nodeStore.GetRecord(Id, nodeStore.NewRecord(), NORMAL); if (node.Dense) { RecordStore <RelationshipGroupRecord> relationshipGroupStore = store.RelationshipGroupStore; RelationshipGroupRecord group = relationshipGroupStore.NewRecord(); relationshipGroupStore.GetRecord(node.NextRel, group, NORMAL); do { @out.println("group " + group); @out.println("out:"); PrintRelChain(store, @out, group.FirstOut); @out.println("in:"); PrintRelChain(store, @out, group.FirstIn); @out.println("loop:"); PrintRelChain(store, @out, group.FirstLoop); group = group.Next != -1 ? relationshipGroupStore.GetRecord(group.Next, group, NORMAL) : null; } while (group != null); } else { PrintRelChain(store, @out, node.NextRel); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void nodeCommandWithFixedReferenceFormat302() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void NodeCommandWithFixedReferenceFormat302() { // Given InMemoryClosableChannel channel = new InMemoryClosableChannel(); NodeRecord before = new NodeRecord(42, true, false, 33, 99, 66); NodeRecord after = new NodeRecord(42, true, false, 33, 99, 66); before.UseFixedReferences = true; after.UseFixedReferences = true; (new Command.NodeCommand(before, after)).Serialize(channel); // When PhysicalLogCommandReaderV3_0_2 reader = new PhysicalLogCommandReaderV3_0_2(); Command command = reader.Read(channel); assertTrue(command is Command.NodeCommand); Command.NodeCommand nodeCommand = (Command.NodeCommand)command; // Then assertEquals(before, nodeCommand.Before); assertEquals(after, nodeCommand.After); assertTrue(nodeCommand.Before.UseFixedReferences); assertTrue(nodeCommand.After.UseFixedReferences); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void writeRecordWithOldFormat(org.neo4j.kernel.impl.store.record.NodeRecord oldFormatRecord) throws java.io.IOException private void WriteRecordWithOldFormat(NodeRecord oldFormatRecord) { int oldRecordSize = NodeRecordFormatV3_0_0.RECORD_SIZE; NodeRecordFormatV3_0_0 recordFormatV30 = new NodeRecordFormatV3_0_0(); recordFormatV30.Prepare(oldFormatRecord, oldRecordSize, _idSequence); recordFormatV30.Write(oldFormatRecord, _pageCursor, oldRecordSize); _pageCursor.Offset = 0; }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void useVariableLengthFormatWhenPropertyReferenceTooBig() throws java.io.IOException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void UseVariableLengthFormatWhenPropertyReferenceTooBig() { NodeRecord source = new NodeRecord(1); NodeRecord target = new NodeRecord(1); source.Initialize(true, RandomFixedReference(), true, 1L << 37, 0L); WriteReadRecord(source, target); assertFalse("Record should use variable length reference format.", target.UseFixedReferences); VerifySameReferences(source, target); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void useFixedReferenceFormatWhenRecordCanFitInRecordSizeRecord() throws java.io.IOException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void UseFixedReferenceFormatWhenRecordCanFitInRecordSizeRecord() { NodeRecord source = new NodeRecord(1); NodeRecord target = new NodeRecord(1); source.Initialize(true, RandomFixedReference(), true, RandomFixedReference(), 0L); WriteReadRecord(source, target, NodeRecordFormat.FixedFormatRecordSize); assertTrue("Record should use fixed reference if can fit in format record.", target.UseFixedReferences); VerifySameReferences(source, target); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void useFixedReferencesFormatWhenPropertyIsMissing() throws java.io.IOException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void UseFixedReferencesFormatWhenPropertyIsMissing() { NodeRecord source = new NodeRecord(1); NodeRecord target = new NodeRecord(1); source.Initialize(true, Record.NULL_REFERENCE.intValue(), true, RandomFixedReference(), 0L); WriteReadRecord(source, target); assertTrue("Record should use fixed reference format.", target.UseFixedReferences); VerifySameReferences(source, target); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void readWriteFixedReferencesRecord() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ReadWriteFixedReferencesRecord() { NodeRecord source = new NodeRecord(1); NodeRecord target = new NodeRecord(1); source.Initialize(true, RandomFixedReference(), true, RandomFixedReference(), 0L); WriteReadRecord(source, target); assertTrue("Record should use fixed reference format.", target.UseFixedReferences); VerifySameReferences(source, target); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void useVariableLengthFormatWhenRecordSizeIsTooSmall() throws java.io.IOException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void UseVariableLengthFormatWhenRecordSizeIsTooSmall() { NodeRecord source = new NodeRecord(1); NodeRecord target = new NodeRecord(1); source.Initialize(true, RandomFixedReference(), true, RandomFixedReference(), 0L); WriteReadRecord(source, target, NodeRecordFormat.FixedFormatRecordSize - 1); assertFalse("Record should use variable length reference if format record is too small.", target.UseFixedReferences); VerifySameReferences(source, target); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void inUseRecordEquality() public virtual void InUseRecordEquality() { NodeRecord record1 = new NodeRecord(1); record1.Initialize(true, 1, false, 2, 3); record1.SecondaryUnitId = 42; NodeRecord record2 = record1.Clone(); NodeCheckType check = new NodeCheckType(); assertTrue(check.Equal(record1, record2)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void readDoubleUnitRecordStoredNotInFixedReferenceFormat() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ReadDoubleUnitRecordStoredNotInFixedReferenceFormat() { NodeRecord oldFormatRecord = new NodeRecord(1); NodeRecord newFormatRecord = new NodeRecord(1); oldFormatRecord.Initialize(true, BigReference(), true, BigReference(), 1L); WriteRecordWithOldFormat(oldFormatRecord); assertTrue("This should be double unit record.", oldFormatRecord.HasSecondaryUnitId()); assertFalse("Old format is not aware about fixed references.", oldFormatRecord.UseFixedReferences); _recordFormat.read(newFormatRecord, _pageCursor, RecordLoad.NORMAL, NodeRecordFormat.RECORD_SIZE); VerifySameReferences(oldFormatRecord, newFormatRecord); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void notInUseRecordEquality() public virtual void NotInUseRecordEquality() { NodeRecord record1 = new NodeRecord(1); record1.Initialize(false, 1, true, 2, 3); record1.SecondaryUnitId = 42; NodeRecord record2 = new NodeRecord(1); record2.Initialize(false, 11, true, 22, 33); record2.SecondaryUnitId = 24; NodeCheckType check = new NodeCheckType(); assertTrue(check.Equal(record1, record2)); }
protected internal override void ProcessCache() { RecordStore <NodeRecord> nodeStore = StoreAccess.NodeStore; CacheAccess_Client client = CacheAccess.client(); long highId = nodeStore.HighId; for (long nodeId = 0; nodeId < highId; nodeId++) { if (client.GetFromCache(nodeId, CacheSlots_NextRelationship_Fields.SLOT_FIRST_IN_TARGET) == 0) { NodeRecord node = nodeStore.GetRecord(nodeId, nodeStore.NewRecord(), FORCE); if (node.InUse() && !node.Dense) { StoreProcessor.processNode(nodeStore, node); } } } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldGrowAFileWhileContinuingToMemoryMapNewRegions() public virtual void ShouldGrowAFileWhileContinuingToMemoryMapNewRegions() { // don't run on windows because memory mapping doesn't work properly there assumeTrue(!SystemUtils.IS_OS_WINDOWS); // given const int numberOfRecords = 1000000; Config config = Config.defaults(pagecache_memory, MmapSize(numberOfRecords, NodeRecordFormat.RECORD_SIZE)); FileSystemAbstraction fileSystemAbstraction = _fileSystemRule.get(); DefaultIdGeneratorFactory idGeneratorFactory = new DefaultIdGeneratorFactory(fileSystemAbstraction); PageCache pageCache = _pageCacheRule.getPageCache(fileSystemAbstraction, config); StoreFactory storeFactory = new StoreFactory(_testDirectory.databaseLayout(), config, idGeneratorFactory, pageCache, fileSystemAbstraction, NullLogProvider.Instance, EmptyVersionContextSupplier.EMPTY); NeoStores neoStores = storeFactory.OpenAllNeoStores(true); NodeStore nodeStore = neoStores.NodeStore; // when int iterations = 2 * numberOfRecords; long startingId = nodeStore.NextId(); long nodeId = startingId; for (int i = 0; i < iterations; i++) { NodeRecord record = new NodeRecord(nodeId, false, i, 0); record.InUse = true; nodeStore.UpdateRecord(record); nodeId = nodeStore.NextId(); } // then NodeRecord record = new NodeRecord(0, false, 0, 0); for (int i = 0; i < iterations; i++) { record.Id = startingId + i; nodeStore.GetRecord(i, record, NORMAL); assertTrue("record[" + i + "] should be in use", record.InUse()); assertThat("record[" + i + "] should have nextRelId of " + i, record.NextRel, @is(( long )i)); } neoStores.Close(); }
protected internal override void ProcessCache() { CacheAccess.clearCache(); long[] fields = new long[] { -1, 1, 0 }; CacheAccess_Client client = CacheAccess.client(); using (ResourceIterator <NodeRecord> nodeRecords = Nodes.GetEnumerator()) { while (nodeRecords.MoveNext()) { NodeRecord node = nodeRecords.Current; if (node.InUse()) { fields[CacheSlots_NextRelationship_Fields.SLOT_RELATIONSHIP_ID] = node.NextRel; client.PutToCache(node.Id, fields); } } } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void toStringShouldPlaceEachRecordOnItsOwnLine() internal virtual void ToStringShouldPlaceEachRecordOnItsOwnLine() { // given NodeRecord record1 = new NodeRecord(1, false, 1, 1); NodeRecord record2 = new NodeRecord(2, false, 2, 2); RecordSet <NodeRecord> set = new RecordSet <NodeRecord>(); set.Add(record1); set.Add(record2); // when string @string = set.ToString(); // then string[] lines = @string.Split("\n", true); assertEquals(4, lines.Length); assertEquals("[", lines[0]); assertEquals(record1.ToString() + ",", lines[1]); assertEquals(record2.ToString() + ",", lines[2]); assertEquals("]", lines[3]); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldReportDuplicatePropertyIndexesInPropertyRecordForNode() internal virtual void ShouldReportDuplicatePropertyIndexesInPropertyRecordForNode() { // given ChainCheck check = new ChainCheck(); RecordAccessStub records = new RecordAccessStub(); NodeRecord master = records.Add(inUse(new NodeRecord(1, false, -1, 1))); PropertyRecord propertyRecord = inUse(new PropertyRecord(1)); PropertyBlock firstBlock = new PropertyBlock(); firstBlock.SingleBlock = 1; firstBlock.KeyIndexId = 1; PropertyBlock secondBlock = new PropertyBlock(); secondBlock.SingleBlock = 1; secondBlock.KeyIndexId = 2; PropertyBlock thirdBlock = new PropertyBlock(); thirdBlock.SingleBlock = 1; thirdBlock.KeyIndexId = 1; propertyRecord.AddPropertyBlock(firstBlock); propertyRecord.AddPropertyBlock(secondBlock); propertyRecord.AddPropertyBlock(thirdBlock); records.Add(propertyRecord); // when Org.Neo4j.Consistency.report.ConsistencyReport_NodeConsistencyReport report = mock(typeof(Org.Neo4j.Consistency.report.ConsistencyReport_NodeConsistencyReport)); CheckerEngine <NodeRecord, Org.Neo4j.Consistency.report.ConsistencyReport_NodeConsistencyReport> checkEngine = records.Engine(master, report); check.checkReference(master, propertyRecord, checkEngine, records); // then verify(report).propertyKeyNotUniqueInChain(); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldParserCommandsUsingAGivenFactory() throws java.io.IOException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldParserCommandsUsingAGivenFactory() { // given // The record, it will be used as before and after NodeRecord theRecord = new NodeRecord(1); Command.NodeCommand nodeCommand = new Command.NodeCommand(theRecord, theRecord); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final LogEntryCommand command = new LogEntryCommand(version, nodeCommand); LogEntryCommand command = new LogEntryCommand(_version, nodeCommand); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.kernel.impl.transaction.log.InMemoryClosableChannel channel = new org.neo4j.kernel.impl.transaction.log.InMemoryClosableChannel(); InMemoryClosableChannel channel = new InMemoryClosableChannel(); channel.Put(Org.Neo4j.Kernel.impl.transaction.command.NeoCommandType_Fields.NodeCommand); channel.PutLong(theRecord.Id); // record image before channel.Put(( sbyte )0); // not in use channel.PutInt(0); // number of dynamic records in use // record image after channel.Put(( sbyte )0); // not in use channel.PutInt(0); // number of dynamic records in use channel.GetCurrentPosition(_marker); // when //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final LogEntryParser parser = version.entryParser(LogEntryByteCodes.COMMAND); LogEntryParser parser = _version.entryParser(LogEntryByteCodes.Command); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final LogEntry logEntry = parser.parse(version, channel, marker, commandReader); LogEntry logEntry = parser.parse(_version, channel, _marker, _commandReader); // then assertEquals(command, logEntry); assertFalse(parser.skip()); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldAbortLoadingGroupChainIfComeTooFar() public virtual void ShouldAbortLoadingGroupChainIfComeTooFar() { // GIVEN a node with relationship group chain 2-->4-->10-->23 LogProvider logProvider = NullLogProvider.Instance; StoreFactory storeFactory = new StoreFactory(_testDirectory.databaseLayout(), Config.defaults(), new DefaultIdGeneratorFactory(_fs.get()), _pageCache.getPageCache(_fs.get()), _fs.get(), logProvider, EmptyVersionContextSupplier.EMPTY); using (NeoStores stores = storeFactory.OpenNeoStores(true, StoreType.RELATIONSHIP_GROUP)) { RecordStore <RelationshipGroupRecord> store = spy(stores.RelationshipGroupStore); RelationshipGroupRecord group2 = Group(0, 2); RelationshipGroupRecord group4 = Group(1, 4); RelationshipGroupRecord group10 = Group(2, 10); RelationshipGroupRecord group23 = Group(3, 23); Link(group2, group4, group10, group23); store.UpdateRecord(group2); store.UpdateRecord(group4); store.UpdateRecord(group10); store.UpdateRecord(group23); RelationshipGroupGetter groupGetter = new RelationshipGroupGetter(store); NodeRecord node = new NodeRecord(0, true, group2.Id, -1); // WHEN trying to find relationship group 7 RecordAccess <RelationshipGroupRecord, int> access = new DirectRecordAccess <RelationshipGroupRecord, int>(store, Loaders.relationshipGroupLoader(store)); RelationshipGroupGetter.RelationshipGroupPosition result = groupGetter.GetRelationshipGroup(node, 7, access); // THEN only groups 2, 4 and 10 should have been loaded InOrder verification = inOrder(store); verification.verify(store).getRecord(eq(group2.Id), any(typeof(RelationshipGroupRecord)), any(typeof(RecordLoad))); verification.verify(store).getRecord(eq(group4.Id), any(typeof(RelationshipGroupRecord)), any(typeof(RecordLoad))); verification.verify(store).getRecord(eq(group10.Id), any(typeof(RelationshipGroupRecord)), any(typeof(RecordLoad))); verification.verify(store, never()).getRecord(eq(group23.Id), any(typeof(RelationshipGroupRecord)), any(typeof(RecordLoad))); // it should also be reported as not found assertNull(result.Group()); // with group 4 as closes previous one assertEquals(group4, result.ClosestPrevious().forReadingData()); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void ioThroughputStatDoesNotOverflow() public virtual void IoThroughputStatDoesNotOverflow() { // store with huge record size to force overflow and not create huge batch of records RecordStore <NodeRecord> store = mock(typeof(RecordStore)); when(store.RecordSize).thenReturn(int.MaxValue / 2); Configuration configuration = mock(typeof(Configuration)); StageControl stageControl = mock(typeof(StageControl)); UpdateRecordsStep <NodeRecord> step = new UpdateRecordsStep <NodeRecord>(stageControl, configuration, store, new StorePrepareIdSequence()); NodeRecord record = new NodeRecord(1); record.InUse = true; NodeRecord[] batch = new NodeRecord[11]; Arrays.fill(batch, record); step.Process(batch, mock(typeof(BatchSender))); Stat stat = step.Stat(Keys.io_throughput); assertThat(stat.AsLong(), greaterThan(0L)); }
private void NodeAdvance(NodeRecord record, PageCursor pageCursor) { _read.nextRecordByCursor(record, RecordLoad.CHECK, pageCursor); }
private void Node(NodeRecord record, long reference, PageCursor pageCursor) { _read.getRecordByCursor(reference, record, RecordLoad.CHECK, pageCursor); }