Returns whether a php.ini configuration is not correct.

@return bool php.ini configuration problem?
770864
public function hasPhpIniConfigIssue()
    {
        foreach ($this->requirements as $req) {
            if (!$req->isFulfilled() && $req instanceof PhpIniRequirement) {
                return true;
            }
        }

        return false;
    }
259149
final public function isConfigured()
	{
		$jname = $this->getJname();
		$result = false;

		if (!empty($jname)) {
			if (!isset(static::$status[$jname])) {
				$db = Factory::getDBO();
				$query = $db->getQuery(true)
					->select('status')
					->from('#__jfusion')
					->where('name = ' . $db->quote($jname));

				$db->setQuery($query);
				$result = $db->loadResult();
				if ($result >= 1) {
					$result = true;
				} else {
					$result = false;
				}
				static::$status[$jname] = $result;
			} else {
				$result = static::$status[$jname];
			}
		}
		return $result;
	}
900103
private static function checkEnvironment()
    {
        list($major, $minor) = explode('.', PHP_VERSION);

        if ((int) $major < 5 || ((int) $major === 5 && (int) $minor < 6)) {
            throw new ClientException('Incompatible PHP environment. Expecting PHP 5.6 or higher');
        }
    }
29205
public function isBehatConfigured() {

    // Verify that URIs required for Drupal and Behat are configured correctly.
    $local_behat_config = $this->getLocalBehatConfig();
    if ($this->getConfigValue('project.local.uri') != $local_behat_config->get('local.extensions.Behat\MinkExtension.base_url')) {
      $this->logger->warning('project.local.uri in blt.yml does not match local.extensions.Behat\MinkExtension.base_url in local.yml.');
      $this->logger->warning('project.local.uri = ' . $this->getConfigValue('project.local.uri'));
      $this->logger->warning('local.extensions.Behat\MinkExtension.base_url = ' . $local_behat_config->get('local.extensions.Behat\MinkExtension.base_url'));
      return FALSE;
    }

    // Verify that URIs required for an ad-hoc PHP internal server are
    // configured correctly.
    if ($this->getConfigValue('tests.run-server')) {
      if ($this->getConfigValue('tests.server.url') != $this->getConfigValue('project.local.uri')) {
        $this->logger->warning("tests.run-server is enabled, but the server URL does not match Drupal's base URL.");
        $this->logger->warning('project.local.uri = ' . $this->getConfigValue('project.local.uri'));
        $this->logger->warning('tests.server.url = ' . $this->getConfigValue('tests.server.url'));
        $this->logger->warning('local.extensions.Behat\MinkExtension.base_url = ' . $local_behat_config->get('local.extensions.Behat\MinkExtension.base_url'));

        return FALSE;
      }
    }

    // Verify that required Behat files are present.
    if (!$this->areBehatConfigFilesPresent()) {
      return FALSE;
    }

    return TRUE;
  }
101825
public function hasAnsiSupport(): bool
	{
		if($this->hasAnsiSupport === null)
		{
			$this->hasAnsiSupport = PHP_OS_FAMILY !== 'Windows' || (getenv('ANSICON') !== false || getenv('ConEmuANSI') === 'ON');
		}

		return $this->hasAnsiSupport;
	}
1018784
public function init(){
        $file= 'config';
        //Seleccion el archivo de configuracion correspondiente segun el MODO y el DOMINIO
        if($this->multiDomain && $this->domain){
            //Ya no importa el modo, se definio todo antes si busca o no por dominio
            //if(ENOLA_MODE == 'HTTP'){
                $file= $this->getConfigFile();
            //}else{
                //reset($this->configFiles);
                //$file= next($this->configFiles);
            //}
        }
        $config= $this->readConfigurationFile($file);
        //Define si muestra o no los errores y en que nivel de detalle dependiendo en que fase se encuentre la aplicacion
        switch ($config['environment']){
            case 'development':
                error_reporting(E_ALL);
                $this->error= 'ALL';
                break;
            case 'production':
                error_reporting(0);
                $this->error= 'NONE';
                break;
            default:
                //No realiza el llamado a funcion de error porque todavia no se cargo el modulo de errores
                $head= 'Configuration Error';
                $message= 'The environment is not defined in configuration.json';
                require $this->pathApp . 'errors/general_error.php';
                exit;
        } 
        //URL_APP: Url donde funciona la aplicacion
        $this->urlApp= $config['url_app'];
        //BASE_URL: Base relativa de la aplicacion - definida por el usuario en el archivo de configuracion    
        $pos= strlen($config['relative_url']) - 1;
        if($config['relative_url'][$pos] != '/'){
            $config['relative_url'] .= '/';
        }
        $this->relativeUrl= $config['relative_url'];
        //INDEX_PAGE: Pagina inicial. En blanco si se utiliza mod_rewrite
        $this->indexPage= $config['index_page'];
        //SESSION_PROFILE: Setea la clave en la que se guarda el profile del usuario
        $this->sessionProfile= "";
        if(isset($config['session-profile'])){
            $this->sessionProfile= $config['session-profile'];
        }
        
        //ENVIRONMENT: Indica el ambiente de la aplicacion
        $this->environment= $config['environment'];
        //AUTHENTICATION: Indica el metodo de autenticacion de la aplicacion
        $this->authentication= $config['authentication'];
        //SESSION_AUTOSTART: Indica si el framework inicia automaticamente la session
        $this->sessionAutostart= $config['session_autostart'];
        //AUTHORIZATION_FILE: Indica el archivo que contiene la configuracion de autorizacion
        $this->authorizationFile= $config['authorization_file'];
        //CONFIG_BD: archivo de configuracion para la base de datos
        if(isset($config['database']) && $config['database'] != ''){
            $this->databaseConfiguration= $config['database'];
        }        
        //Internacionalizacion: En caso que se defina se setea el locale por defecto y todos los locales soportados
        if(isset($config['i18n'])){
            $this->i18nDefaultLocale= $config['i18n']['default'];
            if(isset($config['i18n']['locales'])){
                $locales= str_replace(" ", "", $config['i18n']['locales']);
                $this->i18nLocales= explode(",", $locales);
            }
        }
        
        //Diferentes definiciones
        $this->librariesDefinition= isset($config['libs']) ? $config['libs'] : [];
        $this->dependenciesFile= $config['dependency_injection'];
        $this->controllersFile= $config['controllers'];
        $this->middlewaresDefinition= $config['middlewares'];
        $this->filtersBeforeDefinition= $config['filters'];
        $this->filtersAfterDefinition= $config['filters_after_processing'];
        
        if(isset($config['vars'])){
            $this->contextVars= $config['vars'];
        }
    }
141544
public function check()
    {

        $config = $this->getConfig();

        if (isset($config['ext'])) {
            $this->setExt($config['ext']);
        }

        if (isset($config['folder'])) {

            $folder = $config['folder'];
            $this->setFolder($folder);


            if(!$this->getFileSystem()->exists($folder))
            {
                $this->getFileSystem()->createDir($folder);
                chmod($folder, 0777);
            }
        }else{

            return false;
        }

        // we have do something else

        if (function_exists('gzcompress') && function_exists('gzuncompress')) {
            return true;
        }
    }
988561
private function _checkConfig() {
        // Check each configuration entry
        if (empty($this->_config) || !is_array($this->_config))
            throw new \InvalidArgumentException("Empty configuration or invalid configuration format");
        else if (empty($this->_config['app']))
            throw new \InvalidArgumentException("Application configuration not specified");
        else if (empty($this->_config['app']['name']))
            throw new \InvalidArgumentException("No application name specified under application configuration");
        else if (empty($this->_config['api']))
            throw new \InvalidArgumentException("Api configuration not specified");
        else if (empty($this->_config['api']['url']))
            throw new \InvalidArgumentException("No url specified under api configuration");
        else if (empty($this->_config['api']['sharedKey']))
            throw new \InvalidArgumentException("No shared key specified under api configuration");
        else if (empty($this->_config['api']['secretKey']))
            throw new \InvalidArgumentException("No secret key specified under api configuration");
    }
745431
public function isValidSize()
    {
        // If file was blocked via PHP for being excessive size, shortcut here
        switch ($this->tmpFile['error']) {
            case UPLOAD_ERR_INI_SIZE:
            case UPLOAD_ERR_FORM_SIZE:
                return false;
        }
        $maxSize = $this->getAllowedMaxFileSize($this->getFileExtension());
        return (!$this->tmpFile['size'] || !$maxSize || (int)$this->tmpFile['size'] < $maxSize);
    }
781131
private function isCacheValid()
    {
        if (!$this->cacheFile->exists()) {
            return false;
        }

        $cachedConfigTimestamp = $this->cacheFile->getTimestamp();

        /** @var \Bolt\Filesystem\Filesystem $configFs */
        $configFs = $this->app['filesystem']->getFilesystem('config');

        $configFiles = [
            'config.yml',
            'config_local.yml',
            'contenttypes.yml',
            'extensions.yml',
            'menu.yml',
            'permissions.yml',
            'routing.yml',
            'taxonomy.yml',
        ];
        foreach ($configFiles as $configFile) {
            $timestamp = $configFs->has($configFile) ? $configFs->get($configFile)->getTimestamp() : 0;
            if ($timestamp > $cachedConfigTimestamp) {
                // The configuration file timestamp is *newer* than the cache file's … invalidate!
                $this->invalidateCache();

                return false;
            }
        }

        return true;
    }
398312
public function isConfigured()
    {
        if (!empty($this->urlParts) && isset($this->solrMap[$this->className])) {
            return true;
        }
        return false;
    }
1046532
public function createHostedConfiguration() : bool
    {
        $retval = false;

        if ($this->apache_config_path) {
            $index_list = $this->nb_server->getSitesIndex();
            $index_list->iterate(
                function ($site_key, $nb_site) {
                    $this->createHostedFile($nb_site);

                    return true;
                }
            );
            $this->createHostedIndex($index_list);
            $retval = true;
        }

        return $retval;
    }
613632
public function isDrupalInstalled() {
    $this->logger->debug("Verifying that Drupal is installed...");
    $result = $this->executor->drush("sqlq \"SHOW TABLES LIKE 'config'\"")->run();
    $output = trim($result->getMessage());
    $installed = $result->wasSuccessful() && $output == 'config';

    return $installed;
  }
417540
public function checkDbConfig() {
        if (!$this->dbConfig || !$this->db) {
            $dbConfigs = array_keys(get_class_vars('DATABASE_CONFIG'));

            $this->out('Available database configurations:');

            foreach ($dbConfigs as $i => $db) {
                $this->out(sprintf('[%s] <info>%s</info>', $i, $db));
            }

            $this->out();

            $answer = $this->in('Which database should the queries be executed in?', array_keys($dbConfigs));

            if (isset($dbConfigs[$answer])) {
                $this->setDbConfig($dbConfigs[$answer]);
            } else {
                $this->checkDbConfig();
            }
        }

        $this->out(sprintf('Database Config: <info>%s</info>', $this->dbConfig));

        $answer = strtoupper($this->in('Is this correct?', array('Y', 'N')));

        if ($answer === 'N') {
            $this->dbConfig = null;
            $this->checkDbConfig();
        }

        // Check that database is connected
        if (!$this->db->isConnected()) {
            $this->err(sprintf('<error>Database connection for %s failed</error>', $this->dbConfig));
            return false;
        }

        $this->out('<success>Database check successful, proceeding...</success>');
        return true;
    }
669876
public function hasPhpConfigIssue()
    {
        foreach ($this->requirements as $req) {
            if (!$req->isFulfilled() && $req instanceof PhpConfigRequirement) {
                return true;
            }
        }

        return false;
    }
59706
public function ensureCorrectDebugSetting()
    {
        if (!defined('YII_DEBUG')) {
            return false;
        }
        if (!defined('YII_ENV')) {
            return false;
        }
        if (defined('YII_ENV') && YII_ENV !== 'dev') {
            return false;
        }
        if (defined('YII_DEBUG') && YII_DEBUG !== true) {
            return false;
        }

        return Yii::$app->getModule('user')->debug;
    }
732812
protected function _check() {
		$result = true;
		$this->out(__d('cake_installer', 'Checking PHP version'));
		$this->hr();
		$phpVesion = $this->InstallerCheck->checkPHPversion();
		if ($phpVesion !== null) {
			if ($phpVesion) {
				$state = '<success>' . __d('cake_installer', 'Ok') . '</success>';
			} else {
				$state = '<error>' . __d('cake_installer', 'Bad') . '</error>';
				$result = false;
			}
			$state = '[' . $state . ']';

			$message = ' * ' . __d('cake_installer', 'Current PHP version: %s', PHP_VERSION);
			$formattedMessage = $this->state->getState($message, $state, $this->maxWidth - 1);
		} else {
			$formattedMessage = __d('cake_installer', 'Ok');
		}
		$this->out($formattedMessage, 1);
		$this->hr();
		$this->nl(1);

		$this->out(__d('cake_installer', 'Checking PHP extensions'));
		$this->hr();
		$phpModules = $this->InstallerCheck->checkPhpExtensions();
		if ($phpModules !== null) {
			$result = true;
			$messages = [];
			$this->waiting->animateMessage();
			foreach ($phpModules as $moduleName => $moduleState) {
				switch ($moduleState) {
					case 2:
						$state = '<success>' . __d('cake_installer', 'Ok') . '</success>';
						break;
					case 1:
						$state = '<warning>' . __d('cake_installer', 'Ok') . '</warning>';
						break;
					default:
						$state = '<error>' . __d('cake_installer', 'Bad') . '</error>';
						$result = false;
				}
				$state = '[' . $state . ']';
				$message = ' * ' . __d('cake_installer', 'Checking module is loaded: \'%s\'', $moduleName);
				$messages[] = $this->state->getState($message, $state, $this->maxWidth - 1);
				$this->waiting->animateMessage();
			}
			$this->waiting->hideMessage();
		} else {
			$messages = __d('cake_installer', 'Ok');
		}
		$this->out($messages, 1);
		$this->hr();
		$this->nl(1);
		if ($result) {
			$this->out('<success>' . __d('cake_installer', 'Check completed successfully.') . '</success>');
		} else {
			$this->out('<error>' . __d('cake_installer', 'Check completed unsuccessfully.') . '</error>');
		}

		return $result;
	}