Proyectos de Subversion Moodle

            return str_replace('/', DIRECTORY_SEPARATOR, $source);

            return str_replace('/', DIRECTORY_SEPARATOR, $source);

        }

        }

        return $source; // No changes, so far.

        return $source; // No changes, so far.

    }

    }

    public function test_diagnose() {

    public function test_diagnose(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $result = $DB->diagnose();

        $result = $DB->diagnose();

        $this->assertNull($result, 'Database self diagnostics failed %s');

        $this->assertNull($result, 'Database self diagnostics failed %s');

    public function test_get_server_info() {

    public function test_get_server_info(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $result = $DB->get_server_info();

        $result = $DB->get_server_info();

        $this->assertIsArray($result);

        $this->assertIsArray($result);

        $this->assertArrayHasKey('description', $result);

        $this->assertArrayHasKey('description', $result);

    }

    }

    public function test_get_in_or_equal() {

    public function test_get_in_or_equal(): void {

        $key = key($params);

        $key = key($params);

        $this->assertSame('<> :'.$key, $usql);

        $this->assertSame('<> :'.$key, $usql);

        $this->assertSame($value, 'onevalue');

        $this->assertSame($value, 'onevalue');

    }

    }

    public function test_fix_table_names() {

    public function test_fix_table_names(): void {

        $DB = new moodle_database_for_testing();

        $DB = new moodle_database_for_testing();

        $prefix = $DB->get_prefix();

        $prefix = $DB->get_prefix();

        $sql = "SELECT * FROM {user}, {funny_table_name}, {mdl_stupid_table} WHERE {user}.id = {funny_table_name}.userid";

        $sql = "SELECT * FROM {user}, {funny_table_name}, {mdl_stupid_table} WHERE {user}.id = {funny_table_name}.userid";

        $expected = "SELECT * FROM {$prefix}user, {$prefix}funny_table_name, {$prefix}mdl_stupid_table WHERE {$prefix}user.id = {$prefix}funny_table_name.userid";

        $expected = "SELECT * FROM {$prefix}user, {$prefix}funny_table_name, {$prefix}mdl_stupid_table WHERE {$prefix}user.id = {$prefix}funny_table_name.userid";

        $this->assertSame($expected, $DB->public_fix_table_names($sql));

        $this->assertSame($expected, $DB->public_fix_table_names($sql));

    }

    }

    public function test_fix_sql_params() {

    public function test_fix_sql_params(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $prefix = $DB->get_prefix();

        $prefix = $DB->get_prefix();

    }

    }

    /**

    /**

     * Test the database debugging as SQL comment.

     * Test the database debugging as SQL comment.

    public function test_add_sql_debugging() {

    public function test_add_sql_debugging(): void {

        global $CFG;

        global $CFG;

        $DB = $this->tdb;

        $DB = $this->tdb;

    /**

    /**

     * Test the database debugging as SQL comment in anon class

     * Test the database debugging as SQL comment in anon class

     *

     *

     * @covers ::add_sql_debugging

     * @covers ::add_sql_debugging

     */

     */

        global $CFG;

        global $CFG;

        $CFG->debugsqltrace = 100;

        $CFG->debugsqltrace = 100;

        // A anon class.

        // A anon class.

        $site = $another->get_site();

        $site = $another->get_site();

        $CFG->debugsqltrace = 0;

        $CFG->debugsqltrace = 0;

        $this->assertEquals(get_site(), $site);

        $this->assertEquals(get_site(), $site);

    }

    }

    public function test_strtok() {

    public function test_strtok(): void {

        // Strtok was previously used by bound emulation, make sure it is not used any more.

        // Strtok was previously used by bound emulation, make sure it is not used any more.

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $this->tdb->get_manager();

        $dbman = $this->tdb->get_manager();

        $DB->get_records($tablename, array('id'=>1));

        $DB->get_records($tablename, array('id'=>1));

        $this->assertSame(strtok('?'), 'b');

        $this->assertSame(strtok('?'), 'b');

    public function test_tweak_param_names() {

    public function test_tweak_param_names(): void {

        // Note the tweak_param_names() method is only available in the oracle driver,

        // Note the tweak_param_names() method is only available in the oracle driver,

        // Execute().

        // Execute().

        $DB->execute("DELETE FROM {{$tablename}} WHERE $select", (array)$rec1);

        $DB->execute("DELETE FROM {{$tablename}} WHERE $select", (array)$rec1);

        $this->assertEquals(0, $DB->count_records($tablename));

        $this->assertEquals(0, $DB->count_records($tablename));

    }

    }

    public function test_get_tables() {

    public function test_get_tables(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $this->tdb->get_manager();

        $dbman = $this->tdb->get_manager();

        $dbman->drop_table($table);

        $dbman->drop_table($table);

        $this->assertTrue(count($DB->get_tables()) == $original_count);

        $this->assertTrue(count($DB->get_tables()) == $original_count);

    public function test_get_indexes() {

    public function test_get_indexes(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $this->tdb->get_manager();

        $dbman = $this->tdb->get_manager();

     *

     *

     * Note that, strictly speaking, unique indexes on null columns are far from ideal. Both

     * Note that, strictly speaking, unique indexes on null columns are far from ideal. Both

     * conceptually and also in practice, because they cause DBs to use full scans in a

     * conceptually and also in practice, because they cause DBs to use full scans in a

     * number of situations. But if we support them, we need to ensure get_indexes() work on them.

     * number of situations. But if we support them, we need to ensure get_indexes() work on them.

     */

     */

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $this->tdb->get_manager();

        $dbman = $this->tdb->get_manager();

        $table = $this->get_test_table();

        $table = $this->get_test_table();

        $tablename = $table->getName();

        $tablename = $table->getName();

        $index = array_shift($indexes);

        $index = array_shift($indexes);

        $this->assertTrue($index['unique']);

        $this->assertTrue($index['unique']);

        $this->assertSame($indexcolumns, $index['columns']);

        $this->assertSame($indexcolumns, $index['columns']);

    }

    }

    public function test_get_columns() {

    public function test_get_columns(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $this->tdb->get_manager();

        $dbman = $this->tdb->get_manager();

        $columns = $DB->get_columns($tablename);

        $columns = $DB->get_columns($tablename);

        $this->assertFalse($columns['id']->auto_increment);

        $this->assertFalse($columns['id']->auto_increment);

    public function test_get_manager() {

    public function test_get_manager(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $this->tdb->get_manager();

        $dbman = $this->tdb->get_manager();

        $this->assertInstanceOf('database_manager', $dbman);

        $this->assertInstanceOf('database_manager', $dbman);

    }

    }

        $DB = $this->tdb;

        $DB = $this->tdb;

        $this->assertTrue($DB->setup_is_unicodedb());

        $this->assertTrue($DB->setup_is_unicodedb());

    }

    }

        $this->assertTrue($debuginfo === '');

        $this->assertTrue($debuginfo === '');

        $DB->set_debug($prevdebug);

        $DB->set_debug($prevdebug);

    public function test_execute() {

    public function test_execute(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $this->tdb->get_manager();

        $dbman = $this->tdb->get_manager();

        $this->assertCount(1, $records);

        $this->assertCount(1, $records);

        $record = reset($records);

        $record = reset($records);

        $this->assertSame($newonetext, $record->onetext);

        $this->assertSame($newonetext, $record->onetext);

    }

    }

    public function test_get_recordset() {

    public function test_get_recordset(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        // Notes:

        // Notes:

        //  * limits are tested in test_get_recordset_sql()

        //  * limits are tested in test_get_recordset_sql()

        //  * where_clause() is used internally and is tested in test_get_records()

        //  * where_clause() is used internally and is tested in test_get_records()

    }

    }

    public function test_get_recordset_static() {

    public function test_get_recordset_static(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        }

        }

        $rs->close();

        $rs->close();

        $this->assertEquals(3, $i);

        $this->assertEquals(3, $i);

    }

    }

    public function test_get_recordset_iterator_keys() {

    public function test_get_recordset_iterator_keys(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        }

        }

        $rs->close();

        $rs->close();

        $this->assertEquals(3, $count);

        $this->assertEquals(3, $count);

    }

    }

    public function test_get_recordset_list() {

    public function test_get_recordset_list(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        // Notes:

        // Notes:

        //  * limits are tested in test_get_recordset_sql()

        //  * limits are tested in test_get_recordset_sql()

        //  * where_clause() is used internally and is tested in test_get_records()

        //  * where_clause() is used internally and is tested in test_get_records()

    }

    }

    public function test_get_recordset_select() {

    public function test_get_recordset_select(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        // Notes:

        // Notes:

        //  * limits are tested in test_get_recordset_sql()

        //  * limits are tested in test_get_recordset_sql()

    public function test_get_recordset_sql() {

    public function test_get_recordset_sql(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        $this->assertEquals($inskey7, end($records)->id);

        $this->assertEquals($inskey7, end($records)->id);

        // Note: fetching nulls, empties, LOBs already tested by test_insert_record() no needed here.

        // Note: fetching nulls, empties, LOBs already tested by test_insert_record() no needed here.

    public function test_export_table_recordset() {

    public function test_export_table_recordset(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        }

        }

        $rs->close();

        $rs->close();

        $this->assertEqualsCanonicalizing($ids, $rids);

        $this->assertEqualsCanonicalizing($ids, $rids);

    }

    }

    public function test_get_records() {

    public function test_get_records(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        }

        }

        // Note: delegate limits testing to test_get_records_sql().

        // Note: delegate limits testing to test_get_records_sql().

    public function test_get_records_list() {

    public function test_get_records_list(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        $this->assertCount(0, $records);

        $this->assertCount(0, $records);

        // Note: delegate limits testing to test_get_records_sql().

        // Note: delegate limits testing to test_get_records_sql().

    public function test_get_records_sql() {

    public function test_get_records_sql(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        // TODO: Test limits in queries having DISTINCT clauses.

        // TODO: Test limits in queries having DISTINCT clauses.

        // Note: fetching nulls, empties, LOBs already tested by test_update_record() no needed here.

        // Note: fetching nulls, empties, LOBs already tested by test_update_record() no needed here.

    public function test_get_records_menu() {

    public function test_get_records_menu(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        $this->assertEquals(3, $records[2]);

        $this->assertEquals(3, $records[2]);

        // Note: delegate limits testing to test_get_records_sql().

        // Note: delegate limits testing to test_get_records_sql().

    public function test_get_records_select_menu() {

    public function test_get_records_select_menu(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        $this->assertSame('5', $records[4]);

        $this->assertSame('5', $records[4]);

        // Note: delegate limits testing to test_get_records_sql().

        // Note: delegate limits testing to test_get_records_sql().

    public function test_get_records_sql_menu() {

    public function test_get_records_sql_menu(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        $this->assertSame('5', $records[4]);

        $this->assertSame('5', $records[4]);

        // Note: delegate limits testing to test_get_records_sql().

        // Note: delegate limits testing to test_get_records_sql().

    public function test_get_record() {

    public function test_get_record(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        $this->assertEquals(2, $record->course);

        $this->assertEquals(2, $record->course);

        $this->assertEquals(2, $record->id);

        $this->assertEquals(2, $record->id);

    }

    }

    public function test_get_record_select() {

    public function test_get_record_select(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        $this->assertEquals(2, $record->course);

        $this->assertEquals(2, $record->course);

        // Note: delegates limit testing to test_get_records_sql().

        // Note: delegates limit testing to test_get_records_sql().

    public function test_get_record_sql() {

    public function test_get_record_sql(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        } catch (dml_multiple_records_exception $e) {

        } catch (dml_multiple_records_exception $e) {

            $this->assertTrue(true);

            $this->assertTrue(true);

        }

        }

    }

    }

    public function test_get_field() {

    public function test_get_field(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

            $this->assertInstanceOf('dml_exception', $e);

            $this->assertInstanceOf('dml_exception', $e);

            $this->assertSame('textconditionsnotallowed', $e->errorcode);

            $this->assertSame('textconditionsnotallowed', $e->errorcode);

        }

        }

    }

    }

    public function test_get_field_select() {

    public function test_get_field_select(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        $DB->insert_record($tablename, array('course' => 3));

        $DB->insert_record($tablename, array('course' => 3));

        $this->assertEquals(3, $DB->get_field_select($tablename, 'course', "id = ?", array(1)));

        $this->assertEquals(3, $DB->get_field_select($tablename, 'course', "id = ?", array(1)));

    public function test_get_field_sql() {

    public function test_get_field_sql(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        $DB->insert_record($tablename, array('course' => 3));

        $DB->insert_record($tablename, array('course' => 3));

        $this->assertEquals(3, $DB->get_field_sql("SELECT course FROM {{$tablename}} WHERE id = ?", array(1)));

        $this->assertEquals(3, $DB->get_field_sql("SELECT course FROM {{$tablename}} WHERE id = ?", array(1)));

    public function test_get_fieldset() {

    public function test_get_fieldset(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        $this->assertEquals(1, $fieldset[0]);

        $this->assertEquals(1, $fieldset[0]);

        $this->assertEquals(2, $fieldset[1]);

        $this->assertEquals(2, $fieldset[1]);

        $this->assertEquals(4, $fieldset[2]);

        $this->assertEquals(4, $fieldset[2]);

    }

    }

    public function test_get_fieldset_select() {

    public function test_get_fieldset_select(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        $this->assertEquals(3, $fieldset[0]);

        $this->assertEquals(3, $fieldset[0]);

        $this->assertEquals(2, $fieldset[1]);

        $this->assertEquals(2, $fieldset[1]);

        $this->assertEquals(6, $fieldset[2]);

        $this->assertEquals(6, $fieldset[2]);

    }

    }

    public function test_get_fieldset_sql() {

    public function test_get_fieldset_sql(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        $this->assertEquals($binarydata, $fieldset[0]);

        $this->assertEquals($binarydata, $fieldset[0]);

        $this->assertEquals($binarydata, $fieldset[1]);

        $this->assertEquals($binarydata, $fieldset[1]);

        $this->assertEquals($binarydata, $fieldset[2]);

        $this->assertEquals($binarydata, $fieldset[2]);

    }

    }

    public function test_insert_record_raw() {

    public function test_insert_record_raw(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        $DB->insert_record_raw($tablename, $record, false, false, true);

        $DB->insert_record_raw($tablename, $record, false, false, true);

        $record = $DB->get_record($tablename, array());

        $record = $DB->get_record($tablename, array());

        $this->assertEquals(5, $record->id);

        $this->assertEquals(5, $record->id);

    }

    }

    public function test_insert_record() {

    public function test_insert_record(): void {

        // All the information in this test is fetched from DB by get_recordset() so we

        // All the information in this test is fetched from DB by get_recordset() so we

        // have such method properly tested against nulls, empties and friends...

        // have such method properly tested against nulls, empties and friends...

        } catch (\Exception $e) {

        } catch (\Exception $e) {

            $this->assertTrue($e instanceof dml_exception);

            $this->assertTrue($e instanceof dml_exception);

        }

        }

    }

    }

    public function test_insert_records() {

    public function test_insert_records(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        } catch (\moodle_exception $e) {

        } catch (\moodle_exception $e) {

            $this->assertInstanceOf('coding_exception', $e);

            $this->assertInstanceOf('coding_exception', $e);

        }

        }

    }

    }

    public function test_insert_record_with_nullable_unique_index() {

    public function test_insert_record_with_nullable_unique_index(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        $this->assertEquals(3, $DB->count_records($table->getName(), ['nullable1' => 1]));

        $this->assertEquals(3, $DB->count_records($table->getName(), ['nullable1' => 1]));

        $this->assertEquals(2, $DB->count_records($table->getName(), ['nullable1' => null]));

        $this->assertEquals(2, $DB->count_records($table->getName(), ['nullable1' => null]));

    public function test_import_record() {

    public function test_import_record(): void {

        // All the information in this test is fetched from DB by get_recordset() so we

        // All the information in this test is fetched from DB by get_recordset() so we

        // have such method properly tested against nulls, empties and friends...

        // have such method properly tested against nulls, empties and friends...

        $this->assertEquals($newclob, $record->onetext, 'Test "small" CLOB insert (full contents output disabled)');

        $this->assertEquals($newclob, $record->onetext, 'Test "small" CLOB insert (full contents output disabled)');

        $this->assertEquals($newblob, $record->onebinary, 'Test "small" BLOB insert (full contents output disabled)');

        $this->assertEquals($newblob, $record->onebinary, 'Test "small" BLOB insert (full contents output disabled)');

        $this->assertEquals(false, $rs->key()); // Ensure recordset key() method to be working ok after closing.

        $this->assertEquals(false, $rs->key()); // Ensure recordset key() method to be working ok after closing.

    }

    }

    public function test_update_record_raw() {

    public function test_update_record_raw(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        } catch (\moodle_exception $e) {

        } catch (\moodle_exception $e) {

            $this->assertInstanceOf('coding_exception', $e);

            $this->assertInstanceOf('coding_exception', $e);

        }

        }

    }

    }

    public function test_update_record() {

    public function test_update_record(): void {

        // All the information in this test is fetched from DB by get_record() so we

        // All the information in this test is fetched from DB by get_record() so we

        $this->assertEquals(1e-300, $DB->get_field($tablename, 'onetext', array('id' => $id)));

        $this->assertEquals(1e-300, $DB->get_field($tablename, 'onetext', array('id' => $id)));

        $DB->update_record($tablename, array('id' => $id, 'onetext' => 1e300));

        $DB->update_record($tablename, array('id' => $id, 'onetext' => 1e300));

        $this->assertEquals(1e300, $DB->get_field($tablename, 'onetext', array('id' => $id)));

        $this->assertEquals(1e300, $DB->get_field($tablename, 'onetext', array('id' => $id)));

    }

    }

    public function test_set_field() {

    public function test_set_field(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        // Note: All the nulls, booleans, empties, quoted and backslashes tests

        // Note: All the nulls, booleans, empties, quoted and backslashes tests

        // go to set_field_select() because set_field() is just one wrapper over it.

        // go to set_field_select() because set_field() is just one wrapper over it.

    public function test_set_field_select() {

    public function test_set_field_select(): void {

            $this->assertFalse(true, 'We have an unexpected exception.');

            $this->assertFalse(true, 'We have an unexpected exception.');

            throw $e;

            throw $e;

        }

        }

    }

    }

    public function test_count_records() {

    public function test_count_records(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

            $this->assertInstanceOf('dml_exception', $e);

            $this->assertInstanceOf('dml_exception', $e);

            $this->assertSame('textconditionsnotallowed', $e->errorcode);

            $this->assertSame('textconditionsnotallowed', $e->errorcode);

        }

        }

    }

    }

    public function test_count_records_select() {

    public function test_count_records_select(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $DB->insert_record($tablename, array('course' => 5));

        $DB->insert_record($tablename, array('course' => 5));

        $this->assertSame(2, $DB->count_records_select($tablename, 'course > ?', array(3)));

        $this->assertSame(2, $DB->count_records_select($tablename, 'course > ?', array(3)));

    public function test_count_records_sql() {

    public function test_count_records_sql(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        } catch (\moodle_exception $e) {

        } catch (\moodle_exception $e) {

            $this->assertInstanceOf('coding_exception', $e);

            $this->assertInstanceOf('coding_exception', $e);

        }

        }

    }

    }

    public function test_record_exists() {

    public function test_record_exists(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

            $this->assertInstanceOf('dml_exception', $e);

            $this->assertInstanceOf('dml_exception', $e);

            $this->assertSame('textconditionsnotallowed', $e->errorcode);

            $this->assertSame('textconditionsnotallowed', $e->errorcode);

        }

        }

    }

    }

    public function test_record_exists_select() {

    public function test_record_exists_select(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        $DB->insert_record($tablename, array('course' => 3));

        $DB->insert_record($tablename, array('course' => 3));

        $this->assertTrue($DB->record_exists_select($tablename, "course = ?", array(3)));

        $this->assertTrue($DB->record_exists_select($tablename, "course = ?", array(3)));

    public function test_record_exists_sql() {

    public function test_record_exists_sql(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        $DB->insert_record($tablename, array('course' => 3));

        $DB->insert_record($tablename, array('course' => 3));

        $this->assertTrue($DB->record_exists_sql("SELECT * FROM {{$tablename}} WHERE course = ?", array(3)));

        $this->assertTrue($DB->record_exists_sql("SELECT * FROM {{$tablename}} WHERE course = ?", array(3)));

    public function test_recordset_locks_delete() {

    public function test_recordset_locks_delete(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        $rs->close();

        $rs->close();

        $this->assertEquals(4, $DB->count_records($tablename, array()));

        $this->assertEquals(4, $DB->count_records($tablename, array()));

    public function test_recordset_locks_update() {

    public function test_recordset_locks_update(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        $rs->close();

        $rs->close();

        $this->assertEquals(2, $DB->count_records($tablename, array('course' => 10)));

        $this->assertEquals(2, $DB->count_records($tablename, array('course' => 10)));

    public function test_delete_records() {

    public function test_delete_records(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

            $this->assertInstanceOf('dml_exception', $e);

            $this->assertInstanceOf('dml_exception', $e);

            $this->assertSame('textconditionsnotallowed', $e->errorcode);

            $this->assertSame('textconditionsnotallowed', $e->errorcode);

        }

        }

    }

    }

    public function test_delete_records_select() {

    public function test_delete_records_select(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        $this->assertTrue($DB->delete_records_select($tablename, 'course = ?', array(2)));

        $this->assertTrue($DB->delete_records_select($tablename, 'course = ?', array(2)));

        $this->assertEquals(1, $DB->count_records($tablename));

        $this->assertEquals(1, $DB->count_records($tablename));

    public function test_delete_records_subquery() {

    public function test_delete_records_subquery(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        $DB->delete_records_subquery($tablename, 'id', 'frog',

        $DB->delete_records_subquery($tablename, 'id', 'frog',

                'SELECT id AS frog FROM {' . $tablename . '} WHERE course = ?', [2]);

                'SELECT id AS frog FROM {' . $tablename . '} WHERE course = ?', [2]);

        $this->assertEquals(1, $DB->count_records($tablename));

        $this->assertEquals(1, $DB->count_records($tablename));

    }

    }

    public function test_delete_records_list() {

    public function test_delete_records_list(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        $this->assertTrue($DB->delete_records_list($tablename, 'course', array())); // Must delete 0 rows without conditions. MDL-17645.

        $this->assertTrue($DB->delete_records_list($tablename, 'course', array())); // Must delete 0 rows without conditions. MDL-17645.

        $this->assertEquals(1, $DB->count_records($tablename));

        $this->assertEquals(1, $DB->count_records($tablename));

    public function test_object_params() {

    public function test_object_params(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        } catch (\moodle_exception $e) {

        } catch (\moodle_exception $e) {

            $this->assertInstanceOf('coding_exception', $e);

            $this->assertInstanceOf('coding_exception', $e);

        }

        }

    }

    }

    public function test_sql_null_from_clause() {

    public function test_sql_null_from_clause(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $sql = "SELECT 1 AS id ".$DB->sql_null_from_clause();

        $sql = "SELECT 1 AS id ".$DB->sql_null_from_clause();

        $this->assertEquals(1, $DB->get_field_sql($sql));

        $this->assertEquals(1, $DB->get_field_sql($sql));

    public function test_sql_bitand() {

    public function test_sql_bitand(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        $result = $DB->get_records_sql($sql, array(10));

        $result = $DB->get_records_sql($sql, array(10));

        $this->assertCount(1, $result);

        $this->assertCount(1, $result);

        $this->assertEquals(2, reset($result)->res);

        $this->assertEquals(2, reset($result)->res);

    }

    }

    public function test_sql_bitnot() {

    public function test_sql_bitnot(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $not = $DB->sql_bitnot(2);

        $not = $DB->sql_bitnot(2);

        $notlimited = $DB->sql_bitand($not, 7); // Might be positive or negative number which can not fit into PHP INT!

        $notlimited = $DB->sql_bitand($not, 7); // Might be positive or negative number which can not fit into PHP INT!

        $this->assertEquals(5, $DB->get_field_sql($sql));

        $this->assertEquals(5, $DB->get_field_sql($sql));

    }

    }

    public function test_sql_bitor() {

    public function test_sql_bitor(): void {

        $result = $DB->get_records_sql($sql, array(10));

        $result = $DB->get_records_sql($sql, array(10));

        $this->assertCount(1, $result);

        $this->assertCount(1, $result);

        $this->assertEquals(11, reset($result)->res);

        $this->assertEquals(11, reset($result)->res);

    }

    }

    public function test_sql_bitxor() {

    public function test_sql_bitxor(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        $result = $DB->get_records_sql($sql, array(10));

        $result = $DB->get_records_sql($sql, array(10));

        $this->assertCount(1, $result);

        $this->assertCount(1, $result);

        $this->assertEquals(9, reset($result)->res);

        $this->assertEquals(9, reset($result)->res);

    }

    }

    public function test_sql_modulo() {

    public function test_sql_modulo(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $sql = "SELECT ".$DB->sql_modulo(10, 7)." AS res ".$DB->sql_null_from_clause();

        $sql = "SELECT ".$DB->sql_modulo(10, 7)." AS res ".$DB->sql_null_from_clause();

        $this->assertEquals(3, $DB->get_field_sql($sql));

        $this->assertEquals(3, $DB->get_field_sql($sql));

    public function test_sql_ceil() {

    public function test_sql_ceil(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $sql = "SELECT ".$DB->sql_ceil(665.666)." AS res ".$DB->sql_null_from_clause();

        $sql = "SELECT ".$DB->sql_ceil(665.666)." AS res ".$DB->sql_null_from_clause();

        $fieldset = $DB->get_fieldset_sql($sql);

        $fieldset = $DB->get_fieldset_sql($sql);

        $this->assertEquals(['uno'], $fieldset);

        $this->assertEquals(['uno'], $fieldset);

    public function test_cast_char2int() {

    public function test_cast_char2int(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        $this->assertCount(2, $records);

        $this->assertCount(2, $records);

        $this->assertSame('20', reset($records)->nametext);

        $this->assertSame('20', reset($records)->nametext);

        $this->assertSame('0200', next($records)->nametext);

        $this->assertSame('0200', next($records)->nametext);

    }

    }

    public function test_cast_char2real() {

    public function test_cast_char2real(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        // And also, although not recommended, with directly passed values.

        // And also, although not recommended, with directly passed values.

        $sql = "SELECT name FROM {{$tablename}} WHERE FLOOR(res - " . $DB->sql_cast_char2real('10.09999') . ") = 0";

        $sql = "SELECT name FROM {{$tablename}} WHERE FLOOR(res - " . $DB->sql_cast_char2real('10.09999') . ") = 0";

        $this->assertEquals('011.13333333', $DB->get_field_sql($sql));

        $this->assertEquals('011.13333333', $DB->get_field_sql($sql));

    }

    }

    public function test_sql_compare_text() {

    public function test_sql_compare_text(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        $this->assertCount(1, $records);

        $this->assertCount(1, $records);

        $record = reset($records);

        $record = reset($records);

        $this->assertSame($clob, $record->description);

        $this->assertSame($clob, $record->description);

    }

    }

    public function test_unique_index_collation_trouble() {

    public function test_unique_index_collation_trouble(): void {

        // Note: this is a work in progress, we should probably move this to ddl test.

        // Note: this is a work in progress, we should probably move this to ddl test.

            }

            }

            throw($e);

            throw($e);

        }

        }

    }

    }

    public function test_sql_equal() {

    public function test_sql_equal(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        $sql = "SELECT * FROM {{$tablename}} WHERE " . $DB->sql_equal('name', 'name2', false, false);

        $sql = "SELECT * FROM {{$tablename}} WHERE " . $DB->sql_equal('name', 'name2', false, false);

        $records = $DB->get_records_sql($sql);

        $records = $DB->get_records_sql($sql);

        $this->assertGreaterThanOrEqual(4, count($records)); // At very least, there are 4 records with CI/AI names matching.

        $this->assertGreaterThanOrEqual(4, count($records)); // At very least, there are 4 records with CI/AI names matching.

    }

    }

    public function test_sql_like() {

    public function test_sql_like(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

            'lionel%_^-[0]',

            'lionel%_^-[0]',

            'rick%_^-[0]',

            'rick%_^-[0]',

        ], $DB->get_fieldset_select($tablename, 'name', $select, $params));

        ], $DB->get_fieldset_select($tablename, 'name', $select, $params));

    }

    }

    public function test_coalesce() {

    public function test_coalesce(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        // Testing not-null occurrences, return 1st.

        // Testing not-null occurrences, return 1st.

        // Check there are not problems with whitespace strings.

        // Check there are not problems with whitespace strings.

        $sql = "SELECT COALESCE(null, :paramvalue, null) AS test" . $DB->sql_null_from_clause();

        $sql = "SELECT COALESCE(null, :paramvalue, null) AS test" . $DB->sql_null_from_clause();

        $this->assertSame('', $DB->get_field_sql($sql, array('paramvalue' => '')));

        $this->assertSame('', $DB->get_field_sql($sql, array('paramvalue' => '')));

    }

    }

    public function test_sql_concat() {

    public function test_sql_concat(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

     * @param string $concat The string to use when concatanating.

     * @param string $concat The string to use when concatanating.

     * @param array $fields The fields to concatanate

     * @param array $fields The fields to concatanate

     * @param array $params Any parameters to provide to the query

     * @param array $params Any parameters to provide to the query

     * @param @string $expected The expected result

     * @param @string $expected The expected result

     */

     */

        $DB = $this->tdb;

        $DB = $this->tdb;

        $sql = "SELECT " . $DB->sql_concat_join($concat, $fields) . " AS result" . $DB->sql_null_from_clause();

        $sql = "SELECT " . $DB->sql_concat_join($concat, $fields) . " AS result" . $DB->sql_null_from_clause();

        $result = $DB->get_field_sql($sql, $params);

        $result = $DB->get_field_sql($sql, $params);

        $this->assertEquals($expected, $result);

        $this->assertEquals($expected, $result);

    }

    }

                'falias' => 'Dan, Grace',

                'falias' => 'Dan, Grace',

            ],

            ],

        ], $DB->get_records_sql($sql));

        ], $DB->get_records_sql($sql));

    }

    }

    public function test_sql_fullname() {

    public function test_sql_fullname(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $sql = "SELECT ".$DB->sql_fullname(':first', ':last')." AS fullname ".$DB->sql_null_from_clause();

        $sql = "SELECT ".$DB->sql_fullname(':first', ':last')." AS fullname ".$DB->sql_null_from_clause();

        $params = array('first'=>'Firstname', 'last'=>'Surname');

        $params = array('first'=>'Firstname', 'last'=>'Surname');

        $this->assertEquals("Firstname Surname", $DB->get_field_sql($sql, $params));

        $this->assertEquals("Firstname Surname", $DB->get_field_sql($sql, $params));

    public function test_sql_order_by_text() {

    public function test_sql_order_by_text(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        $this->assertEquals('aaaa', array_shift($records)->name);

        $this->assertEquals('aaaa', array_shift($records)->name);

        $this->assertEquals('', array_shift($records)->name);

        $this->assertEquals('', array_shift($records)->name);

        $this->assertEquals(null, array_shift($records)->name);

        $this->assertEquals(null, array_shift($records)->name);

    }

    }

    public function test_sql_substring() {

    public function test_sql_substring(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        $sql = "SELECT id, ".$DB->sql_substr("name", "(:param1 + 1) - 1")." AS name FROM {{$tablename}}";

        $sql = "SELECT id, ".$DB->sql_substr("name", "(:param1 + 1) - 1")." AS name FROM {{$tablename}}";

        $record = $DB->get_record_sql($sql, array('param1' => $start));

        $record = $DB->get_record_sql($sql, array('param1' => $start));

        $this->assertEquals(substr($string, $start - 1), $record->name); // PHP's substr is 0-based.

        $this->assertEquals(substr($string, $start - 1), $record->name); // PHP's substr is 0-based.

    }

    }

    public function test_sql_length() {

    public function test_sql_length(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $this->assertEquals($DB->get_field_sql(

        $this->assertEquals($DB->get_field_sql(

            "SELECT ".$DB->sql_length("'aeiou'").$DB->sql_null_from_clause()), 5);

            "SELECT ".$DB->sql_length("'aeiou'").$DB->sql_null_from_clause()), 5);

        $this->assertEquals($DB->get_field_sql(

        $this->assertEquals($DB->get_field_sql(

            "SELECT ".$DB->sql_length("'áéíóú'").$DB->sql_null_from_clause()), 5);

            "SELECT ".$DB->sql_length("'áéíóú'").$DB->sql_null_from_clause()), 5);

    public function test_sql_position() {

    public function test_sql_position(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $this->assertEquals($DB->get_field_sql(

        $this->assertEquals($DB->get_field_sql(

            "SELECT ".$DB->sql_position("'ood'", "'Moodle'").$DB->sql_null_from_clause()), 2);

            "SELECT ".$DB->sql_position("'ood'", "'Moodle'").$DB->sql_null_from_clause()), 2);

        $this->assertEquals($DB->get_field_sql(

        $this->assertEquals($DB->get_field_sql(

    }

    }

    public function test_sql_empty() {

    public function test_sql_empty(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $this->assertCount(4, $records);

        $this->assertCount(4, $records);

        $record = reset($records);

        $record = reset($records);

        $this->assertSame('', $record->namenotnullnodeflt);

        $this->assertSame('', $record->namenotnullnodeflt);

    }

    }

    public function test_sql_isempty() {

    public function test_sql_isempty(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        $this->assertCount(1, $records);

        $this->assertCount(1, $records);

        $record = reset($records);

        $record = reset($records);

        $this->assertSame('', $record->descriptionnull);

        $this->assertSame('', $record->descriptionnull);

    }

    }

    public function test_sql_isnotempty() {

    public function test_sql_isnotempty(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        $this->assertCount(2, $records); // Nulls aren't comparable (so they aren't "not empty"). SQL expected behaviour.

        $this->assertCount(2, $records); // Nulls aren't comparable (so they aren't "not empty"). SQL expected behaviour.

        $record = reset($records);

        $record = reset($records);

        $this->assertSame('lalala', $record->descriptionnull); // So 'lalala' is the first non-empty 'descriptionnull' record.

        $this->assertSame('lalala', $record->descriptionnull); // So 'lalala' is the first non-empty 'descriptionnull' record.

    }

    }

    public function test_sql_regex() {

    public function test_sql_regex(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        if (!$DB->sql_regex_supported()) {

        if (!$DB->sql_regex_supported()) {

            $this->markTestSkipped($DB->get_name().' does not support regular expressions');

            $this->markTestSkipped($DB->get_name().' does not support regular expressions');

    }

    }

    /**

    /**

     * Test some complicated variations of set_field_select.

     * Test some complicated variations of set_field_select.

    public function test_set_field_select_complicated() {

    public function test_set_field_select_complicated(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

    /**

    /**

     * Test some more complex SQL syntax which moodle uses and depends on to work

     * Test some more complex SQL syntax which moodle uses and depends on to work

     * useful to determine if new database libraries can be supported.

     * useful to determine if new database libraries can be supported.

    public function test_get_records_sql_complicated() {

    public function test_get_records_sql_complicated(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

                 WHERE id $insql";

                 WHERE id $insql";

        $results = $DB->get_records_sql($sql, $inparams);

        $results = $DB->get_records_sql($sql, $inparams);

        $this->assertCount($currentcount, $results);

        $this->assertCount($currentcount, $results);

    }

    }

    public function test_replace_all_text() {

    public function test_replace_all_text(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        $result = $DB->get_records($tablename, array(), 'id ASC');

        $result = $DB->get_records($tablename, array(), 'id ASC');

        $expected[$id5]->intro = $long.'llll';

        $expected[$id5]->intro = $long.'llll';

        $this->assertEquals($expected, $result);

        $this->assertEquals($expected, $result);

    }

    }

    public function test_onelevel_commit() {

    public function test_onelevel_commit(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        $this->assertEquals(1, $DB->count_records($tablename));

        $this->assertEquals(1, $DB->count_records($tablename));

        $transaction->allow_commit();

        $transaction->allow_commit();

        $this->assertEquals(1, $DB->count_records($tablename));

        $this->assertEquals(1, $DB->count_records($tablename));

    }

    }

    public function test_transaction_ignore_error_trouble() {

    public function test_transaction_ignore_error_trouble(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        $this->assertFalse($DB->is_transaction_started());

        $this->assertFalse($DB->is_transaction_started());

        // NOTE: SQL_QUERY_STRUCTURE is intentionally not tested here because it should never fail.

        // NOTE: SQL_QUERY_STRUCTURE is intentionally not tested here because it should never fail.

    public function test_onelevel_rollback() {

    public function test_onelevel_rollback(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

            // Ignored.

            // Ignored.

        }

        }

        $this->assertEquals(0, $DB->count_records($tablename));

        $this->assertEquals(0, $DB->count_records($tablename));

    }

    }

    public function test_nested_transactions() {

    public function test_nested_transactions(): void {

        $DB = $this->tdb;

        $DB = $this->tdb;

        $dbman = $DB->get_manager();

        $dbman = $DB->get_manager();

        }

        }

        $rs1->close();

        $rs1->close();

        $this->assertEquals(3, $i);

        $this->assertEquals(3, $i);

    }

    }

    public function test_transactions_forbidden() {

    public function test_transactions_forbidden(): void {

        $DB = $this->tdb;