Check object elements in given template

@return void
329550
protected function checkObjects()
	{
		foreach ($this->getElements('object') as $object)
		{
			// Make sure this object doesn't have dynamic params
			$this->checkDynamicParams($object);

			// Test the element's <param/> descendants
			$params = $this->getObjectParams($object);
			foreach ($params as $param)
			{
				$this->checkSetting($param, $param->getAttribute('value'));
			}
			if (empty($params))
			{
				$this->checkSetting($object, $this->defaultSetting);
			}
		}
	}
1240807
public function verifyElements(): void
    {
        $this->navLinkTabs->verifyVisibility();
        $this->adminLists['Policies']->verifyVisibility();
        $this->navLinkTabs->goToTab('Assignments');
        $this->adminLists['Assignments']->verifyVisibility();
    }
1080891
private function checkScope(Entity &$object)
	{
		if ( ! empty($this->localization) && ! empty($this->block)) {
			try {
				// do not-strict match (allows page data with template block)
				$this->localization->matchDiscriminator($this->block);
			} catch (\Exception $e) {
				$object = null;
				throw $e;
			}
		}
	}
561319
private function validateTwigTemplate($template)
    {
        $loader = $this->twig->getLoader();
        if (!$loader->exists($template)) {
            throw new \Exception(sprintf(
                'Unable to find template "%s".',
                $template
            ));
        }
    }
837284
def check_obj(keys, name, obj):
    """"""
    msg = validate_obj(keys, obj)

    if msg:
        raise aomi.exceptions.AomiData("object check : %s in %s" % (msg, name))
1202206
protected function loadTemplates()
    {
        $templates = $this->templatesObjectBackend->loadObject();
        if (!is_array($templates)) {
            $templates = array();
        }
        
        $this->templates = $templates;
    }
147061
public function parse_template()
    {
        $self = $this;
        return preg_replace_callback('/\{\{([a-zA-Z\d-_]+)\}\}/', function($a) use($self) {
            $component = $self->get_component($a[1]);
            return $component->render();
        }, $this->model['template']);
    }
819459
private static function CheckConditions(){
            $oThis = self::CreateInstanceIfNotExists();
            $oThis->sBuffer = str_replace("{else}", "<?php } else { ?>", $oThis->sBuffer);
            $oThis->sBuffer = str_replace("{endif}", "<?php } ?>", $oThis->sBuffer);
            $oThis->sBuffer = str_replace(array('{if }', '{if  }'), "<?php if(false){ ?>", $oThis->sBuffer);

            //IF
            $Offset = 0;

            while(preg_match('/{if\s*(.*?)}/i', $oThis->sBuffer, $aMatches, PREG_OFFSET_CAPTURE, $Offset)){
                $oThis->sBuffer = str_replace($aMatches[0][0], "<?php if(".$aMatches[1][0]."){ ?>", $oThis->sBuffer);
                $Offset = $aMatches[0][1]+strlen($aMatches[0][0]);
            }

            //Elseif
            $Offset = 0;

            while(preg_match('/{elseif\s*(.*?)}/i', $oThis->sBuffer, $aMatches, PREG_OFFSET_CAPTURE, $Offset)){
                $oThis->sBuffer = str_replace($aMatches[0][0], "<?php } elseif(".$aMatches[1][0]."){ ?>", $oThis->sBuffer);
                $Offset = $aMatches[0][1]+strlen($aMatches[0][0]);
            }
        }
1169074
function checkElement(node, attr, includeScope) {
  var elements = getElements(node, attr);

  if (includeScope && node.hasAttribute(attr)) {
    elements.push(node);
  }

  return elements;
}
444878
protected function checkRules($object)
    {
        $this->assertTrue(property_exists($object, 'rules'));

        $this->assertInternalType('array', $object->rules);

        foreach ($object->rules as $rule) {
            $this->checkRule($rule);
        }
    }
497392
public function checkPaths()
    {
        $path = Yii::getAlias($this->templatePath, false);

        if (!$path || !is_dir($path)) {
            throw new Exception("The template path \"{$this->templatePath}\" does not exist");
        }
    }
1195278
function it_tokenize_templates()
    {
        $this->tokenize(new Cursor("TEXT <{ ... . keyword 'string' \"string\" 3.14 var null true false }> TEXT"))->shouldBeLike([
            new Token(Token::TYPE_TEXT, 'TEXT ', 1),
            new Token(Token::TYPE_OPEN_TAG | Token::TYPE_SYMBOL, '<{', 1),
            new Token(Token::TYPE_SYMBOL, '...', 1),
            new Token(Token::TYPE_SYMBOL, '.', 1),
            new Token(Token::TYPE_KEYWORD | Token::TYPE_IDENTIFIER, 'keyword', 1),
            new Token(Token::TYPE_STRING | Token::TYPE_SINGLE_QUOTED, 'string', 1),
            new Token(Token::TYPE_STRING | Token::TYPE_DOUBLE_QUOTED, 'string', 1),
            new Token(Token::TYPE_NUMBER, '3.14', 1),
            new Token(Token::TYPE_IDENTIFIER, 'var', 1),
            new Token(Token::TYPE_CONSTANT, 'null', 1),
            new Token(Token::TYPE_CONSTANT, 'true', 1),
            new Token(Token::TYPE_CONSTANT, 'false', 1),
            new Token(Token::TYPE_CLOSE_TAG | Token::TYPE_SYMBOL, '}>', 1),
            new Token(Token::TYPE_TEXT, ' TEXT', 1),
            new Token(Token::TYPE_EOF, null, 1),
        ]);
    }
1215105
private void insanityCheck(Element element, Meta meta, Opcode.Type type) {
		if (meta != null) {
			throw new TemplateException("Invalid operators list on element |%s|. Only one %s operator is allowed.", element, type);
		}
	}
958141
private function checkTemplate($template)
    {
        if ( ! is_string($template)) {
            $type = gettype($template);
            throw new Exceptions\InvalidTypeException(
                "The default template name must be a string, $type given."
            );
        }

        $template = strtolower(trim($template));

        if ( ! array_key_exists($template, $this->supported)) {
            throw new Exceptions\InvalidTemplateException(
                "The template [$template] is not supported."
            );
        }
    }
926662
protected function templateExists($template)
    {
        try {
            $class = $this->templating->getTemplateClass($template);
        } catch (Twig_Error_Loader $e) {
            return false;
        }

        return $template;
    }
326177
public function check(DOMElement $template, Tag $tag)
	{
		foreach ($this->getNodes($template) as $node)
		{
			// Test this node's safety
			$this->checkNode($node, $tag);
		}
	}
527715
private function detect()
	{
		# Init
		$this->xss = false;

		# No data
		if(!$this->string) { return; }

		# Detect
		foreach ($this->list as $item) {
			if(preg_match("`$item`i", $this->string)) {
				$this->xss = true;
			}
		}
	}