diff --git a/README.md b/README.md
index 45057c5..92035bd 100644
--- a/README.md
+++ b/README.md
@@ -26,37 +26,37 @@ Then, where you had to use `setUp(): void`  template method, use `legacySetUp()`
 
 ```diff
 - protected function setUp(): void
-+ protected function legacySetUp()
++ protected function doSetUp()
 ```
 
 There are similar replacements for most other template method:
 
 ```diff
 - public static function setUpBeforeClass(): void
-+ public static function legacySetUpBeforeClass()
++ public static function doSetUpBeforeClass()
 ```
 
 ```diff
 - public static function tearDownAfterClass(): void
-+ public static function legacyTearDownAfterClass()
++ public static function doTearDownAfterClass()
 ```
 
 ```diff
 - protected function setUp(): void
-+ protected function legacySetUp()
++ protected function doSetUp()
 ```
 
 ```diff
 - protected function tearDown(): void
-+ protected function legacyTearDown()
++ protected function doTearDown()
 ```
 
 ```diff
 - protected function assertPreConditions(): void
-+ protected function legacyAssertPreConditions()
++ protected function doAssertPreConditions()
 ```
 
 ```diff
 - protected function assertPostConditions(): void
-+ protected function legacyAssertPostConditions()
++ protected function doAssertPostConditions()
 ```
diff --git a/src/TestCase.php b/src/TestCase.php
index ffc973d..aace8a9 100644
--- a/src/TestCase.php
+++ b/src/TestCase.php
@@ -23,59 +23,91 @@ abstract class TestCase extends \PHPUnit\Framework\TestCase
     public static function setUpBeforeClass()
     {
         static::legacySetUpBeforeClass();
+        static::doSetUpBeforeClass();
     }
 
-    public static function legacySetUpBeforeClass()
+    /** {@inheritdoc} */
+    public static function tearDownAfterClass()
     {
+        static::legacyTearDownAfterClass();
+        static::doTearDownAfterClass();
     }
 
     /** {@inheritdoc} */
-    public static function tearDownAfterClass()
+    protected function setUp()
     {
-        static::legacyTearDownAfterClass();
+        $this->legacySetUp();
+        $this->doSetUp();
     }
 
-    public static function legacyTearDownAfterClass()
+    /** {@inheritdoc} */
+    protected function tearDown()
     {
+        $this->legacyTearDown();
+        $this->doTearDown();
     }
 
     /** {@inheritdoc} */
-    protected function setUp()
+    protected function assertPreConditions()
+    {
+        $this->legacyAssertPreConditions();
+        $this->doAssertPreConditions();
+    }
+
+    /** {@inheritdoc} */
+    protected function assertPostConditions()
+    {
+        $this->legacyAssertPostConditions();
+        $this->doAssertPostConditions();
+    }
+
+    // All replacement methods should go below. They better to be in a trait, but we don't have traits in PHP 5.3.
+
+    public static function legacySetUpBeforeClass()
+    {
+    }
+
+    public static function doSetUpBeforeClass()
+    {
+    }
+
+    public static function legacyTearDownAfterClass()
+    {
+    }
+
+    public static function doTearDownAfterClass()
     {
-        $this->legacySetUp();
     }
 
     protected function legacySetUp()
     {
     }
 
-    /** {@inheritdoc} */
-    protected function tearDown()
+    protected function doSetUp()
     {
-        $this->legacyTearDown();
     }
 
     protected function legacyTearDown()
     {
     }
 
-    /** {@inheritdoc} */
-    protected function assertPreConditions()
+    protected function doTearDown()
     {
-        $this->legacyAssertPreConditions();
     }
 
     protected function legacyAssertPreConditions()
     {
     }
 
-    /** {@inheritdoc} */
-    protected function assertPostConditions()
+    protected function doAssertPreConditions()
     {
-        $this->legacyAssertPostConditions();
     }
 
     protected function legacyAssertPostConditions()
     {
     }
+
+    protected function doAssertPostConditions()
+    {
+    }
 }
diff --git a/tests/Test.php b/tests/Test.php
index 6d361a9..f3bcba8 100644
--- a/tests/Test.php
+++ b/tests/Test.php
@@ -25,12 +25,16 @@
  */
 final class Test extends TestCase
 {
-    const EXPECTED_SEQUENCE_LEN = 6;
+    const EXPECTED_SEQUENCE_LEN = 12;
 
     private static $callSequence = array();
 
     public function testExample()
     {
+        if (self::EXPECTED_SEQUENCE_LEN !== count(self::getExpectedCallSequence())) {
+            $this->fail(sprintf('EXPECTED_SEQUENCE_LEN needs an update to %d', count(self::getExpectedCallSequence())));
+        }
+
         $this->assertTrue(count(self::$callSequence) > 0);
 
         if (count(self::$callSequence) > self::EXPECTED_SEQUENCE_LEN) {
@@ -57,11 +61,22 @@ public static function getExpectedCallSequence()
             return __CLASS__.$method;
         }, array(
             '::legacySetUpBeforeClass',
+            '::doSetUpBeforeClass',
+
             '::legacySetUp',
+            '::doSetUp',
+
             '::legacyAssertPreConditions',
+            '::doAssertPreConditions',
+
             '::legacyAssertPostConditions',
+            '::doAssertPostConditions',
+
             '::legacyTearDown',
+            '::doTearDown',
+
             '::legacyTearDownAfterClass',
+            '::doTearDownAfterClass',
         ));
     }
 
@@ -70,28 +85,58 @@ public static function legacySetUpBeforeClass()
         self::add(__METHOD__);
     }
 
+    public static function doSetUpBeforeClass()
+    {
+        self::add(__METHOD__);
+    }
+
     public static function legacyTearDownAfterClass()
     {
         self::add(__METHOD__);
     }
 
+    public static function doTearDownAfterClass()
+    {
+        self::add(__METHOD__);
+    }
+
     protected function legacySetUp()
     {
         self::add(__METHOD__);
     }
 
+    protected function doSetUp()
+    {
+        self::add(__METHOD__);
+    }
+
     protected function legacyTearDown()
     {
         self::add(__METHOD__);
     }
 
+    protected function doTearDown()
+    {
+        self::add(__METHOD__);
+    }
+
     protected function legacyAssertPreConditions()
     {
         self::add(__METHOD__);
     }
 
+    protected function doAssertPreConditions()
+    {
+        self::add(__METHOD__);
+    }
+
     protected function legacyAssertPostConditions()
     {
         self::add(__METHOD__);
     }
+
+    protected function doAssertPostConditions()
+    {
+        self::add(__METHOD__);
+    }
 }