Returns an array of tokens this test wants to listen for.

@return array
161838
public function register()
    {
        return array(
            T_IF,
            T_ELSE,
            T_ELSEIF,
            T_SWITCH,
            T_WHILE,
            T_FOR,
            T_FOREACH,
            T_OPEN_PARENTHESIS,
            T_CLOSE_PARENTHESIS,
        );
    }
1136988
protected function getTokenReplaces()
    {
        $replaces = array();

        foreach ($this->tokens as $token => $value) {
            $key              = $this->getFormatter()->untokenize($token);
            $formatter        = $this->getTokenFormatter($key);
            $replaces[$token] = $formatter::format($value);
        }

        return $replaces;
    }
249768
public function peek()
    {
        $l = count($this->tokens);
        if ($l == 0) {
            return null;
        } else {
            return $this->tokens[$l - 1];
        }
    }
11384
private function getAssignedValue()
    {
        $this->match(DocLexer::T_IDENTIFIER);

        $tokens = array(
            array(DocLexer::T_IDENTIFIER, $this->lexer->token['value']),
            array(DocLexer::T_EQUALS),
        );

        $this->match(DocLexer::T_EQUALS);

        return array_merge($tokens, $this->getPlainValue());
    }
239541
private function get_token()
    {
        if ($this->last_token === 'TK_TAG_SCRIPT' || $this->last_token === 'TK_TAG_STYLE') { //check if we need to format javascript
            $type = substr($this->last_token, 7);
            $token = $this->get_contents_to($type);
            if (!is_string($token)) {
                return $token;
            }
            return array($token, 'TK_' . $type);
        }
        if ($this->current_mode === 'CONTENT') {
            $token = $this->get_content();

            if (!is_string($token)) {
                return $token;
            } else {
                return array($token, 'TK_CONTENT');
            }
        }

        if ($this->current_mode === 'TAG') {
            $token = $this->get_tag();

            if (!is_string($token)) {
                return $token;
            } else {
                $tag_name_type = 'TK_TAG_' . $this->tag_type;
                return array($token, $tag_name_type);
            }
        }
    }
1205154
public function getKeywords()
    {
        $keywords = [];

        foreach ($this->config()->get('global_keywords') as $k => $v) {
            $keywords[] = '<strong>'.$k.'</strong> ' . $v;
        }

        if ($this->NotifyOnClass && class_exists($this->NotifyOnClass)) {
            $dummy = singleton($this->NotifyOnClass);
            if ($dummy instanceof NotifiedOn || $dummy->hasMethod('getAvailableKeywords')) {
                $myKeywords = $dummy->getAvailableKeywords();
                
                if (is_array($myKeywords)) {
                    foreach ($myKeywords as $keyword => $desc) {
                        $keywords[] = '<strong>'.$keyword.'</strong> - '.$desc;
                    }
                }
            }
        }

        return $keywords;
    }
818684
private function getSearchSuggestions()
    {
        $tokens = $this->getTokens();
        $allResults = array();
        foreach ($tokens as $token) {
            $allResults = $this->getSearchSuggestion($token, $allResults);
        }
        return $allResults;
    }
496820
public function peek()
    {
        if (isset($this->tokens[$this->current + ++$this->peek])) {
            return $this->tokens[$this->current + $this->peek];
        } else {
            return null;
        }
    }
1317699
protected function getToken() {
    // Iterate over the supported tokens to find the token in the tokenized
    // path.
    foreach (array_keys($this->supportedTokens) as $token_name) {
      if (strpos($this->path, $token_name) !== FALSE) {
        return $token_name;
      }
    }
    return NULL;
  }
112784
public function getTokens() : array
    {
        return [
            'T_N' => self::T_N,
            'T_I' => self::T_I,
            'T_V' => self::T_V,
            'T_X' => self::T_X,
            'T_L' => self::T_L,
            'T_C' => self::T_C,
            'T_D' => self::T_D,
            'T_M' => self::T_M,
        ];
    }
262080
protected function parseArguments() {
    $token_name = $this->getToken();
    $delimiter = '/';
    $matches = array();
    if (preg_match($delimiter . preg_quote($token_name) . '<(.+)>.*' . $delimiter, $this->path, $matches)) {
      // Some arguments were found.
      return explode(',', $matches[1]);
    }
    return array();
  }
1361146
public function tags(): array
    {

        if (property_exists($this, 'tags')) {
            if (is_null($this->token))
                return array_merge($this->tags, ['public']);

            return array_merge($this->tags, ['character_id:' . $this->getCharacterId()]);
        }

        if (is_null($this->token))
            return ['unknown_tag', 'public'];

        return ['unknown_tag', 'character_id:' . $this->getCharacterId()];
    }
1090353
public function getTagTokens(): array
    {
        $iteratedPos = 0;
        $tagPositions = $this->getCommentStartToken()['comment_tags'];
        $tagTokens = [];

        /** @var int $tagPos */
        foreach ($tagPositions as $tagPos) {
            if ($tagPos >= $iteratedPos) {
                $tagTokens[$tagPos] = $this->tokens[$tagPos] + [
                    'contents' => $this->loadTagContentTokens($tagPos, $iteratedPos)
                ];
            }
        }

        return $tagTokens;
    }
1252891
public function connect() {
		if (! isset ( $this->apiTokens )) {
			$this->apiTokens = $this->_loadApiTokens ();
		}
		$token = $this->apiTokens->addToken ();
		$this->_addHeaderToken ( $token );
		return [ "access_token" => $token,"token_type" => "Bearer","expires_in" => $this->apiTokens->getDuration () ];
	}
662456
private function queryTokens()
    {
        $tokens = $this->getTokens();

        $queryNorm = $this->getQueryNorm($tokens);
        $results = array();
        foreach ($tokens as $token) {
            $results[$token] = $this->getResultsForToken($token, $queryNorm);
        }
        return $results;
    }
486036
public function getTokens()
    {
        $conditions = '';
        $params = array();
        $records = Oauth_TokenRecord::model()->findAll($conditions, $params);
        return Oauth_TokenModel::populateModels($records);
    }
767694
public function readToken(): Token
    {
        // List of types is reverse-sorted by frequency for typical locator.
        $typeList = [
            Token::TYPE_UNESCAPED,
            Token::TYPE_SLASH,
            Token::TYPE_ESCAPED,
        ];
        $token = $this->matchNextToken($typeList);
        if (null === $token) {
            // Checking for known syntax errors.
            $errorTypeList = [
                Token::TYPE_ERROR_INVALID_ESCAPE,
            ];
            $token = $this->matchNextToken($errorTypeList);
        }
        if (null === $token) {
            throw new UnknownSyntaxException("Unknown syntax error in source text");
        }
        return $token;
    }