mirror of
https://gitlab.com/signalytic/client-external/streamline/streamline-emr.git
synced 2026-09-12 03:01:32 +00:00
resolved conflicts
This commit is contained in:
@@ -0,0 +1,313 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Tests\Lexer;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Context;
|
||||
use PhpMyAdmin\SqlParser\Contexts;
|
||||
use PhpMyAdmin\SqlParser\Tests\TestCase;
|
||||
use Throwable;
|
||||
|
||||
use function class_exists;
|
||||
|
||||
class ContextTest extends TestCase
|
||||
{
|
||||
public static function tearDownAfterClass(): void
|
||||
{
|
||||
Context::setMode();
|
||||
}
|
||||
|
||||
public function testLoad(): void
|
||||
{
|
||||
// Default context is 5.7.0.
|
||||
$this->assertEquals('\\PhpMyAdmin\\SqlParser\\Contexts\\ContextMySql50700', Context::$loadedContext);
|
||||
$this->assertArrayHasKey('STORED', Context::$KEYWORDS);
|
||||
$this->assertArrayNotHasKey('AUTHORS', Context::$KEYWORDS);
|
||||
|
||||
// Restoring context.
|
||||
Context::load('');
|
||||
$this->assertEquals('\\PhpMyAdmin\\SqlParser\\Contexts\\ContextMySql50700', Context::$defaultContext);
|
||||
$this->assertArrayHasKey('STORED', Context::$KEYWORDS);
|
||||
$this->assertArrayNotHasKey('AUTHORS', Context::$KEYWORDS);
|
||||
}
|
||||
|
||||
/**
|
||||
* Test for loading closest SQL context
|
||||
*
|
||||
* @dataProvider contextLoadingProvider
|
||||
*/
|
||||
public function testLoadClosest(string $context, ?string $expected): void
|
||||
{
|
||||
$this->assertEquals($expected, Context::loadClosest($context));
|
||||
if ($expected !== null) {
|
||||
$this->assertEquals('\\PhpMyAdmin\\SqlParser\\Contexts\\Context' . $expected, Context::$loadedContext);
|
||||
$this->assertTrue(class_exists(Context::$loadedContext));
|
||||
}
|
||||
|
||||
// Restoring context.
|
||||
Context::load('');
|
||||
}
|
||||
|
||||
/**
|
||||
* @return array<string, array<int, string|null>>
|
||||
* @psalm-return array<string, array{string, (string|null)}>
|
||||
*/
|
||||
public static function contextLoadingProvider(): array
|
||||
{
|
||||
return [
|
||||
'MySQL match' => [
|
||||
'MySql50500',
|
||||
'MySql50500',
|
||||
],
|
||||
'MySQL strip' => [
|
||||
'MySql50712',
|
||||
'MySql50700',
|
||||
],
|
||||
'MySQL fallback' => [
|
||||
'MySql9897969594',
|
||||
'MySql50700',
|
||||
],
|
||||
'MariaDB match' => [
|
||||
'MariaDb100000',
|
||||
'MariaDb100000',
|
||||
],
|
||||
'MariaDB stripg' => [
|
||||
'MariaDb109900',
|
||||
'MariaDb100000',
|
||||
],
|
||||
'MariaDB fallback' => [
|
||||
'MariaDb990000',
|
||||
'MariaDb100300',
|
||||
],
|
||||
'Invalid' => [
|
||||
'Sql',
|
||||
null,
|
||||
],
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider contextNamesProvider
|
||||
*/
|
||||
public function testLoadAll(string $context): void
|
||||
{
|
||||
Context::load($context);
|
||||
$this->assertEquals('\\PhpMyAdmin\\SqlParser\\Contexts\\Context' . $context, Context::$loadedContext);
|
||||
|
||||
// Restoring context.
|
||||
Context::load('');
|
||||
}
|
||||
|
||||
/**
|
||||
* @return string[][]
|
||||
*/
|
||||
public static function contextNamesProvider(): array
|
||||
{
|
||||
return [
|
||||
['MySql50000'],
|
||||
['MySql50100'],
|
||||
['MySql50500'],
|
||||
['MySql50600'],
|
||||
['MySql50700'],
|
||||
['MySql80000'],
|
||||
['MySql80100'],
|
||||
['MySql80200'],
|
||||
['MySql80300'],
|
||||
['MySql80400'],
|
||||
['MySql90000'],
|
||||
['MySql90100'],
|
||||
['MariaDb100000'],
|
||||
['MariaDb100100'],
|
||||
['MariaDb100200'],
|
||||
['MariaDb100300'],
|
||||
['MariaDb100400'],
|
||||
['MariaDb100500'],
|
||||
['MariaDb100600'],
|
||||
['MariaDb100700'],
|
||||
['MariaDb100800'],
|
||||
['MariaDb100900'],
|
||||
['MariaDb101000'],
|
||||
['MariaDb101100'],
|
||||
['MariaDb110000'],
|
||||
['MariaDb110100'],
|
||||
['MariaDb110200'],
|
||||
['MariaDb110300'],
|
||||
['MariaDb110400'],
|
||||
['MariaDb110500'],
|
||||
['MariaDb110600'],
|
||||
['MariaDb110700'],
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider contextClassesProvider
|
||||
*/
|
||||
public function testLoadAllByClass(string $context): void
|
||||
{
|
||||
Context::load($context);
|
||||
$this->assertEquals('\\' . $context, Context::$loadedContext);
|
||||
|
||||
// Restoring context.
|
||||
Context::load('');
|
||||
}
|
||||
|
||||
/**
|
||||
* @return string[][]
|
||||
*/
|
||||
public static function contextClassesProvider(): array
|
||||
{
|
||||
return [
|
||||
[Contexts\ContextMySql50000::class],
|
||||
[Contexts\ContextMySql50100::class],
|
||||
[Contexts\ContextMySql50500::class],
|
||||
[Contexts\ContextMySql50600::class],
|
||||
[Contexts\ContextMySql50700::class],
|
||||
[Contexts\ContextMySql80000::class],
|
||||
[Contexts\ContextMySql80100::class],
|
||||
[Contexts\ContextMySql80200::class],
|
||||
[Contexts\ContextMySql80300::class],
|
||||
[Contexts\ContextMySql80400::class],
|
||||
[Contexts\ContextMySql90000::class],
|
||||
[Contexts\ContextMySql90100::class],
|
||||
[Contexts\ContextMariaDb100000::class],
|
||||
[Contexts\ContextMariaDb100100::class],
|
||||
[Contexts\ContextMariaDb100200::class],
|
||||
[Contexts\ContextMariaDb100300::class],
|
||||
[Contexts\ContextMariaDb100400::class],
|
||||
[Contexts\ContextMariaDb100500::class],
|
||||
[Contexts\ContextMariaDb100600::class],
|
||||
[Contexts\ContextMariaDb100700::class],
|
||||
[Contexts\ContextMariaDb100800::class],
|
||||
[Contexts\ContextMariaDb100900::class],
|
||||
[Contexts\ContextMariaDb101000::class],
|
||||
[Contexts\ContextMariaDb101100::class],
|
||||
[Contexts\ContextMariaDb110000::class],
|
||||
[Contexts\ContextMariaDb110100::class],
|
||||
[Contexts\ContextMariaDb110200::class],
|
||||
[Contexts\ContextMariaDb110300::class],
|
||||
[Contexts\ContextMariaDb110400::class],
|
||||
[Contexts\ContextMariaDb110500::class],
|
||||
[Contexts\ContextMariaDb110600::class],
|
||||
[Contexts\ContextMariaDb110700::class],
|
||||
];
|
||||
}
|
||||
|
||||
public function testLoadError(): void
|
||||
{
|
||||
$this->expectExceptionMessage(
|
||||
'Specified context ("\PhpMyAdmin\SqlParser\Contexts\ContextFoo") does not exist.'
|
||||
);
|
||||
$this->expectException(Throwable::class);
|
||||
Context::load('Foo');
|
||||
}
|
||||
|
||||
/**
|
||||
* @param int|string $mode
|
||||
*
|
||||
* @dataProvider providerForTestMode
|
||||
*/
|
||||
public function testMode($mode, int $expected): void
|
||||
{
|
||||
Context::setMode($mode);
|
||||
$this->assertSame($expected, Context::getMode());
|
||||
}
|
||||
|
||||
/**
|
||||
* @return array<int, array<int, int|string>>
|
||||
* @psalm-return list<array{int|string, int}>
|
||||
*/
|
||||
public static function providerForTestMode(): array
|
||||
{
|
||||
return [
|
||||
[0, Context::SQL_MODE_NONE],
|
||||
[1, 1],
|
||||
['', Context::SQL_MODE_NONE],
|
||||
['invalid', Context::SQL_MODE_NONE],
|
||||
['ALLOW_INVALID_DATES', Context::SQL_MODE_ALLOW_INVALID_DATES],
|
||||
['ANSI_QUOTES', Context::SQL_MODE_ANSI_QUOTES],
|
||||
['COMPAT_MYSQL', Context::SQL_MODE_COMPAT_MYSQL],
|
||||
['ERROR_FOR_DIVISION_BY_ZERO', Context::SQL_MODE_ERROR_FOR_DIVISION_BY_ZERO],
|
||||
['HIGH_NOT_PRECEDENCE', Context::SQL_MODE_HIGH_NOT_PRECEDENCE],
|
||||
['IGNORE_SPACE', Context::SQL_MODE_IGNORE_SPACE],
|
||||
['NO_AUTO_CREATE_USER', Context::SQL_MODE_NO_AUTO_CREATE_USER],
|
||||
['NO_AUTO_VALUE_ON_ZERO', Context::SQL_MODE_NO_AUTO_VALUE_ON_ZERO],
|
||||
['NO_BACKSLASH_ESCAPES', Context::SQL_MODE_NO_BACKSLASH_ESCAPES],
|
||||
['NO_DIR_IN_CREATE', Context::SQL_MODE_NO_DIR_IN_CREATE],
|
||||
['NO_ENGINE_SUBSTITUTION', Context::SQL_MODE_NO_ENGINE_SUBSTITUTION],
|
||||
['NO_FIELD_OPTIONS', Context::SQL_MODE_NO_FIELD_OPTIONS],
|
||||
['NO_KEY_OPTIONS', Context::SQL_MODE_NO_KEY_OPTIONS],
|
||||
['NO_TABLE_OPTIONS', Context::SQL_MODE_NO_TABLE_OPTIONS],
|
||||
['NO_UNSIGNED_SUBTRACTION', Context::SQL_MODE_NO_UNSIGNED_SUBTRACTION],
|
||||
['NO_ZERO_DATE', Context::SQL_MODE_NO_ZERO_DATE],
|
||||
['NO_ZERO_IN_DATE', Context::SQL_MODE_NO_ZERO_IN_DATE],
|
||||
['ONLY_FULL_GROUP_BY', Context::SQL_MODE_ONLY_FULL_GROUP_BY],
|
||||
['PIPES_AS_CONCAT', Context::SQL_MODE_PIPES_AS_CONCAT],
|
||||
['REAL_AS_FLOAT', Context::SQL_MODE_REAL_AS_FLOAT],
|
||||
['STRICT_ALL_TABLES', Context::SQL_MODE_STRICT_ALL_TABLES],
|
||||
['STRICT_TRANS_TABLES', Context::SQL_MODE_STRICT_TRANS_TABLES],
|
||||
['NO_ENCLOSING_QUOTES', Context::SQL_MODE_NO_ENCLOSING_QUOTES],
|
||||
['ANSI', Context::SQL_MODE_ANSI],
|
||||
['DB2', Context::SQL_MODE_DB2],
|
||||
['MAXDB', Context::SQL_MODE_MAXDB],
|
||||
['MSSQL', Context::SQL_MODE_MSSQL],
|
||||
['ORACLE', Context::SQL_MODE_ORACLE],
|
||||
['POSTGRESQL', Context::SQL_MODE_POSTGRESQL],
|
||||
['TRADITIONAL', Context::SQL_MODE_TRADITIONAL],
|
||||
];
|
||||
}
|
||||
|
||||
public function testModeWithCombinedModes(): void
|
||||
{
|
||||
Context::setMode(
|
||||
Context::SQL_MODE_REAL_AS_FLOAT | Context::SQL_MODE_ANSI_QUOTES | Context::SQL_MODE_IGNORE_SPACE
|
||||
);
|
||||
$this->assertSame(
|
||||
Context::SQL_MODE_REAL_AS_FLOAT | Context::SQL_MODE_ANSI_QUOTES | Context::SQL_MODE_IGNORE_SPACE,
|
||||
Context::getMode()
|
||||
);
|
||||
$this->assertTrue(Context::hasMode(Context::SQL_MODE_REAL_AS_FLOAT | Context::SQL_MODE_IGNORE_SPACE));
|
||||
$this->assertTrue(Context::hasMode(Context::SQL_MODE_ANSI_QUOTES));
|
||||
$this->assertFalse(Context::hasMode(Context::SQL_MODE_REAL_AS_FLOAT | Context::SQL_MODE_ALLOW_INVALID_DATES));
|
||||
$this->assertFalse(Context::hasMode(Context::SQL_MODE_ALLOW_INVALID_DATES));
|
||||
|
||||
Context::setMode(Context::SQL_MODE_TRADITIONAL);
|
||||
$this->assertSame(Context::SQL_MODE_TRADITIONAL, Context::getMode());
|
||||
|
||||
Context::setMode();
|
||||
$this->assertSame(Context::SQL_MODE_NONE, Context::getMode());
|
||||
}
|
||||
|
||||
public function testModeWithString(): void
|
||||
{
|
||||
Context::setMode('REAL_AS_FLOAT,ANSI_QUOTES,IGNORE_SPACE');
|
||||
$this->assertSame(
|
||||
Context::SQL_MODE_REAL_AS_FLOAT | Context::SQL_MODE_ANSI_QUOTES | Context::SQL_MODE_IGNORE_SPACE,
|
||||
Context::getMode()
|
||||
);
|
||||
$this->assertTrue(Context::hasMode(Context::SQL_MODE_REAL_AS_FLOAT | Context::SQL_MODE_IGNORE_SPACE));
|
||||
$this->assertTrue(Context::hasMode(Context::SQL_MODE_ANSI_QUOTES));
|
||||
$this->assertFalse(Context::hasMode(Context::SQL_MODE_REAL_AS_FLOAT | Context::SQL_MODE_ALLOW_INVALID_DATES));
|
||||
$this->assertFalse(Context::hasMode(Context::SQL_MODE_ALLOW_INVALID_DATES));
|
||||
|
||||
Context::setMode('TRADITIONAL');
|
||||
$this->assertSame(Context::SQL_MODE_TRADITIONAL, Context::getMode());
|
||||
|
||||
Context::setMode('');
|
||||
$this->assertSame(Context::SQL_MODE_NONE, Context::getMode());
|
||||
}
|
||||
|
||||
public function testEscape(): void
|
||||
{
|
||||
Context::setMode(Context::SQL_MODE_NO_ENCLOSING_QUOTES);
|
||||
$this->assertEquals('test', Context::escape('test'));
|
||||
|
||||
Context::setMode(Context::SQL_MODE_ANSI_QUOTES);
|
||||
$this->assertEquals('"test"', Context::escape('test'));
|
||||
|
||||
Context::setMode();
|
||||
$this->assertEquals('`test`', Context::escape('test'));
|
||||
|
||||
$this->assertEquals(['`a`', '`b`'], Context::escape(['a', 'b']));
|
||||
}
|
||||
}
|
||||
+138
@@ -0,0 +1,138 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Tests\Lexer;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Context;
|
||||
use PhpMyAdmin\SqlParser\Tests\TestCase;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
|
||||
class IsMethodsTest extends TestCase
|
||||
{
|
||||
public function testIsKeyword(): void
|
||||
{
|
||||
$this->assertEquals(1 | Token::FLAG_KEYWORD_RESERVED, Context::isKeyword('SELECT'));
|
||||
$this->assertEquals(1 | Token::FLAG_KEYWORD_RESERVED, Context::isKeyword('ALL'));
|
||||
$this->assertEquals(1 | Token::FLAG_KEYWORD_RESERVED, Context::isKeyword('DISTINCT'));
|
||||
|
||||
$this->assertEquals(
|
||||
1 | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_KEY,
|
||||
Context::isKeyword('PRIMARY KEY')
|
||||
);
|
||||
$this->assertEquals(
|
||||
1 | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
Context::isKeyword('CHARACTER SET')
|
||||
);
|
||||
|
||||
$this->assertEquals(1 | Token::FLAG_KEYWORD_RESERVED, Context::isKeyword('FROM', true));
|
||||
$this->assertNull(Context::isKeyword('MODIFY', true));
|
||||
|
||||
$this->assertNull(Context::isKeyword('foo'));
|
||||
$this->assertNull(Context::isKeyword('bar baz'));
|
||||
}
|
||||
|
||||
public function testIsOperator(): void
|
||||
{
|
||||
$this->assertEquals(Token::FLAG_OPERATOR_ARITHMETIC, Context::isOperator('%'));
|
||||
$this->assertEquals(Token::FLAG_OPERATOR_LOGICAL, Context::isOperator('!'));
|
||||
$this->assertEquals(Token::FLAG_OPERATOR_LOGICAL, Context::isOperator('&&'));
|
||||
$this->assertEquals(Token::FLAG_OPERATOR_LOGICAL, Context::isOperator('<=>'));
|
||||
$this->assertEquals(Token::FLAG_OPERATOR_BITWISE, Context::isOperator('&'));
|
||||
$this->assertEquals(Token::FLAG_OPERATOR_ASSIGNMENT, Context::isOperator(':='));
|
||||
$this->assertEquals(Token::FLAG_OPERATOR_SQL, Context::isOperator(','));
|
||||
|
||||
$this->assertNull(Context::isOperator('a'));
|
||||
}
|
||||
|
||||
public function testIsWhitespace(): void
|
||||
{
|
||||
$this->assertTrue(Context::isWhitespace(' '));
|
||||
$this->assertTrue(Context::isWhitespace("\r"));
|
||||
$this->assertTrue(Context::isWhitespace("\n"));
|
||||
$this->assertTrue(Context::isWhitespace("\t"));
|
||||
|
||||
$this->assertFalse(Context::isWhitespace('a'));
|
||||
$this->assertFalse(Context::isWhitespace("\b"));
|
||||
$this->assertFalse(Context::isWhitespace("\u1000"));
|
||||
}
|
||||
|
||||
public function testIsComment(): void
|
||||
{
|
||||
$this->assertEquals(Token::FLAG_COMMENT_BASH, Context::isComment('#'));
|
||||
$this->assertEquals(Token::FLAG_COMMENT_C, Context::isComment('/*'));
|
||||
$this->assertEquals(Token::FLAG_COMMENT_C, Context::isComment('*/'));
|
||||
$this->assertEquals(Token::FLAG_COMMENT_SQL, Context::isComment('-- '));
|
||||
$this->assertEquals(Token::FLAG_COMMENT_SQL, Context::isComment("--\t"));
|
||||
$this->assertEquals(Token::FLAG_COMMENT_SQL, Context::isComment("--\n"));
|
||||
|
||||
$this->assertEquals(Token::FLAG_COMMENT_BASH, Context::isComment('# a comment'));
|
||||
$this->assertEquals(Token::FLAG_COMMENT_C, Context::isComment('/*comment */'));
|
||||
$this->assertEquals(Token::FLAG_COMMENT_SQL, Context::isComment('-- my comment'));
|
||||
|
||||
$this->assertNull(Context::isComment(''));
|
||||
$this->assertNull(Context::isComment('--not a comment'));
|
||||
}
|
||||
|
||||
public function testIsBool(): void
|
||||
{
|
||||
$this->assertTrue(Context::isBool('true'));
|
||||
$this->assertTrue(Context::isBool('false'));
|
||||
|
||||
$this->assertFalse(Context::isBool('tru'));
|
||||
$this->assertFalse(Context::isBool('falsee'));
|
||||
}
|
||||
|
||||
public function testIsNumber(): void
|
||||
{
|
||||
$this->assertTrue(Context::isNumber('+'));
|
||||
$this->assertTrue(Context::isNumber('-'));
|
||||
$this->assertTrue(Context::isNumber('.'));
|
||||
$this->assertTrue(Context::isNumber('0'));
|
||||
$this->assertTrue(Context::isNumber('1'));
|
||||
$this->assertTrue(Context::isNumber('2'));
|
||||
$this->assertTrue(Context::isNumber('3'));
|
||||
$this->assertTrue(Context::isNumber('4'));
|
||||
$this->assertTrue(Context::isNumber('5'));
|
||||
$this->assertTrue(Context::isNumber('6'));
|
||||
$this->assertTrue(Context::isNumber('7'));
|
||||
$this->assertTrue(Context::isNumber('8'));
|
||||
$this->assertTrue(Context::isNumber('9'));
|
||||
$this->assertTrue(Context::isNumber('e'));
|
||||
$this->assertTrue(Context::isNumber('E'));
|
||||
}
|
||||
|
||||
public function testIsString(): void
|
||||
{
|
||||
$this->assertEquals(Token::FLAG_STRING_SINGLE_QUOTES, Context::isString("'"));
|
||||
$this->assertEquals(Token::FLAG_STRING_DOUBLE_QUOTES, Context::isString('"'));
|
||||
|
||||
$this->assertEquals(Token::FLAG_STRING_SINGLE_QUOTES, Context::isString("'foo bar'"));
|
||||
$this->assertEquals(Token::FLAG_STRING_DOUBLE_QUOTES, Context::isString('"foo bar"'));
|
||||
|
||||
$this->assertNull(Context::isString(''));
|
||||
$this->assertNull(Context::isString('foo bar'));
|
||||
}
|
||||
|
||||
public function testIsSymbol(): void
|
||||
{
|
||||
$this->assertEquals(Token::FLAG_SYMBOL_VARIABLE, Context::isSymbol('@'));
|
||||
$this->assertEquals(Token::FLAG_SYMBOL_BACKTICK, Context::isSymbol('`'));
|
||||
|
||||
$this->assertEquals(Token::FLAG_SYMBOL_VARIABLE, Context::isSymbol('@id'));
|
||||
$this->assertEquals(Token::FLAG_SYMBOL_BACKTICK, Context::isSymbol('`id`'));
|
||||
|
||||
$this->assertNull(Context::isSymbol(''));
|
||||
$this->assertNull(Context::isSymbol('id'));
|
||||
}
|
||||
|
||||
public function testisSeparator(): void
|
||||
{
|
||||
$this->assertTrue(Context::isSeparator('+'));
|
||||
$this->assertTrue(Context::isSeparator('.'));
|
||||
|
||||
$this->assertFalse(Context::isSeparator('1'));
|
||||
$this->assertFalse(Context::isSeparator('E'));
|
||||
$this->assertFalse(Context::isSeparator('_'));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,101 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Tests\Lexer;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Exceptions\LexerException;
|
||||
use PhpMyAdmin\SqlParser\Lexer;
|
||||
use PhpMyAdmin\SqlParser\Tests\TestCase;
|
||||
|
||||
use function sprintf;
|
||||
|
||||
class LexerTest extends TestCase
|
||||
{
|
||||
/**
|
||||
* @runInSeparateProcess
|
||||
* @preserveGlobalState disabled
|
||||
*/
|
||||
public function testError(): void
|
||||
{
|
||||
$lexer = new Lexer('');
|
||||
|
||||
$lexer->error('error #1', 'foo', 1, 2);
|
||||
$lexer->error(
|
||||
sprintf('%2$s #%1$d', 2, 'error'),
|
||||
'bar',
|
||||
3,
|
||||
4
|
||||
);
|
||||
|
||||
$this->assertEquals(
|
||||
$lexer->errors,
|
||||
[
|
||||
new LexerException('error #1', 'foo', 1, 2),
|
||||
new LexerException('error #2', 'bar', 3, 4),
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
public function testErrorStrict(): void
|
||||
{
|
||||
$this->expectExceptionCode(4);
|
||||
$this->expectExceptionMessage('strict error');
|
||||
$this->expectException(LexerException::class);
|
||||
$lexer = new Lexer('');
|
||||
$lexer->strict = true;
|
||||
|
||||
$lexer->error('strict error', 'foo', 1, 4);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider lexProvider
|
||||
*/
|
||||
public function testLex(string $test): void
|
||||
{
|
||||
$this->runParserTest($test);
|
||||
}
|
||||
|
||||
/**
|
||||
* @return string[][]
|
||||
*/
|
||||
public static function lexProvider(): array
|
||||
{
|
||||
return [
|
||||
['lexer/lex'],
|
||||
['lexer/lexUtf8'],
|
||||
['lexer/lexBool'],
|
||||
['lexer/lexComment'],
|
||||
['lexer/lexCommentEnd'],
|
||||
['lexer/lexDelimiter'],
|
||||
['lexer/lexDelimiter2'],
|
||||
['lexer/lexDelimiterErr1'],
|
||||
['lexer/lexDelimiterErr2'],
|
||||
['lexer/lexDelimiterErr3'],
|
||||
['lexer/lexDelimiterLen'],
|
||||
['lexer/lexKeyword'],
|
||||
['lexer/lexKeyword2'],
|
||||
['lexer/lexNumber'],
|
||||
['lexer/lexOperator'],
|
||||
['lexer/lexOperatorStarIsArithmetic'],
|
||||
['lexer/lexOperatorStarIsWildcard'],
|
||||
['lexer/lexEmptyCStyleComment'],
|
||||
['lexer/lexString'],
|
||||
['lexer/lexStringErr1'],
|
||||
['lexer/lexSymbol'],
|
||||
['lexer/lexSymbolErr1'],
|
||||
['lexer/lexSymbolErr2'],
|
||||
['lexer/lexSymbolErr3'],
|
||||
['lexer/lexSymbolUser1'],
|
||||
['lexer/lexSymbolUser2'],
|
||||
['lexer/lexSymbolUser3'],
|
||||
['lexer/lexSymbolUser4_mariadb_100400'],
|
||||
['lexer/lexSymbolUser5_mariadb_100400'],
|
||||
['lexer/lexWhitespace'],
|
||||
['lexer/lexLabel1'],
|
||||
['lexer/lexLabel2'],
|
||||
['lexer/lexNoLabel'],
|
||||
['lexer/lexWildcardThenComment'],
|
||||
];
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,92 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Tests\Lexer;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Tests\TestCase;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
|
||||
class TokenTest extends TestCase
|
||||
{
|
||||
public function testExtractKeyword(): void
|
||||
{
|
||||
$tok = new Token('SelecT', Token::TYPE_KEYWORD, Token::FLAG_KEYWORD_RESERVED);
|
||||
$this->assertEquals($tok->value, 'SELECT');
|
||||
|
||||
$tok = new Token('aS', Token::TYPE_KEYWORD, Token::FLAG_KEYWORD_RESERVED);
|
||||
$this->assertEquals($tok->value, 'AS');
|
||||
}
|
||||
|
||||
public function testExtractWhitespace(): void
|
||||
{
|
||||
$tok = new Token(" \t \r \n ", Token::TYPE_WHITESPACE);
|
||||
$this->assertEquals($tok->value, ' ');
|
||||
}
|
||||
|
||||
public function testExtractBool(): void
|
||||
{
|
||||
$tok = new Token('false', Token::TYPE_BOOL);
|
||||
$this->assertFalse($tok->value);
|
||||
|
||||
$tok = new Token('True', Token::TYPE_BOOL);
|
||||
$this->assertTrue($tok->value);
|
||||
}
|
||||
|
||||
public function testExtractNumber(): void
|
||||
{
|
||||
$tok = new Token('--42', Token::TYPE_NUMBER, Token::FLAG_NUMBER_NEGATIVE);
|
||||
$this->assertEquals($tok->value, 42);
|
||||
|
||||
$tok = new Token('---42', Token::TYPE_NUMBER, Token::FLAG_NUMBER_NEGATIVE);
|
||||
$this->assertEquals($tok->value, -42);
|
||||
|
||||
$tok = new Token('0xFE', Token::TYPE_NUMBER, Token::FLAG_NUMBER_HEX);
|
||||
$this->assertEquals($tok->value, 0xFE);
|
||||
|
||||
$tok = new Token('-0xEF', Token::TYPE_NUMBER, Token::FLAG_NUMBER_NEGATIVE | Token::FLAG_NUMBER_HEX);
|
||||
$this->assertEquals($tok->value, -0xEF);
|
||||
|
||||
$tok = new Token('3.14', Token::TYPE_NUMBER, Token::FLAG_NUMBER_FLOAT);
|
||||
$this->assertEquals($tok->value, 3.14);
|
||||
}
|
||||
|
||||
public function testExtractString(): void
|
||||
{
|
||||
$tok = new Token('"foo bar "', Token::TYPE_STRING);
|
||||
$this->assertEquals($tok->value, 'foo bar ');
|
||||
|
||||
$tok = new Token("' bar foo '", Token::TYPE_STRING);
|
||||
$this->assertEquals($tok->value, ' bar foo ');
|
||||
|
||||
$tok = new Token("'\''", Token::TYPE_STRING);
|
||||
$this->assertEquals($tok->value, '\'');
|
||||
|
||||
$tok = new Token('"\c\d\e\f\g\h\i\j\k\l\m\p\q\s\u\v\w\x\y\z"', Token::TYPE_STRING);
|
||||
$this->assertEquals($tok->value, 'cdefghijklmpqsuvwxyz');
|
||||
}
|
||||
|
||||
public function testExtractSymbol(): void
|
||||
{
|
||||
$tok = new Token('@foo', Token::TYPE_SYMBOL, Token::FLAG_SYMBOL_VARIABLE);
|
||||
$this->assertEquals($tok->value, 'foo');
|
||||
|
||||
$tok = new Token('`foo`', Token::TYPE_SYMBOL, Token::FLAG_SYMBOL_BACKTICK);
|
||||
$this->assertEquals($tok->value, 'foo');
|
||||
|
||||
$tok = new Token('@`foo`', Token::TYPE_SYMBOL, Token::FLAG_SYMBOL_VARIABLE);
|
||||
$this->assertEquals($tok->value, 'foo');
|
||||
|
||||
$tok = new Token(':foo', Token::TYPE_SYMBOL, Token::FLAG_SYMBOL_PARAMETER);
|
||||
$this->assertEquals($tok->value, 'foo');
|
||||
|
||||
$tok = new Token('?', Token::TYPE_SYMBOL, Token::FLAG_SYMBOL_PARAMETER);
|
||||
$this->assertEquals($tok->value, '?');
|
||||
}
|
||||
|
||||
public function testInlineToken(): void
|
||||
{
|
||||
$token = new Token(" \r \n \t ");
|
||||
$this->assertEquals($token->getInlineToken(), ' \r \n \t ');
|
||||
}
|
||||
}
|
||||
+177
@@ -0,0 +1,177 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Tests\Lexer;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Tests\TestCase;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
use function count;
|
||||
|
||||
class TokensListTest extends TestCase
|
||||
{
|
||||
/**
|
||||
* ArrayObj of tokens that are used for testing.
|
||||
*
|
||||
* @var Token[]
|
||||
*/
|
||||
public $tokens;
|
||||
|
||||
/**
|
||||
* Test setup.
|
||||
*/
|
||||
public function setUp(): void
|
||||
{
|
||||
parent::setUp();
|
||||
$this->tokens = [
|
||||
new Token('SELECT', Token::TYPE_KEYWORD),
|
||||
new Token(' ', Token::TYPE_WHITESPACE),
|
||||
new Token('*', Token::TYPE_OPERATOR),
|
||||
new Token(' ', Token::TYPE_WHITESPACE),
|
||||
new Token('FROM', Token::TYPE_KEYWORD, Token::FLAG_KEYWORD_RESERVED),
|
||||
new Token(' ', Token::TYPE_WHITESPACE),
|
||||
new Token('`test`', Token::TYPE_SYMBOL),
|
||||
new Token(' ', Token::TYPE_WHITESPACE),
|
||||
new Token('WHERE', Token::TYPE_KEYWORD, Token::FLAG_KEYWORD_RESERVED),
|
||||
new Token(' ', Token::TYPE_WHITESPACE),
|
||||
new Token('name', Token::TYPE_NONE),
|
||||
new Token('=', Token::TYPE_OPERATOR),
|
||||
new Token('fa', Token::TYPE_NONE),
|
||||
];
|
||||
}
|
||||
|
||||
public function testBuild(): void
|
||||
{
|
||||
$list = new TokensList($this->tokens);
|
||||
$this->assertEquals('SELECT * FROM `test` WHERE name=fa', TokensList::build($list));
|
||||
}
|
||||
|
||||
public function testAdd(): void
|
||||
{
|
||||
$list = new TokensList();
|
||||
foreach ($this->tokens as $token) {
|
||||
$list->add($token);
|
||||
}
|
||||
|
||||
$this->assertEquals(new TokensList($this->tokens), $list);
|
||||
}
|
||||
|
||||
public function testGetNext(): void
|
||||
{
|
||||
$list = new TokensList($this->tokens);
|
||||
$this->assertEquals($this->tokens[0], $list->getNext());
|
||||
$this->assertEquals($this->tokens[2], $list->getNext());
|
||||
$this->assertEquals($this->tokens[4], $list->getNext());
|
||||
$this->assertEquals($this->tokens[6], $list->getNext());
|
||||
$this->assertEquals($this->tokens[8], $list->getNext());
|
||||
$this->assertEquals($this->tokens[10], $list->getNext());
|
||||
$this->assertEquals($this->tokens[11], $list->getNext());
|
||||
$this->assertEquals($this->tokens[12], $list->getNext());
|
||||
$this->assertNull($list->getNext());
|
||||
}
|
||||
|
||||
public function testGetPrevious(): void
|
||||
{
|
||||
$list = new TokensList($this->tokens);
|
||||
$list->idx = 7;
|
||||
$this->assertEquals($this->tokens[6], $list->getPrevious());
|
||||
$this->assertEquals($this->tokens[4], $list->getPrevious());
|
||||
$this->assertEquals($this->tokens[2], $list->getPrevious());
|
||||
$this->assertEquals($this->tokens[0], $list->getPrevious());
|
||||
$this->assertNull($list->getPrevious());
|
||||
}
|
||||
|
||||
public function testGetNextOfType(): void
|
||||
{
|
||||
$list = new TokensList($this->tokens);
|
||||
$this->assertEquals($this->tokens[0], $list->getNextOfType(Token::TYPE_KEYWORD));
|
||||
$this->assertEquals($this->tokens[4], $list->getNextOfType([Token::TYPE_KEYWORD]));
|
||||
$this->assertEquals($this->tokens[6], $list->getNextOfType([Token::TYPE_KEYWORD, Token::TYPE_SYMBOL]));
|
||||
$this->assertEquals($this->tokens[8], $list->getNextOfType([Token::TYPE_KEYWORD, Token::TYPE_SYMBOL]));
|
||||
$this->assertNull($list->getNextOfType(Token::TYPE_KEYWORD));
|
||||
}
|
||||
|
||||
public function testGetPreviousOfType(): void
|
||||
{
|
||||
$list = new TokensList($this->tokens);
|
||||
$list->idx = 9;
|
||||
$this->assertEquals($this->tokens[8], $list->getPreviousOfType([Token::TYPE_KEYWORD, Token::TYPE_SYMBOL]));
|
||||
$this->assertEquals($this->tokens[6], $list->getPreviousOfType([Token::TYPE_KEYWORD, Token::TYPE_SYMBOL]));
|
||||
$this->assertEquals($this->tokens[4], $list->getPreviousOfType([Token::TYPE_KEYWORD]));
|
||||
$this->assertEquals($this->tokens[0], $list->getPreviousOfType(Token::TYPE_KEYWORD));
|
||||
$this->assertNull($list->getPreviousOfType(Token::TYPE_KEYWORD));
|
||||
}
|
||||
|
||||
public function testGetNextOfTypeAndFlag(): void
|
||||
{
|
||||
$list = new TokensList($this->tokens);
|
||||
$this->assertEquals($this->tokens[4], $list->getNextOfTypeAndFlag(
|
||||
Token::TYPE_KEYWORD,
|
||||
Token::FLAG_KEYWORD_RESERVED
|
||||
));
|
||||
$this->assertEquals($this->tokens[8], $list->getNextOfTypeAndFlag(
|
||||
Token::TYPE_KEYWORD,
|
||||
Token::FLAG_KEYWORD_RESERVED
|
||||
));
|
||||
$this->assertNull($list->getNextOfTypeAndFlag(Token::TYPE_KEYWORD, Token::FLAG_KEYWORD_RESERVED));
|
||||
}
|
||||
|
||||
public function testGetNextOfTypeAndValue(): void
|
||||
{
|
||||
$list = new TokensList($this->tokens);
|
||||
$this->assertEquals($this->tokens[0], $list->getNextOfTypeAndValue(Token::TYPE_KEYWORD, 'SELECT'));
|
||||
$this->assertNull($list->getNextOfTypeAndValue(Token::TYPE_KEYWORD, 'SELECT'));
|
||||
}
|
||||
|
||||
public function testArrayAccess(): void
|
||||
{
|
||||
$list = new TokensList();
|
||||
|
||||
// offsetSet(NULL, $value)
|
||||
foreach ($this->tokens as $token) {
|
||||
$list[] = $token;
|
||||
}
|
||||
|
||||
// offsetSet($offset, $value)
|
||||
$list[2] = $this->tokens[2];
|
||||
|
||||
// offsetSet($offset, $value) with overflowed offset
|
||||
$list[$list->count] = $this->tokens[1];
|
||||
$this->assertSame($list[$list->count - 1], $this->tokens[1]);
|
||||
$this->assertSame($list->count, count($this->tokens) + 1);
|
||||
|
||||
// offsetGet($offset) with negative offset
|
||||
$this->assertNull($list[-1]);
|
||||
|
||||
// offsetGet($offset) with overflow offset
|
||||
$this->assertNull($list[$list->count]);
|
||||
|
||||
// offsetGet($offset)
|
||||
for ($i = 0, $count = count($this->tokens); $i < $count; ++$i) {
|
||||
$this->assertSame($this->tokens[$i], $list[$i]);
|
||||
}
|
||||
|
||||
// offsetExists($offset)
|
||||
$this->assertArrayHasKey(2, $list);
|
||||
$this->assertArrayNotHasKey(14, $list);
|
||||
$this->assertArrayNotHasKey(-8, $list);
|
||||
|
||||
// offsetUnset($offset)
|
||||
$currentCountTokens = $list->count;
|
||||
unset($list[2]);
|
||||
$newCountTokens = $list->count;
|
||||
$this->assertSame($this->tokens[3], $list[2]);
|
||||
$this->assertSame($currentCountTokens - 1, $newCountTokens);
|
||||
|
||||
// offsetUnset($offset) with invalid offset (negative or overflowed)
|
||||
$currentListTokens = $list->tokens;
|
||||
unset($list[-1]);
|
||||
$this->assertSame($currentListTokens, $list->tokens);
|
||||
$this->assertSame($newCountTokens, $list->count); // No unset actually performed.
|
||||
unset($list[999]);
|
||||
$this->assertSame($currentListTokens, $list->tokens);
|
||||
$this->assertSame($newCountTokens, $list->count); // No unset actually performed.
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user