/// <summary>
/// Sets the length of the stream.
/// </summary>
/// <param name="value">The new length in bytes.</param>
/// <remarks>
/// The stream will be truncated if the new length is less than
/// the current length. The stream will be extended if the new
/// length is greater than the current length. In this case,
/// the contents of the extended portion will be undefined.
/// </remarks>
public override void SetLength(long value)
{
int cb;
if (value < 0 || value > int.MaxValue)
{
throw new IOException(TooLongError);
}
cb = (int)value;
if (cb < length)
{
length = cb;
blocks.TruncateTo(length);
if (pos > length)
{
pos = length;
}
}
else if (cb > length)
{
length = cb;
blocks.ExtendTo(length);
}
}
public void TruncateTo()
{
BlockArray blocks;
blocks = new BlockArray();
blocks.TruncateTo(0);
Assert.Equal(0, blocks.Size);
Assert.Empty(blocks.GetBlocks());
blocks.ExtendTo(1);
blocks.TruncateTo(1);
Assert.Equal(blocks.BlockSize, blocks.Size);
Assert.Single(blocks.GetBlocks());
blocks.TruncateTo(1000000);
blocks.TruncateTo(1);
Assert.Equal(blocks.BlockSize, blocks.Size);
Assert.Single(blocks.GetBlocks());
blocks.TruncateTo(0);
Assert.Equal(0, blocks.Size);
Assert.Empty(blocks.GetBlocks());
blocks.ExtendTo(blocks.BlockSize * 4);
blocks.GetBlocks()[0].Buffer[0] = 0;
blocks.GetBlocks()[1].Buffer[0] = 1;
blocks.GetBlocks()[2].Buffer[0] = 2;
blocks.GetBlocks()[3].Buffer[0] = 3;
blocks.TruncateTo(blocks.BlockSize * 3);
Assert.Equal(blocks.BlockSize * 3, blocks.Size);
Assert.Equal(3, blocks.GetBlocks().Length);
Assert.Equal(0, blocks.GetBlocks()[0].Buffer[0]);
Assert.Equal(1, blocks.GetBlocks()[1].Buffer[0]);
Assert.Equal(2, blocks.GetBlocks()[2].Buffer[0]);
blocks.TruncateTo(blocks.BlockSize * 2 + 1);
Assert.Equal(blocks.BlockSize * 3, blocks.Size);
Assert.Equal(3, blocks.GetBlocks().Length);
Assert.Equal(0, blocks.GetBlocks()[0].Buffer[0]);
Assert.Equal(1, blocks.GetBlocks()[1].Buffer[0]);
Assert.Equal(2, blocks.GetBlocks()[2].Buffer[0]);
blocks.TruncateTo(blocks.BlockSize);
Assert.Equal(blocks.BlockSize, blocks.Size);
Assert.Single(blocks.GetBlocks());
Assert.Equal(0, blocks.GetBlocks()[0].Buffer[0]);
}
public void Reload()
{
BlockArray ba;
Block b;
byte v;
ba = new BlockArray(0, 10, 5);
ba.ExtendTo(10);
Assert.Equal(10, ba.Size);
v = ba[5];
b = ba.GetBlock(0);
b.Offset = 0;
b.Length = b.Buffer.Length;
for (int i = 0; i < b.Length; i++)
{
b.Buffer[i] = (byte)i;
}
b = ba.GetBlock(1);
b.Offset = 0;
b.Length = b.Buffer.Length;
for (int i = 0; i < b.Length; i++)
{
b.Buffer[i] = (byte)(i + 100);
}
ba.Reload();
Assert.Equal(20, ba.Size);
Assert.Equal(5, ba[5]);
}
public void ExtendTo()
{
BlockArray blocks;
blocks = new BlockArray();
blocks.ExtendTo(1);
Assert.Equal(blocks.BlockSize, blocks.Size);
Assert.Single(blocks.GetBlocks());
blocks.ExtendTo(blocks.BlockSize / 2);
Assert.Equal(blocks.BlockSize, blocks.Size);
Assert.Single(blocks.GetBlocks());
Assert.Equal(blocks.BlockSize, blocks.GetBlocks()[0].Length);
blocks.ExtendTo(blocks.BlockSize + 1);
Assert.Equal(blocks.BlockSize * 2, blocks.Size);
Assert.Equal(2, blocks.GetBlocks().Length);
Assert.Equal(blocks.BlockSize, blocks.GetBlocks()[0].Length);
Assert.Equal(blocks.BlockSize, blocks.GetBlocks()[1].Length);
}
public void BlockOffset()
{
BlockArray ba;
ba = new BlockArray(0, 10, 5);
ba.ExtendTo(10);
Assert.Equal(10, ba.Size);
Assert.Equal(10, ba.GetBlock(0).Buffer.Length);
Assert.Equal(5, ba.GetBlock(0).Length);
Assert.Equal(5, ba.GetBlock(0).Offset);
Assert.Equal(10, ba.GetBlock(1).Buffer.Length);
Assert.Equal(5, ba.GetBlock(1).Length);
Assert.Equal(5, ba.GetBlock(1).Offset);
}
public void SetExactSize()
{
BlockArray blocks;
blocks = new BlockArray();
blocks.SetExactSize(0);
Assert.Equal(0, blocks.Size);
Assert.Equal(0, blocks.Count);
blocks.SetExactSize(1);
Assert.Equal(1, blocks.Size);
Assert.Equal(1, blocks.Count);
Assert.Equal(1, blocks.GetBlock(0).Length);
blocks.SetExactSize(blocks.BlockSize);
Assert.Equal(blocks.BlockSize, blocks.Size);
Assert.Equal(2, blocks.Count);
Assert.Equal(1, blocks.GetBlock(0).Length);
Assert.Equal(blocks.BlockSize - 1, blocks.GetBlock(1).Length);
blocks.SetExactSize(blocks.BlockSize + 1);
Assert.Equal(blocks.BlockSize + 1, blocks.Size);
Assert.Equal(3, blocks.Count);
Assert.Equal(1, blocks.GetBlock(0).Length);
Assert.Equal(blocks.BlockSize - 1, blocks.GetBlock(1).Length);
Assert.Equal(1, blocks.GetBlock(2).Length);
blocks = new BlockArray();
blocks.ExtendTo(blocks.BlockSize * 3);
blocks.SetExactSize(blocks.Size - blocks.BlockSize / 2);
Assert.Equal(3, blocks.Count);
Assert.Equal(blocks.BlockSize, blocks.GetBlock(0).Length);
Assert.Equal(blocks.BlockSize, blocks.GetBlock(1).Length);
Assert.Equal(blocks.BlockSize - blocks.BlockSize / 2, blocks.GetBlock(2).Length);
blocks.SetExactSize(blocks.BlockSize * 2);
Assert.Equal(2, blocks.Count);
Assert.Equal(blocks.BlockSize, blocks.GetBlock(0).Length);
Assert.Equal(blocks.BlockSize, blocks.GetBlock(1).Length);
blocks.SetExactSize(blocks.BlockSize + 1);
Assert.Equal(2, blocks.Count);
Assert.Equal(blocks.BlockSize, blocks.GetBlock(0).Length);
Assert.Equal(1, blocks.GetBlock(1).Length);
}
public void Construction()
{
BlockArray blocks;
blocks = new BlockArray();
Assert.Equal(0, blocks.Size);
blocks.ExtendTo(1);
Assert.Equal(blocks.BlockSize, blocks.Size);
blocks = new BlockArray(1);
Assert.Equal(blocks.BlockSize, blocks.Size);
blocks = new BlockArray(1, 10);
Assert.Equal(10, blocks.Size);
blocks = new BlockArray(10, 10);
Assert.Equal(10, blocks.Size);
blocks = new BlockArray(new Block(10), new Block(10), new Block(10));
Assert.Equal(30, blocks.Size);
}