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 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 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_predicate__eq__str__repr():
foo2 = Functor('foo', 2)
mod = Module(Atom('mod'))
foo2_no_module = Predicate(foo2)
foo2_mod = Predicate(foo2, mod)
foo2_no_module_name_arity = Predicate.from_name_arity('foo', 2)
assert_equal(foo2_no_module, foo2_no_module_name_arity)
assert_not_equal(foo2_no_module, foo2_mod)
assert_not_equal(foo2_no_module_name_arity, foo2_mod)
assert_equal(foo2_no_module, foo2_no_module)
assert_equal(foo2_mod, foo2_mod)
assert_equal(foo2_no_module_name_arity, foo2_no_module_name_arity)
assert_equal(str(foo2_no_module), 'user:foo/2')
assert_equal(str(foo2_no_module_name_arity), 'user:foo/2')
assert_equal(str(foo2_mod), 'mod:foo/2')
assert_equal(repr(foo2_no_module),
'Predicate(functor={functor!r}, module={module!r})'.format(
functor=foo2, module=Module.current_context()))
assert_equal(repr(foo2_mod),
'Predicate(functor={functor!r}, module={module!r})'.format(
functor=foo2, module=mod))
def check_predicate(name, arity, module=None, predicate=None):
if isinstance(name, str):
name = Atom(name)
if isinstance(module, str):
module = Module(Atom(module))
module_str = str(module) if module is not None else None
if predicate is None:
check_predicate(name=name, arity=arity, module=module,
predicate=Predicate.from_name_arity(
name=str(name), arity=arity,
module_name=module_str)
)
check_predicate(name=name, arity=arity, module=module,
predicate=Predicate(
functor=Functor(name=name, arity=arity),
module=module))
return
stored_module = Module.current_context() if module is None else module
assert_equal(str(predicate), '{module!s}:{name!s}/{arity!s}'.format(
module=stored_module, name=name, arity=arity))
assert_equal(repr(predicate),
'Predicate(functor={functor!r}, module={module!r})'.format(
functor=Functor(name=name, arity=arity),
module=stored_module))
info = predicate.get_info()
assert_equal(info.name, name)
assert_equal(info.arity, arity)
assert_equal(info.module, stored_module)
assert_equal(predicate, predicate)
assert_equal(predicate, Predicate(functor=Functor(name, arity),
module=module))
assert_equal(predicate,
Predicate.from_name_arity(str(name), arity, module_str))
assert_equal(hash(predicate), hash(Predicate(functor=Functor(name, arity),
module=module)))
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_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 test_unification_eq(self):
X = Term()
assert_not_equal(self.term, X)
Predicate.from_name_arity('=', 2)(self.term, X)
assert_equal(self.term, X)
def setup(self):
self.retractall = Predicate.from_name_arity('retractall', 1)
self.assertz = Predicate.from_name_arity('assertz', 1)
self.dynamic = Predicate.from_name_arity('dynamic', 1)
self.call = Predicate.from_name_arity('call', 1)
self.rule = Functor(':-', 2)