def test_valid_contains_argument_types(self):
a = ast.ForbidConvention(ast.Node(descriptor=ast.NodeTypeDescriptor(type_='property'),
constraint=ast.ContainsExpr(ast.VariableExpr.DEFAULT,
ast.Node(ast.NodeTypeDescriptor(type_='a')))), '')
convention_set = self.wrap_convention_in_set(a)
error_log = checker.TypeChecker.check(convention_set)
assert not error_log.contain_errors()
def visitSemantic_node(self, context):
node_descriptor = self.get_node_descriptor(context.type_)
line = context.type_.start.line
if not context.constraint:
return ast.Node(node_descriptor, line)
constraint = self.visitLogic_expr(context.constraint)
return ast.Node(node_descriptor, line, constraint)
def visit_semantic_node_with_id(self, context, variable):
node_descriptor = self.get_node_descriptor(context.type_)
line = context.type_.start.line
if not context.constraint:
return ast.Node(node_descriptor, line, identifier=variable)
constraint = self.visitLogic_expr(context.constraint)
return ast.Node(node_descriptor, line, identifier=variable, constraint=constraint)
def test_undefined_variable_in_method_expr(self):
a = ast.FindRequireConvention(ast.Node(descriptor=ast.NodeTypeDescriptor(type_='property'), identifier='a'), '',
constraint=ast.MethodExpr(ast.VariableExpr('b'), 'child', ast.IntegerExpr(5)))
convention_set = self.wrap_convention_in_set(a)
error_log = checker.TypeChecker.check(convention_set)
assert error_log.contain_errors()
assert len(error_log.get_errors()) == 1
def test_diff_ineq_argument_types(self):
a = ast.ForbidConvention(ast.Node(descriptor=ast.NodeTypeDescriptor(type_='property'),
constraint=ast.NotEqualExpr(ast.StringExpr('t'), ast.IntegerExpr(5), 3)), '')
convention_set = self.wrap_convention_in_set(a)
error_log = checker.TypeChecker.check(convention_set)
assert error_log.contain_errors()
assert len(error_log.get_errors_for_convention(a)) == 1
def test_same_eq_argument_types_list(self):
a = ast.ForbidConvention(ast.Node(descriptor=ast.NodeTypeDescriptor(type_='property'),
constraint=ast.EqualExpr(ast.ListExpr([]),
ast.ListExpr([]), 3)), '')
convention_set = self.wrap_convention_in_set(a)
error_log = checker.TypeChecker.check(convention_set)
assert not error_log.contain_errors()
def test_same_gr_eq_argument_types_integer(self):
a = ast.ForbidConvention(ast.Node(descriptor=ast.NodeTypeDescriptor(type_='property'),
constraint=ast.GreaterThanOrEqualExpr(ast.IntegerExpr(2),
ast.IntegerExpr(2), 3)), '')
convention_set = self.wrap_convention_in_set(a)
error_log = checker.TypeChecker.check(convention_set)
assert not error_log.contain_errors()
def test_valid_minus_argument_types(self):
a = ast.ForbidConvention(ast.Node(descriptor=ast.NodeTypeDescriptor(type_='property'),
constraint=ast.EqualExpr(ast.UnaryMinusExpr(ast.IntegerExpr(1)),
ast.IntegerExpr(2))), '')
convention_set = self.wrap_convention_in_set(a)
error_log = checker.TypeChecker.check(convention_set)
assert not error_log.contain_errors()
def test_invalid_minus_argument_types(self):
a = ast.ForbidConvention(ast.Node(descriptor=ast.NodeTypeDescriptor(type_='property'),
constraint=ast.UnaryMinusExpr(ast.StringExpr(''))), '')
convention_set = self.wrap_convention_in_set(a)
error_log = checker.TypeChecker.check(convention_set)
assert error_log.contain_errors()
assert len(error_log.get_errors()) == 1
def test_valid_or_argument_types(self):
a = ast.ForbidConvention(ast.Node(descriptor=ast.NodeTypeDescriptor(type_='property'),
constraint=ast.OrExpr(ast.BooleanExpr(True),
ast.BooleanExpr(False))), '')
convention_set = self.wrap_convention_in_set(a)
error_log = checker.TypeChecker.check(convention_set)
assert not error_log.contain_errors()
def test_valid_match_argument_types(self):
a = ast.ForbidConvention(ast.Node(descriptor=ast.NodeTypeDescriptor(type_='property'),
constraint=ast.MatchExpr(ast.StringExpr('t'),
ast.StringExpr('m'))), '')
convention_set = self.wrap_convention_in_set(a)
error_log = checker.TypeChecker.check(convention_set)
assert not error_log.contain_errors()
def visitWhitespace_node(self, context):
node_descriptor = self.get_ws_node_descriptor(context.type_.text)
line = context.type_.line
if context.quantifier:
repeater = self.visitRepeater(context.quantifier)
return ast.WhitespaceNode(node_descriptor, repeater, line)
return ast.Node(node_descriptor, line)
def test_undefined_variable_in_node_query(self):
a = ast.FindRequireConvention(ast.Node(descriptor=ast.NodeTypeDescriptor(type_='property'), identifier='a'), '',
constraint=ast.NextSiblingExpr(ast.VariableExpr('b')))
convention_set = self.wrap_convention_in_set(a)
error_log = checker.TypeChecker.check(convention_set)
assert error_log.contain_errors()
assert len(error_log.get_errors()) == 1
def test_invalid_boolean_constraint(self):
a = ast.ForbidConvention(ast.Node(descriptor=ast.NodeTypeDescriptor(type_='property'),
constraint=ast.IntegerExpr(1)), '')
convention_set = self.wrap_convention_in_set(a)
error_log = checker.TypeChecker.check(convention_set)
assert error_log.contain_errors()
assert len(error_log.get_errors()) == 1
def test_list_with_diff_elements(self):
a = ast.ForbidConvention(ast.Node(descriptor=ast.NodeTypeDescriptor(type_='property'),
constraint=ast.EqualExpr(ast.ListExpr([ast.IntegerExpr(1), ast.StringExpr('')]),
ast.IntegerExpr(2))), '')
convention_set = self.wrap_convention_in_set(a)
error_log = checker.TypeChecker.check(convention_set)
assert error_log.contain_errors()
assert len(error_log.get_errors()) == 1
def test_invalid_lt_argument_types(self):
a = ast.ForbidConvention(ast.Node(descriptor=ast.NodeTypeDescriptor(type_='property'),
constraint=ast.LessThanExpr(ast.NodeTypeExpr('t'),
ast.IntegerExpr(5), 3)), '')
convention_set = self.wrap_convention_in_set(a)
error_log = checker.TypeChecker.check(convention_set)
assert error_log.contain_errors()
assert len(error_log.get_errors()) == 1
def test_invalid_contains_all_argument_types(self):
a = ast.ForbidConvention(ast.Node(descriptor=ast.NodeTypeDescriptor(type_='property'),
constraint=ast.ContainsAllExpr(
ast.VariableExpr.DEFAULT,
ast.ListExpr([ast.IntegerExpr(2)]))), '')
convention_set = self.wrap_convention_in_set(a)
error_log = checker.TypeChecker.check(convention_set)
assert error_log.contain_errors()
assert len(error_log.get_errors()) == 1
def _get_sequence(node_type):
return ast.SequencePattern(
[ast.Node(ast.NodeTypeDescriptor.build_type(type_=node_type))])
def build_node_desc(type_):
return ast.Node(ast.NodeTypeDescriptor(type_=type_))
