aschwarz/Kompetenz
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
aschwarz
2023-02-23 10:52:06 +01:00
commit 8bb9cee456
2426 changed files with 471082 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

64
htmlpurifier-4.10.0/tests/HTMLPurifier/DefinitionCache/Decorator/CleanupTest.php Executable file
View File

@ -0,0 +1,64 @@
<?php
generate_mock_once('HTMLPurifier_DefinitionCache');
class HTMLPurifier_DefinitionCache_Decorator_CleanupTest extends HTMLPurifier_DefinitionCache_DecoratorHarness
{
public function setup()
{
$this->cache = new HTMLPurifier_DefinitionCache_Decorator_Cleanup();
parent::setup();
}
public function setupMockForSuccess($op)
{
$this->mock->expectOnce($op, array($this->def, $this->config));
$this->mock->returns($op, true, array($this->def, $this->config));
$this->mock->expectNever('cleanup');
}
public function setupMockForFailure($op)
{
$this->mock->expectOnce($op, array($this->def, $this->config));
$this->mock->returns($op, false, array($this->def, $this->config));
$this->mock->expectOnce('cleanup', array($this->config));
}
public function test_get()
{
$this->mock->expectOnce('get', array($this->config));
$this->mock->returns('get', true, array($this->config));
$this->mock->expectNever('cleanup');
$this->assertEqual($this->cache->get($this->config), $this->def);
}
public function test_get_failure()
{
$this->mock->expectOnce('get', array($this->config));
$this->mock->returns('get', false, array($this->config));
$this->mock->expectOnce('cleanup', array($this->config));
$this->assertEqual($this->cache->get($this->config), false);
}
public function test_set()
{
$this->setupMockForSuccess('set');
$this->assertEqual($this->cache->set($this->def, $this->config), true);
}
public function test_replace()
{
$this->setupMockForSuccess('replace');
$this->assertEqual($this->cache->replace($this->def, $this->config), true);
}
public function test_add()
{
$this->setupMockForSuccess('add');
$this->assertEqual($this->cache->add($this->def, $this->config), true);
}
}
// vim: et sw=4 sts=4

80
htmlpurifier-4.10.0/tests/HTMLPurifier/DefinitionCache/Decorator/MemoryTest.php Executable file
View File

@ -0,0 +1,80 @@
<?php
generate_mock_once('HTMLPurifier_DefinitionCache');
class HTMLPurifier_DefinitionCache_Decorator_MemoryTest extends HTMLPurifier_DefinitionCache_DecoratorHarness
{
public function setup()
{
$this->cache = new HTMLPurifier_DefinitionCache_Decorator_Memory();
parent::setup();
}
public function setupMockForSuccess($op)
{
$this->mock->expectOnce($op, array($this->def, $this->config));
$this->mock->returns($op, true, array($this->def, $this->config));
$this->mock->expectNever('get');
}
public function setupMockForFailure($op)
{
$this->mock->expectOnce($op, array($this->def, $this->config));
$this->mock->returns($op, false, array($this->def, $this->config));
$this->mock->expectOnce('get', array($this->config));
}
public function test_get()
{
$this->mock->expectOnce('get', array($this->config)); // only ONE call!
$this->mock->returns('get', $this->def, array($this->config));
$this->assertEqual($this->cache->get($this->config), $this->def);
$this->assertEqual($this->cache->get($this->config), $this->def);
}
public function test_set()
{
$this->setupMockForSuccess('set', 'get');
$this->assertEqual($this->cache->set($this->def, $this->config), true);
$this->assertEqual($this->cache->get($this->config), $this->def);
}
public function test_set_failure()
{
$this->setupMockForFailure('set', 'get');
$this->assertEqual($this->cache->set($this->def, $this->config), false);
$this->cache->get($this->config);
}
public function test_replace()
{
$this->setupMockForSuccess('replace', 'get');
$this->assertEqual($this->cache->replace($this->def, $this->config), true);
$this->assertEqual($this->cache->get($this->config), $this->def);
}
public function test_replace_failure()
{
$this->setupMockForFailure('replace', 'get');
$this->assertEqual($this->cache->replace($this->def, $this->config), false);
$this->cache->get($this->config);
}
public function test_add()
{
$this->setupMockForSuccess('add', 'get');
$this->assertEqual($this->cache->add($this->def, $this->config), true);
$this->assertEqual($this->cache->get($this->config), $this->def);
}
public function test_add_failure()
{
$this->setupMockForFailure('add', 'get');
$this->assertEqual($this->cache->add($this->def, $this->config), false);
$this->cache->get($this->config);
}
}
// vim: et sw=4 sts=4

25
htmlpurifier-4.10.0/tests/HTMLPurifier/DefinitionCache/DecoratorHarness.php Executable file
View File

@ -0,0 +1,25 @@
<?php
generate_mock_once('HTMLPurifier_DefinitionCache');
class HTMLPurifier_DefinitionCache_DecoratorHarness extends HTMLPurifier_DefinitionCacheHarness
{
public function setup()
{
$this->mock = new HTMLPurifier_DefinitionCacheMock();
$this->mock->type = 'Test';
$this->cache = $this->cache->decorate($this->mock);
$this->def = $this->generateDefinition();
$this->config = $this->generateConfigMock();
}
public function teardown()
{
unset($this->mock);
unset($this->cache);
}
}
// vim: et sw=4 sts=4

42
htmlpurifier-4.10.0/tests/HTMLPurifier/DefinitionCache/DecoratorTest.php Executable file
View File

@ -0,0 +1,42 @@
<?php
class HTMLPurifier_DefinitionCache_DecoratorTest extends HTMLPurifier_DefinitionCacheHarness
{
public function test()
{
generate_mock_once('HTMLPurifier_DefinitionCache');
$mock = new HTMLPurifier_DefinitionCacheMock();
$mock->type = 'Test';
$cache = new HTMLPurifier_DefinitionCache_Decorator();
$cache = $cache->decorate($mock);
$this->assertIdentical($cache->type, $mock->type);
$def = $this->generateDefinition();
$config = $this->generateConfigMock();
$mock->expectOnce('add', array($def, $config));
$cache->add($def, $config);
$mock->expectOnce('set', array($def, $config));
$cache->set($def, $config);
$mock->expectOnce('replace', array($def, $config));
$cache->replace($def, $config);
$mock->expectOnce('get', array($config));
$cache->get($config);
$mock->expectOnce('flush', array($config));
$cache->flush($config);
$mock->expectOnce('cleanup', array($config));
$cache->cleanup($config);
}
}
// vim: et sw=4 sts=4

243
htmlpurifier-4.10.0/tests/HTMLPurifier/DefinitionCache/SerializerTest.php Executable file
View File

@ -0,0 +1,243 @@
<?php
class HTMLPurifier_DefinitionCache_SerializerTest extends HTMLPurifier_DefinitionCacheHarness
{
public function test()
{
// XXX SimpleTest does some really crazy stuff in the background
// to do equality checks. Unfortunately, this makes some
// versions of PHP segfault. So we need to define a better,
// homebrew notion of equality and use that instead. For now,
// the identical asserts are commented out.
$cache = new HTMLPurifier_DefinitionCache_Serializer('Test');
$config = $this->generateConfigMock('serial');
$config->returns('get', 2, array('Test.DefinitionRev'));
$config->version = '1.0.0';
$config_md5 = '1.0.0,serial,2';
$file = realpath(
$rel_file = HTMLPURIFIER_PREFIX . '/HTMLPurifier/DefinitionCache/Serializer/Test/' .
$config_md5 . '.ser'
);
if($file && file_exists($file)) unlink($file); // prevent previous failures from causing problems
$this->assertIdentical($config_md5, $cache->generateKey($config));
$def_original = $this->generateDefinition();
$cache->add($def_original, $config);
$this->assertFileExist($rel_file);
$file_generated = $cache->generateFilePath($config);
$this->assertIdentical(realpath($rel_file), realpath($file_generated));
$def_1 = $cache->get($config);
// $this->assertIdentical($def_original, $def_1);
$def_original->info_random = 'changed';
$cache->set($def_original, $config);
$def_2 = $cache->get($config);
// $this->assertIdentical($def_original, $def_2);
// $this->assertNotEqual ($def_original, $def_1);
$def_original->info_random = 'did it change?';
$this->assertFalse($cache->add($def_original, $config));
$def_3 = $cache->get($config);
// $this->assertNotEqual ($def_original, $def_3); // did not change!
// $this->assertIdentical($def_3, $def_2);
$cache->replace($def_original, $config);
$def_4 = $cache->get($config);
// $this->assertIdentical($def_original, $def_4);
$cache->remove($config);
$this->assertFileNotExist($file);
$this->assertFalse($cache->replace($def_original, $config));
$def_5 = $cache->get($config);
$this->assertFalse($def_5);
}
public function test_errors()
{
$cache = new HTMLPurifier_DefinitionCache_Serializer('Test');
$def = $this->generateDefinition();
$def->setup = true;
$def->type = 'NotTest';
$config = $this->generateConfigMock('testfoo');
$this->expectError('Cannot use definition of type NotTest in cache for Test');
$cache->add($def, $config);
$this->expectError('Cannot use definition of type NotTest in cache for Test');
$cache->set($def, $config);
$this->expectError('Cannot use definition of type NotTest in cache for Test');
$cache->replace($def, $config);
}
public function test_flush()
{
$cache = new HTMLPurifier_DefinitionCache_Serializer('Test');
$config1 = $this->generateConfigMock('test1');
$config2 = $this->generateConfigMock('test2');
$config3 = $this->generateConfigMock('test3');
$def1 = $this->generateDefinition(array('info_candles' => 1));
$def2 = $this->generateDefinition(array('info_candles' => 2));
$def3 = $this->generateDefinition(array('info_candles' => 3));
$cache->add($def1, $config1);
$cache->add($def2, $config2);
$cache->add($def3, $config3);
$this->assertEqual($def1, $cache->get($config1));
$this->assertEqual($def2, $cache->get($config2));
$this->assertEqual($def3, $cache->get($config3));
$cache->flush($config1); // only essential directive is %Cache.SerializerPath
$this->assertFalse($cache->get($config1));
$this->assertFalse($cache->get($config2));
$this->assertFalse($cache->get($config3));
}
public function testCleanup()
{
$cache = new HTMLPurifier_DefinitionCache_Serializer('Test');
// in order of age, oldest first
// note that configurations are all identical, but version/revision
// are different
$config1 = $this->generateConfigMock();
$config1->version = '0.9.0';
$config1->returns('get', 574, array('Test.DefinitionRev'));
$def1 = $this->generateDefinition(array('info' => 1));
$config2 = $this->generateConfigMock();
$config2->version = '1.0.0beta';
$config2->returns('get', 1, array('Test.DefinitionRev'));
$def2 = $this->generateDefinition(array('info' => 3));
$cache->set($def1, $config1);
$cache->cleanup($config1);
$this->assertEqual($def1, $cache->get($config1)); // no change
$cache->cleanup($config2);
$this->assertFalse($cache->get($config1));
$this->assertFalse($cache->get($config2));
}
public function testCleanupOnlySameID()
{
$cache = new HTMLPurifier_DefinitionCache_Serializer('Test');
$config1 = $this->generateConfigMock('serial1');
$config1->version = '1.0.0';
$config1->returns('get', 1, array('Test.DefinitionRev'));
$def1 = $this->generateDefinition(array('info' => 1));
$config2 = $this->generateConfigMock('serial2');
$config2->version = '1.0.0';
$config2->returns('get', 34, array('Test.DefinitionRev'));
$def2 = $this->generateDefinition(array('info' => 3));
$cache->set($def1, $config1);
$cache->cleanup($config1);
$this->assertEqual($def1, $cache->get($config1)); // no change
$cache->set($def2, $config2);
$cache->cleanup($config2);
$this->assertEqual($def1, $cache->get($config1));
$this->assertEqual($def2, $cache->get($config2));
$cache->flush($config1);
}
/**
* Asserts that a file exists, ignoring the stat cache
*/
public function assertFileExist($file)
{
clearstatcache();
$this->assertTrue(file_exists($file), 'Expected ' . $file . ' exists');
}
/**
* Asserts that a file does not exist, ignoring the stat cache
*/
public function assertFileNotExist($file)
{
clearstatcache();
$this->assertFalse(file_exists($file), 'Expected ' . $file . ' does not exist');
}
public function testAlternatePath()
{
$cache = new HTMLPurifier_DefinitionCache_Serializer('Test');
$config = $this->generateConfigMock('serial');
$config->version = '1.0.0';
$config->returns('get', 1, array('Test.DefinitionRev'));
$dir = dirname(__FILE__) . '/SerializerTest';
$config->returns('get', $dir, array('Cache.SerializerPath'));
$def_original = $this->generateDefinition();
$cache->add($def_original, $config);
$this->assertFileExist($dir . '/Test/1.0.0,serial,1.ser');
unlink($dir . '/Test/1.0.0,serial,1.ser');
rmdir( $dir . '/Test');
}
public function testAlternatePermissions()
{
$cache = new HTMLPurifier_DefinitionCache_Serializer('Test');
$config = $this->generateConfigMock('serial');
$config->version = '1.0.0';
$config->returns('get', 1, array('Test.DefinitionRev'));
$dir = dirname(__FILE__) . '/SerializerTest';
$config->returns('get', $dir, array('Cache.SerializerPath'));
$config->returns('get', 0700, array('Cache.SerializerPermissions'));
$def_original = $this->generateDefinition();
$cache->add($def_original, $config);
$this->assertFileExist($dir . '/Test/1.0.0,serial,1.ser');
$this->assertEqual(0600, 0777 & fileperms($dir . '/Test/1.0.0,serial,1.ser'));
$this->assertEqual(0700, 0777 & fileperms($dir . '/Test'));
unlink($dir . '/Test/1.0.0,serial,1.ser');
rmdir( $dir . '/Test');
}
public function testNoInfiniteLoop()
{
$cache = new HTMLPurifier_DefinitionCache_Serializer('Test');
$config = $this->generateConfigMock('serial');
$config->version = '1.0.0';
$config->returns('get', 1, array('Test.DefinitionRev'));
$dir = dirname(__FILE__) . '/SerializerTest';
$config->returns('get', $dir, array('Cache.SerializerPath'));
$config->returns('get', 0400, array('Cache.SerializerPermissions'));
$cache->cleanup($config);
}
}
// vim: et sw=4 sts=4

3
htmlpurifier-4.10.0/tests/HTMLPurifier/DefinitionCache/SerializerTest/README Executable file
View File

@ -0,0 +1,3 @@
This is a dummy file to prevent Git from ignoring this empty directory.
vim: et sw=4 sts=4