//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void sendLargeFileWithUnreliableReadBufferSize() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void SendLargeFileWithUnreliableReadBufferSize() { // given sbyte[] bytes = new sbyte[MAX_SIZE * 3]; _random.NextBytes(bytes); File smallFile = TestDirectory.file("smallFile"); using (StoreChannel storeChannel = _fs.create(smallFile)) { storeChannel.write(ByteBuffer.wrap(bytes)); } Adversary adversary = new RandomAdversary(0.9, 0.0, 0.0); AdversarialFileSystemAbstraction afs = new AdversarialFileSystemAbstraction(adversary, _fs); FileSender fileSender = new FileSender(new StoreResource(smallFile, null, 16, afs)); // when + then assertFalse(fileSender.EndOfInput); assertEquals(FileChunk.Create(copyOfRange(bytes, 0, MAX_SIZE), false), fileSender.ReadChunk(_allocator)); assertEquals(FileChunk.Create(copyOfRange(bytes, MAX_SIZE, MAX_SIZE * 2), false), fileSender.ReadChunk(_allocator)); assertEquals(FileChunk.Create(copyOfRange(bytes, MAX_SIZE * 2, bytes.Length), true), fileSender.ReadChunk(_allocator)); assertNull(fileSender.ReadChunk(_allocator)); assertTrue(fileSender.EndOfInput); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldRecoverAfterCrashUnderLoad() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldRecoverAfterCrashUnderLoad() { EphemeralFileSystemAbstraction @delegate = _fileSystemRule.get(); AdversarialFileSystemAbstraction fsa = new AdversarialFileSystemAbstraction(new MethodGuardedAdversary(new CountingAdversary(100, true), typeof(StoreChannel).GetMethod("writeAll", typeof(ByteBuffer))), @delegate); long lastValue = 0; try { using (LongState persistedState = new LongState(fsa, _testDir.directory(), 14)) { while (true) // it will break from the Exception that AFS will throw { long tempValue = lastValue + 1; persistedState.TheState = tempValue; lastValue = tempValue; } } } catch (Exception expected) { EnsureStackTraceContainsExpectedMethod(expected.StackTrace, "writeAll"); } using (LongState restoredState = new LongState(@delegate, _testDir.directory(), 4)) { assertEquals(lastValue, restoredState.TheState); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldProperlyRecoveryAfterCloseOnActiveFileDuringRotation() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldProperlyRecoveryAfterCloseOnActiveFileDuringRotation() { EphemeralFileSystemAbstraction normalFSA = _fileSystemRule.get(); AdversarialFileSystemAbstraction breakingFSA = new AdversarialFileSystemAbstraction(new MethodGuardedAdversary(new CountingAdversary(5, true), typeof(StoreChannel).GetMethod("close")), normalFSA); SelectiveFileSystemAbstraction combinedFSA = new SelectiveFileSystemAbstraction(new File(new File(_testDir.directory(), "long-state"), "long.a"), breakingFSA, normalFSA); long lastValue = 0; try { using (LongState persistedState = new LongState(combinedFSA, _testDir.directory(), 14)) { while (true) // it will break from the Exception that AFS will throw { long tempValue = lastValue + 1; persistedState.TheState = tempValue; lastValue = tempValue; } } } catch (Exception expected) { // this stack trace should contain close() EnsureStackTraceContainsExpectedMethod(expected.StackTrace, "close"); } using (LongState restoredState = new LongState(normalFSA, _testDir.directory(), 14)) { assertThat(restoredState.TheState, greaterThanOrEqualTo(lastValue)); } }
/* * There was an issue where if multiple concurrent appending threads did append and they moved on * to await a force, where the force would fail and the one doing the force would raise a panic... * the other threads may not notice the panic and move on to mark those transactions as committed * and notice the panic later (which would be too late). */ //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldHaveAllConcurrentAppendersSeePanic() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldHaveAllConcurrentAppendersSeePanic() { // GIVEN Adversary adversary = new ClassGuardedAdversary(new CountingAdversary(1, true), FailMethod(typeof(BatchingTransactionAppender), "force")); EphemeralFileSystemAbstraction efs = new EphemeralFileSystemAbstraction(); FileSystemAbstraction fs = new AdversarialFileSystemAbstraction(adversary, efs); _life.add(new FileSystemLifecycleAdapter(fs)); DatabaseHealth databaseHealth = new DatabaseHealth(mock(typeof(DatabasePanicEventGenerator)), NullLog.Instance); LogFiles logFiles = LogFilesBuilder.builder(_testDirectory.databaseLayout(), fs).withLogVersionRepository(_logVersionRepository).withTransactionIdStore(_transactionIdStore).build(); _life.add(logFiles); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final BatchingTransactionAppender appender = life.add(new BatchingTransactionAppender(logFiles, logRotation, transactionMetadataCache, transactionIdStore, explicitIndexTransactionOrdering, databaseHealth)); BatchingTransactionAppender appender = _life.add(new BatchingTransactionAppender(logFiles, _logRotation, _transactionMetadataCache, _transactionIdStore, _explicitIndexTransactionOrdering, databaseHealth)); _life.start(); // WHEN int numberOfAppenders = 10; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.CountDownLatch trap = new java.util.concurrent.CountDownLatch(numberOfAppenders); System.Threading.CountdownEvent trap = new System.Threading.CountdownEvent(numberOfAppenders); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.kernel.impl.transaction.tracing.LogAppendEvent beforeForceTrappingEvent = new org.neo4j.kernel.impl.transaction.tracing.LogAppendEvent_Empty() LogAppendEvent beforeForceTrappingEvent = new LogAppendEvent_EmptyAnonymousInnerClass(this, trap); Race race = new Race(); for (int i = 0; i < numberOfAppenders; i++) { race.AddContestant(() => { try { // Append to the log, the LogAppenderEvent will have all of the appending threads // do wait for all of the other threads to start the force thing appender.Append(Tx(), beforeForceTrappingEvent); fail("No transaction should be considered appended"); } catch (IOException) { // Good, we know that this test uses an adversarial file system which will throw // an exception in BatchingTransactionAppender#force, and since all these transactions // will append and be forced in the same batch, where the force will fail then // all these transactions should fail. If there's any transaction not failing then // it just didn't notice the panic, which would be potentially hazardous. } }); } // THEN perform the race. The relevant assertions are made inside the contestants. race.Go(); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldProperlyRecoveryAfterCrashOnFileForceDuringWrite() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldProperlyRecoveryAfterCrashOnFileForceDuringWrite() { EphemeralFileSystemAbstraction normalFSA = _fileSystemRule.get(); /* * Magic number warning. For a rotation threshold of 14, 990 operations on file A falls on a force() of the * current active file. This has been discovered via experimentation. The end result is that there is a * flush (but not write) a value. This should be recoverable. Interestingly, the failure semantics are a bit * unclear on what should happen to that value. We assume that exception during persistence requires recovery * to discover if the last argument made it to disk or not. Since we use an EFSA, force is not necessary and * the value that caused the failure is actually "persisted" and recovered. */ AdversarialFileSystemAbstraction breakingFSA = new AdversarialFileSystemAbstraction(new MethodGuardedAdversary(new CountingAdversary(40, true), typeof(StoreChannel).GetMethod("force", typeof(bool))), normalFSA); SelectiveFileSystemAbstraction combinedFSA = new SelectiveFileSystemAbstraction(new File(new File(_testDir.directory(), "long-state"), "long.a"), breakingFSA, normalFSA); long lastValue = 0; try { using (LongState persistedState = new LongState(combinedFSA, _testDir.directory(), 14)) { while (true) // it will break from the Exception that AFS will throw { long tempValue = lastValue + 1; persistedState.TheState = tempValue; lastValue = tempValue; } } } catch (Exception expected) { // this stack trace should contain force() EnsureStackTraceContainsExpectedMethod(expected.StackTrace, "force"); } using (LongState restoredState = new LongState(normalFSA, _testDir.directory(), 14)) { assertThat(restoredState.TheState, greaterThanOrEqualTo(lastValue)); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldProperlyRecoveryAfterCrashOnFileCreationDuringRotation() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldProperlyRecoveryAfterCrashOnFileCreationDuringRotation() { EphemeralFileSystemAbstraction normalFSA = _fileSystemRule.get(); /* * Magic number warning. For a rotation threshold of 14, 998 operations on file A falls on truncation of the * file during rotation. This has been discovered via experimentation. The end result is that there is a * failure to create the file to rotate to. This should be recoverable. */ AdversarialFileSystemAbstraction breakingFSA = new AdversarialFileSystemAbstraction(new MethodGuardedAdversary(new CountingAdversary(20, true), typeof(FileSystemAbstraction).GetMethod("truncate", typeof(File), typeof(long))), normalFSA); SelectiveFileSystemAbstraction combinedFSA = new SelectiveFileSystemAbstraction(new File(new File(_testDir.directory(), "long-state"), "long.a"), breakingFSA, normalFSA); long lastValue = 0; try { using (LongState persistedState = new LongState(combinedFSA, _testDir.directory(), 14)) { while (true) // it will break from the Exception that AFS will throw { long tempValue = lastValue + 1; persistedState.TheState = tempValue; lastValue = tempValue; } } } catch (Exception expected) { // this stack trace should contain FSA.truncate() EnsureStackTraceContainsExpectedMethod(expected.StackTrace, "truncate"); } using (LongState restoredState = new LongState(normalFSA, _testDir.directory(), 14)) { assertEquals(lastValue, restoredState.TheState); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @RepeatedTest(20) void pageCacheMustRemainInternallyConsistentWhenGettingRandomFailures() internal virtual void PageCacheMustRemainInternallyConsistentWhenGettingRandomFailures() { assertTimeout(ofMillis(LONG_TIMEOUT_MILLIS), () => { // NOTE: This test is inherently non-deterministic. This means that every failure must be // thoroughly investigated, since they have a good chance of being a real issue. // This is effectively a targeted robustness test. RandomAdversary adversary = new RandomAdversary(0.5, 0.2, 0.2); adversary.ProbabilityFactor = 0.0; FileSystemAbstraction fs = new AdversarialFileSystemAbstraction(adversary, this.fs); ThreadLocalRandom rng = ThreadLocalRandom.current(); // Because our test failures are non-deterministic, we use this tracer to capture a full history of the // events leading up to any given failure. LinearTracers linearTracers = LinearHistoryTracerFactory.pageCacheTracer(); getPageCache(fs, maxPages, linearTracers.PageCacheTracer, linearTracers.CursorTracerSupplier); PagedFile pfA = pageCache.map(existingFile("a"), filePageSize); PagedFile pfB = pageCache.map(existingFile("b"), filePageSize / 2 + 1); adversary.ProbabilityFactor = 1.0; for (int i = 0; i < 1000; i++) { PagedFile pagedFile = rng.nextBoolean() ? pfA : pfB; long maxPageId = pagedFile.LastPageId; bool performingRead = rng.nextBoolean() && maxPageId != -1; long startingPage = maxPageId < 0 ? 0 : rng.nextLong(maxPageId + 1); int pfFlags = performingRead ? PF_SHARED_READ_LOCK : PF_SHARED_WRITE_LOCK; int pageSize = pagedFile.PageSize(); try { using (PageCursor cursor = pagedFile.Io(startingPage, pfFlags)) { if (performingRead) { PerformConsistentAdversarialRead(cursor, maxPageId, startingPage, pageSize); } else { PerformConsistentAdversarialWrite(cursor, rng, pageSize); } } } catch (AssertionError error) { // Capture any exception that might have hit the eviction thread. adversary.ProbabilityFactor = 0.0; try { using (PageCursor cursor = pagedFile.Io(0, PF_SHARED_WRITE_LOCK)) { for (int j = 0; j < 100; j++) { cursor.Next(rng.nextLong(maxPageId + 1)); } } } catch (Exception throwable) { error.addSuppressed(throwable); } throw error; } catch (Exception) { // Don't worry about it... it's fine! // throwable.printStackTrace(); // only enable this when debugging test failures. } } // Unmapping will cause pages to be flushed. // We don't want that to fail, since it will upset the test tear-down. adversary.ProbabilityFactor = 0.0; try { // Flushing all pages, if successful, should clear any internal // exception. pageCache.flushAndForce(); // Do some post-chaos verification of what has been written. VerifyAdversarialPagedContent(pfA); VerifyAdversarialPagedContent(pfB); pfA.Close(); pfB.Close(); } catch (Exception e) { linearTracers.printHistory(System.err); throw e; } }); }