Return an array that contains
each suite's instant feedback. Since
logs do not contain skipped or incomplete
tests this array will contain any number of the following
characters: .,F,E
TODO: Update this, skipped was added in phpunit.

@return array
974735
public function getFeedback(): array
    {
        $feedback = [];
        $suites = $this->isSingle ? $this->suites : $this->suites[0]->suites;
        foreach ($suites as $suite) {
            foreach ($suite->cases as $case) {
                if ($case->failures) {
                    $feedback[] = 'F';
                } elseif ($case->errors) {
                    $feedback[] = 'E';
                } elseif ($case->skipped) {
                    $feedback[] = 'S';
                } else {
                    $feedback[] = '.';
                }
            }
        }

        return $feedback;
    }
1188751
private function getShrinkedSession()
    {
        $serialized = '';
        if (isset($_SESSION)) {
            $serialized = serialize($_SESSION);
        }
        if (strlen($serialized) > 64000) {
            $sessionCopy = $_SESSION;
            $ignoredKeys = array();
            foreach ($_SESSION as $key => $value) {
                $size = strlen(serialize($value));
                if ($size > 1000) {
                    unset($sessionCopy[$key]);
                    $ignoredKeys[$key] = $key;
                }
            }
            $sessionCopy['__ignored_keys_in_audit'] = $ignoredKeys;
            $serialized = serialize($sessionCopy);
        }
        return unserialize($serialized);
    }
1033921
protected function getDefaultFormats()
    {
        return [
            [
                'type' => Token::TYPE_KEYWORD,
                'flags' => Token::FLAG_KEYWORD_RESERVED,
                'html' => 'class="sql-reserved"',
                'cli' => "\x1b[35m",
                'function' => 'strtoupper',
            ],
            [
                'type' => Token::TYPE_KEYWORD,
                'flags' => 0,
                'html' => 'class="sql-keyword"',
                'cli' => "\x1b[95m",
                'function' => 'strtoupper',
            ],
            [
                'type' => Token::TYPE_COMMENT,
                'flags' => 0,
                'html' => 'class="sql-comment"',
                'cli' => "\x1b[37m",
                'function' => '',
            ],
            [
                'type' => Token::TYPE_BOOL,
                'flags' => 0,
                'html' => 'class="sql-atom"',
                'cli' => "\x1b[36m",
                'function' => 'strtoupper',
            ],
            [
                'type' => Token::TYPE_NUMBER,
                'flags' => 0,
                'html' => 'class="sql-number"',
                'cli' => "\x1b[92m",
                'function' => 'strtolower',
            ],
            [
                'type' => Token::TYPE_STRING,
                'flags' => 0,
                'html' => 'class="sql-string"',
                'cli' => "\x1b[91m",
                'function' => '',
            ],
            [
                'type' => Token::TYPE_SYMBOL,
                'flags' => 0,
                'html' => 'class="sql-variable"',
                'cli' => "\x1b[36m",
                'function' => '',
            ],
        ];
    }
852743
public function getParsedExceptions()
    {
        $parsedExceptions = [];

        $exceptions = $this->getExceptionLinesFromLogFile();
        foreach ($exceptions as $exception) {
            $parsedExceptions[] = str_replace('\\\\', '\\', $exception);
        }

        return $parsedExceptions;
    }
224952
private function getStatementLexingMethods() : array
    {
        $statements = [
            $this->directiveDelimiters[0] => 'lexDirectiveStatement',
            $this->sanitizedTagDelimiters[0] => 'lexSanitizedTagStatement',
            $this->unsanitizedTagDelimiters[0] => 'lexUnsanitizedTagStatement',
            $this->commentDelimiters[0] => 'lexCommentStatement',
            '<?php' => 'lexPhpStatement',
            '<?' => 'lexPhpStatement'
        ];

        /**
         * In case one delimiter is a substring of the other ("{{" and "{{!"), we want to sort the delimiters
         * so that the longest delimiters come first
         */
        uksort($statements, function ($a, $b) {
            if (strlen($a) > strlen($b)) {
                return -1;
            } else {
                return 1;
            }
        });

        return $statements;
    }
658778
public function getStubStmts(): array
    {
        foreach ($this->classLikes as $classLike) {
            $this->resolveClassLike($classLike);
        }

        if ($this->allAreGlobal($this->namespaces) && $this->allAreGlobal($this->classLikeNamespaces)) {
            return array_merge(
                $this->reduceStmts($this->classLikeNamespaces),
                $this->reduceStmts($this->namespaces),
                $this->globalNamespace->stmts,
                $this->globalExpressions
            );
        }

        return array_merge(
            $this->classLikeNamespaces,
            $this->namespaces,
            $this->globalNamespace->stmts ? [$this->globalNamespace] : [],
            $this->globalExpressions ? [new Namespace_(null, $this->globalExpressions)] : []
        );
    }
822186
public function getRequirementStrings()
    {
        $strings = [];
        foreach ($this->getValidators() as $validator) {
            $validator_strings = $validator->getRequirementStrings();
            $strings = array_merge($strings, $validator_strings);
        }

        return $strings;
    }
594369
protected function getContextMessage()
    {
        $context = [];
        foreach ($this->logVars as $name) {
            if (!empty($GLOBALS[$name])) {
                $context[] = "\${$name} = " . VarDumper::dumpAsString($GLOBALS[$name]);
            }
        }

        return implode("\n\n", $context);
    }
73105
private function getNewUseStatements(): string
    {
        $this->sortUseStatements();

        $file = $this->getFile()->getBaseFile();

        return implode(
            $file->eolChar,
            array_map(
                function (UseStatement $useStatement) use ($file): string {
                    $unqualifiedName = NamespaceHelper::getUnqualifiedNameFromFullyQualifiedName(
                        $useStatement->getFullyQualifiedTypeName()
                    );

                    $useTypeName = UseStatementHelper::getTypeName($file, $useStatement);
                    $useTypeFormatted = $useTypeName ? sprintf('%s ', $useTypeName) : '';

                    return ($unqualifiedName === $useStatement->getNameAsReferencedInFile())
                        ? sprintf(
                            'use %s%s;',
                            $useTypeFormatted,
                            $useStatement->getFullyQualifiedTypeName()
                        )
                        : sprintf(
                            'use %s%s as %s;',
                            $useTypeFormatted,
                            $useStatement->getFullyQualifiedTypeName(),
                            $useStatement->getNameAsReferencedInFile()
                        );
                },
                $this->useStatements
            )
        );
    }
201585
public function getDeclareStrictTypeSequence(): array
    {
        if (self::$cachedDeclareStrictTypeTokens) {
            return self::$cachedDeclareStrictTypeTokens;
        }

        $tokens = [
            new Token([T_DECLARE, 'declare']),
            new Token('('),
            new Token([T_STRING, 'strict_types']),
            new Token('='),
            new Token([T_LNUMBER, '1']),
            new Token(')'),
            new Token(';'),
        ];

        return self::$cachedDeclareStrictTypeTokens = $tokens;
    }
172253
public function flattenCases(): array
    {
        $dict = [];
        foreach ($this->getCases() as $case) {
            if (!isset($dict[$case->file])) {
                $dict[$case->file] = new TestSuite($case->class, 0, 0, 0, 0, 0, 0);
            }
            $dict[$case->file]->cases[] = $case;
            ++$dict[$case->file]->tests;
            $dict[$case->file]->assertions += $case->assertions;
            $dict[$case->file]->failures += \count($case->failures);
            $dict[$case->file]->errors += \count($case->errors);
            $dict[$case->file]->skipped += \count($case->skipped);
            $dict[$case->file]->time += $case->time;
            $dict[$case->file]->file = $case->file;
        }

        return array_values($dict);
    }
17450
protected static function formatDebugDumps () {
		$dumps = '';
		$lastDump = FALSE;
		$app = static::$app ?: (static::$app = & \MvcCore\Application::GetInstance());
		$appRoot = $app->GetRequest()->GetAppRoot();
		foreach (self::$dumps as $values) {
			list($dumpResult, $lastDumpLocal) = self::formatDebugDump($values, $appRoot);
			$dumps .= $dumpResult;
			if ($lastDumpLocal) $lastDump = $lastDumpLocal;
		}
		return [$dumps, $lastDump];
	}
1113726
public function getNext() {
		$nextPrompt = array();
		$prompts = $this->getPrompts();

		foreach ( $prompts as $prompt ) {
			$isDismissed      = isset( $prompt['time_dismissed'] );
			$isOlder          = empty( $nextPrompt ) || ( ! $isDismissed && $prompt['time_added'] < $nextPrompt['time_added'] );
			$isStillSnoozing  = ! empty( $prompt['time_snoozed_until'] ) && $prompt['time_snoozed_until'] > time();

			if ( ! $isDismissed && $isOlder && ! $isStillSnoozing ) {
				$nextPrompt = $prompt;
			}
		}

		if ( ! $this->isMinInterval() ) {
			$nextPrompt = array();
		}

		return $nextPrompt;
	}
600612
public function losLogMe()
    {
        $ret = [];
        $ret[get_class($this)] = [];
        foreach (get_object_vars($this) as $name => $content) {
            if (! is_object($content)) {
                $ret[$name] = ['type' => gettype($content), 'content' => $content];
            } else {
                $ret[$name] = ['type' => gettype($content), 'class' => get_class($content)];
            }
        }

        return $ret;
    }
1335191
public function getLogsLevel()
    {
        $levels = $this->createQueryBuilder()
                       ->select('l.level, l.level_name, COUNT(l.id) AS count')
                       ->from($this->tableName, 'l')
                       ->groupBy('l.level, l.level_name')
                       ->orderBy('l.level', 'DESC')
                       ->execute()
                       ->fetchAll();

        $normalizedLevels = array();
        foreach ($levels as $level) {
            $normalizedLevels[$level['level']] = sprintf('%s (%s)', $level['level_name'], $level['count']);
        }

        return $normalizedLevels;
    }
791580
public function getVarDeclarations()
	{
		asort($this->jsLengths);

		$src = '';
		foreach (array_keys($this->jsLengths) as $varName)
		{
			$configValue = $this->configValues[$varName];
			if ($configValue->isDeduplicated())
			{
				$src .= '/** @const */ var ' . $varName . '=' . $this->encoder->encode($configValue->getValue()) . ";\n";
			}
		}

		return $src;
	}
14122
private function getSuffixesToTry()
    {
        if ($this->suffixesToTry === null) {
            $this->suffixesToTry = [];

            if (isset($this->conf['salutation'])) {
                if ($this->conf['salutation'] === 'informal') {
                    $this->suffixesToTry[] = '_informal';
                }
                $this->suffixesToTry[] = '_formal';
            }
            $this->suffixesToTry[] = '';
        }

        return $this->suffixesToTry;
    }