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