def testLongName(self):
package = LocalPackage(rootdirectory=self.fs_.rootdirectory(),
setups=[ConfixSetup(use_libtool=False)])
package.boil(external_nodes=[])
dir3lib_builder = None
for b in package.rootbuilder().find_entry_builder(
['dir1', 'dir2', 'dir3']).iter_builders():
if isinstance(b, LibraryBuilder):
self.failIf(dir3lib_builder is not None)
dir3lib_builder = b
pass
pass
self.failUnlessEqual(
dir3lib_builder.basename(),
'_'.join([package.name()] +
self.dir3_.relpath(self.fs_.rootdirectory())))
pass
class AutomakeOutputTest(unittest.TestCase):
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 tearDown(self):
self.__fs = None
self.__package = None
pass
def test__subdirs(self):
rootdir_automake_builder = find_automake_output_builder(
self.__package.rootbuilder())
self.failIfEqual(self.__fs.rootdirectory().find(['Makefile.am']), None)
self.failUnless(const.CONFIX2_DIR in
rootdir_automake_builder.makefile_am().extra_dist())
self.failUnless(const.CONFIX2_PKG in
rootdir_automake_builder.makefile_am().extra_dist())
# relative positions of subdir1, subdir2, subdir3 in toplevel
# Makefile.am's SUBDIRS must be subdir1 < subdir2 <
# subdir3. (we cannot count on absolute positions because the
# topological range of '.' is random - '.' has no
# dependencies. (same hold for aux.))
aux = dot = subdir1 = subdir2 = subdir3 = None
for i in xrange(len(rootdir_automake_builder.makefile_am().subdirs())):
if rootdir_automake_builder.makefile_am().subdirs(
)[i] == 'confix-admin/automake':
self.failUnless(aux is None)
aux = i
elif rootdir_automake_builder.makefile_am().subdirs(
)[i] == 'subdir1':
self.failUnless(subdir1 is None)
subdir1 = i
elif rootdir_automake_builder.makefile_am().subdirs(
)[i] == 'subdir2':
self.failUnless(subdir2 is None)
subdir2 = i
elif rootdir_automake_builder.makefile_am().subdirs(
)[i] == 'subdir3':
self.failUnless(subdir3 is None)
subdir3 = i
pass
elif rootdir_automake_builder.makefile_am().subdirs()[i] == '.':
self.failUnless(dot is None)
dot = i
pass
pass
# see if there is anything in there at all
self.failIfEqual(
len(self.__fs.rootdirectory().find(['Makefile.am']).lines()), 0)
self.failIf(aux is None)
self.failIf(dot is None)
self.failIf(subdir1 is None)
self.failIf(subdir2 is None)
self.failIf(subdir3 is None)
self.failUnless(subdir1 < subdir2 < subdir3)
# see if we have our subdir's Makefiles registered for output
self.failUnless('Makefile' in rootdir_automake_builder.configure_ac().ac_config_files() or \
'./Makefile' in rootdir_automake_builder.configure_ac().ac_config_files())
self.failUnless('subdir1/Makefile' in rootdir_automake_builder.
configure_ac().ac_config_files())
self.failUnless('subdir2/Makefile' in rootdir_automake_builder.
configure_ac().ac_config_files())
self.failUnless('subdir3/Makefile' in rootdir_automake_builder.
configure_ac().ac_config_files())
pass
def test__configure_ac(self):
rootdir_automake_builder = find_automake_output_builder(
self.__package.rootbuilder())
self.failIfEqual(self.__fs.rootdirectory().find(['configure.ac']),
None)
self.failUnless('config.h' in rootdir_automake_builder.configure_ac().
ac_config_headers())
self.failIf(
rootdir_automake_builder.configure_ac().packagename() is None)
self.failIf(
rootdir_automake_builder.configure_ac().packageversion() is None)
pass
def test__auxdir(self):
rootdir_automake_builder = find_automake_output_builder(
self.__package.rootbuilder())
auxdir = self.__package.rootbuilder().directory().find(
['confix-admin', 'automake'])
self.failIf(auxdir is None)
mf_am = auxdir.find(['Makefile.am'])
self.failIf(mf_am is None)
self.failUnlessEqual(
rootdir_automake_builder.configure_ac().ac_config_aux_dir(),
'confix-admin/automake')
self.failUnless(
'confix-admin/automake/Makefile' in
rootdir_automake_builder.configure_ac().ac_config_files())
pass
def test__toplevel_makefile_am(self):
rootdir_automake_builder = find_automake_output_builder(
self.__package.rootbuilder())
self.failUnless(
'1.9' in rootdir_automake_builder.makefile_am().automake_options())
self.failUnless('dist-bzip2' in rootdir_automake_builder.makefile_am().
automake_options())
self.failUnless('dist-shar' not in rootdir_automake_builder.
makefile_am().automake_options())
self.failUnless('dist-zip' in rootdir_automake_builder.makefile_am().
automake_options())
self.failUnless(const.CONFIX2_DIR in
rootdir_automake_builder.makefile_am().extra_dist())
self.failUnless(const.CONFIX2_PKG in
rootdir_automake_builder.makefile_am().extra_dist())
self.failUnless(
self.__package.name() +
'.repo' in rootdir_automake_builder.makefile_am().extra_dist())
self.failUnless('Makefile.in' in rootdir_automake_builder.makefile_am(
).maintainercleanfiles())
self.failUnless('Makefile.am' in rootdir_automake_builder.makefile_am(
).maintainercleanfiles())
pass
def test__subdir1_makefile_am(self):
subdir1_automake_builder = find_automake_output_builder(
self.__package.rootbuilder().find_entry_builder(['subdir1']))
self.failIfEqual(
self.__fs.rootdirectory().find(['subdir1', 'Makefile.am']), None)
self.failUnless(const.CONFIX2_DIR in
subdir1_automake_builder.makefile_am().extra_dist())
self.failUnless('Makefile.in' in subdir1_automake_builder.makefile_am(
).maintainercleanfiles())
self.failUnless('Makefile.am' in subdir1_automake_builder.makefile_am(
).maintainercleanfiles())
pass
def test__subdir2_makefile_am(self):
subdir2_automake_builder = find_automake_output_builder(
self.__package.rootbuilder().find_entry_builder(['subdir2']))
self.failIfEqual(
self.__fs.rootdirectory().find(['subdir2', 'Makefile.am']), None)
self.failUnless(const.CONFIX2_DIR in
subdir2_automake_builder.makefile_am().extra_dist())
self.failUnless('Makefile.in' in subdir2_automake_builder.makefile_am(
).maintainercleanfiles())
self.failUnless('Makefile.am' in subdir2_automake_builder.makefile_am(
).maintainercleanfiles())
pass
def test__subdir3_makefile_am(self):
subdir3_automake_builder = find_automake_output_builder(
self.__package.rootbuilder().find_entry_builder(['subdir3']))
self.failIfEqual(
self.__fs.rootdirectory().find(['subdir3', 'Makefile.am']), None)
self.failUnless(const.CONFIX2_DIR in
subdir3_automake_builder.makefile_am().extra_dist())
self.failUnless('Makefile.in' in subdir3_automake_builder.makefile_am(
).maintainercleanfiles())
self.failUnless('Makefile.am' in subdir3_automake_builder.makefile_am(
).maintainercleanfiles())
pass
pass
parser = optparse.OptionParser(version='%prog ' + const.CONFIX_VERSION,
description='%prog [options] packages')
parser.add_option('--packagename',
action="store_true",
dest='packagename',
help='print the package name')
parser.add_option('--packageversion',
action="store_true",
help='print the package version')
options, rest = parser.parse_args(sys.argv[1:])
if len(rest) > 1:
raise Error('Only one package at a time can be massaged')
if len(rest) == 1:
os.chdir(rest[0])
pass
packageroot = os.getcwd().split(os.sep)
fs = scan.scan_filesystem(packageroot)
package = LocalPackage(rootdirectory=fs.rootdirectory(), setups=[])
if options.packagename:
print package.name()
pass
if options.packageversion:
print package.version()
pass
if len(rest) == 1:
os.chdir(rest[0])
pass
packageroot = os.getcwd().split(os.sep)
fs = scan.scan_filesystem(packageroot)
package = LocalPackage(rootdirectory=fs.rootdirectory(), setups=[])
prefix = options.prefix
readonly_prefixes = []
if options.readonly_prefixes is not None:
for p in options.readonly_prefixes.split(','):
readonly_prefixes.append(p.split(os.sep))
pass
pass
external_nodes = []
for p in AutomakeCascadedPackageRepository(
prefix=prefix.split(os.sep),
readonly_prefixes=readonly_prefixes).iter_packages():
if p.name() != package.name():
external_nodes.extend(p.nodes())
pass
pass
package.boil(external_nodes=external_nodes)
package.output()
fs.sync()
class IntraPackageTest(unittest.TestCase):
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
def test__output(self):
# library 'lo'
self.failUnlessEqual(len(self.__lo_output_builder.local_cmakelists().get_library('lo')), 4)
self.failUnless('lo1.h' in self.__lo_output_builder.local_cmakelists().get_library('lo'))
self.failUnless('lo1.c' in self.__lo_output_builder.local_cmakelists().get_library('lo'))
self.failUnless('lo2.h' in self.__lo_output_builder.local_cmakelists().get_library('lo'))
self.failUnless('lo2.c' in self.__lo_output_builder.local_cmakelists().get_library('lo'))
# library 'hi'
self.failUnlessEqual(len(self.__hi_output_builder.local_cmakelists().get_library('hi')), 4)
self.failUnless('hi1.h' in self.__hi_output_builder.local_cmakelists().get_library('hi'))
self.failUnless('hi1.c' in self.__hi_output_builder.local_cmakelists().get_library('hi'))
self.failUnless('hi2.h' in self.__hi_output_builder.local_cmakelists().get_library('hi'))
self.failUnless('hi2.c' in self.__hi_output_builder.local_cmakelists().get_library('hi'))
# executable 'exe'
self.failUnlessEqual(len(self.__exe_output_builder.local_cmakelists().get_executable('exe')), 5)
self.failUnless('main.c' in self.__exe_output_builder.local_cmakelists().get_executable('exe'))
self.failUnless('require_lo.h' in self.__exe_output_builder.local_cmakelists().get_executable('exe'))
self.failUnless('require_lo.c' in self.__exe_output_builder.local_cmakelists().get_executable('exe'))
self.failUnless('require_hi.h' in self.__exe_output_builder.local_cmakelists().get_executable('exe'))
self.failUnless('require_hi.c' in self.__exe_output_builder.local_cmakelists().get_executable('exe'))
pass
def test__linklines(self):
# lo needs nothing.
self.failUnless(self.__lo_output_builder.local_cmakelists().get_target_link_libraries('lo') is None)
# hi needs lo.
hi_link_libraries = self.__hi_output_builder.local_cmakelists().get_target_link_libraries('hi')
self.failUnlessEqual(len(hi_link_libraries), 1)
self.failUnlessEqual(hi_link_libraries[0], 'lo')
# exe need hi and lo, in that particular order.
exe_link_libraries = self.__exe_output_builder.local_cmakelists().get_target_link_libraries('exe')
self.failUnlessEqual(len(exe_link_libraries), 2)
self.failUnlessEqual(exe_link_libraries[0], 'hi')
self.failUnlessEqual(exe_link_libraries[1], 'lo')
pass
def test__include_paths(self):
self.failUnlessEqual(len(self.__lo_output_builder.local_cmakelists().get_include_directories()),
# the binary directory that is associated with 'lo'
1
)
hi_include_directories = self.__hi_output_builder.local_cmakelists().get_include_directories()
self.failUnlessEqual(len(hi_include_directories),
# the binary directory that is associated
# with 'hi', plus twice 'lo' (binary and
# source)
1 + 1*2)
self.failUnless(hi_include_directories[0] == '${CMAKE_CURRENT_BINARY_DIR}' and
hi_include_directories[1] == '${'+self.__package.name()+'_SOURCE_DIR}/lo' and
hi_include_directories[2] == '${'+self.__package.name()+'_BINARY_DIR}/lo' or
hi_include_directories[1] == '${'+self.__package.name()+'_BINARY_DIR}/lo' and
hi_include_directories[2] == '${'+self.__package.name()+'_SOURCE_DIR}/lo')
exe_include_directories = self.__exe_output_builder.local_cmakelists().get_include_directories()
self.failUnlessEqual(len(exe_include_directories),
# the binary directory that is
# associaated with 'exe', plus two each
# for 'hi' and 'lo'.
1 + 2*2)
self.failUnless(exe_include_directories[0] == '${CMAKE_CURRENT_BINARY_DIR}')
self.failUnless(exe_include_directories[1] == '${'+self.__package.name()+'_SOURCE_DIR}/hi' and
exe_include_directories[2] == '${'+self.__package.name()+'_BINARY_DIR}/hi' or
exe_include_directories[1] == '${'+self.__package.name()+'_BINARY_DIR}/hi' and
exe_include_directories[2] == '${'+self.__package.name()+'_SOURCE_DIR}/hi')
self.failUnless(exe_include_directories[3] == '${'+self.__package.name()+'_SOURCE_DIR}/lo' and
exe_include_directories[4] == '${'+self.__package.name()+'_BINARY_DIR}/lo' or
exe_include_directories[3] == '${'+self.__package.name()+'_BINARY_DIR}/lo' and
exe_include_directories[4] == '${'+self.__package.name()+'_SOURCE_DIR}/lo')
pass
pass
