You can use reflection and setAccessible() in your tests to allow you to set the internal state of your object in such a way that it will return what you want from the private method. You'll need to be on PHP 5.3.2.

$fixture = new MyClass(...); $reflector = new ReflectionProperty('MyClass', 'myPrivateProperty'); $reflector->setAccessible(true); $reflector->setValue($fixture, 'value'); // test $fixture ... 

You can test private methods but you can't simulate (mock) the running of this methods.

Furthermore, the reflection does not allow you to convert a private method to a protected or public method. setAccessible only allows you to invoke the original method.

Alternatively, you could use runkit for rename the private methods and include a "new implementation". However, these features are experimental and their use is not recommended.

You can get mock of protected method , so if you can convert C to protected then this code will help.

 $mock = $this->getMockBuilder('A') ->disableOriginalConstructor() ->setMethods(array('C')) ->getMock(); $response = $mock->B(); 

This will definitely work , It worked for me . Then For covering protected method C you can use reflection classes.

Assuming that you need to test $myClass->privateMethodX($arg1, $arg2), you can do this with reflection:

$class = new ReflectionClass ($myClass); $method = $class->getMethod ('privateMethodX'); $method->setAccessible(true); $output = $method->invoke ($myClass, $arg1, $arg2); 

One option would be to make c() protected instead of private and then subclass and override c(). Then test with your subclass. Another option would be to refactor c() out into a different class that you can inject into A (this is called dependency injection). And then inject a testing instance with a mock implementation of c() in your unit test.

Here's a variation of the other answers that can be used to make such calls one line:

public function callPrivateMethod($object, $methodName) { $reflectionClass = new \ReflectionClass($object); $reflectionMethod = $reflectionClass->getMethod($methodName); $reflectionMethod->setAccessible(true); $params = array_slice(func_get_args(), 2); //get all the parameters after $methodName return $reflectionMethod->invokeArgs($object, $params); } 

I came up with this general purpose class for my case:

/** * @author Torge Kummerow */ class Liberator { private $originalObject; private $class; public function __construct($originalObject) { $this->originalObject = $originalObject; $this->class = new ReflectionClass($originalObject); } public function __get($name) { $property = $this->class->getProperty($name); $property->setAccessible(true); return $property->getValue($this->originalObject); } public function __set($name, $value) { $property = $this->class->getProperty($name); $property->setAccessible(true); $property->setValue($this->originalObject, $value); } public function __call($name, $args) { $method = $this->class->getMethod($name); $method->setAccessible(true); return $method->invokeArgs($this->originalObject, $args); } } 

With this class you can now easily & transparently liberate all private functions/fields on any object.

$myObject = new Liberator(new MyObject()); /* @var $myObject MyObject */ //Usefull for code completion in some IDEs //Writing to a private field $myObject->somePrivateField = "testData"; //Reading a private field echo $myObject->somePrivateField; //calling a private function $result = $myObject->somePrivateFunction($arg1, $arg2); 

If performance is important, it can be improved by caching the properties/methods called in the Liberator class.

An alternative solution is to change your private method to a protected method and then mock.

$myMockObject = $this->getMockBuilder('MyMockClass') ->setMethods(array('__construct')) ->setConstructorArgs(array("someValue", 5)) ->setMethods(array('myProtectedMethod')) ->getMock(); $response = $myMockObject->myPublicMethod(); 

where myPublicMethod calls myProtectedMethod. Unfortunately we can not do this with private methods since setMethods can not find a private method where as it can find a protected method

You can use anonymous classes using PHP 7.

$mock = new class Concrete { private function bob():void { } }; 

In prior versions of PHP you can make a test class extending the base class.

When the target class is neither static nor final, I solve this kind of problem in a way close to @jgmjgm, by anonymously and locally extending the original class and therefore not testing the same method multiple times in different test cases :

$extent = new class ($args) extends A { private function c() { return $hardCodedValue; } }; 

Then I can test the behaviour of $extent->b() without executing again the potentially heavy c() method.