private int SaveItem(object item, IDataReaderPool dataReaderPool, string path, OverallProgressReporter overallProgressReporter, HandledContainers handledContainers, bool createForensicIntegrityLog)
{
IInputFile inputFile = item as IInputFile;
if (inputFile != null)
{
return(SaveInputFile(inputFile, dataReaderPool, path, overallProgressReporter, handledContainers, createForensicIntegrityLog));
}
IDataBlock dataBlock = item as IDataBlock;
if (dataBlock != null)
{
return(SaveDataBlock(dataBlock, dataReaderPool, path, overallProgressReporter, handledContainers, createForensicIntegrityLog));
}
ICodecStream codecStream = item as ICodecStream;
if (codecStream != null)
{
path = string.Format("{0}__{1}", path, ReplaceIllegalPathCharactersByUnderscore(codecStream.Name));
return(SaveCodecStream(codecStream, dataReaderPool, path, overallProgressReporter, handledContainers, createForensicIntegrityLog));
}
return(0); // TODO: is this an error?
}
internal static IResultNode GetResults(IFragment fragment)
{
using (IDataReaderPool dataReaderPool = _container.Resolve <IDataReaderPool>())
{
return(DataBlockScanner.GetResults(fragment, new NullProgressReporter(), dataReaderPool));
}
}
private IResultNode GetResults(IFragment fragment, IProgressReporter progressReporter)
{
using (IDataReaderPool dataReaderPool = _createDataReaderPool())
{
return(_dataBlockScanner.GetResults(fragment, progressReporter, dataReaderPool));
}
}
/// <summary>
/// Saves a <paramref name="dataBlock"/> and its codec streams.
/// </summary>
/// <param name="dataBlock">The data block to save</param>
/// <param name="dataReaderPool">The shared pool of file data readers</param>
/// <param name="path">The directory in which to store the files</param>
/// <param name="overallProgressReporter"></param>
/// <param name="handledContainers"></param>
/// <param name="forensicIntegrityLogFile"></param>
/// <returns>The number of files saved</returns>
private int SaveDataBlock(IDataBlock dataBlock, IDataReaderPool dataReaderPool, string path, OverallProgressReporter overallProgressReporter, HandledContainers handledContainers, bool createForensicIntegrityLog)
{
if (string.IsNullOrEmpty(path) || dataBlock == null)
{
return(0);
}
int numFullFiles = 0;
path += string.Format("_{0}", ReplaceIllegalPathCharactersByUnderscore(dataBlock.Detectors.First().Name));
if (Write(dataBlock, dataReaderPool, path, overallProgressReporter, handledContainers, createForensicIntegrityLog))
{
numFullFiles++;
// Save all detectables
foreach (ICodecStream codecStream in dataBlock.CodecStreams)
{
string fileName = string.Format("{0}_extracted_{1}_stream", path,
ReplaceIllegalPathCharactersByUnderscore(codecStream.DataFormat.ToString()));
numFullFiles += SaveCodecStream(codecStream, dataReaderPool, fileName, overallProgressReporter, handledContainers,
createForensicIntegrityLog);
}
}
return(numFullFiles);
}
//internal IDataPacket GetData(ICodecStream codecStream)
//{
// return GetData(codecStream, new NullProgressReporter());
//}
internal IDataPacket GetData(ICodecStream codecStream, IProgressReporter progressReporter)
{
using (IDataReaderPool dataReaderPool = _createDataReaderPool())
{
return(_dataBlockScanner.GetData(codecStream, progressReporter, dataReaderPool));
}
}
private IDataPacket RescanDataPackets(IEnumerable <IDataPacket> dataPackets, IDataReaderPool dataReaderPool, IProgressReporter progressReporter)
{
IDataPacket concatenatedDataPacket = null;
long totalByteCount = dataPackets.Sum(x => x.Length);
long bytesSaved = 0L;
foreach (IDataPacket dataPacket in dataPackets)
{
if (progressReporter.CancellationPending)
{
return(null);
}
IDataPacket rescannedDataPacket = dataPacket;
if (dataPacket is ICodecStream)
{
if (dataPacket is RescannedCodecStream)
{
rescannedDataPacket = dataPacket;
}
else
{
IProgressReporter rescanProgressReporter = new NullProgressReporter();
rescannedDataPacket = CreateDataBlockScanner().GetData(dataPacket as ICodecStream, rescanProgressReporter, dataReaderPool);
}
}
concatenatedDataPacket = (concatenatedDataPacket == null) ? rescannedDataPacket : concatenatedDataPacket.Append(rescannedDataPacket);
bytesSaved += dataPacket.Length;
}
return(concatenatedDataPacket);
}
/// <summary>
/// Creates a new file scanner for scanning (multiple) files.
/// </summary>
/// <param name="containerDataScanner">The <see cref="IDataScanner"/> for container formats</param>
/// <param name="codecDataScanner">The <see cref="IDataScanner"/> for codec formats</param>
/// <param name="dataReaderPool">The shared pool of file data readers</param>
/// <param name="createDataBlockBuilder">The factory method for creating data blocks</param>
/// <param name="createSubProgressReporter">The factory method for creating a sub progress reporter</param>
/// data scanner fors canning codec streams (of a detected data block)</param>
/// <exception cref="ArgumentNullException">If any argument is <c>null</c></exception>
public FileScanner(IDataScanner containerDataScanner, IDataScanner codecDataScanner, IDataScanner codecStreamDataScanner,
IDataReaderPool dataReaderPool, Creator <IDataBlockBuilder> createDataBlockBuilder,
Creator <IProgressReporter, IProgressReporter, long, long, long> createSubProgressReporter)
{
PreConditions.Argument("containerDataScanner").Value(containerDataScanner).IsNotNull();
PreConditions.Argument("codecDataScanner").Value(codecDataScanner).IsNotNull();
PreConditions.Argument("codecStreamDataScanner").Value(codecStreamDataScanner).IsNotNull();
PreConditions.Argument("dataReaderPool").Value(dataReaderPool).IsNotNull();
PreConditions.Argument("createDataBlockBuilder").Value(createDataBlockBuilder).IsNotNull();
PreConditions.Argument("createSubProgressReporter").Value(createSubProgressReporter).IsNotNull();
_containerDataScanner = containerDataScanner;
_codecDataScanner = codecDataScanner;
_codecStreamDataScanner = codecStreamDataScanner;
_dataReaderPool = dataReaderPool;
_createDataBlockBuilder = createDataBlockBuilder;
_createSubProgressReporter = createSubProgressReporter;
_codecDataScanner.DataBlockDetected += (sender, e) => FixAndReportDataBlock(e.DataBlock);
_containerDataScanner.DataBlockDetected += (sender, e) => ScanCodecStreams(e, e.DataBlock);
_containerDataScanner.UnknownDataDetected += (sender, e) => ScanForCodecFormats(_inputFile.CreateDataPacket().GetSubPacket(e.Offset, e.Length));
// The default is that container blocks are allowed to overlap. See also issue DEFR-867.
AllowOverlap = true;
}
/// <summary>
/// Writes <paramref name="detectables"/> sequentially to file with
/// name <paramref name="fileName"/>.
/// </summary>
/// <param name="detectables">the detectables to write</param>
/// <param name="fileName">the name of the file to write to</param>
/// <typeparam name="T">the type of detectables to write</typeparam>
internal static void WriteDetectables <T>(IList <T> detectables, string fileName, IProgressReporter progressReporter, ref long handledBytes, long totalBytes) where T : IDataPacket
{
if (detectables == null)
{
throw new ArgumentNullException("detectables");
}
if (string.IsNullOrEmpty(fileName))
{
throw new ArgumentNullException("fileName");
}
using (IDataReaderPool dataReaderPool = CreateDataReaderPool())
using (ResultWriter writer = new ResultWriter(File.Create(fileName), dataReaderPool))
{
foreach (T detectable in detectables)
{
IDataPacket dataPacket;
if (detectable is ICodecStream)
{
// It's a codec stream
dataPacket = DataBlockScanner.GetData(detectable as ICodecStream, progressReporter, dataReaderPool);
}
else
{
// It's a container stream
dataPacket = detectable;
}
writer.WriteDataPacket(dataPacket, progressReporter, ref handledBytes, totalBytes);
}
}
}
/// <summary>
/// Saves the <paramref name="dataPacket"/> sequentially to a single file with
/// given <paramref name="filePath"/>.
/// </summary>
/// <param name="dataPacket">The data packet to save</param>
/// <param name="detectors">The detectors used to create data packet</param>
/// <param name="dataReaderPool">The shared pool of file data readers</param>
/// <param name="filePath">The path name of the file to write to</param>
/// <param name="progressReporter">For reporting progress and checking cancellation</param>
/// <param name="createForensicIntegrityLog">Create a forensic integrity log file along with the normal output</param>
/// <exception cref="ArgumentNullException">If any argument is <c>null</c></exception>
/// <exception cref="IOException">On error writing the output file</exception>
public void Save(IDataPacket dataPacket, IEnumerable <IDetector> detectors, IDataReaderPool dataReaderPool, string filePath, IProgressReporter progressReporter, bool createForensicIntegrityLog)
{
PreConditions.Argument("dataPacket").Value(dataPacket).IsNotNull();
PreConditions.Argument("detectors").Value(detectors).IsNotNull().And.DoesNotContainNull();
PreConditions.Argument("dataReaderPool").Value(dataReaderPool).IsNotNull();
PreConditions.Argument("filePath").Value(filePath).IsNotNull().And.IsNotEmpty();
PreConditions.Argument("progressReporter").Value(progressReporter).IsNotNull();
if (progressReporter.CancellationPending)
{
return;
}
using (IDataWriter dataWriter = _createDataWriter(filePath))
{
using (IDataReader dataReader = dataReaderPool.CreateDataReader(dataPacket, progressReporter))
{
dataWriter.Write(dataReader);
}
}
if (createForensicIntegrityLog)
{
string logFileName = string.Format("{0}.csv", filePath);
using (FileStream fs = new FileStream(logFileName, FileMode.Create, FileAccess.Write, FileShare.Read))
{
_forensicIntegrityLog.Log(dataPacket, detectors, filePath, fs, ForensicLogType.CopiedData);
}
}
}
/// <summary>
/// Creates a new <see cref="FragmentedDataReader"/> for reading the
/// (possibly) fragmented <paramref name="dataPacket"/> using the given
/// <paramref name="dataReaderPool"/>.
/// </summary>
/// <remarks>
/// The fragments of the data packet can refer to multiple files, which will
/// be opened using the <paramref name="dataReaderPool"/>. The <see cref="Dispose"/>
/// method will close all open files by disposing the <see cref="IDataReaderPool"/>.
/// </remarks>
/// <param name="dataPacket">the data packet</param>
/// <param name="dataReaderPool">the pool of data readers to use</param>
public FragmentedDataReader(IDataPacket dataPacket, IDataReaderPool dataReaderPool)
{
PreConditions.Argument("dataPacket").Value(dataPacket).IsNotNull();
PreConditions.Argument("dataReaderPool").Value(dataReaderPool).IsNotNull();
_dataPacket = dataPacket;
_dataReaderPool = dataReaderPool;
_position = 0;
}
/// <summary>
/// Saves all data blocks (and codec streams) for one <paramref name="inputFile"/>.
/// </summary>
/// <param name="inputFile">The input file to save</param>
/// <param name="path">The directory in which to store the files</param>
/// <returns>The number of files saved</returns>
private int SaveInputFile(IInputFile inputFile, IDataReaderPool dataReaderPool, string path, OverallProgressReporter overallProgressReporter, HandledContainers handledContainers, bool createForensicIntegrityLog)
{
int numFullFiles = 0;
foreach (IDataBlock dataBlock in inputFile.Project.GetDataBlocks(inputFile))
{
numFullFiles += SaveDataBlock(dataBlock, dataReaderPool, path, overallProgressReporter, handledContainers, createForensicIntegrityLog);
}
return(numFullFiles);
}
public void Dispose()
{
if (_dataReaderPool != null)
{
// It should probably not dispose the pool, since that would defeat
// the purpose of a _shared_ pool of data readers!
//_dataReaderPool.Dispose();
_dataReaderPool = null;
}
}
public void SaveAsSeparateFiles(IEnumerable <object> items, string directory, bool createForensicIntegrityLog, IProgressReporter progressReporter)
{
PreConditions.Argument("items").Value(items).IsNotNull();
PreConditions.Argument("directory").Value(directory).IsNotNull().And.IsNotEmpty();
PreConditions.Argument("progressReporter").Value(progressReporter).IsNotNull();
using (IDataReaderPool dataReaderPool = _createDataReaderPool())
{
_saveAsSeparateFiles.Save(items, Enumerable.Empty <IDetector>(), dataReaderPool, directory, progressReporter, createForensicIntegrityLog);
}
}
internal static string ExportToXml(IEnumerable <IFragment> fragments)
{
StringBuilder xmlStringBuider = new StringBuilder();
ExportToXml exportToXml = new ExportToXml((f) => new StringWriter(xmlStringBuider), DataBlockScanner, new DefaultDetectorFormatter());
using (IDataReaderPool dataReaderPool = _container.Resolve <IDataReaderPool>())
{
exportToXml.Export(fragments, dataReaderPool, "<path>", MockRepository.GenerateStub <IProgressReporter>());
return(xmlStringBuider.ToString());
}
}
private byte[] ReadDataPacket(IDataPacket dataPacket)
{
var data = new byte[dataPacket.Length];
using (IDataReaderPool pool = _poolCreator())
using (IDataReader reader = pool.CreateDataReader(dataPacket))
{
reader.Read(data, 0, data.Length);
}
return(data);
}
public void ExportToXml(IEnumerable <IFragment> fragments, string filePath, IProgressReporter progressReporter)
{
PreConditions.Argument("fragments").Value(fragments).IsNotNull();
PreConditions.Argument("filePath").Value(filePath).IsNotNull().And.IsNotEmpty();
PreConditions.Argument("progressReporter").Value(progressReporter).IsNotNull();
using (IDataReaderPool dataReaderPool = _createDataReaderPool())
{
_exportToXml.Export(fragments, dataReaderPool, filePath, progressReporter);
}
}
public void SaveAsSingleFile(IInputFile inputFile, string filePath, bool createForensicIntegrityLog, IProgressReporter progressReporter)
{
PreConditions.Argument("inputFile").Value(inputFile).IsNotNull();
PreConditions.Argument("filePath").Value(filePath).IsNotNull().And.IsNotEmpty();
PreConditions.Argument("progressReporter").Value(progressReporter).IsNotNull();
using (IDataReaderPool dataReaderPool = _createDataReaderPool())
{
_saveAsSingleFile.Save(inputFile, Enumerable.Empty <IDetector>(), dataReaderPool, filePath, progressReporter, createForensicIntegrityLog);
}
}
public void TearDown()
{
_mockRepository = null;
_codecStream = null;
_dataWriter = null;
_progressReporter1 = null;
_detectors = null;
_dataReaderPool = null;
_createDataWriter = null;
_createSubProgressReporter = null;
_saveAsSeparateFiles = null;
}
/// <summary>
/// Writes <paramref name="results"/> recursively to file with
/// name <paramref name="fileName"/>.
/// </summary>
/// <param name="results">the results to write</param>
/// <param name="fileName">the name of the file to write to/param>
internal static void WriteResults(IResultNode[] results, string fileName)
{
long dummy = 0L;
using (IDataReaderPool dataReaderPool = TestFramework.CreateDataReaderPool())
using (ResultWriter writer = new ResultWriter(File.Create(fileName), dataReaderPool))
{
foreach (IResultNode result in results)
{
writer.WriteResult(result, null, ref dummy, 0L);
}
}
}
/// <summary>
/// Closes all associated output and input streams.
/// </summary>
public void Dispose()
{
if (_outputStream != null)
{
_outputStream.Close();
_outputStream = null;
}
if (_dataReaderPool != null)
{
// DO NOT DISPOSE THE DATA READER POOL !!!!
_dataReaderPool = null;
}
}
public void TearDown()
{
_mockRepository = null;
_dataPacket = null;
_dataReader = null;
_dataWriter = null;
_progressReporter = null;
_detectors = null;
_dataReaderPool = null;
_createDataWriter = null;
_forensicIntegrityLog = null;
_saveAsContiguousFile = null;
}
public void TearDown()
{
_mockRepository = null;
_containerDataScanner = null;
_codecDataScanner = null;
_codecStreamDataScanner = null;
_dataReaderPool = null;
_progressReporter = null;
_createDataBlockBuilder = null;
_createSubProgressReporter = null;
_inputFile = null;
_fileScanner = null;
}
public void TearDown()
{
_mockRepository = null;
_inputFile = null;
_detectors = null;
_dataPacket = null;
_dataReader = null;
_dataWriter = null;
_progressReporter = null;
_dataReaderPool = null;
_createDataWriter = null;
_saveAsSingleFile = null;
}
public void SetUp()
{
_mockRepository = new MockRepository();
_containerDataScanner = MockRepository.GenerateStub <IDataScanner>();
_codecDataScanner = MockRepository.GenerateStub <IDataScanner>();
_codecStreamDataScanner = MockRepository.GenerateStub <IDataScanner>();
_dataReaderPool = MockRepository.GenerateStub <IDataReaderPool>();
_progressReporter = MockRepository.GenerateStub <IProgressReporter>();
_createDataBlockBuilder = MockRepository.GenerateStub <Creator <IDataBlockBuilder> >();
_createSubProgressReporter = MockRepository.GenerateStub <Creator <IProgressReporter, IProgressReporter, long, long, long> >();
_inputFile = MockRepository.GenerateStub <IInputFile>();
_fileScanner = new FileScanner(_containerDataScanner, _codecDataScanner, _codecStreamDataScanner, _dataReaderPool, _createDataBlockBuilder, _createSubProgressReporter);
}
/// <summary>
/// Start the export to XML.
/// The export process is done using a background worker.
/// This gives the posibility to show progress and cancel the export any moment.
/// </summary>
/// <param name="resultTreeList">used to </param>
/// <param name="fragments">The fragments to export</param>
/// <param name="xmlExportFileName">The filename to export the detectables to</param>
public void Export(IEnumerable <IFragment> fragments, IDataReaderPool dataReaderPool, string filePath, IProgressReporter progressReporter)
{
PreConditions.Argument("fragments").Value(fragments).IsNotNull().And.IsNotEmpty().And.DoesNotContainNull();
PreConditions.Argument("dataReaderPool").Value(dataReaderPool).IsNotNull();
PreConditions.Argument("filePath").Value(filePath).IsNotNull().And.IsNotEmpty();
PreConditions.Argument("progressReporter").Value(progressReporter).IsNotNull();
// Create the XML document
XmlDocument xmlDocument = new XmlDocument();
// Create the root element and add it to the document
List <NameValuePair> infoNameValuePairs = new List <NameValuePair>();
infoNameValuePairs.Add(new NameValuePair("CreatedWith", ApplicationName));
infoNameValuePairs.Add(new NameValuePair("Version", ApplicationVersion));
infoNameValuePairs.Add(new NameValuePair("User", Environment.UserName));
DateTime currentDateTime = DateTime.Now;
infoNameValuePairs.Add(new NameValuePair("Date", currentDateTime.ToLongDateString()));
infoNameValuePairs.Add(new NameValuePair("Time", currentDateTime.ToLongTimeString()));
XmlElement root = CreateElement(xmlDocument, "FileInfo", infoNameValuePairs.ToArray());
xmlDocument.AppendChild(root);
// The progress must be measured and reported to the user;
// for that the total number of bytes to export is counted.
_totalBytes = fragments.Sum(x => x.Length);
foreach (IFragment fragment in fragments)
{
Export(root, fragment, dataReaderPool, progressReporter);
if (progressReporter.CancellationPending)
{
break;
}
}
// If the operation was canceled by the user,
// set the DoWorkEventArgs.Cancel property to true.
// This property is used in the RunWorkerCompleted method.
if (!progressReporter.CancellationPending)
{
using (TextWriter xmlExportWriter = _createTextWriter(filePath))
{
// Wait on completion of asynchronous method above before executing this method
xmlDocument.Save(xmlExportWriter);
}
}
}
private void Export(XmlNode parent, IFragment fragment, IDataReaderPool dataReaderPool, IProgressReporter progressReporter)
{
if (fragment == null)
{
return;
}
IResultNode results = _dataBlockScanner.GetResults(fragment, new NullProgressReporter(), dataReaderPool);
if (results == null)
{
// No results were found in the data block
// Add the bytes from this data block to the _byteCount variable
// to keep the progress bar correct.
_handledBytes += fragment.Length;
progressReporter.ReportProgress(_totalBytes == 0 ? 0 : (int)((_handledBytes * 100) / _totalBytes));
return;
}
List <NameValuePair> detectableNameValuePairs = new List <NameValuePair>();
detectableNameValuePairs.Add(new NameValuePair("File", fragment.InputFile.Name));
if (fragment.Detectors != null)
{
foreach (IDetector detector in fragment.Detectors)
{
detectableNameValuePairs.Add(new NameValuePair(_detectorFormatter.DetectorType(detector), detector.Name));
detectableNameValuePairs.Add(new NameValuePair(_detectorFormatter.DetectorType(detector) + "Version", _detectorFormatter.FormatVersion(detector)));
}
}
detectableNameValuePairs.Add(new NameValuePair("Offset", fragment.StartOffset.ToString()));
detectableNameValuePairs.Add(new NameValuePair("Length", fragment.Length.ToString()));
string nodeName = "UnknownContainerOrCodec";
if (fragment is IDataBlock)
{
nodeName = "Container";
}
else
{
nodeName = "Codec";
}
XmlElement fragmentElement = CreateElement(parent.OwnerDocument, nodeName, detectableNameValuePairs.ToArray());
parent.AppendChild(fragmentElement);
Export(fragmentElement, results.Children, progressReporter);
}
/// <summary>
/// Writes <paramref name="dataPacket"/> to <paramref name="fileName"/>.
/// </summary>
/// <param name="dataPacket">the data packet to write</param>
/// <param name="fileName">the name of the file to write to</param>
public static void WriteDataPacket(IDataPacket dataPacket, IDataReaderPool dataReaderPool, string fileName)
{
byte[] buffer = new byte[512 * 1024];
using (FileStream outputFileStream = new FileStream(fileName, FileMode.Create))
using (IDataReader dataReader = dataReaderPool.CreateDataReader(dataPacket))
{
int count;
while ((count = dataReader.Read(buffer, 0, buffer.Length)) > 0)
{
outputFileStream.Write(buffer, 0, count);
dataReader.Position += count;
}
}
}
public void SaveAsContiguousFile(IEnumerable <IDataPacket> dataPackets, IEnumerable <IDetector> detectors, string filePath, bool createForensicIntegrityLog, IProgressReporter progressReporter)
{
PreConditions.Argument("dataPackets").Value(dataPackets).IsNotNull();
PreConditions.Argument("detectors").Value(dataPackets).IsNotNull();
PreConditions.Argument("filePath").Value(filePath).IsNotNull().And.IsNotEmpty();
PreConditions.Argument("progressReporter").Value(progressReporter).IsNotNull();
using (IDataReaderPool dataReaderPool = _createDataReaderPool())
{
IDataPacket rescannedDataPacket = RescanDataPackets(dataPackets, dataReaderPool, progressReporter);
if (rescannedDataPacket != null)
{
_saveAsContiguousFile.Save(rescannedDataPacket, detectors, dataReaderPool, filePath, progressReporter, createForensicIntegrityLog);
}
}
}
public void SetUp()
{
_mockRepository = new MockRepository();
_codecStream = MockRepository.GenerateStub <ICodecStream>();
_dataWriter = _mockRepository.StrictMock <IDataWriter>();
_progressReporter1 = MockRepository.GenerateStub <IProgressReporter>();
_detectors = Enumerable.Empty <IDetector>();
_dataReaderPool = MockRepository.GenerateStub <IDataReaderPool>();
_createDataWriter = MockRepository.GenerateStub <Creator <IDataWriter, string> >();
_createSubProgressReporter = MockRepository.GenerateStub <Creator <IProgressReporter, IProgressReporter, long, long, long> >();
_forensicIntegrityLog = MockRepository.GenerateStub <IForensicIntegrityLog>();
_createDataWriter.Stub(x => x(FileName)).Return(_dataWriter).Repeat.Once();
_saveAsSeparateFiles = new SaveAsSeparateFiles(_createDataWriter, _createSubProgressReporter, TestFramework.DataBlockScanner, _forensicIntegrityLog);
}
public void SetUp()
{
_mockRepository = new MockRepository();
_dataPacket = MockRepository.GenerateStub <IDataPacket>();
_dataReader = MockRepository.GenerateStub <IDataReader>();
_dataWriter = _mockRepository.StrictMock <IDataWriter>();
_progressReporter = MockRepository.GenerateStub <IProgressReporter>();
_detectors = Enumerable.Empty <IDetector>();
_dataReaderPool = MockRepository.GenerateStub <IDataReaderPool>();
_createDataWriter = MockRepository.GenerateStub <Creator <IDataWriter, string> >();
_forensicIntegrityLog = MockRepository.GenerateStub <IForensicIntegrityLog>();
_dataPacket.Stub(x => x.Length).Return(DataPacketLength1);
_createDataWriter.Stub(x => x(FileName)).Return(_dataWriter).Repeat.Once();
_saveAsContiguousFile = new SaveAsContiguousFile(_createDataWriter, _forensicIntegrityLog);
}
