class ProtectedPrivatesTest

class ProtectedPrivatesTest extends UnitTestCase {
    
    /**
     * Get an accessible method using reflection.
     */
    public function getAccessibleMethod($class_name, $method_name) {
        $class = new \ReflectionClass($class_name);
        $method = $class->getMethod($method_name);
        $method->setAccessible(TRUE);
        return $method;
    }
    
    /**
     * Good data provider.
     */
    public static function addDataProvider() {
        return [
            [
                5,
                2,
                3,
            ],
        ];
    }
    
    /**
     * Test ProtectedPrivate::privateAdd().
     *
     * We want to test a private method on a class. This is problematic
     * because, by design, we don't have access to this method. However,
     * we do have a tool available to help us out with this problem:
     * We can override the accessibility of a method using reflection.
     *
     * @dataProvider addDataProvider
     */
    public function testPrivateAdd($expected, $a, $b) {
        // Get a reflected, accessible version of the privateAdd() method.
        $private_method = $this->getAccessibleMethod('Drupal\\phpunit_example\\ProtectedPrivates', 'privateAdd');
        // Create a new ProtectedPrivates object.
        $pp = new ProtectedPrivates();
        // Use the reflection to invoke on the object.
        $sum = $private_method->invokeArgs($pp, [
            $a,
            $b,
        ]);
        // Make an assertion.
        $this->assertEquals($expected, $sum);
    }
    
    /**
     * Bad data provider.
     */
    public static function addBadDataProvider() {
        return [
            [
                'string',
                [],
            ],
        ];
    }
    
    /**
     * Test ProtectedPrivate::privateAdd() with bad data.
     *
     * This is essentially the same test as testPrivateAdd(), but using
     * non-numeric data. This lets us test the exception-throwing ability
     * of this private method.
     *
     * @dataProvider addBadDataProvider
     */
    public function testPrivateAddBadData($a, $b) {
        // Get a reflected, accessible version of the privateAdd() method.
        $private_method = $this->getAccessibleMethod('Drupal\\phpunit_example\\ProtectedPrivates', 'privateAdd');
        // Create a new ProtectedPrivates object.
        $pp = new ProtectedPrivates();
        // Use the reflection to invoke on the object.
        // This should throw an exception.
        $this->expectException(\InvalidArgumentException::class);
        $private_method->invokeArgs($pp, [
            $a,
            $b,
        ]);
    }
    
    /**
     * Test ProtectedPrivates::protectedAdd() using a stub class.
     *
     * We could use the same reflection technique to test protected
     * methods, just like we did with private ones.
     *
     * But sometimes it might make more sense to use a stub class
     * which will have access to the protected method. That's what
     * we'll demonstrate here.
     *
     * @dataProvider addDataProvider
     */
    public function testProtectedAdd($expected, $a, $b) {
        $stub = new ProtectedPrivatesSubclass();
        $this->assertEquals($expected, $stub->subclassProtectedAdd($a, $b));
    }
    
    /**
     * Test ProtectedPrivates::protectedAdd() with bad data using a stub class.
     *
     * This test is similar to testProtectedAdd(), but expects an exception.
     *
     * @dataProvider addBadDataProvider
     */
    public function testProtectedAddBadData($a, $b) {
        $stub = new ProtectedPrivatesSubclass();
        $this->expectException(\InvalidArgumentException::class);
        $stub->subclassProtectedAdd($a, $b);
    }

}