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(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 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 = dirhier.packageroot()
file = fs.rootdirectory().add(name='x.iface',
entry=File(lines=['REQUIRE_SYMBOL(symbol="unknown_symbol", urgency=URGENCY_ERROR)']))
package = LocalPackage(rootdirectory=fs.rootdirectory(),
setups=[FileInterfaceTestSetup()])
self.failUnlessRaises(NotResolved, package.boil, external_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 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 setUp(self):
self.fs_ = dirhier.packageroot()
dir1 = self.fs_.rootdirectory().add(name='dir1', entry=Directory())
dir1.add(name=const.CONFIX2_DIR, entry=File(lines=[]))
dir2 = dir1.add(name='dir2', entry=Directory())
dir2.add(name=const.CONFIX2_DIR, entry=File(lines=[]))
dir3 = dir2.add(name='dir3', entry=Directory())
dir3.add(name=const.CONFIX2_DIR, entry=File(lines=[]))
dir3.add(name='file.c', entry=File(lines=[]))
self.dir3_ = dir3
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(self):
fs = dirhier.packageroot()
lodir = dirhier.subdir(fs.rootdirectory(), 'lo')
lofile = lodir.add(name='lo.iface',
entry=File(lines=['PROVIDE_SYMBOL(symbol="lo")']))
hidir = dirhier.subdir(fs.rootdirectory(), 'hi')
hifile = hidir.add(name='hi.iface',
entry=File(lines=['REQUIRE_SYMBOL(symbol="lo", urgency=URGENCY_ERROR)']))
package = LocalPackage(rootdirectory=fs.rootdirectory(),
setups=[ImplicitDirectorySetup(),
FileInterfaceTestSetup()])
package.boil(external_nodes=[])
lodirbuilder = package.rootbuilder().find_entry_builder(['lo'])
hidirbuilder = package.rootbuilder().find_entry_builder(['hi'])
# root, lo, hi
self.assertEqual(len(package.digraph().nodes()), 3)
rootnode = None
lonode = None
hinode = None
for n in package.digraph().nodes():
if n is package.rootbuilder():
rootnode = n
continue
if n is lodirbuilder:
lonode = n
continue
if n is hidirbuilder:
hinode = n
continue
pass
self.assertEqual(len(package.digraph().successors(hinode)), 1)
self.assertEqual(len(package.digraph().successors(lonode)), 0)
self.assert_(lonode in package.digraph().successors(hinode))
pass
def test(self):
fs = dirhier.packageroot()
lodir = dirhier.subdir(fs.rootdirectory(), 'lo')
lofile = lodir.add(name='lo.iface',
entry=File(lines=['PROVIDE_SYMBOL(symbol="lo")']))
hidir = dirhier.subdir(fs.rootdirectory(), 'hi')
hifile = hidir.add(
name='hi.iface',
entry=File(
lines=['REQUIRE_SYMBOL(symbol="lo", urgency=URGENCY_ERROR)']))
package = LocalPackage(
rootdirectory=fs.rootdirectory(),
setups=[ImplicitDirectorySetup(),
FileInterfaceTestSetup()])
package.boil(external_nodes=[])
lodirbuilder = package.rootbuilder().find_entry_builder(['lo'])
self.failIf(lodirbuilder is None)
hidirbuilder = package.rootbuilder().find_entry_builder(['hi'])
self.failIf(hidirbuilder is None)
lofilebuilder = package.rootbuilder().find_entry_builder(
['lo', 'lo.iface'])
self.failIf(lofilebuilder is None)
hifilebuilder = package.rootbuilder().find_entry_builder(
['hi', 'hi.iface'])
self.failIf(hifilebuilder is None)
self.failIf(lofilebuilder.successors() is None)
self.failUnlessEqual(len(lofilebuilder.successors()), 0)
self.failUnlessEqual(len(hifilebuilder.successors()), 1)
self.failUnless(lodirbuilder in hifilebuilder.successors())
self.failUnless(lofilebuilder.node() is lodirbuilder)
self.failUnless(hifilebuilder.node() is hidirbuilder)
self.failUnlessEqual(lofilebuilder.relate_calls(), 1)
self.failUnlessEqual(hifilebuilder.relate_calls(), 1)
pass
def test(self):
fs = dirhier.packageroot()
dirA = dirhier.subdir(fs.rootdirectory(), 'A')
fileA = dirA.add(name='A.iface',
entry=File(lines=['PROVIDE_SYMBOL(symbol="A")',
'REQUIRE_SYMBOL(symbol="B")']))
dirB = dirhier.subdir(fs.rootdirectory(), 'B')
fileB = dirB.add(name='B.iface',
entry=File(lines=['PROVIDE_SYMBOL(symbol="B")',
'REQUIRE_SYMBOL(symbol="A")']))
package = LocalPackage(rootdirectory=fs.rootdirectory(),
setups=[ImplicitDirectorySetup(),
FileInterfaceTestSetup()])
try:
package.boil(external_nodes=[])
except CycleError:
return
self.fail()
pass
def test(self):
fs = dirhier.packageroot()
fs.rootdirectory().add(
name='_check_proggy.c',
entry=File(lines=['int main(void) { return 0; }']))
fs.rootdirectory().add(
name='_proggy.c',
entry=File(lines=['int main(void) { return 0; }']))
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)
self.failUnless('blah__check_proggy' in
rootdir_output_builder.makefile_am().check_programs())
self.failUnless('blah__proggy' in
rootdir_output_builder.makefile_am().noinst_programs())
pass
def test(self):
fs = dirhier.packageroot()
providing_file = fs.rootdirectory().add(
name='providing_file.iface',
entry=File(lines=[
'PROVIDE_SYMBOL(symbol="the_symbol_which_it_is_all_about")'
]))
requiring_file = fs.rootdirectory().add(
name='requiring_file.iface',
entry=File(lines=[
'REQUIRE_SYMBOL(symbol="the_symbol_which_it_is_all_about",',
' urgency=URGENCY_ERROR)'
]))
package = LocalPackage(
rootdirectory=fs.rootdirectory(),
setups=[ImplicitDirectorySetup(),
FileInterfaceTestSetup()])
package.boil(external_nodes=[])
self.failUnlessEqual(len(package.rootbuilder().requires()), 0)
pass
def setUp(self):
self.__fs = dirhier.packageroot()
subdir1 = self.__fs.rootdirectory().add(name='subdir1',
entry=Directory())
subdir1.add(name=const.CONFIX2_DIR,
entry=File(lines=['PROVIDE_SYMBOL("subdir1")']))
subdir2 = self.__fs.rootdirectory().add(name='subdir2',
entry=Directory())
subdir2.add(
name=const.CONFIX2_DIR,
entry=File(lines=[
'PROVIDE_SYMBOL("subdir2")', 'REQUIRE_SYMBOL("subdir1")'
]))
subdir3 = self.__fs.rootdirectory().add(name='subdir3',
entry=Directory())
subdir3.add(name=const.CONFIX2_DIR,
entry=File(lines=['REQUIRE_SYMBOL("subdir2")']))
self.__package = LocalPackage(rootdirectory=self.__fs.rootdirectory(),
setups=[
ImplicitDirectorySetup(),
AutomakeSetup(use_libtool=False)
])
self.__package.boil(external_nodes=[])
self.__package.output()
self.__subdir1_builder = self.__package.rootbuilder(
).find_entry_builder(['subdir1'])
self.__subdir2_builder = self.__package.rootbuilder(
).find_entry_builder(['subdir2'])
self.__subdir3_builder = self.__package.rootbuilder(
).find_entry_builder(['subdir3'])
assert self.__subdir1_builder
assert self.__subdir2_builder
assert self.__subdir3_builder
pass
def test(self):
fs = dirhier.packageroot()
subdir = dirhier.subdir(parent=fs.rootdirectory(), name='a')
subsubdir = dirhier.subdir(parent=subdir, name='a')
package = LocalPackage(rootdirectory=fs.rootdirectory(),
setups=[ImplicitDirectorySetup()])
package.boil(external_nodes=[])
self.assertEqual(package.rootbuilder().directory().find(['a']), subdir)
self.assertEqual(package.rootbuilder().directory().find(['a', 'a']),
subsubdir)
subdir_builder = package.rootbuilder().find_entry_builder(['a'])
self.failIf(subdir_builder is None)
subsubdir_builder = package.rootbuilder().find_entry_builder(
['a', 'a'])
self.failIf(subsubdir_builder is None)
self.assertEqual(subdir_builder.directory(), subdir)
self.assertEqual(subsubdir_builder.directory(), subsubdir)
pass
def test__zerodeep(self):
fs = dirhier.packageroot()
file_h = fs.rootdirectory().add(name='file.h',
entry=File())
file_h.set_property(name='INSTALLPATH_CINCLUDE', value=[])
package = LocalPackage(rootdirectory=fs.rootdirectory(),
setups=[ConfixSetup(use_libtool=False)])
package.boil(external_nodes=[])
package.output()
# installation of file.h goes directly to $(includedir); no
# subdir involved.
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('')
self.failIf(directory_definition is None)
self.failUnless(directory_definition.dirname() is None)
self.failIf(directory_definition.files('HEADERS') is None)
self.failUnless(directory_definition.files('HEADERS') == ['file.h'])
# no local install is done; user will have his includepath
# pointed to $(srcdir)
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=[]))
# main.c has file property MAIN set to True, and hence must
# become the center of an executable.
main_c = fs.rootdirectory().add(
name='main.c',
entry=File(lines=[]))
main_c.set_property(name='MAIN', value=True)
# main2.c's builder (CBuilder, in this case) sees the
# EXENAME() call in its body, and must also become the center
# of an executable.
main2_c = fs.rootdirectory().add(
name='main2.c',
entry=File(lines=['// CONFIX:EXENAME("main2")']))
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
main_builder = None
main2_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
elif b.file().name() == 'file.c' and isinstance(b, CBuilder):
file_c_builder = b
pass
pass
elif isinstance(b, LibraryBuilder):
library_builder = b
pass
elif isinstance(b, ExecutableBuilder):
if b.center().file().name() == 'main.c':
main_builder = b
continue
if b.center().file().name() == 'main2.c':
main2_builder = b
continue
pass
pass
self.failUnless(isinstance(file_h_builder, HeaderBuilder))
self.failUnless(isinstance(file_c_builder, CBuilder))
self.failUnless(library_builder is None)
self.failUnless(isinstance(main_builder, ExecutableBuilder))
self.failUnless(isinstance(main2_builder, ExecutableBuilder))
self.failUnlessEqual(main2_builder.exename(), 'main2')
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=[]))
liblo.add(name='lo.h',
entry=File(lines=[
'#ifndef LO_H',
'#define LO_H',
'void lo();',
'#endif',
]))
liblo.add(name='lo.c', entry=File(lines=['void lo() {}']))
libhi = self.fs_.rootdirectory().add(name='hi', entry=Directory())
libhi.add(name=const.CONFIX2_DIR, entry=File(lines={}))
libhi.add(name='hi.h',
entry=File(lines=[
'#ifndef HI_H', '# define HI_H', '#endif', 'void hi();'
]))
libhi.add(
name='hi.c',
entry=File(lines=[
'#include <hi.h>', '#include <lo.h>', 'void hi() { lo(); }'
]))
exe = self.fs_.rootdirectory().add(name='exe', entry=Directory())
exe.add(name=const.CONFIX2_DIR, entry=File(lines=[]))
exe.add(name='main.c',
entry=File(lines=[
'#include <hi.h>', 'int main(void) {', ' hi();',
' return 0;', '}'
]))
exe.add(name='something.c', entry=File())
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.hidir_builder_ = self.package_.rootbuilder().find_entry_builder(
['hi'])
self.exedir_builder_ = self.package_.rootbuilder().find_entry_builder(
['exe'])
assert self.lodir_builder_
assert self.hidir_builder_
assert self.exedir_builder_
self.lolib_builder_ = None
self.hilib_builder_ = None
self.exe_builder_ = None
for b in self.lodir_builder_.iter_builders():
if isinstance(b, LibraryBuilder):
self.lolib_builder_ = b
pass
pass
for b in self.hidir_builder_.iter_builders():
if isinstance(b, LibraryBuilder):
self.hilib_builder_ = b
pass
pass
for b in self.exedir_builder_.iter_builders():
if isinstance(b, ExecutableBuilder):
self.exe_builder_ = b
pass
pass
pass
