//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldSurviveFilesystemErrors() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldSurviveFilesystemErrors() { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.adversaries.RandomAdversary adversary = new org.neo4j.adversaries.RandomAdversary(0.1, 0.1, 0); RandomAdversary adversary = new RandomAdversary(0.1, 0.1, 0); adversary.ProbabilityFactor = 0; AdversarialFileSystemAbstraction adversarialFileSystem = new SensibleAdversarialFileSystemAbstraction(adversary, _fileSystem); RotatingFileOutputStreamSupplier supplier = new RotatingFileOutputStreamSupplier(adversarialFileSystem, _logFile, 1000, 0, 9, _directExecutor); adversary.ProbabilityFactor = 1; WriteLines(supplier, 10000); // run cleanly for a while, to allow it to fill any gaps left in log archive numbers adversary.ProbabilityFactor = 0; WriteLines(supplier, 10000); assertThat(_fileSystem.fileExists(_logFile), @is(true)); assertThat(_fileSystem.fileExists(_archiveLogFile1), @is(true)); assertThat(_fileSystem.fileExists(_archiveLogFile2), @is(true)); assertThat(_fileSystem.fileExists(_archiveLogFile3), @is(true)); assertThat(_fileSystem.fileExists(_archiveLogFile4), @is(true)); assertThat(_fileSystem.fileExists(_archiveLogFile5), @is(true)); assertThat(_fileSystem.fileExists(_archiveLogFile6), @is(true)); assertThat(_fileSystem.fileExists(_archiveLogFile7), @is(true)); assertThat(_fileSystem.fileExists(_archiveLogFile8), @is(true)); assertThat(_fileSystem.fileExists(_archiveLogFile9), @is(true)); }
//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: @ParameterizedTest @ValueSource(ints = {0, 1}) void mustHandleMischiefInPositionedVectoredRead(int noChannelStriping) throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void MustHandleMischiefInPositionedVectoredRead(int noChannelStriping) { int bytesTotal = 512; int bytesPerPage = 32; int pageCount = bytesTotal / bytesPerPage; sbyte[] data = new sbyte[bytesTotal]; ThreadLocalRandom.current().NextBytes(data); PageSwapperFactory factory = CreateSwapperFactory(); factory.Open(Fs, Configuration.EMPTY); File file = File; PageSwapper swapper = CreateSwapper(factory, file, bytesTotal, NoCallback, true, Bool(noChannelStriping)); try { long page = CreatePage(data); swapper.Write(0, page); } finally { swapper.Close(); } RandomAdversary adversary = new RandomAdversary(0.5, 0.0, 0.0); factory.Open(new AdversarialFileSystemAbstraction(adversary, Fs), Configuration.EMPTY); swapper = CreateSwapper(factory, file, bytesPerPage, NoCallback, false, Bool(noChannelStriping)); long[] pages = new long[pageCount]; for (int i = 0; i < pageCount; i++) { pages[i] = CreatePage(bytesPerPage); } sbyte[] temp = new sbyte[bytesPerPage]; try { for (int i = 0; i < 10_000; i++) { foreach (long page in pages) { Clear(page); } assertThat(swapper.Read(0, pages, bytesPerPage, 0, pages.Length), @is(( long )bytesTotal)); for (int j = 0; j < pageCount; j++) { Array.Copy(data, j * bytesPerPage, temp, 0, bytesPerPage); assertThat(Array(pages[j]), @is(temp)); } } } finally { swapper.Close(); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @ParameterizedTest @ValueSource(ints = {0, 1}) void mustHandleMischiefInPositionedVectoredWrite(int noChannelStriping) throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void MustHandleMischiefInPositionedVectoredWrite(int noChannelStriping) { int bytesTotal = 512; int bytesPerPage = 32; int pageCount = bytesTotal / bytesPerPage; sbyte[] data = new sbyte[bytesTotal]; ThreadLocalRandom.current().NextBytes(data); long zeroPage = CreatePage(bytesPerPage); Clear(zeroPage); File file = File; PageSwapperFactory factory = CreateSwapperFactory(); RandomAdversary adversary = new RandomAdversary(0.5, 0.0, 0.0); factory.Open(new AdversarialFileSystemAbstraction(adversary, Fs), Configuration.EMPTY); PageSwapper swapper = CreateSwapper(factory, file, bytesPerPage, NoCallback, true, Bool(noChannelStriping)); long[] writePages = new long[pageCount]; long[] readPages = new long[pageCount]; long[] zeroPages = new long[pageCount]; for (int i = 0; i < pageCount; i++) { writePages[i] = CreatePage(bytesPerPage); PutBytes(writePages[i], data, 0, i * bytesPerPage, bytesPerPage); readPages[i] = CreatePage(bytesPerPage); zeroPages[i] = zeroPage; } try { for (int i = 0; i < 10_000; i++) { adversary.ProbabilityFactor = 0; swapper.Write(0, zeroPages, 0, pageCount); adversary.ProbabilityFactor = 1; swapper.Write(0, writePages, 0, pageCount); foreach (long readPage in readPages) { Clear(readPage); } adversary.ProbabilityFactor = 0; assertThat(swapper.Read(0, readPages, bytesPerPage, 0, pageCount), @is(( long )bytesTotal)); for (int j = 0; j < pageCount; j++) { assertThat(Array(readPages[j]), @is(Array(writePages[j]))); } } } finally { swapper.Close(); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @ParameterizedTest @ValueSource(ints = {0, 1}) void mustHandleMischiefInPositionedRead(int noChannelStriping) throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void MustHandleMischiefInPositionedRead(int noChannelStriping) { int bytesTotal = 512; sbyte[] data = new sbyte[bytesTotal]; ThreadLocalRandom.current().NextBytes(data); PageSwapperFactory factory = CreateSwapperFactory(); factory.Open(Fs, Configuration.EMPTY); File file = File; PageSwapper swapper = CreateSwapper(factory, file, bytesTotal, NoCallback, true, Bool(noChannelStriping)); try { long page = CreatePage(data); swapper.Write(0, page); } finally { swapper.Close(); } RandomAdversary adversary = new RandomAdversary(0.5, 0.0, 0.0); factory.Open(new AdversarialFileSystemAbstraction(adversary, Fs), Configuration.EMPTY); swapper = CreateSwapper(factory, file, bytesTotal, NoCallback, false, Bool(noChannelStriping)); long page = CreatePage(bytesTotal); try { for (int i = 0; i < 10_000; i++) { Clear(page); assertThat(swapper.Read(0, page, SizeOfAsInt(page)), @is(( long )bytesTotal)); assertThat(Array(page), @is(data)); } } finally { swapper.Close(); } }
//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; } }); }
public AdversarialChannelDefaultFileSystemAbstraction(RandomAdversary adversary) { this._adversary = adversary; }