def test_term_equality():
a = Term.from_atom_name('a')
b = Term.from_atom_name('b')
eq = Predicate.from_name_arity('=', 2)
assert_true(eq(a, a))
assert_false(eq(a, b))
def test_knowledge_database_1(self):
self.dynamic(Term.from_functor(woman))
self.dynamic(rock_concert)
self.assertz(woman(mia))
self.assertz(woman(jody))
self.assertz(woman(yolanda))
self.assertz(plays_air_guitar(jody))
self.assertz(party)
assert_true(woman(mia)())
assert_true(woman(jody)())
assert_true(woman(yolanda)())
assert_false(woman(Term.from_atom_name('bob'))())
once = Functor('once', 1)
once_pred = Predicate(once)
assert_true(once_pred(woman(mia)))
once_pred(woman(mia), check=True)
assert_false(once_pred(woman(Term.from_atom_name('bob'))))
assert_true(plays_air_guitar(jody)())
assert_false(plays_air_guitar(mia)())
assert_true(party())
assert_false(Term.from_atom_name('rockConcert')())
def test_term__eq__():
foo = Term.from_atom_name('foo')
assert foo == foo
bar = Term.from_atom_name('bar')
assert foo != bar
assert foo != Term()
assert Term() != Term()
def test_term_logic():
true = Term.from_atom_name('true')
false = Term.from_atom_name('false')
assert_true(true())
assert_false(false())
assert_true((true | false)())
assert_false((true & false)())
assert_false((false & true | false)())
assert_true((false & false | true)())
assert_false((false & (false | true))())
def test_term__or__():
a = Term.from_atom_name('a')
b = Term.from_atom_name('b')
eq = Functor('=', 2)
assert_true((eq(a, b) | eq(a, a))())
assert_false((eq(a, b) | eq(b, a))())
X = Term()
assert_true((eq(X, a) | eq(X, b))())
assert X == a or X == b
assert_equal(str(eq(a, a) | eq(a, b)), 'a=a;a=b')
def test_term_variable_assignment():
a = Term.from_atom_name('a')
b = Term.from_atom_name('b')
eq = Predicate.from_name_arity('=', 2)
X = Term()
assert_true(eq(X, a))
assert_equal(X, a)
assert_false(eq(X, b))
assert_true(eq(Term(), b))
X.put_variable()
assert_true(eq(X, b))
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 __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 __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_term__and__():
a = Term.from_atom_name('a')
b = Term.from_atom_name('b')
eq = Functor('=', 2)
assert_true((eq(a, a) & eq(b, b))())
assert_false((eq(a, b) & eq(a, a))())
assert_false((eq(a, a) & eq(a, b))())
X = Term()
Y = Term()
assert_true((eq(X, a) & eq(Y, a) & eq(X, Y))())
assert_equal(X, Y)
X.put_variable()
Y.put_variable()
assert_false((eq(X, a) & eq(X, b))())
assert_equal(str(eq(a, a) & eq(a, b)), 'a=a,a=b')
def test_frame_dynamic_database():
dynamic = Predicate.from_name_arity('dynamic', 1)
assertz = Predicate.from_name_arity('assertz', 1)
foo = Functor('foo', 1)
a = Term.from_atom_name('a')
dynamic(foo(Term()))
with Frame(discard=True):
assertz(foo(a))
assert_true(foo(a)())
# Frames have no effect on the dynamic database
assert_true(foo(a)())
def __init__(self):
super().__init__('[bar]')
self.term = Term.from_cons_list(Term.from_atom_name('bar'),
Term.from_nil())
def __init__(self):
super().__init__('atom', term=Term.from_atom_name('atom'))
def test_term_atom():
foo = Term.from_atom_name('foo')
assert_equal(foo.type(), 'atom')
assert_equal(str(foo), 'foo')
# Tests based on the content of "Learn Prolog Now"
# http://www.learnprolognow.org/
from nose.tools import assert_true, assert_false, assert_equal
from swilite.prolog import (Functor, Term, Predicate, Query, Frame)
# Common terms
happy = Functor('happy', 1)
jealous = Functor('jealous', 2)
listens_2_music = Functor('listens2Music', 1)
loves = Functor('loves', 2)
plays_air_guitar = Functor('plays_air_guitar', 1)
woman = Functor('woman', 1)
mia = Term.from_atom_name('mia')
jody = Term.from_atom_name('jody')
yolanda = Term.from_atom_name('yolanda')
vincent = Term.from_atom_name('vincent')
butch = Term.from_atom_name('butch')
marcellus = Term.from_atom_name('marcellus')
honey_bunny = Term.from_atom_name('honey_bunny')
pumpkin = Term.from_atom_name('pumpkin')
party = Term.from_atom_name('party')
rock_concert = Term.from_atom_name('rockConcert')
class BasicKeywords():
