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; } }