Repository: hedyorg/hedy

Issue:
feat: add sleep to an early level
That allows for the making of counters like 3...2...1... BOOM


Discussion:
Superseded by #1263 
Reopening to make a separate PR for this to minizine chances of merge conflicts

Resolving patch:
diff --git a/coursedata/yaml_transformer.py b/coursedata/yaml_transformer.py
--- a/coursedata/yaml_transformer.py
+++ b/coursedata/yaml_transformer.py
@@ -7,7 +7,7 @@ def nop(s):
 
 def transform_level_defaults(old_level, new_level=None, function=nop):
   input_path = '../coursedata/level-defaults'
-  output_path = '../coursedata/level-defaults-transformed/'
+  output_path = '../coursedata/level-defaults/'
   yaml_filesnames = [f for f in os.listdir(input_path) if
                      os.path.isfile(os.path.join(input_path, f)) and f.endswith('.yaml')]
 
@@ -27,18 +27,21 @@ def transform_level_defaults(old_level, new_level=None, function=nop):
           for c in old_content['commands']:
             c['demo_code'] = function(c['demo_code'])
 
-
-          transformed_dict[new_level] = old_content
+          transformed_dict[new_level] = copy.deepcopy(old_content)
         del transformed_dict[old_level]
         file_transformed = True
 
     if file_transformed:  #only write updated files
+      sorted_dict = {}
+      for key in sorted(transformed_dict):
+        sorted_dict[key] = transformed_dict[key]
+
       with open(output_path + yaml_filesname_without_path, 'w') as f:
-        f.write(utils.dump_yaml_rt(transformed_dict))
+        f.write(utils.dump_yaml_rt(sorted_dict))
 
 def transform_adventures(old_level, new_level=None, function=nop):
   input_path = '../coursedata/adventures'
-  output_path = '../coursedata/adventures-transformed/'
+  output_path = '../coursedata/adventures/'
   yaml_filesnames = [f for f in os.listdir(input_path) if
                      os.path.isfile(os.path.join(input_path, f)) and f.endswith('.yaml')]
 
@@ -53,8 +56,8 @@ def transform_adventures(old_level, new_level=None, function=nop):
       for level in adventure['levels']:
         if level == old_level:
           if new_level != None:
-            transformed_dict['adventures'][akey]['levels'][new_level] = transformed_dict['adventures'][akey]['levels'][old_level]
-          del transformed_dict['adventures'][akey]['levels'][old_level]
+            transformed_dict['adventures'][akey]['levels'][new_level] = copy.deepcopy(transformed_dict['adventures'][akey]['levels'][old_level])
+          # del transformed_dict['adventures'][akey]['levels'][old_level]
           file_transformed = True
 
     if file_transformed: #only write updated files
@@ -64,12 +67,12 @@ def transform_adventures(old_level, new_level=None, function=nop):
 def transform_levels_in_all_YAMLs(old_level, new_level=None, function=nop):
   # Set the current directory to the root Hedy folder
   os.chdir(os.path.join(os.getcwd(), __file__.replace(os.path.basename(__file__), '')))
-  transform_level_defaults(old_level, new_level, function)
+  # transform_level_defaults(old_level, new_level, function)
   # WARNING: adventure do not properly use the transformer function yet!
-  # transform_adventures(old_level, new_level, function=nop)
+  transform_adventures(old_level, new_level, function=nop)
 
 
 def remove_brackets(s):
   return s.replace('(', ' ').replace(')', '').replace(':', '').replace('input', 'ask')
 
-transform_levels_in_all_YAMLs('and', 12, remove_brackets)
\ No newline at end of file
+transform_levels_in_all_YAMLs(2, 3)
\ No newline at end of file
diff --git a/hedy.py b/hedy.py
--- a/hedy.py
+++ b/hedy.py
@@ -14,8 +14,9 @@
 import exceptions
 
 # Some useful constants
-HEDY_MAX_LEVEL = 14
+HEDY_MAX_LEVEL = 16
 MAX_LINES = 100
+LEVEL_STARTING_INDENTATION = 8
 
 #dictionary to store transpilers
 TRANSPILER_LOOKUP = {}
@@ -745,6 +746,7 @@ def process_variable_for_fstring_padded(name, lookup):
         return f"'{name}'.zfill(100)"
 
 @hedy_transpiler(level=2)
+@hedy_transpiler(level=3)
 class ConvertToPython_2(ConvertToPython_1):
 
     def ask_dep_2(self, args):
@@ -877,8 +879,8 @@ def make_f_string(args, lookup):
 
 
 #TODO: punctuation chars not be needed for level2 and up anymore, could be removed
-@hedy_transpiler(level=3)
-class ConvertToPython_3(ConvertToPython_2):
+@hedy_transpiler(level=4)
+class ConvertToPython_4(ConvertToPython_2):
 
     def var_access(self, args):
         name = args[0]
@@ -929,8 +931,8 @@ def indent(s):
     lines = s.split('\n')
     return '\n'.join(['  ' + l for l in lines])
 
-@hedy_transpiler(level=4)
-class ConvertToPython_4(ConvertToPython_3):
+@hedy_transpiler(level=5)
+class ConvertToPython_5(ConvertToPython_4):
     def list_access_var(self, args):
         var = hash_var(args[0])
         if args[2].data == 'random':
@@ -958,8 +960,8 @@ def in_list_check(self, args):
         arg1 = process_variable(args[1], self.lookup)
         return f"{arg0} in {arg1}"
 
-@hedy_transpiler(level=5)
-class ConvertToPython_5(ConvertToPython_4):
+@hedy_transpiler(level=6)
+class ConvertToPython_6(ConvertToPython_5):
 
     def print(self, args):
         # we only check non-Tree (= non calculation) arguments
@@ -1025,8 +1027,8 @@ def multiplication(self, args):
     def division(self, args):
         return self.process_calculation(args, '//')
 
-@hedy_transpiler(level=6)
-class ConvertToPython_6(ConvertToPython_5):
+@hedy_transpiler(level=7)
+class ConvertToPython_7(ConvertToPython_6):
     def repeat(self, args):
         var_name = self.get_fresh_var('i')
         times = process_variable(args[0], self.lookup)
@@ -1034,9 +1036,9 @@ def repeat(self, args):
         return f"""for {var_name} in range(int({str(times)})):
 {indent(command)}"""
 
-@hedy_transpiler(level=7)
 @hedy_transpiler(level=8)
-class ConvertToPython_7_8(ConvertToPython_6):
+@hedy_transpiler(level=9)
+class ConvertToPython_8_9(ConvertToPython_7):
     def __init__(self, punctuation_symbols, lookup):
         self.punctuation_symbols = punctuation_symbols
         self.lookup = lookup
@@ -1069,8 +1071,8 @@ def var_access(self, args):
         # this is list_access
             return hash_var(args[0]) + "[" + str(hash_var(args[1])) + "]" if type(args[1]) is not Tree else "random.choice(" + str(hash_var(args[0])) + ")"
 
-@hedy_transpiler(level=9)
-class ConvertToPython_9(ConvertToPython_7_8):
+@hedy_transpiler(level=10)
+class ConvertToPython_10(ConvertToPython_8_9):
     def repeat_list(self, args):
       args = [a for a in args if a != ""]  # filter out in|dedent tokens
 
@@ -1078,8 +1080,8 @@ def repeat_list(self, args):
 
       return f"for {args[0]} in {args[1]}:\n{body}"
 
-@hedy_transpiler(level=10)
-class ConvertToPython_10(ConvertToPython_9):
+@hedy_transpiler(level=11)
+class ConvertToPython_11(ConvertToPython_10):
     def for_loop(self, args):
         args = [a for a in args if a != ""]  # filter out in|dedent tokens
         body = "\n".join([indent(x) for x in args[3:]])
@@ -1109,8 +1111,8 @@ def is_random(s):
     return 'random.choice' in s
 
 
-@hedy_transpiler(level=11)
-class ConvertToPython_11(ConvertToPython_10):
+@hedy_transpiler(level=12)
+class ConvertToPython_12(ConvertToPython_11):
     def number(self, args):
         return ''.join(args)
 
@@ -1196,15 +1198,15 @@ def assign(self, args):
             # we no longer escape quotes here because they are now needed
             return parameter + " = " + value + ""
 
-@hedy_transpiler(level=12)
-class ConvertToPython_12(ConvertToPython_11):
+@hedy_transpiler(level=13)
+class ConvertToPython_13(ConvertToPython_12):
     def andcondition(self, args):
         return ' and '.join(args)
     def orcondition(self, args):
         return ' or '.join(args)
 
-@hedy_transpiler(level=13)
-class ConvertToPython_13(ConvertToPython_12):
+@hedy_transpiler(level=14)
+class ConvertToPython_14(ConvertToPython_13):
     def process_comparison(self, args, operator):
 
         # we are generating an fstring now
@@ -1240,15 +1242,15 @@ def bigger_equal(self, args):
     def not_equal(self, args):
         return self.process_comparison(args, "!=")
 
-@hedy_transpiler(level=14)
-class ConvertToPython_14(ConvertToPython_13):
+@hedy_transpiler(level=15)
+class ConvertToPython_15(ConvertToPython_14):
     def while_loop(self, args):
         args = [a for a in args if a != ""]  # filter out in|dedent tokens
         all_lines = [indent(x) for x in args[1:]]
         return "while " + args[0] + ":\n"+"\n".join(all_lines)
 
-@hedy_transpiler(level=15)
-class ConvertToPython_15(ConvertToPython_14):
+@hedy_transpiler(level=16)
+class ConvertToPython_16(ConvertToPython_15):
     def assign_list(self, args):
         parameter = args[0]
         values = [a for a in args[1:]]
@@ -1611,7 +1613,7 @@ def preprocess_blocks(code, level):
                                                                  indent_size=indent_size)
 
             current_number_of_indents = leading_spaces // indent_size
-            if current_number_of_indents > 1 and level == 7:
+            if current_number_of_indents > 1 and level == hedy.LEVEL_STARTING_INDENTATION:
                 raise hedy.exceptions.LockedLanguageFeatureException(concept="nested blocks")
 
         if next_line_needs_indentation and current_number_of_indents <= previous_number_of_indents:
@@ -1670,8 +1672,8 @@ def process_input_string(input_string, level):
     if level >= 3:
         result = result.replace("\\", "\\\\")
 
-    # In level 7 we add indent-dedent blocks to the code before parsing
-    if level >= 7:
+    # In level 8 we add indent-dedent blocks to the code before parsing
+    if level >= hedy.LEVEL_STARTING_INDENTATION:
         result = preprocess_blocks(result, level)
 
     return result


Test patch:
diff --git a/tests/test_level_02.py b/tests/test_level_02.py
--- a/tests/test_level_02.py
+++ b/tests/test_level_02.py
@@ -34,18 +34,6 @@ def test_print_comma(self):
     self.assertEqual(expected, result.code)
     self.assertEqual(False, result.has_turtle)
 
-
-  # issue #745
-  def test_print_list(self):
-    code = textwrap.dedent("""\
-        plaatsen is een stad, een  dorp, een strand
-        print test plaatsen""")
-
-    with self.assertRaises(hedy.exceptions.InvalidArgumentTypeException) as context:
-      result = hedy.transpile(code, self.level)
-
-    self.assertEqual('Invalid Argument Type', context.exception.error_code)
-
   def test_print_multiple_lines(self):
     code = textwrap.dedent("""\
     print Hallo welkom bij Hedy!
@@ -147,31 +135,6 @@ def test_assign_integer(self):
     expected = textwrap.dedent("""\
     naam = '14'""")
 
-    self.assertEqual(expected, result.code)
-    self.assertEqual(False, result.has_turtle)
-  def test_assign_list(self):
-
-    code = textwrap.dedent("""\
-    dieren is Hond, Kat, Kangoeroe""")
-
-    result = hedy.transpile(code, self.level)
-
-    expected = textwrap.dedent("""\
-    dieren = ['Hond', 'Kat', 'Kangoeroe']""")
-
-    self.assertEqual(expected, result.code)
-    self.assertEqual(False, result.has_turtle)
-  def test_assign_list_exclamation_mark(self):
-    code = textwrap.dedent("""\
-    antwoorden is ja, NEE!, misschien
-    print antwoorden at random""")
-
-    result = hedy.transpile(code, self.level)
-
-    expected = textwrap.dedent("""\
-    antwoorden = ['ja', 'NEE!', 'misschien']
-    print(f'{random.choice(antwoorden)}')""")
-
     self.assertEqual(expected, result.code)
     self.assertEqual(False, result.has_turtle)
 
@@ -314,16 +277,6 @@ def test_forward_with_string_variable(self):
       exception=hedy.exceptions.InvalidArgumentTypeException,
       test_name=self.name()
     )
-  def test_forward_with_list_variable(self):
-    code = textwrap.dedent("""\
-        a is 1, 2, 3
-        forward a""")
-    self.multi_level_tester(
-      max_level=9,
-      code=code,
-      exception=hedy.exceptions.InvalidArgumentTypeException,
-      test_name=self.name()
-    )
 
   #markup tests
   def test_spaces_in_arguments(self):
@@ -398,25 +351,6 @@ def test_random_turn(self):
 
     self.assertEqual(expected, result.code)
     self.assertEqual(True, result.has_turtle)
-  def test_print_list_random(self):
-    code = textwrap.dedent("""\
-    dieren is Hond, Kat, Kangoeroe
-    print dieren at random""")
-
-    expected = textwrap.dedent("""\
-    dieren = ['Hond', 'Kat', 'Kangoeroe']
-    print(f'{random.choice(dieren)}')""")
-
-    # check if result is in the expected list
-    check_in_list = (lambda x: HedyTester.run_code(x) in ['Hond', 'Kat', 'Kangoeroe'])
-
-    self.multi_level_tester(
-      max_level=10,
-      code=code,
-      expected=expected,
-      extra_check_function=check_in_list,
-      test_name=self.name()
-    )
   def test_assign_print_punctuation(self):
     code = textwrap.dedent("""\
     naam is Hedy
@@ -458,24 +392,6 @@ def test_assign_print_something_else(self):
     self.assertEqual(expected, result.code)
     self.assertEqual(False, result.has_turtle)
 
-  def test_print_list_var(self):
-    code = textwrap.dedent("""\
-    dieren is Hond, Kat, Kangoeroe
-    print dieren at 1""")
-
-    expected = textwrap.dedent("""\
-    dieren = ['Hond', 'Kat', 'Kangoeroe']
-    print(f'{dieren[1-1]}')""")
-
-    check_in_list = (lambda x: HedyTester.run_code(x) == 'Hond')
-
-    self.multi_level_tester(
-      max_level=10,
-      code=code,
-      expected=expected,
-      extra_check_function=check_in_list,
-      test_name=self.name()
-    )
 
   #negative tests
   def test_echo_no_longer_in_use(self):
diff --git a/tests/test_level_03.py b/tests/test_level_03.py
--- a/tests/test_level_03.py
+++ b/tests/test_level_03.py
@@ -6,7 +6,7 @@ class TestsLevel3(HedyTester):
   level = 3
 
   # tests should be ordered as follows:
-  # * commands in the order of hedy.py for level 3: ['print', 'ask', 'is', 'turn', 'forward'],
+  # * commands in the order of hedy.py e..g for level 2: ['print', 'ask', 'echo', 'is', 'turn', 'forward']
   # * combined tests
   # * markup tests
   # * negative tests (inc. negative & multilevel)
@@ -18,339 +18,489 @@ class TestsLevel3(HedyTester):
   # * situation_gives_exception
 
 
-  # print tests
+  #print tests
   def test_print(self):
+    result = hedy.transpile("print Hallo welkom bij Hedy!", self.level)
+    expected = textwrap.dedent("""\
+    print(f'Hallo welkom bij Hedy!')""")
+
+    self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
+  def test_print_comma(self):
+    result = hedy.transpile("print welkom bij steen, schaar, papier", self.level)
+    expected = textwrap.dedent("""\
+    print(f'welkom bij steen, schaar, papier')""")
+
+    self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
+
+
+  # issue #745
+  def test_print_list(self):
+    code = textwrap.dedent("""\
+        plaatsen is een stad, een  dorp, een strand
+        print test plaatsen""")
+
+    with self.assertRaises(hedy.exceptions.InvalidArgumentTypeException) as context:
+      result = hedy.transpile(code, self.level)
+
+    self.assertEqual('Invalid Argument Type', context.exception.error_code)
+
+  def test_print_multiple_lines(self):
     code = textwrap.dedent("""\
-    print 'hallo wereld!'""")
+    print Hallo welkom bij Hedy!
+    print Mooi hoor""")
 
     result = hedy.transpile(code, self.level)
 
     expected = textwrap.dedent("""\
-    print(f'hallo wereld!')""")
+    print(f'Hallo welkom bij Hedy!')
+    print(f'Mooi hoor')""")
 
     self.assertEqual(expected, result.code)
     self.assertEqual(False, result.has_turtle)
-  def test_print_comma(self):
-    code = textwrap.dedent("""\
-    naam is Hedy
-    print 'ik heet ,'""")
-    expected = textwrap.dedent("""\
-    naam = 'Hedy'
-    print(f'ik heet ,')""")
-    self.multi_level_tester(
-      code=code,
-      max_level=10,
-      expected=expected,
-      test_name=self.name(),
-      extra_check_function=self.is_not_turtle()
-    )
-  def test_print_two_spaces(self):
-    code = "print        'hallo!'"
+
+    expected_output = textwrap.dedent("""\
+    Hallo welkom bij Hedy!
+    Mooi hoor""")
+
+    self.assertEqual(expected_output, HedyTester.run_code(result))
+  def test_print_spaces(self):
+    code = "print        hallo!"
+    result = hedy.transpile(code, self.level)
 
     expected = textwrap.dedent("""\
     print(f'hallo!')""")
 
-    self.multi_level_tester(
-      code=code,
-      max_level=4,
-      expected=expected,
-      test_name=self.name(),
-      extra_check_function=self.is_not_turtle()
-    )
-  def test_print_with_slashes(self):
-    code = "print 'Welcome to \\'"
+    self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
+  def test_print_asterisk(self):
+    code = "print *Jouw* favoriet is dus kleur"
+    result = hedy.transpile(code, self.level)
+
+    expected = textwrap.dedent("""\
+    print(f'*Jouw* favoriet is dus kleur')""")
+
+    self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
+  def test_print_quotes(self):
+    code = "print 'Welcome to OceanView!'"
     result = hedy.transpile(code, self.level)
 
     expected = textwrap.dedent("""\
-    print(f'Welcome to \\\\')""")
+    print(f'\\'Welcome to OceanView! \\'')""")
 
     self.assertEqual(expected, result.code)
     self.assertEqual(False, result.has_turtle)
 
     expected_output = HedyTester.run_code(result)
-    self.assertEqual("Welcome to \\", expected_output)
+    self.assertEqual("'Welcome to OceanView! '", expected_output)
+  def test_print_slashes(self):
+    code = "print Welcome to O/ceanView"
+    result = hedy.transpile(code, self.level)
 
-  # ask
-  def test_assign_print(self):
-    code = textwrap.dedent("""\
-    naam is Hedy
-    print 'ik heet' naam""")
+    expected = textwrap.dedent("""\
+    print(f'Welcome to O/ceanView')""")
+
+    self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
+
+    expected_output = HedyTester.run_code(result)
+    self.assertEqual("Welcome to O/ceanView", expected_output)
+
+  #is tests
+  def test_assign(self):
+    result = hedy.transpile("naam is Felienne", self.level)
 
     expected = textwrap.dedent("""\
-    naam = 'Hedy'
-    print(f'ik heet{naam}')""")
+    naam = 'Felienne'""")
 
-    self.multi_level_tester(
-      max_level=10,
-      code=code,
-      expected=expected,
-      extra_check_function=self.is_not_turtle(),
-      test_name=self.name()
-    )
+    self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
+  def test_assign_integer(self):
+    result = hedy.transpile("naam is 14", self.level)
+
+    expected = textwrap.dedent("""\
+    naam = '14'""")
+
+    self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
+  def test_assign_list(self):
 
-  # issue #745
-  def test_print_list(self):
     code = textwrap.dedent("""\
-        plaatsen is een stad, een  dorp, een strand
-        print 'test' plaatsen""")
+    dieren is Hond, Kat, Kangoeroe""")
 
-    self.multi_level_tester(
-      code=code,
-      max_level=10,
-      exception=hedy.exceptions.InvalidArgumentTypeException,
-      test_name=self.name()
-    )
+    result = hedy.transpile(code, self.level)
+
+    expected = textwrap.dedent("""\
+    dieren = ['Hond', 'Kat', 'Kangoeroe']""")
 
-  def test_ask_Spanish(self):
+    self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
+  def test_assign_list_exclamation_mark(self):
     code = textwrap.dedent("""\
-    color is ask 'Cuál es tu color favorito?'""")
+    antwoorden is ja, NEE!, misschien
+    print antwoorden at random""")
+
+    result = hedy.transpile(code, self.level)
+
     expected = textwrap.dedent("""\
-    color = input('Cuál es tu color favorito?')""")
-    self.multi_level_tester(
-      max_level=10,
-      code=code,
-      expected=expected,
-      extra_check_function=self.is_not_turtle(),
-      test_name=self.name()
-    )
-  def test_ask_without_quotes(self):
-    code = textwrap.dedent("""
-    ding is kleur
-    kleur is ask Wat is je lievelingskleur'
-    print 'Jouw favoriet is dus ' kleur""")
+    antwoorden = ['ja', 'NEE!', 'misschien']
+    print(f'{random.choice(antwoorden)}')""")
 
-    with self.assertRaises(hedy.exceptions.UnquotedTextException) as context:
-      result = hedy.transpile(code, self.level)
+    self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
 
-    self.assertEqual('Unquoted Text', context.exception.error_code)  # hier moet nog we een andere foutmelding komen!
+  #ask tests
+  def test_ask(self):
+    result = hedy.transpile("kleur is ask wat is je lievelingskleur?", self.level)
 
-  # is - assign tests
-  def test_assign_underscore(self):
-    code = textwrap.dedent("""\
-    voor_naam is Hedy
-    print 'ik heet '""")
+    expected = textwrap.dedent("""\
+    kleur = input('wat is je lievelingskleur'+'?')""")
 
+    self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
+  def test_ask_quotes(self):
+    code = "name is ask 'What restaurant'"
     result = hedy.transpile(code, self.level)
 
     expected = textwrap.dedent("""\
-    voor_naam = 'Hedy'
-    print(f'ik heet ')""")
+    name = input('\\'What restaurant\\'')""")
 
     self.assertEqual(expected, result.code)
     self.assertEqual(False, result.has_turtle)
-  def test_assign_bengali(self):
-    hashed_var = hedy.hash_var("নাম")
+  def test_ask_Spanish_text(self):
+    result = hedy.transpile("color is ask ask Cuál es tu color favorito?", self.level)
+
+    expected = textwrap.dedent("""\
+    color = input('ask Cuál es tu color favorito'+'?')""")
 
+    self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
+  def test_ask_bengali_var(self):
     code = textwrap.dedent("""\
-    নাম is হেডি""")
+      রং is ask আপনার প্রিয় রং কি?
+      print রং is আপনার প্রিয""")
 
     result = hedy.transpile(code, self.level)
 
-    expected = textwrap.dedent(f"""\
-    {hashed_var} = 'হেডি'""")
+    expected = textwrap.dedent("""\
+    ve1760b6272d4c9f816e62af4882d874f = input('আপনার প্রিয় রং কি'+'?')
+    print(f'{ve1760b6272d4c9f816e62af4882d874f} is আপনার প্রিয')""")
 
     self.assertEqual(expected, result.code)
     self.assertEqual(False, result.has_turtle)
-  def test_assign_Python_keyword(self):
-    hashed_var = hedy.hash_var("for")
+  def test_ask_Hungarian_var(self):
+    code = textwrap.dedent("""\
+      állatok is kutya, macska, kenguru
+      print állatok at random""")
 
+    result = hedy.transpile(code, self.level)
+  def test_ask_with_comma(self):
     code = textwrap.dedent("""\
-    for is Hedy
-    print 'ik heet ' for """)
+    dieren is ask hond, kat, kangoeroe
+    print dieren""")
 
     result = hedy.transpile(code, self.level)
 
     expected = textwrap.dedent("""\
-    vd55669822f1a8cf72ec1911e462a54eb = 'Hedy'
-    print(f'ik heet {vd55669822f1a8cf72ec1911e462a54eb}')""")
+    dieren = input('hond, kat, kangoeroe')
+    print(f'{dieren}')""")
 
     self.assertEqual(expected, result.code)
     self.assertEqual(False, result.has_turtle)
 
-  # negative tests
-  def test_print_without_quotes(self):
-    with self.assertRaises(hedy.exceptions.UnquotedTextException) as context:
-      result = hedy.transpile("print felienne 123", self.level)
+  #sleep tests
+  def test_sleep_with_number(self):
+    code = "sleep 2"
+    expected = "time.sleep(2)"
 
-    self.assertEqual('Unquoted Text', context.exception.error_code)  # hier moet nog we een andere foutmelding komen!
+    self.multi_level_tester(
+      code=code,
+      expected=expected,
+      test_name=self.name()
+    )
+  def test_sleep_without_number(self):
+    code = "sleep"
+    expected = "time.sleep(1)"
 
-  #combined tests
-  def test_assign_print_bengali(self):
-    hashed_var = hedy.hash_var("নাম")
-    self.assertEqual('veb9b5c786e8cde0910df4197f630ee75', hashed_var)
+    self.multi_level_tester(
+      code=code,
+      expected=expected,
+      test_name=self.name()
+    )
 
+  #turn tests
+  def test_turn_number(self):
     code = textwrap.dedent("""\
-    নাম is হেডি
-    print 'আমার নাম is ' নাম """)
+    print Turtle race
+    turn 90""")
 
     result = hedy.transpile(code, self.level)
 
     expected = textwrap.dedent("""\
-    veb9b5c786e8cde0910df4197f630ee75 = 'হেডি'
-    print(f'আমার নাম is {veb9b5c786e8cde0910df4197f630ee75}')""")
+    print(f'Turtle race')
+    t.right(90)""")
 
     self.assertEqual(expected, result.code)
-  def test_assign_print_chinese(self):
-    hashed_var = hedy.hash_var("你好世界")
-    self.assertEqual('v65396ee4aad0b4f17aacd1c6112ee364', hashed_var)
-
+    self.assertEqual(True, result.has_turtle)
+  def test_turn_number_var(self):
     code = textwrap.dedent("""\
-    你好世界 is 你好世界
-    print 你好世界""")
+    print Turtle race
+    direction is 70
+    turn direction""")
 
     result = hedy.transpile(code, self.level)
 
     expected = textwrap.dedent("""\
-    v65396ee4aad0b4f17aacd1c6112ee364 = '你好世界'
-    print(f'{v65396ee4aad0b4f17aacd1c6112ee364}')""")
+    print(f'Turtle race')
+    direction = '70'
+    t.right(direction)""")
 
     self.assertEqual(expected, result.code)
+    self.assertEqual(True, result.has_turtle)
 
-  def test_print_list_var_random(self):
+  # issue #792
+  def test_turn_right_number(self):
+    self.multi_level_tester(
+      max_level=10,
+      code="turn right 90",
+      exception=hedy.exceptions.InvalidArgumentTypeException,
+      test_name=self.name()
+    )
 
+  #forward tests
+  def test_forward_without_argument(self):
     code = textwrap.dedent("""\
-    dieren is Hond, Kat, Kangoeroe
-    print 'hallo ' dieren at random""")
-
+    forward""")
     result = hedy.transpile(code, self.level)
+    expected = textwrap.dedent("""\
+    t.forward(50)
+    time.sleep(0.1)""")
+
+    self.assertEqual(expected, result.code)
+    self.assertEqual(True, result.has_turtle)
+  def test_forward_with_string_variable(self):
+    code = textwrap.dedent("""\
+        a is test
+        forward a""")
+    self.multi_level_tester(
+      max_level=9,
+      code=code,
+      exception=hedy.exceptions.InvalidArgumentTypeException,
+      test_name=self.name()
+    )
+  def test_forward_with_list_variable(self):
+    code = textwrap.dedent("""\
+        a is 1, 2, 3
+        forward a""")
+    self.multi_level_tester(
+      max_level=9,
+      code=code,
+      exception=hedy.exceptions.InvalidArgumentTypeException,
+      test_name=self.name()
+    )
 
+  #markup tests
+  def test_spaces_in_arguments(self):
+    result = hedy.transpile("print hallo      wereld", self.level)
     expected = textwrap.dedent("""\
-    dieren = ['Hond', 'Kat', 'Kangoeroe']
-    print(f'hallo {random.choice(dieren)}')""")
+    print(f'hallo wereld')""")
 
     self.assertEqual(expected, result.code)
     self.assertEqual(False, result.has_turtle)
-    self.assertIn(HedyTester.run_code(result), ['hallo Hond', 'hallo Kat', 'hallo Kangoeroe'])
+
+  #combined tests
   def test_ask_print(self):
+    result = hedy.transpile("kleur is ask wat is je lievelingskleur?\nprint kleur!", self.level)
+
+    expected = textwrap.dedent("""\
+    kleur = input('wat is je lievelingskleur'+'?')
+    print(f'{kleur}!')""")
 
-    code = textwrap.dedent("""
-    kleur is ask 'wat is je lievelingskleur?'
-    print 'jouw lievelingskleur is dus' kleur '!'""")
+    self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
+  def test_assign_print(self):
+    code = textwrap.dedent("""\
+    naam is Felienne
+    print naam""")
 
     result = hedy.transpile(code, self.level)
 
     expected = textwrap.dedent("""\
-    kleur = input('wat is je lievelingskleur?')
-    print(f'jouw lievelingskleur is dus{kleur}!')""")
+    naam = 'Felienne'
+    print(f'{naam}')""")
 
     self.assertEqual(expected, result.code)
     self.assertEqual(False, result.has_turtle)
-  def test_ask_assign(self):
-
-    code = textwrap.dedent("""
-    ding is kleur
-    kleur is ask 'Wat is je lievelings' ding
-    print 'Jouw favoriet is dus ' kleur""")
+  def test_forward_ask(self):
+    code = textwrap.dedent("""\
+    afstand is ask hoe ver dan?
+    forward afstand""")
+    result = hedy.transpile(code, self.level)
+    expected = textwrap.dedent("""\
+    afstand = input('hoe ver dan'+'?')
+    t.forward(afstand)
+    time.sleep(0.1)""")
+    self.assertEqual(expected, result.code)
+    self.assertEqual(True, result.has_turtle)
+  def test_turn_ask(self):
+    code = textwrap.dedent("""\
+    print Turtle race
+    direction is ask Where to turn?
+    turn direction""")
 
     result = hedy.transpile(code, self.level)
 
     expected = textwrap.dedent("""\
-    ding = 'kleur'
-    kleur = input('Wat is je lievelings'+ding)
-    print(f'Jouw favoriet is dus {kleur}')""")
+    print(f'Turtle race')
+    direction = input('Where to turn'+'?')
+    t.right(direction)""")
 
     self.assertEqual(expected, result.code)
-    self.assertEqual(False, result.has_turtle)
+    self.assertEqual(True, result.has_turtle)
+  def test_random_turn(self):
+    code = textwrap.dedent("""\
+    print Turtle race
+    directions is 10, 100, 360
+    turn directions at random""")
+
+    result = hedy.transpile(code, self.level)
+
+    expected = textwrap.dedent("""\
+    print(f'Turtle race')
+    directions = ['10', '100', '360']
+    t.right(random.choice(directions))""")
 
-  def test_ask_assign_list(self):
+    self.assertEqual(expected, result.code)
+    self.assertEqual(True, result.has_turtle)
+  def test_print_list_random(self):
     code = textwrap.dedent("""\
-    color is gree, blue
-    choice is ask 'Is your favorite color one of: ' color""")
+    dieren is Hond, Kat, Kangoeroe
+    print dieren at random""")
+
+    expected = textwrap.dedent("""\
+    dieren = ['Hond', 'Kat', 'Kangoeroe']
+    print(f'{random.choice(dieren)}')""")
+
+    # check if result is in the expected list
+    check_in_list = (lambda x: HedyTester.run_code(x) in ['Hond', 'Kat', 'Kangoeroe'])
 
     self.multi_level_tester(
-      code=code,
-      exception=hedy.exceptions.InvalidArgumentTypeException,
       max_level=10,
+      code=code,
+      expected=expected,
+      extra_check_function=check_in_list,
       test_name=self.name()
     )
+  def test_assign_print_punctuation(self):
+    code = textwrap.dedent("""\
+    naam is Hedy
+    print Hallo naam!""")
 
-  def test_forward_ask(self):
+    result = hedy.transpile(code, self.level)
+
+    expected = textwrap.dedent("""\
+    naam = 'Hedy'
+    print(f'Hallo {naam}!')""")
+
+    self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
+  def test_assign_print_sentence(self):
     code = textwrap.dedent("""\
-    afstand is ask 'hoe ver dan?'
-    forward afstand""")
+    naam is Hedy
+    print naam is jouw voornaam""")
+
+    result = hedy.transpile(code, self.level)
+
     expected = textwrap.dedent("""\
-    afstand = input('hoe ver dan?')
-    t.forward(afstand)
-    time.sleep(0.1)""")
+    naam = 'Hedy'
+    print(f'{naam} is jouw voornaam')""")
+
+    self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
+  def test_assign_print_something_else(self):
+
+    code = textwrap.dedent("""\
+    naam is Felienne
+    print Hallo""")
+
+    result = hedy.transpile(code, self.level)
+
+    expected = textwrap.dedent("""\
+    naam = 'Felienne'
+    print(f'Hallo')""")
+
+    self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
+
+  def test_print_list_var(self):
+    code = textwrap.dedent("""\
+    dieren is Hond, Kat, Kangoeroe
+    print dieren at 1""")
+
+    expected = textwrap.dedent("""\
+    dieren = ['Hond', 'Kat', 'Kangoeroe']
+    print(f'{dieren[1-1]}')""")
+
+    check_in_list = (lambda x: HedyTester.run_code(x) == 'Hond')
+
     self.multi_level_tester(
-      max_level=7,
+      max_level=10,
       code=code,
       expected=expected,
-      extra_check_function=self.is_turtle(),
+      extra_check_function=check_in_list,
       test_name=self.name()
     )
 
-
   #negative tests
-  def test_var_undefined_error_message(self):
+  def test_echo_no_longer_in_use(self):
     code = textwrap.dedent("""\
-      naam is Hedy
-      print 'ik heet ' name""")
-
+    ask what is jouw lievelingskleur?
+    echo Jouw lievelingskleur is dus...""")
+    with self.assertRaises(hedy.exceptions.WrongLevelException) as context:
+      result = hedy.transpile(code, self.level)
+    self.assertEqual('Wrong Level', context.exception.error_code)
+  def test_ask_without_argument_upto_22(self):
     self.multi_level_tester(
-      code=code,
-      exception=hedy.exceptions.UndefinedVarException,
+      code="name is ask",
       max_level=10,
+      exception=hedy.exceptions.IncompleteCommandException,
       test_name=self.name()
     )
-
-    # deze extra check functie kan nu niet mee omdat die altijd op result werkt
-    # evt toch splitsen in 2 (pos en neg?)
-    # self.assertEqual('name', context.exception.arguments['name'])
-
-  def test_issue_375(self):
-    code = textwrap.dedent("""
-      is Foobar
-      print welcome""")
-
-    with self.assertRaises(hedy.exceptions.ParseException) as context:
-      result = hedy.transpile(code, self.level)
-
-    self.assertEqual('Parse', context.exception.error_code)
-  def test_missing_opening_quote(self):
-    code = textwrap.dedent("""\
-      print hallo wereld'""")
-
-    with self.assertRaises(hedy.exceptions.UnquotedTextException) as context:
-      result = hedy.transpile(code, self.level)
-
-    self.assertEqual('Unquoted Text', context.exception.error_code)
-  def test_missing_all_quotes(self):
+  def test_random_from_string(self):
     code = textwrap.dedent("""\
-      print hallo wereld""")
-
+      items is aap noot mies
+      print items at random""")
     self.multi_level_tester(
       code=code,
       max_level=4,
-      test_name=self.name(),
-      exception=hedy.exceptions.UndefinedVarException,
+      exception=hedy.exceptions.RequiredArgumentTypeException,
+      test_name=self.name()
     )
-  def test_print_Spanish(self):
+  def test_random_undefined_var(self):
+    # todo could be added for higher levels but that is a lot of variations so I am not doing it now :) (FH, oct 2021)
     code = textwrap.dedent("""\
-    print 'Cuál es tu color favorito?'""")
-    expected = textwrap.dedent("""\
-    print(f'Cuál es tu color favorito?')""")
-
+    dieren is hond, kat, kangoeroe
+    print dier at random""")
     self.multi_level_tester(
       code=code,
-      max_level=11,
-      test_name=self.name(),
-      expected=expected,
-      extra_check_function=self.is_not_turtle()
+      max_level=10,
+      exception=hedy.exceptions.UndefinedVarException,
+      test_name=self.name()
     )
 
-  #assorti
-  def test_detect_accented_chars(self):
-    self.assertEqual(True, hedy.hash_needed('éyyy'))
-    self.assertEqual(True, hedy.hash_needed('héyyy'))
-    self.assertEqual(False, hedy.hash_needed('heyyy'))
-
-
-
-
-
-
-
+  def test_ask_level_2(self):
+    code = textwrap.dedent("""\
+    keuzes is steen, schaar, papier
+    print keuzes at random
+    ask is de papier goed?""")
+    self.multi_level_tester(
+      code=code,
+      max_level=2,
+      exception=hedy.exceptions.WrongLevelException,
+      test_name=self.name()
+    )
 
 
 
diff --git a/tests/test_level_04.py b/tests/test_level_04.py
--- a/tests/test_level_04.py
+++ b/tests/test_level_04.py
@@ -3,390 +3,354 @@
 from test_level_01 import HedyTester
 
 class TestsLevel4(HedyTester):
-  level=4
+  level = 4
 
-  # test/command order: ['print', 'ask', 'is', 'if', 'turn', 'forward']
+  # tests should be ordered as follows:
+  # * commands in the order of hedy.py for level 3: ['print', 'ask', 'is', 'turn', 'forward'],
+  # * combined tests
+  # * markup tests
+  # * negative tests (inc. negative & multilevel)
 
-  # print & ask -> no changes, covered by tests of earlier levels
+  # test name conventions are like this:
+  # * single keyword positive tests are just keyword or keyword_special_case
+  # * multi keyword positive tests are keyword1_keywords_2
+  # * negative tests should be
+  # * situation_gives_exception
 
-  # is
-  def test_assign_list_access(self):
+
+  # print tests
+  def test_print(self):
     code = textwrap.dedent("""\
-    dieren is Hond, Kat, Kangoeroe
-    dier is dieren at random
-    print dier""")
+    print 'hallo wereld!'""")
 
     result = hedy.transpile(code, self.level)
 
     expected = textwrap.dedent("""\
-    dieren = ['Hond', 'Kat', 'Kangoeroe']
-    dier=random.choice(dieren)
-    print(f'{dier}')""")
+    print(f'hallo wereld!')""")
 
     self.assertEqual(expected, result.code)
     self.assertEqual(False, result.has_turtle)
-    self.assertIn(HedyTester.run_code(result), ['Hond', 'Kat', 'Kangoeroe'])
-  def test_assign_list_multiple_spaces(self):
+  def test_print_comma(self):
     code = textwrap.dedent("""\
-    dieren is Hond,  Kat,       Kangoeroe
-    dier is dieren at random
-    print dier""")
+    naam is Hedy
+    print 'ik heet ,'""")
+    expected = textwrap.dedent("""\
+    naam = 'Hedy'
+    print(f'ik heet ,')""")
+    self.multi_level_tester(
+      code=code,
+      max_level=10,
+      expected=expected,
+      test_name=self.name(),
+      extra_check_function=self.is_not_turtle()
+    )
+  def test_print_two_spaces(self):
+    code = "print        'hallo!'"
+
+    expected = textwrap.dedent("""\
+    print(f'hallo!')""")
 
+    self.multi_level_tester(
+      code=code,
+      max_level=4,
+      expected=expected,
+      test_name=self.name(),
+      extra_check_function=self.is_not_turtle()
+    )
+  def test_print_with_slashes(self):
+    code = "print 'Welcome to \\'"
     result = hedy.transpile(code, self.level)
 
     expected = textwrap.dedent("""\
-    dieren = ['Hond', 'Kat', 'Kangoeroe']
-    dier=random.choice(dieren)
-    print(f'{dier}')""")
+    print(f'Welcome to \\\\')""")
 
     self.assertEqual(expected, result.code)
     self.assertEqual(False, result.has_turtle)
-  def test_assign_single_quote(self):
-    code = """message is 'Hello welcome to Hedy.'"""
-    expected = "message = '\\'Hello welcome to Hedy.\\''"
 
-    result = hedy.transpile(code, self.level)
-    self.assertEqual(expected, result.code)
-    self.assertEqual(False, result.has_turtle)
+    expected_output = HedyTester.run_code(result)
+    self.assertEqual("Welcome to \\", expected_output)
 
-  # if
-  def test_allow_space_after_else_line(self):
-    #this code has a space at the end of line 2
+  # ask
+  def test_assign_print(self):
     code = textwrap.dedent("""\
-    a is 2
-    if a is 1 print a
-    else print 'nee'""")
-
-    result = hedy.transpile(code, self.level)
+    naam is Hedy
+    print 'ik heet' naam""")
 
     expected = textwrap.dedent("""\
-    a = '2'
-    if a == '1':
-      print(f'{a}')
-    else:
-      print(f'nee')""")
+    naam = 'Hedy'
+    print(f'ik heet{naam}')""")
 
-    self.assertEqual(expected, result.code)
-  def test_ifelse_should_go_before_assign(self):
+    self.multi_level_tester(
+      max_level=10,
+      code=code,
+      expected=expected,
+      extra_check_function=self.is_not_turtle(),
+      test_name=self.name()
+    )
+
+  # issue #745
+  def test_print_list(self):
     code = textwrap.dedent("""\
-    kleur is geel
-    if kleur is groen antwoord is ok else antwoord is stom
-    print antwoord""")
-    expected = textwrap.dedent("""\
-      kleur = 'geel'
-      if kleur == 'groen':
-        antwoord = 'ok'
-      else:
-        antwoord = 'stom'
-      print(f'{antwoord}')""")
+        plaatsen is een stad, een  dorp, een strand
+        print 'test' plaatsen""")
 
     self.multi_level_tester(
-      max_level=4,
+      code=code,
+      max_level=10,
+      exception=hedy.exceptions.InvalidArgumentTypeException,
+      test_name=self.name()
+    )
+
+  def test_ask_Spanish(self):
+    code = textwrap.dedent("""\
+    color is ask 'Cuál es tu color favorito?'""")
+    expected = textwrap.dedent("""\
+    color = input('Cuál es tu color favorito?')""")
+    self.multi_level_tester(
+      max_level=10,
       code=code,
       expected=expected,
       extra_check_function=self.is_not_turtle(),
       test_name=self.name()
     )
+  def test_ask_without_quotes(self):
+    code = textwrap.dedent("""
+    ding is kleur
+    kleur is ask Wat is je lievelingskleur'
+    print 'Jouw favoriet is dus ' kleur""")
 
-  def test_identifies_backtick_inside_conditional(self):
-    self.assertRaises(hedy.exceptions.UnquotedTextException, lambda: hedy.transpile("if 1 is 1 print `yay!` else print `nay`", self.level))
-
+    with self.assertRaises(hedy.exceptions.UnquotedTextException) as context:
+      result = hedy.transpile(code, self.level)
 
-  # turn forward
-  # no new tests, covered by lower levels.
+    self.assertEqual('Unquoted Text', context.exception.error_code)  # hier moet nog we een andere foutmelding komen!
 
-  # combined tests
-  def test_turn_forward(self):
-    result = hedy.transpile("forward 50\nturn\nforward 100", self.level)
-    expected = textwrap.dedent("""\
-    t.forward(50)
-    time.sleep(0.1)
-    t.right(90)
-    t.forward(100)
-    time.sleep(0.1)""")
-    self.assertEqual(expected, result.code)
-    self.assertEqual(True, result.has_turtle)
-  def test_ask_print(self):
+  # is - assign tests
+  def test_assign_underscore(self):
     code = textwrap.dedent("""\
-    kleur is ask 'wat is je lievelingskleur?'
-    print 'jouw lievelingskleur is dus' kleur '!'""")
+    voor_naam is Hedy
+    print 'ik heet '""")
 
     result = hedy.transpile(code, self.level)
 
     expected = textwrap.dedent("""\
-    kleur = input('wat is je lievelingskleur?')
-    print(f'jouw lievelingskleur is dus{kleur}!')""")
+    voor_naam = 'Hedy'
+    print(f'ik heet ')""")
 
     self.assertEqual(expected, result.code)
     self.assertEqual(False, result.has_turtle)
-  def test_print_if_else(self):
+  def test_assign_bengali(self):
+    hashed_var = hedy.hash_var("নাম")
+
     code = textwrap.dedent("""\
-    naam is Hedy
-    print 'ik heet' naam
-    if naam is Hedy print 'leuk' else print 'minder leuk'""")
+    নাম is হেডি""")
 
     result = hedy.transpile(code, self.level)
 
-    expected = textwrap.dedent("""\
-    naam = 'Hedy'
-    print(f'ik heet{naam}')
-    if naam == 'Hedy':
-      print(f'leuk')
-    else:
-      print(f'minder leuk')""")
+    expected = textwrap.dedent(f"""\
+    {hashed_var} = 'হেডি'""")
 
     self.assertEqual(expected, result.code)
     self.assertEqual(False, result.has_turtle)
-  def test_print_if_else_ask(self):
+  def test_assign_Python_keyword(self):
+    hashed_var = hedy.hash_var("for")
 
     code = textwrap.dedent("""\
-    kleur is ask 'Wat is je lievelingskleur?'
-    if kleur is groen print 'mooi!' else print 'niet zo mooi'""")
+    for is Hedy
+    print 'ik heet ' for """)
 
     result = hedy.transpile(code, self.level)
 
     expected = textwrap.dedent("""\
-    kleur = input('Wat is je lievelingskleur?')
-    if kleur == 'groen':
-      print(f'mooi!')
-    else:
-      print(f'niet zo mooi')""")
+    vd55669822f1a8cf72ec1911e462a54eb = 'Hedy'
+    print(f'ik heet {vd55669822f1a8cf72ec1911e462a54eb}')""")
 
     self.assertEqual(expected, result.code)
     self.assertEqual(False, result.has_turtle)
-  def test_print_if_else_with_line_break(self):
-    # line breaks should be allowed in if-elses until level 7 when we start with indentation
-    code = textwrap.dedent("""\
-    naam is Hedy
-    print 'ik heet' naam
-    if naam is Hedy print 'leuk'
-    else print 'minder leuk'""")
 
-    expected = textwrap.dedent("""\
-    naam = 'Hedy'
-    print(f'ik heet{naam}')
-    if naam == 'Hedy':
-      print(f'leuk')
-    else:
-      print(f'minder leuk')""")
+  # negative tests
+  def test_print_without_quotes(self):
+    with self.assertRaises(hedy.exceptions.UnquotedTextException) as context:
+      result = hedy.transpile("print felienne 123", self.level)
 
-    self.multi_level_tester(
-      max_level=4,
-      code=code,
-      expected=expected,
-      test_name=self.name(),
-      extra_check_function=self.is_not_turtle()
-    )
-  def test_print_if_else_with_line_break_after_condition(self):
-    # line breaks after conditional should be allowed in if-elses until level 7 when we start with indentation
-    code = textwrap.dedent("""\
-    naam is Hedy
-    print 'ik heet' naam
-    if naam is Hedy
-    print 'leuk'
-    else print 'minder leuk'""")
+    self.assertEqual('Unquoted Text', context.exception.error_code)  # hier moet nog we een andere foutmelding komen!
 
-    expected = textwrap.dedent("""\
-    naam = 'Hedy'
-    print(f'ik heet{naam}')
-    if naam == 'Hedy':
-      print(f'leuk')
-    else:
-      print(f'minder leuk')""")
+  #combined tests
+  def test_assign_print_bengali(self):
+    hashed_var = hedy.hash_var("নাম")
+    self.assertEqual('veb9b5c786e8cde0910df4197f630ee75', hashed_var)
 
-    self.multi_level_tester(
-      max_level=4,
-      code=code,
-      expected=expected,
-      test_name=self.name(),
-      extra_check_function=self.is_not_turtle()
-    )
-  def test_if_else_newline_list_assigment_print(self):
-    # line breaks after conditional should be allowed in if-elses until level 7 when we start with indentation
     code = textwrap.dedent("""\
-    people is mom, dad, Emma, Sophie
-    dishwasher is people at random
-    if dishwasher is Sophie
-    print 'too bad I have to do the dishes'
-    else
-    print 'luckily no dishes because' dishwasher 'is already washing up'""")
+    নাম is হেডি
+    print 'আমার নাম is ' নাম """)
 
-    expected = textwrap.dedent("""\
-    people = ['mom', 'dad', 'Emma', 'Sophie']
-    dishwasher=random.choice(people)
-    if dishwasher == 'Sophie':
-      print(f'too bad I have to do the dishes')
-    else:
-      print(f'luckily no dishes because{dishwasher}is already washing up')""")
-
-    self.multi_level_tester(
-      max_level=4,
-      code=code,
-      expected=expected,
-      test_name=self.name(),
-      extra_check_function=self.is_not_turtle()
-    )
+    result = hedy.transpile(code, self.level)
 
+    expected = textwrap.dedent("""\
+    veb9b5c786e8cde0910df4197f630ee75 = 'হেডি'
+    print(f'আমার নাম is {veb9b5c786e8cde0910df4197f630ee75}')""")
 
-  def test_print_if_else_line_break_and_space(self):
-    # line breaks should be allowed in if-elses until level 7 when we start with indentation
+    self.assertEqual(expected, result.code)
+  def test_assign_print_chinese(self):
+    hashed_var = hedy.hash_var("你好世界")
+    self.assertEqual('v65396ee4aad0b4f17aacd1c6112ee364', hashed_var)
 
     code = textwrap.dedent("""\
-    naam is Hedy
-    print 'ik heet' naam
-    if naam is Hedy print 'leuk'
-    else print 'minder leuk'""")
-
-    expected = textwrap.dedent("""\
-    naam = 'Hedy'
-    print(f'ik heet{naam}')
-    if naam == 'Hedy':
-      print(f'leuk')
-    else:
-      print(f'minder leuk')""")
+    你好世界 is 你好世界
+    print 你好世界""")
 
-    self.multi_level_tester(
-      max_level=4,
-      code=code,
-      expected=expected,
-      test_name=self.name(),
-      extra_check_function=self.is_not_turtle()
-    )
-  def test_print_if_linebreak_statement(self):
-    # Breaking an if statement and its following statement should be
-    # permited until level 7 
-    
-    code = textwrap.dedent("""\
-    people is 1, 2, 3, 3
-    dishwasher is people at random
-    test is 1
-    if dishwasher is test
-    print 'too bad I have to do the dishes!'""")
+    result = hedy.transpile(code, self.level)
 
     expected = textwrap.dedent("""\
-    people = ['1', '2', '3', '3']
-    dishwasher=random.choice(people)
-    test = '1'
-    if dishwasher == test:
-      print(f'too bad I have to do the dishes!')""")
+    v65396ee4aad0b4f17aacd1c6112ee364 = '你好世界'
+    print(f'{v65396ee4aad0b4f17aacd1c6112ee364}')""")
 
-    self.multi_level_tester(
-      max_level=4,
-      code=code,
-      expected=expected,
-      test_name=self.name(),
-      extra_check_function=self.is_not_turtle()
-    )
-  def test_print_if_else_and_var(self):
+    self.assertEqual(expected, result.code)
+
+  def test_print_list_var_random(self):
 
     code = textwrap.dedent("""\
-    jouwkeuze is steen
-    computerkeuze is schaar
-    if computerkeuze is schaar and jouwkeuze is steen print 'jij wint'""")
+    dieren is Hond, Kat, Kangoeroe
+    print 'hallo ' dieren at random""")
 
     result = hedy.transpile(code, self.level)
 
     expected = textwrap.dedent("""\
-    jouwkeuze = 'steen'
-    computerkeuze = 'schaar'
-    if computerkeuze == 'schaar' and jouwkeuze == 'steen':
-      print(f'jij wint')""")
+    dieren = ['Hond', 'Kat', 'Kangoeroe']
+    print(f'hallo {random.choice(dieren)}')""")
 
     self.assertEqual(expected, result.code)
     self.assertEqual(False, result.has_turtle)
-    self.assertEqual(HedyTester.run_code(result), 'jij wint')
-  def test_print_if_assign(self):
-    code = textwrap.dedent("""\
-    jouwkeuze is schaar
-    computerkeuze is schaar
-    if computerkeuze is jouwkeuze print 'gelijkspel!'""")
+    self.assertIn(HedyTester.run_code(result), ['hallo Hond', 'hallo Kat', 'hallo Kangoeroe'])
+  def test_ask_print(self):
+
+    code = textwrap.dedent("""
+    kleur is ask 'wat is je lievelingskleur?'
+    print 'jouw lievelingskleur is dus' kleur '!'""")
 
     result = hedy.transpile(code, self.level)
 
     expected = textwrap.dedent("""\
-    jouwkeuze = 'schaar'
-    computerkeuze = 'schaar'
-    if computerkeuze == jouwkeuze:
-      print(f'gelijkspel!')""")
+    kleur = input('wat is je lievelingskleur?')
+    print(f'jouw lievelingskleur is dus{kleur}!')""")
 
     self.assertEqual(expected, result.code)
     self.assertEqual(False, result.has_turtle)
-    self.assertEqual(HedyTester.run_code(result), 'gelijkspel!')
-  def test_if_in_list(self):
-    code = textwrap.dedent("""\
-    items is red, green
-    selected is red
-    if selected in items print 'found!'""")
+  def test_ask_assign(self):
 
-    expected = textwrap.dedent("""\
-    items = ['red', 'green']
-    selected = 'red'
-    if selected in items:
-      print(f'found!')""")
+    code = textwrap.dedent("""
+    ding is kleur
+    kleur is ask 'Wat is je lievelings' ding
+    print 'Jouw favoriet is dus ' kleur""")
 
     result = hedy.transpile(code, self.level)
 
+    expected = textwrap.dedent("""\
+    ding = 'kleur'
+    kleur = input('Wat is je lievelings'+ding)
+    print(f'Jouw favoriet is dus {kleur}')""")
+
     self.assertEqual(expected, result.code)
     self.assertEqual(False, result.has_turtle)
-    self.assertEqual('found!', HedyTester.run_code(result))
-  # todo would be good to make combinations with if and turtle
 
+  def test_ask_assign_list(self):
+    code = textwrap.dedent("""\
+    color is gree, blue
+    choice is ask 'Is your favorite color one of: ' color""")
 
+    self.multi_level_tester(
+      code=code,
+      exception=hedy.exceptions.InvalidArgumentTypeException,
+      max_level=10,
+      test_name=self.name()
+    )
 
-  #negative tests
-  def test_indent_gives_parse_error(self):
+  def test_forward_ask(self):
     code = textwrap.dedent("""\
-    option is ask 'Rock Paper or Scissors?'
-    print 'Player 2 ' option
-    if option is Scissors
-        print 'Its a tie!'""")
+    afstand is ask 'hoe ver dan?'
+    forward afstand""")
+    expected = textwrap.dedent("""\
+    afstand = input('hoe ver dan?')
+    t.forward(afstand)
+    time.sleep(0.1)""")
+    self.multi_level_tester(
+      max_level=7,
+      code=code,
+      expected=expected,
+      extra_check_function=self.is_turtle(),
+      test_name=self.name()
+    )
 
-    with self.assertRaises(hedy.exceptions.ParseException) as context:
-      result = hedy.transpile(code, self.level)
-    self.assertEqual('Parse', context.exception.error_code)
-  def test_if_print_has_no_turtle(self):
+
+  #negative tests
+  def test_var_undefined_error_message(self):
     code = textwrap.dedent("""\
-    jouwkeuze is schaar
-    computerkeuze is schaar
-    if computerkeuze is jouwkeuze print 'gelijkspel!'""")
-    result = hedy.transpile_inner(code, self.level)
-    self.assertEqual(False, result.has_turtle)
-  def test_no_space_after_keyword_gives_invalid(self):
-    code = textwrap.dedent("print'test'")
+      naam is Hedy
+      print 'ik heet ' name""")
 
     self.multi_level_tester(
-      max_level=10,
       code=code,
-      exception=hedy.exceptions.InvalidCommandException,
+      exception=hedy.exceptions.UndefinedVarException,
+      max_level=10,
       test_name=self.name()
     )
 
-    #we don't have a function now for testing more exceptoion logic
-    # self.assertEqual('print', str(context.exception.arguments['guessed_command']))
-  def test_pront_should_suggest_print(self):
-    code = "pront 'Hedy is leuk!'"
+    # deze extra check functie kan nu niet mee omdat die altijd op result werkt
+    # evt toch splitsen in 2 (pos en neg?)
+    # self.assertEqual('name', context.exception.arguments['name'])
+
+  def test_issue_375(self):
+    code = textwrap.dedent("""
+      is Foobar
+      print welcome""")
+
+    with self.assertRaises(hedy.exceptions.ParseException) as context:
+      result = hedy.transpile(code, self.level)
+
+    self.assertEqual('Parse', context.exception.error_code)
+  def test_missing_opening_quote(self):
+    code = textwrap.dedent("""\
+      print hallo wereld'""")
 
-    with self.assertRaises(hedy.exceptions.InvalidCommandException) as context:
+    with self.assertRaises(hedy.exceptions.UnquotedTextException) as context:
       result = hedy.transpile(code, self.level)
-    self.assertEqual('Invalid', context.exception.error_code)
-    self.assertEqual('<span class="command-highlighted">print</span>', str(context.exception.arguments['guessed_command']))
-  def test_if_with_print_backtick(self):
+
+    self.assertEqual('Unquoted Text', context.exception.error_code)
+  def test_missing_all_quotes(self):
     code = textwrap.dedent("""\
-    name is ask 'ποιό είναι το όνομά σου;'
-    if name is Hedy print `ωραία` else print `μπου!`""")
+      print hallo wereld""")
 
     self.multi_level_tester(
+      code=code,
       max_level=4,
+      test_name=self.name(),
+      exception=hedy.exceptions.UndefinedVarException,
+    )
+  def test_print_Spanish(self):
+    code = textwrap.dedent("""\
+    print 'Cuál es tu color favorito?'""")
+    expected = textwrap.dedent("""\
+    print(f'Cuál es tu color favorito?')""")
+
+    self.multi_level_tester(
       code=code,
-      exception=hedy.exceptions.UnquotedTextException,
-      test_name=self.name()
+      max_level=11,
+      test_name=self.name(),
+      expected=expected,
+      extra_check_function=self.is_not_turtle()
     )
 
-  # def test_list_find_issue(self):
-  #   #'list' object has no attribute 'find'
-  #   # FH dd sept 2021 for later fixing!
-  #   code = textwrap.dedent("""\
-  #     নাম is ask আপনার নাম কি?
-  #     if নাম is হেডি print 'ভালো!' else print 'মন্দ'\"""")
-  #
-  #
+  #assorti
+  def test_detect_accented_chars(self):
+    self.assertEqual(True, hedy.hash_needed('éyyy'))
+    self.assertEqual(True, hedy.hash_needed('héyyy'))
+    self.assertEqual(False, hedy.hash_needed('heyyy'))
+
+
+
+
+
+
+
+
+
+
diff --git a/tests/test_level_05.py b/tests/test_level_05.py
--- a/tests/test_level_05.py
+++ b/tests/test_level_05.py
@@ -3,55 +3,157 @@
 from test_level_01 import HedyTester
 
 class TestsLevel5(HedyTester):
-  level = 5
+  level=5
 
-  # test/command order: 6: ['print', 'ask', 'is', 'if', 'repeat', 'turn', 'forward', calculations]
+  # test/command order: ['print', 'ask', 'is', 'if', 'turn', 'forward']
 
-  # print tests
-  def test_print_quoted_var(self):
+  # print & ask -> no changes, covered by tests of earlier levels
+
+  # is
+  def test_assign_list_access(self):
+    code = textwrap.dedent("""\
+    dieren is Hond, Kat, Kangoeroe
+    dier is dieren at random
+    print dier""")
+
+    result = hedy.transpile(code, self.level)
+
+    expected = textwrap.dedent("""\
+    dieren = ['Hond', 'Kat', 'Kangoeroe']
+    dier=random.choice(dieren)
+    print(f'{dier}')""")
+
+    self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
+    self.assertIn(HedyTester.run_code(result), ['Hond', 'Kat', 'Kangoeroe'])
+  def test_assign_list_multiple_spaces(self):
+    code = textwrap.dedent("""\
+    dieren is Hond,  Kat,       Kangoeroe
+    dier is dieren at random
+    print dier""")
+
+    result = hedy.transpile(code, self.level)
+
+    expected = textwrap.dedent("""\
+    dieren = ['Hond', 'Kat', 'Kangoeroe']
+    dier=random.choice(dieren)
+    print(f'{dier}')""")
+
+    self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
+  def test_assign_single_quote(self):
+    code = """message is 'Hello welcome to Hedy.'"""
+    expected = "message = '\\'Hello welcome to Hedy.\\''"
+
+    result = hedy.transpile(code, self.level)
+    self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
+
+  # if
+  def test_allow_space_after_else_line(self):
+    #this code has a space at the end of line 2
     code = textwrap.dedent("""\
-    naam is 'Hedy'
-    print 'ik heet ' naam""")
+    a is 2
+    if a is 1 print a
+    else print 'nee'""")
+
+    result = hedy.transpile(code, self.level)
+
     expected = textwrap.dedent("""\
-    naam = '\\'Hedy\\''
-    print(f'ik heet {naam}')""")
+    a = '2'
+    if a == '1':
+      print(f'{a}')
+    else:
+      print(f'nee')""")
+
+    self.assertEqual(expected, result.code)
+  def test_ifelse_should_go_before_assign(self):
+    code = textwrap.dedent("""\
+    kleur is geel
+    if kleur is groen antwoord is ok else antwoord is stom
+    print antwoord""")
+    expected = textwrap.dedent("""\
+      kleur = 'geel'
+      if kleur == 'groen':
+        antwoord = 'ok'
+      else:
+        antwoord = 'stom'
+      print(f'{antwoord}')""")
 
     self.multi_level_tester(
-      max_level=10,
+      max_level=4,
       code=code,
       expected=expected,
+      extra_check_function=self.is_not_turtle(),
       test_name=self.name()
     )
 
-  def test_unsupported_float_with_dot(self):
-    self.multi_level_tester(
-      max_level=10,
-      code="print 1.5 + 1",
-      exception=hedy.exceptions.UnsupportedFloatException,
-      test_name=self.name()
-    )
-  def test_unsupported_float_with_comma(self):
-    self.multi_level_tester(
-      max_level=10,
-      code="print 1,5 + 1",
-      exception=hedy.exceptions.UnsupportedFloatException,
-      test_name=self.name()
-    )
+  def test_identifies_backtick_inside_conditional(self):
+    self.assertRaises(hedy.exceptions.UnquotedTextException, lambda: hedy.transpile("if 1 is 1 print `yay!` else print `nay`", self.level))
 
-  #ask tests
-  def test_ask(self):
+
+  # turn forward
+  # no new tests, covered by lower levels.
+
+  # combined tests
+  def test_turn_forward(self):
+    result = hedy.transpile("forward 50\nturn\nforward 100", self.level)
+    expected = textwrap.dedent("""\
+    t.forward(50)
+    time.sleep(0.1)
+    t.right(90)
+    t.forward(100)
+    time.sleep(0.1)""")
+    self.assertEqual(expected, result.code)
+    self.assertEqual(True, result.has_turtle)
+  def test_ask_print(self):
     code = textwrap.dedent("""\
-    antwoord is ask 'wat is je lievelingskleur?'""")
+    kleur is ask 'wat is je lievelingskleur?'
+    print 'jouw lievelingskleur is dus' kleur '!'""")
 
     result = hedy.transpile(code, self.level)
 
     expected = textwrap.dedent("""\
-    antwoord = input('wat is je lievelingskleur?')""")
+    kleur = input('wat is je lievelingskleur?')
+    print(f'jouw lievelingskleur is dus{kleur}!')""")
 
     self.assertEqual(expected, result.code)
     self.assertEqual(False, result.has_turtle)
+  def test_print_if_else(self):
+    code = textwrap.dedent("""\
+    naam is Hedy
+    print 'ik heet' naam
+    if naam is Hedy print 'leuk' else print 'minder leuk'""")
+
+    result = hedy.transpile(code, self.level)
+
+    expected = textwrap.dedent("""\
+    naam = 'Hedy'
+    print(f'ik heet{naam}')
+    if naam == 'Hedy':
+      print(f'leuk')
+    else:
+      print(f'minder leuk')""")
 
-  #if tests
+    self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
+  def test_print_if_else_ask(self):
+
+    code = textwrap.dedent("""\
+    kleur is ask 'Wat is je lievelingskleur?'
+    if kleur is groen print 'mooi!' else print 'niet zo mooi'""")
+
+    result = hedy.transpile(code, self.level)
+
+    expected = textwrap.dedent("""\
+    kleur = input('Wat is je lievelingskleur?')
+    if kleur == 'groen':
+      print(f'mooi!')
+    else:
+      print(f'niet zo mooi')""")
+
+    self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
   def test_print_if_else_with_line_break(self):
     # line breaks should be allowed in if-elses until level 7 when we start with indentation
     code = textwrap.dedent("""\
@@ -63,280 +165,228 @@ def test_print_if_else_with_line_break(self):
     expected = textwrap.dedent("""\
     naam = 'Hedy'
     print(f'ik heet{naam}')
-    if str(naam) == str('Hedy'):
+    if naam == 'Hedy':
       print(f'leuk')
     else:
       print(f'minder leuk')""")
 
     self.multi_level_tester(
-      max_level=6,
+      max_level=4,
       code=code,
       expected=expected,
       test_name=self.name(),
       extra_check_function=self.is_not_turtle()
     )
-  def test_print_if_else_with_line_break_and_space(self):
-    # line breaks should be allowed in if-elses until level 7 when we start with indentation
-
+  def test_print_if_else_with_line_break_after_condition(self):
+    # line breaks after conditional should be allowed in if-elses until level 7 when we start with indentation
     code = textwrap.dedent("""\
     naam is Hedy
     print 'ik heet' naam
-    if naam is Hedy print 'leuk'
+    if naam is Hedy
+    print 'leuk'
     else print 'minder leuk'""")
 
     expected = textwrap.dedent("""\
     naam = 'Hedy'
     print(f'ik heet{naam}')
-    if str(naam) == str('Hedy'):
+    if naam == 'Hedy':
       print(f'leuk')
     else:
       print(f'minder leuk')""")
 
     self.multi_level_tester(
-      max_level=6,
+      max_level=4,
       code=code,
       expected=expected,
       test_name=self.name(),
       extra_check_function=self.is_not_turtle()
     )
-  def test_if_else_with_space(self):
-    #this code has a space at the end of line 2
+  def test_if_else_newline_list_assigment_print(self):
+    # line breaks after conditional should be allowed in if-elses until level 7 when we start with indentation
     code = textwrap.dedent("""\
-    a is 2
-    if a is 1 print a
-    else print 'nee'""")
+    people is mom, dad, Emma, Sophie
+    dishwasher is people at random
+    if dishwasher is Sophie
+    print 'too bad I have to do the dishes'
+    else
+    print 'luckily no dishes because' dishwasher 'is already washing up'""")
 
     expected = textwrap.dedent("""\
-    a = '2'
-    if str(a) == str('1'):
-      print(f'{a}')
+    people = ['mom', 'dad', 'Emma', 'Sophie']
+    dishwasher=random.choice(people)
+    if dishwasher == 'Sophie':
+      print(f'too bad I have to do the dishes')
     else:
-      print(f'nee')""")
+      print(f'luckily no dishes because{dishwasher}is already washing up')""")
 
     self.multi_level_tester(
-      max_level=6,
+      max_level=4,
       code=code,
       expected=expected,
       test_name=self.name(),
       extra_check_function=self.is_not_turtle()
     )
 
-  # calculation tests
-  # todo should all be tested for higher levels too!
-  def test_print_calc(self):
-    code = textwrap.dedent("""\
-    print '5 keer 5 is ' 5 * 5""")
-
-    expected = textwrap.dedent("""\
-    print(f'5 keer 5 is {int(5) * int(5)}')""")
-
-    result = hedy.transpile(code, self.level)
-
-    self.assertEqual(expected, result.code)
-    self.assertEqual(False, result.has_turtle)
-  def test_print_multiple_calcs(self):
-    code = textwrap.dedent("""\
-    print '5 keer 5 keer 5 is ' 5 * 5 * 5""")
-
-    expected = textwrap.dedent("""\
-    print(f'5 keer 5 keer 5 is {int(5) * int(5) * int(5)}')""")
 
-    result = hedy.transpile(code, self.level)
-    self.assertEqual(expected, result.code)
+  def test_print_if_else_line_break_and_space(self):
+    # line breaks should be allowed in if-elses until level 7 when we start with indentation
 
-    output = HedyTester.run_code(result)
-    self.assertEqual(output, '5 keer 5 keer 5 is 125')
-    self.assertEqual(False, result.has_turtle)
-  def test_calc_print(self):
     code = textwrap.dedent("""\
-    nummer is 4 + 5
-    print nummer""")
-
-    result = hedy.transpile(code, self.level)
+    naam is Hedy
+    print 'ik heet' naam
+    if naam is Hedy print 'leuk'
+    else print 'minder leuk'""")
 
     expected = textwrap.dedent("""\
-    nummer = int(4) + int(5)
-    print(f'{nummer}')""")
-
-    self.assertEqual(expected, result.code)
-    self.assertEqual(False, result.has_turtle)
-    self.assertEqual("9", HedyTester.run_code(result))
-  def test_calc_assign(self):
-    code = "nummer is 4 + 5"
-    result = hedy.transpile(code, self.level)
-
-    expected = "nummer = int(4) + int(5)"
-    self.assertEqual(expected, result.code)
-    self.assertEqual(False, result.has_turtle)
-  def test_calc_without_space(self):
-    code = "nummer is 4+5"
-    result = hedy.transpile(code, self.level)
+    naam = 'Hedy'
+    print(f'ik heet{naam}')
+    if naam == 'Hedy':
+      print(f'leuk')
+    else:
+      print(f'minder leuk')""")
 
-    expected = "nummer = int(4) + int(5)"
-    self.assertEqual(expected, result.code)
-    self.assertEqual(False, result.has_turtle)
-  def test_assign_calc(self):
+    self.multi_level_tester(
+      max_level=4,
+      code=code,
+      expected=expected,
+      test_name=self.name(),
+      extra_check_function=self.is_not_turtle()
+    )
+  def test_print_if_linebreak_statement(self):
+    # Breaking an if statement and its following statement should be
+    # permited until level 7 
+    
     code = textwrap.dedent("""\
-    var is 5
-    print var + 5""")
-
-    result = hedy.transpile(code, self.level)
+    people is 1, 2, 3, 3
+    dishwasher is people at random
+    test is 1
+    if dishwasher is test
+    print 'too bad I have to do the dishes!'""")
 
     expected = textwrap.dedent("""\
-    var = '5'
-    print(f'{int(var) + int(5)}')""")
-
-    self.assertEqual(expected, result.code)
-
-  def test_assign_parses_periods(self):
-    code = "period is ."
-    expected = "period = '.'"
+    people = ['1', '2', '3', '3']
+    dishwasher=random.choice(people)
+    test = '1'
+    if dishwasher == test:
+      print(f'too bad I have to do the dishes!')""")
 
     self.multi_level_tester(
-      max_level=10,
+      max_level=4,
       code=code,
       expected=expected,
-      extra_check_function=self.is_not_turtle(),
-      test_name=self.name()
+      test_name=self.name(),
+      extra_check_function=self.is_not_turtle()
     )
+  def test_print_if_else_and_var(self):
 
-  def test_calc_vars(self):
     code = textwrap.dedent("""\
-    nummer is 5
-    nummertwee is 6
-    getal is nummer * nummertwee
-    print getal""")
+    jouwkeuze is steen
+    computerkeuze is schaar
+    if computerkeuze is schaar and jouwkeuze is steen print 'jij wint'""")
 
     result = hedy.transpile(code, self.level)
 
     expected = textwrap.dedent("""\
-    nummer = '5'
-    nummertwee = '6'
-    getal = int(nummer) * int(nummertwee)
-    print(f'{getal}')""")
+    jouwkeuze = 'steen'
+    computerkeuze = 'schaar'
+    if computerkeuze == 'schaar' and jouwkeuze == 'steen':
+      print(f'jij wint')""")
 
     self.assertEqual(expected, result.code)
     self.assertEqual(False, result.has_turtle)
-    self.assertEqual("30", HedyTester.run_code(result))
-  def test_calc_vars_print(self):
+    self.assertEqual(HedyTester.run_code(result), 'jij wint')
+  def test_print_if_assign(self):
     code = textwrap.dedent("""\
-    nummer is 5
-    nummertwee is 6
-    print nummer * nummertwee""")
+    jouwkeuze is schaar
+    computerkeuze is schaar
+    if computerkeuze is jouwkeuze print 'gelijkspel!'""")
 
     result = hedy.transpile(code, self.level)
 
     expected = textwrap.dedent("""\
-    nummer = '5'
-    nummertwee = '6'
-    print(f'{int(nummer) * int(nummertwee)}')""")
+    jouwkeuze = 'schaar'
+    computerkeuze = 'schaar'
+    if computerkeuze == jouwkeuze:
+      print(f'gelijkspel!')""")
 
     self.assertEqual(expected, result.code)
     self.assertEqual(False, result.has_turtle)
-    self.assertEqual("30", HedyTester.run_code(result))
-  def test_calc_vars_print_divide(self):
+    self.assertEqual(HedyTester.run_code(result), 'gelijkspel!')
+  def test_if_in_list(self):
     code = textwrap.dedent("""\
-    nummer is 5
-    nummertwee is 6
-    print nummer / nummertwee""")
-
-    result = hedy.transpile(code, self.level)
+    items is red, green
+    selected is red
+    if selected in items print 'found!'""")
 
     expected = textwrap.dedent("""\
-    nummer = '5'
-    nummertwee = '6'
-    print(f'{int(nummer) // int(nummertwee)}')""")
+    items = ['red', 'green']
+    selected = 'red'
+    if selected in items:
+      print(f'found!')""")
+
+    result = hedy.transpile(code, self.level)
 
     self.assertEqual(expected, result.code)
     self.assertEqual(False, result.has_turtle)
-    self.assertEqual("0", HedyTester.run_code(result))
+    self.assertEqual('found!', HedyTester.run_code(result))
+  # todo would be good to make combinations with if and turtle
 
 
-  # combined tests
-  def test_print_else(self):
-      code = textwrap.dedent("""\
-      keuzes is 1, 2, 3, 4, 5, regenworm
-      punten is 0
-      worp is keuzes at random
-      if worp is regenworm punten is punten + 5
-      else punten is punten + worp
-      print 'dat zijn dan ' punten""")
-
-      result = hedy.transpile(code, self.level)
 
-      expected = textwrap.dedent("""\
-      keuzes = ['1', '2', '3', '4', '5', 'regenworm']
-      punten = '0'
-      worp=random.choice(keuzes)
-      if str(worp) == str('regenworm'):
-        punten = int(punten) + int(5)
-      else:
-        punten = int(punten) + int(worp)
-      print(f'dat zijn dan {punten}')""")
+  #negative tests
+  def test_indent_gives_parse_error(self):
+    code = textwrap.dedent("""\
+    option is ask 'Rock Paper or Scissors?'
+    print 'Player 2 ' option
+    if option is Scissors
+        print 'Its a tie!'""")
 
-      self.assertEqual(expected, result.code)
-      self.assertEqual(False, result.has_turtle)
-  def test_ifelse_should_go_before_assign(self):
+    with self.assertRaises(hedy.exceptions.ParseException) as context:
+      result = hedy.transpile(code, self.level)
+    self.assertEqual('Parse', context.exception.error_code)
+  def test_if_print_has_no_turtle(self):
     code = textwrap.dedent("""\
-    kleur is geel
-    if kleur is groen antwoord is ok else antwoord is stom
-    print antwoord""")
-    expected = textwrap.dedent("""\
-    kleur = 'geel'
-    if str(kleur) == str('groen'):
-      antwoord = 'ok'
-    else:
-      antwoord = 'stom'
-    print(f'{antwoord}')""")
+    jouwkeuze is schaar
+    computerkeuze is schaar
+    if computerkeuze is jouwkeuze print 'gelijkspel!'""")
+    result = hedy.transpile_inner(code, self.level)
+    self.assertEqual(False, result.has_turtle)
+  def test_no_space_after_keyword_gives_invalid(self):
+    code = textwrap.dedent("print'test'")
 
     self.multi_level_tester(
-      max_level=6,
+      max_level=10,
       code=code,
-      expected=expected,
-      extra_check_function=self.is_not_turtle(),
+      exception=hedy.exceptions.InvalidCommandException,
       test_name=self.name()
     )
-  def test_ifelse_calc_vars(self):
-    code =  textwrap.dedent("""\
-    cmp is 1
-    test is 2
-    acu is 0
-    if test is cmp
-    acu is acu + 1
-    else
-    acu is acu + 5""")
-    expected = textwrap.dedent("""\
-    cmp = '1'
-    test = '2'
-    acu = '0'
-    if str(test) == str(cmp):
-      acu = int(acu) + int(1)
-    else:
-      acu = int(acu) + int(5)""")
+
+    #we don't have a function now for testing more exceptoion logic
+    # self.assertEqual('print', str(context.exception.arguments['guessed_command']))
+  def test_pront_should_suggest_print(self):
+    code = "pront 'Hedy is leuk!'"
+
+    with self.assertRaises(hedy.exceptions.InvalidCommandException) as context:
+      result = hedy.transpile(code, self.level)
+    self.assertEqual('Invalid', context.exception.error_code)
+    self.assertEqual('<span class="command-highlighted">print</span>', str(context.exception.arguments['guessed_command']))
+  def test_if_with_print_backtick(self):
+    code = textwrap.dedent("""\
+    name is ask 'ποιό είναι το όνομά σου;'
+    if name is Hedy print `ωραία` else print `μπου!`""")
+
     self.multi_level_tester(
-      max_level=6,
+      max_level=4,
       code=code,
-      expected=expected,
-      extra_check_function=self.is_not_turtle(),
+      exception=hedy.exceptions.UnquotedTextException,
       test_name=self.name()
     )
-  def test_if_calc_vars(self):
-    code =  textwrap.dedent("""\
-    cmp is 1
-    test is 2
-    acu is 0
-    if test is cmp
-    acu is acu + 1""")
-    expected = textwrap.dedent("""\
-    cmp = '1'
-    test = '2'
-    acu = '0'
-    if str(test) == str(cmp):
-      acu = int(acu) + int(1)""")
-    self.multi_level_tester(
-      max_level=6,
-      code=code,
-      expected=expected,
-      extra_check_function=self.is_not_turtle(),
-      test_name=self.name()
-    )
\ No newline at end of file
+
+  # def test_list_find_issue(self):
+  #   #'list' object has no attribute 'find'
+  #   # FH dd sept 2021 for later fixing!
+  #   code = textwrap.dedent("""\
+  #     নাম is ask আপনার নাম কি?
+  #     if নাম is হেডি print 'ভালো!' else print 'মন্দ'\"""")
+  #
+  #
diff --git a/tests/test_level_06.py b/tests/test_level_06.py
--- a/tests/test_level_06.py
+++ b/tests/test_level_06.py
@@ -5,114 +5,338 @@
 class TestsLevel6(HedyTester):
   level = 6
 
+  # test/command order: 6: ['print', 'ask', 'is', 'if', 'repeat', 'turn', 'forward', calculations]
 
-  #repeat tests
-  def test_repeat_turtle(self):
+  # print tests
+  def test_print_quoted_var(self):
     code = textwrap.dedent("""\
-    repeat 3 times forward 100""")
+    naam is 'Hedy'
+    print 'ik heet ' naam""")
+    expected = textwrap.dedent("""\
+    naam = '\\'Hedy\\''
+    print(f'ik heet {naam}')""")
+
+    self.multi_level_tester(
+      max_level=10,
+      code=code,
+      expected=expected,
+      test_name=self.name()
+    )
+
+  def test_unsupported_float_with_dot(self):
+    self.multi_level_tester(
+      max_level=10,
+      code="print 1.5 + 1",
+      exception=hedy.exceptions.UnsupportedFloatException,
+      test_name=self.name()
+    )
+  def test_unsupported_float_with_comma(self):
+    self.multi_level_tester(
+      max_level=10,
+      code="print 1,5 + 1",
+      exception=hedy.exceptions.UnsupportedFloatException,
+      test_name=self.name()
+    )
+
+  #ask tests
+  def test_ask(self):
+    code = textwrap.dedent("""\
+    antwoord is ask 'wat is je lievelingskleur?'""")
+
+    result = hedy.transpile(code, self.level)
+
+    expected = textwrap.dedent("""\
+    antwoord = input('wat is je lievelingskleur?')""")
+
+    self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
+
+  #if tests
+  def test_print_if_else_with_line_break(self):
+    # line breaks should be allowed in if-elses until level 7 when we start with indentation
+    code = textwrap.dedent("""\
+    naam is Hedy
+    print 'ik heet' naam
+    if naam is Hedy print 'leuk'
+    else print 'minder leuk'""")
+
+    expected = textwrap.dedent("""\
+    naam = 'Hedy'
+    print(f'ik heet{naam}')
+    if str(naam) == str('Hedy'):
+      print(f'leuk')
+    else:
+      print(f'minder leuk')""")
+
+    self.multi_level_tester(
+      max_level=6,
+      code=code,
+      expected=expected,
+      test_name=self.name(),
+      extra_check_function=self.is_not_turtle()
+    )
+  def test_print_if_else_with_line_break_and_space(self):
+    # line breaks should be allowed in if-elses until level 7 when we start with indentation
+
+    code = textwrap.dedent("""\
+    naam is Hedy
+    print 'ik heet' naam
+    if naam is Hedy print 'leuk'
+    else print 'minder leuk'""")
+
+    expected = textwrap.dedent("""\
+    naam = 'Hedy'
+    print(f'ik heet{naam}')
+    if str(naam) == str('Hedy'):
+      print(f'leuk')
+    else:
+      print(f'minder leuk')""")
+
+    self.multi_level_tester(
+      max_level=6,
+      code=code,
+      expected=expected,
+      test_name=self.name(),
+      extra_check_function=self.is_not_turtle()
+    )
+  def test_if_else_with_space(self):
+    #this code has a space at the end of line 2
+    code = textwrap.dedent("""\
+    a is 2
+    if a is 1 print a
+    else print 'nee'""")
+
+    expected = textwrap.dedent("""\
+    a = '2'
+    if str(a) == str('1'):
+      print(f'{a}')
+    else:
+      print(f'nee')""")
+
+    self.multi_level_tester(
+      max_level=6,
+      code=code,
+      expected=expected,
+      test_name=self.name(),
+      extra_check_function=self.is_not_turtle()
+    )
+
+  # calculation tests
+  # todo should all be tested for higher levels too!
+  def test_print_calc(self):
+    code = textwrap.dedent("""\
+    print '5 keer 5 is ' 5 * 5""")
+
+    expected = textwrap.dedent("""\
+    print(f'5 keer 5 is {int(5) * int(5)}')""")
 
     result = hedy.transpile(code, self.level)
 
+    self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
+  def test_print_multiple_calcs(self):
+    code = textwrap.dedent("""\
+    print '5 keer 5 keer 5 is ' 5 * 5 * 5""")
+
     expected = textwrap.dedent("""\
-    for i in range(int('3')):
-      t.forward(100)
-      time.sleep(0.1)""")
+    print(f'5 keer 5 keer 5 is {int(5) * int(5) * int(5)}')""")
 
+    result = hedy.transpile(code, self.level)
     self.assertEqual(expected, result.code)
-    self.assertEqual(True, result.has_turtle)
-  def test_repeat_with_variable_print(self):
+
+    output = HedyTester.run_code(result)
+    self.assertEqual(output, '5 keer 5 keer 5 is 125')
+    self.assertEqual(False, result.has_turtle)
+  def test_calc_print(self):
     code = textwrap.dedent("""\
-    n is 5
-    repeat n times print 'me wants a cookie!'""")
+    nummer is 4 + 5
+    print nummer""")
 
     result = hedy.transpile(code, self.level)
 
     expected = textwrap.dedent("""\
-    n = '5'
-    for i in range(int(n)):
-      print(f'me wants a cookie!')""")
+    nummer = int(4) + int(5)
+    print(f'{nummer}')""")
+
+    self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
+    self.assertEqual("9", HedyTester.run_code(result))
+  def test_calc_assign(self):
+    code = "nummer is 4 + 5"
+    result = hedy.transpile(code, self.level)
+
+    expected = "nummer = int(4) + int(5)"
+    self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
+  def test_calc_without_space(self):
+    code = "nummer is 4+5"
+    result = hedy.transpile(code, self.level)
 
+    expected = "nummer = int(4) + int(5)"
     self.assertEqual(expected, result.code)
     self.assertEqual(False, result.has_turtle)
+  def test_assign_calc(self):
+    code = textwrap.dedent("""\
+    var is 5
+    print var + 5""")
+
+    result = hedy.transpile(code, self.level)
 
-    expected_output = textwrap.dedent("""\
-    me wants a cookie!
-    me wants a cookie!
-    me wants a cookie!
-    me wants a cookie!
-    me wants a cookie!""")
+    expected = textwrap.dedent("""\
+    var = '5'
+    print(f'{int(var) + int(5)}')""")
+
+    self.assertEqual(expected, result.code)
+
+  def test_assign_parses_periods(self):
+    code = "period is ."
+    expected = "period = '.'"
 
-    self.assertEqual(expected_output, HedyTester.run_code(result))
-  def test_repeat_basic_print(self):
+    self.multi_level_tester(
+      max_level=10,
+      code=code,
+      expected=expected,
+      extra_check_function=self.is_not_turtle(),
+      test_name=self.name()
+    )
+
+  def test_calc_vars(self):
     code = textwrap.dedent("""\
-    repeat 5 times print 'me wants a cookie!'""")
+    nummer is 5
+    nummertwee is 6
+    getal is nummer * nummertwee
+    print getal""")
 
     result = hedy.transpile(code, self.level)
 
     expected = textwrap.dedent("""\
-    for i in range(int('5')):
-      print(f'me wants a cookie!')""")
+    nummer = '5'
+    nummertwee = '6'
+    getal = int(nummer) * int(nummertwee)
+    print(f'{getal}')""")
 
     self.assertEqual(expected, result.code)
     self.assertEqual(False, result.has_turtle)
+    self.assertEqual("30", HedyTester.run_code(result))
+  def test_calc_vars_print(self):
+    code = textwrap.dedent("""\
+    nummer is 5
+    nummertwee is 6
+    print nummer * nummertwee""")
 
-    expected_output = textwrap.dedent("""\
-    me wants a cookie!
-    me wants a cookie!
-    me wants a cookie!
-    me wants a cookie!
-    me wants a cookie!""")
+    result = hedy.transpile(code, self.level)
 
-    self.assertEqual(expected_output, HedyTester.run_code(result))
-  def test_repeat_over_9_times(self):
+    expected = textwrap.dedent("""\
+    nummer = '5'
+    nummertwee = '6'
+    print(f'{int(nummer) * int(nummertwee)}')""")
 
+    self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
+    self.assertEqual("30", HedyTester.run_code(result))
+  def test_calc_vars_print_divide(self):
     code = textwrap.dedent("""\
-    repeat 10 times print 'me wants a cookie!'""")
+    nummer is 5
+    nummertwee is 6
+    print nummer / nummertwee""")
 
     result = hedy.transpile(code, self.level)
 
     expected = textwrap.dedent("""\
-    for i in range(int('10')):
-      print(f'me wants a cookie!')""")
+    nummer = '5'
+    nummertwee = '6'
+    print(f'{int(nummer) // int(nummertwee)}')""")
 
     self.assertEqual(expected, result.code)
     self.assertEqual(False, result.has_turtle)
+    self.assertEqual("0", HedyTester.run_code(result))
 
-    expected_output = textwrap.dedent("""\
-    me wants a cookie!
-    me wants a cookie!
-    me wants a cookie!
-    me wants a cookie!
-    me wants a cookie!
-    me wants a cookie!
-    me wants a cookie!
-    me wants a cookie!
-    me wants a cookie!
-    me wants a cookie!""")
-    self.assertEqual(expected_output, HedyTester.run_code(result))
-  def test_repeat_with_collision(self):
+
+  # combined tests
+  def test_print_else(self):
       code = textwrap.dedent("""\
-      i is hallo!
-      repeat 5 times print 'me wants a cookie!'
-      print i""")
+      keuzes is 1, 2, 3, 4, 5, regenworm
+      punten is 0
+      worp is keuzes at random
+      if worp is regenworm punten is punten + 5
+      else punten is punten + worp
+      print 'dat zijn dan ' punten""")
 
       result = hedy.transpile(code, self.level)
 
       expected = textwrap.dedent("""\
-      i = 'hallo!'
-      for _i in range(int('5')):
-        print(f'me wants a cookie!')
-      print(f'{i}')""")
+      keuzes = ['1', '2', '3', '4', '5', 'regenworm']
+      punten = '0'
+      worp=random.choice(keuzes)
+      if str(worp) == str('regenworm'):
+        punten = int(punten) + int(5)
+      else:
+        punten = int(punten) + int(worp)
+      print(f'dat zijn dan {punten}')""")
 
       self.assertEqual(expected, result.code)
       self.assertEqual(False, result.has_turtle)
+  def test_ifelse_should_go_before_assign(self):
+    code = textwrap.dedent("""\
+    kleur is geel
+    if kleur is groen antwoord is ok else antwoord is stom
+    print antwoord""")
+    expected = textwrap.dedent("""\
+    kleur = 'geel'
+    if str(kleur) == str('groen'):
+      antwoord = 'ok'
+    else:
+      antwoord = 'stom'
+    print(f'{antwoord}')""")
 
-      expected_output = textwrap.dedent("""\
-      me wants a cookie!
-      me wants a cookie!
-      me wants a cookie!
-      me wants a cookie!
-      me wants a cookie!
-      hallo!""")
-
-      self.assertEqual(expected_output, HedyTester.run_code(result))
\ No newline at end of file
+    self.multi_level_tester(
+      max_level=6,
+      code=code,
+      expected=expected,
+      extra_check_function=self.is_not_turtle(),
+      test_name=self.name()
+    )
+  def test_ifelse_calc_vars(self):
+    code =  textwrap.dedent("""\
+    cmp is 1
+    test is 2
+    acu is 0
+    if test is cmp
+    acu is acu + 1
+    else
+    acu is acu + 5""")
+    expected = textwrap.dedent("""\
+    cmp = '1'
+    test = '2'
+    acu = '0'
+    if str(test) == str(cmp):
+      acu = int(acu) + int(1)
+    else:
+      acu = int(acu) + int(5)""")
+    self.multi_level_tester(
+      max_level=6,
+      code=code,
+      expected=expected,
+      extra_check_function=self.is_not_turtle(),
+      test_name=self.name()
+    )
+  def test_if_calc_vars(self):
+    code =  textwrap.dedent("""\
+    cmp is 1
+    test is 2
+    acu is 0
+    if test is cmp
+    acu is acu + 1""")
+    expected = textwrap.dedent("""\
+    cmp = '1'
+    test = '2'
+    acu = '0'
+    if str(test) == str(cmp):
+      acu = int(acu) + int(1)""")
+    self.multi_level_tester(
+      max_level=6,
+      code=code,
+      expected=expected,
+      extra_check_function=self.is_not_turtle(),
+      test_name=self.name()
+    )
\ No newline at end of file
diff --git a/tests/test_level_07.py b/tests/test_level_07.py
--- a/tests/test_level_07.py
+++ b/tests/test_level_07.py
@@ -5,38 +5,25 @@
 class TestsLevel7(HedyTester):
   level = 7
 
-  def test_if_with_indent(self):
-    # todo should be tested for all levels!
-    code = textwrap.dedent("""\
-    naam is Hedy
-    if naam is Hedy
-        print 'koekoek'""")
-
-    result = hedy.transpile(code, self.level)
-
-    expected = textwrap.dedent("""\
-    naam = 'Hedy'
-    if str(naam) == str('Hedy'):
-      print(f'koekoek')""")
 
-    self.assertEqual(expected, result.code)
-  def test_repeat_with_indent(self):
+  #repeat tests
+  def test_repeat_turtle(self):
     code = textwrap.dedent("""\
-    repeat 5 times
-      print 'koekoek'""")
+    repeat 3 times forward 100""")
 
     result = hedy.transpile(code, self.level)
 
     expected = textwrap.dedent("""\
-    for i in range(int(5)):
-      print(f'koekoek')""")
+    for i in range(int('3')):
+      t.forward(100)
+      time.sleep(0.1)""")
 
     self.assertEqual(expected, result.code)
+    self.assertEqual(True, result.has_turtle)
   def test_repeat_with_variable_print(self):
     code = textwrap.dedent("""\
     n is 5
-    repeat n times
-        print 'me wants a cookie!'""")
+    repeat n times print 'me wants a cookie!'""")
 
     result = hedy.transpile(code, self.level)
 
@@ -46,6 +33,7 @@ def test_repeat_with_variable_print(self):
       print(f'me wants a cookie!')""")
 
     self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
 
     expected_output = textwrap.dedent("""\
     me wants a cookie!
@@ -55,20 +43,18 @@ def test_repeat_with_variable_print(self):
     me wants a cookie!""")
 
     self.assertEqual(expected_output, HedyTester.run_code(result))
-  def test_repeat_with_non_latin_variable_print(self):
+  def test_repeat_basic_print(self):
     code = textwrap.dedent("""\
-    állatok is 5
-    repeat állatok times
-        print 'me wants a cookie!'""")
+    repeat 5 times print 'me wants a cookie!'""")
 
     result = hedy.transpile(code, self.level)
 
     expected = textwrap.dedent("""\
-    v79de0191e90551f058d466c5e8c267ff = '5'
-    for i in range(int(v79de0191e90551f058d466c5e8c267ff)):
+    for i in range(int('5')):
       print(f'me wants a cookie!')""")
 
     self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
 
     expected_output = textwrap.dedent("""\
     me wants a cookie!
@@ -78,146 +64,55 @@ def test_repeat_with_non_latin_variable_print(self):
     me wants a cookie!""")
 
     self.assertEqual(expected_output, HedyTester.run_code(result))
-  def test_if_else(self):
-    code = textwrap.dedent("""\
-    antwoord is ask 'Hoeveel is 10 plus 10?'
-    if antwoord is 20
-        print 'Goedzo!'
-        print 'Het antwoord was inderdaad ' antwoord
-    else
-        print 'Foutje'
-        print 'Het antwoord moest zijn ' antwoord""")
-
-    result = hedy.transpile(code, self.level)
+  def test_repeat_over_9_times(self):
 
-    expected = textwrap.dedent("""\
-    antwoord = input('Hoeveel is 10 plus 10?')
-    if str(antwoord) == str('20'):
-      print(f'Goedzo!')
-      print(f'Het antwoord was inderdaad {antwoord}')
-    else:
-      print(f'Foutje')
-      print(f'Het antwoord moest zijn {antwoord}')""")
-
-    self.assertEqual(expected, result.code)
-  def test_repeat_basic_print(self):
     code = textwrap.dedent("""\
-    repeat 5 times
-      print 'me wants a cookie!'""")
+    repeat 10 times print 'me wants a cookie!'""")
 
     result = hedy.transpile(code, self.level)
 
     expected = textwrap.dedent("""\
-    for i in range(int(5)):
+    for i in range(int('10')):
       print(f'me wants a cookie!')""")
 
     self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
 
     expected_output = textwrap.dedent("""\
     me wants a cookie!
     me wants a cookie!
     me wants a cookie!
     me wants a cookie!
+    me wants a cookie!
+    me wants a cookie!
+    me wants a cookie!
+    me wants a cookie!
+    me wants a cookie!
     me wants a cookie!""")
-
     self.assertEqual(expected_output, HedyTester.run_code(result))
-  def test_allow_space_after_else_line(self):
-    #todo should work up to 11??
-    code = textwrap.dedent("""\
-    a is 1
-    if a is 1
-      print a
-    else
-      print 'nee'""")
-
-    expected = textwrap.dedent("""\
-    a = '1'
-    if str(a) == str('1'):
-      print(f'{a}')
-    else:
-      print(f'nee')""")
-
-    self.multi_level_tester(
-      max_level=9,
-      code=code,
-      expected=expected,
-      test_name=self.name()
-    )
-
-  def test_issue_297(self):
-    code = textwrap.dedent("""\
-    count is 1
-    repeat 12 times
-      print count ' times 12 is ' count*12
-      count is count + 1""")
-
-    result = hedy.transpile(code, self.level)
-
-    expected = textwrap.dedent("""\
-    count = '1'
-    for i in range(int(12)):
-      print(f'{count} times 12 is {int(count) * int(12)}')
-      count = int(count) + int(1)""")
-
-    self.assertEqual(expected, result.code)
+  def test_repeat_with_collision(self):
+      code = textwrap.dedent("""\
+      i is hallo!
+      repeat 5 times print 'me wants a cookie!'
+      print i""")
 
-  # negative tests
-
-  def test_issue_902(self):
-    code = textwrap.dedent("""\
-    print 'kassabon'
-    prijs is 0
-    repeat 7 times
-      ingredient is ask 'wat wil je kopen?'
-      if ingredient is appel
-          prijs is prijs + 1
-    print 'Dat is in totaal ' prijs ' euro.'""")
-
-    with self.assertRaises(hedy.exceptions.LockedLanguageFeatureException) as context:
       result = hedy.transpile(code, self.level)
-  def test_repeat_nested_in_if(self):
-    code = textwrap.dedent("""\
-    kleur is groen
-    if kleur is groen
-        repeat 3 times
-            print 'mooi'""")
 
-    with self.assertRaises(hedy.exceptions.LockedLanguageFeatureException) as context:
-      result = hedy.transpile(code, self.level)
+      expected = textwrap.dedent("""\
+      i = 'hallo!'
+      for _i in range(int('5')):
+        print(f'me wants a cookie!')
+      print(f'{i}')""")
 
+      self.assertEqual(expected, result.code)
+      self.assertEqual(False, result.has_turtle)
 
-  def test_quote_in_if(self):
-    code = textwrap.dedent("""\
-    if eten is 'pizza'
-      print 'lekker'""")
-
-    result = hedy.transpile(code, self.level)
-
-    expected = textwrap.dedent("""\
-    if str('eten') == str('pizza'):
-      print(f'lekker')""")
-
-    self.multi_level_tester(
-      code=code,
-      expected=expected,
-      test_name=self.name()
-    )
-
-
-# (so this should fail, for now)
-# at one point we want a real "Indent" error and a better error message
-# for this!
-
-# def test_level_7_no_indentation(self):
-#   #test that we get a parse error here
-#   code = textwrap.dedent("""\
-#   antwoord is ask Hoeveel is 10 keer tien?
-#   if antwoord is 100
-#   print 'goed zo'
-#   else
-#   print 'bah slecht'""")
-#
-#   with self.assertRaises(Exception) as context:
-#     result = hedy.transpile(code, self.level)
-#   self.assertEqual(str(context.exception), 'Parse')
+      expected_output = textwrap.dedent("""\
+      me wants a cookie!
+      me wants a cookie!
+      me wants a cookie!
+      me wants a cookie!
+      me wants a cookie!
+      hallo!""")
 
+      self.assertEqual(expected_output, HedyTester.run_code(result))
\ No newline at end of file
diff --git a/tests/test_level_08.py b/tests/test_level_08.py
--- a/tests/test_level_08.py
+++ b/tests/test_level_08.py
@@ -55,89 +55,169 @@ def test_repeat_with_variable_print(self):
     me wants a cookie!""")
 
     self.assertEqual(expected_output, HedyTester.run_code(result))
-
-  # neesting
-
-  def test_issue_902(self):
+  def test_repeat_with_non_latin_variable_print(self):
     code = textwrap.dedent("""\
-    print 'kassabon'
-    prijs is 0
-    repeat 7 times
-      ingredient is ask 'wat wil je kopen?'
-      if ingredient is appel
-        prijs is prijs + 1
-    print 'Dat is in totaal ' prijs ' euro.'""")
+    állatok is 5
+    repeat állatok times
+        print 'me wants a cookie!'""")
 
     result = hedy.transpile(code, self.level)
 
     expected = textwrap.dedent("""\
-    print(f'kassabon')
-    prijs = '0'
-    for i in range(int(7)):
-      ingredient = input('wat wil je kopen?')
-      if str(ingredient) == str('appel'):
-        prijs = int(prijs) + int(1)
-    print(f'Dat is in totaal {prijs} euro.')""")
+    v79de0191e90551f058d466c5e8c267ff = '5'
+    for i in range(int(v79de0191e90551f058d466c5e8c267ff)):
+      print(f'me wants a cookie!')""")
+
     self.assertEqual(expected, result.code)
 
-  def test_repeat_nested_in_if(self):
+    expected_output = textwrap.dedent("""\
+    me wants a cookie!
+    me wants a cookie!
+    me wants a cookie!
+    me wants a cookie!
+    me wants a cookie!""")
+
+    self.assertEqual(expected_output, HedyTester.run_code(result))
+  def test_if_else(self):
     code = textwrap.dedent("""\
-    kleur is groen
-    if kleur is groen
-        repeat 3 times
-            print 'mooi'""")
+    antwoord is ask 'Hoeveel is 10 plus 10?'
+    if antwoord is 20
+        print 'Goedzo!'
+        print 'Het antwoord was inderdaad ' antwoord
+    else
+        print 'Foutje'
+        print 'Het antwoord moest zijn ' antwoord""")
 
     result = hedy.transpile(code, self.level)
 
     expected = textwrap.dedent("""\
-    kleur = 'groen'
-    if str(kleur) == str('groen'):
-      for i in range(int(3)):
-        print(f'mooi')""")
+    antwoord = input('Hoeveel is 10 plus 10?')
+    if str(antwoord) == str('20'):
+      print(f'Goedzo!')
+      print(f'Het antwoord was inderdaad {antwoord}')
+    else:
+      print(f'Foutje')
+      print(f'Het antwoord moest zijn {antwoord}')""")
 
     self.assertEqual(expected, result.code)
-
-  def test_issue_396(self):
+  def test_repeat_basic_print(self):
     code = textwrap.dedent("""\
     repeat 5 times
-        if antwoord2 is 10
-            print 'Goedzo'
-        else
-            print 'lalala'""")
+      print 'me wants a cookie!'""")
 
     result = hedy.transpile(code, self.level)
 
     expected = textwrap.dedent("""\
     for i in range(int(5)):
-      if str('antwoord2') == str('10'):
-        print(f'Goedzo')
-      else:
-        print(f'lalala')""")
+      print(f'me wants a cookie!')""")
 
     self.assertEqual(expected, result.code)
 
-  def test_empty_line_with_whitespace(self):
+    expected_output = textwrap.dedent("""\
+    me wants a cookie!
+    me wants a cookie!
+    me wants a cookie!
+    me wants a cookie!
+    me wants a cookie!""")
+
+    self.assertEqual(expected_output, HedyTester.run_code(result))
+  def test_allow_space_after_else_line(self):
+    #todo should work up to 11??
+    code = textwrap.dedent("""\
+    a is 1
+    if a is 1
+      print a
+    else
+      print 'nee'""")
+
+    expected = textwrap.dedent("""\
+    a = '1'
+    if str(a) == str('1'):
+      print(f'{a}')
+    else:
+      print(f'nee')""")
+
+    self.multi_level_tester(
+      max_level=9,
+      code=code,
+      expected=expected,
+      test_name=self.name()
+    )
+
+  def test_issue_297(self):
     code = textwrap.dedent("""\
-    repeat 3 times
-      food is ask 'What do you want?'
-      if food is 'pizza'
-        print 'nice!'
-         
-      else
-        print 'pizza is better'""")
+    count is 1
+    repeat 12 times
+      print count ' times 12 is ' count*12
+      count is count + 1""")
 
     result = hedy.transpile(code, self.level)
 
     expected = textwrap.dedent("""\
-    for i in range(int(3)):
-      food = input('What do you want?')
-      if str(food) == str('pizza'):
-        print(f'nice!')
-      else:
-        print(f'pizza is better')""")
+    count = '1'
+    for i in range(int(12)):
+      print(f'{count} times 12 is {int(count) * int(12)}')
+      count = int(count) + int(1)""")
 
     self.assertEqual(expected, result.code)
 
+  # negative tests
+
+  def test_issue_902(self):
+    code = textwrap.dedent("""\
+    print 'kassabon'
+    prijs is 0
+    repeat 7 times
+        ingredient is ask 'wat wil je kopen?'
+        if ingredient is appel
+            prijs is prijs + 1
+    print 'Dat is in totaal ' prijs ' euro.'""")
+
+    with self.assertRaises(hedy.exceptions.LockedLanguageFeatureException) as context:
+      result = hedy.transpile(code, self.level)
+  def test_repeat_nested_in_if(self):
+    code = textwrap.dedent("""\
+    kleur is groen
+    if kleur is groen
+        repeat 3 times
+            print 'mooi'""")
+
+    with self.assertRaises(hedy.exceptions.LockedLanguageFeatureException) as context:
+      result = hedy.transpile(code, self.level)
 
 
+  def test_quote_in_if(self):
+    code = textwrap.dedent("""\
+    if eten is 'pizza'
+      print 'lekker'""")
+
+    result = hedy.transpile(code, self.level)
+
+    expected = textwrap.dedent("""\
+    if str('eten') == str('pizza'):
+      print(f'lekker')""")
+
+    self.multi_level_tester(
+      code=code,
+      expected=expected,
+      test_name=self.name()
+    )
+
+
+# (so this should fail, for now)
+# at one point we want a real "Indent" error and a better error message
+# for this!
+
+# def test_level_7_no_indentation(self):
+#   #test that we get a parse error here
+#   code = textwrap.dedent("""\
+#   antwoord is ask Hoeveel is 10 keer tien?
+#   if antwoord is 100
+#   print 'goed zo'
+#   else
+#   print 'bah slecht'""")
+#
+#   with self.assertRaises(Exception) as context:
+#     result = hedy.transpile(code, self.level)
+#   self.assertEqual(str(context.exception), 'Parse')
 
diff --git a/tests/test_level_09.py b/tests/test_level_09.py
--- a/tests/test_level_09.py
+++ b/tests/test_level_09.py
@@ -4,52 +4,140 @@
 
 class TestsLevel9(HedyTester):
   level = 9
-  
-  def test_for_list(self):
+
+  def test_if_with_indent(self):
+    # todo should be tested for all levels!
+    code = textwrap.dedent("""\
+    naam is Hedy
+    if naam is Hedy
+        print 'koekoek'""")
+
+    result = hedy.transpile(code, self.level)
+
+    expected = textwrap.dedent("""\
+    naam = 'Hedy'
+    if str(naam) == str('Hedy'):
+      print(f'koekoek')""")
+
+    self.assertEqual(expected, result.code)
+  def test_repeat_with_indent(self):
+    code = textwrap.dedent("""\
+    repeat 5 times
+      print 'koekoek'""")
+
+    result = hedy.transpile(code, self.level)
+
+    expected = textwrap.dedent("""\
+    for i in range(int(5)):
+      print(f'koekoek')""")
+
+    self.assertEqual(expected, result.code)
+  def test_repeat_with_variable_print(self):
+    code = textwrap.dedent("""\
+    n is 5
+    repeat n times
+        print 'me wants a cookie!'""")
+
+    result = hedy.transpile(code, self.level)
+
+    expected = textwrap.dedent("""\
+    n = '5'
+    for i in range(int(n)):
+      print(f'me wants a cookie!')""")
+
+    self.assertEqual(expected, result.code)
+
+    expected_output = textwrap.dedent("""\
+    me wants a cookie!
+    me wants a cookie!
+    me wants a cookie!
+    me wants a cookie!
+    me wants a cookie!""")
+
+    self.assertEqual(expected_output, HedyTester.run_code(result))
+
+  # neesting
+
+  def test_issue_902(self):
+    code = textwrap.dedent("""\
+    print 'kassabon'
+    prijs is 0
+    repeat 7 times
+      ingredient is ask 'wat wil je kopen?'
+      if ingredient is appel
+        prijs is prijs + 1
+    print 'Dat is in totaal ' prijs ' euro.'""")
+
+    result = hedy.transpile(code, self.level)
+
+    expected = textwrap.dedent("""\
+    print(f'kassabon')
+    prijs = '0'
+    for i in range(int(7)):
+      ingredient = input('wat wil je kopen?')
+      if str(ingredient) == str('appel'):
+        prijs = int(prijs) + int(1)
+    print(f'Dat is in totaal {prijs} euro.')""")
+    self.assertEqual(expected, result.code)
+
+  def test_repeat_nested_in_if(self):
     code = textwrap.dedent("""\
-    dieren is hond, kat, papegaai
-    for dier in dieren
-      print dier""")
+    kleur is groen
+    if kleur is groen
+        repeat 3 times
+            print 'mooi'""")
 
     result = hedy.transpile(code, self.level)
 
     expected = textwrap.dedent("""\
-    dieren = ['hond', 'kat', 'papegaai']
-    for dier in dieren:
-      print(f'{dier}')""")
+    kleur = 'groen'
+    if str(kleur) == str('groen'):
+      for i in range(int(3)):
+        print(f'mooi')""")
 
     self.assertEqual(expected, result.code)
-  def test_for_list_multiple_lines(self):
+
+  def test_issue_396(self):
     code = textwrap.dedent("""\
-    familie is baby, mommy, daddy, grandpa, grandma
-    for shark in familie
-      print shark ' shark tudutudutudu'
-      print shark ' shark tudutudutudu'
-      print shark ' shark tudutudutudu'
-      print shark ' shark'""")
+    repeat 5 times
+        if antwoord2 is 10
+            print 'Goedzo'
+        else
+            print 'lalala'""")
 
     result = hedy.transpile(code, self.level)
 
     expected = textwrap.dedent("""\
-    familie = ['baby', 'mommy', 'daddy', 'grandpa', 'grandma']
-    for shark in familie:
-      print(f'{shark} shark tudutudutudu')
-      print(f'{shark} shark tudutudutudu')
-      print(f'{shark} shark tudutudutudu')
-      print(f'{shark} shark')""")
+    for i in range(int(5)):
+      if str('antwoord2') == str('10'):
+        print(f'Goedzo')
+      else:
+        print(f'lalala')""")
 
     self.assertEqual(expected, result.code)
-  def test_for_list_dutch(self):
+
+  def test_empty_line_with_whitespace(self):
     code = textwrap.dedent("""\
-    dieren is hond, kat, papegaai
-    voor dier in dieren
-      drukaf dier""")
+    repeat 3 times
+      food is ask 'What do you want?'
+      if food is 'pizza'
+        print 'nice!'
+         
+      else
+        print 'pizza is better'""")
 
-    result = hedy.transpile(code, self.level, lang="nl")
+    result = hedy.transpile(code, self.level)
 
     expected = textwrap.dedent("""\
-    dieren = ['hond', 'kat', 'papegaai']
-    for dier in dieren:
-      print(f'{dier}')""")
+    for i in range(int(3)):
+      food = input('What do you want?')
+      if str(food) == str('pizza'):
+        print(f'nice!')
+      else:
+        print(f'pizza is better')""")
 
     self.assertEqual(expected, result.code)
+
+
+
+
diff --git a/tests/test_level_10.py b/tests/test_level_10.py
--- a/tests/test_level_10.py
+++ b/tests/test_level_10.py
@@ -4,214 +4,52 @@
 
 class TestsLevel10(HedyTester):
   level = 10
-
-  def test_if_with_indent(self):
-    code = textwrap.dedent("""\
-    naam is Hedy
-    if naam is Hedy
-        print 'koekoek'""")
-    expected = textwrap.dedent("""\
-    naam = 'Hedy'
-    if str(naam) == str('Hedy'):
-      print(f'koekoek')""")
-    result = hedy.transpile(code, self.level)
-
-    self.assertEqual(expected, result.code)
-    self.assertEqual(False, result.has_turtle)
-
-  def test_if_else(self):
+  
+  def test_for_list(self):
     code = textwrap.dedent("""\
-    antwoord is ask 'Hoeveel is 10 plus 10?'
-    if antwoord is 20
-        print 'Goedzo!'
-        print 'Het antwoord was inderdaad ' antwoord
-    else
-        print 'Foutje'
-        print 'Het antwoord moest zijn ' antwoord""")
-
-    expected = textwrap.dedent("""\
-    antwoord = input('Hoeveel is 10 plus 10?')
-    if str(antwoord) == str('20'):
-      print(f'Goedzo!')
-      print(f'Het antwoord was inderdaad {antwoord}')
-    else:
-      print(f'Foutje')
-      print(f'Het antwoord moest zijn {antwoord}')""")
+    dieren is hond, kat, papegaai
+    for dier in dieren
+      print dier""")
 
     result = hedy.transpile(code, self.level)
 
-    self.assertEqual(expected, result.code)
-    self.assertEqual(False, result.has_turtle)
-
-
-
-  def test_for_loop(self):
-    code = textwrap.dedent("""\
-    a is 2
-    a is 3
-    for a in range 2 to 4
-      a is a + 2
-      b is b + 2""")
     expected = textwrap.dedent("""\
-    a = '2'
-    a = '3'
-    step = 1 if int(2) < int(4) else -1
-    for a in range(int(2), int(4) + step, step):
-      a = int(a) + int(2)
-      b = int(b) + int(2)""")
-
-    result = hedy.transpile(code, self.level)
+    dieren = ['hond', 'kat', 'papegaai']
+    for dier in dieren:
+      print(f'{dier}')""")
 
     self.assertEqual(expected, result.code)
-    self.assertEqual(False, result.has_turtle)
-
-  def test_if__else(self):
+  def test_for_list_multiple_lines(self):
     code = textwrap.dedent("""\
-    a is 5
-    if a is 1
-      x is 2
-    else
-      x is 222""")
-    expected = textwrap.dedent("""\
-    a = '5'
-    if str(a) == str('1'):
-      x = '2'
-    else:
-      x = '222'""")
+    familie is baby, mommy, daddy, grandpa, grandma
+    for shark in familie
+      print shark ' shark tudutudutudu'
+      print shark ' shark tudutudutudu'
+      print shark ' shark tudutudutudu'
+      print shark ' shark'""")
 
     result = hedy.transpile(code, self.level)
 
-    self.assertEqual(expected, result.code)
-    self.assertEqual(False, result.has_turtle)
-
-  def test_forloop(self):
-    code = textwrap.dedent("""\
-    for i in range 1 to 10
-      print i
-    print 'wie niet weg is is gezien'""")
     expected = textwrap.dedent("""\
-    step = 1 if int(1) < int(10) else -1
-    for i in range(int(1), int(10) + step, step):
-      print(f'{i}')
-    print(f'wie niet weg is is gezien')""")
-
-    result = hedy.transpile(code, self.level)
+    familie = ['baby', 'mommy', 'daddy', 'grandpa', 'grandma']
+    for shark in familie:
+      print(f'{shark} shark tudutudutudu')
+      print(f'{shark} shark tudutudutudu')
+      print(f'{shark} shark tudutudutudu')
+      print(f'{shark} shark')""")
 
     self.assertEqual(expected, result.code)
-    self.assertEqual(False, result.has_turtle)
-
-
-  def test_reverse_range(self):
+  def test_for_list_dutch(self):
     code = textwrap.dedent("""\
-    for i in range 10 to 1
-      print i
-    print 'wie niet weg is is gezien'""")
-    expected = textwrap.dedent("""\
-    step = 1 if int(10) < int(1) else -1
-    for i in range(int(10), int(1) + step, step):
-      print(f'{i}')
-    print(f'wie niet weg is is gezien')""")
-
-    result = hedy.transpile(code, self.level)
+    dieren is hond, kat, papegaai
+    voor dier in dieren
+      drukaf dier""")
 
-    self.assertEqual(expected, result.code)
-    self.assertEqual(False, result.has_turtle)
-
-
-  def test_if_under_else_in_for(self):
-    code = textwrap.dedent("""\
-    for i in range 0 to 10
-      antwoord is ask 'Wat is 5*5'
-      if antwoord is 24
-        print 'Dat is fout!'
-      else
-        print 'Dat is goed!'
-      if antwoord is 25
-        i is 10""")
+    result = hedy.transpile(code, self.level, lang="nl")
 
     expected = textwrap.dedent("""\
-    step = 1 if int(0) < int(10) else -1
-    for i in range(int(0), int(10) + step, step):
-      antwoord = input('Wat is 5*5')
-      if str(antwoord) == str('24'):
-        print(f'Dat is fout!')
-      else:
-        print(f'Dat is goed!')
-      if str(antwoord) == str('25'):
-        i = '10'""")
-
-    result = hedy.transpile(code, self.level)
-
-    self.assertEqual(expected, result.code)
-    self.assertEqual(False, result.has_turtle)
-
-    #fails, issue 363
-
-  def test_for_ifbug(self):
-    code = textwrap.dedent("""\
-    for i in range 0 to 10
-      antwoord is ask 'Wat is 5*5'
-      if antwoord is 24
-        print 'fout'
-    print 'klaar met for loop'""")
-
-    expected = textwrap.dedent("""\
-      step = 1 if int(0) < int(10) else -1
-      for i in range(int(0), int(10) + step, step):
-        antwoord = input('Wat is 5*5')
-        if str(antwoord) == str('24'):
-          print(f'fout')
-      print(f'klaar met for loop')""")
-
-    result = hedy.transpile(code, self.level)
+    dieren = ['hond', 'kat', 'papegaai']
+    for dier in dieren:
+      print(f'{dier}')""")
 
     self.assertEqual(expected, result.code)
-    self.assertEqual(False, result.has_turtle)
-
-  def test_for_loopbug599(self):
-    code = textwrap.dedent("""\
-    for i in range 0 to 10
-      if i is 2
-        print '2'""")
-
-    expected = textwrap.dedent("""\
-      step = 1 if int(0) < int(10) else -1
-      for i in range(int(0), int(10) + step, step):
-        if str(i) == str('2'):
-          print(f'2')""")
-
-    result = hedy.transpile(code, self.level)
-
-    self.assertEqual(expected, result.code)
-    self.assertEqual(False, result.has_turtle)
-
-  def test_unindented_second_loop_1209(self):
-    code = textwrap.dedent("""\
-    for x in range 1 to 10
-     for y in range 1 to 10
-     print 'x*y'""")
-
-    with self.assertRaises(hedy.exceptions.NoIndentationException) as context:
-      result = hedy.transpile(code, self.level)
-
-  def test_dedented_second_loop_1209(self):
-    code = textwrap.dedent("""\
-    for x in range 1 to 10
-     for y in range 1 to 10
-    print 'x*y'""")
-
-    with self.assertRaises(hedy.exceptions.NoIndentationException) as context:
-      result = hedy.transpile(code, self.level)
-
-  def test_zigzag_indented_loop_1209(self):
-    code = textwrap.dedent("""\
-    for x in range 1 to 10
-      for y in range 1 to 10
-         print 'this number is'
-        print x*y""")
-
-    with self.assertRaises(hedy.exceptions.IndentationException) as context:
-      result = hedy.transpile(code, self.level)
-
-
-
diff --git a/tests/test_level_11.py b/tests/test_level_11.py
--- a/tests/test_level_11.py
+++ b/tests/test_level_11.py
@@ -1,4 +1,3 @@
-
 import hedy
 import textwrap
 from test_level_01 import HedyTester
@@ -6,406 +5,213 @@
 class TestsLevel11(HedyTester):
   level = 11
 
-  # ask tests
-  def test_ask_number_answer(self):
-    code = textwrap.dedent("""\
-            prijs is ask 'hoeveel?'
-            gespaard is 7
-            sparen is prijs - gespaard
-            print 'hallo' sparen""")
-    expected = textwrap.dedent("""\
-            prijs = input('hoeveel?')
-            try:
-              prijs = int(prijs)
-            except ValueError:
-              try:
-                prijs = float(prijs)
-              except ValueError:
-                pass
-            gespaard = 7
-            sparen = prijs - gespaard
-            print(f'hallo{sparen}')""")
-
-    self.multi_level_tester(
-      code=code,
-      expected=expected,
-      extra_check_function=self.is_not_turtle(),
-      test_name=self.name()
-    )
-
-  # new calculations
-  def test_int_addition_directly(self):
-    code = textwrap.dedent("""\
-            print 2 + 2""")
-    expected = textwrap.dedent("""\
-            print(f'{2 + 2}')""")
-
-    self.multi_level_tester(
-      code=code,
-      expected=expected,
-      extra_check_function=self.is_not_turtle(),
-      test_name=self.name()
-    )
-
-  def test_float_addition_directly(self):
+  def test_if_with_indent(self):
     code = textwrap.dedent("""\
-            print 2.5 + 2.5""")
-    expected = textwrap.dedent("""\
-            print(f'{2.5 + 2.5}')""")
-
-    self.multi_level_tester(
-      code=code,
-      expected=expected,
-      extra_check_function=self.is_not_turtle(),
-      test_name=self.name()
-    )
-
-  def test_float_addition_with_string(self):
-    code = textwrap.dedent("""\
-            print 'het antwoord is ' 2.5 + 2.5""")
+    naam is Hedy
+    if naam is Hedy
+        print 'koekoek'""")
     expected = textwrap.dedent("""\
-            print(f'het antwoord is {2.5 + 2.5}')""")
+    naam = 'Hedy'
+    if str(naam) == str('Hedy'):
+      print(f'koekoek')""")
+    result = hedy.transpile(code, self.level)
 
-    self.multi_level_tester(
-      code=code,
-      expected=expected,
-      extra_check_function=self.is_not_turtle(),
-      test_name=self.name()
-    )
+    self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
 
-  def test_float_addition_in_var(self):
+  def test_if_else(self):
     code = textwrap.dedent("""\
-            antwoord is 2.5 + 2.5
-            print antwoord
-            """)
-    expected = textwrap.dedent("""\
-            antwoord = 2.5 + 2.5
-            print(f'{antwoord}')""")
-
-    self.multi_level_tester(
-      code=code,
-      expected=expected,
-      extra_check_function=self.is_not_turtle(),
-      test_name=self.name()
-    )
+    antwoord is ask 'Hoeveel is 10 plus 10?'
+    if antwoord is 20
+        print 'Goedzo!'
+        print 'Het antwoord was inderdaad ' antwoord
+    else
+        print 'Foutje'
+        print 'Het antwoord moest zijn ' antwoord""")
 
-  def test_float_addition_with_var(self):
-    code = textwrap.dedent("""\
-            getal1 is 5
-            getal2 is 4.3
-            print 'dat is dan: ' getal1 + getal2
-            """)
     expected = textwrap.dedent("""\
-            getal1 = 5
-            getal2 = 4.3
-            print(f'dat is dan: {getal1 + getal2}')""")
-
-    self.multi_level_tester(
-      code=code,
-      expected=expected,
-      extra_check_function=self.is_not_turtle(),
-      test_name=self.name()
-    )
-
-  def test_store_calc_in_var(self):
-    code = textwrap.dedent("""\
-            a is 1
-            b is 2
-            c is a + b
-            print c ' is 3'""")
-    expected = textwrap.dedent("""\
-            a = 1
-            b = 2
-            c = a + b
-            print(f'{c} is 3')""")
-
-    self.multi_level_tester(
-      code=code,
-      expected=expected,
-      extra_check_function=self.is_not_turtle(),
-      test_name=self.name()
-    )
-
-  def test_add_string_vars(self):
-    code = textwrap.dedent("""\
-            getal1 is '5'
-            getal2 is '6'
-            print 'dat is dan: ' getal1 + getal2""")
-    expected = textwrap.dedent("""\
-            getal1 = '5'
-            getal2 = '6'
-            print(f'dat is dan: {getal1 + getal2}')""")
-
-    check_output = (lambda x: HedyTester.run_code(x) == 'dat is dan: 56')
+    antwoord = input('Hoeveel is 10 plus 10?')
+    if str(antwoord) == str('20'):
+      print(f'Goedzo!')
+      print(f'Het antwoord was inderdaad {antwoord}')
+    else:
+      print(f'Foutje')
+      print(f'Het antwoord moest zijn {antwoord}')""")
 
-    self.multi_level_tester(
-      code=code,
-      expected=expected,
-      extra_check_function=check_output,
-      test_name=self.name()
-    )
+    result = hedy.transpile(code, self.level)
 
-  def test_add_int_vars(self):
-    code = textwrap.dedent("""\
-            getal1 is 5
-            getal2 is 6
-            print 'dat is dan: ' getal1 + getal2""")
-    expected = textwrap.dedent("""\
-            getal1 = 5
-            getal2 = 6
-            print(f'dat is dan: {getal1 + getal2}')""")
+    self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
 
-    check_output = (lambda x: HedyTester.run_code(x) == 'dat is dan: 11')
 
-    self.multi_level_tester(
-      code=code,
-      expected=expected,
-      extra_check_function=check_output,
-      test_name=self.name()
-    )
 
-  def test_assign_string_with_quotes(self):
+  def test_for_loop(self):
     code = textwrap.dedent("""\
-            name is 'felienne'
-            print name""")
+    a is 2
+    a is 3
+    for a in range 2 to 4
+      a is a + 2
+      b is b + 2""")
     expected = textwrap.dedent("""\
-            name = 'felienne'
-            print(f'{name}')""")
-    self.multi_level_tester(
-      code=code,
-      expected=expected,
-      extra_check_function=self.is_not_turtle(),
-      test_name=self.name()
-    )
-
-  def test_assign_string_with_quotes_and_string_value(self):
-    code = textwrap.dedent("""\
-            name is 'felienne'
-            print 'hallo ' name""")
-    expected = textwrap.dedent("""\
-            name = 'felienne'
-            print(f'hallo {name}')""")
-    self.multi_level_tester(
-      code=code,
-      expected=expected,
-      extra_check_function=self.is_not_turtle(),
-      test_name=self.name()
-    )
-
-  def test_print_multiple_calcs(self):
-    code = textwrap.dedent("""\
-            name is 1 + 2 + 3
-            print name""")
+    a = '2'
+    a = '3'
+    step = 1 if int(2) < int(4) else -1
+    for a in range(int(2), int(4) + step, step):
+      a = int(a) + int(2)
+      b = int(b) + int(2)""")
 
-    expected = textwrap.dedent("""\
-            name = 1 + 2 + 3
-            print(f'{name}')""")
-
-    self.multi_level_tester(
-      code=code,
-      expected=expected,
-      extra_check_function=self.is_not_turtle(),
-      test_name=self.name()
-    )
-
-  def test_calc_string_and_int(self):
-    code = textwrap.dedent("""\
-            x is 'test1'
-            y is x + 1""")
-
-    self.multi_level_tester(
-      code=code,
-      exception=hedy.exceptions.InvalidArgumentTypeException,
-      test_name=self.name()
-    )
+    result = hedy.transpile(code, self.level)
 
-  def test_print_chained_assignments(self):
-    code = textwrap.dedent("""\
-            x is 1 + 2
-            y is x + 3
-            print y + 4""")
+    self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
 
-    expected = textwrap.dedent("""\
-            x = 1 + 2
-            y = x + 3
-            print(f'{y + 4}')""")
-
-    self.multi_level_tester(
-      code=code,
-      expected=expected,
-      extra_check_function=self.is_not_turtle(),
-      test_name=self.name()
-    )
-
-  def test_assign_calc(self):
+  def test_if__else(self):
     code = textwrap.dedent("""\
-            var is 5
-            print var + 5""")
-
+    a is 5
+    if a is 1
+      x is 2
+    else
+      x is 222""")
     expected = textwrap.dedent("""\
-            var = 5
-            print(f'{var + 5}')""")
-
-    self.multi_level_tester(
-      code=code,
-      expected=expected,
-      extra_check_function=self.is_not_turtle(),
-      test_name=self.name()
-    )
-
-  def test_access_variable_before_definition(self):
-    code = textwrap.dedent("""\
-            a is b
-            b is 3
-            print a""")
+    a = '5'
+    if str(a) == str('1'):
+      x = '2'
+    else:
+      x = '222'""")
 
-    expected = textwrap.dedent("""\
-            a = b
-            b = 3
-            print(f'{a}')""")
-
-    self.multi_level_tester(
-      code=code,
-      expected=expected,
-      extra_check_function=self.is_not_turtle(),
-      test_name=self.name()
-    )
-
-  def test_list_creation_with_spaces(self):
-    code = textwrap.dedent("""\
-    actions is 'clap your hands', 'stomp your feet', 'shout Hurray'
-    for action in actions
-        for i in range 1 to 2
-            print 'if youre happy and you know it'
-            print action
-        print 'if youre happy and you know it and you really want to show it'
-        print 'if youre happy and you know it'
-        print action""")
-    expected = textwrap.dedent("""\
-    actions = ['clap your hands', 'stomp your feet', 'shout Hurray']
-    for action in actions:
-      step = 1 if int(1) < int(2) else -1
-      for i in range(int(1), int(2) + step, step):
-        print(f'if youre happy and you know it')
-        print(f'{action}')
-      print(f'if youre happy and you know it and you really want to show it')
-      print(f'if youre happy and you know it')
-      print(f'{action}')""")
     result = hedy.transpile(code, self.level)
 
     self.assertEqual(expected, result.code)
     self.assertEqual(False, result.has_turtle)
 
-  def test_list_creation_with_numbers(self):
+  def test_forloop(self):
     code = textwrap.dedent("""\
-    getallen is 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
-    getal is getallen at random""")
+    for i in range 1 to 10
+      print i
+    print 'wie niet weg is is gezien'""")
     expected = textwrap.dedent("""\
-    getallen = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-    getal=random.choice(getallen)""")
+    step = 1 if int(1) < int(10) else -1
+    for i in range(int(1), int(10) + step, step):
+      print(f'{i}')
+    print(f'wie niet weg is is gezien')""")
+
     result = hedy.transpile(code, self.level)
 
     self.assertEqual(expected, result.code)
     self.assertEqual(False, result.has_turtle)
 
-  def test_if_quotes_in_condition(self):
+
+  def test_reverse_range(self):
     code = textwrap.dedent("""\
-    naam is 'Hedy'
-    if naam is 'Hedy'
-        print 'koekoek'""")
+    for i in range 10 to 1
+      print i
+    print 'wie niet weg is is gezien'""")
     expected = textwrap.dedent("""\
-    naam = 'Hedy'
-    if str(naam) == str('Hedy'):
-      print(f'koekoek')""")
+    step = 1 if int(10) < int(1) else -1
+    for i in range(int(10), int(1) + step, step):
+      print(f'{i}')
+    print(f'wie niet weg is is gezien')""")
+
     result = hedy.transpile(code, self.level)
 
     self.assertEqual(expected, result.code)
     self.assertEqual(False, result.has_turtle)
 
-  def test_if_quotes_and_spaces_in_condition(self):
+
+  def test_if_under_else_in_for(self):
     code = textwrap.dedent("""\
-    naam is 'Hedy is top'
-    if naam is 'Hedy is top'
-        print 'koekoek'""")
+    for i in range 0 to 10
+      antwoord is ask 'Wat is 5*5'
+      if antwoord is 24
+        print 'Dat is fout!'
+      else
+        print 'Dat is goed!'
+      if antwoord is 25
+        i is 10""")
+
     expected = textwrap.dedent("""\
-    naam = 'Hedy is top'
-    if str(naam) == str('Hedy is top'):
-      print(f'koekoek')""")
+    step = 1 if int(0) < int(10) else -1
+    for i in range(int(0), int(10) + step, step):
+      antwoord = input('Wat is 5*5')
+      if str(antwoord) == str('24'):
+        print(f'Dat is fout!')
+      else:
+        print(f'Dat is goed!')
+      if str(antwoord) == str('25'):
+        i = '10'""")
+
     result = hedy.transpile(code, self.level)
 
     self.assertEqual(expected, result.code)
     self.assertEqual(False, result.has_turtle)
 
-  def test_if_else_quotes_in_condition(self):
+    #fails, issue 363
+
+  def test_for_ifbug(self):
     code = textwrap.dedent("""\
-    naam is 'Hedy'
-    if naam is 'Hedy'
-        print 'koekoek'
-    else
-        print 'soepkip'""")
+    for i in range 0 to 10
+      antwoord is ask 'Wat is 5*5'
+      if antwoord is 24
+        print 'fout'
+    print 'klaar met for loop'""")
+
     expected = textwrap.dedent("""\
-    naam = 'Hedy'
-    if str(naam) == str('Hedy'):
-      print(f'koekoek')
-    else:
-      print(f'soepkip')""")
+      step = 1 if int(0) < int(10) else -1
+      for i in range(int(0), int(10) + step, step):
+        antwoord = input('Wat is 5*5')
+        if str(antwoord) == str('24'):
+          print(f'fout')
+      print(f'klaar met for loop')""")
+
     result = hedy.transpile(code, self.level)
 
     self.assertEqual(expected, result.code)
     self.assertEqual(False, result.has_turtle)
 
-  def test_if_else_no_quotes_for_num_in_condition(self):
+  def test_for_loopbug599(self):
     code = textwrap.dedent("""\
-    antwoord is ask 'Hoeveel is 10 plus 10?'
-    if antwoord is 20
-        print 'Goedzo!'
-        print 'Het antwoord was inderdaad ' antwoord
-    else
-        print 'Foutje'
-        print 'Het antwoord moest zijn ' antwoord""")
+    for i in range 0 to 10
+      if i is 2
+        print '2'""")
 
     expected = textwrap.dedent("""\
-    antwoord = input('Hoeveel is 10 plus 10?')
-    try:
-      antwoord = int(antwoord)
-    except ValueError:
-      try:
-        antwoord = float(antwoord)
-      except ValueError:
-        pass
-    if str(antwoord) == str('20'):
-      print(f'Goedzo!')
-      print(f'Het antwoord was inderdaad {antwoord}')
-    else:
-      print(f'Foutje')
-      print(f'Het antwoord moest zijn {antwoord}')""")
+      step = 1 if int(0) < int(10) else -1
+      for i in range(int(0), int(10) + step, step):
+        if str(i) == str('2'):
+          print(f'2')""")
 
     result = hedy.transpile(code, self.level)
 
     self.assertEqual(expected, result.code)
     self.assertEqual(False, result.has_turtle)
 
+  def test_unindented_second_loop_1209(self):
+    code = textwrap.dedent("""\
+    for x in range 1 to 10
+     for y in range 1 to 10
+     print 'x*y'""")
+
+    with self.assertRaises(hedy.exceptions.NoIndentationException) as context:
+      result = hedy.transpile(code, self.level)
 
-  # negative tests
-  def test_assign_string_without_quotes(self):
+  def test_dedented_second_loop_1209(self):
     code = textwrap.dedent("""\
-            name is felienne
-            print name""")
-
-    self.multi_level_tester(
-      code=code,
-      exception=hedy.exceptions.UnquotedAssignTextException,
-      test_name=self.name()
-    )
-  
-  def test_list_creation(self):
+    for x in range 1 to 10
+     for y in range 1 to 10
+    print 'x*y'""")
+
+    with self.assertRaises(hedy.exceptions.NoIndentationException) as context:
+      result = hedy.transpile(code, self.level)
+
+  def test_zigzag_indented_loop_1209(self):
     code = textwrap.dedent("""\
-    animals is 'duck', 'dog', 'penguin'""")
-    expected = textwrap.dedent("""\
-    animals = ['duck', 'dog', 'penguin']""")
-    result = hedy.transpile(code, self.level)
+    for x in range 1 to 10
+      for y in range 1 to 10
+         print 'this number is'
+        print x*y""")
+
+    with self.assertRaises(hedy.exceptions.IndentationException) as context:
+      result = hedy.transpile(code, self.level)
 
-    self.assertEqual(expected, result.code)
-    self.assertEqual(False, result.has_turtle)
 
 
diff --git a/tests/test_level_12.py b/tests/test_level_12.py
--- a/tests/test_level_12.py
+++ b/tests/test_level_12.py
@@ -6,31 +6,65 @@
 class TestsLevel12(HedyTester):
   level = 12
 
-  def test_and(self):
+  # ask tests
+  def test_ask_number_answer(self):
     code = textwrap.dedent("""\
-      naam is ask 'hoe heet jij?'
-      leeftijd is ask 'hoe oud ben jij?'
-      if naam is 'Felienne' and leeftijd is 37
-          print 'hallo jij!'""")
+            prijs is ask 'hoeveel?'
+            gespaard is 7
+            sparen is prijs - gespaard
+            print 'hallo' sparen""")
     expected = textwrap.dedent("""\
-      naam = input('hoe heet jij?')
-      try:
-        naam = int(naam)
-      except ValueError:
-        try:
-          naam = float(naam)
-        except ValueError:
-          pass
-      leeftijd = input('hoe oud ben jij?')
-      try:
-        leeftijd = int(leeftijd)
-      except ValueError:
-        try:
-          leeftijd = float(leeftijd)
-        except ValueError:
-          pass
-      if str(naam) == str('Felienne') and str(leeftijd) == str('37'):
-        print(f'hallo jij!')""")
+            prijs = input('hoeveel?')
+            try:
+              prijs = int(prijs)
+            except ValueError:
+              try:
+                prijs = float(prijs)
+              except ValueError:
+                pass
+            gespaard = 7
+            sparen = prijs - gespaard
+            print(f'hallo{sparen}')""")
+
+    self.multi_level_tester(
+      code=code,
+      expected=expected,
+      extra_check_function=self.is_not_turtle(),
+      test_name=self.name()
+    )
+
+  # new calculations
+  def test_int_addition_directly(self):
+    code = textwrap.dedent("""\
+            print 2 + 2""")
+    expected = textwrap.dedent("""\
+            print(f'{2 + 2}')""")
+
+    self.multi_level_tester(
+      code=code,
+      expected=expected,
+      extra_check_function=self.is_not_turtle(),
+      test_name=self.name()
+    )
+
+  def test_float_addition_directly(self):
+    code = textwrap.dedent("""\
+            print 2.5 + 2.5""")
+    expected = textwrap.dedent("""\
+            print(f'{2.5 + 2.5}')""")
+
+    self.multi_level_tester(
+      code=code,
+      expected=expected,
+      extra_check_function=self.is_not_turtle(),
+      test_name=self.name()
+    )
+
+  def test_float_addition_with_string(self):
+    code = textwrap.dedent("""\
+            print 'het antwoord is ' 2.5 + 2.5""")
+    expected = textwrap.dedent("""\
+            print(f'het antwoord is {2.5 + 2.5}')""")
 
     self.multi_level_tester(
       code=code,
@@ -39,13 +73,14 @@ def test_and(self):
       test_name=self.name()
     )
 
-  def test_or(self):
+  def test_float_addition_in_var(self):
     code = textwrap.dedent("""\
-      if 5 is 5 or 4 is 4
-          print 'hallo'""")
+            antwoord is 2.5 + 2.5
+            print antwoord
+            """)
     expected = textwrap.dedent("""\
-      if str('5') == str('5') or str('4') == str('4'):
-        print(f'hallo')""")
+            antwoord = 2.5 + 2.5
+            print(f'{antwoord}')""")
 
     self.multi_level_tester(
       code=code,
@@ -54,5 +89,323 @@ def test_or(self):
       test_name=self.name()
     )
 
+  def test_float_addition_with_var(self):
+    code = textwrap.dedent("""\
+            getal1 is 5
+            getal2 is 4.3
+            print 'dat is dan: ' getal1 + getal2
+            """)
+    expected = textwrap.dedent("""\
+            getal1 = 5
+            getal2 = 4.3
+            print(f'dat is dan: {getal1 + getal2}')""")
+
+    self.multi_level_tester(
+      code=code,
+      expected=expected,
+      extra_check_function=self.is_not_turtle(),
+      test_name=self.name()
+    )
+
+  def test_store_calc_in_var(self):
+    code = textwrap.dedent("""\
+            a is 1
+            b is 2
+            c is a + b
+            print c ' is 3'""")
+    expected = textwrap.dedent("""\
+            a = 1
+            b = 2
+            c = a + b
+            print(f'{c} is 3')""")
+
+    self.multi_level_tester(
+      code=code,
+      expected=expected,
+      extra_check_function=self.is_not_turtle(),
+      test_name=self.name()
+    )
+
+  def test_add_string_vars(self):
+    code = textwrap.dedent("""\
+            getal1 is '5'
+            getal2 is '6'
+            print 'dat is dan: ' getal1 + getal2""")
+    expected = textwrap.dedent("""\
+            getal1 = '5'
+            getal2 = '6'
+            print(f'dat is dan: {getal1 + getal2}')""")
+
+    check_output = (lambda x: HedyTester.run_code(x) == 'dat is dan: 56')
+
+    self.multi_level_tester(
+      code=code,
+      expected=expected,
+      extra_check_function=check_output,
+      test_name=self.name()
+    )
+
+  def test_add_int_vars(self):
+    code = textwrap.dedent("""\
+            getal1 is 5
+            getal2 is 6
+            print 'dat is dan: ' getal1 + getal2""")
+    expected = textwrap.dedent("""\
+            getal1 = 5
+            getal2 = 6
+            print(f'dat is dan: {getal1 + getal2}')""")
+
+    check_output = (lambda x: HedyTester.run_code(x) == 'dat is dan: 11')
+
+    self.multi_level_tester(
+      code=code,
+      expected=expected,
+      extra_check_function=check_output,
+      test_name=self.name()
+    )
+
+  def test_assign_string_with_quotes(self):
+    code = textwrap.dedent("""\
+            name is 'felienne'
+            print name""")
+    expected = textwrap.dedent("""\
+            name = 'felienne'
+            print(f'{name}')""")
+    self.multi_level_tester(
+      code=code,
+      expected=expected,
+      extra_check_function=self.is_not_turtle(),
+      test_name=self.name()
+    )
+
+  def test_assign_string_with_quotes_and_string_value(self):
+    code = textwrap.dedent("""\
+            name is 'felienne'
+            print 'hallo ' name""")
+    expected = textwrap.dedent("""\
+            name = 'felienne'
+            print(f'hallo {name}')""")
+    self.multi_level_tester(
+      code=code,
+      expected=expected,
+      extra_check_function=self.is_not_turtle(),
+      test_name=self.name()
+    )
+
+  def test_print_multiple_calcs(self):
+    code = textwrap.dedent("""\
+            name is 1 + 2 + 3
+            print name""")
+
+    expected = textwrap.dedent("""\
+            name = 1 + 2 + 3
+            print(f'{name}')""")
+
+    self.multi_level_tester(
+      code=code,
+      expected=expected,
+      extra_check_function=self.is_not_turtle(),
+      test_name=self.name()
+    )
+
+  def test_calc_string_and_int(self):
+    code = textwrap.dedent("""\
+            x is 'test1'
+            y is x + 1""")
+
+    self.multi_level_tester(
+      code=code,
+      exception=hedy.exceptions.InvalidArgumentTypeException,
+      test_name=self.name()
+    )
+
+  def test_print_chained_assignments(self):
+    code = textwrap.dedent("""\
+            x is 1 + 2
+            y is x + 3
+            print y + 4""")
+
+    expected = textwrap.dedent("""\
+            x = 1 + 2
+            y = x + 3
+            print(f'{y + 4}')""")
+
+    self.multi_level_tester(
+      code=code,
+      expected=expected,
+      extra_check_function=self.is_not_turtle(),
+      test_name=self.name()
+    )
+
+  def test_assign_calc(self):
+    code = textwrap.dedent("""\
+            var is 5
+            print var + 5""")
+
+    expected = textwrap.dedent("""\
+            var = 5
+            print(f'{var + 5}')""")
+
+    self.multi_level_tester(
+      code=code,
+      expected=expected,
+      extra_check_function=self.is_not_turtle(),
+      test_name=self.name()
+    )
+
+  def test_access_variable_before_definition(self):
+    code = textwrap.dedent("""\
+            a is b
+            b is 3
+            print a""")
+
+    expected = textwrap.dedent("""\
+            a = b
+            b = 3
+            print(f'{a}')""")
+
+    self.multi_level_tester(
+      code=code,
+      expected=expected,
+      extra_check_function=self.is_not_turtle(),
+      test_name=self.name()
+    )
+
+  def test_list_creation_with_spaces(self):
+    code = textwrap.dedent("""\
+    actions is 'clap your hands', 'stomp your feet', 'shout Hurray'
+    for action in actions
+        for i in range 1 to 2
+            print 'if youre happy and you know it'
+            print action
+        print 'if youre happy and you know it and you really want to show it'
+        print 'if youre happy and you know it'
+        print action""")
+    expected = textwrap.dedent("""\
+    actions = ['clap your hands', 'stomp your feet', 'shout Hurray']
+    for action in actions:
+      step = 1 if int(1) < int(2) else -1
+      for i in range(int(1), int(2) + step, step):
+        print(f'if youre happy and you know it')
+        print(f'{action}')
+      print(f'if youre happy and you know it and you really want to show it')
+      print(f'if youre happy and you know it')
+      print(f'{action}')""")
+    result = hedy.transpile(code, self.level)
+
+    self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
+
+  def test_list_creation_with_numbers(self):
+    code = textwrap.dedent("""\
+    getallen is 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
+    getal is getallen at random""")
+    expected = textwrap.dedent("""\
+    getallen = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+    getal=random.choice(getallen)""")
+    result = hedy.transpile(code, self.level)
+
+    self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
+
+  def test_if_quotes_in_condition(self):
+    code = textwrap.dedent("""\
+    naam is 'Hedy'
+    if naam is 'Hedy'
+        print 'koekoek'""")
+    expected = textwrap.dedent("""\
+    naam = 'Hedy'
+    if str(naam) == str('Hedy'):
+      print(f'koekoek')""")
+    result = hedy.transpile(code, self.level)
+
+    self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
+
+  def test_if_quotes_and_spaces_in_condition(self):
+    code = textwrap.dedent("""\
+    naam is 'Hedy is top'
+    if naam is 'Hedy is top'
+        print 'koekoek'""")
+    expected = textwrap.dedent("""\
+    naam = 'Hedy is top'
+    if str(naam) == str('Hedy is top'):
+      print(f'koekoek')""")
+    result = hedy.transpile(code, self.level)
+
+    self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
+
+  def test_if_else_quotes_in_condition(self):
+    code = textwrap.dedent("""\
+    naam is 'Hedy'
+    if naam is 'Hedy'
+        print 'koekoek'
+    else
+        print 'soepkip'""")
+    expected = textwrap.dedent("""\
+    naam = 'Hedy'
+    if str(naam) == str('Hedy'):
+      print(f'koekoek')
+    else:
+      print(f'soepkip')""")
+    result = hedy.transpile(code, self.level)
+
+    self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
+
+  def test_if_else_no_quotes_for_num_in_condition(self):
+    code = textwrap.dedent("""\
+    antwoord is ask 'Hoeveel is 10 plus 10?'
+    if antwoord is 20
+        print 'Goedzo!'
+        print 'Het antwoord was inderdaad ' antwoord
+    else
+        print 'Foutje'
+        print 'Het antwoord moest zijn ' antwoord""")
+
+    expected = textwrap.dedent("""\
+    antwoord = input('Hoeveel is 10 plus 10?')
+    try:
+      antwoord = int(antwoord)
+    except ValueError:
+      try:
+        antwoord = float(antwoord)
+      except ValueError:
+        pass
+    if str(antwoord) == str('20'):
+      print(f'Goedzo!')
+      print(f'Het antwoord was inderdaad {antwoord}')
+    else:
+      print(f'Foutje')
+      print(f'Het antwoord moest zijn {antwoord}')""")
+
+    result = hedy.transpile(code, self.level)
+
+    self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
+
+
+  # negative tests
+  def test_assign_string_without_quotes(self):
+    code = textwrap.dedent("""\
+            name is felienne
+            print name""")
+
+    self.multi_level_tester(
+      code=code,
+      exception=hedy.exceptions.UnquotedAssignTextException,
+      test_name=self.name()
+    )
+  
+  def test_list_creation(self):
+    code = textwrap.dedent("""\
+    animals is 'duck', 'dog', 'penguin'""")
+    expected = textwrap.dedent("""\
+    animals = ['duck', 'dog', 'penguin']""")
+    result = hedy.transpile(code, self.level)
+
+    self.assertEqual(expected, result.code)
+    self.assertEqual(False, result.has_turtle)
 
 
diff --git a/tests/test_level_13.py b/tests/test_level_13.py
--- a/tests/test_level_13.py
+++ b/tests/test_level_13.py
@@ -1,3 +1,4 @@
+
 import hedy
 import textwrap
 from test_level_01 import HedyTester
@@ -5,36 +6,22 @@
 class TestsLevel13(HedyTester):
   level = 13
 
-  def tests_smaller(self):
+  def test_and(self):
     code = textwrap.dedent("""\
-      leeftijd is ask 'Hoe oud ben jij?'
-      if leeftijd < 12
-          print 'Dan ben je jonger dan ik!'""")
+      naam is ask 'hoe heet jij?'
+      leeftijd is ask 'hoe oud ben jij?'
+      if naam is 'Felienne' and leeftijd is 37
+          print 'hallo jij!'""")
     expected = textwrap.dedent("""\
-      leeftijd = input('Hoe oud ben jij?')
+      naam = input('hoe heet jij?')
       try:
-        leeftijd = int(leeftijd)
+        naam = int(naam)
       except ValueError:
         try:
-          leeftijd = float(leeftijd)
+          naam = float(naam)
         except ValueError:
           pass
-      if str(leeftijd).zfill(100)<str(12).zfill(100):
-        print(f'Dan ben je jonger dan ik!')""")
-
-    self.multi_level_tester(
-      code=code,
-      expected=expected,
-      extra_check_function=self.is_not_turtle(),
-      test_name=self.name()
-    )
-  def tests_bigger(self):
-    code = textwrap.dedent("""\
-      leeftijd is ask 'Hoe oud ben jij?'
-      if leeftijd > 12
-          print 'Dan ben je ouder dan ik!'""")
-    expected = textwrap.dedent("""\
-      leeftijd = input('Hoe oud ben jij?')
+      leeftijd = input('hoe oud ben jij?')
       try:
         leeftijd = int(leeftijd)
       except ValueError:
@@ -42,8 +29,8 @@ def tests_bigger(self):
           leeftijd = float(leeftijd)
         except ValueError:
           pass
-      if str(leeftijd).zfill(100)>str(12).zfill(100):
-        print(f'Dan ben je ouder dan ik!')""")
+      if str(naam) == str('Felienne') and str(leeftijd) == str('37'):
+        print(f'hallo jij!')""")
 
     self.multi_level_tester(
       code=code,
@@ -51,78 +38,14 @@ def tests_bigger(self):
       extra_check_function=self.is_not_turtle(),
       test_name=self.name()
     )
-  def tests_smaller_else(self):
-    code = textwrap.dedent("""\
-      leeftijd is ask 'Hoe oud ben jij?'
-      if leeftijd < 12
-          print 'Dan ben je jonger dan ik!'
-      else
-          print 'Dan ben je ouder dan ik!'""")
-    expected = textwrap.dedent("""\
-      leeftijd = input('Hoe oud ben jij?')
-      try:
-        leeftijd = int(leeftijd)
-      except ValueError:
-        try:
-          leeftijd = float(leeftijd)
-        except ValueError:
-          pass
-      if str(leeftijd).zfill(100)<str(12).zfill(100):
-        print(f'Dan ben je jonger dan ik!')
-      else:
-        print(f'Dan ben je ouder dan ik!')""")
 
-    self.multi_level_tester(
-      code=code,
-      expected=expected,
-      extra_check_function=self.is_not_turtle(),
-      test_name=self.name()
-    )
-
-  def test_not_equal(self):
-      code = textwrap.dedent("""\
-        land is ask 'In welk land woon jij?'
-        if land != Nederland
-            print 'Cool!'
-        else
-            print 'Ik kom ook uit Nederland!'""")
-      expected = textwrap.dedent("""\
-        land = input('In welk land woon jij?')
-        try:
-          land = int(land)
-        except ValueError:
-          try:
-            land = float(land)
-          except ValueError:
-            pass
-        if str(land).zfill(100)!='Nederland'.zfill(100):
-          print(f'Cool!')
-        else:
-          print(f'Ik kom ook uit Nederland!')""")
-      self.multi_level_tester(
-
-        code=code,
-        expected=expected,
-        extra_check_function=self.is_not_turtle(),
-        test_name=self.name()
-      )
-
-  def tests_smaller_equal(self):
+  def test_or(self):
     code = textwrap.dedent("""\
-      leeftijd is ask 'Hoe oud ben jij?'
-      if leeftijd <= 12
-          print 'Dan ben je jonger dan ik!'""")
+      if 5 is 5 or 4 is 4
+          print 'hallo'""")
     expected = textwrap.dedent("""\
-      leeftijd = input('Hoe oud ben jij?')
-      try:
-        leeftijd = int(leeftijd)
-      except ValueError:
-        try:
-          leeftijd = float(leeftijd)
-        except ValueError:
-          pass
-      if str(leeftijd).zfill(100)<=str(12).zfill(100):
-        print(f'Dan ben je jonger dan ik!')""")
+      if str('5') == str('5') or str('4') == str('4'):
+        print(f'hallo')""")
 
     self.multi_level_tester(
       code=code,
@@ -130,53 +53,6 @@ def tests_smaller_equal(self):
       extra_check_function=self.is_not_turtle(),
       test_name=self.name()
     )
-  def tests_bigger_equal(self):
-    code = textwrap.dedent("""\
-      leeftijd is ask 'Hoe oud ben jij?'
-      if leeftijd >= 12
-          print 'Dan ben je ouder dan ik!'""")
-    expected = textwrap.dedent("""\
-      leeftijd = input('Hoe oud ben jij?')
-      try:
-        leeftijd = int(leeftijd)
-      except ValueError:
-        try:
-          leeftijd = float(leeftijd)
-        except ValueError:
-          pass
-      if str(leeftijd).zfill(100)>=str(12).zfill(100):
-        print(f'Dan ben je ouder dan ik!')""")
 
-    self.multi_level_tester(
-      code=code,
-      expected=expected,
-      extra_check_function=self.is_not_turtle(),
-      test_name=self.name()
-    )
-  def tests_smaller_equal_else(self):
-    code = textwrap.dedent("""\
-      leeftijd is ask 'Hoe oud ben jij?'
-      if leeftijd <= 12
-          print 'Dan ben je jonger dan ik!'
-      else
-          print 'Dan ben je ouder dan ik!'""")
-    expected = textwrap.dedent("""\
-      leeftijd = input('Hoe oud ben jij?')
-      try:
-        leeftijd = int(leeftijd)
-      except ValueError:
-        try:
-          leeftijd = float(leeftijd)
-        except ValueError:
-          pass
-      if str(leeftijd).zfill(100)<=str(12).zfill(100):
-        print(f'Dan ben je jonger dan ik!')
-      else:
-        print(f'Dan ben je ouder dan ik!')""")
 
-    self.multi_level_tester(
-      code=code,
-      expected=expected,
-      extra_check_function=self.is_not_turtle(),
-      test_name=self.name()
-    )
\ No newline at end of file
+
diff --git a/tests/test_level_14.py b/tests/test_level_14.py
--- a/tests/test_level_14.py
+++ b/tests/test_level_14.py
@@ -5,24 +5,22 @@
 class TestsLevel14(HedyTester):
   level = 14
 
-  def test_while_equals(self):
+  def tests_smaller(self):
     code = textwrap.dedent("""\
-      antwoord is 0
-      while antwoord != 25
-          antwoord is ask 'Wat is 5 keer 5?'
-      print 'Goed gedaan!'""")
+      leeftijd is ask 'Hoe oud ben jij?'
+      if leeftijd < 12
+          print 'Dan ben je jonger dan ik!'""")
     expected = textwrap.dedent("""\
-    antwoord = 0
-    while str(antwoord).zfill(100)!=str(25).zfill(100):
-      antwoord = input(\'Wat is 5 keer 5?\')
+      leeftijd = input('Hoe oud ben jij?')
       try:
-        antwoord = int(antwoord)
+        leeftijd = int(leeftijd)
       except ValueError:
         try:
-          antwoord = float(antwoord)
+          leeftijd = float(leeftijd)
         except ValueError:
           pass
-    print(f'Goed gedaan!')""")
+      if str(leeftijd).zfill(100)<str(12).zfill(100):
+        print(f'Dan ben je jonger dan ik!')""")
 
     self.multi_level_tester(
       code=code,
@@ -30,25 +28,49 @@ def test_while_equals(self):
       extra_check_function=self.is_not_turtle(),
       test_name=self.name()
     )
+  def tests_bigger(self):
+    code = textwrap.dedent("""\
+      leeftijd is ask 'Hoe oud ben jij?'
+      if leeftijd > 12
+          print 'Dan ben je ouder dan ik!'""")
+    expected = textwrap.dedent("""\
+      leeftijd = input('Hoe oud ben jij?')
+      try:
+        leeftijd = int(leeftijd)
+      except ValueError:
+        try:
+          leeftijd = float(leeftijd)
+        except ValueError:
+          pass
+      if str(leeftijd).zfill(100)>str(12).zfill(100):
+        print(f'Dan ben je ouder dan ik!')""")
 
-  def test_while_smaller(self):
+    self.multi_level_tester(
+      code=code,
+      expected=expected,
+      extra_check_function=self.is_not_turtle(),
+      test_name=self.name()
+    )
+  def tests_smaller_else(self):
     code = textwrap.dedent("""\
-      getal is 0
-      while getal < 100000
-          getal is ask 'HOGER!!!!!'
-      print 'Hoog he?'""")
+      leeftijd is ask 'Hoe oud ben jij?'
+      if leeftijd < 12
+          print 'Dan ben je jonger dan ik!'
+      else
+          print 'Dan ben je ouder dan ik!'""")
     expected = textwrap.dedent("""\
-    getal = 0
-    while str(getal).zfill(100)<str(100000).zfill(100):
-      getal = input('HOGER!!!!!')
+      leeftijd = input('Hoe oud ben jij?')
       try:
-        getal = int(getal)
+        leeftijd = int(leeftijd)
       except ValueError:
         try:
-          getal = float(getal)
+          leeftijd = float(leeftijd)
         except ValueError:
           pass
-    print(f'Hoog he?')""")
+      if str(leeftijd).zfill(100)<str(12).zfill(100):
+        print(f'Dan ben je jonger dan ik!')
+      else:
+        print(f'Dan ben je ouder dan ik!')""")
 
     self.multi_level_tester(
       code=code,
@@ -56,3 +78,105 @@ def test_while_smaller(self):
       extra_check_function=self.is_not_turtle(),
       test_name=self.name()
     )
+
+  def test_not_equal(self):
+      code = textwrap.dedent("""\
+        land is ask 'In welk land woon jij?'
+        if land != Nederland
+            print 'Cool!'
+        else
+            print 'Ik kom ook uit Nederland!'""")
+      expected = textwrap.dedent("""\
+        land = input('In welk land woon jij?')
+        try:
+          land = int(land)
+        except ValueError:
+          try:
+            land = float(land)
+          except ValueError:
+            pass
+        if str(land).zfill(100)!='Nederland'.zfill(100):
+          print(f'Cool!')
+        else:
+          print(f'Ik kom ook uit Nederland!')""")
+      self.multi_level_tester(
+
+        code=code,
+        expected=expected,
+        extra_check_function=self.is_not_turtle(),
+        test_name=self.name()
+      )
+
+  def tests_smaller_equal(self):
+    code = textwrap.dedent("""\
+      leeftijd is ask 'Hoe oud ben jij?'
+      if leeftijd <= 12
+          print 'Dan ben je jonger dan ik!'""")
+    expected = textwrap.dedent("""\
+      leeftijd = input('Hoe oud ben jij?')
+      try:
+        leeftijd = int(leeftijd)
+      except ValueError:
+        try:
+          leeftijd = float(leeftijd)
+        except ValueError:
+          pass
+      if str(leeftijd).zfill(100)<=str(12).zfill(100):
+        print(f'Dan ben je jonger dan ik!')""")
+
+    self.multi_level_tester(
+      code=code,
+      expected=expected,
+      extra_check_function=self.is_not_turtle(),
+      test_name=self.name()
+    )
+  def tests_bigger_equal(self):
+    code = textwrap.dedent("""\
+      leeftijd is ask 'Hoe oud ben jij?'
+      if leeftijd >= 12
+          print 'Dan ben je ouder dan ik!'""")
+    expected = textwrap.dedent("""\
+      leeftijd = input('Hoe oud ben jij?')
+      try:
+        leeftijd = int(leeftijd)
+      except ValueError:
+        try:
+          leeftijd = float(leeftijd)
+        except ValueError:
+          pass
+      if str(leeftijd).zfill(100)>=str(12).zfill(100):
+        print(f'Dan ben je ouder dan ik!')""")
+
+    self.multi_level_tester(
+      code=code,
+      expected=expected,
+      extra_check_function=self.is_not_turtle(),
+      test_name=self.name()
+    )
+  def tests_smaller_equal_else(self):
+    code = textwrap.dedent("""\
+      leeftijd is ask 'Hoe oud ben jij?'
+      if leeftijd <= 12
+          print 'Dan ben je jonger dan ik!'
+      else
+          print 'Dan ben je ouder dan ik!'""")
+    expected = textwrap.dedent("""\
+      leeftijd = input('Hoe oud ben jij?')
+      try:
+        leeftijd = int(leeftijd)
+      except ValueError:
+        try:
+          leeftijd = float(leeftijd)
+        except ValueError:
+          pass
+      if str(leeftijd).zfill(100)<=str(12).zfill(100):
+        print(f'Dan ben je jonger dan ik!')
+      else:
+        print(f'Dan ben je ouder dan ik!')""")
+
+    self.multi_level_tester(
+      code=code,
+      expected=expected,
+      extra_check_function=self.is_not_turtle(),
+      test_name=self.name()
+    )
\ No newline at end of file
diff --git a/tests/test_level_15.py b/tests/test_level_15.py
--- a/tests/test_level_15.py
+++ b/tests/test_level_15.py
@@ -1,92 +1,58 @@
+import hedy
 import textwrap
 from test_level_01 import HedyTester
 
-
 class TestsLevel15(HedyTester):
-    level = 15
-
-    def test_print_list_var(self):
-        code = textwrap.dedent("""\
-            dieren is ['Hond', 'Kat', 'Kangoeroe']
-            print dieren[1]""")
-
-        expected = textwrap.dedent("""\
-            dieren = ['Hond', 'Kat', 'Kangoeroe']
-            print(f'{dieren[1-1]}')""")
-
-        check_in_list = (lambda x: HedyTester.run_code(x) == 'Hond')
-
-        self.multi_level_tester(
-            code=code,
-            expected=expected,
-            extra_check_function=check_in_list,
-            test_name=self.name()
-        )
-
-    def test_print_list_access(self):
-        code = textwrap.dedent("""\
-            fruit is ['banaan', 'appel', 'kers'] 
-            print fruit[1]""")
-        expected = textwrap.dedent("""\
-            fruit = ['banaan', 'appel', 'kers']
-            print(f'{fruit[1-1]}')""")
-
-        self.multi_level_tester(
-            code=code,
-            expected=expected,
-            extra_check_function=self.is_not_turtle(),
-            test_name=self.name()
-        )
-
-    def test_list_access_var(self):
-        code = textwrap.dedent("""\
-            fruit is ['banaan', 'appel', 'kers']
-            eerstefruit is fruit[1]
-            print eerstefruit""")
-        expected = textwrap.dedent("""\
-            fruit = ['banaan', 'appel', 'kers']
-            eerstefruit = fruit[1-1]
-            print(f'{eerstefruit}')""")
-
-        self.multi_level_tester(
-            code=code,
-            expected=expected,
-            extra_check_function=self.is_not_turtle(),
-            test_name=self.name()
-        )
-
-    def test_access_plus(self):
-        code = textwrap.dedent("""\
-            lijst is [1, 2, 3]
-            optellen is lijst[1] + lijst[2]
-            optellen is optellen + lijst[3]
-            print optellen""")
-        expected = textwrap.dedent("""\
-            lijst = [1, 2, 3]
-            optellen = lijst[1-1] + lijst[2-1]
-            optellen = optellen + lijst[3-1]
-            print(f'{optellen}')""")
-
-        self.multi_level_tester(
-            code=code,
-            expected=expected,
-            extra_check_function=self.is_not_turtle(),
-            test_name=self.name()
-        )
-
-    def test_list_access_random(self):
-        code = textwrap.dedent("""\
-            fruit is ['banaan', 'appel', 'kers']
-            randomfruit is fruit[random]
-            print randomfruit""")
-        expected = textwrap.dedent("""\
-            fruit = ['banaan', 'appel', 'kers']
-            randomfruit = random.choice(fruit)
-            print(f'{randomfruit}')""")
-
-        self.multi_level_tester(
-            code=code,
-            expected=expected,
-            extra_check_function=self.is_not_turtle(),
-            test_name=self.name()
-        )
+  level = 15
+
+  def test_while_equals(self):
+    code = textwrap.dedent("""\
+      antwoord is 0
+      while antwoord != 25
+          antwoord is ask 'Wat is 5 keer 5?'
+      print 'Goed gedaan!'""")
+    expected = textwrap.dedent("""\
+    antwoord = 0
+    while str(antwoord).zfill(100)!=str(25).zfill(100):
+      antwoord = input(\'Wat is 5 keer 5?\')
+      try:
+        antwoord = int(antwoord)
+      except ValueError:
+        try:
+          antwoord = float(antwoord)
+        except ValueError:
+          pass
+    print(f'Goed gedaan!')""")
+
+    self.multi_level_tester(
+      code=code,
+      expected=expected,
+      extra_check_function=self.is_not_turtle(),
+      test_name=self.name()
+    )
+
+  def test_while_smaller(self):
+    code = textwrap.dedent("""\
+      getal is 0
+      while getal < 100000
+          getal is ask 'HOGER!!!!!'
+      print 'Hoog he?'""")
+    expected = textwrap.dedent("""\
+    getal = 0
+    while str(getal).zfill(100)<str(100000).zfill(100):
+      getal = input('HOGER!!!!!')
+      try:
+        getal = int(getal)
+      except ValueError:
+        try:
+          getal = float(getal)
+        except ValueError:
+          pass
+    print(f'Hoog he?')""")
+
+    self.multi_level_tester(
+      code=code,
+      expected=expected,
+      extra_check_function=self.is_not_turtle(),
+      test_name=self.name()
+    )
diff --git a/tests/test_level_16.py b/tests/test_level_16.py
new file mode 100644
--- /dev/null
+++ b/tests/test_level_16.py
@@ -0,0 +1,92 @@
+import textwrap
+from test_level_01 import HedyTester
+
+
+class TestsLevel16(HedyTester):
+    level = 16
+
+    def test_print_list_var(self):
+        code = textwrap.dedent("""\
+            dieren is ['Hond', 'Kat', 'Kangoeroe']
+            print dieren[1]""")
+
+        expected = textwrap.dedent("""\
+            dieren = ['Hond', 'Kat', 'Kangoeroe']
+            print(f'{dieren[1-1]}')""")
+
+        check_in_list = (lambda x: HedyTester.run_code(x) == 'Hond')
+
+        self.multi_level_tester(
+            code=code,
+            expected=expected,
+            extra_check_function=check_in_list,
+            test_name=self.name()
+        )
+
+    def test_print_list_access(self):
+        code = textwrap.dedent("""\
+            fruit is ['banaan', 'appel', 'kers'] 
+            print fruit[1]""")
+        expected = textwrap.dedent("""\
+            fruit = ['banaan', 'appel', 'kers']
+            print(f'{fruit[1-1]}')""")
+
+        self.multi_level_tester(
+            code=code,
+            expected=expected,
+            extra_check_function=self.is_not_turtle(),
+            test_name=self.name()
+        )
+
+    def test_list_access_var(self):
+        code = textwrap.dedent("""\
+            fruit is ['banaan', 'appel', 'kers']
+            eerstefruit is fruit[1]
+            print eerstefruit""")
+        expected = textwrap.dedent("""\
+            fruit = ['banaan', 'appel', 'kers']
+            eerstefruit = fruit[1-1]
+            print(f'{eerstefruit}')""")
+
+        self.multi_level_tester(
+            code=code,
+            expected=expected,
+            extra_check_function=self.is_not_turtle(),
+            test_name=self.name()
+        )
+
+    def test_access_plus(self):
+        code = textwrap.dedent("""\
+            lijst is [1, 2, 3]
+            optellen is lijst[1] + lijst[2]
+            optellen is optellen + lijst[3]
+            print optellen""")
+        expected = textwrap.dedent("""\
+            lijst = [1, 2, 3]
+            optellen = lijst[1-1] + lijst[2-1]
+            optellen = optellen + lijst[3-1]
+            print(f'{optellen}')""")
+
+        self.multi_level_tester(
+            code=code,
+            expected=expected,
+            extra_check_function=self.is_not_turtle(),
+            test_name=self.name()
+        )
+
+    def test_list_access_random(self):
+        code = textwrap.dedent("""\
+            fruit is ['banaan', 'appel', 'kers']
+            randomfruit is fruit[random]
+            print randomfruit""")
+        expected = textwrap.dedent("""\
+            fruit = ['banaan', 'appel', 'kers']
+            randomfruit = random.choice(fruit)
+            print(f'{randomfruit}')""")
+
+        self.multi_level_tester(
+            code=code,
+            expected=expected,
+            extra_check_function=self.is_not_turtle(),
+            test_name=self.name()
+        )