//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldSuppressFailureToCloseChannelInFailedAttemptToReadHeaderAfterOpen() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldSuppressFailureToCloseChannelInFailedAttemptToReadHeaderAfterOpen()
{
// GIVEN a file which returns 1/2 log header size worth of bytes
FileSystemAbstraction fs = mock(typeof(FileSystemAbstraction));
LogFiles logFiles = LogFilesBuilder.builder(_directory.databaseLayout(), fs).withTransactionIdStore(_transactionIdStore).withLogVersionRepository(_logVersionRepository).build();
int logVersion = 0;
File logFile = logFiles.GetLogFileForVersion(logVersion);
StoreChannel channel = mock(typeof(StoreChannel));
when(channel.read(any(typeof(ByteBuffer)))).thenReturn(LogHeader.LOG_HEADER_SIZE / 2);
when(fs.FileExists(logFile)).thenReturn(true);
when(fs.Open(eq(logFile), any(typeof(OpenMode)))).thenReturn(channel);
doThrow(typeof(IOException)).when(channel).close();
// WHEN
try
{
logFiles.OpenForVersion(logVersion);
fail("Should have failed");
}
catch (IncompleteLogHeaderException e)
{
// THEN good
verify(channel).close();
assertEquals(1, e.Suppressed.length);
assertTrue(e.Suppressed[0] is IOException);
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private org.neo4j.kernel.impl.transaction.log.ReadableLogChannel openLogFile(org.neo4j.io.fs.FileSystemAbstraction fs, int version) throws java.io.IOException
internal virtual ReadableLogChannel OpenLogFile(FileSystemAbstraction fs, int version)
{
LogFiles logFiles = LogFilesBuilder.logFilesBasedOnlyBuilder(WorkingDirectory, fs).build();
PhysicalLogVersionedStoreChannel channel = logFiles.OpenForVersion(version);
return(new ReadAheadLogChannel(channel, new ReaderLogVersionBridge(logFiles)));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public void execute() throws java.io.IOException, org.neo4j.commandline.admin.CommandFailed
public virtual void Execute()
{
if (!_fs.fileExists(_fromDatabasePath))
{
throw new System.ArgumentException(format("Source directory does not exist [%s]", _fromDatabasePath));
}
try
{
Validators.CONTAINS_EXISTING_DATABASE.validate(_fromDatabasePath);
}
catch (System.ArgumentException)
{
throw new System.ArgumentException(format("Source directory is not a database backup [%s]", _fromDatabasePath));
}
if (_fs.fileExists(_toDatabaseDir) && !_forceOverwrite)
{
throw new System.ArgumentException(format("Database with name [%s] already exists at %s", _toDatabaseName, _toDatabaseDir));
}
checkLock(DatabaseLayout.of(_toDatabaseDir).StoreLayout);
_fs.deleteRecursively(_toDatabaseDir);
if (!isSameOrChildFile(_toDatabaseDir, _transactionLogsDirectory))
{
_fs.deleteRecursively(_transactionLogsDirectory);
}
LogFiles backupLogFiles = LogFilesBuilder.logFilesBasedOnlyBuilder(_fromDatabasePath, _fs).build();
RestoreDatabaseFiles(backupLogFiles, _fromDatabasePath.listFiles());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldWriteSomeDataIntoTheLog() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldWriteSomeDataIntoTheLog()
{
// GIVEN
string name = "log";
FileSystemAbstraction fs = _fileSystemRule.get();
LogFiles logFiles = LogFilesBuilder.builder(_directory.databaseLayout(), fs).withTransactionIdStore(_transactionIdStore).withLogVersionRepository(_logVersionRepository).build();
_life.start();
_life.add(logFiles);
// WHEN
FlushablePositionAwareChannel writer = logFiles.LogFile.Writer;
LogPositionMarker positionMarker = new LogPositionMarker();
writer.GetCurrentPosition(positionMarker);
int intValue = 45;
long longValue = 4854587;
writer.PutInt(intValue);
writer.PutLong(longValue);
writer.PrepareForFlush().flush();
// THEN
using (ReadableClosableChannel reader = logFiles.LogFile.getReader(positionMarker.NewPosition()))
{
assertEquals(intValue, reader.Int);
assertEquals(longValue, reader.Long);
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: static org.neo4j.kernel.impl.transaction.log.files.LogFiles readLogFiles(org.neo4j.io.layout.DatabaseLayout databaseLayout) throws java.io.IOException
internal static LogFiles ReadLogFiles(DatabaseLayout databaseLayout)
{
FileSystemAbstraction fileSystemAbstraction = new DefaultFileSystemAbstraction();
PageCache pageCache = ConfigurableStandalonePageCacheFactory.createPageCache(fileSystemAbstraction, new ThreadPoolJobScheduler());
return(LogFilesBuilder.activeFilesBuilder(databaseLayout, fileSystemAbstraction, pageCache).build());
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public ReadOnlyTransactionStore(org.neo4j.io.pagecache.PageCache pageCache, org.neo4j.io.fs.FileSystemAbstraction fs, org.neo4j.io.layout.DatabaseLayout fromDatabaseLayout, org.neo4j.kernel.configuration.Config config, org.neo4j.kernel.monitoring.Monitors monitors) throws java.io.IOException
public ReadOnlyTransactionStore(PageCache pageCache, FileSystemAbstraction fs, DatabaseLayout fromDatabaseLayout, Config config, Monitors monitors)
{
TransactionMetadataCache transactionMetadataCache = new TransactionMetadataCache();
LogEntryReader <ReadableClosablePositionAwareChannel> logEntryReader = new VersionAwareLogEntryReader <ReadableClosablePositionAwareChannel>();
LogFiles logFiles = LogFilesBuilder.activeFilesBuilder(fromDatabaseLayout, fs, pageCache).withLogEntryReader(logEntryReader).withConfig(config).build();
_physicalStore = new PhysicalLogicalTransactionStore(logFiles, transactionMetadataCache, logEntryReader, monitors, true);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public TemporaryStoreDirectory(org.neo4j.io.fs.FileSystemAbstraction fs, org.neo4j.io.pagecache.PageCache pageCache, java.io.File parent) throws java.io.IOException
public TemporaryStoreDirectory(FileSystemAbstraction fs, PageCache pageCache, File parent)
{
this._tempStoreDir = new File(parent, TEMP_COPY_DIRECTORY_NAME);
this._tempDatabaseLayout = DatabaseLayout.of(_tempStoreDir, GraphDatabaseSettings.DEFAULT_DATABASE_NAME);
_storeFiles = new StoreFiles(fs, pageCache, (directory, name) => true);
_tempLogFiles = LogFilesBuilder.logFilesBasedOnlyBuilder(_tempDatabaseLayout.databaseDirectory(), fs).build();
_storeFiles.delete(_tempStoreDir, _tempLogFiles);
}
/// <summary>
/// Analyzes transactions found in log file(s) specified by {@code storeDirOrLogFile} calling methods on the supplied
/// <seealso cref="Monitor"/> for each encountered data item.
/// </summary>
/// <param name="fileSystem"> <seealso cref="FileSystemAbstraction"/> to find the files on. </param>
/// <param name="storeDirOrLogFile"> <seealso cref="File"/> pointing either to a directory containing transaction log files, or directly
/// pointing to a single transaction log file to analyze. </param>
/// <param name="invalidLogEntryHandler"> <seealso cref="InvalidLogEntryHandler"/> to pass in to the internal <seealso cref="LogEntryReader"/>. </param>
/// <param name="monitor"> <seealso cref="Monitor"/> receiving call-backs for all <seealso cref="Monitor.transaction(LogEntry[]) transactions"/>,
/// <seealso cref="Monitor.checkpoint(CheckPoint, LogPosition) checkpoints"/> and <seealso cref="Monitor.logFile(File, long) log file transitions"/>
/// encountered during the analysis. </param>
/// <exception cref="IOException"> on I/O error. </exception>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public static void analyze(org.neo4j.io.fs.FileSystemAbstraction fileSystem, java.io.File storeDirOrLogFile, org.neo4j.kernel.impl.transaction.log.entry.InvalidLogEntryHandler invalidLogEntryHandler, Monitor monitor) throws java.io.IOException
public static void Analyze(FileSystemAbstraction fileSystem, File storeDirOrLogFile, InvalidLogEntryHandler invalidLogEntryHandler, Monitor monitor)
{
File firstFile;
LogVersionBridge bridge;
ReadAheadLogChannel channel;
LogEntryReader <ReadableClosablePositionAwareChannel> entryReader;
LogPositionMarker positionMarker;
if (storeDirOrLogFile.Directory)
{
// Use natural log version bridging if a directory is supplied
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.impl.transaction.log.files.LogFiles logFiles = org.neo4j.kernel.impl.transaction.log.files.LogFilesBuilder.logFilesBasedOnlyBuilder(storeDirOrLogFile, fileSystem).build();
LogFiles logFiles = LogFilesBuilder.logFilesBasedOnlyBuilder(storeDirOrLogFile, fileSystem).build();
bridge = new ReaderLogVersionBridgeAnonymousInnerClass(logFiles, monitor, channel);
long lowestLogVersion = logFiles.LowestLogVersion;
if (lowestLogVersion < 0)
{
throw new System.InvalidOperationException(format("Transaction logs at '%s' not found.", storeDirOrLogFile));
}
firstFile = logFiles.GetLogFileForVersion(lowestLogVersion);
monitor.LogFile(firstFile, lowestLogVersion);
}
else
{
// Use no bridging, simply reading this single log file if a file is supplied
firstFile = storeDirOrLogFile;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.impl.transaction.log.files.LogFiles logFiles = org.neo4j.kernel.impl.transaction.log.files.LogFilesBuilder.logFilesBasedOnlyBuilder(storeDirOrLogFile, fileSystem).build();
LogFiles logFiles = LogFilesBuilder.logFilesBasedOnlyBuilder(storeDirOrLogFile, fileSystem).build();
monitor.LogFile(firstFile, logFiles.GetLogVersion(firstFile));
bridge = NO_MORE_CHANNELS;
}
channel = new ReadAheadLogChannel(openVersionedChannel(fileSystem, firstFile), bridge);
entryReader = new VersionAwareLogEntryReader <ReadableClosablePositionAwareChannel>(new RecordStorageCommandReaderFactory(), invalidLogEntryHandler);
positionMarker = new LogPositionMarker();
using (TransactionLogEntryCursor cursor = new TransactionLogEntryCursor(new LogEntryCursor(entryReader, channel)))
{
channel.GetCurrentPosition(positionMarker);
while (cursor.Next())
{
LogEntry[] tx = cursor.Get();
if (tx.Length == 1 && tx[0].Type == CHECK_POINT)
{
monitor.Checkpoint(tx[0].As(), positionMarker.NewPosition());
}
else
{
monitor.Transaction(tx);
}
}
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void writePartialTx(java.io.File storeDir) throws java.io.IOException
private void WritePartialTx(File storeDir)
{
using (PageCache pageCache = this.PageCache.getPageCache(_fs))
{
LogFiles logFiles = LogFilesBuilder.activeFilesBuilder(DatabaseLayout.of(storeDir), _fs, pageCache).build();
using (Lifespan ignored = new Lifespan(logFiles))
{
LogEntryWriter writer = new LogEntryWriter(logFiles.LogFile.Writer);
writer.WriteStartEntry(0, 0, 0x123456789ABCDEFL, logFiles.LogFileInformation.LastEntryId + 1, new sbyte[] { 0 });
}
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void appendDropTransactionToTransactionLog(java.io.File databaseDirectory, org.neo4j.kernel.impl.transaction.CommittedTransactionRepresentation dropTransaction) throws java.io.IOException
private void AppendDropTransactionToTransactionLog(File databaseDirectory, CommittedTransactionRepresentation dropTransaction)
{
LogFiles logFiles = LogFilesBuilder.logFilesBasedOnlyBuilder(databaseDirectory, Fs).build();
File logFile = logFiles.GetLogFileForVersion(logFiles.HighestLogVersion);
StoreChannel writeStoreChannel = Fs.open(logFile, OpenMode.READ_WRITE);
writeStoreChannel.Position(writeStoreChannel.size());
using (PhysicalFlushableChannel writeChannel = new PhysicalFlushableChannel(writeStoreChannel))
{
(new LogEntryWriter(writeChannel)).serialize(dropTransaction);
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public boolean isRecoveryRequiredAt(org.neo4j.io.layout.DatabaseLayout databaseLayout) throws java.io.IOException
public virtual bool IsRecoveryRequiredAt(DatabaseLayout databaseLayout)
{
// We need config to determine where the logical log files are
if (!NeoStores.isStorePresent(_pageCache, databaseLayout))
{
return(false);
}
LogEntryReader <ReadableClosablePositionAwareChannel> reader = new VersionAwareLogEntryReader <ReadableClosablePositionAwareChannel>();
LogFiles logFiles = LogFilesBuilder.activeFilesBuilder(databaseLayout, _fs, _pageCache).withConfig(_config).withLogEntryReader(reader).build();
LogTailScanner tailScanner = new LogTailScanner(logFiles, reader, _monitors);
return((new RecoveryStartInformationProvider(tailScanner, NO_MONITOR)).get().RecoveryRequired);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldReadOlderLogs() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldReadOlderLogs()
{
// GIVEN
FileSystemAbstraction fs = _fileSystemRule.get();
LogFiles logFiles = LogFilesBuilder.builder(_directory.databaseLayout(), fs).withTransactionIdStore(_transactionIdStore).withLogVersionRepository(_logVersionRepository).build();
_life.start();
_life.add(logFiles);
// WHEN
LogFile logFile = logFiles.LogFile;
FlushablePositionAwareChannel writer = logFile.Writer;
LogPositionMarker positionMarker = new LogPositionMarker();
writer.GetCurrentPosition(positionMarker);
LogPosition position1 = positionMarker.NewPosition();
int intValue = 45;
long longValue = 4854587;
sbyte[] someBytes = someBytes(40);
writer.PutInt(intValue);
writer.PutLong(longValue);
writer.Put(someBytes, someBytes.Length);
writer.PrepareForFlush().flush();
writer.GetCurrentPosition(positionMarker);
LogPosition position2 = positionMarker.NewPosition();
long longValue2 = 123456789L;
writer.PutLong(longValue2);
writer.Put(someBytes, someBytes.Length);
writer.PrepareForFlush().flush();
// THEN
using (ReadableClosableChannel reader = logFile.GetReader(position1))
{
assertEquals(intValue, reader.Int);
assertEquals(longValue, reader.Long);
assertArrayEquals(someBytes, ReadBytes(reader, 40));
}
using (ReadableClosableChannel reader = logFile.GetReader(position2))
{
assertEquals(longValue2, reader.Long);
assertArrayEquals(someBytes, ReadBytes(reader, 40));
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldOpenInFreshDirectoryAndFinallyAddHeader() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldOpenInFreshDirectoryAndFinallyAddHeader()
{
// GIVEN
string name = "log";
FileSystemAbstraction fs = _fileSystemRule.get();
LogFiles logFiles = LogFilesBuilder.builder(_directory.databaseLayout(), fs).withTransactionIdStore(_transactionIdStore).withLogVersionRepository(_logVersionRepository).build();
// WHEN
_life.start();
_life.add(logFiles);
_life.shutdown();
// THEN
File file = LogFilesBuilder.logFilesBasedOnlyBuilder(_directory.databaseDir(), fs).build().getLogFileForVersion(1L);
LogHeader header = readLogHeader(fs, file);
assertEquals(1L, header.LogVersion);
assertEquals(2L, header.LastCommittedTxId);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void skipLogFileWithoutHeader() throws java.io.IOException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void SkipLogFileWithoutHeader()
{
FileSystemAbstraction fs = _fileSystemRule.get();
LogFiles logFiles = LogFilesBuilder.builder(_directory.databaseLayout(), fs).withTransactionIdStore(_transactionIdStore).withLogVersionRepository(_logVersionRepository).build();
_life.add(logFiles);
_life.start();
// simulate new file without header presence
_logVersionRepository.incrementAndGetVersion();
fs.Create(logFiles.GetLogFileForVersion(_logVersionRepository.CurrentLogVersion)).close();
_transactionIdStore.transactionCommitted(5L, 5L, 5L);
PhysicalLogicalTransactionStore.LogVersionLocator versionLocator = new PhysicalLogicalTransactionStore.LogVersionLocator(4L);
logFiles.Accept(versionLocator);
LogPosition logPosition = versionLocator.LogPosition;
assertEquals(1, logPosition.LogVersion);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void appendCheckpoint(org.neo4j.kernel.impl.transaction.log.entry.LogEntryVersion logVersion) throws java.io.IOException
private void AppendCheckpoint(LogEntryVersion logVersion)
{
PageCache pageCache = _pageCacheRule.getPageCache(_fs);
VersionAwareLogEntryReader <ReadableClosablePositionAwareChannel> logEntryReader = new VersionAwareLogEntryReader <ReadableClosablePositionAwareChannel>();
LogFiles logFiles = LogFilesBuilder.activeFilesBuilder(_storeDirectory.databaseLayout(), _fs, pageCache).withLogEntryReader(logEntryReader).build();
LogTailScanner tailScanner = new LogTailScanner(logFiles, logEntryReader, new Monitors());
LogTailScanner.LogTailInformation tailInformation = tailScanner.TailInformation;
using (Lifespan lifespan = new Lifespan(logFiles))
{
FlushablePositionAwareChannel channel = logFiles.LogFile.Writer;
LogPosition logPosition = tailInformation.LastCheckPoint.LogPosition;
// Fake record
channel.Put(logVersion.byteCode()).put(CHECK_POINT).putLong(logPosition.LogVersion).putLong(logPosition.ByteOffset);
channel.PrepareForFlush().flush();
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public static void removeCheckPointFromTxLog(org.neo4j.io.fs.FileSystemAbstraction fileSystem, java.io.File databaseDirectory) throws java.io.IOException
public static void RemoveCheckPointFromTxLog(FileSystemAbstraction fileSystem, File databaseDirectory)
{
LogFiles logFiles = LogFilesBuilder.logFilesBasedOnlyBuilder(databaseDirectory, fileSystem).build();
LogEntryReader <ReadableClosablePositionAwareChannel> logEntryReader = new VersionAwareLogEntryReader <ReadableClosablePositionAwareChannel>();
LogTailScanner tailScanner = new LogTailScanner(logFiles, logEntryReader, new Monitors());
LogTailScanner.LogTailInformation logTailInformation = tailScanner.TailInformation;
if (logTailInformation.CommitsAfterLastCheckpoint())
{
// done already
return;
}
// let's assume there is at least a checkpoint
assertNotNull(logTailInformation.LastCheckPoint);
LogPosition logPosition = logTailInformation.LastCheckPoint.LogPosition;
File logFile = logFiles.GetLogFileForVersion(logPosition.LogVersion);
fileSystem.Truncate(logFile, logPosition.ByteOffset);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldVisitLogFile() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldVisitLogFile()
{
// GIVEN
string name = "log";
FileSystemAbstraction fs = _fileSystemRule.get();
LogFiles logFiles = LogFilesBuilder.builder(_directory.databaseLayout(), fs).withTransactionIdStore(_transactionIdStore).withLogVersionRepository(_logVersionRepository).build();
_life.start();
_life.add(logFiles);
LogFile logFile = logFiles.LogFile;
FlushablePositionAwareChannel writer = logFile.Writer;
LogPositionMarker mark = new LogPositionMarker();
writer.GetCurrentPosition(mark);
for (int i = 0; i < 5; i++)
{
writer.Put(( sbyte )i);
}
writer.PrepareForFlush();
// WHEN/THEN
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.atomic.AtomicBoolean called = new java.util.concurrent.atomic.AtomicBoolean();
AtomicBoolean called = new AtomicBoolean();
logFile.Accept(channel =>
{
for (int i = 0; i < 5; i++)
{
assertEquals(( sbyte )i, channel.get());
}
called.set(true);
return(true);
}, mark.NewPosition());
assertTrue(called.get());
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public boolean hasTxLogs(org.neo4j.io.layout.DatabaseLayout databaseLayout) throws java.io.IOException
public virtual bool HasTxLogs(DatabaseLayout databaseLayout)
{
return(LogFilesBuilder.activeFilesBuilder(databaseLayout, _fs, _pageCache).withConfig(_config).build().logFiles().Length > 0);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private org.neo4j.kernel.impl.transaction.log.files.LogFiles createLogFiles(org.neo4j.kernel.impl.transaction.log.TransactionIdStore transactionIdStore, org.neo4j.io.fs.FileSystemAbstraction fileSystemAbstraction) throws java.io.IOException
private LogFiles CreateLogFiles(TransactionIdStore transactionIdStore, FileSystemAbstraction fileSystemAbstraction)
{
SimpleLogVersionRepository logVersionRepository = new SimpleLogVersionRepository();
return(LogFilesBuilder.builder(_databaseLayout, fileSystemAbstraction).withTransactionIdStore(transactionIdStore).withLogVersionRepository(logVersionRepository).build());
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private org.neo4j.kernel.impl.transaction.log.files.LogFiles prepareLogFiles() throws java.io.IOException
private LogFiles PrepareLogFiles()
{
return(LogFilesBuilder.logFilesBasedOnlyBuilder(TestDirectory.directory(), _fs).build());
}
