test_missing.py | searchcode

/DLR_Main/Languages/IronPython/Tests/test_missing.py

https://bitbucket.org/mdavid/dlr
Python | 248 lines | 191 code | 39 blank | 18 comment | 33 complexity | 22a39a7a68b218d3c571f7680bcb1762 MD5 | raw file

#####################################################################################

#

#  Copyright (c) Microsoft Corporation. All rights reserved.

#

# This source code is subject to terms and conditions of the Apache License, Version 2.0. A

# copy of the license can be found in the License.html file at the root of this distribution. If

# you cannot locate the  Apache License, Version 2.0, please send an email to

# ironpy@microsoft.com. By using this source code in any fashion, you are agreeing to be bound

# by the terms of the Apache License, Version 2.0.

#

# You must not remove this notice, or any other, from this software.

#

#

#####################################################################################



from iptest.assert_util import *



skiptest("silverlight")

skiptest("win32")



# set this flag to True to have the test trace progress

trace = False



skipTypes =  [

    'System.Void',

    'System.ArgIterator',

    'System.RuntimeArgumentHandle',

    'System.TypedReference'

    ]



counter = 1



import clr

import System

import System.IO as IO

import System.Reflection as Reflection

import System.Reflection.Emit as Emit

import System.Runtime.InteropServices as Interop

import System.Diagnostics as Diagnostics

from System.Reflection.Emit import OpCodes



def MakeArray(type, *values):

    a = System.Array.CreateInstance(clr.GetClrType(type), len(values))

    for i in range(len(values)):

        a[i] = values[i]

    return a



class AssemblyGenerator:

    def __init__(self, fileName, ab, mb, sdw):

        self.fileName = fileName

        self.ab = ab

        self.mb = mb

        self.sdw = sdw



    def DefineType(self, name):

        return TypeGenerator(self, self.mb.DefineType(name, Reflection.TypeAttributes.Public))



    def Save(self):

        self.ab.Save(self.fileName, Reflection.PortableExecutableKinds.ILOnly, Reflection.ImageFileMachine.I386);



def CreateAssemblyGenerator(path, name):

    dir = IO.Path.GetDirectoryName(path)

    file = IO.Path.GetFileName(path)



    aname = Reflection.AssemblyName(name)

    domain = System.AppDomain.CurrentDomain

    ab = domain.DefineDynamicAssembly(aname, Emit.AssemblyBuilderAccess.RunAndSave, dir, None)

    mb = ab.DefineDynamicModule(file, file, True);



    ab.DefineVersionInfoResource()



    constructor = clr.GetClrType(Diagnostics.DebuggableAttribute).GetConstructor(MakeArray(System.Type, clr.GetClrType(Diagnostics.DebuggableAttribute.DebuggingModes)))

    attributeValue = MakeArray(System.Object,

        Diagnostics.DebuggableAttribute.DebuggingModes.Default |

        Diagnostics.DebuggableAttribute.DebuggingModes.DisableOptimizations |

        Diagnostics.DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints

    )

    cab = Emit.CustomAttributeBuilder(constructor, attributeValue)



    ab.SetCustomAttribute(cab)

    mb.SetCustomAttribute(cab)



    return AssemblyGenerator(file, ab, mb, None)



class TypeGenerator:

    def __init__(self, ag, tb):

        self.tb = tb

        self.ag = ag



    def DefineMethod(self, name, attributes, returnType, parameterTypes):

        params = MakeArray(System.Type, parameterTypes)

        mb = self.tb.DefineMethod(name, attributes, returnType, params)

        ilg = mb.GetILGenerator()

        return CodeGenerator(self, mb, ilg)



    def CreateType(self):

        return self.tb.CreateType()



class CodeGenerator:

    def __init__(self, tg, mb, ilg):

        self.tg = tg

        self.mb = mb

        self.ilg = ilg

        self.sdw = tg.ag.sdw



def EmitArg(cg, arg):

    cg.ilg.Emit(OpCodes.Ldarg_0)



    TypeCode = System.TypeCode

    

    if arg.IsByRef:

        base = arg.GetElementType()

        if not base.IsValueType:

            cg.ilg.Emit(OpCodes.Ldind_Ref)

        else:

            tc = System.Type.GetTypeCode(base)

            if tc == TypeCode.Int32:

                cg.ilg.Emit(OpCodes.Ldind_I4)

            elif tc == TypeCode.Object:

                cg.ilg.Emit(OpCodes.Ldobj, base)

            elif tc == TypeCode.Boolean:

                cg.ilg.Emit(OpCodes.Ldind_I1)

            elif tc == TypeCode.Byte:

                cg.ilg.Emit(OpCodes.Ldind_U1)

            elif tc == TypeCode.Char:

                cg.ilg.Emit(OpCodes.Ldind_I2)

            elif tc == TypeCode.DateTime:

                cg.ilg.Emit(OpCodes.Ldobj, base)

            elif tc == TypeCode.DBNull: pass

            elif tc == TypeCode.Decimal:

                cg.ilg.Emit(OpCodes.Ldobj, base)

            elif tc == TypeCode.Double:

                cg.ilg.Emit(OpCodes.Ldind_R8)

            #elif tc == TypeCode.Empty: pass

            elif tc == TypeCode.Int16:

                cg.ilg.Emit(OpCodes.Ldind_I2)

            elif tc == TypeCode.Int64:

                cg.ilg.Emit(OpCodes.Ldind_I8)

            elif tc == TypeCode.SByte:

                cg.ilg.Emit(OpCodes.Ldind_I1)

            elif tc == TypeCode.Single:

                cg.ilg.Emit(OpCodes.Ldind_R4)

            #elif tc == TypeCode.String: pass

            elif tc == TypeCode.UInt16:

                cg.ilg.Emit(OpCodes.Ldind_U2)

            elif tc == TypeCode.UInt32:

                cg.ilg.Emit(OpCodes.Ldind_U4)

            elif tc == TypeCode.UInt64:

                cg.ilg.Emit(OpCodes.Ldind_I8)

            else:

                raise AssertionError("Unknown type", arg, base, tc)

            



def EmitTestMethod(tg, name, argType):

    cg = tg.DefineMethod(name, Reflection.MethodAttributes.Public | Reflection.MethodAttributes.Static, str, argType)

    pb = cg.mb.DefineParameter(1, Reflection.ParameterAttributes.In | Reflection.ParameterAttributes.Optional, "o");



    tostring = cg.ilg.DeclareLocal(str)



    baseType = argType

    if baseType.IsByRef:

        baseType = baseType.GetElementType()



    if not baseType.IsValueType:

        is_null = cg.ilg.DefineLabel()

        end = cg.ilg.DefineLabel()

        EmitArg(cg, argType)

        cg.ilg.Emit(OpCodes.Brfalse_S, is_null)

        cg.ilg.BeginExceptionBlock()

        EmitArg(cg, argType)

        cg.ilg.EmitCall(OpCodes.Callvirt, clr.GetClrType(object).GetMethod("ToString"), None)

        cg.ilg.Emit(OpCodes.Stloc, tostring)

        cg.ilg.BeginCatchBlock(clr.GetClrType(System.Exception))

        cg.ilg.Emit(OpCodes.Callvirt, clr.GetClrType(System.Exception).GetMethod("get_Message"))

        cg.ilg.Emit(OpCodes.Stloc, tostring)

        cg.ilg.Emit(OpCodes.Ldstr, "#EXCEPTION#")

        cg.ilg.Emit(OpCodes.Ldloc, tostring)

        cg.ilg.EmitCall(OpCodes.Call, clr.GetClrType(str).GetMethod("Concat", MakeArray(System.Type, clr.GetClrType(System.String), clr.GetClrType(System.String))), None)

        cg.ilg.Emit(OpCodes.Stloc, tostring)

        cg.ilg.EndExceptionBlock()

        cg.ilg.Emit(OpCodes.Br_S, end);

        cg.ilg.MarkLabel(is_null)

        cg.ilg.Emit(OpCodes.Ldstr, "(null)")

        cg.ilg.Emit(OpCodes.Stloc, tostring)

        cg.ilg.MarkLabel(end)

    else:

        cg.ilg.BeginExceptionBlock()

        EmitArg(cg, argType)

        cg.ilg.Emit(OpCodes.Box, baseType);

        cg.ilg.EmitCall(OpCodes.Callvirt, clr.GetClrType(object).GetMethod("ToString"), None)

        cg.ilg.Emit(OpCodes.Stloc, tostring)

        cg.ilg.BeginCatchBlock(clr.GetClrType(System.Exception))

        cg.ilg.Emit(OpCodes.Callvirt, clr.GetClrType(System.Exception).GetMethod("get_Message"))

        cg.ilg.Emit(OpCodes.Stloc, tostring)

        cg.ilg.Emit(OpCodes.Ldstr, "#EXCEPTION#")

        cg.ilg.Emit(OpCodes.Ldloc, tostring)

        cg.ilg.EmitCall(OpCodes.Call, clr.GetClrType(System.String).GetMethod("Concat", MakeArray(System.Type, clr.GetClrType(System.String), clr.GetClrType(System.String))), None)

        cg.ilg.Emit(OpCodes.Stloc, tostring)

        cg.ilg.EndExceptionBlock()



    cg.ilg.Emit(OpCodes.Ldstr, name + "$" + argType.FullName + "$")

    cg.ilg.Emit(OpCodes.Ldloc, tostring)

    cg.ilg.EmitCall(OpCodes.Call, clr.GetClrType(System.String).GetMethod("Concat", MakeArray(System.Type, clr.GetClrType(System.String), clr.GetClrType(System.String))), None)

    if trace:

        cg.ilg.Emit(OpCodes.Dup)

        cg.ilg.EmitCall(OpCodes.Call, clr.GetClrType(System.Console).GetMethod("WriteLine", MakeArray(System.Type, clr.GetClrType(System.String))), None)

    cg.ilg.Emit(OpCodes.Ret)



def GenerateMethods(ag):

    global counter

    tg = ag.DefineType("Abomination")

    

    system_assembly   = clr.LoadAssemblyByName('System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089')

    mscorlib_assembly = clr.LoadAssemblyByName('mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089')



    for ref in (system_assembly, mscorlib_assembly):

        for t in ref.GetExportedTypes():

            if t.ContainsGenericParameters or t.FullName in skipTypes: continue



            if trace: print counter, t.FullName

            EmitTestMethod(tg, "Test_%d" % counter, t)

            EmitTestMethod(tg, "TestRef_%d" % counter, t.MakeByRefType())

            counter += 1



    return tg.CreateType()



def TestCalls(t):

    t = clr.GetPythonType(t)

    for i in range(1, counter):

        n = "Test_%d" % i

        r = getattr(t, n)()

        if trace: print r



        n = "TestRef_%d" % i

        r = getattr(t, n)()

        if trace: print r



# disabled the test for Orcas CLR bug (DDB#66718)

@skip("orcas")

def test_main():

    path = IO.Path.GetTempPath()

    ag = CreateAssemblyGenerator(IO.Path.Combine(path, "MissingTest.dll"), "MissingTest")

    t = GenerateMethods(ag)

    TestCalls(t)

    

    ag.Save()



run_test(__name__)