def test_add_known_item(self):
"""Test that OrderedSet.add(known) returns False."""
contents = ["foo", "bar", "baz"]
known = contents[1]
os = utility.OrderedSet(contents)
self.assertFalse(os.add(known))
self.assertEqual(list(os), contents)
def test_discard_unknown_item(self):
"""Test that OrderedSet.discard(unknown) returns False."""
contents = ["foo", "bar", "baz"]
unknown = "qux"
os = utility.OrderedSet(contents)
self.assertFalse(os.discard(unknown))
self.assertEqual(list(os), contents)
def test_add_unknown_item(self):
"""Test that OrderedSet.add(unknown) returns True."""
contents = ["foo", "bar", "baz"]
unknown = "qux"
os = utility.OrderedSet(contents)
self.assertTrue(os.add(unknown))
self.assertEqual(list(os), contents + [unknown])
def test_creation_with_duplicates(self):
""""Test that OrderedSet instantiation removes duplicates."""
contents = ["foo", "bar", "foo", "baz"]
os = utility.OrderedSet(contents)
self.assertNotEqual(list(os), contents)
self.assertEqual(len(os), len(contents) - 1)
self.assertEqual(set(os), set(contents))
def add_rule(self, key, rule):
"""Add a rule to the Ruleset
@rule can be a Rule or a Fact. Returns True if add_rule() changes the
RuleSet.
"""
if isinstance(rule, compile.Fact):
# If the rule is a Fact, then add it to self.facts.
if key not in self.facts:
self.facts[key] = factset.FactSet()
return self.facts[key].add(rule)
elif len(rule.body) == 0 and not rule.head.is_negated():
# If the rule is a Rule, with no body, then it's a Fact, so
# convert the Rule to a Fact to a Fact and add to self.facts.
f = compile.Fact(key, (a.name for a in rule.head.arguments))
if key not in self.facts:
self.facts[key] = factset.FactSet()
return self.facts[key].add(f)
else:
# else the rule is a regular rule, so add it to self.rules.
if key in self.rules:
return self.rules[key].add(rule)
else:
self.rules[key] = utility.OrderedSet([rule])
return True
def test_creation_simple(self):
""""Test basic OrderedSet instantiation."""
contents = ["foo", "bar", "baz"]
os = utility.OrderedSet(contents)
self.assertEqual(list(os), contents)
self.assertEqual(len(os), len(contents))
self.assertEqual(set(os), set(contents))
def test_discard_known_item(self):
"""Test that OrderedSet.discard(known) returns True."""
contents = ["foo", "bar", "baz"]
known = contents[1]
new_contents = [x for x in contents if x != known]
os = utility.OrderedSet(contents)
self.assertTrue(os.discard(known))
self.assertEqual(list(os), new_contents)
def test_equals_other_iterable(self):
"""Test that OrderedSet-to-other-iterable equality returns False."""
contents = ["foo", "bar", "baz"]
os = utility.OrderedSet(contents)
self.assertNotEqual(os, set(os))
self.assertNotEqual(os, frozenset(os))
self.assertNotEqual(os, list(os))
self.assertNotEqual(os, tuple(os))
self.assertNotEqual(os, {x: 0 for x in os})
def test_contains(self):
"""Test that basic OrderedSet.__contains__ functionality works."""
contents = ["foo", "bar", "baz"]
missing = "qux"
os = utility.OrderedSet(contents)
self.assertTrue(all(x in os for x in contents))
self.assertNotIn(missing, os)
discarded = contents[1]
os.discard(discarded)
self.assertTrue(all(x in os for x in contents if x != discarded))
self.assertNotIn(discarded, os)
def insert_delta(self, delta):
"""Insert a delta rule."""
self.log(None, "Inserting delta rule %s", delta)
# views (tables occurring in head)
if delta.head.table.table in self.views:
self.views[delta.head.table.table] += 1
else:
self.views[delta.head.table.table] = 1
# tables
for table in delta.tablenames():
if table in self.all_tables:
self.all_tables[table] += 1
else:
self.all_tables[table] = 1
# contents
if delta.trigger.table.table not in self.rules:
self.rules[delta.trigger.table.table] = utility.OrderedSet()
self.rules[delta.trigger.table.table].add(delta)
def __init__(self):
self._facts = utility.OrderedSet()
# key is a sorted tuple of column indices, values are dict mapping a
# specific value for the key to a set of Facts.
self._indicies = {}
def test_pop_not_first_item(self):
"""Test that OrderedSet.pop(last=False) returns the first item."""
contents = ["foo", "bar", "baz"]
os = utility.OrderedSet(contents)
self.assertEqual(os.pop(last=False), contents[0])
self.assertEqual(list(os), contents[1:])
def test_pop_last_item(self):
"""Test that OrderedSet.pop() returns the final item."""
contents = ["foo", "bar", "baz"]
os = utility.OrderedSet(contents)
self.assertEqual(os.pop(), contents[-1])
self.assertEqual(list(os), contents[:-1])
def test_equals_other_ordered_set(self):
"""Test that OrderedSet equality accounts for order."""
contents = ["foo", "bar", "baz"]
os = utility.OrderedSet(contents)
self.assertNotEqual(os, utility.OrderedSet(reversed(os)))
self.assertEqual(os, utility.OrderedSet(contents))
def test_reversed_reverses_order(self):
"""Test that reversed(OrderedSet()) reverses correctly."""
contents = ["foo", "bar", "baz"]
os = utility.OrderedSet(contents)
self.assertEqual(list(reversed(os)), list(reversed(contents)))
def clear_table(self, table):
self.rules[table] = utility.OrderedSet()
self.facts[table] = factset.FactSet()
