@throws \Symfony\Component\DependencyInjection\Exception\BadMethodCallException

@return Reference[]
171780
private function defineParsers(ContainerBuilder $container): array
    {
        $testResultFactory = new Reference(TestResultFactory::class);
        $parserDefinitions = [
            TestStartParser::class => new Definition(TestStartParser::class),
            'paraunit.parser.pass_parser' => new Definition(GenericParser::class, [
                $testResultFactory,
                new Reference('paraunit.test_result.pass_container'),
                LogPrinter::STATUS_PASS,
            ]),
            'paraunit.parser.incomplete_parser' => new Definition(GenericParser::class, [
                $testResultFactory,
                new Reference('paraunit.test_result.incomplete_container'),
                LogPrinter::STATUS_ERROR,
                LogPrinter::MESSAGE_INCOMPLETE_TEST,
            ]),
            'paraunit.parser.skipped_parser' => new Definition(GenericParser::class, [
                $testResultFactory,
                new Reference('paraunit.test_result.skipped_container'),
                LogPrinter::STATUS_ERROR,
                LogPrinter::MESSAGE_SKIPPED_TEST,
            ]),
            'paraunit.parser.risky_parser' => new Definition(GenericParser::class, [
                $testResultFactory,
                new Reference('paraunit.test_result.risky_container'),
                LogPrinter::STATUS_ERROR,
                LogPrinter::MESSAGE_RISKY_TEST,
            ]),
            'paraunit.parser.warning_parser' => new Definition(GenericParser::class, [
                $testResultFactory,
                new Reference('paraunit.test_result.warning_container'),
                LogPrinter::STATUS_WARNING,
            ]),
            'paraunit.parser.failure_parser' => new Definition(GenericParser::class, [
                $testResultFactory,
                new Reference('paraunit.test_result.failure_container'),
                LogPrinter::STATUS_FAIL,
            ]),
            'paraunit.parser.error_parser' => new Definition(GenericParser::class, [
                $testResultFactory,
                new Reference('paraunit.test_result.error_container'),
                LogPrinter::STATUS_ERROR,
            ]),
            AbnormalTerminatedParser::class => new Definition(AbnormalTerminatedParser::class, [
                $testResultFactory,
                new Reference('paraunit.test_result.abnormal_terminated_container'),
                LogFetcher::LOG_ENDING_STATUS,
            ]),
            UnknownResultParser::class => new Definition(UnknownResultParser::class, [
                $testResultFactory,
                new Reference('paraunit.test_result.unknown_container'),
                '',
            ]),
        ];

        $parserReferences = [];
        foreach ($parserDefinitions as $name => $definition) {
            $container->setDefinition($name, $definition);
            $parserReferences[] = new Reference($name);
        }

        $container->setDefinition(DeprecationParser::class, new Definition(DeprecationParser::class, [
            new Reference('paraunit.test_result.deprecation_container'),
        ]));

        return $parserReferences;
    }
1346832
private function getProxyMethods(): array
    {
        if (null !== $this->reflectionProxyMethods) {
            return $this->reflectionProxyMethods;
        }

        $proxyMethods = [];
        $methods = $this->getClassMethods();

        foreach ($methods as $method) {
            $docComment = $method->getDocComment();

            if (\strpos($docComment, 'Transactional') !== false) {
                $annotation = $this->annotationReader->getMethodAnnotation(
                    $method,
                    Transactional::class
                );

                if ($annotation) {
                    $proxyMethods[] = $method;
                }
            }
        }

        $this->reflectionProxyMethods = $proxyMethods;

        return $proxyMethods;
    }
1072303
private function getDependencies(): array
    {
        return [
            'invokables' => [
                NullLogger::class => NullLogger::class,
            ],
            'factories' => [
                Job\JobManager::class => Job\JobManagerFactory::class,
                Job\Strategy\ContainerStrategy::class => Job\Strategy\ContainerStrategyFactory::class,
                Queue\QueueManager::class => Queue\QueueManagerFactory::class,
                Queue\Strategy\Simple::class => Queue\Strategy\SimpleFactory::class,
                Worker\Worker::class => Worker\WorkerFactory::class,
                Worker\WorkerManager::class => Worker\WorkerManagerFactory::class,
            ],
        ];
    }
1303286
public function resolve(): array
    {
        if (\is_array($this->schema)) {
            if (isset($this->schema['$ref'])) {
                $ref = $this->schema['$ref'];

                if ($ref === '#') {
                    return $this->rootSchema;
                }
                if (\preg_match('/^#\/[a-z0-9_-]+(\/[a-z0-9_-]+)?$/i', $ref)) {
                    $schema = $this->rootSchema;
                    $path = \explode('/', substr($ref, 2));

                    foreach ($path as $item) {
                        if (!isset($schema[$item])) {
                            throw new ResolveSchemaReferenceException($ref);
                        }
                        $schema = $schema[$item];
                    }
                    return $schema;
                }
                throw new ResolveSchemaReferenceException($ref);
            }
            return $this->schema;
        }
        if (\filter_var(
            $this->schema,
            \FILTER_VALIDATE_URL, \FILTER_FLAG_SCHEME_REQUIRED | \FILTER_FLAG_HOST_REQUIRED
        )) {
            return $this->loadSchema($this->schema);
        }
        throw new ResolveSchemaException();
    }
314582
public function getChildren()
    {
        $children = new ArrayCollection();
        if ($this->reference) {
            $children->add($this->reference);
        }

        return $children;
    }
455105
public function getReferences() {
		if (count($this->references) == 0) {
			$this->references = EntityReflexion::getReferences(get_class($this));
		}
		return $this->references;
	}
765191
public function getAddons()
    {
        $apiAddons = [];
        $addons = $this->entity->getAddons();
        /** @var AddonEntity $addon */
        foreach ($addons as $addon) {
            $apiAddon = $this->productFactory->createAddonProductApiEntity(
                $addon->getAddon(),
                $this->locale,
                iterator_to_array($addon->getAddonPrices())
            );

            $apiAddons[] = $apiAddon;
        }

        return $apiAddons;
    }
1085002
public function getFrom()
    {
        $result = [];
        $params = [];

        $refCount = $this->query->aliasRefCount;

        foreach ($this->query->tablesAliasList as $alias) {
            if (!ArrayHelper::getValue($refCount, $alias)) {
                continue;
            }

            try {
                /** @var $from BaseJoin */
                $from = ArrayHelper::getValue(
                    $this->query->tableJoinsMap,
                    $alias,
                    ArrayHelper::STRICT
                );

                list($fromSql, $fromParams) = $this->compile($from);
                array_push($result, $fromSql);

                $params = array_merge($params, $fromParams);
            } catch (KeyError $e) {
                continue;
            }
        }

        return [$result, $params];
    }
549900
public function getReferenceRepository()
    {
        if ( ! $this->referenceRepository) {
            $this->referenceRepository = new ProxyReferenceRepository($this->entityManager);
        }

        return $this->referenceRepository;
    }
68504
public function getClassAndMethodNamesForCalling(): array
    {
        $domain = $this->consoleInput->getDomainName();
        $action = $this->consoleInput->getActionName();

        $className = self::getFQDNClass($domain);

        return [$className, $domain, $action];
    }
1138457
public function getComponents () : array
    {
        if (null === $this->components)
        {
            $this->components = $this->loader->loadComponents($this);
        }

        return $this->components;
    }
167185
public function getCompilerPasses(): array
    {
        $mappingBagProvider = $this->getMappingBagProvider();

        return $mappingBagProvider instanceof MappingBagProvider
            ? array_merge(
                parent::getCompilerPasses(),
                [new MappingCompilerPass($mappingBagProvider)]
            )
            : parent::getCompilerPasses();
    }
1320036
public function getReferencedAttributes()
    {
        $objAttribute = null;
        if (!($this->get('attr_id')
            && ($objAttribute = $this->getMetaModel()->getAttributeById($this->get('attr_id'))))) {
            return [];
        }

        return $objAttribute ? [$objAttribute->getColName()] : [];
    }
168415
public function getSetters(): array
    {
        if (null !== $this->setters) {
            return $this->setters;
        }
        $skip            = [
            'addPropertyChangedListener'     => true,
            'setEntityCollectionAndNotify'   => true,
            'addToEntityCollectionAndNotify' => true,
            'setEntityAndNotify'             => true,
        ];
        $this->setters   = [];
        $reflectionClass = $this->getReflectionClass();
        foreach ($reflectionClass->getMethods(
            \ReflectionMethod::IS_PRIVATE | \ReflectionMethod::IS_PUBLIC
        ) as $method) {
            $methodName = $method->getName();
            if (isset($skip[$methodName])) {
                continue;
            }
            if (\ts\stringStartsWith($methodName, 'set')) {
                $this->setters[$this->getGetterForSetter($methodName)] = $methodName;
                continue;
            }
        }

        return $this->setters;
    }
983067
protected function getMappingClasses(): array
    {
        AnnotationRegistry::registerLoader('class_exists');

        $mappingClasses = [];

        foreach ($this->locator->getMappingFiles() as $annotationFile) {
            $mappingClasses[] = $this->loadClassFromFile($annotationFile);
        }

        return \array_map(
            function (string $sourceClass) {
                return new \ReflectionClass($sourceClass);
            },
            \array_filter(\array_unique($mappingClasses))
        );
    }
516474
protected function resolveDependants(): array
    {
        $dependants = [];
        $modules = $this->manager->modules();

        foreach ($modules as $name => $module) {
            if ($name === $this->name) {
                continue;
            }
            $dependencies = $module->dependencies();
            if (isset($dependencies[$this->name])) {
                $dependants[$name] = $module;
            }
        }

        return $dependants;
    }
1071569
private function getServices()
    {
        $container = new DependencyInjectionContainer();
        $components = $this->getComponents();

        foreach ($components as $component) {
            // Sometimes on failures due to invalid configuration, components might return void
            if (is_object($component)) {
                $container->register($component->getName(), $component->getInstance($container, $this->config, $this->input));
            }
        }

        return $container->getAll();
    }