class ConnectionTest

class ConnectionTest extends UnitTestCase {
    
    /**
     * Data provider for testPrefixRoundTrip().
     *
     * @return array
     *   Array of arrays with the following elements:
     *   - Arguments to pass to Connection::setPrefix().
     *   - Expected result from Connection::tablePrefix().
     */
    public static function providerPrefixRoundTrip() {
        return [
            [
                [
                    '' => 'test_',
                ],
                'test_',
            ],
            [
                [
                    'fooTable' => 'foo_',
                    'barTable' => 'foo_',
                ],
                'foo_',
            ],
        ];
    }
    
    /**
     * Exercise setPrefix() and tablePrefix().
     *
     * @dataProvider providerPrefixRoundTrip
     */
    public function testPrefixRoundTrip($expected, $prefix_info) : void {
        $mock_pdo = $this->createMock('Drupal\\Tests\\Core\\Database\\Stub\\StubPDO');
        $connection = new StubConnection($mock_pdo, []);
        // setPrefix() is protected, so we make it accessible with reflection.
        $reflection = new \ReflectionClass('Drupal\\Tests\\Core\\Database\\Stub\\StubConnection');
        $set_prefix = $reflection->getMethod('setPrefix');
        // Set the prefix data.
        $set_prefix->invokeArgs($connection, [
            $prefix_info,
        ]);
        // Check the round-trip.
        foreach ($expected as $table => $prefix) {
            $this->assertEquals($prefix, $connection->getPrefix());
        }
    }
    
    /**
     * Data provider for testPrefixTables().
     *
     * @return array
     *   Array of arrays with the following elements:
     *   - Expected result.
     *   - Table prefix.
     *   - Query to be prefixed.
     *   - Quote identifier.
     */
    public static function providerTestPrefixTables() {
        return [
            [
                'SELECT * FROM test_table',
                'test_',
                'SELECT * FROM {table}',
                [
                    '',
                    '',
                ],
            ],
            [
                'SELECT * FROM "test_table"',
                'test_',
                'SELECT * FROM {table}',
                [
                    '"',
                    '"',
                ],
            ],
            [
                "SELECT * FROM 'test_table'",
                'test_',
                'SELECT * FROM {table}',
                [
                    "'",
                    "'",
                ],
            ],
            [
                "SELECT * FROM [test_table]",
                'test_',
                'SELECT * FROM {table}',
                [
                    '[',
                    ']',
                ],
            ],
        ];
    }
    
    /**
     * Exercise the prefixTables() method.
     *
     * @dataProvider providerTestPrefixTables
     */
    public function testPrefixTables($expected, $prefix_info, $query, array $quote_identifier = [
        '"',
        '"',
    ]) : void {
        $mock_pdo = $this->createMock('Drupal\\Tests\\Core\\Database\\Stub\\StubPDO');
        $connection = new StubConnection($mock_pdo, [
            'prefix' => $prefix_info,
        ], $quote_identifier);
        $this->assertEquals($expected, $connection->prefixTables($query));
    }
    
    /**
     * Data provider for testGetDriverClass().
     *
     * @return array
     *   Array of arrays with the following elements:
     *   - Expected namespaced class name.
     *   - Namespace.
     *   - Class name without namespace.
     */
    public static function providerGetDriverClass() {
        return [
            [
                'nonexistent_class',
                '\\',
                'nonexistent_class',
            ],
            [
                'Drupal\\Tests\\Core\\Database\\Stub\\Select',
                NULL,
                'Select',
            ],
            // Tests with the CoreFake database driver. This driver has no custom
            // driver classes.
[
                'Drupal\\Core\\Database\\Query\\Condition',
                'Drupal\\CoreFake\\Driver\\Database\\CoreFake',
                'Condition',
            ],
            [
                'Drupal\\Core\\Database\\Query\\Delete',
                'Drupal\\CoreFake\\Driver\\Database\\CoreFake',
                'Delete',
            ],
            [
                'Drupal\\Core\\Database\\ExceptionHandler',
                'Drupal\\CoreFake\\Driver\\Database\\CoreFake',
                'ExceptionHandler',
            ],
            [
                'Drupal\\Core\\Database\\Query\\Insert',
                'Drupal\\CoreFake\\Driver\\Database\\CoreFake',
                'Insert',
            ],
            [
                'Drupal\\Core\\Database\\Query\\Merge',
                'Drupal\\CoreFake\\Driver\\Database\\CoreFake',
                'Merge',
            ],
            [
                'PagerSelectExtender',
                'Drupal\\CoreFake\\Driver\\Database\\CoreFake',
                'PagerSelectExtender',
            ],
            [
                'Drupal\\Core\\Database\\Schema',
                'Drupal\\CoreFake\\Driver\\Database\\CoreFake',
                'Schema',
            ],
            [
                'SearchQuery',
                'Drupal\\CoreFake\\Driver\\Database\\CoreFake',
                'SearchQuery',
            ],
            [
                'Drupal\\Core\\Database\\Query\\Select',
                'Drupal\\CoreFake\\Driver\\Database\\CoreFake',
                'Select',
            ],
            [
                'Drupal\\Core\\Database\\Transaction',
                'Drupal\\CoreFake\\Driver\\Database\\CoreFake',
                'Transaction',
            ],
            [
                'TableSortExtender',
                'Drupal\\CoreFake\\Driver\\Database\\CoreFake',
                'TableSortExtender',
            ],
            [
                'Drupal\\Core\\Database\\Query\\Truncate',
                'Drupal\\CoreFake\\Driver\\Database\\CoreFake',
                'Truncate',
            ],
            [
                'Drupal\\Core\\Database\\Query\\Update',
                'Drupal\\CoreFake\\Driver\\Database\\CoreFake',
                'Update',
            ],
            [
                'Drupal\\Core\\Database\\Query\\Upsert',
                'Drupal\\CoreFake\\Driver\\Database\\CoreFake',
                'Upsert',
            ],
            // Tests with the CoreFakeWithAllCustomClasses database driver. This
            // driver has custom driver classes for all classes.
[
                'Drupal\\core_fake\\Driver\\Database\\CoreFakeWithAllCustomClasses\\Condition',
                'Drupal\\core_fake\\Driver\\Database\\CoreFakeWithAllCustomClasses',
                'Condition',
            ],
            [
                'Drupal\\core_fake\\Driver\\Database\\CoreFakeWithAllCustomClasses\\Delete',
                'Drupal\\core_fake\\Driver\\Database\\CoreFakeWithAllCustomClasses',
                'Delete',
            ],
            [
                'Drupal\\core_fake\\Driver\\Database\\CoreFakeWithAllCustomClasses\\ExceptionHandler',
                'Drupal\\core_fake\\Driver\\Database\\CoreFakeWithAllCustomClasses',
                'ExceptionHandler',
            ],
            [
                'Drupal\\core_fake\\Driver\\Database\\CoreFakeWithAllCustomClasses\\Insert',
                'Drupal\\core_fake\\Driver\\Database\\CoreFakeWithAllCustomClasses',
                'Insert',
            ],
            [
                'Drupal\\core_fake\\Driver\\Database\\CoreFakeWithAllCustomClasses\\Merge',
                'Drupal\\core_fake\\Driver\\Database\\CoreFakeWithAllCustomClasses',
                'Merge',
            ],
            [
                'Drupal\\core_fake\\Driver\\Database\\CoreFakeWithAllCustomClasses\\PagerSelectExtender',
                'Drupal\\core_fake\\Driver\\Database\\CoreFakeWithAllCustomClasses',
                'PagerSelectExtender',
            ],
            [
                'Drupal\\core_fake\\Driver\\Database\\CoreFakeWithAllCustomClasses\\Schema',
                'Drupal\\core_fake\\Driver\\Database\\CoreFakeWithAllCustomClasses',
                'Schema',
            ],
            [
                'Drupal\\core_fake\\Driver\\Database\\CoreFakeWithAllCustomClasses\\SearchQuery',
                'Drupal\\core_fake\\Driver\\Database\\CoreFakeWithAllCustomClasses',
                'SearchQuery',
            ],
            [
                'Drupal\\core_fake\\Driver\\Database\\CoreFakeWithAllCustomClasses\\Select',
                'Drupal\\core_fake\\Driver\\Database\\CoreFakeWithAllCustomClasses',
                'Select',
            ],
            [
                'Drupal\\core_fake\\Driver\\Database\\CoreFakeWithAllCustomClasses\\TableSortExtender',
                'Drupal\\core_fake\\Driver\\Database\\CoreFakeWithAllCustomClasses',
                'TableSortExtender',
            ],
            [
                'Drupal\\core_fake\\Driver\\Database\\CoreFakeWithAllCustomClasses\\Transaction',
                'Drupal\\core_fake\\Driver\\Database\\CoreFakeWithAllCustomClasses',
                'Transaction',
            ],
            [
                'Drupal\\core_fake\\Driver\\Database\\CoreFakeWithAllCustomClasses\\Truncate',
                'Drupal\\core_fake\\Driver\\Database\\CoreFakeWithAllCustomClasses',
                'Truncate',
            ],
            [
                'Drupal\\core_fake\\Driver\\Database\\CoreFakeWithAllCustomClasses\\Update',
                'Drupal\\core_fake\\Driver\\Database\\CoreFakeWithAllCustomClasses',
                'Update',
            ],
            [
                'Drupal\\core_fake\\Driver\\Database\\CoreFakeWithAllCustomClasses\\Upsert',
                'Drupal\\core_fake\\Driver\\Database\\CoreFakeWithAllCustomClasses',
                'Upsert',
            ],
            [
                'Drupal\\Core\\Database\\Query\\PagerSelectExtender',
                'Drupal\\core_fake\\Driver\\Database\\CoreFakeWithAllCustomClasses',
                'Drupal\\Core\\Database\\Query\\PagerSelectExtender',
            ],
            [
                '\\Drupal\\Core\\Database\\Query\\PagerSelectExtender',
                'Drupal\\core_fake\\Driver\\Database\\CoreFakeWithAllCustomClasses',
                '\\Drupal\\Core\\Database\\Query\\PagerSelectExtender',
            ],
            [
                'Drupal\\Core\\Database\\Query\\TableSortExtender',
                'Drupal\\core_fake\\Driver\\Database\\CoreFakeWithAllCustomClasses',
                'Drupal\\Core\\Database\\Query\\TableSortExtender',
            ],
            [
                '\\Drupal\\Core\\Database\\Query\\TableSortExtender',
                'Drupal\\core_fake\\Driver\\Database\\CoreFakeWithAllCustomClasses',
                '\\Drupal\\Core\\Database\\Query\\TableSortExtender',
            ],
            [
                'Drupal\\search\\SearchQuery',
                'Drupal\\core_fake\\Driver\\Database\\CoreFakeWithAllCustomClasses',
                'Drupal\\search\\SearchQuery',
            ],
            [
                '\\Drupal\\search\\SearchQuery',
                'Drupal\\core_fake\\Driver\\Database\\CoreFakeWithAllCustomClasses',
                '\\Drupal\\search\\SearchQuery',
            ],
        ];
    }
    
    /**
     * @covers ::getDriverClass
     * @dataProvider providerGetDriverClass
     * @group legacy
     */
    public function testGetDriverClass($expected, $namespace, $class) : void {
        $additional_class_loader = new ClassLoader();
        $additional_class_loader->addPsr4("Drupal\\core_fake\\Driver\\Database\\CoreFake\\", __DIR__ . "/../../../../../tests/fixtures/database_drivers/module/core_fake/src/Driver/Database/CoreFake");
        $additional_class_loader->addPsr4("Drupal\\core_fake\\Driver\\Database\\CoreFakeWithAllCustomClasses\\", __DIR__ . "/../../../../../tests/fixtures/database_drivers/module/core_fake/src/Driver/Database/CoreFakeWithAllCustomClasses");
        $additional_class_loader->register(TRUE);
        $mock_pdo = $this->createMock('Drupal\\Tests\\Core\\Database\\Stub\\StubPDO');
        $connection = new StubConnection($mock_pdo, [
            'namespace' => $namespace,
        ]);
        match ($class) {    'Install\\Tasks', 'ExceptionHandler', 'Select', 'Insert', 'Merge', 'Upsert', 'Update', 'Delete', 'Truncate', 'Schema', 'Condition', 'Transaction' => $this->expectDeprecation('Calling Drupal\\Core\\Database\\Connection::getDriverClass() for \'' . $class . '\' is deprecated in drupal:10.2.0 and is removed from drupal:11.0.0. Use standard autoloading in the methods that return database operations. See https://www.drupal.org/node/3217534'),
            default => NULL,
        
        };
        $this->assertEquals($expected, $connection->getDriverClass($class));
    }
    
    /**
     * Data provider for testSchema().
     *
     * @return array
     *   Array of arrays with the following elements:
     *   - Expected namespaced class of schema object.
     *   - Driver for PDO connection.
     *   - Namespace for connection.
     */
    public static function providerSchema() {
        return [
            [
                'Drupal\\Tests\\Core\\Database\\Stub\\Driver\\Schema',
                'stub',
                'Drupal\\Tests\\Core\\Database\\Stub\\Driver',
            ],
        ];
    }
    
    /**
     * Tests Connection::schema().
     *
     * @dataProvider providerSchema
     */
    public function testSchema($expected, $driver, $namespace) : void {
        $mock_pdo = $this->createMock('Drupal\\Tests\\Core\\Database\\Stub\\StubPDO');
        $connection = new StubConnection($mock_pdo, [
            'namespace' => $namespace,
        ]);
        $connection->driver = $driver;
        $this->assertInstanceOf($expected, $connection->schema());
    }
    
    /**
     * Data provider for testMakeComments().
     *
     * @return array
     *   Array of arrays with the following elements:
     *   - Expected filtered comment.
     *   - Arguments for Connection::makeComment().
     */
    public static function providerMakeComments() {
        return [
            [
                '/*  */ ',
                [
                    '',
                ],
            ],
            [
                '/* Exploit  *  / DROP TABLE node. -- */ ',
                [
                    'Exploit * / DROP TABLE node; --',
                ],
            ],
            [
                '/* Exploit  *  / DROP TABLE node. --. another comment */ ',
                [
                    'Exploit * / DROP TABLE node; --',
                    'another comment',
                ],
            ],
        ];
    }
    
    /**
     * Tests Connection::makeComments().
     *
     * @dataProvider providerMakeComments
     */
    public function testMakeComments($expected, $comment_array) : void {
        $mock_pdo = $this->createMock('Drupal\\Tests\\Core\\Database\\Stub\\StubPDO');
        $connection = new StubConnection($mock_pdo, []);
        $this->assertEquals($expected, $connection->makeComment($comment_array));
    }
    
    /**
     * Data provider for testFilterComments().
     *
     * @return array
     *   Array of arrays with the following elements:
     *   - Expected filtered comment.
     *   - Comment to filter.
     */
    public static function providerFilterComments() {
        return [
            [
                '',
                '',
            ],
            [
                'Exploit  *  / DROP TABLE node. --',
                'Exploit * / DROP TABLE node; --',
            ],
            [
                'Exploit  * / DROP TABLE node. --',
                'Exploit */ DROP TABLE node; --',
            ],
        ];
    }
    
    /**
     * Tests Connection::filterComments().
     *
     * @dataProvider providerFilterComments
     */
    public function testFilterComments($expected, $comment) : void {
        $mock_pdo = $this->createMock('Drupal\\Tests\\Core\\Database\\Stub\\StubPDO');
        $connection = new StubConnection($mock_pdo, []);
        // filterComment() is protected, so we make it accessible with reflection.
        $reflection = new \ReflectionClass('Drupal\\Tests\\Core\\Database\\Stub\\StubConnection');
        $filter_comment = $reflection->getMethod('filterComment');
        $this->assertEquals($expected, $filter_comment->invokeArgs($connection, [
            $comment,
        ]));
    }
    
    /**
     * Data provider for testEscapeTable.
     *
     * @return array
     *   An indexed array of where each value is an array of arguments to pass to
     *   testEscapeField. The first value is the expected value, and the second
     *   value is the value to test.
     */
    public static function providerEscapeTables() {
        return [
            [
                'nocase',
                'nocase',
            ],
            [
                'camelCase',
                'camelCase',
            ],
            [
                'backtick',
                '`backtick`',
                [
                    '`',
                    '`',
                ],
            ],
            [
                'brackets',
                '[brackets]',
                [
                    '[',
                    ']',
                ],
            ],
            [
                'camelCase',
                '"camelCase"',
            ],
            [
                'camelCase',
                'camel/Case',
            ],
            // Sometimes, table names are following the pattern database.schema.table.
[
                'camelCase.nocase.nocase',
                'camelCase.nocase.nocase',
            ],
            [
                'nocase.camelCase.nocase',
                'nocase.camelCase.nocase',
            ],
            [
                'nocase.nocase.camelCase',
                'nocase.nocase.camelCase',
            ],
            [
                'camelCase.camelCase.camelCase',
                'camelCase.camelCase.camelCase',
            ],
        ];
    }
    
    /**
     * @covers ::escapeTable
     * @dataProvider providerEscapeTables
     */
    public function testEscapeTable($expected, $name, array $identifier_quote = [
        '"',
        '"',
    ]) : void {
        $mock_pdo = $this->createMock(StubPDO::class);
        $connection = new StubConnection($mock_pdo, [], $identifier_quote);
        $this->assertEquals($expected, $connection->escapeTable($name));
    }
    
    /**
     * Data provider for testEscapeAlias.
     *
     * @return array
     *   Array of arrays with the following elements:
     *   - Expected escaped string.
     *   - String to escape.
     */
    public static function providerEscapeAlias() {
        return [
            [
                '!nocase!',
                'nocase',
                [
                    '!',
                    '!',
                ],
            ],
            [
                '`backtick`',
                'backtick',
                [
                    '`',
                    '`',
                ],
            ],
            [
                'nocase',
                'nocase',
                [
                    '',
                    '',
                ],
            ],
            [
                '[brackets]',
                'brackets',
                [
                    '[',
                    ']',
                ],
            ],
            [
                '"camelCase"',
                '"camelCase"',
            ],
            [
                '"camelCase"',
                'camelCase',
            ],
            [
                '"camelCase"',
                'camel.Case',
            ],
        ];
    }
    
    /**
     * @covers ::escapeAlias
     * @dataProvider providerEscapeAlias
     */
    public function testEscapeAlias($expected, $name, array $identifier_quote = [
        '"',
        '"',
    ]) : void {
        $mock_pdo = $this->createMock(StubPDO::class);
        $connection = new StubConnection($mock_pdo, [], $identifier_quote);
        $this->assertEquals($expected, $connection->escapeAlias($name));
    }
    
    /**
     * Data provider for testEscapeField.
     *
     * @return array
     *   Array of arrays with the following elements:
     *   - Expected escaped string.
     *   - String to escape.
     */
    public static function providerEscapeFields() {
        return [
            [
                '/title/',
                'title',
                [
                    '/',
                    '/',
                ],
            ],
            [
                '`backtick`',
                'backtick',
                [
                    '`',
                    '`',
                ],
            ],
            [
                'test.title',
                'test.title',
                [
                    '',
                    '',
                ],
            ],
            [
                '"isDefaultRevision"',
                'isDefaultRevision',
            ],
            [
                '"isDefaultRevision"',
                '"isDefaultRevision"',
            ],
            [
                '"entity_test"."isDefaultRevision"',
                'entity_test.isDefaultRevision',
            ],
            [
                '"entity_test"."isDefaultRevision"',
                '"entity_test"."isDefaultRevision"',
            ],
            [
                '"entityTest"."isDefaultRevision"',
                '"entityTest"."isDefaultRevision"',
            ],
            [
                '"entityTest"."isDefaultRevision"',
                'entityTest.isDefaultRevision',
            ],
            [
                '[entityTest].[isDefaultRevision]',
                'entityTest.isDefaultRevision',
                [
                    '[',
                    ']',
                ],
            ],
        ];
    }
    
    /**
     * @covers ::escapeField
     * @dataProvider providerEscapeFields
     */
    public function testEscapeField($expected, $name, array $identifier_quote = [
        '"',
        '"',
    ]) : void {
        $mock_pdo = $this->createMock(StubPDO::class);
        $connection = new StubConnection($mock_pdo, [], $identifier_quote);
        $this->assertEquals($expected, $connection->escapeField($name));
    }
    
    /**
     * Data provider for testEscapeDatabase.
     *
     * @return array
     *   An indexed array of where each value is an array of arguments to pass to
     *   testEscapeField. The first value is the expected value, and the second
     *   value is the value to test.
     */
    public static function providerEscapeDatabase() {
        return [
            [
                '/name/',
                'name',
                [
                    '/',
                    '/',
                ],
            ],
            [
                '`backtick`',
                'backtick',
                [
                    '`',
                    '`',
                ],
            ],
            [
                'anything',
                'any.thing',
                [
                    '',
                    '',
                ],
            ],
            [
                '"name"',
                'name',
            ],
            [
                '[name]',
                'name',
                [
                    '[',
                    ']',
                ],
            ],
        ];
    }
    
    /**
     * @covers ::escapeDatabase
     * @dataProvider providerEscapeDatabase
     */
    public function testEscapeDatabase($expected, $name, array $identifier_quote = [
        '"',
        '"',
    ]) : void {
        $mock_pdo = $this->createMock(StubPDO::class);
        $connection = new StubConnection($mock_pdo, [], $identifier_quote);
        $this->assertEquals($expected, $connection->escapeDatabase($name));
    }
    
    /**
     * @covers ::__construct
     */
    public function testIdentifierQuotesAssertCount() : void {
        $this->expectException(\AssertionError::class);
        $this->expectExceptionMessage('\\Drupal\\Core\\Database\\Connection::$identifierQuotes must contain 2 string values');
        $mock_pdo = $this->createMock(StubPDO::class);
        new StubConnection($mock_pdo, [], [
            '"',
        ]);
    }
    
    /**
     * @covers ::__construct
     */
    public function testIdentifierQuotesAssertString() : void {
        $this->expectException(\AssertionError::class);
        $this->expectExceptionMessage('\\Drupal\\Core\\Database\\Connection::$identifierQuotes must contain 2 string values');
        $mock_pdo = $this->createMock(StubPDO::class);
        new StubConnection($mock_pdo, [], [
            0,
            '1',
        ]);
    }
    
    /**
     * @covers ::__construct
     */
    public function testNamespaceDefault() : void {
        $mock_pdo = $this->createMock(StubPDO::class);
        $connection = new StubConnection($mock_pdo, []);
        $this->assertSame('Drupal\\Tests\\Core\\Database\\Stub', $connection->getConnectionOptions()['namespace']);
    }
    
    /**
     * Test rtrim() of query strings.
     *
     * @dataProvider provideQueriesToTrim
     */
    public function testQueryTrim($expected, $query, $options) : void {
        $mock_pdo = $this->getMockBuilder(StubPdo::class)
            ->getMock();
        $connection = new StubConnection($mock_pdo, []);
        $preprocess_method = new \ReflectionMethod($connection, 'preprocessStatement');
        $this->assertSame($expected, $preprocess_method->invoke($connection, $query, $options));
    }
    
    /**
     * Data provider for testQueryTrim().
     *
     * @return array
     *   Array of arrays with the following elements:
     *   - Expected trimmed query.
     *   - Padded query.
     *   - Query options.
     */
    public static function provideQueriesToTrim() {
        return [
            'remove_non_breaking_space' => [
                'SELECT * FROM test',
                "SELECT * FROM test\xa0",
                [],
            ],
            'remove_ordinary_space' => [
                'SELECT * FROM test',
                'SELECT * FROM test ',
                [],
            ],
            'remove_semicolon' => [
                'SELECT * FROM test',
                'SELECT * FROM test;',
                [],
            ],
            'keep_trailing_semicolon' => [
                'SELECT * FROM test;',
                'SELECT * FROM test;',
                [
                    'allow_delimiter_in_query' => TRUE,
                ],
            ],
            'remove_semicolon_with_whitespace' => [
                'SELECT * FROM test',
                'SELECT * FROM test; ',
                [],
            ],
            'keep_trailing_semicolon_with_whitespace' => [
                'SELECT * FROM test;',
                'SELECT * FROM test; ',
                [
                    'allow_delimiter_in_query' => TRUE,
                ],
            ],
        ];
    }
    
    /**
     * Tests that the proper caller is retrieved from the backtrace.
     *
     * @covers ::findCallerFromDebugBacktrace
     * @covers ::removeDatabaseEntriesFromDebugBacktrace
     * @covers ::getDebugBacktrace
     */
    public function testFindCallerFromDebugBacktrace() : void {
        Database::addConnectionInfo('default', 'default', [
            'driver' => 'test',
            'namespace' => 'Drupal\\Tests\\Core\\Database\\Stub',
        ]);
        $connection = new StubConnection($this->createMock(StubPDO::class), []);
        $result = $connection->findCallerFromDebugBacktrace();
        $this->assertSame([
            'file' => __FILE__,
            'line' => __LINE__ - 3,
            'function' => 'testFindCallerFromDebugBacktrace',
            'class' => 'Drupal\\Tests\\Core\\Database\\ConnectionTest',
            'type' => '->',
            'args' => [],
        ], $result);
    }
    
    /**
     * Tests that a log called by a custom database driver returns proper caller.
     *
     * @param string $driver_namespace
     *   The driver namespace to be tested.
     * @param array $stack
     *   A test debug_backtrace stack.
     * @param array $expected_entry
     *   The expected stack entry.
     *
     * @covers ::findCallerFromDebugBacktrace
     * @covers ::removeDatabaseEntriesFromDebugBacktrace
     *
     * @dataProvider providerMockedBacktrace
     *
     * @group legacy
     */
    public function testFindCallerFromDebugBacktraceWithMockedBacktrace(string $driver_namespace, array $stack, array $expected_entry) : void {
        $mock_builder = $this->getMockBuilder(StubConnection::class);
        $connection = $mock_builder->onlyMethods([
            'getDebugBacktrace',
            'getConnectionOptions',
        ])
            ->setConstructorArgs([
            $this->createMock(StubPDO::class),
            [],
        ])
            ->getMock();
        $connection->expects($this->once())
            ->method('getConnectionOptions')
            ->willReturn([
            'driver' => 'test',
            'namespace' => $driver_namespace,
        ]);
        $connection->expects($this->once())
            ->method('getDebugBacktrace')
            ->willReturn($stack);
        $result = $connection->findCallerFromDebugBacktrace();
        $this->assertEquals($expected_entry, $result);
    }
    
    /**
     * Provides data for testFindCallerFromDebugBacktraceWithMockedBacktrace.
     *
     * @return array[]
     *   A associative array of simple arrays, each having the following elements:
     *   - the contrib driver PHP namespace
     *   - a test debug_backtrace stack
     *   - the stack entry expected to be returned.
     *
     * @see ::testFindCallerFromDebugBacktraceWithMockedBacktrace()
     */
    public static function providerMockedBacktrace() : array {
        $stack = [
            [
                'file' => '/var/www/core/lib/Drupal/Core/Database/Log.php',
                'line' => 125,
                'function' => 'findCaller',
                'class' => 'Drupal\\Core\\Database\\Log',
                'object' => 'test',
                'type' => '->',
                'args' => [
                    0 => 'test',
                ],
            ],
            [
                'file' => '/var/www/libraries/test/lib/Statement.php',
                'line' => 264,
                'function' => 'log',
                'class' => 'Drupal\\Core\\Database\\Log',
                'object' => 'test',
                'type' => '->',
                'args' => [
                    0 => 'test',
                ],
            ],
            [
                'file' => '/var/www/libraries/test/lib/Connection.php',
                'line' => 213,
                'function' => 'execute',
                'class' => 'Drupal\\Driver\\Database\\dbal\\Statement',
                'object' => 'test',
                'type' => '->',
                'args' => [
                    0 => 'test',
                ],
            ],
            [
                'file' => '/var/www/core/tests/Drupal/KernelTests/Core/Database/LoggingTest.php',
                'line' => 23,
                'function' => 'query',
                'class' => 'Drupal\\Driver\\Database\\dbal\\Connection',
                'object' => 'test',
                'type' => '->',
                'args' => [
                    0 => 'test',
                ],
            ],
            [
                'file' => '/var/www/vendor/phpunit/phpunit/src/Framework/TestCase.php',
                'line' => 1154,
                'function' => 'testEnableLogging',
                'class' => 'Drupal\\KernelTests\\Core\\Database\\LoggingTest',
                'object' => 'test',
                'type' => '->',
                'args' => [
                    0 => 'test',
                ],
            ],
            [
                'file' => '/var/www/vendor/phpunit/phpunit/src/Framework/TestCase.php',
                'line' => 842,
                'function' => 'runTest',
                'class' => 'PHPUnit\\Framework\\TestCase',
                'object' => 'test',
                'type' => '->',
                'args' => [
                    0 => 'test',
                ],
            ],
            [
                'file' => '/var/www/vendor/phpunit/phpunit/src/Framework/TestResult.php',
                'line' => 693,
                'function' => 'runBare',
                'class' => 'PHPUnit\\Framework\\TestCase',
                'object' => 'test',
                'type' => '->',
                'args' => [
                    0 => 'test',
                ],
            ],
            [
                'file' => '/var/www/vendor/phpunit/phpunit/src/Framework/TestCase.php',
                'line' => 796,
                'function' => 'run',
                'class' => 'PHPUnit\\Framework\\TestResult',
                'object' => 'test',
                'type' => '->',
                'args' => [
                    0 => 'test',
                ],
            ],
            [
                'file' => 'Standard input code',
                'line' => 57,
                'function' => 'run',
                'class' => 'PHPUnit\\Framework\\TestCase',
                'object' => 'test',
                'type' => '->',
                'args' => [
                    0 => 'test',
                ],
            ],
            [
                'file' => 'Standard input code',
                'line' => 111,
                'function' => '__phpunit_run_isolated_test',
                'args' => [
                    0 => 'test',
                ],
            ],
        ];
        return [
            // Test that if the driver namespace is in the stack trace, the first
            // non-database entry is returned.
'contrib driver namespace' => [
                'Drupal\\Driver\\Database\\dbal',
                $stack,
                [
                    'class' => 'Drupal\\KernelTests\\Core\\Database\\LoggingTest',
                    'function' => 'testEnableLogging',
                    'file' => '/var/www/core/tests/Drupal/KernelTests/Core/Database/LoggingTest.php',
                    'line' => 23,
                    'type' => '->',
                    'args' => [
                        0 => 'test',
                    ],
                ],
            ],
            // Extreme case, should not happen at normal runtime - if the driver
            // namespace is not in the stack trace, the first entry to a method
            // in core database namespace is returned.
'missing driver namespace' => [
                'Drupal\\Driver\\Database\\fake',
                $stack,
                [
                    'class' => 'Drupal\\Driver\\Database\\dbal\\Statement',
                    'function' => 'execute',
                    'file' => '/var/www/libraries/test/lib/Statement.php',
                    'line' => 264,
                    'type' => '->',
                    'args' => [
                        0 => 'test',
                    ],
                ],
            ],
        ];
    }
    
    /**
     * Tests deprecation of the StatementWrapper class.
     *
     * @group legacy
     */
    public function testStatementWrapperDeprecation() : void {
        $this->expectDeprecation('\\Drupal\\Core\\Database\\StatementWrapper is deprecated in drupal:10.1.0 and is removed from drupal:11.0.0. Use \\Drupal\\Core\\Database\\StatementWrapperIterator instead. See https://www.drupal.org/node/3265938');
        $mock_pdo = $this->createMock(StubPDO::class);
        $connection = new StubConnection($mock_pdo, []);
        $this->expectError();
        $connection->prepareStatement('boing', []);
    }
    
    /**
     * Tests deprecation of the StatementPrefetch class.
     *
     * @group legacy
     */
    public function testStatementPrefetchDeprecation() : void {
        $this->expectDeprecation('\\Drupal\\Core\\Database\\StatementPrefetch is deprecated in drupal:10.1.0 and is removed from drupal:11.0.0. Use \\Drupal\\Core\\Database\\StatementPrefetchIterator instead. See https://www.drupal.org/node/3265938');
        $mockPdo = $this->createMock(StubPDO::class);
        $mockConnection = new StubConnection($mockPdo, []);
        $statement = new StatementPrefetch($mockPdo, $mockConnection, '');
        $this->assertInstanceOf(StatementPrefetch::class, $statement);
    }
    
    /**
     * Provides data for testSupportedFetchModes.
     *
     * @return array
     *   An associative array of simple arrays, each having the following
     *   elements:
     *   - a PDO fetch mode.
     */
    public static function providerSupportedFetchModes() : array {
        return [
            'FETCH_ASSOC' => [
                \PDO::FETCH_ASSOC,
            ],
            'FETCH_CLASS' => [
                \PDO::FETCH_CLASS,
            ],
            'FETCH_CLASS | FETCH_PROPS_LATE' => [
                \PDO::FETCH_CLASS | \PDO::FETCH_PROPS_LATE,
            ],
            'FETCH_COLUMN' => [
                \PDO::FETCH_COLUMN,
            ],
            'FETCH_NUM' => [
                \PDO::FETCH_NUM,
            ],
            'FETCH_OBJ' => [
                \PDO::FETCH_OBJ,
            ],
        ];
    }
    
    /**
     * Tests supported fetch modes.
     *
     * @dataProvider providerSupportedFetchModes
     */
    public function testSupportedFetchModes(int $mode) : void {
        $mockPdo = $this->createMock(StubPDO::class);
        $mockConnection = new StubConnection($mockPdo, []);
        $statement = new StatementPrefetchIterator($mockPdo, $mockConnection, '');
        $this->assertInstanceOf(StatementPrefetchIterator::class, $statement);
        $statement->setFetchMode($mode);
    }
    
    /**
     * Provides data for testDeprecatedFetchModes.
     *
     * @return array
     *   An associative array of simple arrays, each having the following
     *   elements:
     *   - a PDO fetch mode.
     */
    public static function providerDeprecatedFetchModes() : array {
        return [
            'FETCH_DEFAULT' => [
                \PDO::FETCH_DEFAULT,
            ],
            'FETCH_LAZY' => [
                \PDO::FETCH_LAZY,
            ],
            'FETCH_BOTH' => [
                \PDO::FETCH_BOTH,
            ],
            'FETCH_BOUND' => [
                \PDO::FETCH_BOUND,
            ],
            'FETCH_INTO' => [
                \PDO::FETCH_INTO,
            ],
            'FETCH_FUNC' => [
                \PDO::FETCH_FUNC,
            ],
            'FETCH_NAMED' => [
                \PDO::FETCH_NAMED,
            ],
            'FETCH_KEY_PAIR' => [
                \PDO::FETCH_KEY_PAIR,
            ],
            'FETCH_CLASS | FETCH_CLASSTYPE' => [
                \PDO::FETCH_CLASS | \PDO::FETCH_CLASSTYPE,
            ],
        ];
    }
    
    /**
     * Tests deprecated fetch modes.
     *
     * @todo in drupal:11.0.0, do not remove this test but convert it to expect
     *   exceptions instead of deprecations.
     *
     * @dataProvider providerDeprecatedFetchModes
     *
     * @group legacy
     */
    public function testDeprecatedFetchModes(int $mode) : void {
        $this->expectDeprecation('Fetch mode %A is deprecated in drupal:10.2.0 and is removed from drupal:11.0.0. Use supported modes only. See https://www.drupal.org/node/3377999');
        $mockPdo = $this->createMock(StubPDO::class);
        $mockConnection = new StubConnection($mockPdo, []);
        $statement = new StatementPrefetchIterator($mockPdo, $mockConnection, '');
        $this->assertInstanceOf(StatementPrefetchIterator::class, $statement);
        $statement->setFetchMode($mode);
    }
    
    /**
     * {@inheritdoc}
     */
    public function tearDown() : void {
        parent::tearDown();
        // Removes the default connection added by the
        // testFindCallerFromDebugBacktrace test.
        Database::removeConnection('default');
    }

}