From 554959ab31244a0c04a65dc2a7ec142cfcc21bee Mon Sep 17 00:00:00 2001
From: Alexey Kopytko <alexey@kopytko.com>
Date: Fri, 11 Dec 2020 14:08:22 +0900
Subject: [PATCH] Add methods like in SetUpTearDownTrait (mainline) (#5)

---
 README.md        | 28 ++++++++++++------------
 src/TestCase.php | 56 +++++++++++++++++++++++++++++++++++-------------
 tests/Test.php   | 51 +++++++++++++++++++++++++++++++++++++++++--
 3 files changed, 104 insertions(+), 31 deletions(-)

diff --git a/README.md b/README.md
index 891d8b7..bee2991 100644
--- a/README.md
+++ b/README.md
@@ -26,55 +26,55 @@ First, update your tests to extend from `\LegacyPHPUnit\TestCase` instead of `\P
 + class MyTest extends \LegacyPHPUnit\TestCase
 ```
 
-Then, where you had to use `setUp(): void`  template method, use `legacySetUp()` method, omitting all any any return types in a fully backward-compatible way. 
+Then, where you had to use `setUp(): void`  template method, use `doSetUp()` method, omitting all any any return types in a fully backward-compatible way. 
 
 ```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()
 ```
 
 ### Reference
 
 |  Method     | Replacement                   |
 | ----------- | ----------------------------- |
-| `setUpBeforeClass(): void` | `legacySetUpBeforeClass()` |
-| `tearDownAfterClass(): void` | `legacyTearDownAfterClass()` |
-| `setUp(): void` | `legacySetUp()` |
-| `tearDown(): void` | `legacyTearDown()` |
-| `assertPreConditions(): void` | `legacyAssertPreConditions()` |
-| `assertPostConditions(): void` | `legacyAssertPostConditions()` |
+| `setUpBeforeClass(): void` | `doSetUpBeforeClass()` |
+| `tearDownAfterClass(): void` | `doTearDownAfterClass()` |
+| `setUp(): void` | `doSetUp()` |
+| `tearDown(): void` | `doTearDown()` |
+| `assertPreConditions(): void` | `doAssertPreConditions()` |
+| `assertPostConditions(): void` | `doAssertPostConditions()` |
 
 
 ### Supported versions
diff --git a/src/TestCase.php b/src/TestCase.php
index e90820c..d9725ce 100644
--- a/src/TestCase.php
+++ b/src/TestCase.php
@@ -27,57 +27,83 @@ public static function setUpBeforeClass(): void
         static::legacySetUpBeforeClass();
     }
 
-    public static function legacySetUpBeforeClass()
+    /** {@inheritdoc} */
+    public static function tearDownAfterClass(): void
     {
+        static::legacyTearDownAfterClass();
     }
 
     /** {@inheritdoc} */
-    public static function tearDownAfterClass(): void
+    protected function setUp(): void
     {
-        static::legacyTearDownAfterClass();
+        $this->legacySetUp();
     }
 
-    public static function legacyTearDownAfterClass()
+    /** {@inheritdoc} */
+    protected function tearDown(): void
     {
+        $this->legacyTearDown();
     }
 
     /** {@inheritdoc} */
-    protected function setUp(): void
+    protected function assertPreConditions(): void
+    {
+        $this->legacyAssertPreConditions();
+    }
+
+    /** {@inheritdoc} */
+    protected function assertPostConditions(): void
+    {
+        $this->legacyAssertPostConditions();
+    }
+
+    // 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(): void
+    protected function doSetUp()
     {
-        $this->legacyTearDown();
     }
 
     protected function legacyTearDown()
     {
     }
 
-    /** {@inheritdoc} */
-    protected function assertPreConditions(): void
+    protected function doTearDown()
     {
-        $this->legacyAssertPreConditions();
     }
 
     protected function legacyAssertPreConditions()
     {
     }
 
-    /** {@inheritdoc} */
-    protected function assertPostConditions(): void
+    protected function doAssertPreConditions()
     {
-        $this->legacyAssertPostConditions();
     }
 
     protected function legacyAssertPostConditions()
     {
     }
+
+    protected function doAssertPostConditions()
+    {
+    }
 }
diff --git a/tests/Test.php b/tests/Test.php
index 5687794..adc61a3 100644
--- a/tests/Test.php
+++ b/tests/Test.php
@@ -27,24 +27,41 @@
  */
 final class Test extends TestCase
 {
+    const EXPECTED_SEQUENCE_LEN = 12;
+
     private const EXPECTED_SEQUENCE = [
         '::legacySetUpBeforeClass',
+        '::doSetUpBeforeClass',
+
         '::legacySetUp',
+        '::doSetUp',
+
         '::legacyAssertPreConditions',
+        '::doAssertPreConditions',
+
         '::legacyAssertPostConditions',
+        '::doAssertPostConditions',
+
         '::legacyTearDown',
+        '::doTearDown',
+
         '::legacyTearDownAfterClass',
+        '::doTearDownAfterClass',
     ];
 
     private static $callSequence = [];
 
     public function testExample(): void
     {
+        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) > \count(self::EXPECTED_SEQUENCE)) {
+        if (\count(self::$callSequence) > self::EXPECTED_SEQUENCE_LEN) {
             $this->assertSame(
-                \array_slice(self::$callSequence, 0, \count(self::EXPECTED_SEQUENCE)),
+                \array_slice(self::$callSequence, 0, self::EXPECTED_SEQUENCE_LEN),
                 self::getExpectedCallSequence()
             );
         }
@@ -72,28 +89,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__);
+    }
 }