def test_v20(self):
"""Test parsing of easyconfig in format v2."""
# hard enable experimental
orig_experimental = easybuild.tools.build_log.EXPERIMENTAL
easybuild.tools.build_log.EXPERIMENTAL = True
fn = os.path.join(TESTDIRBASE, 'v2.0', 'GCC.eb')
ecp = EasyConfigParser(fn)
formatter = ecp._formatter
self.assertEqual(formatter.VERSION, EasyVersion('2.0'))
self.assertTrue('name' in formatter.pyheader_localvars)
self.assertFalse('version' in formatter.pyheader_localvars)
self.assertFalse('toolchain' in formatter.pyheader_localvars)
# this should be ok: ie the default values
ec = ecp.get_config_dict()
self.assertEqual(ec['toolchain'], {
'name': 'system',
'version': 'system'
})
self.assertEqual(ec['name'], 'GCC')
self.assertEqual(ec['version'], '4.6.2')
# changes to this dict should not affect the return value of the next call to get_config_dict
fn = 'test.tar.gz'
ec['sources'].append(fn)
ec_bis = ecp.get_config_dict()
self.assertTrue(fn in ec['sources'])
self.assertFalse(fn in ec_bis['sources'])
# restore
easybuild.tools.build_log.EXPERIMENTAL = orig_experimental
def test_raw(self):
"""Test passing of raw contents to EasyConfigParser."""
ec_file1 = os.path.join(TESTDIRBASE, 'v1.0', 'g', 'GCC',
'GCC-4.6.3.eb')
ec_txt1 = read_file(ec_file1)
ec_file2 = os.path.join(TESTDIRBASE, 'v1.0', 'g', 'gzip',
'gzip-1.5-goolf-1.4.10.eb')
ec_txt2 = read_file(ec_file2)
ecparser = EasyConfigParser(ec_file1)
self.assertEqual(ecparser.rawcontent, ec_txt1)
ecparser = EasyConfigParser(rawcontent=ec_txt2)
self.assertEqual(ecparser.rawcontent, ec_txt2)
# rawcontent supersedes passed filepath
ecparser = EasyConfigParser(ec_file1, rawcontent=ec_txt2)
self.assertEqual(ecparser.rawcontent, ec_txt2)
ec = ecparser.get_config_dict()
self.assertEqual(ec['name'], 'gzip')
self.assertEqual(ec['toolchain']['name'], 'goolf')
self.assertErrorRegex(EasyBuildError,
"Neither filename nor rawcontent provided",
EasyConfigParser)
def test_v20(self):
"""Test parsing of easyconfig in format v2."""
# hard enable experimental
orig_experimental = easybuild.tools.build_log.EXPERIMENTAL
easybuild.tools.build_log.EXPERIMENTAL = True
fn = os.path.join(TESTDIRBASE, 'v2.0', 'GCC.eb')
ecp = EasyConfigParser(fn)
formatter = ecp._formatter
self.assertEqual(formatter.VERSION, EasyVersion('2.0'))
self.assertTrue('name' in formatter.pyheader_localvars)
self.assertFalse('version' in formatter.pyheader_localvars)
self.assertFalse('toolchain' in formatter.pyheader_localvars)
# this should be ok: ie the default values
ec = ecp.get_config_dict()
self.assertEqual(ec['toolchain'], {
'name': 'dummy',
'version': 'dummy'
})
self.assertEqual(ec['name'], 'GCC')
self.assertEqual(ec['version'], '4.6.2')
# restore
easybuild.tools.build_log.EXPERIMENTAL = orig_experimental
def parse(self):
"""
Parse the file and set options
mandatory requirements are checked here
"""
if self.build_specs is None:
arg_specs = {}
elif isinstance(self.build_specs, dict):
# build a new dictionary with only the expected keys, to pass as named arguments to get_config_dict()
arg_specs = self.build_specs
else:
self.log.error("Specifications should be specified using a dictionary, got %s" % type(self.build_specs))
self.log.debug("Obtained specs dict %s" % arg_specs)
self.log.info("Parsing easyconfig file %s with rawcontent: %s" % (self.path, self.rawtxt))
parser = EasyConfigParser(filename=self.path, rawcontent=self.rawtxt)
parser.set_specifications(arg_specs)
local_vars = parser.get_config_dict()
self.log.debug("Parsed easyconfig as a dictionary: %s" % local_vars)
# make sure all mandatory parameters are defined
# this includes both generic mandatory parameters and software-specific parameters defined via extra_options
missing_mandatory_keys = [key for key in self.mandatory if key not in local_vars]
if missing_mandatory_keys:
self.log.error("mandatory parameters not provided in %s: %s" % (self.path, missing_mandatory_keys))
# provide suggestions for typos
possible_typos = [(key, difflib.get_close_matches(key.lower(), self._config.keys(), 1, 0.85))
for key in local_vars if key not in self]
typos = [(key, guesses[0]) for (key, guesses) in possible_typos if len(guesses) == 1]
if typos:
self.log.error("You may have some typos in your easyconfig file: %s" %
', '.join(["%s -> %s" % typo for typo in typos]))
# we need toolchain to be set when we call _parse_dependency
for key in ['toolchain'] + local_vars.keys():
# validations are skipped, just set in the config
# do not store variables we don't need
if key in self._config.keys():
if key in ['builddependencies', 'dependencies']:
self[key] = [self._parse_dependency(dep) for dep in local_vars[key]]
elif key in ['hiddendependencies']:
self[key] = [self._parse_dependency(dep, hidden=True) for dep in local_vars[key]]
else:
self[key] = local_vars[key]
tup = (key, self[key], type(self[key]))
self.log.info("setting config option %s: value %s (type: %s)" % tup)
elif key in REPLACED_PARAMETERS:
_log.nosupport("Easyconfig parameter '%s' is replaced by '%s'" % (key, REPLACED_PARAMETERS[key]), '2.0')
else:
self.log.debug("Ignoring unknown config option %s (value: %s)" % (key, local_vars[key]))
# update templating dictionary
self.generate_template_values()
# indicate that this is a parsed easyconfig
self._config['parsed'] = [True, "This is a parsed easyconfig", "HIDDEN"]
def test_v20_deps(self):
"""Test parsing of easyconfig in format v2 that includes dependencies."""
# hard enable experimental
orig_experimental = easybuild.tools.build_log.EXPERIMENTAL
easybuild.tools.build_log.EXPERIMENTAL = True
fn = os.path.join(TESTDIRBASE, 'v2.0', 'libpng.eb')
ecp = EasyConfigParser(fn)
ec = ecp.get_config_dict()
self.assertEqual(ec['name'], 'libpng')
# first version/toolchain listed is default
self.assertEqual(ec['version'], '1.5.10')
self.assertEqual(ec['toolchain'], {'name': 'goolf', 'version': '1.4.10'})
# dependencies should be parsed correctly
deps = ec['dependencies']
self.assertTrue(isinstance(deps[0], Dependency))
self.assertEqual(deps[0].name(), 'zlib')
self.assertEqual(deps[0].version(), '1.2.5')
fn = os.path.join(TESTDIRBASE, 'v2.0', 'goolf.eb')
ecp = EasyConfigParser(fn)
ec = ecp.get_config_dict()
self.assertEqual(ec['name'], 'goolf')
self.assertEqual(ec['version'], '1.4.10')
self.assertEqual(ec['toolchain'], {'name': 'dummy', 'version': 'dummy'})
# dependencies should be parsed correctly
deps = [
# name, version, versionsuffix, toolchain
('GCC', '4.7.2', None, None),
('OpenMPI', '1.6.4', None, {'name': 'GCC', 'version': '4.7.2'}),
('OpenBLAS', '0.2.6', '-LAPACK-3.4.2', {'name': 'gompi', 'version': '1.4.10'}),
('FFTW', '3.3.3', None, {'name': 'gompi', 'version': '1.4.10'}),
('ScaLAPACK', '2.0.2', '-OpenBLAS-0.2.6-LAPACK-3.4.2', {'name': 'gompi', 'version': '1.4.10'}),
]
for i, (name, version, versionsuffix, toolchain) in enumerate(deps):
self.assertEqual(ec['dependencies'][i].name(), name)
self.assertEqual(ec['dependencies'][i].version(), version)
self.assertEqual(ec['dependencies'][i].versionsuffix(), versionsuffix)
self.assertEqual(ec['dependencies'][i].toolchain(), toolchain)
# restore
easybuild.tools.build_log.EXPERIMENTAL = orig_experimental
def test_v20_deps(self):
"""Test parsing of easyconfig in format v2 that includes dependencies."""
# hard enable experimental
orig_experimental = easybuild.tools.build_log.EXPERIMENTAL
easybuild.tools.build_log.EXPERIMENTAL = True
fn = os.path.join(TESTDIRBASE, 'v2.0', 'libpng.eb')
ecp = EasyConfigParser(fn)
ec = ecp.get_config_dict()
self.assertEqual(ec['name'], 'libpng')
# first version/toolchain listed is default
self.assertEqual(ec['version'], '1.5.10')
self.assertEqual(ec['toolchain'], {'name': 'goolf', 'version': '1.4.10'})
# dependencies should be parsed correctly
deps = ec['dependencies']
self.assertTrue(isinstance(deps[0], Dependency))
self.assertEqual(deps[0].name(), 'zlib')
self.assertEqual(deps[0].version(), '1.2.5')
fn = os.path.join(TESTDIRBASE, 'v2.0', 'goolf.eb')
ecp = EasyConfigParser(fn)
ec = ecp.get_config_dict()
self.assertEqual(ec['name'], 'goolf')
self.assertEqual(ec['version'], '1.4.10')
self.assertEqual(ec['toolchain'], {'name': 'dummy', 'version': 'dummy'})
# dependencies should be parsed correctly
deps = [
# name, version, versionsuffix, toolchain
('GCC', '4.7.2', None, None),
('OpenMPI', '1.6.4', None, {'name': 'GCC', 'version': '4.7.2'}),
('OpenBLAS', '0.2.6', '-LAPACK-3.4.2', {'name': 'gompi', 'version': '1.4.10'}),
('FFTW', '3.3.3', None, {'name': 'gompi', 'version': '1.4.10'}),
('ScaLAPACK', '2.0.2', '-OpenBLAS-0.2.6-LAPACK-3.4.2', {'name': 'gompi', 'version': '1.4.10'}),
]
for i, (name, version, versionsuffix, toolchain) in enumerate(deps):
self.assertEqual(ec['dependencies'][i].name(), name)
self.assertEqual(ec['dependencies'][i].version(), version)
self.assertEqual(ec['dependencies'][i].versionsuffix(), versionsuffix)
self.assertEqual(ec['dependencies'][i].toolchain(), toolchain)
# restore
easybuild.tools.build_log.EXPERIMENTAL = orig_experimental
def test_v20_deps(self):
"""Test parsing of easyconfig in format v2 that includes dependencies."""
# hard enable experimental
orig_experimental = easybuild.tools.build_log.EXPERIMENTAL
easybuild.tools.build_log.EXPERIMENTAL = True
fn = os.path.join(TESTDIRBASE, "v2.0", "libpng.eb")
ecp = EasyConfigParser(fn)
ec = ecp.get_config_dict()
self.assertEqual(ec["name"], "libpng")
# first version/toolchain listed is default
self.assertEqual(ec["version"], "1.5.10")
self.assertEqual(ec["toolchain"], {"name": "goolf", "version": "1.4.10"})
# dependencies should be parsed correctly
deps = ec["dependencies"]
self.assertTrue(isinstance(deps[0], Dependency))
self.assertEqual(deps[0].name(), "zlib")
self.assertEqual(deps[0].version(), "1.2.5")
fn = os.path.join(TESTDIRBASE, "v2.0", "goolf.eb")
ecp = EasyConfigParser(fn)
ec = ecp.get_config_dict()
self.assertEqual(ec["name"], "goolf")
self.assertEqual(ec["version"], "1.4.10")
self.assertEqual(ec["toolchain"], {"name": "dummy", "version": "dummy"})
# dependencies should be parsed correctly
deps = [
# name, version, versionsuffix, toolchain
("GCC", "4.7.2", None, None),
("OpenMPI", "1.6.4", None, {"name": "GCC", "version": "4.7.2"}),
("OpenBLAS", "0.2.6", "-LAPACK-3.4.2", {"name": "gompi", "version": "1.4.10"}),
("FFTW", "3.3.3", None, {"name": "gompi", "version": "1.4.10"}),
("ScaLAPACK", "2.0.2", "-OpenBLAS-0.2.6-LAPACK-3.4.2", {"name": "gompi", "version": "1.4.10"}),
]
for i, (name, version, versionsuffix, toolchain) in enumerate(deps):
self.assertEqual(ec["dependencies"][i].name(), name)
self.assertEqual(ec["dependencies"][i].version(), version)
self.assertEqual(ec["dependencies"][i].versionsuffix(), versionsuffix)
self.assertEqual(ec["dependencies"][i].toolchain(), toolchain)
# restore
easybuild.tools.build_log.EXPERIMENTAL = orig_experimental
def parse(self):
"""
Parse the file and set options
mandatory requirements are checked here
"""
if self.build_specs is None:
arg_specs = {}
elif isinstance(self.build_specs, dict):
# build a new dictionary with only the expected keys, to pass as named arguments to get_config_dict()
arg_specs = self.build_specs
else:
self.log.error("Specifications should be specified using a dictionary, got %s" % type(self.build_specs))
self.log.debug("Obtained specs dict %s" % arg_specs)
parser = EasyConfigParser(self.path)
parser.set_specifications(arg_specs)
local_vars = parser.get_config_dict()
self.log.debug("Parsed easyconfig as a dictionary: %s" % local_vars)
# validate mandatory keys
# TODO: remove this code. this is now (also) checked in the format (see validate_pyheader)
missing_keys = [key for key in self.mandatory if key not in local_vars]
if missing_keys:
self.log.error("mandatory variables %s not provided in %s" % (missing_keys, self.path))
# provide suggestions for typos
possible_typos = [(key, difflib.get_close_matches(key.lower(), self._config.keys(), 1, 0.85))
for key in local_vars if key not in self._config]
typos = [(key, guesses[0]) for (key, guesses) in possible_typos if len(guesses) == 1]
if typos:
self.log.error("You may have some typos in your easyconfig file: %s" %
', '.join(["%s -> %s" % typo for typo in typos]))
# we need toolchain to be set when we call _parse_dependency
for key in ['toolchain'] + local_vars.keys():
# validations are skipped, just set in the config
# do not store variables we don't need
if key in self._config.keys() + DEPRECATED_OPTIONS.keys():
if key in ['builddependencies', 'dependencies']:
self[key] = [self._parse_dependency(dep) for dep in local_vars[key]]
elif key in ['hiddendependencies']:
self[key] = [self._parse_dependency(dep, hidden=True) for dep in local_vars[key]]
else:
self[key] = local_vars[key]
tup = (key, self[key], type(self[key]))
self.log.info("setting config option %s: value %s (type: %s)" % tup)
else:
self.log.debug("Ignoring unknown config option %s (value: %s)" % (key, local_vars[key]))
# update templating dictionary
self.generate_template_values()
# indicate that this is a parsed easyconfig
self._config['parsed'] = [True, "This is a parsed easyconfig", "HIDDEN"]
def test_v10(self):
ecp = EasyConfigParser(os.path.join(TESTDIRBASE, 'v1.0', 'GCC-4.6.3.eb'))
self.assertEqual(ecp._formatter.VERSION, EasyVersion('1.0'))
ec = ecp.get_config_dict()
self.assertEqual(ec['toolchain'], {'name': 'dummy', 'version': 'dummy'})
self.assertEqual(ec['name'], 'GCC')
self.assertEqual(ec['version'], '4.6.3')
def test_v10(self):
ecp = EasyConfigParser(os.path.join(TESTDIRBASE, 'v1.0', 'GCC-4.6.3.eb'))
self.assertEqual(ecp._formatter.VERSION, EasyVersion('1.0'))
ec = ecp.get_config_dict()
self.assertEqual(ec['toolchain'], {'name': 'dummy', 'version': 'dummy'})
self.assertEqual(ec['name'], 'GCC')
self.assertEqual(ec['version'], '4.6.3')
def test_v10(self):
ecp = EasyConfigParser(os.path.join(TESTDIRBASE, "v1.0", "GCC-4.6.3.eb"))
self.assertEqual(ecp._formatter.VERSION, EasyVersion("1.0"))
ec = ecp.get_config_dict()
self.assertEqual(ec["toolchain"], {"name": "dummy", "version": "dummy"})
self.assertEqual(ec["name"], "GCC")
self.assertEqual(ec["version"], "4.6.3")
def test_check_value_types(self):
"""Test checking of easyconfig parameter value types."""
test_ec = os.path.join(TESTDIRBASE, 'test_ecs', 'g', 'gzip', 'gzip-1.4-broken.eb')
error_msg_pattern = "Type checking of easyconfig parameter values failed: .*'version'.*"
ecp = EasyConfigParser(test_ec, auto_convert_value_types=False)
self.assertErrorRegex(EasyBuildError, error_msg_pattern, ecp.get_config_dict)
# test default behaviour: auto-converting of mismatched value types
ecp = EasyConfigParser(test_ec)
ecdict = ecp.get_config_dict()
self.assertEqual(ecdict['version'], '1.4')
def test_check_value_types(self):
"""Test checking of easyconfig parameter value types."""
test_ec = os.path.join(TESTDIRBASE, 'test_ecs', 'g', 'gzip', 'gzip-1.4-broken.eb')
error_msg_pattern = "Type checking of easyconfig parameter values failed: .*'version'.*"
ecp = EasyConfigParser(test_ec, auto_convert_value_types=False)
self.assertErrorRegex(EasyBuildError, error_msg_pattern, ecp.get_config_dict)
# test default behaviour: auto-converting of mismatched value types
ecp = EasyConfigParser(test_ec)
ecdict = ecp.get_config_dict()
self.assertEqual(ecdict['version'], '1.4')
def parse(self):
"""
Parse the file and set options
mandatory requirements are checked here
"""
if self.build_specs is None:
arg_specs = {}
elif isinstance(self.build_specs, dict):
# build a new dictionary with only the expected keys, to pass as named arguments to get_config_dict()
arg_specs = self.build_specs
else:
self.log.error("Specifications should be specified using a dictionary, got %s" % type(self.build_specs))
self.log.debug("Obtained specs dict %s" % arg_specs)
parser = EasyConfigParser(self.path)
parser.set_specifications(arg_specs)
local_vars = parser.get_config_dict()
self.log.debug("Parsed easyconfig as a dictionary: %s" % local_vars)
# validate mandatory keys
# TODO: remove this code. this is now (also) checked in the format (see validate_pyheader)
missing_keys = [key for key in self.mandatory if key not in local_vars]
if missing_keys:
self.log.error("mandatory variables %s not provided in %s" % (missing_keys, self.path))
# provide suggestions for typos
possible_typos = [(key, difflib.get_close_matches(key.lower(), self._config.keys(), 1, 0.85))
for key in local_vars if key not in self._config]
typos = [(key, guesses[0]) for (key, guesses) in possible_typos if len(guesses) == 1]
if typos:
self.log.error("You may have some typos in your easyconfig file: %s" %
', '.join(["%s -> %s" % typo for typo in typos]))
# we need toolchain to be set when we call _parse_dependency
for key in ['toolchain'] + local_vars.keys():
# validations are skipped, just set in the config
# do not store variables we don't need
if key in self._config.keys() + DEPRECATED_OPTIONS.keys():
if key in ['builddependencies', 'dependencies']:
self[key] = [self._parse_dependency(dep) for dep in local_vars[key]]
else:
self[key] = local_vars[key]
tup = (key, self[key], type(self[key]))
self.log.info("setting config option %s: value %s (type: %s)" % tup)
else:
self.log.debug("Ignoring unknown config option %s (value: %s)" % (key, local_vars[key]))
# update templating dictionary
self.generate_template_values()
# indicate that this is a parsed easyconfig
self._config['parsed'] = [True, "This is a parsed easyconfig", "HIDDEN"]
def test_v10(self):
ecp = EasyConfigParser(
os.path.join(TESTDIRBASE, 'v1.0', 'g', 'GCC', 'GCC-4.6.3.eb'))
self.assertEqual(ecp._formatter.VERSION, EasyVersion('1.0'))
ec = ecp.get_config_dict()
self.assertEqual(ec['toolchain'], {
'name': 'system',
'version': 'system'
})
self.assertEqual(ec['name'], 'GCC')
self.assertEqual(ec['version'], '4.6.3')
# changes to this dict should not affect the return value of the next call to get_config_dict
fn = 'test.tar.gz'
ec['sources'].append(fn)
ec_bis = ecp.get_config_dict()
self.assertTrue(fn in ec['sources'])
self.assertFalse(fn in ec_bis['sources'])
def parse(self, path, format_version=None):
"""
Parse the file and set options
mandatory requirements are checked here
"""
parser = EasyConfigParser(path, format_version=format_version)
local_vars = parser.get_config_dict()
# validate mandatory keys
# TODO: remove this code. this is now (also) checked in the format (see validate_pyheader)
missing_keys = [key for key in self.mandatory if key not in local_vars]
if missing_keys:
self.log.error("mandatory variables %s not provided in %s" %
(missing_keys, path))
# provide suggestions for typos
possible_typos = [(key,
difflib.get_close_matches(key.lower(),
self._config.keys(), 1,
0.85))
for key in local_vars if key not in self._config]
typos = [(key, guesses[0]) for (key, guesses) in possible_typos
if len(guesses) == 1]
if typos:
self.log.error(
"You may have some typos in your easyconfig file: %s" %
', '.join(["%s -> %s" % typo for typo in typos]))
self._legacy_license(local_vars)
for key in local_vars:
# validations are skipped, just set in the config
# do not store variables we don't need
if key in self._config:
self[key] = local_vars[key]
self.log.info("setting config option %s: value %s" %
(key, self[key]))
else:
self.log.debug(
"Ignoring unknown config option %s (value: %s)" %
(key, local_vars[key]))
# update templating dictionary
self.generate_template_values()
# indicate that this is a parsed easyconfig
self._config['parsed'] = [
True, "This is a parsed easyconfig", "HIDDEN"
]
def test_raw(self):
"""Test passing of raw contents to EasyConfigParser."""
ec_file1 = os.path.join(TESTDIRBASE, 'v1.0', 'g', 'GCC', 'GCC-4.6.3.eb')
ec_txt1 = read_file(ec_file1)
ec_file2 = os.path.join(TESTDIRBASE, 'v1.0', 'g', 'gzip', 'gzip-1.5-goolf-1.4.10.eb')
ec_txt2 = read_file(ec_file2)
ecparser = EasyConfigParser(ec_file1)
self.assertEqual(ecparser.rawcontent, ec_txt1)
ecparser = EasyConfigParser(rawcontent=ec_txt2)
self.assertEqual(ecparser.rawcontent, ec_txt2)
# rawcontent supersedes passed filepath
ecparser = EasyConfigParser(ec_file1, rawcontent=ec_txt2)
self.assertEqual(ecparser.rawcontent, ec_txt2)
ec = ecparser.get_config_dict()
self.assertEqual(ec['name'], 'gzip')
self.assertEqual(ec['toolchain']['name'], 'goolf')
self.assertErrorRegex(EasyBuildError, "Neither filename nor rawcontent provided", EasyConfigParser)
def parse(self, path, format_version=None):
"""
Parse the file and set options
mandatory requirements are checked here
"""
parser = EasyConfigParser(path, format_version=format_version)
local_vars = parser.get_config_dict()
# validate mandatory keys
# TODO: remove this code. this is now (also) checked in the format (see validate_pyheader)
missing_keys = [key for key in self.mandatory if key not in local_vars]
if missing_keys:
self.log.error("mandatory variables %s not provided in %s" % (missing_keys, path))
# provide suggestions for typos
possible_typos = [(key, difflib.get_close_matches(key.lower(), self._config.keys(), 1, 0.85))
for key in local_vars if key not in self._config]
typos = [(key, guesses[0]) for (key, guesses) in possible_typos if len(guesses) == 1]
if typos:
self.log.error("You may have some typos in your easyconfig file: %s" %
', '.join(["%s -> %s" % typo for typo in typos]))
self._legacy_license(local_vars)
for key in local_vars:
# validations are skipped, just set in the config
# do not store variables we don't need
if key in self._config:
self[key] = local_vars[key]
self.log.info("setting config option %s: value %s" % (key, self[key]))
else:
self.log.debug("Ignoring unknown config option %s (value: %s)" % (key, local_vars[key]))
# update templating dictionary
self.generate_template_values()
# indicate that this is a parsed easyconfig
self._config['parsed'] = [True, "This is a parsed easyconfig", "HIDDEN"]
def test_v20(self):
"""Test parsing of easyconfig in format v2."""
# hard enable experimental
orig_experimental = easybuild.tools.build_log.EXPERIMENTAL
easybuild.tools.build_log.EXPERIMENTAL = True
fn = os.path.join(TESTDIRBASE, 'v2.0', 'GCC.eb')
ecp = EasyConfigParser(fn)
formatter = ecp._formatter
self.assertEqual(formatter.VERSION, EasyVersion('2.0'))
self.assertTrue('name' in formatter.pyheader_localvars)
self.assertFalse('version' in formatter.pyheader_localvars)
self.assertFalse('toolchain' in formatter.pyheader_localvars)
# this should be ok: ie the default values
ec = ecp.get_config_dict()
self.assertEqual(ec['toolchain'], {'name': 'dummy', 'version': 'dummy'})
self.assertEqual(ec['name'], 'GCC')
self.assertEqual(ec['version'], '4.6.2')
# restore
easybuild.tools.build_log.EXPERIMENTAL = orig_experimental
def test_v20(self):
"""Test parsing of easyconfig in format v2."""
# hard enable experimental
orig_experimental = easybuild.tools.build_log.EXPERIMENTAL
easybuild.tools.build_log.EXPERIMENTAL = True
fn = os.path.join(TESTDIRBASE, "v2.0", "GCC.eb")
ecp = EasyConfigParser(fn)
formatter = ecp._formatter
self.assertEqual(formatter.VERSION, EasyVersion("2.0"))
self.assertTrue("name" in formatter.pyheader_localvars)
self.assertFalse("version" in formatter.pyheader_localvars)
self.assertFalse("toolchain" in formatter.pyheader_localvars)
# this should be ok: ie the default values
ec = ecp.get_config_dict()
self.assertEqual(ec["toolchain"], {"name": "dummy", "version": "dummy"})
self.assertEqual(ec["name"], "GCC")
self.assertEqual(ec["version"], "4.6.2")
# restore
easybuild.tools.build_log.EXPERIMENTAL = orig_experimental
