public void ActTwoResponderSide(string actOneValidInput, string expectedHashHex, string expectedOutputHex) { WithResponderHandshakeInitiatedToKnownLocalKeys(); var buffer = new ArrayBufferWriter <byte>(50); NoiseProtocol.ProcessHandshakeRequest(new ReadOnlySequence <Byte>(actOneValidInput.ToByteArray()), buffer); var expectedOutput = expectedOutputHex.ToByteArray(); Assert.Equal(expectedOutput.Length, buffer.WrittenCount); Assert.Equal(expectedOutput, buffer.WrittenSpan.ToArray()); Assert.Equal(expectedHashHex.ToByteArray(), NoiseProtocol.HandshakeContext.Hash); }
public void GetMemory_InitSizeCtor(int sizeHint) { { var output = new ArrayBufferWriter <T>(256); Memory <T> memory = output.GetMemory(sizeHint); Assert.Equal(sizeHint <= 256 ? 256 : sizeHint + 256, memory.Length); } { var output = new ArrayBufferWriter <T>(1000); Memory <T> memory = output.GetMemory(sizeHint); Assert.Equal(sizeHint <= 1000 ? 1000 : sizeHint + 1000, memory.Length); } }
public void DeserializationReturnsSurplusData() { var value = new ExchangeDeclareOk(); var extra = Random.UInt(); var buffer = new ArrayBufferWriter <Byte>(); buffer.WriteSerializable(value) .WriteUInt32LE(extra); ExchangeDeclareOk.Deserialize(buffer.WrittenMemory.Span, out var _, out var surplus); Assert.Equal(expected: sizeof(UInt32), actual: surplus.Length); Assert.Equal(expected: extra, actual: BitConverter.ToUInt32(surplus)); }
public void WriteMessage_ConnectOperation_must_write_CONNECT_command_and_JSON_args() { var buffer = new ArrayBufferWriter <byte>(); var sut = new NatsOperationWriter(); sut.WriteMessage(new NatsOperation(NatsOperationId.CONNECT, new ConnectOperation()), buffer); var writtenText = System.Text.Encoding.UTF8.GetString(buffer.WrittenSpan); var jsonArgPos = writtenText.IndexOf(' '); var jsonArg = writtenText.AsSpan().Slice(jsonArgPos + 1).Trim(); Assert.StartsWith("CONNECT", writtenText); Assert.EndsWith("\r\n", writtenText); }
public void InvalidAdvance() { { var output = new ArrayBufferWriter <T>(); Assert.Throws <ArgumentException>(() => output.Advance(-1)); Assert.Throws <InvalidOperationException>(() => output.Advance(output.Capacity + 1)); } { var output = new ArrayBufferWriter <T>(); WriteData(output, 100); Assert.Throws <InvalidOperationException>(() => output.Advance(output.FreeCapacity + 1)); } }
public void ReadOnlyElementWrite() { var body = new ReadOnlyElement("Body", new ReadOnlyAttr("xmlns", "http://tempuri.org/")) { ["Origin"] = "THR", ["Destination"] = "MHD", }; var buffer = new ArrayBufferWriter <byte>(); body.WriteTo(buffer); var xml = Encoding.UTF8.GetString(buffer.WrittenSpan); }
public void Empty_sequence___true_and_nothing_read_and_written() { var sequence = new ReadOnlySequence <byte>(); IBufferWriter <byte> writer = new ArrayBufferWriter <byte>(); bool result = _encoder.TryDecode(sequence, writer, out long consumed, out long written); Assert.Multiple(() => { Assert.IsTrue(result); Assert.AreEqual(0, consumed); Assert.AreEqual(0, written); }); }
// The protobuf message size is written on 4 bytes after the message size // It's used to know how many bytes are needed to deserialized the object public void Protocol_Should_Write_Protobuf_Message_Size(int messageType) { var logger = NullLogger <ProtobufHubProtocol> .Instance; var protobufType = Array.Empty <Type>(); var protobufHubProtocol = new ProtobufHubProtocol(protobufType, logger); var hubMessage = GetHubMessageFromType(messageType); var writer = new ArrayBufferWriter <byte>(); protobufHubProtocol.WriteMessage(hubMessage, writer); var encodedMessage = writer.WrittenSpan; Assert.True(encodedMessage.Length >= ProtobufHubProtocolConstants.MESSAGE_HEADER_LENGTH, "The protobuf message size is written"); }
public void Write_VarInt32_byte(int x, byte expected) { // arrange var buffer = new ArrayBufferWriter <byte>(); // act buffer.WriteVarInt(x); // assert var mem = buffer.WrittenMemory; Assert.Equal(1, mem.Length); Assert.Equal(expected, mem.Span[0]); }
public void TestActorSettings() { var actorType = typeof(TestActor); var options = new ActorRuntimeOptions(); options.Actors.RegisterActor <TestActor>(); options.ActorIdleTimeout = TimeSpan.FromSeconds(33); options.ActorScanInterval = TimeSpan.FromSeconds(44); options.DrainOngoingCallTimeout = TimeSpan.FromSeconds(55); options.DrainRebalancedActors = true; var runtime = new ActorRuntime(options, loggerFactory, activatorFactory); Assert.Contains(actorType.Name, runtime.RegisteredActors.Select(a => a.Type.ActorTypeName), StringComparer.InvariantCulture); ArrayBufferWriter <byte> writer = new ArrayBufferWriter <byte>(); runtime.SerializeSettingsAndRegisteredTypes(writer).GetAwaiter().GetResult(); // read back the serialized json var array = writer.WrittenSpan.ToArray(); string s = Encoding.UTF8.GetString(array, 0, array.Length); JsonDocument document = JsonDocument.Parse(s); JsonElement root = document.RootElement; // parse out the entities array JsonElement element = root.GetProperty("entities"); Assert.Equal(1, element.GetArrayLength()); JsonElement arrayElement = element[0]; string actor = arrayElement.GetString(); Assert.Equal("TestActor", actor); // validate the other properties have expected values element = root.GetProperty("actorIdleTimeout"); Assert.Equal(TimeSpan.FromSeconds(33), ConverterUtils.ConvertTimeSpanFromDaprFormat(element.GetString())); element = root.GetProperty("actorScanInterval"); Assert.Equal(TimeSpan.FromSeconds(44), ConverterUtils.ConvertTimeSpanFromDaprFormat(element.GetString())); element = root.GetProperty("drainOngoingCallTimeout"); Assert.Equal(TimeSpan.FromSeconds(55), ConverterUtils.ConvertTimeSpanFromDaprFormat(element.GetString())); element = root.GetProperty("drainRebalancedActors"); Assert.True(element.GetBoolean()); }
public static async Task MemoryDTO3() { IDataTransferObject dto = new BinaryTransferObject <long> { Content = 42L }; Equal(sizeof(long), dto.Length); True(dto.IsReusable); var writer = new ArrayBufferWriter <byte>(); await dto.WriteToAsync(writer); Equal(sizeof(long), writer.WrittenCount); Equal(42L, BitConverter.ToInt64(writer.WrittenSpan)); }
public void SerializationIsSymmetric() { var buffer = new ArrayBufferWriter <Byte>(); var value = RandomSubject; value.Serialize(buffer); BasicGetOk.Deserialize(buffer.WrittenMemory.Span, out var deserialized, out var _); Assert.Equal(expected: value.DeliveryTag, actual: deserialized.DeliveryTag); Assert.Equal(expected: value.ExchangeName, actual: deserialized.ExchangeName); Assert.Equal(expected: value.MessageCount, actual: deserialized.MessageCount); Assert.Equal(expected: value.Redelivered, actual: deserialized.Redelivered); Assert.Equal(expected: value.RoutingKey, actual: deserialized.RoutingKey); }
public void DeserializationReturnsSurplusData() { var value = new RawFrame(Random.Enum <FrameType>(), Random.UShort(), Random.Bytes(Random.UShort())); var extra = Random.UInt(); var buffer = new ArrayBufferWriter <Byte>(12); buffer.WriteSerializable(value) .WriteUInt32LE(extra); RawFrame.Deserialize(buffer.WrittenMemory.Span, out var _, out var surplus); Assert.Equal(expected: sizeof(UInt32), actual: surplus.Length); Assert.Equal(expected: extra, actual: BitConverter.ToUInt32(surplus)); }
public void DeserializesThenSerializeTheMessages() { foreach ((string messageHex, TMessage expectedMessage) in GetData()) { var reader = new SequenceReader <byte>(new ReadOnlySequence <byte>(messageHex.ToByteArray())); var message = serializer.Deserialize(ref reader, 0, context); var outputBuffer = new ArrayBufferWriter <byte>(); serializer.Serialize(message, 0, context, outputBuffer); string resultHex = outputBuffer.WrittenMemory.ToArray().ToHexString(); Assert.Equal(resultHex, messageHex); } }
public void SerializationIsSymmetric() { var buffer = new ArrayBufferWriter <Byte>(8); var value = RandomSubject; value.Serialize(buffer); QueueBind.Deserialize(buffer.WrittenMemory.Span, out var deserialized, out var _); Assert.Equal(expected: value.Arguments.ToList(), actual: deserialized.Arguments.ToList()); Assert.Equal(expected: value.ExchangeName, actual: deserialized.ExchangeName); Assert.Equal(expected: value.NoWait, actual: deserialized.NoWait); Assert.Equal(expected: value.QueueName, actual: deserialized.QueueName); Assert.Equal(expected: value.RoutingKey, actual: deserialized.RoutingKey); }
public void Write_VarInt32_roundtrip(int x) { // arrange var buffer = new ArrayBufferWriter <byte>(); // act buffer.WriteVarInt(x); // assert var reader = new SequenceReader <byte>(new ReadOnlySequence <byte>(buffer.WrittenMemory)); Assert.True(reader.TryReadVarint32(out int value)); Assert.Equal(x, value); }
public static string Transliterate(this string s) { if (s.IsAscii()) { return(s); } ArrayBufferWriter <byte> writer = new ArrayBufferWriter <byte>(s.Length); foreach (Rune r in s.EnumerateRunes()) { Transliterate(r, writer); } return(Encoding.ASCII.GetString(writer.WrittenSpan)); }
/// <summary> /// Initializes a new instance of the <see cref="JsonAggregateRoot{TMemento}"/> struct. /// </summary> /// <param name="id">The unique ID of the aggregate root.</param> /// <param name="memento">The current memento.</param> /// <param name="jsonStore">The json store from which to read and write the json stream.</param> /// <param name="bufferWriter">The buffer writer into which we are writing.</param> /// <param name="utf8JsonWriter">The Utf8 json writer over which this aggregate root is implemented.</param> /// <param name="partitionKey">A string for the partition key.</param> /// <param name="eventSequenceNumber">The <see cref="EventSequenceNumber"/>.</param> /// <param name="commitSequenceNumber">The <see cref="CommitSequenceNumber"/>.</param> /// <param name="hasUncommittedEvents">A valut that indicates whether the aggregate has uncommitted events.</param> /// <param name="storeMetadata">Metadata from the store associated with this instance.</param> /// <param name="options">The JSON serializer options for the aggregate root.</param> public JsonAggregateRoot(Guid id, TMemento memento, IStreamStore jsonStore, ArrayBufferWriter <byte> bufferWriter, Utf8JsonWriter utf8JsonWriter, string partitionKey, long eventSequenceNumber, long commitSequenceNumber, bool hasUncommittedEvents, ReadOnlyMemory <byte> storeMetadata, JsonSerializerOptions options) { this.Id = id; this.Memento = memento; this.jsonStore = jsonStore; this.bufferWriter = bufferWriter; this.utf8JsonWriter = utf8JsonWriter; this.PartitionKey = partitionKey; this.EventSequenceNumber = eventSequenceNumber; this.CommitSequenceNumber = commitSequenceNumber; this.HasUncommittedEvents = hasUncommittedEvents; this.StoreMetadata = storeMetadata; this.options = options; }
public void DeserializationReturnsSurplusData() { var value = new ProtocolHeader(Random.Chars(count: 4), Random.Byte(), new ProtocolVersion(Random.Byte(), Random.Byte(), Random.Byte())); var extra = Random.UInt(); var buffer = new ArrayBufferWriter <Byte>(12); buffer.WriteSerializable(value) .WriteUInt32LE(extra); ProtocolHeader.Deserialize(buffer.WrittenMemory.Span, out var _, out var surplus); Assert.Equal(expected: sizeof(UInt32), actual: surplus.Length); Assert.Equal(expected: extra, actual: BitConverter.ToUInt32(surplus)); }
public static T ToObject <T>(this JsonElement element, JsonSerializerOptions?options = null) { var bufferWriter = new ArrayBufferWriter <byte>(); using (var writer = new Utf8JsonWriter(bufferWriter)) { element.WriteTo(writer); } var result = JsonSerializer.Deserialize <T>(bufferWriter.WrittenSpan, options); Debug.Assert(result != null); return(result); }
public void WriteTrailers_InvalidHeaderValue_Error() { // Arrange var trailers = new HeaderDictionary(); trailers.Add("one", "two:" + (char)127); var output = new ArrayBufferWriter <byte>(); // Act var ex = Assert.Throws <InvalidOperationException>(() => GrpcWebProtocolHelpers.WriteTrailers(trailers, output)); // Assert Assert.AreEqual("Invalid non-ASCII or control character in header: 0x007F", ex.Message); }
private void PublishEvent(IMessage @event) { var buffer = new ArrayBufferWriter <byte>(); @event.WriteTo(buffer); var props = this.publisher.CreateBasicProperties(); props.DeliveryMode = 2; props.Type = @event.Descriptor.FullName; props.ContentType = "application/x-protobuf"; this.publisher.BasicPublish(this.Options.Exchange, string.Empty, false, props, buffer.WrittenMemory); }
async Task ISlimGraphMobileAppsClient.CommitMobileAppContentAsync(IAzureTenant tenant, Guid appID, string type, string mobileAppContentID, InvokeRequestOptions?options, CancellationToken cancellationToken) { var buffer = new ArrayBufferWriter <byte>(); using (var writer = new Utf8JsonWriter(buffer)) { writer.WriteStartObject(); writer.WriteString("@odata.type", "#" + type); writer.WriteString("committedContentVersion", mobileAppContentID); writer.WriteEndObject(); } await((ISlimGraphMobileAppsClient)this).UpdateMobileAppAsync(tenant, appID, JsonSerializer.Deserialize <JsonElement>(buffer.WrittenSpan)); }
public void WriteMessage_ShouldThrowArgumentNullException_WhenTopicIsNull() { //TODO: Improve handling of null Topic // Arrange var writer = new MessageReaderWriter(); var message = new Message(); var buffer = new ArrayBufferWriter <byte>(); // Act & Assert var exception = Assert.Throws <ArgumentNullException>(() => writer.WriteMessage(message, buffer)); Assert.Equal("chars", exception.ParamName); }
public void GetSpan_InitSizeCtor(int sizeHint) { { var output = new ArrayBufferWriter <T>(256); Span <T> span = output.GetSpan(sizeHint); Assert.Equal(sizeHint <= 256 ? 256 : sizeHint + 256, span.Length); } { var output = new ArrayBufferWriter <T>(1000); Span <T> span = output.GetSpan(sizeHint); Assert.Equal(sizeHint <= 1000 ? 1000 : sizeHint + 1000, span.Length); } }
public void Can_encode_findvalue_request() { var node = new KNodeId32(1); var buffer = new ArrayBufferWriter <byte>(); var encoder = new KJsonMessageEncoder <KNodeId32>(); var message = new KFindValueRequest <KNodeId32>(node); var request = new KRequest <KNodeId32, KFindValueRequest <KNodeId32> >(new KMessageHeader <KNodeId32>(node, 1), message); encoder.Encode(new KMessageContext <KNodeId32>("application/json".Yield()), buffer, new KMessageSequence <KNodeId32>(1, new IKMessage <KNodeId32>[] { request })); var j = JObject.Parse(Encoding.UTF8.GetString(buffer.WrittenSpan.ToArray())); var z = JObject.ReadFrom(new JsonTextReader(new StreamReader(typeof(KJsonMessageEncoderTests).Assembly.GetManifestResourceStream("Alethic.Kademlia.Tests.Json.Samples.findvalue_request.json")))); j.Should().BeEquivalentTo(z); }
public void GetMemoryAndSpan() { { var output = new ArrayBufferWriter <T>(); WriteData(output, 2); Span <T> span = output.GetSpan(); Memory <T> memory = output.GetMemory(); Span <T> memorySpan = memory.Span; Assert.True(span.Length > 0); Assert.True(memorySpan.Length > 0); Assert.Equal(span.Length, memorySpan.Length); for (int i = 0; i < span.Length; i++) { Assert.Equal(default, span[i]);
public void Can_encode_findvalue_response() { var node = new KNodeId32(1); var buffer = new ArrayBufferWriter <byte>(); var encoder = new KJsonMessageEncoder <KNodeId32>(); var body = new KFindValueResponse <KNodeId32>(new KNodeInfo <KNodeId32>[] { new KNodeInfo <KNodeId32>(node, new[] { new Uri("http://www.google.com") }) }, new KValueInfo(new byte[0], 1, DateTime.UtcNow.AddSeconds(.9))); var message = new KResponse <KNodeId32, KFindValueResponse <KNodeId32> >(new KMessageHeader <KNodeId32>(node, 1), KResponseStatus.Success, body); encoder.Encode(new KMessageContext <KNodeId32>("application/json".Yield()), buffer, new KMessageSequence <KNodeId32>(1, new IKMessage <KNodeId32>[] { message })); var j = JObject.Parse(Encoding.UTF8.GetString(buffer.WrittenSpan.ToArray())); var z = JObject.ReadFrom(new JsonTextReader(new StreamReader(typeof(KJsonMessageEncoderTests).Assembly.GetManifestResourceStream("Alethic.Kademlia.Tests.Json.Samples.findvalue_response.json")))); j.Should().BeEquivalentTo(z); }
public void ActOneInitiatorOutputFitsLightningNetworkBolt8testVector(string expectedHashHex, string expectedOutputHex) { WithInitiatorHandshakeInitiatedToKnownLocalAndRemoteKeys(); var buffer = new ArrayBufferWriter <byte>(50); NoiseProtocol.StartNewInitiatorHandshake(Bolt8TestVectorParameters.Responder.PublicKey, buffer); var expectedOutput = expectedOutputHex.ToByteArray(); Assert.Equal(buffer.WrittenCount, expectedOutput.Length); Assert.Equal(buffer.WrittenSpan.ToArray(), expectedOutput); Assert.Equal(expectedHashHex.ToByteArray(), NoiseProtocol.HandshakeContext.Hash); }
/// <summary> /// Asynchronously commits any left over JSON text that has not yet been flushed and releases all resources used by the current instance. /// </summary> /// <remarks> /// In the case of IBufferWriter, this advances the underlying <see cref="IBufferWriter{Byte}" /> based on what has been written so far. /// In the case of Stream, this writes the data to the stream and flushes it. /// </remarks> /// <remarks> /// The <see cref="Utf8JsonWriter"/> instance cannot be re-used after disposing. /// </remarks> public async ValueTask DisposeAsync() { if (_output == null) { return; } await FlushAsync().ConfigureAwait(false); ResetHelper(); _stream = null; _arrayBufferWriter = null; _output = null; }