def test(self):
package = InstalledPackage(
name='PackageFileTestPackage',
version='1.2.3',
nodes=[
InstalledNode(name=['a', 'b'],
provides=[Provide_Symbol(symbol='beitl')],
requires=[
Require_Symbol(symbol='sack',
found_in=['PackageFileTest'])
],
buildinfos=[])
])
fs = FileSystem(path=['', 'tmp'])
pkgfile = fs.rootdirectory().add(name='test.repo', entry=File())
# dump package to a file, and re-read it from that
# file. perform placebo checks.
repo = PackageFile(file=pkgfile)
repo.dump(package=package)
repo = PackageFile(file=pkgfile)
package = repo.load()
self.failUnless(len(package.nodes()) == 1)
node = package.nodes()[0]
self.failUnless(len(node.provides()) == 1)
self.failUnless(len(node.requires()) == 1)
self.failUnlessRaises(StopIteration, node.iter_buildinfos().next)
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())
lo1 = fs.rootdirectory().add(
name='lo1',
entry=Directory())
lo2 = fs.rootdirectory().add(
name='lo2',
entry=Directory())
hi = fs.rootdirectory().add(
name='hi',
entry=Directory())
package = LocalPackage(rootdirectory=fs.rootdirectory(), setups=[NullSetup()])
lo1_builder = DirectoryBuilder(directory=lo1)
lo1_builder.add_provide(Provide_Symbol(symbol='the_ambiguous_symbol'))
package.rootbuilder().add_builder(lo1_builder)
lo2_builder = DirectoryBuilder(directory=lo2)
lo2_builder.add_provide(Provide_Symbol(symbol='the_ambiguous_symbol'))
package.rootbuilder().add_builder(lo2_builder)
hi_builder = DirectoryBuilder(directory=hi)
hi_builder.add_require(Require_Symbol(symbol='the_ambiguous_symbol', found_in=[]))
package.rootbuilder().add_builder(hi_builder)
self.failUnlessRaises(Error, package.boil, external_nodes=[])
pass
def setUp(self):
fs = FileSystem(path=['', 'home', 'jfasch', '.confix2'])
self.file_ = fs.rootdirectory().add(
name='rc',
entry=File(lines=[
"the_profile = {",
" 'PREFIX': '/some/prefix',",
" 'READONLY_PREFIXES': ['/some/prefix', '/some/other/prefix'],",
" 'SHORT_LIBNAMES': True,",
" 'USE_LIBTOOL': True,",
" 'USE_BULK_INSTALL': True,",
" 'USE_KDE_HACK': False,",
" 'BUILDROOT': '/some/build/dir',",
" 'MESSAGE_PREFIX': 'some-message-prefix',",
" 'PRINT_TIMINGS': False,",
" 'ADVANCED': False,",
"",
" 'CONFIGURE': {",
" 'ENV': {",
" 'CFLAGS': '-some-cflags',",
" 'CXXFLAGS': '-some-cxxflags',",
" 'INSTALL': '/bin/install'",
" },",
" 'ARGS': ['--arg1', '--arg2'],",
" },",
"}",
"PROFILES = {",
" 'some_profile': the_profile,",
"}",
]))
pass
def setUp(self):
fs = FileSystem(path=['', 'path', 'to', 'it'])
fs.rootdirectory().add(name=const.CONFIX2_PKG,
entry=File(lines=[
"PACKAGE_NAME('ExternalLibraryTest')",
"PACKAGE_VERSION('1.2.3')"
]))
fs.rootdirectory().add(name=const.CONFIX2_DIR,
entry=File(lines=[
'DIRECTORY(["lolo"])',
'DIRECTORY(["lo"])',
'DIRECTORY(["hi"])',
]))
lolo = fs.rootdirectory().add(name='lolo', entry=Directory())
lolo.add(
name=const.CONFIX2_DIR,
entry=File(lines=[
"PROVIDE_SYMBOL('lolo')", "EXTERNAL_LIBRARY(",
" incpath=['-I/the/include/path/of/lolo'],",
" libpath=['-L/the/first/library/path/of/lolo', '-L/the/second/library/path/of/lolo'],",
" cflags=['lolo_cflags'],",
" cxxflags=['lolo_cxxflags'],",
" cmdlinemacros={'cmdlinemacro_lolo': 'value_lolo'},",
" libs=['-llolo'])"
]))
lo = fs.rootdirectory().add(name='lo', entry=Directory())
lo.add(
name=const.CONFIX2_DIR,
entry=File(lines=[
"REQUIRE_SYMBOL('lolo', URGENCY_ERROR)",
"PROVIDE_SYMBOL('lo')", "EXTERNAL_LIBRARY(",
" incpath=['-I/the/include/path/of/lo'],",
" libpath=['-L/the/first/library/path/of/lo', '-L/the/second/library/path/of/lo'],",
" cflags=['lo_cflags'],", " cxxflags=['lo_cxxflags'],",
" cmdlinemacros={'cmdlinemacro_lo': 'value_lo'},",
" libs=['-llo'])"
]))
hi = fs.rootdirectory().add(name='hi', entry=Directory())
hi.add(name=const.CONFIX2_DIR,
entry=File(lines=[
'hi_c = C(filename="hi_c.c")',
'hi_cc = CXX(filename="hi_cc.cc")',
'LIBRARY(basename="hi", members=[hi_c, hi_cc])'
]))
hi.add(name='hi_c.c',
entry=File(
lines=["// CONFIX:REQUIRE_SYMBOL('lo', URGENCY_ERROR)"]))
hi.add(name='hi_cc.cc',
entry=File(
lines=["// CONFIX:REQUIRE_SYMBOL('lo', URGENCY_ERROR)"]))
self.__package = LocalPackage(rootdirectory=fs.rootdirectory(),
setups=[ExplicitSetup(use_libtool=True)])
self.__package.boil(external_nodes=[])
self.__package.output()
pass
def test__relative_path(self):
fs = FileSystem(path=['a', 'b'])
subdir = fs.rootdirectory().add(name='subdir', entry=Directory())
subsubdir = subdir.add(name='subsubdir', entry=Directory())
file = subsubdir.add(name='file', entry=File())
self.failUnless(
subsubdir.relpath(fs.rootdirectory()) == ['subdir', 'subsubdir'])
self.failUnless(file.relpath(subdir) == ['subsubdir', 'file'])
pass
def test__sync_root_more_than_one_deep(self):
# the above tests only test syncing an in-memory filesystem
# whose root is only one directory apart from a physical
# directory. here we test whether it work with two directory
# entries in the air as well.
fs = FileSystem(path=self.rootpath())
fs.sync()
self.failUnless(os.path.isdir(os.sep.join(self.rootpath())))
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())
lo = fs.rootdirectory().add(
name='lo',
entry=Directory())
hi = fs.rootdirectory().add(
name='hi',
entry=Directory())
package = LocalPackage(rootdirectory=fs.rootdirectory(), setups=[NullSetup()])
lodir_builder = DirectoryBuilder(directory=lo)
lodir_builder.add_builder(DeferredProvider(provide=Provide_Symbol(symbol='the_deferred_provided_symbol')))
package.rootbuilder().add_builder(lodir_builder)
hidir_builder = DirectoryBuilder(directory=hi)
hidir_builder.add_require(Require_Symbol(symbol='the_deferred_provided_symbol',
found_in=[],
urgency=Require.URGENCY_ERROR))
package.rootbuilder().add_builder(hidir_builder)
package.boil(external_nodes=[])
self.failUnless(lodir_builder in package.digraph().successors(hidir_builder))
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__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(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 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(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__implicit_name(self):
fs = FileSystem(path=[])
fs.rootdirectory().add(name=const.CONFIX2_PKG,
entry=File(lines=[
"PACKAGE_NAME('ExecutableInMemoryTest')",
"PACKAGE_VERSION('1.2.3')"
]))
fs.rootdirectory().add(
name=const.CONFIX2_DIR,
entry=File(
lines=["EXECUTABLE(center=C(filename='main.c'), members=[])"]))
fs.rootdirectory().add(name='main.c', entry=File())
package = LocalPackage(rootdirectory=fs.rootdirectory(),
setups=[ExplicitSetup(use_libtool=False)])
package.boil(external_nodes=[])
found_exe_builder = None
for b in package.rootbuilder().iter_builders():
if isinstance(b, ExecutableBuilder):
self.failUnless(found_exe_builder is None)
found_exe_builder = b
continue
pass
self.failIf(found_exe_builder is None)
self.failUnless(
found_exe_builder.exename() == 'ExecutableInMemoryTest_main')
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 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_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__explicit_mode(self):
fs = FileSystem(path=self.rootpath())
file_with_0755 = fs.rootdirectory().add(name='file_with_0755',
entry=File(mode=0755))
fs.sync()
self.failUnless(os.path.isfile(os.sep.join(file_with_0755.abspath())))
self.failUnlessEqual(
stat.S_IMODE(
os.stat(os.sep.join(file_with_0755.abspath())).st_mode), 0755)
pass
def test(self):
fs_orig = FileSystem(path=[])
fs_overlay = FileSystem(path=[])
fs_overlay.rootdirectory().add(name='dir', entry=Directory())
fs = OverlayFileSystem(original=fs_orig, overlay=fs_overlay)
dir = fs.rootdirectory().get('dir')
try:
dir.add(name='file', entry=File())
self.fail()
except OverlayDirectory.OverlayAddError:
pass
pass
def setUp(self):
fs = FileSystem(path=[], rootdirectory=intra_package.make_source_tree())
self.__package = LocalPackage(rootdirectory=fs.rootdirectory(),
setups=[ExplicitDirectorySetup(), ExplicitCSetup(), CMakeSetup()])
self.__package.boil(external_nodes=[])
self.__package.output()
self.__lo_output_builder = find_cmake_output_builder(self.__package.rootbuilder().find_entry_builder(['lo']))
self.__hi_output_builder = find_cmake_output_builder(self.__package.rootbuilder().find_entry_builder(['hi']))
self.__exe_output_builder = find_cmake_output_builder(self.__package.rootbuilder().find_entry_builder(['exe']))
pass
class CheckProgramBase(PersistentTestCase):
def __init__(self, methodName):
PersistentTestCase.__init__(self, methodName)
self.fs_ = None
pass
def use_libtool(self):
assert 0
def setUp(self):
PersistentTestCase.setUp(self)
self.fs_ = FileSystem(path=self.rootpath())
self.build_ = self.fs_.rootdirectory().add(name='build',
entry=Directory())
self.source_ = self.fs_.rootdirectory().add(name='source',
entry=Directory())
self.source_.add(
name=const.CONFIX2_PKG,
entry=File(lines=[
'PACKAGE_NAME("CheckProgramTest")', 'PACKAGE_VERSION("1.2.3")'
]))
self.source_.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)"
]))
self.source_.add(
name='main.c',
entry=File(lines=[
'#include <sys/types.h>', '#include <sys/stat.h>',
'#include <fcntl.h>', '#include <stdlib.h>',
'#include <string.h>', 'int main(void) {',
' const char* name = getenv("name");', ' if (!name)',
' return 1;', ' if (strcmp(name, "value"))',
' return 1;', ' return open("' +
os.sep.join(self.build_.abspath() + ['my-check-was-here']) +
'",', ' O_CREAT|O_RDWR, 0644) >=0?0:1;', '}'
]))
self.package_ = LocalPackage(
rootdirectory=self.source_,
setups=[ExplicitSetup(use_libtool=self.use_libtool())])
self.package_.boil(external_nodes=[])
self.package_.output()
pass
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__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__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__sync_mem2sync(self):
fs = FileSystem(path=self.rootpath())
subdir = Directory(mode=0700)
fs.rootdirectory().add(name='subdir', entry=subdir)
file = File(mode=0755)
subdir.add(name='file', entry=file)
self.failUnlessEqual(fs.rootdirectory().state(),
DirectoryState.INMEMORY)
self.failUnlessEqual(subdir.state(), DirectoryState.INMEMORY)
self.failUnlessEqual(file.state(), FileState.NEW)
fs.sync()
self.failUnlessEqual(fs.rootdirectory().state(), DirectoryState.SYNC)
self.failUnlessEqual(subdir.state(), DirectoryState.SYNC)
self.failUnlessEqual(file.state(), FileState.SYNC_INMEM)
self.failUnless(os.path.isdir(os.sep.join(self.rootpath())))
self.failUnless(
os.path.isdir(os.sep.join(self.rootpath() + ['subdir'])))
self.failUnless(
os.path.isfile(os.sep.join(self.rootpath() + ['subdir', 'file'])))
self.failUnlessEqual(
stat.S_IMODE(
os.stat(os.sep.join(self.rootpath() + ['subdir'])).st_mode),
0700)
self.failUnlessEqual(
stat.S_IMODE(
os.stat(os.sep.join(self.rootpath() +
['subdir', 'file'])).st_mode), 0755)
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 = FileSystem(path=['don\'t', 'care'])
fs.rootdirectory().add(
name=const.CONFIX2_PKG,
entry=File(lines=[
"PACKAGE_NAME('" + self.__class__.__name__ +
"')", "PACKAGE_VERSION('1.2.3')",
"from libconfix.setups.explicit_setup import ExplicitSetup",
"SETUP([ExplicitSetup(use_libtool=True)])"
]))
fs.rootdirectory().add(
name=const.CONFIX2_DIR,
entry=File(lines=["DIRECTORY(['dir1'])", "DIRECTORY(['dir2'])"]))
dir1 = fs.rootdirectory().add(name='dir1', entry=Directory())
dir2 = fs.rootdirectory().add(name='dir2', entry=Directory())
dir1.add(name=const.CONFIX2_DIR,
entry=File(lines=["PROVIDE_SYMBOL('x')"]))
dir2.add(name=const.CONFIX2_DIR,
entry=File(lines=["PROVIDE_SYMBOL('x')"]))
package = LocalPackage(rootdirectory=fs.rootdirectory(), setups=None)
try:
package.boil(external_nodes=[])
self.fail()
except Error:
pass
pass
class IntraPackageBuildBase(PersistentTestCase):
def __init__(self, methodName):
PersistentTestCase.__init__(self, methodName)
pass
def use_libtool(self): assert 0
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(self):
try:
bootstrap.bootstrap(
packageroot=self.sourcerootpath_,
path=None,
use_kde_hack=False,
argv0=sys.argv[0])
os.makedirs(os.sep.join(self.buildrootpath_))
configure.configure(
packageroot=self.sourcerootpath_,
builddir=self.buildrootpath_,
prefix='/dev/null'.split(os.sep),
readonly_prefixes=[])
make.make(builddir=self.buildrootpath_, args=[])
except Error, e:
sys.stderr.write(`e`+'\n')
raise
self.failUnless(os.path.isfile(os.sep.join(self.buildrootpath_+['lo', 'lo.o'])))
self.failUnless(os.path.isfile(os.sep.join(self.buildrootpath_+['hi1', 'hi1.o'])))
self.failUnless(os.path.isfile(os.sep.join(self.buildrootpath_+['hi2', 'hi2.o'])))
self.failUnless(os.path.isfile(os.sep.join(self.buildrootpath_+['highest', 'highest.o'])))
self.failUnless(os.path.isfile(os.sep.join(self.buildrootpath_+['exe', 'main.o'])))
self.failUnless(os.path.isfile(os.sep.join(self.buildrootpath_+['exe', 'intrapackagebuildtest_exe_main'])))
pass
def test__virtual_file(self):
fs = FileSystem(path=self.rootpath())
dir = fs.rootdirectory().add(name='dir', entry=Directory())
file = dir.add(name='file',
entry=File(state=FileState.VIRTUAL,
lines=['some token']))
file.add_lines(['some other token'])
fs.sync()
self.failIf(os.path.exists(os.sep.join(file.abspath())))
self.failUnless(file.state() == FileState.VIRTUAL)
self.failIf(file.raw_lines() is None)
self.failUnless(file.lines() == ['some token', 'some other token'])
pass
def setUp(self):
self.fs_ = FileSystem(path=['don\'t', 'care'])
self.fs_.rootdirectory().add(
name=const.CONFIX2_PKG,
entry=File(
lines=["PACKAGE_NAME('LIBADD')", "PACKAGE_VERSION('1.2.3')"]))
self.fs_.rootdirectory().add(name=const.CONFIX2_DIR, entry=File())
lo = self.fs_.rootdirectory().add(name='lo', entry=Directory())
lo.add(name=const.CONFIX2_DIR, entry=File())
lo.add(name='lo.h', entry=File())
lo.add(name='lo.c', entry=File())
hi = self.fs_.rootdirectory().add(name='hi', entry=Directory())
hi.add(name=const.CONFIX2_DIR, entry=File())
hi.add(name='hi.c', entry=File(lines=['#include <lo.h>']))
pass
