Added RET keyword

tests/evaluators/test_PythonEvaluator.py

@@ -112,7 +112,7 @@ class TestPythonEvaluator(TestUsingMemoryBasedSheerka):
         evaluated = PythonEvaluator().eval(context, parsed)
 
         assert evaluated.status
-        assert evaluated.value == 2
+        assert evaluated.value == CB("foo", 2)
 
     def test_i_can_eval_concept_token(self):
         context = self.get_context()
@@ -126,13 +126,35 @@ class TestPythonEvaluator(TestUsingMemoryBasedSheerka):
         assert evaluated.status
         assert evaluated.value == "foo"
 
+    def test_i_can_eval_when_expect_success(self):
+        context = self.get_context()
+        context.sheerka.add_in_cache(Concept("foo", body="2"))
+
+        parsed = PythonParser().parse(context, ParserInput("foo==2"))
+        python_evaluator = PythonEvaluator()
+
+        evaluated = python_evaluator.eval(context, parsed)
+        assert evaluated.status
+        assert not evaluated.value  # the first test is between Concept(foo) and int(2)
+
+        context.local_hints.add(BuiltinConcepts.EVAL_SUCCESS_REQUESTED)
+        evaluated = python_evaluator.eval(context, parsed)
+        assert evaluated.status
+        assert evaluated.value  # we test until we compare foo.body and 2
+
+        parsed = PythonParser().parse(context, ParserInput("foo==3"))
+        evaluated = python_evaluator.eval(context, parsed)
+        assert evaluated.status
+        assert not evaluated.value  # neither foo or foo.body ==3
+
     def test_i_can_call_function_with_complex_concepts(self):
         sheerka, context, plus, mult = self.init_concepts(
             self.from_def_concept("plus", "a plus b", ["a", "b"]),
             self.from_def_concept("mult", "a mult b", ["a", "b"]),
         )
 
-        parsed = PythonParser().parse(context, ParserInput("set_is_greater_than(BuiltinConcepts.PRECEDENCE, mult, plus)"))
+        parsed = PythonParser().parse(context,
+                                      ParserInput("set_is_greater_than(BuiltinConcepts.PRECEDENCE, mult, plus)"))
         python_evaluator = PythonEvaluator()
 
         evaluated = python_evaluator.eval(context, parsed)
@@ -164,8 +186,8 @@ class TestPythonEvaluator(TestUsingMemoryBasedSheerka):
 
         all_globals = python_evaluator.get_all_possible_globals(context, my_globals)
         assert len(all_globals) == 2
-        assert all_globals[0]["foo"] == 'foo'
-        assert all_globals[1]["foo"] == CB(foo, "foo")  # body is evaluated
+        assert all_globals[0]["foo"] == CB(foo, "foo")
+        assert all_globals[1]["foo"] == 'foo'  # body is evaluated
 
     def test_i_can_detect_one_error(self):
         sheerka, context, foo = self.init_concepts("foo")
@@ -194,11 +216,11 @@ class TestPythonEvaluator(TestUsingMemoryBasedSheerka):
         error0 = evaluated.body.body[0]
         assert isinstance(error0, PythonEvalError)
         assert isinstance(error0.error, TypeError)
-        assert error0.error.args[0] == 'can only concatenate str (not "int") to str'
-        assert error0.concepts == {'foo': 'string'}
+        assert error0.error.args[0] == "unsupported operand type(s) for +: 'Concept' and 'int'"
+        assert error0.concepts == {'foo': CB(foo, 'string')}
 
         error1 = evaluated.body.body[1]
         assert isinstance(error1, PythonEvalError)
         assert isinstance(error1.error, TypeError)
-        assert error1.error.args[0] == "unsupported operand type(s) for +: 'Concept' and 'int'"
-        assert error1.concepts == {'foo': CB(foo, 'string')}
+        assert error1.error.args[0] == 'can only concatenate str (not "int") to str'
+        assert error1.concepts == {'foo': 'string'}