diff --git a/metamorph/build.gradle b/metamorph/build.gradle
index a14f783d3..ed537f1a5 100644
--- a/metamorph/build.gradle
+++ b/metamorph/build.gradle
@@ -39,3 +39,10 @@ sourceSets {
     output.resourcesDir = sourceSets.test.java.outputDir
   }
 }
+
+test {
+  testLogging {
+    showStandardStreams = true
+    exceptionFormat = 'full'
+  }
+}
diff --git a/metamorph/src/test/java/org/metafacture/metamorph/TestHelpers.java b/metamorph/src/test/java/org/metafacture/metamorph/TestHelpers.java
new file mode 100644
index 000000000..5617f8b0b
--- /dev/null
+++ b/metamorph/src/test/java/org/metafacture/metamorph/TestHelpers.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2020 hbz NRW
+ *
+ * Licensed under the Apache License, Version 2.0 the "License";
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.metafacture.metamorph;
+
+import org.metafacture.framework.StreamReceiver;
+import org.mockito.InOrder;
+import org.mockito.Mockito;
+import org.mockito.exceptions.base.MockitoAssertionError;
+
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.IntFunction;
+import java.util.function.Supplier;
+
+/**
+ * Helper functions for Metamorph tests.
+ *
+ * @author Jens Wille
+ */
+public final class TestHelpers {
+
+    public static void assertMorph(final StreamReceiver receiver, final String morphDef, final Consumer<Metamorph> in, final Consumer<Supplier<StreamReceiver>> out) {
+        assertMorph(receiver, morphDef, in, (s, f) -> out.accept(s));
+    }
+
+    public static void assertMorph(final StreamReceiver receiver, final String morphDef, final Consumer<Metamorph> in, final BiConsumer<Supplier<StreamReceiver>, IntFunction<StreamReceiver>> out) {
+        final Metamorph metamorph = InlineMorph.in(TestHelpers.class).with(morphDef).createConnectedTo(receiver);
+        final InOrder ordered = Mockito.inOrder(receiver);
+
+        try {
+            in.accept(metamorph);
+            out.accept(() -> ordered.verify(receiver), i -> ordered.verify(receiver, Mockito.times(i)));
+
+            ordered.verifyNoMoreInteractions();
+            Mockito.verifyNoMoreInteractions(receiver);
+        }
+        catch (final MockitoAssertionError e) {
+            System.out.println(Mockito.mockingDetails(receiver).printInvocations());
+            throw e;
+        }
+    }
+
+}
diff --git a/metamorph/src/test/java/org/metafacture/metamorph/TestMetamorphBasics.java b/metamorph/src/test/java/org/metafacture/metamorph/TestMetamorphBasics.java
index a564bed85..e2ee92dac 100644
--- a/metamorph/src/test/java/org/metafacture/metamorph/TestMetamorphBasics.java
+++ b/metamorph/src/test/java/org/metafacture/metamorph/TestMetamorphBasics.java
@@ -15,15 +15,11 @@
  */
 package org.metafacture.metamorph;
 
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
+import static org.metafacture.metamorph.TestHelpers.assertMorph;
 
 import org.junit.Rule;
 import org.junit.Test;
 import org.metafacture.framework.StreamReceiver;
-import org.mockito.InOrder;
 import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnit;
 import org.mockito.junit.MockitoRule;
@@ -41,205 +37,225 @@ public final class TestMetamorphBasics {
     @Mock
     private StreamReceiver receiver;
 
-    private Metamorph metamorph;
-
     @Test
     public void shouldUseCustomEntityMarker() {
-        metamorph = InlineMorph.in(this)
-                .with("<metamorph version='1' entityMarker='~'")
-                .with("    xmlns='http://www.culturegraph.org/metamorph'>")
-                .with("  <rules>")
-                .with("    <data source='entity~literal' name='data' />")
-                .with("  </rules>")
-                .with("</metamorph>")
-                .createConnectedTo(receiver);
-
-        metamorph.startRecord("1");
-        metamorph.startEntity("entity");
-        metamorph.literal("literal", "Aloha");
-        metamorph.endEntity();
-        metamorph.endRecord();
-
-        verify(receiver).literal("data", "Aloha");
+        assertMorph(receiver,
+                "<metamorph version='1' entityMarker='~'" +
+                "    xmlns='http://www.culturegraph.org/metamorph'>" +
+                "  <rules>" +
+                "    <data source='entity~literal' name='data' />" +
+                "  </rules>" +
+                "</metamorph>",
+                i -> {
+                    i.startRecord("1");
+                    i.startEntity("entity");
+                    i.literal("literal", "Aloha");
+                    i.endEntity();
+                    i.endRecord();
+                },
+                o -> {
+                    o.get().startRecord("1");
+                    o.get().literal("data", "Aloha");
+                    o.get().endRecord();
+                }
+        );
     }
 
     @Test
     public void shouldHandleUnmatchedLiteralsInElseSource() {
-        metamorph = InlineMorph.in(this)
-                .with("<rules>")
-                .with("  <data source='Sylt' name='Hawaii' />")
-                .with("  <data source='_else' />")
-                .with("</rules>")
-                .createConnectedTo(receiver);
-
-        metamorph.startRecord("1");
-        metamorph.literal("Langeoog", "Moin");
-        metamorph.literal("Sylt", "Aloha");
-        metamorph.literal("Baltrum", "Moin Moin");
-        metamorph.endRecord();
-
-        final InOrder ordered = inOrder(receiver);
-        ordered.verify(receiver).startRecord("1");
-        ordered.verify(receiver).literal("Langeoog", "Moin");
-        ordered.verify(receiver).literal("Hawaii", "Aloha");
-        ordered.verify(receiver).literal("Baltrum", "Moin Moin");
-        ordered.verify(receiver).endRecord();
+        assertMorph(receiver,
+                "<rules>" +
+                "  <data source='Sylt' name='Hawaii' />" +
+                "  <data source='_else' />" +
+                "</rules>",
+                i -> {
+                    i.startRecord("1");
+                    i.literal("Langeoog", "Moin");
+                    i.literal("Sylt", "Aloha");
+                    i.literal("Baltrum", "Moin Moin");
+                    i.endRecord();
+                },
+                o -> {
+                    o.get().startRecord("1");
+                    o.get().literal("Langeoog", "Moin");
+                    o.get().literal("Hawaii", "Aloha");
+                    o.get().literal("Baltrum", "Moin Moin");
+                    o.get().endRecord();
+                }
+        );
     }
 
     @Test
     public void shouldHandleUnmatchedLiteralsAndEntitiesInElseSource() {
-        metamorph = InlineMorph.in(this) //
-                .with("<rules>") //
-                .with("    <data source='_else'/>")//
-                .with("</rules>")//
-                .createConnectedTo(receiver);
-        testElseData();
+        testElseData(
+                "<rules>" +
+                "    <data source='_else'/>" +
+                "</rules>"
+        );
     }
 
     @Test
     public void shouldHandleUnmatchedLiteralsAndEntitiesInElseFlattenedSource() {
-        metamorph = InlineMorph.in(this) //
-                .with("<rules>") //
-                .with("    <data source='_elseFlattened'/>")//
-                .with("</rules>")//
-                .createConnectedTo(receiver);
-        testElseData();
+        testElseData(
+                "<rules>" +
+                "    <data source='_elseFlattened'/>" +
+                "</rules>"
+        );
     }
-    private void testElseData() {
-        metamorph.startRecord("1");
-        metamorph.literal("Shikotan", "Aekap");
-        metamorph.startEntity("Germany");
-        metamorph.literal("Langeoog", "Moin");
-        metamorph.endEntity();
-        metamorph.startEntity("Germany");
-        metamorph.literal("Baltrum", "Moin Moin");
-        metamorph.endEntity();
-        metamorph.endRecord();
-
-        final InOrder ordered = inOrder(receiver);
-        ordered.verify(receiver).startRecord("1");
-        ordered.verify(receiver).literal("Shikotan", "Aekap");
-        ordered.verify(receiver).literal("Germany.Langeoog", "Moin");
-        ordered.verify(receiver).literal("Germany.Baltrum", "Moin Moin");
-        ordered.verify(receiver).endRecord();
+
+    private void testElseData(final String morphDef) {
+        assertMorph(receiver, morphDef,
+                i -> {
+                    i.startRecord("1");
+                    i.literal("Shikotan", "Aekap");
+                    i.startEntity("Germany");
+                    i.literal("Langeoog", "Moin");
+                    i.endEntity();
+                    i.startEntity("Germany");
+                    i.literal("Baltrum", "Moin Moin");
+                    i.endEntity();
+                    i.endRecord();
+                },
+                o -> {
+                    o.get().startRecord("1");
+                    o.get().literal("Shikotan", "Aekap");
+                    o.get().literal("Germany.Langeoog", "Moin");
+                    o.get().literal("Germany.Baltrum", "Moin Moin");
+                    o.get().endRecord();
+                }
+        );
     }
 
     @Test
     public void shouldHandleUnmatchedLiteralsAndEntitiesInElseNestedSource() {
-        metamorph = InlineMorph.in(this).with("<rules>")//
-                .with("  <entity name='USA' >")//
-                .with("    <data source='USA.Sylt' name='Hawaii' />")
-                .with("  </entity>")//
-                .with("  <data source='_elseNested' />")//
-                .with("</rules>")//
-                .createConnectedTo(receiver);
-
-        metamorph.startRecord("1");
-        metamorph.literal("Shikotan", "Aekap");
-        metamorph.startEntity("Germany");
-        metamorph.literal("Langeoog", "Moin");
-        metamorph.literal("Baltrum", "Moin Moin");
-        metamorph.endEntity();
-        metamorph.startEntity("USA");
-        metamorph.literal("Sylt", "Aloha");
-        metamorph.endEntity();
-        metamorph.endRecord();
-
-        final InOrder ordered = inOrder(receiver);
-        ordered.verify(receiver).startRecord("1");
-        ordered.verify(receiver).literal("Shikotan", "Aekap");
-        ordered.verify(receiver).startEntity("Germany");
-        ordered.verify(receiver).literal("Langeoog", "Moin");
-        ordered.verify(receiver).literal("Baltrum", "Moin Moin");
-        ordered.verify(receiver).endEntity();
-        ordered.verify(receiver).startEntity("USA");
-        ordered.verify(receiver).literal("Hawaii", "Aloha");
-        ordered.verify(receiver).endEntity();
-        ordered.verify(receiver).endRecord();
+        assertMorph(receiver,
+                "<rules>" +
+                "  <entity name='USA' >" +
+                "    <data source='USA.Sylt' name='Hawaii' />" +
+                "  </entity>" +
+                "  <data source='_elseNested' />" +
+                "</rules>",
+                i -> {
+                    i.startRecord("1");
+                    i.literal("Shikotan", "Aekap");
+                    i.startEntity("Germany");
+                    i.literal("Langeoog", "Moin");
+                    i.literal("Baltrum", "Moin Moin");
+                    i.endEntity();
+                    i.startEntity("USA");
+                    i.literal("Sylt", "Aloha");
+                    i.endEntity();
+                    i.endRecord();
+                },
+                o -> {
+                    o.get().startRecord("1");
+                    o.get().literal("Shikotan", "Aekap");
+                    o.get().startEntity("Germany");
+                    o.get().literal("Langeoog", "Moin");
+                    o.get().endEntity();
+                    o.get().startEntity("Germany");
+                    o.get().literal("Baltrum", "Moin Moin");
+                    o.get().endEntity();
+                    o.get().startEntity("USA");
+                    o.get().literal("Hawaii", "Aloha");
+                    o.get().endEntity();
+                    o.get().endRecord();
+                }
+        );
     }
 
     @Test
     public void shouldMatchCharacterWithQuestionMarkWildcard() {
-        metamorph = InlineMorph.in(this)
-                .with("<rules>")
-                .with("  <data source='lit-?' />")
-                .with("</rules>")
-                .createConnectedTo(receiver);
-
-        metamorph.startRecord("1");
-        metamorph.literal("lit", "Moin");
-        metamorph.literal("lit-A", "Aloha");
-        metamorph.literal("lit-B", "Aloha 'oe");
-        metamorph.endRecord();
-
-        verify(receiver).literal("lit-A", "Aloha");
-        verify(receiver).literal("lit-B", "Aloha 'oe");
-        verify(receiver, times(2)).literal(any(), any());
+        assertMorph(receiver,
+                "<rules>" +
+                "  <data source='lit-?' />" +
+                "</rules>",
+                i -> {
+                    i.startRecord("1");
+                    i.literal("lit", "Moin");
+                    i.literal("lit-A", "Aloha");
+                    i.literal("lit-B", "Aloha 'oe");
+                    i.endRecord();
+                },
+                o -> {
+                    o.get().startRecord("1");
+                    o.get().literal("lit-A", "Aloha");
+                    o.get().literal("lit-B", "Aloha 'oe");
+                    o.get().endRecord();
+                }
+        );
     }
 
     @Test
     public void shouldMatchCharactersInCharacterClass() {
-        metamorph = InlineMorph.in(this)
-                .with("<rules>")
-                .with("  <data source='lit-[AB]' />")
-                .with("</rules>")
-                .createConnectedTo(receiver);
-
-        metamorph.startRecord("1");
-        metamorph.literal("lit-A", "Hawaii");
-        metamorph.literal("lit-B", "Oahu");
-        metamorph.literal("lit-C", "Fehmarn");
-        metamorph.endRecord();
-
-        verify(receiver).literal("lit-A", "Hawaii");
-        verify(receiver).literal("lit-B", "Oahu");
-        verify(receiver, times(2)).literal(any(), any());
+        assertMorph(receiver,
+                "<rules>" +
+                "  <data source='lit-[AB]' />" +
+                "</rules>",
+                i ->  {
+                    i.startRecord("1");
+                    i.literal("lit-A", "Hawaii");
+                    i.literal("lit-B", "Oahu");
+                    i.literal("lit-C", "Fehmarn");
+                    i.endRecord();
+                },
+                o -> {
+                    o.get().startRecord("1");
+                    o.get().literal("lit-A", "Hawaii");
+                    o.get().literal("lit-B", "Oahu");
+                    o.get().endRecord();
+                }
+        );
     }
 
     @Test
     public void shouldReplaceVariables() {
-        metamorph = InlineMorph.in(this)
-                .with("<vars>")
-                .with("  <var name='in' value='Honolulu' />")
-                .with("  <var name='out' value='Hawaii' />")
-                .with("</vars>")
-                .with("<rules>")
-                .with("  <data source='$[in]' name='$[out]' />")
-                .with("</rules>")
-                .createConnectedTo(receiver);
-
-        metamorph.startRecord("1");
-        metamorph.literal("Honolulu", "Aloha");
-        metamorph.endRecord();
-
-        verify(receiver).literal("Hawaii", "Aloha");
+        assertMorph(receiver,
+                "<vars>" +
+                "  <var name='in' value='Honolulu' />" +
+                "  <var name='out' value='Hawaii' />" +
+                "</vars>" +
+                "<rules>" +
+                "  <data source='$[in]' name='$[out]' />" +
+                "</rules>",
+                i -> {
+                    i.startRecord("1");
+                    i.literal("Honolulu", "Aloha");
+                    i.endRecord();
+                },
+                o -> {
+                    o.get().startRecord("1");
+                    o.get().literal("Hawaii", "Aloha");
+                    o.get().endRecord();
+                }
+        );
     }
 
     @Test
     public void shouldAllowTreatingEntityEndEventsAsLiterals() {
-        metamorph = InlineMorph.in(this)
-                .with("<rules>")
-                .with("  <data source='e1' />")
-                .with("  <data source='e1.e2' />")
-                .with("  <data source='e1.e2.d' />")
-                .with("</rules>")
-                .createConnectedTo(receiver);
-
-        metamorph.startRecord("entity end info");
-        metamorph.startEntity("e1");
-        metamorph.startEntity("e2");
-        metamorph.literal("d", "a");
-        metamorph.endEntity();
-        metamorph.endEntity();
-        metamorph.endRecord();
-
-        final InOrder ordered = inOrder(receiver);
-        ordered.verify(receiver).startRecord("entity end info");
-        ordered.verify(receiver).literal("e1.e2.d", "a");
-        ordered.verify(receiver).literal("e1.e2", "");
-        ordered.verify(receiver).literal("e1", "");
-        ordered.verify(receiver).endRecord();
-        ordered.verifyNoMoreInteractions();
+        assertMorph(receiver,
+                "<rules>" +
+                "  <data source='e1' />" +
+                "  <data source='e1.e2' />" +
+                "  <data source='e1.e2.d' />" +
+                "</rules>",
+                i -> {
+                    i.startRecord("entity end info");
+                    i.startEntity("e1");
+                    i.startEntity("e2");
+                    i.literal("d", "a");
+                    i.endEntity();
+                    i.endEntity();
+                    i.endRecord();
+                },
+                o -> {
+                    o.get().startRecord("entity end info");
+                    o.get().literal("e1.e2.d", "a");
+                    o.get().literal("e1.e2", "");
+                    o.get().literal("e1", "");
+                    o.get().endRecord();
+                }
+        );
     }
 
 }
diff --git a/metamorph/src/test/java/org/metafacture/metamorph/TestMetamorphMacros.java b/metamorph/src/test/java/org/metafacture/metamorph/TestMetamorphMacros.java
index c256a3f6f..f0edadee3 100644
--- a/metamorph/src/test/java/org/metafacture/metamorph/TestMetamorphMacros.java
+++ b/metamorph/src/test/java/org/metafacture/metamorph/TestMetamorphMacros.java
@@ -15,13 +15,11 @@
  */
 package org.metafacture.metamorph;
 
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.verify;
+import static org.metafacture.metamorph.TestHelpers.assertMorph;
 
 import org.junit.Rule;
 import org.junit.Test;
 import org.metafacture.framework.StreamReceiver;
-import org.mockito.InOrder;
 import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnit;
 import org.mockito.junit.MockitoRule;
@@ -39,162 +37,152 @@ public class TestMetamorphMacros {
     @Mock
     private StreamReceiver receiver;
 
-    private Metamorph metamorph;
-
     @Test
     public void shouldReplaceCallMacroWithMacro() {
-        metamorph = InlineMorph.in(this)
-                .with("<macros>")
-                .with("  <macro name='simple-macro'>")
-                .with("    <data source='$[in]' name='$[out]' />")
-                .with("  </macro>")
-                .with("</macros>")
-                .with("<rules>")
-                .with("  <call-macro name='simple-macro' in='in1' out='out1' />")
-                .with("  <call-macro name='simple-macro' in='in2' out='out2' />")
-                .with("</rules>")
-                .createConnectedTo(receiver);
-
-        metamorph.startRecord("1");
-        metamorph.literal("in1", "Hawaii");
-        metamorph.literal("in2", "Maui");
-        metamorph.endRecord();
-
-        verify(receiver).literal("out1", "Hawaii");
-        verify(receiver).literal("out2", "Maui");
+        assertMorph(receiver,
+                "<macros>" +
+                "  <macro name='simple-macro'>" +
+                "    <data source='$[in]' name='$[out]' />" +
+                "  </macro>" +
+                "</macros>" +
+                "<rules>" +
+                "  <call-macro name='simple-macro' in='in1' out='out1' />" +
+                "  <call-macro name='simple-macro' in='in2' out='out2' />" +
+                "</rules>",
+                i -> {
+                    i.startRecord("1");
+                    i.literal("in1", "Hawaii");
+                    i.literal("in2", "Maui");
+                    i.endRecord();
+                },
+                o -> {
+                    o.get().startRecord("1");
+                    o.get().literal("out1", "Hawaii");
+                    o.get().literal("out2", "Maui");
+                    o.get().endRecord();
+                }
+        );
     }
 
     @Test
     public void shouldAllowCallMacroInEntities() {
-        metamorph = InlineMorph.in(this)
-                .with("<macros>")
-                .with("  <macro name='simple-macro'>")
-                .with("    <data source='Honolulu' name='Honolulu' />")
-                .with("  </macro>")
-                .with("</macros>")
-                .with("<rules>")
-                .with("  <entity name='Hawaii'>")
-                .with("    <call-macro name='simple-macro' />")
-                .with("  </entity>")
-                .with("</rules>")
-                .createConnectedTo(receiver);
-
-        processRecordWithSingleLiteral();
-
-        verifyEntityWithSingleLiteral();
+        testSingleLiteral(true,
+                "<macros>" +
+                "  <macro name='simple-macro'>" +
+                "    <data source='Honolulu' name='Honolulu' />" +
+                "  </macro>" +
+                "</macros>" +
+                "<rules>" +
+                "  <entity name='Hawaii'>" +
+                "    <call-macro name='simple-macro' />" +
+                "  </entity>" +
+                "</rules>"
+        );
     }
 
     @Test
     public void shouldAllowNestedMacros() {
-        metamorph = InlineMorph.in(this)
-                .with("<macros>")
-                .with("  <macro name='inner-macro'>")
-                .with("    <data source='$[literal]' />")
-                .with("  </macro>")
-                .with("  <macro name='outer-macro'>")
-                .with("    <entity name='$[entity]'>")
-                .with("      <call-macro name='inner-macro' literal='Honolulu' />")
-                .with("    </entity>")
-                .with("  </macro>")
-                .with("</macros>")
-                .with("<rules>")
-                .with("  <call-macro name='outer-macro' entity='Hawaii' />")
-                .with("</rules>")
-                .createConnectedTo(receiver);
-
-        processRecordWithSingleLiteral();
-
-        verifyEntityWithSingleLiteral();
+        testSingleLiteral(true,
+                "<macros>" +
+                "  <macro name='inner-macro'>" +
+                "    <data source='$[literal]' />" +
+                "  </macro>" +
+                "  <macro name='outer-macro'>" +
+                "    <entity name='$[entity]'>" +
+                "      <call-macro name='inner-macro' literal='Honolulu' />" +
+                "    </entity>" +
+                "  </macro>" +
+                "</macros>" +
+                "<rules>" +
+                "  <call-macro name='outer-macro' entity='Hawaii' />" +
+                "</rules>"
+        );
     }
 
     @Test
     public void shouldAllowoForwardReferencingMacros() {
-        metamorph = InlineMorph.in(this)
-                .with("<macros>")
-                .with("  <macro name='referencing'>")
-                .with("    <entity name='Hawaii'>")
-                .with("      <call-macro name='forward-referenced' />")
-                .with("    </entity>")
-                .with("  </macro>")
-                .with("  <macro name='forward-referenced'>")
-                .with("    <data source='Honolulu' />")
-                .with("  </macro>")
-                .with("</macros>")
-                .with("<rules>")
-                .with("  <call-macro name='referencing' />")
-                .with("</rules>")
-                .createConnectedTo(receiver);
-
-        processRecordWithSingleLiteral();
-
-        verifyEntityWithSingleLiteral();
+        testSingleLiteral(true,
+                "<macros>" +
+                "  <macro name='referencing'>" +
+                "    <entity name='Hawaii'>" +
+                "      <call-macro name='forward-referenced' />" +
+                "    </entity>" +
+                "  </macro>" +
+                "  <macro name='forward-referenced'>" +
+                "    <data source='Honolulu' />" +
+                "  </macro>" +
+                "</macros>" +
+                "<rules>" +
+                "  <call-macro name='referencing' />" +
+                "</rules>"
+        );
     }
 
     @Test
     public void shouldSupportVariablesInMacroParameters() {
-        metamorph = InlineMorph.in(this)
-                .with("<macros>")
-                .with("  <macro name='inner-macro'>")
-                .with("    <data source='$[source]' />")
-                .with("  </macro>")
-                .with("  <macro name='outer-macro'>")
-                .with("    <entity name='Hawaii'>")
-                .with("      <call-macro name='inner-macro' source='$[literal]' />")
-                .with("    </entity>")
-                .with("  </macro>")
-                .with("</macros>")
-                .with("<rules>")
-                .with("  <call-macro name='outer-macro' literal='Honolulu' />")
-                .with("</rules>")
-                .createConnectedTo(receiver);
-
-        processRecordWithSingleLiteral();
-
-        verifyEntityWithSingleLiteral();
+        testSingleLiteral(true,
+                "<macros>" +
+                "  <macro name='inner-macro'>" +
+                "    <data source='$[source]' />" +
+                "  </macro>" +
+                "  <macro name='outer-macro'>" +
+                "    <entity name='Hawaii'>" +
+                "      <call-macro name='inner-macro' source='$[literal]' />" +
+                "    </entity>" +
+                "  </macro>" +
+                "</macros>" +
+                "<rules>" +
+                "  <call-macro name='outer-macro' literal='Honolulu' />" +
+                "</rules>"
+        );
     }
 
     @Test
     public void issue227_shouldSupportXincludeForMacros() {
-        metamorph = InlineMorph.in(this)
-                .with("<include href='issue227_should-support-xinclude-for-macros.xml'")
-                .with("    xmlns='http://www.w3.org/2001/XInclude' />")
-                .with("<rules>")
-                .with("  <call-macro name='included-macro' />")
-                .with("</rules>")
-                .createConnectedTo(receiver);
-
-        processRecordWithSingleLiteral();
-
-        verify(receiver).literal("Honolulu", "Aloha");
+        testSingleLiteral(false,
+                "<include href='issue227_should-support-xinclude-for-macros.xml'" +
+                "    xmlns='http://www.w3.org/2001/XInclude' />" +
+                "<rules>" +
+                "  <call-macro name='included-macro' />" +
+                "</rules>"
+        );
     }
 
     @Test
     public void shouldSupportXPointer() {
-        metamorph = InlineMorph.in(this)
-                .with("<include href='should-support-xpointer.xml'")
-                .with("    xmlns='http://www.w3.org/2001/XInclude'")
-                .with("    xpointer='element(/1/1)' />")
-                .with("<rules>")
-                .with("  <call-macro name='included-macro' />")
-                .with("</rules>")
-                .createConnectedTo(receiver);
-
-        processRecordWithSingleLiteral();
-
-        verify(receiver).literal("Honolulu", "Aloha");
-    }
-
-    private void processRecordWithSingleLiteral() {
-        metamorph.startRecord("1");
-        metamorph.literal("Honolulu", "Aloha");
-        metamorph.endRecord();
+        testSingleLiteral(false,
+                "<include href='should-support-xpointer.xml'" +
+                "    xmlns='http://www.w3.org/2001/XInclude'" +
+                "    xpointer='element(/1/1)' />" +
+                "<rules>" +
+                "  <call-macro name='included-macro' />" +
+                "</rules>"
+        );
     }
 
-    private void verifyEntityWithSingleLiteral() {
-        final InOrder ordered = inOrder(receiver);
-        ordered.verify(receiver).startEntity("Hawaii");
-        ordered.verify(receiver).literal("Honolulu", "Aloha");
-        ordered.verify(receiver).endEntity();
+    private void testSingleLiteral(final boolean withEntity, final String morphDef) {
+        assertMorph(receiver, morphDef,
+                i -> {
+                    i.startRecord("1");
+                    i.literal("Honolulu", "Aloha");
+                    i.endRecord();
+                },
+                o -> {
+                    o.get().startRecord("1");
+
+                    if (withEntity) {
+                        o.get().startEntity("Hawaii");
+                    }
+
+                    o.get().literal("Honolulu", "Aloha");
+
+                    if (withEntity) {
+                        o.get().endEntity();
+                    }
+
+                    o.get().endRecord();
+                }
+        );
     }
 
 }
diff --git a/metamorph/src/test/java/org/metafacture/metamorph/collectors/TuplesTest.java b/metamorph/src/test/java/org/metafacture/metamorph/collectors/TuplesTest.java
index 5fdd1a363..1909c9b09 100644
--- a/metamorph/src/test/java/org/metafacture/metamorph/collectors/TuplesTest.java
+++ b/metamorph/src/test/java/org/metafacture/metamorph/collectors/TuplesTest.java
@@ -15,14 +15,11 @@
  */
 package org.metafacture.metamorph.collectors;
 
-import static org.mockito.Mockito.inOrder;
+import static org.metafacture.metamorph.TestHelpers.assertMorph;
 
 import org.junit.Rule;
 import org.junit.Test;
 import org.metafacture.framework.StreamReceiver;
-import org.metafacture.metamorph.InlineMorph;
-import org.metafacture.metamorph.Metamorph;
-import org.mockito.InOrder;
 import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnit;
 import org.mockito.junit.MockitoRule;
@@ -35,127 +32,125 @@
  */
 public final class TuplesTest {
 
-  @Rule
-  public final MockitoRule mockitoRule = MockitoJUnit.rule();
-
-  @Mock
-  private StreamReceiver receiver;
-
-  private Metamorph metamorph;
-
-  @Test
-  public void shouldEmitTwoandThreeTuples() {
-    metamorph = InlineMorph.in(this)
-        .with("<rules>")
-        .with("  <tuples name='product'>")
-        .with("    <data source='1' />")
-        .with("    <data source='3' />")
-        .with("    <data source='2' />")
-        .with("  </tuples>")
-        .with("</rules>")
-        .createConnectedTo(receiver);
-
-    metamorph.startRecord("1");
-    metamorph.literal("1", "a");
-    metamorph.literal("1", "b");
-    metamorph.literal("2", "A");
-    metamorph.literal("2", "B");
-    metamorph.endRecord();
-    metamorph.startRecord("2");
-    metamorph.literal("3", "X");
-    metamorph.literal("1", "c");
-    metamorph.literal("1", "d");
-    metamorph.literal("2", "C");
-    metamorph.literal("3", "Y");
-    metamorph.literal("2", "D");
-    metamorph.endRecord();
-
-    final InOrder ordered = inOrder(receiver);
-    ordered.verify(receiver).startRecord("1");
-    ordered.verify(receiver).literal("product", "aA");
-    ordered.verify(receiver).literal("product", "bA");
-    ordered.verify(receiver).literal("product", "aB");
-    ordered.verify(receiver).literal("product", "bB");
-    ordered.verify(receiver).endRecord();
-    ordered.verify(receiver).startRecord("2");
-    ordered.verify(receiver).literal("product", "cCX");
-    ordered.verify(receiver).literal("product", "dCX");
-    ordered.verify(receiver).literal("product", "cDX");
-    ordered.verify(receiver).literal("product", "dDX");
-    ordered.verify(receiver).literal("product", "cCY");
-    ordered.verify(receiver).literal("product", "dCY");
-    ordered.verify(receiver).literal("product", "cDY");
-    ordered.verify(receiver).literal("product", "dDY");
-    ordered.verify(receiver).endRecord();
-    ordered.verifyNoMoreInteractions();
-  }
-
-  @Test
-  public void shouldOnlyEmitTriplesWithMoreThanMinNValues() {
-    metamorph = InlineMorph.in(this)
-        .with("<rules>")
-        .with("  <tuples name='product' minN='3'>")
-        .with("    <data source='1' />")
-        .with("    <data source='3' />")
-        .with("    <data source='2' />")
-        .with("  </tuples>")
-        .with("</rules>")
-        .createConnectedTo(receiver);
-
-    metamorph.startRecord("1");
-    metamorph.literal("1", "a");
-    metamorph.literal("1", "b");
-    metamorph.literal("2", "A");
-    metamorph.literal("2", "B");
-    metamorph.endRecord();
-    metamorph.startRecord("2");
-    metamorph.literal("3", "X");
-    metamorph.literal("1", "c");
-    metamorph.literal("1", "d");
-    metamorph.literal("2", "C");
-    metamorph.literal("3", "Y");
-    metamorph.literal("2", "D");
-    metamorph.endRecord();
-
-    final InOrder ordered = inOrder(receiver);
-    ordered.verify(receiver).startRecord("1");
-    ordered.verify(receiver).endRecord();
-    ordered.verify(receiver).startRecord("2");
-    ordered.verify(receiver).literal("product", "cCX");
-    ordered.verify(receiver).literal("product", "dCX");
-    ordered.verify(receiver).literal("product", "cDX");
-    ordered.verify(receiver).literal("product", "dDX");
-    ordered.verify(receiver).literal("product", "cCY");
-    ordered.verify(receiver).literal("product", "dCY");
-    ordered.verify(receiver).literal("product", "cDY");
-    ordered.verify(receiver).literal("product", "dDY");
-    ordered.verify(receiver).endRecord();
-    ordered.verifyNoMoreInteractions();
-  }
-
-  @Test
-  public void shouldEmitTuplesWithMinNIfNotAllStatementsFired() {
-    metamorph = InlineMorph.in(this)
-        .with("<rules>")
-        .with("  <tuples name='product' minN='1'>")
-        .with("    <data source='1' />")
-        .with("    <data source='3' />")
-        .with("    <data source='2' />")
-        .with("  </tuples>")
-        .with("</rules>")
-        .createConnectedTo(receiver);
-
-    metamorph.startRecord("1");
-    metamorph.literal("1", "a");
-    metamorph.literal("1", "b");
-    metamorph.endRecord();
-
-    final InOrder ordered = inOrder(receiver);
-    ordered.verify(receiver).startRecord("1");
-    ordered.verify(receiver).literal("product", "a");
-    ordered.verify(receiver).literal("product", "b");
-    ordered.verify(receiver).endRecord();
-    ordered.verifyNoMoreInteractions();
-  }
+    @Rule
+    public final MockitoRule mockitoRule = MockitoJUnit.rule();
+
+    @Mock
+    private StreamReceiver receiver;
+
+    @Test
+    public void shouldEmitTwoAndThreeTuples() {
+        assertMorph(receiver,
+                "<rules>" +
+                "  <tuples name='product'>" +
+                "    <data source='1' />" +
+                "    <data source='3' />" +
+                "    <data source='2' />" +
+                "  </tuples>" +
+                "</rules>",
+                i -> {
+                    i.startRecord("1");
+                    i.literal("1", "a");
+                    i.literal("1", "b");
+                    i.literal("2", "A");
+                    i.literal("2", "B");
+                    i.endRecord();
+                    i.startRecord("2");
+                    i.literal("3", "X");
+                    i.literal("1", "c");
+                    i.literal("1", "d");
+                    i.literal("2", "C");
+                    i.literal("3", "Y");
+                    i.literal("2", "D");
+                    i.endRecord();
+                },
+                o -> {
+                    o.get().startRecord("1");
+                    o.get().literal("product", "aA");
+                    o.get().literal("product", "bA");
+                    o.get().literal("product", "aB");
+                    o.get().literal("product", "bB");
+                    o.get().endRecord();
+                    o.get().startRecord("2");
+                    o.get().literal("product", "cCX");
+                    o.get().literal("product", "dCX");
+                    o.get().literal("product", "cDX");
+                    o.get().literal("product", "dDX");
+                    o.get().literal("product", "cCY");
+                    o.get().literal("product", "dCY");
+                    o.get().literal("product", "cDY");
+                    o.get().literal("product", "dDY");
+                    o.get().endRecord();
+                }
+        );
+    }
+
+    @Test
+    public void shouldOnlyEmitTriplesWithMoreThanMinNValues() {
+        assertMorph(receiver,
+                "<rules>" +
+                "  <tuples name='product' minN='3'>" +
+                "    <data source='1' />" +
+                "    <data source='3' />" +
+                "    <data source='2' />" +
+                "  </tuples>" +
+                "</rules>",
+                i -> {
+                    i.startRecord("1");
+                    i.literal("1", "a");
+                    i.literal("1", "b");
+                    i.literal("2", "A");
+                    i.literal("2", "B");
+                    i.endRecord();
+                    i.startRecord("2");
+                    i.literal("3", "X");
+                    i.literal("1", "c");
+                    i.literal("1", "d");
+                    i.literal("2", "C");
+                    i.literal("3", "Y");
+                    i.literal("2", "D");
+                    i.endRecord();
+                },
+                o -> {
+                    o.get().startRecord("1");
+                    o.get().endRecord();
+                    o.get().startRecord("2");
+                    o.get().literal("product", "cCX");
+                    o.get().literal("product", "dCX");
+                    o.get().literal("product", "cDX");
+                    o.get().literal("product", "dDX");
+                    o.get().literal("product", "cCY");
+                    o.get().literal("product", "dCY");
+                    o.get().literal("product", "cDY");
+                    o.get().literal("product", "dDY");
+                    o.get().endRecord();
+                }
+        );
+    }
+
+    @Test
+    public void shouldEmitTuplesWithMinNIfNotAllStatementsFired() {
+        assertMorph(receiver,
+                "<rules>" +
+                "  <tuples name='product' minN='1'>" +
+                "    <data source='1' />" +
+                "    <data source='3' />" +
+                "    <data source='2' />" +
+                "  </tuples>" +
+                "</rules>",
+                i -> {
+                    i.startRecord("1");
+                    i.literal("1", "a");
+                    i.literal("1", "b");
+                    i.endRecord();
+                },
+                o -> {
+                    o.get().startRecord("1");
+                    o.get().literal("product", "a");
+                    o.get().literal("product", "b");
+                    o.get().endRecord();
+                }
+        );
+    }
 
 }
diff --git a/metamorph/src/test/java/org/metafacture/metamorph/functions/LookupTest.java b/metamorph/src/test/java/org/metafacture/metamorph/functions/LookupTest.java
index ecf630d5f..aaccb64c9 100644
--- a/metamorph/src/test/java/org/metafacture/metamorph/functions/LookupTest.java
+++ b/metamorph/src/test/java/org/metafacture/metamorph/functions/LookupTest.java
@@ -49,7 +49,7 @@ public final class LookupTest {
     private static final String VALUE = "Kafka";
 
     @Rule
-    public MockitoRule mockito = MockitoJUnit.rule();
+    public MockitoRule mockito = MockitoJUnit.rule().silent();
 
     @Mock
     private Maps maps;
diff --git a/metamorph/src/test/java/org/metafacture/metamorph/functions/UniqueTest.java b/metamorph/src/test/java/org/metafacture/metamorph/functions/UniqueTest.java
index 658b57554..2fcdf7c96 100644
--- a/metamorph/src/test/java/org/metafacture/metamorph/functions/UniqueTest.java
+++ b/metamorph/src/test/java/org/metafacture/metamorph/functions/UniqueTest.java
@@ -15,15 +15,11 @@
  */
 package org.metafacture.metamorph.functions;
 
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.times;
+import static org.metafacture.metamorph.TestHelpers.assertMorph;
 
 import org.junit.Rule;
 import org.junit.Test;
 import org.metafacture.framework.StreamReceiver;
-import org.metafacture.metamorph.InlineMorph;
-import org.metafacture.metamorph.Metamorph;
-import org.mockito.InOrder;
 import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnit;
 import org.mockito.junit.MockitoRule;
@@ -42,114 +38,112 @@ public final class UniqueTest {
   @Mock
   private StreamReceiver receiver;
 
-  private Metamorph metamorph;
-
   @Test
   public void shouldAllowSelectingTheUniqueScope() {
-    metamorph = InlineMorph.in(this)
-        .with("<rules>")
-        .with("  <data source='data' name='inRecord'>")
-        .with("    <unique />")
-        .with("  </data>")
-        .with("  <data source='e.data' name='inEntity'>")
-        .with("    <unique in='entity' />")
-        .with("  </data>")
-        .with("</rules>")
-        .createConnectedTo(receiver);
-
-    metamorph.startRecord("1");
-    metamorph.startEntity("e");
-    metamorph.literal("data", "d");
-    metamorph.literal("data", "d");
-    metamorph.endEntity();
-    metamorph.startEntity("e");
-    metamorph.literal("data", "d");
-    metamorph.literal("data", "d");
-    metamorph.endEntity();
-    metamorph.literal("data", "d");
-    metamorph.literal("data", "d");
-    metamorph.literal("data", "d");
-    metamorph.endRecord();
-    metamorph.startRecord("2");
-    metamorph.startEntity("e");
-    metamorph.literal("data", "d");
-    metamorph.literal("data", "d");
-    metamorph.endEntity();
-    metamorph.startEntity("e");
-    metamorph.literal("data", "d");
-    metamorph.literal("data", "d");
-    metamorph.endEntity();
-    metamorph.literal("data", "d");
-    metamorph.literal("data", "d");
-    metamorph.literal("data", "d");
-    metamorph.endRecord();
-
-    final InOrder ordered = inOrder(receiver);
-    ordered.verify(receiver).startRecord("1");
-    ordered.verify(receiver, times(2)).literal("inEntity", "d");
-    ordered.verify(receiver).literal("inRecord", "d");
-    ordered.verify(receiver).endRecord();
-    ordered.verify(receiver).startRecord("2");
-    ordered.verify(receiver, times(2)).literal("inEntity", "d");
-    ordered.verify(receiver).literal("inRecord", "d");
-    ordered.verify(receiver).endRecord();
-    ordered.verifyNoMoreInteractions();
+      assertMorph(receiver,
+              "<rules>" +
+              "  <data source='data' name='inRecord'>" +
+              "    <unique />" +
+              "  </data>" +
+              "  <data source='e.data' name='inEntity'>" +
+              "    <unique in='entity' />" +
+              "  </data>" +
+              "</rules>",
+              i -> {
+                  i.startRecord("1");
+                  i.startEntity("e");
+                  i.literal("data", "d");
+                  i.literal("data", "d");
+                  i.endEntity();
+                  i.startEntity("e");
+                  i.literal("data", "d");
+                  i.literal("data", "d");
+                  i.endEntity();
+                  i.literal("data", "d");
+                  i.literal("data", "d");
+                  i.literal("data", "d");
+                  i.endRecord();
+                  i.startRecord("2");
+                  i.startEntity("e");
+                  i.literal("data", "d");
+                  i.literal("data", "d");
+                  i.endEntity();
+                  i.startEntity("e");
+                  i.literal("data", "d");
+                  i.literal("data", "d");
+                  i.endEntity();
+                  i.literal("data", "d");
+                  i.literal("data", "d");
+                  i.literal("data", "d");
+                  i.endRecord();
+              },
+              (o, f) -> {
+                  o.get().startRecord("1");
+                  f.apply(2).literal("inEntity", "d");
+                  o.get().literal("inRecord", "d");
+                  o.get().endRecord();
+                  o.get().startRecord("2");
+                  f.apply(2).literal("inEntity", "d");
+                  o.get().literal("inRecord", "d");
+                  o.get().endRecord();
+              }
+      );
   }
 
   @Test
   public void shouldAllowSelectingTheUniquePart() {
-    metamorph = InlineMorph.in(this)
-        .with("<rules>")
-        .with("  <group name='name'>")
-        .with("    <group>")
-        .with("      <data source='data1' />")
-        .with("      <data source='data2' />")
-        .with("      <postprocess>")
-        .with("        <unique part='name' />")
-        .with("      </postprocess>")
-        .with("    </group>")
-        .with("  </group>")
-        .with("  <group name='value'>")
-        .with("    <group>")
-        .with("      <data source='data1' />")
-        .with("      <data source='data2' />")
-        .with("      <postprocess>")
-        .with("        <unique part='value' />")
-        .with("      </postprocess>")
-        .with("    </group>")
-        .with("  </group>")
-        .with("  <group name='both'>")
-        .with("    <group>")
-        .with("      <data source='data1' />")
-        .with("      <data source='data2' />")
-        .with("      <postprocess>")
-        .with("        <unique part='name-value' />")
-        .with("      </postprocess>")
-        .with("    </group>")
-        .with("  </group>")
-        .with("</rules>")
-        .createConnectedTo(receiver);
-
-    metamorph.startRecord("1");
-    metamorph.literal("data1", "d1");
-    metamorph.literal("data1", "d1");
-    metamorph.literal("data1", "d2");
-    metamorph.literal("data1", "d2");
-    metamorph.literal("data2", "d2");
-    metamorph.literal("data2", "d2");
-    metamorph.endRecord();
-
-    final InOrder ordered = inOrder(receiver);
-    ordered.verify(receiver).startRecord("1");
-    ordered.verify(receiver).literal("name", "d1");
-    ordered.verify(receiver).literal("value", "d1");
-    ordered.verify(receiver).literal("both", "d1");
-    ordered.verify(receiver).literal("value", "d2");
-    ordered.verify(receiver).literal("both", "d2");
-    ordered.verify(receiver).literal("name", "d2");
-    ordered.verify(receiver).literal("both", "d2");
-    ordered.verify(receiver).endRecord();
-    ordered.verifyNoMoreInteractions();
+      assertMorph(receiver,
+              "<rules>" +
+              "  <group name='name'>" +
+              "    <group>" +
+              "      <data source='data1' />" +
+              "      <data source='data2' />" +
+              "      <postprocess>" +
+              "        <unique part='name' />" +
+              "      </postprocess>" +
+              "    </group>" +
+              "  </group>" +
+              "  <group name='value'>" +
+              "    <group>" +
+              "      <data source='data1' />" +
+              "      <data source='data2' />" +
+              "      <postprocess>" +
+              "        <unique part='value' />" +
+              "      </postprocess>" +
+              "    </group>" +
+              "  </group>" +
+              "  <group name='both'>" +
+              "    <group>" +
+              "      <data source='data1' />" +
+              "      <data source='data2' />" +
+              "      <postprocess>" +
+              "        <unique part='name-value' />" +
+              "      </postprocess>" +
+              "    </group>" +
+              "  </group>" +
+              "</rules>",
+          i -> {
+              i.startRecord("1");
+              i.literal("data1", "d1");
+              i.literal("data1", "d1");
+              i.literal("data1", "d2");
+              i.literal("data1", "d2");
+              i.literal("data2", "d2");
+              i.literal("data2", "d2");
+              i.endRecord();
+          },
+          o -> {
+              o.get().startRecord("1");
+              o.get().literal("name", "d1");
+              o.get().literal("value", "d1");
+              o.get().literal("both", "d1");
+              o.get().literal("value", "d2");
+              o.get().literal("both", "d2");
+              o.get().literal("name", "d2");
+              o.get().literal("both", "d2");
+              o.get().endRecord();
+          }
+      );
   }
 
 }
diff --git a/metamorph/src/test/java/org/metafacture/metamorph/maps/FileMapTest.java b/metamorph/src/test/java/org/metafacture/metamorph/maps/FileMapTest.java
index bde21a7f1..17b544d4f 100644
--- a/metamorph/src/test/java/org/metafacture/metamorph/maps/FileMapTest.java
+++ b/metamorph/src/test/java/org/metafacture/metamorph/maps/FileMapTest.java
@@ -15,14 +15,11 @@
  */
 package org.metafacture.metamorph.maps;
 
-import static org.mockito.Mockito.inOrder;
+import static org.metafacture.metamorph.TestHelpers.assertMorph;
 
 import org.junit.Rule;
 import org.junit.Test;
 import org.metafacture.framework.StreamReceiver;
-import org.metafacture.metamorph.InlineMorph;
-import org.metafacture.metamorph.Metamorph;
-import org.mockito.InOrder;
 import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnit;
 import org.mockito.junit.MockitoRule;
@@ -35,65 +32,63 @@
  */
 public final class FileMapTest {
 
-  @Rule
-  public final MockitoRule mockitoRule = MockitoJUnit.rule();
+    @Rule
+    public final MockitoRule mockitoRule = MockitoJUnit.rule();
 
-  @Mock
-  private StreamReceiver receiver;
+    @Mock
+    private StreamReceiver receiver;
 
-  private Metamorph metamorph;
-
-  @Test
-  public void shouldLookupValuesInFileBasedMap() {
-    metamorph = InlineMorph.in(this)
-        .with("<rules>")
-        .with("  <data source='1'>")
-        .with("    <lookup in='map1' />")
-        .with("  </data>")
-        .with("</rules>")
-        .with("<maps>")
-        .with("  <filemap name='map1' files='org/metafacture/metamorph/maps/file-map-test.txt' />")
-        .with("</maps>")
-        .createConnectedTo(receiver);
-
-    metamorph.startRecord("1");
-    metamorph.literal("1", "gw");
-    metamorph.literal("1", "fj");
-    metamorph.endRecord();
-
-    final InOrder ordered = inOrder(receiver);
-    ordered.verify(receiver).startRecord("1");
-    ordered.verify(receiver).literal("1", "Germany");
-    ordered.verify(receiver).literal("1", "Fiji");
-    ordered.verify(receiver).endRecord();
-    ordered.verifyNoMoreInteractions();
-  }
+    @Test
+    public void shouldLookupValuesInFileBasedMap() {
+        assertMorph(receiver,
+                "<rules>" +
+                "  <data source='1'>" +
+                "    <lookup in='map1' />" +
+                "  </data>" +
+                "</rules>" +
+                "<maps>" +
+                "  <filemap name='map1' files='org/metafacture/metamorph/maps/file-map-test.txt' />" +
+                "</maps>",
+                i -> {
+                    i.startRecord("1");
+                    i.literal("1", "gw");
+                    i.literal("1", "fj");
+                    i.endRecord();
+                },
+                o -> {
+                    o.get().startRecord("1");
+                    o.get().literal("1", "Germany");
+                    o.get().literal("1", "Fiji");
+                    o.get().endRecord();
+                }
+        );
+    }
 
     @Test
     public void shouldWhitelistValuesInFileBasedMap() {
-        metamorph = InlineMorph.in(this)
-                .with("<rules>")
-                .with("  <data source='1'>")
-                .with("    <whitelist map='map1' />")
-                .with("  </data>")
-                .with("</rules>")
-                .with("<maps>")
-                .with("  <filemap name='map1' files='org/metafacture/metamorph/maps/file-map-test.txt' />")
-                .with("</maps>")
-                .createConnectedTo(receiver);
-
-        metamorph.startRecord("1");
-        metamorph.literal("1", "gw");
-        metamorph.literal("1", "fj");
-        metamorph.literal("1", "bla");
-        metamorph.endRecord();
-
-        final InOrder ordered = inOrder(receiver);
-        ordered.verify(receiver).startRecord("1");
-        ordered.verify(receiver).literal("1", "gw");
-        ordered.verify(receiver).literal("1", "fj");
-        ordered.verify(receiver).endRecord();
-        ordered.verifyNoMoreInteractions();
+        assertMorph(receiver,
+                "<rules>" +
+                "  <data source='1'>" +
+                "    <whitelist map='map1' />" +
+                "  </data>" +
+                "</rules>" +
+                "<maps>" +
+                "  <filemap name='map1' files='org/metafacture/metamorph/maps/file-map-test.txt' />" +
+                "</maps>",
+                i -> {
+                    i.startRecord("1");
+                    i.literal("1", "gw");
+                    i.literal("1", "fj");
+                    i.literal("1", "bla");
+                    i.endRecord();
+                },
+                o -> {
+                    o.get().startRecord("1");
+                    o.get().literal("1", "gw");
+                    o.get().literal("1", "fj");
+                    o.get().endRecord();
+                }
+        );
     }
 
 }
diff --git a/metamorph/src/test/java/org/metafacture/metamorph/maps/JavaMapTest.java b/metamorph/src/test/java/org/metafacture/metamorph/maps/JavaMapTest.java
index fbd4c6039..59ef90b5a 100644
--- a/metamorph/src/test/java/org/metafacture/metamorph/maps/JavaMapTest.java
+++ b/metamorph/src/test/java/org/metafacture/metamorph/maps/JavaMapTest.java
@@ -15,14 +15,11 @@
  */
 package org.metafacture.metamorph.maps;
 
-import static org.mockito.Mockito.inOrder;
+import static org.metafacture.metamorph.TestHelpers.assertMorph;
 
 import org.junit.Rule;
 import org.junit.Test;
 import org.metafacture.framework.StreamReceiver;
-import org.metafacture.metamorph.InlineMorph;
-import org.metafacture.metamorph.Metamorph;
-import org.mockito.InOrder;
 import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnit;
 import org.mockito.junit.MockitoRule;
@@ -36,38 +33,36 @@
  */
 public final class JavaMapTest {
 
-  @Rule
-  public final MockitoRule mockitoRule = MockitoJUnit.rule();
+    @Rule
+    public final MockitoRule mockitoRule = MockitoJUnit.rule();
 
-  @Mock
-  private StreamReceiver receiver;
+    @Mock
+    private StreamReceiver receiver;
 
-  private Metamorph metamorph;
-
-  @Test
-  public void shouldLookupValuesInJavaBackedMap() {
-    metamorph = InlineMorph.in(this)
-        .with("<rules>")
-        .with("  <data source='1'>")
-        .with("    <lookup in='map1' />")
-        .with("  </data>")
-        .with("</rules>")
-        .with("<maps>")
-        .with("  <javamap name='map1' class='org.metafacture.metamorph.maps.FileMap' files='org/metafacture/metamorph/maps/java-map-test.txt' />")
-        .with("</maps>")
-        .createConnectedTo(receiver);
-
-    metamorph.startRecord("1");
-    metamorph.literal("1", "gw");
-    metamorph.literal("1", "fj");
-    metamorph.endRecord();
-
-    final InOrder ordered = inOrder(receiver);
-    ordered.verify(receiver).startRecord("1");
-    ordered.verify(receiver).literal("1", "Germany");
-    ordered.verify(receiver).literal("1", "Fiji");
-    ordered.verify(receiver).endRecord();
-    ordered.verifyNoMoreInteractions();
-  }
+    @Test
+    public void shouldLookupValuesInJavaBackedMap() {
+        assertMorph(receiver,
+                "<rules>" +
+                "  <data source='1'>" +
+                "    <lookup in='map1' />" +
+                "  </data>" +
+                "</rules>" +
+                "<maps>" +
+                "  <javamap name='map1' class='org.metafacture.metamorph.maps.FileMap' files='org/metafacture/metamorph/maps/java-map-test.txt' />" +
+                "</maps>",
+                i -> {
+                    i.startRecord("1");
+                    i.literal("1", "gw");
+                    i.literal("1", "fj");
+                    i.endRecord();
+                },
+                o -> {
+                    o.get().startRecord("1");
+                    o.get().literal("1", "Germany");
+                    o.get().literal("1", "Fiji");
+                    o.get().endRecord();
+                }
+        );
+    }
 
 }