public byte[] GetBytes()
{
var eventTypeBytes = Encoding.UTF8.GetBytes(EventTypeCode);
byte[] actorIdBytes;
if (GrainId is long id)
{
actorIdBytes = BitConverter.GetBytes(id);
}
else if (GrainId is string strId)
{
actorIdBytes = Encoding.UTF8.GetBytes(strId);
}
else
{
throw new PrimaryKeyTypeException(EventTypeCode);
}
using var ms = new PooledMemoryStream();
ms.WriteByte((byte)TransportType.Event);
ms.Write(BitConverter.GetBytes((ushort)eventTypeBytes.Length));
ms.Write(BitConverter.GetBytes((ushort)actorIdBytes.Length));
ms.Write(BitConverter.GetBytes((ushort)BaseBytes.Length));
ms.Write(BitConverter.GetBytes(EventBytes.Length));
ms.Write(eventTypeBytes);
ms.Write(actorIdBytes);
ms.Write(BaseBytes);
ms.Write(EventBytes);
return(ms.ToArray());
}
private void StartListener()
{
var server = new AsyncNetworkStream(_listener.Accept());
HandshakeMessage handshake = server.ReceiveHandshake().Result;
server.SendHandshake(HubId.Generate());
using (var buffer = new PooledMemoryStream())
{
while (true)
{
buffer.Reset();
Receive(server, buffer, WireHeader.Size);
buffer.Position = 0;
WireHeader header = WireHeader.ReadFrom(buffer);
//Console.WriteLine($"Received {header.MessageHeader} ({header.PayloadSize.Value.ToString(CultureInfo.InvariantCulture)})");
Receive(server, buffer, header.PayloadSize.Value);
_serverReceived++;
if (_serverReceived == _count + 1)
{
_allMessagesReceived.Set();
}
}
}
}
public void Update(string key, TValue value)
{
using var s = PooledMemoryStream.New();
_serialize(value, s.MemoryStream);
_table.Update(key, s.MemoryStream.ToArray());
}
public static void PooledMemoryStream_Write_BeyondCapacity()
{
using (PooledMemoryStream memoryStream = new PooledMemoryStream())
{
long origLength = memoryStream.Length;
byte[] bytes = new byte[10];
for (int i = 0; i < bytes.Length; i++)
{
bytes[i] = (byte)i;
}
int spanPastEnd = 5;
memoryStream.Seek(spanPastEnd, SeekOrigin.End);
// Test Write
memoryStream.Write(bytes, 0, bytes.Length);
long pos = memoryStream.Position;
Assert.Equal(pos, origLength + spanPastEnd + bytes.Length);
Assert.Equal(memoryStream.Length, origLength + spanPastEnd + bytes.Length);
// Verify bytes were correct.
memoryStream.Position = origLength;
byte[] newData = new byte[bytes.Length + spanPastEnd];
int n = memoryStream.Read(newData, 0, newData.Length);
Assert.Equal(n, newData.Length);
for (int i = 0; i < spanPastEnd; i++)
{
Assert.Equal(0, newData[i]);
}
for (int i = 0; i < bytes.Length; i++)
{
Assert.Equal(bytes[i], newData[i + spanPastEnd]);
}
}
}
public void Data_Written_Can_Be_Read_Back()
{
var sizes = new int[] { 128 + 256 + 512 + 1024 + 1024 + 2, 200, 1000, 1024 * 1024, 4 };
var pool = new BufferManagerAllocator(1024, 1024 * 1024);
byte i = 1;
foreach (var size in sizes)
{
using (var stream = new PooledMemoryStream(pool))
{
var data = new byte[size];
for (var j = 0; j < data.Length; j++)
{
data[j] = i;
}
stream.Write(data, 0, data.Length);
stream.Position = 0;
Assert.Equal(0, stream.Position);
Assert.Equal(data.Length, stream.Length);
var copy = new byte[size];
stream.Read(copy, 0, copy.Length);
Assert.Equal(data, copy);
}
i++;
}
}
public void SimpleWriteAndRead()
{
var random = new Random(42);
var manager = new NonePooledMemoryStreamManager(new PooledMemoryStreamOptions()
{
MinimumSegmentSize = 16
});
var ms = new MemoryStream();
PooledMemoryStream stream = manager.GetStream();
var writeStream = new BroadcastWriteStream(ms, stream);
byte[] buffer = new byte[32];
random.NextBytes(buffer);
writeStream.Write(buffer, 0, 4);
writeStream.Write(buffer, 0, 8);
writeStream.Write(buffer, 0, 12);
writeStream.Write(buffer, 0, 16);
writeStream.Write(buffer, 0, 32);
writeStream.Write(buffer.AsSpan(0, 4));
writeStream.Write(buffer.AsSpan(0, 8));
writeStream.Write(buffer.AsSpan(0, 12));
writeStream.Write(buffer.AsSpan(0, 16));
writeStream.Write(buffer.AsSpan(0, 32));
AssertHelper.StreamEqual(ms, stream);
}
public bool Put(RavenJToken key, PooledMemoryStream value, Guid transactionId)
{
Guid existing;
if (keysModifiedInTx.TryGetValue(key, out existing) && existing != transactionId)
{
return(false);
}
operationsInTransactions.GetOrAdd(transactionId, new List <Command>())
.Add(new Command
{
Key = key,
Payload = value,
DictionaryId = TableId,
Type = CommandType.Put
});
if (existing != transactionId) // otherwise we are already there
{
keysModifiedInTx.TryAdd(key, transactionId);
}
return(true);
}
/// <summary>
/// 发送无状态更改的消息到消息队列
/// </summary>
/// <returns></returns>
protected async ValueTask Publish(IMessage msg, string hashKey = null)
{
if (string.IsNullOrEmpty(hashKey))
{
hashKey = GrainId.ToString();
}
using (var ms = new PooledMemoryStream())
{
Serializer.Serialize(ms, msg);
var data = new W
{
TypeCode = msg.GetType().FullName,
BinaryBytes = ms.ToArray()
};
ms.Position = 0;
ms.SetLength(0);
Serializer.Serialize(ms, data);
var mqServiceTask = GetMQService();
if (!mqServiceTask.IsCompleted)
{
await mqServiceTask;
}
var pubLishTask = mqServiceTask.Result.Publish(ms.ToArray(), hashKey);
if (!pubLishTask.IsCompleted)
{
await pubLishTask;
}
}
}
public void ExpandOnSingleSegment()
{
PooledMemoryStream stream = s_manager.GetStream();
byte[] buffer = new byte[4];
new Random(42).NextBytes(buffer);
stream.Write(buffer);
Assert.Equal(16, stream.Capacity);
Assert.Equal(4, stream.Length);
Assert.Equal(4, stream.Position);
stream.SetLength(8);
Assert.Equal(16, stream.Capacity);
Assert.Equal(8, stream.Length);
Assert.Equal(4, stream.Position);
stream.Seek(0, SeekOrigin.Begin);
byte[] buffer2 = new byte[8];
Assert.Equal(8, stream.Read(buffer2));
Assert.True(buffer2.AsSpan(0, 4).SequenceEqual(buffer.AsSpan(0, 4)));
Assert.True(buffer2.AsSpan(4, 4).SequenceEqual(s_emptyBytes.AsSpan(0, 4)));
}
private static (int bytesRead, byte[] actual) ReadSomeBytes(PooledMemoryStream stream, int length)
{
var actual = new byte[length];
int readBytes = stream.Read(actual, 0, actual.Length);
return(readBytes, actual);
}
public async Task SendHeader()
{
await semaphoreSlim.WaitAsync();
try
{
using (var ms = new PooledMemoryStream())
{
var nbw = new NetworkBinaryWriter(ms);
nbw.Write(Amqp);
byte one = (byte)1;
if (Endpoint.Protocol.Revision != 0)
{
nbw.Write((byte)0);
nbw.Write((byte)Endpoint.Protocol.MajorVersion);
nbw.Write((byte)Endpoint.Protocol.MinorVersion);
nbw.Write((byte)Endpoint.Protocol.Revision);
}
else
{
nbw.Write(one);
nbw.Write(one);
nbw.Write((byte)Endpoint.Protocol.MajorVersion);
nbw.Write((byte)Endpoint.Protocol.MinorVersion);
}
var bufferSegment = ms.ToUnsafeArraySegment();
await m_netStream.WriteAsync(bufferSegment.Array, bufferSegment.Offset, bufferSegment.Count);
}
}
finally
{
semaphoreSlim.Release();
}
}
public byte[] GetBytes()
{
using var ms = new PooledMemoryStream();
ms.Write(BitConverter.GetBytes(Version));
ms.Write(BitConverter.GetBytes(Timestamp));
return(ms.ToArray());
}
public override void OnMessageReceived(MessageReceivedEventArgs e)
{
var proudMessage = (ProudMessage)e.Message;
using (var ms = new PooledMemoryStream(Service.ArrayPool))
using (var r = ms.ToBinaryReader(true))
{
e.Message.Serialize(ms);
ms.Position = 0;
var opCode = r.ReadUInt16();
var leagueMessage = _messageFactory.GetMessage(e.Session, opCode, r);
leagueMessage.IsRelayed = proudMessage.IsRelayed;
leagueMessage.SenderHostId = proudMessage.SenderHostId;
leagueMessage.TargetHostId = proudMessage.TargetHostId;
if (!r.IsEOF())
#if DEBUG
{ throw new NetsphereBadFormatException(leagueMessage.GetType(), ms.ToSegment()); }
#else
{ throw new NetsphereBadFormatException(leagueMessage.GetType()); }
#endif
e.Message = leagueMessage;
base.OnMessageReceived(e);
}
}
public void Data_Written_Can_Be_Read_Back()
{
var sizes = new int[] { 128 + 256 + 512 + 1024 + 1024 + 2, 200, 1000, 1024 * 1024, 4 };
var pool = new BufferManagerAllocator(1024, 1024 * 1024);
byte i = 1;
foreach (var size in sizes)
{
using (var stream = new PooledMemoryStream(pool))
{
var data = new byte[size];
for (var j = 0; j < data.Length; j++) data[j] = i;
stream.Write(data, 0, data.Length);
stream.Position = 0;
Assert.Equal(0, stream.Position);
Assert.Equal(data.Length, stream.Length);
var copy = new byte[size];
stream.Read(copy, 0, copy.Length);
Assert.Equal(data, copy);
}
i++;
}
}
public override async Task OnActivateAsync()
{
await ReadSnapshotAsync();
while (true)
{
var eventList = await EventStorage.GetListAsync(this.GrainId, this.State.Version, this.State.Version + 1000, this.State.VersionTime);
foreach (var @event in eventList)
{
this.State.IncrementDoingVersion();//标记将要处理的Version
EventHandle.Apply(this.State, @event.Event);
if ([email protected])
{
using (var ms = new PooledMemoryStream())
{
Serializer.Serialize(ms, @event.Event);
await AfterEventSavedHandle(@event.Event, ms.ToArray());
}
}
this.State.UpdateVersion(@event.Event);//更新处理完成的Version
}
if (eventList.Count < 1000)
{
break;
}
}
;
}
public void StreamCanHoldLongData()
{
const long dataSize = 4000L * Constants.MB;
const int bufferPartitionSize = 512 * Constants.MB;
var originalStream = new PredictableStream();
var arrayPoolStream = PooledMemoryStream.BufferStreamPartitionInternal(originalStream, dataSize, dataSize, 0, _pool, bufferPartitionSize, false, default).EnsureCompleted();
originalStream.Position = 0;
// assert it holds the correct amount of data. other tests assert data validity and it's so expensive to do that here.
// test without blowing up memory
const int testSize = 256 * Constants.MB;
var pooledStreamBuffer = new byte[testSize];
long totalRead = 0;
int read;
do
{
// both these streams are backed in memory and will always read what is asked until the pooled stream hits the end
read = arrayPoolStream.Read(pooledStreamBuffer, 0, testSize);
totalRead += read;
} while (read != 0);
Assert.AreEqual(dataSize, totalRead);
}
public static void MemoryStream_LengthTest()
{
using (PooledMemoryStream ms2 = new PooledMemoryStream())
{
// [] Get the Length when position is at length
ms2.SetLength(50);
ms2.Position = 50;
StreamWriter sw2 = new StreamWriter(ms2);
for (char c = 'a'; c < 'f'; c++)
{
sw2.Write(c);
}
sw2.Flush();
Assert.Equal(55, ms2.Length);
// Somewhere in the middle (set the length to be shorter.)
ms2.SetLength(30);
Assert.Equal(30, ms2.Length);
Assert.Equal(30, ms2.Position);
// Increase the length
ms2.SetLength(100);
Assert.Equal(100, ms2.Length);
Assert.Equal(30, ms2.Position);
}
}
public void ShrinkFromTwoSegment()
{
PooledMemoryStream stream = s_manager.GetStream();
byte[] buffer = new byte[12];
new Random(42).NextBytes(buffer);
stream.Write(buffer);
stream.Write(buffer);
Assert.Equal(32, stream.Capacity);
Assert.Equal(24, stream.Length);
Assert.Equal(24, stream.Position);
stream.SetLength(12);
Assert.Equal(16, stream.Capacity);
Assert.Equal(12, stream.Length);
Assert.Equal(12, stream.Position);
stream.Seek(0, SeekOrigin.Begin);
byte[] buffer2 = new byte[12];
Assert.Equal(12, stream.Read(buffer2));
Assert.True(buffer2.AsSpan(0, 12).SequenceEqual(buffer.AsSpan(0, 12)));
}
public static void MemoryStream_CopyTo_Invalid()
{
PooledMemoryStream memoryStream;
using (memoryStream = new PooledMemoryStream())
{
AssertExtensions.Throws <ArgumentNullException>("destination", () => memoryStream.CopyTo(destination: null));
// Validate the destination parameter first.
AssertExtensions.Throws <ArgumentNullException>("destination", () => memoryStream.CopyTo(destination: null, bufferSize: 0));
AssertExtensions.Throws <ArgumentNullException>("destination", () => memoryStream.CopyTo(destination: null, bufferSize: -1));
// Then bufferSize.
AssertExtensions.Throws <ArgumentOutOfRangeException>("bufferSize", () => memoryStream.CopyTo(Stream.Null, bufferSize: 0)); // 0-length buffer doesn't make sense.
AssertExtensions.Throws <ArgumentOutOfRangeException>("bufferSize", () => memoryStream.CopyTo(Stream.Null, bufferSize: -1));
}
// After the Stream is disposed, we should fail on all CopyTos.
AssertExtensions.Throws <ArgumentOutOfRangeException>("bufferSize", () => memoryStream.CopyTo(Stream.Null, bufferSize: 0)); // Not before bufferSize is validated.
AssertExtensions.Throws <ArgumentOutOfRangeException>("bufferSize", () => memoryStream.CopyTo(Stream.Null, bufferSize: -1));
PooledMemoryStream disposedStream = memoryStream;
// We should throw first for the source being disposed...
Assert.Throws <ObjectDisposedException>(() => memoryStream.CopyTo(disposedStream, 1));
}
private PooledMemoryStream ReadDataNoCaching(Stream log, long pos, int size, RavenJToken key)
{
log.Position = pos;
var data = PooledMemoryStream.From(log, size);
if (data.Length != size)
{
throw new InvalidDataException("Could not read complete data, the file is probably corrupt when reading: " +
key.ToString(Formatting.None) + " on table " + Name);
}
var hash = data.ComputeHash();
var binaryReader = new BinaryReader(log);
var hashFromFile = binaryReader.ReadBytes(hash.Length);
if (hashFromFile.Length != hash.Length)
{
throw new InvalidDataException("Could not read complete SHA data, the file is probably corrupt when reading: " +
key.ToString(Formatting.None) + " on table " + Name);
}
if (hashFromFile.Where((t, i) => hash[i] != t).Any())
{
throw new InvalidDataException("Invalid SHA signature, the file is probably corrupt when reading: " +
key.ToString(Formatting.None) + " on table " + Name);
}
return(data);
}
public async ValueTask <MemoryStream> LoadFileToMemory(IFile file)
{
MemoryStream targetStream;
await using (var fileStream = file.OpenRead())
{
var length = (int)fileStream.Length;
var arrayPool = GetArrayPool();
var buffer = arrayPool.Rent(length);
try
{
await fileStream.ReadAsync(buffer, 0, length);
targetStream = new PooledMemoryStream(buffer, 0, length, arrayPool);
}
catch (Exception)
{
arrayPool.Return(buffer);
throw;
}
}
return(targetStream);
}
public void RandomStreamWriteAndReadTest(int seed, int maxChunkSize, int minTotalSize)
{
var random = new Random(seed);
var ms = new MemoryStream();
var stream = new PooledMemoryStream();
var writeStream = new BroadcastWriteStream(ms, stream);
int length = 0;
byte[] buffer = new byte[maxChunkSize];
bool useSpan = false;
while (length < minTotalSize)
{
int chunkSize = random.Next(1, maxChunkSize);
random.NextBytes(buffer);
if (useSpan)
{
writeStream.Write(buffer.AsSpan(0, chunkSize));
}
else
{
writeStream.Write(buffer, 0, chunkSize);
}
useSpan = !useSpan;
length += chunkSize;
}
AssertHelper.StreamEqual(ms, stream);
}
internal Task ProcessAndSendMessage(MessageEventArgs e, EncryptContext context)
{
var message = (ProudMessage)e.Message;
var data = message.ToArray();
CoreMessage coreMessage = new RmiMessage(data);
if (message.Compress)
{
data = coreMessage.ToArray();
coreMessage = new CompressedMessage(data.Length, data.CompressZLib());
}
if (message.Encrypt)
{
data = coreMessage.ToArray();
using (var w = new PooledMemoryStream(Service.ArrayPool).ToBinaryWriter(false))
{
w.Write(context.EncryptCounter);
w.Write(data);
data = w.ToArray();
}
data = context.Encrypt(data);
coreMessage = new EncryptedReliableMessage(data);
}
e.Message = coreMessage;
return(base.OnSendMessage(e));
}
public byte[] GetBytes()
{
if (allBytes == default)
{
var eventTypeBytes = Encoding.Default.GetBytes(EventType);
byte[] actorIdBytes;
if (ActorId is long id)
{
actorIdBytes = BitConverter.GetBytes(id);
}
else if (ActorId is string strId)
{
actorIdBytes = Encoding.Default.GetBytes(strId);
}
else
{
throw new PrimaryKeyTypeException(EventType);
}
using (var ms = new PooledMemoryStream())
{
ms.WriteByte((byte)TransportType.Event);
ms.Write(BitConverter.GetBytes((ushort)eventTypeBytes.Length));
ms.Write(BitConverter.GetBytes((ushort)actorIdBytes.Length));
ms.Write(BitConverter.GetBytes((ushort)BaseBytes.Length));
ms.Write(BitConverter.GetBytes(EventBytes.Length));
ms.Write(eventTypeBytes);
ms.Write(actorIdBytes);
ms.Write(BaseBytes);
ms.Write(EventBytes);
allBytes = ms.ToArray();
}
}
return(allBytes);
}
public async Task SaveAsync()
{
var fileInfo = this.directory.CreateFileInfoInDirectory("SaveAsyncTest.cfg");
using (var stream = PooledMemoryStream.Borrow())
{
using var writer = new StreamWriter(stream);
writer.Write("1 2");
writer.Flush();
stream.Position = 0;
await FileHelper.SaveAsync(fileInfo, stream).ConfigureAwait(false);
}
var text = File.ReadAllText(fileInfo.FullName);
Assert.AreEqual("1 2", text);
using (var stream = PooledMemoryStream.Borrow())
{
using var writer = new StreamWriter(stream);
writer.Write("3");
writer.Flush();
stream.Position = 0;
await FileHelper.SaveAsync(fileInfo, stream).ConfigureAwait(false);
}
text = File.ReadAllText(fileInfo.FullName);
Assert.AreEqual("3", text);
}
protected async ValueTask<bool> RaiseEvent(IEventBase<K> @event, string uniqueId = null, string hashKey = null)
{
try
{
this.State.IncrementDoingVersion();//标记将要处理的Version
@event.StateId = GrainId;
@event.Version = this.State.Version + 1;
@event.Timestamp = DateTime.UtcNow;
using (var ms = new PooledMemoryStream())
{
Serializer.Serialize(ms, @event);
var bytes = ms.ToArray();
var result = await EventStorage.SaveAsync(@event, bytes, uniqueId);
if (result)
{
EventHandle.Apply(this.State, @event);
await AfterEventSavedHandle(@event, bytes, hashKey: hashKey);
this.State.UpdateVersion(@event);//更新处理完成的Version
await SaveSnapshotAsync();
return true;
}
else
this.State.DecrementDoingVersion();//还原doing Version
}
}
catch (Exception ex)
{
this.GetLogger("Event_Raise").Log(LogCodes.EventRaiseError, Orleans.Runtime.Severity.Error, $"applay event {@event.TypeCode} error, eventId={@event.Version}", null, ex);
await OnActivateAsync();//重新激活Actor
throw ex;
}
return false;
}
public static void MemoryStream_LengthTest_Negative()
{
using (PooledMemoryStream ms2 = new PooledMemoryStream())
{
Assert.Throws <ArgumentOutOfRangeException>(() => ms2.SetLength(long.MaxValue));
Assert.Throws <ArgumentOutOfRangeException>(() => ms2.SetLength(-2));
}
}
/// <summary>
/// 发送消息到消息队列
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="data"></param>
/// <param name="exchange"></param>
/// <param name="queue"></param>
/// <returns></returns>
public void Publish <T>(T data, string exchange, string queue, bool persistent = true)
{
using (var ms = new PooledMemoryStream())
{
Serializer.Serialize(ms, data);
Publish(ms.ToArray(), exchange, queue, persistent);
}
}
public void PooledMemoryStream()
{
for (int i = 0; i < Iterations; i++)
{
using var stream = new PooledMemoryStream();
Process(stream);
}
}
public void Stream_Looks_OK()
{
var stream = new PooledMemoryStream(new BufferManagerAllocator(1024, 1024 * 1024));
Assert.True(stream.CanSeek);
Assert.True(stream.CanRead);
Assert.True(stream.CanWrite);
}
/// <summary>
/// Sets the given key and value in the current session. Value is serialized using given
/// custom serializer.
/// </summary>
/// <typeparam name="T">The type of the value.</typeparam>
/// <param name="session">The session.</param>
/// <param name="serializer">The custom serializer.</param>
/// <param name="key">The key.</param>
/// <param name="value">The value.</param>
public static void SetObject <T>(this ISession session, ISerializer serializer, string key, T value)
{
using (var serializedStream = new PooledMemoryStream())
{
BlobSerializer.Serialize(serializer, serializedStream, value);
session.Set(key, serializedStream.ToArray());
}
}
/// <summary>
/// Gets a readable <see cref="Stream"/> for the current instance, by detaching the used buffer
/// </summary>
/// <returns>A readable <see cref="Stream"/> with the contents of the current instance</returns>
public Stream DetachStream()
{
var stream = new PooledMemoryStream(this);
buffer = Array.Empty <byte>();
return(stream);
}
public void Read_Must_Indicate_End_Of_Stream()
{
var pool = new BufferManagerAllocator(1024, 1024 * 1024);
var stream = new PooledMemoryStream(pool);
var buffer = new byte[129];
Assert.Equal(-1, stream.Read(buffer, 0, buffer.Length));
stream.Write(buffer, 0, buffer.Length);
Assert.Equal(-1, stream.Read(buffer, 0, buffer.Length));
}
public void Write_Sets_Properties_Properly()
{
var sizes = new int[] { 128 + 256 + 512 + 1024 + 1024 + 2, 200, 1000, 1024 * 1024, 4 };
var pool = new BufferManagerAllocator(1024, 1024 * 1024);
foreach (var size in sizes)
{
using (var stream = new PooledMemoryStream(pool))
{
var data = new byte[size];
stream.Write(data, 0, data.Length);
Assert.Equal(data.Length, stream.Position);
Assert.Equal(data.Length, stream.Length);
}
}
}
public void Segmented_Data_Written_Can_Be_Read_Back_In_Segments()
{
var sizes = new int[] { 128 + 256 + 512 + 1024 + 1024 + 2, 200, 1000, 1024 * 1024 };
var pool = new BufferManagerAllocator(1024, 1024 * 1024);
const int STEP_WRITE = 37;
foreach (var size in sizes)
{
using (var stream = new PooledMemoryStream(pool))
{
var remaining = size;
var data = new byte[STEP_WRITE];
byte value = 1;
for (var i = 0; i < size - (size % STEP_WRITE); i += STEP_WRITE)
{
Fill(data, value);
stream.Write(data, 0, data.Length);
value++;
remaining -= STEP_WRITE;
}
if (remaining > 0)
{
Fill(data, value);
stream.Write(data, 0, remaining);
}
Assert.Equal(size, stream.Position);
Assert.Equal(size, stream.Length);
stream.Position = 0;
Assert.Equal(0, stream.Position);
var copy = new byte[STEP_WRITE];
value = 1;
for (var i = 0; i < size - (size % STEP_WRITE); i += STEP_WRITE)
{
Fill(data, value);
Fill(copy, (byte)(value - 1));
stream.Read(copy, 0, copy.Length);
value++;
remaining -= STEP_WRITE;
Assert.Equal(data, copy);
}
if (remaining > 0)
{
Fill(data, value);
stream.Write(data, 0, remaining);
Assert.Equal(data.Take(remaining), copy.Take(remaining));
}
}
}
}
private PooledSegment SerializeObject(object value)
{
using (var ms = new PooledMemoryStream(allocator))
{
new BinaryFormatter().Serialize(ms, value);
var retval = new PooledSegment(allocator, (int)ms.Length);
ms.Position = 0;
ms.Read(retval.Array, 0, retval.Count);
return retval;
}
}
public void Can_Rewrite_Stream()
{
var pool = new BufferManagerAllocator(1024, 1024 * 1024);
var stream = new PooledMemoryStream(pool);
var chunk = new byte[60];
for (var i = 0; i < 10; i++)
{
Fill(chunk, (byte)(i + 1));
stream.Write(chunk, 0, chunk.Length);
Assert.Equal((i + 1) * 60, stream.Position);
Assert.Equal((i + 1) * 60, stream.Length);
}
stream.Position = 120;
Fill(chunk, 200);
stream.Write(chunk, 0, chunk.Length);
stream.Position = 370;
Fill(chunk, 100);
stream.Write(chunk, 0, chunk.Length);
Assert.Equal(430, stream.Position);
Assert.Equal(600, stream.Length);
var all = new byte[stream.Length];
stream.Position = 0;
stream.Read(all, 0, all.Length);
Assert.Equal(600, stream.Position);
Assert.Equal(600, stream.Length);
var expected = new[]
{
Enumerable.Repeat(1, 60), // 0
Enumerable.Repeat(2, 60), // 60
Enumerable.Repeat(200, 60), // 120
Enumerable.Repeat(4, 60), // 180
Enumerable.Repeat(5, 60), // 240
Enumerable.Repeat(6, 60), // 300
Enumerable.Repeat(7, 10), // 360
Enumerable.Repeat(100, 60), // 370
Enumerable.Repeat(8, 50), // 430
Enumerable.Repeat(9, 60), // 480
Enumerable.Repeat(10, 60), // 540
};
var expectedValue = expected.SelectMany(_ => _.Select(v => (byte)v)).ToArray();
Assert.Equal(expectedValue.Length, all.Length);
Assert.Equal(stream.Length, all.Length);
AssertArray(expectedValue, all);
}
