pax_global_header00006660000000000000000000000064131004102560014502gustar00rootroot0000000000000052 comment=e8ba02eed7bbbb9e59e43dedd3dddeff4a56b0c4 global-state-2.0.0/000077500000000000000000000000001310041025600140575ustar00rootroot00000000000000global-state-2.0.0/.gitignore000066400000000000000000000000551310041025600160470ustar00rootroot00000000000000/.idea /.php_cs.cache /composer.lock /vendor global-state-2.0.0/.php_cs000066400000000000000000000056501310041025600153420ustar00rootroot00000000000000 For the full copyright and license information, please view the LICENSE file that was distributed with this source code. EOF; return PhpCsFixer\Config::create() ->setRiskyAllowed(true) ->setRules( [ 'array_syntax' => ['syntax' => 'short'], 'binary_operator_spaces' => [ 'align_double_arrow' => true, 'align_equals' => true ], 'blank_line_after_namespace' => true, 'blank_line_before_return' => true, 'braces' => true, 'cast_spaces' => true, 'concat_space' => ['spacing' => 'one'], 'elseif' => true, 'encoding' => true, 'full_opening_tag' => true, 'function_declaration' => true, #'header_comment' => ['header' => $header, 'separate' => 'none'], 'indentation_type' => true, 'line_ending' => true, 'lowercase_constants' => true, 'lowercase_keywords' => true, 'method_argument_space' => true, 'native_function_invocation' => true, 'no_alias_functions' => true, 'no_blank_lines_after_class_opening' => true, 'no_blank_lines_after_phpdoc' => true, 'no_closing_tag' => true, 'no_empty_phpdoc' => true, 'no_empty_statement' => true, 'no_extra_consecutive_blank_lines' => true, 'no_leading_namespace_whitespace' => true, 'no_singleline_whitespace_before_semicolons' => true, 'no_spaces_after_function_name' => true, 'no_spaces_inside_parenthesis' => true, 'no_trailing_comma_in_list_call' => true, 'no_trailing_whitespace' => true, 'no_unused_imports' => true, 'no_whitespace_in_blank_line' => true, 'phpdoc_align' => true, 'phpdoc_indent' => true, 'phpdoc_no_access' => true, 'phpdoc_no_empty_return' => true, 'phpdoc_no_package' => true, 'phpdoc_scalar' => true, 'phpdoc_separation' => true, 'phpdoc_to_comment' => true, 'phpdoc_trim' => true, 'phpdoc_types' => true, 'phpdoc_var_without_name' => true, 'self_accessor' => true, 'simplified_null_return' => true, 'single_blank_line_at_eof' => true, 'single_import_per_statement' => true, 'single_line_after_imports' => true, 'single_quote' => true, 'ternary_operator_spaces' => true, 'trim_array_spaces' => true, 'visibility_required' => true, ] ) ->setFinder( PhpCsFixer\Finder::create() ->files() ->in(__DIR__ . '/src') ->in(__DIR__ . '/tests') ->name('*.php') ); global-state-2.0.0/.travis.yml000066400000000000000000000007021310041025600161670ustar00rootroot00000000000000language: php php: - 7.0 - 7.0snapshot - 7.1 - 7.1snapshot - master sudo: false before_install: - composer self-update - composer clear-cache install: - travis_retry composer update --no-interaction --no-ansi --no-progress --no-suggest --optimize-autoloader --prefer-stable script: - ./vendor/bin/phpunit --coverage-clover=coverage.xml after_success: - bash <(curl -s https://codecov.io/bash) notifications: email: false global-state-2.0.0/LICENSE000066400000000000000000000030251310041025600150640ustar00rootroot00000000000000sebastian/global-state Copyright (c) 2001-2017, Sebastian Bergmann . All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of Sebastian Bergmann nor the names of his contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. global-state-2.0.0/README.md000066400000000000000000000011721310041025600153370ustar00rootroot00000000000000# GlobalState Snapshotting of global state, factored out of PHPUnit into a stand-alone component. [![Build Status](https://travis-ci.org/sebastianbergmann/global-state.svg?branch=master)](https://travis-ci.org/sebastianbergmann/global-state) ## Installation You can add this library as a local, per-project dependency to your project using [Composer](https://getcomposer.org/): composer require sebastian/global-state If you only need this library during development, for instance to run your project's test suite, then you should add it as a development-time dependency: composer require --dev sebastian/global-state global-state-2.0.0/build.xml000066400000000000000000000015251310041025600157030ustar00rootroot00000000000000 global-state-2.0.0/composer.json000066400000000000000000000015311310041025600166010ustar00rootroot00000000000000{ "name": "sebastian/global-state", "description": "Snapshotting of global state", "keywords": ["global state"], "homepage": "http://www.github.com/sebastianbergmann/global-state", "license": "BSD-3-Clause", "authors": [ { "name": "Sebastian Bergmann", "email": "sebastian@phpunit.de" } ], "require": { "php": "^7.0" }, "require-dev": { "phpunit/phpunit": "^6.0" }, "suggest": { "ext-uopz": "*" }, "autoload": { "classmap": [ "src/" ] }, "autoload-dev": { "classmap": [ "tests/_fixture/" ], "files": [ "tests/_fixture/SnapshotFunctions.php" ] }, "extra": { "branch-alias": { "dev-master": "2.0-dev" } } } global-state-2.0.0/phpunit.xml000066400000000000000000000014721310041025600162740ustar00rootroot00000000000000 tests src global-state-2.0.0/src/000077500000000000000000000000001310041025600146465ustar00rootroot00000000000000global-state-2.0.0/src/Blacklist.php000066400000000000000000000052561310041025600172770ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ declare(strict_types=1); namespace SebastianBergmann\GlobalState; use ReflectionClass; /** * A blacklist for global state elements that should not be snapshotted. */ class Blacklist { /** * @var array */ private $globalVariables = []; /** * @var string[] */ private $classes = []; /** * @var string[] */ private $classNamePrefixes = []; /** * @var string[] */ private $parentClasses = []; /** * @var string[] */ private $interfaces = []; /** * @var array */ private $staticAttributes = []; public function addGlobalVariable(string $variableName) { $this->globalVariables[$variableName] = true; } public function addClass(string $className) { $this->classes[] = $className; } public function addSubclassesOf(string $className) { $this->parentClasses[] = $className; } public function addImplementorsOf(string $interfaceName) { $this->interfaces[] = $interfaceName; } public function addClassNamePrefix(string $classNamePrefix) { $this->classNamePrefixes[] = $classNamePrefix; } public function addStaticAttribute(string $className, string $attributeName) { if (!isset($this->staticAttributes[$className])) { $this->staticAttributes[$className] = []; } $this->staticAttributes[$className][$attributeName] = true; } public function isGlobalVariableBlacklisted(string $variableName): bool { return isset($this->globalVariables[$variableName]); } public function isStaticAttributeBlacklisted(string $className, string $attributeName): bool { if (\in_array($className, $this->classes)) { return true; } foreach ($this->classNamePrefixes as $prefix) { if (\strpos($className, $prefix) === 0) { return true; } } $class = new ReflectionClass($className); foreach ($this->parentClasses as $type) { if ($class->isSubclassOf($type)) { return true; } } foreach ($this->interfaces as $type) { if ($class->implementsInterface($type)) { return true; } } if (isset($this->staticAttributes[$className][$attributeName])) { return true; } return false; } } global-state-2.0.0/src/CodeExporter.php000066400000000000000000000045461310041025600177730ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ declare(strict_types=1); namespace SebastianBergmann\GlobalState; /** * Exports parts of a Snapshot as PHP code. */ class CodeExporter { public function constants(Snapshot $snapshot): string { $result = ''; foreach ($snapshot->constants() as $name => $value) { $result .= \sprintf( 'if (!defined(\'%s\')) define(\'%s\', %s);' . "\n", $name, $name, $this->exportVariable($value) ); } return $result; } public function globalVariables(Snapshot $snapshot): string { $result = '$GLOBALS = [];' . PHP_EOL; foreach ($snapshot->globalVariables() as $name => $value) { $result .= \sprintf( '$GLOBALS[%s] = %s;' . PHP_EOL, $this->exportVariable($name), $this->exportVariable($value) ); } return $result; } public function iniSettings(Snapshot $snapshot): string { $result = ''; foreach ($snapshot->iniSettings() as $key => $value) { $result .= \sprintf( '@ini_set(%s, %s);' . "\n", $this->exportVariable($key), $this->exportVariable($value) ); } return $result; } private function exportVariable($variable): string { if (\is_scalar($variable) || \is_null($variable) || (\is_array($variable) && $this->arrayOnlyContainsScalars($variable))) { return \var_export($variable, true); } return 'unserialize(' . \var_export(\serialize($variable), true) . ')'; } private function arrayOnlyContainsScalars(array $array): bool { $result = true; foreach ($array as $element) { if (\is_array($element)) { $result = self::arrayOnlyContainsScalars($element); } elseif (!\is_scalar($element) && !\is_null($element)) { $result = false; } if ($result === false) { break; } } return $result; } } global-state-2.0.0/src/Restorer.php000066400000000000000000000104421310041025600171650ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ declare(strict_types=1); namespace SebastianBergmann\GlobalState; use ReflectionProperty; /** * Restorer of snapshots of global state. */ class Restorer { /** * Deletes function definitions that are not defined in a snapshot. * * @throws RuntimeException when the uopz_delete() function is not available * * @see https://github.com/krakjoe/uopz */ public function restoreFunctions(Snapshot $snapshot) { if (!\function_exists('uopz_delete')) { throw new RuntimeException('The uopz_delete() function is required for this operation'); } $functions = \get_defined_functions(); foreach (\array_diff($functions['user'], $snapshot->functions()) as $function) { uopz_delete($function); } } /** * Restores all global and super-global variables from a snapshot. */ public function restoreGlobalVariables(Snapshot $snapshot) { $superGlobalArrays = $snapshot->superGlobalArrays(); foreach ($superGlobalArrays as $superGlobalArray) { $this->restoreSuperGlobalArray($snapshot, $superGlobalArray); } $globalVariables = $snapshot->globalVariables(); foreach (\array_keys($GLOBALS) as $key) { if ($key != 'GLOBALS' && !\in_array($key, $superGlobalArrays) && !$snapshot->blacklist()->isGlobalVariableBlacklisted($key)) { if (\array_key_exists($key, $globalVariables)) { $GLOBALS[$key] = $globalVariables[$key]; } else { unset($GLOBALS[$key]); } } } } /** * Restores all static attributes in user-defined classes from this snapshot. */ public function restoreStaticAttributes(Snapshot $snapshot) { $current = new Snapshot($snapshot->blacklist(), false, false, false, false, true, false, false, false, false); $newClasses = \array_diff($current->classes(), $snapshot->classes()); unset($current); foreach ($snapshot->staticAttributes() as $className => $staticAttributes) { foreach ($staticAttributes as $name => $value) { $reflector = new ReflectionProperty($className, $name); $reflector->setAccessible(true); $reflector->setValue($value); } } foreach ($newClasses as $className) { $class = new \ReflectionClass($className); $defaults = $class->getDefaultProperties(); foreach ($class->getProperties() as $attribute) { if (!$attribute->isStatic()) { continue; } $name = $attribute->getName(); if ($snapshot->blacklist()->isStaticAttributeBlacklisted($className, $name)) { continue; } if (!isset($defaults[$name])) { continue; } $attribute->setAccessible(true); $attribute->setValue($defaults[$name]); } } } /** * Restores a super-global variable array from this snapshot. */ private function restoreSuperGlobalArray(Snapshot $snapshot, string $superGlobalArray) { $superGlobalVariables = $snapshot->superGlobalVariables(); if (isset($GLOBALS[$superGlobalArray]) && \is_array($GLOBALS[$superGlobalArray]) && isset($superGlobalVariables[$superGlobalArray])) { $keys = \array_keys( \array_merge( $GLOBALS[$superGlobalArray], $superGlobalVariables[$superGlobalArray] ) ); foreach ($keys as $key) { if (isset($superGlobalVariables[$superGlobalArray][$key])) { $GLOBALS[$superGlobalArray][$key] = $superGlobalVariables[$superGlobalArray][$key]; } else { unset($GLOBALS[$superGlobalArray][$key]); } } } } } global-state-2.0.0/src/Snapshot.php000066400000000000000000000207541310041025600171660ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ declare(strict_types=1); namespace SebastianBergmann\GlobalState; use ReflectionClass; use Serializable; /** * A snapshot of global state. */ class Snapshot { /** * @var Blacklist */ private $blacklist; /** * @var array */ private $globalVariables = []; /** * @var array */ private $superGlobalArrays = []; /** * @var array */ private $superGlobalVariables = []; /** * @var array */ private $staticAttributes = []; /** * @var array */ private $iniSettings = []; /** * @var array */ private $includedFiles = []; /** * @var array */ private $constants = []; /** * @var array */ private $functions = []; /** * @var array */ private $interfaces = []; /** * @var array */ private $classes = []; /** * @var array */ private $traits = []; /** * Creates a snapshot of the current global state. */ public function __construct(Blacklist $blacklist = null, bool $includeGlobalVariables = true, bool $includeStaticAttributes = true, bool $includeConstants = true, bool $includeFunctions = true, bool $includeClasses = true, bool $includeInterfaces = true, bool $includeTraits = true, bool $includeIniSettings = true, bool $includeIncludedFiles = true) { if ($blacklist === null) { $blacklist = new Blacklist; } $this->blacklist = $blacklist; if ($includeConstants) { $this->snapshotConstants(); } if ($includeFunctions) { $this->snapshotFunctions(); } if ($includeClasses || $includeStaticAttributes) { $this->snapshotClasses(); } if ($includeInterfaces) { $this->snapshotInterfaces(); } if ($includeGlobalVariables) { $this->setupSuperGlobalArrays(); $this->snapshotGlobals(); } if ($includeStaticAttributes) { $this->snapshotStaticAttributes(); } if ($includeIniSettings) { $this->iniSettings = \ini_get_all(null, false); } if ($includeIncludedFiles) { $this->includedFiles = \get_included_files(); } $this->traits = \get_declared_traits(); } public function blacklist(): Blacklist { return $this->blacklist; } public function globalVariables(): array { return $this->globalVariables; } public function superGlobalVariables(): array { return $this->superGlobalVariables; } public function superGlobalArrays(): array { return $this->superGlobalArrays; } public function staticAttributes(): array { return $this->staticAttributes; } public function iniSettings(): array { return $this->iniSettings; } public function includedFiles(): array { return $this->includedFiles; } public function constants(): array { return $this->constants; } public function functions(): array { return $this->functions; } public function interfaces(): array { return $this->interfaces; } public function classes(): array { return $this->classes; } public function traits(): array { return $this->traits; } /** * Creates a snapshot user-defined constants. */ private function snapshotConstants() { $constants = \get_defined_constants(true); if (isset($constants['user'])) { $this->constants = $constants['user']; } } /** * Creates a snapshot user-defined functions. */ private function snapshotFunctions() { $functions = \get_defined_functions(); $this->functions = $functions['user']; } /** * Creates a snapshot user-defined classes. */ private function snapshotClasses() { foreach (\array_reverse(\get_declared_classes()) as $className) { $class = new ReflectionClass($className); if (!$class->isUserDefined()) { break; } $this->classes[] = $className; } $this->classes = \array_reverse($this->classes); } /** * Creates a snapshot user-defined interfaces. */ private function snapshotInterfaces() { foreach (\array_reverse(\get_declared_interfaces()) as $interfaceName) { $class = new ReflectionClass($interfaceName); if (!$class->isUserDefined()) { break; } $this->interfaces[] = $interfaceName; } $this->interfaces = \array_reverse($this->interfaces); } /** * Creates a snapshot of all global and super-global variables. */ private function snapshotGlobals() { $superGlobalArrays = $this->superGlobalArrays(); foreach ($superGlobalArrays as $superGlobalArray) { $this->snapshotSuperGlobalArray($superGlobalArray); } foreach (\array_keys($GLOBALS) as $key) { if ($key != 'GLOBALS' && !\in_array($key, $superGlobalArrays) && $this->canBeSerialized($GLOBALS[$key]) && !$this->blacklist->isGlobalVariableBlacklisted($key)) { $this->globalVariables[$key] = \unserialize(\serialize($GLOBALS[$key])); } } } /** * Creates a snapshot a super-global variable array. */ private function snapshotSuperGlobalArray(string $superGlobalArray) { $this->superGlobalVariables[$superGlobalArray] = []; if (isset($GLOBALS[$superGlobalArray]) && \is_array($GLOBALS[$superGlobalArray])) { foreach ($GLOBALS[$superGlobalArray] as $key => $value) { $this->superGlobalVariables[$superGlobalArray][$key] = \unserialize(\serialize($value)); } } } /** * Creates a snapshot of all static attributes in user-defined classes. */ private function snapshotStaticAttributes() { foreach ($this->classes as $className) { $class = new ReflectionClass($className); $snapshot = []; foreach ($class->getProperties() as $attribute) { if ($attribute->isStatic()) { $name = $attribute->getName(); if ($this->blacklist->isStaticAttributeBlacklisted($className, $name)) { continue; } $attribute->setAccessible(true); $value = $attribute->getValue(); if ($this->canBeSerialized($value)) { $snapshot[$name] = \unserialize(\serialize($value)); } } } if (!empty($snapshot)) { $this->staticAttributes[$className] = $snapshot; } } } /** * Returns a list of all super-global variable arrays. */ private function setupSuperGlobalArrays() { $this->superGlobalArrays = [ '_ENV', '_POST', '_GET', '_COOKIE', '_SERVER', '_FILES', '_REQUEST' ]; if (\ini_get('register_long_arrays') == '1') { $this->superGlobalArrays = \array_merge( $this->superGlobalArrays, [ 'HTTP_ENV_VARS', 'HTTP_POST_VARS', 'HTTP_GET_VARS', 'HTTP_COOKIE_VARS', 'HTTP_SERVER_VARS', 'HTTP_POST_FILES' ] ); } } /** * @todo Implement this properly */ private function canBeSerialized($variable): bool { if (!\is_object($variable)) { return !\is_resource($variable); } if ($variable instanceof \stdClass) { return true; } $class = new ReflectionClass($variable); do { if ($class->isInternal()) { return $variable instanceof Serializable; } } while ($class = $class->getParentClass()); return true; } } global-state-2.0.0/src/exceptions/000077500000000000000000000000001310041025600170275ustar00rootroot00000000000000global-state-2.0.0/src/exceptions/Exception.php000066400000000000000000000005201310041025600214730ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ declare(strict_types=1); namespace SebastianBergmann\GlobalState; interface Exception { } global-state-2.0.0/src/exceptions/RuntimeException.php000066400000000000000000000006021310041025600230400ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ declare(strict_types=1); namespace SebastianBergmann\GlobalState; class RuntimeException extends \RuntimeException implements Exception { } global-state-2.0.0/tests/000077500000000000000000000000001310041025600152215ustar00rootroot00000000000000global-state-2.0.0/tests/BlacklistTest.php000066400000000000000000000062461310041025600205120ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ declare(strict_types=1); namespace SebastianBergmann\GlobalState; use PHPUnit\Framework\TestCase; use SebastianBergmann\GlobalState\TestFixture\BlacklistedChildClass; use SebastianBergmann\GlobalState\TestFixture\BlacklistedClass; use SebastianBergmann\GlobalState\TestFixture\BlacklistedImplementor; use SebastianBergmann\GlobalState\TestFixture\BlacklistedInterface; /** * @covers \SebastianBergmann\GlobalState\Blacklist */ class BlacklistTest extends TestCase { /** * @var \SebastianBergmann\GlobalState\Blacklist */ private $blacklist; protected function setUp() { $this->blacklist = new Blacklist; } public function testGlobalVariableThatIsNotBlacklistedIsNotTreatedAsBlacklisted() { $this->assertFalse($this->blacklist->isGlobalVariableBlacklisted('variable')); } public function testGlobalVariableCanBeBlacklisted() { $this->blacklist->addGlobalVariable('variable'); $this->assertTrue($this->blacklist->isGlobalVariableBlacklisted('variable')); } public function testStaticAttributeThatIsNotBlacklistedIsNotTreatedAsBlacklisted() { $this->assertFalse( $this->blacklist->isStaticAttributeBlacklisted( BlacklistedClass::class, 'attribute' ) ); } public function testClassCanBeBlacklisted() { $this->blacklist->addClass(BlacklistedClass::class); $this->assertTrue( $this->blacklist->isStaticAttributeBlacklisted( BlacklistedClass::class, 'attribute' ) ); } public function testSubclassesCanBeBlacklisted() { $this->blacklist->addSubclassesOf(BlacklistedClass::class); $this->assertTrue( $this->blacklist->isStaticAttributeBlacklisted( BlacklistedChildClass::class, 'attribute' ) ); } public function testImplementorsCanBeBlacklisted() { $this->blacklist->addImplementorsOf(BlacklistedInterface::class); $this->assertTrue( $this->blacklist->isStaticAttributeBlacklisted( BlacklistedImplementor::class, 'attribute' ) ); } public function testClassNamePrefixesCanBeBlacklisted() { $this->blacklist->addClassNamePrefix('SebastianBergmann\GlobalState'); $this->assertTrue( $this->blacklist->isStaticAttributeBlacklisted( BlacklistedClass::class, 'attribute' ) ); } public function testStaticAttributeCanBeBlacklisted() { $this->blacklist->addStaticAttribute( BlacklistedClass::class, 'attribute' ); $this->assertTrue( $this->blacklist->isStaticAttributeBlacklisted( BlacklistedClass::class, 'attribute' ) ); } } global-state-2.0.0/tests/CodeExporterTest.php000066400000000000000000000016271310041025600212030ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ declare(strict_types=1); namespace SebastianBergmann\GlobalState; use PHPUnit\Framework\TestCase; /** * @covers \SebastianBergmann\GlobalState\CodeExporter */ class CodeExporterTest extends TestCase { /** * @runInSeparateProcess */ public function testCanExportGlobalVariablesToCode() { $GLOBALS = ['foo' => 'bar']; $snapshot = new Snapshot(null, true, false, false, false, false, false, false, false, false); $exporter = new CodeExporter; $this->assertEquals( '$GLOBALS = [];' . PHP_EOL . '$GLOBALS[\'foo\'] = \'bar\';' . PHP_EOL, $exporter->globalVariables($snapshot) ); } } global-state-2.0.0/tests/RestorerTest.php000066400000000000000000000102571310041025600204040ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ declare(strict_types=1); namespace SebastianBergmann\GlobalState; use PHPUnit\Framework\TestCase; /** * Class Restorer. */ class RestorerTest extends TestCase { public static function setUpBeforeClass() { $GLOBALS['varBool'] = false; $GLOBALS['varNull'] = null; $_GET['varGet'] = 0; } /** * Check global variables are correctly backuped and restored (unit test). * * @covers \SebastianBergmann\GlobalState\Restorer::restoreGlobalVariables * @covers \SebastianBergmann\GlobalState\Restorer::restoreSuperGlobalArray * * @uses \SebastianBergmann\GlobalState\Blacklist::isGlobalVariableBlacklisted * @uses \SebastianBergmann\GlobalState\Snapshot::__construct * @uses \SebastianBergmann\GlobalState\Snapshot::blacklist * @uses \SebastianBergmann\GlobalState\Snapshot::canBeSerialized * @uses \SebastianBergmann\GlobalState\Snapshot::globalVariables * @uses \SebastianBergmann\GlobalState\Snapshot::setupSuperGlobalArrays * @uses \SebastianBergmann\GlobalState\Snapshot::snapshotGlobals * @uses \SebastianBergmann\GlobalState\Snapshot::snapshotSuperGlobalArray * @uses \SebastianBergmann\GlobalState\Snapshot::superGlobalArrays * @uses \SebastianBergmann\GlobalState\Snapshot::superGlobalVariables */ public function testRestorerGlobalVariable() { $snapshot = new Snapshot(null, true, false, false, false, false, false, false, false, false); $restorer = new Restorer; $restorer->restoreGlobalVariables($snapshot); $this->assertArrayHasKey('varBool', $GLOBALS); $this->assertEquals(false, $GLOBALS['varBool']); $this->assertArrayHasKey('varNull', $GLOBALS); $this->assertEquals(null, $GLOBALS['varNull']); $this->assertArrayHasKey('varGet', $_GET); $this->assertEquals(0, $_GET['varGet']); } /** * Check global variables are correctly backuped and restored. * * The real test is the second, but the first has to be executed to backup the globals. * * @backupGlobals enabled * @covers \SebastianBergmann\GlobalState\Restorer::restoreGlobalVariables * @covers \SebastianBergmann\GlobalState\Restorer::restoreSuperGlobalArray * * @uses \SebastianBergmann\GlobalState\Blacklist::addClassNamePrefix * @uses \SebastianBergmann\GlobalState\Blacklist::isGlobalVariableBlacklisted * @uses \SebastianBergmann\GlobalState\Snapshot::__construct * @uses \SebastianBergmann\GlobalState\Snapshot::blacklist * @uses \SebastianBergmann\GlobalState\Snapshot::canBeSerialized * @uses \SebastianBergmann\GlobalState\Snapshot::globalVariables * @uses \SebastianBergmann\GlobalState\Snapshot::setupSuperGlobalArrays * @uses \SebastianBergmann\GlobalState\Snapshot::snapshotGlobals * @uses \SebastianBergmann\GlobalState\Snapshot::snapshotSuperGlobalArray * @uses \SebastianBergmann\GlobalState\Snapshot::superGlobalArrays * @uses \SebastianBergmann\GlobalState\Snapshot::superGlobalVariables */ public function testIntegrationRestorerGlobalVariables() { $this->assertArrayHasKey('varBool', $GLOBALS); $this->assertEquals(false, $GLOBALS['varBool']); $this->assertArrayHasKey('varNull', $GLOBALS); $this->assertEquals(null, $GLOBALS['varNull']); $this->assertArrayHasKey('varGet', $_GET); $this->assertEquals(0, $_GET['varGet']); } /** * Check global variables are correctly backuped and restored. * * @depends testIntegrationRestorerGlobalVariables */ public function testIntegrationRestorerGlobalVariables2() { $this->assertArrayHasKey('varBool', $GLOBALS); $this->assertEquals(false, $GLOBALS['varBool']); $this->assertArrayHasKey('varNull', $GLOBALS); $this->assertEquals(null, $GLOBALS['varNull']); $this->assertArrayHasKey('varGet', $_GET); $this->assertEquals(0, $_GET['varGet']); } } global-state-2.0.0/tests/SnapshotTest.php000066400000000000000000000072411310041025600203750ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ declare(strict_types=1); namespace SebastianBergmann\GlobalState; use ArrayObject; use PHPUnit\Framework\TestCase; use SebastianBergmann\GlobalState\TestFixture\BlacklistedInterface; use SebastianBergmann\GlobalState\TestFixture\SnapshotClass; use SebastianBergmann\GlobalState\TestFixture\SnapshotTrait; /** * @covers \SebastianBergmann\GlobalState\Snapshot */ class SnapshotTest extends TestCase { /** * @var Blacklist */ private $blacklist; protected function setUp() { $this->blacklist = $this->createMock(Blacklist::class); } public function testStaticAttributes() { $this->blacklist->method('isStaticAttributeBlacklisted')->willReturnCallback( function ($class) { return $class !== SnapshotClass::class; } ); SnapshotClass::init(); $snapshot = new Snapshot($this->blacklist, false, true, false, false, false, false, false, false, false); $expected = [ SnapshotClass::class => [ 'string' => 'snapshot', 'arrayObject' => new ArrayObject([1, 2, 3]), 'stdClass' => new \stdClass(), ] ]; $this->assertEquals($expected, $snapshot->staticAttributes()); } public function testConstants() { $snapshot = new Snapshot($this->blacklist, false, false, true, false, false, false, false, false, false); $this->assertArrayHasKey('GLOBALSTATE_TESTSUITE', $snapshot->constants()); } public function testFunctions() { $snapshot = new Snapshot($this->blacklist, false, false, false, true, false, false, false, false, false); $functions = $snapshot->functions(); $this->assertContains('sebastianbergmann\globalstate\testfixture\snapshotfunction', $functions); $this->assertNotContains('assert', $functions); } public function testClasses() { $snapshot = new Snapshot($this->blacklist, false, false, false, false, true, false, false, false, false); $classes = $snapshot->classes(); $this->assertContains(TestCase::class, $classes); $this->assertNotContains(Exception::class, $classes); } public function testInterfaces() { $snapshot = new Snapshot($this->blacklist, false, false, false, false, false, true, false, false, false); $interfaces = $snapshot->interfaces(); $this->assertContains(BlacklistedInterface::class, $interfaces); $this->assertNotContains(\Countable::class, $interfaces); } public function testTraits() { \spl_autoload_call('SebastianBergmann\GlobalState\TestFixture\SnapshotTrait'); $snapshot = new Snapshot($this->blacklist, false, false, false, false, false, false, true, false, false); $this->assertContains(SnapshotTrait::class, $snapshot->traits()); } public function testIniSettings() { $snapshot = new Snapshot($this->blacklist, false, false, false, false, false, false, false, true, false); $iniSettings = $snapshot->iniSettings(); $this->assertArrayHasKey('date.timezone', $iniSettings); $this->assertEquals('Etc/UTC', $iniSettings['date.timezone']); } public function testIncludedFiles() { $snapshot = new Snapshot($this->blacklist, false, false, false, false, false, false, false, false, true); $this->assertContains(__FILE__, $snapshot->includedFiles()); } } global-state-2.0.0/tests/_fixture/000077500000000000000000000000001310041025600170465ustar00rootroot00000000000000global-state-2.0.0/tests/_fixture/BlacklistedChildClass.php000066400000000000000000000005751310041025600237410ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ declare(strict_types=1); namespace SebastianBergmann\GlobalState\TestFixture; class BlacklistedChildClass extends BlacklistedClass { } global-state-2.0.0/tests/_fixture/BlacklistedClass.php000066400000000000000000000005761310041025600227760ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ declare(strict_types=1); namespace SebastianBergmann\GlobalState\TestFixture; class BlacklistedClass { private static $attribute; } global-state-2.0.0/tests/_fixture/BlacklistedImplementor.php000066400000000000000000000006441310041025600242200ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ declare(strict_types=1); namespace SebastianBergmann\GlobalState\TestFixture; class BlacklistedImplementor implements BlacklistedInterface { private static $attribute; } global-state-2.0.0/tests/_fixture/BlacklistedInterface.php000066400000000000000000000005471310041025600236270ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ declare(strict_types=1); namespace SebastianBergmann\GlobalState\TestFixture; interface BlacklistedInterface { } global-state-2.0.0/tests/_fixture/SnapshotClass.php000066400000000000000000000017711310041025600223520ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ declare(strict_types=1); namespace SebastianBergmann\GlobalState\TestFixture; use DomDocument; use ArrayObject; class SnapshotClass { private static $string = 'snapshot'; private static $dom; private static $closure; private static $arrayObject; private static $snapshotDomDocument; private static $resource; private static $stdClass; public static function init() { self::$dom = new DomDocument(); self::$closure = function () {}; self::$arrayObject = new ArrayObject([1, 2, 3]); self::$snapshotDomDocument = new SnapshotDomDocument(); self::$resource = \fopen('php://memory', 'r'); self::$stdClass = new \stdClass(); } } global-state-2.0.0/tests/_fixture/SnapshotDomDocument.php000066400000000000000000000006101310041025600235120ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ declare(strict_types=1); namespace SebastianBergmann\GlobalState\TestFixture; use DomDocument; class SnapshotDomDocument extends DomDocument { } global-state-2.0.0/tests/_fixture/SnapshotFunctions.php000066400000000000000000000005441310041025600232520ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ declare(strict_types=1); namespace SebastianBergmann\GlobalState\TestFixture; function snapshotFunction() { } global-state-2.0.0/tests/_fixture/SnapshotTrait.php000066400000000000000000000005341310041025600223640ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ declare(strict_types=1); namespace SebastianBergmann\GlobalState\TestFixture; trait SnapshotTrait { }