fix php7.4 deprecation and remove php7.4 from travis allow_failures since php7.4 is current stable

Revert "Reinstitute the phpunit/phpunit dependency the right way."

.gitignore

@@ -11,4 +11,3 @@ utilies/*.php
 phpunit*
 vendor/*
 composer.lock
-templates_c/*

.travis.yml

@@ -11,11 +11,10 @@ matrix:
    - php: 7.1
    - php: 7.2
    - php: 7.3
-   - php: 7.4snapshot
+   - php: 7.4
    - php: nightly
   fast_finish: true
   allow_failures:
-   - php: 7.4snapshot
    - php: nightly
 
 services:
@@ -30,8 +29,6 @@ before_install:
 
 install:
     - travis_retry composer install
-    - git clone --depth=50 --branch=master git://github.com/smarty-php/smarty-phpunit.git
 
 script:
-   - cd smarty-phpunit
-   - ../vendor/bin/phpunit ./
+   - ./phpunit.sh

TODO.md

@@ -0,0 +1,69 @@
+# Todo
+
+## Add unit test for strip issue in correct branch
+tests/UnitTests/TemplateSource/TagTests/Strip/CompileStripTest.php 
+```
+@@ -76,6 +76,7 @@ class CompileStripTest extends PHPUnit_Smarty
+                      array("{'Var'}\n <b></b> <c></c>", 'Var<b></b> <c></c>', '', $i ++),
+                      array("\n<b></b>  <c></c>", '<b></b> <c></c>', '', $i ++),
+                      array("\n<b></b>\n  <c></c>", '<b></b><c></c>', '', $i ++),
++                     array("\n<b>\n  {* a comment *}\n   <c>", '<b><c>', '', $i ++),
+
+         );
+     }
+```
+
+## Add unit test for isset issue in correct branch
+tests/UnitTests/TemplateSource/ValueTests/PHPfunctions/PhpFunctionTest.php
+```php
+    /**
+     * test PHP isset() on (non-)variables
+     * @dataProvider        dataTestIsset3
+     * @param string $strTemplate template to test
+     * @param string $result expected result
+     */
+    public function testIsset3($strTemplate, $result)
+    {
+        $this->smarty->disableSecurity();
+
+        $this->smarty->assign('varobject', new TestIsset());
+        $this->smarty->assign('vararray', $vararray = [
+            'keythatexists' => false,
+            'keywitharray' => [1 => 1],
+            'keywithobject' => new TestIsset()]
+        );
+
+        $this->smarty->assign('key', 'A');
+        $this->smarty->assign('_varsimpleA', 1);
+        $this->smarty->assign('varsimpleB', 0);
+        $this->smarty->assign('varsimpleC', null);
+
+        $this->assertEquals($result, $this->smarty->fetch('string:' . $strTemplate));
+    }
+
+    /**
+     * Data provider for testIsset3
+     */
+    public function dataTestIsset3()
+    {
+        return array(
+            array('{if isset($varobject->arr)}true{else}false{/if}', 'true'),
+            array('{if isset($vararray["keywitharray"])}true{else}false{/if}', 'true'),
+            array('{if isset($vararray["keythatexists"])}true{else}false{/if}', 'true'),
+            array('{if isset($vararray["nonexistingkey"])}true{else}false{/if}', 'false'),
+            array('{if isset($_GET["sscr6hr6cz34j6"])}true{else}false{/if}', 'false'),
+            array('{if isset(count([\'hi\']))}true{else}false{/if}', 'true'),
+            array('{if isset($vararray[\'keywitharray\'][intval(\'1\')])}true{else}false{/if}', 'true'),
+            array('{if isset($vararray[\'keywithobject\']->arr[\'isSet\'])}true{else}false{/if}', 'true'),
+            array('{if isset($vararray[\'keywithobject\']->arr[\'isNull\'])}true{else}false{/if}', 'false'),
+            array('{if isset($varobject->arr[\'isSet\'])}true{else}false{/if}', 'true'),
+            array('{if isset($varobject->arr[\'isNull\'])}true{else}false{/if}', 'false'),
+            array('{if isset($_varsimpleA)}true{else}false{/if}', 'true'),
+            array('{if isset($varsimpleB)}true{else}false{/if}', 'true'),
+            array('{if isset($varsimpleC)}true{else}false{/if}', 'false'),
+            array('{if isset($_varsimpleA && varsimpleB)}true{else}false{/if}', 'true'),
+            array('{if isset($_varsimpleA && varsimpleC)}true{else}false{/if}', 'true'),
+            array('{if isset($_varsimple{$key})}true{else}false{/if}', 'true'),
+        );
+    }
+```

phpunit.sh

@@ -0,0 +1,2 @@
+#! /bin/bash
+vendor/phpunit/phpunit/phpunit tests/UnitTests

phpunit.xml

@@ -0,0 +1,43 @@
+<phpunit
+        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:noNamespaceSchemaLocation="http://schema.phpunit.de/4.5/phpunit.xsd"
+        bootstrap="tests/Bootstrap.php"
+        colors="true"
+        backupGlobals="false"
+        backupStaticAttributes="true"
+        forceCoversAnnotation="false"
+        mapTestClassNameToCoveredClassName="false"
+        processIsolation="false"
+        stopOnError="false"
+        stopOnFailure="false"
+        stopOnIncomplete="false"
+        stopOnSkipped="false"
+        stopOnRisky="false"
+        timeoutForSmallTests="1"
+        timeoutForMediumTests="10"
+        timeoutForLargeTests="60"
+        verbose="false">
+
+<filter>
+        <testsuites>
+            <testsuite name="Smarty Test Suite">
+                <directory>tests/UnitTests</directory>
+            </testsuite>
+        </testsuites>
+        <blacklist>
+            <directory suffix=".php">tests</directory>
+            <directory suffix=".php">tests/cache</directory>
+            <directory suffix=".php">tests/templates_c</directory>
+        </blacklist>
+        <whitelist processUncoveredFilesFromWhitelist="true">
+            <directory suffix=".php">libs</directory>
+            <directory suffix=".php">libs/plugins</directory>
+            <directory suffix=".php">libs/sysplugins</directory>
+            <directory suffix=".php">demo/plugins</directory>
+        </whitelist>
+    </filter>
+    <logging>
+        <log type="tap" target="tests/TestResults.tap"/>
+    </logging>
+
+</phpunit>

tests/.gitignore

@@ -0,0 +1,11 @@
+.idea
+
+# Unit test / coverage reports
+.coverage
+.tox
+
+#Smarty
+testdox.html
+TestResults.tap
+TestResults.txt
+

tests/Bootstrap.php

@@ -0,0 +1,28 @@
+<?php
+/*
+* This file is part of the Smarty PHPUnit tests.
+*
+*/
+/*
+ * Smarty PHPUnit Bootstrap
+ */
+require_once dirname(__FILE__) . '/Config.php';
+require_once dirname(__FILE__) . '/../vendor/autoload.php';
+require_once dirname(__FILE__) . '/../libs/bootstrap.php';
+
+if (!class_exists('\PHPUnit_Framework_TestCase') && class_exists('\PHPUnit\Framework\TestCase')) {
+    class_alias('\PHPUnit\Framework\TestCase', '\PHPUnit_Framework_TestCase');
+    class_alias('\PHPUnit\Framework\Error\Notice', '\PHPUnit_Framework_Error_Notice');
+    class_alias('\PHPUnit\Framework\Error\Error', '\PHPUnit_Framework_Error_Error');
+    class_alias('\PHPUnit\Framework\Error\Warning', '\PHPUnit_Framework_Error_Warning');
+    class_alias('\PHPUnit\Framework\Error\Warning', '\PHPUnit_Framework_Error_Deprecated');
+    class_alias('\PHPUnit\Util\Configuration', '\PHPUnit_Util_Configuration');
+}
+
+require_once 'PHPUnit_Smarty.php';
+if (!ini_get('date.timezone')) {
+    ini_set('date.timezone', 'Europe/Berlin');
+}
+
+
+

tests/Config.php

@@ -0,0 +1,18 @@
+<?php
+/*
+* This file is part of the Smarty PHPUnit tests.
+*
+*/
+/*
+ * Smarty PHPUnit Config
+ */
+define('individualFolders', true);
+define('MemCacheEnable', false);
+define('ApcCacheEnable', false);
+define('MysqlCacheEnable', false);
+define('PdoCacheEnable', false);
+define('PdoGzipCacheEnable', false);
+define('MysqlResourceEnable', false);
+define('DB_DSN', "mysql:dbname=test;host=localhost");
+define('DB_USER', "travis");
+define('DB_PASSWD', "");

tests/Include_Path/Plugins/include/function.plugin1.php

@@ -0,0 +1,5 @@
+<?php
+function smarty_function_plugin1($params, $template)
+{
+    return 'plugin1';
+}

tests/Include_Path/Plugins/include1/function.plugin2.php

@@ -0,0 +1,5 @@
+<?php
+function smarty_function_plugin2($params, $template)
+{
+    return 'plugin2';
+}

tests/Include_Path/Tpl/include/include_test2.tpl

@@ -0,0 +1 @@
+include_test2

tests/Include_Path/Tpl/include/include_test4.tpl

@@ -0,0 +1 @@
+include_test4

tests/Include_Path/Tpl/templates_2/test4.tpl

@@ -0,0 +1 @@
+{include 'include_test4.tpl'}

tests/Include_Path/Tpl/test5.tpl

@@ -0,0 +1 @@
+include path root

tests/PHPUnit_Smarty.php

@@ -0,0 +1,699 @@
+<?php
+/*
+ * This file is part of the Smarty PHPUnit tests.
+ *
+ */
+
+/**
+ * Smarty Test Case Fixture
+ */
+class PHPUnit_Smarty extends PHPUnit_Framework_TestCase
+{
+    /**
+     * Smarty object
+     *
+     * @var SmartyBC
+     */
+    public $smartyBC = null;
+
+    /**
+     * SmartyBC object
+     *
+     * @var Smarty
+     */
+    public $smarty = null;
+
+    /**
+     * Flag if test is using the Smarty object
+     *
+     * @var bool
+     */
+    public $loadSmarty = true;
+
+    /**
+     * Flag if test is using the SmartyBC object
+     *
+     * @var bool
+     */
+    public $loadSmartyBC = false;
+
+    /**
+     * Flag for initialization at first test
+     *
+     * @var bool
+     */
+    public static $init = true;
+
+    /**
+     * Count test number
+     *
+     * @var bool
+     */
+    public static $testNumber = 0;
+
+    /**
+     * Configuration data from config.xml
+     *
+     * @var array
+     */
+    public static $config = null;
+
+    /**
+     * Saved current working directory
+     *
+     * @var null
+     */
+    public static $cwd = null;
+
+    /**
+     * PDO object for Mysql tests
+     *
+     * @var PDO
+     */
+    public static $pdo = null;
+
+    public static $pluginsdir = null;
+
+    /**
+     * Default blacklist
+     *
+     * @var array
+     */
+    protected $backupStaticAttributesBlacklist = array('PHPUnit_Smarty' => array('config', 'pdo', 'init',
+                                                                                 'testNumver', 'pluginsdir'),);
+
+    /**
+     * This method is called before the first test of this test class is run.
+     *
+     */
+    public static function setUpBeforeClass()
+    {
+        error_reporting(E_ALL & ~E_STRICT);
+        self::$init = true;
+        self::$pluginsdir =self::getSmartyPluginsDir();
+    }
+
+    /**
+     * This method is called after the last test of this test class is run.
+     *
+     */
+    public static function tearDownAfterClass()
+    {
+        //self::$pdo = null;
+        self::$testNumber = 0;
+    }
+
+    /**
+     * Constructs a test case with the given name.
+     *
+     * @param string $name
+     * @param array  $data
+     * @param string $dataName
+     */
+    public function __construct($name = null, array $data = array(), $dataName = '')
+    {
+        date_default_timezone_set('Europe/Berlin');
+        if (!defined('individualFolders')) {
+            define('individualFolders', true);
+        }
+        parent::__construct($name, $data, $dataName);
+      $this->backupStaticAttributesBlacklist[ get_class($this) ] = array('init', 'config', 'pdo', 'testNumber');
+    }
+
+    /**
+     * Setup Smarty instance called for each test
+     *
+     * @param null $dir working directory
+     */
+    public function setUpSmarty($dir = null)
+    {
+        static $s_dir;
+        // set up current working directory
+        chdir($dir);
+        self::$cwd = getcwd();
+        // create missing folders for test
+        if (self::$init) {
+            if (!is_dir($dir . '/templates')) {
+                mkdir($dir . '/templates');
+            }
+            if (!is_dir($dir . '/configs')) {
+                mkdir($dir . '/configs');
+            }
+            if (individualFolders != 'true') {
+                if (!isset($s_dir[ $dir ])) {
+                    $this->cleanDir($dir . '/templates_c');
+                    $this->cleanDir($dir . '/cache');
+                    if (is_dir($dir . '/templates_tmp')) {
+                        $this->cleanDir($dir . '/templates_tmp');
+                    }
+                    $s_dir[ $dir ] = true;
+                }
+                $dir = dirname(__FILE__);
+            }
+            if (!is_dir($dir . '/templates_c')) {
+                mkdir($dir . '/templates_c');
+            }
+            chmod($dir . '/templates_c', 0775);
+            if (!is_dir($dir . '/cache')) {
+                mkdir($dir . '/cache');
+                chmod($dir . '/cache', 0775);
+            }
+            self::$init = false;
+        }
+        clearstatcache();
+        // instance Smarty class
+        if ($this->loadSmarty) {
+            $this->smarty = new Smarty;
+            if (individualFolders != 'true') {
+                $this->smarty->setCompileDir(dirname(__FILE__) . '/templates_c');
+                $this->smarty->setCacheDir(dirname(__FILE__) . '/cache');
+            }
+        }
+        // instance SmartyBC class
+        if ($this->loadSmartyBC) {
+            $this->smartyBC = new SmartyBC;
+            if (individualFolders != 'true') {
+                $this->smartyBC->setCompileDir(dirname(__FILE__) . '/templates_c');
+                $this->smartyBC->setCacheDir(dirname(__FILE__) . '/cache');
+            }
+        }
+        $smarty = $this->getSmartyObj();
+    }
+
+    /**
+     * Create Mysql PDO object
+     *
+     */
+    final public function getConnection()
+    {
+        if (PHPUnit_Smarty::$pdo == null) {
+            try {
+                PHPUnit_Smarty::$pdo = new PDO(DB_DSN, DB_USER, DB_PASSWD);
+            }
+            catch (PDOException $e) {
+                throw new SmartyException('Mysql Resource failed: ' . $e->getMessage());
+            }
+            $timezone = date_default_timezone_get();
+            $j = PHPUnit_Smarty::$pdo->exec("SET time_zone = '{$timezone}';");
+
+
+        }
+    }
+
+    /**
+     * Create table for Mysql resource
+     *
+     */
+    public function initMysqlResource()
+    {
+        $this->getConnection();
+        PHPUnit_Smarty::$pdo->exec("DROP TABLE `templates`");
+        PHPUnit_Smarty::$pdo->exec("CREATE TABLE IF NOT EXISTS `templates` (
+ `name` varchar(100) NOT NULL,
+ `modified` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+ `source` text,
+PRIMARY KEY (`name`)
+ ) ENGINE=InnoDB DEFAULT CHARSET=utf8");
+
+    }
+
+    /**
+     * Create table for Mysql cache resource
+     *
+     */
+    public function initMysqlCache()
+    {
+        $this->getConnection();
+        PHPUnit_Smarty::$pdo->exec("DROP TABLE `output_cache`");
+         PHPUnit_Smarty::$pdo->exec("CREATE TABLE IF NOT EXISTS `output_cache` (
+ `name` varchar(256) NOT NULL,
+ `id` char(40) NOT NULL,
+ `cache_id` varchar(250) DEFAULT NULL,
+ `compile_id` varchar(250) DEFAULT NULL,
+`modified` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+ `content` mediumblob NOT NULL,
+PRIMARY KEY (`id`),
+KEY `cache_id` (`cache_id`),
+KEY `compile_id` (`compile_id`),
+KEY `modified` (`modified`),
+KEY `name` (`name`)
+ ) ENGINE=InnoDB DEFAULT CHARSET=utf8");
+//     PHPUnit_Smarty::$pdo->exec("CREATE TABLE IF NOT EXISTS `output_cache` (
+//`id` char(40) NOT NULL,
+//`name` varchar(250) NOT NULL,
+//`cache_id` varchar(250) DEFAULT NULL,
+//`compile_id` varchar(250) DEFAULT NULL,
+//`modified` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
+//`expire` timestamp NOT NULL DEFAULT '0000-00-00 00:00:00',
+//`content` mediumblob NOT NULL,
+///PRIMARY KEY (`id`),
+//KEY `name` (`name`),
+//KEY `cache_id` (`cache_id`),
+//KEY `compile_id` (`compile_id`),
+//KEY `modified` (`modified`),
+//KEY `expire` (`expire`)
+//) ENGINE=InnoDB DEFAULT CHARSET=utf8");
+
+    }
+
+    /**
+     * Delete files in templates_c and cache folders
+     *
+     */
+    public function cleanDirs()
+    {
+        $this->cleanCompileDir();
+        $this->cleanCacheDir();
+        if (is_dir(self::$cwd . '/templates_tmp')) {
+            $this->cleanDir(self::$cwd . '/templates_tmp');
+        }
+        $this->assertTrue(true);
+   }
+
+    /**
+     * Make temporary template file
+     *
+     */
+    public function makeTemplateFile($name, $code)
+    {
+        if (!is_dir(self::$cwd . '/templates_tmp')) {
+            mkdir(self::$cwd . '/templates_tmp');
+            chmod(self::$cwd . '/templates_tmp', 0775);
+        }
+        $fileName = self::$cwd . '/templates_tmp/' . "{$name}";
+        file_put_contents($fileName, $code);
+    }
+
+    /**
+     * Delete files in templates_c folder
+     *
+     */
+    public function cleanCompileDir()
+    {
+        $smarty = $this->getSmartyObj();
+        if (isset($smarty)) {
+            $dir = $smarty->getCompileDir();
+            $this->cleanDir($dir);
+        }
+    }
+
+    /**
+     * Delete files in cache folder
+     *
+     */
+    public function cleanCacheDir()
+    {
+        $smarty = $this->getSmartyObj();
+        if (isset($smarty)) {
+            $dir = $smarty->getCacheDir();
+            $this->cleanDir($dir);
+         }
+    }
+
+    /**
+     * Delete files and sub folders
+     *
+     * @param string $dir
+     */
+    public function cleanDir($dir)
+    {
+        $di = new RecursiveDirectoryIterator($dir);
+        $ri = new RecursiveIteratorIterator($di, RecursiveIteratorIterator::CHILD_FIRST);
+        foreach ($ri as $file) {
+            if (substr(basename($file->getPathname()), 0, 1) === '.' || substr((string)$file,-4) === '.txt') {
+                continue;
+            }
+            // directory ?
+            if ($file->isDir()) {
+                if (!$ri->isDot()) {
+                    // delete folder if empty
+                    @rmdir($file->getPathname());
+                }
+            } else {
+                unlink($file->getPathname());
+            }
+        }
+    }
+
+    /**
+     * Get PDO object
+     *
+     * @return null|PDO
+     */
+    final public function getPDO()
+    {
+        return PHPUnit_Smarty::$pdo;
+    }
+
+    /**
+     * Remove "\r" and replace "\t" with spaces
+     *
+     * @param string $in
+     *
+     * @return mixed
+     */
+    public function normalizeString($in)
+    {
+        if (is_string($in)) {
+            return str_replace(array("\r", "\t"), array('', '    '), $in);
+        } else {
+            return $in;
+        }
+    }
+
+    /**
+     * Remove all spaces
+     *
+     * @param string $in
+     *
+     * @return mixed
+     */
+    public function strip($in)
+    {
+        if (is_string($in)) {
+            return preg_replace('/\s/', '', $in);
+        } else {
+            return $in;
+        }
+    }
+
+    /**
+     * Return source path
+     *
+     * @param Smarty_Internal_TemplateBase $tpl  template object
+     * @param null|string                  $name optional template name
+     * @param null|string                  $type optional template type
+     * @param null|string                  $dir  optional template folder
+     *
+     * @return string
+     * @throws \Exception
+     */
+    public function buildSourcePath($tpl, $name = null, $type = null, $dir = null)
+    {
+        $name = isset($name) ? $name : $tpl->source->name;
+        $type = isset($type) ? $type : $tpl->source->type;
+        $dir = isset($dir) ? $dir : $this->smarty->getTemplateDir(0);
+        switch ($type) {
+            case 'file':
+            case 'filetest':
+            case 'php':
+                return $this->normalizePath($dir . $name);
+            case 'mysqltest':
+            case 'mysql':
+                return sha1($type . ':' . $name);
+            case 'string':
+                $this->smarty->getTemplateDir();
+                return sha1($name . $this->smarty->_joined_template_dir);
+            default:
+                throw new Exception("Unhandled source resource type '{$type}'");
+        }
+    }
+
+    /**
+     * Build template uid
+     *
+     * @param Smarty_Internal_TemplateBase $tpl  template object
+     * @param null|string                  $value
+     * @param null|string                  $name optional template name
+     * @param null|string                  $type optional template type
+     *
+     * @return string
+     * @throws \Exception
+     */
+    public function buildUid($tpl, $value = null, $name = null, $type = null)
+    {
+        $type = isset($type) ? $type : $tpl->source->type;
+        $name = isset($name) ? $name : $tpl->source->name;
+        switch ($type) {
+            case 'php':
+            case 'file':
+            case 'filetest':
+                if ($tpl instanceof Smarty) {
+                    return sha1($this->normalizePath($this->smarty->getTemplateDir(0) . $name) .
+                                $this->smarty->_joined_template_dir);
+                }
+                return sha1($tpl->source->filepath . $this->smarty->_joined_template_dir);
+            case 'mysqltest':
+            case 'mysql':
+                return sha1($type . ':' . $name);
+            case 'string':
+                $this->smarty->getTemplateDir();
+                return sha1($name . $this->smarty->_joined_template_dir);
+            default:
+                throw new Exception("Unhandled source resource type '{$type}'");
+        }
+    }
+
+    /**
+     * Normalize path
+     *  - remove /./ and /../
+     *  - make it absolute
+     *
+     * @param string $path file path
+     *
+     * @return string
+     */
+    public function normalizePath($path, $ds =null ,$absolute = true)
+    {
+        $ds = isset($ds) ? $ds : DIRECTORY_SEPARATOR;
+        $nds = $ds == '/' ? '\\' : '/';
+        $getcwd = getcwd();
+        // normalize $ds
+        $path = str_replace($nds, $ds, $path);
+        preg_match('#^([a-zA-Z][:])?([.]{1,2}[\/\\\]+)?([\\\])?([.]{0,2}[\/\\\]+)?([[:print:]]*)#', $path, $match);
+        if ($match[1] === '') {
+            if ($match[ 2 ] !== '' || $match[ 2 ] . $match[ 3 ] . $match[ 4 ] === '') {
+                $path = $getcwd . $ds . $path;
+            } else if (Smarty::$_IS_WINDOWS && $match[ 3 ] !== '') {
+                $path = substr($getcwd, 0, 2) . $path;
+            }
+        }
+        $path = preg_replace('#[\\\/]+([.][\\\/]+)*#', $ds, $path);
+        while (strrpos($path, '.' . $ds) !== false) {
+            $path =
+                preg_replace('#([\\\/]([^\\\/]+[\\\/]){2}([.][.][\\\/]){2})|([\\\/][^\\\/]+[\\\/][.][.][\\\/])#', $ds,
+                             $path);
+        }
+        $cwd  = preg_replace('#[\\\/]#', $ds, $getcwd);
+        $path = str_ireplace($cwd,$getcwd, $path);
+        if (!$absolute) {
+            $path = preg_replace('#'.$getcwd.'#', '', $path);
+        }
+        return $path;
+    }
+
+    /**
+     * Return base name
+     *
+     * @param \Smarty_Internal_Template|\Smarty_Internal_TemplateBase $tpl  template object
+     * @param null|string                                             $name optional template name
+     * @param null|string                                             $type optional template type
+     *
+     * @return null|string
+     */
+    public function getBasename(Smarty_Internal_Template $tpl, $name = null, $type = null)
+    {
+        $name = isset($name) ? $name : $tpl->source->name;
+        $type = isset($type) ? $type : $tpl->source->type;
+        switch ($type) {
+            case 'file':
+            case 'filetest':
+                if (($_pos = strpos($name, ']')) !== false) {
+                    $name = substr($name, $_pos + 1);
+                }
+                return basename($name);
+            case 'mysqltest':
+            case 'mysql':
+                return $name;
+            case 'string':
+                return '';
+            default:
+                return null;
+        }
+    }
+
+    /**
+     * Return compiled file path
+     *
+     * @param \Smarty_Internal_Template|\Smarty_Internal_TemplateBase $tpl        template object
+     * @param bool                                                    $sub        use sub directory flag
+     * @param bool                                                    $caching    caching flag
+     * @param null|string                                             $compile_id optional compile id
+     * @param null|string                                             $name       optional template name
+     * @param null|string                                             $type       optional template type
+     * @param null|string                                             $dir        optional template folder
+     *
+     * @return string
+     * @throws \Exception
+     */
+    public function buildCompiledPath(Smarty_Internal_Template $tpl, $sub = true, $caching = false, $compile_id = null,
+                                      $name = null, $type = null, $dir = null)
+    {
+        $sep = DIRECTORY_SEPARATOR;
+        $_compile_id = isset($compile_id) ? preg_replace('![^\w\|]+!', '_', $compile_id) : null;
+        $sp = $this->buildSourcePath($tpl, $name, $type, $dir);
+        $uid = $this->buildUid($tpl, $sp, $name, $type);
+        $_flag = '';
+        if (isset($tpl->source) && $tpl->source->isConfig) {
+            $_flag = '_' . ((int) $tpl->smarty->config_read_hidden + (int) $tpl->smarty->config_booleanize * 2 +
+                            (int) $tpl->smarty->config_overwrite * 4);
+        } else {
+            $_flag = '_' . ((int) $tpl->smarty->merge_compiled_includes + (int) $tpl->smarty->escape_html * 2);
+        }
+        $_filepath = $uid . $_flag;
+        // if use_sub_dirs, break file into directories
+        if ($sub) {
+            $_filepath =
+                substr($_filepath, 0, 2) . $sep . substr($_filepath, 2, 2) . $sep . substr($_filepath, 4, 2) . $sep .
+                $_filepath;
+        }
+        $_compile_dir_sep = $sub ? $sep : '^';
+        if (isset($_compile_id)) {
+            $_filepath = $_compile_id . $_compile_dir_sep . $_filepath;
+        }
+        // caching token
+        if ($caching) {
+            $_cache = '.cache';
+        } else {
+            $_cache = '';
+        }
+        $_compile_dir = $tpl->smarty->getCompileDir();
+        // set basename if not specified
+        $_basename = $this->getBasename($tpl, $name, $type);
+        if ($_basename === null) {
+            $_basename = basename(preg_replace('![^\w\/]+!', '_', $name));
+        }
+        // separate (optional) basename by dot
+        if ($_basename) {
+            $_basename = '.' . $_basename;
+        }
+
+        return $_compile_dir . $_filepath . '.' . $type . $_basename . $_cache . '.php';
+    }
+
+    /**
+     * Return cache file path
+     *
+     * @param Smarty_Internal_TemplateBase $tpl        template object
+     * @param bool                         $sub        use sub directory flag
+     * @param null|string                  $cache_id   optional cache id
+     * @param null|string                  $compile_id optional compile id
+     * @param null|string                  $name       optional template name
+     * @param null|string                  $type       optional template type
+     * @param null|string                  $dir        optional template folder
+     * @param null|string                  $cacheType  optional cache resource type
+     *
+     * @return string
+     * @throws \Exception
+     */
+    public function buildCachedPath($tpl, $sub = true, $cache_id = null, $compile_id = null, $name = null, $type = null,
+                                    $dir = null, $cacheType = null)
+    {
+        $cacheType = isset($cacheType) ? $cacheType : $tpl->smarty->caching_type;
+        switch ($cacheType) {
+            case 'file':
+            case 'filetest':
+                $sep = DIRECTORY_SEPARATOR;
+                $_compile_id = isset($compile_id) ? preg_replace('![^\w\|]+!', '_', $compile_id) : null;
+                $_cache_id = isset($cache_id) ? preg_replace('![^\w\|]+!', '_', $cache_id) : null;
+                $sp = $this->buildSourcePath($tpl, $name, $type, $dir);
+                $uid = $this->buildUid($tpl, $sp, $name, $type);
+                $_filepath = sha1($uid . $this->smarty->_joined_template_dir);
+                // if use_sub_dirs, break file into directories
+                if ($sub) {
+                    $_filepath =
+                        substr($_filepath, 0, 2) . $sep . substr($_filepath, 2, 2) . $sep . substr($_filepath, 4, 2) .
+                        $sep . $_filepath;
+                }
+                $_compile_dir_sep = $sub ? $sep : '^';
+                if (isset($_cache_id)) {
+                    $_cache_id = str_replace('|', $_compile_dir_sep, $_cache_id) . $_compile_dir_sep;
+                } else {
+                    $_cache_id = '';
+                }
+                if (isset($_compile_id)) {
+                    $_compile_id = $_compile_id . $_compile_dir_sep;
+                } else {
+                    $_compile_id = '';
+                }
+                $smarty = isset($tpl->smarty) ? $tpl->smarty : $tpl;
+                $_cache_dir = $smarty->getCacheDir();
+                return $_cache_dir . $_cache_id . $_compile_id . $_filepath . '.' . basename($sp) . '.php';
+            case 'mysql':
+            case 'mysqltest':
+            case 'pdo':
+            case 'foobar':
+                $sp = $this->buildSourcePath($tpl, $name, $type, $dir);
+                $uid = $this->buildUid($tpl, $sp, $name, $type);
+                $_compile_id = isset($compile_id) ? preg_replace('![^\w\|]+!', '_', $compile_id) : null;
+                $_cache_id = isset($cache_id) ? preg_replace('![^\w\|]+!', '_', $cache_id) : null;
+                return sha1($uid . $_cache_id . $_compile_id);
+            case 'memcachetest':
+            case 'acp':
+                $sp = $this->buildSourcePath($tpl, $name, $type, $dir);
+                $uid = $this->buildUid($tpl, $sp, $name, $type);
+                $_compile_id = isset($compile_id) ? preg_replace('![^\w\|]+!', '_', $compile_id) : null;
+                $_cache_id = isset($cache_id) ? preg_replace('![^\w\|]+!', '_', $cache_id) : null;
+                return sha1($uid) . '#' . preg_replace('#[^\w\|]+#S', '_', $tpl->template_resource) . '#' . $_cache_id .
+                       '#' . $_compile_id;
+
+            default:
+                throw new Exception("Unhandled cache resource type '{$cacheType}'");
+        }
+    }
+
+    /**
+     * prefilter to insert test number
+     *
+     * @param  string                   $source
+     * @param \Smarty_Internal_Template $tpl
+     *
+     * @return string
+     */
+    public function prefilterTest($source, Smarty_Internal_Template $tpl)
+    {
+        return str_replace('#test#', "test:{\$test nocache} compiled:{$tpl->getTemplateVars('test')} rendered:{\$test}",
+                           $source);
+    }
+
+    /**
+     *  Gat Smarty object
+     * @return null|\Smarty|\SmartyBC
+     */
+    public function getSmartyObj(){
+        return isset($this->smarty) ? $this->smarty : (isset($this->smartyBC) ? $this->smartyBC : null);
+    }
+
+    public static function getSmartyPluginsDir(){
+        if (is_dir(dirname(__FILE__) . '/../smarty/libs/plugins')) {
+            return dirname(__FILE__) . '/../smarty/libs/plugins';
+        } else if(is_dir(dirname(__FILE__) . '/../libs/plugins')) {
+            return dirname(__FILE__) . '/../libs/plugins';
+        }
+    }
+    /**
+     * Tears down the fixture
+     * This method is called after a test is executed.
+     *
+     */
+    protected function tearDown()
+    {
+        if (class_exists('Smarty_Internal_TemplateCompilerBase') &&
+            isset(Smarty_Internal_TemplateCompilerBase::$_tag_objects)
+        ) {
+            Smarty_Internal_TemplateCompilerBase::$_tag_objects = array();
+        }
+        if (isset($this->smarty->smarty)) {
+            $this->smarty->smarty = null;
+        }
+        if (isset($this->smarty)) {
+            $this->smarty = null;
+        }
+        if (isset($this->smartyBC->smarty)) {
+            $this->smartyBC->smarty = null;
+        }
+        if (isset($this->smartyBC)) {
+            $this->smartyBC = null;
+        }
+    }
+}

tests/UnitTests/A_0/PathNormalization/PathNormalizationTest.php

@@ -0,0 +1,78 @@
+<?php
+/*
+ * This file is part of the Smarty PHPUnit tests.
+ */
+
+/**
+ * class for path normalization tests
+ *
+ * @runTestsInSeparateProcess
+ * @preserveGlobalState disabled
+ * @backupStaticAttributes enabled
+ */
+class PathNormalizationTest extends PHPUnit_Smarty
+{
+    /*
+     * Setup test fixture
+     */
+    public function setUp()
+    {
+        $this->setUpSmarty(dirname(__FILE__));
+    }
+
+    public function testNormalizeToAbsolute() {
+        $d = $this->smarty->_realpath('./foo/a.foo', true);
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . 'foo' . DIRECTORY_SEPARATOR . 'a.foo', $d);
+    }
+    /**public function testNormalizeAbsolute() {
+        if (DIRECTORY_SEPARATOR == '/') {
+            $d = $this->smarty->_realpath('\\foo\\a.foo', true);
+            $this->assertEquals('/foo/a.foo', $d);
+        } else {
+            $d = $this->smarty->_realpath('/foo/a.foo', true);
+            $this->assertEquals(substr(getcwd(), 0, 2) . DIRECTORY_SEPARATOR . 'foo' . DIRECTORY_SEPARATOR . 'a.foo', $d);
+            $d = $this->smarty->_realpath(substr(getcwd(), 0, 2) . '/foo/a.foo', true);
+            $this->assertEquals(substr(getcwd(), 0, 2) . DIRECTORY_SEPARATOR . 'foo' . DIRECTORY_SEPARATOR . 'a.foo', $d);
+        }
+    }
+ * */
+    public function testNormalizeToAbsoluteNoStart() {
+        $d = $this->smarty->_realpath('foo/a.foo', true);
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . 'foo' . DIRECTORY_SEPARATOR . 'a.foo', $d);
+    }
+    public function testNormalizeToAbsoluteNoStart2() {
+        $d = $this->smarty->_realpath('a.foo', true);
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . 'a.foo', $d);
+    }
+    public function testNormalizeToAbsolutePathLeadingDot() {
+        $d = $this->smarty->_realpath('.foo/a.foo', true);
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . '.foo' . DIRECTORY_SEPARATOR . 'a.foo', $d);
+    }
+    public function testNormalizeToAbsolutePathTrailingDot() {
+        $d = $this->smarty->_realpath('./foo./a.foo', true);
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . 'foo.' . DIRECTORY_SEPARATOR . 'a.foo', $d);
+    }
+    public function testNormalizeToAbsolutePathBubbleUp() {
+        $ds = '\\' . DIRECTORY_SEPARATOR;
+        $prefix = preg_replace("#[{$ds}][^{$ds}]+$#", '', getcwd());
+        $d = $this->smarty->_realpath('./../a.foo', true);
+        $this->assertEquals($prefix . DIRECTORY_SEPARATOR . 'a.foo', $d);
+    }
+    public function testNormalizeToAbsolutePathBubbleUp2() {
+        $ds = '\\' . DIRECTORY_SEPARATOR;
+        $prefix = preg_replace("#[{$ds}][^{$ds}]+$#", '', getcwd());
+        $d = $this->smarty->_realpath('././../././a.foo', true);
+        $this->assertEquals($prefix . DIRECTORY_SEPARATOR . 'a.foo', $d);
+    }
+    public function testNormalizeToAbsolutePathBubbleUp3() {
+        $ds = '\\' . DIRECTORY_SEPARATOR;
+        $prefix = preg_replace("#[{$ds}][^{$ds}]+[{$ds}][^{$ds}]+$#", '', getcwd());
+        $d = $this->smarty->_realpath('././.././.././a.foo', true);
+        $this->assertEquals($prefix . DIRECTORY_SEPARATOR . 'a.foo', $d);
+    }
+    public function testNormalizeToAbsoluteKomplex() {
+        $d = $this->smarty->_realpath('./foo/\\./bar/jo/wie/so/../..///.././././../aa/bb/cc/../../go/a.foo', true);
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . 'foo' . DIRECTORY_SEPARATOR . 'aa'. DIRECTORY_SEPARATOR . 'go' . DIRECTORY_SEPARATOR .'a.foo', $d);
+    }
+
+}

tests/UnitTests/A_0/PathNormalization/PluginDirNormalizationTest.php

@@ -0,0 +1,145 @@
+<?php
+/*
+ * This file is part of the Smarty PHPUnit tests.
+ */
+
+/**
+ * class for path normalization tests
+ *
+ * @runTestsInSeparateProcess
+ * @preserveGlobalState    disabled
+ * @backupStaticAttributes enabled
+ */
+class PluginNormalizationTest extends PHPUnit_Smarty
+{
+    /*
+     * Setup test fixture
+     */
+    public function setUp()
+    {
+        $this->setUpSmarty(dirname(__FILE__));
+    }
+
+    public function testGetPluginsDefaultDir()
+    {
+        $result = $this->smarty->getPluginsDir();
+        $this->assertEquals(1, count($result));
+        $this->assertEquals(SMARTY_PLUGINS_DIR, $result[ 0 ]);
+    }
+    public function testGetPluginsDefaultDir2()
+    {
+        $this->smarty->addPluginsDir('./foo/');
+        $result = $this->smarty->getPluginsDir();
+        $this->assertEquals(2, count($result));
+        $this->assertEquals(SMARTY_PLUGINS_DIR, $result[ 0 ]);
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . 'foo' . DIRECTORY_SEPARATOR, $result[ 1 ]);
+    }
+
+    public function testSetPluginsDir1()
+    {
+        $result = $this->smarty->getPluginsDir();
+        $this->assertEquals(1, count($result));
+        $this->smarty->setPluginsDir('foo');
+        $result = $this->smarty->getPluginsDir();
+        $this->assertEquals(1, count($result));
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . 'foo' . DIRECTORY_SEPARATOR, $result[ 0 ]);
+    }
+
+    public function testSetPluginsDir2()
+    {
+        $result = $this->smarty->getPluginsDir();
+        $this->assertEquals(1, count($result));
+        $this->smarty->setPluginsDir('foo/');
+        $result = $this->smarty->getPluginsDir();
+        $this->assertEquals(1, count($result));
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . 'foo' . DIRECTORY_SEPARATOR, $result[ 0 ]);
+    }
+
+    public function testSetPluginsDir3()
+    {
+        $result = $this->smarty->getPluginsDir();
+        $this->assertEquals(1, count($result));
+        $this->smarty->setPluginsDir('foo/.');
+        $result = $this->smarty->getPluginsDir();
+        $this->assertEquals(1, count($result));
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . 'foo' . DIRECTORY_SEPARATOR, $result[ 0 ]);
+    }
+
+    public function testSetPluginsDir4()
+    {
+        $result = $this->smarty->getPluginsDir();
+        $this->assertEquals(1, count($result));
+        $this->smarty->setPluginsDir('foo/./');
+        $result = $this->smarty->getPluginsDir();
+        $this->assertEquals(1, count($result));
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . 'foo' . DIRECTORY_SEPARATOR, $result[ 0 ]);
+    }
+
+    public function testSetPluginsDir5()
+    {
+        $result = $this->smarty->getPluginsDir();
+        $this->assertEquals(1, count($result));
+        $this->smarty->setPluginsDir('.foo');
+        $result = $this->smarty->getPluginsDir();
+        $this->assertEquals(1, count($result));
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . '.foo' . DIRECTORY_SEPARATOR, $result[ 0 ]);
+    }
+
+    public function testSetPluginsDir6()
+    {
+        $result = $this->smarty->getPluginsDir();
+        $this->assertEquals(1, count($result));
+        $this->smarty->setPluginsDir('..foo');
+        $result = $this->smarty->getPluginsDir();
+        $this->assertEquals(1, count($result));
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . '..foo' . DIRECTORY_SEPARATOR, $result[ 0 ]);
+    }
+
+    public function testSetPluginsDir7()
+    {
+        $result = $this->smarty->getPluginsDir();
+        $this->assertEquals(1, count($result));
+        $this->smarty->setPluginsDir('../foo');
+        $result = $this->smarty->getPluginsDir();
+        $this->assertEquals(1, count($result));
+        $this->assertEquals(substr(getcwd(), 0, - strlen(basename(getcwd()))) . 'foo' . DIRECTORY_SEPARATOR,
+                            $result[ 0 ]);
+    }
+
+    public function testSetPluginsDir8()
+    {
+        $this->smarty->setPluginsDir(array('foo', 'bah'));
+        $result = $this->smarty->getPluginsDir();
+        $this->assertEquals(2, count($result));
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . 'foo' . DIRECTORY_SEPARATOR, $result[ 0 ]);
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . 'bah' . DIRECTORY_SEPARATOR, $result[ 1 ]);
+    }
+
+    public function testSetPluginsDir9()
+    {
+        $this->smarty->setPluginsDir(array('foo', 'bah'));
+        $result = $this->smarty->getPluginsDir();
+        $this->assertEquals(2, count($result));
+        $this->smarty->addPluginsDir('blar');
+        $result = $this->smarty->getPluginsDir();
+        $this->assertEquals(3, count($result));
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . 'foo' . DIRECTORY_SEPARATOR, $result[ 0 ]);
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . 'bah' . DIRECTORY_SEPARATOR, $result[ 1 ]);
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . 'blar' . DIRECTORY_SEPARATOR, $result[ 2 ]);
+    }
+
+    public function testSetPluginsDir10()
+    {
+        $this->smarty->setPluginsDir(array('foo', 'bah'));
+        $result = $this->smarty->getPluginsDir();
+        $this->assertEquals(2, count($result));
+        $this->smarty->addPluginsDir(array('blar', 'smarty'));
+        $result = $this->smarty->getPluginsDir();
+        $this->assertEquals(4, count($result));
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . 'foo' . DIRECTORY_SEPARATOR, $result[ 0 ]);
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . 'bah' . DIRECTORY_SEPARATOR, $result[ 1 ]);
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . 'blar' . DIRECTORY_SEPARATOR, $result[ 2 ]);
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . 'smarty' . DIRECTORY_SEPARATOR, $result[ 3 ]);
+    }
+
+}

tests/UnitTests/A_0/PathNormalization/TemlateDirNormalizationTest.php

@@ -0,0 +1,137 @@
+<?php
+/*
+ * This file is part of the Smarty PHPUnit tests.
+ */
+
+/**
+ * class for path normalization tests
+ *
+ * @runTestsInSeparateProcess
+ * @preserveGlobalState    disabled
+ * @backupStaticAttributes enabled
+ */
+class TemplateNormalizationTest extends PHPUnit_Smarty
+{
+    /*
+     * Setup test fixture
+     */
+    public function setUp()
+    {
+        $this->setUpSmarty(dirname(__FILE__));
+    }
+
+    public function testGetTemplateDir()
+    {
+        $result = $this->smarty->getTemplateDir();
+        $this->assertEquals(1, count($result));
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . 'templates' . DIRECTORY_SEPARATOR, $result[ 0 ]);
+    }
+
+    public function testSetTemplateDir1()
+    {
+        $result = $this->smarty->getTemplateDir();
+        $this->assertEquals(1, count($result));
+        $this->smarty->setTemplateDir('foo');
+        $result = $this->smarty->getTemplateDir();
+        $this->assertEquals(1, count($result));
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . 'foo' . DIRECTORY_SEPARATOR, $result[ 0 ]);
+    }
+
+    public function testSetTemplateDir2()
+    {
+        $result = $this->smarty->getTemplateDir();
+        $this->assertEquals(1, count($result));
+        $this->smarty->setTemplateDir('foo/');
+        $result = $this->smarty->getTemplateDir();
+        $this->assertEquals(1, count($result));
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . 'foo' . DIRECTORY_SEPARATOR, $result[ 0 ]);
+    }
+
+    public function testSetTemplateDir3()
+    {
+        $result = $this->smarty->getTemplateDir();
+        $this->assertEquals(1, count($result));
+        $this->smarty->setTemplateDir('foo/.');
+        $result = $this->smarty->getTemplateDir();
+        $this->assertEquals(1, count($result));
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . 'foo' . DIRECTORY_SEPARATOR, $result[ 0 ]);
+    }
+
+    public function testSetTemplateDir4()
+    {
+        $result = $this->smarty->getTemplateDir();
+        $this->assertEquals(1, count($result));
+        $this->smarty->setTemplateDir('foo/./');
+        $result = $this->smarty->getTemplateDir();
+        $this->assertEquals(1, count($result));
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . 'foo' . DIRECTORY_SEPARATOR, $result[ 0 ]);
+    }
+
+    public function testSetTemplateDir5()
+    {
+        $result = $this->smarty->getTemplateDir();
+        $this->assertEquals(1, count($result));
+        $this->smarty->setTemplateDir('.foo');
+        $result = $this->smarty->getTemplateDir();
+        $this->assertEquals(1, count($result));
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . '.foo' . DIRECTORY_SEPARATOR, $result[ 0 ]);
+    }
+
+    public function testSetTemplateDir6()
+    {
+        $result = $this->smarty->getTemplateDir();
+        $this->assertEquals(1, count($result));
+        $this->smarty->setTemplateDir('..foo');
+        $result = $this->smarty->getTemplateDir();
+        $this->assertEquals(1, count($result));
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . '..foo' . DIRECTORY_SEPARATOR, $result[ 0 ]);
+    }
+
+    public function testSetTemplateDir7()
+    {
+        $result = $this->smarty->getTemplateDir();
+        $this->assertEquals(1, count($result));
+        $this->smarty->setTemplateDir('../foo');
+        $result = $this->smarty->getTemplateDir();
+        $this->assertEquals(1, count($result));
+        $this->assertEquals(substr(getcwd(), 0, - strlen(basename(getcwd()))) . 'foo' . DIRECTORY_SEPARATOR,
+                            $result[ 0 ]);
+    }
+
+    public function testSetTemplateDir8()
+    {
+        $this->smarty->setTemplateDir(array('foo', 'bah'));
+        $result = $this->smarty->getTemplateDir();
+        $this->assertEquals(2, count($result));
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . 'foo' . DIRECTORY_SEPARATOR, $result[ 0 ]);
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . 'bah' . DIRECTORY_SEPARATOR, $result[ 1 ]);
+    }
+
+    public function testSetTemplateDir9()
+    {
+        $this->smarty->setTemplateDir(array('foo', 'bah'));
+        $result = $this->smarty->getTemplateDir();
+        $this->assertEquals(2, count($result));
+        $this->smarty->addTemplateDir('blar');
+        $result = $this->smarty->getTemplateDir();
+        $this->assertEquals(3, count($result));
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . 'foo' . DIRECTORY_SEPARATOR, $result[ 0 ]);
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . 'bah' . DIRECTORY_SEPARATOR, $result[ 1 ]);
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . 'blar' . DIRECTORY_SEPARATOR, $result[ 2 ]);
+    }
+
+    public function testSetTemplateDir10()
+    {
+        $this->smarty->setTemplateDir(array('foo', 'bah'));
+        $result = $this->smarty->getTemplateDir();
+        $this->assertEquals(2, count($result));
+        $this->smarty->addTemplateDir(array('blar', 'smarty'));
+        $result = $this->smarty->getTemplateDir();
+        $this->assertEquals(4, count($result));
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . 'foo' . DIRECTORY_SEPARATOR, $result[ 0 ]);
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . 'bah' . DIRECTORY_SEPARATOR, $result[ 1 ]);
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . 'blar' . DIRECTORY_SEPARATOR, $result[ 2 ]);
+        $this->assertEquals(getcwd() . DIRECTORY_SEPARATOR . 'smarty' . DIRECTORY_SEPARATOR, $result[ 3 ]);
+    }
+
+}

tests/UnitTests/A_0/PathNormalization/cache/.gitignore

@@ -0,0 +1,2 @@
+# Ignore anything in here, but keep this directory
+*

tests/UnitTests/A_0/PathNormalization/templates_c/.gitignore

@@ -0,0 +1,2 @@
+# Ignore anything in here, but keep this directory
+*

tests/UnitTests/A_1/ProtectedFolderVars/ProtectedFolderVarsTest.php

@@ -0,0 +1,226 @@
+<?php
+/*
+ * This file is part of the Smarty PHPUnit tests.
+ */
+
+/**
+ * class for protected $template_dir, $compile_dir, $cache_dir, $config_dir, $plugins_dir property tests
+ *
+ * @runTestsInSeparateProcess
+ * @preserveGlobalState    disabled
+ * @backupStaticAttributes enabled
+ */
+class ProtectedFolderVarsTest extends PHPUnit_Smarty
+{
+    /*
+     * Setup test fixture
+     */
+    public function setUp()
+    {
+        $this->setUpSmarty(dirname(__FILE__));
+    }
+
+    /*
+     * template_dir
+     */
+
+    public function testTemplateDirDirectRelative()
+    {
+        $s = new Smarty();
+        $s->template_dir = './foo';
+        $d = $s->getTemplateDir();
+        $this->assertEquals(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'foo' . DIRECTORY_SEPARATOR, $d[ 0 ]);
+    }
+
+    public function testTemplateDirDirectRelativeArray()
+    {
+        $s = new Smarty();
+        $s->template_dir = array('./foo', './bar/');
+        $d = $s->template_dir;
+        $this->assertEquals(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'foo' . DIRECTORY_SEPARATOR, $d[ 0 ]);
+        $this->assertEquals(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'bar' . DIRECTORY_SEPARATOR, $d[ 1 ]);
+    }
+
+    public function testTemplateDirDirectRelativeArrayAdd()
+    {
+        $s = new Smarty();
+        $s->template_dir = './foo';
+        $s->addTemplateDir('./bar/');
+        $d = $s->getTemplateDir();
+        $this->assertEquals(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'foo' . DIRECTORY_SEPARATOR, $d[ 0 ]);
+        $this->assertEquals(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'bar' . DIRECTORY_SEPARATOR, $d[ 1 ]);
+    }
+
+    public function testTemplateDirDirectRelativeExtends()
+    {
+        $s = new FolderT();
+        $d = $s->getTemplateDir();
+        $this->assertEquals(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'foo' . DIRECTORY_SEPARATOR, $d[ 0 ]);
+    }
+
+    public function testTemplateDirDirectRelativeExtends2()
+    {
+        $s = new FolderT();
+        $s->template_dir = './bar';
+        $d = $s->getTemplateDir();
+        $this->assertEquals(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'bar' . DIRECTORY_SEPARATOR, $d[ 0 ]);
+    }
+
+    /*
+    * config_dir
+    */
+
+    public function testConfigDirDirectRelative()
+    {
+        $s = new Smarty();
+        $s->config_dir = './foo';
+        $d = $s->getConfigDir();
+        $this->assertEquals(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'foo' . DIRECTORY_SEPARATOR, $d[ 0 ]);
+    }
+
+    public function testConfigDirDirectRelativeArray()
+    {
+        $s = new Smarty();
+        $s->config_dir = array('./foo', './bar/');
+        $d = $s->config_dir;
+        $this->assertEquals(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'foo' . DIRECTORY_SEPARATOR, $d[ 0 ]);
+        $this->assertEquals(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'bar' . DIRECTORY_SEPARATOR, $d[ 1 ]);
+    }
+
+    public function testConfigDirDirectRelativeArrayAdd()
+    {
+        $s = new Smarty();
+        $s->config_dir = './foo';
+        $s->addConfigDir('./bar/');
+        $d = $s->getConfigDir();
+        $this->assertEquals(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'foo' . DIRECTORY_SEPARATOR, $d[ 0 ]);
+        $this->assertEquals(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'bar' . DIRECTORY_SEPARATOR, $d[ 1 ]);
+    }
+
+    public function testConfigDirDirectRelativeExtends()
+    {
+        $s = new FolderT();
+        $d = $s->getConfigDir();
+        $this->assertEquals(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'conf' . DIRECTORY_SEPARATOR, $d[ 0 ]);
+    }
+
+    public function testConfigDirDirectRelativeExtends2()
+    {
+        $s = new FolderT();
+        $s->config_dir = './bar';
+        $d = $s->getConfigDir();
+        $this->assertEquals(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'bar' . DIRECTORY_SEPARATOR, $d[ 0 ]);
+    }
+
+    /*
+    * plugins_dir
+    */
+
+    public function testPluginDirDirectRelative()
+    {
+        $s = new Smarty();
+        $s->plugins_dir = './foo';
+        $d = $s->getPluginsDir();
+        $this->assertEquals(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'foo' . DIRECTORY_SEPARATOR, $d[ 0 ]);
+    }
+
+    public function testPluginDirDirectRelativeArray()
+    {
+        $s = new Smarty();
+        $s->plugins_dir = array('./foo', './bar/');
+        $d = $s->plugins_dir;
+        $this->assertEquals(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'foo' . DIRECTORY_SEPARATOR, $d[ 0 ]);
+        $this->assertEquals(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'bar' . DIRECTORY_SEPARATOR, $d[ 1 ]);
+    }
+
+    public function testPluginDirDirectRelativeArrayAdd()
+    {
+        $s = new Smarty();
+        $s->plugins_dir = './foo';
+        $s->addPluginsDir('./bar/');
+        $d = $s->getPluginsDir();
+        $this->assertEquals(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'foo' . DIRECTORY_SEPARATOR, $d[ 0 ]);
+        $this->assertEquals(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'bar' . DIRECTORY_SEPARATOR, $d[ 1 ]);
+    }
+
+    public function testPluginDirDirectRelativeExtends()
+    {
+        $s = new FolderT();
+        $d = $s->getPluginsDir();
+        $this->assertEquals(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'plug' . DIRECTORY_SEPARATOR, $d[ 0 ]);
+    }
+
+    public function testPluginDirDirectRelativeExtends2()
+    {
+        $s = new FolderT();
+        $s->plugins_dir = './bar';
+        $d = $s->getPluginsDir();
+        $this->assertEquals(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'bar' . DIRECTORY_SEPARATOR, $d[ 0 ]);
+    }
+    /*
+     * compile_dir
+     */
+
+    public function testCompileDirDirectRelative()
+    {
+        $s = new Smarty();
+        $s->compile_dir = './foo';
+        $d = $s->getCompileDir();
+        $this->assertEquals(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'foo' . DIRECTORY_SEPARATOR, $d);
+    }
+
+    public function testCompileDirDirectRelativeExtends()
+    {
+        $s = new FolderT();
+        $d = $s->getCompileDir();
+        $this->assertEquals(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'comp' . DIRECTORY_SEPARATOR, $d);
+    }
+
+    public function testCompileDirDirectRelativeExtends2()
+    {
+        $s = new FolderT();
+        $s->compile_dir = './bar';
+        $d = $s->getCompileDir();
+        $this->assertEquals(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'bar' . DIRECTORY_SEPARATOR, $d);
+    }
+    /*
+     * cache_dir
+     */
+
+    public function testCacheDirDirectRelative()
+    {
+        $s = new Smarty();
+        $s->cache_dir = './foo';
+        $d = $s->getCacheDir();
+        $this->assertEquals(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'foo' . DIRECTORY_SEPARATOR, $d);
+    }
+
+    public function testCacheDirDirectRelativeExtends()
+    {
+        $s = new FolderT();
+        $d = $s->getCacheDir();
+        $this->assertEquals(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'cache' . DIRECTORY_SEPARATOR, $d);
+    }
+
+    public function testCacheDirDirectRelativeExtends2()
+    {
+        $s = new FolderT();
+        $s->cache_dir = './bar';
+        $d = $s->getCacheDir();
+        $this->assertEquals(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'bar' . DIRECTORY_SEPARATOR, $d);
+    }
+}
+
+class FolderT extends Smarty
+{
+    protected $template_dir = './foo';
+
+    protected $compile_dir = './comp/';
+
+    protected $plugins_dir = './plug/';
+
+    protected $cache_dir = './cache/';
+
+    protected $config_dir = array('./conf/');
+
+}

tests/UnitTests/A_1/ProtectedFolderVars/cache/.gitignore

@@ -0,0 +1,2 @@
+# Ignore anything in here, but keep this directory
+*

tests/UnitTests/A_1/ProtectedFolderVars/comp/.gitignore

@@ -0,0 +1,2 @@
+# Ignore anything in here, but keep this directory
+*

tests/UnitTests/A_2/UndefinedTemplateVar/UndefinedTemplateVarTest.php

@@ -0,0 +1,74 @@
+<?php
+/*
+ * This file is part of the Smarty PHPUnit tests.
+ */
+
+/**
+ * class for protected $template_dir, $compile_dir, $cache_dir, $config_dir, $plugins_dir property tests
+ *
+ * @backupStaticAttributes enabled
+ */
+class UndefinedTemplateVarTest extends PHPUnit_Smarty
+{
+    /*
+     * Setup test fixture
+     */
+    public function setUp()
+    {
+        $this->setUpSmarty(dirname(__FILE__));
+        error_reporting(E_ALL | E_STRICT);
+    }
+
+    public function testInit()
+    {
+        $this->cleanDirs();
+    }
+    /**
+     * Test E_NOTICE suppression template fetched by Smarty object
+     */
+    public function testE_NoticeDisabled()
+    {
+        $e1 = error_reporting();
+        $this->smarty->setErrorReporting(E_ALL & ~E_NOTICE);
+        $this->assertEquals('undefined = ', $this->smarty->fetch('001_main.tpl'));
+        $e2 = error_reporting();
+        $this->assertEquals($e1, $e2);
+    }
+
+    /**
+     * Test E_NOTICE suppression template fetched by template object
+     */
+    public function testE_NoticeDisabledTplObject_1()
+    {
+        $e1 = error_reporting();
+        $this->smarty->setErrorReporting(E_ALL & ~E_NOTICE);
+        $tpl = $this->smarty->createTemplate('001_main.tpl');
+        $this->assertEquals('undefined = ', $tpl->fetch());
+        $e2 = error_reporting();
+        $this->assertEquals($e1, $e2);
+    }
+
+    public function testE_NoticeDisabledTplObject_2()
+    {
+        $e1 = error_reporting();
+        $this->smarty->setErrorReporting(E_ALL & ~E_NOTICE);
+        $tpl = $this->smarty->createTemplate('001_main.tpl');
+        $this->assertEquals('undefined = ', $this->smarty->fetch($tpl));
+        $e2 = error_reporting();
+        $this->assertEquals($e1, $e2);
+    }
+
+    /**
+     * Throw E_NOTICE message
+     *
+     * @expectedException PHPUnit_Framework_Error_Notice
+     * @expectedExceptionMessage Undefined index: foo
+     */
+    public function testE_Notice()
+    {
+            $e1 = error_reporting();
+            $this->assertEquals('undefined = ', $this->smarty->fetch('001_main.tpl'));
+            $e2 = error_reporting();
+            $this->assertEquals($e1, $e2);
+    }
+}

tests/UnitTests/A_2/UndefinedTemplateVar/cache/.gitignore

@@ -0,0 +1,2 @@
+# Ignore anything in here, but keep this directory
+*

tests/UnitTests/A_2/UndefinedTemplateVar/templates/001_include.tpl

@@ -0,0 +1 @@
+undefined = {$foo}

tests/UnitTests/A_2/UndefinedTemplateVar/templates/001_main.tpl

@@ -0,0 +1 @@
+{include '001_include.tpl'}

tests/UnitTests/A_2/UndefinedTemplateVar/templates_c/.gitignore

@@ -0,0 +1,2 @@
+# Ignore anything in here, but keep this directory
+*

tests/UnitTests/A_Core/AutoEscape/AutoEscapeTest.php

@@ -0,0 +1,33 @@
+<?php
+/*
+ * This file is part of the Smarty PHPUnit tests.
+ */
+
+/**
+ * class for 'escapeHtml' property tests
+ *
+ * @runTestsInSeparateProcess
+ * @preserveGlobalState disabled
+ * @backupStaticAttributes enabled
+ */
+class AutoEscapeTest extends PHPUnit_Smarty
+{
+    /*
+     * Setup test fixture
+     */
+    public function setUp()
+    {
+        $this->setUpSmarty(dirname(__FILE__));
+        $this->smarty->setEscapeHtml(true);
+    }
+
+    /**
+     * test 'escapeHtml' property
+     */
+    public function testAutoEscape()
+    {
+        $tpl = $this->smarty->createTemplate('eval:{$foo}');
+        $tpl->assign('foo', '<a@b.c>');
+        $this->assertEquals("&lt;a@b.c&gt;", $this->smarty->fetch($tpl));
+    }
+}

tests/UnitTests/A_Core/AutoEscape/cache/.gitignore

@@ -0,0 +1,2 @@
+# Ignore anything in here, but keep this directory
+*

tests/UnitTests/A_Core/AutoEscape/templates_c/.gitignore

@@ -0,0 +1,2 @@
+# Ignore anything in here, but keep this directory
+*

tests/UnitTests/A_Core/Filter/FilterClosure.php

@@ -0,0 +1,14 @@
+<?php
+
+     /**
+     * test registered pre filter closure
+     * @requires PHP 5.3
+     */
+
+        $this->smarty->registerFilter(Smarty::FILTER_PRE, function ($input) {
+            return '{$foo}' . $input;
+        });
+        $tpl = $this->smarty->createTemplate('eval:{" hello world"}');
+        $tpl->assign('foo', 'buh');
+        $this->assertEquals("buh hello world", $this->smarty->fetch($tpl));
+

tests/UnitTests/A_Core/Filter/FilterTest.php

@@ -0,0 +1,279 @@
+<?php
+/**
+ * Smarty PHPunit tests of filter
+ *
+ * @package PHPunit
+ * @author  Uwe Tews
+ */
+
+/**
+ * class for filter tests
+ *
+ * @runTestsInSeparateProcess
+ * @preserveGlobalState    disabled
+ * @backupStaticAttributes enabled
+ */
+class FilterTest extends PHPUnit_Smarty
+{
+    public $loadSmartyBC = true;
+
+    public function setUp()
+    {
+        $this->setUpSmarty(dirname(__FILE__));
+    }
+
+    public function testInit()
+    {
+        $this->cleanDirs();
+    }
+
+    /**
+     * test autoload output filter
+     */
+    public function testAutoloadOutputFilter()
+    {
+        $this->smarty->autoload_filters[ 'output' ] = 'trimwhitespace';
+        $tpl = $this->smarty->createTemplate('eval:{"    <br>hello world"}');
+        $this->assertEquals("<br>hello world", $this->smarty->fetch($tpl));
+    }
+
+    /**
+     * test autoload variable filter
+     */
+    public function testAutoloadVariableFilter()
+    {
+        $this->smarty->autoload_filters[ 'variable' ] = 'htmlspecialchars';
+        $tpl = $this->smarty->createTemplate('eval:{"<test>"}');
+        $this->assertEquals("&lt;test&gt;", $this->smarty->fetch($tpl));
+    }
+
+    /**
+     * test loaded filter
+     */
+    public function testLoadedOutputFilter()
+    {
+        $this->smarty->loadFilter(Smarty::FILTER_OUTPUT, 'trimwhitespace');
+        $tpl = $this->smarty->createTemplate('string:{"    <br>hello world"}');
+        $this->assertEquals("<br>hello world", $this->smarty->fetch($tpl));
+    }
+
+    public function testLoadedOutputFilterWrapper()
+    {
+        $this->smartyBC->load_filter(Smarty::FILTER_OUTPUT, 'trimwhitespace');
+        $tpl = $this->smartyBC->createTemplate('eval:{"    <br>hello world"}');
+        $this->assertEquals("<br>hello world", $this->smartyBC->fetch($tpl));
+    }
+
+    /**
+     * test registered output filter
+     */
+    public function testRegisteredOutputFilter()
+    {
+        $this->smarty->registerFilter(Smarty::FILTER_OUTPUT, 'myoutputfilter');
+        $tpl = $this->smarty->createTemplate('eval:{"hello   world"}');
+        $this->assertEquals("hello world", $this->smarty->fetch($tpl));
+    }
+
+    /**
+     * test registered output filter not cached
+     *
+     * @runInSeparateProcess
+     * @preserveGlobalState disabled
+     */
+    public function testRegisteredOutputFilter_001()
+    {
+        $this->smarty->assign('foo', 1);
+        $this->smarty->assign('bar', 2);
+        $this->smarty->registerFilter(Smarty::FILTER_OUTPUT, 'myoutputfilter2');
+        $this->assertEquals('1 filter 2', $this->smarty->fetch('output_001.tpl'));
+    }
+
+    /**
+     * test registered output filter not cached 2"
+     *
+     * @runInSeparateProcess
+     * @preserveGlobalState disabled
+     */
+    public function testRegisteredOutputFilter_001_2()
+    {
+        $this->smarty->assign('foo', 3);
+        $this->smarty->assign('bar', 4);
+        $this->smarty->registerFilter(Smarty::FILTER_OUTPUT, 'myoutputfilter2');
+        $this->assertEquals('3 filter 4', $this->smarty->fetch('output_001.tpl'));
+    }
+
+    /**
+     * test registered output filter cached 1"
+     *
+     * @runInSeparateProcess
+     * @preserveGlobalState disabled
+     */
+    public function testRegisteredOutputFilter_001_3()
+    {
+        $this->smarty->setCaching(true);
+        $this->smarty->assign('foo', 5);
+        $this->smarty->assign('bar', 6);
+        $this->smarty->registerFilter(Smarty::FILTER_OUTPUT, 'myoutputfilter2');
+        $this->assertEquals('5 filter 6', $this->smarty->fetch('output_001.tpl'));
+    }
+
+    /**
+     * test registered output filter cached 1"
+     *
+     * @runInSeparateProcess
+     * @preserveGlobalState disabled
+     */
+    public function testRegisteredOutputFilter_001_4()
+    {
+        $this->smarty->setCaching(true);
+        $this->smarty->assign('foo', 7);
+        $this->smarty->assign('bar', 8);
+        $this->smarty->registerFilter(Smarty::FILTER_OUTPUT, 'myoutputfilter2');
+        $this->assertEquals('5 filter 6', $this->smarty->fetch('output_001.tpl'));
+    }
+
+    /**
+     * test registered output filter cached nocache"
+     *
+     * @runInSeparateProcess
+     * @preserveGlobalState disabled
+     */
+    public function testRegisteredOutputFilter_002_1()
+    {
+        $this->smarty->setCaching(true);
+        $this->smarty->assign('foo', 10);
+        $this->smarty->assign('bar', 11);
+        $this->smarty->registerFilter(Smarty::FILTER_OUTPUT, 'myoutputfilter2');
+        $this->assertEquals('10 filter 11', $this->smarty->fetch('output_002.tpl'));
+    }
+
+    /**
+     * test registered output filter cached nocache"
+     *
+     * @runInSeparateProcess
+     * @preserveGlobalState disabled
+     */
+    public function testRegisteredOutputFilter_002_2()
+    {
+        $this->smarty->setCaching(true);
+        $this->smarty->assign('foo', 12);
+        $this->smarty->assign('bar', 13);
+        $this->smarty->registerFilter(Smarty::FILTER_OUTPUT, 'myoutputfilter2');
+        $this->assertEquals('12 filter 13', $this->smarty->fetch('output_002.tpl'));
+    }
+
+    public function testRegisteredOutputFilterWrapper()
+    {
+        $this->smartyBC->register_outputfilter('myoutputfilter');
+        $tpl = $this->smartyBC->createTemplate('eval:{"hello   world"}');
+        $this->assertEquals("hello world", $this->smartyBC->fetch($tpl));
+    }
+
+    /**
+     * test registered pre filter
+     */
+    public function testRegisteredPreFilter()
+    {
+        function myprefilter($input)
+        {
+            return '{$foo}' . $input;
+        }
+
+        $this->smarty->registerFilter(Smarty::FILTER_PRE, 'myprefilter');
+        $tpl = $this->smarty->createTemplate('eval:{" hello world"}');
+        $tpl->assign('foo', 'bar');
+        $this->assertEquals("bar hello world", $this->smarty->fetch($tpl));
+    }
+
+    /**
+     * test registered pre filter closure
+     * @requires PHP 5.3
+     */
+
+    public function testRegisteredPreFilterClosure()
+    {
+       if (version_compare(PHP_VERSION,'5.3','<'))
+       {
+           $this->markTestSkipped('does not run for PHP 5.2');
+       } else {
+           include 'FilterClosure.php';
+       }
+    }
+
+    /**
+     * test registered pre filter class
+     */
+    public function testRegisteredPreFilterClass()
+    {
+        $this->smarty->registerFilter(Smarty::FILTER_PRE, array('myprefilterclass', 'myprefilter'));
+        $tpl = $this->smarty->createTemplate('eval:{" hello world"}');
+        $tpl->assign('foo', 'bar');
+        $this->assertEquals("bar hello world", $this->smarty->fetch($tpl));
+    }
+
+    /**
+     * test registered post filter
+     */
+    public function testRegisteredPostFilter()
+    {
+        function mypostfilter($input)
+        {
+            return '{$foo}' . $input;
+        }
+
+        $this->smarty->registerFilter(Smarty::FILTER_POST, 'mypostfilter');
+        $tpl = $this->smarty->createTemplate('eval:{" hello world"}');
+        $tpl->assign('foo', 'bar');
+        $this->assertEquals('{$foo} hello world', $this->smarty->fetch($tpl));
+    }
+
+    /**
+     * test variable filter
+     */
+    public function testLoadedVariableFilter()
+    {
+        $this->smarty->loadFilter("variable", "htmlspecialchars");
+        $tpl = $this->smarty->createTemplate('eval:{$foo}');
+        $tpl->assign('foo', '<?php ?>');
+        $this->assertEquals('&lt;?php ?&gt;', $this->smarty->fetch($tpl));
+    }
+
+    /**
+     * test registered post filter
+     */
+    public function testRegisteredVariableFilter2()
+    {
+        $var = new VarFilter();
+
+        $this->smarty->registerFilter(Smarty::FILTER_VARIABLE, array($var, 'variablefilter'));
+        $tpl = $this->smarty->createTemplate('string:{$foo}');
+        $tpl->assign('foo', 'bar');
+        $this->assertEquals('var{$foo}bar', $this->smarty->fetch($tpl));
+    }
+}
+
+Class VarFilter
+{
+    function variablefilter($input, $smarty)
+    {
+        return 'var{$foo}' . $input;
+    }
+}
+
+function myoutputfilter($input)
+{
+    return str_replace('   ', ' ', $input);
+}
+
+function myoutputfilter2($input, $tpl)
+{
+    return $input . ' filter ' . $tpl->tpl_vars[ 'bar' ];
+}
+
+class myprefilterclass
+{
+    static function myprefilter($input)
+    {
+        return '{$foo}' . $input;
+    }
+}

tests/UnitTests/A_Core/Filter/LoadFilterTest.php

@@ -0,0 +1,31 @@
+<?php
+/**
+ * Smarty PHPunit tests loadFilter method
+ *
+ * @package PHPunit
+ * @author  Uwe Tews
+ */
+
+/**
+ * class for loadFilter method tests
+ *
+ * @runTestsInSeparateProcess
+ * @preserveGlobalState disabled
+ * @backupStaticAttributes enabled
+ */
+class LoadFilterTest extends PHPUnit_Smarty
+{
+    public function setUp()
+    {
+        $this->setUpSmarty(dirname(__FILE__));
+    }
+
+    /**
+     * test loadFilter method
+     */
+    public function testLoadFilter()
+    {
+        $this->smarty->loadFilter('output', 'trimwhitespace');
+        $this->assertTrue(is_callable($this->smarty->registered_filters['output']['smarty_outputfilter_trimwhitespace']));
+    }
+}

tests/UnitTests/A_Core/Filter/RegisterFilterTest.php

@@ -0,0 +1,158 @@
+<?php
+/**
+ * Smarty PHPunit tests register_filter / unregister_filter methods
+ *
+ * @package PHPunit
+ * @author  Uwe Tews
+ */
+
+/**
+ * class for register_filter / unregister_filter methods tests
+ *
+ * @runTestsInSeparateProcess
+ * @preserveGlobalState disabled
+ * @backupStaticAttributes enabled
+ */
+class RegisterFilterTest extends PHPUnit_Smarty
+{
+    public function setUp()
+    {
+        $this->setUpSmarty(dirname(__FILE__));
+    }
+
+    /**
+     * test register->preFilter method for function
+     */
+    public function testRegisterPrefilterFunction()
+    {
+        $this->smarty->registerFilter(Smarty::FILTER_PRE, 'myfilter');
+        $this->assertTrue(is_callable($this->smarty->registered_filters['pre']['myfilter']));
+    }
+
+    /**
+     * test register->preFilter method for class method
+     */
+    public function testRegisterPrefiltermethod()
+    {
+        $this->smarty->registerFilter(Smarty::FILTER_PRE, array('myfilterclass', 'execute'));
+        $this->assertTrue(is_callable($this->smarty->registered_filters['pre']['myfilterclass_execute']));
+    }
+
+    /**
+     * test register->preFilter method for class object
+     */
+    public function testRegisterPrefilterObject()
+    {
+        $this->smarty->registerFilter(Smarty::FILTER_PRE, array(new myfilterclass, 'execute'));
+        $this->assertTrue(is_callable($this->smarty->registered_filters['pre']['myfilterclass_execute']));
+    }
+
+    /**
+     * test unregister->preFilter method for function
+     */
+    public function testUnegisterPrefilterFunction()
+    {
+        $this->smarty->registerFilter(Smarty::FILTER_PRE, 'myfilter');
+        $this->smarty->unregisterFilter(Smarty::FILTER_PRE, 'myfilter');
+        $this->assertFalse(isset($this->smarty->registered_filters['pre']['myfilter']));
+    }
+
+    /**
+     * test unregister->preFilter method for class method
+     */
+    public function testUnregisterPrefiltermethod()
+    {
+        $this->smarty->registerFilter(Smarty::FILTER_PRE, array('myfilterclass', 'execute'));
+        $this->smarty->unregisterFilter(Smarty::FILTER_PRE, array('myfilterclass', 'execute'));
+        $this->assertFalse(isset($this->smarty->registered_filters['pre']['myfilterclass_execute']));
+    }
+
+    /**
+     * test register->postFilter method for function
+     */
+    public function testRegisterPostfilterFunction()
+    {
+        $this->smarty->registerFilter(Smarty::FILTER_POST, 'myfilter');
+        $this->assertTrue(is_callable($this->smarty->registered_filters['post']['myfilter']));
+    }
+
+    /**
+     * test register->postFilter method for class method
+     */
+    public function testRegisterPostfiltermethod()
+    {
+        $this->smarty->registerFilter(Smarty::FILTER_POST, array('myfilterclass', 'execute'));
+        $this->assertTrue(is_callable($this->smarty->registered_filters['post']['myfilterclass_execute']));
+    }
+
+    /**
+     * test unregister->postFilter method for function
+     */
+    public function testUnegisterPostfilterFunction()
+    {
+        $this->smarty->registerFilter(Smarty::FILTER_POST, 'myfilter');
+        $this->smarty->unregisterFilter(Smarty::FILTER_POST, 'myfilter');
+        $this->assertFalse(isset($this->smarty->registered_filters['post']['myfilter']));
+    }
+
+    /**
+     * test unregister->postFilter method for class method
+     */
+    public function testUnregisterPostfiltermethod()
+    {
+        $this->smarty->registerFilter(Smarty::FILTER_POST, array('myfilterclass', 'execute'));
+        $this->smarty->unregisterFilter(Smarty::FILTER_POST, array('myfilterclass', 'execute'));
+        $this->assertFalse(isset($this->smarty->registered_filters['post']['myfilterclass_execute']));
+    }
+
+    /**
+     * test register->outputFilter method for function
+     */
+    public function testRegisterOutputfilterFunction()
+    {
+        $this->smarty->registerFilter(Smarty::FILTER_OUTPUT, 'myfilter');
+        $this->assertTrue(is_callable($this->smarty->registered_filters['output']['myfilter']));
+    }
+
+    /**
+     * test register->outputFilter method for class method
+     */
+    public function testRegisterOutputfiltermethod()
+    {
+        $this->smarty->registerFilter(Smarty::FILTER_OUTPUT, array('myfilterclass', 'execute'));
+        $this->assertTrue(is_callable($this->smarty->registered_filters['output']['myfilterclass_execute']));
+    }
+
+    /**
+     * test unregister->outputFilter method for function
+     */
+    public function testUnegisterOutputfilterFunction()
+    {
+        $this->smarty->registerFilter(Smarty::FILTER_OUTPUT, 'myfilter');
+        $this->smarty->unregisterFilter(Smarty::FILTER_OUTPUT, 'myfilter');
+        $this->assertFalse(isset($this->smarty->registered_filters['output']['myfilter']));
+    }
+
+    /**
+     * test unregister->outputFilter method for class method
+     */
+    public function testUnregisterOutputfiltermethod()
+    {
+        $this->smarty->registerFilter(Smarty::FILTER_OUTPUT, array('myfilterclass', 'execute'));
+        $this->smarty->unregisterFilter(Smarty::FILTER_OUTPUT, array('myfilterclass', 'execute'));
+        $this->assertFalse(isset($this->smarty->registered_filters['output']['myfilterclass_execute']));
+    }
+}
+
+function myfilter($input)
+{
+    return $input;
+}
+
+class myfilterclass
+{
+    static function execute($input)
+    {
+        return $input;
+    }
+}

tests/UnitTests/A_Core/Filter/cache/.gitignore

@@ -0,0 +1,2 @@
+# Ignore anything in here, but keep this directory
+*

tests/UnitTests/A_Core/Filter/templates/output_001.tpl

@@ -0,0 +1 @@
+{$foo}

tests/UnitTests/A_Core/Filter/templates/output_002.tpl

@@ -0,0 +1 @@
+{$foo nocache}

tests/UnitTests/A_Core/Filter/templates_c/.gitignore

@@ -0,0 +1,2 @@
+# Ignore anything in here, but keep this directory
+*

tests/UnitTests/A_Core/GetterSetter/GetterSetterTest.php

@@ -0,0 +1,75 @@
+<?php
+/**
+ * Smarty PHPunit tests of generic getter/setter
+ *
+ * @package PHPunit
+ * @author  Uwe Tews
+ */
+
+/**
+ * class for generic getter/setter tests
+ *
+ * @runTestsInSeparateProcess
+ * @preserveGlobalState disabled
+ * @backupStaticAttributes enabled
+ */
+class GetterSetterTest extends PHPUnit_Smarty
+{
+     public function setUp()
+    {
+        $this->setUpSmarty(dirname(__FILE__));
+    }
+
+    public function testInit()
+    {
+        $this->cleanDirs();
+    }
+
+    /**
+     * test setter on Smarty object
+     */
+    public function testSmartySetter()
+    {
+        $this->smarty->setLeftDelimiter('<{');
+        $this->smarty->setRightDelimiter('}>');
+        $this->assertEquals('<{', $this->smarty->left_delimiter);
+        $this->assertEquals('}>', $this->smarty->right_delimiter);
+    }
+
+    /**
+     * test getter on Smarty object
+     */
+    public function testSmartyGetter()
+    {
+        $this->smarty->setLeftDelimiter('<{');
+        $this->smarty->setRightDelimiter('}>');
+        $this->assertEquals('<{', $this->smarty->getLeftDelimiter());
+        $this->assertEquals('}>', $this->smarty->getRightDelimiter());
+    }
+
+    /**
+     * test setter on Template object
+     */
+    public function testTemplateSetter()
+    {
+        $tpl = $this->smarty->createTemplate('helloworld.tpl');
+        $tpl->setLeftDelimiter('<{');
+        $tpl->setRightDelimiter('}>');
+        $this->assertEquals('<{', $tpl->smarty->left_delimiter);
+        $this->assertEquals('}>', $tpl->smarty->right_delimiter);
+        $this->assertEquals('{', $this->smarty->left_delimiter);
+        $this->assertEquals('}', $this->smarty->right_delimiter);
+    }
+
+    /**
+     * test getter on Template object
+     */
+    public function testTemplateGetter()
+    {
+        $tpl = $this->smarty->createTemplate('helloworld.tpl');
+        $tpl->setLeftDelimiter('<{');
+        $tpl->setRightDelimiter('}>');
+        $this->assertEquals('<{', $tpl->getLeftDelimiter());
+        $this->assertEquals('}>', $tpl->getRightDelimiter());
+    }
+}

tests/UnitTests/A_Core/GetterSetter/cache/.gitignore

@@ -0,0 +1,2 @@
+# Ignore anything in here, but keep this directory
+*

tests/UnitTests/A_Core/GetterSetter/templates_c/.gitignore

@@ -0,0 +1,2 @@
+# Ignore anything in here, but keep this directory
+*

tests/UnitTests/A_Core/LoadPlugin/DefaultPluginHandlerTest.php

@@ -0,0 +1,182 @@
+<?php
+/**
+ * Smarty PHPunit tests deault plugin handler
+ *
+ * @package PHPunit
+ * @author  Uwe Tews
+ */
+
+/**
+ * class for plugin handler tests
+ *
+ * @runTestsInSeparateProcess
+ * @preserveGlobalState disabled
+ * @backupStaticAttributes enabled
+ */
+class DefaultPluginHandlerTest extends PHPUnit_Smarty
+{
+    public function setUp()
+    {
+        $this->setUpSmarty(dirname(__FILE__));
+        $this->smarty->setForceCompile(true);
+        $this->smarty->disableSecurity();
+        $this->smarty->registerDefaultPluginHandler('my_plugin_handler');
+    }
+
+
+    public function testInit()
+    {
+        $this->cleanDirs();
+    }
+    public function testDefaultFunctionScript()
+    {
+        $this->assertEquals("scriptfunction foo bar", $this->smarty->fetch('test_default_function_script.tpl'));
+    }
+
+    public function testDefaultFunctionScriptNotCachable1()
+    {
+        $this->smarty->assign('foo', 'foo');
+        $this->smarty->caching = 1;
+        $this->assertEquals("scriptfunction foo", $this->smarty->fetch('test_default_function_script_notcachable.tpl'));
+    }
+
+    public function testDefaultFunctionScriptNotCachable2()
+    {
+        $this->smarty->assign('foo', 'bar');
+        $this->smarty->caching = 1;
+        $this->assertEquals("scriptfunction bar", $this->smarty->fetch('test_default_function_script_notcachable.tpl'));
+    }
+
+    public function testDefaultFunctionLocal()
+    {
+        $this->assertEquals("localfunction foo bar", $this->smarty->fetch('test_default_function_local.tpl'));
+    }
+
+    public function testDefaultCompilerFunctionScript()
+    {
+        $this->assertEquals("echo 'scriptcompilerfunction '.'foo bar';", $this->smarty->fetch('test_default_compiler_function_script.tpl'));
+    }
+    public function testDefaultCompilerObject()
+    {
+        $this->assertEquals('Public World', $this->smarty->fetch('test_default_compiler_object.tpl'));
+    }
+
+    public function testDefaultBlockScript()
+    {
+        $this->assertEquals("scriptblock foo bar", $this->smarty->fetch('test_default_block_script.tpl'));
+    }
+
+    public function testDefaultModifierScript()
+    {
+        $this->smarty->assign('foo', 'bar');
+        $this->assertEquals("scriptmodifier default bar", $this->smarty->fetch('test_default_modifier_script.tpl'));
+    }
+
+    public function testDefaultModifier()
+    {
+        $this->smarty->assign('foo', 'bar');
+        $this->assertEquals("localmodifier bar", $this->smarty->fetch('test_default_modifier.tpl'));
+    }
+
+    public function testDefaultModifierStaticClassMethodCaching1()
+    {
+        $this->smarty->assign('foo', 'bar');
+        $this->smarty->caching = 1;
+        $this->assertEquals("staticmodifier bar", $this->smarty->fetch('test_default_static_modifier.tpl'));
+    }
+
+    public function testDefaultModifierStaticClassMethodCaching2()
+    {
+        $this->smarty->assign('foo', 'bar');
+        $this->smarty->caching = 1;
+        $this->assertEquals("staticmodifier bar", $this->smarty->fetch('test_default_static_modifier.tpl'));
+    }
+}
+
+function my_plugin_handler($tag, $type, $template, &$callback, &$script, &$cachable)
+{
+    switch ($type) {
+        case Smarty::PLUGIN_FUNCTION:
+            switch ($tag) {
+                case 'scriptfunction':
+                    $script = './scripts/script_function_tag.php';
+                    $callback = 'default_script_function_tag';
+
+                    return true;
+                case 'scriptfunctionnotcachable':
+                    $script = './scripts/script_function_tag.php';
+                    $callback = 'default_script_function_tag';
+                    $cachable = false;
+
+                    return true;
+                case 'localfunction':
+                    $callback = 'default_local_function_tag';
+
+                    return true;
+                default:
+                    return false;
+            }
+        case Smarty::PLUGIN_COMPILER:
+            switch ($tag) {
+                case 'scriptcompilerfunction':
+                    $script = './scripts/script_compiler_function_tag.php';
+                    $callback = 'default_script_compiler_function_tag';
+                    return true;
+                case 'compilerobject':
+                     $callback = array(new CompilerDefaultPluginClass, 'compile');
+                    return true;
+                default:
+                    return false;
+            }
+        case Smarty::PLUGIN_BLOCK:
+            switch ($tag) {
+                case 'scriptblock':
+                    $script = './scripts/script_block_tag.php';
+                    $callback = 'default_script_block_tag';
+
+                    return true;
+                default:
+                    return false;
+            }
+        case Smarty::PLUGIN_MODIFIER:
+            switch ($tag) {
+                case 'scriptmodifier':
+                    $script = './scripts/script_modifier.php';
+                    $callback = 'default_script_modifier';
+
+                    return true;
+                case 'mydefaultmodifier':
+                    $callback = 'default_local_modifier';
+
+                    return true;
+                case 'mydefaultstaticmodifier':
+                    $script = './scripts/script_default_static_modifier.php';
+                    $callback = array('DefModifier', 'default_static_modifier');
+
+                    return true;
+                default:
+                    return false;
+            }
+        default:
+            return false;
+    }
+}
+
+function default_local_function_tag($params, $template)
+{
+    return 'localfunction ' . $params['value'];
+}
+
+function default_local_modifier($input)
+{
+    return 'localmodifier ' . $input;
+}
+class CompilerDefaultPluginClass
+{
+    static function statCompile ($params, $compiler) {
+        return '<?php echo \'Static World\';?>';
+    }
+    public function compile ($params, $compiler) {
+        return '<?php echo \'Public World\';?>';
+    }
+}

tests/UnitTests/A_Core/LoadPlugin/IncludePathTest.php

@@ -0,0 +1,51 @@
+<?php
+
+/**
+ * Smarty PHPunit tests for File resources
+ *
+ * @package                PHPunit
+ * @author                 Rodney Rehm
+ * @runTestsInSeparateProcess
+ * @preserveGlobalState disabled
+ * @backupStaticAttributes enabled
+ */
+class IncludePathTest extends PHPUnit_Smarty
+{
+    public function setUp()
+    {
+        $this->setUpSmarty(dirname(__FILE__));
+        $this->smarty->use_include_path = true;
+        $this->smarty->setPluginsDir(array('./include','./include1'));
+        $this->smarty->enableSecurity();
+        $ds = DIRECTORY_SEPARATOR;
+        set_include_path($this->smarty->_realpath(dirname(__FILE__) . "{$ds}..{$ds}..{$ds}..{$ds}Include_Path{$ds}Plugins{$ds}", true) . PATH_SEPARATOR . get_include_path());
+    }
+
+    /**
+     * Tears down the fixture
+     * This method is called after a test is executed.
+     *
+     */
+    protected function tearDown()
+    {
+        ini_restore('include_path');
+        $this->smarty->disableSecurity();
+        parent::tearDown();
+     }
+    public function testInit()
+    {
+        $this->cleanDirs();
+    }
+    public function testInclude1()
+    {
+        $this->assertContains('plugin1', $this->smarty->fetch('test_include_path1.tpl'));
+    }
+    public function testInclude2()
+    {
+        $this->assertContains('plugin2', $this->smarty->fetch('test_include_path2.tpl'));
+    }
+    public function testInclude3()
+    {
+        $this->assertContains('plugin3', $this->smarty->fetch('test_include_path3.tpl'));
+    }
+  }

tests/UnitTests/A_Core/LoadPlugin/LoadPluginTest.php

@@ -0,0 +1,54 @@
+<?php
+/**
+ * Smarty PHPunit basic core function tests
+ *
+ * @package PHPunit
+ * @author  Uwe Tews
+ */
+
+/**
+ * class core function tests
+ *
+ * @runTestsInSeparateProcess
+ * @preserveGlobalState disabled
+ * @backupStaticAttributes enabled
+ */
+class LoadPluginTest extends PHPUnit_Smarty
+{
+    public function setUp()
+    {
+        $this->setUpSmarty(dirname(__FILE__));
+    }
+
+    /**
+     * loadPlugin test unkown plugin
+     */
+    public function testLoadPluginErrorReturn()
+    {
+        $this->assertFalse($this->smarty->loadPlugin('Smarty_Not_Known'));
+    }
+
+    /**
+     * loadPlugin test Smarty_Internal_Debug exists
+     */
+    public function testLoadPluginSmartyInternalDebug()
+    {
+        $this->assertTrue($this->smarty->loadPlugin('Smarty_Internal_Debug') == true);
+    }
+
+    /**
+     * loadPlugin test $template_class exists
+     */
+    public function testLoadPluginSmartyTemplateClass()
+    {
+        $this->assertTrue($this->smarty->loadPlugin($this->smarty->template_class) == true);
+    }
+
+    /**
+     * loadPlugin test loaging from plugins_dir
+     */
+    public function testLoadPluginSmartyPluginCounter()
+    {
+        $this->assertTrue($this->smarty->loadPlugin('Smarty_Function_Counter') == true);
+    }
+}

tests/UnitTests/A_Core/LoadPlugin/cache/.gitignore

@@ -0,0 +1,2 @@
+# Ignore anything in here, but keep this directory
+*

tests/UnitTests/A_Core/LoadPlugin/include/function.plugin3.php

@@ -0,0 +1,5 @@
+<?php
+function smarty_function_plugin3($params, $template)
+{
+    return 'plugin3';
+}

tests/UnitTests/A_Core/LoadPlugin/scripts/script_block_tag.php

@@ -0,0 +1,7 @@
+<?php
+function default_script_block_tag($params, $content, $template, &$repeat)
+{
+    if (isset($content)) {
+        return 'scriptblock ' . $content;
+    }
+}

tests/UnitTests/A_Core/LoadPlugin/scripts/script_compiler_function_tag.php

@@ -0,0 +1,5 @@
+<?php
+function default_script_compiler_function_tag($params, $template)
+{
+    return "echo 'scriptcompilerfunction '." . $params['value'] . ";";
+}

tests/UnitTests/A_Core/LoadPlugin/scripts/script_default_static_modifier.php

@@ -0,0 +1,10 @@
+<?php
+if (!class_exists('DefModifier')) {
+    Class DefModifier
+    {
+        static function default_static_modifier($input)
+        {
+            return 'staticmodifier ' . $input;
+        }
+    }
+}

tests/UnitTests/A_Core/LoadPlugin/scripts/script_function_tag.php

@@ -0,0 +1,5 @@
+<?php
+function default_script_function_tag($params, $template)
+{
+    return 'scriptfunction ' . $params['value'];
+}

tests/UnitTests/A_Core/LoadPlugin/scripts/script_modifier.php

@@ -0,0 +1,5 @@
+<?php
+function default_script_modifier($input, $text = null)
+{
+    return $text . $input;
+}

tests/UnitTests/A_Core/LoadPlugin/scripts/test_include_php.php

@@ -0,0 +1,2 @@
+<?php
+echo 'test include php';

tests/UnitTests/A_Core/LoadPlugin/templates/test_default_block_script.tpl

@@ -0,0 +1 @@
+{scriptblock}foo bar{/scriptblock}

tests/UnitTests/A_Core/LoadPlugin/templates/test_default_compiler_function_script.tpl

@@ -0,0 +1 @@
+{scriptcompilerfunction value='foo bar'}

tests/UnitTests/A_Core/LoadPlugin/templates/test_default_compiler_object.tpl

@@ -0,0 +1 @@
+{compilerobject value='foo bar'}

tests/UnitTests/A_Core/LoadPlugin/templates/test_default_function_local.tpl

@@ -0,0 +1 @@
+{localfunction value='foo bar'}

tests/UnitTests/A_Core/LoadPlugin/templates/test_default_function_script.tpl

@@ -0,0 +1 @@
+{scriptfunction value='foo bar'}

tests/UnitTests/A_Core/LoadPlugin/templates/test_default_function_script_notcachable.tpl

@@ -0,0 +1 @@
+{scriptfunctionnotcachable value=$foo}

tests/UnitTests/A_Core/LoadPlugin/templates/test_default_modifier.tpl

@@ -0,0 +1 @@
+{$foo|mydefaultmodifier}

tests/UnitTests/A_Core/LoadPlugin/templates/test_default_modifier_script.tpl

@@ -0,0 +1 @@
+{$foo|scriptmodifier:'scriptmodifier default '}

tests/UnitTests/A_Core/LoadPlugin/templates/test_default_static_modifier.tpl

@@ -0,0 +1 @@
+{$foo|mydefaultstaticmodifier nocache}

tests/UnitTests/A_Core/LoadPlugin/templates/test_include_path1.tpl

@@ -0,0 +1 @@
+{plugin1}

tests/UnitTests/A_Core/LoadPlugin/templates/test_include_path2.tpl

@@ -0,0 +1 @@
+{plugin2}

tests/UnitTests/A_Core/LoadPlugin/templates/test_include_path3.tpl

@@ -0,0 +1 @@
+{plugin3}

tests/UnitTests/A_Core/LoadPlugin/templates_c/.gitignore

@@ -0,0 +1,2 @@
+# Ignore anything in here, but keep this directory
+*

tests/UnitTests/A_Core/MuteExpectedErrors/MuteExpectedErrorsTest.php

@@ -0,0 +1,123 @@
+<?php
+/**
+ * Smarty PHPunit tests of filter
+ *
+ * @package PHPunit
+ * @author  Rodney Rehm
+ */
+
+/**
+ * class for filter tests
+ *
+ * @runTestsInSeparateProcess
+ * @preserveGlobalState disabled
+ * @backupStaticAttributes enabled
+ */
+class MuteExpectedErrorsTest extends PHPUnit_Smarty
+{
+    protected $_errors = array();
+
+    public function setUp()
+    {
+        $this->setUpSmarty(dirname(__FILE__));
+    }
+
+
+    public function testInit()
+    {
+        $this->cleanDirs();
+    }
+    public function error_handler($errno, $errstr, $errfile, $errline, $errcontext)
+    {
+        $this->_errors[] = $errfile . ' line ' . $errline;
+    }
+
+    public function testMuted()
+    {
+        set_error_handler(array($this, 'error_handler'));
+        Smarty::muteExpectedErrors();
+
+        $this->smarty->clearCache('default.tpl');
+        $this->smarty->clearCompiledTemplate('default.tpl');
+        $this->smarty->fetch('default.tpl');
+
+        $this->assertEquals($this->_errors, array());
+
+        @filemtime('ckxladanwijicajscaslyxck');
+        $error = array(__FILE__ . ' line ' . (__LINE__ - 1));
+        $this->assertEquals($this->_errors, $error);
+
+        Smarty::unmuteExpectedErrors();
+        restore_error_handler();
+    }
+
+    /**
+     *
+     * @rrunInSeparateProcess
+     *
+     */
+    public function testUnmuted()
+    {
+        set_error_handler(array($this, 'error_handler'));
+
+        $this->smarty->clearCache('default.tpl');
+        $this->smarty->clearCompiledTemplate('default.tpl');
+        $this->smarty->fetch('default.tpl');
+
+        $this->assertEquals(Smarty::$_IS_WINDOWS ? 2 : 2, count($this->_errors));
+
+        @filemtime('ckxladanwijicajscaslyxck');
+        $this->assertEquals(Smarty::$_IS_WINDOWS ? 3 : 3, count($this->_errors));
+
+        restore_error_handler();
+    }
+
+    /**
+     *
+     * @runInSeparateProcess
+     * @preserveGlobalState disabled
+     *
+     */
+    public function testMutedCaching()
+    {
+        set_error_handler(array($this, 'error_handler'));
+        Smarty::muteExpectedErrors();
+
+        $this->smarty->caching = true;
+        $this->smarty->clearCache('default.tpl');
+        $this->smarty->clearCompiledTemplate('default.tpl');
+        $this->smarty->fetch('default.tpl');
+
+        $this->assertEquals($this->_errors, array());
+
+        @filemtime('ckxladanwijicajscaslyxck');
+        $error = array(__FILE__ . ' line ' . (__LINE__ - 1));
+        $this->assertEquals($error, $this->_errors);
+
+        Smarty::unmuteExpectedErrors();
+        restore_error_handler();
+    }
+
+    /**
+     * @runInSeparateProcess
+     * @preserveGlobalState disabled
+     *
+     */
+    public function testUnmutedCaching()
+    {
+        set_error_handler(array($this, 'error_handler'));
+
+        $this->smarty->caching = true;
+        $this->smarty->clearCache('default.tpl');
+        $this->smarty->clearCompiledTemplate('default.tpl');
+        $this->smarty->fetch('default.tpl');
+
+        $this->assertEquals(Smarty::$_IS_WINDOWS ? 2 : 2, count($this->_errors));
+
+        @filemtime('ckxladanwijicajscaslyxck');
+        $error = array(__FILE__ . ' line ' . (__LINE__ - 1));
+        $this->assertEquals(Smarty::$_IS_WINDOWS ? 3 : 3, count($this->_errors));
+
+        restore_error_handler();
+    }
+}

tests/UnitTests/A_Core/MuteExpectedErrors/cache/.gitignore

@@ -0,0 +1,2 @@
+# Ignore anything in here, but keep this directory
+*

tests/UnitTests/A_Core/MuteExpectedErrors/templates/default.tpl

@@ -0,0 +1 @@
+{$foo|default:""} /* should compile something with @silence error suppression */

tests/UnitTests/A_Core/MuteExpectedErrors/templates_c/.gitignore

@@ -0,0 +1,2 @@
+# Ignore anything in here, but keep this directory
+*

tests/UnitTests/A_Core/PluginTests/PHPunitplugins/function.chain1.php

@@ -0,0 +1,7 @@
+<?php
+function smarty_function_chain1($params, $tpl)
+{
+    $tpl->smarty->loadPlugin('smarty_function_chain2');
+
+    return smarty_function_chain2($params, $tpl);
+}

tests/UnitTests/A_Core/PluginTests/PHPunitplugins/function.chain2.php

@@ -0,0 +1,7 @@
+<?php
+function smarty_function_chain2($params, $tpl)
+{
+    $tpl->smarty->loadPlugin('smarty_function_chain3');
+
+    return smarty_function_chain3($params, $tpl);
+}

tests/UnitTests/A_Core/PluginTests/PHPunitplugins/function.chain3.php

@@ -0,0 +1,5 @@
+<?php
+function smarty_function_chain3($params, $tpl)
+{
+    return 'from chain3';
+}

tests/UnitTests/A_Core/PluginTests/PluginChainedLoadTest.php

@@ -0,0 +1,33 @@
+<?php
+/**
+ * Smarty PHPunit tests chained loading of dependend pluglind
+ *
+ * @package PHPunit
+ * @author  Rodney Rehm
+ */
+
+/**
+ * class for modifier tests
+ *
+ * @runTestsInSeparateProcess
+ * @preserveGlobalState disabled
+ * @backupStaticAttributes enabled
+ */
+class PluginChainedLoadTest extends PHPUnit_Smarty
+{
+    public function setUp()
+    {
+        $this->setUpSmarty(dirname(__FILE__));
+    }
+
+    public function testInit()
+    {
+        $this->cleanDirs();
+    }
+
+    public function testPluginChainedLoad()
+    {
+        $this->smarty->addPluginsDir(dirname(__FILE__) . "/PHPunitplugins/");
+        $this->assertContains('from chain3', $this->smarty->fetch('test_plugin_chained_load.tpl'));
+    }
+}

tests/UnitTests/A_Core/PluginTests/Shared/SharedFunctionsTest.php

@@ -0,0 +1,29 @@
+<?php
+/**
+ * Smarty PHPunit tests of shared plugin functions
+ *
+ * @package PHPunit
+ * @author  Rodney Rehm
+ */
+
+/**
+ * class for function tests
+ */
+class SharedFunctionsTest extends PHPUnit_Smarty
+{
+    public function setUp()
+    {
+        $this->setUpSmarty(dirname(__FILE__));
+    }
+
+    /**
+     * test smarty_function_escape_special_chars()
+     */
+    public function testEscapeSpecialChars()
+    {
+        require_once SMARTY_PLUGINS_DIR . 'shared.escape_special_chars.php';
+
+        $this->assertEquals('hello&lt;world &copy;', smarty_function_escape_special_chars('hello<world &copy;'));
+        $this->assertEquals('ö€', smarty_function_escape_special_chars('ö€'));
+    }
+}

tests/UnitTests/A_Core/PluginTests/Shared/cache/.gitignore

@@ -0,0 +1,2 @@
+# Ignore anything in here, but keep this directory
+*

tests/UnitTests/A_Core/PluginTests/Shared/templates_c/.gitignore

@@ -0,0 +1,2 @@
+# Ignore anything in here, but keep this directory
+*

tests/UnitTests/A_Core/PluginTests/cache/.gitignore

@@ -0,0 +1,2 @@
+# Ignore anything in here, but keep this directory
+*

tests/UnitTests/A_Core/PluginTests/helpers/_object_tostring.php

@@ -0,0 +1,26 @@
+<?php
+
+class _object_toString
+{
+    protected $string = null;
+
+    public function __construct($string)
+    {
+        $this->string = (string) $string;
+    }
+
+    public function __toString()
+    {
+        return $this->string;
+    }
+}
+
+class _object_noString
+{
+    protected $string = null;
+
+    public function __construct($string)
+    {
+        $this->string = (string) $string;
+    }
+}

tests/UnitTests/A_Core/PluginTests/templates/test_plugin_chained_load.tpl

@@ -0,0 +1 @@
+{chain1}

tests/UnitTests/A_Core/PluginTests/templates_c/.gitignore

@@ -0,0 +1,2 @@
+# Ignore anything in here, but keep this directory
+*

tests/UnitTests/A_Core/SmartyBC/SmartyBcTest.php

@@ -0,0 +1,37 @@
+<?php
+/**
+ * Smarty PHPunit tests SmartyBC code
+ *
+ * @package PHPunit
+ * @author  Uwe Tews
+ */
+
+/**
+ * class SmartyBC class tests
+ *
+ * @runTestsInSeparateProcess
+ * @preserveGlobalState disabled
+ * @backupStaticAttributes enabled
+ */
+class SmartyBcTest extends PHPUnit_Smarty
+{
+    public $loadSmartyBC = true;
+    public $loadSmarty = false;
+    public function setUp()
+    {
+        $this->setUpSmarty(dirname(__FILE__));
+    }
+
+
+    public function testInit()
+    {
+        $this->cleanDirs();
+    }
+    /**
+     * test {php} tag
+     */
+    public function testSmartyPhpTag()
+    {
+        $this->assertEquals('hello world', $this->smartyBC->fetch('string:{php} echo "hello world"; {/php}'));
+    }
+}

tests/UnitTests/A_Core/SmartyBC/cache/.gitignore

@@ -0,0 +1,2 @@
+# Ignore anything in here, but keep this directory
+*

tests/UnitTests/A_Core/SmartyBC/templates_c/.gitignore

@@ -0,0 +1,2 @@
+# Ignore anything in here, but keep this directory
+*

tests/UnitTests/CacheModify/ModifiedSince/HttpModifiedSinceTest.php

@@ -0,0 +1,148 @@
+<?php
+/**
+ * Smarty PHPunit tests for cache resource file
+ *
+ * @package PHPunit
+ * @author  Uwe Tews
+ */
+
+/**
+ * class for cache resource file tests
+ *
+ * @runTestsInSeparateProcess
+ * @preserveGlobalState disabled
+ * @backupStaticAttributes enabled
+ */
+class HttpModifiedSinceTest extends PHPUnit_Smarty
+{
+
+    public function setUp()
+    {
+        $this->markTestSkipped('modified since tests are disabled');
+        $this->setUpSmarty(dirname(__FILE__));
+     }
+
+    public function testInit()
+    {
+        $this->cleanDirs();
+    }
+
+    /**
+     *
+     */
+    public function testDisabled()
+    {
+        $_SERVER['SMARTY_PHPUNIT_DISABLE_HEADERS'] = true;
+        $_SERVER['SMARTY_PHPUNIT_HEADERS'] = array();
+
+        $this->smarty->setCacheModifiedCheck(false);
+        $this->smarty->caching = true;
+        $this->smarty->cache_lifetime = 20;
+        ob_start();
+        $this->smarty->display('helloworld.tpl');
+        $output = ob_get_contents();
+        ob_end_clean();
+        $this->assertEquals('hello world', $output);
+        $this->assertEquals('', join("\r\n", $_SERVER['SMARTY_PHPUNIT_HEADERS']));
+
+        unset($_SERVER['HTTP_IF_MODIFIED_SINCE']);
+        unset($_SERVER['SMARTY_PHPUNIT_HEADERS']);
+        unset($_SERVER['SMARTY_PHPUNIT_DISABLE_HEADERS']);
+    }
+
+    /**
+     *
+     */
+    public function testEnabledUncached()
+    {
+        $_SERVER['SMARTY_PHPUNIT_DISABLE_HEADERS'] = true;
+        $_SERVER['SMARTY_PHPUNIT_HEADERS'] = array();
+
+        $this->smarty->setCacheModifiedCheck(true);
+        $this->smarty->caching = false;
+        $this->smarty->cache_lifetime = 20;
+        ob_start();
+        $this->smarty->display('helloworld.tpl');
+        $output = ob_get_contents();
+        ob_end_clean();
+        $this->assertEquals('hello world', $output);
+        $this->assertEquals('', join("\r\n", $_SERVER['SMARTY_PHPUNIT_HEADERS']));
+
+        unset($_SERVER['HTTP_IF_MODIFIED_SINCE']);
+        unset($_SERVER['SMARTY_PHPUNIT_HEADERS']);
+        unset($_SERVER['SMARTY_PHPUNIT_DISABLE_HEADERS']);
+    }
+
+    /**
+     *
+     */
+    public function testEnabledCached()
+    {
+        $_SERVER['SMARTY_PHPUNIT_DISABLE_HEADERS'] = true;
+        $_SERVER['SMARTY_PHPUNIT_HEADERS'] = array();
+
+        $this->smarty->setCacheModifiedCheck(true);
+        $this->smarty->caching = true;
+        $this->smarty->cache_lifetime = 20;
+
+        ob_start();
+        $l1 = ob_get_level();
+        $this->smarty->display('helloworld.tpl');
+        $l2 = ob_get_level();
+        $output = ob_get_contents();
+        ob_end_clean();
+        $this->assertEquals('hello world', $output);
+        $t1 = time();
+        $t2 = strtotime(substr( $_SERVER['SMARTY_PHPUNIT_HEADERS'][0],15));
+        $this->assertTrue(($t2-$t1) <= 1);
+    }
+
+    /**
+     *
+     */
+    public function testEnabledCached2()
+    {
+
+        $_SERVER['SMARTY_PHPUNIT_HEADERS'] = array();
+        $_SERVER['HTTP_IF_MODIFIED_SINCE'] = gmdate('D, d M Y H:i:s', time() - 3600) . ' GMT';
+        $this->smarty->setCacheModifiedCheck(true);
+        $this->smarty->caching = true;
+        $this->smarty->cache_lifetime = 20;
+        ob_start();
+        $l3 = ob_get_level();
+        $this->smarty->display('helloworld.tpl');
+        $l4 = ob_get_level();
+        $output = ob_get_contents();
+        ob_end_clean();
+        $this->assertEquals('hello world', $output);
+        $t1 = time();
+        $t2 = strtotime(substr( $_SERVER['SMARTY_PHPUNIT_HEADERS'][0],15));
+        $this->assertTrue(($t2-$t1) <= 1);
+    }
+
+    /**
+     *
+     */
+    public function testEnabledCached3()
+    {
+
+        $_SERVER['SERVER_PROTOCOL'] = 'HTTP/1.1';
+        $_SERVER['SMARTY_PHPUNIT_HEADERS'] = array();
+        $_SERVER['HTTP_IF_MODIFIED_SINCE'] = gmdate('D, d M Y H:i:s', time() + 10) . ' GMT';
+        $this->smarty->setCacheModifiedCheck(true);
+        $this->smarty->caching = true;
+        $this->smarty->cache_lifetime = 20;
+        ob_start();
+        $l5 = ob_get_level();
+        $this->smarty->display('helloworld.tpl');
+        $l6 = ob_get_level();
+        $output = ob_get_contents();
+        ob_end_clean();
+        $this->assertEquals('', $output);
+        $this->assertEquals('304 Not Modified', join("\r\n", $_SERVER['SMARTY_PHPUNIT_HEADERS']));
+
+        unset($_SERVER['HTTP_IF_MODIFIED_SINCE']);
+        unset($_SERVER['SMARTY_PHPUNIT_HEADERS']);
+        unset($_SERVER['SMARTY_PHPUNIT_DISABLE_HEADERS']);
+    }
+}

tests/UnitTests/CacheModify/ModifiedSince/cache/.gitignore

@@ -0,0 +1,2 @@
+# Ignore anything in here, but keep this directory
+*

tests/UnitTests/CacheModify/ModifiedSince/templates/helloworld.tpl

@@ -0,0 +1 @@
+hello world

tests/UnitTests/CacheModify/ModifiedSince/templates_c/.gitignore

@@ -0,0 +1,2 @@
+# Ignore anything in here, but keep this directory
+*

tests/UnitTests/CacheResourceTests/Apc/CacheResourceCustomApcTest.php

@@ -0,0 +1,36 @@
+<?php
+/**
+ * Smarty PHPunit tests for cache resource Apc
+ *
+ * @package PHPunit
+ * @author  Uwe Tews
+ */
+if (ApcCacheEnable == true) {
+    include_once dirname(__FILE__) . '/../Memcache/CacheResourceCustomMemcacheTest.php';
+
+    /**
+     * class for cache resource file tests
+     *
+     * @runTestsInSeparateProcess
+     * @preserveGlobalState    disabled
+     * @backupStaticAttributes enabled
+     */
+    class CacheResourceCustomApcTest extends CacheResourceCustomMemcacheTest
+    {
+        public function setUp()
+        {
+            if (ApcCacheEnable != true) {
+                $this->markTestSkipped('Apc tests are disabled');
+            } else {
+                if (!function_exists('apc_cache_info') || ini_get('apc.enable_cli')) {
+                    $this->markTestSkipped('APC cache not available');
+                }
+            }
+            $this->setUpSmarty(dirname(__FILE__));
+            parent::setUp();
+            $this->smarty->setCachingType('apc');
+            $this->smarty->addPluginsDir(SMARTY_DIR . '../demo/plugins/');
+        }
+    }
+}
+

tests/UnitTests/CacheResourceTests/File/CacheResourceFileTest.php

@@ -0,0 +1,383 @@
+<?php
+/**
+ * Smarty PHPunit tests for cache resource file
+ *
+ * @package PHPunit
+ * @author  Uwe Tews
+ */
+
+include_once dirname(__FILE__) . '/../_shared/CacheResourceTestCommon.php';
+
+/**
+ * class for cache resource file tests
+ *
+ * @runTestsInSeparateProcess
+ * @preserveGlobalState disabled
+ * @backupStaticAttributes enabled
+ */
+class CacheResourceFileTest extends CacheResourceTestCommon
+{
+
+    public function setUp()
+    {
+        $this->setUpSmarty(dirname(__FILE__));
+        parent::setUp();
+        $this->smarty->setCachingType('filetest');
+    }
+
+
+    public function testInit()
+
+    {
+        $this->cleanDirs();
+    }
+
+    /**
+     * test getCachedFilepath with configuration['useSubDirs'] enabled
+     */
+    public function testGetCachedFilepathSubDirs()
+    {
+        $this->smarty->caching = true;
+        $this->smarty->cache_lifetime = 1000;
+        $this->smarty->setUseSubDirs(true);
+        $tpl = $this->smarty->createTemplate('helloworld.tpl');
+        $this->assertEquals($this->buildCachedPath($tpl, true, null, null, 'helloworld.tpl', $type = 'file', $this->smarty->getTemplateDir(0), 'file')
+            , $tpl->cached->filepath);
+    }
+
+    /**
+     * test getCachedFilepath with cache_id
+     */
+    public function testGetCachedFilepathCacheId()
+    {
+        $this->smarty->caching = true;
+        $this->smarty->cache_lifetime = 1000;
+        $this->smarty->setUseSubDirs(true);
+        $tpl = $this->smarty->createTemplate('helloworld.tpl', 'foo|bar');
+        $this->assertEquals($this->buildCachedPath($tpl, true, 'foo|bar', null, 'helloworld.tpl', $type = 'file', $this->smarty->getTemplateDir(0), 'file')
+            , $tpl->cached->filepath);
+    }
+
+    /**
+     * test getCachedFilepath with compile_id
+     */
+    public function testGetCachedFilepathCompileId()
+    {
+        $this->smarty->caching = true;
+        $this->smarty->cache_lifetime = 1000;
+        $this->smarty->setUseSubDirs(true);
+        $tpl = $this->smarty->createTemplate('helloworld.tpl', null, 'blar');
+        $this->assertEquals($this->buildCachedPath($tpl, true, null, 'blar', 'helloworld.tpl', $type = 'file', $this->smarty->getTemplateDir(0), 'file')
+            , $tpl->cached->filepath);
+    }
+
+    /**
+     * test getCachedFilepath with cache_id and compile_id
+     */
+    public function testGetCachedFilepathCacheIdCompileId()
+    {
+        $this->smarty->caching = true;
+        $this->smarty->cache_lifetime = 1000;
+        $this->smarty->setUseSubDirs(true);
+        $tpl = $this->smarty->createTemplate('helloworld.tpl', 'foo|bar', 'blar');
+        $this->assertEquals($this->buildCachedPath($tpl, true, 'foo|bar', 'blar', 'helloworld.tpl', $type = 'file', $this->smarty->getTemplateDir(0), 'file')
+            , $tpl->cached->filepath);
+    }
+
+    /**
+     * test cache->clear_all with cache_id and compile_id
+     */
+    public function testClearCacheAllCacheIdCompileId()
+    {
+        $this->cleanCacheDir();
+        $this->smarty->caching = true;
+        $this->smarty->cache_lifetime = 1000;
+        $this->smarty->setUseSubDirs(true);
+        $tpl = $this->smarty->createTemplate('helloworld.tpl', 'foo|bar', 'blar');
+        $this->writeCachedContent($tpl);
+        $this->assertTrue(file_exists($tpl->cached->filepath));
+        $this->assertEquals(1, $this->smarty->clearAllCache());
+    }
+
+    /**
+     * test cache->clear with cache_id and compile_id
+     */
+    public function testClearCacheCacheIdCompileId()
+    {
+        $this->smarty->caching = true;
+        $this->smarty->cache_lifetime = 1000;
+        $this->cleanCacheDir();
+        $this->smarty->setUseSubDirs(false);
+        $tpl = $this->smarty->createTemplate('helloworld.tpl', 'foo|bar', 'blar');
+        $this->writeCachedContent($tpl);
+        $tpl2 = $this->smarty->createTemplate('helloworld.tpl', 'foo|bar2', 'blar');
+        $this->writeCachedContent($tpl2);
+        $tpl3 = $this->smarty->createTemplate('helloworld2.tpl', 'foo|bar', 'blar');
+        $this->writeCachedContent($tpl3);
+        $this->assertTrue(file_exists($tpl->cached->filepath));
+        $this->assertTrue(file_exists($tpl2->cached->filepath));
+        $this->assertTrue(file_exists($tpl3->cached->filepath));
+        $this->assertEquals(2, $this->smarty->clearCache(null, 'foo|bar'));
+        $this->assertFalse(file_exists($tpl->cached->filepath));
+        $this->assertTrue(file_exists($tpl2->cached->filepath));
+        $this->assertFalse(file_exists($tpl3->cached->filepath));
+    }
+
+    public function testClearCacheCacheIdCompileId2()
+    {
+        $this->smarty->caching = true;
+        $this->smarty->cache_lifetime = 1000;
+        $this->smarty->setUseSubDirs(false);
+        $this->cleanCacheDir();
+        $tpl = $this->smarty->createTemplate('helloworld.tpl', 'foo|bar', 'blar');
+        $this->writeCachedContent($tpl);
+        $tpl2 = $this->smarty->createTemplate('helloworld.tpl', 'foo|bar2', 'blar');
+        $this->writeCachedContent($tpl2);
+        $tpl3 = $this->smarty->createTemplate('helloworld2.tpl', 'foo|bar', 'blar');
+        $this->writeCachedContent($tpl3);
+        $this->assertTrue(file_exists($tpl->cached->filepath));
+        $this->assertTrue(file_exists($tpl2->cached->filepath));
+        $this->assertTrue(file_exists($tpl3->cached->filepath));
+        $this->assertEquals(2, $this->smarty->clearCache('helloworld.tpl'));
+        $this->assertFalse(file_exists($tpl->cached->filepath));
+        $this->assertFalse(file_exists($tpl2->cached->filepath));
+        $this->assertTrue(file_exists($tpl3->cached->filepath));
+    }
+
+    public function testClearCacheCacheIdCompileId2Sub()
+    {
+        $this->smarty->caching = true;
+        $this->smarty->cache_lifetime = 1000;
+        $this->smarty->setUseSubDirs(true);
+        $this->cleanCacheDir();
+        $tpl = $this->smarty->createTemplate('helloworld.tpl', 'foo|bar', 'blar');
+        $this->writeCachedContent($tpl);
+        $tpl2 = $this->smarty->createTemplate('helloworld.tpl', 'foo|bar2', 'blar');
+        $this->writeCachedContent($tpl2);
+        $tpl3 = $this->smarty->createTemplate('helloworld2.tpl', 'foo|bar', 'blar');
+        $this->writeCachedContent($tpl3);
+        $this->assertTrue(file_exists($tpl->cached->filepath));
+        $this->assertTrue(file_exists($tpl2->cached->filepath));
+        $this->assertTrue(file_exists($tpl3->cached->filepath));
+        $this->assertEquals(2, $this->smarty->clearCache('helloworld.tpl'));
+        $this->assertFalse(file_exists($tpl->cached->filepath));
+        $this->assertFalse(file_exists($tpl2->cached->filepath));
+        $this->assertTrue(file_exists($tpl3->cached->filepath));
+    }
+
+    public function testClearCacheCacheIdCompileId3()
+    {
+        $this->smarty->caching = true;
+        $this->smarty->cache_lifetime = 1000;
+        $this->cleanCacheDir();
+        $this->smarty->setUseSubDirs(false);
+        $tpl = $this->smarty->createTemplate('helloworld.tpl', 'foo|bar', 'blar');
+        $this->writeCachedContent($tpl);
+        $tpl2 = $this->smarty->createTemplate('helloworld.tpl', 'foo|bar', 'blar2');
+        $this->writeCachedContent($tpl2);
+        $tpl3 = $this->smarty->createTemplate('helloworld2.tpl', 'foo|bar', 'blar');
+        $this->writeCachedContent($tpl3);
+        $this->assertTrue(file_exists($tpl->cached->filepath));
+        $this->assertTrue(file_exists($tpl2->cached->filepath));
+        $this->assertTrue(file_exists($tpl3->cached->filepath));
+        $this->assertEquals(1, $this->smarty->clearCache('helloworld.tpl', null, 'blar2'));
+        $this->assertTrue(file_exists($tpl->cached->filepath));
+        $this->assertFalse(file_exists($tpl2->cached->filepath));
+        $this->assertTrue(file_exists($tpl3->cached->filepath));
+    }
+
+    public function testClearCacheCacheIdCompileId3Sub()
+    {
+        $this->smarty->caching = true;
+        $this->smarty->cache_lifetime = 1000;
+        $this->cleanCacheDir();
+        $this->smarty->setUseSubDirs(true);
+        $tpl = $this->smarty->createTemplate('helloworld.tpl', 'foo|bar', 'blar');
+        $this->writeCachedContent($tpl);
+        $tpl2 = $this->smarty->createTemplate('helloworld.tpl', 'foo|bar', 'blar2');
+        $this->writeCachedContent($tpl2);
+        $tpl3 = $this->smarty->createTemplate('helloworld2.tpl', 'foo|bar', 'blar');
+        $this->writeCachedContent($tpl3);
+        $this->assertTrue(file_exists($tpl->cached->filepath));
+        $this->assertTrue(file_exists($tpl2->cached->filepath));
+        $this->assertTrue(file_exists($tpl3->cached->filepath));
+        $this->assertEquals(1, $this->smarty->clearCache('helloworld.tpl', null, 'blar2'));
+        $this->assertTrue(file_exists($tpl->cached->filepath));
+        $this->assertFalse(file_exists($tpl2->cached->filepath));
+        $this->assertTrue(file_exists($tpl3->cached->filepath));
+    }
+
+    public function testClearCacheCacheIdCompileId4()
+    {
+        $this->smarty->caching = true;
+        $this->smarty->cache_lifetime = 1000;
+        $this->smarty->setUseSubDirs(false);
+        $this->cleanCacheDir();
+        $tpl = $this->smarty->createTemplate('helloworld.tpl', 'foo|bar', 'blar');
+        $this->writeCachedContent($tpl);
+        $tpl2 = $this->smarty->createTemplate('helloworld.tpl', 'foo|bar', 'blar2');
+        $this->writeCachedContent($tpl2);
+        $tpl3 = $this->smarty->createTemplate('helloworld2.tpl', 'foo|bar', 'blar');
+        $this->writeCachedContent($tpl3);
+        $this->assertTrue(file_exists($tpl->cached->filepath));
+        $this->assertTrue(file_exists($tpl2->cached->filepath));
+        $this->assertTrue(file_exists($tpl3->cached->filepath));
+        $this->assertEquals(1, $this->smarty->clearCache('helloworld.tpl', null, 'blar2'));
+        $this->assertTrue(file_exists($tpl->cached->filepath));
+        $this->assertFalse(file_exists($tpl2->cached->filepath));
+        $this->assertTrue(file_exists($tpl3->cached->filepath));
+    }
+
+    public function testClearCacheCacheIdCompileId4Sub()
+    {
+        $this->smarty->caching = true;
+        $this->smarty->cache_lifetime = 1000;
+        $this->smarty->setUseSubDirs(true);
+        $this->cleanCacheDir();
+        $tpl = $this->smarty->createTemplate('helloworld.tpl', 'foo|bar', 'blar');
+        $this->writeCachedContent($tpl);
+        $tpl2 = $this->smarty->createTemplate('helloworld.tpl', 'foo|bar', 'blar2');
+        $this->writeCachedContent($tpl2);
+        $tpl3 = $this->smarty->createTemplate('helloworld2.tpl', 'foo|bar', 'blar');
+        $this->writeCachedContent($tpl3);
+        $this->assertTrue(file_exists($tpl->cached->filepath));
+        $this->assertTrue(file_exists($tpl2->cached->filepath));
+        $this->assertTrue(file_exists($tpl3->cached->filepath));
+        $this->assertEquals(1, $this->smarty->clearCache('helloworld.tpl', null, 'blar2'));
+        $this->assertTrue(file_exists($tpl->cached->filepath));
+        $this->assertFalse(file_exists($tpl2->cached->filepath));
+        $this->assertTrue(file_exists($tpl3->cached->filepath));
+    }
+
+    public function testClearCacheCacheIdCompileId5()
+    {
+        $this->smarty->caching = true;
+        $this->smarty->cache_lifetime = 1000;
+        $this->smarty->setUseSubDirs(false);
+        $this->cleanCacheDir();
+        $tpl = $this->smarty->createTemplate('helloworld.tpl', 'foo|bar', 'blar');
+        $this->writeCachedContent($tpl);
+        $tpl2 = $this->smarty->createTemplate('helloworld.tpl', 'foo|bar', 'blar2');
+        $this->writeCachedContent($tpl2);
+        $tpl3 = $this->smarty->createTemplate('helloworld2.tpl', 'foo|bar', 'blar');
+        $this->writeCachedContent($tpl3);
+        $this->assertTrue(file_exists($tpl->cached->filepath));
+        $this->assertTrue(file_exists($tpl2->cached->filepath));
+        $this->assertTrue(file_exists($tpl3->cached->filepath));
+        $this->assertEquals(2, $this->smarty->clearCache(null, null, 'blar'));
+        $this->assertFalse(file_exists($tpl->cached->filepath));
+        $this->assertTrue(file_exists($tpl2->cached->filepath));
+        $this->assertFalse(file_exists($tpl3->cached->filepath));
+    }
+
+    public function testClearCacheCacheIdCompileId5Sub()
+    {
+        $this->smarty->caching = true;
+        $this->smarty->cache_lifetime = 1000;
+        $this->smarty->setUseSubDirs(true);
+        $this->cleanCacheDir();
+        $tpl = $this->smarty->createTemplate('helloworld.tpl', 'foo|bar', 'blar');
+        $this->writeCachedContent($tpl);
+        $tpl2 = $this->smarty->createTemplate('helloworld.tpl', 'foo|bar', 'blar2');
+        $this->writeCachedContent($tpl2);
+        $tpl3 = $this->smarty->createTemplate('helloworld2.tpl', 'foo|bar', 'blar');
+        $this->writeCachedContent($tpl3);
+        $this->assertTrue(file_exists($tpl->cached->filepath));
+        $this->assertTrue(file_exists($tpl2->cached->filepath));
+        $this->assertTrue(file_exists($tpl3->cached->filepath));
+        $this->assertEquals(2, $this->smarty->clearCache(null, null, 'blar'));
+        $this->assertFalse(file_exists($tpl->cached->filepath));
+        $this->assertTrue(file_exists($tpl2->cached->filepath));
+        $this->assertFalse(file_exists($tpl3->cached->filepath));
+    }
+
+    public function testClearCacheCacheFile()
+    {
+        $this->smarty->caching = true;
+        $this->smarty->cache_lifetime = 1000;
+        $this->smarty->setUseSubDirs(false);
+        $this->cleanCacheDir();
+        $tpl = $this->smarty->createTemplate('helloworld.tpl');
+        $this->writeCachedContent($tpl);
+        $tpl2 = $this->smarty->createTemplate('helloworld.tpl', null, 'bar');
+        $this->writeCachedContent($tpl2);
+        $tpl3 = $this->smarty->createTemplate('helloworld.tpl', 'buh|blar');
+        $this->writeCachedContent($tpl3);
+        $tpl4 = $this->smarty->createTemplate('helloworld2.tpl');
+        $this->writeCachedContent($tpl4);
+        $this->assertTrue(file_exists($tpl->cached->filepath));
+        $this->assertTrue(file_exists($tpl2->cached->filepath));
+        $this->assertTrue(file_exists($tpl3->cached->filepath));
+        $this->assertTrue(file_exists($tpl4->cached->filepath));
+        $this->assertEquals(3, $this->smarty->clearCache('helloworld.tpl'));
+        $this->assertFalse(file_exists($tpl->cached->filepath));
+        $this->assertFalse(file_exists($tpl2->cached->filepath));
+        $this->assertFalse(file_exists($tpl3->cached->filepath));
+        $this->assertTrue(file_exists($tpl4->cached->filepath));
+    }
+
+    public function testClearCacheCacheFileSub()
+    {
+        $this->smarty->caching = true;
+        $this->smarty->cache_lifetime = 1000;
+        $this->smarty->setUseSubDirs(true);
+        $this->cleanCacheDir();
+        $tpl = $this->smarty->createTemplate('helloworld.tpl');
+        $this->writeCachedContent($tpl);
+        $tpl2 = $this->smarty->createTemplate('helloworld.tpl', null, 'bar');
+        $this->writeCachedContent($tpl2);
+        $tpl3 = $this->smarty->createTemplate('helloworld.tpl', 'buh|blar');
+        $this->writeCachedContent($tpl3);
+        $tpl4 = $this->smarty->createTemplate('helloworld2.tpl');
+        $this->writeCachedContent($tpl4);
+        $this->assertTrue(file_exists($tpl->cached->filepath));
+        $this->assertTrue(file_exists($tpl2->cached->filepath));
+        $this->assertTrue(file_exists($tpl3->cached->filepath));
+        $this->assertTrue(file_exists($tpl4->cached->filepath));
+        $this->assertEquals(3, $this->smarty->clearCache('helloworld.tpl'));
+        $this->assertFalse(file_exists($tpl->cached->filepath));
+        $this->assertFalse(file_exists($tpl2->cached->filepath));
+        $this->assertFalse(file_exists($tpl3->cached->filepath));
+        $this->assertTrue(file_exists($tpl4->cached->filepath));
+    }
+
+    /**
+     * test cache->clear_all method
+     */
+    public function testClearCacheAll()
+    {
+        $this->cleanCacheDir();
+        file_put_contents($this->smarty->getCacheDir() . 'dummy.php', 'test');
+        $this->assertEquals(1, $this->smarty->clearAllCache());
+    }
+
+    /**
+     * test cache->clear_all method not expired
+     */
+    public function testClearCacheAllNotExpired()
+    {
+        $this->cleanCacheDir();
+        file_put_contents($this->smarty->getCacheDir() . 'dummy.php', 'test');
+        touch($this->smarty->getCacheDir() . 'dummy.php', time() - 1000);
+        clearstatcache();
+        $this->assertEquals(0, $this->smarty->clearAllCache(2000));
+    }
+
+    /**
+     * test cache->clear_all method expired
+     */
+    public function testClearCacheAllExpired()
+    {
+        $this->cleanCacheDir();
+        file_put_contents($this->smarty->getCacheDir() . 'dummy.php', 'test');
+        touch($this->smarty->getCacheDir() . 'dummy.php', time() - 1000);
+        clearstatcache();
+        $this->assertEquals(1, $this->smarty->clearAllCache(500));
+    }
+
+
+    private function writeCachedContent($tpl)
+    {
+        $tpl->writeCachedContent("echo 'hello world';\n");
+    }
+}

tests/UnitTests/CacheResourceTests/File/cache/.gitignore

@@ -0,0 +1,2 @@
+# Ignore anything in here, but keep this directory
+*

tests/UnitTests/CacheResourceTests/File/templates_c/.gitignore

@@ -0,0 +1,2 @@
+# Ignore anything in here, but keep this directory
+*

tests/UnitTests/CacheResourceTests/Memcache/CacheResourceCustomMemcacheTest.php

@@ -0,0 +1,97 @@
+<?php
+/**
+ * Smarty PHPunit tests for cache resource memcache
+ *
+ * @package PHPunit
+ * @author  Uwe Tews
+ */
+
+include_once dirname(__FILE__) . '/../_shared/CacheResourceTestCommon.php';
+
+/**
+ * class for cache resource memcache tests
+ *
+ * @runTestsInSeparateProcess
+ * @preserveGlobalState disabled
+ * @backupStaticAttributes enabled
+ */
+class CacheResourceCustomMemcacheTest extends CacheResourceTestCommon
+{
+    /**
+     * Sets up the fixture
+     * This method is called before a test is executed.
+     *
+     */
+    public function setUp()
+    {
+        if (MemCacheEnable != true) {
+            $this->markTestSkipped('Memcache tests are disabled');
+        } else {
+            if (!class_exists('Memcache')) {
+                $this->markTestSkipped('Memcache not available');
+            }
+        }
+        $this->setUpSmarty(dirname(__FILE__));
+        parent::setUp();
+        $this->smarty->setCachingType('memcachetest');
+    }
+
+    public function testInit()
+    {
+        $this->cleanDirs();
+    }
+
+    protected function doClearCacheAssertion($a, $b)
+    {
+        $this->assertEquals(- 1, $b);
+    }
+
+    public function testGetCachedFilepathSubDirs()
+    {
+        $this->smarty->caching = true;
+        $this->smarty->cache_lifetime = 1000;
+        $tpl = $this->smarty->createTemplate('helloworld.tpl');
+        $tpl->loadCached();
+        $sha1 = $tpl->source->uid . '#helloworld_tpl##';
+        $this->assertEquals($sha1, $tpl->cached->filepath);
+    }
+
+    /**
+     * test getCachedFilepath with cache_id
+     */
+    public function testGetCachedFilepathCacheId()
+    {
+        $this->smarty->caching = true;
+        $this->smarty->cache_lifetime = 1000;
+        $tpl = $this->smarty->createTemplate('helloworld.tpl', 'foo|bar');
+        $tpl->loadCached();
+        $sha1 = $tpl->source->uid . '#helloworld_tpl#foo|bar#';
+        $this->assertEquals($sha1, $tpl->cached->filepath);
+    }
+
+    /**
+     * test getCachedFilepath with compile_id
+     */
+    public function testGetCachedFilepathCompileId()
+    {
+        $this->smarty->caching = true;
+        $this->smarty->cache_lifetime = 1000;
+        $tpl = $this->smarty->createTemplate('helloworld.tpl', null, 'blar');
+        $tpl->loadCached();
+        $sha1 = $tpl->source->uid . '#helloworld_tpl##blar';
+        $this->assertEquals($sha1, $tpl->cached->filepath);
+    }
+
+    /**
+     * test getCachedFilepath with cache_id and compile_id
+     */
+    public function testGetCachedFilepathCacheIdCompileId()
+    {
+        $this->smarty->caching = true;
+        $this->smarty->cache_lifetime = 1000;
+        $tpl = $this->smarty->createTemplate('helloworld.tpl', 'foo|bar', 'blar');
+        $tpl->loadCached();
+        $sha1 = $tpl->source->uid . '#helloworld_tpl#foo|bar#blar';
+        $this->assertEquals($sha1, $tpl->cached->filepath);
+    }
+}

tests/UnitTests/CacheResourceTests/Memcache/templates_c/.gitignore

@@ -0,0 +1,2 @@
+# Ignore anything in here, but keep this directory
+*

tests/UnitTests/CacheResourceTests/Mysql/CacheResourceCustomMysqlTest.php

@@ -0,0 +1,43 @@
+<?php
+/**
+ * Smarty PHPunit tests for cache resource mysql
+ *
+ * @package PHPunit
+ * @author  Uwe Tews
+ */
+if (MysqlCacheEnable == true) {
+
+    include_once dirname(__FILE__) . '/../_shared/CacheResourceTestCommon.php';
+
+    /**
+     * class for cache resource file tests
+     *
+     * @runTestsInSeparateProcess
+     * @preserveGlobalState    disabled
+     * @backupStaticAttributes enabled
+     */
+    class CacheResourceCustomMysqlTest extends CacheResourceTestCommon
+    {
+
+        public function setUp()
+        {
+
+         if (MysqlCacheEnable != true) {
+                $this->markTestSkipped('mysql tests are disabled');
+            }
+            if (self::$init) {
+                $this->getConnection();
+            }
+            $this->setUpSmarty(dirname(__FILE__));
+            parent::setUp();
+            $this->smarty->setCachingType('mysqltest');
+        }
+
+        public function testInit()
+        {
+            $this->cleanDirs();
+            $this->initMysqlCache();
+        }
+    }
+}
+

tests/UnitTests/CacheResourceTests/Mysql/cache/.gitignore

@@ -0,0 +1,2 @@
+# Ignore anything in here, but keep this directory
+*

tests/UnitTests/CacheResourceTests/Mysql/templates_c/.gitignore

@@ -0,0 +1,2 @@
+# Ignore anything in here, but keep this directory
+*

tests/UnitTests/CacheResourceTests/PDO/CacheResourceCustomPDOTest.php

@@ -0,0 +1,47 @@
+<?php
+/**
+ * Smarty PHPunit tests for cache resource Pdo
+ *
+ * @package PHPunit
+ * @author  Uwe Tews
+ */
+if (PdoCacheEnable == true) {
+
+    include_once dirname(__FILE__) . '/../_shared/CacheResourceTestCommon.php';
+
+    /**
+     * class for cache resource file tests
+     *
+     * @runTestsInSeparateProcess
+     * @preserveGlobalState    disabled
+     * @backupStaticAttributes enabled
+     */
+    class CacheResourceCustomPDOTest extends CacheResourceTestCommon
+    {
+
+        public function setUp($dir = null, $clear = true)
+        {
+            if (PdoCacheEnable != true) {
+                $this->markTestSkipped('mysql Pdo tests are disabled');
+            }
+            if (self::$init) {
+                $this->getConnection();
+            }
+            $this->setUpSmarty(dirname(__FILE__));
+            parent::setUp();
+            $this->smarty->setCachingType('pdo');
+            $this->smarty->addPluginsDir(SMARTY_DIR . '../demo/plugins/');
+            $this->assertTrue(false !== $this->smarty->loadPlugin('Smarty_CacheResource_Pdotest'),
+                              'loadPlugin() could not load PDO cache resource');
+            $this->smarty->registerCacheResource('pdo',
+                                                 new Smarty_CacheResource_Pdotest($this->getPDO(), 'output_cache'));
+        }
+
+        public function testInit()
+        {
+            $this->cleanDirs();
+            $this->initMysqlCache();
+        }
+    }
+}
+

tests/UnitTests/CacheResourceTests/PDOgzip/CacheResourceCustomPDOGzipTest.php

@@ -0,0 +1,45 @@
+<?php
+/**
+ * Smarty PHPunit tests for cache resource file
+ *
+ * @package PHPunit
+ * @author  Uwe Tews
+ */
+if (PdoGzipCacheEnable == true) {
+
+    include_once dirname(__FILE__) . '/../_shared/CacheResourceTestCommon.php';
+
+    /**
+     * class for cache resource file tests
+     *
+     * @backupStaticAttributes enabled
+     */
+    class CacheResourceCustomPDOGzipTest extends CacheResourceTestCommon
+    {
+
+        public function setUp($dir = null, $clear = true)
+        {
+            if (PdoGzipCacheEnable != true) {
+                $this->markTestSkipped('mysql Pdo Gzip tests are disabled');
+            }
+            if (self::$init) {
+                $this->getConnection();
+            }
+            $this->setUpSmarty(dirname(__FILE__));
+            parent::setUp();
+            $this->smarty->setCachingType('pdo');
+            $this->smarty->addPluginsDir(SMARTY_DIR . '../demo/plugins/');
+            $this->assertTrue(false !== $this->smarty->loadPlugin('Smarty_CacheResource_Pdo_Gziptest'),
+                              'loadPlugin() could not load PDOGzip cache resource');
+            $this->smarty->registerCacheResource('pdo', new Smarty_CacheResource_Pdo_Gziptest($this->getPDO(),
+                                                                                              'output_cache'));
+        }
+
+        public function testInit()
+        {
+            $this->cleanDirs();
+            $this->initMysqlCache();
+        }
+    }
+}
+

tests/UnitTests/CacheResourceTests/Registered/CacheResourceCustomRegisteredTest.php

@@ -0,0 +1,44 @@
+<?php
+/**
+ * Smarty PHPunit tests for cache resource registered
+ *
+ * @package PHPunit
+ * @author  Uwe Tews
+ */
+if (MysqlCacheEnable == true) {
+    include_once dirname(__FILE__) . '/../_shared/CacheResourceTestCommon.php';
+
+    /**
+     * class for cache resource file tests
+     *
+     * @runTestsInSeparateProcess
+     * @preserveGlobalState    disabled
+     * @backupStaticAttributes enabled
+     */
+    class CacheResourceCustomRegisteredTest extends CacheResourceTestCommon
+    {
+        public function setUp()
+        {
+            if (MysqlCacheEnable != true) {
+                $this->markTestSkipped('mysql tests are disabled');
+            }
+            if (self::$init) {
+                $this->getConnection();
+            }
+            $this->setUpSmarty(dirname(__FILE__));
+            parent::setUp();
+            if (!class_exists('Smarty_CacheResource_Mysqltest', false)) {
+                require_once(dirname(__FILE__) . "/../_shared/PHPunitplugins/cacheresource.mysqltest.php");
+            }
+            $this->smarty->setCachingType('foobar');
+            $this->smarty->registerCacheResource('foobar', new Smarty_CacheResource_Mysqltest());
+        }
+
+        public function testInit()
+        {
+            $this->cleanDirs();
+            $this->initMysqlCache();
+        }
+    }
+}
+