def Build(self):
BuildType = self.env.GetValue("TARGET")
edk2_logging.log_progress("Running Build %s" % BuildType)
# set target, arch, toolchain, threads, and platform
params = "-p " + self.env.GetValue("ACTIVE_PLATFORM")
params += " -b " + BuildType
params += " -t " + self.env.GetValue("TOOL_CHAIN_TAG")
# Thread number is now optional and not set in default tianocore target.txt
if self.env.GetValue("MAX_CONCURRENT_THREAD_NUMBER") is not None:
params += " -n " + self.env.GetValue(
"MAX_CONCURRENT_THREAD_NUMBER")
# Set the arch flags. Multiple are split by space
rt = self.env.GetValue("TARGET_ARCH").split(" ")
for t in rt:
params += " -a " + t
# get the report options and setup the build command
if (self.env.GetValue("BUILDREPORTING") == "TRUE"):
params += " -y " + self.env.GetValue("BUILDREPORT_FILE")
rt = self.env.GetValue("BUILDREPORT_TYPES").split(" ")
for t in rt:
params += " -Y " + t
# add special processing to handle building a single module
mod = self.env.GetValue("BUILDMODULE")
if (mod is not None and len(mod.strip()) > 0):
params += " -m " + mod
edk2_logging.log_progress("Single Module Build: " + mod)
self.SkipPostBuild = True
self.FlashImage = False
# attach the generic build vars
buildvars = self.env.GetAllBuildKeyValues(BuildType)
for key, value in buildvars.items():
params += " -D " + key + "=" + value
output_stream = edk2_logging.create_output_stream()
env = shell_environment.ShellEnvironment()
# WORKAROUND - Pin the PYTHONHASHSEED so that TianoCore build tools
# have consistent ordering. Addresses incremental builds.
pre_build_env_chk = env.checkpoint()
env.set_shell_var('PYTHONHASHSEED', '0')
env.log_environment()
ret = RunCmd("build", params)
# WORKAROUND - Undo the workaround.
env.restore_checkpoint(pre_build_env_chk)
problems = edk2_logging.scan_compiler_output(output_stream)
edk2_logging.remove_output_stream(output_stream)
for level, problem in problems:
logging.log(level, problem)
if (ret != 0):
return ret
return 0
def test_can_set_and_get_build_vars(self):
shell_env = SE.ShellEnvironment()
var_name = 'SE-TEST-VAR-3'
var_data = 'Dummy3'
# Make sure it doesn't exist beforehand.
self.assertIs(shell_env.get_build_var(var_name), None, "test var should not exist before creation")
shell_env.set_build_var(var_name, var_data)
self.assertEqual(shell_env.get_build_var(var_name), var_data, "get var data should match set var data")
def test_checkpoint_indices_should_be_unique(self):
shell_env = SE.ShellEnvironment()
shell_env.append_path('/SE/TEST/PATH/1')
check_point1 = shell_env.checkpoint()
shell_env.append_path('/SE/TEST/PATH/2')
check_point2 = shell_env.checkpoint()
self.assertNotEqual(check_point1, SE.ShellEnvironment.INITIAL_CHECKPOINT)
self.assertNotEqual(check_point2, SE.ShellEnvironment.INITIAL_CHECKPOINT)
self.assertNotEqual(check_point1, check_point2)
def test_get_build_vars_should_update_vars(self):
shell_env = SE.ShellEnvironment()
build_vars = SE.GetBuildVars()
test_var_name = 'SE_TEST_VAR_4'
test_var_data = 'NewData1'
build_vars.SetValue(test_var_name, test_var_data, 'random set')
self.assertEqual(shell_env.get_build_var(test_var_name), test_var_data)
def test_special_build_vars_should_default_non_overrideable(self):
shell_env = SE.ShellEnvironment()
build_vars = SE.GetBuildVars()
test_var_name = 'SE_TEST_VAR_4'
test_var_data = 'NewData1'
test_var_data2 = 'NewerData1'
build_vars.SetValue(test_var_name, test_var_data, 'random set')
build_vars.SetValue(test_var_name, test_var_data2, 'another random set')
self.assertEqual(shell_env.get_build_var(test_var_name), test_var_data)
def test_set_build_vars_should_default_overrideable(self):
shell_env = SE.ShellEnvironment()
var_name = 'SE_TEST_VAR_4'
var_data = 'NewData1'
var_data2 = 'NewerData1'
self.assertIs(shell_env.get_build_var(var_name), None, "test var should not exist before creation")
shell_env.set_build_var(var_name, var_data)
shell_env.set_build_var(var_name, var_data2)
self.assertEqual(shell_env.get_build_var(var_name), var_data2)
def test_set_path_elements(self):
shell_env = SE.ShellEnvironment()
# Test pass 1.
testpath_elems = ['MY_PATH']
testpath_string = os.pathsep.join(testpath_elems)
shell_env.set_path(testpath_elems)
self.assertEqual(os.environ['PATH'], testpath_string, "the final string should be correct")
for elem in testpath_elems:
self.assertIn(elem, shell_env.active_path, "the active path should contain all elements")
# Test pass 2.
testpath_elems = ['/bin/bash', 'new_path', '/root']
testpath_string = os.pathsep.join(testpath_elems)
shell_env.set_path(testpath_elems)
self.assertEqual(os.environ['PATH'], testpath_string, "the final string should be correct")
for elem in testpath_elems:
self.assertIn(elem, shell_env.active_path, "the active path should contain all elements")
def test_special_build_vars_should_be_checkpointable(self):
shell_env = SE.ShellEnvironment()
build_vars = SE.GetBuildVars()
# This test is basically a rehash of the object checkpointing test,
# but this time with the special vars.
test_var1_name = 'SE_TEST_VAR_3'
test_var1_data = 'MyData1'
test_var1_data2 = 'RevisedData1'
test_var1_data3 = 'MoreRevisedData1'
test_var2_name = 'SE_TEST_VAR_4'
test_var2_data = 'MyData2'
# Set the first data and make a checkpoint.
build_vars.SetValue(test_var1_name, test_var1_data, 'var1 set', overridable=True)
check_point1 = shell_env.checkpoint()
# Update previous value and set second data. Then checkpoint.
build_vars.SetValue(test_var1_name, test_var1_data2, 'var1 set', overridable=True)
build_vars.SetValue(test_var2_name, test_var2_data, 'var2 set', overridable=True)
check_point2 = shell_env.checkpoint()
# Restore the first checkpoint and verify values.
shell_env.restore_checkpoint(check_point1)
self.assertEqual(shell_env.get_build_var(test_var1_name), test_var1_data)
self.assertIs(shell_env.get_build_var(test_var2_name), None)
# Make a change to be tested later.
build_vars.SetValue(test_var1_name, test_var1_data3, 'var1 set', overridable=True)
self.assertEqual(shell_env.get_build_var(test_var1_name), test_var1_data3,
'even after restore, special build vars should always update current')
# Restore the second checkpoint and verify values.
shell_env.restore_checkpoint(check_point2)
self.assertEqual(shell_env.get_build_var(test_var1_name), test_var1_data2)
self.assertEqual(shell_env.get_build_var(test_var2_name), test_var2_data)
# Restore the first checkpoint again and make sure original value still stands.
shell_env.restore_checkpoint(check_point1)
self.assertEqual(shell_env.get_build_var(test_var1_name), test_var1_data)
def test_checkpointed_objects_should_behave_correctly(self):
shell_env = SE.ShellEnvironment()
# This test is to make sure that pass-by-reference elements don't persist unexpectedly.
test_var1_name = 'SE_TEST_VAR_3'
test_var1_data = 'MyData1'
test_var1_data2 = 'RevisedData1'
test_var1_data3 = 'MoreRevisedData1'
test_var2_name = 'SE_TEST_VAR_4'
test_var2_data = 'MyData2'
# Set the first data and make a checkpoint.
shell_env.set_build_var(test_var1_name, test_var1_data)
check_point1 = shell_env.checkpoint()
# Update previous value and set second data. Then checkpoint.
shell_env.set_build_var(test_var1_name, test_var1_data2)
shell_env.set_build_var(test_var2_name, test_var2_data)
check_point2 = shell_env.checkpoint()
# Restore the first checkpoint and verify values.
shell_env.restore_checkpoint(check_point1)
self.assertEqual(shell_env.get_build_var(test_var1_name),
test_var1_data)
self.assertIs(shell_env.get_build_var(test_var2_name), None)
# Make a change to be tested later.
shell_env.set_build_var(test_var1_name, test_var1_data3)
# Restore the second checkpoint and verify values.
shell_env.restore_checkpoint(check_point2)
self.assertEqual(shell_env.get_build_var(test_var1_name),
test_var1_data2)
self.assertEqual(shell_env.get_build_var(test_var2_name),
test_var2_data)
# Restore the first checkpoint again and make sure original value still stands.
shell_env.restore_checkpoint(check_point1)
self.assertEqual(shell_env.get_build_var(test_var1_name),
test_var1_data)
def test_restore_new_checkpoint_should_contain_new_changes(self):
shell_env = SE.ShellEnvironment()
# Check to make sure the change doesn't exist.
test_path_change = '/SE/TEST/PATH/3'
self.assertNotIn(test_path_change, shell_env.active_path, "starting condition should not have the test change")
# Make the change and checkpoint.
shell_env.append_path(test_path_change)
self.assertIn(test_path_change, shell_env.active_path)
check_point1 = shell_env.checkpoint()
# Restore initial checkpoint and verify change is gone.
shell_env.restore_initial_checkpoint()
self.assertNotIn(test_path_change, shell_env.active_path,
"restoring initial checkpoint should remove test change")
# Restore new checkpoint and verify change is back.
shell_env.restore_checkpoint(check_point1)
self.assertIn(test_path_change, shell_env.active_path, "restoring new checkpoint should restore test change")
def test_restore_initial_checkpoint_should_erase_changes(self):
shell_env = SE.ShellEnvironment()
# Check to make sure the change doesn't exist.
test_path_change = '/SE/TEST/PATH/1'
self.assertNotIn(test_path_change, shell_env.active_path, "starting condition should not have the test change")
# Make the change and verify.
shell_env.append_path(test_path_change)
self.assertIn(test_path_change, shell_env.active_path)
# Add a shell_var while we're at it.
self.assertEqual(shell_env.get_shell_var('i_should_not_exist'), None)
shell_env.set_shell_var('i_should_not_exist', 'a_value')
self.assertEqual(shell_env.get_shell_var('i_should_not_exist'), 'a_value')
# Restore initial checkpoint and verify change is gone.
shell_env.restore_initial_checkpoint()
self.assertNotIn(test_path_change, shell_env.active_path, "restoring checkpoint should remove test change")
self.assertEqual(shell_env.get_shell_var('i_should_not_exist'), None)
def test_special_build_vars_should_always_update_current(self):
shell_env = SE.ShellEnvironment()
build_vars = SE.GetBuildVars()
test_var1_name = 'SE_TEST_VAR_update_current1'
test_var1_data = 'NewData1'
test_var1_data2 = 'NewerData1'
test_var2_name = 'SE_TEST_VAR_update_current2'
test_var2_data = 'NewData2'
# Make a change and checkpoint.
build_vars.SetValue(test_var1_name, test_var1_data, 'var1 set', overridable=True)
shell_env.checkpoint()
# Make a couple more changes.
build_vars.SetValue(test_var1_name, test_var1_data2, 'var1 set', overridable=True)
build_vars.SetValue(test_var2_name, test_var2_data, 'var2 set', overridable=True)
# Make sure that the newer changes are valid.
self.assertEqual(shell_env.get_build_var(test_var1_name), test_var1_data2)
self.assertEqual(shell_env.get_build_var(test_var2_name), test_var2_data)
def test_insert_append_remove_replace_pypath(self):
shell_env = SE.ShellEnvironment()
# Start with a known PATH
mid_elem = 'MIDDLEPATH'
shell_env.set_pypath(mid_elem)
self.assertEqual(1, len(shell_env.active_pypath))
self.assertIn(mid_elem, shell_env.active_pypath)
# Add an element to the end.
end_elem = 'ENDPATH'
shell_env.append_pypath(end_elem)
# Add an element to the beginning.
start_elem = 'STARTPATH'
shell_env.insert_pypath(start_elem)
# Test for the realities.
self.assertEqual(3, len(shell_env.active_pypath))
self.assertEqual(shell_env.active_pypath[0], start_elem)
self.assertEqual(shell_env.active_pypath[1], mid_elem)
self.assertEqual(shell_env.active_pypath[2], end_elem)
for elem in (start_elem, mid_elem, end_elem):
self.assertIn(elem, os.environ["PYTHONPATH"])
self.assertIn(elem, sys.path)
# Test replacing an element on the pypath
new_mid_elem = 'NEWMIDDLEPATH'
shell_env.replace_pypath_element(mid_elem, new_mid_elem)
self.assertEqual(shell_env.active_pypath[1], new_mid_elem)
# Test replacing an element that doesn't exist
old_pypath = shell_env.active_pypath
shell_env.replace_pypath_element("PATH1", "PATH2")
self.assertEqual(old_pypath, shell_env.active_pypath)
# Test that removing an element works as expected
shell_env.remove_pypath_element(new_mid_elem)
self.assertNotIn(new_mid_elem, shell_env.active_pypath)
def test_can_get_os_vars(self):
shell_env = SE.ShellEnvironment()
new_value = 'Dummy2'
shell_env.set_shell_var('SE-TEST-VAR-2', new_value)
self.assertEqual(shell_env.get_shell_var('SE-TEST-VAR-2'), new_value)
def setUp(self):
# Grab the singleton and restore the initial checkpoint.
shell_env = SE.ShellEnvironment()
shell_env.restore_initial_checkpoint()
# For testing, purge all checkpoints each time.
shell_env.checkpoints = [shell_env.checkpoints[SE.ShellEnvironment.INITIAL_CHECKPOINT]]
def test_shell_should_always_have_an_initial_checkpoint(self):
shell_env = SE.ShellEnvironment()
self.assertTrue((len(shell_env.checkpoints) > 0),
"a new instance of ShellEnvironment should have at least one checkpoint")
def test_shell_should_be_a_singleton(self):
shell_a = SE.ShellEnvironment()
shell_b = SE.ShellEnvironment()
self.assertIs(shell_a, shell_b, "two instances of ShellEnvironment should be identical")
