diff --git a/javatests/google/registry/flows/domain/DomainCheckFlowTest.java b/javatests/google/registry/flows/domain/DomainCheckFlowTest.java
index 413137597..908f87336 100644
--- a/javatests/google/registry/flows/domain/DomainCheckFlowTest.java
+++ b/javatests/google/registry/flows/domain/DomainCheckFlowTest.java
@@ -24,7 +24,8 @@ import static google.registry.testing.DatastoreHelper.persistDeletedDomain;
 import static google.registry.testing.DatastoreHelper.persistPremiumList;
 import static google.registry.testing.DatastoreHelper.persistReservedList;
 import static google.registry.testing.DatastoreHelper.persistResource;
-import static google.registry.testing.JUnitBackports.assertThrows;
+import static google.registry.testing.EppExceptionSubject.assertAboutEppExceptions;
+import static google.registry.testing.JUnitBackports.expectThrows;
 import static google.registry.util.DateTimeUtils.START_OF_TIME;
 import static org.joda.money.CurrencyUnit.USD;
 
@@ -32,6 +33,8 @@ import com.google.common.base.Strings;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.ImmutableSortedMap;
+import com.google.common.collect.Ordering;
+import google.registry.flows.EppException;
 import google.registry.flows.ResourceCheckFlowTestCase;
 import google.registry.flows.domain.DomainCheckFlow.OnlyCheckedNamesCanBeFeeCheckedException;
 import google.registry.flows.domain.DomainFlowUtils.BadCommandForRegistryPhaseException;
@@ -76,13 +79,13 @@ public class DomainCheckFlowTest
   }
 
   private ReservedList createReservedList() throws Exception {
-      return persistReservedList(
-          "tld-reserved",
-          "reserved,FULLY_BLOCKED",
-          "anchor,RESERVED_FOR_ANCHOR_TENANT,foo2BAR",
-          "allowedinsunrise,ALLOWED_IN_SUNRISE",
-          "collision,NAME_COLLISION",
-          "premiumcollision,NAME_COLLISION");
+    return persistReservedList(
+        "tld-reserved",
+        "reserved,FULLY_BLOCKED",
+        "anchor,RESERVED_FOR_ANCHOR_TENANT,foo2BAR",
+        "allowedinsunrise,ALLOWED_IN_SUNRISE",
+        "collision,NAME_COLLISION",
+        "premiumcollision,NAME_COLLISION");
   }
 
   @Before
@@ -148,8 +151,9 @@ public class DomainCheckFlowTest
     persistResource(
         Registry.get("tld.foo")
             .asBuilder()
-            .setReservedLists(persistReservedList(
-                "tld.foo", "reserved,FULLY_BLOCKED", "allowedinsunrise,ALLOWED_IN_SUNRISE"))
+            .setReservedLists(
+                persistReservedList(
+                    "tld.foo", "reserved,FULLY_BLOCKED", "allowedinsunrise,ALLOWED_IN_SUNRISE"))
             .build());
     setEppInput("domain_check_one_multipart_tld_reserved.xml");
     doCheckTest(
@@ -171,9 +175,7 @@ public class DomainCheckFlowTest
   @Test
   public void testSuccess_duplicatesAllowed() throws Exception {
     setEppInput("domain_check_duplicates.xml");
-    doCheckTest(
-        create(true, "example1.tld", null),
-        create(true, "example1.tld", null));
+    doCheckTest(create(true, "example1.tld", null), create(true, "example1.tld", null));
   }
 
   @Test
@@ -192,8 +194,7 @@ public class DomainCheckFlowTest
   @Test
   public void testSuccess_pendingSunriseApplicationInGeneralAvailability() throws Exception {
     createTld("tld", TldState.GENERAL_AVAILABILITY);
-    persistResource(newDomainApplication("example2.tld").asBuilder()
-        .build());
+    persistResource(newDomainApplication("example2.tld").asBuilder().build());
     doCheckTest(
         create(true, "example1.tld", null),
         create(false, "example2.tld", "Pending allocation"),
@@ -203,9 +204,8 @@ public class DomainCheckFlowTest
   @Test
   public void testSuccess_pendingLandrushApplicationInGeneralAvailability() throws Exception {
     createTld("tld", TldState.GENERAL_AVAILABILITY);
-    persistResource(newDomainApplication("example2.tld").asBuilder()
-        .setPhase(LaunchPhase.LANDRUSH)
-        .build());
+    persistResource(
+        newDomainApplication("example2.tld").asBuilder().setPhase(LaunchPhase.LANDRUSH).build());
     doCheckTest(
         create(true, "example1.tld", null),
         create(false, "example2.tld", "Pending allocation"),
@@ -215,8 +215,7 @@ public class DomainCheckFlowTest
   @Test
   public void testSuccess_pendingSunriseApplicationInQuietPeriod() throws Exception {
     createTld("tld", TldState.QUIET_PERIOD);
-    persistResource(newDomainApplication("example2.tld").asBuilder()
-        .build());
+    persistResource(newDomainApplication("example2.tld").asBuilder().build());
     doCheckTest(
         create(true, "example1.tld", null),
         create(false, "example2.tld", "Pending allocation"),
@@ -226,9 +225,8 @@ public class DomainCheckFlowTest
   @Test
   public void testSuccess_pendingLandrushApplicationInQuietPeriod() throws Exception {
     createTld("tld", TldState.QUIET_PERIOD);
-    persistResource(newDomainApplication("example2.tld").asBuilder()
-        .setPhase(LaunchPhase.LANDRUSH)
-        .build());
+    persistResource(
+        newDomainApplication("example2.tld").asBuilder().setPhase(LaunchPhase.LANDRUSH).build());
     doCheckTest(
         create(true, "example1.tld", null),
         create(false, "example2.tld", "Pending allocation"),
@@ -238,8 +236,7 @@ public class DomainCheckFlowTest
   @Test
   public void testSuccess_pendingSunriseApplicationInSunrise() throws Exception {
     createTld("tld", TldState.SUNRISE);
-    persistResource(newDomainApplication("example2.tld").asBuilder()
-        .build());
+    persistResource(newDomainApplication("example2.tld").asBuilder().build());
     doCheckTest(
         create(true, "example1.tld", null),
         create(true, "example2.tld", null),
@@ -249,9 +246,8 @@ public class DomainCheckFlowTest
   @Test
   public void testSuccess_pendingLandrushApplicationInLandrush() throws Exception {
     createTld("tld", TldState.LANDRUSH);
-    persistResource(newDomainApplication("example2.tld").asBuilder()
-        .setPhase(LaunchPhase.LANDRUSH)
-        .build());
+    persistResource(
+        newDomainApplication("example2.tld").asBuilder().setPhase(LaunchPhase.LANDRUSH).build());
     doCheckTest(
         create(true, "example1.tld", null),
         create(true, "example2.tld", null),
@@ -261,10 +257,12 @@ public class DomainCheckFlowTest
   @Test
   public void testSuccess_rejectedApplication() throws Exception {
     createTld("tld", TldState.LANDRUSH);
-    persistResource(newDomainApplication("example2.tld").asBuilder()
-        .setPhase(LaunchPhase.LANDRUSH)
-        .setApplicationStatus(ApplicationStatus.REJECTED)
-        .build());
+    persistResource(
+        newDomainApplication("example2.tld")
+            .asBuilder()
+            .setPhase(LaunchPhase.LANDRUSH)
+            .setApplicationStatus(ApplicationStatus.REJECTED)
+            .build());
     doCheckTest(
         create(true, "example1.tld", null),
         create(true, "example2.tld", null),
@@ -274,20 +272,23 @@ public class DomainCheckFlowTest
   @Test
   public void testFailure_tooManyIds() throws Exception {
     setEppInput("domain_check_51.xml");
-    assertThrows(TooManyResourceChecksException.class, this::runFlow);
+    EppException thrown = expectThrows(TooManyResourceChecksException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_wrongTld() throws Exception {
     setEppInput("domain_check.xml");
-    assertThrows(TldDoesNotExistException.class, this::runFlow);
+    EppException thrown = expectThrows(TldDoesNotExistException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_notAuthorizedForTld() throws Exception {
     persistResource(
         loadRegistrar("TheRegistrar").asBuilder().setAllowedTlds(ImmutableSet.of()).build());
-    assertThrows(NotAuthorizedForTldException.class, this::runFlow);
+    EppException thrown = expectThrows(NotAuthorizedForTldException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -299,10 +300,11 @@ public class DomainCheckFlowTest
         CommitMode.LIVE, UserPrivileges.SUPERUSER, loadFile("domain_check_one_tld_response.xml"));
   }
 
-  private void doFailingBadLabelTest(String label, Class<? extends Exception> expectedException)
+  private void doFailingBadLabelTest(String label, Class<? extends EppException> expectedException)
       throws Exception {
     setEppInput("domain_check_template.xml", ImmutableMap.of("LABEL", label));
-    assertThrows(expectedException, this::runFlow);
+    EppException thrown = expectThrows(expectedException, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -386,7 +388,8 @@ public class DomainCheckFlowTest
   @Test
   public void testFailure_predelegation() throws Exception {
     createTld("tld", TldState.PREDELEGATION);
-    assertThrows(BadCommandForRegistryPhaseException.class, this::runFlow);
+    EppException thrown = expectThrows(BadCommandForRegistryPhaseException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -461,7 +464,8 @@ public class DomainCheckFlowTest
 
   /**
    * Test commands for create, renew, transfer, restore and update with implicit period and
-   * currency. */
+   * currency.
+   */
   @Test
   public void testFeeExtension_multipleCommands_v06() throws Exception {
     setEppInput("domain_check_fee_multiple_commands_v06.xml");
@@ -531,9 +535,11 @@ public class DomainCheckFlowTest
     // Note that the response xml expects to see "11.10" with two digits after the decimal point.
     // This works because Money.getAmount(), used in the flow, returns a BigDecimal that is set to
     // display the number of digits that is conventional for the given currency.
-    persistResource(Registry.get("tld").asBuilder()
-        .setCreateBillingCost(Money.of(CurrencyUnit.USD, 11.1))
-        .build());
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setCreateBillingCost(Money.of(CurrencyUnit.USD, 11.1))
+            .build());
     setEppInput("domain_check_fee_fractional.xml");
     runFlowAssertResponse(loadFile("domain_check_fee_fractional_response.xml"));
   }
@@ -541,10 +547,12 @@ public class DomainCheckFlowTest
   /** Test that create fees are properly omitted/classed on names on reserved lists. */
   @Test
   public void testFeeExtension_reservedName_v06() throws Exception {
-    persistResource(Registry.get("tld").asBuilder()
-        .setReservedLists(createReservedList())
-        .setPremiumList(persistPremiumList("tld", "premiumcollision,USD 70"))
-        .build());
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setReservedLists(createReservedList())
+            .setPremiumList(persistPremiumList("tld", "premiumcollision,USD 70"))
+            .build());
     setEppInput("domain_check_fee_reserved_v06.xml");
     runFlowAssertResponse(loadFile("domain_check_fee_reserved_response_v06.xml"));
   }
@@ -552,50 +560,60 @@ public class DomainCheckFlowTest
   /** The tests must be split up for version 11, which allows only one command at a time. */
   @Test
   public void testFeeExtension_reservedName_v11_create() throws Exception {
-    persistResource(Registry.get("tld").asBuilder()
-        .setReservedLists(createReservedList())
-        .setPremiumList(persistPremiumList("tld", "premiumcollision,USD 70"))
-        .build());
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setReservedLists(createReservedList())
+            .setPremiumList(persistPremiumList("tld", "premiumcollision,USD 70"))
+            .build());
     setEppInput("domain_check_fee_reserved_v11_create.xml");
     runFlowAssertResponse(loadFile("domain_check_fee_reserved_response_v11_create.xml"));
   }
 
   @Test
   public void testFeeExtension_reservedName_v11_renew() throws Exception {
-    persistResource(Registry.get("tld").asBuilder()
-        .setReservedLists(createReservedList())
-        .setPremiumList(persistPremiumList("tld", "premiumcollision,USD 70"))
-        .build());
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setReservedLists(createReservedList())
+            .setPremiumList(persistPremiumList("tld", "premiumcollision,USD 70"))
+            .build());
     setEppInput("domain_check_fee_reserved_v11_renew.xml");
     runFlowAssertResponse(loadFile("domain_check_fee_reserved_response_v11_renew.xml"));
   }
 
   @Test
   public void testFeeExtension_reservedName_v11_transfer() throws Exception {
-    persistResource(Registry.get("tld").asBuilder()
-        .setReservedLists(createReservedList())
-        .setPremiumList(persistPremiumList("tld", "premiumcollision,USD 70"))
-        .build());
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setReservedLists(createReservedList())
+            .setPremiumList(persistPremiumList("tld", "premiumcollision,USD 70"))
+            .build());
     setEppInput("domain_check_fee_reserved_v11_transfer.xml");
     runFlowAssertResponse(loadFile("domain_check_fee_reserved_response_v11_transfer.xml"));
   }
 
   @Test
   public void testFeeExtension_reservedName_v11_restore() throws Exception {
-    persistResource(Registry.get("tld").asBuilder()
-        .setReservedLists(createReservedList())
-        .setPremiumList(persistPremiumList("tld", "premiumcollision,USD 70"))
-        .build());
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setReservedLists(createReservedList())
+            .setPremiumList(persistPremiumList("tld", "premiumcollision,USD 70"))
+            .build());
     setEppInput("domain_check_fee_reserved_v11_restore.xml");
     runFlowAssertResponse(loadFile("domain_check_fee_reserved_response_v11_restore.xml"));
   }
 
   @Test
   public void testFeeExtension_reservedName_v12() throws Exception {
-    persistResource(Registry.get("tld").asBuilder()
-        .setReservedLists(createReservedList())
-        .setPremiumList(persistPremiumList("tld", "premiumcollision,USD 70"))
-        .build());
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setReservedLists(createReservedList())
+            .setPremiumList(persistPremiumList("tld", "premiumcollision,USD 70"))
+            .build());
     setEppInput("domain_check_fee_reserved_v12.xml");
     runFlowAssertResponse(loadFile("domain_check_fee_reserved_response_v12.xml"));
   }
@@ -603,58 +621,67 @@ public class DomainCheckFlowTest
   @Test
   public void testFeeExtension_feesNotOmittedOnReservedNamesInSunrise_v06() throws Exception {
     createTld("tld", TldState.SUNRISE);
-    persistResource(Registry.get("tld").asBuilder()
-        .setReservedLists(createReservedList())
-        .setPremiumList(persistPremiumList("tld", "premiumcollision,USD 70"))
-        .build());
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setReservedLists(createReservedList())
+            .setPremiumList(persistPremiumList("tld", "premiumcollision,USD 70"))
+            .build());
     setEppInput("domain_check_fee_reserved_v06.xml");
     runFlowAssertResponse(loadFile("domain_check_fee_reserved_sunrise_response_v06.xml"));
   }
 
   @Test
-  public void
-      testFeeExtension_feesNotOmittedOnReservedNamesInSunrise_v11_create() throws Exception {
+  public void testFeeExtension_feesNotOmittedOnReservedNamesInSunrise_v11_create()
+      throws Exception {
     createTld("tld", TldState.SUNRISE);
-    persistResource(Registry.get("tld").asBuilder()
-        .setReservedLists(createReservedList())
-        .setPremiumList(persistPremiumList("tld", "premiumcollision,USD 70"))
-        .build());
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setReservedLists(createReservedList())
+            .setPremiumList(persistPremiumList("tld", "premiumcollision,USD 70"))
+            .build());
     setEppInput("domain_check_fee_reserved_v11_create.xml");
     runFlowAssertResponse(loadFile("domain_check_fee_reserved_sunrise_response_v11_create.xml"));
   }
 
   @Test
-  public void
-      testFeeExtension_feesNotOmittedOnReservedNamesInSunrise_v11_renew() throws Exception {
+  public void testFeeExtension_feesNotOmittedOnReservedNamesInSunrise_v11_renew() throws Exception {
     createTld("tld", TldState.SUNRISE);
-    persistResource(Registry.get("tld").asBuilder()
-        .setReservedLists(createReservedList())
-        .setPremiumList(persistPremiumList("tld", "premiumcollision,USD 70"))
-        .build());
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setReservedLists(createReservedList())
+            .setPremiumList(persistPremiumList("tld", "premiumcollision,USD 70"))
+            .build());
     setEppInput("domain_check_fee_reserved_v11_renew.xml");
     runFlowAssertResponse(loadFile("domain_check_fee_reserved_sunrise_response_v11_renew.xml"));
   }
 
   @Test
-  public void
-      testFeeExtension_feesNotOmittedOnReservedNamesInSunrise_v11_transfer() throws Exception {
+  public void testFeeExtension_feesNotOmittedOnReservedNamesInSunrise_v11_transfer()
+      throws Exception {
     createTld("tld", TldState.SUNRISE);
-    persistResource(Registry.get("tld").asBuilder()
-        .setReservedLists(createReservedList())
-        .setPremiumList(persistPremiumList("tld", "premiumcollision,USD 70"))
-        .build());
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setReservedLists(createReservedList())
+            .setPremiumList(persistPremiumList("tld", "premiumcollision,USD 70"))
+            .build());
     setEppInput("domain_check_fee_reserved_v11_transfer.xml");
     runFlowAssertResponse(loadFile("domain_check_fee_reserved_sunrise_response_v11_transfer.xml"));
   }
 
   @Test
-  public void
-      testFeeExtension_feesNotOmittedOnReservedNamesInSunrise_v11_restore() throws Exception {
+  public void testFeeExtension_feesNotOmittedOnReservedNamesInSunrise_v11_restore()
+      throws Exception {
     createTld("tld", TldState.SUNRISE);
-    persistResource(Registry.get("tld").asBuilder()
-        .setReservedLists(createReservedList())
-        .setPremiumList(persistPremiumList("tld", "premiumcollision,USD 70"))
-        .build());
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setReservedLists(createReservedList())
+            .setPremiumList(persistPremiumList("tld", "premiumcollision,USD 70"))
+            .build());
     setEppInput("domain_check_fee_reserved_v11_restore.xml");
     runFlowAssertResponse(loadFile("domain_check_fee_reserved_sunrise_response_v11_restore.xml"));
   }
@@ -662,10 +689,12 @@ public class DomainCheckFlowTest
   @Test
   public void testFeeExtension_feesNotOmittedOnReservedNamesInSunrise_v12() throws Exception {
     createTld("tld", TldState.SUNRISE);
-    persistResource(Registry.get("tld").asBuilder()
-        .setReservedLists(createReservedList())
-        .setPremiumList(persistPremiumList("tld", "premiumcollision,USD 70"))
-        .build());
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setReservedLists(createReservedList())
+            .setPremiumList(persistPremiumList("tld", "premiumcollision,USD 70"))
+            .build());
     setEppInput("domain_check_fee_reserved_v12.xml");
     runFlowAssertResponse(loadFile("domain_check_fee_reserved_sunrise_response_v12.xml"));
   }
@@ -673,164 +702,194 @@ public class DomainCheckFlowTest
   @Test
   public void testFeeExtension_wrongCurrency_v06() throws Exception {
     setEppInput("domain_check_fee_euro_v06.xml");
-    assertThrows(CurrencyUnitMismatchException.class, this::runFlow);
+    EppException thrown = expectThrows(CurrencyUnitMismatchException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFeeExtension_wrongCurrency_v11() throws Exception {
     setEppInput("domain_check_fee_euro_v11.xml");
-    assertThrows(CurrencyUnitMismatchException.class, this::runFlow);
+    EppException thrown = expectThrows(CurrencyUnitMismatchException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFeeExtension_wrongCurrency_v12() throws Exception {
     setEppInput("domain_check_fee_euro_v12.xml");
-    assertThrows(CurrencyUnitMismatchException.class, this::runFlow);
+    EppException thrown = expectThrows(CurrencyUnitMismatchException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFeeExtension_periodNotInYears_v06() throws Exception {
     setEppInput("domain_check_fee_bad_period_v06.xml");
-    assertThrows(BadPeriodUnitException.class, this::runFlow);
+    EppException thrown = expectThrows(BadPeriodUnitException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFeeExtension_periodNotInYears_v11() throws Exception {
     setEppInput("domain_check_fee_bad_period_v11.xml");
-    assertThrows(BadPeriodUnitException.class, this::runFlow);
+    EppException thrown = expectThrows(BadPeriodUnitException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFeeExtension_periodNotInYears_v12() throws Exception {
     setEppInput("domain_check_fee_bad_period_v12.xml");
-    assertThrows(BadPeriodUnitException.class, this::runFlow);
+    EppException thrown = expectThrows(BadPeriodUnitException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFeeExtension_commandWithPhase_v06() throws Exception {
     setEppInput("domain_check_fee_command_phase_v06.xml");
-    assertThrows(FeeChecksDontSupportPhasesException.class, this::runFlow);
+    EppException thrown = expectThrows(FeeChecksDontSupportPhasesException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFeeExtension_commandWithPhase_v11() throws Exception {
     setEppInput("domain_check_fee_command_phase_v11.xml");
-    assertThrows(FeeChecksDontSupportPhasesException.class, this::runFlow);
+    EppException thrown = expectThrows(FeeChecksDontSupportPhasesException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFeeExtension_commandWithPhase_v12() throws Exception {
     setEppInput("domain_check_fee_command_phase_v12.xml");
-    assertThrows(FeeChecksDontSupportPhasesException.class, this::runFlow);
+    EppException thrown = expectThrows(FeeChecksDontSupportPhasesException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFeeExtension_commandSubphase_v06() throws Exception {
     setEppInput("domain_check_fee_command_subphase_v06.xml");
-    assertThrows(FeeChecksDontSupportPhasesException.class, this::runFlow);
+    EppException thrown = expectThrows(FeeChecksDontSupportPhasesException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFeeExtension_commandSubphase_v11() throws Exception {
     setEppInput("domain_check_fee_command_subphase_v11.xml");
-    assertThrows(FeeChecksDontSupportPhasesException.class, this::runFlow);
+    EppException thrown = expectThrows(FeeChecksDontSupportPhasesException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFeeExtension_commandSubphase_v12() throws Exception {
     setEppInput("domain_check_fee_command_subphase_v12.xml");
-    assertThrows(FeeChecksDontSupportPhasesException.class, this::runFlow);
+    EppException thrown = expectThrows(FeeChecksDontSupportPhasesException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   // This test is only relevant for v06, since domain names are not specified in v11 or v12.
   @Test
   public void testFeeExtension_feeCheckNotInAvailabilityCheck() throws Exception {
     setEppInput("domain_check_fee_not_in_avail.xml");
-    assertThrows(OnlyCheckedNamesCanBeFeeCheckedException.class, this::runFlow);
+    EppException thrown =
+        expectThrows(OnlyCheckedNamesCanBeFeeCheckedException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFeeExtension_multiyearRestore_v06() throws Exception {
     setEppInput("domain_check_fee_multiyear_restore_v06.xml");
-    assertThrows(RestoresAreAlwaysForOneYearException.class, this::runFlow);
+    EppException thrown = expectThrows(RestoresAreAlwaysForOneYearException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFeeExtension_multiyearRestore_v11() throws Exception {
     setEppInput("domain_check_fee_multiyear_restore_v11.xml");
-    assertThrows(RestoresAreAlwaysForOneYearException.class, this::runFlow);
+    EppException thrown = expectThrows(RestoresAreAlwaysForOneYearException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFeeExtension_multiyearRestore_v12() throws Exception {
     setEppInput("domain_check_fee_multiyear_restore_v12.xml");
-    assertThrows(RestoresAreAlwaysForOneYearException.class, this::runFlow);
+    EppException thrown = expectThrows(RestoresAreAlwaysForOneYearException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFeeExtension_multiyearTransfer_v06() throws Exception {
     setEppInput("domain_check_fee_multiyear_transfer_v06.xml");
-    assertThrows(TransfersAreAlwaysForOneYearException.class, this::runFlow);
+    EppException thrown = expectThrows(TransfersAreAlwaysForOneYearException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFeeExtension_multiyearTransfer_v11() throws Exception {
     setEppInput("domain_check_fee_multiyear_transfer_v11.xml");
-    assertThrows(TransfersAreAlwaysForOneYearException.class, this::runFlow);
+    EppException thrown = expectThrows(TransfersAreAlwaysForOneYearException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFeeExtension_multiyearTransfer_v12() throws Exception {
     setEppInput("domain_check_fee_multiyear_transfer_v12.xml");
-    assertThrows(TransfersAreAlwaysForOneYearException.class, this::runFlow);
+    EppException thrown = expectThrows(TransfersAreAlwaysForOneYearException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFeeExtension_unknownCommand_v06() throws Exception {
     setEppInput("domain_check_fee_unknown_command_v06.xml");
-    assertThrows(UnknownFeeCommandException.class, this::runFlow);
+    EppException thrown = expectThrows(UnknownFeeCommandException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFeeExtension_unknownCommand_v11() throws Exception {
     setEppInput("domain_check_fee_unknown_command_v11.xml");
-    assertThrows(UnknownFeeCommandException.class, this::runFlow);
+    EppException thrown = expectThrows(UnknownFeeCommandException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFeeExtension_unknownCommand_v12() throws Exception {
     setEppInput("domain_check_fee_unknown_command_v12.xml");
-    assertThrows(UnknownFeeCommandException.class, this::runFlow);
+    EppException thrown = expectThrows(UnknownFeeCommandException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFeeExtension_invalidCommand_v06() throws Exception {
     setEppInput("domain_check_fee_invalid_command_v06.xml");
-    assertThrows(UnknownFeeCommandException.class, this::runFlow);
+    EppException thrown = expectThrows(UnknownFeeCommandException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFeeExtension_invalidCommand_v11() throws Exception {
     setEppInput("domain_check_fee_invalid_command_v11.xml");
-    assertThrows(UnknownFeeCommandException.class, this::runFlow);
+    EppException thrown = expectThrows(UnknownFeeCommandException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFeeExtension_invalidCommand_v12() throws Exception {
     setEppInput("domain_check_fee_invalid_command_v12.xml");
-    assertThrows(UnknownFeeCommandException.class, this::runFlow);
+    EppException thrown = expectThrows(UnknownFeeCommandException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   private void runEapFeeCheckTest(String inputFile, String outputFile) throws Exception {
     clock.setTo(DateTime.parse("2010-01-01T10:00:00Z"));
     persistActiveDomain("example1.tld");
-    persistResource(Registry.get("tld").asBuilder()
-        .setEapFeeSchedule(ImmutableSortedMap.of(
-            START_OF_TIME, Money.of(USD, 0),
-            clock.nowUtc().minusDays(1), Money.of(USD, 100),
-            clock.nowUtc().plusDays(1), Money.of(USD, 50),
-            clock.nowUtc().plusDays(2), Money.of(USD, 0)))
-        .build());
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setEapFeeSchedule(
+                new ImmutableSortedMap.Builder<DateTime, Money>(Ordering.natural())
+                    .put(START_OF_TIME, Money.of(USD, 0))
+                    .put(clock.nowUtc().minusDays(1), Money.of(USD, 100))
+                    .put(clock.nowUtc().plusDays(1), Money.of(USD, 50))
+                    .put(clock.nowUtc().plusDays(2), Money.of(USD, 0))
+                    .build())
+            .build());
     setEppInput(inputFile);
     runFlowAssertResponse(loadFile(outputFile));
   }
@@ -852,8 +911,8 @@ public class DomainCheckFlowTest
 
   @Test
   public void testSuccess_eapFeeCheck_date_v12() throws Exception {
-    runEapFeeCheckTest("domain_check_fee_date_v12.xml",
-        "domain_check_eap_fee_response_date_v12.xml");
+    runEapFeeCheckTest(
+        "domain_check_fee_date_v12.xml", "domain_check_eap_fee_response_date_v12.xml");
   }
 
   @Ignore
diff --git a/javatests/google/registry/flows/domain/DomainClaimsCheckFlowTest.java b/javatests/google/registry/flows/domain/DomainClaimsCheckFlowTest.java
index b0bf55a4f..577c0ba12 100644
--- a/javatests/google/registry/flows/domain/DomainClaimsCheckFlowTest.java
+++ b/javatests/google/registry/flows/domain/DomainClaimsCheckFlowTest.java
@@ -18,10 +18,12 @@ import static google.registry.testing.DatastoreHelper.assertNoBillingEvents;
 import static google.registry.testing.DatastoreHelper.createTld;
 import static google.registry.testing.DatastoreHelper.loadRegistrar;
 import static google.registry.testing.DatastoreHelper.persistResource;
-import static google.registry.testing.JUnitBackports.assertThrows;
+import static google.registry.testing.EppExceptionSubject.assertAboutEppExceptions;
+import static google.registry.testing.JUnitBackports.expectThrows;
 
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
+import google.registry.flows.EppException;
 import google.registry.flows.ResourceFlowTestCase;
 import google.registry.flows.domain.DomainClaimsCheckFlow.DomainClaimsCheckNotAllowedInSunrise;
 import google.registry.flows.domain.DomainFlowUtils.BadCommandForRegistryPhaseException;
@@ -51,8 +53,8 @@ public class DomainClaimsCheckFlowTest
 
   protected void doSuccessfulTest(String expectedXmlFilename) throws Exception {
     assertTransactionalFlow(false);
-    assertNoHistory();  // Checks don't create a history event.
-    assertNoBillingEvents();  // Checks are always free.
+    assertNoHistory(); // Checks don't create a history event.
+    assertNoBillingEvents(); // Checks are always free.
     runFlowAssertResponse(loadFile(expectedXmlFilename));
   }
 
@@ -102,20 +104,23 @@ public class DomainClaimsCheckFlowTest
   @Test
   public void testFailure_TooManyIds() throws Exception {
     setEppInput("domain_check_claims_51.xml");
-    assertThrows(TooManyResourceChecksException.class, this::runFlow);
+    EppException thrown = expectThrows(TooManyResourceChecksException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_tldDoesntExist() throws Exception {
     setEppInput("domain_check_claims_bad_tld.xml");
-    assertThrows(TldDoesNotExistException.class, this::runFlow);
+    EppException thrown = expectThrows(TldDoesNotExistException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_notAuthorizedForTld() throws Exception {
     persistResource(
         loadRegistrar("TheRegistrar").asBuilder().setAllowedTlds(ImmutableSet.of()).build());
-    assertThrows(NotAuthorizedForTldException.class, this::runFlow);
+    EppException thrown = expectThrows(NotAuthorizedForTldException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -136,7 +141,8 @@ public class DomainClaimsCheckFlowTest
     createTld("tld", TldState.PREDELEGATION);
     persistResource(Registry.get("tld").asBuilder().build());
     setEppInput("domain_check_claims.xml");
-    assertThrows(BadCommandForRegistryPhaseException.class, this::runFlow);
+    EppException thrown = expectThrows(BadCommandForRegistryPhaseException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -144,7 +150,8 @@ public class DomainClaimsCheckFlowTest
     createTld("tld", TldState.SUNRISE);
     persistResource(Registry.get("tld").asBuilder().build());
     setEppInput("domain_check_claims.xml");
-    assertThrows(DomainClaimsCheckNotAllowedInSunrise.class, this::runFlow);
+    EppException thrown = expectThrows(DomainClaimsCheckNotAllowedInSunrise.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -154,7 +161,8 @@ public class DomainClaimsCheckFlowTest
     persistResource(
         Registry.get("tld2").asBuilder().setClaimsPeriodEnd(clock.nowUtc().minusMillis(1)).build());
     setEppInput("domain_check_claims_multiple_tlds.xml");
-    assertThrows(ClaimsPeriodEndedException.class, this::runFlow);
+    EppException thrown = expectThrows(ClaimsPeriodEndedException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
diff --git a/javatests/google/registry/flows/domain/DomainCreateFlowTest.java b/javatests/google/registry/flows/domain/DomainCreateFlowTest.java
index 22a6d92f7..c37722528 100644
--- a/javatests/google/registry/flows/domain/DomainCreateFlowTest.java
+++ b/javatests/google/registry/flows/domain/DomainCreateFlowTest.java
@@ -43,7 +43,6 @@ import static google.registry.testing.DatastoreHelper.persistReservedList;
 import static google.registry.testing.DatastoreHelper.persistResource;
 import static google.registry.testing.DomainResourceSubject.assertAboutDomains;
 import static google.registry.testing.EppExceptionSubject.assertAboutEppExceptions;
-import static google.registry.testing.JUnitBackports.assertThrows;
 import static google.registry.testing.JUnitBackports.expectThrows;
 import static google.registry.testing.TaskQueueHelper.assertDnsTasksEnqueued;
 import static google.registry.testing.TaskQueueHelper.assertNoDnsTasksEnqueued;
@@ -60,6 +59,7 @@ import com.google.common.base.Strings;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.ImmutableSortedMap;
+import google.registry.flows.EppException;
 import google.registry.flows.EppException.UnimplementedExtensionException;
 import google.registry.flows.EppRequestSource;
 import google.registry.flows.ExtensionManager.UndeclaredServiceExtensionException;
@@ -162,17 +162,21 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
   @Before
   public void initCreateTest() throws Exception {
     createTld("tld");
-    persistResource(Registry.get("tld").asBuilder()
-        .setReservedLists(persistReservedList(
-            "tld-reserved",
-            "reserved,FULLY_BLOCKED",
-            "anchor,RESERVED_FOR_ANCHOR_TENANT,2fooBAR"))
-        .build());
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setReservedLists(
+                persistReservedList(
+                    "tld-reserved",
+                    "reserved,FULLY_BLOCKED",
+                    "anchor,RESERVED_FOR_ANCHOR_TENANT,2fooBAR"))
+            .build());
     persistClaimsList(ImmutableMap.of("example-one", CLAIMS_KEY));
   }
 
   /**
    * Create host and contact entries for testing.
+   *
    * @param hostTld the TLD of the host (which might be an external TLD)
    */
   private void persistContactsAndHosts(String hostTld) {
@@ -185,31 +189,37 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
   }
 
   private void persistContactsAndHosts() {
-    persistContactsAndHosts("net");  // domain_create.xml uses hosts on "net".
+    persistContactsAndHosts("net"); // domain_create.xml uses hosts on "net".
   }
 
   private void assertSuccessfulCreate(String domainTld, boolean isAnchorTenant) throws Exception {
     DomainResource domain = reloadResourceByForeignKey();
 
     // Calculate the total cost.
-    Money cost = isDomainPremium(getUniqueIdFromCommand(), clock.nowUtc())
-        ? Money.of(USD, 200)
-        : Money.of(USD, 26);
-    Money eapFee = Money.of(Registry.get(domainTld).getCurrency(),
-        Registry.get(domainTld).getEapFeeFor(clock.nowUtc()).getCost());
+    Money cost =
+        isDomainPremium(getUniqueIdFromCommand(), clock.nowUtc())
+            ? Money.of(USD, 200)
+            : Money.of(USD, 26);
+    Money eapFee =
+        Money.of(
+            Registry.get(domainTld).getCurrency(),
+            Registry.get(domainTld).getEapFeeFor(clock.nowUtc()).getCost());
 
-    DateTime billingTime = isAnchorTenant
-        ? clock.nowUtc().plus(Registry.get(domainTld).getAnchorTenantAddGracePeriodLength())
-        : clock.nowUtc().plus(Registry.get(domainTld).getAddGracePeriodLength());
-    ImmutableSet<BillingEvent.Flag> billingFlags = isAnchorTenant
-        ? ImmutableSet.of(BillingEvent.Flag.ANCHOR_TENANT)
-        : ImmutableSet.of();
+    DateTime billingTime =
+        isAnchorTenant
+            ? clock.nowUtc().plus(Registry.get(domainTld).getAnchorTenantAddGracePeriodLength())
+            : clock.nowUtc().plus(Registry.get(domainTld).getAddGracePeriodLength());
+    ImmutableSet<BillingEvent.Flag> billingFlags =
+        isAnchorTenant ? ImmutableSet.of(BillingEvent.Flag.ANCHOR_TENANT) : ImmutableSet.of();
     HistoryEntry historyEntry = getHistoryEntries(domain).get(0);
-    assertAboutDomains().that(domain)
+    assertAboutDomains()
+        .that(domain)
         .hasRegistrationExpirationTime(
-            ofy().load().key(domain.getAutorenewBillingEvent()).now().getEventTime()).and()
+            ofy().load().key(domain.getAutorenewBillingEvent()).now().getEventTime())
+        .and()
         .hasOnlyOneHistoryEntryWhich()
-        .hasType(HistoryEntry.Type.DOMAIN_CREATE).and()
+        .hasType(HistoryEntry.Type.DOMAIN_CREATE)
+        .and()
         .hasPeriodYears(2);
     // There should be one bill for the create and one for the recurring autorenew event.
     BillingEvent.OneTime createBillingEvent =
@@ -268,11 +278,7 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     assertGracePeriods(
         domain.getGracePeriods(),
         ImmutableMap.of(
-            GracePeriod.create(
-                GracePeriodStatus.ADD,
-                billingTime,
-                "TheRegistrar",
-                null),
+            GracePeriod.create(GracePeriodStatus.ADD, billingTime, "TheRegistrar", null),
             createBillingEvent));
     assertDnsTasksEnqueued(getUniqueIdFromCommand());
     assertEppResourceIndexEntityFor(domain);
@@ -282,32 +288,41 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     assertNoLordn(null, null);
   }
 
-  private void assertNoLordn(
-      @Nullable String smdId, @Nullable LaunchNotice launchNotice) throws Exception {
-    assertAboutDomains().that(reloadResourceByForeignKey())
-        .hasSmdId(smdId).and()
+  private void assertNoLordn(@Nullable String smdId, @Nullable LaunchNotice launchNotice)
+      throws Exception {
+    assertAboutDomains()
+        .that(reloadResourceByForeignKey())
+        .hasSmdId(smdId)
+        .and()
         .hasLaunchNotice(launchNotice);
     assertNoTasksEnqueued(QUEUE_CLAIMS, QUEUE_SUNRISE);
   }
 
   private void assertSunriseLordn() throws Exception {
-    assertAboutDomains().that(reloadResourceByForeignKey())
-        .hasSmdId("0000001761376042759136-65535").and()
+    assertAboutDomains()
+        .that(reloadResourceByForeignKey())
+        .hasSmdId("0000001761376042759136-65535")
+        .and()
         .hasLaunchNotice(null);
-    TaskMatcher task = new TaskMatcher().payload(
-        reloadResourceByForeignKey().getRepoId()
-            + ",test-validate.tld,0000001761376042759136-65535,1,2014-09-09T09:09:09.001Z");
+    TaskMatcher task =
+        new TaskMatcher()
+            .payload(
+                reloadResourceByForeignKey().getRepoId()
+                    + ",test-validate.tld,0000001761376042759136-65535,1,2014-09-09T09:09:09.001Z");
     assertTasksEnqueued(QUEUE_SUNRISE, task);
   }
 
   private void assertClaimsLordn() throws Exception {
-    assertAboutDomains().that(reloadResourceByForeignKey())
-        .hasSmdId(null).and()
-        .hasLaunchNotice(LaunchNotice.create(
-            "370d0b7c9223372036854775807",
-            "tmch",
-            DateTime.parse("2010-08-16T09:00:00.0Z"),
-            DateTime.parse("2009-08-16T09:00:00.0Z")));
+    assertAboutDomains()
+        .that(reloadResourceByForeignKey())
+        .hasSmdId(null)
+        .and()
+        .hasLaunchNotice(
+            LaunchNotice.create(
+                "370d0b7c9223372036854775807",
+                "tmch",
+                DateTime.parse("2010-08-16T09:00:00.0Z"),
+                DateTime.parse("2009-08-16T09:00:00.0Z")));
     TaskMatcher task =
         new TaskMatcher()
             .payload(
@@ -318,9 +333,7 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
   }
 
   private void doSuccessfulTest(
-      String domainTld,
-      String responseXmlFile,
-      UserPrivileges userPrivileges) throws Exception {
+      String domainTld, String responseXmlFile, UserPrivileges userPrivileges) throws Exception {
     doSuccessfulTest(domainTld, responseXmlFile, userPrivileges, ImmutableMap.of());
   }
 
@@ -328,7 +341,8 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
       String domainTld,
       String responseXmlFile,
       UserPrivileges userPrivileges,
-      Map<String, String> substitutions) throws Exception {
+      Map<String, String> substitutions)
+      throws Exception {
     assertTransactionalFlow(true);
     runFlowAssertResponse(
         CommitMode.LIVE, userPrivileges, loadFile(responseXmlFile, substitutions));
@@ -337,9 +351,8 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
   }
 
   private void doSuccessfulTest(
-      String domainTld,
-      String responseXmlFile,
-      Map<String, String> substitutions) throws Exception {
+      String domainTld, String responseXmlFile, Map<String, String> substitutions)
+      throws Exception {
     doSuccessfulTest(domainTld, responseXmlFile, UserPrivileges.NORMAL, substitutions);
   }
 
@@ -373,9 +386,9 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     setEppInput("domain_create_with_tld.xml", ImmutableMap.of("TLD", "foo.tld"));
     persistContactsAndHosts("foo.tld");
     assertTransactionalFlow(true);
-    String expectedResponseXml = loadFile(
-        "domain_create_response_wildcard.xml",
-        ImmutableMap.of("DOMAIN", "example.foo.tld"));
+    String expectedResponseXml =
+        loadFile(
+            "domain_create_response_wildcard.xml", ImmutableMap.of("DOMAIN", "example.foo.tld"));
     runFlowAssertResponse(CommitMode.LIVE, UserPrivileges.NORMAL, expectedResponseXml);
     assertSuccessfulCreate("foo.tld", false);
     assertNoLordn();
@@ -386,7 +399,8 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     createTlds("foo.tld", "tld");
     setEppInput("domain_create_wildcard.xml", ImmutableMap.of("DOMAIN", "foo.tld"));
     persistContactsAndHosts();
-    assertThrows(DomainNameExistsAsTldException.class, this::runFlow);
+    EppException thrown = expectThrows(DomainNameExistsAsTldException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -394,7 +408,8 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     createTlds("foo.tld", "tld");
     setEppInput("domain_create_wildcard.xml", ImmutableMap.of("DOMAIN", "FOO.TLD"));
     persistContactsAndHosts();
-    assertThrows(BadDomainNameCharacterException.class, this::runFlow);
+    EppException thrown = expectThrows(BadDomainNameCharacterException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -407,18 +422,20 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     assertNoLordn();
   }
 
-
   @Test
   public void testSuccess_lrp() throws Exception {
-    persistResource(Registry.get("tld").asBuilder()
-        .setLrpPeriod(new Interval(clock.nowUtc().minusDays(1), clock.nowUtc().plusDays(1)))
-        .build());
-    LrpTokenEntity token = persistResource(
-        new LrpTokenEntity.Builder()
-            .setToken("lrptokentest")
-            .setAssignee("example.tld")
-            .setValidTlds(ImmutableSet.of("tld"))
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setLrpPeriod(new Interval(clock.nowUtc().minusDays(1), clock.nowUtc().plusDays(1)))
             .build());
+    LrpTokenEntity token =
+        persistResource(
+            new LrpTokenEntity.Builder()
+                .setToken("lrptokentest")
+                .setAssignee("example.tld")
+                .setValidTlds(ImmutableSet.of("tld"))
+                .build());
     setEppInput("domain_create_lrp.xml");
     persistContactsAndHosts();
     runFlowAssertResponse(loadFile("domain_create_response.xml"));
@@ -432,15 +449,18 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     // If a valid LRP token is passed in even though the TLD is not currently in an LRP phase,
     // just ignore the token and proceed with normal GA registration (i.e. LRP token should
     // remain unredeemed).
-    persistResource(Registry.get("tld").asBuilder()
-        .setLrpPeriod(new Interval(clock.nowUtc().minusDays(2), clock.nowUtc().minusDays(1)))
-        .build());
-    LrpTokenEntity token = persistResource(
-        new LrpTokenEntity.Builder()
-            .setToken("lrptokentest")
-            .setAssignee("example.tld")
-            .setValidTlds(ImmutableSet.of("tld"))
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setLrpPeriod(new Interval(clock.nowUtc().minusDays(2), clock.nowUtc().minusDays(1)))
             .build());
+    LrpTokenEntity token =
+        persistResource(
+            new LrpTokenEntity.Builder()
+                .setToken("lrptokentest")
+                .setAssignee("example.tld")
+                .setValidTlds(ImmutableSet.of("tld"))
+                .build());
     setEppInput("domain_create_lrp.xml");
     persistContactsAndHosts();
     runFlowAssertResponse(loadFile("domain_create_response.xml"));
@@ -451,9 +471,11 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
 
   @Test
   public void testSuccess_outsideOfLrp() throws Exception {
-    persistResource(Registry.get("tld").asBuilder()
-        .setLrpPeriod(new Interval(clock.nowUtc().minusDays(2), clock.nowUtc().minusDays(1)))
-        .build());
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setLrpPeriod(new Interval(clock.nowUtc().minusDays(2), clock.nowUtc().minusDays(1)))
+            .build());
     persistContactsAndHosts();
     doSuccessfulTest();
   }
@@ -463,7 +485,7 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     createTld("tld", TldState.GENERAL_AVAILABILITY);
     clock.setTo(DateTime.parse("2014-09-09T09:09:09Z"));
     setEppInput("domain_create_registration_encoded_signed_mark.xml");
-    eppRequestSource = EppRequestSource.TOOL;  // Only tools can pass in metadata.
+    eppRequestSource = EppRequestSource.TOOL; // Only tools can pass in metadata.
     persistContactsAndHosts();
     runFlow();
     assertSuccessfulCreate("tld", true);
@@ -475,7 +497,7 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     createTld("tld", TldState.GENERAL_AVAILABILITY);
     clock.setTo(DateTime.parse("2014-09-09T09:09:09Z"));
     setEppInput("domain_create_registration_encoded_signed_mark_mismatched_label.xml");
-    eppRequestSource = EppRequestSource.TOOL;  // Only tools can pass in metadata.
+    eppRequestSource = EppRequestSource.TOOL; // Only tools can pass in metadata.
     persistContactsAndHosts();
     runFlowAsSuperuser();
     assertSuccessfulCreate("tld", true);
@@ -534,63 +556,72 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
   public void testFailure_refundableFee_v06() throws Exception {
     setEppInput("domain_create_fee_refundable.xml", ImmutableMap.of("FEE_VERSION", "0.6"));
     persistContactsAndHosts();
-    assertThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    EppException thrown = expectThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_refundableFee_v11() throws Exception {
     setEppInput("domain_create_fee_refundable.xml", ImmutableMap.of("FEE_VERSION", "0.11"));
     persistContactsAndHosts();
-    assertThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    EppException thrown = expectThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_refundableFee_v12() throws Exception {
     setEppInput("domain_create_fee_refundable.xml", ImmutableMap.of("FEE_VERSION", "0.12"));
     persistContactsAndHosts();
-    assertThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    EppException thrown = expectThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_gracePeriodFee_v06() throws Exception {
     setEppInput("domain_create_fee_grace_period.xml", ImmutableMap.of("FEE_VERSION", "0.6"));
     persistContactsAndHosts();
-    assertThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    EppException thrown = expectThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_gracePeriodFee_v11() throws Exception {
     setEppInput("domain_create_fee_grace_period.xml", ImmutableMap.of("FEE_VERSION", "0.11"));
     persistContactsAndHosts();
-    assertThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    EppException thrown = expectThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_gracePeriodFee_v12() throws Exception {
     setEppInput("domain_create_fee_grace_period.xml", ImmutableMap.of("FEE_VERSION", "0.12"));
     persistContactsAndHosts();
-    assertThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    EppException thrown = expectThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_appliedFee_v06() throws Exception {
     setEppInput("domain_create_fee_applied.xml", ImmutableMap.of("FEE_VERSION", "0.6"));
     persistContactsAndHosts();
-    assertThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    EppException thrown = expectThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_appliedFee_v11() throws Exception {
     setEppInput("domain_create_fee_applied.xml", ImmutableMap.of("FEE_VERSION", "0.11"));
     persistContactsAndHosts();
-    assertThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    EppException thrown = expectThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_appliedFee_v12() throws Exception {
     setEppInput("domain_create_fee_applied.xml", ImmutableMap.of("FEE_VERSION", "0.12"));
     persistContactsAndHosts();
-    assertThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    EppException thrown = expectThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -599,10 +630,13 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     setEppInput("domain_create_metadata.xml");
     persistContactsAndHosts();
     doSuccessfulTest();
-    assertAboutDomains().that(reloadResourceByForeignKey())
+    assertAboutDomains()
+        .that(reloadResourceByForeignKey())
         .hasOnlyOneHistoryEntryWhich()
-        .hasType(HistoryEntry.Type.DOMAIN_CREATE).and()
-        .hasMetadataReason("domain-create-test").and()
+        .hasType(HistoryEntry.Type.DOMAIN_CREATE)
+        .and()
+        .hasMetadataReason("domain-create-test")
+        .and()
         .hasMetadataRequestedByRegistrar(false);
   }
 
@@ -610,20 +644,24 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
   public void testFailure_metadataNotFromTool() throws Exception {
     setEppInput("domain_create_metadata.xml");
     persistContactsAndHosts();
-    assertThrows(OnlyToolCanPassMetadataException.class, this::runFlow);
+    EppException thrown = expectThrows(OnlyToolCanPassMetadataException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_lrp_badToken() throws Exception {
-    persistResource(Registry.get("tld").asBuilder()
-        .setLrpPeriod(new Interval(clock.nowUtc().minusDays(1), clock.nowUtc().plusDays(1)))
-        .build());
-    LrpTokenEntity token = persistResource(
-        new LrpTokenEntity.Builder()
-            .setToken("otherlrptoken")
-            .setAssignee("example.tld")
-            .setValidTlds(ImmutableSet.of("tld"))
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setLrpPeriod(new Interval(clock.nowUtc().minusDays(1), clock.nowUtc().plusDays(1)))
             .build());
+    LrpTokenEntity token =
+        persistResource(
+            new LrpTokenEntity.Builder()
+                .setToken("otherlrptoken")
+                .setAssignee("example.tld")
+                .setValidTlds(ImmutableSet.of("tld"))
+                .build());
     setEppInput("domain_create_lrp.xml");
     persistContactsAndHosts();
     Exception e = expectThrows(InvalidLrpTokenException.class, this::runFlow);
@@ -633,9 +671,11 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
 
   @Test
   public void testFailure_lrp_noToken() throws Exception {
-    persistResource(Registry.get("tld").asBuilder()
-        .setLrpPeriod(new Interval(clock.nowUtc().minusDays(1), clock.nowUtc().plusDays(1)))
-        .build());
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setLrpPeriod(new Interval(clock.nowUtc().minusDays(1), clock.nowUtc().plusDays(1)))
+            .build());
     persistContactsAndHosts();
     InvalidLrpTokenException thrown = expectThrows(InvalidLrpTokenException.class, this::runFlow);
     assertThat(thrown).hasMessageThat().contains("Invalid limited registration period token");
@@ -651,9 +691,9 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
   }
 
   /**
-   * Test fix for a bug where we were looking at the length of the unicode string but indexing
-   * into the punycode string. In rare cases (3 and 4 letter labels) this would cause us to think
-   * there was a trailing dash in the domain name and fail to create it.
+   * Test fix for a bug where we were looking at the length of the unicode string but indexing into
+   * the punycode string. In rare cases (3 and 4 letter labels) this would cause us to think there
+   * was a trailing dash in the domain name and fail to create it.
    */
   @Test
   public void testSuccess_unicodeLengthBug() throws Exception {
@@ -665,9 +705,11 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
 
   @Test
   public void testSuccess_nonDefaultAddGracePeriod() throws Exception {
-    persistResource(Registry.get("tld").asBuilder()
-        .setAddGracePeriodLength(Duration.standardMinutes(6))
-        .build());
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setAddGracePeriodLength(Duration.standardMinutes(6))
+            .build());
     persistContactsAndHosts();
     doSuccessfulTest();
   }
@@ -690,16 +732,18 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
   @Test
   public void testSuccess_secDns() throws Exception {
     setEppInput("domain_create_dsdata_no_maxsiglife.xml");
-    persistContactsAndHosts("tld");  // For some reason this sample uses "tld".
+    persistContactsAndHosts("tld"); // For some reason this sample uses "tld".
     doSuccessfulTest("tld");
-    assertAboutDomains().that(reloadResourceByForeignKey()).hasExactlyDsData(
-        DelegationSignerData.create(12345, 3, 1, base16().decode("49FD46E6C4B45C55D4AC")));
+    assertAboutDomains()
+        .that(reloadResourceByForeignKey())
+        .hasExactlyDsData(
+            DelegationSignerData.create(12345, 3, 1, base16().decode("49FD46E6C4B45C55D4AC")));
   }
 
   @Test
   public void testSuccess_secDnsMaxRecords() throws Exception {
     setEppInput("domain_create_dsdata_8_records.xml");
-    persistContactsAndHosts("tld");  // For some reason this sample uses "tld".
+    persistContactsAndHosts("tld"); // For some reason this sample uses "tld".
     doSuccessfulTest("tld");
     assertAboutDomains().that(reloadResourceByForeignKey()).hasNumDsData(8);
   }
@@ -726,9 +770,11 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
   public void testSuccess_periodNotSpecified() throws Exception {
     setEppInput("domain_create_missing_period.xml");
     persistContactsAndHosts();
-    runFlowAssertResponse(loadFile("domain_create_response.xml"),
-        "epp.response.resData.creData.exDate");  // Ignore expiration date; we verify it below
-    assertAboutDomains().that(reloadResourceByForeignKey())
+    runFlowAssertResponse(
+        loadFile("domain_create_response.xml"),
+        "epp.response.resData.creData.exDate"); // Ignore expiration date; we verify it below
+    assertAboutDomains()
+        .that(reloadResourceByForeignKey())
         .hasRegistrationExpirationTime(clock.nowUtc().plusYears(1));
     assertDnsTasksEnqueued("example.tld");
   }
@@ -737,7 +783,8 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
   public void testFailure_periodInMonths() throws Exception {
     setEppInput("domain_create_months.xml");
     persistContactsAndHosts();
-    assertThrows(BadPeriodUnitException.class, this::runFlow);
+    EppException thrown = expectThrows(BadPeriodUnitException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -756,9 +803,7 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     persistClaimsList(ImmutableMap.of("example", CLAIMS_KEY));
     setEppInput("domain_create.xml");
     persistContactsAndHosts();
-    persistResource(Registry.get("tld").asBuilder()
-        .setClaimsPeriodEnd(clock.nowUtc())
-        .build());
+    persistResource(Registry.get("tld").asBuilder().setClaimsPeriodEnd(clock.nowUtc()).build());
     runFlowAssertResponse(loadFile("domain_create_response.xml"));
     assertSuccessfulCreate("tld", false);
     assertDnsTasksEnqueued("example.tld");
@@ -769,7 +814,8 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     persistClaimsList(ImmutableMap.of("example", CLAIMS_KEY));
     setEppInput("domain_create.xml");
     persistContactsAndHosts();
-    assertThrows(MissingClaimsNoticeException.class, this::runFlow);
+    EppException thrown = expectThrows(MissingClaimsNoticeException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -777,7 +823,8 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     setEppInput("domain_create_claim_notice.xml");
     persistClaimsList(ImmutableMap.of());
     persistContactsAndHosts();
-    assertThrows(UnexpectedClaimsNoticeException.class, this::runFlow);
+    EppException thrown = expectThrows(UnexpectedClaimsNoticeException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -785,38 +832,41 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     setEppInput("domain_create_claim_notice.xml");
     persistClaimsList(ImmutableMap.of("example-one", CLAIMS_KEY));
     persistContactsAndHosts();
-    persistResource(Registry.get("tld").asBuilder()
-        .setClaimsPeriodEnd(clock.nowUtc())
-        .build());
-    assertThrows(ClaimsPeriodEndedException.class, this::runFlow);
+    persistResource(Registry.get("tld").asBuilder().setClaimsPeriodEnd(clock.nowUtc()).build());
+    EppException thrown = expectThrows(ClaimsPeriodEndedException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_tooManyNameservers() throws Exception {
     setEppInput("domain_create_14_nameservers.xml");
     persistContactsAndHosts();
-    assertThrows(TooManyNameserversException.class, this::runFlow);
+    EppException thrown = expectThrows(TooManyNameserversException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_secDnsMaxSigLife() throws Exception {
     setEppInput("domain_create_dsdata.xml");
     persistContactsAndHosts();
-    assertThrows(MaxSigLifeNotSupportedException.class, this::runFlow);
+    EppException thrown = expectThrows(MaxSigLifeNotSupportedException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_secDnsTooManyDsRecords() throws Exception {
     setEppInput("domain_create_dsdata_9_records.xml");
     persistContactsAndHosts();
-    assertThrows(TooManyDsRecordsException.class, this::runFlow);
+    EppException thrown = expectThrows(TooManyDsRecordsException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_wrongExtension() throws Exception {
     setEppInput("domain_create_wrong_extension.xml");
     persistContactsAndHosts();
-    assertThrows(UnimplementedExtensionException.class, this::runFlow);
+    EppException thrown = expectThrows(UnimplementedExtensionException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -825,7 +875,8 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     persistResource(
         Registry.get("tld").asBuilder().setCreateBillingCost(Money.of(USD, 20)).build());
     persistContactsAndHosts();
-    assertThrows(FeesMismatchException.class, this::runFlow);
+    EppException thrown = expectThrows(FeesMismatchException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -834,7 +885,8 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     persistResource(
         Registry.get("tld").asBuilder().setCreateBillingCost(Money.of(USD, 20)).build());
     persistContactsAndHosts();
-    assertThrows(FeesMismatchException.class, this::runFlow);
+    EppException thrown = expectThrows(FeesMismatchException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -843,52 +895,62 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     persistResource(
         Registry.get("tld").asBuilder().setCreateBillingCost(Money.of(USD, 20)).build());
     persistContactsAndHosts();
-    assertThrows(FeesMismatchException.class, this::runFlow);
+    EppException thrown = expectThrows(FeesMismatchException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_wrongCurrency_v06() throws Exception {
     setEppInput("domain_create_fee.xml", ImmutableMap.of("FEE_VERSION", "0.6"));
-    persistResource(Registry.get("tld").asBuilder()
-        .setCurrency(CurrencyUnit.EUR)
-        .setCreateBillingCost(Money.of(EUR, 13))
-        .setRestoreBillingCost(Money.of(EUR, 11))
-        .setRenewBillingCostTransitions(ImmutableSortedMap.of(START_OF_TIME, Money.of(EUR, 7)))
-        .setEapFeeSchedule(ImmutableSortedMap.of(START_OF_TIME, Money.zero(EUR)))
-        .setServerStatusChangeBillingCost(Money.of(EUR, 19))
-        .build());
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setCurrency(CurrencyUnit.EUR)
+            .setCreateBillingCost(Money.of(EUR, 13))
+            .setRestoreBillingCost(Money.of(EUR, 11))
+            .setRenewBillingCostTransitions(ImmutableSortedMap.of(START_OF_TIME, Money.of(EUR, 7)))
+            .setEapFeeSchedule(ImmutableSortedMap.of(START_OF_TIME, Money.zero(EUR)))
+            .setServerStatusChangeBillingCost(Money.of(EUR, 19))
+            .build());
     persistContactsAndHosts();
-    assertThrows(CurrencyUnitMismatchException.class, this::runFlow);
+    EppException thrown = expectThrows(CurrencyUnitMismatchException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_wrongCurrency_v11() throws Exception {
     setEppInput("domain_create_fee.xml", ImmutableMap.of("FEE_VERSION", "0.11"));
-    persistResource(Registry.get("tld").asBuilder()
-        .setCurrency(CurrencyUnit.EUR)
-        .setCreateBillingCost(Money.of(EUR, 13))
-        .setRestoreBillingCost(Money.of(EUR, 11))
-        .setRenewBillingCostTransitions(ImmutableSortedMap.of(START_OF_TIME, Money.of(EUR, 7)))
-        .setEapFeeSchedule(ImmutableSortedMap.of(START_OF_TIME, Money.zero(EUR)))
-        .setServerStatusChangeBillingCost(Money.of(EUR, 19))
-        .build());
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setCurrency(CurrencyUnit.EUR)
+            .setCreateBillingCost(Money.of(EUR, 13))
+            .setRestoreBillingCost(Money.of(EUR, 11))
+            .setRenewBillingCostTransitions(ImmutableSortedMap.of(START_OF_TIME, Money.of(EUR, 7)))
+            .setEapFeeSchedule(ImmutableSortedMap.of(START_OF_TIME, Money.zero(EUR)))
+            .setServerStatusChangeBillingCost(Money.of(EUR, 19))
+            .build());
     persistContactsAndHosts();
-    assertThrows(CurrencyUnitMismatchException.class, this::runFlow);
+    EppException thrown = expectThrows(CurrencyUnitMismatchException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_wrongCurrency_v12() throws Exception {
     setEppInput("domain_create_fee.xml", ImmutableMap.of("FEE_VERSION", "0.12"));
-    persistResource(Registry.get("tld").asBuilder()
-        .setCurrency(CurrencyUnit.EUR)
-        .setCreateBillingCost(Money.of(EUR, 13))
-        .setRestoreBillingCost(Money.of(EUR, 11))
-        .setRenewBillingCostTransitions(ImmutableSortedMap.of(START_OF_TIME, Money.of(EUR, 7)))
-        .setEapFeeSchedule(ImmutableSortedMap.of(START_OF_TIME, Money.zero(EUR)))
-        .setServerStatusChangeBillingCost(Money.of(EUR, 19))
-        .build());
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setCurrency(CurrencyUnit.EUR)
+            .setCreateBillingCost(Money.of(EUR, 13))
+            .setRestoreBillingCost(Money.of(EUR, 11))
+            .setRenewBillingCostTransitions(ImmutableSortedMap.of(START_OF_TIME, Money.of(EUR, 7)))
+            .setEapFeeSchedule(ImmutableSortedMap.of(START_OF_TIME, Money.zero(EUR)))
+            .setServerStatusChangeBillingCost(Money.of(EUR, 19))
+            .build());
     persistContactsAndHosts();
-    assertThrows(CurrencyUnitMismatchException.class, this::runFlow);
+    EppException thrown = expectThrows(CurrencyUnitMismatchException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -897,29 +959,35 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     persistActiveDomain(getUniqueIdFromCommand());
     try {
       runFlow();
-      assert_().fail(
-          "Expected to throw ResourceAlreadyExistsException with message "
-              + "Object with given ID (%s) already exists",
-          getUniqueIdFromCommand());
+      assert_()
+          .fail(
+              "Expected to throw ResourceAlreadyExistsException with message "
+                  + "Object with given ID (%s) already exists",
+              getUniqueIdFromCommand());
     } catch (ResourceAlreadyExistsException e) {
-      assertAboutEppExceptions().that(e).marshalsToXml().and().hasMessage(
-          String.format("Object with given ID (%s) already exists", getUniqueIdFromCommand()));
+      assertAboutEppExceptions()
+          .that(e)
+          .marshalsToXml()
+          .and()
+          .hasMessage(
+              String.format("Object with given ID (%s) already exists", getUniqueIdFromCommand()));
     }
   }
 
-
   @Test
   public void testFailure_reserved() throws Exception {
     setEppInput("domain_create_reserved.xml");
     persistContactsAndHosts();
-    assertThrows(DomainReservedException.class, this::runFlow);
+    EppException thrown = expectThrows(DomainReservedException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_anchorTenantViaAuthCode_wrongAuthCode() throws Exception {
     setEppInput("domain_create_anchor_wrong_authcode.xml");
     persistContactsAndHosts();
-    assertThrows(DomainReservedException.class, this::runFlow);
+    EppException thrown = expectThrows(DomainReservedException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -928,21 +996,19 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     // via auth code during GA. We're running this as superuser to bypass the state checks, though
     // anchor tenant code checks and LRP token redemption still happen regardless.
     createTld("tld", TldState.LANDRUSH);
-    persistResource(Registry.get("tld").asBuilder()
-        .setReservedLists(persistReservedList(
-            "tld-reserved",
-            "anchor,RESERVED_FOR_ANCHOR_TENANT,2fooBAR"))
-        .build());
-    LrpTokenEntity token = persistResource(new LrpTokenEntity.Builder()
-        .setToken("2fooBAR")
-        .setAssignee("anchor.tld")
-        .build());
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setReservedLists(
+                persistReservedList("tld-reserved", "anchor,RESERVED_FOR_ANCHOR_TENANT,2fooBAR"))
+            .build());
+    LrpTokenEntity token =
+        persistResource(
+            new LrpTokenEntity.Builder().setToken("2fooBAR").setAssignee("anchor.tld").build());
     setEppInput("domain_create_anchor_authcode.xml");
     persistContactsAndHosts();
     runFlowAssertResponse(
-        CommitMode.LIVE,
-        UserPrivileges.SUPERUSER,
-        loadFile("domain_create_anchor_response.xml"));
+        CommitMode.LIVE, UserPrivileges.SUPERUSER, loadFile("domain_create_anchor_response.xml"));
     assertSuccessfulCreate("tld", true);
     // Token should not be marked as used, since interpreting the authcode as anchor tenant should
     // take precedence.
@@ -960,9 +1026,11 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
 
   @Test
   public void testSuccess_anchorTenantViaAuthCode_duringLrp() throws Exception {
-    persistResource(Registry.get("tld").asBuilder()
-        .setLrpPeriod(new Interval(clock.nowUtc().minusDays(1), clock.nowUtc().plusDays(1)))
-        .build());
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setLrpPeriod(new Interval(clock.nowUtc().minusDays(1), clock.nowUtc().plusDays(1)))
+            .build());
     setEppInput("domain_create_anchor_authcode.xml");
     persistContactsAndHosts();
     runFlowAssertResponse(loadFile("domain_create_anchor_response.xml"));
@@ -972,9 +1040,11 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
 
   @Test
   public void testSuccess_anchorTenantViaExtension_duringLrp() throws Exception {
-    persistResource(Registry.get("tld").asBuilder()
-        .setLrpPeriod(new Interval(clock.nowUtc().minusDays(1), clock.nowUtc().plusDays(1)))
-        .build());
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setLrpPeriod(new Interval(clock.nowUtc().minusDays(1), clock.nowUtc().plusDays(1)))
+            .build());
     eppRequestSource = EppRequestSource.TOOL;
     setEppInput("domain_create_anchor_tenant.xml");
     persistContactsAndHosts();
@@ -983,14 +1053,15 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     assertNoLordn();
   }
 
-
   @Test
   public void testSuccess_anchorTenantViaAuthCode_withClaims() throws Exception {
-    persistResource(Registry.get("tld").asBuilder()
-        .setReservedLists(persistReservedList(
-            "anchor-with-claims",
-            "example-one,RESERVED_FOR_ANCHOR_TENANT,2fooBAR"))
-        .build());
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setReservedLists(
+                persistReservedList(
+                    "anchor-with-claims", "example-one,RESERVED_FOR_ANCHOR_TENANT,2fooBAR"))
+            .build());
     setEppInput("domain_create_claim_notice.xml");
     clock.setTo(DateTime.parse("2009-08-16T09:00:00.0Z"));
     persistContactsAndHosts();
@@ -1005,9 +1076,7 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     setEppInput("domain_create_reserved.xml");
     persistContactsAndHosts();
     runFlowAssertResponse(
-        CommitMode.LIVE,
-        UserPrivileges.SUPERUSER,
-        loadFile("domain_create_reserved_response.xml"));
+        CommitMode.LIVE, UserPrivileges.SUPERUSER, loadFile("domain_create_reserved_response.xml"));
     assertSuccessfulCreate("tld", false);
   }
 
@@ -1026,13 +1095,14 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     persistActiveHost("ns1.example.net");
     persistActiveContact("jd1234");
     persistActiveContact("sh8013");
-    persistResource(newHostResource("ns2.example.net").asBuilder()
-        .addStatusValue(StatusValue.PENDING_DELETE)
-        .build());
+    persistResource(
+        newHostResource("ns2.example.net")
+            .asBuilder()
+            .addStatusValue(StatusValue.PENDING_DELETE)
+            .build());
     clock.advanceOneMilli();
     LinkedResourceInPendingDeleteProhibitsOperationException thrown =
-        expectThrows(
-            LinkedResourceInPendingDeleteProhibitsOperationException.class, this::runFlow);
+        expectThrows(LinkedResourceInPendingDeleteProhibitsOperationException.class, this::runFlow);
     assertThat(thrown).hasMessageThat().contains("ns2.example.net");
   }
 
@@ -1041,7 +1111,8 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     persistContactsAndHosts();
     persistActiveDomainApplication(getUniqueIdFromCommand());
     clock.advanceOneMilli();
-    assertThrows(DomainHasOpenApplicationsException.class, this::runFlow);
+    EppException thrown = expectThrows(DomainHasOpenApplicationsException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -1054,9 +1125,11 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
   @Test
   public void testSuccess_rejectedApplication() throws Exception {
     persistContactsAndHosts();
-    persistResource(newDomainApplication(getUniqueIdFromCommand()).asBuilder()
-        .setApplicationStatus(ApplicationStatus.REJECTED)
-        .build());
+    persistResource(
+        newDomainApplication(getUniqueIdFromCommand())
+            .asBuilder()
+            .setApplicationStatus(ApplicationStatus.REJECTED)
+            .build());
     clock.advanceOneMilli();
     doSuccessfulTest();
   }
@@ -1076,13 +1149,14 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     persistActiveHost("ns1.example.net");
     persistActiveHost("ns2.example.net");
     persistActiveContact("sh8013");
-    persistResource(newContactResource("jd1234").asBuilder()
-        .addStatusValue(StatusValue.PENDING_DELETE)
-        .build());
+    persistResource(
+        newContactResource("jd1234")
+            .asBuilder()
+            .addStatusValue(StatusValue.PENDING_DELETE)
+            .build());
     clock.advanceOneMilli();
     LinkedResourceInPendingDeleteProhibitsOperationException thrown =
-        expectThrows(
-            LinkedResourceInPendingDeleteProhibitsOperationException.class, this::runFlow);
+        expectThrows(LinkedResourceInPendingDeleteProhibitsOperationException.class, this::runFlow);
     assertThat(thrown).hasMessageThat().contains("jd1234");
   }
 
@@ -1090,42 +1164,53 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
   public void testFailure_wrongTld() throws Exception {
     persistContactsAndHosts("net");
     deleteTld("tld");
-    assertThrows(TldDoesNotExistException.class, this::runFlow);
+    EppException thrown = expectThrows(TldDoesNotExistException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_predelegation() throws Exception {
     createTld("tld", TldState.PREDELEGATION);
     persistContactsAndHosts();
-    assertThrows(NoGeneralRegistrationsInCurrentPhaseException.class, this::runFlow);
+    EppException thrown =
+        expectThrows(NoGeneralRegistrationsInCurrentPhaseException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_sunrise() throws Exception {
     createTld("tld", TldState.SUNRISE);
     persistContactsAndHosts();
-    assertThrows(NoGeneralRegistrationsInCurrentPhaseException.class, this::runFlow);
+    EppException thrown =
+        expectThrows(NoGeneralRegistrationsInCurrentPhaseException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_sunrush() throws Exception {
     createTld("tld", TldState.SUNRUSH);
     persistContactsAndHosts();
-    assertThrows(NoGeneralRegistrationsInCurrentPhaseException.class, this::runFlow);
+    EppException thrown =
+        expectThrows(NoGeneralRegistrationsInCurrentPhaseException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_landrush() throws Exception {
     createTld("tld", TldState.LANDRUSH);
     persistContactsAndHosts();
-    assertThrows(NoGeneralRegistrationsInCurrentPhaseException.class, this::runFlow);
+    EppException thrown =
+        expectThrows(NoGeneralRegistrationsInCurrentPhaseException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_quietPeriod() throws Exception {
     createTld("tld", TldState.QUIET_PERIOD);
     persistContactsAndHosts();
-    assertThrows(NoGeneralRegistrationsInCurrentPhaseException.class, this::runFlow);
+    EppException thrown =
+        expectThrows(NoGeneralRegistrationsInCurrentPhaseException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -1158,9 +1243,7 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     // Modify the Registrar to block premium names.
     persistResource(loadRegistrar("TheRegistrar").asBuilder().setBlockPremiumNames(true).build());
     runFlowAssertResponse(
-        CommitMode.LIVE,
-        UserPrivileges.SUPERUSER,
-        loadFile("domain_create_response_premium.xml"));
+        CommitMode.LIVE, UserPrivileges.SUPERUSER, loadFile("domain_create_response_premium.xml"));
     assertSuccessfulCreate("example", false);
   }
 
@@ -1198,7 +1281,8 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
   public void testFailure_duplicateContact() throws Exception {
     setEppInput("domain_create_duplicate_contact.xml");
     persistContactsAndHosts();
-    assertThrows(DuplicateContactForRoleException.class, this::runFlow);
+    EppException thrown = expectThrows(DuplicateContactForRoleException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -1206,35 +1290,40 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     // We need to test for missing type, but not for invalid - the schema enforces that for us.
     setEppInput("domain_create_missing_contact_type.xml");
     persistContactsAndHosts();
-    assertThrows(MissingContactTypeException.class, this::runFlow);
+    EppException thrown = expectThrows(MissingContactTypeException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_missingRegistrant() throws Exception {
     setEppInput("domain_create_missing_registrant.xml");
     persistContactsAndHosts();
-    assertThrows(MissingRegistrantException.class, this::runFlow);
+    EppException thrown = expectThrows(MissingRegistrantException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_missingAdmin() throws Exception {
     setEppInput("domain_create_missing_admin.xml");
     persistContactsAndHosts();
-    assertThrows(MissingAdminContactException.class, this::runFlow);
+    EppException thrown = expectThrows(MissingAdminContactException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_missingTech() throws Exception {
     setEppInput("domain_create_missing_tech.xml");
     persistContactsAndHosts();
-    assertThrows(MissingTechnicalContactException.class, this::runFlow);
+    EppException thrown = expectThrows(MissingTechnicalContactException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_missingNonRegistrantContacts() throws Exception {
     setEppInput("domain_create_missing_non_registrant_contacts.xml");
     persistContactsAndHosts();
-    assertThrows(MissingAdminContactException.class, this::runFlow);
+    EppException thrown = expectThrows(MissingAdminContactException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -1242,7 +1331,8 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     createTld("xn--q9jyb4c");
     setEppInput("domain_create_bad_idn_minna.xml");
     persistContactsAndHosts("net");
-    assertThrows(InvalidIdnDomainLabelException.class, this::runFlow);
+    EppException thrown = expectThrows(InvalidIdnDomainLabelException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -1250,14 +1340,16 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     setEppInput("domain_create_bad_validator_id.xml");
     persistClaimsList(ImmutableMap.of("exampleone", CLAIMS_KEY));
     persistContactsAndHosts();
-    assertThrows(InvalidTrademarkValidatorException.class, this::runFlow);
+    EppException thrown = expectThrows(InvalidTrademarkValidatorException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_codeMark() throws Exception {
     setEppInput("domain_create_code_with_mark.xml");
     persistContactsAndHosts();
-    assertThrows(UnsupportedMarkTypeException.class, this::runFlow);
+    EppException thrown = expectThrows(UnsupportedMarkTypeException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -1265,7 +1357,9 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     createTld("tld", TldState.SUNRISE);
     setEppInput("domain_create_signed_mark.xml");
     persistContactsAndHosts();
-    assertThrows(NoGeneralRegistrationsInCurrentPhaseException.class, this::runFlow);
+    EppException thrown =
+        expectThrows(NoGeneralRegistrationsInCurrentPhaseException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -1273,7 +1367,8 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     clock.setTo(DateTime.parse("2010-08-17T09:00:00.0Z"));
     setEppInput("domain_create_claim_notice.xml");
     persistContactsAndHosts();
-    assertThrows(ExpiredClaimException.class, this::runFlow);
+    EppException thrown = expectThrows(ExpiredClaimException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -1281,7 +1376,8 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     clock.setTo(DateTime.parse("2009-09-16T09:00:00.0Z"));
     setEppInput("domain_create_claim_notice.xml");
     persistContactsAndHosts();
-    assertThrows(AcceptedTooLongAgoException.class, this::runFlow);
+    EppException thrown = expectThrows(AcceptedTooLongAgoException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -1289,7 +1385,8 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     clock.setTo(DateTime.parse("2009-08-16T09:00:00.0Z"));
     setEppInput("domain_create_malformed_claim_notice1.xml");
     persistContactsAndHosts();
-    assertThrows(MalformedTcnIdException.class, this::runFlow);
+    EppException thrown = expectThrows(MalformedTcnIdException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -1297,7 +1394,8 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     clock.setTo(DateTime.parse("2009-08-16T09:00:00.0Z"));
     setEppInput("domain_create_malformed_claim_notice2.xml");
     persistContactsAndHosts();
-    assertThrows(MalformedTcnIdException.class, this::runFlow);
+    EppException thrown = expectThrows(MalformedTcnIdException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -1305,7 +1403,8 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     clock.setTo(DateTime.parse("2009-08-16T09:00:00.0Z"));
     setEppInput("domain_create_bad_checksum_claim_notice.xml");
     persistContactsAndHosts();
-    assertThrows(InvalidTcnIdChecksumException.class, this::runFlow);
+    EppException thrown = expectThrows(InvalidTcnIdChecksumException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -1315,10 +1414,9 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     setEppInput("domain_create_premium.xml");
     persistContactsAndHosts("net");
     // Modify the Registrar to block premium names.
-    persistResource(loadRegistrar("TheRegistrar").asBuilder()
-        .setBlockPremiumNames(true)
-        .build());
-    assertThrows(PremiumNameBlockedException.class, this::runFlow);
+    persistResource(loadRegistrar("TheRegistrar").asBuilder().setBlockPremiumNames(true).build());
+    EppException thrown = expectThrows(PremiumNameBlockedException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -1326,7 +1424,8 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     createTld("example");
     setEppInput("domain_create_premium.xml");
     persistContactsAndHosts("net");
-    assertThrows(FeesRequiredForPremiumNameException.class, this::runFlow);
+    EppException thrown = expectThrows(FeesRequiredForPremiumNameException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -1337,7 +1436,8 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     createTld("net");
     setEppInput("domain_create_fee.xml", ImmutableMap.of("FEE_VERSION", "0.6"));
     persistContactsAndHosts();
-    assertThrows(UndeclaredServiceExtensionException.class, this::runFlow);
+    EppException thrown = expectThrows(UndeclaredServiceExtensionException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -1348,7 +1448,8 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     createTld("net");
     setEppInput("domain_create_fee.xml", ImmutableMap.of("FEE_VERSION", "0.11"));
     persistContactsAndHosts();
-    assertThrows(UndeclaredServiceExtensionException.class, this::runFlow);
+    EppException thrown = expectThrows(UndeclaredServiceExtensionException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -1359,28 +1460,32 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     createTld("net");
     setEppInput("domain_create_fee.xml", ImmutableMap.of("FEE_VERSION", "0.12"));
     persistContactsAndHosts();
-    assertThrows(UndeclaredServiceExtensionException.class, this::runFlow);
+    EppException thrown = expectThrows(UndeclaredServiceExtensionException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_feeGivenInWrongScale_v06() throws Exception {
     setEppInput("domain_create_fee_bad_scale.xml", ImmutableMap.of("FEE_VERSION", "0.6"));
     persistContactsAndHosts();
-    assertThrows(CurrencyValueScaleException.class, this::runFlow);
+    EppException thrown = expectThrows(CurrencyValueScaleException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_feeGivenInWrongScale_v11() throws Exception {
     setEppInput("domain_create_fee_bad_scale.xml", ImmutableMap.of("FEE_VERSION", "0.11"));
     persistContactsAndHosts();
-    assertThrows(CurrencyValueScaleException.class, this::runFlow);
+    EppException thrown = expectThrows(CurrencyValueScaleException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_feeGivenInWrongScale_v12() throws Exception {
     setEppInput("domain_create_fee_bad_scale.xml", ImmutableMap.of("FEE_VERSION", "0.12"));
     persistContactsAndHosts();
-    assertThrows(CurrencyValueScaleException.class, this::runFlow);
+    EppException thrown = expectThrows(CurrencyValueScaleException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -1393,16 +1498,18 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
             .asBuilder()
             .setState(State.SUSPENDED)
             .build());
-    assertThrows(RegistrarMustBeActiveToCreateDomainsException.class, this::runFlow);
+    EppException thrown =
+        expectThrows(RegistrarMustBeActiveToCreateDomainsException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
-  private void doFailingDomainNameTest(
-      String domainName,
-      Class<? extends Throwable> exception) throws Exception {
+  private void doFailingDomainNameTest(String domainName, Class<? extends EppException> exception)
+      throws Exception {
     setEppInput("domain_create_uppercase.xml");
     eppLoader.replaceAll("Example.tld", domainName);
     persistContactsAndHosts();
-    assertThrows(exception, this::runFlow);
+    EppException thrown = expectThrows(exception, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -1476,7 +1583,9 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     createTld("tld", TldState.SUNRISE);
     setEppInput("domain_create_registration_sunrise.xml");
     persistContactsAndHosts();
-    assertThrows(NoGeneralRegistrationsInCurrentPhaseException.class, this::runFlow);
+    EppException thrown =
+        expectThrows(NoGeneralRegistrationsInCurrentPhaseException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -1491,7 +1600,7 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
   public void testSuccess_qlpSunriseRegistration() throws Exception {
     createTld("tld", TldState.SUNRISE);
     setEppInput("domain_create_registration_qlp_sunrise.xml");
-    eppRequestSource = EppRequestSource.TOOL;  // Only tools can pass in metadata.
+    eppRequestSource = EppRequestSource.TOOL; // Only tools can pass in metadata.
     persistContactsAndHosts();
     runFlowAssertResponse(loadFile("domain_create_response.xml"));
     assertSuccessfulCreate("tld", true);
@@ -1503,7 +1612,7 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     createTld("tld", TldState.SUNRISE);
     clock.setTo(DateTime.parse("2014-09-09T09:09:09Z"));
     setEppInput("domain_create_registration_qlp_sunrise_encoded_signed_mark.xml");
-    eppRequestSource = EppRequestSource.TOOL;  // Only tools can pass in metadata.
+    eppRequestSource = EppRequestSource.TOOL; // Only tools can pass in metadata.
     persistContactsAndHosts();
     runFlowAssertResponse(loadFile("domain_create_response_encoded_signed_mark_name.xml"));
     assertSuccessfulCreate("tld", true);
@@ -1515,7 +1624,7 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     createTld("tld", TldState.SUNRISE);
     clock.setTo(DateTime.parse("2009-08-16T09:00:00.0Z"));
     setEppInput("domain_create_registration_qlp_sunrise_claims_notice.xml");
-    eppRequestSource = EppRequestSource.TOOL;  // Only tools can pass in metadata.
+    eppRequestSource = EppRequestSource.TOOL; // Only tools can pass in metadata.
     persistContactsAndHosts();
     runFlowAssertResponse(loadFile("domain_create_response_claims.xml"));
     assertSuccessfulCreate("tld", true);
@@ -1527,7 +1636,9 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     createTld("tld", TldState.SUNRUSH);
     setEppInput("domain_create_registration_sunrush.xml");
     persistContactsAndHosts();
-    assertThrows(NoGeneralRegistrationsInCurrentPhaseException.class, this::runFlow);
+    EppException thrown =
+        expectThrows(NoGeneralRegistrationsInCurrentPhaseException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -1539,7 +1650,8 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
             .setAllowedTlds(ImmutableSet.of("irrelevant"))
             .build());
     persistContactsAndHosts();
-    assertThrows(NotAuthorizedForTldException.class, this::runFlow);
+    EppException thrown = expectThrows(NotAuthorizedForTldException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -1554,7 +1666,7 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
   public void testSuccess_qlpSunrushRegistration() throws Exception {
     createTld("tld", TldState.SUNRUSH);
     setEppInput("domain_create_registration_qlp_sunrush.xml");
-    eppRequestSource = EppRequestSource.TOOL;  // Only tools can pass in metadata.
+    eppRequestSource = EppRequestSource.TOOL; // Only tools can pass in metadata.
     persistContactsAndHosts();
     runFlowAssertResponse(loadFile("domain_create_response.xml"));
     assertSuccessfulCreate("tld", true);
@@ -1566,7 +1678,7 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     createTld("tld", TldState.SUNRUSH);
     clock.setTo(DateTime.parse("2014-09-09T09:09:09Z"));
     setEppInput("domain_create_registration_qlp_sunrush_encoded_signed_mark.xml");
-    eppRequestSource = EppRequestSource.TOOL;  // Only tools can pass in metadata.
+    eppRequestSource = EppRequestSource.TOOL; // Only tools can pass in metadata.
     persistContactsAndHosts();
     runFlowAssertResponse(loadFile("domain_create_response_encoded_signed_mark_name.xml"));
     assertSuccessfulCreate("tld", true);
@@ -1578,7 +1690,7 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     createTld("tld", TldState.SUNRUSH);
     clock.setTo(DateTime.parse("2009-08-16T09:00:00.0Z"));
     setEppInput("domain_create_registration_qlp_sunrush_claims_notice.xml");
-    eppRequestSource = EppRequestSource.TOOL;  // Only tools can pass in metadata.
+    eppRequestSource = EppRequestSource.TOOL; // Only tools can pass in metadata.
     persistContactsAndHosts();
     runFlowAssertResponse(loadFile("domain_create_response_claims.xml"));
     assertSuccessfulCreate("tld", true);
@@ -1590,7 +1702,9 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     createTld("tld", TldState.LANDRUSH);
     setEppInput("domain_create_registration_landrush.xml");
     persistContactsAndHosts();
-    assertThrows(NoGeneralRegistrationsInCurrentPhaseException.class, this::runFlow);
+    EppException thrown =
+        expectThrows(NoGeneralRegistrationsInCurrentPhaseException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -1605,7 +1719,7 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
   public void testSuccess_qlpLandrushRegistration() throws Exception {
     createTld("tld", TldState.LANDRUSH);
     setEppInput("domain_create_registration_qlp_landrush.xml");
-    eppRequestSource = EppRequestSource.TOOL;  // Only tools can pass in metadata.
+    eppRequestSource = EppRequestSource.TOOL; // Only tools can pass in metadata.
     persistContactsAndHosts();
     runFlowAssertResponse(loadFile("domain_create_response.xml"));
     assertSuccessfulCreate("tld", true);
@@ -1617,7 +1731,7 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     createTld("tld", TldState.LANDRUSH);
     clock.setTo(DateTime.parse("2014-09-09T09:09:09Z"));
     setEppInput("domain_create_registration_qlp_landrush_encoded_signed_mark.xml");
-    eppRequestSource = EppRequestSource.TOOL;  // Only tools can pass in metadata.
+    eppRequestSource = EppRequestSource.TOOL; // Only tools can pass in metadata.
     persistContactsAndHosts();
     runFlow();
     assertSuccessfulCreate("tld", true);
@@ -1629,7 +1743,7 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     createTld("tld", TldState.LANDRUSH);
     clock.setTo(DateTime.parse("2009-08-16T09:00:00.0Z"));
     setEppInput("domain_create_registration_qlp_landrush_claims_notice.xml");
-    eppRequestSource = EppRequestSource.TOOL;  // Only tools can pass in metadata.
+    eppRequestSource = EppRequestSource.TOOL; // Only tools can pass in metadata.
     persistContactsAndHosts();
     runFlowAssertResponse(loadFile("domain_create_response_claims.xml"));
     assertSuccessfulCreate("tld", true);
@@ -1640,9 +1754,11 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
   public void testFailure_registrantNotWhitelisted() throws Exception {
     persistActiveContact("someone");
     persistContactsAndHosts();
-    persistResource(Registry.get("tld").asBuilder()
-        .setAllowedRegistrantContactIds(ImmutableSet.of("someone"))
-        .build());
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setAllowedRegistrantContactIds(ImmutableSet.of("someone"))
+            .build());
     RegistrantNotAllowedException thrown =
         expectThrows(RegistrantNotAllowedException.class, this::runFlow);
     assertThat(thrown).hasMessageThat().contains("jd1234");
@@ -1651,9 +1767,11 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
   @Test
   public void testFailure_nameserverNotWhitelisted() throws Exception {
     persistContactsAndHosts();
-    persistResource(Registry.get("tld").asBuilder()
-        .setAllowedFullyQualifiedHostNames(ImmutableSet.of("ns2.example.net"))
-        .build());
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setAllowedFullyQualifiedHostNames(ImmutableSet.of("ns2.example.net"))
+            .build());
     NameserversNotAllowedForTldException thrown =
         expectThrows(NameserversNotAllowedForTldException.class, this::runFlow);
     assertThat(thrown).hasMessageThat().contains("ns1.example.net");
@@ -1662,20 +1780,27 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
   @Test
   public void testFailure_emptyNameserverFailsWhitelist() throws Exception {
     setEppInput("domain_create_no_hosts_or_dsdata.xml");
-    persistResource(Registry.get("tld").asBuilder()
-        .setAllowedFullyQualifiedHostNames(ImmutableSet.of("somethingelse.example.net"))
-        .build());
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setAllowedFullyQualifiedHostNames(ImmutableSet.of("somethingelse.example.net"))
+            .build());
     persistContactsAndHosts();
-    assertThrows(
-        NameserversNotSpecifiedForTldWithNameserverWhitelistException.class, this::runFlow);
+    EppException thrown =
+        expectThrows(
+            NameserversNotSpecifiedForTldWithNameserverWhitelistException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testSuccess_nameserverAndRegistrantWhitelisted() throws Exception {
-    persistResource(Registry.get("tld").asBuilder()
-        .setAllowedRegistrantContactIds(ImmutableSet.of("jd1234"))
-        .setAllowedFullyQualifiedHostNames(ImmutableSet.of("ns1.example.net", "ns2.example.net"))
-        .build());
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setAllowedRegistrantContactIds(ImmutableSet.of("jd1234"))
+            .setAllowedFullyQualifiedHostNames(
+                ImmutableSet.of("ns1.example.net", "ns2.example.net"))
+            .build());
     persistContactsAndHosts();
     doSuccessfulTest();
   }
@@ -1708,8 +1833,10 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
                     "example,NAMESERVER_RESTRICTED,"
                         + "ns1.example.net:ns2.example.net:ns3.example.net"))
             .build());
-    assertThrows(
-        NameserversNotSpecifiedForNameserverRestrictedDomainException.class, this::runFlow);
+    EppException thrown =
+        expectThrows(
+            NameserversNotSpecifiedForNameserverRestrictedDomainException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -1871,12 +1998,18 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
   public void testSuccess_eapFeeApplied_v06() throws Exception {
     setEppInput("domain_create_eap_fee.xml", ImmutableMap.of("FEE_VERSION", "0.6"));
     persistContactsAndHosts();
-    persistResource(Registry.get("tld").asBuilder()
-        .setEapFeeSchedule(ImmutableSortedMap.of(
-            START_OF_TIME, Money.of(USD, 0),
-            clock.nowUtc().minusDays(1), Money.of(USD, 100),
-            clock.nowUtc().plusDays(1), Money.of(USD, 0)))
-        .build());
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setEapFeeSchedule(
+                ImmutableSortedMap.of(
+                    START_OF_TIME,
+                    Money.of(USD, 0),
+                    clock.nowUtc().minusDays(1),
+                    Money.of(USD, 100),
+                    clock.nowUtc().plusDays(1),
+                    Money.of(USD, 0)))
+            .build());
     doSuccessfulTest(
         "tld", "domain_create_response_eap_fee.xml", ImmutableMap.of("FEE_VERSION", "0.6"));
   }
@@ -1885,12 +2018,18 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
   public void testSuccess_eapFeeApplied_v11() throws Exception {
     setEppInput("domain_create_eap_fee.xml", ImmutableMap.of("FEE_VERSION", "0.11"));
     persistContactsAndHosts();
-    persistResource(Registry.get("tld").asBuilder()
-        .setEapFeeSchedule(ImmutableSortedMap.of(
-            START_OF_TIME, Money.of(USD, 0),
-            clock.nowUtc().minusDays(1), Money.of(USD, 100),
-            clock.nowUtc().plusDays(1), Money.of(USD, 0)))
-        .build());
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setEapFeeSchedule(
+                ImmutableSortedMap.of(
+                    START_OF_TIME,
+                    Money.of(USD, 0),
+                    clock.nowUtc().minusDays(1),
+                    Money.of(USD, 100),
+                    clock.nowUtc().plusDays(1),
+                    Money.of(USD, 0)))
+            .build());
     doSuccessfulTest(
         "tld", "domain_create_response_eap_fee.xml", ImmutableMap.of("FEE_VERSION", "0.11"));
   }
@@ -1899,12 +2038,18 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
   public void testSuccess_eapFeeApplied_v12() throws Exception {
     setEppInput("domain_create_eap_fee.xml", ImmutableMap.of("FEE_VERSION", "0.12"));
     persistContactsAndHosts();
-    persistResource(Registry.get("tld").asBuilder()
-        .setEapFeeSchedule(ImmutableSortedMap.of(
-            START_OF_TIME, Money.of(USD, 0),
-            clock.nowUtc().minusDays(1), Money.of(USD, 100),
-            clock.nowUtc().plusDays(1), Money.of(USD, 0)))
-        .build());
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setEapFeeSchedule(
+                ImmutableSortedMap.of(
+                    START_OF_TIME,
+                    Money.of(USD, 0),
+                    clock.nowUtc().minusDays(1),
+                    Money.of(USD, 100),
+                    clock.nowUtc().plusDays(1),
+                    Money.of(USD, 0)))
+            .build());
     doSuccessfulTest(
         "tld", "domain_create_response_eap_fee.xml", ImmutableMap.of("FEE_VERSION", "0.12"));
   }
@@ -1917,9 +2062,12 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
             .asBuilder()
             .setEapFeeSchedule(
                 ImmutableSortedMap.of(
-                    START_OF_TIME, Money.of(USD, 0),
-                    clock.nowUtc().minusDays(1), Money.of(USD, 100),
-                    clock.nowUtc().plusDays(1), Money.of(USD, 0)))
+                    START_OF_TIME,
+                    Money.of(USD, 0),
+                    clock.nowUtc().minusDays(1),
+                    Money.of(USD, 100),
+                    clock.nowUtc().plusDays(1),
+                    Money.of(USD, 0)))
             .build());
     Exception e = expectThrows(FeesRequiredDuringEarlyAccessProgramException.class, this::runFlow);
     assertThat(e)
@@ -1927,30 +2075,41 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
         .isEqualTo(
             "Fees must be explicitly acknowledged when creating domains "
                 + "during the Early Access Program. The EAP fee is: USD 100.00");
-
   }
 
   @Test
   public void testSuccess_eapFee_beforeEntireSchedule() throws Exception {
     persistContactsAndHosts();
-    persistResource(Registry.get("tld").asBuilder()
-        .setEapFeeSchedule(ImmutableSortedMap.of(
-            START_OF_TIME, Money.of(USD, 0),
-            clock.nowUtc().plusDays(1), Money.of(USD, 10),
-            clock.nowUtc().plusDays(2), Money.of(USD, 0)))
-        .build());
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setEapFeeSchedule(
+                ImmutableSortedMap.of(
+                    START_OF_TIME,
+                    Money.of(USD, 0),
+                    clock.nowUtc().plusDays(1),
+                    Money.of(USD, 10),
+                    clock.nowUtc().plusDays(2),
+                    Money.of(USD, 0)))
+            .build());
     doSuccessfulTest("tld", "domain_create_response.xml");
   }
 
   @Test
   public void testSuccess_eapFee_afterEntireSchedule() throws Exception {
     persistContactsAndHosts();
-    persistResource(Registry.get("tld").asBuilder()
-        .setEapFeeSchedule(ImmutableSortedMap.of(
-            START_OF_TIME, Money.of(USD, 0),
-            clock.nowUtc().minusDays(2), Money.of(USD, 100),
-            clock.nowUtc().minusDays(1), Money.of(USD, 0)))
-        .build());
+    persistResource(
+        Registry.get("tld")
+            .asBuilder()
+            .setEapFeeSchedule(
+                ImmutableSortedMap.of(
+                    START_OF_TIME,
+                    Money.of(USD, 0),
+                    clock.nowUtc().minusDays(2),
+                    Money.of(USD, 100),
+                    clock.nowUtc().minusDays(1),
+                    Money.of(USD, 0)))
+            .build());
     doSuccessfulTest("tld", "domain_create_response.xml");
   }
 
@@ -1958,7 +2117,8 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
   public void testFailure_max10Years() throws Exception {
     setEppInput("domain_create_11_years.xml");
     persistContactsAndHosts();
-    assertThrows(ExceedsMaxRegistrationYearsException.class, this::runFlow);
+    EppException thrown = expectThrows(ExceedsMaxRegistrationYearsException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -1982,12 +2142,13 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
     runFlow();
     DomainResource domain = reloadResourceByForeignKey();
     HistoryEntry historyEntry = getHistoryEntries(domain).get(0);
-    assertThat(historyEntry.getDomainTransactionRecords()).containsExactly(
-        DomainTransactionRecord.create(
-            "tld",
-            historyEntry.getModificationTime().plusMinutes(9),
-            TransactionReportField.netAddsFieldFromYears(2),
-            1));
+    assertThat(historyEntry.getDomainTransactionRecords())
+        .containsExactly(
+            DomainTransactionRecord.create(
+                "tld",
+                historyEntry.getModificationTime().plusMinutes(9),
+                TransactionReportField.netAddsFieldFromYears(2),
+                1));
   }
 
   @Test
diff --git a/javatests/google/registry/flows/domain/DomainDeleteFlowTest.java b/javatests/google/registry/flows/domain/DomainDeleteFlowTest.java
index b629eaf4a..3a0e73d6a 100644
--- a/javatests/google/registry/flows/domain/DomainDeleteFlowTest.java
+++ b/javatests/google/registry/flows/domain/DomainDeleteFlowTest.java
@@ -41,8 +41,8 @@ import static google.registry.testing.DatastoreHelper.persistActiveDomain;
 import static google.registry.testing.DatastoreHelper.persistDeletedDomain;
 import static google.registry.testing.DatastoreHelper.persistResource;
 import static google.registry.testing.DomainResourceSubject.assertAboutDomains;
+import static google.registry.testing.EppExceptionSubject.assertAboutEppExceptions;
 import static google.registry.testing.HistoryEntrySubject.assertAboutHistoryEntries;
-import static google.registry.testing.JUnitBackports.assertThrows;
 import static google.registry.testing.JUnitBackports.expectThrows;
 import static google.registry.testing.TaskQueueHelper.assertDnsTasksEnqueued;
 import static google.registry.util.DateTimeUtils.END_OF_TIME;
@@ -53,6 +53,7 @@ import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.ImmutableSortedMap;
 import com.googlecode.objectify.Key;
+import google.registry.flows.EppException;
 import google.registry.flows.EppRequestSource;
 import google.registry.flows.ResourceFlowTestCase;
 import google.registry.flows.ResourceFlowUtils.ResourceDoesNotExistException;
@@ -120,35 +121,39 @@ public class DomainDeleteFlowTest extends ResourceFlowTestCase<DomainDeleteFlow,
 
   private void setUpSuccessfulTest() throws Exception {
     createReferencedEntities(A_MONTH_FROM_NOW);
-    BillingEvent.Recurring autorenewBillingEvent = persistResource(
-        createAutorenewBillingEvent("TheRegistrar").build());
-    PollMessage.Autorenew autorenewPollMessage = persistResource(
-        createAutorenewPollMessage("TheRegistrar").build());
-    domain = persistResource(domain.asBuilder()
-        .setAutorenewBillingEvent(Key.create(autorenewBillingEvent))
-        .setAutorenewPollMessage(Key.create(autorenewPollMessage))
-        .build());
+    BillingEvent.Recurring autorenewBillingEvent =
+        persistResource(createAutorenewBillingEvent("TheRegistrar").build());
+    PollMessage.Autorenew autorenewPollMessage =
+        persistResource(createAutorenewPollMessage("TheRegistrar").build());
+    domain =
+        persistResource(
+            domain
+                .asBuilder()
+                .setAutorenewBillingEvent(Key.create(autorenewBillingEvent))
+                .setAutorenewPollMessage(Key.create(autorenewPollMessage))
+                .build());
     assertTransactionalFlow(true);
   }
 
   private void createReferencedEntities(DateTime expirationTime) throws Exception {
     // Persist a linked contact.
     ContactResource contact = persistActiveContact("sh8013");
-    domain = newDomainResource(getUniqueIdFromCommand()).asBuilder()
-        .setCreationTimeForTest(TIME_BEFORE_FLOW)
-        .setRegistrant(Key.create(contact))
-        .setRegistrationExpirationTime(expirationTime)
-        .build();
-    earlierHistoryEntry = persistResource(
-        new HistoryEntry.Builder()
-            .setType(DOMAIN_CREATE)
-            .setParent(domain)
-            .build());
+    domain =
+        newDomainResource(getUniqueIdFromCommand())
+            .asBuilder()
+            .setCreationTimeForTest(TIME_BEFORE_FLOW)
+            .setRegistrant(Key.create(contact))
+            .setRegistrationExpirationTime(expirationTime)
+            .build();
+    earlierHistoryEntry =
+        persistResource(
+            new HistoryEntry.Builder().setType(DOMAIN_CREATE).setParent(domain).build());
   }
 
   private void setUpGracePeriods(GracePeriod... gracePeriods) throws Exception {
-    domain = persistResource(
-        domain.asBuilder().setGracePeriods(ImmutableSet.copyOf(gracePeriods)).build());
+    domain =
+        persistResource(
+            domain.asBuilder().setGracePeriods(ImmutableSet.copyOf(gracePeriods)).build());
   }
 
   private void setUpGracePeriodDurations() {
@@ -165,35 +170,35 @@ public class DomainDeleteFlowTest extends ResourceFlowTestCase<DomainDeleteFlow,
 
   private void setUpAutorenewGracePeriod() throws Exception {
     createReferencedEntities(A_MONTH_AGO.plusYears(1));
-    BillingEvent.Recurring autorenewBillingEvent = persistResource(
-        createAutorenewBillingEvent("TheRegistrar")
-            .setEventTime(A_MONTH_AGO)
-            .build());
-    PollMessage.Autorenew autorenewPollMessage = persistResource(
-        createAutorenewPollMessage("TheRegistrar")
-            .setEventTime(A_MONTH_AGO)
-            .build());
-    domain = persistResource(
-        domain.asBuilder()
-            .setGracePeriods(ImmutableSet.of(GracePeriod.createForRecurring(
-                GracePeriodStatus.AUTO_RENEW,
-                A_MONTH_AGO.plusDays(45),
-                "TheRegistrar",
-                Key.create(autorenewBillingEvent))))
-            .setAutorenewBillingEvent(Key.create(autorenewBillingEvent))
-            .setAutorenewPollMessage(Key.create(autorenewPollMessage))
-            .build());
+    BillingEvent.Recurring autorenewBillingEvent =
+        persistResource(
+            createAutorenewBillingEvent("TheRegistrar").setEventTime(A_MONTH_AGO).build());
+    PollMessage.Autorenew autorenewPollMessage =
+        persistResource(
+            createAutorenewPollMessage("TheRegistrar").setEventTime(A_MONTH_AGO).build());
+    domain =
+        persistResource(
+            domain
+                .asBuilder()
+                .setGracePeriods(
+                    ImmutableSet.of(
+                        GracePeriod.createForRecurring(
+                            GracePeriodStatus.AUTO_RENEW,
+                            A_MONTH_AGO.plusDays(45),
+                            "TheRegistrar",
+                            Key.create(autorenewBillingEvent))))
+                .setAutorenewBillingEvent(Key.create(autorenewBillingEvent))
+                .setAutorenewPollMessage(Key.create(autorenewPollMessage))
+                .build());
     assertTransactionalFlow(true);
   }
 
   private void assertAutorenewClosedAndCancellationCreatedFor(
-      BillingEvent.OneTime graceBillingEvent,
-      HistoryEntry historyEntryDomainDelete) throws Exception {
+      BillingEvent.OneTime graceBillingEvent, HistoryEntry historyEntryDomainDelete)
+      throws Exception {
     DateTime eventTime = clock.nowUtc();
     assertBillingEvents(
-        createAutorenewBillingEvent("TheRegistrar")
-            .setRecurrenceEndTime(eventTime)
-            .build(),
+        createAutorenewBillingEvent("TheRegistrar").setRecurrenceEndTime(eventTime).build(),
         graceBillingEvent,
         new BillingEvent.Cancellation.Builder()
             .setReason(graceBillingEvent.getReason())
@@ -249,8 +254,8 @@ public class DomainDeleteFlowTest extends ResourceFlowTestCase<DomainDeleteFlow,
   @Test
   public void testDryRun() throws Exception {
     setUpSuccessfulTest();
-    setUpGracePeriods(GracePeriod.create(
-        GracePeriodStatus.ADD, TIME_BEFORE_FLOW.plusDays(1), "foo", null));
+    setUpGracePeriods(
+        GracePeriod.create(GracePeriodStatus.ADD, TIME_BEFORE_FLOW.plusDays(1), "foo", null));
     dryRunFlowAssertResponse(loadFile("domain_delete_response.xml"));
   }
 
@@ -268,7 +273,8 @@ public class DomainDeleteFlowTest extends ResourceFlowTestCase<DomainDeleteFlow,
   private void doImmediateDeleteTest(
       GracePeriodStatus gracePeriodStatus,
       String responseFilename,
-      Map<String, String> substitutions) throws Exception {
+      Map<String, String> substitutions)
+      throws Exception {
     // Persist the billing event so it can be retrieved for cancellation generation and checking.
     setUpSuccessfulTest();
     BillingEvent.OneTime graceBillingEvent =
@@ -339,12 +345,20 @@ public class DomainDeleteFlowTest extends ResourceFlowTestCase<DomainDeleteFlow,
     runFlowAssertResponse(loadFile(responseFilename, substitutions));
     DomainResource resource = reloadResourceByForeignKey();
     // Check that the domain is in the pending delete state.
-    assertAboutDomains().that(resource)
-        .hasStatusValue(StatusValue.PENDING_DELETE).and()
-        .hasDeletionTime(clock.nowUtc().plus(Registry.get("tld").getRedemptionGracePeriodLength())
-            .plus(Registry.get("tld").getPendingDeleteLength())).and()
-        .hasDeletePollMessage().and()
-        .hasExactlyStatusValues(StatusValue.INACTIVE, StatusValue.PENDING_DELETE).and()
+    assertAboutDomains()
+        .that(resource)
+        .hasStatusValue(StatusValue.PENDING_DELETE)
+        .and()
+        .hasDeletionTime(
+            clock
+                .nowUtc()
+                .plus(Registry.get("tld").getRedemptionGracePeriodLength())
+                .plus(Registry.get("tld").getPendingDeleteLength()))
+        .and()
+        .hasDeletePollMessage()
+        .and()
+        .hasExactlyStatusValues(StatusValue.INACTIVE, StatusValue.PENDING_DELETE)
+        .and()
         .hasOneHistoryEntryEachOfTypes(DOMAIN_CREATE, DOMAIN_DELETE);
     // We leave the original expiration time unchanged; if the expiration time is before the
     // deletion time, that means once it passes the domain will experience a "phantom autorenew"
@@ -355,17 +369,17 @@ public class DomainDeleteFlowTest extends ResourceFlowTestCase<DomainDeleteFlow,
     assertAutorenewClosedAndCancellationCreatedFor(
         renewBillingEvent, getOnlyHistoryEntryOfType(resource, DOMAIN_DELETE));
     // All existing grace periods should be gone, and a new REDEMPTION one should be added.
-    assertThat(resource.getGracePeriods()).containsExactly(
-        GracePeriod.create(
-            GracePeriodStatus.REDEMPTION,
-            clock.nowUtc().plus(Registry.get("tld").getRedemptionGracePeriodLength()),
-            "TheRegistrar",
-            null));
+    assertThat(resource.getGracePeriods())
+        .containsExactly(
+            GracePeriod.create(
+                GracePeriodStatus.REDEMPTION,
+                clock.nowUtc().plus(Registry.get("tld").getRedemptionGracePeriodLength()),
+                "TheRegistrar",
+                null));
     // There should be a future poll message at the deletion time. The previous autorenew poll
     // message should now be deleted.
     DateTime deletionTime = resource.getDeletionTime();
-    assertThat(getPollMessages("TheRegistrar", deletionTime.minusMinutes(1)))
-        .isEmpty();
+    assertThat(getPollMessages("TheRegistrar", deletionTime.minusMinutes(1))).isEmpty();
     assertThat(getPollMessages("TheRegistrar", deletionTime)).hasSize(1);
     assertThat(resource.getDeletePollMessage())
         .isEqualTo(Key.create(getOnlyPollMessage("TheRegistrar")));
@@ -401,7 +415,11 @@ public class DomainDeleteFlowTest extends ResourceFlowTestCase<DomainDeleteFlow,
     // Modify the autorenew poll message so that it has unacked messages in the past. This should
     // prevent it from being deleted when the domain is deleted.
     persistResource(
-        ofy().load().key(reloadResourceByForeignKey().getAutorenewPollMessage()).now().asBuilder()
+        ofy()
+            .load()
+            .key(reloadResourceByForeignKey().getAutorenewPollMessage())
+            .now()
+            .asBuilder()
             .setEventTime(A_MONTH_FROM_NOW.minusYears(3))
             .build());
     clock.advanceOneMilli();
@@ -409,8 +427,7 @@ public class DomainDeleteFlowTest extends ResourceFlowTestCase<DomainDeleteFlow,
     // There should now be two poll messages; one for the delete of the domain (in the future), and
     // another for the unacked autorenew messages.
     DateTime deletionTime = reloadResourceByForeignKey().getDeletionTime();
-    assertThat(getPollMessages("TheRegistrar", deletionTime.minusMinutes(1)))
-        .hasSize(1);
+    assertThat(getPollMessages("TheRegistrar", deletionTime.minusMinutes(1))).hasSize(1);
     assertThat(getPollMessages("TheRegistrar", deletionTime)).hasSize(2);
   }
 
@@ -467,8 +484,12 @@ public class DomainDeleteFlowTest extends ResourceFlowTestCase<DomainDeleteFlow,
     persistResource(
         Registry.get("tld")
             .asBuilder()
-            .setRenewBillingCostTransitions(ImmutableSortedMap.of(
-                START_OF_TIME, Money.of(USD, 11), TIME_BEFORE_FLOW.minusDays(5), Money.of(USD, 20)))
+            .setRenewBillingCostTransitions(
+                ImmutableSortedMap.of(
+                    START_OF_TIME,
+                    Money.of(USD, 11),
+                    TIME_BEFORE_FLOW.minusDays(5),
+                    Money.of(USD, 20)))
             .build());
     setUpAutorenewGracePeriod();
     clock.advanceOneMilli();
@@ -481,8 +502,12 @@ public class DomainDeleteFlowTest extends ResourceFlowTestCase<DomainDeleteFlow,
     persistResource(
         Registry.get("tld")
             .asBuilder()
-            .setRenewBillingCostTransitions(ImmutableSortedMap.of(
-                START_OF_TIME, Money.of(USD, 11), TIME_BEFORE_FLOW.minusDays(5), Money.of(USD, 20)))
+            .setRenewBillingCostTransitions(
+                ImmutableSortedMap.of(
+                    START_OF_TIME,
+                    Money.of(USD, 11),
+                    TIME_BEFORE_FLOW.minusDays(5),
+                    Money.of(USD, 20)))
             .build());
     setUpAutorenewGracePeriod();
     clock.advanceOneMilli();
@@ -494,8 +519,12 @@ public class DomainDeleteFlowTest extends ResourceFlowTestCase<DomainDeleteFlow,
     persistResource(
         Registry.get("tld")
             .asBuilder()
-            .setRenewBillingCostTransitions(ImmutableSortedMap.of(
-                START_OF_TIME, Money.of(USD, 11), TIME_BEFORE_FLOW.minusDays(5), Money.of(USD, 20)))
+            .setRenewBillingCostTransitions(
+                ImmutableSortedMap.of(
+                    START_OF_TIME,
+                    Money.of(USD, 11),
+                    TIME_BEFORE_FLOW.minusDays(5),
+                    Money.of(USD, 20)))
             .build());
     setUpAutorenewGracePeriod();
     clock.advanceOneMilli();
@@ -524,21 +553,27 @@ public class DomainDeleteFlowTest extends ResourceFlowTestCase<DomainDeleteFlow,
     DomainResource domain = reloadResourceByForeignKey();
     // Check that the domain is in the pending delete state.
     // The PENDING_TRANSFER status should be gone.
-    assertAboutDomains().that(domain)
-        .hasExactlyStatusValues(StatusValue.INACTIVE, StatusValue.PENDING_DELETE).and()
-        .hasDeletionTime(clock.nowUtc().plus(Registry.get("tld").getRedemptionGracePeriodLength())
-            .plus(Registry.get("tld").getPendingDeleteLength())).and()
+    assertAboutDomains()
+        .that(domain)
+        .hasExactlyStatusValues(StatusValue.INACTIVE, StatusValue.PENDING_DELETE)
+        .and()
+        .hasDeletionTime(
+            clock
+                .nowUtc()
+                .plus(Registry.get("tld").getRedemptionGracePeriodLength())
+                .plus(Registry.get("tld").getPendingDeleteLength()))
+        .and()
         .hasOneHistoryEntryEachOfTypes(DOMAIN_CREATE, DOMAIN_TRANSFER_REQUEST, DOMAIN_DELETE);
     // All existing grace periods should be gone, and a new REDEMPTION one should be added.
-    assertThat(domain.getGracePeriods()).containsExactly(
-        GracePeriod.create(
-            GracePeriodStatus.REDEMPTION,
-            clock.nowUtc().plus(Registry.get("tld").getRedemptionGracePeriodLength()),
-            "TheRegistrar",
-            null));
+    assertThat(domain.getGracePeriods())
+        .containsExactly(
+            GracePeriod.create(
+                GracePeriodStatus.REDEMPTION,
+                clock.nowUtc().plus(Registry.get("tld").getRedemptionGracePeriodLength()),
+                "TheRegistrar",
+                null));
     // The poll message (in the future) to the losing registrar for implicit ack should be gone.
-    assertThat(getPollMessages("TheRegistrar", clock.nowUtc().plusMonths(1)))
-        .isEmpty();
+    assertThat(getPollMessages("TheRegistrar", clock.nowUtc().plusMonths(1))).isEmpty();
     // The poll message in the future to the gaining registrar should be gone too, but there
     // should be one at the current time to the gaining registrar.
     PollMessage gainingPollMessage = getOnlyPollMessage("NewRegistrar");
@@ -564,15 +599,15 @@ public class DomainDeleteFlowTest extends ResourceFlowTestCase<DomainDeleteFlow,
     assertThat(panData.getActionResult()).isFalse();
     // There should be a future poll message to the losing registrar at the deletion time.
     DateTime deletionTime = domain.getDeletionTime();
-    assertThat(getPollMessages("TheRegistrar", deletionTime.minusMinutes(1)))
-        .isEmpty();
+    assertThat(getPollMessages("TheRegistrar", deletionTime.minusMinutes(1))).isEmpty();
     assertThat(getPollMessages("TheRegistrar", deletionTime)).hasSize(1);
     assertOnlyBillingEventIsClosedAutorenew("TheRegistrar");
     // The domain TransferData should reflect the cancelled transfer as we expect, with
     // all the speculative server-approve fields nulled out.
     assertThat(domain.getTransferData())
         .isEqualTo(
-            oldTransferData.copyConstantFieldsToBuilder()
+            oldTransferData
+                .copyConstantFieldsToBuilder()
                 .setTransferStatus(TransferStatus.SERVER_CANCELLED)
                 .setPendingTransferExpirationTime(clock.nowUtc())
                 .build());
@@ -581,10 +616,10 @@ public class DomainDeleteFlowTest extends ResourceFlowTestCase<DomainDeleteFlow,
     assertThat(ofy().load().key(oldTransferData.getServerApproveAutorenewEvent()).now()).isNull();
     assertThat(ofy().load().key(oldTransferData.getServerApproveAutorenewPollMessage()).now())
         .isNull();
-    assertThat(oldTransferData.getServerApproveEntities()).isNotEmpty();  // Just a sanity check.
-    assertThat(ofy().load()
-        .keys(oldTransferData.getServerApproveEntities().toArray(new Key<?>[]{})))
-            .isEmpty();
+    assertThat(oldTransferData.getServerApproveEntities()).isNotEmpty(); // Just a sanity check.
+    assertThat(
+            ofy().load().keys(oldTransferData.getServerApproveEntities().toArray(new Key<?>[] {})))
+        .isEmpty();
   }
 
   @Test
@@ -616,15 +651,15 @@ public class DomainDeleteFlowTest extends ResourceFlowTestCase<DomainDeleteFlow,
     runFlowAssertResponse(loadFile("domain_delete_response.xml"));
     assertDnsTasksEnqueued("example.tld");
     assertAutorenewClosedAndCancellationCreatedFor(
-        graceBillingEvent,
-        getOnlyHistoryEntryOfType(domain, DOMAIN_DELETE));
+        graceBillingEvent, getOnlyHistoryEntryOfType(domain, DOMAIN_DELETE));
   }
 
   @Test
   public void testSuccess_deletedSubordinateDomain() throws Exception {
     setUpSuccessfulTest();
     persistResource(
-        newHostResource("ns1." + getUniqueIdFromCommand()).asBuilder()
+        newHostResource("ns1." + getUniqueIdFromCommand())
+            .asBuilder()
             .setSuperordinateDomain(Key.create(reloadResourceByForeignKey()))
             .setDeletionTime(clock.nowUtc().minusDays(1))
             .build());
@@ -638,7 +673,8 @@ public class DomainDeleteFlowTest extends ResourceFlowTestCase<DomainDeleteFlow,
   public void testFailure_predelegation() throws Exception {
     createTld("tld", TldState.PREDELEGATION);
     setUpSuccessfulTest();
-    assertThrows(BadCommandForRegistryPhaseException.class, this::runFlow);
+    EppException thrown = expectThrows(BadCommandForRegistryPhaseException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -668,21 +704,28 @@ public class DomainDeleteFlowTest extends ResourceFlowTestCase<DomainDeleteFlow,
   @Test
   public void testFailure_hasSubordinateHosts() throws Exception {
     DomainResource domain = persistActiveDomain(getUniqueIdFromCommand());
-    HostResource subordinateHost = persistResource(
-        newHostResource("ns1." + getUniqueIdFromCommand()).asBuilder()
-            .setSuperordinateDomain(Key.create(reloadResourceByForeignKey()))
-            .build());
-    domain = persistResource(domain.asBuilder()
-        .addSubordinateHost(subordinateHost.getFullyQualifiedHostName())
-        .build());
-    assertThrows(DomainToDeleteHasHostsException.class, this::runFlow);
+    HostResource subordinateHost =
+        persistResource(
+            newHostResource("ns1." + getUniqueIdFromCommand())
+                .asBuilder()
+                .setSuperordinateDomain(Key.create(reloadResourceByForeignKey()))
+                .build());
+    domain =
+        persistResource(
+            domain
+                .asBuilder()
+                .addSubordinateHost(subordinateHost.getFullyQualifiedHostName())
+                .build());
+    EppException thrown = expectThrows(DomainToDeleteHasHostsException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_unauthorizedClient() throws Exception {
     sessionMetadata.setClientId("NewRegistrar");
     persistActiveDomain(getUniqueIdFromCommand());
-    assertThrows(ResourceNotOwnedException.class, this::runFlow);
+    EppException thrown = expectThrows(ResourceNotOwnedException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -699,7 +742,8 @@ public class DomainDeleteFlowTest extends ResourceFlowTestCase<DomainDeleteFlow,
     setUpSuccessfulTest();
     persistResource(
         loadRegistrar("TheRegistrar").asBuilder().setAllowedTlds(ImmutableSet.of()).build());
-    assertThrows(NotAuthorizedForTldException.class, this::runFlow);
+    EppException thrown = expectThrows(NotAuthorizedForTldException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -714,9 +758,11 @@ public class DomainDeleteFlowTest extends ResourceFlowTestCase<DomainDeleteFlow,
 
   @Test
   public void testFailure_clientDeleteProhibited() throws Exception {
-    persistResource(newDomainResource(getUniqueIdFromCommand()).asBuilder()
-        .addStatusValue(StatusValue.CLIENT_DELETE_PROHIBITED)
-        .build());
+    persistResource(
+        newDomainResource(getUniqueIdFromCommand())
+            .asBuilder()
+            .addStatusValue(StatusValue.CLIENT_DELETE_PROHIBITED)
+            .build());
     ResourceStatusProhibitsOperationException thrown =
         expectThrows(ResourceStatusProhibitsOperationException.class, this::runFlow);
     assertThat(thrown).hasMessageThat().contains("clientDeleteProhibited");
@@ -724,9 +770,11 @@ public class DomainDeleteFlowTest extends ResourceFlowTestCase<DomainDeleteFlow,
 
   @Test
   public void testFailure_serverDeleteProhibited() throws Exception {
-    persistResource(newDomainResource(getUniqueIdFromCommand()).asBuilder()
-        .addStatusValue(StatusValue.SERVER_DELETE_PROHIBITED)
-        .build());
+    persistResource(
+        newDomainResource(getUniqueIdFromCommand())
+            .asBuilder()
+            .addStatusValue(StatusValue.SERVER_DELETE_PROHIBITED)
+            .build());
     ResourceStatusProhibitsOperationException thrown =
         expectThrows(ResourceStatusProhibitsOperationException.class, this::runFlow);
     assertThat(thrown).hasMessageThat().contains("serverDeleteProhibited");
@@ -734,9 +782,11 @@ public class DomainDeleteFlowTest extends ResourceFlowTestCase<DomainDeleteFlow,
 
   @Test
   public void testFailure_pendingDelete() throws Exception {
-    persistResource(newDomainResource(getUniqueIdFromCommand()).asBuilder()
-        .addStatusValue(StatusValue.PENDING_DELETE)
-        .build());
+    persistResource(
+        newDomainResource(getUniqueIdFromCommand())
+            .asBuilder()
+            .addStatusValue(StatusValue.PENDING_DELETE)
+            .build());
     ResourceStatusProhibitsOperationException thrown =
         expectThrows(ResourceStatusProhibitsOperationException.class, this::runFlow);
     assertThat(thrown).hasMessageThat().contains("pendingDelete");
@@ -749,12 +799,15 @@ public class DomainDeleteFlowTest extends ResourceFlowTestCase<DomainDeleteFlow,
     setUpSuccessfulTest();
     clock.advanceOneMilli();
     runFlow();
-    assertAboutDomains().that(reloadResourceByForeignKey())
+    assertAboutDomains()
+        .that(reloadResourceByForeignKey())
         .hasOneHistoryEntryEachOfTypes(DOMAIN_CREATE, DOMAIN_DELETE);
     assertAboutHistoryEntries()
         .that(getOnlyHistoryEntryOfType(domain, DOMAIN_DELETE))
-        .hasType(DOMAIN_DELETE).and()
-        .hasMetadataReason("domain-delete-test").and()
+        .hasType(DOMAIN_DELETE)
+        .and()
+        .hasMetadataReason("domain-delete-test")
+        .and()
         .hasMetadataRequestedByRegistrar(false);
   }
 
@@ -762,7 +815,8 @@ public class DomainDeleteFlowTest extends ResourceFlowTestCase<DomainDeleteFlow,
   public void testFailure_metadataNotFromTool() throws Exception {
     setEppInput("domain_delete_metadata.xml");
     persistResource(newDomainResource(getUniqueIdFromCommand()));
-    assertThrows(OnlyToolCanPassMetadataException.class, this::runFlow);
+    EppException thrown = expectThrows(OnlyToolCanPassMetadataException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
diff --git a/javatests/google/registry/flows/domain/DomainInfoFlowTest.java b/javatests/google/registry/flows/domain/DomainInfoFlowTest.java
index 11b49c870..21da8ef62 100644
--- a/javatests/google/registry/flows/domain/DomainInfoFlowTest.java
+++ b/javatests/google/registry/flows/domain/DomainInfoFlowTest.java
@@ -23,13 +23,14 @@ import static google.registry.testing.DatastoreHelper.newDomainResource;
 import static google.registry.testing.DatastoreHelper.persistActiveContact;
 import static google.registry.testing.DatastoreHelper.persistActiveHost;
 import static google.registry.testing.DatastoreHelper.persistResource;
-import static google.registry.testing.JUnitBackports.assertThrows;
+import static google.registry.testing.EppExceptionSubject.assertAboutEppExceptions;
 import static google.registry.testing.JUnitBackports.expectThrows;
 
 import com.google.common.base.Predicates;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import com.googlecode.objectify.Key;
+import google.registry.flows.EppException;
 import google.registry.flows.ResourceFlowTestCase;
 import google.registry.flows.ResourceFlowUtils.BadAuthInfoForResourceException;
 import google.registry.flows.ResourceFlowUtils.ResourceDoesNotExistException;
@@ -73,8 +74,7 @@ public class DomainInfoFlowTest extends ResourceFlowTestCase<DomainInfoFlow, Dom
     sessionMetadata.setClientId("NewRegistrar");
     clock.setTo(DateTime.parse("2005-03-03T22:00:00.000Z"));
     createTld("tld");
-    persistResource(
-        AppEngineRule.makeRegistrar1().asBuilder().setClientId("ClientZ").build());
+    persistResource(AppEngineRule.makeRegistrar1().asBuilder().setClientId("ClientZ").build());
   }
 
   private void persistTestEntities(String domainName, boolean inactive) {
@@ -82,40 +82,47 @@ public class DomainInfoFlowTest extends ResourceFlowTestCase<DomainInfoFlow, Dom
     contact = persistActiveContact("sh8013");
     host1 = persistActiveHost("ns1.example.tld");
     host2 = persistActiveHost("ns1.example.net");
-    domain = persistResource(new DomainResource.Builder()
-        .setFullyQualifiedDomainName(domainName)
-        .setRepoId("2FF-TLD")
-        .setPersistedCurrentSponsorClientId("NewRegistrar")
-        .setCreationClientId("TheRegistrar")
-        .setLastEppUpdateClientId("NewRegistrar")
-        .setCreationTimeForTest(DateTime.parse("1999-04-03T22:00:00.0Z"))
-        .setLastEppUpdateTime(DateTime.parse("1999-12-03T09:00:00.0Z"))
-        .setLastTransferTime(DateTime.parse("2000-04-08T09:00:00.0Z"))
-        .setRegistrationExpirationTime(DateTime.parse("2005-04-03T22:00:00.0Z"))
-        .setRegistrant(Key.create(registrant))
-        .setContacts(ImmutableSet.of(
-            DesignatedContact.create(Type.ADMIN, Key.create(contact)),
-            DesignatedContact.create(Type.TECH, Key.create(contact))))
-        .setNameservers(inactive ? null : ImmutableSet.of(Key.create(host1), Key.create(host2)))
-        .setAuthInfo(DomainAuthInfo.create(PasswordAuth.create("2fooBAR")))
-        .build());
+    domain =
+        persistResource(
+            new DomainResource.Builder()
+                .setFullyQualifiedDomainName(domainName)
+                .setRepoId("2FF-TLD")
+                .setPersistedCurrentSponsorClientId("NewRegistrar")
+                .setCreationClientId("TheRegistrar")
+                .setLastEppUpdateClientId("NewRegistrar")
+                .setCreationTimeForTest(DateTime.parse("1999-04-03T22:00:00.0Z"))
+                .setLastEppUpdateTime(DateTime.parse("1999-12-03T09:00:00.0Z"))
+                .setLastTransferTime(DateTime.parse("2000-04-08T09:00:00.0Z"))
+                .setRegistrationExpirationTime(DateTime.parse("2005-04-03T22:00:00.0Z"))
+                .setRegistrant(Key.create(registrant))
+                .setContacts(
+                    ImmutableSet.of(
+                        DesignatedContact.create(Type.ADMIN, Key.create(contact)),
+                        DesignatedContact.create(Type.TECH, Key.create(contact))))
+                .setNameservers(
+                    inactive ? null : ImmutableSet.of(Key.create(host1), Key.create(host2)))
+                .setAuthInfo(DomainAuthInfo.create(PasswordAuth.create("2fooBAR")))
+                .build());
     // Set the superordinate domain of ns1.example.com to example.com. In reality, this would have
     // happened in the flow that created it, but here we just overwrite it in Datastore.
-    host1 = persistResource(
-        host1.asBuilder().setSuperordinateDomain(Key.create(domain)).build());
+    host1 = persistResource(host1.asBuilder().setSuperordinateDomain(Key.create(domain)).build());
     // Create a subordinate host that is not delegated to by anyone.
-    host3 = persistResource(
-        new HostResource.Builder()
-            .setFullyQualifiedHostName("ns2.example.tld")
-            .setRepoId("3FF-TLD")
-            .setSuperordinateDomain(Key.create(domain))
-            .build());
+    host3 =
+        persistResource(
+            new HostResource.Builder()
+                .setFullyQualifiedHostName("ns2.example.tld")
+                .setRepoId("3FF-TLD")
+                .setSuperordinateDomain(Key.create(domain))
+                .build());
     // Add the subordinate host keys to the existing domain.
-    domain = persistResource(domain.asBuilder()
-        .setSubordinateHosts(ImmutableSet.of(
-            host1.getFullyQualifiedHostName(),
-            host3.getFullyQualifiedHostName()))
-        .build());
+    domain =
+        persistResource(
+            domain
+                .asBuilder()
+                .setSubordinateHosts(
+                    ImmutableSet.of(
+                        host1.getFullyQualifiedHostName(), host3.getFullyQualifiedHostName()))
+                .build());
   }
 
   private void persistTestEntities(boolean inactive) {
@@ -239,11 +246,15 @@ public class DomainInfoFlowTest extends ResourceFlowTestCase<DomainInfoFlow, Dom
   public void testSuccess_secDns() throws Exception {
     persistTestEntities(false);
     // Add the dsData to the saved resource and change the nameservers to match the sample xml.
-    persistResource(domain.asBuilder()
-        .setDsData(ImmutableSet.of(DelegationSignerData.create(
-            12345, 3, 1, base16().decode("49FD46E6C4B45C55D4AC"))))
-        .setNameservers(ImmutableSet.of(Key.create(host1), Key.create(host3)))
-        .build());
+    persistResource(
+        domain
+            .asBuilder()
+            .setDsData(
+                ImmutableSet.of(
+                    DelegationSignerData.create(
+                        12345, 3, 1, base16().decode("49FD46E6C4B45C55D4AC"))))
+            .setNameservers(ImmutableSet.of(Key.create(host1), Key.create(host3)))
+            .build());
     doSuccessfulTest("domain_info_response_dsdata.xml", false);
   }
 
@@ -251,16 +262,18 @@ public class DomainInfoFlowTest extends ResourceFlowTestCase<DomainInfoFlow, Dom
     persistTestEntities(false);
     // Add the grace period to the saved resource, and change a few other fields to match the sample
     // xml.
-    persistResource(domain.asBuilder()
-        .addGracePeriod(
-            GracePeriod.create(gracePeriodStatus, clock.nowUtc().plusDays(1), "foo", null))
-        .setCreationClientId("NewRegistrar")
-        .setCreationTimeForTest(DateTime.parse("2003-11-26T22:00:00.0Z"))
-        .setRegistrationExpirationTime(DateTime.parse("2005-11-26T22:00:00.0Z"))
-        .setLastTransferTime(null)
-        .setLastEppUpdateTime(null)
-        .setLastEppUpdateClientId(null)
-        .build());
+    persistResource(
+        domain
+            .asBuilder()
+            .addGracePeriod(
+                GracePeriod.create(gracePeriodStatus, clock.nowUtc().plusDays(1), "foo", null))
+            .setCreationClientId("NewRegistrar")
+            .setCreationTimeForTest(DateTime.parse("2003-11-26T22:00:00.0Z"))
+            .setRegistrationExpirationTime(DateTime.parse("2005-11-26T22:00:00.0Z"))
+            .setLastTransferTime(null)
+            .setLastEppUpdateTime(null)
+            .setLastEppUpdateClientId(null)
+            .build());
     doSuccessfulTest("domain_info_response_addperiod.xml", false);
   }
 
@@ -278,13 +291,16 @@ public class DomainInfoFlowTest extends ResourceFlowTestCase<DomainInfoFlow, Dom
   public void testSuccess_autoRenewGracePeriod() throws Exception {
     persistTestEntities(false);
     // Add an AUTO_RENEW grace period to the saved resource.
-    persistResource(domain.asBuilder()
-        .addGracePeriod(GracePeriod.createForRecurring(
-            GracePeriodStatus.AUTO_RENEW,
-            clock.nowUtc().plusDays(1),
-            "foo",
-            Key.create(Recurring.class, 12345)))
-        .build());
+    persistResource(
+        domain
+            .asBuilder()
+            .addGracePeriod(
+                GracePeriod.createForRecurring(
+                    GracePeriodStatus.AUTO_RENEW,
+                    clock.nowUtc().plusDays(1),
+                    "foo",
+                    Key.create(Recurring.class, 12345)))
+            .build());
     doSuccessfulTest("domain_info_response_autorenewperiod.xml", false);
   }
 
@@ -293,11 +309,14 @@ public class DomainInfoFlowTest extends ResourceFlowTestCase<DomainInfoFlow, Dom
     persistTestEntities(false);
     // Add an REDEMPTION grace period to the saved resource, and change a few other fields to match
     // the sample xml.
-    persistResource(domain.asBuilder()
-        .addGracePeriod(GracePeriod.create(
-            GracePeriodStatus.REDEMPTION, clock.nowUtc().plusDays(1), "foo", null))
-        .setStatusValues(ImmutableSet.of(StatusValue.PENDING_DELETE))
-        .build());
+    persistResource(
+        domain
+            .asBuilder()
+            .addGracePeriod(
+                GracePeriod.create(
+                    GracePeriodStatus.REDEMPTION, clock.nowUtc().plusDays(1), "foo", null))
+            .setStatusValues(ImmutableSet.of(StatusValue.PENDING_DELETE))
+            .build());
     doSuccessfulTest("domain_info_response_redemptionperiod.xml", false);
   }
 
@@ -305,10 +324,13 @@ public class DomainInfoFlowTest extends ResourceFlowTestCase<DomainInfoFlow, Dom
   public void testSuccess_renewGracePeriod() throws Exception {
     persistTestEntities(false);
     // Add an RENEW grace period to the saved resource.
-    persistResource(domain.asBuilder()
-        .addGracePeriod(
-            GracePeriod.create(GracePeriodStatus.RENEW, clock.nowUtc().plusDays(1), "foo", null))
-        .build());
+    persistResource(
+        domain
+            .asBuilder()
+            .addGracePeriod(
+                GracePeriod.create(
+                    GracePeriodStatus.RENEW, clock.nowUtc().plusDays(1), "foo", null))
+            .build());
     doSuccessfulTest("domain_info_response_renewperiod.xml", false);
   }
 
@@ -316,12 +338,16 @@ public class DomainInfoFlowTest extends ResourceFlowTestCase<DomainInfoFlow, Dom
   public void testSuccess_multipleRenewGracePeriods() throws Exception {
     persistTestEntities(false);
     // Add multiple RENEW grace periods to the saved resource.
-    persistResource(domain.asBuilder()
-        .addGracePeriod(
-            GracePeriod.create(GracePeriodStatus.RENEW, clock.nowUtc().plusDays(1), "foo", null))
-        .addGracePeriod(
-            GracePeriod.create(GracePeriodStatus.RENEW, clock.nowUtc().plusDays(2), "foo", null))
-        .build());
+    persistResource(
+        domain
+            .asBuilder()
+            .addGracePeriod(
+                GracePeriod.create(
+                    GracePeriodStatus.RENEW, clock.nowUtc().plusDays(1), "foo", null))
+            .addGracePeriod(
+                GracePeriod.create(
+                    GracePeriodStatus.RENEW, clock.nowUtc().plusDays(2), "foo", null))
+            .build());
     doSuccessfulTest("domain_info_response_renewperiod.xml", false);
   }
 
@@ -329,10 +355,13 @@ public class DomainInfoFlowTest extends ResourceFlowTestCase<DomainInfoFlow, Dom
   public void testSuccess_transferGracePeriod() throws Exception {
     persistTestEntities(false);
     // Add an TRANSFER grace period to the saved resource.
-    persistResource(domain.asBuilder()
-        .addGracePeriod(GracePeriod.create(
-            GracePeriodStatus.TRANSFER, clock.nowUtc().plusDays(1), "foo", null))
-        .build());
+    persistResource(
+        domain
+            .asBuilder()
+            .addGracePeriod(
+                GracePeriod.create(
+                    GracePeriodStatus.TRANSFER, clock.nowUtc().plusDays(1), "foo", null))
+            .build());
     doSuccessfulTest("domain_info_response_transferperiod.xml", false);
   }
 
@@ -341,9 +370,8 @@ public class DomainInfoFlowTest extends ResourceFlowTestCase<DomainInfoFlow, Dom
     persistTestEntities(false);
     // Set the domain to be pending delete with no grace period, which will cause an RGP status of
     // pending delete to show up, too.
-    persistResource(domain.asBuilder()
-        .setStatusValues(ImmutableSet.of(StatusValue.PENDING_DELETE))
-        .build());
+    persistResource(
+        domain.asBuilder().setStatusValues(ImmutableSet.of(StatusValue.PENDING_DELETE)).build());
     doSuccessfulTest("domain_info_response_pendingdelete.xml", false);
   }
 
@@ -351,12 +379,15 @@ public class DomainInfoFlowTest extends ResourceFlowTestCase<DomainInfoFlow, Dom
   public void testSuccess_stackedAddRenewGracePeriods() throws Exception {
     persistTestEntities(false);
     // Add both an ADD and RENEW grace period, both which should show up in the RGP status.
-    persistResource(domain.asBuilder()
-        .addGracePeriod(
-            GracePeriod.create(GracePeriodStatus.ADD, clock.nowUtc().plusDays(1), "foo", null))
-        .addGracePeriod(
-            GracePeriod.create(GracePeriodStatus.RENEW, clock.nowUtc().plusDays(2), "foo", null))
-        .build());
+    persistResource(
+        domain
+            .asBuilder()
+            .addGracePeriod(
+                GracePeriod.create(GracePeriodStatus.ADD, clock.nowUtc().plusDays(1), "foo", null))
+            .addGracePeriod(
+                GracePeriod.create(
+                    GracePeriodStatus.RENEW, clock.nowUtc().plusDays(2), "foo", null))
+            .build());
     doSuccessfulTest("domain_info_response_stackedaddrenewperiod.xml", false);
   }
 
@@ -364,12 +395,16 @@ public class DomainInfoFlowTest extends ResourceFlowTestCase<DomainInfoFlow, Dom
   public void testSuccess_secDnsAndAddGracePeriod() throws Exception {
     persistTestEntities(false);
     // Add both an ADD grace period and SecDNS data.
-    persistResource(domain.asBuilder()
-        .addGracePeriod(
-            GracePeriod.create(GracePeriodStatus.ADD, clock.nowUtc().plusDays(1), "foo", null))
-        .setDsData(ImmutableSet.of(DelegationSignerData.create(
-            12345, 3, 1, base16().decode("49FD46E6C4B45C55D4AC"))))
-        .build());
+    persistResource(
+        domain
+            .asBuilder()
+            .addGracePeriod(
+                GracePeriod.create(GracePeriodStatus.ADD, clock.nowUtc().plusDays(1), "foo", null))
+            .setDsData(
+                ImmutableSet.of(
+                    DelegationSignerData.create(
+                        12345, 3, 1, base16().decode("49FD46E6C4B45C55D4AC"))))
+            .build());
     doSuccessfulTest("domain_info_response_dsdata_addperiod.xml", false);
   }
 
@@ -382,9 +417,11 @@ public class DomainInfoFlowTest extends ResourceFlowTestCase<DomainInfoFlow, Dom
 
   @Test
   public void testFailure_existedButWasDeleted() throws Exception {
-    persistResource(newDomainResource("example.tld").asBuilder()
-        .setDeletionTime(clock.nowUtc().minusDays(1))
-        .build());
+    persistResource(
+        newDomainResource("example.tld")
+            .asBuilder()
+            .setDeletionTime(clock.nowUtc().minusDays(1))
+            .build());
     ResourceDoesNotExistException thrown =
         expectThrows(ResourceDoesNotExistException.class, this::runFlow);
     assertThat(thrown).hasMessageThat().contains(String.format("(%s)", getUniqueIdFromCommand()));
@@ -394,81 +431,99 @@ public class DomainInfoFlowTest extends ResourceFlowTestCase<DomainInfoFlow, Dom
   public void testFailure_differentRegistrarWrongAuthInfo() throws Exception {
     persistTestEntities(false);
     // Change the password of the domain so that it does not match the file.
-    persistResource(domain.asBuilder()
-        .setAuthInfo(DomainAuthInfo.create(PasswordAuth.create("diffpw")))
-        .build());
+    persistResource(
+        domain
+            .asBuilder()
+            .setAuthInfo(DomainAuthInfo.create(PasswordAuth.create("diffpw")))
+            .build());
     sessionMetadata.setClientId("ClientZ");
     setEppInput("domain_info_with_auth.xml");
-    assertThrows(BadAuthInfoForResourceException.class, this::runFlow);
+    EppException thrown = expectThrows(BadAuthInfoForResourceException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_wrongAuthInfo() throws Exception {
     persistTestEntities(false);
     // Change the password of the domain so that it does not match the file.
-    persistResource(domain.asBuilder()
-        .setAuthInfo(DomainAuthInfo.create(PasswordAuth.create("diffpw")))
-        .build());
+    persistResource(
+        domain
+            .asBuilder()
+            .setAuthInfo(DomainAuthInfo.create(PasswordAuth.create("diffpw")))
+            .build());
     setEppInput("domain_info_with_auth.xml");
-    assertThrows(BadAuthInfoForResourceException.class, this::runFlow);
+    EppException thrown = expectThrows(BadAuthInfoForResourceException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_differentRegistrarWrongRegistrantAuthInfo() throws Exception {
     persistTestEntities(false);
     // Change the password of the registrant so that it does not match the file.
-    registrant = persistResource(
-        registrant.asBuilder()
-            .setAuthInfo(ContactAuthInfo.create(PasswordAuth.create("diffpw")))
-            .build());
+    registrant =
+        persistResource(
+            registrant
+                .asBuilder()
+                .setAuthInfo(ContactAuthInfo.create(PasswordAuth.create("diffpw")))
+                .build());
     sessionMetadata.setClientId("ClientZ");
     setEppInput("domain_info_with_contact_auth.xml");
     // Replace the ROID in the xml file with the one for our registrant.
     eppLoader.replaceAll("JD1234-REP", registrant.getRepoId());
-    assertThrows(BadAuthInfoForResourceException.class, this::runFlow);
+    EppException thrown = expectThrows(BadAuthInfoForResourceException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_wrongRegistrantAuthInfo() throws Exception {
     persistTestEntities(false);
     // Change the password of the registrant so that it does not match the file.
-    registrant = persistResource(
-        registrant.asBuilder()
-            .setAuthInfo(ContactAuthInfo.create(PasswordAuth.create("diffpw")))
-            .build());
+    registrant =
+        persistResource(
+            registrant
+                .asBuilder()
+                .setAuthInfo(ContactAuthInfo.create(PasswordAuth.create("diffpw")))
+                .build());
     setEppInput("domain_info_with_contact_auth.xml");
     // Replace the ROID in the xml file with the one for our registrant.
     eppLoader.replaceAll("JD1234-REP", registrant.getRepoId());
-    assertThrows(BadAuthInfoForResourceException.class, this::runFlow);
+    EppException thrown = expectThrows(BadAuthInfoForResourceException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_differentRegistrarWrongContactAuthInfo() throws Exception {
     persistTestEntities(false);
     // Change the password of the contact so that it does not match the file.
-    contact = persistResource(
-        contact.asBuilder()
-            .setAuthInfo(ContactAuthInfo.create(PasswordAuth.create("diffpw")))
-            .build());
+    contact =
+        persistResource(
+            contact
+                .asBuilder()
+                .setAuthInfo(ContactAuthInfo.create(PasswordAuth.create("diffpw")))
+                .build());
     sessionMetadata.setClientId("ClientZ");
     setEppInput("domain_info_with_contact_auth.xml");
     // Replace the ROID in the xml file with the one for our contact.
     eppLoader.replaceAll("JD1234-REP", contact.getRepoId());
-    assertThrows(BadAuthInfoForResourceException.class, this::runFlow);
+    EppException thrown = expectThrows(BadAuthInfoForResourceException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_wrongContactAuthInfo() throws Exception {
     persistTestEntities(false);
     // Change the password of the contact so that it does not match the file.
-    contact = persistResource(
-        contact.asBuilder()
-            .setAuthInfo(ContactAuthInfo.create(PasswordAuth.create("diffpw")))
-            .build());
+    contact =
+        persistResource(
+            contact
+                .asBuilder()
+                .setAuthInfo(ContactAuthInfo.create(PasswordAuth.create("diffpw")))
+                .build());
     setEppInput("domain_info_with_contact_auth.xml");
     // Replace the ROID in the xml file with the one for our contact.
     eppLoader.replaceAll("JD1234-REP", contact.getRepoId());
-    assertThrows(BadAuthInfoForResourceException.class, this::runFlow);
+    EppException thrown = expectThrows(BadAuthInfoForResourceException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -479,7 +534,8 @@ public class DomainInfoFlowTest extends ResourceFlowTestCase<DomainInfoFlow, Dom
     setEppInput("domain_info_with_contact_auth.xml");
     // Replace the ROID in the xml file with the one for our unrelated contact.
     eppLoader.replaceAll("JD1234-REP", unrelatedContact.getRepoId());
-    assertThrows(BadAuthInfoForResourceException.class, this::runFlow);
+    EppException thrown = expectThrows(BadAuthInfoForResourceException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -489,12 +545,13 @@ public class DomainInfoFlowTest extends ResourceFlowTestCase<DomainInfoFlow, Dom
     setEppInput("domain_info_with_contact_auth.xml");
     // Replace the ROID in the xml file with the one for our unrelated contact.
     eppLoader.replaceAll("JD1234-REP", unrelatedContact.getRepoId());
-    assertThrows(BadAuthInfoForResourceException.class, this::runFlow);
+    EppException thrown = expectThrows(BadAuthInfoForResourceException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   /**
-   * Test create command. Fee extension version 6 is the only one which supports fee extensions
-   * on info commands and responses, so we don't need to test the other versions.
+   * Test create command. Fee extension version 6 is the only one which supports fee extensions on
+   * info commands and responses, so we don't need to test the other versions.
    */
   @Test
   public void testFeeExtension_createCommand() throws Exception {
@@ -568,7 +625,8 @@ public class DomainInfoFlowTest extends ResourceFlowTestCase<DomainInfoFlow, Dom
   public void testFeeExtension_wrongCurrency() throws Exception {
     setEppInput("domain_info_fee_create_euro.xml");
     persistTestEntities(false);
-    assertThrows(CurrencyUnitMismatchException.class, this::runFlow);
+    EppException thrown = expectThrows(CurrencyUnitMismatchException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   /** Test requesting a period that isn't in years. */
@@ -576,7 +634,8 @@ public class DomainInfoFlowTest extends ResourceFlowTestCase<DomainInfoFlow, Dom
   public void testFeeExtension_periodNotInYears() throws Exception {
     setEppInput("domain_info_fee_bad_period.xml");
     persistTestEntities(false);
-    assertThrows(BadPeriodUnitException.class, this::runFlow);
+    EppException thrown = expectThrows(BadPeriodUnitException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   /** Test a command that specifies a phase. */
@@ -584,7 +643,8 @@ public class DomainInfoFlowTest extends ResourceFlowTestCase<DomainInfoFlow, Dom
   public void testFeeExtension_commandPhase() throws Exception {
     setEppInput("domain_info_fee_command_phase.xml");
     persistTestEntities(false);
-    assertThrows(FeeChecksDontSupportPhasesException.class, this::runFlow);
+    EppException thrown = expectThrows(FeeChecksDontSupportPhasesException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   /** Test a command that specifies a subphase. */
@@ -592,7 +652,8 @@ public class DomainInfoFlowTest extends ResourceFlowTestCase<DomainInfoFlow, Dom
   public void testFeeExtension_commandSubphase() throws Exception {
     setEppInput("domain_info_fee_command_subphase.xml");
     persistTestEntities(false);
-    assertThrows(FeeChecksDontSupportPhasesException.class, this::runFlow);
+    EppException thrown = expectThrows(FeeChecksDontSupportPhasesException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   /** Test a restore for more than one year. */
@@ -600,7 +661,8 @@ public class DomainInfoFlowTest extends ResourceFlowTestCase<DomainInfoFlow, Dom
   public void testFeeExtension_multiyearRestore() throws Exception {
     setEppInput("domain_info_fee_multiyear_restore.xml");
     persistTestEntities(false);
-    assertThrows(RestoresAreAlwaysForOneYearException.class, this::runFlow);
+    EppException thrown = expectThrows(RestoresAreAlwaysForOneYearException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   /** Test a transfer for more than one year. */
@@ -608,7 +670,8 @@ public class DomainInfoFlowTest extends ResourceFlowTestCase<DomainInfoFlow, Dom
   public void testFeeExtension_multiyearTransfer() throws Exception {
     setEppInput("domain_info_fee_multiyear_transfer.xml");
     persistTestEntities(false);
-    assertThrows(TransfersAreAlwaysForOneYearException.class, this::runFlow);
+    EppException thrown = expectThrows(TransfersAreAlwaysForOneYearException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   /** Test that we load contacts and hosts as a batch rather than individually. */
diff --git a/javatests/google/registry/flows/domain/DomainRenewFlowTest.java b/javatests/google/registry/flows/domain/DomainRenewFlowTest.java
index f2c879d88..17002854e 100644
--- a/javatests/google/registry/flows/domain/DomainRenewFlowTest.java
+++ b/javatests/google/registry/flows/domain/DomainRenewFlowTest.java
@@ -26,8 +26,8 @@ import static google.registry.testing.DatastoreHelper.persistActiveDomain;
 import static google.registry.testing.DatastoreHelper.persistDeletedDomain;
 import static google.registry.testing.DatastoreHelper.persistResource;
 import static google.registry.testing.DomainResourceSubject.assertAboutDomains;
+import static google.registry.testing.EppExceptionSubject.assertAboutEppExceptions;
 import static google.registry.testing.HistoryEntrySubject.assertAboutHistoryEntries;
-import static google.registry.testing.JUnitBackports.assertThrows;
 import static google.registry.testing.JUnitBackports.expectThrows;
 import static google.registry.util.DateTimeUtils.END_OF_TIME;
 import static google.registry.util.DateTimeUtils.START_OF_TIME;
@@ -38,6 +38,7 @@ import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.ImmutableSortedMap;
 import com.googlecode.objectify.Key;
+import google.registry.flows.EppException;
 import google.registry.flows.ResourceFlowTestCase;
 import google.registry.flows.ResourceFlowUtils.ResourceDoesNotExistException;
 import google.registry.flows.ResourceFlowUtils.ResourceNotOwnedException;
@@ -94,36 +95,42 @@ public class DomainRenewFlowTest extends ResourceFlowTestCase<DomainRenewFlow, D
 
   private void persistDomain(StatusValue... statusValues) throws Exception {
     DomainResource domain = newDomainResource(getUniqueIdFromCommand());
-    HistoryEntry historyEntryDomainCreate = persistResource(
-        new HistoryEntry.Builder()
-            .setParent(domain)
-            .setType(HistoryEntry.Type.DOMAIN_CREATE)
-            .build());
-    BillingEvent.Recurring autorenewEvent = persistResource(
-        new BillingEvent.Recurring.Builder()
-            .setReason(Reason.RENEW)
-            .setFlags(ImmutableSet.of(Flag.AUTO_RENEW))
-            .setTargetId(getUniqueIdFromCommand())
-            .setClientId("TheRegistrar")
-            .setEventTime(expirationTime)
-            .setRecurrenceEndTime(END_OF_TIME)
-            .setParent(historyEntryDomainCreate)
-            .build());
-    PollMessage.Autorenew autorenewPollMessage = persistResource(
-        new PollMessage.Autorenew.Builder()
-            .setTargetId(getUniqueIdFromCommand())
-            .setClientId("TheRegistrar")
-            .setEventTime(expirationTime)
-            .setAutorenewEndTime(END_OF_TIME)
-            .setMsg("Domain was auto-renewed.")
-            .setParent(historyEntryDomainCreate)
-            .build());
-    domain = persistResource(domain.asBuilder()
-        .setRegistrationExpirationTime(expirationTime)
-        .setStatusValues(ImmutableSet.copyOf(statusValues))
-        .setAutorenewBillingEvent(Key.create(autorenewEvent))
-        .setAutorenewPollMessage(Key.create(autorenewPollMessage))
-        .build());
+    HistoryEntry historyEntryDomainCreate =
+        persistResource(
+            new HistoryEntry.Builder()
+                .setParent(domain)
+                .setType(HistoryEntry.Type.DOMAIN_CREATE)
+                .build());
+    BillingEvent.Recurring autorenewEvent =
+        persistResource(
+            new BillingEvent.Recurring.Builder()
+                .setReason(Reason.RENEW)
+                .setFlags(ImmutableSet.of(Flag.AUTO_RENEW))
+                .setTargetId(getUniqueIdFromCommand())
+                .setClientId("TheRegistrar")
+                .setEventTime(expirationTime)
+                .setRecurrenceEndTime(END_OF_TIME)
+                .setParent(historyEntryDomainCreate)
+                .build());
+    PollMessage.Autorenew autorenewPollMessage =
+        persistResource(
+            new PollMessage.Autorenew.Builder()
+                .setTargetId(getUniqueIdFromCommand())
+                .setClientId("TheRegistrar")
+                .setEventTime(expirationTime)
+                .setAutorenewEndTime(END_OF_TIME)
+                .setMsg("Domain was auto-renewed.")
+                .setParent(historyEntryDomainCreate)
+                .build());
+    domain =
+        persistResource(
+            domain
+                .asBuilder()
+                .setRegistrationExpirationTime(expirationTime)
+                .setStatusValues(ImmutableSet.copyOf(statusValues))
+                .setAutorenewBillingEvent(Key.create(autorenewEvent))
+                .setAutorenewPollMessage(Key.create(autorenewPollMessage))
+                .build());
     clock.advanceOneMilli();
   }
 
@@ -145,7 +152,8 @@ public class DomainRenewFlowTest extends ResourceFlowTestCase<DomainRenewFlow, D
       String responseFilename,
       int renewalYears,
       Map<String, String> substitutions,
-      Money totalRenewCost) throws Exception {
+      Money totalRenewCost)
+      throws Exception {
     assertTransactionalFlow(true);
     DateTime currentExpiration = reloadResourceByForeignKey().getRegistrationExpirationTime();
     DateTime newExpiration = currentExpiration.plusYears(renewalYears);
@@ -155,23 +163,26 @@ public class DomainRenewFlowTest extends ResourceFlowTestCase<DomainRenewFlow, D
         getOnlyHistoryEntryOfType(domain, HistoryEntry.Type.DOMAIN_RENEW);
     assertThat(ofy().load().key(domain.getAutorenewBillingEvent()).now().getEventTime())
         .isEqualTo(newExpiration);
-    assertAboutDomains().that(domain)
-        .isActiveAt(clock.nowUtc()).and()
-        .hasRegistrationExpirationTime(newExpiration).and()
+    assertAboutDomains()
+        .that(domain)
+        .isActiveAt(clock.nowUtc())
+        .and()
+        .hasRegistrationExpirationTime(newExpiration)
+        .and()
         .hasOneHistoryEntryEachOfTypes(
-            HistoryEntry.Type.DOMAIN_CREATE,
-            HistoryEntry.Type.DOMAIN_RENEW);
+            HistoryEntry.Type.DOMAIN_CREATE, HistoryEntry.Type.DOMAIN_RENEW);
     assertAboutHistoryEntries().that(historyEntryDomainRenew).hasPeriodYears(renewalYears);
-    BillingEvent.OneTime renewBillingEvent = new BillingEvent.OneTime.Builder()
-        .setReason(Reason.RENEW)
-        .setTargetId(getUniqueIdFromCommand())
-        .setClientId("TheRegistrar")
-        .setCost(totalRenewCost)
-        .setPeriodYears(renewalYears)
-        .setEventTime(clock.nowUtc())
-        .setBillingTime(clock.nowUtc().plus(Registry.get("tld").getRenewGracePeriodLength()))
-        .setParent(historyEntryDomainRenew)
-        .build();
+    BillingEvent.OneTime renewBillingEvent =
+        new BillingEvent.OneTime.Builder()
+            .setReason(Reason.RENEW)
+            .setTargetId(getUniqueIdFromCommand())
+            .setClientId("TheRegistrar")
+            .setCost(totalRenewCost)
+            .setPeriodYears(renewalYears)
+            .setEventTime(clock.nowUtc())
+            .setBillingTime(clock.nowUtc().plus(Registry.get("tld").getRenewGracePeriodLength()))
+            .setParent(historyEntryDomainRenew)
+            .build();
     assertBillingEvents(
         renewBillingEvent,
         new BillingEvent.Recurring.Builder()
@@ -293,63 +304,72 @@ public class DomainRenewFlowTest extends ResourceFlowTestCase<DomainRenewFlow, D
   public void testFailure_refundableFee_v06() throws Exception {
     setEppInput("domain_renew_fee_refundable.xml", FEE_06_MAP);
     persistDomain();
-    assertThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    EppException thrown = expectThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_refundableFee_v11() throws Exception {
     setEppInput("domain_renew_fee_refundable.xml", FEE_11_MAP);
     persistDomain();
-    assertThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    EppException thrown = expectThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_refundableFee_v12() throws Exception {
     setEppInput("domain_renew_fee_refundable.xml", FEE_12_MAP);
     persistDomain();
-    assertThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    EppException thrown = expectThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_gracePeriodFee_v06() throws Exception {
     setEppInput("domain_renew_fee_grace_period.xml", FEE_06_MAP);
     persistDomain();
-    assertThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    EppException thrown = expectThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_gracePeriodFee_v11() throws Exception {
     setEppInput("domain_renew_fee_grace_period.xml", FEE_11_MAP);
     persistDomain();
-    assertThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    EppException thrown = expectThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_gracePeriodFee_v12() throws Exception {
     setEppInput("domain_renew_fee_grace_period.xml", FEE_12_MAP);
     persistDomain();
-    assertThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    EppException thrown = expectThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_appliedFee_v06() throws Exception {
     setEppInput("domain_renew_fee_applied.xml", FEE_06_MAP);
     persistDomain();
-    assertThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    EppException thrown = expectThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_appliedFee_v11() throws Exception {
     setEppInput("domain_renew_fee_applied.xml", FEE_11_MAP);
     persistDomain();
-    assertThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    EppException thrown = expectThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_appliedFee_v12() throws Exception {
     setEppInput("domain_renew_fee_applied.xml", FEE_12_MAP);
     persistDomain();
-    assertThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    EppException thrown = expectThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -375,7 +395,11 @@ public class DomainRenewFlowTest extends ResourceFlowTestCase<DomainRenewFlow, D
     persistDomain();
     // Modify the autorenew poll message so that it has an undelivered message in the past.
     persistResource(
-        ofy().load().key(reloadResourceByForeignKey().getAutorenewPollMessage()).now().asBuilder()
+        ofy()
+            .load()
+            .key(reloadResourceByForeignKey().getAutorenewPollMessage())
+            .now()
+            .asBuilder()
             .setEventTime(expirationTime.minusYears(1))
             .build());
     runFlowAssertResponse(loadFile("domain_renew_response.xml"));
@@ -388,8 +412,9 @@ public class DomainRenewFlowTest extends ResourceFlowTestCase<DomainRenewFlow, D
             .setEventTime(expirationTime.minusYears(1))
             .setAutorenewEndTime(clock.nowUtc())
             .setMsg("Domain was auto-renewed.")
-            .setParent(getOnlyHistoryEntryOfType(
-                reloadResourceByForeignKey(), HistoryEntry.Type.DOMAIN_CREATE))
+            .setParent(
+                getOnlyHistoryEntryOfType(
+                    reloadResourceByForeignKey(), HistoryEntry.Type.DOMAIN_CREATE))
             .build(),
         new PollMessage.Autorenew.Builder()
             .setTargetId(getUniqueIdFromCommand())
@@ -434,11 +459,13 @@ public class DomainRenewFlowTest extends ResourceFlowTestCase<DomainRenewFlow, D
 
   @Test
   public void testFailure_pendingDelete() throws Exception {
-    persistResource(newDomainResource(getUniqueIdFromCommand()).asBuilder()
-        .setRegistrationExpirationTime(expirationTime)
-        .setDeletionTime(clock.nowUtc().plusDays(1))
-        .addStatusValue(StatusValue.PENDING_DELETE)
-        .build());
+    persistResource(
+        newDomainResource(getUniqueIdFromCommand())
+            .asBuilder()
+            .setRegistrationExpirationTime(expirationTime)
+            .setDeletionTime(clock.nowUtc().plusDays(1))
+            .addStatusValue(StatusValue.PENDING_DELETE)
+            .build());
     ResourceStatusProhibitsOperationException thrown =
         expectThrows(ResourceStatusProhibitsOperationException.class, this::runFlow);
     assertThat(thrown).hasMessageThat().contains("pendingDelete");
@@ -453,7 +480,8 @@ public class DomainRenewFlowTest extends ResourceFlowTestCase<DomainRenewFlow, D
             .setRenewBillingCostTransitions(ImmutableSortedMap.of(START_OF_TIME, Money.of(USD, 20)))
             .build());
     persistDomain();
-    assertThrows(FeesMismatchException.class, this::runFlow);
+    EppException thrown = expectThrows(FeesMismatchException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -465,7 +493,8 @@ public class DomainRenewFlowTest extends ResourceFlowTestCase<DomainRenewFlow, D
             .setRenewBillingCostTransitions(ImmutableSortedMap.of(START_OF_TIME, Money.of(USD, 20)))
             .build());
     persistDomain();
-    assertThrows(FeesMismatchException.class, this::runFlow);
+    EppException thrown = expectThrows(FeesMismatchException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -477,7 +506,8 @@ public class DomainRenewFlowTest extends ResourceFlowTestCase<DomainRenewFlow, D
             .setRenewBillingCostTransitions(ImmutableSortedMap.of(START_OF_TIME, Money.of(USD, 20)))
             .build());
     persistDomain();
-    assertThrows(FeesMismatchException.class, this::runFlow);
+    EppException thrown = expectThrows(FeesMismatchException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -494,7 +524,8 @@ public class DomainRenewFlowTest extends ResourceFlowTestCase<DomainRenewFlow, D
             .setServerStatusChangeBillingCost(Money.of(EUR, 19))
             .build());
     persistDomain();
-    assertThrows(CurrencyUnitMismatchException.class, this::runFlow);
+    EppException thrown = expectThrows(CurrencyUnitMismatchException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -511,7 +542,8 @@ public class DomainRenewFlowTest extends ResourceFlowTestCase<DomainRenewFlow, D
             .setServerStatusChangeBillingCost(Money.of(EUR, 19))
             .build());
     persistDomain();
-    assertThrows(CurrencyUnitMismatchException.class, this::runFlow);
+    EppException thrown = expectThrows(CurrencyUnitMismatchException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -528,37 +560,42 @@ public class DomainRenewFlowTest extends ResourceFlowTestCase<DomainRenewFlow, D
             .setServerStatusChangeBillingCost(Money.of(EUR, 19))
             .build());
     persistDomain();
-    assertThrows(CurrencyUnitMismatchException.class, this::runFlow);
+    EppException thrown = expectThrows(CurrencyUnitMismatchException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_feeGivenInWrongScale_v06() throws Exception {
     setEppInput("domain_renew_fee_bad_scale.xml", FEE_06_MAP);
     persistDomain();
-    assertThrows(CurrencyValueScaleException.class, this::runFlow);
+    EppException thrown = expectThrows(CurrencyValueScaleException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_feeGivenInWrongScale_v11() throws Exception {
     setEppInput("domain_renew_fee_bad_scale.xml", FEE_11_MAP);
     persistDomain();
-    assertThrows(CurrencyValueScaleException.class, this::runFlow);
+    EppException thrown = expectThrows(CurrencyValueScaleException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_feeGivenInWrongScale_v12() throws Exception {
     setEppInput("domain_renew_fee_bad_scale.xml", FEE_12_MAP);
     persistDomain();
-    assertThrows(CurrencyValueScaleException.class, this::runFlow);
+    EppException thrown = expectThrows(CurrencyValueScaleException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_pendingTransfer() throws Exception {
     persistDomain();
-    persistWithPendingTransfer(reloadResourceByForeignKey()
-        .asBuilder()
-        .setRegistrationExpirationTime(DateTime.parse("2001-09-08T22:00:00.0Z"))
-        .build());
+    persistWithPendingTransfer(
+        reloadResourceByForeignKey()
+            .asBuilder()
+            .setRegistrationExpirationTime(DateTime.parse("2001-09-08T22:00:00.0Z"))
+            .build());
     ResourceStatusProhibitsOperationException thrown =
         expectThrows(ResourceStatusProhibitsOperationException.class, this::runFlow);
     assertThat(thrown).hasMessageThat().contains("pendingTransfer");
@@ -568,31 +605,38 @@ public class DomainRenewFlowTest extends ResourceFlowTestCase<DomainRenewFlow, D
   public void testFailure_periodInMonths() throws Exception {
     setEppInput("domain_renew_months.xml");
     persistDomain();
-    assertThrows(BadPeriodUnitException.class, this::runFlow);
+    EppException thrown = expectThrows(BadPeriodUnitException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_max10Years() throws Exception {
     setEppInput("domain_renew_11_years.xml");
     persistDomain();
-    assertThrows(ExceedsMaxRegistrationYearsException.class, this::runFlow);
+    EppException thrown = expectThrows(ExceedsMaxRegistrationYearsException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_curExpDateMustMatch() throws Exception {
     persistDomain();
     // Note expiration time is off by one day.
-    persistResource(reloadResourceByForeignKey().asBuilder()
-        .setRegistrationExpirationTime(DateTime.parse("2000-04-04T22:00:00.0Z"))
-        .build());
-    assertThrows(IncorrectCurrentExpirationDateException.class, this::runFlow);
+    persistResource(
+        reloadResourceByForeignKey()
+            .asBuilder()
+            .setRegistrationExpirationTime(DateTime.parse("2000-04-04T22:00:00.0Z"))
+            .build());
+    EppException thrown =
+        expectThrows(IncorrectCurrentExpirationDateException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_unauthorizedClient() throws Exception {
     sessionMetadata.setClientId("NewRegistrar");
     persistActiveDomain(getUniqueIdFromCommand());
-    assertThrows(ResourceNotOwnedException.class, this::runFlow);
+    EppException thrown = expectThrows(ResourceNotOwnedException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -608,7 +652,8 @@ public class DomainRenewFlowTest extends ResourceFlowTestCase<DomainRenewFlow, D
     persistResource(
         loadRegistrar("TheRegistrar").asBuilder().setAllowedTlds(ImmutableSet.of()).build());
     persistDomain();
-    assertThrows(NotAuthorizedForTldException.class, this::runFlow);
+    EppException thrown = expectThrows(NotAuthorizedForTldException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -626,7 +671,8 @@ public class DomainRenewFlowTest extends ResourceFlowTestCase<DomainRenewFlow, D
     persistResource(Registry.get("example").asBuilder().setPremiumPriceAckRequired(true).build());
     setEppInput("domain_renew_premium.xml");
     persistDomain();
-    assertThrows(FeesRequiredForPremiumNameException.class, this::runFlow);
+    EppException thrown = expectThrows(FeesRequiredForPremiumNameException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -648,13 +694,13 @@ public class DomainRenewFlowTest extends ResourceFlowTestCase<DomainRenewFlow, D
             .build());
     runFlow();
     DomainResource domain = reloadResourceByForeignKey();
-    HistoryEntry historyEntry =
-        getOnlyHistoryEntryOfType(domain, HistoryEntry.Type.DOMAIN_RENEW);
-    assertThat(historyEntry.getDomainTransactionRecords()).containsExactly(
-        DomainTransactionRecord.create(
-            "tld",
-            historyEntry.getModificationTime().plusMinutes(9),
-            TransactionReportField.netRenewsFieldFromYears(5),
-            1));
+    HistoryEntry historyEntry = getOnlyHistoryEntryOfType(domain, HistoryEntry.Type.DOMAIN_RENEW);
+    assertThat(historyEntry.getDomainTransactionRecords())
+        .containsExactly(
+            DomainTransactionRecord.create(
+                "tld",
+                historyEntry.getModificationTime().plusMinutes(9),
+                TransactionReportField.netRenewsFieldFromYears(5),
+                1));
   }
 }
diff --git a/javatests/google/registry/flows/domain/DomainRestoreRequestFlowTest.java b/javatests/google/registry/flows/domain/DomainRestoreRequestFlowTest.java
index 77bce8116..ef2264e88 100644
--- a/javatests/google/registry/flows/domain/DomainRestoreRequestFlowTest.java
+++ b/javatests/google/registry/flows/domain/DomainRestoreRequestFlowTest.java
@@ -27,7 +27,7 @@ import static google.registry.testing.DatastoreHelper.persistDeletedDomain;
 import static google.registry.testing.DatastoreHelper.persistReservedList;
 import static google.registry.testing.DatastoreHelper.persistResource;
 import static google.registry.testing.DomainResourceSubject.assertAboutDomains;
-import static google.registry.testing.JUnitBackports.assertThrows;
+import static google.registry.testing.EppExceptionSubject.assertAboutEppExceptions;
 import static google.registry.testing.JUnitBackports.expectThrows;
 import static google.registry.testing.TaskQueueHelper.assertDnsTasksEnqueued;
 import static google.registry.util.DateTimeUtils.END_OF_TIME;
@@ -39,6 +39,7 @@ import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.ImmutableSortedMap;
 import com.googlecode.objectify.Key;
+import google.registry.flows.EppException;
 import google.registry.flows.EppException.UnimplementedExtensionException;
 import google.registry.flows.ResourceFlowTestCase;
 import google.registry.flows.ResourceFlowUtils.ResourceDoesNotExistException;
@@ -71,8 +72,8 @@ import org.junit.Before;
 import org.junit.Test;
 
 /** Unit tests for {@link DomainRestoreRequestFlow}. */
-public class DomainRestoreRequestFlowTest extends
-    ResourceFlowTestCase<DomainRestoreRequestFlow, DomainResource> {
+public class DomainRestoreRequestFlowTest
+    extends ResourceFlowTestCase<DomainRestoreRequestFlow, DomainResource> {
 
   private static final ImmutableMap<String, String> FEE_06_MAP =
       ImmutableMap.of("FEE_VERSION", "0.6", "FEE_NS", "fee");
@@ -92,24 +93,31 @@ public class DomainRestoreRequestFlowTest extends
 
   void persistPendingDeleteDomain() throws Exception {
     DomainResource domain = newDomainResource(getUniqueIdFromCommand());
-    HistoryEntry historyEntry = persistResource(
-        new HistoryEntry.Builder()
-            .setType(HistoryEntry.Type.DOMAIN_DELETE)
-            .setParent(domain)
-            .build());
-    domain = persistResource(domain.asBuilder()
-        .setRegistrationExpirationTime(clock.nowUtc().plusYears(5).plusDays(45))
-        .setDeletionTime(clock.nowUtc().plusDays(35))
-        .addGracePeriod(GracePeriod.create(
-            GracePeriodStatus.REDEMPTION, clock.nowUtc().plusDays(1), "foo", null))
-        .setStatusValues(ImmutableSet.of(StatusValue.PENDING_DELETE))
-        .setDeletePollMessage(Key.create(persistResource(
-            new PollMessage.OneTime.Builder()
-                .setClientId("TheRegistrar")
-                .setEventTime(clock.nowUtc().plusDays(5))
-                .setParent(historyEntry)
-                .build())))
-        .build());
+    HistoryEntry historyEntry =
+        persistResource(
+            new HistoryEntry.Builder()
+                .setType(HistoryEntry.Type.DOMAIN_DELETE)
+                .setParent(domain)
+                .build());
+    domain =
+        persistResource(
+            domain
+                .asBuilder()
+                .setRegistrationExpirationTime(clock.nowUtc().plusYears(5).plusDays(45))
+                .setDeletionTime(clock.nowUtc().plusDays(35))
+                .addGracePeriod(
+                    GracePeriod.create(
+                        GracePeriodStatus.REDEMPTION, clock.nowUtc().plusDays(1), "foo", null))
+                .setStatusValues(ImmutableSet.of(StatusValue.PENDING_DELETE))
+                .setDeletePollMessage(
+                    Key.create(
+                        persistResource(
+                            new PollMessage.OneTime.Builder()
+                                .setClientId("TheRegistrar")
+                                .setEventTime(clock.nowUtc().plusDays(5))
+                                .setParent(historyEntry)
+                                .build())))
+                .build());
     clock.advanceOneMilli();
   }
 
@@ -126,22 +134,24 @@ public class DomainRestoreRequestFlowTest extends
     persistPendingDeleteDomain();
     assertTransactionalFlow(true);
     // Double check that we see a poll message in the future for when the delete happens.
-    assertThat(getPollMessages("TheRegistrar", clock.nowUtc().plusMonths(1)))
-        .hasSize(1);
+    assertThat(getPollMessages("TheRegistrar", clock.nowUtc().plusMonths(1))).hasSize(1);
     runFlowAssertResponse(loadFile("domain_update_response.xml"));
     DomainResource domain = reloadResourceByForeignKey();
     HistoryEntry historyEntryDomainRestore =
         getOnlyHistoryEntryOfType(domain, HistoryEntry.Type.DOMAIN_RESTORE);
     assertThat(ofy().load().key(domain.getAutorenewBillingEvent()).now().getEventTime())
         .isEqualTo(clock.nowUtc().plusYears(1));
-    assertAboutDomains().that(domain)
+    assertAboutDomains()
+        .that(domain)
         // New expiration time should be exactly a year from now.
-        .hasRegistrationExpirationTime(clock.nowUtc().plusYears(1)).and()
-        .doesNotHaveStatusValue(StatusValue.PENDING_DELETE).and()
-        .hasDeletionTime(END_OF_TIME).and()
+        .hasRegistrationExpirationTime(clock.nowUtc().plusYears(1))
+        .and()
+        .doesNotHaveStatusValue(StatusValue.PENDING_DELETE)
+        .and()
+        .hasDeletionTime(END_OF_TIME)
+        .and()
         .hasOneHistoryEntryEachOfTypes(
-            HistoryEntry.Type.DOMAIN_DELETE,
-            HistoryEntry.Type.DOMAIN_RESTORE);
+            HistoryEntry.Type.DOMAIN_DELETE, HistoryEntry.Type.DOMAIN_RESTORE);
     assertThat(domain.getGracePeriods()).isEmpty();
     assertDnsTasksEnqueued("example.tld");
     // The poll message for the delete should now be gone. The only poll message should be the new
@@ -209,6 +219,7 @@ public class DomainRestoreRequestFlowTest extends
     persistPendingDeleteDomain();
     runFlowAssertResponse(loadFile("domain_update_restore_request_response_fee.xml", FEE_12_MAP));
   }
+
   @Test
   public void testSuccess_fee_withDefaultAttributes_v06() throws Exception {
     setEppInput("domain_update_restore_request_fee_defaults.xml", FEE_06_MAP);
@@ -234,63 +245,72 @@ public class DomainRestoreRequestFlowTest extends
   public void testFailure_refundableFee_v06() throws Exception {
     setEppInput("domain_update_restore_request_fee_refundable.xml", FEE_06_MAP);
     persistPendingDeleteDomain();
-    assertThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    EppException thrown = expectThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_refundableFee_v11() throws Exception {
     setEppInput("domain_update_restore_request_fee_refundable.xml", FEE_11_MAP);
     persistPendingDeleteDomain();
-    assertThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    EppException thrown = expectThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_refundableFee_v12() throws Exception {
     setEppInput("domain_update_restore_request_fee_refundable.xml", FEE_12_MAP);
     persistPendingDeleteDomain();
-    assertThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    EppException thrown = expectThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_gracePeriodFee_v06() throws Exception {
     setEppInput("domain_update_restore_request_fee_grace_period.xml", FEE_06_MAP);
     persistPendingDeleteDomain();
-    assertThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    EppException thrown = expectThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_gracePeriodFee_v11() throws Exception {
     setEppInput("domain_update_restore_request_fee_grace_period.xml", FEE_11_MAP);
     persistPendingDeleteDomain();
-    assertThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    EppException thrown = expectThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_gracePeriodFee_v12() throws Exception {
     setEppInput("domain_update_restore_request_fee_grace_period.xml", FEE_12_MAP);
     persistPendingDeleteDomain();
-    assertThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    EppException thrown = expectThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_appliedFee_v06() throws Exception {
     setEppInput("domain_update_restore_request_fee_applied.xml", FEE_06_MAP);
     persistPendingDeleteDomain();
-    assertThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    EppException thrown = expectThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_appliedFee_v11() throws Exception {
     setEppInput("domain_update_restore_request_fee_applied.xml", FEE_11_MAP);
     persistPendingDeleteDomain();
-    assertThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    EppException thrown = expectThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_appliedFee_v12() throws Exception {
     setEppInput("domain_update_restore_request_fee_applied.xml", FEE_12_MAP);
     persistPendingDeleteDomain();
-    assertThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    EppException thrown = expectThrows(UnsupportedFeeAttributeException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -311,9 +331,7 @@ public class DomainRestoreRequestFlowTest extends
             .build());
     persistPendingDeleteDomain();
     runFlowAssertResponse(
-        CommitMode.LIVE,
-        UserPrivileges.SUPERUSER,
-        loadFile("domain_update_response.xml"));
+        CommitMode.LIVE, UserPrivileges.SUPERUSER, loadFile("domain_update_response.xml"));
   }
 
   @Test
@@ -323,12 +341,9 @@ public class DomainRestoreRequestFlowTest extends
     setEppInput("domain_update_restore_request_premium.xml");
     persistPendingDeleteDomain();
     // Modify the Registrar to block premium names.
-    persistResource(
-        loadRegistrar("TheRegistrar").asBuilder().setBlockPremiumNames(true).build());
+    persistResource(loadRegistrar("TheRegistrar").asBuilder().setBlockPremiumNames(true).build());
     runFlowAssertResponse(
-        CommitMode.LIVE,
-        UserPrivileges.SUPERUSER,
-        loadFile("domain_update_response.xml"));
+        CommitMode.LIVE, UserPrivileges.SUPERUSER, loadFile("domain_update_response.xml"));
   }
 
   @Test
@@ -344,7 +359,8 @@ public class DomainRestoreRequestFlowTest extends
     persistPendingDeleteDomain();
     persistResource(
         Registry.get("tld").asBuilder().setRestoreBillingCost(Money.of(USD, 100)).build());
-    assertThrows(FeesMismatchException.class, this::runFlow);
+    EppException thrown = expectThrows(FeesMismatchException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -353,7 +369,8 @@ public class DomainRestoreRequestFlowTest extends
     persistPendingDeleteDomain();
     persistResource(
         Registry.get("tld").asBuilder().setRestoreBillingCost(Money.of(USD, 100)).build());
-    assertThrows(FeesMismatchException.class, this::runFlow);
+    EppException thrown = expectThrows(FeesMismatchException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -362,7 +379,8 @@ public class DomainRestoreRequestFlowTest extends
     persistPendingDeleteDomain();
     persistResource(
         Registry.get("tld").asBuilder().setRestoreBillingCost(Money.of(USD, 100)).build());
-    assertThrows(FeesMismatchException.class, this::runFlow);
+    EppException thrown = expectThrows(FeesMismatchException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   private void runWrongCurrencyTest(Map<String, String> substitutions) throws Exception {
@@ -378,7 +396,8 @@ public class DomainRestoreRequestFlowTest extends
             .setEapFeeSchedule(ImmutableSortedMap.of(START_OF_TIME, Money.zero(EUR)))
             .setServerStatusChangeBillingCost(Money.of(EUR, 19))
             .build());
-    assertThrows(CurrencyUnitMismatchException.class, this::runFlow);
+    EppException thrown = expectThrows(CurrencyUnitMismatchException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -400,21 +419,24 @@ public class DomainRestoreRequestFlowTest extends
   public void testFailure_feeGivenInWrongScale_v06() throws Exception {
     setEppInput("domain_update_restore_request_fee_bad_scale.xml", FEE_06_MAP);
     persistPendingDeleteDomain();
-    assertThrows(CurrencyValueScaleException.class, this::runFlow);
+    EppException thrown = expectThrows(CurrencyValueScaleException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_feeGivenInWrongScale_v11() throws Exception {
     setEppInput("domain_update_restore_request_fee_bad_scale.xml", FEE_11_MAP);
     persistPendingDeleteDomain();
-    assertThrows(CurrencyValueScaleException.class, this::runFlow);
+    EppException thrown = expectThrows(CurrencyValueScaleException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_feeGivenInWrongScale_v12() throws Exception {
     setEppInput("domain_update_restore_request_fee_bad_scale.xml", FEE_12_MAP);
     persistPendingDeleteDomain();
-    assertThrows(CurrencyValueScaleException.class, this::runFlow);
+    EppException thrown = expectThrows(CurrencyValueScaleException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -425,63 +447,73 @@ public class DomainRestoreRequestFlowTest extends
             .setDeletionTime(clock.nowUtc().plusDays(4))
             .setStatusValues(ImmutableSet.of(StatusValue.PENDING_DELETE))
             .build());
-    assertThrows(DomainNotEligibleForRestoreException.class, this::runFlow);
+    EppException thrown = expectThrows(DomainNotEligibleForRestoreException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_notDeleted() throws Exception {
     persistActiveDomain(getUniqueIdFromCommand());
-    assertThrows(DomainNotEligibleForRestoreException.class, this::runFlow);
+    EppException thrown = expectThrows(DomainNotEligibleForRestoreException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_fullyDeleted() throws Exception {
     persistDeletedDomain(getUniqueIdFromCommand(), clock.nowUtc().minusDays(1));
-    assertThrows(ResourceDoesNotExistException.class, this::runFlow);
+    EppException thrown = expectThrows(ResourceDoesNotExistException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_withChange() throws Exception {
     persistPendingDeleteDomain();
     setEppInput("domain_update_restore_request_with_change.xml");
-    assertThrows(RestoreCommandIncludesChangesException.class, this::runFlow);
+    EppException thrown = expectThrows(RestoreCommandIncludesChangesException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_withAdd() throws Exception {
     persistPendingDeleteDomain();
     setEppInput("domain_update_restore_request_with_add.xml");
-    assertThrows(RestoreCommandIncludesChangesException.class, this::runFlow);
+    EppException thrown = expectThrows(RestoreCommandIncludesChangesException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_withRemove() throws Exception {
     persistPendingDeleteDomain();
     setEppInput("domain_update_restore_request_with_remove.xml");
-    assertThrows(RestoreCommandIncludesChangesException.class, this::runFlow);
+    EppException thrown = expectThrows(RestoreCommandIncludesChangesException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_withSecDnsExtension() throws Exception {
     persistPendingDeleteDomain();
     setEppInput("domain_update_restore_request_with_secdns.xml");
-    assertThrows(UnimplementedExtensionException.class, this::runFlow);
+    EppException thrown = expectThrows(UnimplementedExtensionException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testFailure_unauthorizedClient() throws Exception {
     sessionMetadata.setClientId("NewRegistrar");
     persistPendingDeleteDomain();
-    assertThrows(ResourceNotOwnedException.class, this::runFlow);
+    EppException thrown = expectThrows(ResourceNotOwnedException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
   public void testSuccess_superuserUnauthorizedClient() throws Exception {
     sessionMetadata.setClientId("NewRegistrar");
     persistPendingDeleteDomain();
-    assertThrows(
-        ResourceNotOwnedException.class,
-        () -> runFlowAssertResponse(loadFile("domain_update_response.xml")));
+    EppException thrown =
+        expectThrows(
+            ResourceNotOwnedException.class,
+            () -> runFlowAssertResponse(loadFile("domain_update_response.xml")));
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -489,7 +521,8 @@ public class DomainRestoreRequestFlowTest extends
     persistResource(
         loadRegistrar("TheRegistrar").asBuilder().setAllowedTlds(ImmutableSet.of()).build());
     persistPendingDeleteDomain();
-    assertThrows(NotAuthorizedForTldException.class, this::runFlow);
+    EppException thrown = expectThrows(NotAuthorizedForTldException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -508,7 +541,8 @@ public class DomainRestoreRequestFlowTest extends
     persistPendingDeleteDomain();
     // Modify the Registrar to block premium names.
     persistResource(loadRegistrar("TheRegistrar").asBuilder().setBlockPremiumNames(true).build());
-    assertThrows(PremiumNameBlockedException.class, this::runFlow);
+    EppException thrown = expectThrows(PremiumNameBlockedException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -520,7 +554,8 @@ public class DomainRestoreRequestFlowTest extends
             .setReservedLists(persistReservedList("tld-reserved", "example,FULLY_BLOCKED"))
             .build());
     persistPendingDeleteDomain();
-    assertThrows(DomainReservedException.class, this::runFlow);
+    EppException thrown = expectThrows(DomainReservedException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -528,7 +563,8 @@ public class DomainRestoreRequestFlowTest extends
     createTld("example");
     setEppInput("domain_update_restore_request_premium.xml");
     persistPendingDeleteDomain();
-    assertThrows(FeesRequiredForPremiumNameException.class, this::runFlow);
+    EppException thrown = expectThrows(FeesRequiredForPremiumNameException.class, this::runFlow);
+    assertAboutEppExceptions().that(thrown).marshalsToXml();
   }
 
   @Test
@@ -537,7 +573,7 @@ public class DomainRestoreRequestFlowTest extends
     runFlow();
     assertIcannReportingActivityFieldLogged("srs-dom-rgp-restore-request");
     assertTldsFieldLogged("tld");
- }
+  }
 
   @Test
   public void testIcannTransactionReportField_getsStored() throws Exception {