import io import unittest import unittest.mock from mcstasscript.helper.mcstas_objects import Component from mcstasscript.helper.formatting import bcolors from mcstasscript.helper.exceptions import McStasError def setup_Component_all_keywords(): """ Sets up a Component by using all initialize keywords """ return Component("test_component", "Arm", AT=[0.124, 183.9, 157], AT_RELATIVE="home", ROTATED=[482, 1240.2, 0.185], ROTATED_RELATIVE="etc", WHEN="1==2", EXTEND="nscat = 8;", GROUP="developers", JUMP="myself 37", SPLIT=7, comment="test comment") def setup_Component_relative(): """ Sets up a Component with the relative keyword used """ return Component("test_component", "Arm", AT=[0.124, 183.9, 157], ROTATED=[482, 1240.2, 0.185], RELATIVE="source", WHEN="1==2", EXTEND="nscat = 8;", GROUP="developers", JUMP="myself 37", SPLIT=7, comment="test comment") def setup_Component_with_parameters(): """ Sets up a Component with parameters and all options used. """ comp = setup_Component_all_keywords() comp._unfreeze() # Need to set up attribute parameters comp.new_par1 = 1.5 comp.new_par2 = 3 comp.new_par3 = None comp.this_par = "test_val" comp.that_par = "\"txt_string\"" # also need to categorize them as when created comp.parameter_names = ["new_par1", "new_par2", "new_par3", "this_par", "that_par"] comp.parameter_defaults = {"new_par1": 5.1, "new_par2": 9, "new_par3": None, "this_par": "conga", "that_par": "\"txt\""} comp.parameter_comments = {"new_par1": "This is important", "new_par2": "This is less important", "this_par": "!", "that_par": ""} comp.parameter_types = {"new_par1": "double", "new_par2": "int", "this_par": "", "that_par": "string"} comp.parameter_units = {"new_par1": "m", "new_par2": "AA", "this_par": "", "that_par": "1"} comp.line_limit = 117 comp._freeze() return comp class TestComponent(unittest.TestCase): """ Components are the building blocks used to create an instrument in the McStas meta language. They describe spatially seperated parts of the neutron scattering instrument. Here the class component is tested. """ def test_Component_basic_init(self): """ Testing basic initialization """ comp = Component("test_component", "Arm") self.assertEqual(comp.name, "test_component") self.assertEqual(comp.component_name, "Arm") def test_Component_basic_init_defaults(self): """ Testing basic initialization sets the correct defaults """ comp = Component("test_component", "Arm") self.assertEqual(comp.name, "test_component") self.assertEqual(comp.component_name, "Arm") self.assertEqual(comp.AT_data, [0, 0, 0]) self.assertEqual(comp.AT_relative, "ABSOLUTE") self.assertEqual(comp.ROTATED_data, [0, 0, 0]) self.assertEqual(comp.ROTATED_relative, "ABSOLUTE") self.assertEqual(comp.WHEN, "") self.assertEqual(comp.EXTEND, "") self.assertEqual(comp.GROUP, "") self.assertEqual(comp.JUMP, "") self.assertEqual(comp.comment, "") def test_Component_init_complex_call(self): """ Testing keywords set attributes correctly """ comp = setup_Component_all_keywords() self.assertEqual(comp.name, "test_component") self.assertEqual(comp.component_name, "Arm") self.assertEqual(comp.AT_data, [0.124, 183.9, 157]) self.assertEqual(comp.AT_relative, "RELATIVE home") self.assertEqual(comp.ROTATED_data, [482, 1240.2, 0.185]) self.assertEqual(comp.ROTATED_relative, "RELATIVE etc") self.assertEqual(comp.WHEN, "WHEN (1==2)") self.assertEqual(comp.EXTEND, "nscat = 8;\n") self.assertEqual(comp.GROUP, "developers") self.assertEqual(comp.JUMP, "myself 37") self.assertEqual(comp.SPLIT, 7) self.assertEqual(comp.comment, "test comment") def test_Component_init_complex_call_relative(self): """ Tests the relative keyword overwrites AT_relative and ROTATED_relative """ comp = setup_Component_relative() self.assertEqual(comp.name, "test_component") self.assertEqual(comp.component_name, "Arm") self.assertEqual(comp.AT_data, [0.124, 183.9, 157]) self.assertEqual(comp.AT_relative, "RELATIVE source") self.assertEqual(comp.ROTATED_data, [482, 1240.2, 0.185]) self.assertEqual(comp.ROTATED_relative, "RELATIVE source") self.assertEqual(comp.WHEN, "WHEN (1==2)") self.assertEqual(comp.EXTEND, "nscat = 8;\n") self.assertEqual(comp.GROUP, "developers") self.assertEqual(comp.JUMP, "myself 37") self.assertEqual(comp.SPLIT, 7) self.assertEqual(comp.comment, "test comment") def test_Component_basic_init_set_AT(self): """ Testing set_AT method """ comp = Component("test_component", "Arm") comp.set_AT([12.124, 214.0, 2], RELATIVE="monochromator") self.assertEqual(comp.name, "test_component") self.assertEqual(comp.component_name, "Arm") self.assertEqual(comp.AT_data, [12.124, 214.0, 2]) self.assertEqual(comp.AT_relative, "RELATIVE monochromator") def test_Component_freeze(self): """ Testing frozen Component cant have new attributes, and that _unfreeze / _freeze works correctly. """ comp = Component("test_component", "Arm") with self.assertRaises(AttributeError): comp.new_parameter = 5 self.assertEqual(comp.name, "test_component") self.assertEqual(comp.component_name, "Arm") comp._unfreeze() comp.new_parameter = 5 self.assertEqual(comp.new_parameter, 5) comp._freeze() with self.assertRaises(AttributeError): comp.another_parameter = 5 def test_Component_basic_init_set_AT_Component(self): """ Testing set_AT method using Component object and method """ prev_component = Component("relative_base", "Arm") comp = Component("test_component", "Arm") comp.set_AT([12.124, 214.0, 2], RELATIVE=prev_component) self.assertEqual(comp.name, "test_component") self.assertEqual(comp.component_name, "Arm") self.assertEqual(comp.AT_data, [12.124, 214.0, 2]) self.assertEqual(comp.AT_relative, "RELATIVE relative_base") def test_Component_basic_init_set_AT_Component_keyword(self): """ Testing set_AT method using Component object and keyword argument """ prev_component = Component("relative_base", "Arm") comp = Component("test_component", "Arm", AT=[1, 2, 3.0], AT_RELATIVE=prev_component) self.assertEqual(comp.name, "test_component") self.assertEqual(comp.component_name, "Arm") self.assertEqual(comp.AT_data, [1, 2, 3.0]) self.assertEqual(comp.AT_relative, "RELATIVE relative_base") def test_Component_basic_init_set_ROTATED(self): """ Testing set_ROTATED method med relative as string """ comp = Component("test_component", "Arm") comp.set_ROTATED([1204.8, 8490.1, 129], RELATIVE="analyzer") self.assertEqual(comp.name, "test_component") self.assertEqual(comp.component_name, "Arm") self.assertEqual(comp.ROTATED_data, [1204.8, 8490.1, 129]) self.assertEqual(comp.ROTATED_relative, "RELATIVE analyzer") def test_Component_basic_init_set_ROTATED_Component(self): """ Testing set_ROTATED method with relative as Component object """ prev_component = Component("relative_base", "Arm") comp = Component("test_component", "Arm") comp.set_ROTATED([1204.8, 8490.1, 129], RELATIVE=prev_component) self.assertEqual(comp.name, "test_component") self.assertEqual(comp.component_name, "Arm") self.assertEqual(comp.ROTATED_data, [1204.8, 8490.1, 129]) self.assertEqual(comp.ROTATED_relative, "RELATIVE relative_base") def test_Component_basic_init_set_ROTATED_Component_keyword(self): """ Testing setting ROTATION with keyword and Component object input """ prev_component = Component("relative_base", "Arm") comp = Component("test_component", "Arm", ROTATED=[1, 2, 3.0], ROTATED_RELATIVE=prev_component) self.assertEqual(comp.name, "test_component") self.assertEqual(comp.component_name, "Arm") self.assertEqual(comp.ROTATED_data, [1, 2, 3.0]) self.assertEqual(comp.ROTATED_relative, "RELATIVE relative_base") def test_Component_basic_init_set_RELATIVE(self): """ Testing set_RELATIVE method with string """ comp = Component("test_component", "Arm") comp.set_RELATIVE("sample") self.assertEqual(comp.name, "test_component") self.assertEqual(comp.component_name, "Arm") self.assertEqual(comp.AT_relative, "RELATIVE sample") self.assertEqual(comp.ROTATED_relative, "RELATIVE sample") def test_Component_basic_object_ref_init_set_RELATIVE(self): """ Testing set_RELATIVE method with Component object input """ prev_component = Component("relative_base", "Arm") comp = Component("test_component", "Arm") comp.set_RELATIVE(prev_component) self.assertEqual(comp.name, "test_component") self.assertEqual(comp.component_name, "Arm") self.assertEqual(comp.AT_relative, "RELATIVE relative_base") self.assertEqual(comp.ROTATED_relative, "RELATIVE relative_base") def test_component_basic_init_set_parameters(self): """ Testing set_parameters method. Need to set some attribute parameters manually to test this. """ comp = Component("test_component", "Arm") # Need to add some parameters to this bare component # Parameters are usually added by McStas_Instr comp._unfreeze() comp.new_par1 = 1 comp.new_par2 = 3 comp.this_par = 1492.2 comp.set_parameters({"new_par1": 37.0, "new_par2": 12.0, "this_par": 1}) self.assertEqual(comp.name, "test_component") self.assertEqual(comp.component_name, "Arm") self.assertEqual(comp.new_par1, 37.0) self.assertEqual(comp.new_par2, 12.0) self.assertEqual(comp.this_par, 1) with self.assertRaises(NameError): comp.set_parameters({"new_par3": 37.0}) def test_Component_basic_init_set_WHEN(self): """ Testing WHEN method """ comp = Component("test_component", "Arm") comp.set_WHEN("1 != 2") self.assertEqual(comp.name, "test_component") self.assertEqual(comp.component_name, "Arm") self.assertEqual(comp.WHEN, "WHEN (1 != 2)") def test_Component_basic_init_set_GROUP(self): """ Testing set_GROUP method """ comp = Component("test_component", "Arm") comp.set_GROUP("test group") self.assertEqual(comp.name, "test_component") self.assertEqual(comp.component_name, "Arm") self.assertEqual(comp.GROUP, "test group") def test_Component_basic_init_set_JUMP(self): """ Testing set_JUMP method """ comp = Component("test_component", "Arm") comp.set_JUMP("test jump") self.assertEqual(comp.name, "test_component") self.assertEqual(comp.component_name, "Arm") self.assertEqual(comp.JUMP, "test jump") def test_Component_basic_init_set_SPLIT(self): """ Testing set_SPLIT method """ comp = Component("test_component", "Arm") comp.set_SPLIT(500) self.assertEqual(comp.name, "test_component") self.assertEqual(comp.component_name, "Arm") self.assertEqual(comp.SPLIT, 500) def test_Component_basic_init_set_EXTEND(self): """ Testing set_EXTEND method """ comp = Component("test_component", "Arm") comp.append_EXTEND("test code") self.assertEqual(comp.name, "test_component") self.assertEqual(comp.component_name, "Arm") self.assertEqual(comp.EXTEND, "test code\n") comp.append_EXTEND("new code") self.assertEqual(comp.EXTEND, "test code\nnew code\n") def test_Component_basic_init_set_comment(self): """ Testing set_comment method """ comp = Component("test_component", "Arm") comp.set_comment("test comment") self.assertEqual(comp.name, "test_component") self.assertEqual(comp.component_name, "Arm") self.assertEqual(comp.comment, "test comment") def test_Component_basic_new_attribute_error(self): """ The Component class is frozen after initialize in order to prevent the user accidentilly misspelling an attribute name, or at least be able to report an error when they do so. """ comp = Component("test_component", "Arm") with self.assertRaises(AttributeError): comp.new_attribute = 1 # If unfreeze does not work, this would cause an error comp._unfreeze() comp.new_attribute = 1 @unittest.mock.patch('__main__.__builtins__.open', new_callable=unittest.mock.mock_open) def test_Component_write_to_file_simple(self, mock_f): """ Testing that a Component can be written to file with the expected output. Here with simple input. """ comp = Component("test_component", "Arm") comp._unfreeze() # Need to set up attribute parameters # Also need to categorize them as when created comp.parameter_names = [] comp.parameter_defaults = {} comp.parameter_types = {} comp._freeze() with mock_f('test.txt', 'w') as m_fo: comp.write_component(m_fo) my_call = unittest.mock.call expected_writes = [my_call("COMPONENT test_component = Arm("), my_call(")\n"), my_call("AT (0,0,0)"), my_call(" ABSOLUTE\n")] mock_f.assert_called_with('test.txt', 'w') handle = mock_f() handle.write.assert_has_calls(expected_writes, any_order=False) @unittest.mock.patch('__main__.__builtins__.open', new_callable=unittest.mock.mock_open) def test_Component_write_to_file_simple_search(self, mock_f): """ Testing that a Component can be written to file with the expected output. Here with simple input and search. """ comp = Component("test_component", "Arm") comp.add_search("A search_statement") comp.add_search("Another search_statement", SHELL=True) comp.add_search('"One with double quotes"') comp._unfreeze() # Need to set up attribute parameters # Also need to categorize them as when created comp.parameter_names = [] comp.parameter_defaults = {} comp.parameter_types = {} comp._freeze() with mock_f('test.txt', 'w') as m_fo: comp.write_component(m_fo) my_call = unittest.mock.call expected_writes = [my_call('SEARCH "A search_statement"\n'), my_call('SEARCH SHELL "Another search_statement"\n'), my_call('SEARCH "One with double quotes"\n'), my_call("COMPONENT test_component = Arm("), my_call(")\n"), my_call("AT (0,0,0)"), my_call(" ABSOLUTE\n")] mock_f.assert_called_with('test.txt', 'w') handle = mock_f() handle.write.assert_has_calls(expected_writes, any_order=False) @unittest.mock.patch('__main__.__builtins__.open', new_callable=unittest.mock.mock_open) def test_Component_write_to_file_include(self, mock_f): """ Testing that a Component can be written to file with the expected output. Here with simple input. """ comp = Component("test_component", "Arm", c_code_before="%include \"test.instr\"") comp.set_c_code_after("%include \"after.instr\"") comp._unfreeze() # Need to set up attribute parameters # Also need to categorize them as when created comp.parameter_names = [] comp.parameter_defaults = {} comp.parameter_types = {} comp._freeze() with mock_f('test.txt', 'w') as m_fo: comp.write_component(m_fo) my_call = unittest.mock.call expected_writes = [my_call("%include \"test.instr\" // From" + " component named test_component\n"), my_call("\n"), my_call("COMPONENT test_component = Arm("), my_call(")\n"), my_call("AT (0,0,0)"), my_call(" ABSOLUTE\n"), my_call("\n"), my_call("%include \"after.instr\" // From" + " component named test_component\n"), my_call("\n")] mock_f.assert_called_with('test.txt', 'w') handle = mock_f() handle.write.assert_has_calls(expected_writes, any_order=False) @unittest.mock.patch('__main__.__builtins__.open', new_callable=unittest.mock.mock_open) def test_Component_write_to_file_complex(self, mock_f): """ Testing that a Component can be written to file with the expected output. Here with complex input. """ comp = setup_Component_with_parameters() # This setup has a required parameter. # If this parameter is not set, an error should be returned, # this will be tested in the next test. comp.new_par3 = "1.25" with mock_f('test.txt', 'w') as m_fo: comp.write_component(m_fo) my_call = unittest.mock.call expected_writes = [my_call("SPLIT 7 "), my_call("COMPONENT test_component = Arm("), my_call("\n"), my_call(" new_par1 = 1.5"), my_call(","), my_call(" new_par2 = 3"), my_call(","), my_call("\n"), my_call(" new_par3 = 1.25"), my_call(","), my_call(" this_par = test_val"), my_call(","), my_call("\n"), my_call(" that_par = \"txt_string\""), my_call(")\n"), my_call("WHEN (1==2)\n"), my_call("AT (0.124,183.9,157)"), my_call(" RELATIVE home\n"), my_call("ROTATED (482,1240.2,0.185)"), my_call(" RELATIVE etc\n"), my_call("GROUP developers\n"), my_call("EXTEND %{\n"), my_call("nscat = 8;\n"), my_call("%}\n"), my_call("JUMP myself 37\n"), my_call("\n")] mock_f.assert_called_with('test.txt', 'w') handle = mock_f() handle.write.assert_has_calls(expected_writes, any_order=False) @unittest.mock.patch('__main__.__builtins__.open', new_callable=unittest.mock.mock_open) def test_Component_write_to_file_complex_SPLIT_string(self, mock_f): """ Testing that a Component can be written to file with the expected output. Here with complex input, and a string as given for split. """ comp = setup_Component_with_parameters() comp.set_SPLIT("VAR") # This setup has a required parameter. # If this parameter is not set, an error should be returned, # this will be tested in the next test. comp.new_par3 = "1.25" with mock_f('test.txt', 'w') as m_fo: comp.write_component(m_fo) my_call = unittest.mock.call expected_writes = [my_call("SPLIT VAR "), my_call("COMPONENT test_component = Arm("), my_call("\n"), my_call(" new_par1 = 1.5"), my_call(","), my_call(" new_par2 = 3"), my_call(","), my_call("\n"), my_call(" new_par3 = 1.25"), my_call(","), my_call(" this_par = test_val"), my_call(","), my_call("\n"), my_call(" that_par = \"txt_string\""), my_call(")\n"), my_call("WHEN (1==2)\n"), my_call("AT (0.124,183.9,157)"), my_call(" RELATIVE home\n"), my_call("ROTATED (482,1240.2,0.185)"), my_call(" RELATIVE etc\n"), my_call("GROUP developers\n"), my_call("EXTEND %{\n"), my_call("nscat = 8;\n"), my_call("%}\n"), my_call("JUMP myself 37\n"), my_call("\n")] mock_f.assert_called_with('test.txt', 'w') handle = mock_f() handle.write.assert_has_calls(expected_writes, any_order=False) @unittest.mock.patch('__main__.__builtins__.open', new_callable=unittest.mock.mock_open) def test_Component_write_Component_required_parameter_error(self, mock_f): """ Test an error occurs if the Component is asked to write to disk without a required parameter. """ comp = setup_Component_with_parameters() # new_par3 unset and has no default so an error will be raised with self.assertRaises(NameError): with mock_f('test.txt', 'w') as m_fo: comp.write_component(m_fo) @unittest.mock.patch("sys.stdout", new_callable=io.StringIO) def test_Component_print_long(self, mock_stdout): """ Test print to console on the current state of the Component. Using a mocked stdout to catch the print statements. """ comp = setup_Component_with_parameters() comp.append_EXTEND("second extend line;") comp.print_long() output = mock_stdout.getvalue() output = output.split("\n") self.assertEqual(output[0], "// test comment") self.assertEqual(output[1], "SPLIT 7 COMPONENT test_component = Arm(") par_name = bcolors.BOLD + "new_par1" + bcolors.ENDC value = (bcolors.BOLD + bcolors.OKGREEN + "1.5" + bcolors.ENDC + bcolors.ENDC) self.assertEqual(output[2], " " + par_name + " = " + value + ", // [m]") par_name = bcolors.BOLD + "new_par2" + bcolors.ENDC value = (bcolors.BOLD + bcolors.OKGREEN + "3" + bcolors.ENDC + bcolors.ENDC) self.assertEqual(output[3], " " + par_name + " = " + value + ", // [AA]") par_name = bcolors.BOLD + "new_par3" + bcolors.ENDC warning = (bcolors.FAIL + " : Required parameter not yet specified" + bcolors.ENDC) self.assertEqual(output[4], " " + par_name + warning) par_name = bcolors.BOLD + "this_par" + bcolors.ENDC value = (bcolors.BOLD + bcolors.OKGREEN + "test_val" + bcolors.ENDC + bcolors.ENDC) self.assertEqual(output[5], " " + par_name + " = " + value + ", // []") par_name = bcolors.BOLD + "that_par" + bcolors.ENDC value = (bcolors.BOLD + bcolors.OKGREEN + "\"txt_string\"" + bcolors.ENDC + bcolors.ENDC) # No comma after last parameter self.assertEqual(output[6], " " + par_name + " = " + value + " // [1]") self.assertEqual(output[7], ") WHEN (1==2)") self.assertEqual(output[8], "AT (0.124, 183.9, 157) RELATIVE home") self.assertEqual(output[9], "ROTATED (482, 1240.2, 0.185) RELATIVE etc") self.assertEqual(output[10], "GROUP developers") self.assertEqual(output[11], "EXTEND %{") self.assertEqual(output[12], "nscat = 8;") self.assertEqual(output[13], "second extend line;") self.assertEqual(output[14], "%}") self.assertEqual(output[15], "JUMP myself 37") @unittest.mock.patch("sys.stdout", new_callable=io.StringIO) def test_Component_print_short_standard(self, mock_stdout): """ Test print_short that prints name, type and location of the Component to the console. """ comp = setup_Component_with_parameters() comp.print_short() output = mock_stdout.getvalue() output = output.split("\n") expected = ("test_component = Arm " + "\tAT [0.124, 183.9, 157] RELATIVE home " + "ROTATED [482, 1240.2, 0.185] RELATIVE etc") self.assertEqual(output[0], expected) @unittest.mock.patch("sys.stdout", new_callable=io.StringIO) def test_Component_print_short_longest_name(self, mock_stdout): """ Test print_short that prints name, type and location of the Component to the console. Here with specified longest_name. """ comp = setup_Component_with_parameters() comp.print_short(longest_name=15) output = mock_stdout.getvalue() output = output.split("\n") expected = ("test_component Arm " + "\tAT [0.124, 183.9, 157] RELATIVE home " + "ROTATED [482, 1240.2, 0.185] RELATIVE etc") self.assertEqual(output[0], expected) @unittest.mock.patch("sys.stdout", new_callable=io.StringIO) def test_Component_show_parameters(self, mock_stdout): """ Test print_short that prints name, type and location of the Component to the console. An extra parameter was added. This test also checks for specific formatting. """ comp = setup_Component_with_parameters() comp._unfreeze() # This is now not set by the user, but has default # This results in different formatting in show_parameters comp.new_par2 = None comp._freeze() comp.show_parameters() output = mock_stdout.getvalue() output = output.split("\n") self.assertEqual(output[0], " ___ Help Arm " + "_"*103) legend = ("|" + bcolors.BOLD + "optional parameter" + bcolors.ENDC + "|" + bcolors.BOLD + bcolors.UNDERLINE + "required parameter" + bcolors.ENDC + bcolors.ENDC + "|" + bcolors.BOLD + bcolors.OKBLUE + "default value" + bcolors.ENDC + bcolors.ENDC + "|" + bcolors.BOLD + bcolors.OKGREEN + "user specified value" + bcolors.ENDC + bcolors.ENDC + "|") self.assertEqual(output[1], legend) par_name = bcolors.BOLD + "new_par1" + bcolors.ENDC value = (bcolors.BOLD + bcolors.OKGREEN + "1.5" + bcolors.ENDC + bcolors.ENDC) comment = "// This is important" self.assertEqual(output[2], par_name + " = " + value + " [m] " + comment) par_name = bcolors.BOLD + "new_par2" + bcolors.ENDC value = (bcolors.BOLD + bcolors.OKBLUE + "9" + bcolors.ENDC + bcolors.ENDC) comment = "// This is less important" self.assertEqual(output[3], par_name + " = " + value + " [AA] " + comment) par_name = (bcolors.UNDERLINE + bcolors.BOLD + "new_par3" + bcolors.ENDC + bcolors.ENDC) self.assertEqual(output[4], par_name) par_name = bcolors.BOLD + "this_par" + bcolors.ENDC value = (bcolors.BOLD + bcolors.OKGREEN + "test_val" + bcolors.ENDC + bcolors.ENDC) comment = "// !" self.assertEqual(output[5], par_name + " = " + value + " [] " + comment) par_name = bcolors.BOLD + "that_par" + bcolors.ENDC value = (bcolors.BOLD + bcolors.OKGREEN + "\"txt_string\"" + bcolors.ENDC + bcolors.ENDC) comment = "" self.assertEqual(output[6], par_name + " = " + value + " [1]" + comment) @unittest.mock.patch("sys.stdout", new_callable=io.StringIO) def test_Component_show_parameters_simple(self, mock_stdout): """ Test print_short that prints name, type and location of the Component to the console. No formatting used in simple version. """ comp = setup_Component_with_parameters() comp._unfreeze() # This is now not set by the user, but has default # This results in different formatting in show_parameters comp.new_par2 = None comp._freeze() comp.show_parameters_simple() output = mock_stdout.getvalue() output = output.split("\n") self.assertEqual(output[0], "---- Help Arm -----") par_name = "new_par1" value = "1.5" comment = "// This is important" self.assertEqual(output[1], par_name + " = " + value + " [m] " + comment) par_name = "new_par2" value = "9" comment = "// This is less important" self.assertEqual(output[2], par_name + " = " + value + " [AA] " + comment) par_name = "new_par3" self.assertEqual(output[3], par_name) par_name = "this_par" value = "test_val" comment = "// !" self.assertEqual(output[4], par_name + " = " + value + " [] " + comment) par_name = "that_par" value = "\"txt_string\"" comment = "" self.assertEqual(output[5], par_name + " = " + value + " [1]" + comment) def test_component_error_check(self): comp = setup_Component_with_parameters() # Currently no ilegal parameters comp.check_parameters([]) # Introduce illegal parameter comp.new_par1 = "wrong" with self.assertRaises(McStasError): comp.check_parameters([]) # Check no error is raised when on whitelist comp.check_parameters(["wrong"]) if __name__ == '__main__': unittest.main()