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