public void TestRecordEncryptSequenceChange() { var prov = new BulkCipherProvider(); var bKey = (AeadBulkCipherInstance)prov.GetCipherKey(BulkCipherType.AES_128_GCM); bKey.SetKey(key); bKey.SetIV(iv); bKey.WithPadding(paddingLength); for (int i = 0; i < sequenceChange; i++) { bKey.IncrementSequence(); } using (var factory = new PipelineFactory()) { var pipe = factory.Create(); var pipeWriter = factory.Create(); var state = new ServerStateTls13Draft18(_listener); //state.WriteKey = bKey; var buff = pipe.Alloc(); var buffWrite = pipeWriter.Alloc(); buffWrite.Write(plainText); var reader = buffWrite.AsReadableBuffer(); RecordProcessor.WriteRecord(ref buff, (RecordType)plainText[0], reader.Slice(5), state); var result = buff.AsReadableBuffer().ToArray(); Assert.Equal <byte>(message2, result); buff.FlushAsync().Wait(); } }
public async Task ReaderShouldNotGetUnflushedBytesWithAppend() { using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); // Write 10 and flush var buffer = readerWriter.Alloc(); buffer.WriteLittleEndian(10); await buffer.FlushAsync(); // Write Hello to another pipeline and get the buffer var bytes = Encoding.ASCII.GetBytes("Hello"); var c2 = factory.Create(); await c2.WriteAsync(bytes); var result = await c2.ReadAsync(); var c2Buffer = result.Buffer; Assert.Equal(bytes.Length, c2Buffer.Length); // Write 9 to the buffer buffer = readerWriter.Alloc(); buffer.WriteLittleEndian(9); // Append the data from the other pipeline buffer.Append(c2Buffer); // Mark it as consumed c2.Advance(c2Buffer.End); // Now read and make sure we only see the comitted data result = await readerWriter.ReadAsync(); var reader = result.Buffer; Assert.Equal(4, reader.Length); Assert.Equal(10, reader.ReadLittleEndian <int>()); // Consume nothing readerWriter.Advance(reader.Start); // Flush the second set of writes await buffer.FlushAsync(); reader = (await readerWriter.ReadAsync()).Buffer; // int, int, "Hello" Assert.Equal(13, reader.Length); Assert.Equal(10, reader.ReadLittleEndian <int>()); Assert.Equal(9, reader.Slice(4).ReadLittleEndian <int>()); Assert.Equal("Hello", reader.Slice(8).GetUtf8String()); } }
public SecurePipelineConnection(IPipelineConnection pipeline, PipelineFactory factory, SecurePipelineListener listener) { _listener = listener; _lowerConnection = pipeline; _outputPipe = factory.Create(); _inputPipe = factory.Create(); _handshakePipe = factory.Create(); _handshakeOutpipe = factory.Create(); StartReading(); }
private PurchaseOrder ExecuteCheckoutPipeline(PurchaseOrder basketPurchaseOrder) { var checkoutPipeline = PipelineFactory.Create <PurchaseOrder>("Checkout"); var result = checkoutPipeline.Execute(basketPurchaseOrder); return(result == PipelineExecutionResult.Error ? null : basketPurchaseOrder); }
public async Task FastPathIndexOfAcrossBlocks() { var vecUpperR = new Vector <byte>((byte)'R'); const int blockSize = 4032; using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); // block 1 -> block2 // [padding..hello] -> [ world ] var paddingBytes = Enumerable.Repeat((byte)'a', blockSize - 5).ToArray(); var bytes = Encoding.ASCII.GetBytes("Hello World"); var writeBuffer = readerWriter.Alloc(); writeBuffer.Write(paddingBytes); writeBuffer.Write(bytes); await writeBuffer.FlushAsync(); var result = await readerWriter.ReadAsync(); var buffer = result.Buffer; ReadableBuffer slice; ReadCursor cursor; Assert.False(buffer.TrySliceTo((byte)'R', out slice, out cursor)); } }
public async Task AdvanceEmptyBufferAfterWritingResetsAwaitable() { using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); var bytes = Encoding.ASCII.GetBytes("Hello World"); await readerWriter.WriteAsync(bytes); var result = await readerWriter.ReadAsync(); var buffer = result.Buffer; Assert.Equal(11, buffer.Length); Assert.True(buffer.IsSingleSpan); var array = new byte[11]; buffer.First.Span.CopyTo(array); Assert.Equal("Hello World", Encoding.ASCII.GetString(array)); readerWriter.Advance(buffer.End); // Now write 0 and advance 0 await readerWriter.WriteAsync(Span <byte> .Empty); result = await readerWriter.ReadAsync(); readerWriter.Advance(result.Buffer.End); var awaitable = readerWriter.ReadAsync(); Assert.False(awaitable.IsCompleted); } }
public async Task WriteAndCancellingPendingReadBeforeReadAsync() { using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); var bytes = Encoding.ASCII.GetBytes("Hello World"); var output = readerWriter.Alloc(); output.Write(bytes); await output.FlushAsync(); readerWriter.CancelPendingRead(); var result = await readerWriter.ReadAsync(); var buffer = result.Buffer; Assert.False(result.IsCompleted); Assert.True(result.IsCancelled); Assert.False(buffer.IsEmpty); Assert.Equal(11, buffer.Length); Assert.True(buffer.IsSingleSpan); var array = new byte[11]; buffer.First.Span.CopyTo(array); Assert.Equal("Hello World", Encoding.ASCII.GetString(array)); readerWriter.AdvanceReader(buffer.End, buffer.End); } }
private Party UpdateOrderAddress(OrderAddress address, Party party, UpdatePartiesRequest request) { var orderAddressMapper = ObjectFactory.Instance.Resolve <IMapping <OrderAddress, Party> >(); if (IsFromUcommerce(request)) { return(orderAddressMapper.Map(address)); } var addAddressPipeline = PipelineFactory.Create <IPipelineArgs <AddAddressRequest, AddAddressResult> >("AddAddress"); var addAddressPipelineArgs = new AddAddressPipelineArgs(new AddAddressRequest() { PurchaseOrder = address.PurchaseOrder, ExistingOrderAddress = address, AddressName = party.PartyId, FirstName = party.FirstName, LastName = party.LastName, EmailAddress = party.Email, Line1 = party.Address1, Line2 = party.Address2, PostalCode = party.ZipPostalCode, City = party.City, State = party.State, CountryId = FindCountryIdByName(party.Country), PhoneNumber = party.PhoneNumber }, new AddAddressResult()); addAddressPipelineArgs.Request.Properties["FromUCommerce"] = false; addAddressPipeline.Execute(addAddressPipelineArgs); return(orderAddressMapper.Map(addAddressPipelineArgs.Response.OrderAddress)); }
public async Task SlowPathIndexOfAcrossBlocks() { const int blockSize = 4032; using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); // block 1 -> block2 // [padding..hello] -> [ world ] var paddingBytes = Enumerable.Repeat((byte)'a', blockSize - 5).ToArray(); var bytes = Encoding.ASCII.GetBytes("Hello World"); var writeBuffer = readerWriter.Alloc(); writeBuffer.Write(paddingBytes); writeBuffer.Write(bytes); await writeBuffer.FlushAsync(); var result = await readerWriter.ReadAsync(); var buffer = result.Buffer; ReadableBuffer slice; ReadCursor cursor; Assert.False(buffer.IsSingleSpan); Assert.True(buffer.TrySliceTo((byte)' ', out slice, out cursor)); slice = buffer.Slice(cursor).Slice(1); var array = slice.ToArray(); Assert.Equal("World", Encoding.ASCII.GetString(array)); } }
public void ReadableBufferSequenceWorks() { using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); var output = readerWriter.Alloc(); { // empty buffer var readable = output.AsReadableBuffer() as ISequence <ReadOnlyMemory <byte> >; var position = Position.First; ReadOnlyMemory <byte> memory; int spanCount = 0; while (readable.TryGet(ref position, out memory)) { spanCount++; Assert.Equal(0, memory.Length); } Assert.Equal(1, spanCount); } { var readable = BufferUtilities.CreateBuffer(new byte[] { 1 }, new byte[] { 2, 2 }, new byte[] { 3, 3, 3 }) as ISequence <ReadOnlyMemory <byte> >; var position = Position.First; ReadOnlyMemory <byte> memory; int spanCount = 0; while (readable.TryGet(ref position, out memory)) { spanCount++; Assert.Equal(spanCount, memory.Length); } Assert.Equal(3, spanCount); } } }
public async Task TestIndexOfWorksForAllLocations() { using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); const int Size = 5 * 4032; // multiple blocks // populate with a pile of dummy data byte[] data = new byte[512]; for (int i = 0; i < data.Length; i++) { data[i] = 42; } int totalBytes = 0; var writeBuffer = readerWriter.Alloc(); for (int i = 0; i < Size / data.Length; i++) { writeBuffer.Write(data); totalBytes += data.Length; } await writeBuffer.FlushAsync(); // now read it back var result = await readerWriter.ReadAsync(); var readBuffer = result.Buffer; Assert.False(readBuffer.IsSingleSpan); Assert.Equal(totalBytes, readBuffer.Length); TestIndexOfWorksForAllLocations(ref readBuffer, 42); } }
public async Task ReadTWorksAgainstSimpleBuffers() { byte[] chunk = { 0, 1, 2, 3, 4, 5, 6, 7 }; var span = new Span <byte>(chunk); using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); var output = readerWriter.Alloc(); output.Write(span); var readable = output.AsReadableBuffer(); Assert.True(readable.IsSingleSpan); Assert.Equal(span.Read <byte>(), readable.ReadLittleEndian <byte>()); Assert.Equal(span.Read <sbyte>(), readable.ReadLittleEndian <sbyte>()); Assert.Equal(span.Read <short>(), readable.ReadLittleEndian <short>()); Assert.Equal(span.Read <ushort>(), readable.ReadLittleEndian <ushort>()); Assert.Equal(span.Read <int>(), readable.ReadLittleEndian <int>()); Assert.Equal(span.Read <uint>(), readable.ReadLittleEndian <uint>()); Assert.Equal(span.Read <long>(), readable.ReadLittleEndian <long>()); Assert.Equal(span.Read <ulong>(), readable.ReadLittleEndian <ulong>()); Assert.Equal(span.Read <float>(), readable.ReadLittleEndian <float>()); Assert.Equal(span.Read <double>(), readable.ReadLittleEndian <double>()); await output.FlushAsync(); } }
public override void Process(ServicePipelineArgs args) { RemovePaymentInfoRequest request; RemovePaymentInfoResult result; using (new DisposableThreadLifestyleScope()) { CheckParametersAndSetupRequestAndResult(args, out request, out result); Assert.ArgumentNotNull(request.Payments, "request.Payments"); Assert.ArgumentNotNull(request.Cart, "request.Cart"); var purchaseOrder = _basketService.GetBasketByCartExternalId(request.Cart.ExternalId).PurchaseOrder; foreach (var paymentInfo in request.Payments) { RemovePayment(purchaseOrder, paymentInfo); } PipelineFactory.Create <PurchaseOrder>("Basket").Execute(purchaseOrder); var paymentInfos = _paymentMapper.Map(purchaseOrder.Payments); result.Payments = new ReadOnlyCollection <PaymentInfo>(paymentInfos); result.Cart = _purchaseOrderMapper.Map(purchaseOrder); } }
public async Task TestIndexOfWorksForAllLocations() { using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); const int Size = 5 * 4032; // multiple blocks // populate with a pile of dummy data byte[] data = new byte[512]; for (int i = 0; i < data.Length; i++) data[i] = 42; int totalBytes = 0; var writeBuffer = readerWriter.Alloc(); for (int i = 0; i < Size / data.Length; i++) { writeBuffer.Write(data); totalBytes += data.Length; } await writeBuffer.FlushAsync(); // now read it back var result = await readerWriter.ReadAsync(); var readBuffer = result.Buffer; Assert.False(readBuffer.IsSingleSpan); Assert.Equal(totalBytes, readBuffer.Length); TestIndexOfWorksForAllLocations(ref readBuffer, 42); } }
public void AllocMoreThanPoolBlockSizeThrows() { using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); Assert.Throws <ArgumentOutOfRangeException>(() => readerWriter.Alloc(8192)); } }
public ActionResult Index(ProductReviewViewModel formReview) { var product = SiteContext.Current.CatalogContext.CurrentProduct; var category = SiteContext.Current.CatalogContext.CurrentCategory; var request = System.Web.HttpContext.Current.Request; var basket = SiteContext.Current.OrderContext.GetBasket(); if (request.Form.AllKeys.All(x => x != "review-product")) { return(RedirectToAction("Index")); } var name = formReview.Name; var email = formReview.Email; var rating = Convert.ToInt32(formReview.Rating) * 20; var reviewHeadline = formReview.Title; var reviewText = formReview.Comments; if (basket.PurchaseOrder.Customer == null) { basket.PurchaseOrder.Customer = new Customer() { FirstName = name, LastName = String.Empty, EmailAddress = email }; } else { basket.PurchaseOrder.Customer.FirstName = name; if (basket.PurchaseOrder.Customer.LastName == null) { basket.PurchaseOrder.Customer.LastName = String.Empty; } basket.PurchaseOrder.Customer.EmailAddress = email; } basket.PurchaseOrder.Customer.Save(); var review = new ProductReview() { ProductCatalogGroup = SiteContext.Current.CatalogContext.CurrentCatalogGroup, ProductReviewStatus = ProductReviewStatus.SingleOrDefault(s => s.Name == "New"), CreatedOn = DateTime.Now, CreatedBy = "System", Product = product, Customer = basket.PurchaseOrder.Customer, Rating = rating, ReviewHeadline = reviewHeadline, ReviewText = reviewText, Ip = request.UserHostName }; product.AddProductReview(review); PipelineFactory.Create <ProductReview>("ProductReview").Execute(review); return(Redirect(CatalogLibrary.GetNiceUrlForProduct(product, category))); }
public static IPipelineReader ReadFile(this PipelineFactory factory, string path) { var reader = factory.Create(); var file = new FileReader(reader); file.OpenReadFile(path); return(file); }
public async Task EmptyTest() { bool isCalled = false; FilterAction filterAction = ctx => { isCalled = true; return(Task.FromResult <IResponse>(null)); }; var pipeline = PipelineFactory.Create(new IFilter[0], filterAction); (await pipeline(Context)).Should().BeNull(); isCalled.Should().BeTrue(); }
public void EnsureMoreThanPoolBlockSizeThrows() { using (var factory = new PipelineFactory()) { var pipe = factory.Create(); var buffer = pipe.Alloc(); Assert.Throws <ArgumentOutOfRangeException>(() => buffer.Ensure(8192)); } }
public void CompleteWriterThrowsIfWriteInProgress() { using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); readerWriter.Alloc(); Assert.Throws <InvalidOperationException>(() => readerWriter.CompleteWriter()); } }
public void ReadingStartedCompletesOnCallToReadAsync() { using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); readerWriter.ReadAsync(); Assert.True(readerWriter.ReadingStarted.IsCompleted); } }
private void Load(DcmDataset dataset) { Dataset = dataset; if (Dataset.InternalTransferSyntax.IsEncapsulated) Dataset.ChangeTransferSyntax(DicomTransferSyntax.ExplicitVRLittleEndian, null); DcmPixelData pixelData = new DcmPixelData(Dataset); _pixelData = PixelDataFactory.Create(pixelData, 0); _pipeline = PipelineFactory.Create(Dataset, pixelData); pixelData.Unload(); _overlays = DcmOverlayData.FromDataset(Dataset); }
public void WriteHex(int value, string hex) { using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); var buffer = readerWriter.Alloc(); buffer.Append(value, EncodingData.InvariantUtf8, 'x'); Assert.Equal(hex, buffer.AsReadableBuffer().GetAsciiString()); } }
public void ThrowsOnReadAfterCompleteReader() { using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); readerWriter.CompleteReader(); Assert.Throws <InvalidOperationException>(() => readerWriter.ReadAsync()); } }
public async Task CompleteReaderThrowsIfReadInProgress() { using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); await readerWriter.WriteAsync(new byte[1]); await readerWriter.ReadAsync(); Assert.Throws <InvalidOperationException>(() => readerWriter.CompleteReader()); } }
public void NullTest() { try { PipelineFactory.Create(null, null); } catch (ArgumentException) { return; } throw new Exception("PipelineFactory.Create should throw exception for null"); }
public void LeaveReview(Product product, string name, string email, string ratingKey, string reviewHeadline, string reviewText) { var request = HttpContext.Current.Request; var basket = SiteContext.Current.OrderContext.GetBasket(); if (request.Form.AllKeys.All(x => x != "review-product")) { return; } var rating = Convert.ToInt32(request.Form[ratingKey]) * 20; if (basket.PurchaseOrder.Customer == null) { basket.PurchaseOrder.Customer = new Customer() { FirstName = name, LastName = String.Empty, EmailAddress = email }; } else { basket.PurchaseOrder.Customer.FirstName = name; if (basket.PurchaseOrder.Customer.LastName == null) { basket.PurchaseOrder.Customer.LastName = String.Empty; } basket.PurchaseOrder.Customer.EmailAddress = email; } basket.PurchaseOrder.Customer.Save(); var review = new ProductReview() { ProductCatalogGroup = SiteContext.Current.CatalogContext.CurrentCatalogGroup, ProductReviewStatus = ProductReviewStatus.SingleOrDefault(s => s.Name == "New"), CreatedOn = DateTime.Now, CreatedBy = "System", Product = product, Customer = basket.PurchaseOrder.Customer, Rating = rating, ReviewHeadline = reviewHeadline, ReviewText = reviewText, Ip = request.UserHostName }; product.AddProductReview(review); PipelineFactory.Create <ProductReview>("ProductReview").Execute(review); Response.Redirect(Request.RawUrl); }
public void TestRecordEncryptNoPadding() { var prov = new BulkCipherProvider(); var bKey = prov.GetCipherKey(BulkCipherType.AES_128_GCM); bKey.SetKey(key); bKey.SetIV(iv); using (var factory = new PipelineFactory()) { var pipe = factory.Create(); var pipeWriter = factory.Create(); var state = new ServerStateTls13Draft18(_listener); //state.WriteKey = bKey; var buff = pipe.Alloc(); var buffWrite = pipeWriter.Alloc(); buffWrite.Write(plainText); var reader = buffWrite.AsReadableBuffer(); RecordProcessor.WriteRecord(ref buff, (RecordType)plainText[0], reader.Slice(5), state); var result = buff.AsReadableBuffer().ToArray(); Assert.Equal <byte>(message0, result); buff.FlushAsync().Wait(); } }
public override void Process(ServicePipelineArgs args) { AddShippingInfoRequest request; AddShippingInfoResult result; using (new DisposableThreadLifestyleScope()) { CheckParametersAndSetupRequestAndResult(args, out request, out result); Assert.ArgumentNotNull(request.ShippingInfo, "request.ShippingInfo"); Assert.ArgumentNotNull(request.Cart, "request.Cart"); Assert.ArgumentCondition(request.ShippingInfo.Count != 0, "request.ShippingInfo", "request.ShippingInfo cannot be empty"); Assert.ArgumentCondition(request.ShippingInfo.Count == 1, "request.ShippingInfo", "request.ShippingInfo cannot contain more than 1 ShippingInfo"); var shipments = new List <Shipment>(); var purchaseOrder = _basketService.GetBasketByCartExternalId(request.Cart.ExternalId).PurchaseOrder; if (!IsFromUcommerce(request)) { var createShipmentPipeline = PipelineFactory.Create <IPipelineArgs <CreateShipmentRequest, CreateShipmentResult> >("CreateShipment"); var createShipmentPipelineArgs = new CreateShipmentPipelineArgs(new CreateShipmentRequest() { ShippingMethod = GetShippingMethod(request.ShippingInfo.First()), OverwriteExisting = false, PurchaseOrder = purchaseOrder, ShippingAddress = GetOrderAddress(GetPartyFromCart(request.ShippingInfo.First(), request.Cart)) }, new CreateShipmentResult()); createShipmentPipelineArgs.Request.Properties["FromUCommerce"] = false; createShipmentPipeline.Execute(createShipmentPipelineArgs); shipments.Add(createShipmentPipelineArgs.Response.Shipment); PipelineFactory.Create <PurchaseOrder>("Basket").Execute(purchaseOrder); } else { shipments.Add(purchaseOrder.Shipments.Last()); } var shippingInfos = _shipmentMapper.Map(shipments); result.ShippingInfo = new ReadOnlyCollection <ShippingInfo>(shippingInfos); result.Cart = _purchaseOrderMapper.Map(purchaseOrder); } }
public async Task ReaderShouldNotGetUnflushedBytesWhenOverflowingSegments() { using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); // Fill the block with stuff leaving 5 bytes at the end var buffer = readerWriter.Alloc(1); var len = buffer.Memory.Length; // Fill the buffer with garbage // block 1 -> block2 // [padding..hello] -> [ world ] var paddingBytes = Enumerable.Repeat((byte)'a', len - 5).ToArray(); buffer.Write(paddingBytes); await buffer.FlushAsync(); // Write 10 and flush buffer = readerWriter.Alloc(); buffer.WriteLittleEndian(10); // Write 9 buffer.WriteLittleEndian(9); // Write 8 buffer.WriteLittleEndian(8); // Make sure we don't see it yet var result = await readerWriter.ReadAsync(); var reader = result.Buffer; Assert.Equal(len - 5, reader.Length); // Don't move readerWriter.Advance(reader.End); // Now flush await buffer.FlushAsync(); reader = (await readerWriter.ReadAsync()).Buffer; Assert.Equal(12, reader.Length); Assert.Equal(10, reader.ReadLittleEndian <int>()); Assert.Equal(9, reader.Slice(4).ReadLittleEndian <int>()); Assert.Equal(8, reader.Slice(8).ReadLittleEndian <int>()); } }
public async Task ReaderShouldNotGetUnflushedBytesWhenOverflowingSegments() { using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); // Fill the block with stuff leaving 5 bytes at the end var buffer = readerWriter.Alloc(1); var len = buffer.Memory.Length; // Fill the buffer with garbage // block 1 -> block2 // [padding..hello] -> [ world ] var paddingBytes = Enumerable.Repeat((byte)'a', len - 5).ToArray(); buffer.Write(paddingBytes); await buffer.FlushAsync(); // Write 10 and flush buffer = readerWriter.Alloc(); buffer.WriteLittleEndian(10); // Write 9 buffer.WriteLittleEndian(9); // Write 8 buffer.WriteLittleEndian(8); // Make sure we don't see it yet var result = await readerWriter.ReadAsync(); var reader = result.Buffer; Assert.Equal(len - 5, reader.Length); // Don't move readerWriter.Advance(reader.End); // Now flush await buffer.FlushAsync(); reader = (await readerWriter.ReadAsync()).Buffer; Assert.Equal(12, reader.Length); Assert.Equal(10, reader.ReadLittleEndian<int>()); Assert.Equal(9, reader.Slice(4).ReadLittleEndian<int>()); Assert.Equal(8, reader.Slice(8).ReadLittleEndian<int>()); } }
private static async Task CheckSecret(NamedGroup group, byte[] privKey, byte[] peerKey, byte[] publicKey, byte[] secret) { using (var factory = new PipelineFactory()) { var pipe = factory.Create(); var write = pipe.Alloc(); write.Write(peerKey); write.FlushAsync().Wait(); var reader = await pipe.ReadAsync(); var instance = new FiniteFieldInstance(group); instance.GenerateKeys(privKey, publicKey); instance.SetPeerKey(reader.Buffer); var derived = instance.DeriveSecret(); Assert.Equal <byte>(secret, derived); } }
public async Task PeekTraversesSegments() { using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); var w = readerWriter.Alloc(); w.Append(ReadableBuffer.Create(new byte[] { 1 }, 0, 1)); w.Append(ReadableBuffer.Create(new byte[] { 2 }, 0, 1)); await w.FlushAsync(); var result = await readerWriter.ReadAsync(); var buffer = result.Buffer; var reader = new ReadableBufferReader(buffer); Assert.Equal(1, reader.Take()); Assert.Equal(2, reader.Peek()); Assert.Equal(2, reader.Take()); Assert.Equal(-1, reader.Peek()); Assert.Equal(-1, reader.Take()); } }
public async Task EqualsDetectsDeltaForAllLocations() { using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); // populate with dummy data const int DataSize = 10000; byte[] data = new byte[DataSize]; var rand = new Random(12345); rand.NextBytes(data); var writeBuffer = readerWriter.Alloc(); writeBuffer.Write(data); await writeBuffer.FlushAsync(); // now read it back var result = await readerWriter.ReadAsync(); var readBuffer = result.Buffer; Assert.False(readBuffer.IsSingleSpan); Assert.Equal(data.Length, readBuffer.Length); // check the entire buffer EqualsDetectsDeltaForAllLocations(readBuffer, data, 0, data.Length); // check the first 32 sub-lengths for (int i = 0; i <= 32; i++) { var slice = readBuffer.Slice(0, i); EqualsDetectsDeltaForAllLocations(slice, data, 0, i); } // check the last 32 sub-lengths for (int i = 0; i <= 32; i++) { var slice = readBuffer.Slice(data.Length - i, i); EqualsDetectsDeltaForAllLocations(slice, data, data.Length - i, i); } } }
public async Task ReaderShouldNotGetUnflushedBytes() { using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); // Write 10 and flush var buffer = readerWriter.Alloc(); buffer.WriteLittleEndian(10); await buffer.FlushAsync(); // Write 9 buffer = readerWriter.Alloc(); buffer.WriteLittleEndian(9); // Write 8 buffer.WriteLittleEndian(8); // Make sure we don't see it yet var result = await readerWriter.ReadAsync(); var reader = result.Buffer; Assert.Equal(4, reader.Length); Assert.Equal(10, reader.ReadLittleEndian<int>()); // Don't move readerWriter.Advance(reader.Start); // Now flush await buffer.FlushAsync(); reader = (await readerWriter.ReadAsync()).Buffer; Assert.Equal(12, reader.Length); Assert.Equal(10, reader.ReadLittleEndian<int>()); Assert.Equal(9, reader.Slice(4).ReadLittleEndian<int>()); Assert.Equal(8, reader.Slice(8).ReadLittleEndian<int>()); } }
public void ReadableBufferSequenceWorks() { using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); var output = readerWriter.Alloc(); { // empty buffer var readable = output.AsReadableBuffer() as ISequence<ReadOnlyMemory<byte>>; var position = Position.First; ReadOnlyMemory<byte> memory; int spanCount = 0; while (readable.TryGet(ref position, out memory, advance: true)) { spanCount++; Assert.Equal(0, memory.Length); } Assert.Equal(1, spanCount); } { // 3 segment buffer output.Write(new byte[] { 1 }); output.Ensure(4032); output.Write(new byte[] { 2, 2 }); output.Ensure(4031); output.Write(new byte[] { 3, 3, 3 }); var readable = output.AsReadableBuffer() as ISequence<ReadOnlyMemory<byte>>; var position = Position.First; ReadOnlyMemory<byte> memory; int spanCount = 0; while (readable.TryGet(ref position, out memory, advance: true)) { spanCount++; Assert.Equal(spanCount, memory.Length); } Assert.Equal(3, spanCount); } } }
public async Task ReaderShouldNotGetUnflushedBytesWithAppend() { using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); // Write 10 and flush var buffer = readerWriter.Alloc(); buffer.WriteLittleEndian(10); await buffer.FlushAsync(); // Write Hello to another pipeline and get the buffer var bytes = Encoding.ASCII.GetBytes("Hello"); var c2 = factory.Create(); await c2.WriteAsync(bytes); var result = await c2.ReadAsync(); var c2Buffer = result.Buffer; Assert.Equal(bytes.Length, c2Buffer.Length); // Write 9 to the buffer buffer = readerWriter.Alloc(); buffer.WriteLittleEndian(9); // Append the data from the other pipeline buffer.Append(c2Buffer); // Mark it as consumed c2.Advance(c2Buffer.End); // Now read and make sure we only see the comitted data result = await readerWriter.ReadAsync(); var reader = result.Buffer; Assert.Equal(4, reader.Length); Assert.Equal(10, reader.ReadLittleEndian<int>()); // Consume nothing readerWriter.Advance(reader.Start); // Flush the second set of writes await buffer.FlushAsync(); reader = (await readerWriter.ReadAsync()).Buffer; // int, int, "Hello" Assert.Equal(13, reader.Length); Assert.Equal(10, reader.ReadLittleEndian<int>()); Assert.Equal(9, reader.Slice(4).ReadLittleEndian<int>()); Assert.Equal("Hello", reader.Slice(8).GetUtf8String()); } }
public async Task TrimEndTrimsWhitespaceAtEnd(string input, string expected) { using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); var writeBuffer = readerWriter.Alloc(); var bytes = Encoding.ASCII.GetBytes(input); writeBuffer.Write(bytes); await writeBuffer.FlushAsync(); var result = await readerWriter.ReadAsync(); var buffer = result.Buffer; var trimmed = buffer.TrimEnd(); var outputBytes = trimmed.ToArray(); Assert.Equal(expected, Encoding.ASCII.GetString(outputBytes)); } }
public async Task TrySliceToSpan(string input, string sliceTo, string expected) { var sliceToBytes = Encoding.UTF8.GetBytes(sliceTo); using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); var writeBuffer = readerWriter.Alloc(); var bytes = Encoding.UTF8.GetBytes(input); writeBuffer.Write(bytes); await writeBuffer.FlushAsync(); var result = await readerWriter.ReadAsync(); var buffer = result.Buffer; ReadableBuffer slice; ReadCursor cursor; Assert.True(buffer.TrySliceTo(sliceToBytes, out slice, out cursor)); Assert.Equal(expected, slice.GetUtf8String()); } }
public async Task CancellingPendingAfterReadAsync() { using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); var bytes = Encoding.ASCII.GetBytes("Hello World"); var output = readerWriter.Alloc(); output.Write(bytes); var task = Task.Run(async () => { var result = await readerWriter.ReadAsync(); var buffer = result.Buffer; readerWriter.Advance(buffer.End); Assert.False(result.IsCompleted); Assert.True(result.IsCancelled); Assert.True(buffer.IsEmpty); await output.FlushAsync(); result = await readerWriter.ReadAsync(); buffer = result.Buffer; Assert.Equal(11, buffer.Length); Assert.True(buffer.IsSingleSpan); Assert.False(result.IsCancelled); var array = new byte[11]; buffer.First.Span.CopyTo(array); Assert.Equal("Hello World", Encoding.ASCII.GetString(array)); readerWriter.CompleteReader(); }); // Wait until reading starts to cancel the pending read await readerWriter.ReadingStarted; readerWriter.CancelPendingRead(); await task; readerWriter.CompleteWriter(); } }
public async Task CopyToAsyncNativeMemory() { using (var pool = new NativePool()) using (var factory = new PipelineFactory(pool)) { var readerWriter = factory.Create(); var output = readerWriter.Alloc(); output.Append("Hello World", TextEncoding.Utf8); await output.FlushAsync(); var ms = new MemoryStream(); var result = await readerWriter.ReadAsync(); var rb = result.Buffer; await rb.CopyToAsync(ms); ms.Position = 0; Assert.Equal(11, rb.Length); Assert.Equal(11, ms.Length); Assert.Equal(rb.ToArray(), ms.ToArray()); Assert.Equal("Hello World", Encoding.ASCII.GetString(ms.ToArray())); } }
public async Task ReadTWorksAgainstSimpleBuffers() { byte[] chunk = { 0, 1, 2, 3, 4, 5, 6, 7 }; var span = new Span<byte>(chunk); using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); var output = readerWriter.Alloc(); output.Write(span); var readable = output.AsReadableBuffer(); Assert.True(readable.IsSingleSpan); Assert.Equal(span.Read<byte>(), readable.ReadLittleEndian<byte>()); Assert.Equal(span.Read<sbyte>(), readable.ReadLittleEndian<sbyte>()); Assert.Equal(span.Read<short>(), readable.ReadLittleEndian<short>()); Assert.Equal(span.Read<ushort>(), readable.ReadLittleEndian<ushort>()); Assert.Equal(span.Read<int>(), readable.ReadLittleEndian<int>()); Assert.Equal(span.Read<uint>(), readable.ReadLittleEndian<uint>()); Assert.Equal(span.Read<long>(), readable.ReadLittleEndian<long>()); Assert.Equal(span.Read<ulong>(), readable.ReadLittleEndian<ulong>()); Assert.Equal(span.Read<float>(), readable.ReadLittleEndian<float>()); Assert.Equal(span.Read<double>(), readable.ReadLittleEndian<double>()); await output.FlushAsync(); } }
public void AllocMoreThanPoolBlockSizeThrows() { using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); Assert.Throws<ArgumentOutOfRangeException>(() => readerWriter.Alloc(8192)); } }
public async Task FastPathIndexOfAcrossBlocks() { var vecUpperR = new Vector<byte>((byte)'R'); const int blockSize = 4032; using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); // block 1 -> block2 // [padding..hello] -> [ world ] var paddingBytes = Enumerable.Repeat((byte)'a', blockSize - 5).ToArray(); var bytes = Encoding.ASCII.GetBytes("Hello World"); var writeBuffer = readerWriter.Alloc(); writeBuffer.Write(paddingBytes); writeBuffer.Write(bytes); await writeBuffer.FlushAsync(); var result = await readerWriter.ReadAsync(); var buffer = result.Buffer; ReadableBuffer slice; ReadCursor cursor; Assert.False(buffer.TrySliceTo((byte)'R', out slice, out cursor)); } }
public async Task IndexOfNotFoundReturnsEnd() { using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); var bytes = Encoding.ASCII.GetBytes("Hello World"); await readerWriter.WriteAsync(bytes); var result = await readerWriter.ReadAsync(); var buffer = result.Buffer; ReadableBuffer slice; ReadCursor cursor; Assert.False(buffer.TrySliceTo(10, out slice, out cursor)); } }
public async Task HelloWorldAcrossTwoBlocks() { const int blockSize = 4032; using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); // block 1 -> block2 // [padding..hello] -> [ world ] var paddingBytes = Enumerable.Repeat((byte)'a', blockSize - 5).ToArray(); var bytes = Encoding.ASCII.GetBytes("Hello World"); var writeBuffer = readerWriter.Alloc(); writeBuffer.Write(paddingBytes); writeBuffer.Write(bytes); await writeBuffer.FlushAsync(); var result = await readerWriter.ReadAsync(); var buffer = result.Buffer; Assert.False(buffer.IsSingleSpan); var helloBuffer = buffer.Slice(blockSize - 5); Assert.False(helloBuffer.IsSingleSpan); var memory = new List<Memory<byte>>(); foreach (var m in helloBuffer) { memory.Add(m); } var spans = memory; Assert.Equal(2, memory.Count); var helloBytes = new byte[spans[0].Length]; spans[0].Span.CopyTo(helloBytes); var worldBytes = new byte[spans[1].Length]; spans[1].Span.CopyTo(worldBytes); Assert.Equal("Hello", Encoding.ASCII.GetString(helloBytes)); Assert.Equal(" World", Encoding.ASCII.GetString(worldBytes)); } }
public async Task ReadingCanBeCancelled() { using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); var cts = new CancellationTokenSource(); cts.Token.Register(() => { readerWriter.CompleteWriter(new OperationCanceledException(cts.Token)); }); var ignore = Task.Run(async () => { await Task.Delay(1000); cts.Cancel(); }); await Assert.ThrowsAsync<OperationCanceledException>(async () => { var result = await readerWriter.ReadAsync(); var buffer = result.Buffer; }); } }
public async Task WriteAndCancellingPendingReadBeforeReadAsync() { using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); var bytes = Encoding.ASCII.GetBytes("Hello World"); var output = readerWriter.Alloc(); output.Write(bytes); await output.FlushAsync(); readerWriter.CancelPendingRead(); var result = await readerWriter.ReadAsync(); var buffer = result.Buffer; Assert.False(result.IsCompleted); Assert.True(result.IsCancelled); Assert.False(buffer.IsEmpty); Assert.Equal(11, buffer.Length); Assert.True(buffer.IsSingleSpan); var array = new byte[11]; buffer.First.Span.CopyTo(array); Assert.Equal("Hello World", Encoding.ASCII.GetString(array)); readerWriter.CompleteWriter(); readerWriter.CompleteReader(); } }
public async Task ReadTWorksAgainstMultipleBuffers() { using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); var output = readerWriter.Alloc(); // we're going to try to force 3 buffers for 8 bytes output.Write(new byte[] { 0, 1, 2 }); output.Ensure(4031); output.Write(new byte[] { 3, 4, 5 }); output.Ensure(4031); output.Write(new byte[] { 6, 7, 9 }); var readable = output.AsReadableBuffer(); Assert.Equal(9, readable.Length); int spanCount = 0; foreach (var _ in readable) { spanCount++; } Assert.Equal(3, spanCount); byte[] local = new byte[9]; readable.CopyTo(local); var span = new Span<byte>(local); Assert.Equal(span.Read<byte>(), readable.ReadLittleEndian<byte>()); Assert.Equal(span.Read<sbyte>(), readable.ReadLittleEndian<sbyte>()); Assert.Equal(span.Read<short>(), readable.ReadLittleEndian<short>()); Assert.Equal(span.Read<ushort>(), readable.ReadLittleEndian<ushort>()); Assert.Equal(span.Read<int>(), readable.ReadLittleEndian<int>()); Assert.Equal(span.Read<uint>(), readable.ReadLittleEndian<uint>()); Assert.Equal(span.Read<long>(), readable.ReadLittleEndian<long>()); Assert.Equal(span.Read<ulong>(), readable.ReadLittleEndian<ulong>()); Assert.Equal(span.Read<float>(), readable.ReadLittleEndian<float>()); Assert.Equal(span.Read<double>(), readable.ReadLittleEndian<double>()); await output.FlushAsync(); } }
public async Task AdvanceEmptyBufferAfterWritingResetsAwaitable() { using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); var bytes = Encoding.ASCII.GetBytes("Hello World"); await readerWriter.WriteAsync(bytes); var result = await readerWriter.ReadAsync(); var buffer = result.Buffer; Assert.Equal(11, buffer.Length); Assert.True(buffer.IsSingleSpan); var array = new byte[11]; buffer.First.Span.CopyTo(array); Assert.Equal("Hello World", Encoding.ASCII.GetString(array)); readerWriter.Advance(buffer.End); // Now write 0 and advance 0 await readerWriter.WriteAsync(Span<byte>.Empty); result = await readerWriter.ReadAsync(); readerWriter.Advance(result.Buffer.End); var awaitable = readerWriter.ReadAsync(); Assert.False(awaitable.IsCompleted); } }
public Task Split(string input, char delimiter) { // note: different expectation to string.Split; empty has 0 outputs var expected = input == "" ? new string[0] : input.Split(delimiter); using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); var output = readerWriter.Alloc(); output.Append(input, TextEncoding.Utf8); var readable = output.AsReadableBuffer(); // via struct API var iter = readable.Split((byte)delimiter); Assert.Equal(expected.Length, iter.Count()); int i = 0; foreach (var item in iter) { Assert.Equal(expected[i++], item.GetUtf8String()); } Assert.Equal(expected.Length, i); // via objects/LINQ etc IEnumerable<ReadableBuffer> asObject = iter; Assert.Equal(expected.Length, asObject.Count()); i = 0; foreach (var item in asObject) { Assert.Equal(expected[i++], item.GetUtf8String()); } Assert.Equal(expected.Length, i); return output.FlushAsync(); } }
public async Task WritingDataMakesDataReadableViaPipeline() { using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); var bytes = Encoding.ASCII.GetBytes("Hello World"); await readerWriter.WriteAsync(bytes); var result = await readerWriter.ReadAsync(); var buffer = result.Buffer; Assert.Equal(11, buffer.Length); Assert.True(buffer.IsSingleSpan); var array = new byte[11]; buffer.First.Span.CopyTo(array); Assert.Equal("Hello World", Encoding.ASCII.GetString(array)); } }
public async Task GetUInt64GivesExpectedValues() { using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); var writeBuffer = readerWriter.Alloc(); writeBuffer.Ensure(50); writeBuffer.Advance(50); // not even going to pretend to write data here - we're going to cheat await writeBuffer.FlushAsync(); // by overwriting the buffer in-situ // now read it back var result = await readerWriter.ReadAsync(); var readBuffer = result.Buffer; ReadUInt64GivesExpectedValues(ref readBuffer); } }
public async Task AdvanceShouldResetStateIfReadCancelled() { using (var factory = new PipelineFactory()) { var readerWriter = factory.Create(); readerWriter.CancelPendingRead(); var result = await readerWriter.ReadAsync(); var buffer = result.Buffer; readerWriter.Advance(buffer.End); Assert.False(result.IsCompleted); Assert.True(result.IsCancelled); Assert.True(buffer.IsEmpty); var awaitable = readerWriter.ReadAsync(); Assert.False(awaitable.IsCompleted); } }