internal BlockInfo MemoryRequest(int len)
{
int c = len / 1500;
if (len % 1500 > 0)
{
c++;
}
BlockInfo block = new BlockInfo();
for (int i = 0; i < Buffer.Count; i++)
{
var t = Buffer[i];
if (t.RemainBlock >= c)
{
if (t.RegNew(ref block, len))
{
return(block);
}
}
}
BlockBuffer <byte> tmp = new BlockBuffer <byte>(1500, 8192);
tmp.RegNew(ref block, len);
Buffer.Add(tmp);
return(block);
}
public override void Read(BlockBuffer bb)
{
bb.ReadByte();
TimeStamp = bb.ReadLong();
Continuations = bb.ReadByte();
Name = bb.ReadString();
}
/// <summary>
/// コンストラクタです。
/// </summary>
public Md5()
{
LengthBytes = 0;
Buffer = new BlockBuffer(_BlockSize);
State = new uint[4];
_InitState.CopyTo(State, 0);
}
/// <summary>
/// Converts a RIFF WAVE bitstream with header to raw samples.
/// </summary>
public RIFFWaveDecoder(BinaryReader reader)
{
// RIFF header
if (reader.ReadInt32() != RIFFWave.syncWord1)
{
throw new SyncException();
}
stream = reader.BaseStream;
stream.Position += 4; // File length
// Format header
if (reader.ReadInt64() != RIFFWave.syncWord2)
{
throw new SyncException();
}
stream.Position += 4; // Format header length
short sampleFormat = reader.ReadInt16(); // 1 = int, 3 = float, -2 = WAVE EX
channelCount = reader.ReadInt16();
sampleRate = reader.ReadInt32();
stream.Position += 4; // Bytes/sec
stream.Position += 2; // Block size in bytes
short bitDepth = reader.ReadInt16();
if (sampleFormat == -2)
{
// Extension size (22) - 2 bytes, valid bits per sample - 2 bytes, channel mask - 4 bytes
stream.Position += 8;
sampleFormat = reader.ReadInt16();
stream.Position += 15; // Skip the rest of the sub format GUID
}
if (sampleFormat == 1)
{
Bits = bitDepth switch {
8 => BitDepth.Int8,
16 => BitDepth.Int16,
24 => BitDepth.Int24,
_ => throw new IOException($"Unsupported bit depth for signed little endian integer: {bitDepth}.")
};
}
else if (sampleFormat == 3 && bitDepth == 32)
{
Bits = BitDepth.Float32;
}
else
{
throw new IOException($"Unsupported bit depth ({bitDepth}) for sample format {sampleFormat}.");
}
// Data header
int header = 0;
do
{
header = (header << 8) | reader.ReadByte();
}while (header != RIFFWave.syncWord3BE && stream.Position < stream.Length);
length = reader.ReadUInt32() * 8L / (long)Bits / ChannelCount;
dataStart = stream.Position;
this.reader = BlockBuffer <byte> .Create(reader, FormatConsts.blockSize);
}
/// <summary>
/// Converts a RIFF WAVE bitstream to raw samples.
/// </summary>
public RIFFWaveDecoder(BlockBuffer <byte> reader, int channelCount, long length, int sampleRate, BitDepth bits) :
base(reader)
{
this.channelCount = channelCount;
this.length = length;
this.sampleRate = sampleRate;
Bits = bits;
}
public void WriteSmall()
{
var buffer = new BlockBuffer <byte>();
var bytes = new byte[100];
buffer.Write(bytes);
Assert.AreEqual(buffer.WritePosition, 100);
Assert.AreEqual(buffer.ReadPosition, 0);
}
public void WriteHuge()
{
byte[] bytes = new byte[2000];
var buffer = new BlockBuffer <byte>();
buffer.Write(bytes);
Assert.AreEqual(buffer.WritePosition, bytes.Length);
Assert.AreEqual(buffer.ReadPosition, 0);
Assert.IsTrue(buffer.Size >= bytes.Length);
}
public void Initialize(Constant _c, IAudioClipStreamingBuffer streamingbuf)
{
Stop();
c = _c;
audioClipData = new float[c.audioClipChannelSampleSize * 2];
dspTimes = new double[c.audioClipBlockCount];
angleAtTime = new int[c.audioClipBlockCount];
audioClipStreamingBuffer = streamingbuf;
blockBuffer = new BlockBuffer(c);
}
/// <summary>Advances to the following block.
public void Next()
{
BlockIndex++;
if (Buffer != null && BlockIndex == MeshDataBufferPool.BlockCount)
{
// Advance a buffer:
Buffer = Buffer.Next;
BlockIndex = 0;
}
}
public void Index()
{
var buffer = new BlockBuffer <byte>(100);
var bytes = new byte[100];
buffer.Write(bytes);
buffer.Read(50);
buffer.ResetIndex();
Assert.AreEqual(buffer.WritePosition, 50);
Assert.AreEqual(buffer.ReadPosition, 0);
}
public void Read()
{
var buffer = new BlockBuffer <byte>();
var buffer2 = new BlockBuffer <int>();
var bytes = new byte[100];
buffer.Write(bytes);
buffer.Read(50);
Assert.AreEqual(buffer.WritePosition, 100);
Assert.AreEqual(buffer.ReadPosition, 50);
}
/// <summary>Let the mesh know it's about to undergo a layout routine.
/// <see cref="PowerUI.Renderman.Layout"/>.</summary>
public void PrepareForLayout()
{
// Release the buffers back to the pool:
MeshDataBufferPool.Return(FirstBuffer, LastBuffer);
// Clear values:
FirstBuffer = null;
LastBuffer = null;
FullBufferCount = 0;
CurrentBufferBlocks = 0;
BlockCount = 0;
}
public override void Read(BlockBuffer bb)
{
bb.Offset = 0x0194;
TimeStamp = bb.ReadLong();
DataSizeInBlocks = bb.ReadLong();
SizeOfIndexInBytes = bb.ReadLong();
bb.Offset = 0x01AF;
VersionNumber = bb.ReadByte();
TotalBlocks = bb.ReadLong();
TotalReservedBlocks = bb.ReadLong();
BlockSize = bb.ReadByte();
Checksum = bb.ReadByte();
}
protected override void Pack(BlockBuffer <byte> bytes, Action <byte[]> onPacked)
{
//Use int as header
int length = bytes.WritePosition;
var header = BitConverter.GetBytes(length);
var newBytes = new BlockBuffer <byte>(length + header.Length);
//Write header and body to buffer
newBytes.Write(header);
newBytes.Write(bytes.Buffer);
//Notice pack funished
onPacked(newBytes.Buffer);
}
public override void Write(BlockBuffer bb)
{
bb.Offset = 0x0194;
bb.WriteLong(TimeStamp);
bb.WriteLong(DataSizeInBlocks);
bb.WriteLong(SizeOfIndexInBytes);
bb.WriteByte((byte)'S');
bb.WriteByte((byte)'F');
bb.WriteByte((byte)'S');
bb.WriteByte(VersionNumber);
bb.WriteLong(TotalBlocks);
bb.WriteLong(TotalReservedBlocks);
bb.WriteByte(BlockSize);
bb.WriteByte(Checksum);
}
/// <summary>Let the mesh know that UV3 is required.</summary>
public void RequireUV3()
{
if (UV3 != null)
{
return;
}
UV3 = new FixedSizeBuffer <Vector2>(4, false);
BlockBuffer buff = FirstBuffer;
while (buff != null)
{
buff.RequireUV3();
buff = buff.Next;
}
}
/// <summary>Let the mesh know that normals are required.</summary>
public void RequireNormals()
{
if (Normals != null)
{
return;
}
Normals = new FixedSizeBuffer <Vector3>(4, false);
BlockBuffer buff = FirstBuffer;
while (buff != null)
{
buff.RequireNormals();
buff = buff.Next;
}
}
protected override void Unpack(BlockBuffer <byte> bytes, Action <byte[]> onUnpacked)
{
//Because header is int and cost 4 byte
while (bytes.WritePosition > 4)
{
int length = BitConverter.ToInt32(bytes.Buffer, 0);
//If receive body
if (bytes.WritePosition >= 4 + length)
{
bytes.MoveReadPostion(4);
var data = bytes.Read(length);
//Notice unpack finished
onUnpacked(data);
bytes.ResetIndex();
}
}
}
public override void Write(BlockBuffer bb)
{
bb.WriteByte(EntryType);
bb.WriteLong(TimeStamp);
const int rem = 46;
if (Name.Length > rem)
{
Continuations = (byte)(((Name.Length - rem) / 64) + 1);
bb.WriteByte(Continuations);
bb.WriteString(Name.Remove(rem));
}
else
{
bb.WriteByte(Continuations);
bb.WriteString(Name);
}
}
/// <summary>Gets the next vertex buffer.</summary>
public void NextBuffer()
{
// Get it:
BlockBuffer buffer = MeshDataBufferPool.GetBuffer();
buffer.Mesh = this;
if (Normals != null)
{
buffer.RequireNormals();
}
if (UV3 != null)
{
buffer.RequireUV3();
}
// Clear count:
CurrentBufferBlocks = 0;
if (FirstBuffer == null)
{
// Only one:
buffer.Previous = null;
buffer.Offset = 0;
buffer.BlocksBefore = 0;
FirstBuffer = LastBuffer = buffer;
}
else
{
// Filled one:
FullBufferCount++;
buffer.Offset = FullBufferCount * MeshDataBufferPool.VertexBufferSize;
buffer.BlocksBefore = FullBufferCount * MeshDataBufferPool.BlockCount;
// Add to end:
buffer.Previous = LastBuffer;
LastBuffer.Next = buffer;
LastBuffer = buffer;
}
}
public void TestBufferReaderWriter()
{
var writer = new BlockBufferWriter();
int loop = 10000;
var data = generateCheckData();
Assert.IsNotNull(data);
for (int i = 0; i < loop; i++)
{
var index = Rand.Default.RandInt(data.Count);
writeData(writer, index, data[index]);
}
var reader = new BlockBufferReader(writer.Block, writer.Position);
var count = readData(reader, data);
Assert.AreEqual(count, loop);
// check read block
var block = writer.Block;
var size = writer.Position;
writer = new BlockBufferWriter();
writer.WriteBlock(block, size);
var blockWrite = writer.ToBlock();
reader = new BlockBufferReader(blockWrite);
Assert.AreEqual(reader.Limit, size);
var checkBlock = new BlockBuffer();
Assert.AreEqual(reader.ReadBlock(checkBlock), size);
Assert.IsTrue(reader.IsEnd);
var array = block.ToArray();
var arrayCheck = checkBlock.ToArray();
for (int i = 0; i < size; i++)
{
Assert.AreEqual(array[i], arrayCheck[i]);
}
}
public override void Write(BlockBuffer bb)
{
bb.WriteByte(EntryType);
}
protected void Erosion(EditHelper editSession, int brushSize, int erodeFaces, int erodeRec, int fillFaces, int fillRec, Level level, BlockCoordinates targetBlock)
{
double brushSizeSquared = brushSize * brushSize;
int tx = targetBlock.X;
int ty = targetBlock.Y;
int tz = targetBlock.Z;
BlockBuffer buffer1 = new BlockBuffer();
BlockBuffer buffer2 = new BlockBuffer();
for (int x = -brushSize - 1; x <= brushSize + 1; x++)
{
int x0 = x + tx;
for (int y = -brushSize - 1; y <= brushSize + 1; y++)
{
int y0 = y + ty;
for (int z = -brushSize - 1; z <= brushSize + 1; z++)
{
int z0 = z + tz;
var block = level.GetBlock(new BlockCoordinates(x0, y0, z0));
buffer1[new BlockCoordinates(x, y, z)] = block;
buffer2[new BlockCoordinates(x, y, z)] = block;
}
}
}
int swap = 0;
for (int i = 0; i < erodeRec; ++i)
{
ErosionIteration(brushSize, erodeFaces, swap % 2 == 0 ? buffer1 : buffer2, swap % 2 == 1 ? buffer1 : buffer2);
swap++;
}
for (int i = 0; i < fillRec; ++i)
{
FillIteration(brushSize, fillFaces, swap % 2 == 0 ? buffer1 : buffer2, swap % 2 == 1 ? buffer1 : buffer2);
swap++;
}
BlockBuffer finalBuffer = swap % 2 == 0 ? buffer1 : buffer2;
// apply the buffer to the world
for (int x = -brushSize; x <= brushSize; x++)
{
int x0 = x + tx;
for (int y = -brushSize; y <= brushSize; y++)
{
int y0 = y + ty;
for (int z = -brushSize; z <= brushSize; z++)
{
int z0 = z + tz;
var coord = new BlockCoordinates(x, y, z);
if (x * x + y * y + z * z <= brushSizeSquared && finalBuffer.ContainsKey(coord))
{
var block = finalBuffer[coord];
block.Coordinates = new BlockCoordinates(x0, y0, z0);
Block old = level.GetBlock(block.Coordinates);
if (block.Id == old.Id && block.Metadata == old.Metadata)
{
continue;
}
editSession.SetBlock(block);
}
}
}
}
}
public override void Read(BlockBuffer bb)
{
}
private void FillIteration(int inbrushSize, int fillFaces, BlockBuffer current, BlockBuffer target)
{
double brushSizeSquared = inbrushSize * inbrushSize;
int brushSize = inbrushSize + 1;
Dictionary <int, int> frequency = new Dictionary <int, int>();
for (int x = -brushSize; x <= brushSize; x++)
{
for (int y = -brushSize; y <= brushSize; y++)
{
for (int z = -brushSize; z <= brushSize; z++)
{
BlockCoordinates coord = new BlockCoordinates(x, y, z);
target[coord] = current[coord];
if (x * x + y * y + z * z >= brushSizeSquared)
{
continue;
}
Block state = current[coord];
if (state.IsSolid)
{
continue;
}
int total = 0;
int highest = 1;
Block highestState = state;
frequency.Clear();
foreach (var offs in FACES_TO_CHECK)
{
Block next = current[coord + offs];
if (!next.IsSolid)
{
continue;
}
total++;
int count;
if (!frequency.ContainsKey(next.Id))
{
count = 1;
}
else
{
count = frequency[next.Id];
count++;
}
if (count >= highest)
{
highest = count;
highestState = next;
}
frequency[next.Id] = count;
}
if (total >= fillFaces)
{
target[coord] = highestState;
}
}
}
}
}
public void TestBufferBlock()
{
var data = new byte[checkCount];
for (int i = 0; i < data.Length; i++)
{
data[i] = Rand.Default.RandByte();
}
var block = new BlockBuffer();
int offset = 0;
Assert.IsTrue(block.IsEmpty);
while (offset < data.Length)
{
int size = Rand.Default.RandInt(data.Length - offset + 1);
if (size > 0)
{
var unit = new ByteBufferNode(data, offset, size);
offset += size;
block.Add(unit);
}
}
Assert.IsFalse(block.IsEmpty);
Assert.AreEqual(block.Count, checkCount);
var array = block.ToArray();
Assert.IsNotNull(array);
Assert.AreEqual(array.Length, checkCount);
for (int i = 0; i < checkCount; i++)
{
Assert.AreEqual(data[i], array[i]);
}
for (int i = 0; i < checkCount; i++)
{
block[i] = 0;
}
for (int i = 0; i < checkCount; i++)
{
Assert.AreEqual(0, block[i]);
}
for (int i = 0; i < checkCount; i++)
{
block[i] = data[i];
}
for (int i = 0; i < checkCount; i++)
{
Assert.AreEqual(data[i], block[i]);
}
var tempBlock = block;
block = (BlockBuffer)tempBlock.Clone();
int checkOffset = 10;
block.AdvanceOffset(checkOffset);
Assert.AreEqual(block.Count, checkCount - checkOffset);
array = block.ToArray();
Assert.IsNotNull(array);
Assert.AreEqual(array.Length, checkCount - checkOffset);
for (int i = 0; i < checkCount - checkOffset; i++)
{
Assert.AreEqual(data[i + checkOffset], array[i]);
}
block = (BlockBuffer)tempBlock.Clone();
block.AdvanceSize(checkOffset);
Assert.AreEqual(block.Count, checkCount - checkOffset);
array = block.ToArray();
Assert.IsNotNull(array);
Assert.AreEqual(array.Length, checkCount - checkOffset);
for (int i = 0; i < checkCount - checkOffset; i++)
{
Assert.AreEqual(data[i], array[i]);
}
block = (BlockBuffer)tempBlock.Clone();
block.Resize(checkCount - checkOffset);
Assert.AreEqual(block.Count, checkCount - checkOffset);
array = block.ToArray();
Assert.IsNotNull(array);
Assert.AreEqual(array.Length, checkCount - checkOffset);
for (int i = 0; i < checkCount - checkOffset; i++)
{
Assert.AreEqual(data[i], array[i]);
}
block = tempBlock;
for (int i = 0; i < checkCount; i++)
{
int index = Rand.Default.Range(1, checkCount - 1);
int length = Rand.Default.Range(1, checkCount - index);
var value = block.ToArray(index, length);
Assert.IsNotNull(value);
Assert.AreEqual(value.Length, length);
for (int j = 0; j < length; j++)
{
Assert.AreEqual(data[j + index], value[j]);
}
}
block = (BlockBuffer)block.Clone();
Assert.AreEqual(block.Count, checkCount);
array = block.ToArray();
Assert.IsNotNull(array);
Assert.AreEqual(array.Length, checkCount);
for (int i = 0; i < checkCount; i++)
{
Assert.AreEqual(data[i], array[i]);
}
}
/// <summary> /// Converts a bitstream to raw samples. /// </summary> public Decoder(BlockBuffer <byte> reader) => this.reader = reader;
public void TestBufferStream()
{
var bufferPool = new BufferPoolSimple();
var buff = new BlockBufferStream();
int loops = 1024;
int length = 0;
// read write byte[]
for (int i = 0; i < loops; i++)
{
int result = buff.WriteBuffer(BitConverter.GetBytes(i));
Assert.AreEqual(4, result);
length += result;
}
Assert.AreEqual(length, buff.Size);
int pos1 = length / 2;
// Seek
Assert.AreEqual(buff.SeekSet(0), 0);
Assert.AreEqual(buff.SeekSet(pos1), pos1);
Assert.AreEqual(buff.SeekSet(length), length);
Assert.AreEqual(buff.SeekSet(length + pos1), length);
Assert.AreEqual(buff.SeekEnd(0), length);
Assert.AreEqual(buff.SeekEnd(pos1), length - pos1);
Assert.AreEqual(buff.SeekEnd(length), 0);
Assert.AreEqual(buff.SeekEnd(length + pos1), 0);
Assert.AreEqual(buff.SeekCur(0), 0);
Assert.AreEqual(buff.SeekCur(pos1), pos1);
Assert.AreEqual(buff.SeekCur(length + pos1), length);
Assert.AreEqual(buff.SeekCur(-pos1), length - pos1);
Assert.AreEqual(buff.SeekCur(-length), 0);
byte[] data = new byte[4];
// Read
for (int i = 0; i < loops; i++)
{
int result = buff.ReadBuffer(data, 0, 4);
Assert.AreEqual(4, result);
Assert.AreEqual(BitConverter.ToInt32(data, 0), i);
length += result;
}
// read write BufferUnit
loops = 10;
for (int l = 0; l < loops; l++)
{
var arr = new List <int>();
buff.Clear();
int size = checkCount;
size = Rand.Default.RandInt(size);
for (int i = 0; i < size; i++)
{
Assert.AreEqual(4, buff.WriteBuffer(BitConverter.GetBytes(i)));
arr.Add(i);
}
int push_loops = checkCount;
for (int i = 0; i < push_loops; i++)
{
var buffer = bufferPool.TakeBuffer(Rand.Default.RandInt(512) + checkCount);
int push_size = buffer.Count / 4;
push_size = Rand.Default.RandInt(push_size);
if (push_size == 0)
{
continue;
}
int end = 0;
for (int j = 0; j < push_size; j++)
{
int num = j + size;
Buffer.BlockCopy(BitConverter.GetBytes(num), 0, buffer.Array, buffer.Offset + end, 4);
end += 4;
arr.Add(num);
}
var unit = new ByteBuffer(buffer.Array, buffer.Offset, end);
Assert.AreEqual(push_size * 4, buff.WriteBuffer(unit));
bufferPool.Return(buffer);
size += push_size;
}
buff.SeekSet(0);
byte[] value = new byte[4];
foreach (var it in arr)
{
Assert.AreEqual(buff.ReadBuffer(value, 0, 4), 4);
Assert.AreEqual(BitConverter.ToInt32(value, 0), it);
}
}
// read write BufferBlock
loops = 10;
for (int l = 0; l < loops; l++)
{
buff.Clear();
var arr = new List <int>();
int size = checkCount;
size = Rand.Default.RandInt(size);
for (int i = 0; i < size; i++)
{
Assert.AreEqual(4, buff.WriteBuffer(BitConverter.GetBytes(i)));
arr.Add(i);
}
int push_loops = checkCount;
for (int i = 0; i < push_loops; i++)
{
int push_size = checkCount;
push_size = Rand.Default.RandInt(push_size);
var block = new BlockBuffer();
var pushBuffer = new BlockBufferStream(block);
for (int j = 0; j < push_size; j++)
{
int num = j + size;
Assert.AreEqual(4, pushBuffer.WriteBuffer(BitConverter.GetBytes(num)));
arr.Add(num);
}
block = new BlockBuffer();
pushBuffer.SeekSet(0);
Assert.AreEqual(pushBuffer.Size, pushBuffer.ReadBlock(block));
Assert.AreEqual(push_size * 4, buff.WriteBlock(block, push_size * 4));
size += push_size;
}
buff.SeekSet(0);
byte[] value = new byte[4];
foreach (var it in arr)
{
Assert.AreEqual(buff.ReadBuffer(value, 0, 4), 4);
Assert.AreEqual(BitConverter.ToInt32(value, 0), it);
}
}
}
private void ErosionIteration(int inbrushSize, int erodeFaces, BlockBuffer current, BlockBuffer target)
{
double brushSizeSquared = inbrushSize * inbrushSize;
int brushSize = inbrushSize + 1;
Dictionary <byte, int> frequency = new Dictionary <byte, int>();
for (int x = -brushSize; x <= brushSize; x++)
{
for (int y = -brushSize; y <= brushSize; y++)
{
for (int z = -brushSize; z <= brushSize; z++)
{
BlockCoordinates coord = new BlockCoordinates(x, y, z);
target[coord] = (Block)current[coord];
if (x * x + y * y + z * z >= brushSizeSquared)
{
continue;
}
Block state = current[coord];
if (state is Air)
{
continue;
}
int total = 0;
int highest = 1;
byte highestState = state.Id;
frequency.Clear();
foreach (var offs in FACES_TO_CHECK)
{
Block next = current[coord + offs];
if (!(next is Air))
{
continue;
}
total++;
int count;
if (!frequency.ContainsKey(next.Id))
{
count = 1;
}
else
{
count = frequency[next.Id];
count++;
}
if (count > highest)
{
highest = count;
highestState = next.Id;
}
frequency[next.Id] = count;
}
if (total > erodeFaces)
{
target[coord] = BlockFactory.GetBlockById(highestState);
}
}
}
}
}
public void TestByteBuffer()
{
checkBufferEmpty(ByteBuffer.Empty);
var buffer = new ByteBuffer();
checkBufferEmpty(buffer);
buffer = new ByteBuffer(checkCount);
checkBufferNotEmpty(ref buffer, null, 0, checkCount);
var tempBuffer = buffer;
var array = new byte[checkCount];
buffer = new ByteBuffer(array);
checkBufferNotEmpty(ref buffer, array, 0, checkCount);
Assert.IsTrue(buffer != tempBuffer);
tempBuffer = buffer;
buffer = new ByteBuffer(array, 1, 3);
checkBufferNotEmpty(ref buffer, array, 1, 3);
Assert.IsTrue(buffer != tempBuffer);
buffer = new ByteBuffer(new ArraySegment <byte>(array));
checkBufferNotEmpty(ref buffer, array, 0, checkCount);
Assert.IsTrue(buffer == tempBuffer);
buffer = new ByteBuffer(new ByteBufferNode(array));
checkBufferNotEmpty(ref buffer, array, 0, checkCount);
Assert.IsTrue(buffer == tempBuffer);
buffer = new ByteBuffer(new ByteBuffer(array));
checkBufferNotEmpty(ref buffer, array, 0, checkCount);
Assert.IsTrue(buffer == tempBuffer);
buffer = new ByteBuffer(array);
buffer = new ByteBuffer(ref buffer, 1);
checkBufferNotEmpty(ref buffer, array, 1, checkCount - 1);
Assert.IsTrue(buffer != tempBuffer);
buffer = new ByteBuffer(checkCount);
checkBufferNotEmpty(ref buffer, null, 0, checkCount);
for (int i = 0; i < checkCount; i++)
{
buffer[i] = (byte)i;
}
for (int i = 0; i < checkCount; i++)
{
Assert.AreEqual(buffer[i], (byte)i);
}
int advanceOffset = 10;
tempBuffer = ByteBuffer.AdvanceOffset(ref buffer, advanceOffset);
checkBufferNotEmpty(ref tempBuffer, null, advanceOffset, checkCount - advanceOffset);
Assert.IsTrue(tempBuffer.CheckPtr(0, ref buffer, advanceOffset));
tempBuffer = ByteBuffer.AdvanceSize(ref buffer, advanceOffset);
checkBufferNotEmpty(ref tempBuffer, null, 0, checkCount - advanceOffset);
Assert.IsTrue(tempBuffer.CheckPtr(ref buffer));
tempBuffer = ByteBuffer.Resize(ref buffer, checkCount - advanceOffset);
checkBufferNotEmpty(ref tempBuffer, null, 0, checkCount - advanceOffset);
Assert.IsTrue(tempBuffer.CheckPtr(ref buffer));
tempBuffer = buffer;
tempBuffer.AdvanceOffset(advanceOffset);
checkBufferNotEmpty(ref tempBuffer, null, advanceOffset, checkCount - advanceOffset);
Assert.IsTrue(tempBuffer.CheckPtr(0, ref buffer, advanceOffset));
tempBuffer = buffer;
tempBuffer.AdvanceSize(advanceOffset);
checkBufferNotEmpty(ref tempBuffer, null, 0, checkCount - advanceOffset);
Assert.IsTrue(tempBuffer.CheckPtr(ref buffer));
tempBuffer = buffer;
tempBuffer.Resize(checkCount - advanceOffset);
checkBufferNotEmpty(ref tempBuffer, null, 0, checkCount - advanceOffset);
Assert.IsTrue(tempBuffer.CheckPtr(ref buffer));
tempBuffer = buffer;
buffer = new ByteBuffer(checkCount);
Assert.IsFalse(buffer.CheckPtr(ref tempBuffer));
tempBuffer.CopyTo(ref buffer);
for (int i = 0; i < checkCount; i++)
{
Assert.AreEqual(buffer[i], (byte)i);
}
tempBuffer.CopyTo(10, ref buffer, 20, 30);
Assert.AreEqual(buffer[20 - 1], 20 - 1);
for (int i = 0; i < 30; i++)
{
Assert.AreEqual(buffer[20 + i], (byte)(10 + i));
}
Assert.AreEqual(buffer[20 + 30], 20 + 30);
buffer = new ByteBuffer(checkCount);
for (int i = 0; i < checkCount; i++)
{
buffer.WriteByte(i, (byte)i);
}
for (int i = 0; i < checkCount; i++)
{
Assert.AreEqual(buffer.ReadByte(i), (byte)i);
}
var blockBuffer = new BlockBuffer();
blockBuffer.Add(buffer);
tempBuffer = blockBuffer.ToBuffer();
checkBufferNotEmpty(ref tempBuffer, null, 0, buffer.Count);
Assert.IsTrue(tempBuffer.CheckPtr(ref buffer));
for (int i = 0; i < checkCount; i++)
{
Assert.AreEqual(tempBuffer.ReadByte(i), (byte)i);
}
buffer = new ByteBuffer(checkCount);
long startValue = Byte.MaxValue * 2;
int count = checkCount / 2;
for (int i = 0; i < count; i++)
{
buffer.WriteUint16(i * 2, (ushort)(startValue + i));
}
for (int i = 0; i < count; i++)
{
Assert.AreEqual(buffer.ReadUint16(i * 2), (ushort)(startValue + i));
}
buffer = new ByteBuffer(checkCount);
startValue = ushort.MaxValue * 2;
count = checkCount / 4;
for (int i = 0; i < count; i++)
{
buffer.WriteUint32(i * 4, (uint)(startValue + i));
}
for (int i = 0; i < count; i++)
{
Assert.AreEqual(buffer.ReadUint32(i * 4), (uint)(startValue + i));
}
buffer = new ByteBuffer(checkCount);
startValue = (long)uint.MaxValue * 2;
count = checkCount / 8;
for (int i = 0; i < count; i++)
{
buffer.WriteUint64(i * 8, (uint)(startValue + i));
}
for (int i = 0; i < count; i++)
{
Assert.AreEqual(buffer.ReadUint64(i * 8), (uint)(startValue + i));
}
tempBuffer = buffer;
buffer = new ByteBuffer(checkCount);
for (int i = 0; i < count; i++)
{
buffer.WriteBuffer(i * 8, ref tempBuffer, i * 8, 8);
}
for (int i = 0; i < count; i++)
{
Assert.AreEqual(buffer.ReadUint64(i * 8), (uint)(startValue + i));
}
tempBuffer = buffer;
buffer = new ByteBuffer(checkCount);
for (int i = 0; i < count; i++)
{
tempBuffer.ReadBuffer(i * 8, ref buffer, i * 8, 8);
}
for (int i = 0; i < count; i++)
{
Assert.AreEqual(buffer.ReadUint64(i * 8), (uint)(startValue + i));
}
string checkString = "";
for (int i = 0; i < checkCount / 2; i++)
{
checkString += i.ToString();
}
int stringSize = Encoding.UTF8.GetByteCount(checkString);
Assert.IsTrue(stringSize > 0 && stringSize < checkCount);
int index = Rand.Default.RandInt(checkCount - stringSize);
buffer = new ByteBuffer(checkCount);
buffer.WriteString(index, checkString);
int readOffset;
var value = buffer.ReadString(index, out readOffset);
Assert.AreEqual(value, checkString);
Assert.Less(stringSize, readOffset);
buffer = new ByteBuffer(checkCount);
count = checkCount / 4;
float[] checkFloatSet = new float[count];
for (int i = 0; i < count; i++)
{
checkFloatSet[i] = Rand.Default.RandFloat();
}
for (int i = 0; i < count; i++)
{
buffer.WriteFloat(i * 4, checkFloatSet[i]);
}
for (int i = 0; i < count; i++)
{
Assert.AreEqual(buffer.ReadFloat(i * 4), checkFloatSet[i]);
}
buffer = new ByteBuffer(checkCount);
count = checkCount / 8;
double[] checkDoubleSet = new double[count];
for (int i = 0; i < count; i++)
{
checkDoubleSet[i] = Rand.Default.RandFloat();
}
for (int i = 0; i < count; i++)
{
buffer.WriteDouble(i * 8, checkDoubleSet[i]);
}
for (int i = 0; i < count; i++)
{
Assert.AreEqual(buffer.ReadDouble(i * 8), checkDoubleSet[i]);
}
buffer = new ByteBuffer(checkCount);
count = checkCount / 5;
uint[] checkUintSet = new uint[count];
for (int i = 0; i < count; i++)
{
checkUintSet[i] = Rand.Default.RandUint();
}
int offset = 0;
for (int i = 0; i < count; i++)
{
offset += buffer.WriteVarint32(offset, checkUintSet[i]);
}
offset = 0;
for (int i = 0; i < count; i++)
{
int size;
Assert.AreEqual(buffer.ReadVarint32(offset, out size), checkUintSet[i]);
offset += size;
}
count = checkCount / 9;
long[] checkLongSet = new long[count];
for (int i = 0; i < count; i++)
{
checkLongSet[i] = Rand.Default.RandLong();
}
offset = 0;
for (int i = 0; i < count; i++)
{
offset += buffer.WriteVarint64(offset, (ulong)checkLongSet[i]);
}
offset = 0;
for (int i = 0; i < count; i++)
{
int size;
Assert.AreEqual(buffer.ReadVarint32(offset, out size), (uint)checkLongSet[i]);
offset += size;
}
offset = 0;
for (int i = 0; i < count; i++)
{
int size;
Assert.AreEqual(buffer.ReadVarint64(offset, out size), checkLongSet[i]);
offset += size;
}
}
