def test__includepath(self): # lolo must not be seen in lo's include path since nothing is # built there lodir_builder = self.__package.rootbuilder().find_entry_builder(['lo']) self.failIf(lodir_builder is None) # paranoia lodir_output_builder = find_automake_output_builder(lodir_builder) self.failIf(lodir_output_builder is None) self.failIf('-I/the/include/path/of/lolo' in lodir_output_builder.makefile_am().includepath()) # hi is building something, so we should definitely see # include paths. lo must come before lolo in hi's include # path. hidir_builder = self.__package.rootbuilder().find_entry_builder(['hi']) self.failIf(hidir_builder is None) hidir_output_builder = find_automake_output_builder(hidir_builder) self.failIf(hidir_output_builder is None) pos_lo = pos_lolo = None i = -1 for ip in hidir_output_builder.makefile_am().includepath(): i += 1 if ip == '-I/the/include/path/of/lolo': pos_lolo = i continue if ip == '-I/the/include/path/of/lo': pos_lo = i continue pass self.failIf(pos_lo is None) self.failIf(pos_lolo is None) self.failUnless(pos_lo < pos_lolo) pass
def output(self): automake_output_builder = find_automake_output_builder( self.parentbuilder()) super(HeaderOutputBuilder, self).output() for header in self.parentbuilder().iter_builders(): if not isinstance(header, HeaderBuilder): continue visibility = header.visibility() package_visibility_action = header.package_visibility_action() if header.public(): automake_output_builder.file_installer().add_public_header( filename=header.file().name(), dir=visibility) else: automake_output_builder.file_installer().add_noinst_header( filename=header.file().name()) pass assert package_visibility_action[0] in \ (HeaderBuilder.LOCALVISIBILITY_INSTALL, HeaderBuilder.LOCALVISIBILITY_DIRECT_INCLUDE) if package_visibility_action[ 0] == HeaderBuilder.LOCALVISIBILITY_INSTALL: automake_output_builder.file_installer().add_private_header( filename=header.file().name(), dir=package_visibility_action[1]) elif package_visibility_action[ 0] == HeaderBuilder.LOCALVISIBILITY_DIRECT_INCLUDE: pass else: assert False, package_visibility_action[0] pass pass pass
def output(self): super(AutomakeScriptOutputBuilder, self).output() output_builder = None for script in self.parentbuilder().iter_builders(): if isinstance(script, ScriptBuilder): if output_builder is None: output_builder = find_automake_output_builder( self.parentbuilder()) assert output_builder is not None pass if script.what() == ScriptBuilder.BIN: output_builder.makefile_am().add_bin_script( scriptname=script.file().name()) elif script.what() == ScriptBuilder.CHECK: output_builder.makefile_am().add_check_script( scriptname=script.file().name()) else: assert False pass pass pass pass
def test__library(self): rootdir = Directory() rootdir.add( name=const.CONFIX2_PKG, entry=File(lines=["PACKAGE_NAME('LibtoolInMemoryTest.testLibrary')", "PACKAGE_VERSION('1.2.3')"])) rootdir.add( name=const.CONFIX2_DIR, entry=File(lines=["LIBRARY(members=[C(filename='file.c')])"])) rootdir.add( name='file.c', entry=File()) package = LocalPackage(rootdirectory=rootdir, setups=[ExplicitSetup(use_libtool=True)]) package.boil(external_nodes=[]) package.output() library_builder = None for b in package.rootbuilder().iter_builders(): if isinstance(b, LibraryBuilder): self.failUnless(library_builder is None) library_builder = b pass pass self.failIf(library_builder is None) automake_output_builder = find_automake_output_builder(package.rootbuilder()) self.failUnless('lib'+library_builder.basename()+'.la' in automake_output_builder.makefile_am().ltlibraries()) pass
def test(self): source = source_tree(testname=self.__class__.__name__) lo_dir = source.get('lo') hi_dir = source.get('hi') lo_pkg = LocalPackage(rootdirectory=lo_dir, setups=[ConfixSetup(use_libtool=False)]) lo_pkg.boil(external_nodes=[]) lo_pkg_inst = lo_pkg.install() hi_pkg = LocalPackage(rootdirectory=hi_dir, setups=[ConfixSetup(use_libtool=False)]) hi_pkg.boil(external_nodes=lo_pkg_inst.nodes()) hi_pkg.output() hi_pkg_rootdir_output_builder = find_automake_output_builder( hi_pkg.rootbuilder()) self.failIf(hi_pkg_rootdir_output_builder is None) makefile_am = hi_pkg_rootdir_output_builder.makefile_am() self.failUnless( '$(readonly_prefixes_incpath)' in makefile_am.includepath()) print hi_ldadd = makefile_am.compound_ldadd(self.__class__.__name__ + '-hi_main') self.failIf(hi_ldadd is None) self.failUnless('$(readonly_prefixes_libpath)' in hi_ldadd) pass
def output(self): super(AutomakePlainfileOutputBuilder, self).output() output_builder = None for b in self.parentbuilder().iter_builders(): if type(b) is PlainFileBuilder: if output_builder is None: output_builder = find_automake_output_builder( self.parentbuilder()) assert output_builder is not None pass output_builder.makefile_am().add_extra_dist(b.file().name()) if b.datadir() is not None: output_builder.file_installer().add_datafile( filename=b.file().name(), dir=b.datadir()) elif b.prefixdir() is not None: output_builder.file_installer().add_prefixfile( filename=b.file().name(), dir=b.prefixdir()) else: assert 0 pass pass pass pass
def setUp(self): self.fs_ = dirhier.packageroot() liblo = self.fs_.rootdirectory().add(name='lo', entry=Directory()) liblo.add(name=const.CONFIX2_DIR, entry=File(lines=["LIBRARY_VERSION((1,2,3))"])) liblo.add(name='lo.h', entry=File(lines=[ '#ifndef LO_H', '# define LO_H', '#endif', 'void lo();' ])) liblo.add(name='lo.c', entry=File(lines=['void lo() {}'])) self.package_ = LocalPackage( rootdirectory=self.fs_.rootdirectory(), setups=[ConfixSetup(use_libtool=self.use_libtool())]) self.package_.boil(external_nodes=[]) self.package_.output() self.lodir_builder_ = self.package_.rootbuilder().find_entry_builder( ['lo']) self.failIf(self.lodir_builder_ is None) self.lodir_output_builder_ = find_automake_output_builder( self.lodir_builder_) self.failIf(self.lodir_output_builder_ is None) self.lolib_builder_ = None for b in self.lodir_builder_.iter_builders(): if isinstance(b, LibraryBuilder): self.lolib_builder_ = b pass pass assert self.lolib_builder_ is not None pass
def test__with_explicit_setup(self): filesys = FileSystem(path=[]) filesys.rootdirectory().add( name=const.CONFIX2_PKG, entry=File(lines=[ 'PACKAGE_NAME("CheckProgramTest")', 'PACKAGE_VERSION("1.2.3")' ])) filesys.rootdirectory().add( name=const.CONFIX2_DIR, entry=File(lines=[ "TESTS_ENVIRONMENT('name', 'value')", "EXECUTABLE(center=C(filename='main.c'),", " exename='the-test-program',", " what=EXECUTABLE_CHECK)" ])) filesys.rootdirectory().add(name='main.c', entry=File(lines=['int main(void) {}'])) package = LocalPackage(rootdirectory=filesys.rootdirectory(), setups=[ExplicitSetup(use_libtool=False)]) package.boil(external_nodes=[]) package.output() rootdir_output_builder = find_automake_output_builder( package.rootbuilder()) self.failIf(rootdir_output_builder is None) self.failUnless('the-test-program' in rootdir_output_builder.makefile_am().check_programs()) self.failUnlessEqual( len(rootdir_output_builder.makefile_am().tests_environment()), 1) self.failUnlessEqual( rootdir_output_builder.makefile_am().tests_environment()['name'], 'value')
def output(self): super(YaccOutputBuilder, self).output() automake_output_builder = find_automake_output_builder( self.parentbuilder()) for b in self.parentbuilder().iter_builders(): if not isinstance(b, YaccBuilder): continue automake_output_builder.configure_ac().add_paragraph( paragraph=Paragraph(['AC_PROG_YACC']), order=Configure_ac.PROGRAMS) root, ext = os.path.splitext(b.file().name()) if ext == '.y': automake_output_builder.configure_ac().add_paragraph( paragraph=Paragraph(['AC_PROG_CC']), order=Configure_ac.PROGRAMS) automake_output_builder.makefile_am().add_built_sources(root + '.c') elif ext == '.yy': automake_output_builder.configure_ac().add_paragraph( paragraph=Paragraph(['AC_PROG_CXX']), order=Configure_ac.PROGRAMS) automake_output_builder.makefile_am().add_built_sources(root + '.cc') # force Yacc to output files named y.tab.h automake_output_builder.makefile_am().add_am_yflags('-d') else: assert 0 pass pass pass
def test__plain_output(self): dirstructure = DirectoryStructure(path=self.rootpath()) # kind of bootstrap packages in order (just without writing # anything - just boil and install) first_local_package = LocalPackage( rootdirectory=dirstructure.first_source(), setups=[ConfixSetup(use_libtool=False)]) first_local_package.boil(external_nodes=[]) first_installed_package = first_local_package.install() second_local_package = LocalPackage( rootdirectory=dirstructure.second_source(), setups=[ConfixSetup(use_libtool=False)]) second_local_package.boil( external_nodes=first_installed_package.nodes()) second_installed_package = second_local_package.install() third_local_package = LocalPackage( rootdirectory=dirstructure.third_source(), setups=[ConfixSetup(use_libtool=False)]) third_local_package.boil( external_nodes=first_installed_package.nodes() + second_installed_package.nodes()) third_local_package.output() # so here, finally, go the tests ... exedir_builder = third_local_package.rootbuilder().find_entry_builder( ['exe']) self.failIf(exedir_builder is None) exedir_output_builder = find_automake_output_builder(exedir_builder) # see if we have the convenience item in makefile_am() convenience_deps = exedir_output_builder.makefile_am( ).compound_dependencies('ThirdPackage_exe_exe') self.failIf(convenience_deps is None) # see if the convenience item has all it should have self.failUnless('$(top_builddir)/library/libThirdPackage_library.a' in convenience_deps) self.failUnless('@installeddeplib_FirstPackage@' in convenience_deps) self.failUnless('@installeddeplib_SecondPackage@' in convenience_deps) # see if it got correctly written to the Makefile.am real_deps = makefile.find_list( elements=makefile.parse_makefile( exedir_output_builder.makefile_am().lines()), name='ThirdPackage_exe_exe_DEPENDENCIES') self.failIf(real_deps is None) self.failUnless( '$(top_builddir)/library/libThirdPackage_library.a' in real_deps) self.failUnless('@installeddeplib_FirstPackage@' in real_deps) self.failUnless('@installeddeplib_SecondPackage@' in real_deps) pass
def test(self): exedir_output_builder = find_automake_output_builder( self.exedir_builder_) self.failIf(exedir_output_builder is None) self.failUnlessEqual( exedir_output_builder.makefile_am().compound_ldadd( 'blah_exe_main'), ['-L$(top_builddir)/hi', '-lblah_hi']) pass
def test__common(self): exedir_automake_builder = find_automake_output_builder( self.exedir_builder_) self.failUnless('blah_exe_main' in exedir_automake_builder.makefile_am().bin_programs()) self.failUnless('main.c' in exedir_automake_builder.makefile_am(). compound_sources('blah_exe_main')) self.failUnless('something.c' in exedir_automake_builder.makefile_am(). compound_sources('blah_exe_main')) pass
def test__onedeep(self): fs = dirhier.packageroot() file_h = fs.rootdirectory().add(name='file.h', entry=File()) file_h.set_property(name='INSTALLPATH_CINCLUDE', value=['xxx']) package = LocalPackage(rootdirectory=fs.rootdirectory(), setups=[ConfixSetup(use_libtool=False)]) package.boil(external_nodes=[]) package.output() # public installation goes to $(includedir)/xxx; see if the # subdir stuff is handled correctly. rootdir_output_builder = find_automake_output_builder(package.rootbuilder()) self.failIf(rootdir_output_builder is None) directory_definition = rootdir_output_builder.makefile_am().install_directories().get('publicheader_xxx') self.failIf(directory_definition is None) self.failUnless(directory_definition.dirname() == '$(includedir)/xxx') self.failIf(directory_definition.files('HEADERS') is None) self.failUnless(directory_definition.files('HEADERS') == ['file.h']) # private installation stuff. # all-local -> confix-install-local -> $(top_builddir)/confix-include/file.h -> $(top_builddir)/confix-include confix_install_local = makefile.find_rule( targets=['confix-install-local'], elements=rootdir_output_builder.makefile_am().elements()) install_file_h = makefile.find_rule( targets=['$(top_builddir)/confix-include/xxx/file.h'], elements=rootdir_output_builder.makefile_am().elements()) mkdir = makefile.find_rule( targets=['$(top_builddir)/confix-include/xxx'], elements=rootdir_output_builder.makefile_am().elements()) self.failIf(confix_install_local is None) self.failIf(install_file_h is None) self.failIf(mkdir is None) self.failUnless('confix-install-local' in rootdir_output_builder.makefile_am().all_local().prerequisites()) self.failUnless('$(top_builddir)/confix-include/xxx/file.h' in confix_install_local.prerequisites()) # clean-local -> confix-clean-local -> $(top_builddir)/confix-include/file.h-clean confix_clean_local = makefile.find_rule( targets=['confix-clean-local'], elements=rootdir_output_builder.makefile_am().elements()) clean_file_h = makefile.find_rule( targets=['$(top_builddir)/confix-include/xxx/file.h-clean'], elements=rootdir_output_builder.makefile_am().elements()) self.failIf(confix_clean_local is None) self.failIf(clean_file_h is None) self.failUnless('confix-clean-local' in rootdir_output_builder.makefile_am().clean_local().prerequisites()) self.failUnless('$(top_builddir)/confix-include/xxx/file.h-clean' in confix_clean_local.prerequisites()) pass
def test__cxxflags(self): hidir_builder = self.__package.rootbuilder().find_entry_builder(['hi']) self.failIf(hidir_builder is None) hidir_output_builder = find_automake_output_builder(hidir_builder) self.failIf(hidir_output_builder is None) self.failUnless('lolo_cxxflags' in hidir_output_builder.makefile_am().am_cxxflags()) self.failUnless( 'lo_cxxflags' in hidir_output_builder.makefile_am().am_cxxflags()) pass
def output(self): super(LibraryOutputBuilder, self).output() automake_output_builder = find_automake_output_builder( self.parentbuilder()) for b in self.parentbuilder().iter_builders(): if not isinstance(b, LibraryBuilder): continue if self.use_libtool(): filelibname = 'lib' + b.basename() + '.la' else: filelibname = 'lib' + b.basename() + '.a' pass automakelibname = helper.automake_name(filelibname) if self.use_libtool(): automake_output_builder.makefile_am().add_ltlibrary( filelibname) if b.version() is not None: automake_output_builder.makefile_am().add_compound_ldflags( automakelibname, '-version-info %d:%d:%d' % b.version()) elif b.default_version() is not None: automake_output_builder.makefile_am().add_compound_ldflags( automakelibname, '-release ' + b.default_version()) pass if b.has_undefined_symbols() is False: automake_output_builder.makefile_am().add_compound_ldflags( automakelibname, '-no-undefined') pass pass else: automake_output_builder.configure_ac().add_paragraph( paragraph=Paragraph(['AC_PROG_RANLIB']), order=Configure_ac.PROGRAMS) automake_output_builder.makefile_am().add_library(filelibname) pass for m in b.members(): automake_output_builder.makefile_am().add_compound_sources( automakelibname, m.file().name()) pass if self.use_libtool(): for fragment in self.get_linkline(linked_builder=b): automake_output_builder.makefile_am().add_compound_libadd( compound_name=automakelibname, lib=fragment) pass pass pass pass
def output(self): super(COutputBuilder, self).output() automake_output_builder = find_automake_output_builder( self.parentbuilder()) for b in self.parentbuilder().iter_builders(): if not isinstance(b, CBuilder): continue automake_output_builder.configure_ac().add_paragraph( paragraph=Paragraph(['AC_PROG_CC']), order=Configure_ac.PROGRAMS) pass pass
def test__configure_ac(self): rootdir_automake_builder = find_automake_output_builder( self.__package.rootbuilder()) self.failIfEqual(self.__fs.rootdirectory().find(['configure.ac']), None) self.failUnless('config.h' in rootdir_automake_builder.configure_ac(). ac_config_headers()) self.failIf( rootdir_automake_builder.configure_ac().packagename() is None) self.failIf( rootdir_automake_builder.configure_ac().packageversion() is None) pass
def test__subdir3_makefile_am(self): subdir3_automake_builder = find_automake_output_builder( self.__package.rootbuilder().find_entry_builder(['subdir3'])) self.failIfEqual( self.__fs.rootdirectory().find(['subdir3', 'Makefile.am']), None) self.failUnless(const.CONFIX2_DIR in subdir3_automake_builder.makefile_am().extra_dist()) self.failUnless('Makefile.in' in subdir3_automake_builder.makefile_am( ).maintainercleanfiles()) self.failUnless('Makefile.am' in subdir3_automake_builder.makefile_am( ).maintainercleanfiles()) pass
def test(self): automake_output_builder = find_automake_output_builder( self.package_.rootbuilder()) self.failUnless(automake_output_builder) self.failUnless('the-test-program' in automake_output_builder.makefile_am().check_programs()) self.failUnlessEqual( len(automake_output_builder.makefile_am().tests_environment()), 1) self.failUnlessEqual( automake_output_builder.makefile_am().tests_environment()['name'], 'value') pass
def test__no_libtool(self): package = LocalPackage(rootdirectory=self.fs_.rootdirectory(), setups=[ConfixSetup(use_libtool=False)]) package.boil(external_nodes=[]) package.output() exedir_builder = package.rootbuilder().find_entry_builder(['exe']) self.failIf(exedir_builder is None) exedir_output_builder = find_automake_output_builder(exedir_builder) self.failIf(exedir_output_builder is None) self.failUnless('-lLDADD_lib' in exedir_output_builder.makefile_am(). compound_ldadd('LDADD_exe_exe')) pass
def test(self): try: # confixize, bootstrap, and install package 'lo' self.lo_package_.boil(external_nodes=[]) self.lo_package_.output() self.lo_fs_.sync() # once I suspected the error to be of that root. lo_dir_output_builder = find_automake_output_builder( self.lo_package_.rootbuilder()) self.failUnless('confixrepo' in lo_dir_output_builder.makefile_am( ).install_directories()) bootstrap.bootstrap(packageroot=self.lo_sourcedir_, use_kde_hack=False, path=None, argv0=sys.argv[0]) os.makedirs(os.sep.join(self.lo_builddir_)) configure.configure(packageroot=self.lo_sourcedir_, builddir=self.lo_builddir_, prefix=self.installdir_, readonly_prefixes=[]) make.make(builddir=self.lo_builddir_, args=['install']) # read repo from prefix repo = AutomakeCascadedPackageRepository(prefix=self.installdir_, readonly_prefixes=[]) # confixize, bootstrap, and install package 'hi' self.hi_package_.boil(external_nodes=repo.iter_nodes()) self.hi_package_.output() self.hi_fs_.sync() bootstrap.bootstrap(packageroot=self.hi_sourcedir_, use_kde_hack=False, path=None, argv0=sys.argv[0]) os.makedirs(os.sep.join(self.hi_builddir_)) configure.configure(packageroot=self.hi_sourcedir_, builddir=self.hi_builddir_, prefix=self.installdir_, readonly_prefixes=[]) make.make(builddir=self.hi_builddir_, args=['install']) except Error, e: sys.stderr.write( ` e ` + '\n') raise
def test_no_libtool(self): package = LocalPackage(rootdirectory=self.fs_.rootdirectory(), setups=[ConfixSetup(use_libtool=False)]) package.boil(external_nodes=[]) package.output() hidir_builder = package.rootbuilder().find_entry_builder(['hi']) self.failIf(hidir_builder is None) hidir_output_builder = find_automake_output_builder(hidir_builder) self.failIf(hidir_output_builder is None) self.failUnless(hidir_output_builder.makefile_am().compound_libadd( 'libLIBADD_hi_a') is None) pass
def test(self): root = Directory() root.add(name=const.CONFIX2_PKG, entry=File(lines=[ 'PACKAGE_NAME("' + self.__class__.__name__ + '")', 'PACKAGE_VERSION("1.2.3")' ])) root.add(name=const.CONFIX2_DIR, entry=File()) ext_lib = root.add(name='ext-lib', entry=Directory()) ext_lib.add(name=const.CONFIX2_DIR, entry=File(lines=[ 'PROVIDE_H("ext_lib.h")', 'PKG_CONFIG_LIBRARY(packagename="ext_lib")' ])) main = root.add(name='main', entry=Directory()) main.add(name='main.cc', entry=File(lines=[ '#include <ext_lib.h>', '// CONFIX:REQUIRE_H("ext_lib.h", REQUIRED)', '// CONFIX:EXENAME("the_exe")', 'int main() { return 0; }' ])) main.add(name=const.CONFIX2_DIR, entry=File()) package = LocalPackage( rootdirectory=root, setups=[ConfixSetup(use_libtool=False), PkgConfigSetup()]) package.boil(external_nodes=[]) package.output() maindir_builder = package.rootbuilder().find_entry_builder(['main']) self.failIf(maindir_builder is None) maindir_output_builder = find_automake_output_builder(maindir_builder) self.failIf(maindir_output_builder is None) self.failUnless('$(ext_lib_PKG_CONFIG_CFLAGS)' in maindir_output_builder.makefile_am().am_cflags()) self.failUnless('$(ext_lib_PKG_CONFIG_CFLAGS)' in maindir_output_builder.makefile_am().am_cxxflags()) main_ldadd = maindir_output_builder.makefile_am().compound_ldadd( compound_name='the_exe') self.failIf(main_ldadd is None) self.failUnless('$(ext_lib_PKG_CONFIG_LIBS)' in main_ldadd) pass
def test__cmdline_macros(self): hidir_builder = self.__package.rootbuilder().find_entry_builder(['hi']) self.failIf(hidir_builder is None) hidir_output_builder = find_automake_output_builder(hidir_builder) self.failIf(hidir_output_builder is None) self.failIf(hidir_output_builder.makefile_am().cmdlinemacros().get( 'cmdlinemacro_lolo') is None) self.failUnless(hidir_output_builder.makefile_am().cmdlinemacros().get( 'cmdlinemacro_lolo') == 'value_lolo') self.failIf(hidir_output_builder.makefile_am().cmdlinemacros().get( 'cmdlinemacro_lo') is None) self.failUnless(hidir_output_builder.makefile_am().cmdlinemacros().get( 'cmdlinemacro_lo') == 'value_lo') pass
def test__linkery(self): hidir_builder = self.__package.rootbuilder().find_entry_builder(['hi']) self.failIf(hidir_builder is None) hidir_output_builder = find_automake_output_builder(hidir_builder) self.failIf(hidir_output_builder is None) # paths (-L): lo (first and second) must come before lolo # (first and second). the order of lo's and lolo's both paths # must be preserved (in other words, first before second) # libraries (-l): lo before lolo. pos_Llo_first = pos_Llo_second = pos_Llolo_first = pos_Llolo_second = pos_llolo = pos_llo = None i = -1 for lp in hidir_output_builder.makefile_am().compound_libadd( compound_name='libhi_la'): i += 1 if lp == '-L/the/first/library/path/of/lo': pos_Llo_first = i continue if lp == '-L/the/second/library/path/of/lo': pos_Llo_second = i continue if lp == '-L/the/first/library/path/of/lolo': pos_Llolo_first = i continue if lp == '-L/the/second/library/path/of/lolo': pos_Llolo_second = i continue if lp == '-llo': pos_llo = i continue if lp == '-llolo': pos_llolo = i continue pass self.failIf(pos_Llo_first is None) self.failIf(pos_Llo_second is None) self.failIf(pos_Llolo_first is None) self.failIf(pos_Llolo_second is None) self.failIf(pos_llolo is None) self.failIf(pos_llo is None) self.failUnless(pos_Llo_first < pos_Llo_second) self.failUnless(pos_Llo_second < pos_Llolo_first) self.failUnless(pos_Llolo_first < pos_Llolo_second) self.failUnless(pos_llo < pos_llolo) pass
def test__auxdir(self): rootdir_automake_builder = find_automake_output_builder( self.__package.rootbuilder()) auxdir = self.__package.rootbuilder().directory().find( ['confix-admin', 'automake']) self.failIf(auxdir is None) mf_am = auxdir.find(['Makefile.am']) self.failIf(mf_am is None) self.failUnlessEqual( rootdir_automake_builder.configure_ac().ac_config_aux_dir(), 'confix-admin/automake') self.failUnless( 'confix-admin/automake/Makefile' in rootdir_automake_builder.configure_ac().ac_config_files()) pass
def output(self): super(LinkedOutputBuilder, self).output() automake_output_builder = find_automake_output_builder( self.parentbuilder()) for b in self.parentbuilder().iter_builders(): if not isinstance(b, LinkedBuilder): continue if self.__use_libtool: automake_output_builder.configure_ac().add_paragraph( paragraph=Paragraph([ 'AC_LIBTOOL_DLOPEN', 'AC_LIBTOOL_WIN32_DLL', 'AC_PROG_LIBTOOL' ]), order=Configure_ac.PROGRAMS) pass pass pass
def output(self): super(CXXOutputBuilder, self).output() automake_output_builder = find_automake_output_builder( self.parentbuilder()) for b in self.parentbuilder().iter_builders(): if not isinstance(b, CXXBuilder): continue automake_output_builder.configure_ac().add_paragraph( paragraph=Paragraph(['AC_PROG_CXX']), order=Configure_ac.PROGRAMS) for f in b.cxxflags() + self.__external_cxxflags: automake_output_builder.makefile_am().add_am_cxxflags(f) pass pass pass
def test__twodeep(self): fs = dirhier.packageroot() file_h = fs.rootdirectory().add(name='file.h', entry=File()) file_h.set_property(name='INSTALLPATH_CINCLUDE', value=['xxx/yyy']) package = LocalPackage(rootdirectory=fs.rootdirectory(), setups=[ConfixSetup(use_libtool=False)]) package.boil(external_nodes=[]) package.output() rootdir_output_builder = find_automake_output_builder(package.rootbuilder()) self.failIf(rootdir_output_builder is None) directory_definition = rootdir_output_builder.makefile_am().install_directories().get('publicheader_xxxyyy') self.failIf(directory_definition is None) self.failUnless(directory_definition.dirname() == '$(includedir)/xxx/yyy') self.failIf(directory_definition.files('HEADERS') is None) self.failUnless(directory_definition.files('HEADERS') == ['file.h']) pass
def test__no_files(self): fs = FileSystem(path=['dont', 'care']) fs.rootdirectory().add( name=const.CONFIX2_PKG, entry=File(lines=["PACKAGE_NAME('"+self.__class__.__name__+"')", "PACKAGE_VERSION('1.2.3')"])) fs.rootdirectory().add( name=const.CONFIX2_DIR, entry=File()) package = LocalPackage(rootdirectory=fs.rootdirectory(), setups=[ExplicitSetup(use_libtool=False)]) package.boil(external_nodes=[]) package.output() rootdir_automake_builder = find_automake_output_builder(package.rootbuilder()) self.failIf(rootdir_automake_builder is None) self.failIf(rootdir_automake_builder.configure_ac().unique_file_in_srcdir() is None) self.failUnless(rootdir_automake_builder.configure_ac().unique_file_in_srcdir() in ('Confix2.dir', 'Confix2.pkg')) pass