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
