public static void ToEnumerableEmpty()
{
Memory <int> memory = Memory <int> .Empty;
IEnumerable <int> copy = MemoryMarshal.ToEnumerable <int>(memory);
Assert.Equal(0, copy.Count());
}
public static void ToEnumerableDefault()
{
Memory <int> memory = default;
IEnumerable <int> copy = MemoryMarshal.ToEnumerable <int>(memory);
Assert.Equal(0, copy.Count());
}
public void can_create_stream_write_record_for_single_event()
{
var record = RecordCreator.CreateStreamWriteRecordForSingleEvent(
timeStamp: _dateTime1,
correlationId: _guid1,
logPosition: _long1,
transactionPosition: _long2,
transactionOffset: _int1,
streamNumber: _long3,
startingEventNumber: _long4,
eventId: _guid2,
eventType: _string1,
eventData: _bytes3.Span,
eventMetadata: _bytes4.Span,
eventFlags: _prepareflags);
Assert.Equal(LogRecordType.StreamWrite, record.Header.Type);
Assert.Equal(LogRecordVersion.LogRecordV0, record.Header.Version);
Assert.Equal(_dateTime1, record.Header.TimeStamp);
Assert.Equal(_long1, record.Header.LogPosition);
Assert.Equal <Guid>(_guid1, record.SystemMetadata.CorrelationId);
Assert.Equal(_long2, record.SystemMetadata.TransactionPosition);
Assert.Equal(_int1, record.SystemMetadata.TransactionOffset);
Assert.Equal(0, record.WriteId.CategoryNumber);
Assert.Equal(0, record.WriteId.TopicNumber);
Assert.Equal(_long3, record.WriteId.StreamNumber);
Assert.Equal(_long4, record.WriteId.StartingEventNumber);
Assert.Equal <Guid>(_guid2, record.Event.SystemMetadata.EventId);
Assert.Equal(_string1, record.Event.SystemMetadata.EventType);
Assert.Equal(MemoryMarshal.ToEnumerable(_bytes3), MemoryMarshal.ToEnumerable(record.Event.Data));
Assert.Equal(MemoryMarshal.ToEnumerable(_bytes4), MemoryMarshal.ToEnumerable(record.Event.Metadata));
Assert.Equal(_prepareflags, record.Event.Header.Flags);
}
public void NegativeOne()
{
var i = new BigInt(false, 32, -1);
Assert.AreEqual(i.AsMemory().Length, 4);
Assert.IsTrue(MemoryMarshal.ToEnumerable(i.AsMemory()).All(b => b == 255));
Assert.AreEqual(BigInt.AllOnes(false, 32), i);
}
public static void ToEnumerableWithIndexAndLength()
{
int[] a = { 91, 92, 93 };
var memory = new Memory <int>(a, 1, 1);
IEnumerable <int> copy = MemoryMarshal.ToEnumerable <int>(memory);
Assert.Equal <int>(new int[] { 92 }, copy);
}
public static void ToEnumerableWithIndex()
{
int[] a = { 91, 92, 93, 94, 95 };
var memory = new Memory <int>(a);
IEnumerable <int> copy = MemoryMarshal.ToEnumerable <int>(memory.Slice(2));
Assert.Equal <int>(new int[] { 93, 94, 95 }, copy);
}
public static void ToEnumerable()
{
int[] a = { 91, 92, 93 };
var memory = new Memory <int>(a);
IEnumerable <int> copy = MemoryMarshal.ToEnumerable <int>(memory);
Assert.Equal <int>(a, copy);
}
public static void ToEnumerableSameAsIEnumerator()
{
int[] a = { 91, 92, 93 };
var memory = new Memory <int>(a);
IEnumerable <int> enumer = MemoryMarshal.ToEnumerable <int>(memory);
IEnumerator <int> enumerat = enumer.GetEnumerator();
Assert.Same(enumer, enumerat);
}
public static void ToEnumerableGivenToExistingConstructor()
{
int[] a = { 91, 92, 93 };
var memory = new Memory <int>(a);
IEnumerable <int> enumer = MemoryMarshal.ToEnumerable <int>(memory);
var li = new List <int>(enumer);
Assert.Equal(a, li);
}
public void CreateAllOnes()
{
var i = BigInt.AllOnes(false, 32);
Assert.AreEqual(i.AsMemory().Length, 4);
Assert.IsTrue(i.IsOdd);
Assert.IsTrue(MemoryMarshal.ToEnumerable(i.AsMemory()).All(b => b == 255));
Assert.AreEqual(-1, (int)i);
Assert.AreEqual(uint.MaxValue, (uint)i);
}
public static void ToEnumerableForEach()
{
int[] a = { 91, 92, 93 };
var memory = new Memory <int>(a);
int index = 0;
foreach (int curr in MemoryMarshal.ToEnumerable <int>(memory))
{
Assert.Equal(a[index++], curr);
}
}
public override Task <StateSyncBatch?> PrepareRequest()
{
List <StateSyncItem> batchElements = new List <StateSyncItem>(_maxRequestSize);
int freeSpace = _maxRequestSize;
while (freeSpace > 0 && _blockSyncBatches.TryPop(out var batch))
{
Memory <Keccak> items = batch.Response !.Value;
int itemsToTake = Math.Min(freeSpace, items.Length);
batchElements.AddRange(MemoryMarshal.ToEnumerable <Keccak>(items.Slice(0, itemsToTake))
.Select(GetStateSyncItem));
if (itemsToTake != items.Length) // still items left
{
batch.Response = items.Slice(itemsToTake);
_blockSyncBatches.Push(batch);
}
freeSpace = _maxRequestSize - batchElements.Count;
if (_logger.IsTrace)
{
_logger.Trace($"Preparing to download state with witness for block {batch.BlockNumber} ({batch.BlockHash}) with {itemsToTake} elements.");
}
}
if (batchElements.Count != 0)
{
Interlocked.Increment(ref Metrics.WitnessStateRequests);
return(Task.FromResult <StateSyncBatch?>(CreateBatch(batchElements.ToArray())));
}
else if (_retryBatches.TryDequeue(out var retryBatch))
{
return(Task.FromResult <StateSyncBatch?>(retryBatch));
}
else
{
FallAsleep();
return(Task.FromResult <StateSyncBatch?>(null));
}
}
public IEnumerator <byte> GetEnumerator()
{
return(MemoryMarshal.ToEnumerable(bytes).GetEnumerator());
}
public static IEnumerable <T> ToEnumerable <T>(this ReadOnlyMemory <T> memory)
{
return(MemoryMarshal.ToEnumerable(memory));
}
public static IEnumerable <T> enumerate <T>(ReadOnlyMemory <T> src) => MemoryMarshal.ToEnumerable(src);
