def _evaluate_query_term_next_solution(query, var): with query as active_query: assert_true(active_query.next_solution()) assert_equal(var, Term.from_integer(1)) assert_true(active_query.next_solution()) assert_equal(var, Term.from_integer(2)) assert_false(active_query.next_solution())
def _make_query__init__arglist(var): eq = Functor('=', 2) or_ = Predicate(Functor(';', 2)) args = TermList(2) args[0].put_cons_functor(eq, var, Term.from_integer(1)) args[1].put_cons_functor(eq, var, Term.from_integer(2)) return Query(or_, arglist=args)
def __init__(self): super().__init__('[-1,2,a,3.4]') self.term = Term.from_list_terms([ Term.from_integer(-1), Term.from_integer(2), Term.from_atom_name('a'), Term.from_float(3.4)])
def test_lines_example(self): point = Functor('point', 2) line = Functor('line', 2) vertical = Functor('vectical', 1) horizontal = Functor('horizontal', 1) with Frame(): X = Term() Y = Term() Z = Term() self.assertz(vertical(line(point(X, Y), point(X, Z)))) self.assertz(horizontal(line(point(X, Y), point(Z, Y)))) _1 = Term.from_integer(1) _2 = Term.from_integer(2) _3 = Term.from_integer(3) assert_true(vertical(line(point(_1, _1), point(_1, _3)))()) assert_false(vertical(line(point(_1, _1), point(_3, _2)))()) with Frame(): Y = Term() assert_true(horizontal(line(point(_1, _1), point(_2, Y)))()) assert_equal(Y, _1) with Frame(): P = Term() expr = horizontal(line(point(_2, _3), P)) res = list(Query(self.call, expr).term_assignments(P, True)) assert_equal(len(res), 1) assert_true(res[0].get().unify(point(Term(), _3)))
def test_frame_close(): f1 = Frame() t1 = f1.term() t1.put_atom_name('t1') assert_equal(str(t1), 't1') f1.close() with assert_raises(AttributeError): str(t1) with assert_raises(AttributeError): f1.close() with Frame() as f2: t2 = f2.term() t2.put_atom_name('t2') assert_equal(str(t2), 't2') with assert_raises(AttributeError): str(t2) with assert_raises(AttributeError): f2.close() X = Term() with Frame(): X.put_integer(1) assert_equal(str(X), '1') assert_equal(str(X), '1') eq = Predicate.from_name_arity('=', 2) X = Term() with Frame(): eq(X, Term.from_integer(1)) assert_equal(str(X), '1') assert_equal(str(X), '1')
def __init__(self): super().__init__("[1,a]") tail = Term.from_list() tail.unify_arg(0, Term.from_atom_name('a')) tail.unify_arg(1, Term.from_nil()) self.term = Term.from_list() self.term.unify_arg(0, Term.from_integer(1)) self.term.unify_arg(1, tail)
def test_frame_rewind(): X = Term() with Frame() as f: t = f.term() t.put_integer(1) X.unify_integer(2) assert_equal(t, Term.from_integer(1)) assert_equal(X, Term.from_integer(2)) f.rewind() with assert_raises(AttributeError): str(t) assert_equal(X.type(), 'variable') X.unify_integer(3) assert_equal(X, Term.from_integer(3)) f.rewind() assert_equal(X.type(), 'variable') X.unify_integer(2) assert_equal(X, Term.from_integer(2))
def test_basic_unification(self): assert_true(mia.unify(mia)) two = Term.from_integer(2) assert_true(two, two) assert_false(mia.unify(vincent)) with Frame(): assert_true(Term().unify(mia)) with Frame(): assert_true(Term().unify(Term())) with Frame(): X = Term() assert_true(X.unify(mia)) assert_false(X.unify(vincent)) k = Functor('k', 2) s = Functor('s', 1) t = Functor('t', 1) g = Term.from_atom_name('g') k_atom = Term.from_atom_name('k') with Frame(): X = Term() Y = Term() assert_true(k(s(g), Y).unify(k(X, t(k_atom)))) assert_equal(X, s(g)) assert_equal(Y, t(k_atom)) with Frame(): X = Term() Y = Term() assert_true(k(s(g), t(k_atom)).unify(k(X, t(Y)))) assert_equal(X, s(g)) assert_equal(Y, k_atom) self.retractall(loves(Term(), Term())) self.assertz(loves(vincent, mia)) self.assertz(loves(marcellus, mia)) self.assertz(loves(pumpkin, honey_bunny)) self.assertz(loves(honey_bunny, pumpkin)) with Frame(): X = Term() assert_false(loves(X, X).unify(loves(marcellus, mia)))
def test_frame_discard(): eq = Predicate.from_name_arity('=', 2) X = Term() with Frame(discard=True): X.put_integer(1) assert_equal(str(X), '1') assert_equal(str(X), '1') X = Term() with Frame(discard=True): eq(X, Term.from_integer(1)) assert_equal(str(X), '1') assert_equal(X.type(), 'integer') assert_not_equal(str(X), '1') assert_equal(X.type(), 'variable')
def _make_query_call_term(var): eq = Functor('=', 2) or_ = Functor(';', 2) return Query.call_term(or_(eq(var, Term.from_integer(1)), eq(var, Term.from_integer(2))))
def _make_query__init__(var): eq = Functor('=', 2) or_ = Predicate(Functor(';', 2)) return Query(or_, eq(var, Term.from_integer(1)), eq(var, Term.from_integer(2)))
def __init__(self): super().__init__('@(%v,[%v=[5|%v]])', is_acyclic=False) self.term = Term.from_list() self.term.unify_arg(0, Term.from_integer(5)) self.term.unify_arg(1, self.term)
def __init__(self): super().__init__("[1|2]") self.term = Term.from_list() self.term.unify_arg(0, Term.from_integer(1)) self.term.unify_arg(1, Term.from_integer(2))
def __init__(self): super().__init__('[1]') self.term = Term.from_list() self.term.unify_arg(0, Term.from_integer(1)) self.term.unify_arg(1, Term.from_nil())
def __init__(self, value): super().__init__(type_='integer', value=value, prolog_string=str(value)) self.term = Term.from_integer(value)
def _evaluate_query_term_assignments_persistent(query, var): assignments = list(query.term_assignments(var, persistent=True)) assert_equal(len(assignments), 2) assert_equal(assignments[0].get(), Term.from_integer(1)) assert_equal(assignments[1].get(), Term.from_integer(2))