/**
* Fills $this->files with all the .request files found in the regression
* directory, recursively.
*/
public function __construct()
{
$siteaccess = strtolower(__CLASS__);
if (ezcBaseFeatures::classExists('eZSiteAccessHelper', true)) {
require_once 'siteaccesscreator.php';
// - ./siteaccess/site.ini.append.php.replace is copied over site.ini.append.php,
// with certain values replaced dynamically (@ezc_siteaccess@ and
// @ezc_webdav_database@)
// - the extension ezsiteaccesshelper is called to create the siteaccess with
// the same name as this class (in lowercase), and it will copy the site.ini.append.php
// file to the ezp/siteaccess/@ezc_siteaccess@ folder
// - the extension ezsiteaccesshelper is called to enable the created siteaccess
// in ezp/siteaccess/override/site.ini.append.php
$replace = array();
$replace['@ezc_siteaccess@'] = $siteaccess;
$replace['@ezc_webdav_database@'] = ezpTestRunner::dsn()->database;
$templateDir = dirname(__FILE__) . DIRECTORY_SEPARATOR . 'siteaccess';
try {
// replace @ezc_siteaccess@ and @ezc_webdav_database@ in site.ini.append.php
// with respective values
$contents = file_get_contents($templateDir . DIRECTORY_SEPARATOR . 'site.ini.append.php.replace');
if (count($replace) > 0) {
foreach ($replace as $key => $replacement) {
$contents = str_replace($key, $replacement, $contents);
}
}
file_put_contents($templateDir . DIRECTORY_SEPARATOR . 'site.ini.append.php', $contents);
ezpSiteAccessCreator::$docRoot = eZSys::rootDir() . DIRECTORY_SEPARATOR;
ezpSiteAccessCreator::createSiteAccess($siteaccess, $templateDir);
} catch (Exception $e) {
// eZSiteAccessHelper::createSiteAccess throws an exception
// if the siteaccess exists already
// var_dump( $e->getMessage() );
}
} else {
die("The WebDAV test suite requires the extension eZSiteAccessHelper in order to create a siteaccess.\n");
}
$basePath = dirname(__FILE__) . '/regression';
$this->readDirRecursively($basePath, $this->files, 'request');
parent::__construct();
}
/**
* Parses a required type.
*
* @param mixed $type
* @param ezcTemplateCursor $startCursor
* @param bool $mergeElements
* @return bool
*/
protected function parseRequiredType($type, ezcTemplateCursor $startCursor = null, $mergeElements = true)
{
if (is_string($type)) {
$className = 'ezcTemplate' . $type . 'SourceToTstParser';
if (!ezcBaseFeatures::classExists($className)) {
throw new ezcTemplateInternalException("Could instantiate sub-parser for type <{$type}>, the class <{$className}> does not exist");
}
$this->subParser = new $className($this->parser, $this, $startCursor);
} else {
if (is_object($type) && $type instanceof ezcTemplateSourceToTstParser) {
$this->subParser = $type;
} else {
throw new ezcTemplateInternalException("Cannot use <" . gettype($type) . "> as parser in ezcTemplateSourceToTstParser::parseRequiredType()");
}
}
$this->lastParser = $this->subParser;
$this->subParser->parse();
if ($this->subParser->status == self::PARSE_SUCCESS) {
$this->currentCursor->copy($this->subParser->endCursor);
$this->lastCursor->copy($this->currentCursor);
if ($mergeElements) {
$this->mergeElements($this->subParser);
}
$this->subParser = null;
return true;
} elseif ($this->subParser->status === self::PARSE_PARTIAL_SUCCESS) {
$this->status = $this->subParser->status;
return false;
}
return false;
}
public function testClassExistsNotFoundAutoload()
{
$this->assertEquals(false, ezcBaseFeatures::classExists('ezcBaseNonExistingClass'));
}
/**
* Creates a new cache in the manager.
* This method is used to create a new cache inside the manager.
* Each cache has a unique ID to access it during the application
* runtime. Each location may only be used by 1 cache.
*
* The $storageClass parameter must be a subclass of
* {@link ezcCacheStorage} and tells the manager which object
* will be used for the cache.
*
* The $location parameter depends on the kind of {@link ezcCacheStorage}
* used for the cache you create. Usually this is a directory on your
* file system, but may also be e.g. a data source name, if you cache in
* a database or similar. For memory-based storage ({@link ezcCacheStorageApcPlain}
* or {@link ezcCacheStorageMemcachePlain}) it is null, but for
* memory/file hybrid storage ({@link ezcCacheStorageFileApcArray}) it should
* be an existing writeable path.
*
* The $options array consists of several standard attributes and can
* additionally contain options defined by the {@link ezcCacheStorage}
* class. Standard options are:
*
* <code>
* array(
* 'ttl' => 60*60*24, // Time-to-life, default: 1 day
* );
* </code>
*
* @param string $id ID of the cache to create.
* @param string $location Location to create the cache in. Null for
* memory-based storage and an existing
* writeable path for file or memory/file
* storage.
* @param string $storageClass Subclass of {@link ezcCacheStorage}.
* @param array(string=>string) $options Options for the cache.
* @return void
*
* @throws ezcBaseFileNotFoundException
* If the given location does not exist or is not a
* directory (thrown by sanity checks performed when storing the
* configuration of a cache to ensure the latter calls to
* {@link ezcCacheManager::getCache()} do not fail).
* @throws ezcBaseFilePermissionException
* If the given location is not read/writeable (thrown by sanity
* checks performed when storing the configuration of a cache to
* ensure the latter calls to {@link ezcCacheManager::getCache()}
* do not fail).
* @throws ezcCacheUsedLocationException
* If the given location is already in use by another cache.
* @throws ezcCacheInvalidStorageClassException
* If the given storage class does not exist or is no subclass of
* ezcCacheStorage.
*/
public static function createCache($id, $location = null, $storageClass, $options = array())
{
// BC for missing location. The location should not be missing.
if ($location !== null) {
// Unifiy file system locations
if (substr($location, 0, 1) === '/') {
// If non-existent
if (($realLocation = realpath($location)) === false) {
throw new ezcBaseFileNotFoundException($location, 'cache location', 'Does not exist or is no directory.');
}
$location = $realLocation;
}
// Sanity check double taken locations.
foreach (self::$configurations as $confId => $config) {
if ($config['location'] === $location) {
throw new ezcCacheUsedLocationException($location, $confId);
}
}
}
// Sanity check storage class.
if (!ezcBaseFeatures::classExists($storageClass) || !is_subclass_of($storageClass, 'ezcCacheStorage')) {
throw new ezcCacheInvalidStorageClassException($storageClass);
}
self::$configurations[$id] = array('location' => $location, 'class' => $storageClass, 'options' => $options);
}
/**
* Initializes the manager.
*
* Initializes the manager with the values which will be used by the configuration
* reader. It sets the default location and reader options and which reader to
* use by specifying the class name.
*
* @throws ezcConfigurationInvalidReaderClassException if the $readerClass
* does not exist or does not implement the ezcConfigurationReader
* interface.
*
* @param string $readerClass The name of the class to use as a
* configuration reader. This class must implement the
* ezcConfigurationReader interface.
* @param string $location The main placement for the configuration. It is
* up to the specific reader to interpret this value. This
* can for instance be used to determine the directory
* location for an INI file.
* @param array $options Options for the configuration reader, this is
* passed on the reader specified in $readerClass when it is
* created. Check the documentation for the specific reader
* to see which options it supports.
* @return void
*/
public function init($readerClass, $location, array $options = array())
{
// Check if the passed classname actually exists
if (!ezcBaseFeatures::classExists($readerClass, true)) {
throw new ezcConfigurationInvalidReaderClassException($readerClass);
}
// Check if the passed classname actually implements the interface.
if (!in_array('ezcConfigurationReader', class_parents($readerClass))) {
throw new ezcConfigurationInvalidReaderClassException($readerClass);
}
$this->readerClass = $readerClass;
$this->location = $location;
$this->options = $options;
}
/**
* Check all known handlers for availability.
*
* This method checks all registered handler classes for if the they are
* available (using {@link ezcImageAnalyzerHandler::isAvailable()}).
*
* @throws ezcImageAnalyzerInvalidHandlerException
* If a registered handler class does not exist
* or does not inherit from {@link ezcImageAnalyzerHandler}.
*/
protected function checkHandlers()
{
if (isset(ezcImageAnalyzer::$availableHandlers) && is_array(ezcImageAnalyzer::$availableHandlers)) {
return;
}
ezcImageAnalyzer::$availableHandlers = array();
foreach (ezcImageAnalyzer::$knownHandlers as $handlerClass => $options) {
if (!ezcBaseFeatures::classExists($handlerClass) || !is_subclass_of($handlerClass, 'ezcImageAnalyzerHandler')) {
throw new ezcImageAnalyzerInvalidHandlerException($handlerClass);
}
$handler = new $handlerClass($options);
if ($handler->isAvailable()) {
ezcImageAnalyzer::$availableHandlers[] = clone $handler;
}
}
}
/**
* Initialize converter with settings object.
* The ezcImageConverter can be directly instantiated, but it's
* highly recommended to use a manual singleton implementation
* to have just 1 instance of a ezcImageConverter per Request.
*
* ATTENTION: The ezcImageConverter does not support animated
* GIFs. Animated GIFs will simply be ignored by all filters and
* conversions.
*
* @param ezcImageConverterSettings $settings Settings for the converter.
*
* @throws ezcImageHandlerSettingsInvalidException
* If handler settings are invalid.
* @throws ezcImageMimeTypeUnsupportedException
* If a given MIME type is not supported.
*/
public function __construct(ezcImageConverterSettings $settings)
{
// Initialize handlers
foreach ($settings->handlers as $i => $handlerSettings) {
if (!$handlerSettings instanceof ezcImageHandlerSettings) {
throw new ezcImageHandlerSettingsInvalidException();
}
$handlerClass = $handlerSettings->className;
if (!ezcBaseFeatures::classExists($handlerClass)) {
throw new ezcImageHandlerNotAvailableException($handlerClass);
}
$handler = new $handlerClass($handlerSettings);
$this->handlers[$handlerSettings->referenceName] = $handler;
}
// Check implicit conversions
foreach ($settings->conversions as $mimeIn => $mimeOut) {
if (!$this->allowsInput($mimeIn)) {
throw new ezcImageMimeTypeUnsupportedException($mimeIn, 'input');
}
if (!$this->allowsOutput($mimeOut)) {
throw new ezcImageMimeTypeUnsupportedException($mimeOut, 'output');
}
}
$this->settings = $settings;
}
/**
* Adds the difference write handler class $writerClass to the manager for $type
*
* @throws ezcDbSchemaInvalidWriterClassException if the $writerClass
* doesn't exist or doesn't extend the abstract class
* ezcDbSchemaDiffWriter.
* @param string $type
* @param string $writerClass
*/
public static function addDiffWriter($type, $writerClass)
{
// Check if the passed classname actually exists
if (!ezcBaseFeatures::classExists($writerClass, true)) {
throw new ezcDbSchemaInvalidDiffWriterClassException($writerClass);
}
// Check if the passed classname actually implements the interface.
if (!in_array('ezcDbSchemaDiffWriter', class_implements($writerClass))) {
throw new ezcDbSchemaInvalidDiffWriterClassException($writerClass);
}
self::$diffWriteHandlers[$type] = $writerClass;
}
/**
* Adds the classname $callbackClassname as callback for the identifier $identifier.
*
* @param string $identifier
* @param string $callbackClassname
*/
public static function setCallback($identifier, $callbackClassname)
{
if (array_key_exists($identifier, self::$callbackMap)) {
throw new ezcBaseInitCallbackConfiguredException($identifier, self::$callbackMap[$identifier]);
} else {
// Check if the passed classname actually exists
if (!ezcBaseFeatures::classExists($callbackClassname, true)) {
throw new ezcBaseInitInvalidCallbackClassException($callbackClassname);
}
// Check if the passed classname actually implements the interface.
if (!in_array('ezcBaseConfigurationInitializer', class_implements($callbackClassname))) {
throw new ezcBaseInitInvalidCallbackClassException($callbackClassname);
}
self::$callbackMap[$identifier] = $callbackClassname;
}
}
/**
* Parses the statements, foreach, while, if, elseif, etc.
*
* @param ezcTemplateCursor $cursor
* @return bool
*/
protected function parseCurrent(ezcTemplateCursor $cursor)
{
// Check if any control structure names are used.
// Note: The code inside the (?:) brace ensures that the next character
// is not an alphabetical character ie. a word boundary
$matches = $cursor->pregMatchComplete("#^(tr|tr_context|foreach|while|if|elseif|else|switch|case|default|include|return|break|continue|skip|delimiter|increment|decrement|reset|charset|capture)(?:[^a-zA-Z0-9_])#");
if ($matches === false) {
return false;
}
$name = $matches[1][0];
$cursor->advance(strlen($matches[1][0]));
// control structure map
$csMap = array();
$csMap['foreach'] = 'ForeachLoop';
$csMap['for'] = 'ForLoop';
$csMap['while'] = 'WhileLoop';
$csMap['if'] = 'IfCondition';
$csMap['elseif'] = 'IfCondition';
$csMap['else'] = 'IfCondition';
$csMap['switch'] = 'SwitchCondition';
$csMap['case'] = 'SwitchCondition';
$csMap['default'] = 'SwitchCondition';
$csMap['include'] = 'Include';
$csMap['return'] = 'Include';
$csMap['break'] = 'Loop';
$csMap['continue'] = 'Loop';
$csMap['skip'] = 'Delimiter';
$csMap['delimiter'] = 'Delimiter';
$csMap['increment'] = 'Cycle';
$csMap['decrement'] = 'Cycle';
$csMap['reset'] = 'Cycle';
$csMap['charset'] = 'Charset';
$csMap['capture'] = 'Capture';
$csMap['tr'] = 'Translation';
$csMap['tr_context'] = 'TranslationContext';
// tmp
if (!isset($csMap[$name])) {
return false;
}
$parser = 'ezcTemplate' . $csMap[$name] . 'SourceToTstParser';
// tmp
if (!ezcBaseFeatures::classExists($parser)) {
return false;
}
if (!ezcBaseFeatures::classExists($parser)) {
throw new ezcTemplateInternalException("Requested parser class <{$parser}> does not exist");
}
$controlStructureParser = new $parser($this->parser, $this, null);
$this->block->name = $name;
$controlStructureParser->block = $this->block;
if (!$this->parseRequiredType($controlStructureParser)) {
return false;
}
return true;
}
public function testReader5()
{
if (!ezcBaseFeatures::classExists('SimpleXMLIterator')) {
$this->markTestSkipped("This test is supposed to run only when the SimpleXML extension is available.");
}
$currentDir = dirname(__FILE__);
$backend = new ezcTranslationTsBackend("{$currentDir}/files/translations");
$backend->setOptions(array('format' => '[LOCALE].xml'));
$backend->initReader('nb-no');
$contexts = array();
foreach ($backend as $contextName => $context) {
$contexts[] = $contextName;
}
$backend->deinitReader();
$expected = array('contentstructuremenu/show_content_structure', 'design/admin/class/classlist', 'design/admin/class/datatype/browse_objectrelationlist_placement');
self::assertEquals($expected, $contexts);
}
/**
* Adds custom tags or functions to the customBlock or customFunction
* property and indirectly adds the custom extension to the template
* language.
*
* The parameter $customBlockClass expects a class that implements either
* the interface ezcTemplateCustomBlock, ezcTemplateCustomFunction, or both.
*
* New custom blocks are added to the
* {@link ezcTemplateConfiguration::customBlocks $customBlocks} property while
* custom functions are added to the
* {@link ezcTemplateConfiguration::customFunctions $customFunctions} property.
*
* @param string $customClass
* @throws ezcBaseValueException if the $customClass parameter is not a
* string, or when the classname that it represents does not
* implement either the ezcTemplateCustomBlock or
* ezcTemplateCustomFunction interface.
*/
public function addExtension($customClass)
{
if (!is_string($customClass) || !ezcBaseFeatures::classExists($customClass, true)) {
throw new ezcBaseValueException('customClass', $customClass, 'string with classname that implements the ezcTemplateCustomBlock or ezcTemplateCustomFunction interface', 'argument');
}
$implements = class_implements($customClass);
$added = false;
if (in_array("ezcTemplateCustomBlock", $implements)) {
$this->properties["customBlocks"][$customClass] = $customClass;
$added = true;
}
if (in_array("ezcTemplateCustomFunction", $implements)) {
$this->properties["customFunctions"][$customClass] = $customClass;
$added = true;
}
if (!$added) {
throw new ezcBaseValueException('customClass', $customClass, 'string with classname that implements the ezcTemplateCustomBlock or ezcTemplateCustomFunction interface', 'argument');
}
}
/**
* Adds the classname $callbackClassname as callback for the identifier $identifier.
*
* @param string $identifier
* @param string $callbackClassname
*/
public static function setCallback($identifier, $callbackClassname)
{
if (array_key_exists($identifier, self::$callbackMap)) {
throw new ezcBaseInitCallbackConfiguredException($identifier, self::$callbackMap[$identifier]);
} else {
// Check if the passed classname actually exists
if (!ezcBaseFeatures::classExists($callbackClassname, true)) {
throw new ezcBaseInitInvalidCallbackClassException($callbackClassname);
}
// Check if the passed classname actually implements the interface. We
// have to do that with reflection here unfortunately
$interfaceClass = new ReflectionClass('ezcBaseConfigurationInitializer');
$handlerClass = new ReflectionClass($callbackClassname);
if (!$handlerClass->isSubclassOf($interfaceClass)) {
throw new ezcBaseInitInvalidCallbackClassException($callbackClassname);
}
self::$callbackMap[$identifier] = $callbackClassname;
}
}
/**
* Initializes the ezcExecution environment.
*
* With this method you initialize the ezcExecution environment. You need
* to specify a class name $callBackClassName that will be used to call the
* onError() method on in case of an error. The class name that you
* pass should implement the ezcExecutionErrorHandler interface. This
* method takes care of registering the uncaught exception and shutdown
* handlers.
*
* @throws ezcExecutionInvalidCallbackException if an unknown callback
* class was passed.
* @throws ezcExecutionWrongClassException if an invalid callback class was
* passed.
* @throws ezcExecutionAlreadyInitializedException if the environment was
* already initialized.
*
* @param string $callbackClassName
* @return void
*/
public static function init($callbackClassName)
{
// Check if the passed classname actually exists
if (!ezcBaseFeatures::classExists($callbackClassName, true)) {
throw new ezcExecutionInvalidCallbackException($callbackClassName);
}
// Check if the passed classname actually implements the interface. We
// have to do that with reflection here unfortunately since we only
// have the classname and not an object.
$interfaceClass = new ReflectionClass('ezcExecutionErrorHandler');
$handlerClass = new ReflectionClass($callbackClassName);
if (!$handlerClass->isSubclassOf($interfaceClass)) {
throw new ezcExecutionWrongClassException($callbackClassName);
}
// Check if it was already initialized once
if (self::$isInitialized == true) {
throw new ezcExecutionAlreadyInitializedException();
}
// Install shutdown handler and exception handler
set_exception_handler(array('ezcExecution', 'exceptionCallbackHandler'));
if (!self::$shutdownHandlerRegistered) {
register_shutdown_function(array('ezcExecution', 'shutdownCallbackHandler'));
}
self::$callbackClassName = $callbackClassName;
self::$isInitialized = true;
self::$cleanExit = false;
self::$shutdownHandlerRegistered = true;
}
/**
* Initializes the ezcExecution environment.
*
* With this method you initialize the ezcExecution environment. You need
* to specify a class name $callBackClassName that will be used to call the
* onError() method on in case of an error. The class name that you
* pass should implement the ezcExecutionErrorHandler interface. This
* method takes care of registering the uncaught exception and shutdown
* handlers.
*
* @throws ezcExecutionInvalidCallbackException if an unknown callback
* class was passed.
* @throws ezcExecutionWrongClassException if an invalid callback class was
* passed.
* @throws ezcExecutionAlreadyInitializedException if the environment was
* already initialized.
*
* @param string $callbackClassName
* @return void
*/
public static function init($callbackClassName)
{
// Check if the passed classname actually exists
if (!ezcBaseFeatures::classExists($callbackClassName, true)) {
throw new ezcExecutionInvalidCallbackException($callbackClassName);
}
// Check if the passed classname actually implements the interface.
if (!in_array('ezcExecutionErrorHandler', class_implements($callbackClassName))) {
throw new ezcExecutionWrongClassException($callbackClassName);
}
// Check if it was already initialized once
if (self::$isInitialized == true) {
throw new ezcExecutionAlreadyInitializedException();
}
// Install shutdown handler and exception handler
set_exception_handler(array('ezcExecution', 'exceptionCallbackHandler'));
if (!self::$shutdownHandlerRegistered) {
register_shutdown_function(array('ezcExecution', 'shutdownCallbackHandler'));
}
self::$callbackClassName = $callbackClassName;
self::$isInitialized = true;
self::$cleanExit = false;
self::$shutdownHandlerRegistered = true;
}
