private void DoTestMixedGenerics <T1, T2, T3>(int argA, T1 expectedRetval, T1 argB, T2 argC, T2 expectedC, T3 expectedD)
        {
            var handler = CreateClass("MyService", "MixedGenerics")(new[] { typeof(T1), typeof(T2), typeof(T3) });

            var intCodec = codecContainer.GetManualCodecFor <int>();
            var t1Codec  = codecContainer.GetManualCodecFor <T1>();
            var t2Codec  = codecContainer.GetManualCodecFor <T2>();
            var t3Codec  = codecContainer.GetManualCodecFor <T3>();

            var data = new byte[intCodec.CalculateSize(argA) + t1Codec.CalculateSize(argB) + t2Codec.CalculateSize(argC)];

            fixed(byte *pData = data)
            {
                var p = pData;

                intCodec.Encode(ref p, argA);
                t1Codec.Encode(ref p, argB);
                t2Codec.Encode(ref p, argC);
            }

            var expectedData = new byte[t2Codec.CalculateSize(expectedC) + t3Codec.CalculateSize(expectedD) + t1Codec.CalculateSize(expectedRetval)];

            fixed(byte *pData = expectedData)
            {
                var p = pData;

                t2Codec.Encode(ref p, expectedC);
                t3Codec.Encode(ref p, expectedD);
                t1Codec.Encode(ref p, expectedRetval);
            }

            T2  dummyC = default(T2);
            T3  dummyD;
            int realA = default(int);
            T1  realB = default(T1);
            T2  realC = default(T2);

            service.MixedGenerics(0, default(T1), ref dummyC, out dummyD).ReturnsForAnyArgs(x =>
            {
                realA = (int)x[0];
                realB = (T1)x[1];
                realC = (T2)x[2];
                x[2]  = expectedC;
                x[3]  = expectedD;
                return(expectedRetval);
            });

            var result = handler.Handle(service, data, 0).Result;

            var serviceCall = service.ReceivedCalls().Last();

            Assert.That(serviceCall.GetMethodInfo(), Is.EqualTo(typeof(IGlobalService).GetMethod("MixedGenerics").MakeGenericMethod(new[] { typeof(T1), typeof(T2), typeof(T3) })));

            Assert.That(realA, Is.EqualTo(argA));
            Assert.That(realB, Is.EqualTo(argB));
            Assert.That(realC, Is.EqualTo(argC));

            Assert.That(result, Is.EquivalentTo(expectedData));
        }