public void TryChangingPositionCombinedWithWritingAndReading()
{
DataStreamReadableWritable dataStream = TestCollaboratorsFactory.CreateEmptyDataStream();
byte[] bytes = ByteBufferFactory.CreateByteBufferWithAllBytesSet(123, 123);
dataStream.Write(bytes, 0, bytes.Length);
dataStream.SetPosition(0);
byte[] bytes2 = ByteBufferFactory.CreateByteBufferWithAllBytesSet(14, 77);
dataStream.Write(bytes2, 0, bytes2.Length);
var bytesRead = new byte[dataStream.Length];
dataStream.SetPosition(0);
dataStream.Read(bytesRead, 0, dataStream.Length);
for (int i = 0; i < dataStream.Length; i++)
{
if (i <= 13)
{
Assert.AreEqual(77, bytesRead[i]);
}
else
{
Assert.AreEqual(123, bytesRead[i]);
}
}
}
public void MakeSureMovingAFolderInvalidatesAllEnumeratorsUnderIt()
{
Stream stream;
VirtualFileSystem fileSystem = TestCollaboratorsFactory.CreateFileSystem(out stream);
var folderA = fileSystem.CreateFolder(@"\A");
var folderB = fileSystem.CreateFolder(@"\A\B");
var folderC = fileSystem.CreateFolder(@"\A\B\C");
var folderBUnderRoot = fileSystem.CreateFolder(@"\B");
var enumeratorA = fileSystem.EnumerateFilesUnderFolder(folderA.FullPath, "*");
var enumeratorB = fileSystem.EnumerateFilesUnderFolder(folderB.FullPath, "*");
var enumeratorC = fileSystem.EnumerateFilesUnderFolder(folderC.FullPath, "*");
fileSystem.MoveFolder(folderA.FullPath, folderBUnderRoot.FullPath);
ExceptionAssert.MakeSureExceptionIsRaisedBy <InvalidOperationException>(
delegate
{
enumeratorA.MoveNext();
});
ExceptionAssert.MakeSureExceptionIsRaisedBy <InvalidOperationException>(
delegate
{
enumeratorB.MoveNext();
});
ExceptionAssert.MakeSureExceptionIsRaisedBy <InvalidOperationException>(
delegate
{
enumeratorC.MoveNext();
});
}
public void MakeSureYouCannotMoveAFolderWhileItOrItsSubfoldersIsLocked()
{
Stream stream;
VirtualFileSystem fileSystem = TestCollaboratorsFactory.CreateFileSystem(out stream);
fileSystem.CreateFolder(@"\Books");
var literacyFolder = fileSystem.CreateFolder(@"\Books\Literacy");
var tolstoysFolder = fileSystem.CreateFolder(@"\books\literacy\tolstoj");
var warAndPeace = fileSystem.CreateFile(fileSystem.PathBuilder.CombinePaths(tolstoysFolder.FullPath, "WarAndPeace.txt"));
using (var dataStream = fileSystem.OpenFileForReading(warAndPeace.FullPath))
{
ExceptionAssert.MakeSureExceptionIsRaisedBy <FolderLockedException>(
delegate
{
fileSystem.MoveFolder(literacyFolder.FullPath, VirtualFileSystem.Root);
fileSystem.MoveFolder(tolstoysFolder.FullPath, VirtualFileSystem.Root);
});
}
using (var dataStream = fileSystem.OpenFileForWriting(warAndPeace.FullPath))
{
ExceptionAssert.MakeSureExceptionIsRaisedBy <FolderLockedException>(
delegate
{
fileSystem.MoveFolder(literacyFolder.FullPath, VirtualFileSystem.Root);
fileSystem.MoveFolder(tolstoysFolder.FullPath, VirtualFileSystem.Root);
});
}
fileSystem.MoveFolder(literacyFolder.FullPath, VirtualFileSystem.Root);
}
public void MakeSureFileSystemDoesNotDieWhenAbsolutelyFull() // был такой баг
{
VirtualFileSystem fileSystem = TestCollaboratorsFactory.CreateAllCollaborators(15000, false).VirtualFileSystem;
using (var stream = fileSystem.CreateAndOpenFileForWriting(@"\huge"))
{
stream.SetLength((fileSystem.FreeSpaceInBytes / 8) * 7);
}
try
{
while (fileSystem.FreeSpaceInBytes != 0)
{
string fileName = Guid.NewGuid().ToString("N");
fileSystem.CreateFile(@"\" + fileName);
}
}
catch (Exception exception)
{
if (!(exception is InsufficientSpaceException)) // единственный приемлемый тип исключения в данном случае.
{
throw;
}
}
}
public void MakeSureDeletingAFileFreesSpaceForSure() // был такой баг.
{
var collaborators = TestCollaboratorsFactory.CreateAllCollaborators(50000, false);
VirtualFileSystem fileSystem = collaborators.VirtualFileSystem;
int freeSpaceBeforeAnything = fileSystem.FreeSpaceInBytes;
byte[] interestingData = ByteBufferFactory.BuildSomeGuidsIntoByteArray(10000);
using (var dataStream = fileSystem.CreateAndOpenFileForWriting(@"\hey"))
{
for (int i = 0; i < 50; i++)
{
dataStream.Write(interestingData, 0, interestingData.Length);
}
}
fileSystem.DeleteFile(@"\hey");
Assert.AreEqual(freeSpaceBeforeAnything, fileSystem.FreeSpaceInBytes);
fileSystem = TestCollaboratorsFactory.CreateFileSystemFromExistingStream(collaborators.Stream);
Assert.AreEqual(freeSpaceBeforeAnything, fileSystem.FreeSpaceInBytes);
}
public void TryClearingOutABunchOfFilesAndFolderAfterReloadingFileSystem()
{
Stream stream;
VirtualFileSystem fileSystem = TestCollaboratorsFactory.CreateFileSystem(out stream);
fileSystem.CreateFolder(@"\emails");
fileSystem.CreateFolder(@"\system128");
fileSystem.CreateFolder(@"\folder10dsjknfskdjfnkjsnfkjsnfkjskjfskjfsnkjkdjsfnsjkd");
fileSystem.CreateFile(@"\hello1");
fileSystem.CreateFile(@"\GoodWillHunting.dvd");
fileSystem.CreateFile(@"\Casablanca.flv");
fileSystem = TestCollaboratorsFactory.CreateFileSystemFromExistingStream(stream);
CollectionAssert.AreEquivalent(new[] { "emails", "system128", "folder10dsjknfskdjfnkjsnfkjsnfkjskjfskjfsnkjkdjsfnsjkd" }, fileSystem.GetNamesOfAllFoldersFrom(VirtualFileSystem.Root));
CollectionAssert.AreEquivalent(new[] { "hello1", "GoodWillHunting.dvd", "Casablanca.flv" }, fileSystem.GetNamesOfAllFilesFrom(VirtualFileSystem.Root));
fileSystem.DeleteFolder(@"\emails");
fileSystem.DeleteFile(@"\hello1");
fileSystem.DeleteFolder(@"\system128");
fileSystem.DeleteFolder(@"\folder10dsjknfskdjfnkjsnfkjsnfkjskjfskjfsnkjkdjsfnsjkd");
fileSystem.DeleteFile(@"\GoodWillHunting.dvd");
fileSystem.DeleteFile(@"\Casablanca.flv");
Assert.AreEqual(0, fileSystem.GetAllFoldersFrom(VirtualFileSystem.Root).Count);
Assert.AreEqual(0, fileSystem.GetAllFilesFrom(VirtualFileSystem.Root).Count);
}
public void MakeSureYouCannotMoveAFileWhileItIsLocked()
{
Stream stream;
VirtualFileSystem fileSystem = TestCollaboratorsFactory.CreateFileSystem(out stream);
var newFile = fileSystem.CreateFile(@"\WarAndPeace.txt");
var newFolder = fileSystem.CreateFolder(@"\Books");
using (var dataStream = fileSystem.OpenFileForReading(newFile.FullPath))
{
ExceptionAssert.MakeSureExceptionIsRaisedBy <FileLockedException>(
delegate
{
fileSystem.MoveFile(newFile.FullPath, newFolder.FullPath);
});
}
using (var dataStream = fileSystem.OpenFileForWriting(newFile.FullPath))
{
ExceptionAssert.MakeSureExceptionIsRaisedBy <FileLockedException>(
delegate
{
fileSystem.MoveFile(newFile.FullPath, newFolder.FullPath);
});
}
fileSystem.MoveFile(newFile.FullPath, newFolder.FullPath);
}
public void TryExpandingTheStreamViaSetLengthAndThenWritingReadingFromIt()
{
DataStreamReadableWritable dataStream = TestCollaboratorsFactory.CreateEmptyDataStream();
const int testArrayLength = 500000;
dataStream.SetLength(testArrayLength);
Assert.AreEqual(testArrayLength, dataStream.Length);
Assert.AreEqual(0, dataStream.Position);
const int halfTestArray = testArrayLength / 2; //на половине пути запишем что-нибудь интересное.
dataStream.SetPosition(halfTestArray);
var bytesToWrite = new byte[halfTestArray];
for (int i = 0; i < bytesToWrite.Length; i++)
{
bytesToWrite[i] = 231;
}
dataStream.Write(bytesToWrite, 0, bytesToWrite.Length);
dataStream.SetPosition(halfTestArray);
var bytesRead = new byte[bytesToWrite.Length];
dataStream.Read(bytesRead, 0, bytesRead.Length);
MakeSureEachByteInArrayIsRight(bytesRead, 231); // и проверим, что записалось что нужно, - новый объем как будто проработан.
}
public void MakeSureYouCanMoveFileToTheSameFolderItIsIn()
{
Stream stream;
VirtualFileSystem fileSystem = TestCollaboratorsFactory.CreateFileSystem(out stream);
var newFolder = fileSystem.CreateFolder(@"\Books");
var newFile = fileSystem.CreateFile(@"\Books\WarAndPeace.txt");
fileSystem.MoveFile(newFile.FullPath, newFolder.FullPath);
CollectionAssert.AreEqual(new[] { newFile.Name }, fileSystem.GetNamesOfAllFilesFrom(newFolder.FullPath));
}
public void MakeSureYouCanMoveFolderToTheSameFolderItIsIn()
{
Stream stream;
VirtualFileSystem fileSystem = TestCollaboratorsFactory.CreateFileSystem(out stream);
var newFolder = fileSystem.CreateFolder(@"\Books");
var movedFolder = fileSystem.MoveFolder(newFolder.FullPath, VirtualFileSystem.Root);
var namesOfFolders = fileSystem.GetNamesOfAllFoldersFrom(VirtualFileSystem.Root);
CollectionAssert.AreEqual(new[] { newFolder.Name }, namesOfFolders);
}
public void MakeSureYouCannotMoveANonExistingFolder()
{
Stream stream;
VirtualFileSystem fileSystem = TestCollaboratorsFactory.CreateFileSystem(out stream);
var newFolder = fileSystem.CreateFolder(@"\Folder");
ExceptionAssert.MakeSureExceptionIsRaisedBy <FolderNotFoundException>(
delegate
{
fileSystem.MoveFolder(@"\Guid.NewGuid()", newFolder.FullPath);
});
}
public void MakeSureYouCannotMoveFolderToANonExistingFolder()
{
Stream stream;
VirtualFileSystem fileSystem = TestCollaboratorsFactory.CreateFileSystem(out stream);
var newFolder = fileSystem.CreateFolder(@"\WarAndPeace.Editions");
ExceptionAssert.MakeSureExceptionIsRaisedBy <FolderNotFoundException>(
delegate
{
fileSystem.MoveFile(newFolder.FullPath, @"\BogusFolder");
});
}
public void MakeSureReadDoesNotThrowIfReadingBeyondTheStream()
{
DataStreamReadableWritable dataStream = TestCollaboratorsFactory.CreateEmptyDataStream();
byte[] bytes = ByteBufferFactory.CreateByteBufferWithAllBytesSet(55000, 123);
dataStream.Write(bytes, 0, bytes.Length);
dataStream.SetPosition(55000 - 35);
var largeArray = new byte[2000];
Assert.AreEqual(35, dataStream.Read(largeArray, 0, 2000));
}
public void MakeSureFileSystemChangesPersistAfterItHasBeenReloaded()
{
Stream stream;
VirtualFileSystem fileSystem = TestCollaboratorsFactory.CreateFileSystem(out stream);
Assert.AreEqual(0, fileSystem.GetAllFoldersFrom(VirtualFileSystem.Root).Count);
CreateFilesAndFolders(fileSystem);
fileSystem = TestCollaboratorsFactory.CreateFileSystemFromExistingStream(stream);
fileSystem.CreateFile(@"\newFile");
fileSystem.CreateFolder(@"\newFolder");
}
public void MakeSureYouCannotMoveAFolderWhenDestinationFolderAlreadyContainsDirectoryWithGivenName()
{
Stream stream;
VirtualFileSystem fileSystem = TestCollaboratorsFactory.CreateFileSystem(out stream);
var newFolder = fileSystem.CreateFolder(@"\Fitzgerald");
var newSubfolder = fileSystem.CreateFolder(@"\Books");
fileSystem.CreateFolder(@"\Books\Fitzgerald");
ExceptionAssert.MakeSureExceptionIsRaisedBy <FolderAlreadyExistsException>(
delegate
{
fileSystem.MoveFolder(newFolder.FullPath, newSubfolder.FullPath);
});
}
public void MakeSureMovingAFolderIsProhibitedIfYouAreMovingItDownItsOwnPathToRoot()
{
Stream stream;
VirtualFileSystem fileSystem = TestCollaboratorsFactory.CreateFileSystem(out stream);
var folderA = fileSystem.CreateFolder(@"\A");
fileSystem.CreateFolder(@"\A\B");
var folderC = fileSystem.CreateFolder(@"\A\B\C");
ExceptionAssert.MakeSureExceptionIsRaisedBy <InvalidOperationException>(
delegate
{
fileSystem.MoveFolder(folderA.FullPath, folderC.FullPath);
});
}
public void MakeSureYouCannotMoveAFileWhenDestinationFolderAlreadyContainsFileWithGivenName()
{
Stream stream;
VirtualFileSystem fileSystem = TestCollaboratorsFactory.CreateFileSystem(out stream);
var newFile = fileSystem.CreateFile(@"\WarAndPeace.txt");
var newFolder = fileSystem.CreateFolder(@"\Books");
fileSystem.CreateFile(fileSystem.PathBuilder.CombinePaths(newFolder.FullPath, newFile.Name));
ExceptionAssert.MakeSureExceptionIsRaisedBy <FileAlreadyExistsException>(
delegate
{
fileSystem.MoveFile(newFile.FullPath, newFolder.FullPath);
});
}
public void TryPushingAFileToItsLimitSize()
{
var testCollaborators = TestCollaboratorsFactory.CreateCollaboratorsForTestingDataStreamsOneGigabyteDrive();
DataStreamReadableWritable stream =
testCollaborators.VirtualFileSystem.OpenFileForWriting(testCollaborators.FileInfo.FullPath);
var zeroes = new byte[testCollaborators.Disk.BlockSizeInBytes * 1000];
ExceptionAssert.MakeSureExceptionIsRaisedBy <MaximumFileSizeReachedException>(
delegate
{
while (stream.Length != Int32.MaxValue)
{
stream.Write(zeroes, 0, zeroes.Length);
}
});
}
public void TryCreatingAndThenRemovingABunchOfFilesCheckingFreeSpace()
{
Stream stream;
VirtualFileSystem fileSystem = TestCollaboratorsFactory.CreateFileSystem(out stream);
int freeSpaceBeforeAnything = fileSystem.FreeSpaceInBytes;
int numberOfItemsToCreate = 50;
var files = new List <string>();
var folders = new List <string>();
for (int i = 0; i < numberOfItemsToCreate; i++)
{
var fileName = Guid.NewGuid().ToString("N");
files.Add(fileSystem.CreateFile(fileSystem.PathBuilder.CombinePaths(VirtualFileSystem.Root, fileName)).FullPath);
}
for (int i = 0; i < numberOfItemsToCreate; i++)
{
var folderName = Guid.NewGuid().ToString("N");
folders.Add(fileSystem.CreateFolder(fileSystem.PathBuilder.CombinePaths(VirtualFileSystem.Root, folderName)).FullPath);
}
int freeSpaceAsLastReported = fileSystem.FreeSpaceInBytes;
fileSystem = TestCollaboratorsFactory.CreateFileSystemFromExistingStream(stream);
Assert.AreEqual(freeSpaceAsLastReported, fileSystem.FreeSpaceInBytes);
foreach (string filePath in files)
{
fileSystem.DeleteFile(filePath);
}
foreach (string folderPath in folders)
{
fileSystem.DeleteFolder(folderPath);
}
Assert.AreEqual(freeSpaceBeforeAnything, fileSystem.FreeSpaceInBytes);
}
public void MakeSureShrinkingFreesDiskSpace()
{
var testCollaborators = TestCollaboratorsFactory.CreateCollaboratorsForTestingDataStreams();
DataStreamReadableWritable dataStream =
testCollaborators.VirtualFileSystem.OpenFileForWriting(testCollaborators.FileInfo.FullPath);
int valueCloseToDiskSize = (int)testCollaborators.Disk.DiskSizeInBytes - 25 * testCollaborators.Disk.BlockSizeInBytes;
dataStream.SetLength(valueCloseToDiskSize);
var fileSystem = testCollaborators.VirtualFileSystem;
FileInfo newFileNode = fileSystem.CreateFile(@"\testFile2");
DataStreamReadableWritable newFileNodeStream = fileSystem.OpenFileForWriting(newFileNode.FullPath);
ExceptionAssert.MakeSureExceptionIsRaisedBy <InsufficientSpaceException>(
delegate
{
newFileNodeStream.SetLength(valueCloseToDiskSize);
});
dataStream.SetLength(0);
newFileNodeStream.SetLength(valueCloseToDiskSize);
dataStream.SetPosition(0);
const int answeringToAllQuestionsByte = 42;
byte[] bytesToWrite = ByteBufferFactory.CreateByteBufferWithAllBytesSet(valueCloseToDiskSize, answeringToAllQuestionsByte);
newFileNodeStream.Write(bytesToWrite, 0, bytesToWrite.Length);
newFileNodeStream.SetPosition(0);
var buffer = new byte[valueCloseToDiskSize];
newFileNodeStream.Read(buffer, 0, buffer.Length);
MakeSureEachByteInArrayIsRight(buffer, answeringToAllQuestionsByte);
}
public void MakeSureMovingUnlistsFileFromOldParentAndEnlistsItInNewOne()
{
Stream stream;
VirtualFileSystem fileSystem = TestCollaboratorsFactory.CreateFileSystem(out stream);
var folderA = fileSystem.CreateFolder(@"\A");
fileSystem.CreateFolder(@"\A\B");
var folderC = fileSystem.CreateFolder(@"\A\B\C");
var fileA = fileSystem.CreateFile(fileSystem.PathBuilder.CombinePaths(folderA.FullPath, "AUnderA.txt"));
var fileB = fileSystem.CreateFile(fileSystem.PathBuilder.CombinePaths(folderA.FullPath, "BUnderA.txt"));
CollectionAssert.AreEquivalent(new[] { fileA.Name, fileB.Name }, fileSystem.GetNamesOfAllFilesFrom(folderA.FullPath));
fileSystem.MoveFile(fileA.FullPath, folderC.FullPath);
CollectionAssert.AreEquivalent(new[] { fileB.Name }, fileSystem.GetNamesOfAllFilesFrom(folderA.FullPath));
CollectionAssert.AreEquivalent(new[] { fileA.Name }, fileSystem.GetNamesOfAllFilesFrom(folderC.FullPath));
}
private void TryWritingAndReadingBackSpecifiedByteArrays(byte[] testArray)
{
DataStreamReadableWritable dataStream = TestCollaboratorsFactory.CreateEmptyDataStream();
Assert.AreEqual(0, dataStream.Position);
Assert.AreEqual(0, dataStream.Length);
dataStream.Write(testArray, 0, testArray.Length);
Assert.AreEqual(testArray.Length, dataStream.Position);
Assert.AreEqual(testArray.Length, dataStream.Length);
var bytesRead = new byte[testArray.Length];
Assert.AreEqual(0, dataStream.Read(bytesRead, 0, testArray.Length)); // позиция в DataStream = testArray.Length; Прочитать ничего не получится.
dataStream.SetPosition(0);
dataStream.Read(bytesRead, 0, testArray.Length);
CollectionAssert.AreEqual(testArray, bytesRead);
}
public void MakeSureWeirdBugWithFoldersAndFilesWithDuplicatedNamesIsGone()
{
Stream stream;
VirtualFileSystem fileSystem = TestCollaboratorsFactory.CreateFileSystem(out stream);
Assert.AreEqual(0, fileSystem.GetAllFoldersFrom(VirtualFileSystem.Root).Count);
fileSystem.CreateFile(@"\hip");
fileSystem.CreateFolder(@"\hop");
fileSystem.CreateFile(@"\chop");
fileSystem.CreateFolder(@"\chop");
fileSystem = TestCollaboratorsFactory.CreateFileSystemFromExistingStream(stream);
fileSystem.CreateFile(@"\chopper");
fileSystem.CreateFolder(@"\chopper");
CollectionAssert.AreEquivalent(new[] { "hip", "chop", "chopper" }, fileSystem.GetNamesOfAllFilesFrom(VirtualFileSystem.Root));
ReadOnlyCollection <FolderInfo> foldersUnderRoot = fileSystem.GetAllFoldersFrom(VirtualFileSystem.Root);
CollectionAssert.AreEquivalent(new[] { "hop", "chop", "chopper" }, foldersUnderRoot.Select(folder => folder.Name).ToList());
}
public void TryReadingAndWritingPortionsOfDataByteByByte()
{
DataStreamReadableWritable dataStream = TestCollaboratorsFactory.CreateEmptyDataStream();
var stream = new MemoryStream();
var binaryWriter = new BinaryWriter(stream);
const int numberOfIntegersToTest = 2561;
for (int i = 0; i < numberOfIntegersToTest; i++)
{
binaryWriter.Write(i);
}
byte[] bytes = stream.ToArray();
for (int i = 0; i < bytes.Length; i++)
{
dataStream.Write(new byte[] { bytes[i] }, 0, 1);
}
dataStream.SetPosition(0);
var bytesRead = new byte[dataStream.Length];
dataStream.Read(bytesRead, 0, dataStream.Length);
var readingStream = new MemoryStream(bytesRead, false);
var reader = new BinaryReader(readingStream);
for (int i = 0; i < numberOfIntegersToTest; i++)
{
int number = reader.ReadInt32();
Assert.AreEqual(i, number);
}
}
public void MakeSureMovingUnlistsFolderFromOldParentAndEnlistsItInNewOnePreservingChildren()
{
Stream stream;
VirtualFileSystem fileSystem = TestCollaboratorsFactory.CreateFileSystem(out stream);
var folderA = fileSystem.CreateFolder(@"\A");
var folderB = fileSystem.CreateFolder(@"\A\B");
var folderC = fileSystem.CreateFolder(@"\A\B\C");
var fileA = fileSystem.CreateFile(fileSystem.PathBuilder.CombinePaths(folderB.FullPath, "AUnderB.txt"));
var fileB = fileSystem.CreateFile(fileSystem.PathBuilder.CombinePaths(folderB.FullPath, "BUnderB.txt"));
var fileC = fileSystem.CreateFile(fileSystem.PathBuilder.CombinePaths(folderC.FullPath, "C1.txt"));
var fileD = fileSystem.CreateFile(fileSystem.PathBuilder.CombinePaths(folderC.FullPath, "C2.txt"));
var folderBMoved = fileSystem.MoveFolder(folderB.FullPath, VirtualFileSystem.Root);
Assert.AreEqual(@"\B", folderBMoved.FullPath);
CollectionAssert.AreEquivalent(new List <string>(), fileSystem.GetNamesOfAllFilesFrom(folderA.FullPath));
CollectionAssert.AreEquivalent(new List <string>(), fileSystem.GetNamesOfAllFoldersFrom(folderA.FullPath));
CollectionAssert.AreEquivalent(new[] { folderA.Name, folderB.Name }, fileSystem.GetNamesOfAllFoldersFrom(VirtualFileSystem.Root));
CollectionAssert.AreEquivalent(new[] { fileA.Name, fileB.Name }, fileSystem.GetNamesOfAllFilesFrom(folderBMoved.FullPath));
CollectionAssert.AreEquivalent(new[] { folderC.Name }, fileSystem.GetNamesOfAllFoldersFrom(folderBMoved.FullPath));
CollectionAssert.AreEquivalent(new[] { fileC.Name, fileD.Name }, fileSystem.GetNamesOfAllFilesFrom(@"\B\c"));
}
public void TryShrinkingTheStreamAndThenWritingReadingFromIt()
{
DataStreamReadableWritable dataStream = TestCollaboratorsFactory.CreateEmptyDataStream();
const int testArrayLength = 50000;
dataStream.SetLength(testArrayLength);
byte[] bytesToWrite = new byte[testArrayLength];
for (int i = 0; i < bytesToWrite.Length; i++)
{
bytesToWrite[i] = (byte)(i / 10000);
}
dataStream.Write(bytesToWrite, 0, bytesToWrite.Length);
ShrinkAndMakeSureDataIsIntact(dataStream, 40000);
ShrinkAndMakeSureDataIsIntact(dataStream, 34567);
ShrinkAndMakeSureDataIsIntact(dataStream, 25000);
ShrinkAndMakeSureDataIsIntact(dataStream, 9999);
ShrinkAndMakeSureDataIsIntact(dataStream, 24);
ShrinkAndMakeSureDataIsIntact(dataStream, 1);
}
public void TryWritingABigFileReadingItAfterSystemReload()
{
var testCollaborators = TestCollaboratorsFactory.CreateAllCollaborators(50000, false);
byte[] interestingBytes = ByteBufferFactory.BuildSomeGuidsIntoByteArray(5000);
int streamLength;
const int numberOfGuidPortionsToReadAndWrite = 500;
using (DataStreamReadableWritable stream = testCollaborators.VirtualFileSystem.CreateAndOpenFileForWriting(@"\hey"))
{
for (int i = 0; i < numberOfGuidPortionsToReadAndWrite; i++)
{
stream.Write(interestingBytes, 0, interestingBytes.Length);
}
streamLength = stream.Length;
}
VirtualFileSystem fileSystemReloaded =
TestCollaboratorsFactory.CreateFileSystemFromExistingStream(testCollaborators.Stream);
using (DataStreamReadable stream = fileSystemReloaded.OpenFileForReading(@"\hey"))
{
Assert.AreEqual(streamLength, stream.Length);
var bytesRead = new byte[interestingBytes.Length];
for (int i = 0; i < numberOfGuidPortionsToReadAndWrite; i++)
{
int numberOfBytesRead = stream.Read(bytesRead, 0, interestingBytes.Length);
CollectionAssert.AreEqual(interestingBytes, bytesRead);
}
}
}
public void MakeSureStructureBuilderAllocatesExactlyTheNumberOfBlocksNeededToStoreTheData()
{
var testCollaborators = TestCollaboratorsFactory.CreateCollaboratorsForTestingDataStreamStructureBuilder();
MockRepository mocks = new MockRepository();
IFreeBlockManager freeBlockManager = mocks.DynamicMock <IFreeBlockManager>();
IFileSystemNodeStorage nodeStorageStub = mocks.Stub <IFileSystemNodeStorage>();
int freeBlockCounter = 25;
int numberOfFreeBlocksAllocated = 0;
using (mocks.Unordered())
{
Expect.Call(freeBlockManager.AcquireFreeBlocks(1)).IgnoreArguments().Do(
new Func <int, ReadOnlyCollection <int> >(delegate(int i)
{
var blocks = new List <int>();
for (int j = 0; j < i; j++)
{
blocks.Add(freeBlockCounter);
freeBlockCounter++;
}
numberOfFreeBlocksAllocated += i;
return(blocks.AsReadOnly());
}));
Expect.Call(freeBlockManager.AcquireFreeBlock()).IgnoreArguments().Do(
new Func <int>(delegate
{
freeBlockCounter++;
numberOfFreeBlocksAllocated++;
return(freeBlockCounter);
}));
}
mocks.ReplayAll();
var dataStreamStructureBuilder =
new TestDataStreamStructureBuilder(
testCollaborators.FileNode.ResolvedNode.FileContentsStreamDefinition,
testCollaborators.Disk,
freeBlockManager,
nodeStorageStub,
testCollaborators.FileNode.ResolvedNode,
AddressingSystemParameters.Default);
Assert.AreEqual(0, dataStreamStructureBuilder.DoubleIndirectBlocks.Count);
dataStreamStructureBuilder.SetSize(1000);
Assert.AreEqual(1000, dataStreamStructureBuilder.CurrentSize);
var diskStructureEnumerator = dataStreamStructureBuilder.CreateEnumerator();
Assert.AreEqual(2, numberOfFreeBlocksAllocated); // один для данных, другой - под single indirect block
Assert.AreEqual(1, diskStructureEnumerator.Count); // количество дисковых блоков = 1
Assert.AreEqual(1, dataStreamStructureBuilder.DoubleIndirectBlocks.Count);
dataStreamStructureBuilder.SetSize(1500);
Assert.AreEqual(1500, dataStreamStructureBuilder.CurrentSize);
dataStreamStructureBuilder.SetSize(2000);
Assert.AreEqual(2000, dataStreamStructureBuilder.CurrentSize);
diskStructureEnumerator = dataStreamStructureBuilder.CreateEnumerator();
Assert.AreEqual(2, numberOfFreeBlocksAllocated);
Assert.AreEqual(1, diskStructureEnumerator.Count); // количество дисковых блоков = 1
Assert.AreEqual(1, dataStreamStructureBuilder.DoubleIndirectBlocks.Count);
dataStreamStructureBuilder.SetSize(2048);
Assert.AreEqual(2048, dataStreamStructureBuilder.CurrentSize);
diskStructureEnumerator = dataStreamStructureBuilder.CreateEnumerator();
Assert.AreEqual(2, numberOfFreeBlocksAllocated); // оверхед системы адресации - еще один блок.
Assert.AreEqual(1, diskStructureEnumerator.Count); // количество дисковых блоков = 2
Assert.AreEqual(1, dataStreamStructureBuilder.DoubleIndirectBlocks.Count);
dataStreamStructureBuilder.SetSize(testCollaborators.Disk.BlockSizeInBytes * (testCollaborators.Disk.BlockSizeInBytes / 4) * 3);
Assert.AreEqual((testCollaborators.Disk.BlockSizeInBytes / 4) * 3 + 3, numberOfFreeBlocksAllocated);
dataStreamStructureBuilder.SetSize(testCollaborators.Disk.BlockSizeInBytes * (testCollaborators.Disk.BlockSizeInBytes / 4) * 5);
}
