RunAsync() public static méthode

Asynchronously simulates S101 communication.

Reads messages with logReader and depending on the direction either sends them to the remote party or matches them to messages received from the remote party. If a message received from the remote party does not match the one in the log then an appropriate exception is thrown.

Subsequent messages read with logReader that match the direction of the first message read with logReader are sent if sendFirstMessage equals true; otherwise such messages are matched to the ones received from the remote party. The opposite happens with log messages of opposite direction.

, and/or /// equal null. /// There was a mismatch between an incoming message and one read from the log. /// The event occurred on the client passed to /// . /// The XML read with is invalid, see /// for details.
public static RunAsync ( S101Client client, EmberTypeBag types, XmlReader logReader, bool sendFirstMessage ) : System.Threading.Tasks.Task
client S101Client The to use.
types EmberTypeBag The types to pass to the internal , which is used to convert /// between XML payload and EmBER payload.
logReader XmlReader The to read the messages from. The messages that are /// expected to be received from the remote party as well as the ones that will be sent are read with this /// reader. The format needs to match the one written by .
sendFirstMessage bool true to send the first message read with /// ; false to wait for the first message from the remote party and match it /// to the first message read with .
Résultat System.Threading.Tasks.Task
S101Robot Class Documentation
Exemple #1
0
        protected static Task TestWithRobot <TResourceNamespace>(
            Func <S101Client, Task> testCallback,
            IS101Logger consumerLogger,
            IS101Logger providerLogger,
            EmberTypeBag types,
            bool sendFirstMessage,
            string logXmlName,
            params object[] args)
        {
            var xml = string.Format(CultureInfo.InvariantCulture, GetContent <TResourceNamespace>(logXmlName), args);

            return(TestNoExceptionsAsync(
                       async(consumerClientTask, providerClient) =>
            {
                using (var reader = new StringReader(xml))
                    using (var xmlReader = XmlReader.Create(reader))
                    {
                        var robotTask = S101Robot.RunAsync(providerClient, types, xmlReader, sendFirstMessage);

                        using (var consumerClient = await consumerClientTask)
                        {
                            var testTask = testCallback(consumerClient);

                            // The following lines ensure that exceptions thrown from either testTask or robotTask are
                            // immediately propagated up the call chain to fail the test. It also makes sure that
                            // both tasks complete when the first completed task did not throw an exception.
                            await await Task.WhenAny(testTask, robotTask);
                            await Task.WhenAll(testTask, robotTask);
                        }
                    }
            },
                       () => ConnectAsync(-1, consumerLogger),
                       () => WaitForConnectionAsync(providerLogger)));
        }
Exemple #2
0
        public void ExceptionTest()
        {
            AsyncPump.Run(
                async() =>
            {
                using (var client = new S101Client(Stream.Null, Stream.Null.ReadAsync, Stream.Null.WriteAsync))
                {
                    await AssertThrowAsync <ArgumentNullException>(
                        () => S101Robot.RunAsync(null, Types, XmlReader.Create(Stream.Null), false),
                        () => S101Robot.RunAsync(client, null, XmlReader.Create(Stream.Null), false),
                        () => S101Robot.RunAsync(client, Types, null, false));
                }

                await AssertThrowAsync <XmlException>(() => TestWithRobot <S101Payloads>(
                                                          client => Task.FromResult(false), null, null, Types, true, "MissingPayloadLog.xml"));
            });
        }