public void MakeSureYouCannotPutNegativeNumbersInTheBlock()
{
byte[] bytes = new byte[4096];
const int numberOfIntegers = 10;
var block = new IntegerListConstrained(bytes, 2, numberOfIntegers + 1);
ExceptionAssert.MakeSureExceptionIsRaisedBy <ArgumentOutOfRangeException>(
delegate
{
block[0] = -1;
});
ExceptionAssert.MakeSureExceptionIsRaisedBy <ArgumentOutOfRangeException>(
delegate
{
block.AddInteger(-2);
});
MemoryStream stream = new MemoryStream(bytes, true);
BinaryWriter writer = new BinaryWriter(stream);
writer.Write((int)-56);
ExceptionAssert.MakeSureExceptionIsRaisedBy <ArgumentException>(
delegate
{
new IntegerListConstrained(bytes, 2, numberOfIntegers + 1);
});
}
/// <summary>
///
/// </summary>
/// <param name="numberOfBytesToAdd"></param>
/// <param name="numberOfBlocksCommitted"></param>
/// <param name="allBlocksAcquired"></param>
/// <param name="blocksToDistribute"></param>
/// <exception cref="NoFreeBlocksException"></exception>
private void PushFreeBlocksToAddressingSystem(int numberOfBytesToAdd, int numberOfBlocksCommitted, List <int> allBlocksAcquired, Stack <int> blocksToDistribute)
{
IntegerListConstrained lastSinglyIndirectBlock = null;
int lastSingleIndirectBlockSize = 0;
var addressingSystemBlockSizes =
base.AddressingBlockSizesCalculator.GetSizesOfAddressingBlocksSufficientToStoreItems(numberOfBlocksCommitted);
lastSingleIndirectBlockSize = addressingSystemBlockSizes.LastSingleIndirectBlockSize;
if (this.CurrentSize != 0)
{
var lastSingleIndirectBlockIndex = base.DoubleIndirectBlocks[base.DoubleIndirectBlocks.Count - 1];
lastSinglyIndirectBlock = new IntegerListConstrained(
base.Disk.ReadAllBytesFromBlock(lastSingleIndirectBlockIndex),
lastSingleIndirectBlockSize,
base.AddressingSystemParameters.DataBlockReferencesCountInSingleIndirectBlock);
}
try
{
while (blocksToDistribute.Count != 0)
{
if ((lastSinglyIndirectBlock != null) && (!lastSinglyIndirectBlock.IsFull))
{
lastSinglyIndirectBlock.AddInteger(blocksToDistribute.Pop());
}
else
{
if (lastSinglyIndirectBlock != null)
{
base.Disk.WriteBytesToBlock(base.DoubleIndirectBlocks[base.DoubleIndirectBlocks.Count - 1],
lastSinglyIndirectBlock.ToByteArray());
}
int newBlockIndex = _freeBlockManager.AcquireFreeBlock();
allBlocksAcquired.Add(newBlockIndex);
base.DoubleIndirectBlocks.AddInteger(newBlockIndex);
base.Disk.WriteBytesToBlock(base.DataStreamDefinition.ContentsBlockIndex, base.DoubleIndirectBlocks.ToByteArray());
lastSinglyIndirectBlock = new IntegerListConstrained(new byte[0], 0, base.AddressingSystemParameters.DataBlockReferencesCountInSingleIndirectBlock);
}
}
base.Disk.WriteBytesToBlock(base.DoubleIndirectBlocks[base.DoubleIndirectBlocks.Count - 1], lastSinglyIndirectBlock.ToByteArray());
base.DataStreamDefinition.StreamLengthInBytes += (numberOfBytesToAdd);
}
catch (NoFreeBlocksException)
{
_freeBlockManager.MarkBlocksAsFree(allBlocksAcquired);
throw;
}
}
public void MakeSureYouCannotAddressIntegeresOutsideOfInitializedSpace()
{
byte[] bytes = new byte[4096];
IntegerListConstrained integersList = new IntegerListConstrained(bytes, 0, 24);
ExceptionAssert.MakeSureExceptionIsRaisedBy <ArgumentOutOfRangeException>(
delegate()
{
integersList[1] = 25;
});
}
private void InitializeSingleIndirectionBlock(int indexOfBlockToCreateIndirectionBlockFrom, int currentCountOfIntegersInBlock, int currentPositionInBlock)
{
byte[] blockContents = _disk.ReadAllBytesFromBlock(indexOfBlockToCreateIndirectionBlockFrom);
_singlyIndirectBlockReferences = new IntegerListConstrained(blockContents, currentCountOfIntegersInBlock, _addressingSystemParameters.DataBlockReferencesCountInSingleIndirectBlock);
_singlyIndirectReferencesEnumerator = _singlyIndirectBlockReferences.GetAddressableEnumerator();
if (currentPositionInBlock != PositionBeforeFirstElement)
{
_singlyIndirectReferencesEnumerator.SetPosition(currentPositionInBlock);
}
}
public DataStreamStructureBuilderImmutable(IVirtualDisk disk, DataStreamDefinition dataStreamDefinition, AddressingSystemParameters addressingSystemParameters, IFileSystemNodeStorage fileSystemNodeStorage, Node governingNode)
{
if (disk == null)
{
throw new ArgumentNullException("disk");
}
if (dataStreamDefinition == null)
{
throw new ArgumentNullException("dataStreamDefinition");
}
if (addressingSystemParameters == null)
{
throw new ArgumentNullException("addressingSystemParameters");
}
if (fileSystemNodeStorage == null)
{
throw new ArgumentNullException("fileSystemNodeStorage");
}
if (governingNode == null)
{
throw new ArgumentNullException("governingNode");
}
_disk = disk;
_governingNode = governingNode;
_fileSystemNodeStorage = fileSystemNodeStorage;
_addressingSystemParameters = addressingSystemParameters;
_dataStreamDefinition = dataStreamDefinition;
int numberOfBlocks =
SpaceRequirementsCalculator.GetNumberOfChunksNeededToStoreData(
dataStreamDefinition.StreamLengthInBytes, addressingSystemParameters.BlockSize);
_addressingBlockSizesCalculator = new AddressingBlockSizesCalculator(addressingSystemParameters.IndirectBlockReferencesCountInDoubleIndirectBlock,
addressingSystemParameters.DataBlockReferencesCountInSingleIndirectBlock);
_sizesOfLastAddressingBlocks = AddressingBlockSizesCalculator.GetSizesOfAddressingBlocksSufficientToStoreItems(numberOfBlocks);
int doubleIndirectBlockSize = _sizesOfLastAddressingBlocks.DoubleIndirectBlockSize;
_doubleIndirectBlocks = new IntegerListConstrained(disk.ReadAllBytesFromBlock(dataStreamDefinition.ContentsBlockIndex), doubleIndirectBlockSize, _addressingSystemParameters.IndirectBlockReferencesCountInDoubleIndirectBlock);
CalculateAndSetMaximumSize(addressingSystemParameters);
}
public void MakeSureTheIntegeresAreBeingProperlyUpdatedAndSerialized()
{
byte[] bytes = new byte[4096];
const int numberOfIntegers = 10;
IntegerListConstrained integersList = new IntegerListConstrained(bytes, numberOfIntegers, numberOfIntegers);
for (int i = 0; i < numberOfIntegers; i++)
{
integersList[i] = i;
Assert.AreEqual(i, integersList[i]);
}
IntegerListConstrained recreatedBlock = new IntegerListConstrained(integersList.ToByteArray(), integersList.Count, integersList.Count);
for (int i = 0; i < numberOfIntegers; i++)
{
Assert.AreEqual(i, recreatedBlock[i]);
}
}
public void MakeSureYouCannotAddIntegersIfTheBlockIsFull()
{
byte[] bytes = new byte[4096];
const int numberOfIntegers = 10;
IntegerListConstrained integersList = new IntegerListConstrained(bytes, numberOfIntegers, numberOfIntegers + 1);
int initialCount = integersList.Count;
Assert.AreEqual(numberOfIntegers, initialCount);
integersList.AddInteger(1234);
int count = integersList.Count;
Assert.AreEqual(initialCount + 1, count);
ExceptionAssert.MakeSureExceptionIsRaisedBy <InvalidOperationException>(
delegate
{
integersList.AddInteger(44);
});
}
/// <summary>
///
/// </summary>
/// <param name="newLength"></param>
/// <exception cref="ArgumentException"></exception>
/// <exception cref="ArgumentOutOfRangeException"></exception>
/// <exception cref="InconsistentDataDetectedException"></exception>
/// <exception cref="ArgumentNullException"></exception>
private void MakeShorter(int newLength)
{
int numberOfBlocksCommitted =
SpaceRequirementsCalculator.GetNumberOfChunksNeededToStoreData(base.CurrentSize,
base.AddressingSystemParameters.BlockSize);
int numberOfBlocksNeededToStoreNewData =
SpaceRequirementsCalculator.GetNumberOfChunksNeededToStoreData(newLength,
base.AddressingSystemParameters.BlockSize);
int numberOfBlocksToRemove = numberOfBlocksCommitted - numberOfBlocksNeededToStoreNewData;
if (numberOfBlocksToRemove == 0) //изменения в пределах одного блока.
{
base.DataStreamDefinition.StreamLengthInBytes = newLength;
base.FileSystemNodeStorage.WriteNode(base.GoverningNode);
return;
}
var oldAddressingSystemBlockSizes =
base.AddressingBlockSizesCalculator.GetSizesOfAddressingBlocksSufficientToStoreItems(numberOfBlocksCommitted);
var newAddressingSystemBlockSizes =
base.AddressingBlockSizesCalculator.GetSizesOfAddressingBlocksSufficientToStoreItems(numberOfBlocksNeededToStoreNewData);
int doubleIndirectBlockIndexToStopAt = newAddressingSystemBlockSizes.DoubleIndirectBlockSize == 0
? 0
: newAddressingSystemBlockSizes.DoubleIndirectBlockSize;
for (int i = oldAddressingSystemBlockSizes.DoubleIndirectBlockSize - 1; i >= doubleIndirectBlockIndexToStopAt; i--)
{
int singlyIndirectBlockIndex = base.DoubleIndirectBlocks[i];
int newSize;
int currentSize;
if (i == oldAddressingSystemBlockSizes.DoubleIndirectBlockSize - 1)
{
currentSize = oldAddressingSystemBlockSizes.LastSingleIndirectBlockSize;
}
else
{
currentSize = base.AddressingSystemParameters.DataBlockReferencesCountInSingleIndirectBlock;
}
if (i == doubleIndirectBlockIndexToStopAt) // ок, этот - остается.
{
newSize = newAddressingSystemBlockSizes.LastSingleIndirectBlockSize;
}
else
{
newSize = 0;
}
var listConstrained =
new IntegerListConstrained(base.Disk.ReadAllBytesFromBlock(singlyIndirectBlockIndex), currentSize, base.AddressingSystemParameters.DataBlockReferencesCountInSingleIndirectBlock);
_freeBlockManager.MarkBlocksAsFree(listConstrained.Shrink(newSize));
}
_freeBlockManager.MarkBlocksAsFree(base.DoubleIndirectBlocks.Shrink(newAddressingSystemBlockSizes.DoubleIndirectBlockSize));
base.Disk.WriteBytesToBlock(base.DataStreamDefinition.ContentsBlockIndex, base.DoubleIndirectBlocks.ToByteArray());
base.DataStreamDefinition.StreamLengthInBytes = newLength;
base.FileSystemNodeStorage.WriteNode(base.GoverningNode);
}
