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 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):
fs = FileSystem(path=[])
fs.rootdirectory().add(
name=const.CONFIX2_PKG,
entry=File(lines=[
"PACKAGE_NAME('ExplicitLibraryVersionTest')",
"PACKAGE_VERSION('1.2.3')"
]))
fs.rootdirectory().add(name=const.CONFIX2_DIR,
entry=File(lines=["LIBRARY_VERSION((6,6,6))"]))
fs.rootdirectory().add(name='file.c', entry=File())
package = LocalPackage(rootdirectory=fs.rootdirectory(),
setups=[ConfixSetup(use_libtool=True)])
package.boil(external_nodes=[])
for b in package.rootbuilder().iter_builders():
if isinstance(b, LibraryBuilder):
lib_builder = b
break
pass
else:
self.fail()
pass
self.failUnlessEqual(lib_builder.version(), (6, 6, 6))
self.failUnlessEqual(lib_builder.default_version(), "1.2.3")
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 testExplicitName(self):
fs = FileSystem(path=['don\'t', 'care'])
fs.rootdirectory().add(
name=const.CONFIX2_PKG,
entry=File(lines=[
"PACKAGE_NAME('LibraryNames.testExplicitName')",
"PACKAGE_VERSION('1.2.3')"
]))
fs.rootdirectory().add(name=const.CONFIX2_DIR,
entry=File(lines=["LIBNAME('myownname')"]))
fs.rootdirectory().add(name='file.c', entry=File())
package = LocalPackage(rootdirectory=fs.rootdirectory(),
setups=[ConfixSetup(use_libtool=False)])
package.boil(external_nodes=[])
for b in package.rootbuilder().iter_builders():
if isinstance(b, LibraryBuilder):
self.failUnlessEqual(b.basename(), 'myownname')
break
pass
else:
self.fail()
pass
pass
def test__creator(self):
fs = FileSystem(path=['a'])
fs.rootdirectory().add(
name=const.CONFIX2_PKG,
entry=File(lines=[
"PACKAGE_NAME('ignore-entries-c')", "PACKAGE_VERSION('6.6.6')"
]))
fs.rootdirectory().add(name=const.CONFIX2_DIR,
entry=File(lines=[
'IGNORE_ENTRIES(["ignored1.idl"])',
'IGNORE_FILE("ignored2.idl")'
]))
fs.rootdirectory().add(name='ignored1.idl', entry=File())
fs.rootdirectory().add(name='ignored2.idl', entry=File())
fs.rootdirectory().add(name='not-ignored.idl', entry=File())
package = LocalPackage(rootdirectory=fs.rootdirectory(),
setups=[ConfixSetup(use_libtool=False)])
package.boil(external_nodes=[])
self.failIf(
package.rootbuilder().find_entry_builder(path=['ignored1.idl']))
self.failIf(
package.rootbuilder().find_entry_builder(path=['ignored2.idl']))
self.failUnless(
package.rootbuilder().find_entry_builder(path=['not-ignored.idl']))
pass
def test(self):
fs = FileSystem(path=[])
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())
fs.rootdirectory().add(name='main.cc',
entry=File(lines=[
'// CONFIX:EXENAME("explicit-name")',
'int main() { return 0; }'
]))
package = LocalPackage(rootdirectory=fs.rootdirectory(),
setups=[ConfixSetup(use_libtool=False)])
package.boil(external_nodes=[])
package.output()
for b in package.rootbuilder().iter_builders():
if isinstance(
b, ExecutableBuilder) and b.exename() == 'explicit-name':
break
pass
else:
self.fail()
pass
pass
def test(self):
fs = FileSystem(path=['', 'path', 'to', 'it'])
fs.rootdirectory().add(name=const.CONFIX2_PKG,
entry=File(lines=[
"PACKAGE_NAME('ProvideRequireInclude')",
"PACKAGE_VERSION('1.2.3')"
]))
fs.rootdirectory().add(name=const.CONFIX2_DIR, entry=File())
lo = fs.rootdirectory().add(name='lo', entry=Directory())
lo.add(name=const.CONFIX2_DIR, entry=File(lines=["PROVIDE_H('lo.h')"]))
hi = fs.rootdirectory().add(name='hi', entry=Directory())
hi.add(name=const.CONFIX2_DIR,
entry=File(lines=["REQUIRE_H('lo.h', URGENCY_ERROR)"]))
package = LocalPackage(rootdirectory=fs.rootdirectory(),
setups=[ConfixSetup(use_libtool=False)])
package.boil(external_nodes=[])
lo_builder = package.rootbuilder().find_entry_builder(['lo'])
hi_builder = package.rootbuilder().find_entry_builder(['hi'])
self.failUnless(lo_builder in package.digraph().successors(hi_builder))
pass
def test__with_implicit_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')"]))
filesys.rootdirectory().add(name='_check_proggy.c',
entry=File(lines=['int main(void) {}']))
package = LocalPackage(rootdirectory=filesys.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)
self.failUnless('CheckProgramTest__check_proggy' 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')
pass
def test_auto_fileiface_only(self):
fs = FileSystem(path=[])
fs.rootdirectory().add(
name=const.CONFIX2_PKG,
entry=File(['PACKAGE_NAME("argh")', 'PACKAGE_VERSION("1.2.3")']))
fs.rootdirectory().add(name=const.CONFIX2_DIR, entry=File())
file = fs.rootdirectory().add(
name='file.h',
entry=File(lines=["// CONFIX:INSTALLPATH(['xxx'])"]))
package = LocalPackage(rootdirectory=fs.rootdirectory(),
setups=[ConfixSetup(use_libtool=False)])
package.boil(external_nodes=[])
package.output()
file_h_builder = package.rootbuilder().find_entry_builder(['file.h'])
self.failIf(file_h_builder is None)
self.failUnless(isinstance(file_h_builder, HeaderBuilder))
self.failUnlessEqual(file_h_builder.visibility(), ['xxx'])
self.failUnless(file_h_builder.public())
self.failUnlessEqual(file_h_builder.package_visibility_action()[0],
HeaderBuilder.LOCALVISIBILITY_INSTALL)
self.failUnlessEqual(file_h_builder.package_visibility_action()[1],
['xxx'])
pass
def test(self):
fs = dirhier.packageroot()
fs.rootdirectory().add(name='file.h', entry=File(lines=[]))
fs.rootdirectory().add(name='file.c', entry=File(lines=[]))
package = LocalPackage(rootdirectory=fs.rootdirectory(),
setups=[ConfixSetup(use_libtool=False)])
package.boil(external_nodes=[])
file_h_builder = None
file_c_builder = None
library_builder = None
for b in package.rootbuilder().iter_builders():
if isinstance(b, FileBuilder):
if b.file().name() == 'file.h' and isinstance(
b, HeaderBuilder):
file_h_builder = b
pass
if b.file().name() == 'file.c' and isinstance(b, CBuilder):
file_c_builder = b
pass
pass
if isinstance(b, LibraryBuilder):
library_builder = b
pass
pass
self.failUnless(isinstance(file_h_builder, HeaderBuilder))
self.failUnless(isinstance(file_c_builder, CBuilder))
self.failUnless(isinstance(library_builder, LibraryBuilder))
self.failUnless(file_h_builder in library_builder.members())
self.failUnless(file_c_builder in library_builder.members())
pass
def testDirectory(self):
fs = FileSystem(path=[])
fs.rootdirectory().add(
name=const.CONFIX2_PKG,
entry=File(
lines=["PACKAGE_NAME('xxx')", "PACKAGE_VERSION('6.6.6')"]))
fs.rootdirectory().add(
name=const.CONFIX2_DIR,
entry=File(lines=[
"SET_FILE_PROPERTY(", " filename='file.h', ",
" name='INSTALLPATH_CINCLUDE',", " value=['xxx'])"
]))
fs.rootdirectory().add(name='file.h', entry=File(lines=[]))
package = LocalPackage(rootdirectory=fs.rootdirectory(),
setups=[ConfixSetup(use_libtool=False)])
package.boil(external_nodes=[])
package.output()
file_h_builder = package.rootbuilder().find_entry_builder(['file.h'])
self.failIf(file_h_builder is None)
self.failUnless(isinstance(file_h_builder, HeaderBuilder))
self.failUnlessEqual(file_h_builder.visibility(), ['xxx'])
self.failUnless(file_h_builder.public())
self.failUnlessEqual(file_h_builder.package_visibility_action()[0],
HeaderBuilder.LOCALVISIBILITY_INSTALL)
self.failUnlessEqual(file_h_builder.package_visibility_action()[1],
['xxx'])
pass
def test__basic(self):
fs = dirhier.packageroot()
fs.rootdirectory().add(name='file.h',
entry=File(lines=['#ifndef FILE_H',
'#define FILE_H',
'extern int i;'
'#endif',
]))
fs.rootdirectory().add(name='file.c',
entry=File(lines=['#include "file.h"',
'int i;',
]))
package = LocalPackage(
rootdirectory=fs.rootdirectory(),
setups=[ConfixSetup(use_libtool=False)])
package.boil(external_nodes=[])
package.output()
conf_ac = fs.rootdirectory().find(['configure.ac'])
self.failIf(conf_ac is None)
found_AC_PROG_CC = False
for l in conf_ac.lines():
if l == 'AC_PROG_CC':
found_AC_PROG_CC = True
continue
pass
self.failUnless(found_AC_PROG_CC)
pass
def test(self):
fs = FileSystem(path=['don\'t', 'care'])
fs.rootdirectory().add(
name=const.CONFIX2_PKG,
entry=File(lines=["PACKAGE_NAME('LexYaccSetupTest')",
"PACKAGE_VERSION('1.2.3')"]))
fs.rootdirectory().add(
name=const.CONFIX2_DIR,
entry=File())
fs.rootdirectory().add(
name='clexfile.l',
entry=File())
fs.rootdirectory().add(
name='cxxlexfile.ll',
entry=File())
fs.rootdirectory().add(
name='cyaccfile.y',
entry=File())
fs.rootdirectory().add(
name='cxxyaccfile.yy',
entry=File())
package = LocalPackage(rootdirectory=fs.rootdirectory(),
setups=[ConfixSetup(use_libtool=False)])
package.boil(external_nodes=[])
package.output()
clex = cxxlex = cyacc = cxxyacc = lib = None
for b in package.rootbuilder().iter_builders():
if isinstance(b, LexBuilder):
if b.file().name() == 'clexfile.l':
clex = b
continue
if b.file().name() == 'cxxlexfile.ll':
cxxlex = b
continue
self.fail()
pass
if isinstance(b, YaccBuilder):
if b.file().name() == 'cyaccfile.y':
cyacc = b
continue
if b.file().name() == 'cxxyaccfile.yy':
cxxyacc = b
continue
self.fail()
pass
if isinstance(b, LibraryBuilder):
lib = b
continue
pass
self.failIf(clex is None)
self.failIf(cxxlex is None)
self.failIf(cyacc is None)
self.failIf(cxxyacc is None)
self.failIf(lib is None)
pass
def test(self):
common, lo, hi = inter_package.make_source(classname=self.__class__.__name__)
common_package = LocalPackage(rootdirectory=common,
setups=[ConfixSetup(use_libtool=False)])
common_package.boil(external_nodes=[])
common_installed = common_package.install()
lo_package = LocalPackage(rootdirectory=lo,
setups=[ConfixSetup(use_libtool=False)])
lo_package.boil(external_nodes=common_installed.nodes())
lo_installed = lo_package.install()
hi_package = LocalPackage(rootdirectory=hi,
setups=[ConfixSetup(use_libtool=False)])
hi_package.boil(external_nodes=common_installed.nodes() + lo_installed.nodes())
pass
def testNoInstallPath(self):
fs = dirhier.packageroot()
fs.rootdirectory().add(name='file.h', entry=File(lines=[]))
fs.rootdirectory().add(name='file.c',
entry=File(lines=['#include "file.h"']))
package = LocalPackage(rootdirectory=fs.rootdirectory(),
setups=[ConfixSetup(use_libtool=False)])
package.boil(external_nodes=[])
self.failUnlessEqual(len(package.rootbuilder().requires()), 0)
pass
def _generate(source, use_libtool, explicit):
if explicit:
setup = ExplicitSetup(use_libtool=use_libtool)
else:
setup = ConfixSetup(use_libtool=use_libtool)
pass
package = LocalPackage(rootdirectory=source, setups=[setup])
package.boil(external_nodes=[])
package.output()
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_basic(self):
rootdirectory = Directory()
rootdirectory.add(name=const.CONFIX2_PKG,
entry=File(lines=[
'PACKAGE_NAME("' + self.__class__.__name__ +
'")', 'PACKAGE_VERSION("1.2.3")'
]))
rootdirectory.add(name=const.CONFIX2_DIR, entry=File())
lodir = rootdirectory.add(name='lo', entry=Directory())
lodir.add(name=const.CONFIX2_DIR, entry=File())
lodir.add(name='lo.h', entry=File())
hidir = rootdirectory.add(name='hi', entry=Directory())
hidir.add(name=const.CONFIX2_DIR, entry=File())
hidir.add(name='hi.h', entry=File(lines=['#include <lo.h>']))
user = rootdirectory.add(name='user', entry=Directory())
user.add(name=const.CONFIX2_DIR, entry=File())
user.add(name='user.c', entry=File(lines=['#include <hi.h>']))
package = LocalPackage(rootdirectory=rootdirectory,
setups=[ConfixSetup(use_libtool=False)])
package.boil(external_nodes=[])
package.output()
user_c_builder = package.rootbuilder().find_entry_builder(
['user', 'user.c'])
self.failIf(user_c_builder is None)
hi_pos = lo_pos = None
for i in xrange(len(user_c_builder.native_local_include_dirs())):
if user_c_builder.native_local_include_dirs()[i] == ['hi']:
self.failUnless(hi_pos is None)
hi_pos = i
continue
if user_c_builder.native_local_include_dirs()[i] == ['lo']:
self.failUnless(lo_pos is None)
lo_pos = i
continue
pass
self.failIf(hi_pos is None)
self.failIf(lo_pos is None)
self.failIf(hi_pos > lo_pos)
lo_h = package.rootbuilder().find_entry_builder(['lo', 'lo.h'])
self.failUnlessEqual(lo_h.visibility(), [])
self.failUnless(lo_h.public())
self.failUnlessEqual(lo_h.package_visibility_action()[0],
HeaderBuilder.LOCALVISIBILITY_DIRECT_INCLUDE)
self.failUnlessEqual(lo_h.package_visibility_action()[1], ['lo'])
pass
def test(self):
fs = FileSystem(path=self.rootpath())
source = fs.rootdirectory().add(
name='source',
entry=Directory())
build = fs.rootdirectory().add(
name='build',
entry=Directory())
install=fs.rootdirectory().add(
name='install',
entry=Directory())
source.add(
name=const.CONFIX2_PKG,
entry=File(lines=['PACKAGE_NAME("'+self.__class__.__name__+'")',
'PACKAGE_VERSION("1.2.3")']))
source.add(
name=const.CONFIX2_DIR,
entry=File())
source.add(
name='main.cc',
entry=File(lines=['// CONFIX:EXENAME("explicit-name")',
'int main() { return 0; }']))
package = LocalPackage(rootdirectory=source,
setups=[ConfixSetup(use_libtool=False)])
package.boil(external_nodes=[])
package.output()
fs.sync()
bootstrap.bootstrap(
packageroot=source.abspath(),
path=None,
use_kde_hack=False,
argv0=sys.argv[0])
configure.configure(
packageroot=source.abspath(),
builddir=build.abspath(),
prefix=install.abspath(),
readonly_prefixes=None)
make.make(
builddir=build.abspath(),
args=['install'])
# we have written the fs to disk, but unfortunately we cannot
# see what the build contributed to it (we don't implement
# re-reading the fs that has changed under the hood)
exe_path = install.abspath() + ['bin', 'explicit-name']
self.failUnless(os.path.isfile(os.sep.join(exe_path)))
pass
def test(self):
fs = FileSystem(path=self.rootpath())
source = fs.rootdirectory().add(name='source', entry=Directory())
build = fs.rootdirectory().add(name='build', entry=Directory())
source.add(name=const.CONFIX2_PKG,
entry=File(lines=[
'PACKAGE_NAME("' + self.__class__.__name__ +
'")', 'PACKAGE_VERSION("1.2.3")'
]))
source.add(name=const.CONFIX2_DIR,
entry=File(lines=['CALL_MAKE_AND_RESCAN()']))
source.add(
name='Makefile',
entry=File(lines=[
'all:',
'\tif test -e main.c; then echo "make being called twice"; exit 1; fi',
'\techo "// CONFIX:EXENAME(\'the_executable_generated_by_a_call_to_make\')" > main.cc',
'\techo "int main(void) {return 0;}" >> main.cc'
]))
# during enlarge() we will call 'make' which expects the
# Makefile being physically available in the physically
# available directory, so flush it once ...
fs.sync()
package = LocalPackage(rootdirectory=source,
setups=[ConfixSetup(use_libtool=False)])
package.boil(external_nodes=[])
package.output()
# ... and, for the rest of it, we need the automake input
# files as well.
fs.sync()
bootstrap.bootstrap(packageroot=source.abspath(),
path=None,
use_kde_hack=False,
argv0=sys.argv[0])
configure.configure(packageroot=source.abspath(),
builddir=build.abspath(),
prefix=None,
readonly_prefixes=None)
make.make(builddir=build.abspath(), args=None)
self.failUnless(
os.path.isfile(
os.sep.join(build.abspath() +
['the_executable_generated_by_a_call_to_make'])))
pass
def test__CONFIGURE_AC_ACINCLUDE_M4_propagate(self):
""" We pass flags=[PROPAGATE] explicitly, to both
ACINCLUDE_M4() and CONFIGURE_AC(), propagate it to a dependent
node,"hi", and check if both go into acinclude.m4 and configure.ac."""
fs = FileSystem(path=[])
fs.rootdirectory().add(
name=const.CONFIX2_PKG,
entry=File(
lines=['PACKAGE_NAME("blah")', 'PACKAGE_VERSION("1.2.3")']))
fs.rootdirectory().add(name=const.CONFIX2_DIR, entry=File())
lo = fs.rootdirectory().add(name='lo', entry=Directory())
lo.add(name=const.CONFIX2_DIR,
entry=File(lines=[
'PROVIDE_SYMBOL("lo")',
'CONFIGURE_AC(lines=["the_token_for_configure_ac"],',
' order=AC_PROGRAMS,',
' flags=[PROPAGATE])',
'ACINCLUDE_M4(lines=["the_token_for_acinclude_m4"],',
' flags=[PROPAGATE])'
]))
hi = fs.rootdirectory().add(name='hi', entry=Directory())
hi.add(name=const.CONFIX2_DIR,
entry=File(lines=['REQUIRE_SYMBOL("lo", URGENCY_ERROR)']))
package = LocalPackage(rootdirectory=fs.rootdirectory(),
setups=[ConfixSetup(use_libtool=False)])
package.boil(external_nodes=[])
package.output()
configure_ac = fs.rootdirectory().find(['configure.ac'])
acinclude_m4 = fs.rootdirectory().find(['acinclude.m4'])
self.failIf(configure_ac is None)
self.failIf(acinclude_m4 is None)
for line in configure_ac.lines():
if line == 'the_token_for_configure_ac':
break
pass
else:
self.fail()
pass
for line in acinclude_m4.lines():
if line == 'the_token_for_acinclude_m4':
break
pass
else:
self.fail()
pass
pass
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__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):
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__relocated_header_requires_relocated_header(self):
fs = FileSystem(path=['dont\'t', '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())
include = fs.rootdirectory().add(name='include', entry=Directory())
include.add(name=const.CONFIX2_DIR,
entry=File(lines=[
"RELOCATE_HEADER(filename='a.h',",
" directory=['src'])",
"RELOCATE_HEADER(filename='b.h',",
" directory=['src'])"
]))
include.add(name='a.h',
entry=File(lines=[
'#ifndef A_H', '#define A_H',
'// CONFIX:REQUIRE_H("b.h", REQUIRED)',
'#include "b.h"', 'void a(void);'
'#endif'
]))
include.add(
name='b.h',
entry=File(
lines=['#ifndef B_H', '#define B_H', 'void b(void);'
'#endif']))
src = fs.rootdirectory().add(name='src', entry=Directory())
src.add(name=const.CONFIX2_DIR, entry=File())
src.add(name='a.c',
entry=File(lines=[
'#include <a.h>', '// CONFIX:REQUIRE_H("a.h", REQUIRED)',
'void a(void) {}'
]))
src.add(name='b.c',
entry=File(lines=[
'#include <b.h>', '// CONFIX:REQUIRE_H("b.h", REQUIRED)',
'void b(void) {}'
]))
package = LocalPackage(rootdirectory=fs.rootdirectory(),
setups=[ConfixSetup(use_libtool=False)])
package.boil(external_nodes=[])
pass
def test_subdirectory(self):
fs = FileSystem(path=['a'])
fs.rootdirectory().add(
name=const.CONFIX2_PKG,
entry=File(lines=[
"PACKAGE_NAME('ignore-entries-c-subdirectory')",
"PACKAGE_VERSION('6.6.6')"
]))
fs.rootdirectory().add(name=const.CONFIX2_DIR, entry=File())
subdirectory = fs.rootdirectory().add(name='subdirectory',
entry=Directory())
subdirectory.add(
name=const.CONFIX2_DIR,
entry=File(lines=[
'IGNORE_ENTRIES(["ignored.h"])', 'IGNORE_FILE("ignored.c")'
]))
subdirectory.add(name='ignored.h', entry=File())
subdirectory.add(name='ignored.c', entry=File())
subdirectory.add(name='not-ignored.h', entry=File())
subdirectory.add(name='not-ignored.c', entry=File())
package = LocalPackage(rootdirectory=fs.rootdirectory(),
setups=[ConfixSetup(use_libtool=False)])
package.boil(external_nodes=[])
self.failIf(package.rootbuilder().find_entry_builder(
path=['subdirectory', 'ignored.h']))
self.failIf(package.rootbuilder().find_entry_builder(
path=['subdirectory', 'ignored.c']))
self.failUnless(package.rootbuilder().find_entry_builder(
path=['subdirectory', 'not-ignored.h']))
self.failUnless(package.rootbuilder().find_entry_builder(
path=['subdirectory', 'not-ignored.c']))
for librarybuilder in package.rootbuilder().find_entry_builder(
['subdirectory']).iter_builders():
if isinstance(librarybuilder, LibraryBuilder):
break
pass
else:
self.fail()
pass
self.failIf('ignored.c' in (member.entry().name()
for member in librarybuilder.members()))
self.failIf('ignored.h' in (member.entry().name()
for member in librarybuilder.members()))
pass
def setUp(self):
PersistentTestCase.setUp(self)
self.sourcerootpath_ = self.rootpath() + ['source']
self.buildrootpath_ = self.rootpath() + ['build']
self.fs_ = FileSystem(path=self.sourcerootpath_,
rootdirectory=packages.lo_hi1_hi2_highest_exe(name='intrapackagebuildtest',
version='1.2.3'))
self.package_ = LocalPackage(rootdirectory=self.fs_.rootdirectory(),
setups=[ConfixSetup(use_libtool=self.use_libtool())])
self.package_.boil(external_nodes=[])
self.package_.output()
self.fs_.sync()
pass
def test__basic(self):
fs = FileSystem(path=['don\'t', 'care'], rootdirectory=make_package())
package = LocalPackage(rootdirectory=fs.rootdirectory(),
setups=[ConfixSetup(use_libtool=False)])
package.boil(external_nodes=[])
plainfile_data = package.rootbuilder().find_entry_builder(
['plainfile_data'])
plainfile_prefix = package.rootbuilder().find_entry_builder(
['plainfile_prefix'])
self.failIf(plainfile_data is None)
self.failIf(plainfile_prefix is None)
self.failUnless(isinstance(plainfile_data, PlainFileBuilder))
self.failUnless(isinstance(plainfile_prefix, PlainFileBuilder))
pass
def test(self):
fs = FileSystem(path=self.rootpath())
source = fs.rootdirectory().add(name='source', entry=Directory())
source.add(
name=const.CONFIX2_PKG,
entry=File(lines=[
"PACKAGE_NAME('InterixLink')", "PACKAGE_VERSION('1.2.3')"
]))
source.add(name=const.CONFIX2_DIR, entry=File())
lolo = source.add(name='lolo', entry=Directory())
lolo.add(name=const.CONFIX2_DIR, entry=File())
lolo.add(name='lolo.h', entry=File(lines=["void lolo(void);"]))
lolo.add(name='lolo.c', entry=File(lines=["void lolo(void) {}"]))
lo = source.add(name='lo', entry=Directory())
lo.add(name=const.CONFIX2_DIR, entry=File())
lo.add(name='lo.h', entry=File(lines=["void lo(void);"]))
lo.add(
name='lo.c',
entry=File(lines=["#include <lolo.h>", "void lo(void) {lolo();}"]))
hi = source.add(name='hi', entry=Directory())
hi.add(name=const.CONFIX2_DIR, entry=File())
hi.add(name='hi.c',
entry=File(lines=["#include <lo.h>", "void hi(void) {lo();}"]))
build = fs.rootdirectory().add(name='build', entry=Directory())
package = LocalPackage(rootdirectory=source,
setups=[ConfixSetup(use_libtool=True)])
package.boil(external_nodes=[])
package.output()
fs.sync()
bootstrap.bootstrap(packageroot=source.abspath(),
path=None,
use_kde_hack=False,
argv0=sys.argv[0])
configure.configure(packageroot=source.abspath(),
builddir=build.abspath(),
prefix=None,
readonly_prefixes=None)
make.make(builddir=build.abspath(), args=[])
pass