diff --git a/tests/validation/multigrid/test_refinement_three_level.py b/tests/validation/multigrid/test_refinement_three_level.py
index 549a5c4..c846f61 100644
--- a/tests/validation/multigrid/test_refinement_three_level.py
+++ b/tests/validation/multigrid/test_refinement_three_level.py
@@ -27,7 +27,16 @@ from test_refinement_blocked_base import raw
 
 CFG = LBMConfig(nx=16, ny=16, viscosity=.1)
 L1, L2 = (4, 4, 12, 12), (8, 8, 16, 16)
-KW = dict(fine_block=(4, 4), base_block=(4, 4), child=L2, child_block=(4, 4))
+B = (4, 4)
+
+
+def levels(l1=L1, l2=L2, blocks=(B, B, B), objects=((), (), ()), jets=((), (), ())):
+    """Level-list keywords for the scalar L1 patch with one scalar L2 child."""
+    return dict(refinements=[l1, l2], level_blocks=list(blocks),
+                level_objects=list(objects), level_jets=list(jets))
+
+
+KW = levels()
 
 
 def child_body(spec=None):
@@ -52,26 +61,29 @@ def mocked_child():
             patch.object(compiler, "load_module", return_value=module), \
             patch.object(cuda, "mem_alloc", side_effect=lambda size: Mock()), \
             patch.object(cuda, "memcpy_htod"):
-        return FixedPatchStepper(CFG, L1, context=context, child_objects=[child_body()],
-                                 child_jets=[child_jet()], **KW)
+        return FixedPatchStepper(CFG, context=context,
+                                 **levels(objects=((), (), (child_body(),)), jets=((), (), (child_jet(),))))
 
 
 class ThreeLevelCPU(unittest.TestCase):
     def test_rejections_before_cuda(self):
         context = object()  # never activated: every case must fail first
-        bad = (dict(KW, child_block=None), dict(KW, fine_block=None),
-               dict(KW, fine_objects=[circle()]), dict(KW, child=(4, 8, 16, 16)),
-               dict(KW, child_block=(5, 4)))
+        bad = (levels(blocks=(B, B, None)), levels(blocks=(B, None, B)),
+               levels(objects=((), (circle(),), ())), levels(l2=(4, 8, 16, 16)),
+               levels(blocks=(B, B, (5, 4))))
         for kw in bad:
             with self.subTest(kw=kw), self.assertRaises(ValueError):
-                FixedPatchStepper(CFG, L1, context=context, **kw)
-        for kw in (dict(child_objects=[child_body()]), dict(child_jets=[child_jet()]),
-                   dict(KW, child_jets=[child_jet()])):
+                FixedPatchStepper(CFG, context=context, **kw)
+        # L2 bodies/Jets without an L2 level (one entry too many), and an L2 Jet without a body.
+        two_level = dict(refinements=[L1], level_blocks=[None, None])
+        for kw in (dict(two_level, level_objects=[(), (), (child_body(),)]),
+                   dict(two_level, level_jets=[(), (), (child_jet(),)]),
+                   levels(jets=((), (), (child_jet(),)))):
             with self.assertRaises(ValueError):
-                FixedPatchStepper(CFG, L1, context=context, **kw)
-        with self.assertRaises(ValueError):  # several L1 patches + child: not yet
-            FixedPatchStepper(LBMConfig(nx=32, ny=16, viscosity=.1), ((4, 4, 12, 12), (20, 4, 28, 12)),
-                              context=context, **KW)
+                FixedPatchStepper(CFG, context=context, **kw)
+        with self.assertRaises(ValueError):  # several L1 patches + scalar child: not yet
+            FixedPatchStepper(LBMConfig(nx=32, ny=16, viscosity=.1), context=context,
+                              **levels(l1=((4, 4, 12, 12), (20, 4, 28, 12))))
 
 
     def test_four_halo_bfl_steps_and_fresh_middle_feeds(self):
@@ -156,7 +168,7 @@ class ThreeLevelGPU(unittest.TestCase):
     def test_equilibrium_is_kept_on_every_level(self):
         from CelerisLab.cuda.context import CudaContext
         feq = np.asarray(compute_feq_d2q9(1.0, .03, -.02), np.float32)[:, None, None]
-        with CudaContext(0) as ctx, FixedPatchStepper(CFG, L1, context=ctx, **KW) as run:
+        with CudaContext(0) as ctx, FixedPatchStepper(CFG, context=ctx, **KW) as run:
             shapes = ((16, 16), run.patch.fine_shape, run.child_patch.fine_shape)
             run.initialize(*(np.broadcast_to(feq, (9, *s)).copy() for s in shapes))
             run.step(8)
@@ -169,7 +181,7 @@ class ThreeLevelGPU(unittest.TestCase):
 
     def test_nonequilibrium_masks_and_fresh_middle_feeds(self):
         from CelerisLab.cuda.context import CudaContext
-        with CudaContext(0) as ctx, FixedPatchStepper(CFG, L1, context=ctx, **KW) as run:
+        with CudaContext(0) as ctx, FixedPatchStepper(CFG, context=ctx, **KW) as run:
             p1, p2 = run.patch, run.child_patch
             run.initialize(state(16, 16, 1), state(*p1.fine_shape, 2), state(*p2.fine_shape, 3))
             f = run._levels[1]
@@ -205,8 +217,9 @@ class ThreeLevelBodyGPU(unittest.TestCase):
             CFG, velocity=0., wall_normal_velocity=.001, wall_slot_width=4,
             y_wall_bc="on_site_velocity", top_wall_bc="reservoir")
         with CudaContext(0) as ctx, FixedPatchStepper(
-                cfg, L1, context=ctx, coarse_boundary=mode, child_objects=[child_body(spec)],
-                child_jets=jets, **dict(KW, child_block=block)) as run:
+                cfg, context=ctx, coarse_boundary=mode,
+                **levels(blocks=(B, B, block), objects=((), (), (child_body(spec),)),
+                         jets=((), (), tuple(jets)))) as run:
             run.initialize(*(state(*level.shape[1:], i + 1) for i, level in enumerate(run._levels)))
             snapshots = []
             for stop in (0, 1, 2, 4, 8):