WIP WIP

Author: FabioLuporini

tests/test_subdomains.py

@@ -1940,16 +1940,22 @@ class TestSubDomainArguments:
     def _make_operator(left_shift=0, right_shift=0, grid=None, middle=False):
         grid = grid or Grid(shape=(8, 32))
         y = grid.dimensions[-1]
+
         yl = SubDimension.left('yl', y, 8)
         yr = SubDimension.right('yr', y, 8)
         if middle:
             yl = yr = SubDimension.middle('ym', y, 8, 8)
+
         u = TimeFunction(name='u', grid=grid, space_order=8)
         v = TimeFunction(name='v', grid=grid, space_order=8)
-        op = Operator([
+
+        eqs = [
             Eq(u.forward.subs(y, y + left_shift), 1).subs(y, yl),
             Eq(v.forward, u.forward.subs(y, y + right_shift) + 1).subs(y, yr)
-        ], name='subdomain_arguments')
+        ]
+
+        op = Operator(eqs, name='subdomain_arguments')
+
         return op, (u, v)
 
     @pytest.mark.parametrize('middle', [False, True])
@@ -1960,9 +1966,11 @@ def _make_operator(left_shift=0, right_shift=0, grid=None, middle=False):
     @pytest.mark.parametrize('override', ['function', 'bounds', 'thickness'])
     def test_stencil_gap(self, middle, left_shift, right_shift, margin, override):
         op, (u, v) = self._make_operator(left_shift, right_shift, middle=middle)
+
         size = 16 + 8 + margin
         if override == 'function':
             grid = Grid(shape=(8, size))
+
             kwargs = {f.name: TimeFunction(name=f'runtime_{f.name}', grid=grid,
                                            space_order=8) for f in (u, v)}
         elif override == 'bounds':
@@ -1983,10 +1991,13 @@ def test_stencil_gap(self, middle, left_shift, right_shift, margin, override):
     def test_runtime_space_order(self, middle, space_order, margin):
         """Override metadata does not change the compiled stencil order."""
         op, fields = self._make_operator(middle=middle)
+
         required = 8
         grid = Grid(shape=(8, 16 + required + margin))
+
         kwargs = {f.name: TimeFunction(name=f'runtime_{f.name}', grid=grid,
                                        space_order=space_order) for f in fields}
+
         if middle and margin < 0:
             with pytest.raises(InvalidArgument,
                                match=f'at least {required} interior points'):
@@ -1997,6 +2008,7 @@ def test_runtime_space_order(self, middle, space_order, margin):
     @pytest.mark.parametrize('side', ['left', 'right'])
     def test_empty_slab(self, side):
         op, _ = self._make_operator(right_shift=-4)
+
         d, = [d for d in op.dimensions if d.is_Sub and getattr(d, f'is_{side}')]
         thickness = d.ltkn if side == 'left' else d.rtkn
 
@@ -2005,23 +2017,29 @@ def test_empty_slab(self, side):
 
     def test_before_autotuning(self):
         op, _ = self._make_operator(right_shift=-4, middle=True)
+
         with pytest.raises(InvalidArgument, match='interior points'):
             op.arguments(time_M=0, y_M=22, autotune=True)
+
         assert 'autotuning' not in op._state
 
         op.arguments(time_M=0, y_M=23, autotune=True)
+
         assert len(op._state['autotuning']) == 1
 
     @pytest.mark.parametrize('left', [15, 16, 17, 25])
     @pytest.mark.parallel(mode=[(2, 'basic')])
     def test_distributed_middle(self, left, mode):
         grid = Grid(shape=(16, 32), topology=(1, 2))
+
         op, _ = self._make_operator(grid=grid, middle=True)
+
         d, = [d for d in op.dimensions if d.is_Sub]
 
         # Rank 0 has one point or an empty middle (possibly with inverted bounds).
         # Only the global size determines whether the middle is large enough
         kwargs = {d.ltkn.name: left, d.rtkn.name: 0}
+
         if left == 25:
             with pytest.raises(InvalidArgument, match='at least 8 interior points'):
                 op.arguments(time_M=0, **kwargs)
@@ -2031,7 +2049,9 @@ def test_distributed_middle(self, left, mode):
     @pytest.mark.parallel(mode=[(2, 'basic')])
     def test_collective_rejection(self, mode):
         grid = Grid(shape=(32, 32), topology=(2, 1))
+
         op, _ = self._make_operator(right_shift=-4, grid=grid, middle=True)
+
         dl, = [d for d in op.dimensions if d.is_Sub and d.is_middle]
         left = 24 if grid.distributor.myrank == 0 else 0
 
@@ -2047,14 +2067,21 @@ def define(self, dimensions):
                 return {x: x, y: ('middle', 8, 8)}
 
         grid = Grid(shape=(16, 32))
+
         f = Function(name='f', grid=Interior(grid=grid), space_order=8)
         original = f.dimensions[-1]
-        op = Operator(Eq(f, f + 1), name='subdomain_function_arguments')
+
+        eq = Eq(f, f + 1)
+
+        op = Operator(eq, name='subdomain_function_arguments')
+
         concrete, = [d for d in op.dimensions if d.is_Sub]
 
         # Function validation visits `original`; Operator validation visits `concrete`
         assert original not in op.dimensions
+
         args = op.arguments()
+
         assert original.ltkn.name not in args
         assert concrete.ltkn.name in args