def test_if_values_in_value_are_tuples_not_all_weights_are_numbers(self):
""" If value is a tuple of less than 2 terms, it raises an error. """
with self.assertRaises(ValueError):
grammar.Or((
(grammar.SingleTerm('terminal'), 2),
(grammar.SingleTerm('terminal'), '8'),
))
def test_correct_construction(self):
""" If value is correct, the term is correctly initialized. """
value = (
grammar.SingleTerm('terminal1'),
'terminal2'
)
and_connector = grammar.And(*value)
self.assertEquals(value[0], and_connector.value[0])
self.assertEquals(grammar.SingleTerm(value[1]), and_connector.value[1])
def test_correct_construction_without_weights(self):
""" If value correct without weights, term is correctly initialized. """
value = (
grammar.SingleTerm('t1'),
't2',
)
or_connector = grammar.Or(*value)
self.assertEquals(value[0], or_connector.value[0])
self.assertEquals(grammar.SingleTerm(value[1]), or_connector.value[1])
self.assertEquals(tuple(1 for _ in value), or_connector.weights)
def test_correct_construction_with_weights(self):
""" If value correct with weights, term is correctly initialized. """
value_and_weights = (
(grammar.SingleTerm('t1'), 1),
('t2', 3),
)
value = tuple(t[0] for t in value_and_weights)
weights = tuple(t[1] for t in value_and_weights)
or_connector = grammar.Or(*value_and_weights)
self.assertEquals(value[0], or_connector.value[0])
self.assertEquals(grammar.SingleTerm(value[1]), or_connector.value[1])
self.assertEquals(weights, or_connector.weights)
def test_repeated_productions_are_shrunk(self):
""" If two or more productions has the same alpha, they're shrunk.
This implies that if two or more productions has the same alpha, they're
transformed in a single production with all the beta parts of the
productions separated by Or's.
"""
start_symbol = 'expr'
productions = [
grammar.Production(
'expr',
grammar.SingleTerm(str(i))
) for i in range(10)
]
a_grammar = grammar.Grammar(start_symbol, productions)
# The ten productions are transformed in One
self.assertEquals(len(a_grammar.productions), 1)
# The only term of the productions is an Or instance
production = a_grammar.productions[0]
self.assertEquals(start_symbol, production.variable)
self.assertIsInstance(production.term, grammar.Or)
# The Or term contains all the terms in initial productions.
value = production.term.value
for t in value:
self.assertIn(t, [p.term for p in productions])
for t in [p.term for p in productions]:
self.assertIn(t, value)
def test_not_all_values_in_value_tuple_are_not_term_string_or_tuple(self):
""" If value is a tuple of less than 2 terms, it raises an error. """
invalid_values = (
(grammar.SingleTerm('terminal'), 'a nice dog', 9),
(1, 2, 3, 4, 5),
)
for value in invalid_values:
with self.assertRaises(ValueError):
grammar.Or(value)
def test_not_all_values_in_value_tuple_are_terms_or_strings(self):
""" If elements in value are not Term, an error is raised. """
invalid_values = (
(grammar.SingleTerm('terminal'), 'a nice dog', 9),
(1, 2, 3, 4, 5),
)
for value in invalid_values:
with self.assertRaises(ValueError):
grammar.And(value)
def test_value_is_a_tuple_of_less_than_two_terms(self):
""" If value is a tuple of less than 2 terms, it raises an error. """
invalid_values = (
tuple(),
grammar.SingleTerm('terminal'),
)
for value in invalid_values:
with self.assertRaises(ValueError):
grammar.Or(value)
def test_different_instances_with_same_content_are_equal(self):
""" If two different instances has the same content are equal. """
value = (
grammar.SingleTerm('terminal1'),
'terminal2'
)
self.assertEquals(
grammar.And(*value),
grammar.And(*value),
)
def test_value_is_not_a_term_or_is_a_multiple_term(self):
""" Param value should be a term other than Multiplier instance. """
for invalid_value in (
[],
(),
{},
None,
grammar.Multiplier(grammar.SingleTerm('t')),
):
with self.assertRaises(ValueError):
grammar.Multiplier(invalid_value)
def test_correct_construction_with_term_with_lower_upper_and_p(self):
""" Correct construction with all params and a term instance. """
value = grammar.SingleTerm('t')
lower = 1
upper = 7
p = 0.75
multiplier = grammar.Multiplier(value, lower=lower, upper=upper, p=p)
self.assertEquals(value, multiplier.value)
self.assertEquals(lower, multiplier.lower)
self.assertEquals(upper, multiplier.upper)
self.assertAlmostEqual(p, multiplier.p)
def test_correct_construction_with_term_without_anything(self):
""" Correct construction without optional params and a term instance.
That means that "lower", "upper" and "p" take the correct values.
"""
value = grammar.SingleTerm('t')
multiplier = grammar.Multiplier(value)
self.assertEquals(value, multiplier.value)
self.assertEquals(self.__default_lower, multiplier.lower)
self.assertEquals(self.__default_upper, multiplier.upper)
self.assertAlmostEqual(self.__default_p, multiplier.p)
def test_correct_construction_with_term_with_only_p(self):
""" Correct construction with only "p" param and a term instance.
That means that "lower" and "upper" take the correct values.
"""
value = grammar.SingleTerm('t')
p = 0.2
multiplier = grammar.Multiplier(value, p=p)
self.assertEquals(value, multiplier.value)
self.assertEquals(self.__default_lower, multiplier.lower)
self.assertEquals(self.__default_upper, multiplier.upper)
self.assertAlmostEqual(p, multiplier.p)
def test_p_should_be_an_int_or_float(self):
""" Value p should be a number between 0.0 and 1.0 both incl. """
for invalid_p in (
[],
(),
{},
None,
'7',
-0.1,
1.1,
):
with self.assertRaises(ValueError):
grammar.Multiplier(grammar.SingleTerm('t'), p=invalid_p)
def test_correct_construction_with_string_with_only_upper(self):
""" Correct construction with only "upper" param and a string term.
That means that "lower" and "p" take the correct values.
"""
str_value = 't'
value = grammar.SingleTerm(str_value)
upper = 1
multiplier = grammar.Multiplier(str_value, upper=upper)
self.assertEquals(value, multiplier.value)
self.assertEquals(self.__default_lower, multiplier.lower)
self.assertEquals(upper, multiplier.upper)
self.assertAlmostEqual(self.__default_p, multiplier.p)
def test_correct_construction_with_term_with_lower_and_upper(self):
""" Correct construction with only "lower" and "upper" params and a
term instance.
That means that "p" takes the correct value.
"""
value = grammar.SingleTerm('t')
lower = 3
upper = 5
multiplier = grammar.Multiplier(value, lower=lower, upper=upper)
self.assertEquals(value, multiplier.value)
self.assertEquals(lower, multiplier.lower)
self.assertEquals(upper, multiplier.upper)
self.assertAlmostEqual(self.__default_p, multiplier.p)
def test_correct_construction_with_string_with_lower_and_p(self):
""" Correct construction with only "lower" and "p" param and a
string term.
That means that "upper" takes the correct value.
"""
str_value = 't'
value = grammar.SingleTerm(str_value)
lower = 7
p = 0.75
multiplier = grammar.Multiplier(str_value, lower=lower, p=p)
self.assertEquals(value, multiplier.value)
self.assertEquals(lower, multiplier.lower)
self.assertEquals(self.__default_upper, multiplier.upper)
self.assertAlmostEqual(p, multiplier.p)
def test_correct_construction_with_string_with_lower_upper_and_p(self):
""" Correct construction with all optional params and a string term. """
str_value = 't'
value = grammar.SingleTerm(str_value)
lower = 1
upper = 7
p = 0.75
multiplier = grammar.Multiplier(
str_value,
lower=lower,
upper=upper,
p=p
)
self.assertEquals(value, multiplier.value)
self.assertEquals(lower, multiplier.lower)
self.assertEquals(upper, multiplier.upper)
self.assertAlmostEqual(p, multiplier.p)
def test_value_is_not_a_tuple(self):
""" If value is not a tuple, it raises an error. """
with self.assertRaises(ValueError):
grammar.Or(grammar.SingleTerm('terminal'))
def test_value_is_not_a_string(self):
""" Param "value" should be a string. """
for invalid_value in ([], (), {}, None, grammar.SingleTerm('hello')):
with self.assertRaises(ValueError):
grammar.SingleTerm(invalid_value)
def test_different_instances_with_same_content_are_equal(self):
""" If two different instances has the same content are equal. """
self.assertEquals(
grammar.SingleTerm('t'),
grammar.SingleTerm('t'),
)
def test_correct_value_as_a_string(self):
""" If value is a string, the term initializes correctly. """
string_value = 'terminal'
self.assertEquals(string_value, grammar.SingleTerm(string_value).value)
