def test__localinstall_not_absolutely_necessary(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('test_localinstall_not_absolutely_necessary')",
"PACKAGE_VERSION('1.2.3')"
]))
source.add(name=const.CONFIX2_DIR, entry=File())
source.add(name='file.idl', entry=File())
package = LocalPackage(rootdirectory=source,
setups=[
AutoBoilerplate(),
CMake(library_dependencies=False),
IDLSetup()
])
package.boil(external_nodes=[])
package.output()
fs.sync()
commands.cmake(packageroot=source.abspath(),
builddir=build.abspath(),
args=[])
commands.make(builddir=build.abspath(), args=[])
scan.rescan_dir(build)
self.failUnless(build.find(['confix-include', 'file.idl']))
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 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_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_explicit_no_public_visibility(self):
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(lines=["H(filename='header.h', public=False)"]))
fs.rootdirectory().add(name='header.h', entry=File())
package = LocalPackage(rootdirectory=fs.rootdirectory(),
setups=[Boilerplate(), C()])
package.boil(external_nodes=[])
package.output()
h = package.rootbuilder().find_entry_builder(['header.h'])
# no explicit local visibility is given, so the namespace
# recognizer sees no namespace - and the file can locally be
# included directly.
self.failUnlessEqual(h.package_visibility_action()[0],
HeaderBuilder.LOCALVISIBILITY_DIRECT_INCLUDE)
self.failUnlessEqual(h.package_visibility_action()[1], [])
# public visibility is explicitly not wanted.
self.failIf(h.public())
pass
def test__CMAKE_CMAKELISTS_ADD_INCLUDE_local_only(self):
fs = FileSystem(path=[''])
fs.rootdirectory().add(
name=const.CONFIX2_PKG,
entry=File(lines=[
'PACKAGE_NAME("test_CMAKE_CMAKELISTS_ADD_INCLUDE_local_only")',
'PACKAGE_VERSION("1.2.3")'
]))
fs.rootdirectory().add(
name=const.CONFIX2_DIR,
entry=File(lines=[
'CMAKE_CMAKELISTS_ADD_INCLUDE("include1", CMAKE_BUILDINFO_LOCAL)',
'CMAKE_CMAKELISTS_ADD_INCLUDE("include2", CMAKE_BUILDINFO_LOCAL)'
]))
package = LocalPackage(rootdirectory=fs.rootdirectory(),
setups=[ExplicitDirectorySetup(),
CMakeSetup()])
package.boil(external_nodes=[])
package.output()
self.failUnless('include1' in find_cmake_output_builder(
package.rootbuilder()).top_cmakelists().get_includes())
self.failUnless('include2' in find_cmake_output_builder(
package.rootbuilder()).top_cmakelists().get_includes())
for buildinfo in package.rootbuilder().iter_buildinfos():
self.failIf(
isinstance(buildinfo, BuildInfo_Toplevel_CMakeLists_Include))
pass
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__CMAKE_ADD_MODULE_FILE(self):
fs = FileSystem(path=[''])
fs.rootdirectory().add(
name=const.CONFIX2_PKG,
entry=File(lines=[
'PACKAGE_NAME("test_CMAKE_ADD_MODULE_FILE")',
'PACKAGE_VERSION("1.2.3")'
]))
fs.rootdirectory().add(
name=const.CONFIX2_DIR,
entry=File(lines=[
'CMAKE_ADD_MODULE_FILE(', ' name="file1",',
' lines=["xxx"],'
' flags=CMAKE_BUILDINFO_LOCAL)', 'CMAKE_ADD_MODULE_FILE(',
' name="file2",', ' lines=["xxx"],',
' flags=CMAKE_BUILDINFO_LOCAL)'
]))
package = LocalPackage(rootdirectory=fs.rootdirectory(),
setups=[ExplicitDirectorySetup(),
CMakeSetup()])
package.boil(external_nodes=[])
package.output()
self.failUnless(fs.rootdirectory().find(
['confix-admin', 'cmake', 'Modules', 'file1']))
self.failUnless(fs.rootdirectory().find(
['confix-admin', 'cmake', 'Modules', 'file2']))
pass
def test__CMAKE_CMDLINE_MACROS_local_only(self):
fs = FileSystem(path=[])
fs.rootdirectory().add(
name=const.CONFIX2_PKG,
entry=File(lines=[
'PACKAGE_NAME("test_CMAKE_CMDLINE_MACROS_local_only")',
'PACKAGE_VERSION("1.2.3")'
]))
fs.rootdirectory().add(
name=const.CONFIX2_DIR,
entry=File(lines=[
'CMAKE_CMDLINE_MACROS(macros={"macro1": "value1", "macro2": "value2"}, flags=CMAKE_BUILDINFO_LOCAL)'
]))
package = LocalPackage(rootdirectory=fs.rootdirectory(),
setups=[ExplicitDirectorySetup(),
CMakeSetup()])
package.boil(external_nodes=[])
package.output()
self.failUnless("-Dmacro1=value1" in find_cmake_output_builder(
package.rootbuilder()).local_cmakelists().get_definitions())
self.failUnless("-Dmacro2=value2" in find_cmake_output_builder(
package.rootbuilder()).local_cmakelists().get_definitions())
for buildinfo in package.rootbuilder().iter_buildinfos():
self.failIf(
isinstance(buildinfo, BuildInfo_CommandlineMacros_CMake))
pass
pass
def test__CMAKE_CMAKELISTS_ADD_FIND_CALL_propagate_and_local(self):
fs = FileSystem(path=[''])
fs.rootdirectory().add(
name=const.CONFIX2_PKG,
entry=File(lines=[
'PACKAGE_NAME("test_CMAKE_CMAKELISTS_ADD_FIND_CALL_propagate_and_local")',
'PACKAGE_VERSION("1.2.3")'
]))
fs.rootdirectory().add(
name=const.CONFIX2_DIR,
entry=File(lines=[
'CMAKE_CMAKELISTS_ADD_FIND_CALL("call", (CMAKE_BUILDINFO_PROPAGATE, CMAKE_BUILDINFO_LOCAL))'
]))
package = LocalPackage(rootdirectory=fs.rootdirectory(),
setups=[ExplicitDirectorySetup(),
CMakeSetup()])
package.boil(external_nodes=[])
package.output()
self.failUnless('call' in find_cmake_output_builder(
package.rootbuilder()).top_cmakelists().get_find_calls())
for buildinfo in package.rootbuilder().iter_buildinfos():
if isinstance(buildinfo, BuildInfo_Toplevel_CMakeLists_FindCall):
break
pass
else:
self.fail()
pass
pass
def test__explicit_no_public_visibility(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('blah')", "PACKAGE_VERSION('1.2.3')"]))
source.add(name=const.CONFIX2_DIR,
entry=File(lines=["H(filename='header.h', public=False)"]))
source.add(name='header.h', entry=File())
package = LocalPackage(
rootdirectory=source,
setups=[Boilerplate(),
C(), CMake(library_dependencies=False)])
package.boil(external_nodes=[])
package.output()
fs.sync()
commands.cmake(
packageroot=source.abspath(),
builddir=build.abspath(),
args=['-DCMAKE_INSTALL_PREFIX=' + '/'.join(install.abspath())])
commands.make(builddir=build.abspath(), args=['install'])
scan.rescan_dir(install)
self.failIf(install.find(['include', 'header.h']))
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 test(self):
fs = FileSystem(path=self.rootpath())
source = fs.rootdirectory().add(name='source',
entry=intra_package.make_source_tree())
build = fs.rootdirectory().add(name='build', entry=Directory())
package = LocalPackage(
rootdirectory=source,
setups=[ExplicitDirectorySetup(),
ExplicitCSetup(),
CMakeSetup()])
package.boil(external_nodes=[])
package.output()
fs.sync()
commands.cmake(packageroot=source.abspath(),
builddir=build.abspath(),
args=[])
commands.make(builddir=build.abspath(), args=[])
scan.rescan_dir(build)
# I doubt that this will hold on Windows :-) if it becomes an
# issue we will skip this check
self.failUnless(build.find(['lo', 'liblo.a']))
self.failUnless(build.find(['hi', 'libhi.a']))
self.failUnless(build.find(['exe', 'exe']))
pass
def test__basic(self):
fs = FileSystem(path=self.rootpath())
source = fs.rootdirectory().add(name='source', entry=make_package())
build = fs.rootdirectory().add(name='build', entry=Directory())
install = fs.rootdirectory().add(name='install', entry=Directory())
package = LocalPackage(rootdirectory=source,
setups=[
Boilerplate(),
Plainfile(),
CMake(library_dependencies=False)
])
package.boil(external_nodes=[])
package.output()
fs.sync()
commands.cmake(
packageroot=source.abspath(),
builddir=build.abspath(),
args=['-DCMAKE_INSTALL_PREFIX=' + '/'.join(install.abspath())])
commands.make(builddir=build.abspath(), args=['install'])
self.failUnless(
os.path.isfile(
os.sep.join(
self.rootpath() +
['install', 'share', 'subdir', 'data', 'plainfile_data'])))
self.failUnless(
os.path.isfile(
os.sep.join(
self.rootpath() +
['install', 'subdir', 'prefix', 'plainfile_prefix'])))
pass
def test__basic(self):
linked_package = LocalPackage(
rootdirectory=self.__linked_sourcedir,
setups=[ExplicitDirectorySetup(),
ExplicitCSetup(),
CMakeSetup()])
# read repo files along the cascade
repo = AutomakeCascadedPackageRepository(
prefix=self.__regular_installdir.abspath(),
readonly_prefixes=[
self.__two_readonly_installdir.abspath(),
self.__one_readonly_installdir.abspath()
])
linked_package.boil(external_nodes=repo.iter_nodes())
linked_package.output()
self.__fs.sync()
commands.cmake(
packageroot=self.__linked_sourcedir.abspath(),
builddir=self.__linked_builddir.abspath(),
args=[
'-DCMAKE_INSTALL_PREFIX=' +
'/'.join(self.__regular_installdir.abspath()),
'-DREADONLY_PREFIXES=' +
'/'.join(self.__one_readonly_installdir.abspath()) + ';' +
'/'.join(self.__two_readonly_installdir.abspath())
])
commands.make(builddir=self.__linked_builddir.abspath(), args=[])
self.failUnless(
os.path.isfile(
os.sep.join(self.__linked_builddir.abspath() + ['exe'])))
pass
def test__basic(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=[
"from libconfix.setups.boilerplate import Boilerplate",
"from libconfix.setups.cmake import CMake",
"from libconfix.setups.script import Script",
"PACKAGE_NAME('cmake-script-build')",
"PACKAGE_VERSION('1.2.3')",
"SETUP([Boilerplate(), CMake(library_dependencies=False), Script()])",
]))
source.add(name=const.CONFIX2_DIR,
entry=File(lines=['ADD_SCRIPT(filename="script")']))
source.add(name='script', entry=File())
package = LocalPackage(rootdirectory=source, setups=None)
package.boil(external_nodes=[])
package.output()
fs.sync()
commands.cmake(
packageroot=source.abspath(),
builddir=build.abspath(),
args=['-DCMAKE_INSTALL_PREFIX=' + '/'.join(install.abspath())])
commands.make(builddir=build.abspath(), args=['install'])
stat = os.stat(os.sep.join(install.abspath() + ['bin', 'script']))
pass
def test__live(self):
fs = FileSystem(path=[])
fs.rootdirectory().add(name=const.CONFIX2_PKG,
entry=File(lines=[
'PACKAGE_NAME("ModulesInMemoryTest")',
'PACKAGE_VERSION("1.2.3")'
]))
fs.rootdirectory().add(
name=const.CONFIX2_DIR,
entry=File(lines=[
'from libconfix.plugins.cmake.out_cmake import find_cmake_output_builder',
'from libconfix.core.machinery.builder import Builder',
'class ModuleAdder(Builder):', ' def output(self):',
' super(ModuleAdder, self).output()',
' cmake_out = find_cmake_output_builder(self.parentbuilder())',
' cmake_out.add_module_file(name="TestModule.cmake",',
' lines=["my content"])',
' pass', ' pass',
' def locally_unique_id(self):',
' return str(self.__class__)',
'ADD_BUILDER(ModuleAdder())'
]))
package = LocalPackage(rootdirectory=fs.rootdirectory(),
setups=[CMakeSetup(),
ExplicitDirectorySetup()])
package.boil(external_nodes=[])
package.output()
modulefile = fs.rootdirectory().find(
['confix-admin', 'cmake', 'Modules', 'TestModule.cmake'])
self.failIf(modulefile is None)
self.failIf(modulefile.lines()[0] != 'my content')
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):
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__CMAKE_CMAKELISTS_ADD_INCLUDE_DIRECTORY_local(self):
fs = FileSystem(path=[''])
fs.rootdirectory().add(
name=const.CONFIX2_PKG,
entry=File(lines=[
'PACKAGE_NAME("test_CMAKE_CMAKELISTS_ADD_INCLUDE_DIRECTORY_local")',
'PACKAGE_VERSION("1.2.3")'
]))
fs.rootdirectory().add(name=const.CONFIX2_DIR,
entry=File(lines=['DIRECTORY(["subdir"])']))
subdir = fs.rootdirectory().add(name='subdir', entry=Directory())
subdir.add(
name=const.CONFIX2_DIR,
entry=File(lines=[
'CMAKE_CMAKELISTS_ADD_INCLUDE_DIRECTORY("include-directory", CMAKE_BUILDINFO_LOCAL)'
]))
package = LocalPackage(rootdirectory=fs.rootdirectory(),
setups=[ExplicitDirectorySetup(),
CMakeSetup()])
package.boil(external_nodes=[])
package.output()
cmake_output_builder = find_cmake_output_builder(
package.rootbuilder().find_entry_builder(['subdir']))
self.failUnless('include-directory' in cmake_output_builder.
local_cmakelists().get_include_directories())
pass
def test__publicinstall_flat(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('test_publicinstall_flat')",
"PACKAGE_VERSION('1.2.3')"
]))
source.add(name=const.CONFIX2_DIR, entry=File())
source.add(name='file.idl', entry=File())
package = LocalPackage(rootdirectory=source,
setups=[
AutoBoilerplate(),
CMake(library_dependencies=False),
IDLSetup()
])
package.boil(external_nodes=[])
package.output()
fs.sync()
commands.cmake(
packageroot=source.abspath(),
builddir=build.abspath(),
args=['-DCMAKE_INSTALL_PREFIX=' + '/'.join(install.abspath())])
commands.make(builddir=build.abspath(), args=['install'])
scan.rescan_dir(install)
self.failUnless(install.find(['include', 'file.idl']))
pass
def test__basic(self):
fs = FileSystem(path=[])
fs.rootdirectory().add(
name=const.CONFIX2_PKG,
entry=File(lines=[
'PACKAGE_NAME("HierarchyInMemoryTest.basic")',
'PACKAGE_VERSION("1.2.3")'
]))
fs.rootdirectory().add(
name=const.CONFIX2_DIR,
entry=File(lines=[
'DIRECTORY(["directory0"])', 'DIRECTORY(["directory1"])'
]))
fs.rootdirectory().add(name='directory0', entry=Directory())
fs.rootdirectory().add(name='directory1', entry=Directory())
package = LocalPackage(rootdirectory=fs.rootdirectory(),
setups=[ExplicitDirectorySetup(),
CMakeSetup()])
package.boil(external_nodes=[])
package.output()
cmake_output_builder = find_cmake_output_builder(package.rootbuilder())
self.failUnlessEqual(
len(cmake_output_builder.local_cmakelists().get_subdirectories()),
2
# plus the admin stuff, confix-admin/cmake/Modules
+ 4)
self.failUnless('directory0' in cmake_output_builder.local_cmakelists(
).get_subdirectories())
self.failUnless('directory1' in cmake_output_builder.local_cmakelists(
).get_subdirectories())
pass
def test__generated_plainfile_install(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('generated_plainfile_install')",
"PACKAGE_VERSION('1.2.3')"
]))
source.add(
name=const.CONFIX2_DIR,
entry=File(lines=[
"ADD_PLAINFILE(filename='prefixfile', prefixdir='prefixdir')",
"ADD_PLAINFILE(filename='datafile', datadir='datadir')",
"CMAKE_CMAKELISTS_ADD_CUSTOM_COMMAND__OUTPUT(",
" outputs=['prefixfile', 'datafile'],",
" commands=[('touch', ['prefixfile']),",
" ('touch', ['datafile'])],",
" depends=[],",
")",
# without doing anything, nothing will be built. hook
# it to the 'all' target.
"CMAKE_CMAKELISTS_ADD_CUSTOM_TARGET(",
" name='generate_those_bloody_files_when_I_say_make',",
" all=True,",
" depends=['prefixfile', 'datafile'],",
")",
]))
source.add(name='prefixfile',
entry=File(state=FileState.VIRTUAL, lines=[]))
source.add(name='datafile',
entry=File(state=FileState.VIRTUAL, lines=[]))
package = LocalPackage(rootdirectory=source,
setups=[
Boilerplate(),
Plainfile(),
CMake(library_dependencies=False)
])
package.boil(external_nodes=[])
package.output()
fs.sync()
commands.cmake(
packageroot=source.abspath(),
builddir=build.abspath(),
args=['-DCMAKE_INSTALL_PREFIX=' + '/'.join(install.abspath())])
commands.make(builddir=build.abspath(), args=['install'])
scan.rescan_dir(install)
self.failUnless(install.find(['prefixdir', 'prefixfile']))
self.failUnless(install.find(['share', 'datadir', 'datafile']))
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__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 _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__no_timestamp_clobber(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('test_no_timestamp_clobber')",
"PACKAGE_VERSION('1.2.3')"
]))
source.add(name=const.CONFIX2_DIR,
entry=File(lines=[
"for f in xrange(200):",
" H(filename='%s.h' % str(f), install=['subdir'])",
]))
for f in xrange(200):
source.add(name='%s.h' % str(f), entry=File())
pass
package = LocalPackage(
rootdirectory=source,
setups=[ExplicitDirectorySetup(),
ExplicitCSetup(),
CMakeSetup()])
package.boil(external_nodes=[])
package.output()
fs.sync()
commands.cmake(packageroot=source.abspath(),
builddir=build.abspath(),
args=[])
commands.make(builddir=build.abspath(), args=[])
mtimes = {}
for f in xrange(200):
mtime = os.stat(
os.sep.join(build.abspath() +
['confix-include', 'subdir',
'%s.h' % str(f)])).st_mtime
mtimes[f] = mtime
pass
# wait a bit and then call 'make' again
time.sleep(1)
commands.make(builddir=build.abspath(), args=[])
for f in xrange(200):
mtime = os.stat(
os.sep.join(build.abspath() +
['confix-include', 'subdir',
'%s.h' % str(f)])).st_mtime
self.failIf(mtime != mtimes[f], f)
pass
pass
def test__library_depends_on_generated_header__from_a_header_only_directory(
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('library_depends_on_generated_header__from_a_header_only_directory')",
"PACKAGE_VERSION('1.2.3')"
]))
generated_header = source.add(name='generated-header',
entry=Directory())
source.add(name=const.CONFIX2_DIR,
entry=File(lines=[
"DIRECTORY(['generated-header'])",
"DIRECTORY(['library1'])",
"DIRECTORY(['library2'])",
]))
library1 = source.add(name='library1', entry=Directory())
library1.add(
name=const.CONFIX2_DIR,
entry=File(lines=[
"LIBRARY(members=[C(filename='using-generated-header.c')])"
]))
library1.add(name='using-generated-header.c',
entry=File(lines=['#include <generated-header.h>']))
library2 = source.add(name='library2', entry=Directory())
library2.add(
name=const.CONFIX2_DIR,
entry=File(lines=[
"LIBRARY(members=[C(filename='using-generated-header.c')])"
]))
library2.add(name='using-generated-header.c',
entry=File(lines=['#include <generated-header.h>']))
package = LocalPackage(rootdirectory=source,
setups=[
Boilerplate(),
C(),
CMake(library_dependencies=False),
GeneratedHeaderSetup()
])
package.boil(external_nodes=[])
package.output()
fs.sync()
commands.cmake(packageroot=source.abspath(), builddir=build.abspath())
commands.make(builddir=build.abspath(), args=['-j', 'VERBOSE=1'])
pass
def test__two_directories_with_generator_same_outputfilename(self):
"""
The artificial custom target that we generate for every custom
command has a name that is derived from the command's
output(s). This leads to clashes when two directories have
commands that generate outputs with the same name.
"""
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('two_directories_with_generator_same_outputfilename')",
"PACKAGE_VERSION('1.2.3')"
]))
source.add(
name=const.CONFIX2_DIR,
entry=File(lines=['DIRECTORY(["dira"])', 'DIRECTORY(["dirb"])']))
dira = source.add(name='dira', entry=Directory())
dira.add(name=const.CONFIX2_DIR,
entry=File(lines=[
'CMAKE_CMAKELISTS_ADD_CUSTOM_COMMAND__OUTPUT(',
' outputs=["output"],',
' commands=[("touch", ["output"])],', ' depends=[])'
]))
dirb = source.add(name='dirb', entry=Directory())
dirb.add(name=const.CONFIX2_DIR,
entry=File(lines=[
'CMAKE_CMAKELISTS_ADD_CUSTOM_COMMAND__OUTPUT(',
' outputs=["output"],',
' commands=[("touch", ["output"])],', ' depends=[])'
]))
package = LocalPackage(rootdirectory=source,
setups=[
Boilerplate(),
Plainfile(),
CMake(library_dependencies=False)
])
package.boil(external_nodes=[])
package.output()
fs.sync()
commands.cmake(packageroot=source.abspath(),
builddir=build.abspath(),
args=[])
commands.make(builddir=build.abspath(), args=[])
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
