Python declarations.find_declaration函数代码示例

    def __test_type_transformation(self, ns_name, transformer):
        ns_control = declarations.find_declaration(
            self.declarations,
            decl_type=declarations.namespace_t,
            name=ns_name)
        self.assertTrue(ns_control, "unable to find '%s' namespace" % ns_name)
        ns_before = declarations.find_declaration(
            ns_control,
            decl_type=declarations.namespace_t,
            name='before')
        self.assertTrue(ns_before, "unable to find 'before' namespace")
        ns_after = declarations.find_declaration(
            ns_control,
            decl_type=declarations.namespace_t,
            name='after')
        self.assertTrue(ns_after, "unable to find 'after' namespace")

        for tbefore in ns_before.declarations:
            tafter = declarations.find_declaration(
                ns_after,
                name=tbefore.name)
            self.assertTrue(
                tafter,
                "unable to find transformed type definition for type '%s'" %
                tbefore.decl_string)
            transformed = transformer(tbefore)
            self.assertTrue(
                declarations.is_same(
                    transformed,
                    tafter),
                ("there is a difference between expected type '{0}' " +
                 "and result '{1}'. typedef name: {2}").format(
                    declarations.remove_declarated(tafter).decl_string,
                    declarations.remove_declarated(transformed).decl_string,
                    tbefore.decl_string))

    def test_is_base_and_derived(self):
        ns = declarations.find_declaration(
            self.declarations,
            type=declarations.namespace_t,
            name='is_base_and_derived')
        self.failUnless(ns, "unable to find 'is_base_and_derived' namespace")
        base = declarations.find_declaration(
            ns.declarations,
            type=declarations.class_t,
            name='base')
        derived = declarations.find_declaration(
            ns.declarations,
            type=declarations.class_t,
            name='derived')
        self.failUnless(
            base and derived and declarations.is_base_and_derived(
                base,
                derived))
        self.failUnless(
            base and derived and
            declarations.is_base_and_derived(base, (derived, derived)))

        unrelated1 = declarations.find_declaration(
            ns.declarations,
            type=declarations.class_t,
            name='unrelated1')

        unrelated2 = declarations.find_declaration(
            ns.declarations,
            type=declarations.class_t,
            name='unrelated2')
        self.failUnless(
            base and derived and not declarations.is_base_and_derived(
                unrelated1,
                unrelated2))

    def __test_type_category(self, ns_name, controller):
        ns_control = declarations.find_declaration(
            self.declarations,
            type=declarations.namespace_t,
            name=ns_name)
        self.failUnless(ns_control, "unable to find '%s' namespace" % ns_name)
        ns_yes = declarations.find_declaration(
            ns_control,
            type=declarations.namespace_t,
            name='yes')
        self.failUnless(ns_yes, "unable to find 'yes' namespace")
        ns_no = declarations.find_declaration(
            ns_control,
            type=declarations.namespace_t,
            name='no')
        self.failUnless(ns_no, "unable to find 'no' namespace")
        er = 'for type "%s" the answer to the question "%s" should be True'
        for decl in ns_yes.declarations:
            if isinstance(decl, declarations.variable_t):
                self.failUnless(
                    controller(decl.type),
                    er % (decl.type.decl_string, ns_name))
            elif isinstance(decl, declarations.calldef_t) and \
                    decl.name.startswith('test_'):
                continue
            else:
                self.failUnless(
                    controller(decl), er % (decl.decl_string, ns_name))
        er = 'for type "%s" the answer to the question "%s" should be False'
        for decl in ns_no.declarations:
            if isinstance(decl, declarations.calldef_t) and \
                    decl.name.startswith('test_'):
                continue

            self.failIf(controller(decl), er % (decl.decl_string, ns_name))

    def __test_type_transformation(self, ns_name, transformer):
        ns_control = declarations.find_declaration(
            self.declarations,
            type=declarations.namespace_t,
            name=ns_name)
        self.failUnless(ns_control, "unable to find '%s' namespace" % ns_name)
        ns_before = declarations.find_declaration(
            ns_control,
            type=declarations.namespace_t,
            name='before')
        self.failUnless(ns_before, "unable to find 'before' namespace")
        ns_after = declarations.find_declaration(
            ns_control,
            type=declarations.namespace_t,
            name='after')
        self.failUnless(ns_after, "unable to find 'after' namespace")

        for tbefore in ns_before.declarations:
            tafter = declarations.find_declaration(
                ns_after,
                name=tbefore.name)
            self.failUnless(
                tafter,
                "unable to find transformed type definition for type '%s'" %
                tbefore.decl_string)
            transformed = transformer(tbefore)
            self.failUnless(
                declarations.is_same(
                    transformed,
                    tafter),
                ("there is a difference between expected type and result. " +
                 "typedef name: %s") % tbefore.decl_string)

 def __is_convertible_impl( self, decl ):
     defs = decl.bases[0].related_class.declarations
     source_type = declarations.find_declaration( defs, name='source_type' )
     target_type = declarations.find_declaration( defs, name='target_type' )
     expected_type = declarations.find_declaration( defs
                                                    , name='expected'
                                                    , type=declarations.enumeration_t )
     expected_value = bool( expected_type.get_name2value_dict()['value'] )
     self.failUnless( expected_value == declarations.is_convertible( source_type, target_type )
                      , 'Check conversion failed for ' + decl.name )

 def __check_result(self, decls):
     E11 = declarations.find_declaration(decls, fullname='::E11')
     self.assertTrue(E11, "unable to find 'E11' enum")
     ns12 = declarations.find_declaration(decls, fullname='::ns::ns12')
     self.assertTrue(ns12, "unable to find 'ns12' namespace")
     E13 = declarations.find_declaration(ns12.declarations, name='E13')
     self.assertTrue(E13, "unable to find 'E13' enum")
     E14 = declarations.find_declaration(decls, name='E14')
     self.assertTrue(
         not E14,
         "enum 'E14' should not be found in declarations")

 def __is_convertible_impl( self, decl ):
     if decl.name == 'x81':
         i = 0
     defs = decl.bases[0].related_class.declarations
     source_type = declarations.find_declaration( defs, name='source_type' )
     target_type = declarations.find_declaration( defs, name='target_type' )
     expected_type = declarations.find_declaration( defs
                                                    , name='expected'
                                                    , type=declarations.enumeration_t )
     expected_value = bool( expected_type.get_name2value_dict()['value'] )
     if expected_value != declarations.is_convertible( source_type, target_type ):
         print decl.name

 def test_numeric_patcher(self):
     fix_numeric = declarations.find_declaration( self.__decls, type=declarations.free_function_t, name='fix_numeric' )
     self.failUnless( fix_numeric, "Free function fix_numeric has not been found." )
     if 32 == self.architecture:
         self.failUnless( fix_numeric.arguments[0].default_value == u"0xffffffffffffffff" )
     else: 
         self.failUnless( fix_numeric.arguments[0].default_value == u"0ffffffff" )

 def setUp(self):
     if not self.declarations:
         self.declarations = parser.parse( [self.header], self.config )
         self.global_ns = declarations.find_declaration( self.declarations
                                                         , type=declarations.namespace_t
                                                         , name='::' )
         self.global_ns.init_optimizer()

    def test_is_convertible( self ):
        ns_is_convertible = declarations.find_declaration( self.declarations
                                                           , type=declarations.namespace_t
                                                           , name="is_convertible" )

        self.failUnless( ns_is_convertible, "namespace is_convertible was not found" )
        for tester in filter( lambda decl: decl.name.startswith( 'x' ), ns_is_convertible.declarations ):
            self.__is_convertible_impl( tester )

    def __test_type_category(self, ns_name, controller):
        ns_control = declarations.find_declaration(
            self.declarations,
            decl_type=declarations.namespace_t,
            name=ns_name)
        self.assertTrue(ns_control, "unable to find '%s' namespace" % ns_name)
        ns_yes = declarations.find_declaration(
            ns_control,
            decl_type=declarations.namespace_t,
            name='yes')
        self.assertTrue(ns_yes, "unable to find 'yes' namespace")
        ns_no = declarations.find_declaration(
            ns_control,
            decl_type=declarations.namespace_t,
            name='no')
        self.assertTrue(ns_no, "unable to find 'no' namespace")
        er = 'for type "%s" the answer to the question "%s" should be True'
        for decl in ns_yes.declarations:
            if isinstance(decl, declarations.variable_t):
                self.assertTrue(
                    controller(decl.decl_type),
                    er % (decl.decl_type.decl_string, ns_name))
            elif isinstance(decl, declarations.calldef_t) and \
                    decl.name.startswith('test_'):
                continue
            else:
                self.assertTrue(
                    controller(decl), er % (decl.decl_string, ns_name))
        er = 'for type "%s" the answer to the question "%s" should be False'
        generator = self.xml_generator_from_xml_file
        for decl in ns_no.declarations:
            if isinstance(decl, declarations.calldef_t) and \
                    decl.name.startswith('test_'):
                continue

            if generator.is_castxml1 or (
                    generator.is_castxml and
                    float(generator.xml_output_version) < 1.138):
                if decl.name in ['const_item', 'const_container']:
                    # Skip this test to workaround CastXML bug.
                    # See https://github.com/CastXML/CastXML/issues/55
                    continue

            self.assertFalse(
                controller(decl),
                er % (decl.decl_string, ns_name))

 def test( self ):                
     item_cls = declarations.find_declaration( self.declarations
                                           , type=declarations.class_t
                                           , name='item_t' )
     self.failUnless( item_cls, "unable to find class 'item_t'" )
     self.failUnless( len( item_cls.aliases ) == 3 )
     expected_aliases = set( ['Item', 'Item1', 'Item2' ] )
     real_aliases = set( map( lambda typedef: typedef.name, item_cls.aliases ) )
     self.failUnless( real_aliases == expected_aliases )

 def test(self):
     item_cls = declarations.find_declaration(
         self.declarations,
         type=declarations.class_t,
         name='item_t')
     self.assertTrue(item_cls, "unable to find class 'item_t'")
     self.assertTrue(len(item_cls.aliases) == 3)
     expected_aliases = set(['Item', 'Item1', 'Item2'])
     real_aliases = set([typedef.name for typedef in item_cls.aliases])
     self.assertTrue(real_aliases == expected_aliases)

    def test(self):
        fconfig = parser.file_configuration_t(
            data="int i;", start_with_declarations=None, content_type=parser.file_configuration_t.CONTENT_TYPE.TEXT
        )

        prj_reader = parser.project_reader_t(self.config)
        decls = prj_reader.read_files([fconfig], compilation_mode=parser.COMPILATION_MODE.FILE_BY_FILE)

        var_i = declarations.find_declaration(decls, type=declarations.variable_t, name="i")
        self.failUnless(var_i, "Variable i has not been found.")

    def test_is_convertible(self):
        ns_is_convertible = declarations.find_declaration(
            self.declarations,
            type=declarations.namespace_t,
            name="is_convertible")

        self.failUnless(
            ns_is_convertible,
            "namespace is_convertible was not found")
        for tester in [
            decl for decl in ns_is_convertible.declarations if
                decl.name.startswith('x')]:

            self.__is_convertible_impl(tester)