예제 #1
0
        public static IEnumerable <object[]> GetTestCases_Basic()
        {
            yield return(CreateTestCase("nop",
                                        gen => gen.Emit(OpCodes.Nop),
                                        gen => gen.Emit(Inst.Nop())
                                        ));

            yield return(CreateTestCase("break",
                                        gen => gen.Emit(OpCodes.Break),
                                        gen => gen.Emit(Inst.Break())
                                        ));

            yield return(CreateTestCase("ldarg.0",
                                        gen => gen.Emit(OpCodes.Ldarg_0),
                                        gen => gen.Emit(Inst.Ldarg_0())
                                        ));

            yield return(CreateTestCase("ldarg.1",
                                        gen => gen.Emit(OpCodes.Ldarg_1),
                                        gen => gen.Emit(Inst.Ldarg_1())
                                        ));

            yield return(CreateTestCase("ldarg.2",
                                        gen => gen.Emit(OpCodes.Ldarg_2),
                                        gen => gen.Emit(Inst.Ldarg_2())
                                        ));

            yield return(CreateTestCase("ldarg.3",
                                        gen => gen.Emit(OpCodes.Ldarg_3),
                                        gen => gen.Emit(Inst.Ldarg_3())
                                        ));

            yield return(CreateTestCase("ldloc.0",
                                        gen => gen.Emit(OpCodes.Ldloc_0),
                                        gen => gen.Emit(Inst.Ldloc_0())
                                        ));

            yield return(CreateTestCase("ldloc.1",
                                        gen => gen.Emit(OpCodes.Ldloc_1),
                                        gen => gen.Emit(Inst.Ldloc_1())
                                        ));

            yield return(CreateTestCase("ldloc.2",
                                        gen => gen.Emit(OpCodes.Ldloc_2),
                                        gen => gen.Emit(Inst.Ldloc_2())
                                        ));

            yield return(CreateTestCase("ldloc.3",
                                        gen => gen.Emit(OpCodes.Ldloc_3),
                                        gen => gen.Emit(Inst.Ldloc_3())
                                        ));

            yield return(CreateTestCase("stloc.0",
                                        gen => gen.Emit(OpCodes.Stloc_0),
                                        gen => gen.Emit(Inst.Stloc_0())
                                        ));

            yield return(CreateTestCase("stloc.1",
                                        gen => gen.Emit(OpCodes.Stloc_1),
                                        gen => gen.Emit(Inst.Stloc_1())
                                        ));

            yield return(CreateTestCase("stloc.2",
                                        gen => gen.Emit(OpCodes.Stloc_2),
                                        gen => gen.Emit(Inst.Stloc_2())
                                        ));

            yield return(CreateTestCase("stloc.3",
                                        gen => gen.Emit(OpCodes.Stloc_3),
                                        gen => gen.Emit(Inst.Stloc_3())
                                        ));

            yield return(CreateTestCase("ldarg.s",
                                        gen => gen.Emit(OpCodes.Ldarg_S, byte.MaxValue),
                                        gen => gen.Emit(Inst.Ldarg_S(byte.MaxValue))
                                        ));

            yield return(CreateTestCase("ldarga.s",
                                        gen => gen.Emit(OpCodes.Ldarga_S, byte.MaxValue),
                                        gen => gen.Emit(Inst.Ldarga_S(byte.MaxValue))
                                        ));

            yield return(CreateTestCase("starg.s",
                                        gen => gen.Emit(OpCodes.Starg_S, byte.MaxValue),
                                        gen => gen.Emit(Inst.Starg_S(byte.MaxValue))
                                        ));

            yield return(CreateTestCase("ldloc.s",
                                        gen => gen.Emit(OpCodes.Ldloc_S, byte.MaxValue),
                                        gen => gen.Emit(Inst.Ldloc_S(byte.MaxValue))
                                        ));

            yield return(CreateTestCase("ldloca.s",
                                        gen => gen.Emit(OpCodes.Ldloca_S, byte.MaxValue),
                                        gen => gen.Emit(Inst.Ldloca_S(byte.MaxValue))
                                        ));

            yield return(CreateTestCase("stloc.s",
                                        gen => gen.Emit(OpCodes.Stloc_S, byte.MaxValue),
                                        gen => gen.Emit(Inst.Stloc_S(byte.MaxValue))
                                        ));

            yield return(CreateTestCase("ldnull",
                                        gen => gen.Emit(OpCodes.Ldnull),
                                        gen => gen.Emit(Inst.Ldnull())
                                        ));

            yield return(CreateTestCase("ldc.i4.m1",
                                        gen => gen.Emit(OpCodes.Ldc_I4_M1),
                                        gen => gen.Emit(Inst.Ldc_I4_M1())
                                        ));

            yield return(CreateTestCase("ldc.i4.0",
                                        gen => gen.Emit(OpCodes.Ldc_I4_0),
                                        gen => gen.Emit(Inst.Ldc_I4_0())
                                        ));

            yield return(CreateTestCase("ldc.i4.1",
                                        gen => gen.Emit(OpCodes.Ldc_I4_1),
                                        gen => gen.Emit(Inst.Ldc_I4_1())
                                        ));

            yield return(CreateTestCase("ldc.i4.2",
                                        gen => gen.Emit(OpCodes.Ldc_I4_2),
                                        gen => gen.Emit(Inst.Ldc_I4_2())
                                        ));

            yield return(CreateTestCase("ldc.i4.3",
                                        gen => gen.Emit(OpCodes.Ldc_I4_3),
                                        gen => gen.Emit(Inst.Ldc_I4_3())
                                        ));

            yield return(CreateTestCase("ldc.i4.4",
                                        gen => gen.Emit(OpCodes.Ldc_I4_4),
                                        gen => gen.Emit(Inst.Ldc_I4_4())
                                        ));

            yield return(CreateTestCase("ldc.i4.5",
                                        gen => gen.Emit(OpCodes.Ldc_I4_5),
                                        gen => gen.Emit(Inst.Ldc_I4_5())
                                        ));

            yield return(CreateTestCase("ldc.i4.6",
                                        gen => gen.Emit(OpCodes.Ldc_I4_6),
                                        gen => gen.Emit(Inst.Ldc_I4_6())
                                        ));

            yield return(CreateTestCase("ldc.i4.7",
                                        gen => gen.Emit(OpCodes.Ldc_I4_7),
                                        gen => gen.Emit(Inst.Ldc_I4_7())
                                        ));

            yield return(CreateTestCase("ldc.i4.8",
                                        gen => gen.Emit(OpCodes.Ldc_I4_8),
                                        gen => gen.Emit(Inst.Ldc_I4_8())
                                        ));

            yield return(CreateTestCase("ldc.i4.s",
                                        gen => gen.Emit(OpCodes.Ldc_I4_S, sbyte.MaxValue),
                                        gen => gen.Emit(Inst.Ldc_I4_S(sbyte.MaxValue))
                                        ));

            yield return(CreateTestCase("ldc.i4",
                                        gen => gen.Emit(OpCodes.Ldc_I4, int.MaxValue),
                                        gen => gen.Emit(Inst.Ldc_I4(int.MaxValue))
                                        ));

            yield return(CreateTestCase("ldc.i8",
                                        gen => gen.Emit(OpCodes.Ldc_I8, long.MaxValue),
                                        gen => gen.Emit(Inst.Ldc_I8(long.MaxValue))
                                        ));

            yield return(CreateTestCase("ldc.r4",
                                        gen => gen.Emit(OpCodes.Ldc_R4, float.MaxValue),
                                        gen => gen.Emit(Inst.Ldc_R4(float.MaxValue))
                                        ));

            yield return(CreateTestCase("ldc.r8",
                                        gen => gen.Emit(OpCodes.Ldc_R8, double.MaxValue),
                                        gen => gen.Emit(Inst.Ldc_R8(double.MaxValue))
                                        ));

            yield return(CreateTestCase("dup",
                                        gen => gen.Emit(OpCodes.Dup),
                                        gen => gen.Emit(Inst.Dup())
                                        ));

            yield return(CreateTestCase("pop",
                                        gen => gen.Emit(OpCodes.Pop),
                                        gen => gen.Emit(Inst.Pop())
                                        ));

            yield return(CreateTestCase("jmp",
                                        gen => gen.Emit(OpCodes.Jmp, MockType.MethodInfo),
                                        gen => gen.Emit(Inst.Jmp(MockType.MethodInfo))
                                        ));

            yield return(CreateTestCase("call",
                                        gen => gen.Emit(OpCodes.Call, MockType.MethodInfo),
                                        gen => gen.Emit(Inst.Call(MockType.MethodInfo))
                                        ));

            yield return(CreateTestCase("ret",
                                        gen => gen.Emit(OpCodes.Ret),
                                        gen => gen.Emit(Inst.Ret())
                                        ));

            yield return(CreateTestCase("ldind.i1",
                                        gen => gen.Emit(OpCodes.Ldind_I1),
                                        gen => gen.Emit(Inst.Ldind_I1())
                                        ));

            yield return(CreateTestCase("ldind.u1",
                                        gen => gen.Emit(OpCodes.Ldind_U1),
                                        gen => gen.Emit(Inst.Ldind_U1())
                                        ));

            yield return(CreateTestCase("ldind.i2",
                                        gen => gen.Emit(OpCodes.Ldind_I2),
                                        gen => gen.Emit(Inst.Ldind_I2())
                                        ));

            yield return(CreateTestCase("ldind.u2",
                                        gen => gen.Emit(OpCodes.Ldind_U2),
                                        gen => gen.Emit(Inst.Ldind_U2())
                                        ));

            yield return(CreateTestCase("ldind.i4",
                                        gen => gen.Emit(OpCodes.Ldind_I4),
                                        gen => gen.Emit(Inst.Ldind_I4())
                                        ));

            yield return(CreateTestCase("ldind.u4",
                                        gen => gen.Emit(OpCodes.Ldind_U4),
                                        gen => gen.Emit(Inst.Ldind_U4())
                                        ));

            yield return(CreateTestCase("ldind.i8",
                                        gen => gen.Emit(OpCodes.Ldind_I8),
                                        gen => gen.Emit(Inst.Ldind_I8())
                                        ));

            yield return(CreateTestCase("ldind.i",
                                        gen => gen.Emit(OpCodes.Ldind_I),
                                        gen => gen.Emit(Inst.Ldind_I())
                                        ));

            yield return(CreateTestCase("ldind.r4",
                                        gen => gen.Emit(OpCodes.Ldind_R4),
                                        gen => gen.Emit(Inst.Ldind_R4())
                                        ));

            yield return(CreateTestCase("ldind.r8",
                                        gen => gen.Emit(OpCodes.Ldind_R8),
                                        gen => gen.Emit(Inst.Ldind_R8())
                                        ));

            yield return(CreateTestCase("ldind.ref",
                                        gen => gen.Emit(OpCodes.Ldind_Ref),
                                        gen => gen.Emit(Inst.Ldind_Ref())
                                        ));

            yield return(CreateTestCase("stind.ref",
                                        gen => gen.Emit(OpCodes.Stind_Ref),
                                        gen => gen.Emit(Inst.Stind_Ref())
                                        ));

            yield return(CreateTestCase("stind.i1",
                                        gen => gen.Emit(OpCodes.Stind_I1),
                                        gen => gen.Emit(Inst.Stind_I1())
                                        ));

            yield return(CreateTestCase("stind.i2",
                                        gen => gen.Emit(OpCodes.Stind_I2),
                                        gen => gen.Emit(Inst.Stind_I2())
                                        ));

            yield return(CreateTestCase("stind.i4",
                                        gen => gen.Emit(OpCodes.Stind_I4),
                                        gen => gen.Emit(Inst.Stind_I4())
                                        ));

            yield return(CreateTestCase("stind.i8",
                                        gen => gen.Emit(OpCodes.Stind_I8),
                                        gen => gen.Emit(Inst.Stind_I8())
                                        ));

            yield return(CreateTestCase("stind.r4",
                                        gen => gen.Emit(OpCodes.Stind_R4),
                                        gen => gen.Emit(Inst.Stind_R4())
                                        ));

            yield return(CreateTestCase("stind.r8",
                                        gen => gen.Emit(OpCodes.Stind_R8),
                                        gen => gen.Emit(Inst.Stind_R8())
                                        ));

            yield return(CreateTestCase("add",
                                        gen => gen.Emit(OpCodes.Add),
                                        gen => gen.Emit(Inst.Add())
                                        ));

            yield return(CreateTestCase("sub",
                                        gen => gen.Emit(OpCodes.Sub),
                                        gen => gen.Emit(Inst.Sub())
                                        ));

            yield return(CreateTestCase("mul",
                                        gen => gen.Emit(OpCodes.Mul),
                                        gen => gen.Emit(Inst.Mul())
                                        ));

            yield return(CreateTestCase("div",
                                        gen => gen.Emit(OpCodes.Div),
                                        gen => gen.Emit(Inst.Div())
                                        ));

            yield return(CreateTestCase("div.un",
                                        gen => gen.Emit(OpCodes.Div_Un),
                                        gen => gen.Emit(Inst.Div_Un())
                                        ));

            yield return(CreateTestCase("rem",
                                        gen => gen.Emit(OpCodes.Rem),
                                        gen => gen.Emit(Inst.Rem())
                                        ));

            yield return(CreateTestCase("rem.un",
                                        gen => gen.Emit(OpCodes.Rem_Un),
                                        gen => gen.Emit(Inst.Rem_Un())
                                        ));

            yield return(CreateTestCase("and",
                                        gen => gen.Emit(OpCodes.And),
                                        gen => gen.Emit(Inst.And())
                                        ));

            yield return(CreateTestCase("or",
                                        gen => gen.Emit(OpCodes.Or),
                                        gen => gen.Emit(Inst.Or())
                                        ));

            yield return(CreateTestCase("xor",
                                        gen => gen.Emit(OpCodes.Xor),
                                        gen => gen.Emit(Inst.Xor())
                                        ));

            yield return(CreateTestCase("shl",
                                        gen => gen.Emit(OpCodes.Shl),
                                        gen => gen.Emit(Inst.Shl())
                                        ));

            yield return(CreateTestCase("shr",
                                        gen => gen.Emit(OpCodes.Shr),
                                        gen => gen.Emit(Inst.Shr())
                                        ));

            yield return(CreateTestCase("shr.un",
                                        gen => gen.Emit(OpCodes.Shr_Un),
                                        gen => gen.Emit(Inst.Shr_Un())
                                        ));

            yield return(CreateTestCase("neg",
                                        gen => gen.Emit(OpCodes.Neg),
                                        gen => gen.Emit(Inst.Neg())
                                        ));

            yield return(CreateTestCase("not",
                                        gen => gen.Emit(OpCodes.Not),
                                        gen => gen.Emit(Inst.Not())
                                        ));

            yield return(CreateTestCase("conv.i1",
                                        gen => gen.Emit(OpCodes.Conv_I1),
                                        gen => gen.Emit(Inst.Conv_I1())
                                        ));

            yield return(CreateTestCase("conv.i2",
                                        gen => gen.Emit(OpCodes.Conv_I2),
                                        gen => gen.Emit(Inst.Conv_I2())
                                        ));

            yield return(CreateTestCase("conv.i4",
                                        gen => gen.Emit(OpCodes.Conv_I4),
                                        gen => gen.Emit(Inst.Conv_I4())
                                        ));

            yield return(CreateTestCase("conv.i8",
                                        gen => gen.Emit(OpCodes.Conv_I8),
                                        gen => gen.Emit(Inst.Conv_I8())
                                        ));

            yield return(CreateTestCase("conv.r4",
                                        gen => gen.Emit(OpCodes.Conv_R4),
                                        gen => gen.Emit(Inst.Conv_R4())
                                        ));

            yield return(CreateTestCase("conv.r8",
                                        gen => gen.Emit(OpCodes.Conv_R8),
                                        gen => gen.Emit(Inst.Conv_R8())
                                        ));

            yield return(CreateTestCase("conv.u4",
                                        gen => gen.Emit(OpCodes.Conv_U4),
                                        gen => gen.Emit(Inst.Conv_U4())
                                        ));

            yield return(CreateTestCase("conv.u8",
                                        gen => gen.Emit(OpCodes.Conv_U8),
                                        gen => gen.Emit(Inst.Conv_U8())
                                        ));

            yield return(CreateTestCase("callvirt",
                                        gen => gen.Emit(OpCodes.Callvirt, MockType.MethodInfo),
                                        gen => gen.Emit(Inst.Callvirt(MockType.MethodInfo))
                                        ));

            yield return(CreateTestCase("cpobj",
                                        gen => gen.Emit(OpCodes.Cpobj, MockType.Type),
                                        gen => gen.Emit(Inst.Cpobj(MockType.Type))
                                        ));

            yield return(CreateTestCase("ldobj",
                                        gen => gen.Emit(OpCodes.Ldobj, MockType.Type),
                                        gen => gen.Emit(Inst.Ldobj(MockType.Type))
                                        ));

            yield return(CreateTestCase("ldstr",
                                        gen => gen.Emit(OpCodes.Ldstr, "foobar"),
                                        gen => gen.Emit(Inst.Ldstr("foobar"))
                                        ));

            yield return(CreateTestCase("newobj",
                                        gen => gen.Emit(OpCodes.Newobj, MockType.ConstructorInfo),
                                        gen => gen.Emit(Inst.Newobj(MockType.ConstructorInfo))
                                        ));

            yield return(CreateTestCase("castclass",
                                        gen => gen.Emit(OpCodes.Castclass, MockType.Type),
                                        gen => gen.Emit(Inst.Castclass(MockType.Type))
                                        ));

            yield return(CreateTestCase("isinst",
                                        gen => gen.Emit(OpCodes.Isinst, MockType.Type),
                                        gen => gen.Emit(Inst.Isinst(MockType.Type))
                                        ));

            yield return(CreateTestCase("conv.r.un",
                                        gen => gen.Emit(OpCodes.Conv_R_Un),
                                        gen => gen.Emit(Inst.Conv_R_Un())
                                        ));

            yield return(CreateTestCase("unbox",
                                        gen => gen.Emit(OpCodes.Unbox, MockType.Type),
                                        gen => gen.Emit(Inst.Unbox(MockType.Type))
                                        ));

            yield return(CreateTestCase("throw",
                                        gen => gen.Emit(OpCodes.Throw),
                                        gen => gen.Emit(Inst.Throw())
                                        ));

            yield return(CreateTestCase("ldfld",
                                        gen => gen.Emit(OpCodes.Ldfld, MockType.InstanceFieldInfo),
                                        gen => gen.Emit(Inst.Ldfld(MockType.InstanceFieldInfo))
                                        ));

            yield return(CreateTestCase("ldflda",
                                        gen => gen.Emit(OpCodes.Ldflda, MockType.InstanceFieldInfo),
                                        gen => gen.Emit(Inst.Ldflda(MockType.InstanceFieldInfo))
                                        ));

            yield return(CreateTestCase("stfld",
                                        gen => gen.Emit(OpCodes.Stfld, MockType.InstanceFieldInfo),
                                        gen => gen.Emit(Inst.Stfld(MockType.InstanceFieldInfo))
                                        ));

            yield return(CreateTestCase("ldsfld",
                                        gen => gen.Emit(OpCodes.Ldsfld, MockType.StaticFieldInfo),
                                        gen => gen.Emit(Inst.Ldsfld(MockType.StaticFieldInfo))
                                        ));

            yield return(CreateTestCase("ldsflda",
                                        gen => gen.Emit(OpCodes.Ldsflda, MockType.StaticFieldInfo),
                                        gen => gen.Emit(Inst.Ldsflda(MockType.StaticFieldInfo))
                                        ));

            yield return(CreateTestCase("stsfld",
                                        gen => gen.Emit(OpCodes.Stsfld, MockType.StaticFieldInfo),
                                        gen => gen.Emit(Inst.Stsfld(MockType.StaticFieldInfo))
                                        ));

            yield return(CreateTestCase("stobj",
                                        gen => gen.Emit(OpCodes.Stobj, MockType.Type),
                                        gen => gen.Emit(Inst.Stobj(MockType.Type))
                                        ));

            yield return(CreateTestCase("conv.ovf.i1.un",
                                        gen => gen.Emit(OpCodes.Conv_Ovf_I1_Un),
                                        gen => gen.Emit(Inst.Conv_Ovf_I1_Un())
                                        ));

            yield return(CreateTestCase("conv.ovf.i2.un",
                                        gen => gen.Emit(OpCodes.Conv_Ovf_I2_Un),
                                        gen => gen.Emit(Inst.Conv_Ovf_I2_Un())
                                        ));

            yield return(CreateTestCase("conv.ovf.i4.un",
                                        gen => gen.Emit(OpCodes.Conv_Ovf_I4_Un),
                                        gen => gen.Emit(Inst.Conv_Ovf_I4_Un())
                                        ));

            yield return(CreateTestCase("conv.ovf.i8.un",
                                        gen => gen.Emit(OpCodes.Conv_Ovf_I8_Un),
                                        gen => gen.Emit(Inst.Conv_Ovf_I8_Un())
                                        ));

            yield return(CreateTestCase("conv.ovf.u1.un",
                                        gen => gen.Emit(OpCodes.Conv_Ovf_U1_Un),
                                        gen => gen.Emit(Inst.Conv_Ovf_U1_Un())
                                        ));

            yield return(CreateTestCase("conv.ovf.u2.un",
                                        gen => gen.Emit(OpCodes.Conv_Ovf_U2_Un),
                                        gen => gen.Emit(Inst.Conv_Ovf_U2_Un())
                                        ));

            yield return(CreateTestCase("conv.ovf.u4.un",
                                        gen => gen.Emit(OpCodes.Conv_Ovf_U4_Un),
                                        gen => gen.Emit(Inst.Conv_Ovf_U4_Un())
                                        ));

            yield return(CreateTestCase("conv.ovf.u8.un",
                                        gen => gen.Emit(OpCodes.Conv_Ovf_U8_Un),
                                        gen => gen.Emit(Inst.Conv_Ovf_U8_Un())
                                        ));

            yield return(CreateTestCase("conv.ovf.i.un",
                                        gen => gen.Emit(OpCodes.Conv_Ovf_I_Un),
                                        gen => gen.Emit(Inst.Conv_Ovf_I_Un())
                                        ));

            yield return(CreateTestCase("conv.ovf.u.un",
                                        gen => gen.Emit(OpCodes.Conv_Ovf_U_Un),
                                        gen => gen.Emit(Inst.Conv_Ovf_U_Un())
                                        ));

            yield return(CreateTestCase("box",
                                        gen => gen.Emit(OpCodes.Box, MockType.Type),
                                        gen => gen.Emit(Inst.Box(MockType.Type))
                                        ));

            yield return(CreateTestCase("newarr",
                                        gen => gen.Emit(OpCodes.Newarr, MockType.Type),
                                        gen => gen.Emit(Inst.Newarr(MockType.Type))
                                        ));

            yield return(CreateTestCase("ldlen",
                                        gen => gen.Emit(OpCodes.Ldlen),
                                        gen => gen.Emit(Inst.Ldlen())
                                        ));

            yield return(CreateTestCase("ldelema",
                                        gen => gen.Emit(OpCodes.Ldelema, MockType.Type),
                                        gen => gen.Emit(Inst.Ldelema(MockType.Type))
                                        ));

            yield return(CreateTestCase("ldelem.i1",
                                        gen => gen.Emit(OpCodes.Ldelem_I1),
                                        gen => gen.Emit(Inst.Ldelem_I1())
                                        ));

            yield return(CreateTestCase("ldelem.u1",
                                        gen => gen.Emit(OpCodes.Ldelem_U1),
                                        gen => gen.Emit(Inst.Ldelem_U1())
                                        ));

            yield return(CreateTestCase("ldelem.i2",
                                        gen => gen.Emit(OpCodes.Ldelem_I2),
                                        gen => gen.Emit(Inst.Ldelem_I2())
                                        ));

            yield return(CreateTestCase("ldelem.u2",
                                        gen => gen.Emit(OpCodes.Ldelem_U2),
                                        gen => gen.Emit(Inst.Ldelem_U2())
                                        ));

            yield return(CreateTestCase("ldelem.i4",
                                        gen => gen.Emit(OpCodes.Ldelem_I4),
                                        gen => gen.Emit(Inst.Ldelem_I4())
                                        ));

            yield return(CreateTestCase("ldelem.u4",
                                        gen => gen.Emit(OpCodes.Ldelem_U4),
                                        gen => gen.Emit(Inst.Ldelem_U4())
                                        ));

            yield return(CreateTestCase("ldelem.i8",
                                        gen => gen.Emit(OpCodes.Ldelem_I8),
                                        gen => gen.Emit(Inst.Ldelem_I8())
                                        ));

            yield return(CreateTestCase("ldelem.i",
                                        gen => gen.Emit(OpCodes.Ldelem_I),
                                        gen => gen.Emit(Inst.Ldelem_I())
                                        ));

            yield return(CreateTestCase("ldelem.r4",
                                        gen => gen.Emit(OpCodes.Ldelem_R4),
                                        gen => gen.Emit(Inst.Ldelem_R4())
                                        ));

            yield return(CreateTestCase("ldelem.r8",
                                        gen => gen.Emit(OpCodes.Ldelem_R8),
                                        gen => gen.Emit(Inst.Ldelem_R8())
                                        ));

            yield return(CreateTestCase("ldelem.ref",
                                        gen => gen.Emit(OpCodes.Ldelem_Ref),
                                        gen => gen.Emit(Inst.Ldelem_Ref())
                                        ));

            yield return(CreateTestCase("stelem.i",
                                        gen => gen.Emit(OpCodes.Stelem_I),
                                        gen => gen.Emit(Inst.Stelem_I())
                                        ));

            yield return(CreateTestCase("stelem.i1",
                                        gen => gen.Emit(OpCodes.Stelem_I1),
                                        gen => gen.Emit(Inst.Stelem_I1())
                                        ));

            yield return(CreateTestCase("stelem.i2",
                                        gen => gen.Emit(OpCodes.Stelem_I2),
                                        gen => gen.Emit(Inst.Stelem_I2())
                                        ));

            yield return(CreateTestCase("stelem.i4",
                                        gen => gen.Emit(OpCodes.Stelem_I4),
                                        gen => gen.Emit(Inst.Stelem_I4())
                                        ));

            yield return(CreateTestCase("stelem.i8",
                                        gen => gen.Emit(OpCodes.Stelem_I8),
                                        gen => gen.Emit(Inst.Stelem_I8())
                                        ));

            yield return(CreateTestCase("stelem.r4",
                                        gen => gen.Emit(OpCodes.Stelem_R4),
                                        gen => gen.Emit(Inst.Stelem_R4())
                                        ));

            yield return(CreateTestCase("stelem.r8",
                                        gen => gen.Emit(OpCodes.Stelem_R8),
                                        gen => gen.Emit(Inst.Stelem_R8())
                                        ));

            yield return(CreateTestCase("stelem.ref",
                                        gen => gen.Emit(OpCodes.Stelem_Ref),
                                        gen => gen.Emit(Inst.Stelem_Ref())
                                        ));

            yield return(CreateTestCase("ldelem",
                                        gen => gen.Emit(OpCodes.Ldelem, MockType.Type),
                                        gen => gen.Emit(Inst.Ldelem(MockType.Type))
                                        ));

            yield return(CreateTestCase("stelem",
                                        gen => gen.Emit(OpCodes.Stelem, MockType.Type),
                                        gen => gen.Emit(Inst.Stelem(MockType.Type))
                                        ));

            yield return(CreateTestCase("unbox.any",
                                        gen => gen.Emit(OpCodes.Unbox_Any, MockType.Type),
                                        gen => gen.Emit(Inst.Unbox_Any(MockType.Type))
                                        ));

            yield return(CreateTestCase("conv.ovf.i1",
                                        gen => gen.Emit(OpCodes.Conv_Ovf_I1),
                                        gen => gen.Emit(Inst.Conv_Ovf_I1())
                                        ));

            yield return(CreateTestCase("conv.ovf.u1",
                                        gen => gen.Emit(OpCodes.Conv_Ovf_U1),
                                        gen => gen.Emit(Inst.Conv_Ovf_U1())
                                        ));

            yield return(CreateTestCase("conv.ovf.i2",
                                        gen => gen.Emit(OpCodes.Conv_Ovf_I2),
                                        gen => gen.Emit(Inst.Conv_Ovf_I2())
                                        ));

            yield return(CreateTestCase("conv.ovf.u2",
                                        gen => gen.Emit(OpCodes.Conv_Ovf_U2),
                                        gen => gen.Emit(Inst.Conv_Ovf_U2())
                                        ));

            yield return(CreateTestCase("conv.ovf.i4",
                                        gen => gen.Emit(OpCodes.Conv_Ovf_I4),
                                        gen => gen.Emit(Inst.Conv_Ovf_I4())
                                        ));

            yield return(CreateTestCase("conv.ovf.u4",
                                        gen => gen.Emit(OpCodes.Conv_Ovf_U4),
                                        gen => gen.Emit(Inst.Conv_Ovf_U4())
                                        ));

            yield return(CreateTestCase("conv.ovf.i8",
                                        gen => gen.Emit(OpCodes.Conv_Ovf_I8),
                                        gen => gen.Emit(Inst.Conv_Ovf_I8())
                                        ));

            yield return(CreateTestCase("conv.ovf.u8",
                                        gen => gen.Emit(OpCodes.Conv_Ovf_U8),
                                        gen => gen.Emit(Inst.Conv_Ovf_U8())
                                        ));

            yield return(CreateTestCase("refanyval",
                                        gen => gen.Emit(OpCodes.Refanyval, MockType.Type),
                                        gen => gen.Emit(Inst.Refanyval(MockType.Type))
                                        ));

            yield return(CreateTestCase("ckfinite",
                                        gen => gen.Emit(OpCodes.Ckfinite),
                                        gen => gen.Emit(Inst.Ckfinite())
                                        ));

            yield return(CreateTestCase("mkrefany",
                                        gen => gen.Emit(OpCodes.Mkrefany, MockType.Type),
                                        gen => gen.Emit(Inst.Mkrefany(MockType.Type))
                                        ));

            yield return(CreateTestCase("conv.u2",
                                        gen => gen.Emit(OpCodes.Conv_U2),
                                        gen => gen.Emit(Inst.Conv_U2())
                                        ));

            yield return(CreateTestCase("conv.u1",
                                        gen => gen.Emit(OpCodes.Conv_U1),
                                        gen => gen.Emit(Inst.Conv_U1())
                                        ));

            yield return(CreateTestCase("conv.i",
                                        gen => gen.Emit(OpCodes.Conv_I),
                                        gen => gen.Emit(Inst.Conv_I())
                                        ));

            yield return(CreateTestCase("conv.ovf.i",
                                        gen => gen.Emit(OpCodes.Conv_Ovf_I),
                                        gen => gen.Emit(Inst.Conv_Ovf_I())
                                        ));

            yield return(CreateTestCase("conv.ovf.u",
                                        gen => gen.Emit(OpCodes.Conv_Ovf_U),
                                        gen => gen.Emit(Inst.Conv_Ovf_U())
                                        ));

            yield return(CreateTestCase("add.ovf",
                                        gen => gen.Emit(OpCodes.Add_Ovf),
                                        gen => gen.Emit(Inst.Add_Ovf())
                                        ));

            yield return(CreateTestCase("add.ovf.un",
                                        gen => gen.Emit(OpCodes.Add_Ovf_Un),
                                        gen => gen.Emit(Inst.Add_Ovf_Un())
                                        ));

            yield return(CreateTestCase("mul.ovf",
                                        gen => gen.Emit(OpCodes.Mul_Ovf),
                                        gen => gen.Emit(Inst.Mul_Ovf())
                                        ));

            yield return(CreateTestCase("mul.ovf.un",
                                        gen => gen.Emit(OpCodes.Mul_Ovf_Un),
                                        gen => gen.Emit(Inst.Mul_Ovf_Un())
                                        ));

            yield return(CreateTestCase("sub.ovf",
                                        gen => gen.Emit(OpCodes.Sub_Ovf),
                                        gen => gen.Emit(Inst.Sub_Ovf())
                                        ));

            yield return(CreateTestCase("sub.ovf.un",
                                        gen => gen.Emit(OpCodes.Sub_Ovf_Un),
                                        gen => gen.Emit(Inst.Sub_Ovf_Un())
                                        ));

            yield return(CreateTestCase("endfinally",
                                        gen => gen.Emit(OpCodes.Endfinally),
                                        gen => gen.Emit(Inst.Endfinally())
                                        ));

            yield return(CreateTestCase("stind.i",
                                        gen => gen.Emit(OpCodes.Stind_I),
                                        gen => gen.Emit(Inst.Stind_I())
                                        ));

            yield return(CreateTestCase("conv.u",
                                        gen => gen.Emit(OpCodes.Conv_U),
                                        gen => gen.Emit(Inst.Conv_U())
                                        ));

            yield return(CreateTestCase("arglist",
                                        gen => gen.Emit(OpCodes.Arglist),
                                        gen => gen.Emit(Inst.Arglist())
                                        ));

            yield return(CreateTestCase("ceq",
                                        gen => gen.Emit(OpCodes.Ceq),
                                        gen => gen.Emit(Inst.Ceq())
                                        ));

            yield return(CreateTestCase("cgt",
                                        gen => gen.Emit(OpCodes.Cgt),
                                        gen => gen.Emit(Inst.Cgt())
                                        ));

            yield return(CreateTestCase("cgt.un",
                                        gen => gen.Emit(OpCodes.Cgt_Un),
                                        gen => gen.Emit(Inst.Cgt_Un())
                                        ));

            yield return(CreateTestCase("clt",
                                        gen => gen.Emit(OpCodes.Clt),
                                        gen => gen.Emit(Inst.Clt())
                                        ));

            yield return(CreateTestCase("clt.un",
                                        gen => gen.Emit(OpCodes.Clt_Un),
                                        gen => gen.Emit(Inst.Clt_Un())
                                        ));

            yield return(CreateTestCase("ldftn",
                                        gen => gen.Emit(OpCodes.Ldftn, MockType.MethodInfo),
                                        gen => gen.Emit(Inst.Ldftn(MockType.MethodInfo))
                                        ));

            yield return(CreateTestCase("ldvirtftn",
                                        gen => gen.Emit(OpCodes.Ldvirtftn, MockType.MethodInfo),
                                        gen => gen.Emit(Inst.Ldvirtftn(MockType.MethodInfo))
                                        ));

            yield return(CreateTestCase("ldarg",
                                        gen => gen.Emit(OpCodes.Ldarg, unchecked ((short)ushort.MaxValue)),
                                        gen => gen.Emit(Inst.Ldarg(ushort.MaxValue))
                                        ));

            yield return(CreateTestCase("ldarga",
                                        gen => gen.Emit(OpCodes.Ldarga, unchecked ((short)ushort.MaxValue)),
                                        gen => gen.Emit(Inst.Ldarga(ushort.MaxValue))
                                        ));

            yield return(CreateTestCase("starg",
                                        gen => gen.Emit(OpCodes.Starg, unchecked ((short)ushort.MaxValue)),
                                        gen => gen.Emit(Inst.Starg(ushort.MaxValue))
                                        ));

            yield return(CreateTestCase("ldloc",
                                        gen => gen.Emit(OpCodes.Ldloc, unchecked ((short)ushort.MaxValue)),
                                        gen => gen.Emit(Inst.Ldloc(ushort.MaxValue))
                                        ));

            yield return(CreateTestCase("ldloca",
                                        gen => gen.Emit(OpCodes.Ldloca, unchecked ((short)ushort.MaxValue)),
                                        gen => gen.Emit(Inst.Ldloca(ushort.MaxValue))
                                        ));

            yield return(CreateTestCase("stloc",
                                        gen => gen.Emit(OpCodes.Stloc, unchecked ((short)ushort.MaxValue)),
                                        gen => gen.Emit(Inst.Stloc(ushort.MaxValue))
                                        ));

            yield return(CreateTestCase("localloc",
                                        gen => gen.Emit(OpCodes.Localloc),
                                        gen => gen.Emit(Inst.Localloc())
                                        ));

            yield return(CreateTestCase("endfilter",
                                        gen => gen.Emit(OpCodes.Endfilter),
                                        gen => gen.Emit(Inst.Endfilter())
                                        ));

            yield return(CreateTestCase("unaligned.",
                                        gen => gen.Emit(OpCodes.Unaligned, byte.MaxValue),
                                        gen => gen.Emit(Inst.Unaligned(byte.MaxValue))
                                        ));

            yield return(CreateTestCase("volatile.",
                                        gen => gen.Emit(OpCodes.Volatile),
                                        gen => gen.Emit(Inst.Volatile())
                                        ));

            yield return(CreateTestCase("tail.",
                                        gen => gen.Emit(OpCodes.Tailcall),
                                        gen => gen.Emit(Inst.Tailcall())
                                        ));

            yield return(CreateTestCase("initobj",
                                        gen => gen.Emit(OpCodes.Initobj, MockType.Type),
                                        gen => gen.Emit(Inst.Initobj(MockType.Type))
                                        ));

            yield return(CreateTestCase("constrained.",
                                        gen => gen.Emit(OpCodes.Constrained, MockType.Type),
                                        gen => gen.Emit(Inst.Constrained(MockType.Type))
                                        ));

            yield return(CreateTestCase("cpblk",
                                        gen => gen.Emit(OpCodes.Cpblk),
                                        gen => gen.Emit(Inst.Cpblk())
                                        ));

            yield return(CreateTestCase("initblk",
                                        gen => gen.Emit(OpCodes.Initblk),
                                        gen => gen.Emit(Inst.Initblk())
                                        ));

            yield return(CreateTestCase("rethrow",
                                        gen => gen.Emit(OpCodes.Rethrow),
                                        gen => gen.Emit(Inst.Rethrow())
                                        ));

            yield return(CreateTestCase("sizeof",
                                        gen => gen.Emit(OpCodes.Sizeof, MockType.Type),
                                        gen => gen.Emit(Inst.Sizeof(MockType.Type))
                                        ));

            yield return(CreateTestCase("refanytype",
                                        gen => gen.Emit(OpCodes.Refanytype),
                                        gen => gen.Emit(Inst.Refanytype())
                                        ));

            yield return(CreateTestCase("readonly.",
                                        gen => gen.Emit(OpCodes.Readonly),
                                        gen => gen.Emit(Inst.Readonly())
                                        ));

            yield break;
        }