/// <summary> /// This test makes sure that the database is able to start after having been stopped during initialization. /// /// In order to make sure that the server is stopped during startup we create a separate thread that calls stop. /// In order to make sure that this thread does not call stop before the startup procedure has started we use a /// custom implementation of a PageSwapperFactory, which communicates with the thread that calls stop. We do this /// via a static semaphore. </summary> /// <exception cref="IOException"> </exception> /// <exception cref="InterruptedException"> </exception> //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldBeAbleToRestartWhenStoppedDuringStartup() throws java.io.IOException, InterruptedException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldBeAbleToRestartWhenStoppedDuringStartup() { // Make sure that the semaphore is in a clean state. _semaphore.drainPermits(); // Get a server that uses our custom swapper. NeoServer server = GetNeoServer(CUSTOM_SWAPPER); try { AtomicBoolean failure = new AtomicBoolean(); Thread serverStoppingThread = ThreadTestUtils.fork(StopServerAfterStartingHasStarted(server, failure)); server.Start(); // Wait for the server to stop. serverStoppingThread.Join(); // Check if the server stopped successfully. if (failure.get()) { fail("Server failed to stop."); } // Verify that we can start the server again. server = GetNeoServer(CUSTOM_SWAPPER); server.Start(); } finally { server.Stop(); } }
public void DeleteFileLocksFile() { Debug.WriteLine("TEST START: DeleteFileLocksFile"); using (new FileMutex(FileName)) { ThreadTestUtils.RunActionOnThreadAndJoin( () => { Assert.ThrowsException <InvalidOperationException>(() => _io.DeleteFile(FileName)); }); } }
public void DeleteFileLocksParentDirectory() { Debug.WriteLine("TEST START: DeleteFileLocksParentDirectory"); // Mutex name for the root directory, which is the parent directory for the file we're about to try to delete using (new FileMutex(string.Empty)) { ThreadTestUtils.RunActionOnThreadAndJoin( () => Assert.ThrowsException <InvalidOperationException>(() => { _io.DeleteFile(FileName); })); } }
public void ReadFileConcurrently() { _io.Write(FileName, _data); ThreadTestUtils.ParallelExecute( () => { Thread.Sleep(new Random().Next() % 10); byte[] actual = _io.Read(FileName); CollectionAssert.AreEqual(_data, actual); }); }
public void ReadFileDoesNotLockParentDirectory() { Debug.WriteLine("TEST START: ReadFileDoesNotLockParentDirectory"); _io.Write(FileName, _data); // Mutex name for the root directory, which is the parent directory for the file we're about to read using (new FileMutex(string.Empty)) { ThreadTestUtils.RunActionOnThreadAndJoin(() => { Assert.AreEqual(_data, _io.Read(FileName)); }); } }
public void DeleteContentLocksParentDirectory() { Debug.WriteLine("TEST START: DeleteContentLocksParentDirectory"); _io.Write("x/a.txt", _data); // Mutex name for the root directory, which is the parent directory for the directory we're about to try to delete using (new FileMutex(string.Empty)) { ThreadTestUtils.RunActionOnThreadAndJoin( () => Assert.ThrowsException <InvalidOperationException>(() => _io.DeleteContent("x"))); } }
public void WriteFileConcurrently() { ThreadTestUtils.ParallelExecute( () => { Thread.Sleep(new Random().Next() % 10); _io.Write(FileName, _data); }); CollectionAssert.AreEqual(_data, _io.Read(FileName)); // The file is in the right location Assert.IsTrue(_io.RootDirectory.FileExists(FileName)); }
public void WriteDoesNotLockParentDirectory() { Debug.WriteLine("TEST START: WriteDoesNotLockParentDirectory"); // Mutex name for the root directory, which is the parent directory for the file we're about to write to // Create the file _io.Write(FileName, _data); using (new FileMutex(string.Empty)) { // Writing into the file should work, because the file already exists and FileIO::Write doesn't need to lock the // parent directory ThreadTestUtils.RunActionOnThreadAndJoin(() => _io.Write(FileName, _data)); } }
[Ignore] // TODO: re-enable this, getting mutex timeouts... public void WriteFileConcurrently() { Debug.WriteLine("TEST START: WriteFileConcurrently"); ThreadTestUtils.ParallelExecute( () => { Thread.Sleep(new Random().Next() % 10); _io.Write(FileName, _data); }); CollectionAssert.AreEqual(_data, _io.Read(FileName)); // The file is in the right location Assert.IsTrue(File.Exists(_io.GetFullPath(FileName))); }
[Ignore] // TODO: re-enable this, getting mutex timeouts... public void CreateDirectoriesConcurrently() { Debug.WriteLine("TEST START: CreateDirectoriesConcurrently"); ThreadTestUtils.ParallelExecute( () => { Thread.Sleep(new Random().Next() % 10); using (_io.CreateDirectoriesLockParent("Level1/Level2/Level3")) { } }); string actual = _io.GetFullPath("Level1/Level2/Level3"); Assert.IsTrue(Directory.Exists(actual)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test(timeout = TEST_TIMEOUT) public void closeWaitForUpdateToFinish() throws java.io.IOException, InterruptedException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void CloseWaitForUpdateToFinish() { // GIVEN System.Threading.CountdownEvent latch = new System.Threading.CountdownEvent(1); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final IndexProxy inner = new IndexProxyAdapter() IndexProxy inner = new IndexProxyAdapterAnonymousInnerClass3(this); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final IndexProxy outer = newContractCheckingIndexProxy(inner); IndexProxy outer = NewContractCheckingIndexProxy(inner); Thread actionThread = CreateActionThread(outer.close); outer.Start(); // WHEN Thread updaterThread = RunInSeparateThread(() => { try { using (IndexUpdater updater = outer.NewUpdater(IndexUpdateMode.Online)) { updater.process(null); try { actionThread.Start(); latch.await(); } catch (InterruptedException e) { throw new Exception(e); } } } catch (IndexEntryConflictException e) { throw new Exception(e); } }); ThreadTestUtils.awaitThreadState(actionThread, TEST_TIMEOUT, Thread.State.TIMED_WAITING); latch.Signal(); updaterThread.Join(); actionThread.Join(); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void writerCloseWaitForMergesInMergeQueue() internal virtual void WriterCloseWaitForMergesInMergeQueue() { assertTimeout(Duration.ofSeconds(10), () => { _indexWriter = mock(typeof(IndexWriter)); SegmentCommitInfo segmentCommitInfo = SegmentCommitInfo; Mockito.when(_indexWriter.NextMerge).thenReturn(new TestOneMerge(segmentCommitInfo)).thenReturn(null); _mergeScheduler.merge(_indexWriter, MergeTrigger.EXPLICIT, false); assertEquals(1, _mergeScheduler.WriterTaskCount); Thread closeSchedulerThread = ThreadTestUtils.fork(() => _mergeScheduler.close()); ThreadTestUtils.awaitThreadState(closeSchedulerThread, TimeUnit.SECONDS.toMillis(5), Thread.State.TIMED_WAITING); _mergeScheduler.ExecutionLatch.Signal(); closeSchedulerThread.Join(); assertEquals(0, _mergeScheduler.WriterTaskCount); }); }
public void LockFile() { Debug.WriteLine("TEST START: LockFile"); using (_io.LockFile(FileName)) { ThreadTestUtils.RunActionOnThreadAndJoin( () => { // Another thread should not be able to acquire mutex with this name because it's being used by fileMutex Assert.ThrowsException <InvalidOperationException>(() => new FileMutex(FileName)); }); } ThreadTestUtils.RunActionOnThreadAndJoin( () => { // Now this thread should be able to acquire mutex with this name because fileMutex went out of scope Assert.ThrowsException <InvalidOperationException>(() => new FileMutex(FileName)); }); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test(timeout = TEST_TIMEOUT) public void closeWaitForForceToComplete() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void CloseWaitForForceToComplete() { // GIVEN System.Threading.CountdownEvent latch = new System.Threading.CountdownEvent(1); AtomicReference <Thread> actionThreadReference = new AtomicReference <Thread>(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final IndexProxy inner = new IndexProxyAdapter() IndexProxy inner = new IndexProxyAdapterAnonymousInnerClass4(this, latch, actionThreadReference); IndexProxy outer = NewContractCheckingIndexProxy(inner); Thread actionThread = CreateActionThread(outer.close); actionThreadReference.set(actionThread); outer.Start(); Thread thread = RunInSeparateThread(() => outer.force(Org.Neo4j.Io.pagecache.IOLimiter_Fields.Unlimited)); ThreadTestUtils.awaitThreadState(actionThread, TEST_TIMEOUT, Thread.State.TIMED_WAITING); latch.Signal(); thread.Join(); actionThread.Join(); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void takeOrAwaitLatchMustAwaitExistingLatchAndReturnNull() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void TakeOrAwaitLatchMustAwaitExistingLatchAndReturnNull() { AtomicReference <Thread> threadRef = new AtomicReference <Thread>(); BinaryLatch latch = _latches.takeOrAwaitLatch(42); assertThat(latch, @is(notNullValue())); ExecutorService executor = Executors.newSingleThreadExecutor(); Future <BinaryLatch> future = executor.submit(() => { threadRef.set(Thread.CurrentThread); return(_latches.takeOrAwaitLatch(42)); }); Thread th; do { th = threadRef.get(); } while (th == null); ThreadTestUtils.awaitThreadState(th, 10_000, Thread.State.WAITING); latch.Release(); assertThat(future.get(1, TimeUnit.SECONDS), @is(nullValue())); }