public void DataEnumRoundTrip()
{
{
var orig = new DataEnum.Foo();
var result = (DataEnum.Foo)IntegrationTests.RoundtripDataEnum(orig);
Assert.Equal(orig, result);
}
{
var orig = new DataEnum.Bar()
{
Element0 = "What a cool enum!"
};
var result = (DataEnum.Bar)IntegrationTests.RoundtripDataEnum(orig);
Assert.Equal(orig, result);
Assert.Equal(orig.Element0, result.Element0);
}
{
var orig = new DataEnum.Baz {
Name = "Cool Guy McGee", Value = 69
};
var result = (DataEnum.Baz)IntegrationTests.RoundtripDataEnum(orig);
Assert.Equal(orig, result);
Assert.Equal(orig.Name, result.Name);
Assert.Equal(orig.Value, result.Value);
}
}
public void GreetNumberRepeated()
{
for (int number = 0; number < 1000; number += 1)
{
string actual = IntegrationTests.GreetANumber(number);
Assert.Equal($"Hello, #{number}!", actual);
}
}
public void SimpleEnumRoundTrip()
{
foreach (var variant in Enum.GetValues(typeof(SimpleCEnum)).Cast <SimpleCEnum>())
{
SimpleCEnum result = IntegrationTests.RoundtripSimpleEnum(variant);
Assert.Equal(variant, result);
}
}
public void GenerateDataEnum()
{
IDataEnum value = IntegrationTests.GenerateDataEnum();
var baz = (DataEnum.Baz)value;
Assert.Equal("Randal", baz.Name);
Assert.Equal(11, baz.Value);
}
public void DiscriminantEnumRoundTrip()
{
foreach (var variant in Enum.GetValues(typeof(EnumWithDiscriminants)).Cast <EnumWithDiscriminants>())
{
EnumWithDiscriminants result = IntegrationTests.RoundtripSimpleEnumWithDiscriminants(variant);
Assert.Equal(variant, result);
}
}
public void StringArgRepeated()
{
for (int number = 0; number < 1000; number += 1)
{
string result = IntegrationTests.StringArg("Test");
Assert.Equal("Hello, Test!", result);
}
}
public void ReturnSimpleEnumList()
{
var expected = new List <SimpleCEnum>()
{
SimpleCEnum.Foo, SimpleCEnum.Bar, SimpleCEnum.Baz
};
var actual = IntegrationTests.RoundTripSimpleEnumVec(expected);
Assert.Equal(expected, actual);
}
public void ReturnVecInt()
{
var expected = IntegrationTests.ReturnVecI32();
var actual = new List <int>()
{
1, 2, 3, 4
};
Assert.Equal(expected, actual);
}
public void ReturnVecBool()
{
var expected = IntegrationTests.ReturnVecBool();
var actual = new List <bool>()
{
true, false, true, true
};
Assert.Equal(expected, actual);
}
public void ReturnVecFloat()
{
var expected = IntegrationTests.ReturnVecF32();
var actual = new List <float>()
{
1.0f, 2.1f, 3.123f, 4.00000004f
};
Assert.Equal(expected, actual);
}
public void CopyNewtypeStruct_RoundTrip()
{
var original = new CopyNewtypeStruct(123);
Assert.Equal(123, original.Element0);
var result = IntegrationTests.RoundTripCopyNewtypeStruct(original);
Assert.Equal(original, result);
Assert.Equal(original.Element0, result.Element0);
}
public void ReturnDataEnumList()
{
var expected = new List <IDataEnum>()
{
new DataEnum.Foo(),
new DataEnum.Bar("Cool string"),
new DataEnum.Coolness(new InnerEnum.Coolest(SimpleCEnum.Foo)),
};
var actual = IntegrationTests.RoundTripDataEnumVec(expected);
Assert.Equal(expected, actual);
}
public void CopyTupleStruct_RoundTrip()
{
var original = new CopyTupleStruct(1, 2);
Assert.Equal(1, original.Element0);
Assert.Equal(2, original.Element1);
var result = IntegrationTests.RoundTripCopyTupleStruct(original);
Assert.Equal(original, result);
Assert.Equal(original.Element0, result.Element0);
Assert.Equal(original.Element1, result.Element1);
}
public void MahjongTile()
{
var tile = new SimpleTile(Suit.Bamboo, 1);
Assert.Equal(Suit.Bamboo, tile.Suit);
Assert.Equal(1, tile.Value);
var result = IntegrationTests.RoundtripSimpleTile(tile);
Assert.Equal(tile, result);
Assert.Equal(tile.Suit, result.Suit);
Assert.Equal(tile.Value, result.Value);
}
public void ReturnStructList()
{
var expected = new List <CopyStruct>()
{
new CopyStruct(33),
new CopyStruct(12345),
};
var actual = IntegrationTests.StructVecRoundTrip(expected);
Assert.Equal(expected, actual);
Assert.Equal(expected.Count, actual.Count);
Assert.Equal(expected[0].Bar, actual[0].Bar);
Assert.Equal(expected[1].Bar, actual[1].Bar);
}
public async Task Handle(ReplyMessage message, IMessageHandlerContext context)
{
var incomingAttachment = context.Attachments();
IntegrationTests.PerformNestedConnection();
var buffer = await incomingAttachment.GetBytes();
Debug.WriteLine(buffer);
using (var stream = await incomingAttachment.GetStream())
{
Debug.WriteLine(stream);
}
IntegrationTests.HandlerEvent.Set();
}
public async Task Handle(SendMessage message, IMessageHandlerContext context)
{
var replyOptions = new SendOptions();
replyOptions.RouteToThisEndpoint();
var attachment = await context.Attachments().GetBytes("withMetadata");
Assert.Equal("value", attachment.Metadata["key"]);
Assert.NotNull(attachment);
var outgoingAttachment = replyOptions.Attachments();
outgoingAttachment.AddBytes(attachment);
IntegrationTests.PerformNestedConnection();
await context.Send(new ReplyMessage(), replyOptions);
}
public async Task InitializeAsync()
{
Logger = new TestableLogger();
LoggerFactory = Microsoft.Extensions.Logging.LoggerFactory.Create(c => c.ConfigureTestableLogger(Logger));
LogoHardwareMock = new LogoHardwareMock();
var brokerIpAddress = IPAddress.Loopback;
var brokerPort = 1889;
var mqttFactory = new MqttFactory();
mqttServer = mqttFactory.CreateMqttServer();
MqttClient = mqttFactory.CreateMqttClient();
MqttClient.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(args => MqttMessageReceived?.Invoke(this, args));
var mqttServerOptions = new MqttServerOptionsBuilder()
.WithClientId(nameof(IntegrationTestEnvironment) + "Broker")
.WithDefaultEndpointBoundIPAddress(brokerIpAddress)
.WithDefaultEndpointPort(brokerPort)
.Build();
var mqttClientOptions = new MqttClientOptionsBuilder()
.WithClientId(nameof(IntegrationTestEnvironment) + "Client")
.WithTcpServer(brokerIpAddress.ToString(), brokerPort)
.Build();
await mqttServer
.StartAsync(mqttServerOptions)
.ConfigureAwait(false);
await MqttClient
.ConnectAsync(mqttClientOptions)
.ConfigureAwait(false);
var config = IntegrationTests.GetConfig(brokerIpAddress.ToString(), brokerPort);
config.Validate();
appContext = Logic
.Initialize(LoggerFactory, config);
await appContext
.Connect()
.ConfigureAwait(false);
}
public void GreetNumber()
{
string result = IntegrationTests.GreetANumber(7);
Assert.Equal("Hello, #7!", result);
}
public void BoolReturn()
{
Assert.True(IntegrationTests.IsSeven(7));
Assert.False(IntegrationTests.IsSeven(12));
}
public void StringArg()
{
string result = IntegrationTests.StringArg("Test");
Assert.Equal("Hello, Test!", result);
}
static void Main(string[] args)
{
var test = new IntegrationTests();
test.TestTheRepository();
}
public void ReturnNumber()
{
int result = IntegrationTests.ReturnANumber();
Assert.Equal(7, result);
}
