//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldReportProgressInTheSpecifiedIntervals() public virtual void ShouldReportProgressInTheSpecifiedIntervals() { // given Indicator indicator = IndicatorMock(); ProgressListener progressListener = Factory.mock(indicator, 10).singlePart(TestName.MethodName, 16); // when progressListener.Started(); for (int i = 0; i < 16; i++) { progressListener.Add(1); } progressListener.Done(); // then InOrder order = inOrder(indicator); order.verify(indicator).startProcess(16); for (int i = 0; i < 10; i++) { order.verify(indicator).progress(i, i + 1); } order.verify(indicator).completeProcess(); order.verifyNoMoreInteractions(); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldAllowStartingAPartBeforeCompletionOfMultiPartBuilder() public virtual void ShouldAllowStartingAPartBeforeCompletionOfMultiPartBuilder() { // given Indicator indicator = mock(typeof(Indicator)); ProgressMonitorFactory.MultiPartBuilder builder = Factory.mock(indicator, 10).multipleParts(TestName.MethodName); ProgressListener part1 = builder.ProgressForPart("part1", 1); ProgressListener part2 = builder.ProgressForPart("part2", 1); // when part1.Add(1); builder.Build(); part2.Add(1); part1.Done(); part2.Done(); // then InOrder order = inOrder(indicator); order.verify(indicator).startPart("part1", 1); order.verify(indicator).startProcess(2); order.verify(indicator).startPart("part2", 1); order.verify(indicator).completePart("part1"); order.verify(indicator).completePart("part2"); order.verify(indicator).completeProcess(); }
private static void ConsistencyCheckLabelScanStore(LabelScanStore labelScanStore, ConsistencyReporter report, ProgressListener listener) { ConsistencyReporter.FormattingDocumentedHandler handler = report.FormattingHandler(RecordType.LABEL_SCAN_DOCUMENT); ReporterFactory proxyFactory = new ReporterFactory(handler); labelScanStore.ConsistencyCheck(proxyFactory); handler.UpdateSummary(); listener.Add(1); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void detectDuplicateInputIds(Radix radix, org.neo4j.unsafe.impl.batchimport.input.Collector collector, org.neo4j.helpers.progress.ProgressListener progress) throws InterruptedException private void DetectDuplicateInputIds(Radix radix, Collector collector, ProgressListener progress) { // We do this collision sort using ParallelSort which has the data cache and the tracker cache, // the tracker cache gets sorted, data cache stays intact. In the collision data case we actually // have one more layer in here so we have tracker cache pointing to collisionNodeIdCache // pointing to dataCache. This can be done using the ParallelSort.Comparator abstraction. // // The Comparator below takes into account dataIndex for each eId its comparing so that an extra // comparison based on dataIndex is done if it's comparing two equal eIds. We do this so that // stretches of multiple equal eIds are sorted by dataIndex (i.e. node id) order, // to be able to write an efficient duplication scanning below and to have deterministic duplication reporting. Comparator duplicateComparator = new ComparatorAnonymousInnerClass(this); (new ParallelSort(radix, As5ByteLongArray(_collisionNodeIdCache), _numberOfCollisions - 1, _collisionTrackerCache, _processorsForParallelWork, progress, duplicateComparator)).run(); // Here we have a populated C // We want to detect duplicate input ids within it long previousEid = 0; int previousGroupId = -1; SameInputIdDetector detector = new SameInputIdDetector(); progress.Started("DEDUPLICATE"); for (int i = 0; i < _numberOfCollisions; i++) { long collisionIndex = _collisionTrackerCache.get(i); long nodeId = _collisionNodeIdCache.get5ByteLong(collisionIndex, 0); long offset = _collisionNodeIdCache.get6ByteLong(collisionIndex, 5); long eid = _dataCache.get(nodeId); int groupId = GroupOf(nodeId); // collisions of same eId AND groupId are always together bool same = eid == previousEid && previousGroupId == groupId; if (!same) { detector.Clear(); } // Potential duplicate object inputId = _collisionValues.get(offset); long nonDuplicateNodeId = detector.Add(nodeId, inputId); if (nonDuplicateNodeId != -1) { // Duplicate collector.CollectDuplicateNode(inputId, nodeId, _groups.get(groupId).name()); _trackerCache.markAsDuplicate(nodeId); UnmarkAsCollision(nonDuplicateNodeId); } previousEid = eid; previousGroupId = groupId; progress.Add(1); } progress.Done(); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldAggregateProgressFromMultipleProcesses() public virtual void ShouldAggregateProgressFromMultipleProcesses() { // given Indicator indicator = IndicatorMock(); ProgressMonitorFactory.MultiPartBuilder builder = Factory.mock(indicator, 10).multipleParts(TestName.MethodName); ProgressListener first = builder.ProgressForPart("first", 5); ProgressListener other = builder.ProgressForPart("other", 5); builder.Build(); InOrder order = inOrder(indicator); order.verify(indicator).startProcess(10); order.verifyNoMoreInteractions(); // when first.Started(); for (int i = 0; i < 5; i++) { first.Add(1); } first.Done(); // then order.verify(indicator).startPart("first", 5); for (int i = 0; i < 5; i++) { order.verify(indicator).progress(i, i + 1); } order.verify(indicator).completePart("first"); order.verifyNoMoreInteractions(); // when other.Started(); for (int i = 0; i < 5; i++) { other.Add(1); } other.Done(); // then order.verify(indicator).startPart("other", 5); for (int i = 5; i < 10; i++) { order.verify(indicator).progress(i, i + 1); } order.verify(indicator).completePart("other"); order.verify(indicator).completeProcess(); order.verifyNoMoreInteractions(); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldPrintADotEveryHalfPercentAndFullPercentageEveryTenPercentEvenWhenStepResolutionIsLower() public virtual void ShouldPrintADotEveryHalfPercentAndFullPercentageEveryTenPercentEvenWhenStepResolutionIsLower() { // given StringWriter writer = new StringWriter(); ProgressListener progressListener = ProgressMonitorFactory.Textual(writer).singlePart(TestName.MethodName, 50); // when for (int i = 0; i < 50; i++) { progressListener.Add(1); } // then assertEquals(TestName.MethodName + lineSeparator() + _expectedTextualOutput, writer.ToString()); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldPrintADotEveryHalfPercentAndFullPercentageEveryTenPercentWithTextualIndicator() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldPrintADotEveryHalfPercentAndFullPercentageEveryTenPercentWithTextualIndicator() { // given MemoryStream stream = new MemoryStream(); ProgressListener progressListener = ProgressMonitorFactory.Textual(stream).singlePart(TestName.MethodName, 1000); // when for (int i = 0; i < 1000; i++) { progressListener.Add(1); } // then assertEquals(TestName.MethodName + lineSeparator() + _expectedTextualOutput, stream.ToString(Charset.defaultCharset().name())); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private long applyTransactions(java.io.File fromPath, org.neo4j.kernel.internal.GraphDatabaseAPI toDb, org.neo4j.kernel.configuration.Config toConfig, long fromTxExclusive, long toTxInclusive, java.io.PrintStream out) throws Exception private long ApplyTransactions( File fromPath, GraphDatabaseAPI toDb, Config toConfig, long fromTxExclusive, long toTxInclusive, PrintStream @out ) { DependencyResolver resolver = toDb.DependencyResolver; TransactionRepresentationCommitProcess commitProcess = new TransactionRepresentationCommitProcess( resolver.ResolveDependency( typeof( TransactionAppender ) ), resolver.ResolveDependency( typeof( StorageEngine ) ) ); LifeSupport life = new LifeSupport(); try { using ( DefaultFileSystemAbstraction fileSystem = new DefaultFileSystemAbstraction(), JobScheduler jobScheduler = createInitialisedScheduler(), PageCache pageCache = StandalonePageCacheFactory.createPageCache(fileSystem, jobScheduler) ) { LogicalTransactionStore source = life.Add( new ReadOnlyTransactionStore( pageCache, fileSystem, DatabaseLayout.of( fromPath ), Config.defaults(), new Monitors() ) ); life.Start(); long lastAppliedTx = fromTxExclusive; // Some progress if there are more than a couple of transactions to apply ProgressListener progress = toTxInclusive - fromTxExclusive >= 100 ? textual( @out ).singlePart( "Application progress", toTxInclusive - fromTxExclusive ) : Org.Neo4j.Helpers.progress.ProgressListener_Fields.None; using ( IOCursor<CommittedTransactionRepresentation> cursor = source.GetTransactions( fromTxExclusive + 1 ) ) { while ( cursor.next() ) { CommittedTransactionRepresentation transaction = cursor.get(); TransactionRepresentation transactionRepresentation = transaction.TransactionRepresentation; try { commitProcess.Commit( new TransactionToApply( transactionRepresentation ), NULL, EXTERNAL ); progress.Add( 1 ); } //JAVA TO C# CONVERTER WARNING: 'final' catch parameters are not available in C#: //ORIGINAL LINE: catch (final Throwable e) catch ( Exception e ) { Console.Error.WriteLine( "ERROR applying transaction " + transaction.CommitEntry.TxId ); throw e; } lastAppliedTx = transaction.CommitEntry.TxId; if ( lastAppliedTx == toTxInclusive ) { break; } } } return lastAppliedTx; } } finally { life.Shutdown(); } }
private static void ConsistencyCheckSchemaIndexes(IndexAccessors indexes, ConsistencyReporter report, ProgressListener listener) { IList <StoreIndexDescriptor> rulesToRemove = new List <StoreIndexDescriptor>(); foreach (StoreIndexDescriptor onlineRule in indexes.OnlineRules()) { ConsistencyReporter.FormattingDocumentedHandler handler = report.FormattingHandler(RecordType.INDEX); ReporterFactory reporterFactory = new ReporterFactory(handler); IndexAccessor accessor = indexes.AccessorFor(onlineRule); if (!accessor.ConsistencyCheck(reporterFactory)) { rulesToRemove.Add(onlineRule); } handler.UpdateSummary(); listener.Add(1); } foreach (StoreIndexDescriptor toRemove in rulesToRemove) { indexes.Remove(toRemove); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void buildCollisionInfo(System.Func<long, Object> inputIdLookup, long pessimisticNumberOfCollisions, org.neo4j.unsafe.impl.batchimport.input.Collector collector, org.neo4j.helpers.progress.ProgressListener progress) throws InterruptedException private void BuildCollisionInfo(System.Func <long, object> inputIdLookup, long pessimisticNumberOfCollisions, Collector collector, ProgressListener progress) { progress.Started("RESOLVE (~" + pessimisticNumberOfCollisions + " collisions)"); Radix radix = _radixFactory.newInstance(); _collisionNodeIdCache = _cacheFactory.newByteArray(pessimisticNumberOfCollisions, new sbyte[COLLISION_ENTRY_SIZE]); _collisionTrackerCache = _trackerFactory.create(_cacheFactory, pessimisticNumberOfCollisions); _collisionValues = _collisionValuesFactory.apply(pessimisticNumberOfCollisions); for (long nodeId = 0; nodeId <= _highestSetIndex; nodeId++) { long eId = _dataCache.get(nodeId); if (IsCollision(eId)) { // Store this collision input id for matching later in get() long collisionIndex = _numberOfCollisions++; object id = inputIdLookup(nodeId); long eIdFromInputId = Encode(id); long eIdWithoutCollisionBit = ClearCollision(eId); Debug.Assert(eIdFromInputId == eIdWithoutCollisionBit, format("Encoding mismatch during building of " + "collision info. input id %s (a %s) marked as collision where this id was encoded into " + "%d when put, but was now encoded into %d", id, id.GetType().Name, eIdWithoutCollisionBit, eIdFromInputId)); long offset = _collisionValues.add(id); _collisionNodeIdCache.set5ByteLong(collisionIndex, 0, nodeId); _collisionNodeIdCache.set6ByteLong(collisionIndex, 5, offset); // The base of our sorting this time is going to be node id, so register that in the radix radix.RegisterRadixOf(eIdWithoutCollisionBit); } progress.Add(1); } progress.Done(); // Detect input id duplicates within the same group, with source information, line number and the works DetectDuplicateInputIds(radix, collector, progress); // We won't be needing these anymore _collisionTrackerCache.close(); _collisionTrackerCache = null; }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldStartProcessAutomaticallyIfNotDoneBefore() public virtual void ShouldStartProcessAutomaticallyIfNotDoneBefore() { // given Indicator indicator = IndicatorMock(); ProgressListener progressListener = Factory.mock(indicator, 10).singlePart(TestName.MethodName, 16); // when for (int i = 0; i < 16; i++) { progressListener.Add(1); } progressListener.Done(); // then InOrder order = inOrder(indicator); order.verify(indicator, times(1)).startProcess(16); for (int i = 0; i < 10; i++) { order.verify(indicator).progress(i, i + 1); } order.verify(indicator).completeProcess(); order.verifyNoMoreInteractions(); }
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected: //ORIGINAL LINE: public static <RECORD> void distributeRecords(int numberOfThreads, String workerNames, int queueSize, java.util.Iterator<RECORD> records, final org.neo4j.helpers.progress.ProgressListener progress, RecordProcessor<RECORD> processor, org.neo4j.consistency.checking.full.QueueDistribution_QueueDistributor<RECORD> idDistributor) public static void DistributeRecords <RECORD>(int numberOfThreads, string workerNames, int queueSize, IEnumerator <RECORD> records, ProgressListener progress, RecordProcessor <RECORD> processor, QueueDistribution_QueueDistributor <RECORD> idDistributor) { //JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops: if (!records.hasNext()) { return; } //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @SuppressWarnings("unchecked") final java.util.concurrent.ArrayBlockingQueue<RECORD>[] recordQ = new java.util.concurrent.ArrayBlockingQueue[numberOfThreads]; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': ArrayBlockingQueue <RECORD>[] recordQ = new ArrayBlockingQueue[numberOfThreads]; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.unsafe.impl.batchimport.cache.idmapping.string.Workers<RecordCheckWorker<RECORD>> workers = new org.neo4j.unsafe.impl.batchimport.cache.idmapping.string.Workers<>(workerNames); Workers <RecordCheckWorker <RECORD> > workers = new Workers <RecordCheckWorker <RECORD> >(workerNames); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.atomic.AtomicInteger idGroup = new java.util.concurrent.atomic.AtomicInteger(-1); AtomicInteger idGroup = new AtomicInteger(-1); for (int threadId = 0; threadId < numberOfThreads; threadId++) { recordQ[threadId] = new ArrayBlockingQueue <RECORD>(queueSize); workers.Start(new RecordCheckWorker <RECORD>(threadId, idGroup, recordQ[threadId], processor)); } //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int[] recsProcessed = new int[numberOfThreads]; int[] recsProcessed = new int[numberOfThreads]; RecordConsumer <RECORD> recordConsumer = (record, qIndex) => { recordQ[qIndex].put(record); recsProcessed[qIndex]++; }; try { while (records.MoveNext()) { try { // Put records into the queues using the queue distributor. Each Worker will pull and process. RECORD record = records.Current; idDistributor.Distribute(record, recordConsumer); progress.Add(1); } catch (InterruptedException) { Thread.CurrentThread.Interrupt(); break; } } // No more records to distribute, mark as done so that the workers will exit when no more records in queue. foreach (RecordCheckWorker <RECORD> worker in workers) { worker.Done(); } workers.AwaitAndThrowOnError(); } catch (InterruptedException) { Thread.CurrentThread.Interrupt(); throw new Exception("Was interrupted while awaiting completion"); } }