def test_scenario_4(self):
     # know errors in the code
     file_handler = open(glb_input_filename, "w")
     file_handler.write(
         "LET x:                                                                                    "
         + glb_new_line_symbol)
     file_handler.write(
         'PRINT "x"                                                                                 '
         + glb_new_line_symbol)
     file_handler.write(
         'PRINT "maximiliam     had     an  x-man in his  x-pocket full of x rays"                  '
         + glb_new_line_symbol)
     file_handler.close()
     a_dictionary = initialise_a_reference_dictionary()
     an_available_numeric_references = initialise_available_numeric_references_list(
     )
     an_available_string_references = initialise_available_string_references_list(
     )
     an_error_list = prepare_variables_references(
         glb_input_filename, glb_intermediate_filename, a_dictionary,
         an_available_numeric_references, an_available_string_references)
     if an_error_list[0] == glb_no_error_code:
         an_error_list = resolve_variables_references(
             glb_intermediate_filename, glb_output_filename, a_dictionary)
         self.assertEqual(an_error_list[0], glb_no_error_code)
         self.assertEqual(an_error_list[1], 5)
         self.assertEqual({'x': 'AA'}, a_dictionary["variables"])
     else:
         self.fail("error on pre-condition method.")
 def test_scenario_1(self):
     # file is empty, file has empty lines, file has lines with only spaces, file has no variables being used
     file_handler = open(glb_input_filename, "w")
     file_handler.write("")
     file_handler.write(glb_new_line_symbol)
     file_handler.write(
         "                                                                                          "
         + glb_new_line_symbol)
     file_handler.write(
         "some code: some code: some code: some code                                                "
         + glb_new_line_symbol)
     file_handler.write(
         "some code: 'some code: some code: some code                                               "
         + glb_new_line_symbol)
     file_handler.close()
     a_dictionary = initialise_a_reference_dictionary()
     an_available_numeric_references = initialise_available_numeric_references_list(
     )
     an_available_string_references = initialise_available_string_references_list(
     )
     an_error_list = prepare_variables_references(
         glb_input_filename, glb_intermediate_filename, a_dictionary,
         an_available_numeric_references, an_available_string_references)
     if an_error_list[0] == glb_no_error_code:
         an_error_list = resolve_variables_references(
             glb_intermediate_filename, glb_output_filename, a_dictionary)
         self.assertEqual(an_error_list[0], glb_no_error_code)
         self.assertEqual(an_error_list[1], 0)
         self.assertEqual({}, a_dictionary["variables"])
     else:
         self.fail("error on pre-condition method.")
 def test_scenario_1(self):
     # file is empty, file has empty lines, file has lines with only spaces, file has no variables defined
     an_available_numeric_references_list = initialise_available_numeric_references_list(
     )
     an_available_string_references_list = initialise_available_string_references_list(
     )
     file_handler = open(glb_input_filename, "w")
     file_handler.write("")
     file_handler.write(glb_new_line_symbol)
     file_handler.write(
         "                                                                                          "
         + glb_new_line_symbol)
     file_handler.write(
         "some code: some code: some code: some code                                                "
         + glb_new_line_symbol)
     file_handler.write(
         "some code: 'some code: some code: some code :                                             "
         + glb_new_line_symbol)
     file_handler.close()
     a_dictionary = initialise_a_reference_dictionary()
     an_error_list = prepare_variables_references(
         glb_input_filename, glb_output_filename, a_dictionary,
         an_available_numeric_references_list,
         an_available_string_references_list)
     self.assertEqual(an_error_list, [0])
     self.assertEqual({}, a_dictionary["variables"])
 def test_scenario_2(self):
     # lines include comments and empty lines
     file_handler = open(glb_input_filename, "w")
     file_handler.write(
         "LET x:                                                                                    "
         + glb_new_line_symbol)
     file_handler.write(
         " LET y: LET z: ' LET w :                                                                  "
         + glb_new_line_symbol)
     file_handler.write(
         "' LET x: LET y: LET z: LET w :                                                            "
         + glb_new_line_symbol)
     file_handler.write(
         "                                                                                          "
         + glb_new_line_symbol)
     file_handler.write(
         "  LET x$ : LET y$: LET z$ : LET w$:                                                       "
         + glb_new_line_symbol)
     file_handler.write(
         " ' LET a_very_long_name_with_0123 : LET a_very_long_name_with_0123$:                      "
         + glb_new_line_symbol)
     file_handler.write(
         " ' some code : some code : some code : LET abc :                                          "
         + glb_new_line_symbol)
     file_handler.write(
         "   LET p: LET p$                                                                          "
         + glb_new_line_symbol)
     file_handler.write(
         "LET t : LET t$:                                                                             "
         + glb_new_line_symbol)
     file_handler.close()
     a_dictionary = initialise_a_reference_dictionary()
     an_available_numeric_references = initialise_available_numeric_references_list(
     )
     an_available_string_references = initialise_available_string_references_list(
     )
     an_error_list = prepare_variables_references(
         glb_input_filename, glb_intermediate_filename, a_dictionary,
         an_available_numeric_references, an_available_string_references)
     if an_error_list[0] == glb_no_error_code:
         an_error_list = resolve_variables_references(
             glb_intermediate_filename, glb_output_filename, a_dictionary)
         self.assertEqual(an_error_list[0], glb_no_error_code)
         self.assertEqual(an_error_list[1], 10)
         self.assertEqual(
             {
                 'x': 'AA',
                 'y': 'AB',
                 'z': 'AC',
                 'x$': 'AA$',
                 'y$': 'AB$',
                 'z$': 'AC$',
                 'w$': 'AD$',
                 'p': 'AD',
                 't': 'AE',
                 't$': 'AE$'
             }, a_dictionary["variables"])
     else:
         self.fail("error on pre-condition method.")
    def test_scenario_3(self):
        # easy examples
        file_handler = open(glb_input_filename, "w")
        file_handler.write(
            "LET x:                                                                                    "
            + glb_new_line_symbol)
        file_handler.write(
            "x = x + x - x * x / x + (x - x)                                                           "
            + glb_new_line_symbol)
        file_handler.write(
            "x = 1 + x                                                                                 "
            + glb_new_line_symbol)
        file_handler.write(
            "x=1+x                                                                                     "
            + glb_new_line_symbol)
        file_handler.write(
            "PRINT x                                                                                   "
            + glb_new_line_symbol)
        file_handler.write(
            "GOSUB x                                                                                   "
            + glb_new_line_symbol)
        file_handler.write(
            "GOTO x + 1 : GOSUB 1 + x: GOSUB x                                                         "
            + glb_new_line_symbol)
        file_handler.write(
            "GOTO 1 + x                                                                                "
            + glb_new_line_symbol)
        file_handler.write(
            "DRAW(x, x, x, x)                                                                          "
            + glb_new_line_symbol)
        file_handler.write(
            "PAINT(x, x, x, x, x, x, x, x, x, x, x, x, x, x, x,xy,yx,yxz,xyz,yzx,                      "
            + glb_new_line_symbol)
        file_handler.write(
            "ON     x     GOTO     x                                                                   "
            + glb_new_line_symbol)

        file_handler.write(
            "DRAW(x + x, x, xy, x, x, x, x, x,x,x  x , x, x, x,xy,yx,yxz,xyz,yzx,xx,xxx,xxxx,x):x      "
            + glb_new_line_symbol)
        file_handler.close()
        a_dictionary = initialise_a_reference_dictionary()
        an_available_numeric_references = initialise_available_numeric_references_list(
        )
        an_available_string_references = initialise_available_string_references_list(
        )
        an_error_list = prepare_variables_references(
            glb_input_filename, glb_intermediate_filename, a_dictionary,
            an_available_numeric_references, an_available_string_references)
        if an_error_list[0] == glb_no_error_code:
            an_error_list = resolve_variables_references(
                glb_intermediate_filename, glb_output_filename, a_dictionary)
            self.assertEqual(an_error_list[0], glb_no_error_code)
            self.assertEqual(an_error_list[1], 56)
            self.assertEqual({'x': 'AA'}, a_dictionary["variables"])
        else:
            self.fail("error on pre-condition method.")
 def test_scenario_6(self):
     # all valid
     an_available_numeric_references_list = initialise_available_numeric_references_list(
     )
     an_available_string_references_list = initialise_available_string_references_list(
     )
     file_handler = open(glb_input_filename, "w")
     file_handler.write(
         "LET x: LET y: LET z: LET w :                                                              "
         + glb_new_line_symbol)
     file_handler.write(
         "LET x$ : LET y$: LET z$ : LET w$:                                                         "
         + glb_new_line_symbol)
     file_handler.write(
         "LET a_very_long_name_with_0123 : LET a_very_long_name_with_0123$:                         "
         + glb_new_line_symbol)
     file_handler.write(
         " some code : some code : some code : LET abc :                                            "
         + glb_new_line_symbol)
     file_handler.write(
         "LET _a_valid_name: LET _a_valid_name$:                                                    "
         + glb_new_line_symbol)
     file_handler.close()
     a_dictionary = initialise_a_reference_dictionary()
     an_error_list = prepare_variables_references(
         glb_input_filename, glb_output_filename, a_dictionary,
         an_available_numeric_references_list,
         an_available_string_references_list)
     self.assertEqual(an_error_list, [0])
     self.assertEqual(
         {
             'x': 'AA',
             'y': 'AB',
             'z': 'AC',
             'w': 'AD',
             'x$': 'AA$',
             'y$': 'AB$',
             'z$': 'AC$',
             'w$': 'AD$',
             'a_very_long_name_with_0123': 'AE',
             'a_very_long_name_with_0123$': 'AE$',
             'abc': 'AF',
             '_a_valid_name': 'AG',
             '_a_valid_name$': 'AF$'
         }, a_dictionary["variables"])
 def test_scenario_1(self):
     # DECLARE identifier is defined first
     file_handler = open(glb_input_filename, "w")
     file_handler.write(
         "DECLARE _x():                                                       "
         + glb_new_line_symbol)
     file_handler.write(
         "LET _x:                                                             "
         + glb_new_line_symbol)
     file_handler.write(
         "_x:                                                                 "
         + glb_new_line_symbol)
     file_handler.close()
     #
     a_dictionary = initialise_a_reference_dictionary()
     an_available_numeric_references_list = initialise_available_numeric_references_list(
     )
     an_available_string_references_list = initialise_available_string_references_list(
     )
     #
     an_error_list = process_procedure_declaration(glb_input_filename,
                                                   glb_output_filename,
                                                   a_dictionary)
     self.assertEqual(an_error_list, [glb_no_error_code])
     self.assertEqual({'_x': {
         'line': 2,
         'parameters': []
     }}, a_dictionary["declares"])
     #
     an_error_list = prepare_variables_references(
         glb_input_filename, glb_output_filename, a_dictionary,
         an_available_numeric_references_list,
         an_available_string_references_list)
     self.assertEqual(an_error_list,
                      [glb_error_declare_duplicate_identifier])
     self.assertEqual({}, a_dictionary["variables"])
     #
     an_error_list = prepare_goto_and_gosub_references(
         glb_input_filename, glb_output_filename, a_dictionary)
     self.assertEqual(an_error_list,
                      [glb_error_declare_duplicate_identifier])
     self.assertEqual({}, a_dictionary["gotogosub"])
 def test_scenario_4(self):
     # uniqueness
     an_available_numeric_references_list = initialise_available_numeric_references_list(
     )
     an_available_string_references_list = initialise_available_string_references_list(
     )
     file_handler = open(glb_input_filename, "w")
     file_handler.write(
         "LET x: LET x:                                                                             "
         + glb_new_line_symbol)
     file_handler.write(
         "LET x$ : LET x$:                                                                          "
         + glb_new_line_symbol)
     file_handler.close()
     a_dictionary = initialise_a_reference_dictionary()
     an_error_list = prepare_variables_references(
         glb_input_filename, glb_output_filename, a_dictionary,
         an_available_numeric_references_list,
         an_available_string_references_list)
     self.assertEqual(an_error_list, [45, 45])
     self.assertEqual({'x': 'AA', 'x$': 'AA$'}, a_dictionary["variables"])
 def test_scenario_3(self):
     # invalid variables names
     an_available_numeric_references_list = initialise_available_numeric_references_list(
     )
     an_available_string_references_list = initialise_available_string_references_list(
     )
     file_handler = open(glb_input_filename, "w")
     file_handler.write(
         "LET 0: LET 10: LET 200: LET 012345:                                                       "
         + glb_new_line_symbol)
     file_handler.write(
         "LET 0$ : LET 10$ : LET 200$ : LET 012345$:                                                "
         + glb_new_line_symbol)
     file_handler.close()
     a_dictionary = initialise_a_reference_dictionary()
     an_error_list = prepare_variables_references(
         glb_input_filename, glb_output_filename, a_dictionary,
         an_available_numeric_references_list,
         an_available_string_references_list)
     self.assertEqual(an_error_list, [46, 46, 46, 46, 46, 46, 46, 46])
     self.assertEqual({}, a_dictionary["variables"])
 def test_scenario_5(self):
     # number of variables exceeded
     an_available_numeric_references_list = initialise_available_numeric_references_list(
     )
     an_available_string_references_list = initialise_available_string_references_list(
     )
     an_available_numeric_references_list.clear()
     an_available_string_references_list.clear()
     file_handler = open(glb_input_filename, "w")
     file_handler.write(
         "LET y:                                                                                    "
         + glb_new_line_symbol)
     file_handler.write(
         "LET y$:                                                                                   "
         + glb_new_line_symbol)
     file_handler.close()
     a_dictionary = initialise_a_reference_dictionary()
     an_error_list = prepare_variables_references(
         glb_input_filename, glb_output_filename, a_dictionary,
         an_available_numeric_references_list,
         an_available_string_references_list)
     self.assertEqual(an_error_list, [44, 43])
     self.assertEqual({}, a_dictionary["variables"])
 def test_scenario_2(self):
     # not valid variables declarations
     an_available_numeric_references_list = initialise_available_numeric_references_list(
     )
     an_available_string_references_list = initialise_available_string_references_list(
     )
     file_handler = open(glb_input_filename, "w")
     file_handler.write(
         "LET                                                                                       "
         + glb_new_line_symbol)
     file_handler.write(
         "LET : LET : LET : LET  :                                                                  "
         + glb_new_line_symbol)
     file_handler.write(
         "LET :                                                                                     "
         + glb_new_line_symbol)
     file_handler.write(
         "LET x                                                                                     "
         + glb_new_line_symbol)
     file_handler.write(
         "LET 0                                                                                     "
         + glb_new_line_symbol)
     file_handler.write(
         "LET (                                                                                     "
         + glb_new_line_symbol)
     file_handler.write(
         "LET x                                                                                     "
         + glb_new_line_symbol)
     file_handler.write(
         "LET x$                                                                                    "
         + glb_new_line_symbol)
     file_handler.write(
         "LET x + y                                                                                 "
         + glb_new_line_symbol)
     file_handler.write(
         "LET x, y, z:                                                                              "
         + glb_new_line_symbol)
     file_handler.write(
         "LET x, y, z: LET x y z: LET z                                                             "
         + glb_new_line_symbol)
     file_handler.write(
         "LET x, y, z: LET x y z: LET z :                                                           "
         + glb_new_line_symbol)
     file_handler.write(
         "LET z                                                                                     "
         + glb_new_line_symbol)
     file_handler.write(
         "LET x, :                                                                                  "
         + glb_new_line_symbol)
     file_handler.write(
         "LET x,                                                                                    "
         + glb_new_line_symbol)
     file_handler.write(
         "LET x : LET y                                                                             "
         + glb_new_line_symbol)
     file_handler.write(
         "LET z  LET w :                                                                            "
         + glb_new_line_symbol)
     file_handler.close()
     a_dictionary = initialise_a_reference_dictionary()
     an_error_list = prepare_variables_references(
         glb_input_filename, glb_output_filename, a_dictionary,
         an_available_numeric_references_list,
         an_available_string_references_list)
     self.assertEqual(
         an_error_list,
         [42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42])
     self.assertEqual({
         'z': 'AA',
         'x': 'AB',
         'w': 'AC'
     }, a_dictionary["variables"])