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 ReadingStartedCompletesOnCallToReadAsync()
{
using (var factory = new PipelineFactory())
{
var readerWriter = factory.Create();
readerWriter.ReadAsync();
Assert.True(readerWriter.ReadingStarted.IsCompleted);
}
}
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 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 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 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);
}
}
