def test_constructor_full(self):
eprint(
">> Continuum.__init__(self, min_value=None, max_value=None, min_included=None, max_included=None)"
)
for i in range(self.__nb_unit_test):
# Valid continuum
#-----------------
min = random.uniform(self.__min_value, self.__max_value)
max = random.uniform(min, self.__max_value)
min_included = random.choice([True, False])
max_included = random.choice([True, False])
c = Continuum(min, max, min_included, max_included)
self.assertFalse(c.is_empty())
self.assertEqual(c.get_min_value(), min)
self.assertEqual(c.get_max_value(), max)
self.assertEqual(c.min_included(), min_included)
self.assertEqual(c.max_included(), max_included)
# Implicit emptyset
#-------------------
min = random.uniform(self.__min_value, self.__max_value)
c = Continuum(min, min, False, False)
self.assertTrue(c.is_empty())
self.assertEqual(c.get_min_value(), None)
self.assertEqual(c.get_max_value(), None)
self.assertEqual(c.min_included(), None)
self.assertEqual(c.max_included(), None)
# Invalid Continuum
#--------------------
max = random.uniform(self.__min_value, min - 0.001)
self.assertRaises(ValueError, Continuum, min, max, min_included,
max_included)
# Invalid number of arguments
#-------------------------------
self.assertRaises(ValueError, Continuum, min)
self.assertRaises(ValueError, Continuum, min, max)
self.assertRaises(ValueError, Continuum, min, max, min_included)
self.assertRaises(ValueError, Continuum, min, max, min_included,
max_included)
def test_to_string(self):
eprint(">> Continuum.to_string(self)")
for i in range(self.__nb_unit_test):
c = Continuum()
self.assertEqual(c.to_string(), u"\u2205")
c = Continuum.random(self.__min_value, self.__max_value)
if c.is_empty():
self.assertEqual(c.to_string(), u"\u2205")
out = ""
if c.min_included():
out += "["
else:
out += "]"
out += str(c.get_min_value()) + "," + str(c.get_max_value())
if c.max_included():
out += "]"
else:
out += "["
self.assertEqual(c.to_string(), out)
self.assertEqual(c.__str__(), out)
self.assertEqual(c.__repr__(), out)
def test_constructor_empty(self):
eprint(">> Continuum.__init__(self)")
for i in range(self.__nb_unit_test):
c = Continuum()
self.assertTrue(c.is_empty())
self.assertEqual(c.get_min_value(), None)
self.assertEqual(c.get_max_value(), None)
self.assertEqual(c.min_included(), None)
self.assertEqual(c.max_included(), None)
def test_size(self):
eprint(">> Continuum.size(self)")
for i in range(self.__nb_unit_test):
# empty set
c = Continuum()
self.assertEqual(c.size(), 0.0)
# regular
c = Continuum.random(self.__min_value, self.__max_value)
if not c.is_empty():
self.assertEqual(c.size(),
c.get_max_value() - c.get_min_value())
def test_dominates(self):
print(">> ContinuumRule.dominates(self, rule)")
for i in range(self.__nb_unit_test):
variables, domains = self.random_system()
var = random.randint(0, len(variables) - 1)
r = self.random_rule(variables, domains)
# Undominated rule: var = emptyset if anything
r0 = ContinuumRule(r.get_head_variable(), Continuum())
self.assertTrue(r0.dominates(r0))
# r1 is a regular rule
r1 = self.random_rule(variables, domains)
while r1.size() == 0:
r1 = self.random_rule(variables, domains)
var = r.get_head_variable()
val = Continuum.random(domains[var].get_min_value(),
domains[var].get_max_value())
r1 = ContinuumRule(var, val, r1.get_body()) # set head
self.assertTrue(r0.dominates(r1))
self.assertFalse(r1.dominates(r0))
# r2 is precision of r1 (head specification)
r2 = r1.copy()
var = r2.get_head_variable()
val = r2.get_head_value()
while r2.get_head_value(
) == val or not r2.get_head_value().includes(val):
val = Continuum.random(val.get_min_value(),
val.get_max_value())
r2.set_head_value(val)
self.assertEqual(r0.dominates(r2), True)
self.assertEqual(r2.dominates(r0), False)
self.assertEqual(r2.dominates(r1), True)
self.assertEqual(r1.dominates(r2), False)
# r3 is a generalization of r1 (body generalization)
r3 = r1.copy()
var, val = random.choice(r3.get_body())
val_ = val
modif_min = random.uniform(0, self.__max_value)
modif_max = random.uniform(0, self.__max_value)
while val_ == val or not val_.includes(val):
val_ = Continuum.random(val.get_min_value() - modif_min,
val.get_max_value() + modif_max)
r3.set_condition(var, val_)
self.assertEqual(r0.dominates(r3), True)
self.assertEqual(r3.dominates(r0), False)
self.assertEqual(r3.dominates(r1), True)
self.assertEqual(r1.dominates(r3), False)
# r4 is unprecision of r1 (head generalization)
r4 = r1.copy()
var = r4.get_head_variable()
val = r4.get_head_value()
modif_min = random.uniform(0, self.__max_value)
modif_max = random.uniform(0, self.__max_value)
while r4.get_head_value() == val or not val.includes(
r4.get_head_value()):
val = Continuum(val.get_min_value() - modif_min,
val.get_max_value() + modif_max,
random.choice([True, False]),
random.choice([True, False]))
r4.set_head_value(val)
self.assertEqual(r0.dominates(r4), True)
self.assertEqual(r4.dominates(r0), False)
self.assertEqual(r4.dominates(r1), False)
self.assertEqual(r1.dominates(r4), True)
# r5 is specialization of r1 (body specialization)
r5 = r1.copy()
var, val = random.choice(r5.get_body())
val_ = val
while val_ == val or not val.includes(val_):
val_ = Continuum.random(val.get_min_value(),
val.get_max_value())
r5.set_condition(var, val_)
self.assertEqual(r0.dominates(r5), True)
self.assertEqual(r5.dominates(r0), False)
self.assertEqual(r5.dominates(r1), False)
self.assertEqual(r1.dominates(r5), True)
# r6 is a random rule
r6 = self.random_rule(variables, domains)
# head var difference
if r6.get_head_variable() != r1.get_head_variable():
self.assertFalse(r6.dominates(r1))
self.assertFalse(r1.dominates(r6))
r6 = ContinuumRule(r1.get_head_variable(), r6.get_head_value(),
r6.get_body()) # same head var
#eprint("r1: ", r1)
#eprint("r6: ", r6)
# head val inclusion
if not r1.get_head_value().includes(r6.get_head_value()):
self.assertFalse(r6.dominates(r1))
r6 = ContinuumRule(r1.get_head_variable(), r1.get_head_value(),
r6.get_body()) # same head var, same head val
# body subsumption
if r1.dominates(r6):
for var, val in r1.get_body():
self.assertTrue(val.includes(r6.get_condition(var)))
# body subsumption
if r6.dominates(r1):
for var, val in r6.get_body():
self.assertTrue(val.includes(r1.get_condition(var)))
# incomparable
if not r1.dominates(r6) and not r6.dominates(r1):
#eprint("r1: ", r1)
#eprint("r6: ", r6)
conflicts = False
dominant_r1 = False
dominant_r6 = False
for var, val in r1.get_body():
# condition not appearing
if not r6.has_condition(var):
conflicts = True
break
# value not included
if not r6.get_condition(var).includes(
val) and not val.includes(r6.get_condition(var)):
conflicts = True
break
# local dominates
if val.includes(r6.get_condition(var)):
dominant_r1 = True
# local dominated
if r6.get_condition(var).includes(val):
if dominant_r1:
conflicts = True
break
for var, val in r6.get_body():
# condition not appearing
if not r1.has_condition(var):
conflicts = True
break
# value not included
if not r1.get_condition(var).includes(
val) and not val.includes(r1.get_condition(var)):
conflicts = True
break
# local dominates
if val.includes(r1.get_condition(var)):
dominant_r6 = True
if dominant_r1:
conflicts = True
break
# local dominated
if r1.get_condition(var).includes(val):
if dominant_r6:
conflicts = True
break
self.assertTrue(conflicts)
def test_set_upper_bound(self):
eprint(">> Continuum.set_upper_bound(self, value, included)")
for i in range(self.__nb_unit_test):
# Empty set
c = Continuum()
self.assertRaises(TypeError, c.set_upper_bound, "string", True)
self.assertRaises(TypeError, c.set_upper_bound, "string", False)
self.assertRaises(TypeError, c.set_upper_bound, 0.5, 10)
value = random.uniform(self.__min_value, self.__max_value)
# extend with exclusion gives empty set, mistake expected from user
# or both min and max will be changed and constructor must be used
self.assertRaises(ValueError, c.set_upper_bound, value, False)
c.set_upper_bound(value, True)
# Empty set to one value interval
self.assertEqual(c, Continuum(value, value, True, True))
# Regular continuum
# over min value
c = Continuum.random(self.__min_value, self.__max_value)
value = random.uniform(self.__min_value, c.get_min_value())
while value == c.get_min_value():
value = random.uniform(self.__min_value, c.get_min_value())
self.assertRaises(ValueError, c.set_upper_bound, value, True)
self.assertRaises(ValueError, c.set_upper_bound, value, False)
# on min value
c = Continuum.random(self.__min_value, self.__max_value)
c_old = c.copy()
value = c.get_min_value()
if not c.max_included() or not c.min_included():
c.set_upper_bound(value, False)
self.assertEqual(c,
Continuum()) # continuum reduced to empty set
else:
c.set_upper_bound(value, True)
self.assertEqual(c.get_max_value(), value)
self.assertEqual(c.max_included(), True)
self.assertEqual(c.get_max_value(), c.get_min_value())
self.assertEqual(c.get_min_value(), c_old.get_min_value())
self.assertEqual(c.min_included(), c_old.min_included())
# other valid value
c = Continuum.random(self.__min_value, self.__max_value)
c_old = c.copy()
value = random.uniform(c.get_min_value(), self.__max_value)
while value == c.get_min_value():
value = random.uniform(c.get_min_value(), self.__max_value)
c.set_upper_bound(value, True)
self.assertEqual(c.get_max_value(), value)
self.assertEqual(c.max_included(), True)
c = Continuum.random(self.__min_value, self.__max_value)
c_old = c.copy()
value = random.uniform(c.get_min_value(), self.__max_value)
while value == c.get_min_value():
value = random.uniform(c.get_min_value(), self.__max_value)
c.set_upper_bound(value, False)
self.assertEqual(c.get_max_value(), value)
self.assertEqual(c.max_included(), False)
def test__eq__(self):
eprint(">> Continuum.__eq__(self, continuum)")
for i in range(self.__nb_unit_test):
# emptyset
c = Continuum()
self.assertTrue(Continuum() == Continuum())
self.assertTrue(c == Continuum())
self.assertTrue(c == c)
self.assertFalse(Continuum() != Continuum())
self.assertFalse(c != Continuum())
self.assertFalse(c != c)
c = Continuum.random(self.__min_value, self.__max_value)
self.assertTrue(c == c)
self.assertFalse(c != c)
self.assertEqual(c == Continuum(), c.is_empty())
c_ = Continuum.random(self.__min_value, self.__max_value)
if c.is_empty() and c_.is_empty():
self.assertTrue(c == c_)
self.assertTrue(c != c_)
if c.is_empty() != c_.is_empty():
self.assertFalse(c == c_)
self.assertTrue(c != c_)
if c.get_min_value() != c_.get_min_value():
self.assertFalse(c == c_)
self.assertTrue(c != c_)
if c.get_max_value() != c_.get_max_value():
self.assertFalse(c == c_)
self.assertTrue(c != c_)
if c.min_included() != c_.min_included():
self.assertFalse(c == c_)
self.assertTrue(c != c_)
if c.max_included() != c_.max_included():
self.assertFalse(c == c_)
self.assertTrue(c != c_)
# exaustive modifications
if not c.is_empty():
c_ = c.copy()
value = random.uniform(1, 100)
c_.set_lower_bound(c.get_min_value() - value, True)
self.assertFalse(c == c_)
self.assertTrue(c != c_)
c_.set_lower_bound(c.get_min_value() - value, False)
self.assertFalse(c == c_)
self.assertTrue(c != c_)
c_ = c.copy()
c_.set_lower_bound(c.get_min_value(), not c.min_included())
self.assertFalse(c == c_)
self.assertTrue(c != c_)
c_ = c.copy()
value = random.uniform(1, 100)
c_.set_upper_bound(c.get_min_value() + value, True)
self.assertFalse(c == c_)
self.assertTrue(c != c_)
c_.set_upper_bound(c.get_min_value() + value, False)
self.assertFalse(c == c_)
self.assertTrue(c != c_)
c_ = c.copy()
c_.set_upper_bound(c.get_max_value(), not c.max_included())
self.assertFalse(c == c_)
self.assertTrue(c != c_)
# different type
self.assertFalse(c == "test")
self.assertFalse(c == 0)
self.assertFalse(c == True)
self.assertFalse(c == [])
def test_intersects(self):
eprint(">> Continuum.intersects(self, continuum)")
for i in range(self.__nb_unit_test):
c = Continuum.random(self.__min_value, self.__max_value)
c_ = Continuum()
# emptyset
self.assertFalse(c.intersects(c_))
self.assertFalse(c_.intersects(c))
self.assertFalse(c_.intersects(c_))
# stricly before
c = Continuum.random(self.__min_value, self.__max_value)
c_ = Continuum.random(c.get_min_value() - 100, c.get_min_value())
self.assertFalse(c.intersects(c_))
self.assertFalse(c_.intersects(c))
# touching on lower bound
c = Continuum.random(self.__min_value, self.__max_value)
c_ = Continuum.random(c.get_min_value() - 100, c.get_min_value())
c_.set_upper_bound(c.get_min_value(), True)
self.assertEqual(c.intersects(c_), c.min_included())
self.assertEqual(c_.intersects(c), c.min_included())
c_.set_upper_bound(c.get_min_value(), False)
self.assertFalse(c.intersects(c_))
self.assertFalse(c_.intersects(c))
# strictly after
c = Continuum.random(self.__min_value, self.__max_value)
c_ = Continuum.random(c.get_max_value(), c.get_max_value() + 100)
self.assertFalse(c.intersects(c_))
self.assertFalse(c_.intersects(c))
# touching on lower bound
c = Continuum.random(self.__min_value, self.__max_value)
c_ = Continuum.random(c.get_max_value(), c.get_max_value() + 100)
c_.set_lower_bound(c.get_max_value(), True)
self.assertEqual(c.intersects(c_), c.max_included())
self.assertEqual(c_.intersects(c), c.max_included())
c_.set_lower_bound(c.get_max_value(), False)
self.assertFalse(c.intersects(c_))
self.assertFalse(c_.intersects(c))
# same (not empty)
c = Continuum.random(self.__min_value, self.__max_value)
while c.is_empty():
c = Continuum.random(self.__min_value, self.__max_value)
self.assertTrue(c.includes(c))
# smaller
c_ = Continuum.random(c.get_min_value(), c.get_max_value())
while c_.get_min_value() == c.get_min_value() and c_.get_max_value(
) == c.get_max_value():
c_ = Continuum.random(c.get_min_value(), c.get_max_value())
self.assertTrue(c.intersects(c_))
self.assertTrue(c_.intersects(c))
# bigger
c_ = Continuum.random(c.get_min_value() - 100,
c.get_max_value() + 100)
while c_.get_min_value() >= c.get_min_value() or c_.get_max_value(
) <= c.get_max_value():
c_ = Continuum.random(c.get_min_value() - 100,
c.get_max_value() + 100)
#eprint(c.to_string())
#eprint(c_.to_string())
self.assertTrue(c.intersects(c_))
self.assertTrue(c_.intersects(c))
def test_includes(self):
eprint(">> Continuum.includes(self, element)")
for i in range(self.__nb_unit_test):
# bad argument type
c = Continuum.random(self.__min_value, self.__max_value)
self.assertRaises(TypeError, c.includes, "test")
# float argument
#----------------
# empty set includes nothing
c = Continuum()
value = random.uniform(self.__min_value, self.__max_value)
self.assertFalse(c.includes(value))
c = Continuum.random(self.__min_value, self.__max_value)
# Before min
value = c.get_min_value()
while value == c.get_min_value():
value = random.uniform(c.get_min_value() - 100.0,
c.get_min_value())
self.assertFalse(c.includes(value))
# on min bound
self.assertEqual(c.includes(c.get_min_value()), c.min_included())
# Inside
value = c.get_min_value()
while value == c.get_min_value() or value == c.get_max_value():
value = random.uniform(c.get_min_value(), c.get_max_value())
self.assertTrue(c.includes(value))
# on max bound
self.assertEqual(c.includes(c.get_max_value()), c.max_included())
# after max bound
value = c.get_max_value()
while value == c.get_max_value():
value = random.uniform(c.get_max_value(),
c.get_max_value() + 100.0)
self.assertFalse(c.includes(value))
# int argument
#--------------
# empty set includes nothing
c = Continuum()
value = random.randint(int(self.__min_value),
int(self.__max_value))
self.assertFalse(c.includes(value))
c = Continuum.random(self.__min_value, self.__max_value)
while int(c.get_max_value()) - int(c.get_min_value()) <= 1:
min = random.uniform(self.__min_value, self.__max_value)
max = random.uniform(min, self.__max_value)
c = Continuum.random(min, max)
#eprint(c.to_string())
# Before min
value = random.randint(int(c.get_min_value() - 100),
int(c.get_min_value()) - 1)
self.assertFalse(c.includes(value))
# on min bound
self.assertEqual(c.includes(c.get_min_value()), c.min_included())
# Inside
value = random.randint(
int(c.get_min_value()) + 1,
int(c.get_max_value()) - 1)
#eprint(value)
self.assertTrue(c.includes(value))
# on max bound
self.assertEqual(c.includes(c.get_max_value()), c.max_included())
# after max bound
value = random.randint(
int(c.get_max_value()) + 1, int(c.get_max_value() + 100))
self.assertFalse(c.includes(value))
# continuum argument
#--------------------
# 0) c is empty set
c = Continuum()
c_ = Continuum()
self.assertTrue(c.includes(c_)) # empty set VS empty set
c_ = Continuum.random(self.__min_value, self.__max_value)
while c_.is_empty():
c_ = Continuum.random(self.__min_value, self.__max_value)
self.assertFalse(c.includes(c_)) # empty set VS non empty
# 1) c is non empty
c = Continuum.random(self.__min_value, self.__max_value)
self.assertTrue(c.includes(Continuum())) # non empty VS empty set
self.assertTrue(c.includes(c)) # includes itself
# 1.1) Lower bound over
c_ = Continuum.random(c.get_min_value(), self.__max_value)
while c_.is_empty():
c_ = Continuum.random(c.get_min_value(), self.__max_value)
value = c.get_min_value()
while value == c.get_min_value():
value = random.uniform(c.get_min_value() - 100,
c.get_min_value())
c_.set_lower_bound(value, random.choice([True, False]))
self.assertFalse(c.includes(c_))
# 1.2) on min bound
c_ = Continuum.random(c.get_min_value(), self.__max_value)
while c_.is_empty():
c_ = Continuum.random(c.get_min_value(), self.__max_value)
c_.set_lower_bound(c.get_min_value(), random.choice([True, False]))
if not c.min_included() and c_.min_included(): # one value over
self.assertFalse(c.includes(c_))
# 1.3) upper bound over
c_ = Continuum.random(self.__min_value, c.get_max_value())
while c_.is_empty():
c_ = Continuum.random(self.__min_value, c.get_max_value())
value = c.get_max_value()
while value == c.get_max_value():
value = random.uniform(c.get_max_value(),
c.get_max_value() + 100)
c_.set_upper_bound(value, random.choice([True, False]))
self.assertFalse(c.includes(c_))
# 1.4) on upper bound
c_ = Continuum.random(self.__min_value, c.get_max_value())
while c_.is_empty():
c_ = Continuum.random(self.__min_value, c.get_max_value())
c_.set_upper_bound(c.get_max_value(), random.choice([True, False]))
if not c.max_included() and c_.max_included(): # one value over
self.assertFalse(c.includes(c_))
# 1.5) inside
min = c.get_min_value()
while min == c.get_min_value():
min = random.uniform(c.get_min_value(), c.get_max_value())
max = c.get_max_value()
while max == c.get_max_value():
max = random.uniform(min, c.get_max_value())
c_ = Continuum(min, max, random.choice([True, False]),
random.choice([True, False]))
self.assertTrue(c.includes(c_))
self.assertFalse(c_.includes(c))