Can not access to private methods, only public and protected.

@param string $methodName
@param string $statedClassOrigin

@return bool
321260
private function checkVisibilityProtected(string &$methodName, string &$statedClassOrigin): bool
    {
        if (false === $this->reflectionsMethods[$methodName]->isPrivate()
            && !empty($statedClassOrigin)
            && ($statedClassOrigin === $this->statedClassName
                || \is_subclass_of($statedClassOrigin, $this->statedClassName))) {
            //It's a public or protected method, do like if there is no method
            return true;
        }

        return false;
    }
571407
private static function collectBefore(string $className, string $methodName)
    {
        if (!isset(self::$aspects[$className])) {
            return null;
        }

        self::$aspects[$className]['advice']['before'] = [$className, $methodName];
    }
155274
public static function createAggregateQueryHandlerWith(string $inputChannelName, string $aggregateClassName, string $methodName): self
    {
        return new self($inputChannelName, $aggregateClassName, $methodName, false, "", true);
    }
1084337
protected function buildCallParentMethodCode($fullClassName, $methodName)
    {
        if (!$this->reflectionService->hasMethod($fullClassName, $methodName)) {
            return '';
        }
        return 'parent::' . $methodName . '(' . $this->buildMethodParametersCode($fullClassName, $methodName, false) . ");\n";
    }
164485
public function isClassAnnotatedWith($className, $annotationClassName)
    {
        if (!$this->initialized) {
            $this->initialize();
        }
        $className = $this->cleanClassName($className);

        $annotationClassName = $this->cleanClassName($annotationClassName);

        return (isset($this->annotatedClasses[$annotationClassName][$className]));
    }
1253848
private static function deprecated($methodName)
    {
        $message = 'Use of ' . $methodName . ' and the whole ShopgateConfigOld class is deprecated.';
        trigger_error($message, E_USER_DEPRECATED);
        ShopgateLogger::getInstance()->log($message);
    }
600703
public boolean usesMethod(String className, String methodName) {
		int classIndex = findClass(className);
		if (classIndex == NOT_FOUND) return false;
		int methodNameIndex = findUtf8(methodName);
		if (methodNameIndex == NOT_FOUND) return false;
		
		for (int i = 1; i < maxPoolSize; i++) {
			if (isMethod(i) && readValue(offsets[i]) == classIndex) {
				int nameAndTypeIndex = readValue(offsets[i] + 2);
				if (readValue(offsets[nameAndTypeIndex]) == methodNameIndex) return true;
			}
		}
		return false;
	}
917318
public function hasMethod($className, $methodName)
    {
        $className = $this->prepareClassReflectionForUsage($className);
        return isset($this->classReflectionData[$className][self::DATA_CLASS_METHODS][$methodName]);
    }
863007
public static function createAggregateCommandHandlerWith(string $inputChannelName, string $aggregateClassName, string $methodName): self
    {
        return new self($inputChannelName, $aggregateClassName, $methodName, true, "", true);
    }
566571
protected function generateMethod($methodName)
    {
        $methodReflection = $this->_method[$methodName];

        $docBlock = new DocBlockGenerator();
        $docBlock->setShortDescription("Delicate $methodName() to __call() method ");

        if ($methodReflection->getDocComment()) {
            $docBlockReflection = new DocBlockReflection($methodReflection);
            $docBlock->fromReflection($docBlockReflection);
        }

        $method = new MethodGenerator();
        $method->setName($methodName);
        $method->setDocBlock($docBlock);
        $method->setBody(sprintf(self::METHOD_TEMPLATE, $methodName));

        if ($methodReflection->isPublic()) {
            $method->setVisibility(MethodGenerator::VISIBILITY_PUBLIC);
        } else if ($methodReflection->isProtected()) {
            $method->setVisibility(MethodGenerator::VISIBILITY_PROTECTED);
        } else if ($methodReflection->isPrivate()) {
            $method->setVisibility(MethodGenerator::VISIBILITY_PRIVATE);
        }

        foreach ($methodReflection->getParameters() as $parameter) {

            $parameterGenerator = new ParameterGenerator();
            $parameterGenerator->setPosition($parameter->getPosition());
            $parameterGenerator->setName($parameter->getName());
            $parameterGenerator->setPassedByReference($parameter->isPassedByReference());

            if ($parameter->isDefaultValueAvailable()) {
                $parameterGenerator->setDefaultValue($parameter->getDefaultValue());
            }
            if ($parameter->isArray()) {
                $parameterGenerator->setType('array');
            }
            if ($typeClass = $parameter->getClass()) {
                $parameterGenerator->setType($typeClass->getName());
            }

            $method->setParameter($parameterGenerator);
        }
        $this->addMethodFromGenerator($method);
    }
84638
public function isMethodSupported(MethodReflection $methodReflection) : bool {
        if (!static::$methodNames) throw new RuntimeException('The class property '.static::class.'::$methodNames must be defined.');
        return in_array($methodReflection->getName(), static::$methodNames);
    }
279637
public function replaceReservedMethod($methodName, $context = null)
    {
        if ($this->getReservedMethodsInstance()->is($methodName)) {
            if ($context !== null) {
                $methodKey = $methodName . '_' . $context;
                if (!array_key_exists($methodKey, $this->replacedReservedMethods)) {
                    $this->replacedReservedMethods[$methodKey] = 0;
                } else {
                    $this->replacedReservedMethods[$methodKey]++;
                }
                return '_' . $methodName . ($this->replacedReservedMethods[$methodKey] ? '_' . $this->replacedReservedMethods[$methodKey] : '');
            } else {
                return '_' . $methodName;
            }
        } else {
            return $methodName;
        }
    }
1341409
private function createMethod(ClassReflection $classReflection, \ReflectionFunction $functionReflection, string $methodName): MethodReflection
    {

        $phpDocParameterTypes = [];
        $phpDocReturnType = null;
        if ($functionReflection->getFileName() !== false && $functionReflection->getDocComment() !== false) {
            $resolvedPhpDoc = $this->fileTypeMapper->getResolvedPhpDoc(
                $functionReflection->getFileName(),
                null,
                $functionReflection->getDocComment()
            );

            $phpDocParameterTypes = array_map(function (ParamTag $tag): Type {
                return $tag->getType();
            }, $resolvedPhpDoc->getParamTags());
            $phpDocReturnType = $resolvedPhpDoc->getReturnTag() !== null ? $resolvedPhpDoc->getReturnTag()->getType() : null;
        }

        return $this->methodReflectionFactory->create(
            $classReflection,
            new ReflectionMethodFunctionProxy($classReflection->getName(), $methodName, $functionReflection),
            $phpDocParameterTypes,
            $phpDocReturnType
        );
    }
394286
public static function bindStatic($className, $methodName, $args = null)
    {
        if (empty($args)) {
            $args = null;
        }
        $native = [$className, $methodName];
        $callback = function () use ($native, $args) {
            $a = func_get_args();
            if ($args !== null) {
                $a = array_merge($a, $args);
            }
            return call_user_func_array($native, $a);
        };
        return $callback->bindTo(null, $className);
    }
787478
private static function methodExists(string $method, string $className): bool
    {
        return method_exists($className, $method) || resolve($className)->hasMethod($method);
    }
785161
private function checkMethodExists($className, $methodName)
    {
        if (!$this->isMethodAvailable($className, $methodName)) {
            throw new Exception(Piwik::translate('General_ExceptionMethodNotFound', array($methodName, $className)));
        }
    }
613974
protected function loadOriginalClassAndSetAliases($originalClassName)
    {
        if ($this->classOrInterfaceExists($originalClassName) || $this->loadClass($originalClassName)) {
            foreach ($this->aliasMap['classNameToAliasMapping'][$originalClassName] as $aliasClassName) {
                if (!$this->classOrInterfaceExists($aliasClassName)) {
                    class_alias($originalClassName, $aliasClassName);
                }
            }

            return true;
        }

        return null;
    }