TestMu 2025 - The Largest Virtual Software Testing Conference is Back | 50,000+ Attendees

How to use compare_types method in Playwright Python

Best Python code snippet using playwright-python

test_builtins.py

Source:test_builtins.py

...43        StypyTypeError.reset_error_msgs()44        TypeWarning.reset_warning_msgs()45    def test_bytearray(self):46        obj = get_builtin_python_type(self.loc, "bytearray")47        compare_types(obj, bytearray)48        obj_instance = invoke(self.loc, obj)49        compare_types(type(obj_instance), bytearray)50        obj_instance = invoke(self.loc, obj, self.int_obj)51        compare_types(type(obj_instance), bytearray)52        obj_instance = invoke(self.loc, obj, self.str_obj)53        compare_types(type(obj_instance), bytearray)54        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")55        obj_instance = invoke(self.loc, obj, list_)56        assert_if_not_error(obj_instance)57        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj)58        assert_if_not_error(obj_instance)59        list_ = self.type_store.get_type_of(Localization(__file__), "int_list")60        obj_instance = invoke(self.loc, obj, list_)61        compare_types(type(obj_instance), bytearray)62        compare_types(type(get_elements_type(obj_instance)), int)63        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list")64        obj_instance = invoke(self.loc, obj, list_)65        compare_types(type(obj_instance), bytearray)66        compare_types(type(get_elements_type(obj_instance)), int)67        self.assertTrue(len(TypeWarning.get_warning_msgs()) == 1)68    def test_all(self):69        obj = get_builtin_python_type_instance(self.loc, "all")70        compare_types(type(obj), types.BuiltinFunctionType)71        obj_instance = invoke(self.loc, obj)72        assert_if_not_error(obj_instance)73        obj_instance = invoke(self.loc, obj, self.int_obj)74        assert_if_not_error(obj_instance)75        obj_instance = invoke(self.loc, obj, self.str_obj)76        compare_types(type(obj_instance), bool)77        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")78        obj_instance = invoke(self.loc, obj, list_)79        compare_types(type(obj_instance), bool)80        list_ = self.type_store.get_type_of(Localization(__file__), "int_list")81        obj_instance = invoke(self.loc, obj, list_)82        compare_types(type(obj_instance), bool)83    def test_set(self):84        obj = get_builtin_python_type(self.loc, "set")85        compare_types(obj, set)86        obj_instance = invoke(self.loc, obj)87        compare_types(obj_instance, set)88        obj_instance = invoke(self.loc, obj, self.int_obj)89        assert_if_not_error(obj_instance)90        obj_instance = invoke(self.loc, obj, self.str_obj)91        compare_types(obj_instance, set)92        compare_types(get_elements_type(obj_instance), str())93        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")94        obj_instance = invoke(self.loc, obj, list_)95        compare_types(get_elements_type(obj_instance), [complex(), str()])96        obj_instance = invoke(self.loc, obj, self.str_obj, self.int_obj)97        assert_if_not_error(obj_instance)98        list_ = self.type_store.get_type_of(Localization(__file__), "int_list")99        obj_instance = invoke(self.loc, obj, list_)100        compare_types(obj_instance, set)101        compare_types(get_elements_type(obj_instance), int())102        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list")103        obj_instance = invoke(self.loc, obj, list_)104        compare_types(obj_instance, set)105        compare_types(get_elements_type(obj_instance), [int(), str()])106    def test_help(self):107        obj = get_builtin_python_type_instance(self.loc, "help")108        assert_equal_type_name(type(obj), "_Helper")109        obj_instance = invoke(self.loc, obj)110        compare_types(type(obj_instance), str)111        obj_instance = invoke(self.loc, obj, self.int_obj)112        compare_types(type(obj_instance), str)113    def test_vars(self):114        t = self.type_store.open_function_context("test_func")115        t.set_type_of(self.loc, "local_1", get_builtin_python_type_instance(self.loc, "int"))116        t.set_type_of(self.loc, "local_2", get_builtin_python_type_instance(self.loc, "str"))117        obj = get_builtin_python_type_instance(self.loc, "vars")118        compare_types(type(obj), types.BuiltinFunctionType)119        obj_instance = invoke(self.loc, obj)120        compare_types(obj_instance, dict)121        compare_types(type(get_values_from_key(obj_instance, "local_1")), int)122        compare_types(type(get_values_from_key(obj_instance, "local_2")), str)123        obj_instance = invoke(self.loc, obj, self.int_obj)124        assert_if_not_error(obj_instance)125        obj_instance = invoke(self.loc, obj, type(self.int_obj))126        compare_types(obj_instance, dict)127        self.assertTrue(len(obj_instance) == 56)128        t.close_function_context()129    def test_bool(self):130        obj = get_builtin_python_type_instance(self.loc, "bool")131        compare_types(type(obj), bool)132        obj = bool133        obj_instance = invoke(self.loc, obj)134        compare_types(type(obj_instance), bool)135        obj_instance = invoke(self.loc, obj, self.int_obj)136        compare_types(type(obj_instance), bool)137        obj_instance = invoke(self.loc, obj, self.str_obj)138        compare_types(type(obj_instance), bool)139        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")140        obj_instance = invoke(self.loc, obj, list_)141        compare_types(type(obj_instance), bool)142        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj)143        assert_if_not_error(obj_instance)144        list_ = self.type_store.get_type_of(Localization(__file__), "int_list")145        obj_instance = invoke(self.loc, obj, list_)146        compare_types(type(obj_instance), bool)147    def test_float(self):148        class Foo:149            def __float__(self, localization):150                return get_builtin_python_type_instance(localization, 'float')151        obj = get_builtin_python_type(self.loc, "float")152        compare_types(obj, float)153        obj_instance = invoke(self.loc, obj)154        compare_types(type(obj_instance), float)155        obj_instance = invoke(self.loc, obj, self.int_obj)156        compare_types(type(obj_instance), float)157        obj_instance = invoke(self.loc, obj, self.str_obj)158        assert_if_not_error(obj_instance)159        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")160        obj_instance = invoke(self.loc, obj, list_)161        assert_if_not_error(obj_instance)162        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj)163        assert_if_not_error(obj_instance)164        param = Foo()165        obj_instance = invoke(self.loc, obj, param)166        compare_types(type(obj_instance), float)167    def test_import(self):168        obj = get_builtin_python_type_instance(self.loc, "__import__")169        compare_types(type(obj), types.BuiltinFunctionType)170        obj_instance = invoke(self.loc, obj, "math")171        compare_types((obj_instance), types.ModuleType)172        obj_instance = invoke(self.loc, obj, self.int_obj)173        assert_if_not_error(obj_instance)174        obj_instance = invoke(self.loc, obj, "math", self.int_obj)175        compare_types((obj_instance), types.ModuleType)176        obj_instance = invoke(self.loc, obj, "math", self.int_obj, self.int_obj)177        compare_types((obj_instance), types.ModuleType)178        obj_instance = invoke(self.loc, obj, "math", self.int_obj, self.int_obj, self.int_obj)179        compare_types((obj_instance), types.ModuleType)180        obj_instance = invoke(self.loc, obj, "math", self.int_obj, self.int_obj, self.int_obj, self.str_obj)181        assert_if_not_error(obj_instance)182    def test_unicode(self):183        class WrongFoo:184            def __str__(self, localization):185                return get_builtin_python_type_instance(localization, 'float')186        class Foo:187            def __str__(self, localization):188                return get_builtin_python_type_instance(localization, 'str')189        obj = get_builtin_python_type(self.loc, "unicode")190        compare_types(obj, unicode)191        obj_instance = invoke(self.loc, obj)192        compare_types(type(obj_instance), unicode)193        obj_instance = invoke(self.loc, obj, self.int_obj)194        compare_types(type(obj_instance), unicode)195        obj_instance = invoke(self.loc, obj, self.str_obj)196        compare_types(type(obj_instance), unicode)197        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")198        obj_instance = invoke(self.loc, obj, list_)199        compare_types(type(obj_instance), unicode)200        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj)201        assert_if_not_error(obj_instance)202        param = Foo()203        obj_instance = invoke(self.loc, obj, param)204        compare_types(type(obj_instance), unicode)205        param = WrongFoo()206        obj_instance = invoke(self.loc, obj, param)207        assert_if_not_error(obj_instance)208    def test_enumerate(self):209        class Foo:210            def __iter__(self, localization):211                t = get_builtin_python_type_instance(localization, "listiterator")212                set_contained_elements_type(localization, t,213                                            get_builtin_python_type_instance(localization, 'float', 3))214                return t215        obj = get_builtin_python_type(self.loc, "enumerate")216        compare_types(obj, enumerate)217        obj_instance = invoke(self.loc, obj)218        assert_if_not_error(obj_instance)219        obj_instance = invoke(self.loc, obj, self.int_obj)220        assert_if_not_error(obj_instance)221        obj_instance = invoke(self.loc, obj, self.str_obj)222        compare_types(obj_instance, enumerate)223        compare_types(get_elements_type(obj_instance), tuple)224        compare_types(get_elements_type(get_elements_type(obj_instance)), [int(), str()])225        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")226        obj_instance = invoke(self.loc, obj, list_)227        compare_types(obj_instance, enumerate)228        compare_types(get_elements_type(obj_instance), tuple)229        compare_types(get_elements_type(get_elements_type(obj_instance)), [int(), complex(), str()])230        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list")231        obj_instance = invoke(self.loc, obj, list_)232        compare_types(obj_instance, enumerate)233        compare_types(get_elements_type(obj_instance), tuple)234        compare_types(get_elements_type(get_elements_type(obj_instance)), [int(), str()])235        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj)236        assert_if_not_error(obj_instance)237        param = Foo()238        obj_instance = invoke(self.loc, obj, param)239        compare_types(obj_instance, enumerate)240        compare_types(get_elements_type(obj_instance), tuple)241        compare_types(get_elements_type(get_elements_type(obj_instance)), [int(), float(3)])242    def test_reduce(self):243        obj = get_builtin_python_type_instance(self.loc, "reduce")244        compare_types(type(obj), types.BuiltinFunctionType)245        obj_instance = invoke(self.loc, obj)246        assert_if_not_error(obj_instance)247        obj_instance = invoke(self.loc, obj, self.int_obj)248        assert_if_not_error(obj_instance)249        def my_func1(localization, *args, **kwargs):250            result = python_operator(localization, '+', args[0], args[1])251            return result252        func = my_func1253        list_ = self.type_store.get_type_of(Localization(__file__), "int_list")254        obj_instance = invoke(self.loc, obj, func, list_)255        compare_types(type(obj_instance), int)256        def my_func2(localization, *args, **kwargs):257            param1 = get_builtin_python_type(localization, "str")258            arg1 = invoke(localization, param1, args[0])259            param1 = get_builtin_python_type(localization, "str")260            arg2 = invoke(localization, param1, args[1])261            result = python_operator(localization, '+', arg1, arg2)262            return result263        func2 = my_func2264        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")265        obj_instance = invoke(self.loc, obj, func2, list_)266        compare_types(type(obj_instance), str)267        def invalid_func(localization, *args, **kwargs):268            raise Exception("This always fails")269        func3 = invalid_func270        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")271        obj_instance = invoke(self.loc, obj, func3, list_)272        assert_if_not_error(obj_instance)273        initial = get_builtin_python_type_instance(self.loc, "int")274        list_ = self.type_store.get_type_of(Localization(__file__), "int_list")275        obj_instance = invoke(self.loc, obj, func, list_, initial)276        compare_types(type(obj_instance), int)277        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")278        obj_instance = invoke(self.loc, obj, func2, list_, initial)279        compare_types(type(obj_instance), str)280        initial2 = get_builtin_python_type_instance(self.loc, "str")281        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")282        obj_instance = invoke(self.loc, obj, func2, list_, initial2)283        compare_types(type(obj_instance), str)284    def test_list(self):285        obj = get_builtin_python_type(self.loc, "list")286        compare_types(obj, list)287        obj_instance = invoke(self.loc, obj)288        compare_types(obj_instance, list)289        obj_instance = invoke(self.loc, obj, self.int_obj)290        assert_if_not_error(obj_instance)291        obj_instance = invoke(self.loc, obj, self.str_obj)292        compare_types(obj_instance, list)293        compare_types(type(get_elements_type(obj_instance)), str)294        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")295        obj_instance = invoke(self.loc, obj, list_)296        compare_types((get_elements_type(obj_instance)), [complex(), str()])297        obj_instance = invoke(self.loc, obj, self.str_obj, self.int_obj)298        assert_if_not_error(obj_instance)299        list_ = self.type_store.get_type_of(Localization(__file__), "int_list")300        obj_instance = invoke(self.loc, obj, list_)301        compare_types((obj_instance), list)302        compare_types(type(get_elements_type(obj_instance)), int)303        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list")304        obj_instance = invoke(self.loc, obj, list_)305        compare_types((obj_instance), list)306        compare_types((get_elements_type(obj_instance)), [int(), str()])307    def test_coerce(self):308        obj = get_builtin_python_type_instance(self.loc, "coerce")309        compare_types(type(obj), types.BuiltinFunctionType)310        obj_instance = invoke(self.loc, obj)311        assert_if_not_error(obj_instance)312        obj_instance = invoke(self.loc, obj, self.int_obj)313        assert_if_not_error(obj_instance)314        obj_instance = invoke(self.loc, obj, self.str_obj)315        assert_if_not_error(obj_instance)316        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")317        obj_instance = invoke(self.loc, obj, list_)318        assert_if_not_error(obj_instance)319        list_ = self.type_store.get_type_of(Localization(__file__), "int_list")320        obj_instance = invoke(self.loc, obj, list_)321        assert_if_not_error(obj_instance)322        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj)323        compare_types(obj_instance, tuple)324        compare_types(type(get_elements_type(obj_instance)), int)325        obj_instance = invoke(self.loc, obj, self.int_obj, self.float_obj)326        compare_types(obj_instance, tuple)327        compare_types(get_elements_type(obj_instance), [self.int_obj, self.float_obj])328        obj_instance = invoke(self.loc, obj, self.int_obj, self.str_obj)329        assert_if_not_error(obj_instance)330    def test_intern(self):331        obj = get_builtin_python_type_instance(self.loc, "intern")332        compare_types(type(obj), types.BuiltinFunctionType)333        obj_instance = invoke(self.loc, obj)334        assert_if_not_error(obj_instance)335        obj_instance = invoke(self.loc, obj, self.int_obj)336        assert_if_not_error(obj_instance)337        obj_instance = invoke(self.loc, obj, self.str_obj)338        compare_types(type(obj_instance), str)339    def test_globals(self):340        t = Context(None, __file__)341        t.set_type_of(self.loc, "global_1", get_builtin_python_type_instance(self.loc, "int"))342        t.set_type_of(self.loc, "global_2", get_builtin_python_type_instance(self.loc, "str"))343        obj = get_builtin_python_type_instance(self.loc, "globals")344        compare_types(type(obj), types.BuiltinFunctionType)345        obj_instance = invoke(self.loc, obj)346        compare_types(obj_instance, dict)347        #compare_types(obj_instance.wrapped_type['__builtins__'], dict)348        compare_types(obj_instance.wrapped_type['__doc__'], None)349        compare_types(obj_instance.wrapped_type['__name__'], str())350        compare_types(obj_instance.wrapped_type['__package__'], None)351        compare_types(obj_instance.wrapped_type['global_1'], int())352        compare_types(obj_instance.wrapped_type['global_2'], str())353    def test_issubclass(self):354        obj = get_builtin_python_type_instance(self.loc, "issubclass")355        compare_types(type(obj), types.BuiltinFunctionType)356        obj_instance = invoke(self.loc, obj)357        assert_if_not_error(obj_instance)358        type1 = int359        type2 = complex360        obj_instance = invoke(self.loc, obj, type1, type2)361        compare_types(type(obj_instance), bool)362        instance1 = get_builtin_python_type_instance(self.loc, "int")363        instance2 = get_builtin_python_type_instance(self.loc, "complex")364        obj_instance = invoke(self.loc, obj, instance1, instance2)365        assert_if_not_error(obj_instance)366    def test_divmod(self):367        obj = get_builtin_python_type_instance(self.loc, "divmod")368        compare_types(type(obj), types.BuiltinFunctionType)369        obj_instance = invoke(self.loc, obj)370        assert_if_not_error(obj_instance)371        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj)372        compare_types(obj_instance, tuple)373        compare_types(type(get_elements_type(obj_instance)), int)374        obj_instance = invoke(self.loc, obj, self.int_obj, self.float_obj)375        compare_types(obj_instance, tuple)376        compare_types(type(get_elements_type(obj_instance)), float)377    def test_file(self):378        obj = file #get_builtin_python_type_instance(self.loc, "file")379        obj_instance = invoke(self.loc, obj)380        assert_if_not_error(obj_instance)381        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj)382        assert_if_not_error(obj_instance)383        obj_instance = invoke(self.loc, obj, self.str_obj)384        compare_types(type(obj_instance), file)385        obj_instance = invoke(self.loc, obj, self.str_obj, self.str_obj)386        compare_types(type(obj_instance), file)387        obj_instance = invoke(self.loc, obj, self.str_obj, self.str_obj, self.int_obj)388        compare_types(type(obj_instance), file)389        class Foo:390            def __trunc__(self, localization):391                return get_builtin_python_type_instance(localization, "int")392        trunc_instance = Foo()393        obj_instance = invoke(self.loc, obj, self.str_obj, self.str_obj, trunc_instance)394        compare_types(type(obj_instance), file)395    def test_unichr(self):396        obj = get_builtin_python_type_instance(self.loc, "unichr")397        compare_types(type(obj), types.BuiltinFunctionType)398        obj_instance = invoke(self.loc, obj)399        assert_if_not_error(obj_instance)400        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj)401        assert_if_not_error(obj_instance)402        obj_instance = invoke(self.loc, obj, self.int_obj)403        compare_types(type(obj_instance), unicode)404        class Foo:405            def __trunc__(self, localization):406                return get_builtin_python_type_instance(localization, "int")407        trunc_instance = Foo()408        obj_instance = invoke(self.loc, obj, trunc_instance)409        compare_types(type(obj_instance), unicode)410    def test_apply(self):411        class Foo1:412            def __call__(self, localization):413                return get_builtin_python_type_instance(None, "int")414        instance1 = Foo1()415        class Foo2:416            def __call__(self, localization, param):417                return get_builtin_python_type_instance(None, type(param).__name__)418        class Foo2b:419            def __call__(self, localization, param, param2):420                return get_builtin_python_type_instance(None, type(param2).__name__)421        instance2 = Foo2()422        instance2b = Foo2b()423        class Foo3:424            def __call__(self, localization, *param):425                return param[-1]426        instance3 = Foo3()427        apply_func = get_builtin_python_type_instance(self.loc, "apply")428        compare_types(type(apply_func), types.BuiltinFunctionType)429        obj_instance = invoke(self.loc, apply_func)430        assert_if_not_error(obj_instance)431        obj_instance = invoke(self.loc, apply_func, instance1)432        compare_types(type(obj_instance), int)433        tuple_ = get_builtin_python_type(self.loc, "tuple")434        types_ = get_builtin_python_type_instance(self.loc, "list")435        set_contained_elements_type(self.loc, types_, self.float_obj)436        tuple_ = invoke(self.loc, tuple_, types_)437        obj_instance = invoke(self.loc, apply_func, instance2, tuple_)438        compare_types(type(obj_instance), float)439        obj_instance = invoke(self.loc, apply_func, instance2b, tuple_)440        compare_types(type(obj_instance), float)441        dict_ = get_builtin_python_type_instance(self.loc, "dict")442        add_key_and_value_type(dict_, self.str_obj, self.int_obj)443        obj_instance = invoke(self.loc, apply_func, instance3, tuple_, dict_)444        compare_types(obj_instance, dict)445        builtins = load_builtin_operators_module()446        add = self.type_store.get_type_of_member(self.loc, builtins, "add")447        obj_instance = invoke(self.loc, apply_func, add, tuple_)448        compare_types(type(obj_instance), float)449    def test_isinstance(self):450        obj = get_builtin_python_type_instance(self.loc, "isinstance")451        compare_types(type(obj), types.BuiltinFunctionType)452        obj_instance = invoke(self.loc, obj)453        assert_if_not_error(obj_instance)454        obj_instance = invoke(self.loc, obj, self.int_obj, int)455        compare_types(type(obj_instance), bool)456        obj_instance = invoke(self.loc, obj, self.str_obj, str)457        compare_types(type(obj_instance), bool)458        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")459        obj_instance = invoke(self.loc, obj, list_, list)460        compare_types(type(obj_instance), bool)461        list_ = self.type_store.get_type_of(Localization(__file__), "int_list")462        obj_instance = invoke(self.loc, obj, list_, tuple)463        compare_types(type(obj_instance), bool)464    def test_next(self):465        obj = get_builtin_python_type_instance(self.loc, "next")466        compare_types(type(obj), types.BuiltinFunctionType)467        obj_instance = invoke(self.loc, obj)468        assert_if_not_error(obj_instance)469        obj_instance = invoke(self.loc, obj, self.int_obj)470        assert_if_not_error(obj_instance)471        obj_instance = invoke(self.loc, obj, self.str_obj)472        assert_if_not_error(obj_instance)473        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")474        iter_list_call = self.type_store.get_type_of_member(self.loc, list_, "__iter__")475        iter_list = invoke(self.loc, iter_list_call)476        compare_types(iter_list, ExtraTypeDefinitions.listiterator)477        obj_instance = invoke(self.loc, obj, list_)478        assert_if_not_error(obj_instance)479        obj_instance = invoke(self.loc, obj, iter_list)480        compare_types(obj_instance, [complex(), str()])481        obj_instance = invoke(self.loc, obj, iter_list, self.float_obj)482        compare_types(obj_instance, [complex(), str(), float(3.14)])483        list_ = self.type_store.get_type_of(Localization(__file__), "int_list")484        iter_list_call = self.type_store.get_type_of_member(self.loc, list_, "__iter__")485        iter_list = invoke(self.loc, iter_list_call)486        compare_types(iter_list, ExtraTypeDefinitions.listiterator)487        obj_instance = invoke(self.loc, obj, list_)488        assert_if_not_error(obj_instance)489        obj_instance = invoke(self.loc, obj, iter_list)490        compare_types(type(obj_instance), int)491        obj_instance = invoke(self.loc, obj, iter_list, self.float_obj)492        compare_types(obj_instance, [int(), float(3.14)])493    def test_any(self):494        obj = get_builtin_python_type_instance(self.loc, "any")495        compare_types(type(obj), types.BuiltinFunctionType)496        obj_instance = invoke(self.loc, obj)497        assert_if_not_error(obj_instance)498        obj_instance = invoke(self.loc, obj, self.int_obj)499        assert_if_not_error(obj_instance)500        obj_instance = invoke(self.loc, obj, self.str_obj)501        assert_if_not_error(obj_instance)502        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")503        obj_instance = invoke(self.loc, obj, list_)504        compare_types(type(obj_instance), bool)505    def test_locals(self):506        context = self.type_store.open_function_context("test_func2")507        context.set_type_of(self.loc, "local_1", get_builtin_python_type_instance(self.loc, "int"))508        context.set_type_of(self.loc, "local_2", get_builtin_python_type_instance(self.loc, "str"))509        obj = get_builtin_python_type_instance(self.loc, "locals")510        compare_types(type(obj), types.BuiltinFunctionType)511        obj_instance = invoke(self.loc, obj)512        compare_types(obj_instance, dict)513        compare_types(type(obj_instance.wrapped_type['local_1']), int)514        compare_types(type(obj_instance.wrapped_type['local_2']), str)515        self.type_store.close_function_context()516    def test_filter(self):517        obj = get_builtin_python_type_instance(self.loc, "filter")518        compare_types(type(obj), types.BuiltinFunctionType)519        obj_instance = invoke(self.loc, obj)520        assert_if_not_error(obj_instance)521        obj_instance = invoke(self.loc, obj, self.int_obj)522        assert_if_not_error(obj_instance)523        obj_instance = invoke(self.loc, obj, self.str_obj)524        assert_if_not_error(obj_instance)525        def my_func1(localization, *args, **kwargs):526            return False527        func1 = my_func1528        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")529        obj_instance = invoke(self.loc, obj, func1, list_)530        compare_types(obj_instance, list)531        compare_types(get_elements_type(obj_instance), [complex(), str()])532        obj_instance = invoke(self.loc, obj, func1, self.str_obj)533        compare_types(obj_instance, list)534        compare_types(get_elements_type(obj_instance), str())535    def test_slice(self):536        obj = get_builtin_python_type(self.loc, "slice")537        compare_types(obj, slice)538        obj_instance = invoke(self.loc, obj)539        assert_if_not_error(obj_instance)540        obj_instance = invoke(self.loc, obj, self.int_obj)541        compare_types(get_elements_type(obj_instance), [int(), types.NoneType])542        obj_instance = invoke(self.loc, obj, self.str_obj)543        compare_types(get_elements_type(obj_instance), [str(), types.NoneType])544        def my_func1(localization, *args, **kwargs):545            return False546        func1 = my_func1547        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")548        obj_instance = invoke(self.loc, obj, func1, list_)549        compare_types(obj_instance, slice)550        compare_types(get_elements_type(obj_instance), [list_, False])551        obj_instance = invoke(self.loc, obj, func1, self.str_obj)552        compare_types(obj_instance, slice)553        compare_types(get_elements_type(obj_instance), [str(), False])554    def test_copyright(self):555        obj = get_builtin_python_type(self.loc, "copyright")556        assert_equal_type_name(type(obj), "_Printer")557        obj_instance = invoke(self.loc, obj)558        compare_types(type(obj_instance), types.NoneType)559        obj_instance = invoke(self.loc, obj, self.int_obj)560        assert_if_not_error(obj_instance)561    def test_min(self):562        obj = get_builtin_python_type_instance(self.loc, "min")563        compare_types(type(obj), types.BuiltinFunctionType)564        obj_instance = invoke(self.loc, obj)565        assert_if_not_error(obj_instance)566        obj_instance = invoke(self.loc, obj, self.int_obj)567        assert_if_not_error(obj_instance)568        obj_instance = invoke(self.loc, obj, self.str_obj)569        compare_types(type(obj_instance), str)570        obj_instance = invoke(self.loc, obj, self.int_obj, self.float_obj)571        compare_types(obj_instance, [self.int_obj, self.float_obj])572        obj_instance = invoke(self.loc, obj, self.int_obj, self.float_obj, self.int_obj, self.float_obj, self.int_obj,573                              self.float_obj, self.int_obj, self.float_obj)574        compare_types(obj_instance, [int(), float()])575        tuple_ = get_builtin_python_type_instance(self.loc, "tuple")576        set_contained_elements_type(self.loc, tuple_, self.float_obj)577        obj_instance = invoke(self.loc, obj, tuple_)578        compare_types(type(obj_instance), float)579        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")580        obj_instance = invoke(self.loc, obj, list_)581        compare_types(obj_instance, [complex(), str()])582        list_ = self.type_store.get_type_of(Localization(__file__), "int_list")583        obj_instance = invoke(self.loc, obj, list_)584        compare_types(type(obj_instance), int)585        def func(localization, *args, **kwargs):586            return get_builtin_python_type_instance(localization, "int")587        dict = {'key': func}588        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")589        obj_instance = invoke(self.loc, obj, list_, **dict)590        compare_types(obj_instance, [complex(), str()])591    def test_open(self):592        obj = get_builtin_python_type_instance(self.loc, "open")593        compare_types(type(obj), types.BuiltinFunctionType)594        obj_instance = invoke(self.loc, obj)595        assert_if_not_error(obj_instance)596        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj)597        assert_if_not_error(obj_instance)598        obj_instance = invoke(self.loc, obj, self.str_obj)599        compare_types(type(obj_instance), file)600        obj_instance = invoke(self.loc, obj, self.str_obj, self.str_obj)601        compare_types(type(obj_instance), file)602        obj_instance = invoke(self.loc, obj, self.str_obj, self.str_obj, self.int_obj)603        compare_types(type(obj_instance), file)604        class Foo:605            def __trunc__(self, localization):606                return get_builtin_python_type_instance(localization, "int")607        trunc_instance = Foo()608        obj_instance = invoke(self.loc, obj, self.str_obj, self.str_obj, trunc_instance)609        compare_types(type(obj_instance), file)610    def test_sum(self):611        obj = get_builtin_python_type_instance(self.loc, "sum")612        compare_types(type(obj), types.BuiltinFunctionType)613        obj_instance = invoke(self.loc, obj)614        assert_if_not_error(obj_instance)615        obj_instance = invoke(self.loc, obj, self.int_obj)616        assert_if_not_error(obj_instance)617        class Foo:618            def __add__(self, localization, other):619                return get_builtin_python_type_instance(localization, "int")620        list_ = self.type_store.get_type_of(Localization(__file__), "int_list")621        obj_instance = invoke(self.loc, obj, list_)622        compare_types(type(obj_instance), int)623        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")624        obj_instance = invoke(self.loc, obj, list_)625        assert_if_not_error(obj_instance)626        instance = Foo()627        list_ = get_builtin_python_type_instance(self.loc, "list")628        set_contained_elements_type(self.loc, list_, instance)629        obj_instance = invoke(self.loc, obj, list_)630        assert_if_not_error(obj_instance)631        obj_instance = invoke(self.loc, obj, list_, self.int_obj)632        assert_if_not_error(obj_instance)633    def test_chr(self):634        obj = get_builtin_python_type_instance(self.loc, "chr")635        compare_types(type(obj), types.BuiltinFunctionType)636        obj_instance = invoke(self.loc, obj)637        assert_if_not_error(obj_instance)638        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj)639        assert_if_not_error(obj_instance)640        obj_instance = invoke(self.loc, obj, self.int_obj)641        compare_types(type(obj_instance), str)642        obj_instance = invoke(self.loc, obj, self.int_obj, self.str_obj)643        assert_if_not_error(obj_instance)644        class Foo:645            def __trunc__(self, localization):646                return get_builtin_python_type_instance(localization, "int")647        trunc_instance = Foo()648        obj_instance = invoke(self.loc, obj, trunc_instance)649        compare_types(type(obj_instance), str)650    def test_hex(self):651        obj = get_builtin_python_type_instance(self.loc, "hex")652        compare_types(type(obj), types.BuiltinFunctionType)653        obj_instance = invoke(self.loc, obj)654        assert_if_not_error(obj_instance)655        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj)656        assert_if_not_error(obj_instance)657        obj_instance = invoke(self.loc, obj, self.int_obj)658        compare_types(type(obj_instance), str)659        obj_instance = invoke(self.loc, obj, self.int_obj, self.str_obj)660        assert_if_not_error(obj_instance)661        class Foo:662            def __hex__(self, localization):663                return get_builtin_python_type_instance(localization, "int")664        class Foo2:665            def __hex__(self, localization):666                return get_builtin_python_type_instance(localization, "str")667        hex_instance = Foo()668        obj_instance = invoke(self.loc, obj, hex_instance)669        assert_if_not_error(obj_instance)670        hex_instance = Foo2()671        obj_instance = invoke(self.loc, obj, hex_instance)672        compare_types(type(obj_instance), str)673    def test_execfile(self):674        obj = get_builtin_python_type_instance(self.loc, "execfile")675        compare_types(type(obj), types.BuiltinFunctionType)676        obj_instance = invoke(self.loc, obj)677        assert_if_not_error(obj_instance)678        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj)679        assert_if_not_error(obj_instance)680        obj_instance = invoke(self.loc, obj, self.str_obj)681        compare_types(type(obj_instance), DynamicType)682        dict_ = get_builtin_python_type_instance(self.loc, "dict")683        obj_instance = invoke(self.loc, obj, self.str_obj, dict_)684        compare_types(type(obj_instance), DynamicType)685        obj_instance = invoke(self.loc, obj, self.str_obj, dict_, dict_)686        compare_types(type(obj_instance), DynamicType)687    def test_long(self):688        obj = get_builtin_python_type(self.loc, "long")689        compare_types(obj, types.LongType)690        obj_instance = invoke(self.loc, obj)691        compare_types(type(obj_instance), long)692        obj_instance = invoke(self.loc, obj, self.float_obj)693        compare_types(type(obj_instance), long)694        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj)695        compare_types(type(obj_instance), long)696        obj_instance = invoke(self.loc, obj, self.float_obj, self.int_obj)697        compare_types(type(obj_instance), long)698        obj_instance = invoke(self.loc, obj, self.float_obj, self.float_obj)699        assert_if_not_error(obj_instance)700        obj_instance = invoke(self.loc, obj, self.str_obj)701        assert_if_not_error(obj_instance)702        obj_instance = invoke(self.loc, obj, self.int_obj, self.str_obj)703        assert_if_not_error(obj_instance)704        class Foo:705            def __trunc__(self, localization):706                return get_builtin_python_type_instance(localization, "int")707        trunc_instance = Foo()708        obj_instance = invoke(self.loc, obj, trunc_instance)709        compare_types(type(obj_instance), long)710        obj_instance = invoke(self.loc, obj, self.int_obj, trunc_instance)711        compare_types(type(obj_instance), long)712        obj_instance = invoke(self.loc, obj, trunc_instance, trunc_instance)713        compare_types(type(obj_instance), long)714    def test_id(self):715        obj = get_builtin_python_type_instance(self.loc, "id")716        compare_types(type(obj), types.BuiltinFunctionType)717        obj_instance = invoke(self.loc, obj)718        assert_if_not_error(obj_instance)719        type1 = int720        type2 = complex721        obj_instance = invoke(self.loc, obj, type1)722        compare_types(type(obj_instance), long)723        obj_instance = invoke(self.loc, obj, type2)724        compare_types(type(obj_instance), long)725        instance1 = get_builtin_python_type_instance(self.loc, "int")726        instance2 = get_builtin_python_type_instance(self.loc, "complex")727        obj_instance = invoke(self.loc, obj, instance1)728        compare_types(type(obj_instance), long)729        obj_instance = invoke(self.loc, obj, instance2)730        compare_types(type(obj_instance), long)731    def test_xrange(self):732        obj = get_builtin_python_type_instance(self.loc, "xrange")733        compare_types(obj, types.XRangeType)734        obj_instance = invoke(self.loc, obj)735        assert_if_not_error(obj_instance)736        obj_instance = invoke(self.loc, obj, self.float_obj)737        assert_if_not_error(obj_instance)738        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj)739        compare_types(obj_instance, xrange)740        compare_types(type(get_elements_type(obj_instance)), int)741        obj_instance = invoke(self.loc, obj, self.float_obj, self.int_obj)742        assert_if_not_error(obj_instance)743        obj_instance = invoke(self.loc, obj, self.float_obj, self.float_obj)744        assert_if_not_error(obj_instance)745        obj_instance = invoke(self.loc, obj, self.str_obj)746        assert_if_not_error(obj_instance)747        obj_instance = invoke(self.loc, obj, self.int_obj, self.str_obj)748        assert_if_not_error(obj_instance)749        class Foo:750            def __trunc__(self, localization):751                return get_builtin_python_type_instance(localization, "int")752        trunc_instance = Foo()753        obj_instance = invoke(self.loc, obj, trunc_instance)754        compare_types(obj_instance, xrange)755        compare_types(type(get_elements_type(obj_instance)), int)756        obj_instance = invoke(self.loc, obj, self.int_obj, trunc_instance)757        compare_types(obj_instance, xrange)758        compare_types(type(get_elements_type(obj_instance)), int)759        obj_instance = invoke(self.loc, obj, trunc_instance, trunc_instance)760        compare_types(obj_instance, xrange)761        compare_types(type(get_elements_type(obj_instance)), int)762    def test_int(self):763        obj = get_builtin_python_type(self.loc, "int")764        compare_types((obj), types.IntType)765        obj_instance = invoke(self.loc, obj)766        compare_types(type(obj_instance), int)767        obj_instance = invoke(self.loc, obj, self.float_obj)768        compare_types(type(obj_instance), int)769        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj)770        compare_types(type(obj_instance), int)771        obj_instance = invoke(self.loc, obj, self.float_obj, self.int_obj)772        compare_types(type(obj_instance), int)773        obj_instance = invoke(self.loc, obj, self.float_obj, self.float_obj)774        assert_if_not_error(obj_instance)775        obj_instance = invoke(self.loc, obj, self.str_obj)776        assert_if_not_error(obj_instance)777        obj_instance = invoke(self.loc, obj, self.int_obj, self.str_obj)778        assert_if_not_error(obj_instance)779        class Foo:780            def __trunc__(self, localization):781                return get_builtin_python_type_instance(localization, "int")782        trunc_instance = Foo()783        obj_instance = invoke(self.loc, obj, trunc_instance)784        compare_types(type(obj_instance), int)785        obj_instance = invoke(self.loc, obj, self.int_obj, trunc_instance)786        compare_types(type(obj_instance), int)787        obj_instance = invoke(self.loc, obj, trunc_instance, trunc_instance)788        compare_types(type(obj_instance), int)789    def test_getattr(self):790        obj = get_builtin_python_type_instance(self.loc, "getattr")791        compare_types(type(obj), types.BuiltinFunctionType)792        obj_instance = invoke(self.loc, obj)793        assert_if_not_error(obj_instance)794        obj_instance = invoke(self.loc, obj, self.int_obj)795        assert_if_not_error(obj_instance)796        class Foo:797            def __add__(self, localization, other):798                return get_builtin_python_type_instance(localization, "int")799        Foo.attclass = int800        foo_inst = Foo()801        foo_inst.attinst = str802        class_ = Foo803        instance = foo_inst804        val1 = get_builtin_python_type_instance(self.loc, "str", "attclass")805        val2 = get_builtin_python_type_instance(self.loc, "str", "attinst")806        val3 = get_builtin_python_type_instance(self.loc, "str", "not_exist")807        val4 = get_builtin_python_type_instance(self.loc, "str")808        obj_instance = invoke(self.loc, obj, class_, val1)809        compare_types(obj_instance, int)810        obj_instance = invoke(self.loc, obj, class_, val2)811        assert_if_not_error(obj_instance)812        obj_instance = invoke(self.loc, obj, class_, val3)813        assert_if_not_error(obj_instance)814        obj_instance = invoke(self.loc, obj, class_, val4)815        compare_types(obj_instance, [Foo.__add__, str(), int])816        obj_instance = invoke(self.loc, obj, instance, val1)817        compare_types(obj_instance, int)818        obj_instance = invoke(self.loc, obj, instance, val2)819        compare_types(obj_instance, str)820        obj_instance = invoke(self.loc, obj, instance, val3)821        assert_if_not_error(obj_instance)822        obj_instance = invoke(self.loc, obj, instance, val4)823        compare_types(obj_instance, [foo_inst.__add__, str, str(), int])824    def test_abs(self):825        class Foo:826            def __abs__(self, localization):827                return get_builtin_python_type_instance(localization, 'int')828        obj = get_builtin_python_type_instance(self.loc, "abs")829        compare_types(type(obj), types.BuiltinFunctionType)830        obj_instance = invoke(self.loc, obj)831        assert_if_not_error(obj_instance)832        obj_instance = invoke(self.loc, obj, self.int_obj)833        compare_types(type(obj_instance), int)834        complex_inst = get_builtin_python_type_instance(self.loc, "complex")835        obj_instance = invoke(self.loc, obj, complex_inst)836        compare_types(type(obj_instance), float)837        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")838        obj_instance = invoke(self.loc, obj, list_)839        assert_if_not_error(obj_instance)840        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj)841        assert_if_not_error(obj_instance)842        param = Foo()843        obj_instance = invoke(self.loc, obj, param)844        compare_types(type(obj_instance), int)845    def test_exit(self):846        obj = get_builtin_python_type(self.loc, "exit")847        assert_equal_type_name(type(obj), "Quitter")848        obj_instance = invoke(self.loc, obj)849        compare_types(obj_instance, undefined_type.UndefinedType)850        obj_instance = invoke(self.loc, obj, self.int_obj)851        compare_types(obj_instance, undefined_type.UndefinedType)852        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")853        obj_instance = invoke(self.loc, obj, list_)854        compare_types(obj_instance, undefined_type.UndefinedType)855        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj)856        assert_if_not_error(obj_instance)857    def test_pow(self):858        obj = get_builtin_python_type_instance(self.loc, "pow")859        compare_types(type(obj), types.BuiltinFunctionType)860        obj_instance = invoke(self.loc, obj)861        assert_if_not_error(obj_instance)862        obj_instance = invoke(self.loc, obj, self.int_obj)863        assert_if_not_error(obj_instance)864        class Foo:865            def __pow__(self, localization, other, another):866                return get_builtin_python_type_instance(localization, "int")867        complex_inst = get_builtin_python_type_instance(self.loc, "complex")868        obj_instance = invoke(self.loc, obj, complex_inst, self.int_obj)869        compare_types(type(obj_instance), types.ComplexType)870        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj)871        compare_types(type(obj_instance), int)872        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")873        obj_instance = invoke(self.loc, obj, list_, list_)874        assert_if_not_error(obj_instance)875        instance = instance = Foo()876        obj_instance = invoke(self.loc, obj, instance, self.int_obj, self.int_obj)877        compare_types(type(obj_instance), int)878        bool_inst = get_builtin_python_type_instance(self.loc, "bool")879        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj, bool_inst)880        compare_types(type(obj_instance), int)881        long_inst = get_builtin_python_type_instance(self.loc, "long")882        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj, long_inst)883        compare_types(type(obj_instance), long)884    def test_input(self):885        obj = get_builtin_python_type_instance(self.loc, "input")886        assert_equal_type_name(obj, "input")887        obj_instance = invoke(self.loc, obj)888        compare_types((obj_instance), DynamicType)889        obj_instance = invoke(self.loc, obj, self.int_obj)890        compare_types((obj_instance), DynamicType)891        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")892        obj_instance = invoke(self.loc, obj, list_)893        compare_types((obj_instance), DynamicType)894        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj)895        assert_if_not_error(obj_instance)896    def test_type(self):897        obj = get_builtin_python_type_instance(self.loc, "type")898        assert_equal_type_name(obj, "type")899        obj_instance = invoke(self.loc, obj)900        assert_if_not_error(obj_instance)901        obj_instance = invoke(self.loc, obj, self.int_obj)902        compare_types(obj_instance, int)903        obj_instance = invoke(self.loc, obj, self.str_obj)904        compare_types(obj_instance, str)905        class Foo:906            def __pow__(self, localization, other, another):907                return get_builtin_python_type_instance(localization, "int")908        complex_inst = get_builtin_python_type_instance(self.loc, "complex")909        obj_instance = invoke(self.loc, obj, complex_inst)910        compare_types(obj_instance, types.ComplexType)911        obj_instance = invoke(self.loc, obj, self.int_obj)912        compare_types(obj_instance, int)913        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")914        obj_instance = invoke(self.loc, obj, list_, list_)915        assert_if_not_error(obj_instance)916        obj_instance = invoke(self.loc, obj, list_)917        compare_types(obj_instance, list)918        instance = Foo()919        obj_instance = invoke(self.loc, obj, instance)920        compare_types(obj_instance, type(Foo()))921        bool_inst = get_builtin_python_type_instance(self.loc, "bool")922        obj_instance = invoke(self.loc, obj, bool_inst)923        compare_types(obj_instance, bool)924        long_inst = get_builtin_python_type_instance(self.loc, "long")925        obj_instance = invoke(self.loc, obj, long_inst)926        compare_types(obj_instance, long)927        type_inst = get_builtin_python_type_instance(self.loc, "type")928        obj_instance = invoke(self.loc, obj, type_inst)929        compare_types(obj_instance, types.TypeType)930    def test_oct(self):931        obj = get_builtin_python_type_instance(self.loc, "oct")932        compare_types(type(obj), types.BuiltinFunctionType)933        obj_instance = invoke(self.loc, obj)934        assert_if_not_error(obj_instance)935        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj)936        assert_if_not_error(obj_instance)937        obj_instance = invoke(self.loc, obj, self.int_obj)938        compare_types(type(obj_instance), str)939        obj_instance = invoke(self.loc, obj, self.int_obj, self.str_obj)940        assert_if_not_error(obj_instance)941        class Foo:942            def __oct__(self, localization):943                return get_builtin_python_type_instance(localization, "int")944        class Foo2:945            def __oct__(self, localization):946                return get_builtin_python_type_instance(localization, "str")947        hex_instance = Foo()948        obj_instance = invoke(self.loc, obj, hex_instance)949        assert_if_not_error(obj_instance)950        hex_instance = Foo2()951        obj_instance = invoke(self.loc, obj, hex_instance)952        compare_types(type(obj_instance), str)953    def test_bin(self):954        obj = get_builtin_python_type_instance(self.loc, "bin")955        compare_types(type(obj), types.BuiltinFunctionType)956        obj_instance = invoke(self.loc, obj)957        assert_if_not_error(obj_instance)958        bool_inst = get_builtin_python_type_instance(self.loc, "bool")959        obj_instance = invoke(self.loc, obj, bool_inst)960        compare_types(type(obj_instance), str)961        long_inst = get_builtin_python_type_instance(self.loc, "long")962        obj_instance = invoke(self.loc, obj, long_inst)963        compare_types(type(obj_instance), str)964    def test_map(self):965        obj = get_builtin_python_type(self.loc, "map")966        compare_types(type(obj), types.BuiltinFunctionType)967        obj_instance = invoke(self.loc, obj)968        assert_if_not_error(obj_instance)969        obj_instance = invoke(self.loc, obj, self.int_obj)970        assert_if_not_error(obj_instance)971        list_ = self.type_store.get_type_of(Localization(__file__), "int_list")972        obj_instance = invoke(self.loc, obj, self.int_obj, list_)973        assert_if_not_error(obj_instance)974        func = get_builtin_python_type(self.loc, 'str')975        list_ = self.type_store.get_type_of(Localization(__file__), "int_list")976        obj_instance = invoke(self.loc, obj, func, list_)977        compare_types(obj_instance, list)978        compare_types(type(get_elements_type(obj_instance)), str)979        def my_func1(localization, *args, **kwargs):980            param1 = get_builtin_python_type(localization, "str")981            result = invoke(localization, param1, args[0])982            return result983        func = my_func1984        list_ = self.type_store.get_type_of(Localization(__file__), "int_list")985        obj_instance = invoke(self.loc, obj, func, list_)986        compare_types(obj_instance, list)987        compare_types(type(get_elements_type(obj_instance)), str)988        def my_func2(localization, *args, **kwargs):989            param2 = get_builtin_python_type_instance(localization, "int")990            result = python_operator(localization, '/', args[0], param2)991            return result992        func2 = my_func2993        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")994        obj_instance = invoke(self.loc, obj, func2, list_)995        compare_types(obj_instance, list)996        compare_types(type(get_elements_type(obj_instance)), complex)997        def invalid_func(localization, *args, **kwargs):998            return StypyTypeError(localization, "This always fails")999        func3 = invalid_func1000        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")1001        obj_instance = invoke(self.loc, obj, func3, list_)1002        assert_if_not_error(obj_instance)1003        def my_func3(localization, *args, **kwargs):1004            if len(args) > 2:1005                return StypyTypeError(localization, "Too many arguments")1006            result = python_operator(localization, '+', args[0], args[1])1007            return result1008        func4 = my_func31009        list_ = self.type_store.get_type_of(Localization(__file__), "int_list")1010        obj_instance = invoke(self.loc, obj, func4, list_, list_)1011        compare_types(obj_instance, list)1012        compare_types(type(get_elements_type(obj_instance)), int)1013        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")1014        obj_instance = invoke(self.loc, obj, func4, list_, list_, list_)1015        assert_if_not_error(obj_instance)1016        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")1017        obj_instance = invoke(self.loc, obj, func2, list_, list_)1018        compare_types(obj_instance, list)1019        compare_types(type(get_elements_type(obj_instance)), complex)1020        def my_func4(localization, *args, **kwargs):1021            str_var = get_builtin_python_type_instance(localization, "str")1022            result = python_operator(localization, '+', args[0], str_var)1023            return result1024        func5 = my_func41025        str_var = get_builtin_python_type_instance(self.loc, "str")1026        obj_instance = invoke(self.loc, obj, func5, str_var)1027        compare_types(obj_instance, list)1028        compare_types(type(get_elements_type(obj_instance)), str)1029        obj_instance = invoke(self.loc, obj, func2, str_var)1030        assert_if_not_error(obj_instance)1031    def test_zip(self):1032        obj = get_builtin_python_type_instance(self.loc, "zip")1033        compare_types(type(obj), types.BuiltinFunctionType)1034        obj_instance = invoke(self.loc, obj)1035        assert_if_not_error(obj_instance)1036        obj_instance = invoke(self.loc, obj, self.int_obj)1037        assert_if_not_error(obj_instance)1038        list_ = self.type_store.get_type_of(Localization(__file__), "int_list")1039        obj_instance = invoke(self.loc, obj, list_)1040        compare_types(obj_instance, list)1041        compare_types(get_elements_type(obj_instance), tuple)1042        compare_types(type(get_elements_type(get_elements_type(obj_instance))), int)1043        list_ = self.type_store.get_type_of(Localization(__file__), "int_list")1044        obj_instance = invoke(self.loc, obj, list_, list_)1045        compare_types(obj_instance, list)1046        compare_types(get_elements_type(obj_instance), tuple)1047        compare_types(type(get_elements_type(get_elements_type(obj_instance))), int)1048        list_2 = self.type_store.get_type_of(Localization(__file__), "mixed_type_list")1049        obj_instance = invoke(self.loc, obj, list_, list_2)1050        compare_types(obj_instance, list)1051        compare_types(get_elements_type(obj_instance), tuple)1052        compare_types(get_elements_type(get_elements_type(obj_instance)), [int(), str()])1053        list_3 = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")1054        obj_instance = invoke(self.loc, obj, list_, list_3)1055        compare_types(obj_instance, list)1056        compare_types(get_elements_type(obj_instance), tuple)1057        compare_types(get_elements_type(get_elements_type(obj_instance)), [int(), str(), complex()])1058        str_instance = get_builtin_python_type_instance(self.loc, "str")1059        obj_instance = invoke(self.loc, obj, list_, str_instance)1060        compare_types(obj_instance, list)1061        compare_types(get_elements_type(obj_instance), tuple)1062        compare_types(get_elements_type(get_elements_type(obj_instance)), [int(), str()])1063        str_instance = get_builtin_python_type_instance(self.loc, "str")1064        obj_instance = invoke(self.loc, obj, str_instance, str_instance)1065        compare_types(obj_instance, list)1066        compare_types(get_elements_type(obj_instance), tuple)1067        compare_types(type(get_elements_type(get_elements_type(obj_instance))), str)1068    def test_hash(self):1069        obj = get_builtin_python_type_instance(self.loc, "hash")1070        compare_types(type(obj), types.BuiltinFunctionType)1071        obj_instance = invoke(self.loc, obj)1072        assert_if_not_error(obj_instance)1073        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj)1074        assert_if_not_error(obj_instance)1075        obj_instance = invoke(self.loc, obj, self.int_obj)1076        compare_types(type(obj_instance), int)1077        obj_instance = invoke(self.loc, obj, self.str_obj)1078        compare_types(type(obj_instance), int)1079        class Foo:1080            def __trunc__(self, localization):1081                return get_builtin_python_type_instance(localization, "int")1082        trunc_instance = Foo()1083        obj_instance = invoke(self.loc, obj, trunc_instance)1084        compare_types(type(obj_instance), int)1085    def test_format(self):1086        obj = get_builtin_python_type_instance(self.loc, "format")1087        compare_types(type(obj), types.BuiltinFunctionType)1088        obj_instance = invoke(self.loc, obj)1089        assert_if_not_error(obj_instance)1090        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj)1091        assert_if_not_error(obj_instance)1092        obj_instance = invoke(self.loc, obj, self.int_obj)1093        compare_types(type(obj_instance), str)1094        obj_instance = invoke(self.loc, obj, self.str_obj)1095        compare_types(type(obj_instance), str)1096        obj_instance = invoke(self.loc, obj, self.str_obj, self.str_obj)1097        compare_types(type(obj_instance), str)1098        class Foo:1099            def __trunc__(self, localization):1100                return get_builtin_python_type_instance(localization, "int")1101        trunc_instance = Foo()1102        obj_instance = invoke(self.loc, obj, trunc_instance)1103        compare_types(type(obj_instance), str)1104    def test_max(self):1105        obj = get_builtin_python_type_instance(self.loc, "max")1106        compare_types(type(obj), types.BuiltinFunctionType)1107        obj_instance = invoke(self.loc, obj)1108        assert_if_not_error(obj_instance)1109        obj_instance = invoke(self.loc, obj, self.int_obj)1110        assert_if_not_error(obj_instance)1111        obj_instance = invoke(self.loc, obj, self.str_obj)1112        compare_types(type(obj_instance), str)1113        obj_instance = invoke(self.loc, obj, self.int_obj, self.float_obj)1114        compare_types(obj_instance, [self.int_obj, self.float_obj])1115        obj_instance = invoke(self.loc, obj, self.int_obj, self.float_obj, self.int_obj, self.float_obj, self.int_obj,1116                              self.float_obj, self.int_obj, self.float_obj)1117        compare_types(obj_instance, [self.int_obj, self.float_obj])1118        tuple_ = get_builtin_python_type_instance(self.loc, "tuple")1119        set_contained_elements_type(self.loc, tuple_, self.float_obj)1120        obj_instance = invoke(self.loc, obj, tuple_)1121        compare_types(type(obj_instance), float)1122        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")1123        obj_instance = invoke(self.loc, obj, list_)1124        compare_types(obj_instance, [complex(), str()])1125        list_ = self.type_store.get_type_of(Localization(__file__), "int_list")1126        obj_instance = invoke(self.loc, obj, list_)1127        compare_types(type(obj_instance), int)1128        def func(localization, *args, **kwargs):1129            return get_builtin_python_type_instance(localization, "int")1130        dict = {'key': func}1131        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")1132        obj_instance = invoke(self.loc, obj, list_, **dict)1133        compare_types(obj_instance, [complex(), str()])1134    def test_reversed(self):1135        obj = get_builtin_python_type_instance(self.loc, "reversed")1136        assert_equal_type_name(obj, "reversed")1137        obj_instance = invoke(self.loc, obj)1138        assert_if_not_error(obj_instance)1139        obj_instance = invoke(self.loc, obj, self.int_obj)1140        assert_if_not_error(obj_instance)1141        list_ = self.type_store.get_type_of(Localization(__file__), "int_list")1142        obj_instance = invoke(self.loc, obj, list_)1143        compare_types(obj_instance, reversed)1144        compare_types(type(get_elements_type(obj_instance)), int)1145        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")1146        obj_instance = invoke(self.loc, obj, list_)1147        compare_types(obj_instance, reversed)1148        compare_types(get_elements_type(obj_instance), [complex(), str()])1149        str_ = get_builtin_python_type_instance(self.loc, "str")1150        obj_instance = invoke(self.loc, obj, str_)1151        compare_types(obj_instance, reversed)1152        compare_types(get_elements_type(obj_instance), str())1153    def test_object(self):1154        obj = get_builtin_python_type_instance(self.loc, "object")1155        assert_equal_type_name(type(obj), "object")1156        obj = object1157        obj_instance = invoke(self.loc, obj)1158        compare_types(type(obj_instance), object)1159        obj_instance = invoke(self.loc, obj, self.int_obj)1160        assert_if_not_error(obj_instance)1161    def test_quit(self):1162        obj = get_builtin_python_type_instance(self.loc, "quit")1163        assert_equal_type_name(type(obj), "Quitter")1164        obj_instance = invoke(self.loc, obj)1165        compare_types(obj_instance, undefined_type.UndefinedType)1166        obj_instance = invoke(self.loc, obj, self.int_obj)1167        compare_types(obj_instance, undefined_type.UndefinedType)1168    def test_len(self):1169        obj = get_builtin_python_type_instance(self.loc, "len")1170        compare_types(type(obj), types.BuiltinFunctionType)1171        obj_instance = invoke(self.loc, obj)1172        assert_if_not_error(obj_instance)1173        obj_instance = invoke(self.loc, obj, self.int_obj)1174        assert_if_not_error(obj_instance)1175        class Foo:1176            def __len__(self, localization):1177                return get_builtin_python_type_instance(localization, "int")1178        class Foo2:1179            def __len__(self, localization):1180                return get_builtin_python_type_instance(localization, "str")1181        list_ = self.type_store.get_type_of(Localization(__file__), "int_list")1182        obj_instance = invoke(self.loc, obj, list_)1183        compare_types(type(obj_instance), int)1184        instance = Foo()1185        obj_instance = invoke(self.loc, obj, instance)1186        compare_types(type(obj_instance), int)1187        obj_instance = invoke(self.loc, obj, self.str_obj)1188        compare_types(type(obj_instance), int)1189        instance = Foo2()1190        obj_instance = invoke(self.loc, obj, instance)1191        assert_if_not_error(obj_instance)1192    def test_repr(self):1193        obj = get_builtin_python_type_instance(self.loc, "repr")1194        compare_types(type(obj), types.BuiltinFunctionType)1195        obj_instance = invoke(self.loc, obj)1196        assert_if_not_error(obj_instance)1197        obj_instance = invoke(self.loc, obj, self.int_obj)1198        compare_types(type(obj_instance), str)1199        class Foo:1200            def __repr__(self, localization):1201                return get_builtin_python_type_instance(localization, "str")1202        class Foo2:1203            def __repr__(self, localization):1204                return get_builtin_python_type_instance(localization, "int")1205        list_ = self.type_store.get_type_of(Localization(__file__), "int_list")1206        obj_instance = invoke(self.loc, obj, list_)1207        compare_types(type(obj_instance), str)1208        instance = Foo()1209        obj_instance = invoke(self.loc, obj, instance)1210        compare_types(type(obj_instance), str)1211        obj_instance = invoke(self.loc, obj, self.str_obj)1212        compare_types(type(obj_instance), str)1213        instance = Foo2()1214        obj_instance = invoke(self.loc, obj, instance)1215        assert_if_not_error(obj_instance)1216    def test_callable(self):1217        obj = get_builtin_python_type_instance(self.loc, "callable")1218        # self.assert_equal_type_name(obj, "__builtin__.quit")1219        compare_types(type(obj), types.BuiltinFunctionType)1220        obj_instance = invoke(self.loc, obj)1221        assert_if_not_error(obj_instance)1222        obj_instance = invoke(self.loc, obj, self.int_obj)1223        compare_types(type(obj_instance), bool)1224    def test_credits(self):1225        obj = get_builtin_python_type(self.loc, "credits")1226        assert_equal_type_name(type(obj), "_Printer")1227        obj_instance = invoke(self.loc, obj)1228        compare_types(type(obj_instance), types.NoneType)1229        obj_instance = invoke(self.loc, obj, self.int_obj)1230        assert_if_not_error(obj_instance)1231    def test_tuple(self):1232        obj = get_builtin_python_type(self.loc, "tuple")1233        compare_types(obj, tuple)1234        obj_instance = invoke(self.loc, obj)1235        compare_types(obj_instance, tuple)1236        obj_instance = invoke(self.loc, obj, self.int_obj)1237        assert_if_not_error(obj_instance)1238        obj_instance = invoke(self.loc, obj, self.str_obj)1239        compare_types(obj_instance, tuple)1240        compare_types(type(get_elements_type(obj_instance)), str)1241        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")1242        obj_instance = invoke(self.loc, obj, list_)1243        compare_types(get_elements_type(obj_instance), [complex(), str()])1244        obj_instance = invoke(self.loc, obj, self.str_obj, self.int_obj)1245        assert_if_not_error(obj_instance)1246        list_ = self.type_store.get_type_of(Localization(__file__), "int_list")1247        obj_instance = invoke(self.loc, obj, list_)1248        compare_types(obj_instance, tuple)1249        compare_types(type(get_elements_type(obj_instance)), int)1250        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list")1251        obj_instance = invoke(self.loc, obj, list_)1252        compare_types(obj_instance, tuple)1253        compare_types(get_elements_type(obj_instance), [int(), str()])1254    def test_eval(self):1255        obj = get_builtin_python_type_instance(self.loc, "eval")1256        compare_types(type(obj), types.BuiltinFunctionType)1257        obj_instance = invoke(self.loc, obj)1258        assert_if_not_error(obj_instance)1259        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj)1260        assert_if_not_error(obj_instance)1261        code = get_builtin_python_type_instance(self.loc, "CodeType")1262        obj_instance = invoke(self.loc, obj, code)1263        compare_types(type(obj_instance), DynamicType)1264        dict_ = get_builtin_python_type_instance(self.loc, "dict")1265        obj_instance = invoke(self.loc, obj, code, dict_)1266        compare_types(type(obj_instance), DynamicType)1267        obj_instance = invoke(self.loc, obj, code, dict_, dict_)1268        assert_if_not_error(obj_instance)1269        obj_instance = invoke(self.loc, obj, code, dict_, dict_, dict_)1270        assert_if_not_error(obj_instance)1271        str_ = get_builtin_python_type_instance(self.loc, "str")1272        obj_instance = invoke(self.loc, obj, str_, dict_, dict_)1273        compare_types(type(obj_instance), DynamicType)1274    def test_frozenset(self):1275        obj = get_builtin_python_type(self.loc, "frozenset")1276        compare_types(obj, frozenset)1277        obj_instance = invoke(self.loc, obj)1278        compare_types(obj_instance, frozenset)1279        obj_instance = invoke(self.loc, obj, self.int_obj)1280        assert_if_not_error(obj_instance)1281        obj_instance = invoke(self.loc, obj, self.str_obj)1282        compare_types(obj_instance, frozenset)1283        compare_types(get_elements_type(obj_instance), str())1284        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")1285        obj_instance = invoke(self.loc, obj, list_)1286        compare_types(get_elements_type(obj_instance), [complex(), str()])1287        obj_instance = invoke(self.loc, obj, self.str_obj, self.int_obj)1288        assert_if_not_error(obj_instance)1289        list_ = self.type_store.get_type_of(Localization(__file__), "int_list")1290        obj_instance = invoke(self.loc, obj, list_)1291        compare_types(obj_instance, frozenset)1292        compare_types(get_elements_type(obj_instance), int())1293        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list")1294        obj_instance = invoke(self.loc, obj, list_)1295        compare_types(obj_instance, frozenset)1296        compare_types(get_elements_type(obj_instance), [int(), str()])1297    def test_sorted(self):1298        obj = get_builtin_python_type_instance(self.loc, "sorted")1299        compare_types(type(obj), types.BuiltinFunctionType)1300        obj_instance = invoke(self.loc, obj)1301        assert_if_not_error(obj_instance)1302        obj_instance = invoke(self.loc, obj, self.int_obj)1303        assert_if_not_error(obj_instance)1304        list_ = self.type_store.get_type_of(Localization(__file__), "int_list")1305        obj_instance = invoke(self.loc, obj, list_)1306        compare_types(obj_instance, list)1307        compare_types(type(get_elements_type(obj_instance)), int)1308        def my_func1(localization, *args, **kwargs):1309            param1 = get_builtin_python_type_instance(localization, "str", args[0])1310            return param11311        func = my_func11312        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list")1313        obj_instance = invoke(self.loc, obj, list_, func)1314        compare_types(obj_instance, list)1315        compare_types(get_elements_type(obj_instance), [int(), str()])1316        obj_instance = invoke(self.loc, obj, list_, func, func)1317        compare_types(obj_instance, list)1318        compare_types(get_elements_type(obj_instance), [int(), str()])1319        bool_obj = get_builtin_python_type_instance(self.loc, "bool")1320        obj_instance = invoke(self.loc, obj, list_, func, func, bool_obj)1321        compare_types(obj_instance, list)1322        compare_types(get_elements_type(obj_instance), [int(), str()])1323        # str1324        str_ = get_builtin_python_type_instance(self.loc, "str")1325        obj_instance = invoke(self.loc, obj, str_)1326        compare_types(obj_instance, list)1327        compare_types(type(get_elements_type(obj_instance)), str)1328        func = my_func11329        obj_instance = invoke(self.loc, obj, str_, func)1330        compare_types(obj_instance, list)1331        compare_types(type(get_elements_type(obj_instance)), str)1332        obj_instance = invoke(self.loc, obj, str_, func, func)1333        compare_types(obj_instance, list)1334        compare_types(type(get_elements_type(obj_instance)), str)1335        bool_obj = get_builtin_python_type_instance(self.loc, "bool")1336        obj_instance = invoke(self.loc, obj, str_, func, func, bool_obj)1337        compare_types(obj_instance, list)1338        compare_types(type(get_elements_type(obj_instance)), str)1339    def test_ord(self):1340        obj = get_builtin_python_type_instance(self.loc, "ord")1341        compare_types(type(obj), types.BuiltinFunctionType)1342        obj_instance = invoke(self.loc, obj)1343        assert_if_not_error(obj_instance)1344        obj_instance = invoke(self.loc, obj, self.int_obj)1345        assert_if_not_error(obj_instance)1346        list_ = self.type_store.get_type_of(Localization(__file__), "int_list")1347        obj_instance = invoke(self.loc, obj, list_)1348        assert_if_not_error(obj_instance)1349        str_ = get_builtin_python_type_instance(self.loc, "str")1350        obj_instance = invoke(self.loc, obj, str_)1351        compare_types(type(obj_instance), int)1352    def test_super(self):1353        obj = get_builtin_python_type(self.loc, "super")1354        compare_types(obj, super)1355        obj_instance = invoke(self.loc, obj)1356        assert_if_not_error(obj_instance)1357        int_class = get_builtin_python_type(self.loc, "int")1358        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj)1359        assert_if_not_error(obj_instance)1360        obj_instance = invoke(self.loc, obj, int_class)1361        compare_types(type(obj_instance), super)1362        compare_types(get_member(self.loc, obj_instance, "__thisclass__"), int)1363        compare_types(get_member(self.loc, obj_instance, "__self_class__"), None)1364        str_class = get_builtin_python_type(self.loc, "str")1365        obj_instance = invoke(self.loc, obj, str_class)1366        compare_types(type(obj_instance), super)1367        compare_types(get_member(self.loc, obj_instance, "__thisclass__"), str)1368        compare_types(get_member(self.loc, obj_instance, "__self_class__"), None)1369        obj_instance = invoke(self.loc, obj, str_class, self.str_obj)1370        compare_types(type(obj_instance), super)1371        compare_types(get_member(self.loc, obj_instance, "__thisclass__"), str)1372        compare_types(get_member(self.loc, obj_instance, "__self_class__"), str)1373        obj_instance = invoke(self.loc, obj, self.str_obj, self.str_obj)1374        assert_if_not_error(obj_instance)1375        class Foo(object):1376            att = int1377            def func(self, localization):1378                return get_builtin_python_type_instance(localization, "int")1379        foo_class = Foo1380        foo_instance = Foo()1381        obj_instance = invoke(self.loc, obj, foo_class, foo_instance)1382        compare_types(type(obj_instance), super)1383        compare_types(get_member(self.loc, obj_instance, "__thisclass__"), foo_class)1384        compare_types(get_member(self.loc, obj_instance, "__self_class__"), foo_class)1385    def test_hasattr(self):1386        obj = get_builtin_python_type_instance(self.loc, "hasattr")1387        compare_types(type(obj), types.BuiltinFunctionType)1388        obj_instance = invoke(self.loc, obj)1389        assert_if_not_error(obj_instance)1390        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj)1391        assert_if_not_error(obj_instance)1392        obj_instance = invoke(self.loc, obj, self.int_obj)1393        assert_if_not_error(obj_instance)1394        obj_instance = invoke(self.loc, obj, self.str_obj)1395        assert_if_not_error(obj_instance)1396        obj_instance = invoke(self.loc, obj, self.str_obj, self.str_obj)1397        compare_types(type(obj_instance), bool)1398        class Foo:1399            att = int1400            def func(self, localization):1401                return get_builtin_python_type_instance(localization, "int")1402        foo_class = Foo1403        foo_instance = Foo()1404        att_str = get_builtin_python_type_instance(self.loc, "str", value="att")1405        func_str = get_builtin_python_type_instance(self.loc, "str", value="func")1406        ne_str = get_builtin_python_type_instance(self.loc, "str", value="ne")1407        obj_instance = invoke(self.loc, obj, foo_class, att_str)1408        compare_types(type(obj_instance), bool)1409        compare_types(obj_instance, True)1410        obj_instance = invoke(self.loc, obj, foo_class, func_str)1411        compare_types(type(obj_instance), bool)1412        compare_types(obj_instance, True)1413        obj_instance = invoke(self.loc, obj, foo_class, ne_str)1414        compare_types(type(obj_instance), bool)1415        compare_types(obj_instance, False)1416        obj_instance = invoke(self.loc, obj, foo_instance, att_str)1417        compare_types(type(obj_instance), bool)1418        compare_types(obj_instance, True)1419        obj_instance = invoke(self.loc, obj, foo_instance, func_str)1420        compare_types(type(obj_instance), bool)1421        compare_types(obj_instance, True)1422        obj_instance = invoke(self.loc, obj, foo_instance, ne_str)1423        compare_types(type(obj_instance), bool)1424        compare_types(obj_instance, False)1425    def test_delattr(self):1426        obj = get_builtin_python_type_instance(self.loc, "delattr")1427        compare_types(type(obj), types.BuiltinFunctionType)1428        obj_instance = invoke(self.loc, obj)1429        assert_if_not_error(obj_instance)1430        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj)1431        assert_if_not_error(obj_instance)1432        obj_instance = invoke(self.loc, obj, self.int_obj)1433        assert_if_not_error(obj_instance)1434        obj_instance = invoke(self.loc, obj, self.str_obj)1435        assert_if_not_error(obj_instance)1436        obj_instance = invoke(self.loc, obj, self.str_obj, self.str_obj)1437        assert_if_not_error(obj_instance)1438        class Foo:1439            att = int1440            def func(self, localization):1441                return get_builtin_python_type_instance(localization, "int")1442        foo_class = Foo1443        foo_instance = Foo()1444        att_str = get_builtin_python_type_instance(self.loc, "str", value="att")1445        func_str = get_builtin_python_type_instance(self.loc, "str", value="func")1446        ne_str = get_builtin_python_type_instance(self.loc, "str", value="ne")1447        obj_instance = invoke(self.loc, obj, foo_class, att_str)1448        compare_types(type(obj_instance), types.NoneType)1449        obj_instance = invoke(self.loc, obj, foo_class, func_str)1450        compare_types(type(obj_instance), types.NoneType)1451        obj_instance = invoke(self.loc, obj, foo_class, ne_str)1452        assert_if_not_error(obj_instance)1453        obj = get_builtin_python_type_instance(self.loc, "hasattr")1454        obj_instance = invoke(self.loc, obj, foo_class, att_str)1455        compare_types(type(obj_instance), bool)1456        compare_types(obj_instance, False)1457        obj_instance = invoke(self.loc, obj, foo_class, func_str)1458        compare_types(type(obj_instance), bool)1459        compare_types(obj_instance, False)1460        obj_instance = invoke(self.loc, obj, foo_class, ne_str)1461        compare_types(type(obj_instance), bool)1462        compare_types(obj_instance, False)1463        obj_instance = invoke(self.loc, obj, foo_instance, att_str)1464        compare_types(type(obj_instance), bool)1465        compare_types(obj_instance, False)1466        obj_instance = invoke(self.loc, obj, foo_instance, func_str)1467        compare_types(type(obj_instance), bool)1468        compare_types(obj_instance, False)1469        obj_instance = invoke(self.loc, obj, foo_instance, ne_str)1470        compare_types(type(obj_instance), bool)1471        compare_types(obj_instance, False)1472    def test_dict(self):1473        obj = get_builtin_python_type(self.loc, "dict")1474        compare_types(obj, dict)1475        obj_instance = invoke(self.loc, obj)1476        compare_types(obj_instance, dict)1477        obj_instance = invoke(self.loc, obj, self.int_obj)1478        assert_if_not_error(obj_instance)1479        obj_instance = invoke(self.loc, obj, self.str_obj)1480        assert_if_not_error(obj_instance)1481        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")1482        tuple_obj = get_builtin_python_type(self.loc, "tuple")1483        tuple1 = invoke(self.loc, tuple_obj, list_)1484        list_param1 = get_builtin_python_type_instance(self.loc, "list")1485        self.type_store.set_type_of(self.loc, "list_param1", list_param1)1486        append = self.type_store.get_type_of_member(self.loc, list_param1, "append")1487        invoke(self.loc, append, tuple1)1488        obj_instance = invoke(self.loc, obj, list_param1)1489        keys = obj_instance.keys()1490        values = obj_instance.values()1491        self.assertTrue(1492                get_builtin_python_type_instance(self.loc,1493                                                 "complex") in keys and get_builtin_python_type_instance(1494                        self.loc, "str") in keys)1495        list_ = self.type_store.get_type_of(Localization(__file__), "int_list")1496        tuple_obj = get_builtin_python_type(self.loc, "tuple")1497        tuple1 = invoke(self.loc, tuple_obj, list_)1498        list_param2 = get_builtin_python_type_instance(self.loc, "list")1499        self.type_store.set_type_of(self.loc, "list_param2", list_param2)1500        append = self.type_store.get_type_of_member(self.loc, list_param2, "append")1501        invoke(self.loc, append, tuple1)1502        obj_instance = invoke(self.loc, obj, list_param2)1503        keys = obj_instance.keys()1504        values = obj_instance.values()1505        self.assertTrue(isinstance(keys[0], int))1506        self.assertTrue(isinstance(values[0], int))1507        obj_instance2 = invoke(self.loc, obj, obj_instance)1508        compare_types(obj_instance2, dict)1509        keys = obj_instance2.keys()1510        values = obj_instance2.values()1511        self.assertTrue(isinstance(keys[0], int))1512        self.assertTrue(isinstance(values[0], int))1513        obj_instance = invoke(self.loc, obj, self.str_obj, self.int_obj)1514        assert_if_not_error(obj_instance)1515    def test_setattr(self):1516        obj = get_builtin_python_type_instance(self.loc, "setattr")1517        compare_types(type(obj), types.BuiltinFunctionType)1518        obj_instance = invoke(self.loc, obj)1519        assert_if_not_error(obj_instance)1520        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj)1521        assert_if_not_error(obj_instance)1522        obj_instance = invoke(self.loc, obj, self.int_obj)1523        assert_if_not_error(obj_instance)1524        obj_instance = invoke(self.loc, obj, self.str_obj)1525        assert_if_not_error(obj_instance)1526        obj_instance = invoke(self.loc, obj, self.str_obj, self.str_obj)1527        assert_if_not_error(obj_instance)1528        class Foo:1529            pass1530        foo_class = Foo1531        foo_instance = Foo()1532        att_str = get_builtin_python_type_instance(self.loc, "str", value="att")1533        func_str = get_builtin_python_type_instance(self.loc, "str", value="func")1534        ne_str = get_builtin_python_type_instance(self.loc, "str", value="ne")1535        val = get_builtin_python_type_instance(self.loc, "int")1536        obj_instance = invoke(self.loc, obj, foo_class, att_str, val)1537        compare_types(type(obj_instance), types.NoneType)1538        obj_instance = invoke(self.loc, obj, foo_class, func_str, val)1539        compare_types(type(obj_instance), types.NoneType)1540        obj = get_builtin_python_type_instance(self.loc, "hasattr")1541        obj_instance = invoke(self.loc, obj, foo_class, att_str)1542        compare_types(type(obj_instance), bool)1543        compare_types(obj_instance, True)1544        obj_instance = invoke(self.loc, obj, foo_class, func_str)1545        compare_types(type(obj_instance), bool)1546        compare_types(obj_instance, True)1547        obj_instance = invoke(self.loc, obj, foo_class, ne_str)1548        compare_types(type(obj_instance), bool)1549        compare_types(obj_instance, False)1550        obj_instance = invoke(self.loc, obj, foo_instance, att_str)1551        compare_types(type(obj_instance), bool)1552        compare_types(obj_instance, True)1553        obj_instance = invoke(self.loc, obj, foo_instance, func_str)1554        compare_types(type(obj_instance), bool)1555        compare_types(obj_instance, True)1556        obj_instance = invoke(self.loc, obj, foo_instance, ne_str)1557        compare_types(type(obj_instance), bool)1558        compare_types(obj_instance, False)1559    def test_license(self):1560        obj = get_builtin_python_type_instance(self.loc, "license")1561        assert_equal_type_name(type(obj), "_Printer")1562        obj_instance = invoke(self.loc, obj)1563        compare_types(type(obj_instance), types.NoneType)1564        obj_instance = invoke(self.loc, obj, self.int_obj)1565        assert_if_not_error(obj_instance)1566    def test_classmethod(self):1567        obj = get_builtin_python_type(self.loc, "classmethod")1568        compare_types(obj, classmethod)1569        obj_instance = invoke(self.loc, obj)1570        assert_if_not_error(obj_instance)1571        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj)1572        assert_if_not_error(obj_instance)1573        obj_instance = invoke(self.loc, obj, self.int_obj)1574        compare_types(type(obj_instance), classmethod)1575        class Foo:1576            def __oct__(self, localization):1577                return get_builtin_python_type_instance(localization, "int")1578        hex_instance = Foo()1579        obj_instance = invoke(self.loc, obj, hex_instance)1580        compare_types(type(obj_instance), classmethod)1581    def test_raw_input(self):1582        obj = get_builtin_python_type_instance(self.loc, "input")1583        assert_equal_type_name(obj, "input")1584        obj_instance = invoke(self.loc, obj)1585        compare_types(obj_instance, DynamicType)1586        obj_instance = invoke(self.loc, obj, self.int_obj)1587        compare_types(obj_instance, DynamicType)1588        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")1589        obj_instance = invoke(self.loc, obj, list_)1590        compare_types(obj_instance, DynamicType)1591        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj)1592        assert_if_not_error(obj_instance)1593    def test_bytes(self):1594        obj = get_builtin_python_type(self.loc, "bytes")1595        compare_types(obj, bytes)1596        obj_instance = invoke(self.loc, obj)1597        compare_types(type(obj_instance), str)1598        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj)1599        assert_if_not_error(obj_instance)1600        obj_instance = invoke(self.loc, obj, self.int_obj)1601        compare_types(type(obj_instance), str)1602        class Foo:1603            def __str__(self, localization):1604                return get_builtin_python_type_instance(localization, "int")1605        oct_instance = Foo()1606        obj_instance = invoke(self.loc, obj, oct_instance)1607        assert_if_not_error(obj_instance)1608    def test_iter(self):1609        obj = get_builtin_python_type_instance(self.loc, "iter")1610        compare_types(type(obj), types.BuiltinFunctionType)1611        obj_instance = invoke(self.loc, obj)1612        assert_if_not_error(obj_instance)1613        obj_instance = invoke(self.loc, obj, self.int_obj)1614        assert_if_not_error(obj_instance)1615        obj_instance = invoke(self.loc, obj, self.str_obj)1616        compare_types(obj_instance, ExtraTypeDefinitions.iterator)1617        compare_types(type(get_elements_type(obj_instance)), str)1618        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list2")1619        obj_instance = invoke(self.loc, obj, list_)1620        compare_types(obj_instance, ExtraTypeDefinitions.listiterator)1621        compare_types(get_elements_type(obj_instance), [complex(), str()])1622        obj_instance = invoke(self.loc, obj, self.str_obj, self.int_obj)1623        assert_if_not_error(obj_instance)1624        list_ = self.type_store.get_type_of(Localization(__file__), "int_list")1625        obj_instance = invoke(self.loc, obj, list_)1626        compare_types(obj_instance, ExtraTypeDefinitions.listiterator)1627        compare_types(type(get_elements_type(obj_instance)), int)1628        list_ = self.type_store.get_type_of(Localization(__file__), "mixed_type_list")1629        obj_instance = invoke(self.loc, obj, list_)1630        compare_types(obj_instance, ExtraTypeDefinitions.listiterator)1631        compare_types(get_elements_type(obj_instance), [int(), str()])1632        class Foo:1633            def __call__(self, localization, *args, **kwargs):1634                return float()1635        obj_instance = invoke(self.loc, obj, Foo(), int())1636        compare_types(obj_instance, ExtraTypeDefinitions.callable_iterator)1637        compare_types(type(get_elements_type(obj_instance)), float)1638    def test_compile(self):1639        obj = get_builtin_python_type_instance(self.loc, "compile")1640        compare_types(type(obj), types.BuiltinFunctionType)1641        obj_instance = invoke(self.loc, obj)1642        assert_if_not_error(obj_instance)1643        obj_instance = invoke(self.loc, obj, self.int_obj)1644        assert_if_not_error(obj_instance)1645        obj_instance = invoke(self.loc, obj, self.str_obj)1646        assert_if_not_error(obj_instance)1647        obj_instance = invoke(self.loc, obj, self.str_obj, self.str_obj, self.str_obj)1648        compare_types(type(obj_instance), DynamicType)1649        obj_instance = invoke(self.loc, obj, self.str_obj, self.str_obj, self.str_obj, self.int_obj, self.int_obj)1650        compare_types(type(obj_instance), DynamicType)1651    def test_reload(self):1652        obj = get_builtin_python_type_instance(self.loc, "reload")1653        compare_types(type(obj), types.BuiltinFunctionType)1654        obj_instance = invoke(self.loc, obj)1655        assert_if_not_error(obj_instance)1656        obj_instance = invoke(self.loc, obj, self.int_obj)1657        assert_if_not_error(obj_instance)1658        obj_instance = invoke(self.loc, obj, self.str_obj)1659        assert_if_not_error(obj_instance)1660        dest = Context(self.type_store, "func")1661        import_from_module(self.loc, "time", None, dest)1662        module_ = dest.get_type_of(self.loc, "time")1663        obj_instance = invoke(self.loc, obj, module_)1664        compare_types(obj_instance, module_)1665        dest.close_function_context()1666    def test_range(self):1667        obj = get_builtin_python_type_instance(self.loc, "range")1668        compare_types(type(obj), types.BuiltinFunctionType)1669        obj_instance = invoke(self.loc, obj)1670        assert_if_not_error(obj_instance)1671        obj_instance = invoke(self.loc, obj, self.float_obj)1672        assert_if_not_error(obj_instance)1673        obj_instance = invoke(self.loc, obj, self.int_obj)1674        compare_types(obj_instance, list)1675        compare_types(type(get_elements_type(obj_instance)), int)1676        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj)1677        compare_types(obj_instance, list)1678        compare_types(type(get_elements_type(obj_instance)), int)1679        obj_instance = invoke(self.loc, obj, self.float_obj, self.int_obj)1680        assert_if_not_error(obj_instance)1681        obj_instance = invoke(self.loc, obj, self.str_obj)1682        assert_if_not_error(obj_instance)1683        obj_instance = invoke(self.loc, obj, self.int_obj, self.str_obj)1684        assert_if_not_error(obj_instance)1685        class Foo:1686            def __trunc__(self, localization):1687                return get_builtin_python_type_instance(localization, "int")1688        class Foo2:1689            def __trunc__(self, localization):1690                return get_builtin_python_type_instance(localization, "list")1691        trunc_instance = Foo()1692        wrong_instance = Foo2()1693        obj_instance = invoke(self.loc, obj, trunc_instance)1694        compare_types(obj_instance, list)1695        compare_types(type(get_elements_type(obj_instance)), int)1696        obj_instance = invoke(self.loc, obj, trunc_instance, self.int_obj)1697        compare_types(obj_instance, list)1698        compare_types(type(get_elements_type(obj_instance)), int)1699        obj_instance = invoke(self.loc, obj, trunc_instance, trunc_instance)1700        compare_types(obj_instance, list)1701        compare_types(type(get_elements_type(obj_instance)), int)1702        obj_instance = invoke(self.loc, obj, wrong_instance)1703        assert_if_not_error(obj_instance)1704        obj_instance = invoke(self.loc, obj, wrong_instance, self.int_obj)1705        assert_if_not_error(obj_instance)1706        obj_instance = invoke(self.loc, obj, wrong_instance, trunc_instance)1707        assert_if_not_error(obj_instance)1708    def test_staticmethod(self):1709        obj = get_builtin_python_type(self.loc, "staticmethod")1710        compare_types(obj, staticmethod)1711        obj_instance = invoke(self.loc, obj)1712        assert_if_not_error(obj_instance)1713        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj)1714        assert_if_not_error(obj_instance)1715        obj_instance = invoke(self.loc, obj, self.int_obj)1716        compare_types(type(obj_instance), staticmethod)1717        class Foo:1718            def __oct__(self, localization):1719                return get_builtin_python_type_instance(localization, "int")1720        hex_instance = Foo()1721        obj_instance = invoke(self.loc, obj, hex_instance)1722        compare_types(type(obj_instance), staticmethod)1723    def test_str(self):1724        obj = get_builtin_python_type(self.loc, "str")1725        compare_types(obj, str)1726        obj_instance = invoke(self.loc, obj)1727        compare_types(type(obj_instance), str)1728        obj_instance = invoke(self.loc, obj, self.int_obj)1729        compare_types(type(obj_instance), str)1730        class Foo:1731            def __str__(self, localization):1732                return get_builtin_python_type_instance(localization, "str")1733        class Foo2:1734            def __str__(self, localization):1735                return get_builtin_python_type_instance(localization, "int")1736        list_ = self.type_store.get_type_of(Localization(__file__), "int_list")1737        obj_instance = invoke(self.loc, obj, list_)1738        compare_types(type(obj_instance), str)1739        instance = Foo()1740        obj_instance = invoke(self.loc, obj, instance)1741        compare_types(type(obj_instance), str)1742        obj_instance = invoke(self.loc, obj, self.str_obj)1743        compare_types(type(obj_instance), str)1744        instance = Foo2()1745        obj_instance = invoke(self.loc, obj, instance)1746        assert_if_not_error(obj_instance)1747    def test_complex(self):1748        obj = get_builtin_python_type(self.loc, "complex")1749        compare_types(obj, types.ComplexType)1750        obj_instance = invoke(self.loc, obj)1751        compare_types(type(obj_instance), complex)1752        obj_instance = invoke(self.loc, obj, self.float_obj)1753        compare_types(type(obj_instance), complex)1754        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj)1755        compare_types(type(obj_instance), complex)1756        obj_instance = invoke(self.loc, obj, self.float_obj, self.int_obj)1757        compare_types(type(obj_instance), complex)1758        obj_instance = invoke(self.loc, obj, self.str_obj)1759        assert_if_not_error(obj_instance)1760        obj_instance = invoke(self.loc, obj, self.int_obj, self.str_obj)1761        assert_if_not_error(obj_instance)1762        class Foo:1763            def __float__(self, localization):1764                return get_builtin_python_type_instance(localization, "float")1765        class Foo2:1766            def __float__(self, localization):1767                return get_builtin_python_type_instance(localization, "list")1768        float_instance = Foo()1769        wrong_instance = Foo2()1770        obj_instance = invoke(self.loc, obj, float_instance)1771        compare_types(type(obj_instance), complex)1772        obj_instance = invoke(self.loc, obj, self.int_obj, float_instance)1773        compare_types(type(obj_instance), complex)1774        obj_instance = invoke(self.loc, obj, float_instance, float_instance)1775        compare_types(type(obj_instance), complex)1776        obj_instance = invoke(self.loc, obj, wrong_instance)1777        assert_if_not_error(obj_instance)1778        obj_instance = invoke(self.loc, obj, self.int_obj, wrong_instance)1779        assert_if_not_error(obj_instance)1780        obj_instance = invoke(self.loc, obj, wrong_instance, wrong_instance)1781        assert_if_not_error(obj_instance)1782    def test_property(self):1783        obj = get_builtin_python_type_instance(self.loc, "property")1784        compare_types(type(obj), property)1785        obj = property1786        obj_instance = invoke(self.loc, obj)1787        compare_types(type(obj_instance), property)1788        def get(self, localization):1789            return get_builtin_python_type_instance(localization, "int")1790        def set(self, localization, *args):1791            return get_builtin_python_type_instance(localization, "int")1792        def del_(self, localization):1793            return get_builtin_python_type_instance(localization, "int")1794        fget = get1795        fset = set1796        fdel = del_1797        fdoc = get_builtin_python_type_instance(self.loc, "str")1798        obj_instance = invoke(self.loc, obj, fget)1799        compare_types(type(obj_instance), property)1800        compare_types(type(get_member(self.loc, obj_instance, "fget")), types.FunctionType)1801        obj_instance = invoke(self.loc, obj, fget, fset)1802        compare_types(type(obj_instance), property)1803        compare_types(type(get_member(self.loc, obj_instance, "fget")), types.FunctionType)1804        compare_types(type(get_member(self.loc, obj_instance, "fset")), types.FunctionType)1805        obj_instance = invoke(self.loc, obj, fget, fset, fdel)1806        compare_types(type(obj_instance), property)1807        compare_types(type(get_member(self.loc, obj_instance, "fget")), types.FunctionType)1808        compare_types(type(get_member(self.loc, obj_instance, "fset")), types.FunctionType)1809        compare_types(type(get_member(self.loc, obj_instance, "fdel")), types.FunctionType)1810        obj_instance = invoke(self.loc, obj, fget, fset, fdel, fdoc)1811        compare_types(type(obj_instance), property)1812        compare_types(type(get_member(self.loc, obj_instance, "fget")), types.FunctionType)1813        compare_types(type(get_member(self.loc, obj_instance, "fset")), types.FunctionType)1814        compare_types(type(get_member(self.loc, obj_instance, "fdel")), types.FunctionType)1815        compare_types(type(get_member(self.loc, obj_instance, "__doc__")), str)1816    def test_round(self):1817        obj = get_builtin_python_type_instance(self.loc, "round")1818        compare_types(type(obj), types.BuiltinFunctionType)1819        obj_instance = invoke(self.loc, obj)1820        assert_if_not_error(obj_instance)1821        obj_instance = invoke(self.loc, obj, self.float_obj)1822        compare_types(type(obj_instance), float)1823        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj)1824        compare_types(type(obj_instance), float)1825        obj_instance = invoke(self.loc, obj, self.float_obj, self.int_obj)1826        compare_types(type(obj_instance), float)1827        obj_instance = invoke(self.loc, obj, self.str_obj)1828        assert_if_not_error(obj_instance)1829        obj_instance = invoke(self.loc, obj, self.int_obj, self.str_obj)1830        assert_if_not_error(obj_instance)1831        class Foo:1832            def __float__(self, localization):1833                return get_builtin_python_type_instance(localization, "float")1834        class Foo2:1835            def __float__(self, localization):1836                return get_builtin_python_type_instance(localization, "list")1837        class Foo3:1838            def __index__(self, localization):1839                return get_builtin_python_type_instance(localization, "int")1840        float_instance = Foo()1841        wrong_instance = Foo2()1842        index_instance = Foo3()1843        obj_instance = invoke(self.loc, obj, float_instance)1844        compare_types(type(obj_instance), float)1845        obj_instance = invoke(self.loc, obj, float_instance, self.int_obj)1846        compare_types(type(obj_instance), float)1847        obj_instance = invoke(self.loc, obj, float_instance, index_instance)1848        compare_types(type(obj_instance), float)1849        obj_instance = invoke(self.loc, obj, wrong_instance)1850        assert_if_not_error(obj_instance)1851        obj_instance = invoke(self.loc, obj, wrong_instance, self.int_obj)1852        assert_if_not_error(obj_instance)1853        obj_instance = invoke(self.loc, obj, wrong_instance, self.int_obj, self.int_obj)1854        assert_if_not_error(obj_instance)1855    def test_dir(self):1856        obj = get_builtin_python_type_instance(self.loc, "dir")1857        compare_types(type(obj), types.BuiltinFunctionType)1858        obj_instance = invoke(self.loc, obj)1859        compare_types(obj_instance, list)1860        compare_types(type(get_elements_type(obj_instance)), str)1861        obj_instance = invoke(self.loc, obj, self.int_obj, self.int_obj)1862        assert_if_not_error(obj_instance)1863        obj_instance = invoke(self.loc, obj, self.int_obj)1864        compare_types(obj_instance, list)1865        compare_types(type(get_elements_type(obj_instance)), str)1866        class Foo:1867            def __oct__(self, localization):1868                return get_builtin_python_type_instance(localization, "int")1869        hex_instance = Foo()1870        obj_instance = invoke(self.loc, obj, hex_instance)1871        compare_types(obj_instance, list)1872        compare_types(type(get_elements_type(obj_instance)), str)1873    def test_cmp(self):1874        obj = get_builtin_python_type_instance(self.loc, "cmp")1875        compare_types(type(obj), types.BuiltinFunctionType)1876        obj_instance = invoke(self.loc, obj)1877        assert_if_not_error(obj_instance)1878        obj_instance = invoke(self.loc, obj, self.int_obj)1879        assert_if_not_error(obj_instance)1880        obj_instance = invoke(self.loc, obj, self.int_obj, self.str_obj)...

type_inferencer.py

Source:type_inferencer.py

...41        expr_infered = node.expr.inferenced_type42        self.visit(node.expr, scope)43        node_expr = self.update_type(node.expr.inferenced_type)44        node_expr = conforms(node_expr, node_type)45        node.inferenced_type = self.compare_types(type_infered, node_type)46        node.expr.inferenced_type = self.compare_types(expr_infered, node_expr)47        48        var = scope.find_variable(node.id)49        var.type = node.inferenced_type50        self.current_attrb = None51    @visitor.when(FuncDeclarationNode)52    def visit(self, node, scopex:Scope()):53        scope:Scope = scopex.next_child()54        self.current_method = self.current_type.get_method(node.id)55        for idx, typex in zip(self.current_method.param_names, self.current_method.param_types):56            var = scope.find_variable(idx)57            var.type = self.compare_types(var.type, typex)58        decl_inferred = node.inferenced_type59        expr_inferred = node.body.inferenced_type60        ret_type_decl = self.update_type(self.current_method.return_type)61        self.visit(node.body, scope)62        ret_type_expr = self.update_type(node.body.inferenced_type)63        conforms(ret_type_expr, ret_type_decl)64        print("Comapring inferenced type in FuncDecl")65        node.inferenced_type = self.compare_types(decl_inferred, ret_type_decl)66        print("Comapring Body inferenced type in FuncDecl")67        node.body.inferenced_type = self.compare_types(expr_inferred, ret_type_expr)68        if isinstance(self.current_method.return_type, AutoType):69            auto_return = self.current_method.return_type70            ret_type_decl = conforms(ret_type_decl, ret_type_expr)71            print("Comapring inferenced type in FuncDecl Once Agagin")72            node.inferenced_type = self.compare_types(decl_inferred, ret_type_decl)73            if is_subset(ret_type_decl, auto_return):74                self.current_method.return_type = ret_type_decl75        self.current_method = None76    @visitor.when(BlockNode)77    def visit(self, node, scope):78        for expr in node.body:79            self.visit(expr, scope)80        node.inferenced_type = node.body[-1].inferenced_type81    @visitor.when(IfDeclarationNode)82    def visit(self, node, scope):83        if_inferred = node.ifexpr.inferenced_type84        self.visit(node.ifexpr, scope)85        ifexpr_type = self.update_type(node.ifexpr.inferenced_type)86        bool_type = self.context.get_type("Bool")87        if isinstance(ifexpr_type, AutoType):88            ifexpr_type.set_upper_limmit([bool_type])89        node.ifexpr.inferenced_type = self.compare_types(if_inferred, ifexpr_type)90        self.visit(node.thenexpr, scope)91        then_type = self.update_type(node.thenexpr.inferenced_type)92        self.visit(node.elseexpr, scope)93        else_type = self.update_type(node.elseexpr.inferenced_type)94        node_inferred = node.inferenced_type95        joined = join(then_type, else_type)96        if not isinstance(joined, ErrorType):97            type_sets, heads = joined98            auto = AutoType("IF", heads, type_sets)99        else:100            auto = ErrorType()101        102        if is_subset(auto, node_inferred):103            node.inferenced_type = self.compare_types(node_inferred, auto)104    105    @visitor.when(CaseDeclarationNode)106    def visit(self, node, scope:Scope):107        self.visit(node.expr, scope)108        var_types = []109        for var in node.casevars:110            child = scope.next_child()111            self.visit(var, child)112            var_types.append(var.inferenced_type)113        node_inferred = node.inferenced_type114        auto = join_list(var_types)115        if is_subset(auto, node_inferred):116            node.inferenced_type = self.compare_types(node_inferred, auto)117    118    @visitor.when(WhileDeclarationNode)119    def visit(self, node, scope):120        while_inferred = node.whileexpr.inferenced_type121        body_inferred = node.bodyexpr.inferenced_type122        self.visit(node.whileexpr, scope)123        wh_expr = self.update_type(node.whileexpr.inferenced_type)124        if isinstance(wh_expr, AutoType):125            wh_expr.set_upper_limmit([self.context.get_type("Bool")])126        node.whileexpr.inferenced_type = self.compare_types(while_inferred, wh_expr)127        128        self.visit(node.bodyexpr, scope)129        body = self.update_type(node.bodyexpr.inferenced_type)130        node.bodyexpr.inferenced_type = self.compare_types(body_inferred, body)131    132    @visitor.when(LetDeclarationNode)133    def visit(self, node, scope):134        child = scope.next_child()135        for var in node.letvars:136            self.visit(var, child)137        node_inferred = node.inferenced_type138        self.visit(node.expr, child)139        node_type= self.update_type(node.expr.inferenced_type)140        node.inferenced_type = self.compare_types(node_inferred, node_type)141    142    @visitor.when(CaseVarNode)143    def visit(self, node, scope:Scope):144        node_infer = node.inferenced_type145        self.visit(node.expr, scope)146        expr_type = self.update_type(node.expr.inferenced_type)147        node.inferenced_type = self.compare_types(node_infer, expr_type)148    @visitor.when(VarDeclarationNode)149    def visit(self, node, scope:Scope):150        if node.define:151            node_type = scope.find_variable(node.id).type152        else:153            node_type = ErrorType()154        if node.expr:155            expr_inferr = node.expr.inferenced_type156            self.visit(node.expr, scope)157            expr_type = self.update_type(node.expr.inferenced_type)158            expr_type = conforms(expr_type, node_type)159            node.expr.inferenced_type = self.compare_types(expr_inferr, expr_type)160        161        node.inferenced_type = self.compare_types(node.inferenced_type, node_type)162    163    @visitor.when(AssignNode)164    def visit(self, node, scope:Scope):165        if not node.define:166            var = None167            var_type = ErrorType()168        else:169            var = scope.find_variable(node.id)170            var_type = var.type171        expr_inferred = node.expr.inferenced_type172        self.visit(node.expr, scope)173        node_expr = self.update_type(node.expr.inferenced_type)174        if node.define:175            node_expr = conforms(node_expr, var_type)176            node.expr.inferenced_type = self.compare_types(expr_inferred, node_expr)177            if isinstance(var_type, AutoType):178                var_type = conforms(var_type, node_expr)179                var.type = self.compare_types(var.type, var_type)180        node.inferenced_type = self.compare_types(node.inferenced_type, var_type)181    @visitor.when(CallNode)182    def visit(self, node, scope):183        if isinstance(node.inferenced_type, ErrorType):184            return185        if node.obj == None:186            obj_type = self.current_type187        elif isinstance(node.obj, tuple):188            self.visit(node.obj[0], scope)189            child_type = self.update_type(node.obj[0].inferenced_type)190            try:191                obj_type = self.context.get_type(node.obj[1], selftype=False, autotype=False)192                if isinstance(child_type, AutoType):193                    child_type.set_upper_limmit([obj_type])194            except SemanticError:195                obj_type = ErrorType()196        else:197            self.visit(node.obj, scope)198            obj_type = self.update_type(node.obj.inferenced_type)199        200        method = None201        try:202            method = obj_type.get_method(node.id)203        except SemanticError:204            if isinstance(obj_type, AutoType):205                result = self.context.get_method_by_name(node.id, len(node.args))206                valid = []207                for meth, typex in result:208                    if typex in obj_type.type_set:209                        valid.append((meth, typex))210                if len(valid) > 1:211                    error = f"Method \"{node.id}\" found in {len(valid)} unrelated types:\n"212                    error += "   -Found in: "213                    error += ", ".join(typex.name for _, typex in valid)214                    self.AddError(error)215                    obj_type = ErrorType()216                elif len(valid) == 0:217                    self.AddError(f"There is no method called {node.id} which takes {len(node.args)} paramters.")218                    obj_type == ErrorType()219                else:220                    method, types = valid[0]221                    obj_type.set_upper_limmit([types])222        node.inferenced_obj_type = self.compare_types(node.inferenced_obj_type, obj_type)223        if method:224            type_set = set()225            heads = []226            ret_type = self.update_type(method.return_type)227            heads, type_set = smart_add(type_set, heads, ret_type)228            if len(node.args) == len(method.param_types):229                for  i in range(len(node.args)):230                    arg, param_type = node.args[i], method.param_types[i]231                    arg_infer = arg.inferenced_type232                    self.visit(arg, scope)233                    arg_type = self.update_type(arg.inferenced_type)234                    arg_type = conforms(arg_type, param_type)235                    if isinstance(param_type, AutoType):236                        param_type = conforms(param_type, arg_type)237                        method.param_types[i] = self.compare_types(method.param_types[i], param_type)238                    arg.inferenced_type = self.compare_types(arg_infer, arg_type)239            240            inferred = node.inferenced_type241            if isinstance(ret_type, AutoType) and is_subset(inferred, ret_type):242                method.return_type.set_upper_limmit(heads)243                node.inferenced_type = self.compare_types(inferred, method.return_type)244            elif is_subset(ret_type, inferred):245                node.inferenced_type = self.compare_types(inferred, ret_type)246        else:247            node.inferenced_type = ErrorType()248    @visitor.when(OperationNode)249    def visit(self, node, scope):250        left_infer = node.left.inferenced_type251        self.visit(node.left, scope)252        left_type = self.update_type(node.left.inferenced_type)253        254        right_infer = node.right.inferenced_type255        self.visit(node.right, scope)256        right_type = self.update_type(node.right.inferenced_type)257        258        int_type = self.context.get_type("Int")259        if isinstance(left_type, AutoType):260            left_type.set_upper_limmit([int_type])261        node.left.inferenced_type = self.compare_types(left_infer, left_type)262        263        if isinstance(right_type, AutoType):264            right_type.set_upper_limmit([int_type])265        node.right.inferenced_type = self.compare_types(right_infer, right_type)266    @visitor.when(ComparisonNode)267    def visit(self, node, scope):268        left_infer = node.left.inferenced_type269        self.visit(node.left, scope)270        left_type = self.update_type(node.left.inferenced_type)271        right_infer = node.right.inferenced_type272        self.visit(node.right, scope)273        right_type = self.update_type(node.right.inferenced_type)274        left_type = conforms(left_type, right_type)275        node.left.inferenced_type = self.compare_types(left_infer, left_type)276        right_type = conforms(right_type, left_type)277        node.right.inferenced_type = self.compare_types(right_infer, right_type)278        279        node.inferenced_type = self.context.get_type("Bool")# if len(right_type.type_set) > 0 and len(left_type.type_set) > 0 else ErrorType()280        281    @visitor.when(NotNode)282    def visit(self, node, scope):283        lex_infer = node.lex.inferenced_type284        self.visit(node.lex, scope)285        lex_type = self.update_type(node.lex.inferenced_type)286        bool_type = self.context.get_type("Bool")287        if isinstance(lex_type, AutoType):288            lex_type.set_upper_limmit([bool_type])289        node.lex.inferenced_type = self.compare_types(lex_infer, lex_type)290        node.inferenced_type = bool_type291    292    @visitor.when(HyphenNode)293    def visit(self, node, scope):294        lex_infer = node.lex.inferenced_type295        self.visit(node.lex, scope)296        lex_type = self.update_type(node.lex.inferenced_type)297        int_type = self.context.get_type("Int")298        if isinstance(lex_type, AutoType):299            lex_type.set_upper_limmit([int_type])300        node.lex.inferenced_type = self.compare_types(lex_infer, lex_type)301        node.inferenced_type = int_type302    303    @visitor.when(IsVoidDeclarationNode)304    def visit(self, node, scope):305        lex_infer = node.lex.inferenced_type306        self.visit(node.lex, scope)307        lex_type = self.update_type(node.lex.inferenced_type)308        node.lex.inferenced_type = self.compare_types(lex_infer, lex_type)309    310    @visitor.when(VariableNode)311    def visit(self, node, scope):312        313        if node.define:314            var = scope.find_variable(node.lex)315            var.type = self.update_type(var.type)316            var_type =var.type317        else:318            var_type = ErrorType()319        node.inferenced_type = self.compare_types(node.inferenced_type, var_type)320    @visitor.when(InstantiateNode)321    def visit(self, node, scope):322        pass323    324    @visitor.when(ConstantNumNode)325    def visit(self, node, scope):326        pass327    328    @visitor.when(ConstantStringNode)329    def visit(self, node, scope):330        pass331    332    @visitor.when(ConstantBoolNode)333    def visit(self, node, scope):334        pass335    def update_type(self, typex:Type):336        if isinstance(typex, SelfType):337            typex = self.current_type338        return typex339    def compare_types(self, old_type, new_type):340        if isinstance(old_type, ErrorType) or isinstance(new_type, ErrorType):341            return ErrorType()342        343        if isinstance(old_type, AutoType) and isinstance(new_type, AutoType):344            if len(old_type.type_set) == len(new_type.type_set) and len(old_type.type_set.intersection(new_type.type_set)) == len(new_type.type_set):345                return new_type346            print(f"Chaged ocurred while comparing {old_type.name} and {new_type.name}")347            print("old_type set:", ", ".join(typex.name for typex in old_type.type_set))348            print("new_type set:", ", ".join(typex.name for typex in new_type.type_set))349            print("old_type cond:", [[typex.name for typex in type_set] for type_set in old_type.conditions_list])350            print("new_type cond:", [[typex.name for typex in type_set] for type_set in new_type.conditions_list])351            self.types_updated = True352            if len(new_type.type_set) > 0:353                return new_type...

test_union_type.py

Source:test_union_type.py

...15        StypyTypeError.reset_error_msgs()16        TypeWarning.reset_warning_msgs()17    def test_create_union_type_with_vars(self):18        union = UnionType.add(int, str)19        compare_types(union, [int, str])20        union2 = UnionType(union, list)21        compare_types(union, [int, str])22        compare_types(union2, [int, str, list])23        self.assertFalse(union == union2)24        clone = UnionType.add(int, str)25        self.assertTrue(union == clone)26    def test_create_union_type_with_funcs(self):27        def foo():28            pass29        union = UnionType.add(foo, range)30        compare_types(union, [foo, range])31        union2 = UnionType(union, getattr)32        compare_types(union, [foo, range])33        compare_types(union2, [foo, range, getattr])34        self.assertFalse(union == union2)35        clone = UnionType.add(foo, range)36        self.assertTrue(union == clone)37    def test_create_union_type_with_classes(self):38        class Foo:39            pass40        union = UnionType.add(Foo, AssertionError)41        compare_types(union, [Foo, AssertionError])42        union2 = UnionType(union, object)43        compare_types(union2, [Foo, AssertionError, object])44        clone = UnionType.add(Foo, AssertionError)45        self.assertFalse(union == union2)46        self.assertTrue(union == clone)47    def test_create_union_type_with_instances(self):48        class Foo:49            pass50        foo_inst = Foo()51        assert_inst = AssertionError()52        object_inst = object()53        union = UnionType.add(foo_inst, assert_inst)54        compare_types(union, [foo_inst, assert_inst])55        union2 = UnionType(union, object_inst)56        compare_types(union2, [foo_inst, assert_inst, object_inst])57        clone = UnionType.add(foo_inst, assert_inst)58        self.assertFalse(union == union2)59        self.assertTrue(union == clone)60        clone2 = UnionType.add(foo_inst, AssertionError())61        self.assertFalse(union == clone2)62    def test_create_union_type_with_modules(self):63        import math64        import sys65        import types66        union = UnionType.add(math, sys)67        compare_types(union, [math, sys])68        clone = UnionType.add(math, sys)69        compare_types(union, clone.types)70        union2 = UnionType.add(clone, types)71        compare_types(union2, [math, sys, types])72        self.assertFalse(union == union2)73    def test_create_union_type_with_mixed_types(self):74        int_var = int75        def fun():76            pass77        class Foo:78            def method(self):79                pass80            def method_2(self):81                pass82        class_var = Foo83        method_var = Foo.method84        instance_var = Foo()85        import math86        module_var = math87        union = UnionType.create_from_type_list([int_var, fun, class_var, method_var, instance_var,88                                                 module_var])89        compare_types(union, [int_var, fun, class_var, method_var, instance_var,90                              module_var])91        clone = UnionType.create_from_type_list([int_var, fun, class_var, method_var, instance_var,92                                                 module_var])93        compare_types(union, clone)94        method2_var = Foo.method_295        UnionType.add(clone, types)96        UnionType.add(clone, method2_var)97        compare_types(union, [int_var, fun, class_var, method_var, instance_var,98                              module_var])99        compare_types(clone, [int_var, fun, class_var, method_var, instance_var,100                              module_var, method2_var,101                              types102                              ])103    def test_merge_union_types(self):104        int_var = int105        def fun():106            pass107        class Foo:108            def method(self):109                pass110            def method_2(self):111                pass112        class_var = Foo113        method_var = Foo.method114        instance_var = Foo()115        import math116        module_var = math117        union1 = UnionType.create_from_type_list([int_var, fun, class_var])118        union2 = UnionType.create_from_type_list([method_var, instance_var,119                                                  module_var])120        compare_types(union1, [int_var, fun, class_var])121        compare_types(union2, [method_var, instance_var, module_var])122        fused_union = UnionType.add(union1, union2)123        compare_types(fused_union, [int_var, fun, class_var, method_var, instance_var,124                                    module_var])125        clone = UnionType.create_from_type_list([int_var, fun, class_var, method_var, instance_var,126                                                 module_var])127        compare_types(fused_union, clone)128        method2_var = Foo.method_2129        UnionType.add(clone, types)130        UnionType.add(clone, method2_var)131        compare_types(fused_union, [int_var, fun, class_var, method_var, instance_var,132                                    module_var])133        compare_types(clone, [int_var, fun, class_var, method_var, instance_var,134                              module_var, method2_var,135                              types])136        clone2 = UnionType.create_from_type_list([int_var, fun, class_var, method_var, instance_var,137                              module_var, method2_var,138                              types])139        self.assertFalse(fused_union == clone)140        compare_types(clone2, clone)141    # ############################## TYPE-BOUND TESTS ###############################142    def test_get_type_of_member(self):143        context = Context(None, __file__)144        # Access a member that none of the stored types has145        union1 = UnionType.add(int,146                               str)147        ret = union1.foo148        assert_if_not_error(ret)149        class Foo:150            att1 = int151            def method(self):152                pass153            def method_2(self):154                pass155        class Foo2:156            att1 = float157            def method(self):158                pass159            def method_2(self):160                pass161        # Access a member that can be provided only by some of the types in the union162        union2 = UnionType.add(Foo, str)163        ret = union2.method164        self.assertTrue(len(TypeWarning.get_warning_msgs()) == 1)165        TypeWarning.reset_warning_msgs()166        compare_types(ret, Foo.method)167        instance1 = Foo()168        union3 = UnionType.add(instance1, str)169        instance2 = Foo2()170        union3 = UnionType.add(instance2, union3)171        ret = union3.method172        self.assertTrue(len(TypeWarning.get_warning_msgs()) == 1)173        compare_types(ret, [instance1.method,174                            instance2.method,175                            ])176        TypeWarning.reset_warning_msgs()177        # Access a member that can be provided by all the types in the union178        union4 = UnionType.add(Foo, Foo2)179        self.assertTrue(len(TypeWarning.get_warning_msgs()) == 0)180        ret = union4.method181        compare_types(ret, [Foo.method,182                            Foo2.method])183        ret = union4.att1184        compare_types(ret, [int, float])185        # Access a member that can be provided by all the types in the union (using only Python types)186        union5 = UnionType.add(int, str)187        self.assertTrue(len(TypeWarning.get_warning_msgs()) == 0)188        context.set_type_of(self.loc, "union5", union5)189        # "__str__" is a special method so we have to use the context to access to it190        ret = context.get_type_of_member(self.loc, union5, "__str__")191        compare_types(ret, [int.__str__,192                            str.__str__])193    def test_set_type_of_member(self):194        # Set a member on non-modifiable types195        union1 = UnionType.add(int, str)196        union1.foo = int197        self.assertTrue(len(StypyTypeError.get_error_msgs()) == 1)198        class Foo:199            def method(self):200                pass201            def method_2(self):202                pass203        class Foo2:204            def method(self):205                pass206            def method_2(self):207                pass208        # Set a member with some of the types of the union able to be modified209        union2 = UnionType.add(Foo, str)210        union2.member = str211        self.assertTrue(len(TypeWarning.get_warning_msgs()) == 1)212        # TypeWarning.print_warning_msgs()213        compare_types(union2.member, str)214        self.assertTrue(len(TypeWarning.get_warning_msgs()) == 2)215        TypeWarning.reset_warning_msgs()216        instance1 = Foo()217        union3 = UnionType.add(instance1, str)218        instance2 = Foo2()219        union3 = UnionType.add(instance2, union3)220        union3.member = str221        self.assertTrue(len(TypeWarning.get_warning_msgs()) == 1)222        compare_types(union3.member, str)223        TypeWarning.reset_warning_msgs()224        StypyTypeError.reset_error_msgs()225        # Set a member using all-modifiable types226        union4 = UnionType.add(Foo, Foo2)227        self.assertTrue(len(TypeWarning.get_warning_msgs()) == 0)228        union4.member = float229        self.assertTrue(len(StypyTypeError.get_error_msgs()) == 0)230        self.assertTrue(len(TypeWarning.get_warning_msgs()) == 0)231        ret = union4.member232        compare_types(ret, float)233        def obj_func(cls):234            pass235        union4.class_method = types.MethodType(obj_func, union4)236        ret = union4.class_method237        compare_types(ret, types.MethodType(obj_func, union4))238    # # ############################## DYNAMIC INHERITANCE ###############################239    def test_change_type(self):240        # Set a member on non-modifiable types241        union1 = UnionType.add(int, str)242        union1.__class__ = int243        self.assertTrue(len(StypyTypeError.get_error_msgs()) == 1)244        class Foo:245            def method(self):246                pass247            def method_2(self):248                pass249        class Foo2:250            def method(self):251                pass252            def method_2(self):253                pass254        # Set a member with some of the types of the union able to be modified255        union2 = UnionType.add(Foo(), str)256        union2.__class__ = Foo2257        self.assertTrue(len(TypeWarning.get_warning_msgs()) == 1)258        # TypeWarning.print_warning_msgs()259        union_types = map(lambda x: type(x), union2.get_types())260        compare_types(union_types, [type(Foo2()), types.TypeType])261        TypeWarning.reset_warning_msgs()262        instance1 = Foo()263        union3 = UnionType.add(instance1, str)264        instance2 = Foo2()265        union3 = UnionType.add(instance2, union3)266        union3.__class__ = Foo2267        self.assertTrue(len(TypeWarning.get_warning_msgs()) == 1)268        union_types = map(lambda x: type(x), union2.get_types())269        compare_types(union_types, [type(Foo2()), types.TypeType])270        TypeWarning.reset_warning_msgs()271        StypyTypeError.reset_error_msgs()272        # Set a member using all-modifiable types273        foo1 = Foo()274        foo2 = Foo()275        union4 = UnionType.add(foo1, foo2)276        self.assertTrue(len(TypeWarning.get_warning_msgs()) == 0)277        self.assertTrue(len(StypyTypeError.get_error_msgs()) == 0)278        self.assertTrue(len(TypeWarning.get_warning_msgs()) == 0)279        ret = union4280        compare_types(ret, foo1)281    def test_change_base_types(self):282        # Set a member on non-modifiable types283        union1 = UnionType.add(int, str)284        union1.__bases__ = (int,)285        self.assertTrue(len(StypyTypeError.get_error_msgs()) == 1)286        class Foo:287            def method(self):288                pass289            def method_2(self):290                pass291        class Foo2:292            def method(self):293                pass294            def method_2(self):295                pass296        # Set a member with some of the types of the union able to be modified297        union2 = UnionType.add(Foo(), str)298        union2.__bases__ = (Foo2,)299        self.assertTrue(len(TypeWarning.get_warning_msgs()) == 1)300        # TypeWarning.print_warning_msgs()301        compare_types(union2.__bases__.types[0].contained_types, Foo2)302        compare_types(union2.__bases__.types[1].contained_types, str.__bases__[0])303        TypeWarning.reset_warning_msgs()304        instance1 = Foo()305        union3 = UnionType.add(instance1, str)306        instance2 = Foo2()307        union3 = UnionType.add(instance2, union3)308        union3.__bases__ = (Foo2,)309        self.assertTrue(len(TypeWarning.get_warning_msgs()) == 1)310        compare_types(union3.__bases__.types[0].contained_types, Foo2)311        compare_types(union3.__bases__.types[1].contained_types, str.__bases__[0])312        #compare_types(union3.__bases__, [(Foo2,), str.__bases__])313        TypeWarning.reset_warning_msgs()314        StypyTypeError.reset_error_msgs()315        # Set a member using all-modifiable types316        union4 = UnionType.add(Foo(), Foo())317        self.assertTrue(len(TypeWarning.get_warning_msgs()) == 0)318        union4.__bases__ = (Foo2,)319        self.assertTrue(len(StypyTypeError.get_error_msgs()) == 0)320        self.assertTrue(len(TypeWarning.get_warning_msgs()) == 0)321        ret = union4.__bases__...

match.py

Source:match.py

...32    assert isinstance(t2, _linda_server.Value) and t2.isType(), str(t2)33    assert t1.isId(), str(t1)34    assert t2.isId(), str(t2)35    return t1.id == t2.id36def compare_types(t1, t2, checked=None):37    assert t1.isType()38    assert t2.isType()39    if checked is None:40        checked = {(t1, t2): []}41    elif (t1, t2) in checked:42        return lambda x: convertValue(checked(t1, t2), x)43    else:44        checked[(t1, t2)] = []45    code = checked[(t1, t2)]46    print t1, t2, t1.isFunctionType(), t2.isFunctionType()47    if t1.isNil() and t2.isNil():48        code.append(("SETTYPEID", t2.type_id))49    elif t1.isId() and t2.isId():50        if t1.id in builtin and t2.id in builtin:51            if t1.id == t2.id:52                code.append(("SETTYPEID", t2.type_id))53                return lambda x: convertValue(checked[(t1, t2)], x)54            else:55                return None56        else:57            print t1.id, t2.id58            if t1.id not in builtin:59                nt = lookupType(t1.id_type_id)60                func = compare_types(nt, t2, checked)61                if func:62                    code.append(("EVAL", checked[(nt, t2)]))63                    return lambda x: convertValue(checked[(t1, t2)], x)64            if t2.id not in builtin:65                nt = lookupType(t2.id_type_id)66                func = compare_types(t1, nt, checked)67                if func:68                    code.append(("EVAL", checked[(t1, nt)]))69                    return lambda x: convertValue(checked[(t1, t2)], x)70            if t1.id not in builtin and t2.id not in builtin:71                nt1 = lookupType(t1.id_type_id)72                nt2 = lookupType(t2.id_type_id)73                func = compare_types(nt1, nt2, checked)74                if func:75                    code.append(("EVAL", checked[(nt1, nt2)]))76                    return lambda x: convertValue(checked[(t1, t2)], x)77                else:78                    return None79    elif t1.isProductType() and t2.isProductType():80        t1e = flattenProductType(t1)81        t2e = flattenProductType(t2)82        if len(t1e) != len(t2e):83            return None84        funcs = []85        for e1, e2 in zip(t1e, t2e):86            f = compare_types(e1, e2, checked)87            if f is None:88                return89            else:90                funcs.append(checked[(e1, e2)])91        code.append(("EXPLODE", t1))92        for i in range(len(funcs)):93            code.append(("EVAL", funcs[i]))94            code.append(("ROTATE", ))95        code.append(("CONSTRUCT", t2))96        code.append(("SETTYPEID", t2.type_id))97        return lambda x: convertValue(checked[(t1, t2)], x)98    elif t1.isSumType() and t2.isSumType():99        t1e = flattenSumType(t1)100        t2e = flattenSumType(t2)101        if len(t1e) != len(t2e):102            return None103        for perm in all_perms(range(len(t2))):104            funcs = []105            for i in range(len(perm)):106                f = compare_types(t1e[i][0], t2e[perm[i]][0], checked)107                if f is None:108                    break109                else:110                    funcs.append(checked[(t1e[i][0], t2e[perm[i]][0])])111                    for pos in t2e[perm[i]][1][::-1]:112                        funcs[-1].append(("CREATESUM", perm[i]))113            if len(funcs) == len(perm):114                code.append(("SUMCASE", funcs))115        code.append(("SETTYPEID", t2.type_id))116        return lambda x: convertValue(checked[(t1, t2)], x)117    elif t1.isPtrType() and t2.isPtrType():118        f = compare_types(t1.ptrtype, t2.ptrtype, checked)119        if f is None:120            return121        code.append(("PTRCONV", checked[(t1.ptrtype, t2.ptrtype)]))122        return lambda x: convertValue(checked[(t1, t2)], x)123    elif t1.isFunctionType() and t2.isFunctionType():124        print "got functions", t1, t2125        arg = compare_types(t1.arg, t2.arg, checked)126        if arg is None:127            return None128        result = compare_types(t2.result, t1.result, checked)129        if result is None:130            return None131        return lambda x: wrap_function(t2.arg, checked[(t1.arg, t2.arg)], t2.result, checked[(t2.result, t1.result)], x)132def flattenProductType(p, memo = None):133    if memo is None:134        memo = {}135    if p.type_id:136        memo[p.type_id] = True137    l = []138    for i in range(len(p)):139        e = p[i]140        if e.isProductType():141            l.extend(flattenProductType(e, memo))142        elif e.isId() and not e.id in builtin:...

Playwright tutorial

LambdaTest’s Playwright tutorial will give you a broader idea about the Playwright automation framework, its unique features, and use cases with examples to exceed your understanding of Playwright testing. This tutorial will give A to Z guidance, from installing the Playwright framework to some best practices and advanced concepts.

Chapters:

What is Playwright : Playwright is comparatively new but has gained good popularity. Get to know some history of the Playwright with some interesting facts connected with it.
How To Install Playwright : Learn in detail about what basic configuration and dependencies are required for installing Playwright and run a test. Get a step-by-step direction for installing the Playwright automation framework.
Playwright Futuristic Features: Launched in 2020, Playwright gained huge popularity quickly because of some obliging features such as Playwright Test Generator and Inspector, Playwright Reporter, Playwright auto-waiting mechanism and etc. Read up on those features to master Playwright testing.
What is Component Testing: Component testing in Playwright is a unique feature that allows a tester to test a single component of a web application without integrating them with other elements. Learn how to perform Component testing on the Playwright automation framework.
Inputs And Buttons In Playwright: Every website has Input boxes and buttons; learn about testing inputs and buttons with different scenarios and examples.
Functions and Selectors in Playwright: Learn how to launch the Chromium browser with Playwright. Also, gain a better understanding of some important functions like “BrowserContext,” which allows you to run multiple browser sessions, and “newPage” which interacts with a page.
Handling Alerts and Dropdowns in Playwright : Playwright interact with different types of alerts and pop-ups, such as simple, confirmation, and prompt, and different types of dropdowns, such as single selector and multi-selector get your hands-on with handling alerts and dropdown in Playright testing.
Playwright vs Puppeteer: Get to know about the difference between two testing frameworks and how they are different than one another, which browsers they support, and what features they provide.
Run Playwright Tests on LambdaTest: Playwright testing with LambdaTest leverages test performance to the utmost. You can run multiple Playwright tests in Parallel with the LammbdaTest test cloud. Get a step-by-step guide to run your Playwright test on the LambdaTest platform.
Playwright Python Tutorial: Playwright automation framework support all major languages such as Python, JavaScript, TypeScript, .NET and etc. However, there are various advantages to Python end-to-end testing with Playwright because of its versatile utility. Get the hang of Playwright python testing with this chapter.
Playwright End To End Testing Tutorial: Get your hands on with Playwright end-to-end testing and learn to use some exciting features such as TraceViewer, Debugging, Networking, Component testing, Visual testing, and many more.
Playwright Video Tutorial: Watch the video tutorials on Playwright testing from experts and get a consecutive in-depth explanation of Playwright automation testing.