Time 1727698126.357399

        self.assertEqualMettaRunnerResults(metta.run(program),
            [metta.parse_all('red  green  blue'), metta.parse_all('5')])

        self.assertEqual('[[B]]', repr(result))

        self.assertEqual('[[(Cons a1 (Cons a2 (Cons b1 (Cons b2 Nil))))]]', repr(result))

        self.assertEqual('[[5]]', repr(result))

        self.assertEqual('[[1]]', repr(result))

        metta.run('''
                (= (min $a $b) (if (< $a $b) $a $b))
                (= (s-tv (stv $s $c)) $s)
                (= (c-tv (stv $s $c)) $c)
                (= (stv (And $a $b))
                   (stv (min (s-tv (stv $a)) (s-tv (stv $b)))
                        (min (c-tv (stv $a)) (c-tv (stv $b)))))
                (= (stv (P A)) (stv 0.5 0.8))
                (= (stv (P B)) (stv 0.3 0.9))
        ''')

        metta.run('''
                (: A Concept)
                (: B Concept)
                (: P Predicate)
        ''')

        self.assertEqualMettaRunnerResults(
            metta.run('!(stv (And (P A) (P B)))'),
            [metta.parse_all('(stv 0.3 0.8)')])

        metta.run('''
                (= (pln $expr) ($expr (stv $expr)))
        ''')

        self.assertEqualMettaRunnerResults(
            metta.run('!(pln (And (P A) (P $x)))'),
            [metta.parse_all('''
                ((And (P A) (P A)) (stv 0.5 0.8))
                ((And (P A) (P B)) (stv 0.3 0.8))
            ''')])

        self.assertEqual(Environment.config_dir(), "/tmp/hyperon-test")

        self.assertEqual(kb.atom_count(), 2)

        self.assertEqual(kb.get_payload().test_attrib, "Test Space Payload Attrib")

        self.assertEqual(result_atom, space_atom)

        self.assertEqual([[S("B")]], result)

        self.assertEqual(metta.space().get_payload().test_attrib, "Test Space Payload Attrib")

        self.assertEqualMettaRunnerResults(metta.run("!(match &self (= key $val) $val)"),
            [[S("val")]]
        )

        self.assertEqual(
            metta.parse_single("+").get_grounded_type(),
            metta.parse_single("*").get_grounded_type())

        self.assertEqual(
            metta.run("!(+ (* 1 4) 2)")[0][0].get_grounded_type(),
            metta.parse_single("0").get_grounded_type())

        self.assertEqual(
            metta.run("!(or True False)")[0][0].get_grounded_type(),
            metta.parse_single("False").get_grounded_type())

        self.assertEqual(
            metta.run("!(> (* 2 2) 1)")[0][0].get_grounded_type(),
            metta.run("!(or True True)")[0][0].get_grounded_type())

        self.assertEqual(
            metta.run("!(untop)")[0][0],
            metta.parse_single("()"))

            metta.run("!(> 1 1)")[0][0].get_grounded_type(),

            metta.run("!(+ 1 1)")[0][0].get_grounded_type())

    def test_higher_func(self):
        metta = MeTTa(env_builder=Environment.test_env())
        metta.register_atom(

        self.assertEqual(metta.run("!((curry_num + 1) 2)"),
                         metta.run("! 3"))

        v1 = metta.run("!(id_num (+ 2 2))")[0]

        v2 = metta.run("! 4")[0]

        v3 = metta.run("!(as_int (+ 2 2))")[0]

        self.assertEqual(v1, v2)

        self.assertEqual(v1[0].get_grounded_type(), v2[0].get_grounded_type())

        self.assertEqual(metta.run("!(id_num untyp)"), [metta.parse_all("(id_num untyp)")])

        metta.run("(: myAtom myType)")

        self.assertEqual(metta.run('''
            !(id_num myAtom)
            !(id_num False)
            '''),
            [[E(S('Error'), S('myAtom'), S('BadType'))]])

        self.assertEqual(metta.run('''
            !(id_atom 1)
            !(id_atom myAtom)
            !(id_atom untyp)
            ''', flat=True),
            metta.parse_all('''
            1
            myAtom
            untyp
            '''))

        # self.assertEqual(metta.run("!(id_atom (+ 1 1))"), [metta.parse_all("(+ 1 1)")])

        self.assertEqual(metta.run('''
            !(id_poly_w 1)
            !(id_poly_w myAtom)
            !(id_poly_w untyp)
            !(id_poly_w (+ 1 1))
            !(+ 1 (id_poly_w 2))
            ''', flat=True),
            metta.parse_all('''
             1
             myAtom
             untyp
             2
             3
            ''')
        )

        self.assertEqual(metta.run('''
            !(id_undef 1)
            !(id_undef False)
            !(id_undef (+ 1 1))
            ''', flat=True),
            metta.parse_all("1 False 2"))

        self.assertEqual(metta.run('''
            !(id_undef myAtom)
            !(id_undef untyp)
            ''', flat=True),
            metta.parse_all('''
             (id_undef myAtom)
             (id_undef untyp)
            ''')
        )

        self.assertEqual(atom, E(S('A'), S('B')))

        self.assertEqual(atom, E(S('C'), S('B')))

        self.assertEqual(atom, E(S('F'), S('B')))

        self.assertEqual([[S('T')]], result)

        self.assertEqual([S('T')], result)

        self.assertEqual(repr(results), "[[10]]")

        self.assertEqual([[E(S('Error'), ValueAtom('String'), S('BadType'))]], result)

            self.assertEqual(e.args[0], 'Unexpected end of expression')

        self.assertEqual([[]], result)

        self.assertEqualMettaRunnerResults(metta.run("!(repr (my atom))"),
                                           [[ValueAtom("(my atom)")]])

        self.assertEqualMettaRunnerResults(metta.run("!(parse \"(my atom)\")"),
                                           [[E(S("my"), S("atom"))]])

        #self.assertEqualMettaRunnerResults(metta.run('!(parse "$X")'),
        #                                  [[(V("X"))]])

        self.assertEqualMettaRunnerResults(metta.run('!(parse "\\"A\\"")'),
                                           [[(ValueAtom("A"))]])

        #self.assertEqualMettaRunnerResults(metta.run('!(parse "(func (Cons $x (Cons $xs $xss))) ")'),
        #                                   [[E(S("func"), E(S("Cons"), V("x"), E(S("Cons"), V("xs"), V("xss"))))]])

        self.assertEqualMettaRunnerResults(metta.run('!(parse "(A 2 \'S\')")'),
                                   [[E(S("A"), ValueAtom(2), ValueAtom(Char("S")))]])

        self.assertEqualMettaRunnerResults(metta.run('!(stringToChars "ABC")'),
                                           [[E(ValueAtom(Char("A")), ValueAtom(Char("B")), ValueAtom(Char("C")))]])

        self.assertEqualMettaRunnerResults(metta.run("!(charsToString ('A' 'B' 'C'))"),
                                           [[ValueAtom("ABC")]])

        metta.run('''
                  ! (bind! &pow (py-atom math.pow (-> Number Number Number)))
                  ! (bind! &math (py-atom math))
        ''')

        self.assertEqual(metta.run('! (&pow 2 3)'),
                         metta.run('! ((py-dot &math pow) 2 3)'))

        self.assertEqual([[ValueAtom(3)]],
            metta.run('! ((py-dot &math floor) (py-dot &math pi))'))

        self.assertEqual([[ValueAtom('f')]],
                         metta.run('! ((py-dot (py-atom "{5: \'f\'}") get) 5)'))

        self.assertEqual([[ValueAtom('5')]],
                         metta.run('! ((py-atom str) 5)'))

        self.assertEqual([[ValueAtom("/usr")]],
            metta.run('''
                ! ((py-dot (py-atom os) path.commonpath)
                   (py-atom "['/usr/lib', '/usr/local/lib']"))
        '''))

        self.assertEqualMettaRunnerResults(metta.run("!(+ 1 2)"), [[ValueAtom(3)]])

        self.assertEqualMettaRunnerResults(metta.run("!(+ 5.0 -2.0)"), [[ValueAtom(3.0)]])

        self.assertEqualMettaRunnerResults(metta.run("!(+ 1.0e3 2.0e3)"), [[ValueAtom(3e3)]])

        self.assertEqualMettaRunnerResults(metta.run("!(+ 5e-3 -2e-3)"), [[ValueAtom(3e-3)]])

        metta.run('''(= (intent regex:"^Hello[[\.|!]]?$") (Intent Hello))
                    (= (intent regex:"Good~morning.*[[\\.|!]]?") (Intent Hello))
                    (= (intent $x) (empty))''')

        self.assertEqual(metta.run('!(intent "hello")', True), [E(S("Intent"), S("Hello"))])

        self.assertEqual(metta.run('!(intent "Good morning my friend!")', True),
                                           [E(S("Intent"), S("Hello"))])

        self.assertEqual(metta.run('!(intent "Hi")', True), [])

        self.assertEqual(metta.run('!(py-list ())'), [[ValueAtom( [] )]])

        self.assertEqual(metta.run('!(py-tuple ())'), [[ValueAtom( () )]])

        self.assertEqual(metta.run('!(py-dict ())'), [[ValueAtom( {} )]])

        self.assertEqual(metta.run('!(py-tuple (1 (2 (3 "3")) (py-atom list)))'), [[ValueAtom((1,(2,(3, "3")), list))]])

        self.assertEqual(metta.run('!(py-list (1 2 (4.5 3)))'), [[ValueAtom( [1,2,[4.5,3]] )]])

        self.assertEqual(metta.run('!(py-list (1 2 (py-tuple (3 4))))'), [[ValueAtom( [1,2, (3,4)] )]])

        self.assertEqual(metta.run('!(py-dict ((a "b") ("b" "c")))'), [[ValueAtom( {"a":"b", "b":"c"} )]])

        self.assertEqual(str(metta.run('!(py-list (a b c))')[0][0].get_object().content[2]), "c")

        self.assertEqual(metta.run('!(py-chain (1 2 3 4))'), [[ValueAtom( 7 )]])

        self.assertRaises(Exception, metta.run('!(py-dict (("a" "b" "c") ("b" "c")))'))

        self.assertRaises(Exception, metta.run('!(py-dict (("a") ("b" "c")))'))

        self.assertRaises(Exception, metta.run('!(py-dict ("a" "b") ("b" "c"))'))

        self.assertRaises(Exception, metta.run('!(py-list 1 2)'))

        self.assertRaises(Exception, metta.run('!(py-list 1)'))

        metta.run('''
            (= (wood) (spruce-wood))
            (= (spruce-wood) (mine spruce-tree hand))

            (= (four-planks) (craft four-planks inventory (wood)))
            (= (pack $n planks) (if (> $n 0) (allof (four-planks) (pack (- $n 4) planks)) nop))

            (= (crafting-table) (craft crafting-table inventory  (pack 4 planks)))

            (= (stick) (craft stick inventory (pack 2 planks)))
            (= (pack $n sticks) (if (> $n 0) (allof (stick) (pack (- $n 1) sticks)) nop))

            (= (wooden-pickaxe) (craft wooden-pickaxe
                           (crafting-table) (allof (pack 3 planks) (pack 2 sticks))))

            (= (cobblestone) (mine cobble-ore (wooden-pickaxe)))
            (= (pack $n cobblestones) (if (> $n 0) (allof (cobblestone) (pack (- $n 1) cobblestones)) nop))

            (= (stone-pickaxe) (craft stone-pickaxe (crafting-table)
                           (allof (pack 3 cobblestones) (pack 2 sticks))))
        ''')

        metta.run('!(wooden-pickaxe)')

        metta.run('''
            (= (can-be-mined diamond) True)
            (= (can-be-made diamond) False)
            (= (diamond mined-using iron-pickaxe) True)
            (= (diamond mined-from diamond-ore) True)

            (= (can-be-made iron-pickaxe) True)
            (= (can-be-mined iron-pickaxe) False)
            (= (iron-pickaxe made-from
                (, stick stick iron-ingot iron-ingot iron-ingot)) True)
            (= (iron-pickaxe made-at crafting-table) True)

            (= (can-be-made crafting-table) True)
            (= (can-be-mined crafting-table) False)
            (= (crafting-table made-from (pack 4 plank)) True)
            (= (crafting-table made-at inventory) True)

            (= (can-be-made inventory) False)
            (= (can-be-mined inventory) False)

            (= (make $x) (if (and ($x made-from $comp) ($x made-at $tool))
                             (, (get $tool) (get $comp) (do-make $x $tool $comp)) (empty)))

            (= (mine $x) (if (and ($x mined-using $tool) ($x mined-from $source))
                             (, (get $tool) (find $source) (do-mine $x $source $tool)) (empty)))

        metta.run('!(get diamond)')

        self.assertEqual(result, [Atoms.UNIT])

        self.assertEqual(repr(result), '[((py-dot &obj foo))]')

        self.assertEqualMettaRunnerResults(
            metta.run('''
             ! (&f 2 4 6)
             ! (&f 0)
             ! (&f (Kwargs (y 4)))
             ! (&f 2 (Kwargs (z 1)))
             ! (&f 0 (Kwargs (z 1) (y 1)))
            '''),
            [[ValueAtom(12)],
             [ValueAtom(6)],
             [ValueAtom(9)],
             [ValueAtom(5)],
             [ValueAtom(2)]]
            )

        metta.run(
        '''
            (= (remove-st $var)
               (match &self (state $var $y)
                  (remove-atom &self (state $var $y))))
            (= (change-st $var $value)
               (superpose ((remove-st $var)
                  (add-atom &self (state $var $value)))))
            (= (get-st $var)
               (match &self (state $var $value) $value))
        ''')

        metta.run('!(change-st (name id-001) Fritz)')

        self.assertEqualMettaRunnerResults(metta.run('!(get-st (name id-001))'),
                         [[S('Fritz')]])

        metta.run('!(change-st (name id-001) Sam)')

        self.assertEqualMettaRunnerResults(metta.run('!(get-st (name id-001))'),
                         [[S('Sam')]])

        self.assertEqual(metta.run('! pglob')[0][0].get_object().value.get(), 10)

        metta.run('!((py-dot (Setter pglob 5) act))')

        self.assertEqual(pglob.get(), 5)

        self.assertEqual(metta.run('! pglob')[0][0].get_object().value.get(), 5)

        metta.run('!((py-dot (Setter ploc 5) let))')

        self.assertEqual(ploc, 10)

        self.assertEqual(metta.run('! ploc')[0][0].get_object().value, 10)

        self.assertEqual(t.get_children()[1].get_children()[1].get_object().value, 5)

        self.assertEqual(metta.run('! ploc')[0][0].get_object().value, 10)

        metta.run('!((py-dot (Setter ploca 5) let))')

        self.assertEqual(metta.run('! ploca')[0][0].get_object().value, 10)

        self.assertEqual(ploca.get_object().value, 10)

        metta.run('!((py-dot (SetAtom ploca 5) latom))')

        self.assertEqual(metta.run('! ploca')[0][0].get_object().value, 5)

        self.assertEqual(ploca.get_object().value, 5)

        metta.run('''
            (= (croaks Fritz) True)
            (= (chirps Tweety) True)
            (= (yellow Tweety) True)
            (= (eats_flies Tweety) True)
            (= (eats_flies Fritz) True)
        ''')

        fritz_frog = metta.run('!(if (and (croaks $x) (eats_flies $x)) (= (frog $x) True) nop)')[0]

        self.assertEqual(metta.parse_all('(= (frog Fritz) True)'), fritz_frog)

        self.assertEqualMettaRunnerResults([metta.parse_all('(= (green Fritz) True)')],
                metta.run('!(if (frog $x) (= (green $x) True) nop)'))

        metta.run('''
           (= (: (apply\' $f $x) $r) (and (: $f (=> $a $r)) (: $x $a)))

           (= (: reverse (=> String String)) True)
           (= (: "Hello" String) True)
        ''')

        output = metta.run('!(if (: (apply\' reverse "Hello") $t) $t Wrong)')

        self.assertEqualMettaRunnerResults(output, [[S('String')]])

        metta.run('''
           (= (eq $x $x) True)
           (= (plus Z $y) $y)
           (= (plus (S $k) $y) (S (plus $k $y)))
        ''')

        self.assertEqualMettaRunnerResults(metta.run('''
            !(eq (+ 2 2) 4)
            !(eq (+ 2 3) 4)
            !(eq (plus Z $n) $n)
            '''),
            [[ValueAtom(True)],
             metta.parse_all('(eq 5 4)'),
             [ValueAtom(True)]
            ]
        )

        output = metta.run('!(eq (plus (S Z) $n) $n)')

        self.assertEqualMettaRunnerResults(metta1.run('!(inverse B)'), [[S('A')]])

        self.assertEqualMettaRunnerResults(metta2.run('!(find-in &space1 B)'), [[S('A')]])

        self.assertEqualMettaRunnerResults(metta2.run('!(find-in &self B)'), [[S('C')]])

        self.assertEqualMettaRunnerResults(metta2.run('!(borrow &space1 (inverse B))'), [[S('A')]])

        self.assertEqualMettaRunnerResults(metta2.run('!(borrow &space1 (how-it-works?))'), [[S('success')]])

        self.assertEqualMettaRunnerResults(metta1.run('!(how-it-works?)'), [[S('failure')]])

        metta.run('''
            (= (:? $c)
               (match &self (:= $c $t) $t))
            (= (:? ($c $a))
               (let $at (:? $a)
                    (match &self (:= ($c $at) $t) $t)))
            (= (:? ($c $a $b))
               (let* (($at (:? $a))
                      ($bt (:? $b)))
                     (match &self (:= ($c $at $bt) $t) $t)))

            (= (:check $c $t)
               (match &self (:= $c $t) T))
            (= (:check ($c $a) $t)
               (let $at (:? $a)
                    (match &self (:= ($c $at) $t) T)))
            (= (:check ($c $a $b) $t)
               (let* (($at (:? $a))
                      ($bt (:? $b)))
                     (match &self (:= ($c $at $bt) $t) T)))

            (:= (= $t $t) Prop)

            (:= Entity Prop)
            (:= (Human Entity) Prop)
            (:= Socrates Entity)

        self.assertEqualMettaRunnerResults(metta.run('''
            !(:? (HumansAreMortal SocratesIsHuman))
            !(:check (HumansAreMortal SocratesIsHuman) (Mortal Socrates))
            !(:? (= SocratesIsMortal (HumansAreMortal SocratesIsHuman)))
            !(:check (= (Mortal Plato) (Mortal Socrates)) Prop)
            !(:check (= (Human Socrates) (Mortal Socrates)) Prop)
            !(:? (GreenAndCroaksIsFrog SamIsGreen SamCroaks))
            '''),
            [[E(S('Mortal'), S('Socrates'))],
             [S('T')],
             [S('Prop')],
             [S('T')],
             [S('T')], # they are both of Prop type and can be equated
             [E(S('Frog'), S('Sam'))]
            ]
        )

        self.assertEqualMettaRunnerResults(metta.run('''
            !(:check (= SocratesIsHuman SocratesIsMortal) Prop)
            !(:? (SocratesIsHuman (Human Socrates)))
            !(:? (Human Time))
            '''),
            [[], [], []]
        )

        # self.assertEqualMettaRunnerResults(metta.run("!(:? (HumansAreMortal (Human Time)))"),
        #                                  [[]])

        metta.run('''
            (= (:? $c)
               (match &self (:: $c $t) $t))
            (= (:? ($c $a))
               (let $at (:? $a)
                    (match &self (:: $c (-> $at $t)) $t)))
            (= (:? ($c $a $b))
               (let* (($at (:? $a))
                      ($bt (:? $b)))
                     (match &self (:: $c (-> $at $bt $t)) $t)))

            (:: = (-> $t $t Type))

            (:: Entity Type)
            (:: Human (-> Entity Type))
            (:: Socrates Entity)
            (:: Plato Entity)
            (:: Mortal (-> Entity Type))
            (:: HumansAreMortal (-> (Human $t) (Mortal $t)))
            (:: SocratesIsHuman (Human Socrates))
            (:: SocratesIsMortal (Mortal Socrates))
        ''')

        self.assertEqualMettaRunnerResults(metta.run('''
            !(:? (Human Plato))
            !(:? (Human Time))
            !(:? (HumansAreMortal SocratesIsHuman))
            !(:? (= SocratesIsMortal (HumansAreMortal SocratesIsHuman)))
            !(:? (= Human Entity))
            !(:? (= (Human Socrates) Plato))
            !(:? (= SocratesIsHuman SocratesIsMortal))
            !(:? (= (Human Socrates) (Human Plato)))
            !(:? (= Human Mortal))
            !(:? (= HumansAreMortal Mortal))
            '''),
            [[S('Type')],
             [],
             [E(S('Mortal'), S('Socrates'))],
             [S('Type')],
             [],
             [],
             [],
             [S('Type')],
             [S('Type')],
             []
            ]
        )

        self.assertEqualMettaRunnerResults(metta.run("!(:? (HumansAreMortal (Human Socrates)))"), [[]])

        metta.run('''
            (= (perform (visit $x)) (perform (lunch-order $x)))
            (= (perform (visit $x)) (perform (health-check $x)))

            (impl (is-achieved (visit $x))
                (And (is-achieved (lunch-order $x)) (is-achieved (health-check $x))))

            (= (achieve $goal)
                (match &self (impl (is-achieved $goal)
                                (And (is-achieved $subgoal1) (is-achieved $subgoal2)))
                    (do $subgoal1 $subgoal2)))

            (= (achieve (health-check Kim)) True)
            (= (achieve (lunch-order Kim)) False)
        ''')

        self.assertEqualMettaRunnerResults(metta.run('''
            !(perform (visit Kim))
            !(achieve (visit Kim))
            '''),
            [metta.parse_all('(perform (lunch-order Kim)) (perform (health-check Kim))'),
             metta.parse_all('(do (lunch-order Kim) (health-check Kim))')]
        )

        metta.run('''
            (= (do $goal1 $goal2) (achieve $goal1))
            (= (do $goal1 $goal2) (achieve $goal2))
        ''')

        self.assertEqualMettaRunnerResults(metta.run('!(achieve (visit Kim))'),
            [metta.parse_all('False True')])

        self.assertEqual(repr(metta.run("!('A')")), "[[('A')]]")

        self.assertEqual(repr(metta.run('!("A")')), '[[("A")]]')

        self.assertEqualMettaRunnerResults(metta.run("!(get-type 'A')"), [[S('Char')]])

        self.assertEqualMettaRunnerResults(metta.run('!(get-type "A")'), [[S('String')]])

    def assertEqualMettaRunnerResults(self, left, right):

        self.assertEqual(len(actual), len(expected),
                "Actual and expected contains different number of atoms:" +
                f"\n{actual}\n{expected}")

        self.assertEqual(repr(output),
            '[(do-mine ((: stone type) (: stone variant)))]')

        self.assertEqual(S("a"), S("a"))

        self.assertEqual(str(S("a")), "a")

        self.assertEqual(S("a").get_metatype(), AtomKind.SYMBOL)

        self.assertEqual(S("a").get_name(), "a")

        self.assertEqual(S("здравствуйте").get_name(), "здравствуйте")

        self.assertEqual(V("x"), V("x"))

        self.assertEqual(str(V("x")), "$x")

        self.assertEqual(V("x").get_metatype(), AtomKind.VARIABLE)

        self.assertEqual(V("x").get_name(), "x")

        self.assertEqual(ValueAtom(1.0), ValueAtom(1.0))

        self.assertEqual(str(ValueAtom(1.0)), "1.0")

        self.assertEqual(str(ValueAtom("1.0")), '"1.0"')

        self.assertEqual(ValueAtom(1.0).get_metatype(), AtomKind.GROUNDED)

        self.assertEqual(atom.get_grounded_type(), S("Float"))

        self.assertEqual("Method copy should be implemented by grounded object",
                        str(context.exception))

        # self.assertEqual(ValueAtom(1.0).get_object().execute(VecAtom(),
            # VecAtom()), "1.0 is not executable")

        self.assertEqual(res, [ValueAtom(2.0)])

        self.assertEqual(E(S("+"), S("1"), S("2")),
                E(S("+"), S("1"), S("2")))

        self.assertEqual(E(x2Atom, ValueAtom(1.0)),
                E(x2Atom, ValueAtom(1.0)))

        self.assertEqual(str(E(x2Atom, ValueAtom(1.0))), "(*2 1.0)")

        self.assertEqual(E(x2Atom, ValueAtom(1.0)).get_metatype(), AtomKind.EXPR)

        self.assertEqual(E(x2Atom, ValueAtom(1.0)).get_children(),
                [x2Atom, ValueAtom(1.0)])

        self.assertEqual(kb_a.get_atoms(), kb_b.get_atoms())

        self.assertEqual(kb_a, kb_c)

        self.assertEqual(interpret(space, x2), [ValueAtom(2)])

        self.assertEqual(interpret(space, E(Atoms.METTA, expr, AtomType.UNDEFINED, G(space))),
                [E(S('Error'), expr, S('Grounded operation which is defined using unwrap=False should return atom instead of Python type'))])

        self.assertEqual(interpret(space, printExpr), [E()])

        self.assertEqual(interpret(space, expr),
                [E(noReduceAtom, ValueAtom(1))])

        self.assertEqual(AtomKind.SYMBOL.name, str(result[0]['atom_type']))

        self.assertEqual(AtomKind.EXPR.name, str(result[0]['atom_type']))

        self.assertEqual(AtomKind.GROUNDED.name, str(result[0]['atom_type']))

        self.assertEqual(S("MatchableAtom").get_name(), str(result[0]['Z']))

        self.assertEqual(
            metta.run('''
              !(import! &self extension)
              !(get-by-key &my-dict "A")
              !(get-by-key &my-dict 6)
            '''),
            [[E()],
             [ValueAtom(5)],
             [ValueAtom('B')]])

        self.assertEqual(
              metta.run('! &runner')[0][0].get_object().value, metta)

        self.assertEqual(
            metta.run('''
              !(import! &self ext_dir)
              !(get-by-key &my-dict "A")
              !(get-by-key &my-dict 6)
            '''),
            [[E()],
             [ValueAtom(5)],
             [ValueAtom('B')]])

        self.assertEqual(
              metta.run('! &runner')[0][0].get_object().value, metta)

    #     self.assertEqual(
    #         metta.run('''
    #           !(import! &self ext_sub)
    #           !(get-by-key &my-dict "A")
    #           !(get-by-key &my-dict 6)
    #         '''),
    #         [[E()],
    #          [ValueAtom(5)],
    #          [ValueAtom('B')]])

    #     self.assertEqual(
    #           metta.run('! &runner')[0][0].get_object().value, metta)

        self.assertEqual(
            metta.run('''
              !(import! &self ext_recursive:level-2:ext_nested)
              !(get-by-key &my-dict "A")
              !(get-by-key &my-dict 6)
            '''),
            [[E()],
             [ValueAtom(5)],
             [ValueAtom('B')]])

        self.assertEqual(
              metta.run('! &runner')[0][0].get_object().value, metta)

        self.assertEqual(g_object, None)

        metta.run('''
          !(import! &self extension)
          !(set-global! 42)
        ''')

        self.assertEqual(
          metta.run('!(get-global)'),
          metta.run('! 42'))

        self.assertEqual(g_object, 42)

        result = metta.run("!(import! &self error_pyext)")

        self.assertEqual(S('Error'), result[0][0].get_children()[0])

        self.assertEqual(result[0].get_object().content, 3.14159)

        result = metta.run("""
            (three isprime)
            !(match &self ($x isprime) $x)
            !(include test_include)
            !(match &self ($x isprime) $x)
        """)

        result = metta.run("!(match &self ($x notprime) $x)")

        self.assertEqual(result[0], [S("six")])

        self.assertEqual([[S("B")]], result)

        metta.run(f'''
            !(bind! &space (new-space))
            !(load-ascii &space {test_file})
        ''')

        content = metta.run("!(match &space $x $x)")[0]

        self.assertEqual(get_atom_types(space, E(S("foo"), S("a"))), [S("B")])

        self.assertEqual(get_atom_types(space, E(S("foo"), S("b"))),
                [])

        self.assertEqual(get_atom_types(space, S("foo")), [E(S("->"), S("A"), S("B"))])

        #self.assertEqual(hp.bindings_to_str(bindings), "{  }")

        self.assertEqual(bindings_as_str, "{ $x = y, $a = b }")

            self.assertEqual(self.emptyBindings, cloned_empty)

                self.assertEqual(self.bindings, cloned)

                self.assertEqual(cloned, cloned_explicitly)

        self.assertEqual(self.bindings, self.bindings)

        self.assertEqual(self.emptyBindings, self.emptyBindings)

        self.assertEqual(BindingsSet(self.emptyBindings), merged_empty)

        self.assertEqual(merged_with_empty_rl, merged_with_empty_lr)

        self.assertEqual(merged_with_empty_rl, BindingsSet(self.bindings))

        self.assertEqual(merged_self, BindingsSet(self.bindings))

        self.assertEqual(atom_expected, atom_resolved)

            self.assertEqual(expected_name, x[0])

            self.assertEqual(expected_atom, x[1])

        self.assertEqual(set, no_longer_empty_set);

        self.assertEqual(set, set_2)

        self.assertEqual(set, cloned_set)

        self.assertEqual(1, bindings_counter)

        self.assertEqual(len(set_bindings_list), 1)

        self.assertEqual(new_set, expected_bindings_set)

        self.assertEqual(leaf_node_types, expected_node_types)

            self.assertEqual(e.args[0], 'Unclosed String Literal')

            self.assertEqual(e.args[0], 'Unexpected end of expression')

        for result in metta.run(program):

            losses += [metta.run('''
                ! (do-step-loss (loss-fn (classify &inputs) (get-labels &inputs)))
            ''')[0][0].get_object().value]

        runner = metta.run('! ' + runner_name)[0][0].get_object()

        runner = metta.run('! ' + runner_name)[0][0].get_object()