public async Task Single_Scalar_Float_argument()
        {
            /* Given */
            var objectValue = new ArgumentsTestObject();
            var context     = CreateContext(objectValue);

            context.Arguments.Returns(new Dictionary <string, object>()
            {
                ["arg"] = 1.123
            });

            /* When */
            await _sut.Float(context);

            /* Then */
            await _sut.Received().Float(objectValue, 1.123, context);
        }
        public async Task Single_Scalar_String_argument()
        {
            /* Given */
            var objectValue = new ArgumentsTestObject();
            var context     = CreateContext(objectValue);

            context.Arguments.Returns(new Dictionary <string, object>()
            {
                ["arg"] = "hello"
            });

            /* When */
            await _sut.String(context);

            /* Then */
            await _sut.Received().String(objectValue, "hello", context);
        }
        public async Task Single_Scalar_Boolean_argument()
        {
            /* Given */
            var objectValue = new ArgumentsTestObject();
            var context     = CreateContext(objectValue);

            context.Arguments.Returns(new Dictionary <string, object>()
            {
                ["arg"] = true
            });

            /* When */
            await _sut.Boolean(context);

            /* Then */
            await _sut.Received().Boolean(objectValue, true, context);
        }
        public async Task Single_Scalar_Int_Array_argument()
        {
            /* Given */
            var objectValue = new ArgumentsTestObject();
            var context     = CreateContext(objectValue);

            var argValues = new int?[] { 1, 2, 3, 4, 5 };

            context.Arguments.Returns(new Dictionary <string, object>()
            {
                ["arg"] = argValues
            });

            /* When */
            await _sut.ArrayOfInt(context);

            /* Then */
            await _sut.Received().ArrayOfInt(objectValue, argValues, context);
        }
        public async Task Single_InputObject_argument()
        {
            /* Given */
            var objectValue = new ArgumentsTestObject();
            var context     = CreateContext(objectValue);

            context.Arguments.Returns(new Dictionary <string, object>()
            {
                ["arg"] = new Dictionary <string, object>()
                {
                    ["int"] = 1
                }
            });

            /* When */
            await _sut.Input(context);

            /* Then */
            await _sut.Received().Input(objectValue, Arg.Is <TestInputObject>(ti => ti.Int == 1), context);
        }
        public async Task Single_InputObject_Array_argument()
        {
            /* Given */
            var objectValue = new ArgumentsTestObject();
            var context     = CreateContext(objectValue);

            var argValues = new Dictionary <string, object>?[]
            {
                new Dictionary <string, object>()
                {
                    ["int"] = 1
                },
                new Dictionary <string, object>()
                {
                    ["int"] = 2
                },
                new Dictionary <string, object>()
                {
                    ["int"] = 3
                }
            };

            context.Arguments.Returns(new Dictionary <string, object>()
            {
                ["arg"] = argValues
            });

            /* When */
            await _sut.ArrayOfInputObject(context);

            /* Then */
            await _sut.Received().ArrayOfInputObject(
                objectValue,
                Arg.Is <IEnumerable <TestInputObject> >(arr => arr.Count() == 3),
                context);
        }