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 __test_type_category(self, ns_name, controller): ns_control = declarations.find_declaration( self.declarations, 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, type=declarations.namespace_t, name='yes') self.assertTrue(ns_yes, "unable to find 'yes' namespace") ns_no = declarations.find_declaration(ns_control, 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.type), er % (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' 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, 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_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, decl_type=declarations.namespace_t, name='is_base_and_derived') self.assertTrue(ns, "unable to find 'is_base_and_derived' namespace") base = declarations.find_declaration(ns.declarations, decl_type=declarations.class_t, name='base') derived = declarations.find_declaration(ns.declarations, decl_type=declarations.class_t, name='derived') self.assertTrue(base and derived and declarations.is_base_and_derived(base, derived)) self.assertTrue( base and derived and declarations.is_base_and_derived(base, (derived, derived))) unrelated1 = declarations.find_declaration( ns.declarations, decl_type=declarations.class_t, name='unrelated1') unrelated2 = declarations.find_declaration( ns.declarations, decl_type=declarations.class_t, name='unrelated2') self.assertTrue( base and derived and not declarations.is_base_and_derived(unrelated1, unrelated2))
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 __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 __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): 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', decl_type=declarations.enumeration_t) expected_value = bool(expected_type.get_name2value_dict()['value']) self.assertTrue( expected_value == declarations.is_convertible( source_type, target_type), 'Check conversion failed for ' + decl.name)
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(self): item_cls = declarations.find_declaration( self.declarations, decl_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 = {'Item', 'Item1', 'Item2'} real_aliases = set([typedef.name for typedef in item_cls.aliases]) self.assertTrue(real_aliases == expected_aliases)
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 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( 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.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_type_category(self, ns_name, controller): ns_control = declarations.find_declaration( self.declarations, 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, type=declarations.namespace_t, name='yes') self.assertTrue(ns_yes, "unable to find 'yes' namespace") ns_no = declarations.find_declaration( ns_control, 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.type), er % (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' for decl in ns_no.declarations: if isinstance(decl, declarations.calldef_t) and \ decl.name.startswith('test_'): continue if ("CastXML" in utils.xml_generator and utils.xml_output_version < 1.138 and 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.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 filter(lambda decl: decl.name.startswith('x'), ns_is_convertible.declarations): self.__is_convertible_impl(tester)
def test_is_unary_binary_operator(self): operator_not = declarations.find_declaration( self.declarations, decl_type=declarations.operator_t, fullname='::is_unary_operator::dummy::operator!') self.assertTrue(operator_not, 'operator! was not found') self.assertTrue(declarations.is_unary_operator(operator_not), 'operator! should be idenitified as unary operator') self.assertTrue(not declarations.is_binary_operator(operator_not), 'operator! should be idenitified as unary operator') operator_class_p = declarations.find_declaration( self.declarations, decl_type=declarations.operator_t, fullname='::is_unary_operator::dummy::operator+') self.assertTrue(operator_class_p, 'operator+ was not found') self.assertTrue(not declarations.is_unary_operator(operator_class_p), 'operator+ should be idenitified as binary operator') self.assertTrue(declarations.is_binary_operator(operator_class_p), 'operator! should be idenitified as binary operator') operator_class_pp = declarations.find_declaration( self.declarations, decl_type=declarations.operator_t, fullname='::is_unary_operator::dummy::operator++') self.assertTrue(operator_class_pp, 'operator++ was not found') self.assertTrue(declarations.is_unary_operator(operator_class_pp), 'operator++ should be idenitified as unary operator') self.assertTrue(not declarations.is_binary_operator(operator_class_pp), 'operator++ should be idenitified as unary operator') operator_pp = declarations.find_declaration( self.declarations, decl_type=declarations.operator_t, fullname='::is_unary_operator::operator++') self.assertTrue(operator_pp, 'operator++ was not found') self.assertTrue(declarations.is_unary_operator(operator_pp), 'operator++ should be idenitified as unary operator') self.assertTrue(not declarations.is_binary_operator(operator_pp), 'operator++ should be idenitified as unary operator') operator_mm = declarations.find_declaration( self.declarations, decl_type=declarations.operator_t, fullname='::is_unary_operator::operator*') self.assertTrue(operator_mm, 'operator-- was not found') self.assertTrue(not declarations.is_unary_operator(operator_mm), 'operator-- should be idenitified as binary operator') self.assertTrue(declarations.is_binary_operator(operator_mm), 'operator-- should be idenitified as binray operator') operator_pe = declarations.find_declaration( self.declarations, decl_type=declarations.operator_t, fullname='::is_unary_operator::operator+=') self.assertTrue(operator_pe, 'operator+= was not found') self.assertTrue(not declarations.is_unary_operator(operator_pe), 'operator+= should be idenitified as binary operator') self.assertTrue(declarations.is_binary_operator(operator_pe), 'operator+= should be idenitified as binray operator')
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, decl_type=declarations.variable_t, name='i') self.assertTrue(var_i, "Variable i has not been found.")
def test_is_convertible(self): ns_is_convertible = declarations.find_declaration( self.declarations, decl_type=declarations.namespace_t, name="is_convertible") self.assertTrue(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)
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)
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 test_by_location(self): reader = parser.source_reader_t( self.config ) decls = reader.read_file( self.__fname ) decls_count = len( declarations.make_flatten( decls ) ) filtered = declarations.filtering.by_location( decls, [autoconfig.data_directory] ) flatten_filtered = declarations.make_flatten( filtered ) self.failUnless( len( flatten_filtered ) != decls_count ) for decl in flatten_filtered: if decl.location: self.failUnless( declarations.filtering.normalize_path( decl.location.file_name ) , self.__fpath ) self.failUnless( declarations.find_declaration( filtered , name='color' , type=declarations.enumeration_t , recursive=False) )
def test_is_unary_binary_operator(self): operator_not = declarations.find_declaration( self.declarations , type=declarations.operator_t , fullname='::is_unary_operator::dummy::operator!' ) self.failUnless( operator_not, 'operator! was not found' ) self.failUnless( declarations.is_unary_operator( operator_not ), 'operator! should be idenitified as unary operator' ) self.failUnless( not declarations.is_binary_operator( operator_not ), 'operator! should be idenitified as unary operator' ) operator_class_p = declarations.find_declaration( self.declarations , type=declarations.operator_t , fullname='::is_unary_operator::dummy::operator+' ) self.failUnless( operator_class_p, 'operator+ was not found' ) self.failUnless( not declarations.is_unary_operator( operator_class_p ), 'operator+ should be idenitified as binary operator' ) self.failUnless( declarations.is_binary_operator( operator_class_p ), 'operator! should be idenitified as binary operator' ) operator_class_pp = declarations.find_declaration( self.declarations , type=declarations.operator_t , fullname='::is_unary_operator::dummy::operator++' ) self.failUnless( operator_class_pp, 'operator++ was not found' ) self.failUnless( declarations.is_unary_operator( operator_class_pp ), 'operator++ should be idenitified as unary operator' ) self.failUnless( not declarations.is_binary_operator( operator_class_pp ), 'operator++ should be idenitified as unary operator' ) operator_pp = declarations.find_declaration( self.declarations , type=declarations.operator_t , fullname='::is_unary_operator::operator++' ) self.failUnless( operator_pp, 'operator++ was not found' ) self.failUnless( declarations.is_unary_operator( operator_pp ), 'operator++ should be idenitified as unary operator' ) self.failUnless( not declarations.is_binary_operator( operator_pp ), 'operator++ should be idenitified as unary operator' ) operator_mm = declarations.find_declaration( self.declarations , type=declarations.operator_t , fullname='::is_unary_operator::operator*' ) self.failUnless( operator_mm, 'operator-- was not found' ) self.failUnless( not declarations.is_unary_operator( operator_mm ), 'operator-- should be idenitified as binary operator' ) self.failUnless( declarations.is_binary_operator( operator_mm ), 'operator-- should be idenitified as binray operator' ) operator_pe = declarations.find_declaration( self.declarations , type=declarations.operator_t , fullname='::is_unary_operator::operator+=' ) self.failUnless( operator_pe, 'operator+= was not found' ) self.failUnless( not declarations.is_unary_operator( operator_pe ), 'operator+= should be idenitified as binary operator' ) self.failUnless( declarations.is_binary_operator( operator_pe ), 'operator+= should be idenitified as binray operator' )
def test_enum_patcher(self): fix_enum = declarations.find_declaration( self.__decls, type=declarations.free_function_t, name='fix_enum' ) self.failUnless( fix_enum, "Free function fix_enum has not been found." ) self.failUnless( fix_enum.arguments[0].default_value == '::ns1::ns2::apple' )
def test_unnamed_enum_patcher(self): fix_unnamed = declarations.find_declaration( self.__decls, type=declarations.free_function_t, name='fix_unnamed' ) self.failUnless( fix_unnamed, "Free function fix_unnamed has not been found." ) self.failUnless( fix_unnamed.arguments[0].default_value == u"int(::fx::unnamed)" )
def test_function_call_patcher(self): fix_function_call = declarations.find_declaration( self.__decls, type=declarations.free_function_t, name='fix_function_call' ) self.failUnless( fix_function_call, "Free function fix_function_call has not been found." ) self.failUnless( fix_function_call.arguments[0].default_value == u"function_call::calc( 1, 2, 3 )" )
def test_fundamental_patcher(self): fcall = declarations.find_declaration( self.__decls, type=declarations.free_function_t, name='fix_fundamental' ) self.failUnless( fcall, "Free function fix_function_call has not been found." ) self.failUnless( fcall.arguments[0].default_value == u"(unsigned int)(::fundamental::eggs)" )
def test_constructor_patcher(self): typedef__func = declarations.find_declaration( self.__decls, type=declarations.free_function_t, name='typedef__func' ) self.failUnless( typedef__func, "Free function typedef__func has not been found." ) self.failUnless( typedef__func.arguments[0].default_value == u"::typedef_::alias( )" )