def test_repr(self):
# Subclass elements to demonstrate dispatch occurs correctly.
class Face1(grammar.TypeExpression):
def __repr__(self):
return "-_-"
class Exclaim(grammar.TypeExpression):
def __repr__(self):
return '!'
class Face2(grammar.Predicate):
def __repr__(self):
return '(o_o)'
self.assertEqual(repr(grammar.TypeExpression('!')), '!')
self.assertEqual(
repr(grammar.TypeExpression('!', fields=(Face1(''), ))), '![-_-]')
self.assertEqual(
repr(grammar.TypeExpression('!',
fields=(Face1(''), Exclaim('!')))),
'![-_-, !]')
self.assertEqual(
repr(
grammar.TypeExpression('!',
fields=(Face1(''), Exclaim('!')),
predicate=Face2(True))),
'![-_-, !] % (o_o)')
self.assertEqual(
repr(grammar.TypeExpression('(o_-)', predicate=Face2(True))),
'(o_-) % (o_o)')
def test_several(self):
X = grammar.TypeExpression('X')
Y = grammar.TypeExpression('Y')
Z = grammar.TypeExpression('Z')
self.assertIsInstance(X & Y & Z, grammar.IntersectionTypeExpression)
self.assertEqual(X & Y & Z & X & Z, Y & Z & X)
def test_several(self):
X = grammar.TypeExpression('X')
Y = grammar.TypeExpression('Y')
Z = grammar.TypeExpression('Z')
self.assertIsInstance(X | Y | Z, grammar.UnionTypeExpression)
self.assertEqual(X | Y | Z | X | Z, Y | Z | X)
def test_mod(self):
X = grammar.TypeExpression('X')
with self.assertRaisesRegex(TypeError, 'fields'):
X['scikit-bio/assets/.no.gif']
Y = grammar.TypeExpression('Y', fields=(X, ))
with self.assertRaisesRegex(TypeError, 'fields'):
Y[';-)']
def test_apply_predicate(self):
predicate = grammar.Predicate(True)
Y = grammar.TypeExpression('Y')
X = grammar.TypeExpression('X', fields=(Y, ))
result = X._apply_predicate_(predicate)
self.assertIsInstance(result, grammar.TypeExpression)
self.assertEqual(result.fields, (Y, ))
def test_is_subtype_matches(self):
X = grammar.TypeExpression('X')
X_ = grammar.TypeExpression('X')
self.assertTrue(X._is_subtype_(X))
self.assertTrue(X_._is_subtype_(X))
self.assertTrue(X._is_subtype_(X_))
self.assertTrue(X_._is_subtype_(X_))
def test_is_subtype_matches_w_fields(self):
F1 = grammar.TypeExpression('F1')
F2 = grammar.TypeExpression('F2')
X = grammar.TypeExpression('X', fields=(F1, ))
X_ = grammar.TypeExpression('X', fields=(F2, ))
self.assertFalse(X_._is_subtype_(X))
self.assertFalse(X._is_subtype_(X_))
def test_hashable(self):
a = grammar.TypeExpression('X')
b = grammar.TypeExpression('Y', fields=(a, ))
c = grammar.TypeExpression('Y', fields=(a, ))
d = grammar.TypeExpression('Z', predicate=grammar.Predicate("stuff"))
self.assertIsInstance(a, collections.Hashable)
# There really shouldn't be a collision between these:
self.assertNotEqual(hash(a), hash(d))
self.assertEqual(b, c)
self.assertEqual(hash(b), hash(c))
def test_is_subtype_diff_predicates(self):
class Pred(grammar.Predicate):
def __init__(self, value):
self.value = value
super().__init__(value)
def _is_subtype_(self, other):
return self.value <= other.value
P1 = Pred(1)
P2 = Pred(2)
X = grammar.TypeExpression('X', predicate=P1)
X_ = grammar.TypeExpression('X', predicate=P2)
self.assertFalse(X_._is_subtype_(X))
self.assertTrue(X._is_subtype_(X_))
def test_is_subtype_matches_w_predicate(self):
class Pred(grammar.Predicate):
def __init__(self, value=0):
self.value = value
super().__init__(value)
def _is_subtype_(self, other):
return self.value <= other.value
P1 = Pred(1)
P1_ = Pred(1)
X = grammar.TypeExpression('X', predicate=P1)
X_ = grammar.TypeExpression('X', predicate=P1_)
self.assertTrue(X._is_subtype_(X))
self.assertTrue(X_._is_subtype_(X))
self.assertTrue(X._is_subtype_(X_))
self.assertTrue(X_._is_subtype_(X_))
def test_apply_fields(self):
X = grammar.TypeExpression('X')
Example = grammar.CompositeType('Example', ('foo', ))
result = Example._apply_fields_((X, ))
self.assertEqual(result.fields, (X, ))
self.assertEqual(result.name, 'Example')
self.assertIsInstance(result, grammar.TypeExpression)
def test_wrong_length(self):
X = grammar.TypeExpression('X')
composite_type = grammar.CompositeType('C', ['foo', 'bar'])
with self.assertRaisesRegex(TypeError, '1'):
composite_type[X]
composite_type = grammar.CompositeType('C', ['foo'])
with self.assertRaisesRegex(TypeError, '2'):
composite_type[X, X]
def test_validate_intersection_implements_handshake(self):
local = {}
X = grammar.TypeExpression('X')
class Example(grammar.TypeExpression):
def _validate_intersection_(self, other, handshake=False):
local['other'] = other
local['handshake'] = handshake
X._validate_intersection_(Example('Example'))
self.assertIs(local['other'], X)
self.assertTrue(local['handshake'])
def test_nested_expression(self):
X = grammar.TypeExpression('X')
C = grammar.CompositeType('C', ['foo', 'bar'])
self.assertEqual(repr(C[X, C[C[X, X], X]]), 'C[X, C[C[X, X], X]]')
def test_validate_intersection_w_composite_type(self):
X = grammar.TypeExpression('X')
with self.assertRaisesRegex(TypeError, 'incomplete'):
X._validate_intersection_(
grammar.CompositeType('A', field_names=('X', )))
def test_is_subtype_wrong_name(self):
Y = grammar.TypeExpression('Y')
X = grammar.TypeExpression('X')
self.assertFalse(Y._is_subtype_(X))
self.assertFalse(X._is_subtype_(Y))
def test_immutable(self):
# If this test fails, then the hiearchy has been rearranged and the
# properties tested for `_TypeBase` should be tested for
# this class.
# - Your Friendly Dead Man's Switch
self.assertIsInstance(grammar.TypeExpression('X'), grammar._TypeBase)
def test_eq_nonsense(self):
X = grammar.TypeExpression('X')
self.assertIs(X.__eq__(42), NotImplemented)
self.assertFalse(X == 42)
def test_validate_predicate_w_valid(self):
predicate = grammar.Predicate(True)
X = grammar.TypeExpression('X')
X._validate_predicate_(predicate)
def test_eq_different_instances(self):
X = grammar.TypeExpression('X')
X_ = grammar.TypeExpression('X')
self.assertIsNot(X, X_)
self.assertEqual(X, X_)
def test_validate_intersection_w_nonsense(self):
X = grammar.TypeExpression('X')
with self.assertRaisesRegex(TypeError, 'expression'):
X._validate_intersection_(42)
def test_mod_w_none_predicate(self):
X = grammar.TypeExpression('X', predicate=None)
predicate = grammar.Predicate("Truthy")
self.assertIs((X % predicate).predicate, predicate)
def test_mod_w_existing_predicate(self):
X = grammar.TypeExpression('X', predicate=grammar.Predicate('Truthy'))
with self.assertRaisesRegex(TypeError, 'predicate'):
X % grammar.Predicate('Other')
def test_validate_intersection_w_valid(self):
X = grammar.TypeExpression('X')
Y = grammar.TypeExpression('Y')
X._validate_intersection_(Y)
def test_mod_w_none(self):
X = grammar.TypeExpression('X')
self.assertEqual(X % None, X)
def test_build_intersection(self):
X = grammar.TypeExpression('X')
Y = grammar.TypeExpression('Y')
intersection = X._build_intersection_((X, Y))
self.assertIsInstance(intersection, grammar.IntersectionTypeExpression)
self.assertEqual(intersection.members, frozenset({X, Y}))
def test_identity(self):
X = grammar.TypeExpression('X')
X_ = grammar.TypeExpression('X')
self.assertIs(X & X_, X_)
def test_validate_predicate_w_nonsense(self):
X = grammar.TypeExpression('X')
with self.assertRaisesRegex(TypeError, 'predicate'):
X._validate_predicate_(42)
def test_type_expr_not_semantic(self):
TypeExpr = grammar.TypeExpression('TypeExpr')
self.assertFalse(semantic.is_semantic_type(TypeExpr))
def test_validate_field_w_typeexp(self):
Example = grammar.CompositeType('Example', ('foo', ))
# Check that no error is raised:
Example._validate_field_('foo', grammar.TypeExpression('X'))
