@param \Keios\Apparatus\Contracts\LoaderInterface $scenarioLoader

@throws \Keios\Apparatus\Exceptions\InvalidScenarioConfigurationException
357785
protected function getScenariosFrom(LoaderInterface $scenarioLoader)
    {
        if (!is_array($loadedScenarios = $scenarioLoader->loadScenarios())) {
            throw new InvalidScenarioConfigurationException('Scenario registration list must be an array!');
        }

        $this->registeredScenarios = $loadedScenarios;
    }
455381
protected function loadAspectKernel(InputInterface $input, OutputInterface $output): void
    {
        $loader = $input->getArgument('loader');
        $path   = stream_resolve_include_path($loader);
        if (!is_readable($path)) {
            throw new InvalidArgumentException("Invalid loader path: {$loader}");
        }

        ob_start();
        include_once $path;
        ob_clean();

        if (!class_exists(AspectKernel::class, false)) {
            $message = "Kernel was not initialized yet, please configure it in the {$path}";
            throw new InvalidArgumentException($message);
        }

        $this->aspectKernel = AspectKernel::getInstance();
    }
483791
public function load(RouteLoaderInterface $loader, $forceValidate = false)
    {
        if (!$this->isValid($forceValidate)) {
            $loader->addListener($this);
            $this->doLoadResources($loader, $forceValidate);
            $loader->removeListener($this);
        }

        return $this->storage->read();
    }
513861
public function registerContainerConfiguration(LoaderInterface $loader)
    {
        $loader->load(__DIR__.'/../config/config.yml');

        foreach ($this->extraConfigFiles as $configFile) {
            $loader->load($configFile);
        }
    }
381667
public void registerLoaderIndicators(By... loaderIndicators) {
    	for(By locator : loaderIndicators) {
    		log.debug("Registered loader: " + locator);
    		this.expectedGlobalConditions.add(new ExpectedWebElementCondition(locator));
    	}
    }
424040
public function register(FixtureLoader $loader)
    {
        $value = new Pair($loader->getName(), $loader);
        $this->loaders->add($value);
        return $this;
    }
1301755
public function bind($eventName, $scenarioClassName)
    {
        if (!is_callable($scenarioClassName)) {
            $this->assertScenarioExists($scenarioClassName);
            $this->assertScenarioIsRunnable($scenarioClassName);
        }

        // todo solve multiple event bindings problem
        // actual solution is to rebind, latest binding wins

        $this->registeredScenarios[$eventName] = $scenarioClassName;
    }
936905
public function beforeScenario(ScenarioTested $event)
    {
        if ($this->skipCoverage) {
            return;
        }

        $node = $event->getScenario();
        $id   = $event->getFeature()->getFile().':'.$node->getLine();

        $this->coverage->start($id);
    }
502746
public function registerContainerConfiguration(LoaderInterface $loader, array $managerConfig)
    {
        $loader->load('@HeimrichHannotContaoUtilsBundle/Resources/config/services.yml');
        $loader->load('@HeimrichHannotContaoUtilsBundle/Resources/config/listener.yml');
        $loader->load('@HeimrichHannotContaoUtilsBundle/Resources/config/parameters.yml');
        $loader->load('@HeimrichHannotContaoUtilsBundle/Resources/config/utils.yml');
    }
1330164
public function attachLoader(LoaderInterface $loader, $key = '')
    {
        if (empty($key)) {
            $this->loaders[] = $loader;
        } else {
            $this->loaders[$key] = $loader;
        }
    }
987186
public function load(LoaderInterface $loader, $merge = true)
    {
        $this->internalLoad($loader->load(), $merge);
    }
999910
public function removeListenerLoader($loader)
	{
		if ($loader instanceof LoaderInterface)
		{
			$loader = $loader->getName();
		}

		if (isset($this->loaders[$loader]))
		{
			unset($this->loaders[$loader]);
		}

		return $this;
	}
1066104
public function addFileLoader(FileLoaderInterface $fileLoader)
    {
        foreach ($fileLoader->getValidExtensions() as $extension) {
            $this->fileLoaders[$extension] = $fileLoader;
        }
    }
792656
public function setLoaders($loaders)
    {
        if ($loaders instanceof LoaderInterface) {
            $loaders = [$loaders];
        }

        foreach ($loaders as $name => $loader) {
            $this->setLoader($name, $loader);
        }
    }
64026
protected function executeLoader(LoaderInterface $loader)
    {
        $offset = 0;

        try {

            while ($result = $loader->load($this->limit, $offset)) {

                $this->persist($result);
                $offset += $this->limit;
            }

        } catch (LoaderException $e) {
            $this->getLogger()->error($e->getMessage());
        }
    }
486051
public static function addAdapter(AnLoaderAdapterInterface $adapter)
    {
        self::$_adapters[$adapter->getType()] = $adapter;
        self::$_prefix_map[$adapter->getPrefix()] = $adapter->getType();
    }
298876
public function setDownloader(DownloaderInterface $downloader = null)
    {
        if (null === $downloader) {
            $downloader = $this->defaultDownloader();
        }
        $this->downloader = $downloader;
    }