diff -r 15c95d3fcfd8 -r f0a6bf48b05e tests/quadrilaterals.py
--- a/tests/quadrilaterals.py	Wed Jun 05 00:33:50 2019 +0300
+++ b/tests/quadrilaterals.py	Sat Jun 08 01:32:25 2019 +0300
@@ -1,11 +1,12 @@
 from math import radians
-from testsuite import warning, error, notice
+from testsuite import problem_type, report_problem
 from geometry import *
 
 def sign_consistency(container):
     # Returns whether all elements in container have the same sign
     return min(container) * max(container) >= 0
 
+@problem_type('concave', severity = 'error', message = 'concave quadrilateral')
 def concave_test(model):
     ''' Checks that all quadrilaterals are convex. '''
     for quadrilateral in model.quadrilaterals:
@@ -19,8 +20,22 @@
             for v1, v2, v3 in pairs(geometry.vertices, count = 3)
         ]
         if not sign_consistency(z_scores):
-            yield error(quadrilateral, 'concave-error')
+            yield report_problem('concave', bad_object = quadrilateral)
 
+@problem_type('skew-major',
+    severity = 'error',
+    message = lambda skew_angle:
+        str.format('skew quadrilateral (plane angle {})',
+            degree_rep(skew_angle),
+        ),
+)
+@problem_type('skew-minor',
+    severity = 'notice',
+    message = lambda skew_angle:
+        str.format('slightly skew quadrilateral (plane angle {})',
+            degree_rep(skew_angle),
+        ),
+)
 def skew_test(model):
     ''' Checks that all quadrilaterals are coplanar. '''
     for quadrilateral in model.quadrilaterals:
@@ -29,16 +44,24 @@
             plane_2 = triangle_plane_normal(triangles[1])
             skew_angle = vector_angle(plane_1, plane_2, normalized = True)
             if skew_angle > radians(3.0):
-                yield error(quadrilateral, 'skew-error',
+                yield report_problem(
+                    'skew-major',
+                    bad_object = quadrilateral,
                     skew_angle = skew_angle,
                 )
                 break
             elif skew_angle > radians(1.0):
-                yield warning(quadrilateral, 'skew-warning',
+                yield report_problem(
+                    'skew-minor',
+                    bad_object = quadrilateral,
                     skew_angle = skew_angle,
                 )
                 break
 
+@problem_type('self-intersecting',
+    severity = 'error',
+    message = 'self-intersecting quadrilateral',
+)
 def bowtie_test(model):
     for quadrilateral in model.quadrilaterals:
         geometry = transform_to_xy(quadrilateral.geometry)
@@ -48,52 +71,44 @@
             line_2 = LineSegment(vertices[2 + i], vertices[3 + i])
             intersection = line_segment_intersection_xy(line_1, line_2)
             if intersection:
-                yield error(quadrilateral, 'self-intersecting')
+                yield report_problem(
+                    'self-intersecting',
+                    bad_object = quadrilateral,
+                )
                 break
 
+@problem_type('collinear', severity = 'error', message = 'collinear polygon')
 def collinear_test(model):
     for element in model.body:
         if hasattr(element, 'geometry') and len(element.geometry.vertices) >= 3:
             for a, b, c in pairs(element.geometry.vertices, count = 3):
                 if cross_product(b - a, c - a).length() < 1e-5:
-                    yield error(element, 'collinearity-error')
+                    yield report_problem('collinear', bad_object = element)
 
-def hairline_score(smallest_angle):
-    from math import log10
-    return max(0, -log10(smallest_angle))
-
+@problem_type('hairline-polygon',
+    severity = 'notice',
+    message = lambda smallest_angle: str.format(
+        'hairline polygon (smallest angle {})',
+        degree_rep(smallest_angle),
+    ),
+)
 def hairline_test(model):
     for element in model.body:
         if hasattr(element, 'geometry') and len(element.geometry.vertices) >= 3:
             smallest_angle = element.geometry.smallest_angle
             if smallest_angle < radians(0.5):
-                yield notice(element, 'hairline-warning',
+                yield report_problem(
+                    'hairline-polygon',
+                    bad_object = element,
                     smallest_angle = smallest_angle,
                 )
 
 manifest = {
-    'tests': {
-        'skew': skew_test,
-        'concave': concave_test,
-        'bowtie': bowtie_test,
-        'collinearity': collinear_test,
-        'hairline': hairline_test,
-    },
-    'messages': {
-        'skew-error': lambda skew_angle:
-            str.format('skew quadrilateral (plane angle {})',
-                degree_rep(skew_angle),
-            ),
-        'skew-warning': lambda skew_angle:
-            str.format('slightly skew quadrilateral (plane angle {})',
-                degree_rep(skew_angle),
-            ),
-        'concave-error': 'concave quadrilateral',
-        'self-intersecting': 'bowtie quadrilateral',
-        'collinearity-error': 'collinear polygon',
-        'hairline-warning': lambda smallest_angle:
-            str.format('hairline polygon (smallest angle {})',
-                degree_rep(smallest_angle),
-            ),
-    },
+    'tests': [
+        skew_test,
+        concave_test,
+        bowtie_test,
+        collinear_test,
+        hairline_test,
+    ],
 }