public static void ToFile(IBitmapWrapper bitmap, string filename) { Stream stream = FileStreamFactory.New(filename, "rw"); ToStream(bitmap, stream); stream.Dispose(); }
public void CreateReadOnlyShared_ShouldReturnUnwritableFileStream() { var factory = new FileStreamFactory(); var result = factory.CreateReadOnlyShared(Paths.SampleFile); Assert.False(result.CanWrite, "The returned stream was writable."); }
public void CreateWriteOnlyShared_ShouldReturnFileStream() { var factory = new FileStreamFactory(); var result = factory.CreateWriteOnlyShared(Paths.SampleFile); Assert.IsType <FileStream>(result); }
public static object FromFile(string filename) { var stream = FileStreamFactory.New(filename, "r"); var img = FromStream(stream); stream.Dispose(); return(img); }
public void Setup() { tempDirectoryName = "temp" + new Random().Next(); Directory.CreateDirectory(tempDirectoryName); logger = new Mock <ILog>(); fileStreamFactory = new FileStreamFactory(tempDirectoryName, logger.Object); }
void OpenFile() { if (!File.Exists(_filename)) { throw new Exception("file doesn't exists!"); } _filePtr = FileStreamFactory.CreateFileStream(_filename, FileMode.Open, FileAccess.Read, FileShare.Read, FileStreamBufferLength); _processedBytes = 0; }
public void FileAccess_SetFileAccessProperty_FileAccessPropertyIsSet() { var fileAccess = FileAccess.Read; var factory = new FileStreamFactory(); factory.FileAccess = fileAccess; Assert.AreEqual(fileAccess, factory.FileAccess); }
public void Create_FilePathIsNotSet_ExceptionIsThrown() { var fileMode = FileMode.Open; var fileAccess = FileAccess.Read; var fileShare = FileShare.Read; var factory = new FileStreamFactory(null, fileMode, fileAccess, fileShare); factory.Create(); }
public void FileMode_SetFileModeProperty_FileModePropertyIsSet() { var fileMode = FileMode.Open; var factory = new FileStreamFactory(); factory.FileMode = fileMode; Assert.AreEqual(fileMode, factory.FileMode); }
public void FilePath_SetFilePathProperty_FilePathPropertyIsSet() { var filePath = "FilePath"; var factory = new FileStreamFactory(); factory.FilePath = filePath; Assert.AreEqual(filePath, factory.FilePath); }
public void FileShare_SetFileShareProperty_FileSharePropertyIsSet() { var fileShare = FileShare.Read; var factory = new FileStreamFactory(); factory.FileShare = fileShare; Assert.AreEqual(fileShare, factory.FileShare); }
public void Correctly_Constructs_Read_File_Stream() { writeSampleFile(); IFileStreamFactory fileStreamFactory = new FileStreamFactory(); using (Stream stream = fileStreamFactory.ConstructReadFileStream("test.txt")) { Assert.That(stream.Length, Is.EqualTo(10)); } }
public void WhenCreatingAndOpeningFileShouldNotThrow() { var fileStreamFactory = new FileStreamFactory(); var createdStream = fileStreamFactory.CreateFile("testfile.test"); var streamWriter = new StreamWriter(createdStream); streamWriter.Write("blah"); streamWriter.Flush(); createdStream.Close(); Assert.NotNull(fileStreamFactory.OpenFile("testfile.test")); }
private static byte[][] ReadLeafs(HashAlgorithm tg, string filePath, long start, long end) { using (ThreadUtility.EnterBackgroundProcessingMode()) using (var threadFilePtr = FileStreamFactory.CreateFileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read, 128 * 1024)) { var threadFileBlock = new FileBlock(start, end); var LeafSize = 1024; var DataBlockSize = LeafSize * 1024; var data = new byte[LeafSize + 1]; var totalLeafs = threadFileBlock.Length / LeafSize + threadFileBlock.Length % LeafSize > 0 ? 1 : 0; var result = new byte[totalLeafs][]; threadFilePtr.Position = threadFileBlock.Start; while (threadFilePtr.Position < threadFileBlock.End) { var leafIndex = (int)((threadFilePtr.Position - start) / 1024); var dataBlock = new byte[Math.Min(threadFileBlock.End - threadFilePtr.Position, DataBlockSize)]; threadFilePtr.Read(dataBlock, 0, dataBlock.Length); //read block var blockLeafs = dataBlock.Length / LeafSize; int i; for (i = 0; i < blockLeafs; i++) { Buffer.BlockCopy(dataBlock, i * LeafSize, data, 1, LeafSize); tg.Initialize(); result[leafIndex++] = tg.ComputeHash(data); } if (i * LeafSize < dataBlock.Length) { data = new byte[dataBlock.Length - blockLeafs * LeafSize + 1]; data[0] = LeafHash; Buffer.BlockCopy(dataBlock, blockLeafs * LeafSize, data, 1, (data.Length - 1)); tg.Initialize(); result[leafIndex] = tg.ComputeHash(data); data = new byte[LeafSize + 1]; data[0] = LeafHash; } } return(result); } }
public void Constructor_AllParametersPassed_AllPropertiesAreSet() { var filePath = "FilePath"; var fileMode = FileMode.Open; var fileAccess = FileAccess.Read; var fileShare = FileShare.Read; var factory = new FileStreamFactory(filePath, fileMode, fileAccess, fileShare); Assert.AreEqual(filePath, factory.FilePath); Assert.AreEqual(fileMode, factory.FileMode); Assert.AreEqual(fileAccess, factory.FileAccess); Assert.AreEqual(fileShare, factory.FileShare); }
void ProcessLeafs(object threadId) { using (LowPriority ? ThreadUtility.EnterBackgroundProcessingMode() : null) using (var threadFilePtr = FileStreamFactory.CreateFileStream(_filename, FileMode.Open, FileAccess.Read, FileShare.Read, FileStreamBufferLength)) { var threadFileBlock = _fileParts[(int)threadId]; var tg = new T(); var data = new byte[LeafSize + 1]; threadFilePtr.Position = threadFileBlock.Start; var dataBlock = new byte[DataBlockSize]; while (threadFilePtr.Position < threadFileBlock.End) { var leafIndex = (int)(threadFilePtr.Position / 1024); var dataBlockSize = (int)Math.Min(threadFileBlock.End - threadFilePtr.Position, DataBlockSize); threadFilePtr.Read(dataBlock, 0, dataBlockSize); //read block Interlocked.Add(ref _processedBytes, dataBlockSize); var blockLeafs = dataBlockSize / 1024; int i; for (i = 0; i < blockLeafs; i++) { Buffer.BlockCopy(dataBlock, i * LeafSize, data, 1, LeafSize); tg.Initialize(); TTH[0][leafIndex++] = tg.ComputeHash(data); } if (i * LeafSize < dataBlockSize) { data = new byte[dataBlockSize - blockLeafs * LeafSize + 1]; data[0] = LeafHash; Buffer.BlockCopy(dataBlock, blockLeafs * LeafSize, data, 1, (data.Length - 1)); tg.Initialize(); TTH[0][leafIndex] = tg.ComputeHash(data); data = new byte[LeafSize + 1]; data[0] = LeafHash; } } } }
/// <summary> /// Called to send a specific length of bytes to a server identified by serverKey. The transfer /// is a blocking call and returns on success or raises an exception. If Abort() is called durring /// the transfer, or if a ProgressChanged event handler raises the OperationCanceledException, the /// transfer is silently terminated and the method will return false. /// </summary> /// <param name="location">A string of up to 1024 bytes in length</param> /// <param name="filename">The name of the file to write to</param> /// <returns>True if the file was successfully received by the server</returns> public bool Download(string location, string filename) { FileStreamFactory file = new FileStreamFactory(filename, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite); using (TempFile temp = TempFile.Attach(filename)) using (StreamCache cache = new StreamCache(file, LimitThreads)) { temp.Length = 0; if (Download(location, cache)) { temp.Detatch(); return(true); } } return(false); }
private async Task <long> InternalCopyChunk(Stream stream, long filePos, int bytesRequired) { if (_fileStream == null) { FileStream fs; using (new PerfLimit("Slow open " + Content.SystemPath, 4000)) { fs = FileStreamFactory.CreateFileStream(SystemPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, FileStreamReadBufferSize, FileOptions.Asynchronous); } lock (_syncRoot) { if (_isDisposed) { fs.Dispose(); return(0); } _fileStream = fs; } Interlocked.Increment(ref _fileStreamsCount); } _fileStream.Position = filePos; long readSoFar = 0L; var buffer = new byte[FileStreamReadBufferSize]; do { var toRead = Math.Min(bytesRequired - readSoFar, buffer.Length); var readNow = await _fileStream.ReadAsync(buffer, 0, (int)toRead).ConfigureAwait(false); if (readNow == 0) { break; // End of stream } await stream.WriteAsync(buffer, 0, readNow).ConfigureAwait(false); readSoFar += readNow; Interlocked.Add(ref _uploadedBytes, readNow); } while (readSoFar < bytesRequired); return(readSoFar); }
public void Create_OpenExistingFile_StreamIsReturned() { var filePath = this.FilePath; var fileMode = FileMode.Open; var fileAccess = FileAccess.Read; var fileShare = FileShare.Read; var factory = new FileStreamFactory(filePath, fileMode, fileAccess, fileShare); using (var file = File.Create(filePath)) { } using (var stream = factory.Create()) { Assert.IsInstanceOfType(stream, typeof(FileStream)); } }
public void Correctly_Constructs_Write_File_Stream() { deleteTestFile(); IFileStreamFactory fileStreamFactory = new FileStreamFactory(); using (Stream stream = fileStreamFactory.ConstructWriteFileStream("test.txt")) { FileStream fileStream = (FileStream)stream; fileStream.Write(new byte[] { 7, 9, 11 }, 0, 3); } using (Stream stream = fileStreamFactory.ConstructReadFileStream("test.txt")) { byte[] fileContents = new byte[3]; Assert.That(stream.Read(fileContents, 0, 3), Is.EqualTo(3)); Assert.That(fileContents, Is.EqualTo(new byte[] { 7, 9, 11 })); } }
public void TestFileStreamInvalidFileShare() { using (TempFile tempFile = new TempFile()) { FileStreamFactory factory = new FileStreamFactory(tempFile.TempPath, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None); using (factory.Create()) { factory.Create().Dispose(); Assert.Fail(); } } }
public void TestFileStreamInvalidAccessWithMode() { using (TempFile tempFile = new TempFile()) { FileStreamFactory factory = new FileStreamFactory(tempFile.TempPath, FileMode.Create, FileAccess.Read); Assert.AreEqual(tempFile.TempPath, factory.FileName); factory.Create().Dispose(); Assert.Fail(); } }
public void TestFileStreamInvalidBufferSize() { using (TempFile tempFile = new TempFile()) { FileStreamFactory factory = new FileStreamFactory(tempFile.TempPath, FileMode.Create, FileAccess.ReadWrite, FileShare.None, 0); Assert.AreEqual(tempFile.TempPath, factory.FileName); factory.Create().Dispose(); Assert.Fail(); } }
public void TestFileStreamFactoryCreateABunch() { using (TempFile tempFile = new TempFile()) { FileStreamFactory factory = new FileStreamFactory(tempFile.TempPath, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite); using (DisposingList<Stream> open = new DisposingList<Stream>()) { for( int i = 0; i < 50; i++ ) open.Add(factory.Create()); } } }
public void TestFileStreamFactoryReturnsFileStream() { using(TempFile tempFile = new TempFile()) { FileStreamFactory factory = new FileStreamFactory(tempFile.TempPath, FileMode.Create, FileAccess.ReadWrite, FileShare.None, 1024, FileOptions.Asynchronous); Assert.AreEqual(tempFile.TempPath, factory.FileName); using (FileStream s = (FileStream)factory.Create()) Assert.IsTrue(s.CanRead && s.CanWrite && s.IsAsync); } }
/// <summary> Opens the file named 'fname' for writing the bit stream, using the 'he' /// header encoder. The magic number is written to the bit /// stream. Normally, the header encoder must be empty (i.e. no data has /// been written to it yet). A BufferedOutputStream is used on top of the /// file to increase throughput, the length of the buffer is DEF_BUF_LEN. /// /// </summary> /// <param name="fname">The name of file where to write the bit stream /// /// </param> /// <param name="mb">The maximum number of bytes that can be written to the bit /// stream. /// /// </param> /// <param name="encSpec">The encoder's specifications /// /// </param> /// <exception cref="IOException">If an error occurs while trying to open the file /// for writing or while writing the magic number. /// /// </exception> public FileCodestreamWriter(System.String fname, int mb) : base(mb) { //UPGRADE_TODO: Constructor 'java.io.FileOutputStream.FileOutputStream' was converted to 'System.IO.FileStream.FileStream' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javaioFileOutputStreamFileOutputStream_javalangString'" out_Renamed = FileStreamFactory.New(fname, "rw"); initSOP_EPHArrays(); }
/// <summary> /// Called to send a specific length of bytes to a server identified by serverKey. The transfer /// is a blocking call and returns on success or raises an exception. If Abort() is called durring /// the transfer, or if a ProgressChanged event handler raises the OperationCanceledException, the /// transfer is silently terminated and the method will return false. /// </summary> /// <param name="location">A string of up to 1024 bytes in length</param> /// <param name="filename">The name of the file to write to</param> /// <returns>True if the file was successfully received by the server</returns> public bool Download(string location, string filename) { FileStreamFactory file = new FileStreamFactory(filename, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite); using (TempFile temp = TempFile.Attach(filename)) using (StreamCache cache = new StreamCache(file, LimitThreads)) { temp.Length = 0; if (Download(location, cache)) { temp.Detatch(); return true; } } return false; }