daniel/dumbo
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

the whole shebang

Browse Source
This commit is contained in:
Daniel
2014-11-25 16:42:40 +01:00
parent 7f74c0613e
commit ab1334c0cf
3686 changed files with 496409 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

91
vendor/nikic/php-parser/test/PHPParser/Tests/Builder/ClassTest.php vendored Normal file
View File

@@ -0,0 +1,91 @@
<?php
class PHPParser_Tests_Builder_ClassTest extends PHPUnit_Framework_TestCase
{
protected function createClassBuilder($class) {
return new PHPParser_Builder_Class($class);
}
public function testExtendsImplements() {
$node = $this->createClassBuilder('SomeLogger')
->extend('BaseLogger')
->implement('Namespaced\Logger', new PHPParser_Node_Name('SomeInterface'))
->getNode()
;
$this->assertEquals(
new PHPParser_Node_Stmt_Class('SomeLogger', array(
'extends' => new PHPParser_Node_Name('BaseLogger'),
'implements' => array(
new PHPParser_Node_Name('Namespaced\Logger'),
new PHPParser_Node_Name('SomeInterface')
),
)),
$node
);
}
public function testAbstract() {
$node = $this->createClassBuilder('Test')
->makeAbstract()
->getNode()
;
$this->assertEquals(
new PHPParser_Node_Stmt_Class('Test', array(
'type' => PHPParser_Node_Stmt_Class::MODIFIER_ABSTRACT
)),
$node
);
}
public function testFinal() {
$node = $this->createClassBuilder('Test')
->makeFinal()
->getNode()
;
$this->assertEquals(
new PHPParser_Node_Stmt_Class('Test', array(
'type' => PHPParser_Node_Stmt_Class::MODIFIER_FINAL
)),
$node
);
}
public function testStatementOrder() {
$method = new PHPParser_Node_Stmt_ClassMethod('testMethod');
$property = new PHPParser_Node_Stmt_Property(
PHPParser_Node_Stmt_Class::MODIFIER_PUBLIC,
array(new PHPParser_Node_Stmt_PropertyProperty('testProperty'))
);
$const = new PHPParser_Node_Stmt_ClassConst(array(
new PHPParser_Node_Const('TEST_CONST', new PHPParser_Node_Scalar_String('ABC'))
));
$use = new PHPParser_Node_Stmt_TraitUse(array(new PHPParser_Node_Name('SomeTrait')));
$node = $this->createClassBuilder('Test')
->addStmt($method)
->addStmt($property)
->addStmts(array($const, $use))
->getNode()
;
$this->assertEquals(
new PHPParser_Node_Stmt_Class('Test', array(
'stmts' => array($use, $const, $property, $method)
)),
$node
);
}
/**
* @expectedException LogicException
* @expectedExceptionMessage Unexpected node of type "Stmt_Echo"
*/
public function testInvalidStmtError() {
$this->createClassBuilder('Test')
->addStmt(new PHPParser_Node_Stmt_Echo(array()))
;
}
}

70
vendor/nikic/php-parser/test/PHPParser/Tests/Builder/FunctionTest.php vendored Normal file
View File

@@ -0,0 +1,70 @@
<?php
class PHPParser_Tests_Builder_FunctionTest extends PHPUnit_Framework_TestCase
{
public function createFunctionBuilder($name) {
return new PHPParser_Builder_Function($name);
}
public function testReturnByRef() {
$node = $this->createFunctionBuilder('test')
->makeReturnByRef()
->getNode()
;
$this->assertEquals(
new PHPParser_Node_Stmt_Function('test', array(
'byRef' => true
)),
$node
);
}
public function testParams() {
$param1 = new PHPParser_Node_Param('test1');
$param2 = new PHPParser_Node_Param('test2');
$param3 = new PHPParser_Node_Param('test3');
$node = $this->createFunctionBuilder('test')
->addParam($param1)
->addParams(array($param2, $param3))
->getNode()
;
$this->assertEquals(
new PHPParser_Node_Stmt_Function('test', array(
'params' => array($param1, $param2, $param3)
)),
$node
);
}
public function testStmts() {
$stmt1 = new PHPParser_Node_Expr_Print(new PHPParser_Node_Scalar_String('test1'));
$stmt2 = new PHPParser_Node_Expr_Print(new PHPParser_Node_Scalar_String('test2'));
$stmt3 = new PHPParser_Node_Expr_Print(new PHPParser_Node_Scalar_String('test3'));
$node = $this->createFunctionBuilder('test')
->addStmt($stmt1)
->addStmts(array($stmt2, $stmt3))
->getNode()
;
$this->assertEquals(
new PHPParser_Node_Stmt_Function('test', array(
'stmts' => array($stmt1, $stmt2, $stmt3)
)),
$node
);
}
/**
* @expectedException LogicException
* @expectedExceptionMessage Expected parameter node, got "Name"
*/
public function testInvalidParamError() {
$this->createFunctionBuilder('test')
->addParam(new PHPParser_Node_Name('foo'))
;
}
}

91
vendor/nikic/php-parser/test/PHPParser/Tests/Builder/InterfaceTest.php vendored Normal file
View File

@@ -0,0 +1,91 @@
<?php
/**
* This class unit-tests the interface builder
*/
class PHPParser_Tests_Builder_InterfaceTest extends PHPUnit_Framework_TestCase
{
/** @var PHPParser_Builder_Interface */
protected $builder;
protected function setUp() {
$this->builder = new PHPParser_Builder_Interface('Contract');
}
private function dump($node) {
$pp = new PHPParser_PrettyPrinter_Default();
return $pp->prettyPrint(array($node));
}
public function testEmpty() {
$contract = $this->builder->getNode();
$this->assertInstanceOf('PHPParser_Node_Stmt_Interface', $contract);
$this->assertEquals('Contract', $contract->name);
}
public function testExtending() {
$contract = $this->builder->extend('Space\Root1', 'Root2')->getNode();
$this->assertEquals(
new PHPParser_Node_Stmt_Interface('Contract', array(
'extends' => array(
new PHPParser_Node_Name('Space\Root1'),
new PHPParser_Node_Name('Root2')
),
)), $contract
);
}
public function testAddMethod() {
$method = new PHPParser_Node_Stmt_ClassMethod('doSomething');
$contract = $this->builder->addStmt($method)->getNode();
$this->assertEquals(array($method), $contract->stmts);
}
public function testAddConst() {
$const = new PHPParser_Node_Stmt_ClassConst(array(
new PHPParser_Node_Const('SPEED_OF_LIGHT', new PHPParser_Node_Scalar_DNumber(299792458))
));
$contract = $this->builder->addStmt($const)->getNode();
$this->assertEquals(299792458, $contract->stmts[0]->consts[0]->value->value);
}
public function testOrder() {
$const = new PHPParser_Node_Stmt_ClassConst(array(
new PHPParser_Node_Const('SPEED_OF_LIGHT', new PHPParser_Node_Scalar_DNumber(299792458))
));
$method = new PHPParser_Node_Stmt_ClassMethod('doSomething');
$contract = $this->builder
->addStmt($method)
->addStmt($const)
->getNode()
;
$this->assertInstanceOf('PHPParser_Node_Stmt_ClassConst', $contract->stmts[0]);
$this->assertInstanceOf('PHPParser_Node_Stmt_ClassMethod', $contract->stmts[1]);
}
/**
* @expectedException LogicException
* @expectedExceptionMessage Unexpected node of type "Stmt_PropertyProperty"
*/
public function testInvalidStmtError() {
$this->builder->addStmt(new PHPParser_Node_Stmt_PropertyProperty('invalid'));
}
public function testFullFunctional() {
$const = new PHPParser_Node_Stmt_ClassConst(array(
new PHPParser_Node_Const('SPEED_OF_LIGHT', new PHPParser_Node_Scalar_DNumber(299792458))
));
$method = new PHPParser_Node_Stmt_ClassMethod('doSomething');
$contract = $this->builder
->addStmt($method)
->addStmt($const)
->getNode()
;
eval($this->dump($contract));
$this->assertTrue(interface_exists('Contract', false));
}
}

137
vendor/nikic/php-parser/test/PHPParser/Tests/Builder/MethodTest.php vendored Normal file
View File

@@ -0,0 +1,137 @@
<?php
class PHPParser_Tests_Builder_MethodTest extends PHPUnit_Framework_TestCase
{
public function createMethodBuilder($name) {
return new PHPParser_Builder_Method($name);
}
public function testModifiers() {
$node = $this->createMethodBuilder('test')
->makePublic()
->makeAbstract()
->makeStatic()
->getNode()
;
$this->assertEquals(
new PHPParser_Node_Stmt_ClassMethod('test', array(
'type' => PHPParser_Node_Stmt_Class::MODIFIER_PUBLIC
| PHPParser_Node_Stmt_Class::MODIFIER_ABSTRACT
| PHPParser_Node_Stmt_Class::MODIFIER_STATIC,
'stmts' => null,
)),
$node
);
$node = $this->createMethodBuilder('test')
->makeProtected()
->makeFinal()
->getNode()
;
$this->assertEquals(
new PHPParser_Node_Stmt_ClassMethod('test', array(
'type' => PHPParser_Node_Stmt_Class::MODIFIER_PROTECTED
| PHPParser_Node_Stmt_Class::MODIFIER_FINAL
)),
$node
);
$node = $this->createMethodBuilder('test')
->makePrivate()
->getNode()
;
$this->assertEquals(
new PHPParser_Node_Stmt_ClassMethod('test', array(
'type' => PHPParser_Node_Stmt_Class::MODIFIER_PRIVATE
)),
$node
);
}
public function testReturnByRef() {
$node = $this->createMethodBuilder('test')
->makeReturnByRef()
->getNode()
;
$this->assertEquals(
new PHPParser_Node_Stmt_ClassMethod('test', array(
'byRef' => true
)),
$node
);
}
public function testParams() {
$param1 = new PHPParser_Node_Param('test1');
$param2 = new PHPParser_Node_Param('test2');
$param3 = new PHPParser_Node_Param('test3');
$node = $this->createMethodBuilder('test')
->addParam($param1)
->addParams(array($param2, $param3))
->getNode()
;
$this->assertEquals(
new PHPParser_Node_Stmt_ClassMethod('test', array(
'params' => array($param1, $param2, $param3)
)),
$node
);
}
public function testStmts() {
$stmt1 = new PHPParser_Node_Expr_Print(new PHPParser_Node_Scalar_String('test1'));
$stmt2 = new PHPParser_Node_Expr_Print(new PHPParser_Node_Scalar_String('test2'));
$stmt3 = new PHPParser_Node_Expr_Print(new PHPParser_Node_Scalar_String('test3'));
$node = $this->createMethodBuilder('test')
->addStmt($stmt1)
->addStmts(array($stmt2, $stmt3))
->getNode()
;
$this->assertEquals(
new PHPParser_Node_Stmt_ClassMethod('test', array(
'stmts' => array($stmt1, $stmt2, $stmt3)
)),
$node
);
}
/**
* @expectedException LogicException
* @expectedExceptionMessage Cannot add statements to an abstract method
*/
public function testAddStmtToAbstractMethodError() {
$this->createMethodBuilder('test')
->makeAbstract()
->addStmt(new PHPParser_Node_Expr_Print(new PHPParser_Node_Scalar_String('test')))
;
}
/**
* @expectedException LogicException
* @expectedExceptionMessage Cannot make method with statements abstract
*/
public function testMakeMethodWithStmtsAbstractError() {
$this->createMethodBuilder('test')
->addStmt(new PHPParser_Node_Expr_Print(new PHPParser_Node_Scalar_String('test')))
->makeAbstract()
;
}
/**
* @expectedException LogicException
* @expectedExceptionMessage Expected parameter node, got "Name"
*/
public function testInvalidParamError() {
$this->createMethodBuilder('test')
->addParam(new PHPParser_Node_Name('foo'))
;
}
}

118
vendor/nikic/php-parser/test/PHPParser/Tests/Builder/ParamTest.php vendored Normal file
View File

@@ -0,0 +1,118 @@
<?php
class PHPParser_Tests_Builder_ParamTest extends PHPUnit_Framework_TestCase
{
public function createParamBuilder($name) {
return new PHPParser_Builder_Param($name);
}
/**
* @dataProvider provideTestDefaultValues
*/
public function testDefaultValues($value, $expectedValueNode) {
$node = $this->createParamBuilder('test')
->setDefault($value)
->getNode()
;
$this->assertEquals($expectedValueNode, $node->default);
}
public function provideTestDefaultValues() {
return array(
array(
null,
new PHPParser_Node_Expr_ConstFetch(new PHPParser_Node_Name('null'))
),
array(
true,
new PHPParser_Node_Expr_ConstFetch(new PHPParser_Node_Name('true'))
),
array(
false,
new PHPParser_Node_Expr_ConstFetch(new PHPParser_Node_Name('false'))
),
array(
31415,
new PHPParser_Node_Scalar_LNumber(31415)
),
array(
3.1415,
new PHPParser_Node_Scalar_DNumber(3.1415)
),
array(
'Hallo World',
new PHPParser_Node_Scalar_String('Hallo World')
),
array(
array(1, 2, 3),
new PHPParser_Node_Expr_Array(array(
new PHPParser_Node_Expr_ArrayItem(new PHPParser_Node_Scalar_LNumber(1)),
new PHPParser_Node_Expr_ArrayItem(new PHPParser_Node_Scalar_LNumber(2)),
new PHPParser_Node_Expr_ArrayItem(new PHPParser_Node_Scalar_LNumber(3)),
))
),
array(
array('foo' => 'bar', 'bar' => 'foo'),
new PHPParser_Node_Expr_Array(array(
new PHPParser_Node_Expr_ArrayItem(
new PHPParser_Node_Scalar_String('bar'),
new PHPParser_Node_Scalar_String('foo')
),
new PHPParser_Node_Expr_ArrayItem(
new PHPParser_Node_Scalar_String('foo'),
new PHPParser_Node_Scalar_String('bar')
),
))
),
array(
new PHPParser_Node_Scalar_DirConst,
new PHPParser_Node_Scalar_DirConst
)
);
}
public function testTypeHints() {
$node = $this->createParamBuilder('test')
->setTypeHint('array')
->getNode()
;
$this->assertEquals(
new PHPParser_Node_Param('test', null, 'array'),
$node
);
$node = $this->createParamBuilder('test')
->setTypeHint('callable')
->getNode()
;
$this->assertEquals(
new PHPParser_Node_Param('test', null, 'callable'),
$node
);
$node = $this->createParamBuilder('test')
->setTypeHint('Some\Class')
->getNode()
;
$this->assertEquals(
new PHPParser_Node_Param('test', null, new PHPParser_Node_Name('Some\Class')),
$node
);
}
public function testByRef() {
$node = $this->createParamBuilder('test')
->makeByRef()
->getNode()
;
$this->assertEquals(
new PHPParser_Node_Param('test', null, null, true),
$node
);
}
}

123
vendor/nikic/php-parser/test/PHPParser/Tests/Builder/PropertyTest.php vendored Normal file
View File

@@ -0,0 +1,123 @@
<?php
class PHPParser_Tests_Builder_PropertyTest extends PHPUnit_Framework_TestCase
{
public function createPropertyBuilder($name) {
return new PHPParser_Builder_Property($name);
}
public function testModifiers() {
$node = $this->createPropertyBuilder('test')
->makePrivate()
->makeStatic()
->getNode()
;
$this->assertEquals(
new PHPParser_Node_Stmt_Property(
PHPParser_Node_Stmt_Class::MODIFIER_PRIVATE
| PHPParser_Node_Stmt_Class::MODIFIER_STATIC,
array(
new PHPParser_Node_Stmt_PropertyProperty('test')
)
),
$node
);
$node = $this->createPropertyBuilder('test')
->makeProtected()
->getNode()
;
$this->assertEquals(
new PHPParser_Node_Stmt_Property(
PHPParser_Node_Stmt_Class::MODIFIER_PROTECTED,
array(
new PHPParser_Node_Stmt_PropertyProperty('test')
)
),
$node
);
$node = $this->createPropertyBuilder('test')
->makePublic()
->getNode()
;
$this->assertEquals(
new PHPParser_Node_Stmt_Property(
PHPParser_Node_Stmt_Class::MODIFIER_PUBLIC,
array(
new PHPParser_Node_Stmt_PropertyProperty('test')
)
),
$node
);
}
/**
* @dataProvider provideTestDefaultValues
*/
public function testDefaultValues($value, $expectedValueNode) {
$node = $this->createPropertyBuilder('test')
->setDefault($value)
->getNode()
;
$this->assertEquals($expectedValueNode, $node->props[0]->default);
}
public function provideTestDefaultValues() {
return array(
array(
null,
new PHPParser_Node_Expr_ConstFetch(new PHPParser_Node_Name('null'))
),
array(
true,
new PHPParser_Node_Expr_ConstFetch(new PHPParser_Node_Name('true'))
),
array(
false,
new PHPParser_Node_Expr_ConstFetch(new PHPParser_Node_Name('false'))
),
array(
31415,
new PHPParser_Node_Scalar_LNumber(31415)
),
array(
3.1415,
new PHPParser_Node_Scalar_DNumber(3.1415)
),
array(
'Hallo World',
new PHPParser_Node_Scalar_String('Hallo World')
),
array(
array(1, 2, 3),
new PHPParser_Node_Expr_Array(array(
new PHPParser_Node_Expr_ArrayItem(new PHPParser_Node_Scalar_LNumber(1)),
new PHPParser_Node_Expr_ArrayItem(new PHPParser_Node_Scalar_LNumber(2)),
new PHPParser_Node_Expr_ArrayItem(new PHPParser_Node_Scalar_LNumber(3)),
))
),
array(
array('foo' => 'bar', 'bar' => 'foo'),
new PHPParser_Node_Expr_Array(array(
new PHPParser_Node_Expr_ArrayItem(
new PHPParser_Node_Scalar_String('bar'),
new PHPParser_Node_Scalar_String('foo')
),
new PHPParser_Node_Expr_ArrayItem(
new PHPParser_Node_Scalar_String('foo'),
new PHPParser_Node_Scalar_String('bar')
),
))
),
array(
new PHPParser_Node_Scalar_DirConst,
new PHPParser_Node_Scalar_DirConst
)
);
}
}

23
vendor/nikic/php-parser/test/PHPParser/Tests/BuilderFactoryTest.php vendored Normal file
View File

@@ -0,0 +1,23 @@
<?php
class PHPParser_Tests_BuilderFactoryTest extends PHPUnit_Framework_TestCase
{
/**
* @dataProvider provideTestFactory
*/
public function testFactory($methodName, $className) {
$factory = new PHPParser_BuilderFactory;
$this->assertInstanceOf($className, $factory->$methodName('test'));
}
public function provideTestFactory() {
return array(
array('class', 'PHPParser_Builder_Class'),
array('interface', 'PHPParser_Builder_Interface'),
array('method', 'PHPParser_Builder_Method'),
array('function', 'PHPParser_Builder_Function'),
array('property', 'PHPParser_Builder_Property'),
array('param', 'PHPParser_Builder_Param'),
);
}
}

51
vendor/nikic/php-parser/test/PHPParser/Tests/CodeTestAbstract.php vendored Normal file
View File

@@ -0,0 +1,51 @@
<?php
abstract class PHPParser_Tests_CodeTestAbstract extends PHPUnit_Framework_TestCase
{
protected function getTests($directory, $fileExtension) {
$it = new RecursiveDirectoryIterator($directory);
$it = new RecursiveIteratorIterator($it, RecursiveIteratorIterator::LEAVES_ONLY);
$it = new RegexIterator($it, '(\.' . preg_quote($fileExtension) . '$)');
$tests = array();
foreach ($it as $file) {
// read file
$fileContents = file_get_contents($file);
// evaluate @@{expr}@@ expressions
$fileContents = preg_replace_callback(
'/@@\{(.*?)\}@@/',
array($this, 'evalCallback'),
$fileContents
);
// parse sections
$parts = array_map('trim', explode('-----', $fileContents));
// first part is the name
$name = array_shift($parts);
// multiple sections possible with always two forming a pair
foreach (array_chunk($parts, 2) as $chunk) {
$tests[] = array($name, $chunk[0], $chunk[1]);
}
}
return $tests;
}
protected function evalCallback($matches) {
return eval('return ' . $matches[1] . ';');
}
protected function canonicalize($str) {
// trim from both sides
$str = trim($str);
// normalize EOL to \n
$str = str_replace(array("\r\n", "\r"), "\n", $str);
// trim right side of all lines
return implode("\n", array_map('rtrim', explode("\n", $str)));
}
}

69
vendor/nikic/php-parser/test/PHPParser/Tests/CommentTest.php vendored Normal file
View File

@@ -0,0 +1,69 @@
<?php
class PHPParser_Tests_CommentTest extends PHPUnit_Framework_TestCase
{
public function testGetSet() {
$comment = new PHPParser_Comment('/* Some comment */', 1);
$this->assertEquals('/* Some comment */', $comment->getText());
$this->assertEquals('/* Some comment */', (string) $comment);
$this->assertEquals(1, $comment->getLine());
$comment->setText('/* Some other comment */');
$comment->setLine(10);
$this->assertEquals('/* Some other comment */', $comment->getText());
$this->assertEquals('/* Some other comment */', (string) $comment);
$this->assertEquals(10, $comment->getLine());
}
/**
* @dataProvider provideTestReformatting
*/
public function testReformatting($commentText, $reformattedText) {
$comment = new PHPParser_Comment($commentText);
$this->assertEquals($reformattedText, $comment->getReformattedText());
}
public function provideTestReformatting() {
return array(
array('// Some text' . "\n", '// Some text'),
array('/* Some text */', '/* Some text */'),
array(
'/**
* Some text.
* Some more text.
*/',
'/**
* Some text.
* Some more text.
*/'
),
array(
'/*
Some text.
Some more text.
*/',
'/*
Some text.
Some more text.
*/'
),
array(
'/* Some text.
More text.
Even more text. */',
'/* Some text.
More text.
Even more text. */'
),
// invalid comment -> no reformatting
array(
'hallo
world',
'hallo
world',
),
);
}
}

33
vendor/nikic/php-parser/test/PHPParser/Tests/ErrorTest.php vendored Normal file
View File

@@ -0,0 +1,33 @@
<?php
class PHPParser_Tests_ErrorTest extends PHPUnit_Framework_TestCase
{
public function testConstruct() {
$error = new PHPParser_Error('Some error', 10);
$this->assertEquals('Some error', $error->getRawMessage());
$this->assertEquals(10, $error->getRawLine());
$this->assertEquals('Some error on line 10', $error->getMessage());
return $error;
}
/**
* @depends testConstruct
*/
public function testSetMessageAndLine(PHPParser_Error $error) {
$error->setRawMessage('Some other error');
$error->setRawLine(15);
$this->assertEquals('Some other error', $error->getRawMessage());
$this->assertEquals(15, $error->getRawLine());
$this->assertEquals('Some other error on line 15', $error->getMessage());
}
public function testUnknownLine() {
$error = new PHPParser_Error('Some error');
$this->assertEquals(-1, $error->getRawLine());
$this->assertEquals('Some error on unknown line', $error->getMessage());
}
}

103
vendor/nikic/php-parser/test/PHPParser/Tests/Lexer/EmulativeTest.php vendored Normal file
View File

@@ -0,0 +1,103 @@
<?php
class PHPParser_Tests_Lexer_EmulativeTest extends PHPUnit_Framework_TestCase
{
/** @var PHPParser_Lexer_Emulative */
protected $lexer;
protected function setUp() {
$this->lexer = new PHPParser_Lexer_Emulative;
}
/**
* @dataProvider provideTestReplaceKeywords
*/
public function testReplaceKeywords($keyword, $expectedToken) {
$this->lexer->startLexing('<?php ' . $keyword);
$this->assertEquals($expectedToken, $this->lexer->getNextToken());
$this->assertEquals(0, $this->lexer->getNextToken());
}
/**
* @dataProvider provideTestReplaceKeywords
*/
public function testNoReplaceKeywordsAfterObjectOperator($keyword) {
$this->lexer->startLexing('<?php ->' . $keyword);
$this->assertEquals(PHPParser_Parser::T_OBJECT_OPERATOR, $this->lexer->getNextToken());
$this->assertEquals(PHPParser_Parser::T_STRING, $this->lexer->getNextToken());
$this->assertEquals(0, $this->lexer->getNextToken());
}
public function provideTestReplaceKeywords() {
return array(
// PHP 5.5
array('finally', PHPParser_Parser::T_FINALLY),
array('yield', PHPParser_Parser::T_YIELD),
// PHP 5.4
array('callable', PHPParser_Parser::T_CALLABLE),
array('insteadof', PHPParser_Parser::T_INSTEADOF),
array('trait', PHPParser_Parser::T_TRAIT),
array('__TRAIT__', PHPParser_Parser::T_TRAIT_C),
// PHP 5.3
array('__DIR__', PHPParser_Parser::T_DIR),
array('goto', PHPParser_Parser::T_GOTO),
array('namespace', PHPParser_Parser::T_NAMESPACE),
array('__NAMESPACE__', PHPParser_Parser::T_NS_C),
);
}
/**
* @dataProvider provideTestLexNewFeatures
*/
public function testLexNewFeatures($code, array $expectedTokens) {
$this->lexer->startLexing('<?php ' . $code);
foreach ($expectedTokens as $expectedToken) {
list($expectedTokenType, $expectedTokenText) = $expectedToken;
$this->assertEquals($expectedTokenType, $this->lexer->getNextToken($text));
$this->assertEquals($expectedTokenText, $text);
}
$this->assertEquals(0, $this->lexer->getNextToken());
}
/**
* @dataProvider provideTestLexNewFeatures
*/
public function testLeaveStuffAloneInStrings($code) {
$stringifiedToken = '"' . addcslashes($code, '"\\') . '"';
$this->lexer->startLexing('<?php ' . $stringifiedToken);
$this->assertEquals(PHPParser_Parser::T_CONSTANT_ENCAPSED_STRING, $this->lexer->getNextToken($text));
$this->assertEquals($stringifiedToken, $text);
$this->assertEquals(0, $this->lexer->getNextToken());
}
public function provideTestLexNewFeatures() {
return array(
array('0b1010110', array(
array(PHPParser_Parser::T_LNUMBER, '0b1010110'),
)),
array('0b1011010101001010110101010010101011010101010101101011001110111100', array(
array(PHPParser_Parser::T_DNUMBER, '0b1011010101001010110101010010101011010101010101101011001110111100'),
)),
array('\\', array(
array(PHPParser_Parser::T_NS_SEPARATOR, '\\'),
)),
array("<<<'NOWDOC'\nNOWDOC;\n", array(
array(PHPParser_Parser::T_START_HEREDOC, "<<<'NOWDOC'\n"),
array(PHPParser_Parser::T_END_HEREDOC, 'NOWDOC'),
array(ord(';'), ';'),
)),
array("<<<'NOWDOC'\nFoobar\nNOWDOC;\n", array(
array(PHPParser_Parser::T_START_HEREDOC, "<<<'NOWDOC'\n"),
array(PHPParser_Parser::T_ENCAPSED_AND_WHITESPACE, "Foobar\n"),
array(PHPParser_Parser::T_END_HEREDOC, 'NOWDOC'),
array(ord(';'), ';'),
)),
);
}
}

145
vendor/nikic/php-parser/test/PHPParser/Tests/LexerTest.php vendored Normal file
View File

@@ -0,0 +1,145 @@
<?php
class PHPParser_Tests_LexerTest extends PHPUnit_Framework_TestCase
{
/** @var PHPParser_Lexer */
protected $lexer;
protected function setUp() {
$this->lexer = new PHPParser_Lexer;
}
/**
* @dataProvider provideTestError
*/
public function testError($code, $message) {
try {
$this->lexer->startLexing($code);
} catch (PHPParser_Error $e) {
$this->assertEquals($message, $e->getMessage());
return;
}
$this->fail('Expected PHPParser_Error');
}
public function provideTestError() {
return array(
array('<?php /*', 'Unterminated comment on line 1'),
array('<?php ' . "\1", 'Unexpected character "' . "\1" . '" (ASCII 1) on unknown line'),
array('<?php ' . "\0", 'Unexpected null byte on unknown line'),
);
}
/**
* @dataProvider provideTestLex
*/
public function testLex($code, $tokens) {
$this->lexer->startLexing($code);
while ($id = $this->lexer->getNextToken($value, $startAttributes, $endAttributes)) {
$token = array_shift($tokens);
$this->assertEquals($token[0], $id);
$this->assertEquals($token[1], $value);
$this->assertEquals($token[2], $startAttributes);
$this->assertEquals($token[3], $endAttributes);
}
}
public function provideTestLex() {
return array(
// tests conversion of closing PHP tag and drop of whitespace and opening tags
array(
'<?php tokens ?>plaintext',
array(
array(
PHPParser_Parser::T_STRING, 'tokens',
array('startLine' => 1), array('endLine' => 1)
),
array(
ord(';'), '?>',
array('startLine' => 1), array('endLine' => 1)
),
array(
PHPParser_Parser::T_INLINE_HTML, 'plaintext',
array('startLine' => 1), array('endLine' => 1)
),
)
),
// tests line numbers
array(
'<?php' . "\n" . '$ token /** doc' . "\n" . 'comment */ $',
array(
array(
ord('$'), '$',
array('startLine' => 2), array('endLine' => 2)
),
array(
PHPParser_Parser::T_STRING, 'token',
array('startLine' => 2), array('endLine' => 2)
),
array(
ord('$'), '$',
array(
'startLine' => 3,
'comments' => array(new PHPParser_Comment_Doc('/** doc' . "\n" . 'comment */', 2))
),
array('endLine' => 3)
),
)
),
// tests comment extraction
array(
'<?php /* comment */ // comment' . "\n" . '/** docComment 1 *//** docComment 2 */ token',
array(
array(
PHPParser_Parser::T_STRING, 'token',
array(
'startLine' => 2,
'comments' => array(
new PHPParser_Comment('/* comment */', 1),
new PHPParser_Comment('// comment' . "\n", 1),
new PHPParser_Comment_Doc('/** docComment 1 */', 2),
new PHPParser_Comment_Doc('/** docComment 2 */', 2),
),
),
array('endLine' => 2)
),
)
),
// tests differing start and end line
array(
'<?php "foo' . "\n" . 'bar"',
array(
array(
PHPParser_Parser::T_CONSTANT_ENCAPSED_STRING, '"foo' . "\n" . 'bar"',
array('startLine' => 1), array('endLine' => 2)
),
)
),
);
}
/**
* @dataProvider provideTestHaltCompiler
*/
public function testHandleHaltCompiler($code, $remaining) {
$this->lexer->startLexing($code);
while (PHPParser_Parser::T_HALT_COMPILER !== $this->lexer->getNextToken());
$this->assertEquals($this->lexer->handleHaltCompiler(), $remaining);
$this->assertEquals(0, $this->lexer->getNextToken());
}
public function provideTestHaltCompiler() {
return array(
array('<?php ... __halt_compiler();Remaining Text', 'Remaining Text'),
array('<?php ... __halt_compiler ( ) ;Remaining Text', 'Remaining Text'),
array('<?php ... __halt_compiler() ?>Remaining Text', 'Remaining Text'),
//array('<?php ... __halt_compiler();' . "\0", "\0"),
//array('<?php ... __halt_compiler /* */ ( ) ;Remaining Text', 'Remaining Text'),
);
}
}

130
vendor/nikic/php-parser/test/PHPParser/Tests/Node/NameTest.php vendored Normal file
View File

@@ -0,0 +1,130 @@
<?php
class PHPParser_Tests_Node_NameTest extends PHPUnit_Framework_TestCase
{
public function testConstruct() {
$name = new PHPParser_Node_Name(array('foo', 'bar'));
$this->assertEquals(array('foo', 'bar'), $name->parts);
$name = new PHPParser_Node_Name('foo\bar');
$this->assertEquals(array('foo', 'bar'), $name->parts);
}
public function testGet() {
$name = new PHPParser_Node_Name('foo');
$this->assertEquals('foo', $name->getFirst());
$this->assertEquals('foo', $name->getLast());
$name = new PHPParser_Node_Name('foo\bar');
$this->assertEquals('foo', $name->getFirst());
$this->assertEquals('bar', $name->getLast());
}
public function testToString() {
$name = new PHPParser_Node_Name('foo\bar');
$this->assertEquals('foo\bar', (string) $name);
$this->assertEquals('foo\bar', $name->toString());
$this->assertEquals('foo_bar', $name->toString('_'));
}
public function testSet() {
$name = new PHPParser_Node_Name('foo');
$name->set('foo\bar');
$this->assertEquals('foo\bar', $name->toString());
$name->set(array('foo', 'bar'));
$this->assertEquals('foo\bar', $name->toString());
$name->set(new PHPParser_Node_Name('foo\bar'));
$this->assertEquals('foo\bar', $name->toString());
}
public function testSetFirst() {
$name = new PHPParser_Node_Name('foo');
$name->setFirst('bar');
$this->assertEquals('bar', $name->toString());
$name->setFirst('A\B');
$this->assertEquals('A\B', $name->toString());
$name->setFirst('C');
$this->assertEquals('C\B', $name->toString());
$name->setFirst('D\E');
$this->assertEquals('D\E\B', $name->toString());
}
public function testSetLast() {
$name = new PHPParser_Node_Name('foo');
$name->setLast('bar');
$this->assertEquals('bar', $name->toString());
$name->setLast('A\B');
$this->assertEquals('A\B', $name->toString());
$name->setLast('C');
$this->assertEquals('A\C', $name->toString());
$name->setLast('D\E');
$this->assertEquals('A\D\E', $name->toString());
}
public function testAppend() {
$name = new PHPParser_Node_Name('foo');
$name->append('bar');
$this->assertEquals('foo\bar', $name->toString());
$name->append('bar\foo');
$this->assertEquals('foo\bar\bar\foo', $name->toString());
}
public function testPrepend() {
$name = new PHPParser_Node_Name('foo');
$name->prepend('bar');
$this->assertEquals('bar\foo', $name->toString());
$name->prepend('foo\bar');
$this->assertEquals('foo\bar\bar\foo', $name->toString());
}
public function testIs() {
$name = new PHPParser_Node_Name('foo');
$this->assertTrue ($name->isUnqualified());
$this->assertFalse($name->isQualified());
$this->assertFalse($name->isFullyQualified());
$this->assertFalse($name->isRelative());
$name = new PHPParser_Node_Name('foo\bar');
$this->assertFalse($name->isUnqualified());
$this->assertTrue ($name->isQualified());
$this->assertFalse($name->isFullyQualified());
$this->assertFalse($name->isRelative());
$name = new PHPParser_Node_Name_FullyQualified('foo');
$this->assertFalse($name->isUnqualified());
$this->assertFalse($name->isQualified());
$this->assertTrue ($name->isFullyQualified());
$this->assertFalse($name->isRelative());
$name = new PHPParser_Node_Name_Relative('foo');
$this->assertFalse($name->isUnqualified());
$this->assertFalse($name->isQualified());
$this->assertFalse($name->isFullyQualified());
$this->assertTrue ($name->isRelative());
}
/**
* @expectedException InvalidArgumentException
* @expectedExceptionMessage When changing a name you need to pass either a string, an array or a Name node
*/
public function testInvalidArg() {
$name = new PHPParser_Node_Name('foo');
$name->set(new stdClass);
}
}

59
vendor/nikic/php-parser/test/PHPParser/Tests/Node/Scalar/StringTest.php vendored Normal file
View File

@@ -0,0 +1,59 @@
<?php
class PHPParser_Tests_Node_Scalar_StringTest extends PHPUnit_Framework_TestCase
{
/**
* @dataProvider provideTestParseEscapeSequences
*/
public function testParseEscapeSequences($expected, $string, $quote) {
$this->assertEquals(
$expected,
PHPParser_Node_Scalar_String::parseEscapeSequences($string, $quote)
);
}
/**
* @dataProvider provideTestParse
*/
public function testCreate($expected, $string) {
$this->assertEquals(
$expected,
PHPParser_Node_Scalar_String::parse($string)
);
}
public function provideTestParseEscapeSequences() {
return array(
array('"', '\\"', '"'),
array('\\"', '\\"', '`'),
array('\\"\\`', '\\"\\`', null),
array("\\\$\n\r\t\f\v", '\\\\\$\n\r\t\f\v', null),
array("\x1B", '\e', null),
array(chr(255), '\xFF', null),
array(chr(255), '\377', null),
array(chr(0), '\400', null),
array("\0", '\0', null),
array('\xFF', '\\\\xFF', null),
);
}
public function provideTestParse() {
$tests = array(
array('A', '\'A\''),
array('A', 'b\'A\''),
array('A', '"A"'),
array('A', 'b"A"'),
array('\\', '\'\\\\\''),
array('\'', '\'\\\'\''),
);
foreach ($this->provideTestParseEscapeSequences() as $i => $test) {
// skip second and third tests, they aren't for double quotes
if ($i != 1 && $i != 2) {
$tests[] = array($test[0], '"' . $test[1] . '"');
}
}
return $tests;
}
}

35
vendor/nikic/php-parser/test/PHPParser/Tests/Node/Stmt/ClassMethodTest.php vendored Normal file
View File

@@ -0,0 +1,35 @@
<?php
class PHPParser_Tests_Node_Stmt_ClassMethodTest extends PHPUnit_Framework_TestCase
{
/**
* @dataProvider provideModifiers
*/
public function testModifiers($modifier) {
$node = new PHPParser_Node_Stmt_ClassMethod('foo', array(
'type' => constant('PHPParser_Node_Stmt_Class::MODIFIER_' . strtoupper($modifier))
));
$this->assertTrue($node->{'is' . $modifier}());
}
/**
* @dataProvider provideModifiers
*/
public function testNoModifiers($modifier) {
$node = new PHPParser_Node_Stmt_ClassMethod('foo', array('type' => 0));
$this->assertFalse($node->{'is' . $modifier}());
}
public function provideModifiers() {
return array(
array('public'),
array('protected'),
array('private'),
array('abstract'),
array('final'),
array('static'),
);
}
}

40
vendor/nikic/php-parser/test/PHPParser/Tests/Node/Stmt/ClassTest.php vendored Normal file
View File

@@ -0,0 +1,40 @@
<?php
class PHPParser_Tests_Node_Stmt_ClassTest extends PHPUnit_Framework_TestCase
{
public function testIsAbstract() {
$class = new PHPParser_Node_Stmt_Class('Foo', array('type' => PHPParser_Node_Stmt_Class::MODIFIER_ABSTRACT));
$this->assertTrue($class->isAbstract());
$class = new PHPParser_Node_Stmt_Class('Foo');
$this->assertFalse($class->isAbstract());
}
public function testIsFinal() {
$class = new PHPParser_Node_Stmt_Class('Foo', array('type' => PHPParser_Node_Stmt_Class::MODIFIER_FINAL));
$this->assertTrue($class->isFinal());
$class = new PHPParser_Node_Stmt_Class('Foo');
$this->assertFalse($class->isFinal());
}
public function testGetMethods() {
$methods = array(
new PHPParser_Node_Stmt_ClassMethod('foo'),
new PHPParser_Node_Stmt_ClassMethod('bar'),
new PHPParser_Node_Stmt_ClassMethod('fooBar'),
);
$class = new PHPParser_Node_Stmt_Class('Foo', array(
'stmts' => array(
new PHPParser_Node_Stmt_TraitUse(array()),
$methods[0],
new PHPParser_Node_Stmt_Const(array()),
$methods[1],
new PHPParser_Node_Stmt_Property(0, array()),
$methods[2],
)
));
$this->assertEquals($methods, $class->getMethods());
}
}

34
vendor/nikic/php-parser/test/PHPParser/Tests/Node/Stmt/PropertyTest.php vendored Normal file
View File

@@ -0,0 +1,34 @@
<?php
class PHPParser_Tests_Node_Stmt_PropertyTest extends PHPUnit_Framework_TestCase
{
/**
* @dataProvider provideModifiers
*/
public function testModifiers($modifier) {
$node = new PHPParser_Node_Stmt_Property(
constant('PHPParser_Node_Stmt_Class::MODIFIER_' . strtoupper($modifier)),
array() // invalid
);
$this->assertTrue($node->{'is' . $modifier}());
}
/**
* @dataProvider provideModifiers
*/
public function testNoModifiers($modifier) {
$node = new PHPParser_Node_Stmt_Property(0, array());
$this->assertFalse($node->{'is' . $modifier}());
}
public function provideModifiers() {
return array(
array('public'),
array('protected'),
array('private'),
array('static'),
);
}
}

96
vendor/nikic/php-parser/test/PHPParser/Tests/NodeAbstractTest.php vendored Normal file
View File

@@ -0,0 +1,96 @@
<?php
class PHPParser_Tests_NodeAbstractTest extends PHPUnit_Framework_TestCase
{
public function testConstruct() {
$attributes = array(
'startLine' => 10,
'comments' => array(
new PHPParser_Comment('// Comment' . "\n"),
new PHPParser_Comment_Doc('/** doc comment */'),
),
);
$node = $this->getMockForAbstractClass(
'PHPParser_NodeAbstract',
array(
array(
'subNode' => 'value'
),
$attributes
),
'PHPParser_Node_Dummy'
);
$this->assertEquals('Dummy', $node->getType());
$this->assertEquals(array('subNode'), $node->getSubNodeNames());
$this->assertEquals(10, $node->getLine());
$this->assertEquals('/** doc comment */', $node->getDocComment());
$this->assertEquals('value', $node->subNode);
$this->assertTrue(isset($node->subNode));
$this->assertEquals($attributes, $node->getAttributes());
return $node;
}
/**
* @depends testConstruct
*/
public function testGetDocComment(PHPParser_Node $node) {
$this->assertEquals('/** doc comment */', $node->getDocComment());
array_pop($node->getAttribute('comments')); // remove doc comment
$this->assertNull($node->getDocComment());
array_pop($node->getAttribute('comments')); // remove comment
$this->assertNull($node->getDocComment());
}
/**
* @depends testConstruct
*/
public function testChange(PHPParser_Node $node) {
// change of line
$node->setLine(15);
$this->assertEquals(15, $node->getLine());
// direct modification
$node->subNode = 'newValue';
$this->assertEquals('newValue', $node->subNode);
// indirect modification
$subNode =& $node->subNode;
$subNode = 'newNewValue';
$this->assertEquals('newNewValue', $node->subNode);
// removal
unset($node->subNode);
$this->assertFalse(isset($node->subNode));
}
public function testAttributes() {
/** @var $node PHPParser_Node */
$node = $this->getMockForAbstractClass('PHPParser_NodeAbstract');
$this->assertEmpty($node->getAttributes());
$node->setAttribute('key', 'value');
$this->assertTrue($node->hasAttribute('key'));
$this->assertEquals('value', $node->getAttribute('key'));
$this->assertFalse($node->hasAttribute('doesNotExist'));
$this->assertNull($node->getAttribute('doesNotExist'));
$this->assertEquals('default', $node->getAttribute('doesNotExist', 'default'));
$node->setAttribute('null', null);
$this->assertTrue($node->hasAttribute('null'));
$this->assertNull($node->getAttribute('null'));
$this->assertNull($node->getAttribute('null', 'default'));
$this->assertEquals(
array(
'key' => 'value',
'null' => null,
),
$node->getAttributes()
);
}
}

66
vendor/nikic/php-parser/test/PHPParser/Tests/NodeDumperTest.php vendored Normal file
View File

@@ -0,0 +1,66 @@
<?php
class PHPParser_Tests_NodeDumperTest extends PHPUnit_Framework_TestCase
{
/**
* @dataProvider provideTestDump
* @covers PHPParser_NodeDumper::dump
*/
public function testDump($node, $dump) {
$dumper = new PHPParser_NodeDumper;
$this->assertEquals($dump, $dumper->dump($node));
}
public function provideTestDump() {
return array(
array(
array(),
'array(
)'
),
array(
array('Foo', 'Bar', 'Key' => 'FooBar'),
'array(
0: Foo
1: Bar
Key: FooBar
)'
),
array(
new PHPParser_Node_Name(array('Hallo', 'World')),
'Name(
parts: array(
0: Hallo
1: World
)
)'
),
array(
new PHPParser_Node_Expr_Array(array(
new PHPParser_Node_Expr_ArrayItem(new PHPParser_Node_Scalar_String('Foo'))
)),
'Expr_Array(
items: array(
0: Expr_ArrayItem(
key: null
value: Scalar_String(
value: Foo
)
byRef: false
)
)
)'
),
);
}
/**
* @expectedException InvalidArgumentException
* @expectedExceptionMessage Can only dump nodes and arrays.
*/
public function testError() {
$dumper = new PHPParser_NodeDumper;
$dumper->dump(new stdClass);
}
}

125
vendor/nikic/php-parser/test/PHPParser/Tests/NodeTraverserTest.php vendored Normal file
View File

@@ -0,0 +1,125 @@
<?php
class PHPParser_Tests_NodeTraverserTest extends PHPUnit_Framework_TestCase
{
public function testNonModifying() {
$str1Node = new PHPParser_Node_Scalar_String('Foo');
$str2Node = new PHPParser_Node_Scalar_String('Bar');
$echoNode = new PHPParser_Node_Stmt_Echo(array($str1Node, $str2Node));
$stmts = array($echoNode);
$visitor = $this->getMock('PHPParser_NodeVisitor');
$visitor->expects($this->at(0))->method('beforeTraverse')->with($stmts);
$visitor->expects($this->at(1))->method('enterNode')->with($echoNode);
$visitor->expects($this->at(2))->method('enterNode')->with($str1Node);
$visitor->expects($this->at(3))->method('leaveNode')->with($str1Node);
$visitor->expects($this->at(4))->method('enterNode')->with($str2Node);
$visitor->expects($this->at(5))->method('leaveNode')->with($str2Node);
$visitor->expects($this->at(6))->method('leaveNode')->with($echoNode);
$visitor->expects($this->at(7))->method('afterTraverse')->with($stmts);
$traverser = new PHPParser_NodeTraverser;
$traverser->addVisitor($visitor);
$this->assertEquals($stmts, $traverser->traverse($stmts));
}
public function testModifying() {
$str1Node = new PHPParser_Node_Scalar_String('Foo');
$str2Node = new PHPParser_Node_Scalar_String('Bar');
$printNode = new PHPParser_Node_Expr_Print($str1Node);
// first visitor changes the node, second verifies the change
$visitor1 = $this->getMock('PHPParser_NodeVisitor');
$visitor2 = $this->getMock('PHPParser_NodeVisitor');
// replace empty statements with string1 node
$visitor1->expects($this->at(0))->method('beforeTraverse')->with(array())
->will($this->returnValue(array($str1Node)));
$visitor2->expects($this->at(0))->method('beforeTraverse')->with(array($str1Node));
// replace string1 node with print node
$visitor1->expects($this->at(1))->method('enterNode')->with($str1Node)
->will($this->returnValue($printNode));
$visitor2->expects($this->at(1))->method('enterNode')->with($printNode);
// replace string1 node with string2 node
$visitor1->expects($this->at(2))->method('enterNode')->with($str1Node)
->will($this->returnValue($str2Node));
$visitor2->expects($this->at(2))->method('enterNode')->with($str2Node);
// replace string2 node with string1 node again
$visitor1->expects($this->at(3))->method('leaveNode')->with($str2Node)
->will($this->returnValue($str1Node));
$visitor2->expects($this->at(3))->method('leaveNode')->with($str1Node);
// replace print node with string1 node again
$visitor1->expects($this->at(4))->method('leaveNode')->with($printNode)
->will($this->returnValue($str1Node));
$visitor2->expects($this->at(4))->method('leaveNode')->with($str1Node);
// replace string1 node with empty statements again
$visitor1->expects($this->at(5))->method('afterTraverse')->with(array($str1Node))
->will($this->returnValue(array()));
$visitor2->expects($this->at(5))->method('afterTraverse')->with(array());
$traverser = new PHPParser_NodeTraverser;
$traverser->addVisitor($visitor1);
$traverser->addVisitor($visitor2);
// as all operations are reversed we end where we start
$this->assertEquals(array(), $traverser->traverse(array()));
}
public function testRemove() {
$str1Node = new PHPParser_Node_Scalar_String('Foo');
$str2Node = new PHPParser_Node_Scalar_String('Bar');
$visitor = $this->getMock('PHPParser_NodeVisitor');
// remove the string1 node, leave the string2 node
$visitor->expects($this->at(2))->method('leaveNode')->with($str1Node)
->will($this->returnValue(false));
$traverser = new PHPParser_NodeTraverser;
$traverser->addVisitor($visitor);
$this->assertEquals(array($str2Node), $traverser->traverse(array($str1Node, $str2Node)));
}
public function testMerge() {
$strStart = new PHPParser_Node_Scalar_String('Start');
$strMiddle = new PHPParser_Node_Scalar_String('End');
$strEnd = new PHPParser_Node_Scalar_String('Middle');
$strR1 = new PHPParser_Node_Scalar_String('Replacement 1');
$strR2 = new PHPParser_Node_Scalar_String('Replacement 2');
$visitor = $this->getMock('PHPParser_NodeVisitor');
// replace strMiddle with strR1 and strR2 by merge
$visitor->expects($this->at(4))->method('leaveNode')->with($strMiddle)
->will($this->returnValue(array($strR1, $strR2)));
$traverser = new PHPParser_NodeTraverser;
$traverser->addVisitor($visitor);
$this->assertEquals(
array($strStart, $strR1, $strR2, $strEnd),
$traverser->traverse(array($strStart, $strMiddle, $strEnd))
);
}
public function testDeepArray() {
$strNode = new PHPParser_Node_Scalar_String('Foo');
$stmts = array(array(array($strNode)));
$visitor = $this->getMock('PHPParser_NodeVisitor');
$visitor->expects($this->at(1))->method('enterNode')->with($strNode);
$traverser = new PHPParser_NodeTraverser;
$traverser->addVisitor($visitor);
$this->assertEquals($stmts, $traverser->traverse($stmts));
}
}

225
vendor/nikic/php-parser/test/PHPParser/Tests/NodeVisitor/NameResolverTest.php vendored Normal file
View File

@@ -0,0 +1,225 @@
<?php
class PHPParser_Tests_NodeVisitor_NameResolverTest extends PHPUnit_Framework_TestCase
{
/**
* @covers PHPParser_NodeVisitor_NameResolver
*/
public function testResolveNames() {
$code = <<<EOC
<?php
namespace Foo {
use Hallo as Hi;
new Bar();
new Hi();
new Hi\\Bar();
new \\Bar();
new namespace\\Bar();
bar();
hi();
Hi\\bar();
foo\\bar();
\\bar();
namespace\\bar();
}
namespace {
use Hallo as Hi;
new Bar();
new Hi();
new Hi\\Bar();
new \\Bar();
new namespace\\Bar();
bar();
hi();
Hi\\bar();
foo\\bar();
\\bar();
namespace\\bar();
}
EOC;
$expectedCode = <<<EOC
namespace Foo {
use Hallo as Hi;
new \\Foo\\Bar();
new \\Hallo();
new \\Hallo\\Bar();
new \\Bar();
new \\Foo\\Bar();
bar();
hi();
\\Hallo\\bar();
\\Foo\\foo\\bar();
\\bar();
\\Foo\\bar();
}
namespace {
use Hallo as Hi;
new \\Bar();
new \\Hallo();
new \\Hallo\\Bar();
new \\Bar();
new \\Bar();
bar();
hi();
\\Hallo\\bar();
\\foo\\bar();
\\bar();
\\bar();
}
EOC;
$parser = new PHPParser_Parser(new PHPParser_Lexer_Emulative);
$prettyPrinter = new PHPParser_PrettyPrinter_Default;
$traverser = new PHPParser_NodeTraverser;
$traverser->addVisitor(new PHPParser_NodeVisitor_NameResolver);
$stmts = $parser->parse($code);
$stmts = $traverser->traverse($stmts);
$this->assertEquals($expectedCode, $prettyPrinter->prettyPrint($stmts));
}
/**
* @covers PHPParser_NodeVisitor_NameResolver
*/
public function testResolveLocations() {
$code = <<<EOC
<?php
namespace NS;
class A extends B implements C {
use A;
}
interface A extends C {
public function a(A \$a);
}
A::b();
A::\$b;
A::B;
new A;
\$a instanceof A;
namespace\a();
namespace\A;
try {
\$someThing;
} catch (A \$a) {
\$someThingElse;
}
EOC;
$expectedCode = <<<EOC
namespace NS;
class A extends \\NS\\B implements \\NS\\C
{
use \\NS\\A;
}
interface A extends \\NS\\C
{
public function a(\\NS\\A \$a);
}
\\NS\\A::b();
\\NS\\A::\$b;
\\NS\\A::B;
new \\NS\\A();
\$a instanceof \\NS\\A;
\\NS\\a();
\\NS\\A;
try {
\$someThing;
} catch (\\NS\\A \$a) {
\$someThingElse;
}
EOC;
$parser = new PHPParser_Parser(new PHPParser_Lexer_Emulative);
$prettyPrinter = new PHPParser_PrettyPrinter_Default;
$traverser = new PHPParser_NodeTraverser;
$traverser->addVisitor(new PHPParser_NodeVisitor_NameResolver);
$stmts = $parser->parse($code);
$stmts = $traverser->traverse($stmts);
$this->assertEquals($expectedCode, $prettyPrinter->prettyPrint($stmts));
}
public function testNoResolveSpecialName() {
$stmts = array(new PHPParser_Node_Expr_New(new PHPParser_Node_Name('self')));
$traverser = new PHPParser_NodeTraverser;
$traverser->addVisitor(new PHPParser_NodeVisitor_NameResolver);
$this->assertEquals($stmts, $traverser->traverse($stmts));
}
protected function createNamespacedAndNonNamespaced(array $stmts) {
return array(
new PHPParser_Node_Stmt_Namespace(new PHPParser_Node_Name('NS'), $stmts),
new PHPParser_Node_Stmt_Namespace(null, $stmts),
);
}
public function testAddNamespacedName() {
$stmts = $this->createNamespacedAndNonNamespaced(array(
new PHPParser_Node_Stmt_Class('A'),
new PHPParser_Node_Stmt_Interface('B'),
new PHPParser_Node_Stmt_Function('C'),
new PHPParser_Node_Stmt_Const(array(
new PHPParser_Node_Const('D', new PHPParser_Node_Scalar_String('E'))
)),
));
$traverser = new PHPParser_NodeTraverser;
$traverser->addVisitor(new PHPParser_NodeVisitor_NameResolver);
$stmts = $traverser->traverse($stmts);
$this->assertEquals('NS\\A', (string) $stmts[0]->stmts[0]->namespacedName);
$this->assertEquals('NS\\B', (string) $stmts[0]->stmts[1]->namespacedName);
$this->assertEquals('NS\\C', (string) $stmts[0]->stmts[2]->namespacedName);
$this->assertEquals('NS\\D', (string) $stmts[0]->stmts[3]->consts[0]->namespacedName);
$this->assertEquals('A', (string) $stmts[1]->stmts[0]->namespacedName);
$this->assertEquals('B', (string) $stmts[1]->stmts[1]->namespacedName);
$this->assertEquals('C', (string) $stmts[1]->stmts[2]->namespacedName);
$this->assertEquals('D', (string) $stmts[1]->stmts[3]->consts[0]->namespacedName);
}
public function testAddTraitNamespacedName() {
$stmts = $this->createNamespacedAndNonNamespaced(array(
new PHPParser_Node_Stmt_Trait('A')
));
$traverser = new PHPParser_NodeTraverser;
$traverser->addVisitor(new PHPParser_NodeVisitor_NameResolver);
$stmts = $traverser->traverse($stmts);
$this->assertEquals('NS\\A', (string) $stmts[0]->stmts[0]->namespacedName);
$this->assertEquals('A', (string) $stmts[1]->stmts[0]->namespacedName);
}
/**
* @expectedException PHPParser_Error
* @expectedExceptionMessage Cannot use "C" as "B" because the name is already in use on line 2
*/
public function testAlreadyInUseError() {
$stmts = array(
new PHPParser_Node_Stmt_Use(array(
new PHPParser_Node_Stmt_UseUse(new PHPParser_Node_Name('A\B'), 'B', array('startLine' => 1)),
new PHPParser_Node_Stmt_UseUse(new PHPParser_Node_Name('C'), 'B', array('startLine' => 2)),
))
);
$traverser = new PHPParser_NodeTraverser;
$traverser->addVisitor(new PHPParser_NodeVisitor_NameResolver);
$traverser->traverse($stmts);
}
}

44
vendor/nikic/php-parser/test/PHPParser/Tests/ParserTest.php vendored Normal file
View File

@@ -0,0 +1,44 @@
<?php
require_once dirname(__FILE__) . '/CodeTestAbstract.php';
class PHPParser_Tests_ParserTest extends PHPParser_Tests_CodeTestAbstract
{
/**
* @dataProvider provideTestParse
*/
public function testParse($name, $code, $dump) {
$parser = new PHPParser_Parser(new PHPParser_Lexer_Emulative);
$dumper = new PHPParser_NodeDumper;
$stmts = $parser->parse($code);
$this->assertEquals(
$this->canonicalize($dump),
$this->canonicalize($dumper->dump($stmts)),
$name
);
}
public function provideTestParse() {
return $this->getTests(dirname(__FILE__) . '/../../code/parser', 'test');
}
/**
* @dataProvider provideTestParseFail
*/
public function testParseFail($name, $code, $msg) {
$parser = new PHPParser_Parser(new PHPParser_Lexer_Emulative);
try {
$parser->parse($code);
$this->fail(sprintf('"%s": Expected PHPParser_Error', $name));
} catch (PHPParser_Error $e) {
$this->assertEquals($msg, $e->getMessage(), $name);
}
}
public function provideTestParseFail() {
return $this->getTests(dirname(__FILE__) . '/../../code/parser', 'test-fail');
}
}

42
vendor/nikic/php-parser/test/PHPParser/Tests/PrettyPrinterTest.php vendored Normal file
View File

@@ -0,0 +1,42 @@
<?php
require_once dirname(__FILE__) . '/CodeTestAbstract.php';
class PHPParser_Tests_PrettyPrinterTest extends PHPParser_Tests_CodeTestAbstract
{
protected function doTestPrettyPrintMethod($method, $name, $code, $dump) {
$parser = new PHPParser_Parser(new PHPParser_Lexer_Emulative);
$prettyPrinter = new PHPParser_PrettyPrinter_Default;
$stmts = $parser->parse($code);
$this->assertEquals(
$this->canonicalize($dump),
$this->canonicalize($prettyPrinter->$method($stmts)),
$name
);
}
/**
* @dataProvider provideTestPrettyPrint
* @covers PHPParser_PrettyPrinter_Default<extended>
*/
public function testPrettyPrint($name, $code, $dump) {
$this->doTestPrettyPrintMethod('prettyPrint', $name, $code, $dump);
}
/**
* @dataProvider provideTestPrettyPrintFile
* @covers PHPParser_PrettyPrinter_Default<extended>
*/
public function testPrettyPrintFile($name, $code, $dump) {
$this->doTestPrettyPrintMethod('prettyPrintFile', $name, $code, $dump);
}
public function provideTestPrettyPrint() {
return $this->getTests(dirname(__FILE__) . '/../../code/prettyPrinter', 'test');
}
public function provideTestPrettyPrintFile() {
return $this->getTests(dirname(__FILE__) . '/../../code/prettyPrinter', 'file-test');
}
}

152
vendor/nikic/php-parser/test/PHPParser/Tests/Serializer/XMLTest.php vendored Normal file
View File

@@ -0,0 +1,152 @@
<?php
class PHPParser_Tests_Serializer_XMLTest extends PHPUnit_Framework_TestCase
{
/**
* @covers PHPParser_Serializer_XML<extended>
*/
public function testSerialize() {
$code = <<<CODE
<?php
// comment
/** doc comment */
function functionName(&\$a = 0, \$b = 1.0) {
echo 'Foo';
}
CODE;
$xml = <<<XML
<?xml version="1.0" encoding="UTF-8"?>
<AST xmlns:node="http://nikic.github.com/PHPParser/XML/node" xmlns:subNode="http://nikic.github.com/PHPParser/XML/subNode" xmlns:attribute="http://nikic.github.com/PHPParser/XML/attribute" xmlns:scalar="http://nikic.github.com/PHPParser/XML/scalar">
<scalar:array>
<node:Stmt_Function>
<attribute:comments>
<scalar:array>
<comment isDocComment="false" line="2">// comment
</comment>
<comment isDocComment="true" line="3">/** doc comment */</comment>
</scalar:array>
</attribute:comments>
<attribute:startLine>
<scalar:int>4</scalar:int>
</attribute:startLine>
<attribute:endLine>
<scalar:int>6</scalar:int>
</attribute:endLine>
<subNode:byRef>
<scalar:false/>
</subNode:byRef>
<subNode:params>
<scalar:array>
<node:Param>
<attribute:startLine>
<scalar:int>4</scalar:int>
</attribute:startLine>
<attribute:endLine>
<scalar:int>4</scalar:int>
</attribute:endLine>
<subNode:name>
<scalar:string>a</scalar:string>
</subNode:name>
<subNode:default>
<node:Scalar_LNumber>
<attribute:startLine>
<scalar:int>4</scalar:int>
</attribute:startLine>
<attribute:endLine>
<scalar:int>4</scalar:int>
</attribute:endLine>
<subNode:value>
<scalar:int>0</scalar:int>
</subNode:value>
</node:Scalar_LNumber>
</subNode:default>
<subNode:type>
<scalar:null/>
</subNode:type>
<subNode:byRef>
<scalar:true/>
</subNode:byRef>
</node:Param>
<node:Param>
<attribute:startLine>
<scalar:int>4</scalar:int>
</attribute:startLine>
<attribute:endLine>
<scalar:int>4</scalar:int>
</attribute:endLine>
<subNode:name>
<scalar:string>b</scalar:string>
</subNode:name>
<subNode:default>
<node:Scalar_DNumber>
<attribute:startLine>
<scalar:int>4</scalar:int>
</attribute:startLine>
<attribute:endLine>
<scalar:int>4</scalar:int>
</attribute:endLine>
<subNode:value>
<scalar:float>1</scalar:float>
</subNode:value>
</node:Scalar_DNumber>
</subNode:default>
<subNode:type>
<scalar:null/>
</subNode:type>
<subNode:byRef>
<scalar:false/>
</subNode:byRef>
</node:Param>
</scalar:array>
</subNode:params>
<subNode:stmts>
<scalar:array>
<node:Stmt_Echo>
<attribute:startLine>
<scalar:int>5</scalar:int>
</attribute:startLine>
<attribute:endLine>
<scalar:int>5</scalar:int>
</attribute:endLine>
<subNode:exprs>
<scalar:array>
<node:Scalar_String>
<attribute:startLine>
<scalar:int>5</scalar:int>
</attribute:startLine>
<attribute:endLine>
<scalar:int>5</scalar:int>
</attribute:endLine>
<subNode:value>
<scalar:string>Foo</scalar:string>
</subNode:value>
</node:Scalar_String>
</scalar:array>
</subNode:exprs>
</node:Stmt_Echo>
</scalar:array>
</subNode:stmts>
<subNode:name>
<scalar:string>functionName</scalar:string>
</subNode:name>
</node:Stmt_Function>
</scalar:array>
</AST>
XML;
$parser = new PHPParser_Parser(new PHPParser_Lexer);
$serializer = new PHPParser_Serializer_XML;
$stmts = $parser->parse($code);
$this->assertXmlStringEqualsXmlString($xml, $serializer->serialize($stmts));
}
/**
* @expectedException InvalidArgumentException
* @expectedExceptionMessage Unexpected node type
*/
public function testError() {
$serializer = new PHPParser_Serializer_XML;
$serializer->serialize(array(new stdClass));
}
}

48
vendor/nikic/php-parser/test/PHPParser/Tests/TemplateLoaderTest.php vendored Normal file
View File

@@ -0,0 +1,48 @@
<?php
class PHPParser_Tests_TemplateLoaderTest extends PHPUnit_Framework_TestCase
{
public function testLoadWithoutSuffix() {
$templateLoader = new PHPParser_TemplateLoader(
new PHPParser_Parser(new PHPParser_Lexer),
dirname(__FILE__)
);
// load this file as a template, as we don't really care about the contents
$template = $templateLoader->load('TemplateLoaderTest.php');
$this->assertInstanceOf('PHPParser_Template', $template);
}
public function testLoadWithSuffix() {
$templateLoader = new PHPParser_TemplateLoader(
new PHPParser_Parser(new PHPParser_Lexer),
dirname(__FILE__), '.php'
);
// load this file as a template, as we don't really care about the contents
$template = $templateLoader->load('TemplateLoaderTest');
$this->assertInstanceOf('PHPParser_Template', $template);
}
/**
* @expectedException InvalidArgumentException
*/
public function testNonexistentBaseDirectoryError() {
new PHPParser_TemplateLoader(
new PHPParser_Parser(new PHPParser_Lexer),
dirname(__FILE__) . '/someDirectoryThatDoesNotExist'
);
}
/**
* @expectedException InvalidArgumentException
*/
public function testNonexistentFileError() {
$templateLoader = new PHPParser_TemplateLoader(
new PHPParser_Parser(new PHPParser_Lexer),
dirname(__FILE__)
);
$templateLoader->load('SomeTemplateThatDoesNotExist');
}
}

59
vendor/nikic/php-parser/test/PHPParser/Tests/TemplateTest.php vendored Normal file
View File

@@ -0,0 +1,59 @@
<?php
class PHPParser_Tests_TemplateTest extends PHPUnit_Framework_TestCase
{
/**
* @dataProvider provideTestPlaceholderReplacement
* @covers PHPParser_Template
*/
public function testPlaceholderReplacement($templateCode, $placeholders, $expectedPrettyPrint) {
$parser = new PHPParser_Parser(new PHPParser_Lexer);
$prettyPrinter = new PHPParser_PrettyPrinter_Default;
$template = new PHPParser_Template($parser, $templateCode);
$this->assertEquals(
$expectedPrettyPrint,
$prettyPrinter->prettyPrint($template->getStmts($placeholders))
);
}
public function provideTestPlaceholderReplacement() {
return array(
array(
'<?php $__name__ + $__Name__;',
array('name' => 'foo'),
'$foo + $Foo;'
),
array(
'<?php $__name__ + $__Name__;',
array('Name' => 'Foo'),
'$foo + $Foo;'
),
array(
'<?php $__name__ + $__Name__;',
array('name' => 'foo', 'Name' => 'Bar'),
'$foo + $Bar;'
),
array(
'<?php $__name__ + $__Name__;',
array('Name' => 'Bar', 'name' => 'foo'),
'$foo + $Bar;'
),
array(
'<?php $prefix__Name__Suffix;',
array('name' => 'infix'),
'$prefixInfixSuffix;'
),
array(
'<?php $___name___;',
array('name' => 'foo'),
'$_foo_;'
),
array(
'<?php $foobar;',
array(),
'$foobar;'
),
);
}
}

141
vendor/nikic/php-parser/test/PHPParser/Tests/Unserializer/XMLTest.php vendored Normal file
View File

@@ -0,0 +1,141 @@
<?php
class PHPParser_Tests_Unserializer_XMLTest extends PHPUnit_Framework_TestCase
{
public function testNode() {
$xml = <<<XML
<?xml version="1.0" encoding="UTF-8"?>
<AST xmlns:node="http://nikic.github.com/PHPParser/XML/node" xmlns:subNode="http://nikic.github.com/PHPParser/XML/subNode" xmlns:attribute="http://nikic.github.com/PHPParser/XML/attribute" xmlns:scalar="http://nikic.github.com/PHPParser/XML/scalar">
<node:Scalar_String line="1" docComment="/** doc comment */">
<attribute:startLine>
<scalar:int>1</scalar:int>
</attribute:startLine>
<attribute:comments>
<scalar:array>
<comment isDocComment="false" line="2">// comment
</comment>
<comment isDocComment="true" line="3">/** doc comment */</comment>
</scalar:array>
</attribute:comments>
<subNode:value>
<scalar:string>Test</scalar:string>
</subNode:value>
</node:Scalar_String>
</AST>
XML;
$unserializer = new PHPParser_Unserializer_XML;
$this->assertEquals(
new PHPParser_Node_Scalar_String('Test', array(
'startLine' => 1,
'comments' => array(
new PHPParser_Comment('// comment' . "\n", 2),
new PHPParser_Comment_Doc('/** doc comment */', 3),
),
)),
$unserializer->unserialize($xml)
);
}
public function testEmptyNode() {
$xml = <<<XML
<?xml version="1.0" encoding="UTF-8"?>
<AST xmlns:node="http://nikic.github.com/PHPParser/XML/node">
<node:Scalar_ClassConst />
</AST>
XML;
$unserializer = new PHPParser_Unserializer_XML;
$this->assertEquals(
new PHPParser_Node_Scalar_ClassConst,
$unserializer->unserialize($xml)
);
}
public function testScalars() {
$xml = <<<XML
<?xml version="1.0" encoding="UTF-8"?>
<AST xmlns:scalar="http://nikic.github.com/PHPParser/XML/scalar">
<scalar:array>
<scalar:array></scalar:array>
<scalar:array/>
<scalar:string>test</scalar:string>
<scalar:string></scalar:string>
<scalar:string/>
<scalar:int>1</scalar:int>
<scalar:float>1</scalar:float>
<scalar:float>1.5</scalar:float>
<scalar:true/>
<scalar:false/>
<scalar:null/>
</scalar:array>
</AST>
XML;
$result = array(
array(), array(),
'test', '', '',
1,
1, 1.5,
true, false, null
);
$unserializer = new PHPParser_Unserializer_XML;
$this->assertEquals($result, $unserializer->unserialize($xml));
}
/**
* @expectedException DomainException
* @expectedExceptionMessage AST root element not found
*/
public function testWrongRootElementError() {
$xml = <<<XML
<?xml version="1.0" encoding="UTF-8"?>
<notAST/>
XML;
$unserializer = new PHPParser_Unserializer_XML;
$unserializer->unserialize($xml);
}
/**
* @dataProvider provideTestErrors
*/
public function testErrors($xml, $errorMsg) {
$this->setExpectedException('DomainException', $errorMsg);
$xml = <<<XML
<?xml version="1.0" encoding="UTF-8"?>
<AST xmlns:scalar="http://nikic.github.com/PHPParser/XML/scalar"
xmlns:node="http://nikic.github.com/PHPParser/XML/node"
xmlns:subNode="http://nikic.github.com/PHPParser/XML/subNode"
xmlns:foo="http://nikic.github.com/PHPParser/XML/foo">
$xml
</AST>
XML;
$unserializer = new PHPParser_Unserializer_XML;
$unserializer->unserialize($xml);
}
public function provideTestErrors() {
return array(
array('<scalar:true>test</scalar:true>', '"true" scalar must be empty'),
array('<scalar:false>test</scalar:false>', '"false" scalar must be empty'),
array('<scalar:null>test</scalar:null>', '"null" scalar must be empty'),
array('<scalar:foo>bar</scalar:foo>', 'Unknown scalar type "foo"'),
array('<scalar:int>x</scalar:int>', '"x" is not a valid int'),
array('<scalar:float>x</scalar:float>', '"x" is not a valid float'),
array('', 'Expected node or scalar'),
array('<foo:bar>test</foo:bar>', 'Unexpected node of type "foo:bar"'),
array(
'<node:Scalar_String><foo:bar>test</foo:bar></node:Scalar_String>',
'Expected sub node or attribute, got node of type "foo:bar"'
),
array(
'<node:Scalar_String><subNode:value/></node:Scalar_String>',
'Expected node or scalar'
),
);
}
}