def testDefaultArch(self):
# We default to x86_64 except in the special case where the build
# machine is i686 hardware, in which case we default to i686.
with patch('platform.machine', Mock(return_value='i686')):
self.assertEqual(Configuration().arch, 'i686')
with patch('platform.machine', Mock(return_value='dummy')):
self.assertEqual(Configuration().arch, 'x86_64')
def testParsingValid(self):
index = package_index.PackageIndex('dummy_file', test_index)
arm_config = Configuration('arm', 'newlib', False)
i686_config = Configuration('i686', 'newlib', False)
self.assertEqual(len(index.packages), 2)
self.assertTrue(index.Contains('agg-demo', arm_config))
self.assertTrue(index.Contains('agg-demo', i686_config))
def testContains(self):
# Create an empty package index and add a single entry to it
index = package_index.PackageIndex('dummy_file', '')
config_debug = Configuration('arm', 'newlib', True)
config_release = Configuration('arm', 'newlib', False)
self.assertFalse(index.Contains('foo', config_release))
index.packages[('foo', config_release)] = {
'NAME': 'dummy',
'BUILD_SDK_VERSION': 123
}
with patch('naclports.util.GetSDKVersion') as mock_version:
# Setting the mock SDK version to 123 should mean that the
# index contains the 'foo' package and it is installable'
mock_version.return_value = 123
self.assertTrue(index.Contains('foo', config_release))
self.assertTrue(index.Installable('foo', config_release))
# Setting the mock SDK version to some other version should
# mean the index contains that package but it is not installable.
mock_version.return_value = 124
self.assertTrue(index.Contains('foo', config_release))
self.assertFalse(index.Installable('foo', config_release))
self.assertFalse(index.Contains('foo', config_debug))
self.assertFalse(index.Contains('bar', config_release))
def testGetInstallRoot(self):
expected = '/sdk/root/toolchain/linux_x86_newlib/x86_64-nacl/usr'
self.assertEqual(util.GetInstallRoot(Configuration()), expected)
expected = '/sdk/root/toolchain/linux_pnacl/le32-nacl/usr'
self.assertEqual(util.GetInstallRoot(Configuration('pnacl')), expected)
expected = '/emscripten/root/system/local'
self.assertEqual(util.GetInstallRoot(Configuration('emscripten')),
expected)
expected = '/sdk/root/toolchain/linux_pnacl/x86_64-nacl/usr'
self.assertEqual(
util.GetInstallRoot(Configuration(toolchain='clang-newlib')),
expected)
def testDefaults(self):
config = Configuration()
self.assertEqual(config.toolchain, 'newlib')
self.assertEqual(config.arch, 'x86_64')
self.assertEqual(config.debug, False)
self.assertEqual(config.config_name, 'release')
self.assertEqual(config.libc, 'newlib')
def testDisabledArch(self):
self.CreateTestPackage('bar', 'DISABLED_ARCH=(x86_64)')
pkg = source_package.CreatePackage(
'bar', config=Configuration(toolchain='clang-newlib'))
with self.assertRaisesRegexp(error.DisabledError,
'disabled for architecture: x86_64'):
pkg.CheckInstallable()
def testInfoCommand(self):
config = Configuration()
options = Mock()
file_mock = common.MockFileObject('FOO=bar\n')
with patch('sys.stdout', new_callable=StringIO.StringIO) as stdout:
with patch('__builtin__.open', Mock(return_value=file_mock), create=True):
naclports.__main__.CmdInfo(config, options, ['foo'])
self.assertRegexpMatches(stdout.getvalue(), "FOO=bar")
def testListCommandVerbose(self):
config = Configuration()
pkg = Mock(NAME='foo', VERSION='0.1')
with patch('naclports.installed_package.InstalledPackageIterator',
Mock(return_value=[pkg])):
with patch('sys.stdout', new_callable=StringIO.StringIO) as stdout:
options = Mock(verbosity=0, all=False)
naclports.__main__.CmdList(config, options, [])
lines = stdout.getvalue().splitlines()
self.assertRegexpMatches(lines[0], "^foo$")
self.assertEqual(len(lines), 1)
def testDisabledToolchainArch(self):
self.CreateTestPackage('bar', 'DISABLED_TOOLCHAIN=(glibc/x86_64)')
pkg = source_package.CreatePackage(
'bar', config=Configuration(toolchain='glibc'))
with self.assertRaisesRegexp(
error.DisabledError, 'cannot be built with glibc for x86_64$'):
pkg.CheckInstallable()
self.CreateTestPackage('bar2', 'DISABLED_TOOLCHAIN=(pnacl/arm)')
pkg = source_package.CreatePackage('bar2')
pkg.CheckInstallable()
def __init__(self, pkg_root, config=None):
if config is None:
config = Configuration()
for key in naclports.VALID_KEYS:
setattr(self, key, None)
self.config = config
self.DEPENDS = []
self.CONFLICTS = []
self.root = os.path.abspath(pkg_root)
self.info = os.path.join(self.root, 'pkg_info')
if not os.path.isdir(self.root) or not os.path.exists(self.info):
raise Error('Invalid package folder: %s' % pkg_root)
# Parse pkg_info file
info = naclports.ParsePkgInfoFile(self.info)
# Set attributres based on pkg_info setttings.
for key, value in info.items():
setattr(self, key, value)
if '_' in self.NAME:
raise Error('%s: package NAME cannot contain underscores' %
self.info)
if self.NAME != self.NAME.lower():
raise Error(
'%s: package NAME cannot contain uppercase characters' %
self.info)
if '_' in self.VERSION:
raise Error('%s: package VERSION cannot contain underscores' %
self.info)
if self.NAME != os.path.basename(self.root):
raise Error('%s: package NAME must match directory name' %
self.info)
if self.DISABLED_ARCH is not None and self.ARCH is not None:
raise Error('%s: contains both ARCH and DISABLED_ARCH' % self.info)
if self.DISABLED_LIBC is not None and self.LIBC is not None:
raise Error('%s: contains both LIBC and DISABLED_LIBC' % self.info)
def testInvalidArch(self):
expected_error = 'Invalid arch: not_arch'
with self.assertRaisesRegexp(error.Error, expected_error):
Configuration('not_arch')
def testConfigEquality(self):
config1 = Configuration('arm', 'newlib', True)
config2 = Configuration('arm', 'newlib', True)
config3 = Configuration('arm', 'newlib', False)
self.assertEqual(config1, config2)
self.assertNotEqual(config1, config3)
def testConfigStringForm(self):
config = Configuration('arm', 'newlib', True)
self.assertEqual(str(config), 'arm/newlib/debug')
self.assertRegexpMatches(repr(config), '<Configuration .*>')
def testGetInstallRoot(self):
expected = '/sdk/root/toolchain/linux_x86_newlib/x86_64-nacl/usr'
self.assertEqual(util.GetInstallRoot(Configuration()), expected)
expected = '/sdk/root/toolchain/linux_pnacl/usr/local'
self.assertEqual(util.GetInstallRoot(Configuration('pnacl')), expected)
def testCleanAll(self, mock_rmtree):
config = Configuration()
naclports.__main__.CleanAll(config)
mock_rmtree.assert_any_call('/package/install/path')
def run_main(args):
usage = 'Usage: %prog [options] <command> [<package_dir>]'
parser = optparse.OptionParser(prog='naclports', description=__doc__,
usage=usage)
parser.add_option('-v', '--verbose', action='store_true',
help='Output extra information.')
parser.add_option('-V', '--verbose-build', action='store_true',
help='Make the build itself version (e.g. pass V=1 to make')
parser.add_option('--all', action='store_true',
help='Perform action on all known ports.')
parser.add_option('-f', '--force', action='store_const', const='build',
help='Force building specified targets, '
'even if timestamps would otherwise skip it.')
parser.add_option('--from-source', action='store_true',
help='Always build from source rather than downloading '
'prebuilt packages.')
parser.add_option('-F', '--force-all', action='store_const', const='all',
dest='force', help='Force building target and all '
'dependencies, even if timestamps would otherwise skip '
'them.')
parser.add_option('--no-deps', dest='build_deps', action='store_false',
default=True,
help='Disable automatic building of dependencies.')
parser.add_option('--ignore-disabled', action='store_true',
help='Ignore attempts to build disabled packages.\n'
'Normally attempts to build such packages will result\n'
'in an error being returned.')
parser.add_option('--toolchain',
help='Set toolchain to use when building (newlib, glibc, or'
' pnacl)"')
parser.add_option('--debug',
help='Build debug configuration (release is the default)')
parser.add_option('--arch',
help='Set architecture to use when building (x86_64,'
' x86_32, arm, pnacl)')
options, args = parser.parse_args(args)
if not args:
parser.error('You must specify a sub-command. See --help.')
command = args[0]
args = args[1:]
lock_file = GetLock()
naclports.verbose = options.verbose or os.environ.get('VERBOSE') == '1'
if options.verbose_build:
os.environ['VERBOSE'] = '1'
else:
if 'VERBOSE' in os.environ:
del os.environ['VERBOSE']
if 'V' in os.environ:
del os.environ['V']
if not NACL_SDK_ROOT:
raise Error('$NACL_SDK_ROOT not set')
if not os.path.isdir(NACL_SDK_ROOT):
raise Error('$NACL_SDK_ROOT does not exist: %s' % NACL_SDK_ROOT)
sentinel = os.path.join(NACL_SDK_ROOT, 'tools', 'getos.py')
if not os.path.exists(sentinel):
raise Error("$NACL_SDK_ROOT (%s) doesn't look right. "
"Couldn't find sentinel file (%s)" % (NACL_SDK_ROOT, sentinel))
config = Configuration(options.arch, options.toolchain, options.debug)
base_commands = {
'list': CmdList,
'info': CmdInfo,
'contents': CmdContents
}
pkg_commands = {
'download': CmdPkgDownload,
'check': CmdPkgCheck,
'build': CmdPkgBuild,
'uninstall': CmdPkgUninstall,
'install': CmdPkgInstall,
'verify': CmdPkgVerify,
'clean': CmdPkgClean,
}
if command in base_commands:
base_commands[command](config, options, args)
return 0
if command not in pkg_commands:
parser.error("Unknown subcommand: '%s'\n"
'See --help for available commands.' % command)
if len(args) and options.all:
parser.error('Package name(s) and --all cannot be specified together')
if args:
package_dirs = args
else:
package_dirs = [os.getcwd()]
def DoCmd(package):
try:
pkg_commands[command](package, options)
except DisabledError as e:
if options.ignore_disabled:
naclports.Log('naclports: %s' % e)
else:
raise e
def rmtree(path):
naclports.Log('removing %s' % path)
if os.path.exists(path):
shutil.rmtree(path)
if options.all:
options.ignore_disabled = True
if command == 'clean':
rmtree(naclports.STAMP_DIR)
rmtree(naclports.BUILD_ROOT)
rmtree(naclports.PUBLISH_ROOT)
rmtree(naclports.package.PACKAGES_ROOT)
rmtree(naclports.GetInstallStampRoot(config))
rmtree(naclports.GetInstallRoot(config))
else:
for p in PackageIterator():
if not p.DISABLED:
DoCmd(p)
else:
for package_dir in package_dirs:
p = naclports.package.CreatePackage(package_dir, config)
DoCmd(p)
def testConfigString(self):
config = Configuration('arm', 'newlib', True)
self.assertEqual(str(config), 'arm/newlib/debug')
def testDownload(self, download_file_mock):
index = package_index.PackageIndex('dummy_file', test_index)
arm_config = Configuration('arm', 'newlib', False)
index.Download('agg-demo', arm_config)
self.assertEqual(download_file_mock.call_count, 1)
def testEnvironmentVariables(self):
with patch.dict('os.environ', {'NACL_ARCH': 'arm'}):
self.assertEqual(Configuration().arch, 'arm')
with patch.dict('os.environ', {'NACL_DEBUG': '1'}):
self.assertEqual(Configuration().debug, True)
def testMainCleanAll(self, clean_all_mock): naclports.__main__.RunMain(['clean', '--all']) clean_all_mock.assert_called_once_with(Configuration())
def testDefaultToolchain(self):
self.assertEqual(Configuration(arch='pnacl').toolchain, 'pnacl')
self.assertEqual(Configuration(arch='arm').libc, 'newlib')
def testDefaultLibc(self):
self.assertEqual(Configuration(toolchain='pnacl').libc, 'newlib')
self.assertEqual(Configuration(toolchain='newlib').libc, 'newlib')
self.assertEqual(Configuration(toolchain='glibc').libc, 'glibc')
self.assertEqual(Configuration(toolchain='bionic').libc, 'bionic')
def testGetToolchainRoot(self):
expected = '/sdk/root/toolchain/linux_x86_newlib/x86_64-nacl'
self.assertEqual(util.GetToolchainRoot(Configuration()), expected)