Filtering the response header, load the data and check it
@param string $paramName
@return void
777501
public function loadResponseHeader($paramName)
    {
        $headers = $this->getResponseHeader();

        if (array_key_exists($paramName, $headers)) {
            $this->contextDataExists = true;
            $this->contextDataValue  = $headers[$paramName];
        }

        return $this->checkDataIsEmpty();
    }
280996
public function view($filename)
    {
        $serialized = false;

        if ($this->request->getQuery('as') === 'serialized') {
            $serialized = true;
            $this->viewBuilder()->setTemplate('view_as_serialized');
        }

        $content = $this->read($filename, $serialized);

        $this->set(compact('content', 'filename'));
    }
20456
protected function param($paramName)
    {
        $fallbacks = $this->getDefaultParamsNonPersistentCached();

        if ($paramName == 'content') {
            return $this->content
                ? $this->content
                : $fallbacks['content'];
        }

        if (isset($this->params[$paramName])) {
            return $this->params[$paramName];
        } elseif (isset($fallbacks[$paramName])) {
            return $fallbacks[$paramName];
        } else {
            return null;
        }
    }
426097
public function readParam(string $paramName): ValueReader
    {
        return new ValueReader(
                $this->params->errors(),
                $paramName,
                $this->params->value($paramName)
        );
    }
84477
private function arrayValueChecker($paramName, $value)
        {
            if (isset($this->httpConfigs[$paramName])) {
                foreach ($value as $val) {
                    if (true === $this->stringValueChecker($paramName, $val)) {
                        return true;
                    }
                }
            } else {
                return false;
            }
        }
1164981
public function loadRequestBody()
    {
        if (array_key_exists('php://input', $this->mockedData)) {
            $this->loadBodyByContent($this->getRequestHeader(), $this->mockedData['php://input']);
        }
        else {
            $this->loadBodyByContent($this->getRequestHeader(), file_get_contents("php://input"));
        }
    }
594529
public function onKernelResponse(FilterResponseEvent $event)
    {
        $event->getResponse()->headers->set(self::HEADER_NAME, $this->requestId->get());
    }
536939
protected function passes($fieldname = null) {
		
		$helper = new StringToArray();
		return true === Request :: isPost() && null === $helper -> execute($fieldname, null, Message :: getErrors(true));
	}
575762
public function getHeader(string $headerName)
	{
		return $this->hasHeader($headerName) ? $this->headers[ $headerName ] : null;
	}
1346548
public static function validateEquality($paramName, array $data,
                                            array $params = [])
    {
        $result = true;

        if (!isset($data[$paramName])) {
            throw new \Exception('Parameter is not set');
        }
        if (!isset($params['equalTo'])) {
            throw new \Exception('Parameter \'equalTo\' is required');
        }

        if ($data[$paramName] !== $data[$params['equalTo']]) {
            $result = false;
        }

        return $result;
    }
1048267
public function amOnRoute($routeName, $params = [])
    {
        $route = $this->getRouteByName($routeName);

        if (!$route) {
            $this->fail("Could not find route with name '$routeName'");
        }

        $url = $this->generateUrlForRoute($route, $params);
        $this->amOnPage($url);
    }
225539
public function filtering()
    {
        $this->query->where(
                function ($query) {
            $globalKeyword = $this->setupKeyword($this->request->keyword());
            $queryBuilder  = $this->getQueryBuilder($query);
            if ($this->request->hasHeader('search-protection')) {
                $this->request->setSearchableColumnIndex($this->columns, $this->columnDef['filter']);
            }

            foreach ($this->request->searchableColumnIndex() as $index) {
                $columnName = $this->getColumnName($index);
                if ($this->isBlacklisted($columnName)) {
                    continue;
                }

                // check if custom column filtering is applied
                if (isset($this->columnDef['filter'][$columnName])) {
                    $columnDef         = $this->columnDef['filter'][$columnName];
                    // check if global search should be applied for the specific column
                    $applyGlobalSearch = count($columnDef['parameters']) == 0 || end($columnDef['parameters']) !== false;
                    if (!$applyGlobalSearch) {
                        continue;
                    }

                    if ($columnDef['method'] instanceof Closure) {
                        $whereQuery = $queryBuilder->newQuery();
                        call_user_func_array($columnDef['method'], [$whereQuery, $this->request->keyword()]);
                        $queryBuilder->addNestedWhereQuery($whereQuery, 'or');
                    } else {
                        $this->compileColumnQuery(
                                $queryBuilder, Helper::getOrMethod($columnDef['method']), $columnDef['parameters'], $columnName, $this->request->keyword()
                        );
                    }
                } else {
                    if (count(explode('.', $columnName)) > 1) {
                        $eagerLoads     = $this->getEagerLoads();
                        $parts          = explode('.', $columnName);
                        $relationColumn = array_pop($parts);
                        $relation       = implode('.', $parts);
                        if (in_array($relation, $eagerLoads)) {
                            $this->compileRelationSearch(
                                    $queryBuilder, $relation, $relationColumn, $globalKeyword
                            );
                        } else {
                            $this->compileGlobalSearch($queryBuilder, $columnName, $globalKeyword);
                        }
                    } else {
                        $this->compileGlobalSearch($queryBuilder, $columnName, $globalKeyword);
                    }
                }

                $this->isFilterApplied = true;
            }
        }
        );
    }
961564
protected function validateHeaderName($headerName) : void
	{
		if (! \is_string($headerName))
		{
			throw new \InvalidArgumentException('Header name must be a string');
		}
		else if (! \preg_match(HeaderInterface::RFC7230_TOKEN, $headerName))
		{
			throw new \InvalidArgumentException(\sprintf('The given header name "%s" is not valid', $headerName));
		}
	}
758928
public function amOnRoute($routeName, $params = [])
    {
        $route = $this->getRouteByName($routeName);

        $absolute = !is_null($route->domain());
        $url = $this->app['url']->route($routeName, $params, $absolute);
        $this->amOnPage($url);
    }
143795
public function load(string $objectName): void
    {
        // only Froq! stuff
        if (0 !== strpos($objectName, self::NAMESPACE)) {
            return;
        }

        $objectFile = $this->getObjectFile($objectName);

        if ($objectFile == null) {
            throw new \RuntimeException("Could not specify object file '{$objectName}'");
        }

        if (!file_exists($objectFile)) {
            throw new \RuntimeException("Could not find object file '{$objectFile}'");
        }

        require $objectFile;
    }
842172
private function validationStarts(string $paramName, array $ruleIndexes): void
    {
        $this->getCaptures()->clear();
        $this->getValidationErrors()->clear();

        BlockInterpreter::executeStarts(
            $this->serializerClass::readRuleStartIndexes($ruleIndexes),
            $this->getValidationBlocks(),
            $this->getContext(),
            $this->getValidationErrors()
        );
        $this->checkValidationQueueErrors($paramName);
    }
149817
public function matchParam($paramName)
    {
        return (0 == strcasecmp($this->name, $paramName))
                || (0 == strcasecmp($this->shortName, $paramName));
    }