MDL-41022 cleanup core_dml_testcase
[moodle.git] / lib / dml / tests / dml_test.php
index 07ee27e..e0858d0 100644 (file)
@@ -15,7 +15,7 @@
 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
 
 /**
- * DML layer tests
+ * DML layer tests.
  *
  * @package    core_dml
  * @category   phpunit
@@ -29,7 +29,7 @@ class core_dml_testcase extends database_driver_testcase {
 
     protected function setUp() {
         parent::setUp();
-        $dbman = $this->tdb->get_manager(); // loads DDL libs
+        $dbman = $this->tdb->get_manager(); // Loads DDL libs.
     }
 
     /**
@@ -51,79 +51,79 @@ class core_dml_testcase extends database_driver_testcase {
         return new xmldb_table($tablename);
     }
 
-    function test_diagnose() {
+    public function test_diagnose() {
         $DB = $this->tdb;
         $result = $DB->diagnose();
         $this->assertNull($result, 'Database self diagnostics failed %s');
     }
 
-    function test_get_server_info() {
+    public function test_get_server_info() {
         $DB = $this->tdb;
         $result = $DB->get_server_info();
-        $this->assertTrue(is_array($result));
-        $this->assertTrue(array_key_exists('description', $result));
-        $this->assertTrue(array_key_exists('version', $result));
+        $this->assertInternalType('array', $result);
+        $this->assertArrayHasKey('description', $result);
+        $this->assertArrayHasKey('version', $result);
     }
 
     public function test_get_in_or_equal() {
         $DB = $this->tdb;
 
-        // SQL_PARAMS_QM - IN or =
+        // SQL_PARAMS_QM - IN or =.
 
-        // Correct usage of multiple values
+        // Correct usage of multiple values.
         $in_values = array('value1', 'value2', '3', 4, null, false, true);
         list($usql, $params) = $DB->get_in_or_equal($in_values);
-        $this->assertEquals('IN ('.implode(',',array_fill(0, count($in_values), '?')).')', $usql);
+        $this->assertSame('IN ('.implode(',', array_fill(0, count($in_values), '?')).')', $usql);
         $this->assertEquals(count($in_values), count($params));
         foreach ($params as $key => $value) {
             $this->assertSame($in_values[$key], $value);
         }
 
-        // Correct usage of single value (in an array)
+        // Correct usage of single value (in an array).
         $in_values = array('value1');
         list($usql, $params) = $DB->get_in_or_equal($in_values);
         $this->assertEquals("= ?", $usql);
-        $this->assertEquals(1, count($params));
+        $this->assertCount(1, $params);
         $this->assertEquals($in_values[0], $params[0]);
 
-        // Correct usage of single value
+        // Correct usage of single value.
         $in_value = 'value1';
         list($usql, $params) = $DB->get_in_or_equal($in_values);
         $this->assertEquals("= ?", $usql);
-        $this->assertEquals(1, count($params));
+        $this->assertCount(1, $params);
         $this->assertEquals($in_value, $params[0]);
 
-        // SQL_PARAMS_QM - NOT IN or <>
+        // SQL_PARAMS_QM - NOT IN or <>.
 
-        // Correct usage of multiple values
+        // Correct usage of multiple values.
         $in_values = array('value1', 'value2', 'value3', 'value4');
         list($usql, $params) = $DB->get_in_or_equal($in_values, SQL_PARAMS_QM, null, false);
         $this->assertEquals("NOT IN (?,?,?,?)", $usql);
-        $this->assertEquals(4, count($params));
+        $this->assertCount(4, $params);
         foreach ($params as $key => $value) {
             $this->assertEquals($in_values[$key], $value);
         }
 
-        // Correct usage of single value (in array()
+        // Correct usage of single value (in array().
         $in_values = array('value1');
         list($usql, $params) = $DB->get_in_or_equal($in_values, SQL_PARAMS_QM, null, false);
         $this->assertEquals("<> ?", $usql);
-        $this->assertEquals(1, count($params));
+        $this->assertCount(1, $params);
         $this->assertEquals($in_values[0], $params[0]);
 
-        // Correct usage of single value
+        // Correct usage of single value.
         $in_value = 'value1';
         list($usql, $params) = $DB->get_in_or_equal($in_values, SQL_PARAMS_QM, null, false);
         $this->assertEquals("<> ?", $usql);
-        $this->assertEquals(1, count($params));
+        $this->assertCount(1, $params);
         $this->assertEquals($in_value, $params[0]);
 
-        // SQL_PARAMS_NAMED - IN or =
+        // SQL_PARAMS_NAMED - IN or =.
 
-        // Correct usage of multiple values
+        // Correct usage of multiple values.
         $in_values = array('value1', 'value2', 'value3', 'value4');
         list($usql, $params) = $DB->get_in_or_equal($in_values, SQL_PARAMS_NAMED, 'param', true);
-        $this->assertEquals(4, count($params));
+        $this->assertCount(4, $params);
         reset($in_values);
         $ps = array();
         foreach ($params as $key => $value) {
@@ -133,30 +133,30 @@ class core_dml_testcase extends database_driver_testcase {
         }
         $this->assertEquals("IN (".implode(',', $ps).")", $usql);
 
-        // Correct usage of single values (in array)
+        // Correct usage of single values (in array).
         $in_values = array('value1');
         list($usql, $params) = $DB->get_in_or_equal($in_values, SQL_PARAMS_NAMED, 'param', true);
-        $this->assertEquals(1, count($params));
+        $this->assertCount(1, $params);
         $value = reset($params);
         $key = key($params);
         $this->assertEquals("= :$key", $usql);
         $this->assertEquals($in_value, $value);
 
-        // Correct usage of single value
+        // Correct usage of single value.
         $in_value = 'value1';
         list($usql, $params) = $DB->get_in_or_equal($in_values, SQL_PARAMS_NAMED, 'param', true);
-        $this->assertEquals(1, count($params));
+        $this->assertCount(1, $params);
         $value = reset($params);
         $key = key($params);
         $this->assertEquals("= :$key", $usql);
         $this->assertEquals($in_value, $value);
 
-        // SQL_PARAMS_NAMED - NOT IN or <>
+        // SQL_PARAMS_NAMED - NOT IN or <>.
 
-        // Correct usage of multiple values
+        // Correct usage of multiple values.
         $in_values = array('value1', 'value2', 'value3', 'value4');
         list($usql, $params) = $DB->get_in_or_equal($in_values, SQL_PARAMS_NAMED, 'param', false);
-        $this->assertEquals(4, count($params));
+        $this->assertCount(4, $params);
         reset($in_values);
         $ps = array();
         foreach ($params as $key => $value) {
@@ -166,110 +166,110 @@ class core_dml_testcase extends database_driver_testcase {
         }
         $this->assertEquals("NOT IN (".implode(',', $ps).")", $usql);
 
-        // Correct usage of single values (in array)
+        // Correct usage of single values (in array).
         $in_values = array('value1');
         list($usql, $params) = $DB->get_in_or_equal($in_values, SQL_PARAMS_NAMED, 'param', false);
-        $this->assertEquals(1, count($params));
+        $this->assertCount(1, $params);
         $value = reset($params);
         $key = key($params);
         $this->assertEquals("<> :$key", $usql);
         $this->assertEquals($in_value, $value);
 
-        // Correct usage of single value
+        // Correct usage of single value.
         $in_value = 'value1';
         list($usql, $params) = $DB->get_in_or_equal($in_values, SQL_PARAMS_NAMED, 'param', false);
-        $this->assertEquals(1, count($params));
+        $this->assertCount(1, $params);
         $value = reset($params);
         $key = key($params);
         $this->assertEquals("<> :$key", $usql);
         $this->assertEquals($in_value, $value);
 
-        // make sure the param names are unique
-        list($usql1, $params1) = $DB->get_in_or_equal(array(1,2,3), SQL_PARAMS_NAMED, 'param');
-        list($usql2, $params2) = $DB->get_in_or_equal(array(1,2,3), SQL_PARAMS_NAMED, 'param');
+        // Make sure the param names are unique.
+        list($usql1, $params1) = $DB->get_in_or_equal(array(1, 2, 3), SQL_PARAMS_NAMED, 'param');
+        list($usql2, $params2) = $DB->get_in_or_equal(array(1, 2, 3), SQL_PARAMS_NAMED, 'param');
         $params1 = array_keys($params1);
         $params2 = array_keys($params2);
         $common = array_intersect($params1, $params2);
-        $this->assertEquals(count($common), 0);
+        $this->assertCount(0, $common);
 
-        // Some incorrect tests
+        // Some incorrect tests.
 
-        // Incorrect usage passing not-allowed params type
+        // Incorrect usage passing not-allowed params type.
         $in_values = array(1, 2, 3);
         try {
             list($usql, $params) = $DB->get_in_or_equal($in_values, SQL_PARAMS_DOLLAR, 'param', false);
             $this->fail('An Exception is missing, expected due to not supported SQL_PARAMS_DOLLAR');
-        } catch (exception $e) {
-            $this->assertTrue($e instanceof dml_exception);
-            $this->assertEquals($e->errorcode, 'typenotimplement');
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('dml_exception', $e);
+            $this->assertSame('typenotimplement', $e->errorcode);
         }
 
-        // Incorrect usage passing empty array
+        // Incorrect usage passing empty array.
         $in_values = array();
         try {
             list($usql, $params) = $DB->get_in_or_equal($in_values, SQL_PARAMS_NAMED, 'param', false);
             $this->fail('An Exception is missing, expected due to empty array of items');
-        } catch (exception $e) {
-            $this->assertTrue($e instanceof coding_exception);
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('coding_exception', $e);
         }
 
-        // Test using $onemptyitems
+        // Test using $onemptyitems.
 
-        // Correct usage passing empty array and $onemptyitems = NULL (equal = true, QM)
+        // Correct usage passing empty array and $onemptyitems = null (equal = true, QM).
         $in_values = array();
-        list($usql, $params) = $DB->get_in_or_equal($in_values, SQL_PARAMS_QM, 'param', true, NULL);
-        $this->assertEquals(' IS NULL', $usql);
+        list($usql, $params) = $DB->get_in_or_equal($in_values, SQL_PARAMS_QM, 'param', true, null);
+        $this->assertSame(' IS NULL', $usql);
         $this->assertSame(array(), $params);
 
-        // Correct usage passing empty array and $onemptyitems = NULL (equal = false, NAMED)
+        // Correct usage passing empty array and $onemptyitems = null (equal = false, NAMED).
         $in_values = array();
-        list($usql, $params) = $DB->get_in_or_equal($in_values, SQL_PARAMS_NAMED, 'param', false, NULL);
-        $this->assertEquals(' IS NOT NULL', $usql);
+        list($usql, $params) = $DB->get_in_or_equal($in_values, SQL_PARAMS_NAMED, 'param', false, null);
+        $this->assertSame(' IS NOT NULL', $usql);
         $this->assertSame(array(), $params);
 
-        // Correct usage passing empty array and $onemptyitems = true (equal = true, QM)
+        // Correct usage passing empty array and $onemptyitems = true (equal = true, QM).
         $in_values = array();
         list($usql, $params) = $DB->get_in_or_equal($in_values, SQL_PARAMS_QM, 'param', true, true);
-        $this->assertEquals('= ?', $usql);
+        $this->assertSame('= ?', $usql);
         $this->assertSame(array(true), $params);
 
-        // Correct usage passing empty array and $onemptyitems = true (equal = false, NAMED)
+        // Correct usage passing empty array and $onemptyitems = true (equal = false, NAMED).
         $in_values = array();
         list($usql, $params) = $DB->get_in_or_equal($in_values, SQL_PARAMS_NAMED, 'param', false, true);
-        $this->assertEquals(1, count($params));
+        $this->assertCount(1, $params);
         $value = reset($params);
         $key = key($params);
-        $this->assertEquals('<> :'.$key, $usql);
+        $this->assertSame('<> :'.$key, $usql);
         $this->assertSame($value, true);
 
-        // Correct usage passing empty array and $onemptyitems = -1 (equal = true, QM)
+        // Correct usage passing empty array and $onemptyitems = -1 (equal = true, QM).
         $in_values = array();
         list($usql, $params) = $DB->get_in_or_equal($in_values, SQL_PARAMS_QM, 'param', true, -1);
-        $this->assertEquals('= ?', $usql);
+        $this->assertSame('= ?', $usql);
         $this->assertSame(array(-1), $params);
 
-        // Correct usage passing empty array and $onemptyitems = -1 (equal = false, NAMED)
+        // Correct usage passing empty array and $onemptyitems = -1 (equal = false, NAMED).
         $in_values = array();
         list($usql, $params) = $DB->get_in_or_equal($in_values, SQL_PARAMS_NAMED, 'param', false, -1);
-        $this->assertEquals(1, count($params));
+        $this->assertCount(1, $params);
         $value = reset($params);
         $key = key($params);
-        $this->assertEquals('<> :'.$key, $usql);
+        $this->assertSame('<> :'.$key, $usql);
         $this->assertSame($value, -1);
 
-        // Correct usage passing empty array and $onemptyitems = 'onevalue' (equal = true, QM)
+        // Correct usage passing empty array and $onemptyitems = 'onevalue' (equal = true, QM).
         $in_values = array();
         list($usql, $params) = $DB->get_in_or_equal($in_values, SQL_PARAMS_QM, 'param', true, 'onevalue');
-        $this->assertEquals('= ?', $usql);
+        $this->assertSame('= ?', $usql);
         $this->assertSame(array('onevalue'), $params);
 
-        // Correct usage passing empty array and $onemptyitems = 'onevalue' (equal = false, NAMED)
+        // Correct usage passing empty array and $onemptyitems = 'onevalue' (equal = false, NAMED).
         $in_values = array();
         list($usql, $params) = $DB->get_in_or_equal($in_values, SQL_PARAMS_NAMED, 'param', false, 'onevalue');
-        $this->assertEquals(1, count($params));
+        $this->assertCount(1, $params);
         $value = reset($params);
         $key = key($params);
-        $this->assertEquals('<> :'.$key, $usql);
+        $this->assertSame('<> :'.$key, $usql);
         $this->assertSame($value, 'onevalue');
     }
 
@@ -277,37 +277,37 @@ class core_dml_testcase extends database_driver_testcase {
         $DB = new moodle_database_for_testing();
         $prefix = $DB->get_prefix();
 
-        // Simple placeholder
+        // Simple placeholder.
         $placeholder = "{user_123}";
         $this->assertSame($prefix."user_123", $DB->public_fix_table_names($placeholder));
 
-        // wrong table name
+        // Wrong table name.
         $placeholder = "{user-a}";
         $this->assertSame($placeholder, $DB->public_fix_table_names($placeholder));
 
-        // wrong table name
+        // Wrong table name.
         $placeholder = "{123user}";
         $this->assertSame($placeholder, $DB->public_fix_table_names($placeholder));
 
-        // Full SQL
+        // Full SQL.
         $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";
         $this->assertSame($expected, $DB->public_fix_table_names($sql));
     }
 
-    function test_fix_sql_params() {
+    public function test_fix_sql_params() {
         $DB = $this->tdb;
         $prefix = $DB->get_prefix();
 
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        // Correct table placeholder substitution
+        // Correct table placeholder substitution.
         $sql = "SELECT * FROM {{$tablename}}";
         $sqlarray = $DB->fix_sql_params($sql);
         $this->assertEquals("SELECT * FROM {$prefix}".$tablename, $sqlarray[0]);
 
-        // Conversions of all param types
+        // Conversions of all param types.
         $sql = array();
         $sql[SQL_PARAMS_NAMED]  = "SELECT * FROM {$prefix}testtable WHERE name = :param1, course = :param2";
         $sql[SQL_PARAMS_QM]     = "SELECT * FROM {$prefix}testtable WHERE name = ?, course = ?";
@@ -330,134 +330,124 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertSame($rsql, $sql[$rtype]);
         $this->assertSame($rparams, $params[$rtype]);
 
-
-        // Malformed table placeholder
+        // Malformed table placeholder.
         $sql = "SELECT * FROM [testtable]";
         $sqlarray = $DB->fix_sql_params($sql);
         $this->assertSame($sql, $sqlarray[0]);
 
-
-        // Mixed param types (colon and dollar)
+        // Mixed param types (colon and dollar).
         $sql = "SELECT * FROM {{$tablename}} WHERE name = :param1, course = \$1";
         $params = array('param1' => 'record1', 'param2' => 3);
         try {
             $DB->fix_sql_params($sql, $params);
             $this->fail("Expecting an exception, none occurred");
-        } catch (Exception $e) {
-            $this->assertTrue($e instanceof dml_exception);
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('dml_exception', $e);
         }
 
-        // Mixed param types (question and dollar)
+        // Mixed param types (question and dollar).
         $sql = "SELECT * FROM {{$tablename}} WHERE name = ?, course = \$1";
         $params = array('param1' => 'record2', 'param2' => 5);
         try {
             $DB->fix_sql_params($sql, $params);
             $this->fail("Expecting an exception, none occurred");
-        } catch (Exception $e) {
-            $this->assertTrue($e instanceof dml_exception);
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('dml_exception', $e);
         }
 
-        // Too few params in sql
+        // Too few params in sql.
         $sql = "SELECT * FROM {{$tablename}} WHERE name = ?, course = ?, id = ?";
         $params = array('record2', 3);
         try {
             $DB->fix_sql_params($sql, $params);
             $this->fail("Expecting an exception, none occurred");
-        } catch (Exception $e) {
-            $this->assertTrue($e instanceof dml_exception);
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('dml_exception', $e);
         }
 
-        // Too many params in array: no error, just use what is necessary
+        // Too many params in array: no error, just use what is necessary.
         $params[] = 1;
         $params[] = time();
-        try {
-            $sqlarray = $DB->fix_sql_params($sql, $params);
-            $this->assertTrue(is_array($sqlarray));
-            $this->assertEquals(count($sqlarray[1]), 3);
-        } catch (Exception $e) {
-            $this->fail("Unexpected ".get_class($e)." exception");
-        }
+        $sqlarray = $DB->fix_sql_params($sql, $params);
+        $this->assertInternalType('array', $sqlarray);
+        $this->assertCount(3, $sqlarray[1]);
 
-        // Named params missing from array
+        // Named params missing from array.
         $sql = "SELECT * FROM {{$tablename}} WHERE name = :name, course = :course";
         $params = array('wrongname' => 'record1', 'course' => 1);
         try {
             $DB->fix_sql_params($sql, $params);
             $this->fail("Expecting an exception, none occurred");
-        } catch (Exception $e) {
-            $this->assertTrue($e instanceof dml_exception);
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('dml_exception', $e);
         }
 
         // Duplicate named param in query - this is a very important feature!!
-        // it helps with debugging of sloppy code
+        // it helps with debugging of sloppy code.
         $sql = "SELECT * FROM {{$tablename}} WHERE name = :name, course = :name";
         $params = array('name' => 'record2', 'course' => 3);
         try {
             $DB->fix_sql_params($sql, $params);
             $this->fail("Expecting an exception, none occurred");
-        } catch (Exception $e) {
-            $this->assertTrue($e instanceof dml_exception);
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('dml_exception', $e);
         }
 
-        // Extra named param is ignored
+        // Extra named param is ignored.
         $sql = "SELECT * FROM {{$tablename}} WHERE name = :name, course = :course";
         $params = array('name' => 'record1', 'course' => 1, 'extrastuff'=>'haha');
-        try {
-            $sqlarray = $DB->fix_sql_params($sql, $params);
-            $this->assertTrue(is_array($sqlarray));
-            $this->assertEquals(count($sqlarray[1]), 2);
-        } catch (Exception $e) {
-            $this->fail("Unexpected ".get_class($e)." exception");
-        }
+        $sqlarray = $DB->fix_sql_params($sql, $params);
+        $this->assertInternalType('array', $sqlarray);
+        $this->assertCount(2, $sqlarray[1]);
 
-        // Params exceeding 30 chars length
+        // Params exceeding 30 chars length.
         $sql = "SELECT * FROM {{$tablename}} WHERE name = :long_placeholder_with_more_than_30";
         $params = array('long_placeholder_with_more_than_30' => 'record1');
         try {
             $DB->fix_sql_params($sql, $params);
             $this->fail("Expecting an exception, none occurred");
-        } catch (Exception $e) {
-            $this->assertTrue($e instanceof coding_exception);
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('coding_exception', $e);
         }
 
-        // Booleans in NAMED params are casting to 1/0 int
+        // Booleans in NAMED params are casting to 1/0 int.
         $sql = "SELECT * FROM {{$tablename}} WHERE course = ? OR course = ?";
         $params = array(true, false);
         list($sql, $params) = $DB->fix_sql_params($sql, $params);
         $this->assertTrue(reset($params) === 1);
         $this->assertTrue(next($params) === 0);
 
-        // Booleans in QM params are casting to 1/0 int
+        // Booleans in QM params are casting to 1/0 int.
         $sql = "SELECT * FROM {{$tablename}} WHERE course = :course1 OR course = :course2";
         $params = array('course1' => true, 'course2' => false);
         list($sql, $params) = $DB->fix_sql_params($sql, $params);
         $this->assertTrue(reset($params) === 1);
         $this->assertTrue(next($params) === 0);
 
-        // Booleans in DOLLAR params are casting to 1/0 int
+        // Booleans in DOLLAR params are casting to 1/0 int.
         $sql = "SELECT * FROM {{$tablename}} WHERE course = \$1 OR course = \$2";
         $params = array(true, false);
         list($sql, $params) = $DB->fix_sql_params($sql, $params);
         $this->assertTrue(reset($params) === 1);
         $this->assertTrue(next($params) === 0);
 
-        // No data types are touched except bool
+        // No data types are touched except bool.
         $sql = "SELECT * FROM {{$tablename}} WHERE name IN (?,?,?,?,?,?)";
-        $inparams = array('abc', 'ABC', NULL, '1', 1, 1.4);
+        $inparams = array('abc', 'ABC', null, '1', 1, 1.4);
         list($sql, $params) = $DB->fix_sql_params($sql, $inparams);
         $this->assertSame(array_values($params), array_values($inparams));
     }
 
     public function test_strtok() {
-        // 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;
         $dbman = $this->tdb->get_manager();
 
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_field('name', XMLDB_TYPE_CHAR, '255', null, null, null, 'lala');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
@@ -472,7 +462,7 @@ class core_dml_testcase extends database_driver_testcase {
 
     public function test_tweak_param_names() {
         // Note the tweak_param_names() method is only available in the oracle driver,
-        // hence we look for expected results indirectly, by testing various DML methods
+        // hence we look for expected results indirectly, by testing various DML methods.
         // with some "extreme" conditions causing the tweak to happen.
         $DB = $this->tdb;
         $dbman = $this->tdb->get_manager();
@@ -480,12 +470,12 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        // Add some columns with 28 chars in the name
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        // Add some columns with 28 chars in the name.
         $table->add_field('long_int_columnname_with_28c', XMLDB_TYPE_INTEGER, '10');
         $table->add_field('long_dec_columnname_with_28c', XMLDB_TYPE_NUMBER, '10,2');
         $table->add_field('long_str_columnname_with_28c', XMLDB_TYPE_CHAR, '100');
-        // Add some columns with 30 chars in the name
+        // Add some columns with 30 chars in the name.
         $table->add_field('long_int_columnname_with_30cxx', XMLDB_TYPE_INTEGER, '10');
         $table->add_field('long_dec_columnname_with_30cxx', XMLDB_TYPE_NUMBER, '10,2');
         $table->add_field('long_str_columnname_with_30cxx', XMLDB_TYPE_CHAR, '100');
@@ -496,7 +486,7 @@ class core_dml_testcase extends database_driver_testcase {
 
         $this->assertTrue($dbman->table_exists($tablename));
 
-        // Test insert record
+        // Test insert record.
         $rec1 = new stdClass();
         $rec1->long_int_columnname_with_28c = 28;
         $rec1->long_dec_columnname_with_28c = 28.28;
@@ -505,15 +495,15 @@ class core_dml_testcase extends database_driver_testcase {
         $rec1->long_dec_columnname_with_30cxx = 30.30;
         $rec1->long_str_columnname_with_30cxx = '30';
 
-        // insert_record()
+        // Insert_record().
         $rec1->id = $DB->insert_record($tablename, $rec1);
         $this->assertEquals($rec1, $DB->get_record($tablename, array('id' => $rec1->id)));
 
-        // update_record()
+        // Update_record().
         $DB->update_record($tablename, $rec1);
         $this->assertEquals($rec1, $DB->get_record($tablename, array('id' => $rec1->id)));
 
-        // set_field()
+        // Set_field().
         $rec1->long_int_columnname_with_28c = 280;
         $DB->set_field($tablename, 'long_int_columnname_with_28c', $rec1->long_int_columnname_with_28c,
             array('id' => $rec1->id, 'long_int_columnname_with_28c' => 28));
@@ -534,14 +524,14 @@ class core_dml_testcase extends database_driver_testcase {
             array('id' => $rec1->id, 'long_str_columnname_with_30cxx' => '30'));
         $this->assertEquals($rec1, $DB->get_record($tablename, array('id' => $rec1->id)));
 
-        // delete_records()
+        // Delete_records().
         $rec2 = $DB->get_record($tablename, array('id' => $rec1->id));
         $rec2->id = $DB->insert_record($tablename, $rec2);
         $this->assertEquals(2, $DB->count_records($tablename));
         $DB->delete_records($tablename, (array) $rec2);
         $this->assertEquals(1, $DB->count_records($tablename));
 
-        // get_recordset()
+        // Get_recordset().
         $rs = $DB->get_recordset($tablename, (array) $rec1);
         $iterations = 0;
         foreach ($rs as $rec2) {
@@ -551,12 +541,12 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertEquals(1, $iterations);
         $this->assertEquals($rec1, $rec2);
 
-        // get_records()
+        // Get_records().
         $recs = $DB->get_records($tablename, (array) $rec1);
-        $this->assertEquals(1, count($recs));
+        $this->assertCount(1, $recs);
         $this->assertEquals($rec1, reset($recs));
 
-        // get_fieldset_select()
+        // Get_fieldset_select().
         $select = 'id = :id AND
                    long_int_columnname_with_28c = :long_int_columnname_with_28c AND
                    long_dec_columnname_with_28c = :long_dec_columnname_with_28c AND
@@ -565,7 +555,7 @@ class core_dml_testcase extends database_driver_testcase {
                    long_dec_columnname_with_30cxx = :long_dec_columnname_with_30cxx AND
                    long_str_columnname_with_30cxx = :long_str_columnname_with_30cxx';
         $fields = $DB->get_fieldset_select($tablename, 'long_int_columnname_with_28c', $select, (array)$rec1);
-        $this->assertEquals(1, count($fields));
+        $this->assertCount(1, $fields);
         $this->assertEquals($rec1->long_int_columnname_with_28c, reset($fields));
         $fields = $DB->get_fieldset_select($tablename, 'long_dec_columnname_with_28c', $select, (array)$rec1);
         $this->assertEquals($rec1->long_dec_columnname_with_28c, reset($fields));
@@ -578,7 +568,7 @@ class core_dml_testcase extends database_driver_testcase {
         $fields = $DB->get_fieldset_select($tablename, 'long_str_columnname_with_30cxx', $select, (array)$rec1);
         $this->assertEquals($rec1->long_str_columnname_with_30cxx, reset($fields));
 
-        // overlapping placeholders (progressive str_replace)
+        // Overlapping placeholders (progressive str_replace).
         $overlapselect = 'id = :p AND
                    long_int_columnname_with_28c = :param1 AND
                    long_dec_columnname_with_28c = :param2 AND
@@ -595,10 +585,10 @@ class core_dml_testcase extends database_driver_testcase {
             'param_' => $rec1->long_dec_columnname_with_30cxx,
             'param__' => $rec1->long_str_columnname_with_30cxx);
         $recs = $DB->get_records_select($tablename, $overlapselect, $overlapparams);
-        $this->assertEquals(1, count($recs));
+        $this->assertCount(1, $recs);
         $this->assertEquals($rec1, reset($recs));
 
-        // execute()
+        // Execute().
         $DB->execute("DELETE FROM {{$tablename}} WHERE $select", (array)$rec1);
         $this->assertEquals(0, $DB->count_records($tablename));
     }
@@ -607,13 +597,13 @@ class core_dml_testcase extends database_driver_testcase {
         $DB = $this->tdb;
         $dbman = $this->tdb->get_manager();
 
-        // Need to test with multiple DBs
+        // Need to test with multiple DBs.
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
         $original_count = count($DB->get_tables());
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
 
         $dbman->create_table($table);
@@ -630,17 +620,17 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $table->add_index('course', XMLDB_INDEX_NOTUNIQUE, array('course'));
         $table->add_index('course-id', XMLDB_INDEX_UNIQUE, array('course', 'id'));
         $dbman->create_table($table);
 
         $indices = $DB->get_indexes($tablename);
-        $this->assertTrue(is_array($indices));
-        $this->assertEquals(count($indices), 2);
-        // we do not care about index names for now
+        $this->assertInternalType('array', $indices);
+        $this->assertCount(2, $indices);
+        // We do not care about index names for now.
         $first = array_shift($indices);
         $second = array_shift($indices);
         if (count($first['columns']) == 2) {
@@ -652,11 +642,11 @@ class core_dml_testcase extends database_driver_testcase {
         }
         $this->assertFalse($single['unique']);
         $this->assertTrue($composed['unique']);
-        $this->assertEquals(1, count($single['columns']));
-        $this->assertEquals(2, count($composed['columns']));
-        $this->assertEquals('course', $single['columns'][0]);
-        $this->assertEquals('course', $composed['columns'][0]);
-        $this->assertEquals('id', $composed['columns'][1]);
+        $this->assertCount(1, $single['columns']);
+        $this->assertCount(2, $composed['columns']);
+        $this->assertSame('course', $single['columns'][0]);
+        $this->assertSame('course', $composed['columns'][0]);
+        $this->assertSame('id', $composed['columns'][1]);
     }
 
     public function test_get_columns() {
@@ -666,8 +656,8 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_field('name', XMLDB_TYPE_CHAR, '255', null, null, null, 'lala');
         $table->add_field('description', XMLDB_TYPE_TEXT, 'small', null, null, null, null);
         $table->add_field('enumfield', XMLDB_TYPE_CHAR, '255', null, XMLDB_NOTNULL, null, 'test2');
@@ -692,34 +682,34 @@ class core_dml_testcase extends database_driver_testcase {
         $dbman->create_table($table);
 
         $columns = $DB->get_columns($tablename);
-        $this->assertTrue(is_array($columns));
+        $this->assertInternalType('array', $columns);
 
         $fields = $table->getFields();
-        $this->assertEquals(count($columns), count($fields));
+        $this->assertCount(count($columns), $fields);
 
         $field = $columns['id'];
-        $this->assertEquals('R', $field->meta_type);
+        $this->assertSame('R', $field->meta_type);
         $this->assertTrue($field->auto_increment);
         $this->assertTrue($field->unique);
 
         $field = $columns['course'];
-        $this->assertEquals('I', $field->meta_type);
+        $this->assertSame('I', $field->meta_type);
         $this->assertFalse($field->auto_increment);
         $this->assertTrue($field->has_default);
         $this->assertEquals(0, $field->default_value);
         $this->assertTrue($field->not_null);
 
-        for($i=1;$i<=10;$i++) {
+        for ($i=1; $i<=10; $i++) {
             $field = $columns['someint'.$i];
-            $this->assertEquals('I', $field->meta_type);
+            $this->assertSame('I', $field->meta_type);
             $this->assertGreaterThanOrEqual($i, $field->max_length);
         }
         $field = $columns['someint18'];
-        $this->assertEquals('I', $field->meta_type);
+        $this->assertSame('I', $field->meta_type);
         $this->assertGreaterThanOrEqual(18, $field->max_length);
 
         $field = $columns['name'];
-        $this->assertEquals('C', $field->meta_type);
+        $this->assertSame('C', $field->meta_type);
         $this->assertFalse($field->auto_increment);
         $this->assertEquals(255, $field->max_length);
         $this->assertTrue($field->has_default);
@@ -727,20 +717,20 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertFalse($field->not_null);
 
         $field = $columns['description'];
-        $this->assertEquals('X', $field->meta_type);
+        $this->assertSame('X', $field->meta_type);
         $this->assertFalse($field->auto_increment);
         $this->assertFalse($field->has_default);
-        $this->assertSame(null, $field->default_value);
+        $this->assertNull($field->default_value);
         $this->assertFalse($field->not_null);
 
         $field = $columns['enumfield'];
-        $this->assertEquals('C', $field->meta_type);
+        $this->assertSame('C', $field->meta_type);
         $this->assertFalse($field->auto_increment);
         $this->assertSame('test2', $field->default_value);
         $this->assertTrue($field->not_null);
 
         $field = $columns['onenum'];
-        $this->assertEquals('N', $field->meta_type);
+        $this->assertSame('N', $field->meta_type);
         $this->assertFalse($field->auto_increment);
         $this->assertEquals(10, $field->max_length);
         $this->assertEquals(2, $field->scale);
@@ -749,20 +739,20 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertFalse($field->not_null);
 
         $field = $columns['onefloat'];
-        $this->assertEquals('N', $field->meta_type);
+        $this->assertSame('N', $field->meta_type);
         $this->assertFalse($field->auto_increment);
         $this->assertTrue($field->has_default);
         $this->assertEquals(300.0, $field->default_value);
         $this->assertFalse($field->not_null);
 
         $field = $columns['anotherfloat'];
-        $this->assertEquals('N', $field->meta_type);
+        $this->assertSame('N', $field->meta_type);
         $this->assertFalse($field->auto_increment);
         $this->assertTrue($field->has_default);
         $this->assertEquals(400.0, $field->default_value);
         $this->assertFalse($field->not_null);
 
-        // Test negative defaults in numerical columns
+        // Test negative defaults in numerical columns.
         $field = $columns['negativedfltint'];
         $this->assertTrue($field->has_default);
         $this->assertEquals(-1, $field->default_value);
@@ -787,16 +777,16 @@ class core_dml_testcase extends database_driver_testcase {
             $this->assertEquals($next_column->name, $next_field->getName());
         }
 
-        // Test get_columns for non-existing table returns empty array. MDL-30147
+        // Test get_columns for non-existing table returns empty array. MDL-30147.
         $columns = $DB->get_columns('xxxx');
         $this->assertEquals(array(), $columns);
 
-        // create something similar to "context_temp" with id column without sequence
+        // Create something similar to "context_temp" with id column without sequence.
         $dbman->drop_table($table);
         $table = $this->get_test_table();
         $tablename = $table->getName();
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
@@ -808,7 +798,7 @@ class core_dml_testcase extends database_driver_testcase {
         $DB = $this->tdb;
         $dbman = $this->tdb->get_manager();
 
-        $this->assertTrue($dbman instanceof database_manager);
+        $this->assertInstanceOf('database_manager', $dbman);
     }
 
     public function test_setup_is_unicodedb() {
@@ -816,15 +806,15 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertTrue($DB->setup_is_unicodedb());
     }
 
-    public function test_set_debug() { //tests get_debug() too
+    public function test_set_debug() { // Tests get_debug() too.
         $DB = $this->tdb;
         $dbman = $this->tdb->get_manager();
 
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
@@ -857,8 +847,8 @@ class core_dml_testcase extends database_driver_testcase {
 
         $table1 = $this->get_test_table('1');
         $tablename1 = $table1->getName();
-        $table1->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table1->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table1->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table1->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table1->add_field('name', XMLDB_TYPE_CHAR, '255', null, null, null, '0');
         $table1->add_index('course', XMLDB_INDEX_NOTUNIQUE, array('course'));
         $table1->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
@@ -866,8 +856,8 @@ class core_dml_testcase extends database_driver_testcase {
 
         $table2 = $this->get_test_table('2');
         $tablename2 = $table2->getName();
-        $table2->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table2->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table2->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table2->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table2->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table2);
 
@@ -876,44 +866,44 @@ class core_dml_testcase extends database_driver_testcase {
         $DB->insert_record($tablename1, array('course' => 7, 'name' => 'ccc'));
         $DB->insert_record($tablename1, array('course' => 3, 'name' => 'ddd'));
 
-        // select results are ignored
+        // Select results are ignored.
         $sql = "SELECT * FROM {{$tablename1}} WHERE course = :course";
         $this->assertTrue($DB->execute($sql, array('course'=>3)));
 
-        // throw exception on error
+        // Throw exception on error.
         $sql = "XXUPDATE SET XSSD";
         try {
             $DB->execute($sql);
             $this->fail("Expecting an exception, none occurred");
-        } catch (Exception $e) {
-            $this->assertTrue($e instanceof dml_exception);
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('dml_exception', $e);
         }
 
-        // update records
+        // Update records.
         $sql = "UPDATE {{$tablename1}}
                    SET course = 6
                  WHERE course = ?";
         $this->assertTrue($DB->execute($sql, array('3')));
-        $this->assertEquals($DB->count_records($tablename1, array('course' => 6)), 2);
+        $this->assertEquals(2, $DB->count_records($tablename1, array('course' => 6)));
 
-        // update records with subquery condition
-        // confirm that the option not using table aliases is cross-db
+        // Update records with subquery condition.
+        // Confirm that the option not using table aliases is cross-db.
         $sql = "UPDATE {{$tablename1}}
                    SET course = 0
                  WHERE NOT EXISTS (
                            SELECT course
                              FROM {{$tablename2}} tbl2
                             WHERE tbl2.course = {{$tablename1}}.course
-                              AND 1 = 0)"; // Really we don't update anything, but verify the syntax is allowed
+                              AND 1 = 0)"; // Really we don't update anything, but verify the syntax is allowed.
         $this->assertTrue($DB->execute($sql));
 
-        // insert from one into second table
+        // Insert from one into second table.
         $sql = "INSERT INTO {{$tablename2}} (course)
 
                 SELECT course
                   FROM {{$tablename1}}";
         $this->assertTrue($DB->execute($sql));
-        $this->assertEquals($DB->count_records($tablename2), 4);
+        $this->assertEquals(4, $DB->count_records($tablename2));
     }
 
     public function test_get_recordset() {
@@ -923,8 +913,8 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_field('name', XMLDB_TYPE_CHAR, '255', null, null, null, '0');
         $table->add_field('onetext', XMLDB_TYPE_TEXT, 'big', null, null, null);
         $table->add_index('course', XMLDB_INDEX_NOTUNIQUE, array('course'));
@@ -935,15 +925,15 @@ class core_dml_testcase extends database_driver_testcase {
             array('course' => 3, 'name' => 'record2', 'onetext'=>'abcd'),
             array('course' => 5, 'name' => 'record3', 'onetext'=>'abcde'));
 
-        foreach ($data as $key=>$record) {
+        foreach ($data as $key => $record) {
             $data[$key]['id'] = $DB->insert_record($tablename, $record);
         }
 
-        // standard recordset iteration
+        // Standard recordset iteration.
         $rs = $DB->get_recordset($tablename);
-        $this->assertTrue($rs instanceof moodle_recordset);
+        $this->assertInstanceOf('moodle_recordset', $rs);
         reset($data);
-        foreach($rs as $record) {
+        foreach ($rs as $record) {
             $data_record = current($data);
             foreach ($record as $k => $v) {
                 $this->assertEquals($data_record[$k], $v);
@@ -952,9 +942,9 @@ class core_dml_testcase extends database_driver_testcase {
         }
         $rs->close();
 
-        // iterator style usage
+        // Iterator style usage.
         $rs = $DB->get_recordset($tablename);
-        $this->assertTrue($rs instanceof moodle_recordset);
+        $this->assertInstanceOf('moodle_recordset', $rs);
         reset($data);
         while ($rs->valid()) {
             $record = $rs->current();
@@ -967,12 +957,12 @@ class core_dml_testcase extends database_driver_testcase {
         }
         $rs->close();
 
-        // make sure rewind is ignored
+        // Make sure rewind is ignored.
         $rs = $DB->get_recordset($tablename);
-        $this->assertTrue($rs instanceof moodle_recordset);
+        $this->assertInstanceOf('moodle_recordset', $rs);
         reset($data);
         $i = 0;
-        foreach($rs as $record) {
+        foreach ($rs as $record) {
             $i++;
             $rs->rewind();
             if ($i > 10) {
@@ -987,33 +977,33 @@ class core_dml_testcase extends database_driver_testcase {
         }
         $rs->close();
 
-        // test for exception throwing on text conditions being compared. (MDL-24863, unwanted auto conversion of param to int)
+        // Test for exception throwing on text conditions being compared. (MDL-24863, unwanted auto conversion of param to int).
         $conditions = array('onetext' => '1');
         try {
             $rs = $DB->get_recordset($tablename, $conditions);
             $this->fail('An Exception is missing, expected due to equating of text fields');
-        } catch (exception $e) {
-            $this->assertTrue($e instanceof dml_exception);
-            $this->assertEquals($e->errorcode, 'textconditionsnotallowed');
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('dml_exception', $e);
+            $this->assertSame('textconditionsnotallowed', $e->errorcode);
         }
 
         // Test nested iteration.
         $rs1 = $DB->get_recordset($tablename);
         $i = 0;
-        foreach($rs1 as $record1) {
+        foreach ($rs1 as $record1) {
             $rs2 = $DB->get_recordset($tablename);
             $i++;
             $j = 0;
-            foreach($rs2 as $record2) {
+            foreach ($rs2 as $record2) {
                 $j++;
             }
             $rs2->close();
-            $this->assertEquals($j, count($data));
+            $this->assertCount($j, $data);
         }
         $rs1->close();
-        $this->assertEquals($i, count($data));
+        $this->assertCount($i, $data);
 
-        // notes:
+        // Notes:
         //  * limits are tested in test_get_recordset_sql()
         //  * where_clause() is used internally and is tested in test_get_records()
     }
@@ -1025,8 +1015,8 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
@@ -1041,7 +1031,7 @@ class core_dml_testcase extends database_driver_testcase {
         $DB->delete_records($tablename, array('course'=>2));
 
         $i = 0;
-        foreach($rs as $record) {
+        foreach ($rs as $record) {
             $i++;
             $this->assertEquals($i, $record->course);
         }
@@ -1062,7 +1052,7 @@ class core_dml_testcase extends database_driver_testcase {
         $DB->delete_records($tablename, array('course'=>2));
 
         $i = 0;
-        foreach($rs as $record) {
+        foreach ($rs as $record) {
             $i++;
             $this->assertEquals($i, $record->course);
         }
@@ -1077,8 +1067,8 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_field('name', XMLDB_TYPE_CHAR, '255', null, null, null, '0');
         $table->add_index('course', XMLDB_INDEX_NOTUNIQUE, array('course'));
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
@@ -1087,52 +1077,52 @@ class core_dml_testcase extends database_driver_testcase {
         $data = array(array('course' => 3, 'name' => 'record1'),
             array('course' => 3, 'name' => 'record2'),
             array('course' => 5, 'name' => 'record3'));
-        foreach ($data as $key=>$record) {
+        foreach ($data as $key => $record) {
             $data[$key]['id'] = $DB->insert_record($tablename, $record);
         }
 
-        // Test repeated numeric keys are returned ok
-        $rs = $DB->get_recordset($tablename, NULL, NULL, 'course, name, id');
+        // Test repeated numeric keys are returned ok.
+        $rs = $DB->get_recordset($tablename, null, null, 'course, name, id');
 
         reset($data);
         $count = 0;
-        foreach($rs as $key => $record) {
+        foreach ($rs as $key => $record) {
             $data_record = current($data);
             $this->assertEquals($data_record['course'], $key);
             next($data);
             $count++;
         }
         $rs->close();
-        $this->assertEquals($count, 3);
+        $this->assertEquals(3, $count);
 
-        // Test string keys are returned ok
-        $rs = $DB->get_recordset($tablename, NULL, NULL, 'name, course, id');
+        // Test string keys are returned ok.
+        $rs = $DB->get_recordset($tablename, null, null, 'name, course, id');
 
         reset($data);
         $count = 0;
-        foreach($rs as $key => $record) {
+        foreach ($rs as $key => $record) {
             $data_record = current($data);
             $this->assertEquals($data_record['name'], $key);
             next($data);
             $count++;
         }
         $rs->close();
-        $this->assertEquals($count, 3);
+        $this->assertEquals(3, $count);
 
-        // Test numeric not starting in 1 keys are returned ok
-        $rs = $DB->get_recordset($tablename, NULL, 'id DESC', 'id, course, name');
+        // Test numeric not starting in 1 keys are returned ok.
+        $rs = $DB->get_recordset($tablename, null, 'id DESC', 'id, course, name');
 
         $data = array_reverse($data);
         reset($data);
         $count = 0;
-        foreach($rs as $key => $record) {
+        foreach ($rs as $key => $record) {
             $data_record = current($data);
             $this->assertEquals($data_record['id'], $key);
             next($data);
             $count++;
         }
         $rs->close();
-        $this->assertEquals($count, 3);
+        $this->assertEquals(3, $count);
     }
 
     public function test_get_recordset_list() {
@@ -1142,8 +1132,8 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, null, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, null, null, '0');
         $table->add_index('course', XMLDB_INDEX_NOTUNIQUE, array('course'));
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
@@ -1212,7 +1202,7 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertEquals(1, $counter);
         $rs->close();
 
-        $rs = $DB->get_recordset_list($tablename, 'course',array()); // Must return 0 rows without conditions. MDL-17645
+        $rs = $DB->get_recordset_list($tablename, 'course', array()); // Must return 0 rows without conditions. MDL-17645.
 
         $counter = 0;
         foreach ($rs as $record) {
@@ -1221,7 +1211,7 @@ class core_dml_testcase extends database_driver_testcase {
         $rs->close();
         $this->assertEquals(0, $counter);
 
-        // notes:
+        // Notes:
         //  * limits are tested in test_get_recordset_sql()
         //  * where_clause() is used internally and is tested in test_get_records()
     }
@@ -1233,8 +1223,8 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
@@ -1259,7 +1249,7 @@ class core_dml_testcase extends database_driver_testcase {
         $rs->close();
         $this->assertEquals(2, $counter);
 
-        // notes:
+        // Notes:
         //  * limits are tested in test_get_recordset_sql()
     }
 
@@ -1270,8 +1260,8 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
@@ -1291,19 +1281,19 @@ class core_dml_testcase extends database_driver_testcase {
         $rs->close();
         $this->assertEquals(2, $counter);
 
-        // limits - only need to test this case, the rest have been tested by test_get_records_sql()
-        // only limitfrom = skips that number of records
+        // Limits - only need to test this case, the rest have been tested by test_get_records_sql()
+        // only limitfrom = skips that number of records.
         $rs = $DB->get_recordset_sql("SELECT * FROM {{$tablename}} ORDER BY id", null, 2, 0);
         $records = array();
-        foreach($rs as $key => $record) {
+        foreach ($rs as $key => $record) {
             $records[$key] = $record;
         }
         $rs->close();
-        $this->assertEquals(5, count($records));
+        $this->assertCount(5, $records);
         $this->assertEquals($inskey3, reset($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() {
@@ -1343,8 +1333,8 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_field('onetext', XMLDB_TYPE_TEXT, 'big', null, null, null);
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
@@ -1354,23 +1344,23 @@ class core_dml_testcase extends database_driver_testcase {
         $DB->insert_record($tablename, array('course' => 5));
         $DB->insert_record($tablename, array('course' => 2));
 
-        // All records
+        // All records.
         $records = $DB->get_records($tablename);
-        $this->assertEquals(4, count($records));
+        $this->assertCount(4, $records);
         $this->assertEquals(3, $records[1]->course);
         $this->assertEquals(3, $records[2]->course);
         $this->assertEquals(5, $records[3]->course);
         $this->assertEquals(2, $records[4]->course);
 
-        // Records matching certain conditions
+        // Records matching certain conditions.
         $records = $DB->get_records($tablename, array('course' => 3));
-        $this->assertEquals(2, count($records));
+        $this->assertCount(2, $records);
         $this->assertEquals(3, $records[1]->course);
         $this->assertEquals(3, $records[2]->course);
 
-        // All records sorted by course
+        // All records sorted by course.
         $records = $DB->get_records($tablename, null, 'course');
-        $this->assertEquals(4, count($records));
+        $this->assertCount(4, $records);
         $current_record = reset($records);
         $this->assertEquals(4, $current_record->id);
         $current_record = next($records);
@@ -1380,68 +1370,68 @@ class core_dml_testcase extends database_driver_testcase {
         $current_record = next($records);
         $this->assertEquals(3, $current_record->id);
 
-        // All records, but get only one field
+        // All records, but get only one field.
         $records = $DB->get_records($tablename, null, '', 'id');
         $this->assertFalse(isset($records[1]->course));
         $this->assertTrue(isset($records[1]->id));
-        $this->assertEquals(4, count($records));
+        $this->assertCount(4, $records);
 
-        // Booleans into params
+        // Booleans into params.
         $records = $DB->get_records($tablename, array('course' => true));
-        $this->assertEquals(0, count($records));
+        $this->assertCount(0, $records);
         $records = $DB->get_records($tablename, array('course' => false));
-        $this->assertEquals(0, count($records));
+        $this->assertCount(0, $records);
 
-        // test for exception throwing on text conditions being compared. (MDL-24863, unwanted auto conversion of param to int)
+        // Test for exception throwing on text conditions being compared. (MDL-24863, unwanted auto conversion of param to int).
         $conditions = array('onetext' => '1');
         try {
             $records = $DB->get_records($tablename, $conditions);
             if (debugging()) {
-                // only in debug mode - hopefully all devs test code in debug mode...
+                // Only in debug mode - hopefully all devs test code in debug mode...
                 $this->fail('An Exception is missing, expected due to equating of text fields');
             }
-        } catch (exception $e) {
-            $this->assertTrue($e instanceof dml_exception);
-            $this->assertEquals($e->errorcode, 'textconditionsnotallowed');
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('dml_exception', $e);
+            $this->assertSame('textconditionsnotallowed', $e->errorcode);
         }
 
-        // test get_records passing non-existing table
-        // with params
+        // Test get_records passing non-existing table.
+        // with params.
         try {
             $records = $DB->get_records('xxxx', array('id' => 0));
             $this->fail('An Exception is missing, expected due to query against non-existing table');
-        } catch (exception $e) {
-            $this->assertTrue($e instanceof dml_exception);
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('dml_exception', $e);
             if (debugging()) {
-                // information for developers only, normal users get general error message
-                $this->assertEquals($e->errorcode, 'ddltablenotexist');
+                // Information for developers only, normal users get general error message.
+                $this->assertSame('ddltablenotexist', $e->errorcode);
             }
         }
-        // and without params
+        // And without params.
         try {
             $records = $DB->get_records('xxxx', array());
             $this->fail('An Exception is missing, expected due to query against non-existing table');
-        } catch (exception $e) {
-            $this->assertTrue($e instanceof dml_exception);
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('dml_exception', $e);
             if (debugging()) {
-                // information for developers only, normal users get general error message
-                $this->assertEquals($e->errorcode, 'ddltablenotexist');
+                // Information for developers only, normal users get general error message.
+                $this->assertSame('ddltablenotexist', $e->errorcode);
             }
         }
 
-        // test get_records passing non-existing column
+        // Test get_records passing non-existing column.
         try {
             $records = $DB->get_records($tablename, array('xxxx' => 0));
             $this->fail('An Exception is missing, expected due to query against non-existing column');
-        } catch (exception $e) {
-            $this->assertTrue($e instanceof dml_exception);
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('dml_exception', $e);
             if (debugging()) {
-                // information for developers only, normal users get general error message
-                $this->assertEquals($e->errorcode, 'ddlfieldnotexist');
+                // Information for developers only, normal users get general error message.
+                $this->assertSame('ddlfieldnotexist', $e->errorcode);
             }
         }
 
-        // note: delegate limits testing to test_get_records_sql()
+        // Note: delegate limits testing to test_get_records_sql().
     }
 
     public function test_get_records_list() {
@@ -1451,8 +1441,8 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
@@ -1462,16 +1452,16 @@ class core_dml_testcase extends database_driver_testcase {
         $DB->insert_record($tablename, array('course' => 2));
 
         $records = $DB->get_records_list($tablename, 'course', array(3, 2));
-        $this->assertTrue(is_array($records));
-        $this->assertEquals(3, count($records));
+        $this->assertInternalType('array', $records);
+        $this->assertCount(3, $records);
         $this->assertEquals(1, reset($records)->id);
         $this->assertEquals(2, next($records)->id);
         $this->assertEquals(4, next($records)->id);
 
-        $this->assertSame(array(), $records = $DB->get_records_list($tablename, 'course', array())); // Must return 0 rows without conditions. MDL-17645
-        $this->assertEquals(0, count($records));
+        $this->assertSame(array(), $records = $DB->get_records_list($tablename, 'course', array())); // Must return 0 rows without conditions. MDL-17645.
+        $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() {
@@ -1481,8 +1471,8 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
@@ -1496,8 +1486,8 @@ class core_dml_testcase extends database_driver_testcase {
 
         $table2 = $this->get_test_table("2");
         $tablename2 = $table2->getName();
-        $table2->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table2->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table2->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table2->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table2->add_field('nametext', XMLDB_TYPE_TEXT, 'small', null, null, null, null);
         $table2->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table2);
@@ -1508,89 +1498,89 @@ class core_dml_testcase extends database_driver_testcase {
         $DB->insert_record($tablename2, array('course'=>6, 'nametext'=>'badabong'));
 
         $records = $DB->get_records_sql("SELECT * FROM {{$tablename}} WHERE course = ?", array(3));
-        $this->assertEquals(2, count($records));
+        $this->assertCount(2, $records);
         $this->assertEquals($inskey1, reset($records)->id);
         $this->assertEquals($inskey4, next($records)->id);
 
-        // Awful test, requires debug enabled and sent to browser. Let's do that and restore after test
+        // Awful test, requires debug enabled and sent to browser. Let's do that and restore after test.
         $records = $DB->get_records_sql("SELECT course AS id, course AS course FROM {{$tablename}}", null);
         $this->assertDebuggingCalled();
-        $this->assertEquals(6, count($records));
+        $this->assertCount(6, $records);
         set_debugging(DEBUG_MINIMAL);
         $records = $DB->get_records_sql("SELECT course AS id, course AS course FROM {{$tablename}}", null);
         $this->assertDebuggingNotCalled();
-        $this->assertEquals(6, count($records));
+        $this->assertCount(6, $records);
         set_debugging(DEBUG_DEVELOPER);
 
-        // negative limits = no limits
+        // Negative limits = no limits.
         $records = $DB->get_records_sql("SELECT * FROM {{$tablename}} ORDER BY id", null, -1, -1);
-        $this->assertEquals(7, count($records));
+        $this->assertCount(7, $records);
 
-        // zero limits = no limits
+        // Zero limits = no limits.
         $records = $DB->get_records_sql("SELECT * FROM {{$tablename}} ORDER BY id", null, 0, 0);
-        $this->assertEquals(7, count($records));
+        $this->assertCount(7, $records);
 
-        // only limitfrom = skips that number of records
+        // Only limitfrom = skips that number of records.
         $records = $DB->get_records_sql("SELECT * FROM {{$tablename}} ORDER BY id", null, 2, 0);
-        $this->assertEquals(5, count($records));
+        $this->assertCount(5, $records);
         $this->assertEquals($inskey3, reset($records)->id);
         $this->assertEquals($inskey7, end($records)->id);
 
-        // only limitnum = fetches that number of records
+        // Only limitnum = fetches that number of records.
         $records = $DB->get_records_sql("SELECT * FROM {{$tablename}} ORDER BY id", null, 0, 3);
-        $this->assertEquals(3, count($records));
+        $this->assertCount(3, $records);
         $this->assertEquals($inskey1, reset($records)->id);
         $this->assertEquals($inskey3, end($records)->id);
 
-        // both limitfrom and limitnum = skips limitfrom records and fetches limitnum ones
+        // Both limitfrom and limitnum = skips limitfrom records and fetches limitnum ones.
         $records = $DB->get_records_sql("SELECT * FROM {{$tablename}} ORDER BY id", null, 3, 2);
-        $this->assertEquals(2, count($records));
+        $this->assertCount(2, $records);
         $this->assertEquals($inskey4, reset($records)->id);
         $this->assertEquals($inskey5, end($records)->id);
 
-        // both limitfrom and limitnum in query having subqueris
-        // note the subquery skips records with course = 0 and 3
+        // Both limitfrom and limitnum in query having subqueris.
+        // Note the subquery skips records with course = 0 and 3.
         $sql = "SELECT * FROM {{$tablename}}
                  WHERE course NOT IN (
                      SELECT course FROM {{$tablename}}
                       WHERE course IN (0, 3))
                 ORDER BY course";
-        $records = $DB->get_records_sql($sql, null, 0, 2); // Skip 0, get 2
-        $this->assertEquals(2, count($records));
+        $records = $DB->get_records_sql($sql, null, 0, 2); // Skip 0, get 2.
+        $this->assertCount(2, $records);
         $this->assertEquals($inskey6, reset($records)->id);
         $this->assertEquals($inskey5, end($records)->id);
-        $records = $DB->get_records_sql($sql, null, 2, 2); // Skip 2, get 2
-        $this->assertEquals(2, count($records));
+        $records = $DB->get_records_sql($sql, null, 2, 2); // Skip 2, get 2.
+        $this->assertCount(2, $records);
         $this->assertEquals($inskey3, reset($records)->id);
         $this->assertEquals($inskey2, end($records)->id);
 
-        // test 2 tables with aliases and limits with order bys
+        // Test 2 tables with aliases and limits with order bys.
         $sql = "SELECT t1.id, t1.course AS cid, t2.nametext
                   FROM {{$tablename}} t1, {{$tablename2}} t2
                  WHERE t2.course=t1.course
               ORDER BY t1.course, ". $DB->sql_compare_text('t2.nametext');
-        $records = $DB->get_records_sql($sql, null, 2, 2); // Skip courses 3 and 6, get 4 and 5
-        $this->assertEquals(2, count($records));
-        $this->assertEquals('5', end($records)->cid);
-        $this->assertEquals('4', reset($records)->cid);
+        $records = $DB->get_records_sql($sql, null, 2, 2); // Skip courses 3 and 6, get 4 and 5.
+        $this->assertCount(2, $records);
+        $this->assertSame('5', end($records)->cid);
+        $this->assertSame('4', reset($records)->cid);
 
-        // test 2 tables with aliases and limits with the highest INT limit works
-        $records = $DB->get_records_sql($sql, null, 2, PHP_INT_MAX); // Skip course {3,6}, get {4,5}
-        $this->assertEquals(2, count($records));
-        $this->assertEquals('5', end($records)->cid);
-        $this->assertEquals('4', reset($records)->cid);
+        // Test 2 tables with aliases and limits with the highest INT limit works.
+        $records = $DB->get_records_sql($sql, null, 2, PHP_INT_MAX); // Skip course {3,6}, get {4,5}.
+        $this->assertCount(2, $records);
+        $this->assertSame('5', end($records)->cid);
+        $this->assertSame('4', reset($records)->cid);
 
-        // test 2 tables with aliases and limits with order bys (limit which is highest INT number)
-        $records = $DB->get_records_sql($sql, null, PHP_INT_MAX, 2); // Skip all courses
-        $this->assertEquals(0, count($records));
+        // Test 2 tables with aliases and limits with order bys (limit which is highest INT number).
+        $records = $DB->get_records_sql($sql, null, PHP_INT_MAX, 2); // Skip all courses.
+        $this->assertCount(0, $records);
 
-        // test 2 tables with aliases and limits with order bys (limit which s highest INT number)
-        $records = $DB->get_records_sql($sql, null, PHP_INT_MAX, PHP_INT_MAX); // Skip all courses
-        $this->assertEquals(0, count($records));
+        // Test 2 tables with aliases and limits with order bys (limit which s highest INT number).
+        $records = $DB->get_records_sql($sql, null, PHP_INT_MAX, PHP_INT_MAX); // Skip all courses.
+        $this->assertCount(0, $records);
 
-        // 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() {
@@ -1600,8 +1590,8 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
@@ -1611,14 +1601,14 @@ class core_dml_testcase extends database_driver_testcase {
         $DB->insert_record($tablename, array('course' => 2));
 
         $records = $DB->get_records_menu($tablename, array('course' => 3));
-        $this->assertTrue(is_array($records));
-        $this->assertEquals(2, count($records));
-        $this->assertFalse(empty($records[1]));
-        $this->assertFalse(empty($records[2]));
+        $this->assertInternalType('array', $records);
+        $this->assertCount(2, $records);
+        $this->assertNotEmpty($records[1]);
+        $this->assertNotEmpty($records[2]);
         $this->assertEquals(3, $records[1]);
         $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() {
@@ -1628,8 +1618,8 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
@@ -1639,18 +1629,18 @@ class core_dml_testcase extends database_driver_testcase {
         $DB->insert_record($tablename, array('course' => 5));
 
         $records = $DB->get_records_select_menu($tablename, "course > ?", array(2));
-        $this->assertTrue(is_array($records));
-
-        $this->assertEquals(3, count($records));
-        $this->assertFalse(empty($records[1]));
-        $this->assertTrue(empty($records[2]));
-        $this->assertFalse(empty($records[3]));
-        $this->assertFalse(empty($records[4]));
-        $this->assertEquals(3, $records[1]);
-        $this->assertEquals(3, $records[3]);
-        $this->assertEquals(5, $records[4]);
-
-        // note: delegate limits testing to test_get_records_sql()
+        $this->assertInternalType('array', $records);
+
+        $this->assertCount(3, $records);
+        $this->assertArrayHasKey(1, $records);
+        $this->assertArrayNotHasKey(2, $records);
+        $this->assertArrayHasKey(3, $records);
+        $this->assertArrayHasKey(4, $records);
+        $this->assertSame('3', $records[1]);
+        $this->assertSame('3', $records[3]);
+        $this->assertSame('5', $records[4]);
+
+        // Note: delegate limits testing to test_get_records_sql().
     }
 
     public function test_get_records_sql_menu() {
@@ -1660,8 +1650,8 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
@@ -1671,18 +1661,18 @@ class core_dml_testcase extends database_driver_testcase {
         $DB->insert_record($tablename, array('course' => 5));
 
         $records = $DB->get_records_sql_menu("SELECT * FROM {{$tablename}} WHERE course > ?", array(2));
-        $this->assertTrue(is_array($records));
-
-        $this->assertEquals(3, count($records));
-        $this->assertFalse(empty($records[1]));
-        $this->assertTrue(empty($records[2]));
-        $this->assertFalse(empty($records[3]));
-        $this->assertFalse(empty($records[4]));
-        $this->assertEquals(3, $records[1]);
-        $this->assertEquals(3, $records[3]);
-        $this->assertEquals(5, $records[4]);
-
-        // note: delegate limits testing to test_get_records_sql()
+        $this->assertInternalType('array', $records);
+
+        $this->assertCount(3, $records);
+        $this->assertArrayHasKey(1, $records);
+        $this->assertArrayNotHasKey(2, $records);
+        $this->assertArrayHasKey(3, $records);
+        $this->assertArrayHasKey(4, $records);
+        $this->assertSame('3', $records[1]);
+        $this->assertSame('3', $records[3]);
+        $this->assertSame('5', $records[4]);
+
+        // Note: delegate limits testing to test_get_records_sql().
     }
 
     public function test_get_record() {
@@ -1692,8 +1682,8 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
@@ -1701,7 +1691,7 @@ class core_dml_testcase extends database_driver_testcase {
         $DB->insert_record($tablename, array('course' => 2));
 
         $record = $DB->get_record($tablename, array('id' => 2));
-        $this->assertTrue($record instanceof stdClass);
+        $this->assertInstanceOf('stdClass', $record);
 
         $this->assertEquals(2, $record->course);
         $this->assertEquals(2, $record->id);
@@ -1715,8 +1705,8 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
@@ -1724,11 +1714,11 @@ class core_dml_testcase extends database_driver_testcase {
         $DB->insert_record($tablename, array('course' => 2));
 
         $record = $DB->get_record_select($tablename, "id = ?", array(2));
-        $this->assertTrue($record instanceof stdClass);
+        $this->assertInstanceOf('stdClass', $record);
 
         $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() {
@@ -1738,29 +1728,29 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
         $DB->insert_record($tablename, array('course' => 3));
         $DB->insert_record($tablename, array('course' => 2));
 
-        // standard use
+        // Standard use.
         $record = $DB->get_record_sql("SELECT * FROM {{$tablename}} WHERE id = ?", array(2));
-        $this->assertTrue($record instanceof stdClass);
+        $this->assertInstanceOf('stdClass', $record);
         $this->assertEquals(2, $record->course);
         $this->assertEquals(2, $record->id);
 
-        // backwards compatibility with $ignoremultiple
+        // Backwards compatibility with $ignoremultiple.
         $this->assertFalse((bool)IGNORE_MISSING);
         $this->assertTrue((bool)IGNORE_MULTIPLE);
 
-        // record not found - ignore
+        // Record not found - ignore.
         $this->assertFalse($DB->get_record_sql("SELECT * FROM {{$tablename}} WHERE id = ?", array(666), IGNORE_MISSING));
         $this->assertFalse($DB->get_record_sql("SELECT * FROM {{$tablename}} WHERE id = ?", array(666), IGNORE_MULTIPLE));
 
-        // record not found error
+        // Record not found error.
         try {
             $DB->get_record_sql("SELECT * FROM {{$tablename}} WHERE id = ?", array(666), MUST_EXIST);
             $this->fail("Exception expected");
@@ -1775,10 +1765,10 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertDebuggingNotCalled();
         set_debugging(DEBUG_DEVELOPER);
 
-        // multiple matches ignored
+        // Multiple matches ignored.
         $this->assertNotEmpty($DB->get_record_sql("SELECT * FROM {{$tablename}}", array(), IGNORE_MULTIPLE));
 
-        // multiple found error
+        // Multiple found error.
         try {
             $DB->get_record_sql("SELECT * FROM {{$tablename}}", array(), MUST_EXIST);
             $this->fail("Exception expected");
@@ -1794,8 +1784,8 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_field('onetext', XMLDB_TYPE_TEXT, 'big', null, null, null);
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
@@ -1807,7 +1797,7 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertEquals(3, $DB->get_field($tablename, 'course', array('id' => $id1)));
         $this->assertEquals(3, $DB->get_field($tablename, 'course', array('course' => 3)));
 
-        $this->assertSame(false, $DB->get_field($tablename, 'course', array('course' => 11), IGNORE_MISSING));
+        $this->assertFalse($DB->get_field($tablename, 'course', array('course' => 11), IGNORE_MISSING));
         try {
             $DB->get_field($tablename, 'course', array('course' => 4), MUST_EXIST);
             $this->fail('Exception expected due to missing record');
@@ -1821,17 +1811,17 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertEquals(5, $DB->get_field($tablename, 'course', array('course' => 5), IGNORE_MISSING));
         $this->assertDebuggingCalled();
 
-        // test for exception throwing on text conditions being compared. (MDL-24863, unwanted auto conversion of param to int)
+        // Test for exception throwing on text conditions being compared. (MDL-24863, unwanted auto conversion of param to int).
         $conditions = array('onetext' => '1');
         try {
             $DB->get_field($tablename, 'course', $conditions);
             if (debugging()) {
-                // only in debug mode - hopefully all devs test code in debug mode...
+                // Only in debug mode - hopefully all devs test code in debug mode...
                 $this->fail('An Exception is missing, expected due to equating of text fields');
             }
-        } catch (exception $e) {
-            $this->assertTrue($e instanceof dml_exception);
-            $this->assertEquals($e->errorcode, 'textconditionsnotallowed');
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('dml_exception', $e);
+            $this->assertSame('textconditionsnotallowed', $e->errorcode);
         }
     }
 
@@ -1842,8 +1832,8 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
@@ -1859,8 +1849,8 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
@@ -1876,8 +1866,8 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
@@ -1887,9 +1877,9 @@ class core_dml_testcase extends database_driver_testcase {
         $DB->insert_record($tablename, array('course' => 6));
 
         $fieldset = $DB->get_fieldset_select($tablename, 'course', "course > ?", array(1));
-        $this->assertTrue(is_array($fieldset));
+        $this->assertInternalType('array', $fieldset);
 
-        $this->assertEquals(3, count($fieldset));
+        $this->assertCount(3, $fieldset);
         $this->assertEquals(3, $fieldset[0]);
         $this->assertEquals(2, $fieldset[1]);
         $this->assertEquals(6, $fieldset[2]);
@@ -1902,8 +1892,8 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
@@ -1913,9 +1903,9 @@ class core_dml_testcase extends database_driver_testcase {
         $DB->insert_record($tablename, array('course' => 6));
 
         $fieldset = $DB->get_fieldset_sql("SELECT * FROM {{$tablename}} WHERE course > ?", array(1));
-        $this->assertTrue(is_array($fieldset));
+        $this->assertInternalType('array', $fieldset);
 
-        $this->assertEquals(3, count($fieldset));
+        $this->assertCount(3, $fieldset);
         $this->assertEquals(2, $fieldset[0]);
         $this->assertEquals(3, $fieldset[1]);
         $this->assertEquals(4, $fieldset[2]);
@@ -1928,8 +1918,8 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_field('onechar', XMLDB_TYPE_CHAR, '100', null, null, null, 'onestring');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
@@ -1941,26 +1931,26 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertEquals($record, $before);
 
         $record = $DB->get_record($tablename, array('course' => 1));
-        $this->assertTrue($record instanceof stdClass);
+        $this->assertInstanceOf('stdClass', $record);
         $this->assertSame('xx', $record->onechar);
 
         $result = $DB->insert_record_raw($tablename, array('course' => 2, 'onechar' => 'yy'), false);
-        $this->assertSame(true, $result);
+        $this->assertTrue($result);
 
-        // note: bulk not implemented yet
+        // Note: bulk not implemented yet.
         $DB->insert_record_raw($tablename, array('course' => 3, 'onechar' => 'zz'), true, true);
         $record = $DB->get_record($tablename, array('course' => 3));
-        $this->assertTrue($record instanceof stdClass);
+        $this->assertInstanceOf('stdClass', $record);
         $this->assertSame('zz', $record->onechar);
 
-        // custom sequence (id) - returnid is ignored
+        // Custom sequence (id) - returnid is ignored.
         $result = $DB->insert_record_raw($tablename, array('id' => 10, 'course' => 3, 'onechar' => 'bb'), true, false, true);
-        $this->assertSame(true, $result);
+        $this->assertTrue($result);
         $record = $DB->get_record($tablename, array('id' => 10));
-        $this->assertTrue($record instanceof stdClass);
+        $this->assertInstanceOf('stdClass', $record);
         $this->assertSame('bb', $record->onechar);
 
-        // custom sequence - missing id error
+        // Custom sequence - missing id error.
         try {
             $DB->insert_record_raw($tablename, array('course' => 3, 'onechar' => 'bb'), true, false, true);
             $this->fail('Exception expected due to missing record');
@@ -1968,7 +1958,7 @@ class core_dml_testcase extends database_driver_testcase {
             $this->assertTrue(true);
         }
 
-        // wrong column error
+        // Wrong column error.
         try {
             $DB->insert_record_raw($tablename, array('xxxxx' => 3, 'onechar' => 'bb'));
             $this->fail('Exception expected due to invalid column');
@@ -1976,12 +1966,12 @@ class core_dml_testcase extends database_driver_testcase {
             $this->assertTrue(true);
         }
 
-        // create something similar to "context_temp" with id column without sequence
+        // Create something similar to "context_temp" with id column without sequence.
         $dbman->drop_table($table);
         $table = $this->get_test_table();
         $tablename = $table->getName();
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
@@ -2001,9 +1991,9 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
-        $table->add_field('oneint', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, null, null, 100);
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
+        $table->add_field('oneint', XMLDB_TYPE_INTEGER, '10', null, null, null, 100);
         $table->add_field('onenum', XMLDB_TYPE_NUMBER, '10,2', null, null, null, 200);
         $table->add_field('onechar', XMLDB_TYPE_CHAR, '100', null, null, null, 'onestring');
         $table->add_field('onetext', XMLDB_TYPE_TEXT, 'big', null, null, null);
@@ -2014,19 +2004,19 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertSame(1, $DB->insert_record($tablename, array('course' => 1), true));
         $record = $DB->get_record($tablename, array('course' => 1));
         $this->assertEquals(1, $record->id);
-        $this->assertEquals(100, $record->oneint); // Just check column defaults have been applied
+        $this->assertEquals(100, $record->oneint); // Just check column defaults have been applied.
         $this->assertEquals(200, $record->onenum);
         $this->assertSame('onestring', $record->onechar);
         $this->assertNull($record->onetext);
         $this->assertNull($record->onebinary);
 
-        // without returning id, bulk not implemented
-        $result = $this->assertSame(true, $DB->insert_record($tablename, array('course' => 99), false, true));
+        // Without returning id, bulk not implemented.
+        $result = $this->assertTrue($DB->insert_record($tablename, array('course' => 99), false, true));
         $record = $DB->get_record($tablename, array('course' => 99));
         $this->assertEquals(2, $record->id);
         $this->assertEquals(99, $record->course);
 
-        // Check nulls are set properly for all types
+        // Check nulls are set properly for all types.
         $record = new stdClass();
         $record->oneint = null;
         $record->onenum = null;
@@ -2042,7 +2032,7 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertNull($record->onetext);
         $this->assertNull($record->onebinary);
 
-        // Check zeros are set properly for all types
+        // Check zeros are set properly for all types.
         $record = new stdClass();
         $record->oneint = 0;
         $record->onenum = 0;
@@ -2051,9 +2041,9 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertEquals(0, $record->oneint);
         $this->assertEquals(0, $record->onenum);
 
-        // Check booleans are set properly for all types
+        // Check booleans are set properly for all types.
         $record = new stdClass();
-        $record->oneint = true; // trues
+        $record->oneint = true; // Trues.
         $record->onenum = true;
         $record->onechar = true;
         $record->onetext = true;
@@ -2065,7 +2055,7 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertEquals(1, $record->onetext);
 
         $record = new stdClass();
-        $record->oneint = false; // falses
+        $record->oneint = false; // Falses.
         $record->onenum = false;
         $record->onechar = false;
         $record->onetext = false;
@@ -2076,15 +2066,15 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertEquals(0, $record->onechar);
         $this->assertEquals(0, $record->onetext);
 
-        // Check string data causes exception in numeric types
+        // Check string data causes exception in numeric types.
         $record = new stdClass();
         $record->oneint = 'onestring';
         $record->onenum = 0;
         try {
             $DB->insert_record($tablename, $record);
             $this->fail("Expecting an exception, none occurred");
-        } catch (exception $e) {
-            $this->assertTrue($e instanceof dml_exception);
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('dml_exception', $e);
         }
         $record = new stdClass();
         $record->oneint = 0;
@@ -2092,13 +2082,13 @@ class core_dml_testcase extends database_driver_testcase {
         try {
             $DB->insert_record($tablename, $record);
             $this->fail("Expecting an exception, none occurred");
-        } catch (exception $e) {
-            $this->assertTrue($e instanceof dml_exception);
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('dml_exception', $e);
         }
 
-        // Check empty string data is stored as 0 in numeric datatypes
+        // Check empty string data is stored as 0 in numeric datatypes.
         $record = new stdClass();
-        $record->oneint = ''; // empty string
+        $record->oneint = ''; // Empty string.
         $record->onenum = 0;
         $recid = $DB->insert_record($tablename, $record);
         $record = $DB->get_record($tablename, array('id' => $recid));
@@ -2106,12 +2096,12 @@ class core_dml_testcase extends database_driver_testcase {
 
         $record = new stdClass();
         $record->oneint = 0;
-        $record->onenum = ''; // empty string
+        $record->onenum = ''; // Empty string.
         $recid = $DB->insert_record($tablename, $record);
         $record = $DB->get_record($tablename, array('id' => $recid));
         $this->assertTrue(is_numeric($record->onenum) && $record->onenum == 0);
 
-        // Check empty strings are set properly in string types
+        // Check empty strings are set properly in string types.
         $record = new stdClass();
         $record->oneint = 0;
         $record->onenum = 0;
@@ -2122,7 +2112,7 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertTrue($record->onechar === '');
         $this->assertTrue($record->onetext === '');
 
-        // Check operation ((210.10 + 39.92) - 150.02) against numeric types
+        // Check operation ((210.10 + 39.92) - 150.02) against numeric types.
         $record = new stdClass();
         $record->oneint = ((210.10 + 39.92) - 150.02);
         $record->onenum = ((210.10 + 39.92) - 150.02);
@@ -2131,7 +2121,7 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertEquals(100, $record->oneint);
         $this->assertEquals(100, $record->onenum);
 
-        // Check various quotes/backslashes combinations in string types
+        // Check various quotes/backslashes combinations in string types.
         $teststrings = array(
             'backslashes and quotes alone (even): "" \'\' \\\\',
             'backslashes and quotes alone (odd): """ \'\'\' \\\\\\',
@@ -2147,7 +2137,7 @@ class core_dml_testcase extends database_driver_testcase {
             $this->assertEquals($teststring, $record->onetext);
         }
 
-        // Check LOBs in text/binary columns
+        // Check LOBs in text/binary columns.
         $clob = file_get_contents(__DIR__ . '/fixtures/clob.txt');
         $blob = file_get_contents(__DIR__ . '/fixtures/randombinary');
         $record = new stdClass();
@@ -2160,7 +2150,7 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertEquals($clob, $record->onetext, 'Test CLOB insert (full contents output disabled)');
         $this->assertEquals($blob, $record->onebinary, 'Test BLOB insert (full contents output disabled)');
 
-        // And "small" LOBs too, just in case
+        // And "small" LOBs too, just in case.
         $newclob = substr($clob, 0, 500);
         $newblob = substr($blob, 0, 250);
         $record = new stdClass();
@@ -2172,9 +2162,9 @@ class core_dml_testcase extends database_driver_testcase {
         $rs->close();
         $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(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.
 
-        // And "diagnostic" LOBs too, just in case
+        // And "diagnostic" LOBs too, just in case.
         $newclob = '\'"\\;/ěščřžýáíé';
         $newblob = '\'"\\;/ěščřžýáíé';
         $record = new stdClass();
@@ -2186,18 +2176,18 @@ class core_dml_testcase extends database_driver_testcase {
         $rs->close();
         $this->assertSame($newclob, $record->onetext);
         $this->assertSame($newblob, $record->onebinary);
-        $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.
 
-        // test data is not modified
+        // Test data is not modified.
         $record = new stdClass();
-        $record->id     = -1; // has to be ignored
+        $record->id     = -1; // Has to be ignored.
         $record->course = 3;
-        $record->lalala = 'lalal'; // unused
+        $record->lalala = 'lalal'; // Unused.
         $before = clone($record);
         $DB->insert_record($tablename, $record);
         $this->assertEquals($record, $before);
 
-        // make sure the id is always increasing and never reuses the same id
+        // Make sure the id is always increasing and never reuses the same id.
         $id1 = $DB->insert_record($tablename, array('course' => 3));
         $id2 = $DB->insert_record($tablename, array('course' => 3));
         $this->assertTrue($id1 < $id2);
@@ -2246,22 +2236,22 @@ class core_dml_testcase extends database_driver_testcase {
 
         // Let's insert one record violating the constraint multiple times.
         $record = (object)array('course' => 1, 'oneint' => 1);
-        $this->assertTrue($DB->insert_record($tablename, $record, false)); // insert 1st. No problem expected.
+        $this->assertTrue($DB->insert_record($tablename, $record, false)); // Insert 1st. No problem expected.
 
         // Re-insert same record, not returning id. dml_exception expected.
         try {
             $DB->insert_record($tablename, $record, false);
             $this->fail("Expecting an exception, none occurred");
-        } catch (exception $e) {
-            $this->assertTrue($e instanceof dml_exception);
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('dml_exception', $e);
         }
 
         // Re-insert same record, returning id. dml_exception expected.
         try {
             $DB->insert_record($tablename, $record, true);
             $this->fail("Expecting an exception, none occurred");
-        } catch (exception $e) {
-            $this->assertTrue($e instanceof dml_exception);
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('dml_exception', $e);
         }
     }
 
@@ -2275,9 +2265,9 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
-        $table->add_field('oneint', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, null, null, 100);
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
+        $table->add_field('oneint', XMLDB_TYPE_INTEGER, '10', null, null, null, 100);
         $table->add_field('onenum', XMLDB_TYPE_NUMBER, '10,2', null, null, null, 200);
         $table->add_field('onechar', XMLDB_TYPE_CHAR, '100', null, null, null, 'onestring');
         $table->add_field('onetext', XMLDB_TYPE_TEXT, 'big', null, null, null);
@@ -2288,21 +2278,21 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertSame(1, $DB->insert_record($tablename, array('course' => 1), true));
         $record = $DB->get_record($tablename, array('course' => 1));
         $this->assertEquals(1, $record->id);
-        $this->assertEquals(100, $record->oneint); // Just check column defaults have been applied
+        $this->assertEquals(100, $record->oneint); // Just check column defaults have been applied.
         $this->assertEquals(200, $record->onenum);
         $this->assertSame('onestring', $record->onechar);
         $this->assertNull($record->onetext);
         $this->assertNull($record->onebinary);
 
-        // ignore extra columns
+        // Ignore extra columns.
         $record = (object)array('id'=>13, 'course'=>2, 'xxxx'=>788778);
         $before = clone($record);
-        $this->assertSame(true, $DB->import_record($tablename, $record));
+        $this->assertTrue($DB->import_record($tablename, $record));
         $this->assertEquals($record, $before);
         $records = $DB->get_records($tablename);
         $this->assertEquals(2, $records[13]->course);
 
-        // Check nulls are set properly for all types
+        // Check nulls are set properly for all types.
         $record = new stdClass();
         $record->id = 20;
         $record->oneint = null;
@@ -2319,7 +2309,7 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertNull($record->onetext);
         $this->assertNull($record->onebinary);
 
-        // Check zeros are set properly for all types
+        // Check zeros are set properly for all types.
         $record = new stdClass();
         $record->id = 23;
         $record->oneint = 0;
@@ -2329,7 +2319,7 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertEquals(0, $record->oneint);
         $this->assertEquals(0, $record->onenum);
 
-        // Check string data causes exception in numeric types
+        // Check string data causes exception in numeric types.
         $record = new stdClass();
         $record->id = 32;
         $record->oneint = 'onestring';
@@ -2337,8 +2327,8 @@ class core_dml_testcase extends database_driver_testcase {
         try {
             $DB->import_record($tablename, $record);
             $this->fail("Expecting an exception, none occurred");
-        } catch (exception $e) {
-            $this->assertTrue($e instanceof dml_exception);
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('dml_exception', $e);
         }
         $record = new stdClass();
         $record->id = 35;
@@ -2347,11 +2337,11 @@ class core_dml_testcase extends database_driver_testcase {
         try {
             $DB->import_record($tablename, $record);
             $this->fail("Expecting an exception, none occurred");
-        } catch (exception $e) {
-            $this->assertTrue($e instanceof dml_exception);
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('dml_exception', $e);
         }
 
-        // Check empty strings are set properly in string types
+        // Check empty strings are set properly in string types.
         $record = new stdClass();
         $record->id = 44;
         $record->oneint = 0;
@@ -2363,7 +2353,7 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertTrue($record->onechar === '');
         $this->assertTrue($record->onetext === '');
 
-        // Check operation ((210.10 + 39.92) - 150.02) against numeric types
+        // Check operation ((210.10 + 39.92) - 150.02) against numeric types.
         $record = new stdClass();
         $record->id = 47;
         $record->oneint = ((210.10 + 39.92) - 150.02);
@@ -2373,7 +2363,7 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertEquals(100, $record->oneint);
         $this->assertEquals(100, $record->onenum);
 
-        // Check various quotes/backslashes combinations in string types
+        // Check various quotes/backslashes combinations in string types.
         $i = 50;
         $teststrings = array(
             'backslashes and quotes alone (even): "" \'\' \\\\',
@@ -2392,7 +2382,7 @@ class core_dml_testcase extends database_driver_testcase {
             $i = $i + 3;
         }
 
-        // Check LOBs in text/binary columns
+        // Check LOBs in text/binary columns.
         $clob = file_get_contents(__DIR__ . '/fixtures/clob.txt');
         $record = new stdClass();
         $record->id = 70;
@@ -2415,7 +2405,7 @@ class core_dml_testcase extends database_driver_testcase {
         $rs->close();
         $this->assertEquals($blob, $record->onebinary, 'Test BLOB insert (full contents output disabled)');
 
-        // And "small" LOBs too, just in case
+        // And "small" LOBs too, just in case.
         $newclob = substr($clob, 0, 500);
         $newblob = substr($blob, 0, 250);
         $record = new stdClass();
@@ -2428,7 +2418,7 @@ class core_dml_testcase extends database_driver_testcase {
         $rs->close();
         $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(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() {
@@ -2438,8 +2428,8 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
@@ -2458,8 +2448,8 @@ class core_dml_testcase extends database_driver_testcase {
         try {
             $DB->update_record_raw($tablename, $record);
             $this->fail("Expecting an exception, none occurred");
-        } catch (Exception $e) {
-            $this->assertTrue($e instanceof moodle_exception);
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('moodle_exception', $e);
         }
 
         $record = $DB->get_record($tablename, array('course' => 3));
@@ -2467,8 +2457,8 @@ class core_dml_testcase extends database_driver_testcase {
         try {
             $DB->update_record_raw($tablename, $record);
             $this->fail("Expecting an exception, none occurred");
-        } catch (Exception $e) {
-            $this->assertTrue($e instanceof coding_exception);
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('coding_exception', $e);
         }
     }
 
@@ -2483,9 +2473,9 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
-        $table->add_field('oneint', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, null, null, 100);
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
+        $table->add_field('oneint', XMLDB_TYPE_INTEGER, '10', null, null, null, 100);
         $table->add_field('onenum', XMLDB_TYPE_NUMBER, '10,2', null, null, null, 200);
         $table->add_field('onechar', XMLDB_TYPE_CHAR, '100', null, null, null, 'onestring');
         $table->add_field('onetext', XMLDB_TYPE_TEXT, 'big', null, null, null);
@@ -2500,13 +2490,13 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertTrue($DB->update_record($tablename, $record));
         $this->assertFalse($record = $DB->get_record($tablename, array('course' => 1)));
         $this->assertNotEmpty($record = $DB->get_record($tablename, array('course' => 2)));
-        $this->assertEquals(100, $record->oneint); // Just check column defaults have been applied
+        $this->assertEquals(100, $record->oneint); // Just check column defaults have been applied.
         $this->assertEquals(200, $record->onenum);
-        $this->assertEquals('onestring', $record->onechar);
+        $this->assertSame('onestring', $record->onechar);
         $this->assertNull($record->onetext);
         $this->assertNull($record->onebinary);
 
-        // Check nulls are set properly for all types
+        // Check nulls are set properly for all types.
         $record->oneint = null;
         $record->onenum = null;
         $record->onechar = null;
@@ -2520,7 +2510,7 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertNull($record->onetext);
         $this->assertNull($record->onebinary);
 
-        // Check zeros are set properly for all types
+        // Check zeros are set properly for all types.
         $record->oneint = 0;
         $record->onenum = 0;
         $DB->update_record($tablename, $record);
@@ -2528,8 +2518,8 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertEquals(0, $record->oneint);
         $this->assertEquals(0, $record->onenum);
 
-        // Check booleans are set properly for all types
-        $record->oneint = true; // trues
+        // Check booleans are set properly for all types.
+        $record->oneint = true; // Trues.
         $record->onenum = true;
         $record->onechar = true;
         $record->onetext = true;
@@ -2540,7 +2530,7 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertEquals(1, $record->onechar);
         $this->assertEquals(1, $record->onetext);
 
-        $record->oneint = false; // falses
+        $record->oneint = false; // Falses.
         $record->onenum = false;
         $record->onechar = false;
         $record->onetext = false;
@@ -2551,38 +2541,38 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertEquals(0, $record->onechar);
         $this->assertEquals(0, $record->onetext);
 
-        // Check string data causes exception in numeric types
+        // Check string data causes exception in numeric types.
         $record->oneint = 'onestring';
         $record->onenum = 0;
         try {
             $DB->update_record($tablename, $record);
             $this->fail("Expecting an exception, none occurred");
-        } catch (exception $e) {
-            $this->assertTrue($e instanceof dml_exception);
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('dml_exception', $e);
         }
         $record->oneint = 0;
         $record->onenum = 'onestring';
         try {
             $DB->update_record($tablename, $record);
             $this->fail("Expecting an exception, none occurred");
-        } catch (exception $e) {
-            $this->assertTrue($e instanceof dml_exception);
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('dml_exception', $e);
         }
 
-        // Check empty string data is stored as 0 in numeric datatypes
-        $record->oneint = ''; // empty string
+        // Check empty string data is stored as 0 in numeric datatypes.
+        $record->oneint = ''; // Empty string.
         $record->onenum = 0;
         $DB->update_record($tablename, $record);
         $record = $DB->get_record($tablename, array('course' => 2));
         $this->assertTrue(is_numeric($record->oneint) && $record->oneint == 0);
 
         $record->oneint = 0;
-        $record->onenum = ''; // empty string
+        $record->onenum = ''; // Empty string.
         $DB->update_record($tablename, $record);
         $record = $DB->get_record($tablename, array('course' => 2));
         $this->assertTrue(is_numeric($record->onenum) && $record->onenum == 0);
 
-        // Check empty strings are set properly in string types
+        // Check empty strings are set properly in string types.
         $record->oneint = 0;
         $record->onenum = 0;
         $record->onechar = '';
@@ -2592,7 +2582,7 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertTrue($record->onechar === '');
         $this->assertTrue($record->onetext === '');
 
-        // Check operation ((210.10 + 39.92) - 150.02) against numeric types
+        // Check operation ((210.10 + 39.92) - 150.02) against numeric types.
         $record->oneint = ((210.10 + 39.92) - 150.02);
         $record->onenum = ((210.10 + 39.92) - 150.02);
         $DB->update_record($tablename, $record);
@@ -2600,7 +2590,7 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertEquals(100, $record->oneint);
         $this->assertEquals(100, $record->onenum);
 
-        // Check various quotes/backslashes combinations in string types
+        // Check various quotes/backslashes combinations in string types.
         $teststrings = array(
             'backslashes and quotes alone (even): "" \'\' \\\\',
             'backslashes and quotes alone (odd): """ \'\'\' \\\\\\',
@@ -2615,7 +2605,7 @@ class core_dml_testcase extends database_driver_testcase {
             $this->assertEquals($teststring, $record->onetext);
         }
 
-        // Check LOBs in text/binary columns
+        // Check LOBs in text/binary columns.
         $clob = file_get_contents(__DIR__ . '/fixtures/clob.txt');
         $blob = file_get_contents(__DIR__ . '/fixtures/randombinary');
         $record->onetext = $clob;
@@ -2625,7 +2615,7 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertEquals($clob, $record->onetext, 'Test CLOB update (full contents output disabled)');
         $this->assertEquals($blob, $record->onebinary, 'Test BLOB update (full contents output disabled)');
 
-        // And "small" LOBs too, just in case
+        // And "small" LOBs too, just in case.
         $newclob = substr($clob, 0, 500);
         $newblob = substr($blob, 0, 250);
         $record->onetext = $newclob;
@@ -2673,14 +2663,14 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_field('onechar', XMLDB_TYPE_CHAR, '100', null, null, null);
         $table->add_field('onetext', XMLDB_TYPE_TEXT, 'big', null, null, null);
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
-        // simple set_field
+        // Simple set_field.
         $id1 = $DB->insert_record($tablename, array('course' => 1));
         $id2 = $DB->insert_record($tablename, array('course' => 1));
         $id3 = $DB->insert_record($tablename, array('course' => 3));
@@ -2690,7 +2680,7 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertEquals(3, $DB->get_field($tablename, 'course', array('id' => $id3)));
         $DB->delete_records($tablename, array());
 
-        // multiple fields affected
+        // Multiple fields affected.
         $id1 = $DB->insert_record($tablename, array('course' => 1));
         $id2 = $DB->insert_record($tablename, array('course' => 1));
         $id3 = $DB->insert_record($tablename, array('course' => 3));
@@ -2700,7 +2690,7 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertEquals(3, $DB->get_field($tablename, 'course', array('id' => $id3)));
         $DB->delete_records($tablename, array());
 
-        // no field affected
+        // No field affected.
         $id1 = $DB->insert_record($tablename, array('course' => 1));
         $id2 = $DB->insert_record($tablename, array('course' => 1));
         $id3 = $DB->insert_record($tablename, array('course' => 3));
@@ -2710,7 +2700,7 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertEquals(3, $DB->get_field($tablename, 'course', array('id' => $id3)));
         $DB->delete_records($tablename, array());
 
-        // all fields - no condition
+        // All fields - no condition.
         $id1 = $DB->insert_record($tablename, array('course' => 1));
         $id2 = $DB->insert_record($tablename, array('course' => 1));
         $id3 = $DB->insert_record($tablename, array('course' => 3));
@@ -2719,17 +2709,17 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertEquals(5, $DB->get_field($tablename, 'course', array('id' => $id2)));
         $this->assertEquals(5, $DB->get_field($tablename, 'course', array('id' => $id3)));
 
-        // test for exception throwing on text conditions being compared. (MDL-24863, unwanted auto conversion of param to int)
+        // Test for exception throwing on text conditions being compared. (MDL-24863, unwanted auto conversion of param to int).
         $conditions = array('onetext' => '1');
         try {
             $DB->set_field($tablename, 'onechar', 'frog', $conditions);
             if (debugging()) {
-                // only in debug mode - hopefully all devs test code in debug mode...
+                // Only in debug mode - hopefully all devs test code in debug mode...
                 $this->fail('An Exception is missing, expected due to equating of text fields');
             }
-        } catch (exception $e) {
-            $this->assertTrue($e instanceof dml_exception);
-            $this->assertEquals($e->errorcode, 'textconditionsnotallowed');
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('dml_exception', $e);
+            $this->assertSame('textconditionsnotallowed', $e->errorcode);
         }
 
         // Test saving a float in a CHAR column, and reading it back.
@@ -2763,7 +2753,7 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertEquals(1e300, $DB->get_field($tablename, 'onetext', array('id' => $id)));
 
         // 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() {
@@ -2777,9 +2767,9 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
-        $table->add_field('oneint', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, null, null);
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
+        $table->add_field('oneint', XMLDB_TYPE_INTEGER, '10', null, null, null);
         $table->add_field('onenum', XMLDB_TYPE_NUMBER, '10,2', null, null, null);
         $table->add_field('onechar', XMLDB_TYPE_CHAR, '100', null, null, null);
         $table->add_field('onetext', XMLDB_TYPE_TEXT, 'big', null, null, null);
@@ -2792,8 +2782,8 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertTrue($DB->set_field_select($tablename, 'course', 2, 'id = ?', array(1)));
         $this->assertEquals(2, $DB->get_field($tablename, 'course', array('id' => 1)));
 
-        // Check nulls are set properly for all types
-        $DB->set_field_select($tablename, 'oneint', null, 'id = ?', array(1)); // trues
+        // Check nulls are set properly for all types.
+        $DB->set_field_select($tablename, 'oneint', null, 'id = ?', array(1)); // Trues.
         $DB->set_field_select($tablename, 'onenum', null, 'id = ?', array(1));
         $DB->set_field_select($tablename, 'onechar', null, 'id = ?', array(1));
         $DB->set_field_select($tablename, 'onetext', null, 'id = ?', array(1));
@@ -2804,14 +2794,14 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertNull($DB->get_field($tablename, 'onetext', array('id' => 1)));
         $this->assertNull($DB->get_field($tablename, 'onebinary', array('id' => 1)));
 
-        // Check zeros are set properly for all types
+        // Check zeros are set properly for all types.
         $DB->set_field_select($tablename, 'oneint', 0, 'id = ?', array(1));
         $DB->set_field_select($tablename, 'onenum', 0, 'id = ?', array(1));
         $this->assertEquals(0, $DB->get_field($tablename, 'oneint', array('id' => 1)));
         $this->assertEquals(0, $DB->get_field($tablename, 'onenum', array('id' => 1)));
 
-        // Check booleans are set properly for all types
-        $DB->set_field_select($tablename, 'oneint', true, 'id = ?', array(1)); // trues
+        // Check booleans are set properly for all types.
+        $DB->set_field_select($tablename, 'oneint', true, 'id = ?', array(1)); // Trues.
         $DB->set_field_select($tablename, 'onenum', true, 'id = ?', array(1));
         $DB->set_field_select($tablename, 'onechar', true, 'id = ?', array(1));
         $DB->set_field_select($tablename, 'onetext', true, 'id = ?', array(1));
@@ -2820,7 +2810,7 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertEquals(1, $DB->get_field($tablename, 'onechar', array('id' => 1)));
         $this->assertEquals(1, $DB->get_field($tablename, 'onetext', array('id' => 1)));
 
-        $DB->set_field_select($tablename, 'oneint', false, 'id = ?', array(1)); // falses
+        $DB->set_field_select($tablename, 'oneint', false, 'id = ?', array(1)); // Falses.
         $DB->set_field_select($tablename, 'onenum', false, 'id = ?', array(1));
         $DB->set_field_select($tablename, 'onechar', false, 'id = ?', array(1));
         $DB->set_field_select($tablename, 'onetext', false, 'id = ?', array(1));
@@ -2829,21 +2819,21 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertEquals(0, $DB->get_field($tablename, 'onechar', array('id' => 1)));
         $this->assertEquals(0, $DB->get_field($tablename, 'onetext', array('id' => 1)));
 
-        // Check string data causes exception in numeric types
+        // Check string data causes exception in numeric types.
         try {
             $DB->set_field_select($tablename, 'oneint', 'onestring', 'id = ?', array(1));
             $this->fail("Expecting an exception, none occurred");
-        } catch (exception $e) {
-            $this->assertTrue($e instanceof dml_exception);
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('dml_exception', $e);
         }
         try {
             $DB->set_field_select($tablename, 'onenum', 'onestring', 'id = ?', array(1));
             $this->fail("Expecting an exception, none occurred");
-        } catch (exception $e) {
-            $this->assertTrue($e instanceof dml_exception);
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('dml_exception', $e);
         }
 
-        // Check empty string data is stored as 0 in numeric datatypes
+        // Check empty string data is stored as 0 in numeric datatypes.
         $DB->set_field_select($tablename, 'oneint', '', 'id = ?', array(1));
         $field = $DB->get_field($tablename, 'oneint', array('id' => 1));
         $this->assertTrue(is_numeric($field) && $field == 0);
@@ -2852,19 +2842,19 @@ class core_dml_testcase extends database_driver_testcase {
         $field = $DB->get_field($tablename, 'onenum', array('id' => 1));
         $this->assertTrue(is_numeric($field) && $field == 0);
 
-        // Check empty strings are set properly in string types
+        // Check empty strings are set properly in string types.
         $DB->set_field_select($tablename, 'onechar', '', 'id = ?', array(1));
         $DB->set_field_select($tablename, 'onetext', '', 'id = ?', array(1));
         $this->assertTrue($DB->get_field($tablename, 'onechar', array('id' => 1)) === '');
         $this->assertTrue($DB->get_field($tablename, 'onetext', array('id' => 1)) === '');
 
-        // Check operation ((210.10 + 39.92) - 150.02) against numeric types
+        // Check operation ((210.10 + 39.92) - 150.02) against numeric types.
         $DB->set_field_select($tablename, 'oneint', ((210.10 + 39.92) - 150.02), 'id = ?', array(1));
         $DB->set_field_select($tablename, 'onenum', ((210.10 + 39.92) - 150.02), 'id = ?', array(1));
         $this->assertEquals(100, $DB->get_field($tablename, 'oneint', array('id' => 1)));
         $this->assertEquals(100, $DB->get_field($tablename, 'onenum', array('id' => 1)));
 
-        // Check various quotes/backslashes combinations in string types
+        // Check various quotes/backslashes combinations in string types.
         $teststrings = array(
             'backslashes and quotes alone (even): "" \'\' \\\\',
             'backslashes and quotes alone (odd): """ \'\'\' \\\\\\',
@@ -2877,7 +2867,7 @@ class core_dml_testcase extends database_driver_testcase {
             $this->assertEquals($teststring, $DB->get_field($tablename, 'onetext', array('id' => 1)));
         }
 
-        // Check LOBs in text/binary columns
+        // Check LOBs in text/binary columns.
         $clob = file_get_contents(__DIR__ . '/fixtures/clob.txt');
         $blob = file_get_contents(__DIR__ . '/fixtures/randombinary');
         $DB->set_field_select($tablename, 'onetext', $clob, 'id = ?', array(1));
@@ -2885,7 +2875,7 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertEquals($clob, $DB->get_field($tablename, 'onetext', array('id' => 1)), 'Test CLOB set_field (full contents output disabled)');
         $this->assertEquals($blob, $DB->get_field($tablename, 'onebinary', array('id' => 1)), 'Test BLOB set_field (full contents output disabled)');
 
-        // And "small" LOBs too, just in case
+        // And "small" LOBs too, just in case.
         $newclob = substr($clob, 0, 500);
         $newblob = substr($blob, 0, 250);
         $DB->set_field_select($tablename, 'onetext', $newclob, 'id = ?', array(1));
@@ -2897,7 +2887,7 @@ class core_dml_testcase extends database_driver_testcase {
         // which converts the '1' to an integer, which cannot then be compared with
         // onetext cast to a varchar. This should be fixed and working now.
         $newchar = 'frog';
-        // test for exception throwing on text conditions being compared. (MDL-24863, unwanted auto conversion of param to int)
+        // Test for exception throwing on text conditions being compared. (MDL-24863, unwanted auto conversion of param to int).
         $params = array('onetext' => '1');
         try {
             $DB->set_field_select($tablename, 'onechar', $newchar, $DB->sql_compare_text('onetext') . ' = ?', $params);
@@ -2906,8 +2896,6 @@ class core_dml_testcase extends database_driver_testcase {
             $this->assertFalse(true, 'We have an unexpected exception.');
             throw $e;
         }
-
-
     }
 
     public function test_count_records() {
@@ -2918,8 +2906,8 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_field('onetext', XMLDB_TYPE_TEXT, 'big', null, null, null);
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
@@ -2932,17 +2920,17 @@ class core_dml_testcase extends database_driver_testcase {
 
         $this->assertSame(3, $DB->count_records($tablename));
 
-        // test for exception throwing on text conditions being compared. (MDL-24863, unwanted auto conversion of param to int)
+        // Test for exception throwing on text conditions being compared. (MDL-24863, unwanted auto conversion of param to int).
         $conditions = array('onetext' => '1');
         try {
             $DB->count_records($tablename, $conditions);
             if (debugging()) {
-                // only in debug mode - hopefully all devs test code in debug mode...
+                // Only in debug mode - hopefully all devs test code in debug mode...
                 $this->fail('An Exception is missing, expected due to equating of text fields');
             }
-        } catch (exception $e) {
-            $this->assertTrue($e instanceof dml_exception);
-            $this->assertEquals($e->errorcode, 'textconditionsnotallowed');
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('dml_exception', $e);
+            $this->assertSame('textconditionsnotallowed', $e->errorcode);
         }
     }
 
@@ -2954,8 +2942,8 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
@@ -2975,8 +2963,8 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_field('onechar', XMLDB_TYPE_CHAR, '100', null, null, null);
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
@@ -2989,18 +2977,18 @@ class core_dml_testcase extends database_driver_testcase {
 
         $this->assertSame(2, $DB->count_records_sql("SELECT COUNT(*) FROM {{$tablename}} WHERE course > ?", array(3)));
 
-        // test invalid use
+        // Test invalid use.
         try {
             $DB->count_records_sql("SELECT onechar FROM {{$tablename}} WHERE course = ?", array(3));
             $this->fail('Exception expected when non-number field used in count_records_sql');
-        } catch (exception $e) {
+        } catch (moodle_exception $e) {
             $this->assertInstanceOf('coding_exception', $e);
         }
 
         try {
             $DB->count_records_sql("SELECT course FROM {{$tablename}} WHERE 1 = 2");
             $this->fail('Exception expected when non-number field used in count_records_sql');
-        } catch (exception $e) {
+        } catch (moodle_exception $e) {
             $this->assertInstanceOf('coding_exception', $e);
         }
     }
@@ -3012,8 +3000,8 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_field('onetext', XMLDB_TYPE_TEXT, 'big', null, null, null);
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
@@ -3025,18 +3013,17 @@ class core_dml_testcase extends database_driver_testcase {
 
         $this->assertTrue($DB->record_exists($tablename, array('course' => 3)));
 
-
-        // test for exception throwing on text conditions being compared. (MDL-24863, unwanted auto conversion of param to int)
+        // Test for exception throwing on text conditions being compared. (MDL-24863, unwanted auto conversion of param to int).
         $conditions = array('onetext' => '1');
         try {
             $DB->record_exists($tablename, $conditions);
             if (debugging()) {
-                // only in debug mode - hopefully all devs test code in debug mode...
+                // Only in debug mode - hopefully all devs test code in debug mode...
                 $this->fail('An Exception is missing, expected due to equating of text fields');
             }
-        } catch (exception $e) {
-            $this->assertTrue($e instanceof dml_exception);
-            $this->assertEquals($e->errorcode, 'textconditionsnotallowed');
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('dml_exception', $e);
+            $this->assertSame('textconditionsnotallowed', $e->errorcode);
         }
     }
 
@@ -3047,8 +3034,8 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
@@ -3067,8 +3054,8 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
@@ -3084,12 +3071,12 @@ class core_dml_testcase extends database_driver_testcase {
         $DB = $this->tdb;
         $dbman = $DB->get_manager();
 
-        //Setup
+        // Setup.
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
@@ -3100,8 +3087,8 @@ class core_dml_testcase extends database_driver_testcase {
         $DB->insert_record($tablename, array('course' => 5));
         $DB->insert_record($tablename, array('course' => 6));
 
-        // Test against db write locking while on an open recordset
-        $rs = $DB->get_recordset($tablename, array(), null, 'course', 2, 2); // get courses = {3,4}
+        // Test against db write locking while on an open recordset.
+        $rs = $DB->get_recordset($tablename, array(), null, 'course', 2, 2); // Get courses = {3,4}.
         foreach ($rs as $record) {
             $cid = $record->course;
             $DB->delete_records($tablename, array('course' => $cid));
@@ -3116,12 +3103,12 @@ class core_dml_testcase extends database_driver_testcase {
         $DB = $this->tdb;
         $dbman = $DB->get_manager();
 
-        //Setup
+        // Setup.
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
@@ -3132,8 +3119,8 @@ class core_dml_testcase extends database_driver_testcase {
         $DB->insert_record($tablename, array('course' => 5));
         $DB->insert_record($tablename, array('course' => 6));
 
-        // Test against db write locking while on an open recordset
-        $rs = $DB->get_recordset($tablename, array(), null, 'course', 2, 2); // get courses = {3,4}
+        // Test against db write locking while on an open recordset.
+        $rs = $DB->get_recordset($tablename, array(), null, 'course', 2, 2); // Get courses = {3,4}.
         foreach ($rs as $record) {
             $cid = $record->course;
             $DB->set_field($tablename, 'course', 10, array('course' => $cid));
@@ -3151,8 +3138,8 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_field('onetext', XMLDB_TYPE_TEXT, 'big', null, null, null);
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
@@ -3161,11 +3148,11 @@ class core_dml_testcase extends database_driver_testcase {
         $DB->insert_record($tablename, array('course' => 2));
         $DB->insert_record($tablename, array('course' => 2));
 
-        // Delete all records
+        // Delete all records.
         $this->assertTrue($DB->delete_records($tablename));
         $this->assertEquals(0, $DB->count_records($tablename));
 
-        // Delete subset of records
+        // Delete subset of records.
         $DB->insert_record($tablename, array('course' => 3));
         $DB->insert_record($tablename, array('course' => 2));
         $DB->insert_record($tablename, array('course' => 2));
@@ -3173,34 +3160,34 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertTrue($DB->delete_records($tablename, array('course' => 2)));
         $this->assertEquals(1, $DB->count_records($tablename));
 
-        // delete all
+        // Delete all.
         $this->assertTrue($DB->delete_records($tablename, array()));
         $this->assertEquals(0, $DB->count_records($tablename));
 
-        // test for exception throwing on text conditions being compared. (MDL-24863, unwanted auto conversion of param to int)
+        // Test for exception throwing on text conditions being compared. (MDL-24863, unwanted auto conversion of param to int).
         $conditions = array('onetext'=>'1');
         try {
             $DB->delete_records($tablename, $conditions);
             if (debugging()) {
-                // only in debug mode - hopefully all devs test code in debug mode...
+                // Only in debug mode - hopefully all devs test code in debug mode...
                 $this->fail('An Exception is missing, expected due to equating of text fields');
             }
-        } catch (exception $e) {
-            $this->assertTrue($e instanceof dml_exception);
-            $this->assertEquals($e->errorcode, 'textconditionsnotallowed');
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('dml_exception', $e);
+            $this->assertSame('textconditionsnotallowed', $e->errorcode);
         }
 
-        // test for exception throwing on text conditions being compared. (MDL-24863, unwanted auto conversion of param to int)
+        // Test for exception throwing on text conditions being compared. (MDL-24863, unwanted auto conversion of param to int).
         $conditions = array('onetext' => 1);
         try {
             $DB->delete_records($tablename, $conditions);
             if (debugging()) {
-                // only in debug mode - hopefully all devs test code in debug mode...
+                // Only in debug mode - hopefully all devs test code in debug mode...
                 $this->fail('An Exception is missing, expected due to equating of text fields');
             }
-        } catch (exception $e) {
-            $this->assertTrue($e instanceof dml_exception);
-            $this->assertEquals($e->errorcode, 'textconditionsnotallowed');
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('dml_exception', $e);
+            $this->assertSame('textconditionsnotallowed', $e->errorcode);
         }
     }
 
@@ -3211,8 +3198,8 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
@@ -3231,8 +3218,8 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
@@ -3243,7 +3230,7 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertTrue($DB->delete_records_list($tablename, 'course', array(2, 3)));
         $this->assertEquals(1, $DB->count_records($tablename));
 
-        $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));
     }
 
@@ -3253,47 +3240,47 @@ class core_dml_testcase extends database_driver_testcase {
 
         $table = $this->get_test_table();
         $tablename = $table->getName();
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
-        $o = new stdClass(); // objects without __toString - never worked
+        $o = new stdClass(); // Objects without __toString - never worked.
         try {
             $DB->fix_sql_params("SELECT {{$tablename}} WHERE course = ? ", array($o));
             $this->fail('coding_exception expected');
-        } catch (Exception $e) {
-            $this->assertTrue($e instanceof coding_exception);
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('coding_exception', $e);
         }
 
-        // objects with __toString() forbidden everywhere since 2.3
+        // Objects with __toString() forbidden everywhere since 2.3.
         $o = new dml_test_object_one();
         try {
             $DB->fix_sql_params("SELECT {{$tablename}} WHERE course = ? ", array($o));
             $this->fail('coding_exception expected');
-        } catch (Exception $e) {
-            $this->assertTrue($e instanceof coding_exception);
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('coding_exception', $e);
         }
 
         try {
             $DB->execute("SELECT {{$tablename}} WHERE course = ? ", array($o));
             $this->fail('coding_exception expected');
-        } catch (Exception $e) {
-            $this->assertTrue($e instanceof coding_exception);
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('coding_exception', $e);
         }
 
         try {
             $DB->get_recordset_sql("SELECT {{$tablename}} WHERE course = ? ", array($o));
             $this->fail('coding_exception expected');
-        } catch (Exception $e) {
-            $this->assertTrue($e instanceof coding_exception);
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('coding_exception', $e);
         }
 
         try {
             $DB->get_records_sql("SELECT {{$tablename}} WHERE course = ? ", array($o));
             $this->fail('coding_exception expected');
-        } catch (Exception $e) {
-            $this->assertTrue($e instanceof coding_exception);
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('coding_exception', $e);
         }
 
         try {
@@ -3301,8 +3288,8 @@ class core_dml_testcase extends database_driver_testcase {
             $record->course = $o;
             $DB->insert_record_raw($tablename, $record);
             $this->fail('coding_exception expected');
-        } catch (Exception $e) {
-            $this->assertTrue($e instanceof coding_exception);
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('coding_exception', $e);
         }
 
         try {
@@ -3310,8 +3297,8 @@ class core_dml_testcase extends database_driver_testcase {
             $record->course = $o;
             $DB->insert_record($tablename, $record);
             $this->fail('coding_exception expected');
-        } catch (Exception $e) {
-            $this->assertTrue($e instanceof coding_exception);
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('coding_exception', $e);
         }
 
         try {
@@ -3319,8 +3306,8 @@ class core_dml_testcase extends database_driver_testcase {
             $record->course = $o;
             $DB->import_record($tablename, $record);
             $this->fail('coding_exception expected');
-        } catch (Exception $e) {
-            $this->assertTrue($e instanceof coding_exception);
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('coding_exception', $e);
         }
 
         try {
@@ -3329,8 +3316,8 @@ class core_dml_testcase extends database_driver_testcase {
             $record->course = $o;
             $DB->update_record_raw($tablename, $record);
             $this->fail('coding_exception expected');
-        } catch (Exception $e) {
-            $this->assertTrue($e instanceof coding_exception);
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('coding_exception', $e);
         }
 
         try {
@@ -3339,148 +3326,148 @@ class core_dml_testcase extends database_driver_testcase {
             $record->course = $o;
             $DB->update_record($tablename, $record);
             $this->fail('coding_exception expected');
-        } catch (Exception $e) {
-            $this->assertTrue($e instanceof coding_exception);
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('coding_exception', $e);
         }
 
         try {
             $DB->set_field_select($tablename, 'course', 1, "course = ? ", array($o));
             $this->fail('coding_exception expected');
-        } catch (Exception $e) {
-            $this->assertTrue($e instanceof coding_exception);
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('coding_exception', $e);
         }
 
         try {
             $DB->delete_records_select($tablename, "course = ? ", array($o));
             $this->fail('coding_exception expected');
-        } catch (Exception $e) {
-            $this->assertTrue($e instanceof coding_exception);
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('coding_exception', $e);
         }
     }
 
-    function test_sql_null_from_clause() {
+    public function test_sql_null_from_clause() {
         $DB = $this->tdb;
         $sql = "SELECT 1 AS id ".$DB->sql_null_from_clause();
-        $this->assertEquals($DB->get_field_sql($sql), 1);
+        $this->assertEquals(1, $DB->get_field_sql($sql));
     }
 
-    function test_sql_bitand() {
+    public function test_sql_bitand() {
         $DB = $this->tdb;
         $dbman = $DB->get_manager();
 
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('col1', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
-        $table->add_field('col2', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('col1', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
+        $table->add_field('col2', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
         $DB->insert_record($tablename, array('col1' => 3, 'col2' => 10));
 
         $sql = "SELECT ".$DB->sql_bitand(10, 3)." AS res ".$DB->sql_null_from_clause();
-        $this->assertEquals($DB->get_field_sql($sql), 2);
+        $this->assertEquals(2, $DB->get_field_sql($sql));
 
         $sql = "SELECT id, ".$DB->sql_bitand('col1', 'col2')." AS res FROM {{$tablename}}";
         $result = $DB->get_records_sql($sql);
-        $this->assertEquals(count($result), 1);
-        $this->assertEquals(reset($result)->res, 2);
+        $this->assertCount(1, $result);
+        $this->assertEquals(2, reset($result)->res);
 
         $sql = "SELECT id, ".$DB->sql_bitand('col1', '?')." AS res FROM {{$tablename}}";
         $result = $DB->get_records_sql($sql, array(10));
-        $this->assertEquals(count($result), 1);
-        $this->assertEquals(reset($result)->res, 2);
+        $this->assertCount(1, $result);
+        $this->assertEquals(2, reset($result)->res);
     }
 
-    function test_sql_bitnot() {
+    public function test_sql_bitnot() {
         $DB = $this->tdb;
 
         $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!
 
         $sql = "SELECT $notlimited AS res ".$DB->sql_null_from_clause();
-        $this->assertEquals($DB->get_field_sql($sql), 5);
+        $this->assertEquals(5, $DB->get_field_sql($sql));
     }
 
-    function test_sql_bitor() {
+    public function test_sql_bitor() {
         $DB = $this->tdb;
         $dbman = $DB->get_manager();
 
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('col1', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
-        $table->add_field('col2', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('col1', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
+        $table->add_field('col2', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
         $DB->insert_record($tablename, array('col1' => 3, 'col2' => 10));
 
         $sql = "SELECT ".$DB->sql_bitor(10, 3)." AS res ".$DB->sql_null_from_clause();
-        $this->assertEquals($DB->get_field_sql($sql), 11);
+        $this->assertEquals(11, $DB->get_field_sql($sql));
 
         $sql = "SELECT id, ".$DB->sql_bitor('col1', 'col2')." AS res FROM {{$tablename}}";
         $result = $DB->get_records_sql($sql);
-        $this->assertEquals(count($result), 1);
-        $this->assertEquals(reset($result)->res, 11);
+        $this->assertCount(1, $result);
+        $this->assertEquals(11, reset($result)->res);
 
         $sql = "SELECT id, ".$DB->sql_bitor('col1', '?')." AS res FROM {{$tablename}}";
         $result = $DB->get_records_sql($sql, array(10));
-        $this->assertEquals(count($result), 1);
-        $this->assertEquals(reset($result)->res, 11);
+        $this->assertCount(1, $result);
+        $this->assertEquals(11, reset($result)->res);
     }
 
-    function test_sql_bitxor() {
+    public function test_sql_bitxor() {
         $DB = $this->tdb;
         $dbman = $DB->get_manager();
 
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('col1', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
-        $table->add_field('col2', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('col1', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
+        $table->add_field('col2', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
         $DB->insert_record($tablename, array('col1' => 3, 'col2' => 10));
 
         $sql = "SELECT ".$DB->sql_bitxor(10, 3)." AS res ".$DB->sql_null_from_clause();
-        $this->assertEquals($DB->get_field_sql($sql), 9);
+        $this->assertEquals(9, $DB->get_field_sql($sql));
 
         $sql = "SELECT id, ".$DB->sql_bitxor('col1', 'col2')." AS res FROM {{$tablename}}";
         $result = $DB->get_records_sql($sql);
-        $this->assertEquals(count($result), 1);
-        $this->assertEquals(reset($result)->res, 9);
+        $this->assertCount(1, $result);
+        $this->assertEquals(9, reset($result)->res);
 
         $sql = "SELECT id, ".$DB->sql_bitxor('col1', '?')." AS res FROM {{$tablename}}";
         $result = $DB->get_records_sql($sql, array(10));
-        $this->assertEquals(count($result), 1);
-        $this->assertEquals(reset($result)->res, 9);
+        $this->assertCount(1, $result);
+        $this->assertEquals(9, reset($result)->res);
     }
 
-    function test_sql_modulo() {
+    public function test_sql_modulo() {
         $DB = $this->tdb;
         $sql = "SELECT ".$DB->sql_modulo(10, 7)." AS res ".$DB->sql_null_from_clause();
-        $this->assertEquals($DB->get_field_sql($sql), 3);
+        $this->assertEquals(3, $DB->get_field_sql($sql));
     }
 
-    function test_sql_ceil() {
+    public function test_sql_ceil() {
         $DB = $this->tdb;
         $sql = "SELECT ".$DB->sql_ceil(665.666)." AS res ".$DB->sql_null_from_clause();
-        $this->assertEquals($DB->get_field_sql($sql), 666);
+        $this->assertEquals(666, $DB->get_field_sql($sql));
     }
 
-    function test_cast_char2int() {
+    public function test_cast_char2int() {
         $DB = $this->tdb;
         $dbman = $DB->get_manager();
 
         $table1 = $this->get_test_table("1");
         $tablename1 = $table1->getName();
 
-        $table1->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table1->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
         $table1->add_field('name', XMLDB_TYPE_CHAR, '255', null, null, null, null);
         $table1->add_field('nametext', XMLDB_TYPE_TEXT, 'small', null, null, null, null);
         $table1->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
@@ -3491,49 +3478,49 @@ class core_dml_testcase extends database_driver_testcase {
 
         $table2 = $this->get_test_table("2");
         $tablename2 = $table2->getName();
-        $table2->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table2->add_field('res', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
-        $table2->add_field('restext', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table2->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table2->add_field('res', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
+        $table2->add_field('restext', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table2->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table2);
 
         $DB->insert_record($tablename2, array('res'=>100, 'restext'=>200));
 
-        // casting varchar field
+        // Casting varchar field.
         $sql = "SELECT *
                   FROM {".$tablename1."} t1
                   JOIN {".$tablename2."} t2 ON ".$DB->sql_cast_char2int("t1.name")." = t2.res ";
         $records = $DB->get_records_sql($sql);
-        $this->assertEquals(count($records), 1);
-        // also test them in order clauses
+        $this->assertCount(1, $records);
+        // Also test them in order clauses.
         $sql = "SELECT * FROM {{$tablename1}} ORDER BY ".$DB->sql_cast_char2int('name');
         $records = $DB->get_records_sql($sql);
-        $this->assertEquals(count($records), 2);
-        $this->assertEquals(reset($records)->name, '10');
-        $this->assertEquals(next($records)->name, '0100');
+        $this->assertCount(2, $records);
+        $this->assertSame('10', reset($records)->name);
+        $this->assertSame('0100', next($records)->name);
 
-        // casting text field
+        // Casting text field.
         $sql = "SELECT *
                   FROM {".$tablename1."} t1
                   JOIN {".$tablename2."} t2 ON ".$DB->sql_cast_char2int("t1.nametext", true)." = t2.restext ";
         $records = $DB->get_records_sql($sql);
-        $this->assertEquals(count($records), 1);
-        // also test them in order clauses
+        $this->assertCount(1, $records);
+        // Also test them in order clauses.
         $sql = "SELECT * FROM {{$tablename1}} ORDER BY ".$DB->sql_cast_char2int('nametext', true);
         $records = $DB->get_records_sql($sql);
-        $this->assertEquals(count($records), 2);
-        $this->assertEquals(reset($records)->nametext, '20');
-        $this->assertEquals(next($records)->nametext, '0200');
+        $this->assertCount(2, $records);
+        $this->assertSame('20', reset($records)->nametext);
+        $this->assertSame('0200', next($records)->nametext);
     }
 
-    function test_cast_char2real() {
+    public function test_cast_char2real() {
         $DB = $this->tdb;
         $dbman = $DB->get_manager();
 
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
         $table->add_field('name', XMLDB_TYPE_CHAR, '255', null, null, null, null);
         $table->add_field('nametext', XMLDB_TYPE_TEXT, 'small', null, null, null, null);
         $table->add_field('res', XMLDB_TYPE_NUMBER, '12, 7', null, null, null, null);
@@ -3542,31 +3529,31 @@ class core_dml_testcase extends database_driver_testcase {
 
         $DB->insert_record($tablename, array('name'=>'10.10', 'nametext'=>'10.10', 'res'=>5.1));
         $DB->insert_record($tablename, array('name'=>'91.10', 'nametext'=>'91.10', 'res'=>666));
-        $DB->insert_record($tablename, array('name'=>'011.10','nametext'=>'011.10','res'=>10.1));
+        $DB->insert_record($tablename, array('name'=>'011.10', 'nametext'=>'011.10', 'res'=>10.1));
 
-        // casting varchar field
+        // Casting varchar field.
         $sql = "SELECT * FROM {{$tablename}} WHERE ".$DB->sql_cast_char2real('name')." > res";
         $records = $DB->get_records_sql($sql);
-        $this->assertEquals(count($records), 2);
-        // also test them in order clauses
+        $this->assertCount(2, $records);
+        // Also test them in order clauses.
         $sql = "SELECT * FROM {{$tablename}} ORDER BY ".$DB->sql_cast_char2real('name');
         $records = $DB->get_records_sql($sql);
-        $this->assertEquals(count($records), 3);
-        $this->assertEquals(reset($records)->name, '10.10');
-        $this->assertEquals(next($records)->name, '011.10');
-        $this->assertEquals(next($records)->name, '91.10');
+        $this->assertCount(3, $records);
+        $this->assertSame('10.10', reset($records)->name);
+        $this->assertSame('011.10', next($records)->name);
+        $this->assertSame('91.10', next($records)->name);
 
-        // casting text field
+        // Casting text field.
         $sql = "SELECT * FROM {{$tablename}} WHERE ".$DB->sql_cast_char2real('nametext', true)." > res";
         $records = $DB->get_records_sql($sql);
-        $this->assertEquals(count($records), 2);
-        // also test them in order clauses
+        $this->assertCount(2, $records);
+        // Also test them in order clauses.
         $sql = "SELECT * FROM {{$tablename}} ORDER BY ".$DB->sql_cast_char2real('nametext', true);
         $records = $DB->get_records_sql($sql);
-        $this->assertEquals(count($records), 3);
-        $this->assertEquals(reset($records)->nametext, '10.10');
-        $this->assertEquals(next($records)->nametext, '011.10');
-        $this->assertEquals(next($records)->nametext, '91.10');
+        $this->assertCount(3, $records);
+        $this->assertSame('10.10', reset($records)->nametext);
+        $this->assertSame('011.10', next($records)->nametext);
+        $this->assertSame('91.10', next($records)->nametext);
     }
 
     public function test_sql_compare_text() {
@@ -3576,7 +3563,7 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
         $table->add_field('name', XMLDB_TYPE_CHAR, '255', null, null, null, null);
         $table->add_field('description', XMLDB_TYPE_TEXT, 'big', null, null, null, null);
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
@@ -3623,8 +3610,8 @@ class core_dml_testcase extends database_driver_testcase {
 
     }
 
-    function test_unique_index_collation_trouble() {
-        // note: this is a work in progress, we should probably move this to ddl test
+    public function test_unique_index_collation_trouble() {
+        // Note: this is a work in progress, we should probably move this to ddl test.
 
         $DB = $this->tdb;
         $dbman = $DB->get_manager();
@@ -3632,7 +3619,7 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
         $table->add_field('name', XMLDB_TYPE_CHAR, '255', null, null, null, null);
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $table->add_index('name', XMLDB_INDEX_UNIQUE, array('name'));
@@ -3642,35 +3629,35 @@ class core_dml_testcase extends database_driver_testcase {
 
         try {
             $DB->insert_record($tablename, array('name'=>'AAA'));
-        } catch (Exception $e) {
-            //TODO: ignore case insensitive uniqueness problems for now
-            //$this->fail("Unique index is case sensitive - this may cause problems in some tables");
+        } catch (moodle_exception $e) {
+            // TODO: ignore case insensitive uniqueness problems for now.
+            // $this->fail("Unique index is case sensitive - this may cause problems in some tables");
         }
 
         try {
             $DB->insert_record($tablename, array('name'=>'aäa'));
             $DB->insert_record($tablename, array('name'=>'aáa'));
             $this->assertTrue(true);
-        } catch (Exception $e) {
+        } catch (moodle_exception $e) {
             $family = $DB->get_dbfamily();
             if ($family === 'mysql' or $family === 'mssql') {
                 $this->fail("Unique index is accent insensitive, this may cause problems for non-ascii languages. This is usually caused by accent insensitive default collation.");
             } else {
-                // this should not happen, PostgreSQL and Oracle do not support accent insensitive uniqueness.
+                // This should not happen, PostgreSQL and Oracle do not support accent insensitive uniqueness.
                 $this->fail("Unique index is accent insensitive, this may cause problems for non-ascii languages.");
             }
             throw($e);
         }
     }
 
-    function test_sql_binary_equal() {
+    public function test_sql_binary_equal() {
         $DB = $this->tdb;
         $dbman = $DB->get_manager();
 
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
         $table->add_field('name', XMLDB_TYPE_CHAR, '255', null, null, null, null);
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
@@ -3682,20 +3669,20 @@ class core_dml_testcase extends database_driver_testcase {
         $DB->insert_record($tablename, array('name'=>'BBB'));
 
         $records = $DB->get_records_sql("SELECT * FROM {{$tablename}} WHERE name = ?", array('bbb'));
-        $this->assertEquals(count($records), 1, 'SQL operator "=" is expected to be case sensitive');
+        $this->assertEquals(1, count($records), 'SQL operator "=" is expected to be case sensitive');
 
         $records = $DB->get_records_sql("SELECT * FROM {{$tablename}} WHERE name = ?", array('aaa'));
-        $this->assertEquals(count($records), 1, 'SQL operator "=" is expected to be accent sensitive');
+        $this->assertEquals(1, count($records), 'SQL operator "=" is expected to be accent sensitive');
     }
 
-    function test_sql_like() {
+    public function test_sql_like() {
         $DB = $this->tdb;
         $dbman = $DB->get_manager();
 
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
         $table->add_field('name', XMLDB_TYPE_CHAR, '255', null, null, null, null);
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
@@ -3711,122 +3698,122 @@ class core_dml_testcase extends database_driver_testcase {
 
         $sql = "SELECT * FROM {{$tablename}} WHERE ".$DB->sql_like('name', '?', false);
         $records = $DB->get_records_sql($sql, array("%dup_r%"));
-        $this->assertEquals(count($records), 2);
+        $this->assertCount(2, $records);
 
         $sql = "SELECT * FROM {{$tablename}} WHERE ".$DB->sql_like('name', '?', true);
         $records = $DB->get_records_sql($sql, array("%dup%"));
-        $this->assertEquals(count($records), 1);
+        $this->assertCount(1, $records);
 
-        $sql = "SELECT * FROM {{$tablename}} WHERE ".$DB->sql_like('name', '?'); // defaults
+        $sql = "SELECT * FROM {{$tablename}} WHERE ".$DB->sql_like('name', '?'); // Defaults.
         $records = $DB->get_records_sql($sql, array("%dup%"));
-        $this->assertEquals(count($records), 1);
+        $this->assertCount(1, $records);
 
         $sql = "SELECT * FROM {{$tablename}} WHERE ".$DB->sql_like('name', '?', true);
         $records = $DB->get_records_sql($sql, array("ouc\\_"));
-        $this->assertEquals(count($records), 1);
+        $this->assertCount(1, $records);
 
         $sql = "SELECT * FROM {{$tablename}} WHERE ".$DB->sql_like('name', '?', true, true, false, '|');
         $records = $DB->get_records_sql($sql, array($DB->sql_like_escape("ouc%", '|')));
-        $this->assertEquals(count($records), 1);
+        $this->assertCount(1, $records);
 
         $sql = "SELECT * FROM {{$tablename}} WHERE ".$DB->sql_like('name', '?', true, true);
         $records = $DB->get_records_sql($sql, array('aui'));
-        $this->assertEquals(count($records), 1);
+        $this->assertCount(1, $records);
 
-        $sql = "SELECT * FROM {{$tablename}} WHERE ".$DB->sql_like('name', '?', true, true, true); // NOT LIKE
+        $sql = "SELECT * FROM {{$tablename}} WHERE ".$DB->sql_like('name', '?', true, true, true); // NOT LIKE.
         $records = $DB->get_records_sql($sql, array("%o%"));
-        $this->assertEquals(count($records), 3);
+        $this->assertCount(3, $records);
 
-        $sql = "SELECT * FROM {{$tablename}} WHERE ".$DB->sql_like('name', '?', false, true, true); // NOT ILIKE
+        $sql = "SELECT * FROM {{$tablename}} WHERE ".$DB->sql_like('name', '?', false, true, true); // NOT ILIKE.
         $records = $DB->get_records_sql($sql, array("%D%"));
-        $this->assertEquals(count($records), 6);
+        $this->assertCount(6, $records);
 
-        // verify usual escaping characters work fine
+        // Verify usual escaping characters work fine.
         $sql = "SELECT * FROM {{$tablename}} WHERE ".$DB->sql_like('name', '?', true, true, false, '\\');
         $records = $DB->get_records_sql($sql, array("ouc\\_"));
-        $this->assertEquals(count($records), 1);
+        $this->assertCount(1, $records);
         $sql = "SELECT * FROM {{$tablename}} WHERE ".$DB->sql_like('name', '?', true, true, false, '|');
         $records = $DB->get_records_sql($sql, array("ouc|%"));
-        $this->assertEquals(count($records), 1);
+        $this->assertCount(1, $records);
 
-        // TODO: we do not require accent insensitivness yet, just make sure it does not throw errors
+        // TODO: we do not require accent insensitivness yet, just make sure it does not throw errors.
         $sql = "SELECT * FROM {{$tablename}} WHERE ".$DB->sql_like('name', '?', true, false);
         $records = $DB->get_records_sql($sql, array('aui'));
-        //$this->assertEquals(count($records), 2, 'Accent insensitive LIKE searches may not be supported in all databases, this is not a problem.');
+        // $this->assertEquals(2, count($records), 'Accent insensitive LIKE searches may not be supported in all databases, this is not a problem.');
         $sql = "SELECT * FROM {{$tablename}} WHERE ".$DB->sql_like('name', '?', false, false);
         $records = $DB->get_records_sql($sql, array('aui'));
-        //$this->assertEquals(count($records), 3, 'Accent insensitive LIKE searches may not be supported in all databases, this is not a problem.');
+        // $this->assertEquals(3, count($records), 'Accent insensitive LIKE searches may not be supported in all databases, this is not a problem.');
     }
 
-    function test_coalesce() {
+    public function test_coalesce() {
         $DB = $this->tdb;
 
-        // Testing not-null occurrences, return 1st
+        // Testing not-null occurrences, return 1st.
         $sql = "SELECT COALESCE('returnthis', 'orthis', 'orwhynotthis') AS test" . $DB->sql_null_from_clause();
-        $this->assertEquals('returnthis', $DB->get_field_sql($sql, array()));
+        $this->assertSame('returnthis', $DB->get_field_sql($sql, array()));
         $sql = "SELECT COALESCE(:paramvalue, 'orthis', 'orwhynotthis') AS test" . $DB->sql_null_from_clause();
-        $this->assertEquals('returnthis', $DB->get_field_sql($sql, array('paramvalue' => 'returnthis')));
+        $this->assertSame('returnthis', $DB->get_field_sql($sql, array('paramvalue' => 'returnthis')));
 
-        // Testing null occurrences, return 2nd
+        // Testing null occurrences, return 2nd.
         $sql = "SELECT COALESCE(null, 'returnthis', 'orthis') AS test" . $DB->sql_null_from_clause();
-        $this->assertEquals('returnthis', $DB->get_field_sql($sql, array()));
+        $this->assertSame('returnthis', $DB->get_field_sql($sql, array()));
         $sql = "SELECT COALESCE(:paramvalue, 'returnthis', 'orthis') AS test" . $DB->sql_null_from_clause();
-        $this->assertEquals('returnthis', $DB->get_field_sql($sql, array('paramvalue' => null)));
+        $this->assertSame('returnthis', $DB->get_field_sql($sql, array('paramvalue' => null)));
         $sql = "SELECT COALESCE(null, :paramvalue, 'orthis') AS test" . $DB->sql_null_from_clause();
-        $this->assertEquals('returnthis', $DB->get_field_sql($sql, array('paramvalue' => 'returnthis')));
+        $this->assertSame('returnthis', $DB->get_field_sql($sql, array('paramvalue' => 'returnthis')));
 
-        // Testing null occurrences, return 3rd
+        // Testing null occurrences, return 3rd.
         $sql = "SELECT COALESCE(null, null, 'returnthis') AS test" . $DB->sql_null_from_clause();
-        $this->assertEquals('returnthis', $DB->get_field_sql($sql, array()));
+        $this->assertSame('returnthis', $DB->get_field_sql($sql, array()));
         $sql = "SELECT COALESCE(null, :paramvalue, 'returnthis') AS test" . $DB->sql_null_from_clause();
-        $this->assertEquals('returnthis', $DB->get_field_sql($sql, array('paramvalue' => null)));
+        $this->assertSame('returnthis', $DB->get_field_sql($sql, array('paramvalue' => null)));
         $sql = "SELECT COALESCE(null, null, :paramvalue) AS test" . $DB->sql_null_from_clause();
-        $this->assertEquals('returnthis', $DB->get_field_sql($sql, array('paramvalue' => 'returnthis')));
+        $this->assertSame('returnthis', $DB->get_field_sql($sql, array('paramvalue' => 'returnthis')));
 
-        // Testing all null occurrences, return null
+        // Testing all null occurrences, return null.
         // Note: under mssql, if all elements are nulls, at least one must be a "typed" null, hence
         // we cannot test this in a cross-db way easily, so next 2 tests are using
-        // different queries depending of the DB family
+        // different queries depending of the DB family.
         $customnull = $DB->get_dbfamily() == 'mssql' ? 'CAST(null AS varchar)' : 'null';
         $sql = "SELECT COALESCE(null, null, " . $customnull . ") AS test" . $DB->sql_null_from_clause();
         $this->assertNull($DB->get_field_sql($sql, array()));
         $sql = "SELECT COALESCE(null, :paramvalue, " . $customnull . ") AS test" . $DB->sql_null_from_clause();
         $this->assertNull($DB->get_field_sql($sql, array('paramvalue' => null)));
 
-        // Check there are not problems with whitespace strings
+        // Check there are not problems with whitespace strings.
         $sql = "SELECT COALESCE(null, '', null) AS test" . $DB->sql_null_from_clause();
-        $this->assertEquals('', $DB->get_field_sql($sql, array()));
+        $this->assertSame('', $DB->get_field_sql($sql, array()));
         $sql = "SELECT COALESCE(null, :paramvalue, null) AS test" . $DB->sql_null_from_clause();
-        $this->assertEquals('', $DB->get_field_sql($sql, array('paramvalue' => '')));
+        $this->assertSame('', $DB->get_field_sql($sql, array('paramvalue' => '')));
     }
 
-    function test_sql_concat() {
+    public function test_sql_concat() {
         $DB = $this->tdb;
         $dbman = $DB->get_manager();
 
-        // Testing all sort of values
+        // Testing all sort of values.
         $sql = "SELECT ".$DB->sql_concat("?", "?", "?")." AS fullname ". $DB->sql_null_from_clause();
-        // string, some unicode chars
+        // String, some unicode chars.
         $params = array('name', 'áéíóú', 'name3');
-        $this->assertEquals('nameáéíóúname3', $DB->get_field_sql($sql, $params));
-        // string, spaces and numbers
+        $this->assertSame('nameáéíóúname3', $DB->get_field_sql($sql, $params));
+        // String, spaces and numbers.
         $params = array('name', '  ', 12345);
-        $this->assertEquals('name  12345', $DB->get_field_sql($sql, $params));
-        // float, empty and strings
+        $this->assertSame('name  12345', $DB->get_field_sql($sql, $params));
+        // Float, empty and strings.
         $params = array(123.45, '', 'test');
-        $this->assertEquals('123.45test', $DB->get_field_sql($sql, $params));
-        // only integers
+        $this->assertSame('123.45test', $DB->get_field_sql($sql, $params));
+        // Only integers.
         $params = array(12, 34, 56);
-        $this->assertEquals('123456', $DB->get_field_sql($sql, $params));
-        // float, null and strings
+        $this->assertSame('123456', $DB->get_field_sql($sql, $params));
+        // Float, null and strings.
         $params = array(123.45, null, 'test');
-        $this->assertNull($DB->get_field_sql($sql, $params)); // Concatenate NULL with anything result = NULL
+        $this->assertNull($DB->get_field_sql($sql, $params)); // Concatenate null with anything result = null.
 
-        // Testing fieldnames + values and also integer fieldnames
+        // Testing fieldnames + values and also integer fieldnames.
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
         $table->add_field('description', XMLDB_TYPE_TEXT, 'big', null, null, null, null);
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
@@ -3835,25 +3822,25 @@ class core_dml_testcase extends database_driver_testcase {
         $DB->insert_record($tablename, array('description'=>'dxxx'));
         $DB->insert_record($tablename, array('description'=>'bcde'));
 
-        // fieldnames and values mixed
+        // Fieldnames and values mixed.
         $sql = 'SELECT id, ' . $DB->sql_concat('description', "'harcoded'", '?', '?') . ' AS result FROM {' . $tablename . '}';
         $records = $DB->get_records_sql($sql, array(123.45, 'test'));
-        $this->assertEquals(count($records), 3);
-        $this->assertEquals($records[1]->result, 'áéíóúharcoded123.45test');
-        // integer fieldnames and values
+        $this->assertCount(3, $records);
+        $this->assertSame('áéíóúharcoded123.45test', $records[1]->result);
+        // Integer fieldnames and values.
         $sql = 'SELECT id, ' . $DB->sql_concat('id', "'harcoded'", '?', '?') . ' AS result FROM {' . $tablename . '}';
         $records = $DB->get_records_sql($sql, array(123.45, 'test'));
-        $this->assertEquals(count($records), 3);
-        $this->assertEquals($records[1]->result, '1harcoded123.45test');
-        // all integer fieldnames
+        $this->assertCount(3, $records);
+        $this->assertSame('1harcoded123.45test', $records[1]->result);
+        // All integer fieldnames.
         $sql = 'SELECT id, ' . $DB->sql_concat('id', 'id', 'id') . ' AS result FROM {' . $tablename . '}';
         $records = $DB->get_records_sql($sql, array());
-        $this->assertEquals(count($records), 3);
-        $this->assertEquals($records[1]->result, '111');
+        $this->assertCount(3, $records);
+        $this->assertSame('111', $records[1]->result);
 
     }
 
-    function test_concat_join() {
+    public function test_concat_join() {
         $DB = $this->tdb;
         $sql = "SELECT ".$DB->sql_concat_join("' '", array("?", "?", "?"))." AS fullname ".$DB->sql_null_from_clause();
         $params = array("name", "name2", "name3");
@@ -3861,21 +3848,21 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertEquals("name name2 name3", $result);
     }
 
-    function test_sql_fullname() {
+    public function test_sql_fullname() {
         $DB = $this->tdb;
         $sql = "SELECT ".$DB->sql_fullname(':first', ':last')." AS fullname ".$DB->sql_null_from_clause();
         $params = array('first'=>'Firstname', 'last'=>'Surname');
         $this->assertEquals("Firstname Surname", $DB->get_field_sql($sql, $params));
     }
 
-    function test_sql_order_by_text() {
+    public function test_sql_order_by_text() {
         $DB = $this->tdb;
         $dbman = $DB->get_manager();
 
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
         $table->add_field('description', XMLDB_TYPE_TEXT, 'big', null, null, null, null);
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
@@ -3894,14 +3881,14 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertEquals(2, $last->id);
     }
 
-    function test_sql_substring() {
+    public function test_sql_substring() {
         $DB = $this->tdb;
         $dbman = $DB->get_manager();
 
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
         $table->add_field('name', XMLDB_TYPE_CHAR, '255', null, null, null, null);
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
@@ -3919,15 +3906,15 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertEquals(substr($string, 5-1, 2), $record->name);
 
         try {
-            // silence php warning ;-)
+            // Silence php warning.
             @$DB->sql_substr("name");
             $this->fail("Expecting an exception, none occurred");
-        } catch (Exception $e) {
-            $this->assertTrue($e instanceof coding_exception);
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('coding_exception', $e);
         }
     }
 
-    function test_sql_length() {
+    public function test_sql_length() {
         $DB = $this->tdb;
         $this->assertEquals($DB->get_field_sql(
             "SELECT ".$DB->sql_length("'aeiou'").$DB->sql_null_from_clause()), 5);
@@ -3935,7 +3922,7 @@ class core_dml_testcase extends database_driver_testcase {
             "SELECT ".$DB->sql_length("'áéíóú'").$DB->sql_null_from_clause()), 5);
     }
 
-    function test_sql_position() {
+    public function test_sql_position() {
         $DB = $this->tdb;
         $this->assertEquals($DB->get_field_sql(
             "SELECT ".$DB->sql_position("'ood'", "'Moodle'").$DB->sql_null_from_clause()), 2);
@@ -3943,7 +3930,7 @@ class core_dml_testcase extends database_driver_testcase {
             "SELECT ".$DB->sql_position("'Oracle'", "'Moodle'").$DB->sql_null_from_clause()), 0);
     }
 
-    function test_sql_empty() {
+    public function test_sql_empty() {
         $DB = $this->tdb;
         $dbman = $DB->get_manager();
 
@@ -3953,7 +3940,7 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertSame('', $DB->sql_empty()); // Since 2.5 the hack is applied automatically to all bound params.
         $this->assertDebuggingCalled();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
         $table->add_field('name', XMLDB_TYPE_CHAR, '255', null, null, null, null);
         $table->add_field('namenotnull', XMLDB_TYPE_CHAR, '255', null, XMLDB_NOTNULL, null, 'default value');
         $table->add_field('namenotnullnodeflt', XMLDB_TYPE_CHAR, '255', null, XMLDB_NOTNULL, null, null);
@@ -3966,29 +3953,29 @@ class core_dml_testcase extends database_driver_testcase {
         $DB->insert_record($tablename, array('name'=>0));
 
         $records = $DB->get_records_sql("SELECT * FROM {{$tablename}} WHERE name = ?", array(''));
-        $this->assertEquals(count($records), 1);
+        $this->assertCount(1, $records);
         $record = reset($records);
-        $this->assertEquals($record->name, '');
+        $this->assertSame('', $record->name);
 
         $records = $DB->get_records_sql("SELECT * FROM {{$tablename}} WHERE namenotnull = ?", array(''));
-        $this->assertEquals(count($records), 1);
+        $this->assertCount(1, $records);
         $record = reset($records);
-        $this->assertEquals($record->namenotnull, '');
+        $this->assertSame('', $record->namenotnull);
 
         $records = $DB->get_records_sql("SELECT * FROM {{$tablename}} WHERE namenotnullnodeflt = ?", array(''));
-        $this->assertEquals(count($records), 4);
+        $this->assertCount(4, $records);
         $record = reset($records);
-        $this->assertEquals($record->namenotnullnodeflt, '');
+        $this->assertSame('', $record->namenotnullnodeflt);
     }
 
-    function test_sql_isempty() {
+    public function test_sql_isempty() {
         $DB = $this->tdb;
         $dbman = $DB->get_manager();
 
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
         $table->add_field('name', XMLDB_TYPE_CHAR, '255', null, XMLDB_NOTNULL, null, null);
         $table->add_field('namenull', XMLDB_TYPE_CHAR, '255', null, null, null, null);
         $table->add_field('description', XMLDB_TYPE_TEXT, 'big', null, XMLDB_NOTNULL, null, null);
@@ -4002,34 +3989,34 @@ class core_dml_testcase extends database_driver_testcase {
         $DB->insert_record($tablename, array('name'=>0,    'namenull'=>0,    'description'=>0,    'descriptionnull'=>0));
 
         $records = $DB->get_records_sql("SELECT * FROM {{$tablename}} WHERE ".$DB->sql_isempty($tablename, 'name', false, false));
-        $this->assertEquals(count($records), 1);
+        $this->assertCount(1, $records);
         $record = reset($records);
-        $this->assertEquals($record->name, '');
+        $this->assertSame('', $record->name);
 
         $records = $DB->get_records_sql("SELECT * FROM {{$tablename}} WHERE ".$DB->sql_isempty($tablename, 'namenull', true, false));
-        $this->assertEquals(count($records), 1);
+        $this->assertCount(1, $records);
         $record = reset($records);
-        $this->assertEquals($record->namenull, '');
+        $this->assertSame('', $record->namenull);
 
         $records = $DB->get_records_sql("SELECT * FROM {{$tablename}} WHERE ".$DB->sql_isempty($tablename, 'description', false, true));
-        $this->assertEquals(count($records), 1);
+        $this->assertCount(1, $records);
         $record = reset($records);
-        $this->assertEquals($record->description, '');
+        $this->assertSame('', $record->description);
 
         $records = $DB->get_records_sql("SELECT * FROM {{$tablename}} WHERE ".$DB->sql_isempty($tablename, 'descriptionnull', true, true));
-        $this->assertEquals(count($records), 1);
+        $this->assertCount(1, $records);
         $record = reset($records);
-        $this->assertEquals($record->descriptionnull, '');
+        $this->assertSame('', $record->descriptionnull);
     }
 
-    function test_sql_isnotempty() {
+    public function test_sql_isnotempty() {
         $DB = $this->tdb;
         $dbman = $DB->get_manager();
 
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
         $table->add_field('name', XMLDB_TYPE_CHAR, '255', null, XMLDB_NOTNULL, null, null);
         $table->add_field('namenull', XMLDB_TYPE_CHAR, '255', null, null, null, null);
         $table->add_field('description', XMLDB_TYPE_TEXT, 'big', null, XMLDB_NOTNULL, null, null);
@@ -4043,34 +4030,34 @@ class core_dml_testcase extends database_driver_testcase {
         $DB->insert_record($tablename, array('name'=>0,    'namenull'=>0,    'description'=>0,    'descriptionnull'=>0));
 
         $records = $DB->get_records_sql("SELECT * FROM {{$tablename}} WHERE ".$DB->sql_isnotempty($tablename, 'name', false, false));
-        $this->assertEquals(count($records), 3);
+        $this->assertCount(3, $records);
         $record = reset($records);
-        $this->assertEquals($record->name, '??');
+        $this->assertSame('??', $record->name);
 
         $records = $DB->get_records_sql("SELECT * FROM {{$tablename}} WHERE ".$DB->sql_isnotempty($tablename, 'namenull', true, false));
-        $this->assertEquals(count($records), 2); // 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);
-        $this->assertEquals($record->namenull, 'la'); // so 'la' is the first non-empty 'namenull' record
+        $this->assertSame('la', $record->namenull); // So 'la' is the first non-empty 'namenull' record.
 
         $records = $DB->get_records_sql("SELECT * FROM {{$tablename}} WHERE ".$DB->sql_isnotempty($tablename, 'description', false, true));
-        $this->assertEquals(count($records), 3);
+        $this->assertCount(3, $records);
         $record = reset($records);
-        $this->assertEquals($record->description, '??');
+        $this->assertSame('??', $record->description);
 
         $records = $DB->get_records_sql("SELECT * FROM {{$tablename}} WHERE ".$DB->sql_isnotempty($tablename, 'descriptionnull', true, true));
-        $this->assertEquals(count($records), 2); // 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);
-        $this->assertEquals($record->descriptionnull, 'lalala'); // so 'lalala' is the first non-empty 'descriptionnull' record
+        $this->assertSame('lalala', $record->descriptionnull); // So 'lalala' is the first non-empty 'descriptionnull' record.
     }
 
-    function test_sql_regex() {
+    public function test_sql_regex() {
         $DB = $this->tdb;
         $dbman = $DB->get_manager();
 
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
         $table->add_field('name', XMLDB_TYPE_CHAR, '255', null, null, null, null);
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
@@ -4083,7 +4070,7 @@ class core_dml_testcase extends database_driver_testcase {
         $params = array('a$');
         if ($DB->sql_regex_supported()) {
             $records = $DB->get_records_sql($sql, $params);
-            $this->assertEquals(count($records), 2);
+            $this->assertCount(2, $records);
         } else {
             $this->assertTrue(true, 'Regexp operations not supported. Test skipped');
         }
@@ -4092,7 +4079,7 @@ class core_dml_testcase extends database_driver_testcase {
         $params = array('.a');
         if ($DB->sql_regex_supported()) {
             $records = $DB->get_records_sql($sql, $params);
-            $this->assertEquals(count($records), 1);
+            $this->assertCount(1, $records);
         } else {
             $this->assertTrue(true, 'Regexp operations not supported. Test skipped');
         }
@@ -4110,10 +4097,10 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_field('name', XMLDB_TYPE_CHAR, '255', null, null, null, null);
-        $table->add_field('content', XMLDB_TYPE_TEXT, 'big', XMLDB_UNSIGNED, XMLDB_NOTNULL);
+        $table->add_field('content', XMLDB_TYPE_TEXT, 'big', null, XMLDB_NOTNULL);
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
@@ -4122,7 +4109,7 @@ class core_dml_testcase extends database_driver_testcase {
         $DB->insert_record($tablename, array('course' => 5, 'content' => 'hello', 'name'=>'def'));
         $DB->insert_record($tablename, array('course' => 2, 'content' => 'universe', 'name'=>'abc'));
 
-        // test grouping by expressions in the query. MDL-26819. Note that there are 4 ways:
+        // Test grouping by expressions in the query. MDL-26819. Note that there are 4 ways:
         // - By column position (GROUP by 1) - Not supported by mssql & oracle
         // - By column name (GROUP by course) - Supported by all, but leading to wrong results
         // - By column alias (GROUP by casecol) - Not supported by mssql & oracle
@@ -4139,7 +4126,7 @@ class core_dml_testcase extends database_driver_testcase {
         $records = $DB->get_records_sql($sql, null);
         $this->assertEquals($result, $records);
 
-        // another grouping by CASE expression just to ensure it works ok for multiple WHEN
+        // Another grouping by CASE expression just to ensure it works ok for multiple WHEN.
         $sql = "SELECT CASE name
                             WHEN 'xyz' THEN 'last'
                             WHEN 'def' THEN 'mid'
@@ -4165,7 +4152,7 @@ class core_dml_testcase extends database_driver_testcase {
         $sql = "SELECT id, course, name
                   FROM {{$tablename}}
               ORDER BY CASE WHEN (course = 5 OR name  = 'xyz') THEN 0 ELSE 1 END, name, course";
-        // First, records matching the course = 5 OR name = 'xyz', then the rest. Each
+        // First, records matching the course = 5 OR name = 'xyz', then the rest. Each.
         // group ordered by name and course.
         $result = array(
             3 => (object)array('id' => 3, 'course' => 5, 'name' => 'def'),
@@ -4177,59 +4164,59 @@ class core_dml_testcase extends database_driver_testcase {
         // Verify also array keys, order is important in this test.
         $this->assertEquals(array_keys($result), array_keys($records));
 
-        // test limits in queries with DISTINCT/ALL clauses and multiple whitespace. MDL-25268
+        // Test limits in queries with DISTINCT/ALL clauses and multiple whitespace. MDL-25268.
         $sql = "SELECT   DISTINCT   course
                   FROM {{$tablename}}
                  ORDER BY course";
-        // only limitfrom
+        // Only limitfrom.
         $records = $DB->get_records_sql($sql, null, 1);
-        $this->assertEquals(2, count($records));
+        $this->assertCount(2, $records);
         $this->assertEquals(3, reset($records)->course);
         $this->assertEquals(5, next($records)->course);
-        // only limitnum
+        // Only limitnum.
         $records = $DB->get_records_sql($sql, null, 0, 2);
-        $this->assertEquals(2, count($records));
+        $this->assertCount(2, $records);
         $this->assertEquals(2, reset($records)->course);
         $this->assertEquals(3, next($records)->course);
-        // both limitfrom and limitnum
+        // Both limitfrom and limitnum.
         $records = $DB->get_records_sql($sql, null, 2, 2);
-        $this->assertEquals(1, count($records));
+        $this->assertCount(1, $records);
         $this->assertEquals(5, reset($records)->course);
 
-        // we have sql like this in moodle, this syntax breaks on older versions of sqlite for example..
+        // We have sql like this in moodle, this syntax breaks on older versions of sqlite for example..
         $sql = "SELECT a.id AS id, a.course AS course
                   FROM {{$tablename}} a
                   JOIN (SELECT * FROM {{$tablename}}) b ON a.id = b.id
                  WHERE a.course = ?";
 
         $records = $DB->get_records_sql($sql, array(3));
-        $this->assertEquals(2, count($records));
+        $this->assertCount(2, $records);
         $this->assertEquals(1, reset($records)->id);
         $this->assertEquals(2, next($records)->id);
 
-        // do NOT try embedding sql_xxxx() helper functions in conditions array of count_records(), they don't break params/binding!
+        // Do NOT try embedding sql_xxxx() helper functions in conditions array of count_records(), they don't break params/binding!
         $count = $DB->count_records_select($tablename, "course = :course AND ".$DB->sql_compare_text('content')." = :content", array('course' => 3, 'content' => 'hello'));
         $this->assertEquals(1, $count);
 
-        // test int x string comparison
+        // Test int x string comparison.
         $sql = "SELECT *
                   FROM {{$tablename}} c
                  WHERE name = ?";
-        $this->assertEquals(count($DB->get_records_sql($sql, array(10))), 0);
-        $this->assertEquals(count($DB->get_records_sql($sql, array("10"))), 0);
+        $this->assertCount(0, $DB->get_records_sql($sql, array(10)));
+        $this->assertCount(0, $DB->get_records_sql($sql, array("10")));
         $DB->insert_record($tablename, array('course' => 7, 'content' => 'xx', 'name'=>'1'));
         $DB->insert_record($tablename, array('course' => 7, 'content' => 'yy', 'name'=>'2'));
-        $this->assertEquals(count($DB->get_records_sql($sql, array(1))), 1);
-        $this->assertEquals(count($DB->get_records_sql($sql, array("1"))), 1);
-        $this->assertEquals(count($DB->get_records_sql($sql, array(10))), 0);
-        $this->assertEquals(count($DB->get_records_sql($sql, array("10"))), 0);
+        $this->assertCount(1, $DB->get_records_sql($sql, array(1)));
+        $this->assertCount(1, $DB->get_records_sql($sql, array("1")));
+        $this->assertCount(0, $DB->get_records_sql($sql, array(10)));
+        $this->assertCount(0, $DB->get_records_sql($sql, array("10")));
         $DB->insert_record($tablename, array('course' => 7, 'content' => 'xx', 'name'=>'1abc'));
-        $this->assertEquals(count($DB->get_records_sql($sql, array(1))), 1);
-        $this->assertEquals(count($DB->get_records_sql($sql, array("1"))), 1);
+        $this->assertCount(1, $DB->get_records_sql($sql, array(1)));
+        $this->assertCount(1, $DB->get_records_sql($sql, array("1")));
 
         // Test get_in_or_equal() with a big number of elements. Note that ideally
         // we should be detecting and warning about any use over, say, 200 elements
-        // and recommend to change code to use subqueries and/or chunks instead.
+        // And recommend to change code to use subqueries and/or chunks instead.
         $currentcount = $DB->count_records($tablename);
         $numelements = 10000; // Verify that we can handle 10000 elements (crazy!)
         $values = range(1, $numelements);
@@ -4239,25 +4226,25 @@ class core_dml_testcase extends database_driver_testcase {
                   FROM {{$tablename}}
                  WHERE id $insql";
         $results = $DB->get_records_sql($sql, $inparams);
-        $this->assertEquals($currentcount, count($results));
+        $this->assertCount($currentcount, $results);
 
         list($insql, $inparams) = $DB->get_in_or_equal($values, SQL_PARAMS_NAMED); // With NAMED params.
         $sql = "SELECT *
                   FROM {{$tablename}}
                  WHERE id $insql";
         $results = $DB->get_records_sql($sql, $inparams);
-        $this->assertEquals($currentcount, count($results));
+        $this->assertCount($currentcount, $results);
     }
 
-    function test_onelevel_commit() {
+    public function test_onelevel_commit() {
         $DB = $this->tdb;
         $dbman = $DB->get_manager();
 
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
@@ -4270,7 +4257,7 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertEquals(1, $DB->count_records($tablename));
     }
 
-    function test_transaction_ignore_error_trouble() {
+    public function test_transaction_ignore_error_trouble() {
         $DB = $this->tdb;
         $dbman = $DB->get_manager();
 
@@ -4307,7 +4294,7 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertEquals(1, $DB->count_records($tablename));
         try {
             $DB->get_records_sql('s e l e c t');
-        } catch (Exception $e) {
+        } catch (moodle_exception $e) {
             // This must be ignored and it must not roll back the whole transaction.
         }
         $DB->insert_record($tablename, (object)array('course'=>2));
@@ -4324,7 +4311,7 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertEquals(1, $DB->count_records($tablename));
         try {
             $DB->execute('xxxx');
-        } catch (Exception $e) {
+        } catch (moodle_exception $e) {
             // This must be ignored and it must not roll back the whole transaction.
         }
         $DB->insert_record($tablename, (object)array('course'=>2));
@@ -4341,7 +4328,7 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertEquals(1, $DB->count_records($tablename));
         try {
             $DB->change_database_structure('xxxx');
-        } catch (Exception $e) {
+        } catch (moodle_exception $e) {
             // This must be ignored and it must not roll back the whole transaction.
         }
         $DB->insert_record($tablename, (object)array('course'=>2));
@@ -4353,19 +4340,19 @@ class core_dml_testcase extends database_driver_testcase {
         // NOTE: SQL_QUERY_STRUCTURE is intentionally not tested here because it should never fail.
     }
 
-    function test_onelevel_rollback() {
+    public function test_onelevel_rollback() {
         $DB = $this->tdb;
         $dbman = $DB->get_manager();
 
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
-        // this might in fact encourage ppl to migrate from myisam to innodb
+        // This might in fact encourage ppl to migrate from myisam to innodb.
 
         $transaction = $DB->start_delegated_transaction();
         $data = (object)array('course'=>3);
@@ -4376,23 +4363,24 @@ class core_dml_testcase extends database_driver_testcase {
             $transaction->rollback(new Exception('test'));
             $this->fail('transaction rollback must rethrow exception');
         } catch (Exception $e) {
+            // Ignored.
         }
         $this->assertEquals(0, $DB->count_records($tablename));
     }
 
-    function test_nested_transactions() {
+    public function test_nested_transactions() {
         $DB = $this->tdb;
         $dbman = $DB->get_manager();
 
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
-        // two level commit
+        // Two level commit.
         $this->assertFalse($DB->is_transaction_started());
         $transaction1 = $DB->start_delegated_transaction();
         $this->assertTrue($DB->is_transaction_started());
@@ -4409,7 +4397,7 @@ class core_dml_testcase extends database_driver_testcase {
 
         $DB->delete_records($tablename);
 
-        // rollback from top level
+        // Rollback from top level.
         $transaction1 = $DB->start_delegated_transaction();
         $data = (object)array('course'=>3);
         $DB->insert_record($tablename, $data);
@@ -4427,7 +4415,7 @@ class core_dml_testcase extends database_driver_testcase {
 
         $DB->delete_records($tablename);
 
-        // rollback from nested level
+        // Rollback from nested level.
         $transaction1 = $DB->start_delegated_transaction();
         $data = (object)array('course'=>3);
         $DB->insert_record($tablename, $data);
@@ -4440,19 +4428,19 @@ class core_dml_testcase extends database_driver_testcase {
         } catch (Exception $e) {
             $this->assertEquals(get_class($e), 'Exception');
         }
-        $this->assertEquals(2, $DB->count_records($tablename)); // not rolled back yet
+        $this->assertEquals(2, $DB->count_records($tablename)); // Not rolled back yet.
         try {
             $transaction1->allow_commit();
-        } catch (Exception $e) {
-            $this->assertEquals(get_class($e), 'dml_transaction_exception');
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('dml_transaction_exception', $e);
         }
-        $this->assertEquals(2, $DB->count_records($tablename)); // not rolled back yet
-        // the forced rollback is done from the default_exception handler and similar places,
-        // let's do it manually here
+        $this->assertEquals(2, $DB->count_records($tablename)); // Not rolled back yet.
+        // The forced rollback is done from the default_exception handler and similar places,
+        // let's do it manually here.
         $this->assertTrue($DB->is_transaction_started());
         $DB->force_transaction_rollback();
         $this->assertFalse($DB->is_transaction_started());
-        $this->assertEquals(0, $DB->count_records($tablename)); // finally rolled back
+        $this->assertEquals(0, $DB->count_records($tablename)); // Finally rolled back.
 
         $DB->delete_records($tablename);
 
@@ -4460,8 +4448,8 @@ class core_dml_testcase extends database_driver_testcase {
         $table2 = $this->get_test_table('2');
         $tablename2 = $table2->getName();
 
-        $table2->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table2->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table2->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table2->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table2->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table2);
 
@@ -4523,15 +4511,15 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertEquals(3, $i);
     }
 
-    function test_transactions_forbidden() {
+    public function test_transactions_forbidden() {
         $DB = $this->tdb;
         $dbman = $DB->get_manager();
 
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
@@ -4541,29 +4529,28 @@ class core_dml_testcase extends database_driver_testcase {
         $DB->insert_record($tablename, $data);
         try {
             $DB->transactions_forbidden();
-        } catch (Exception $e) {
-            $this->assertEquals(get_class($e), 'dml_transaction_exception');
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('dml_transaction_exception', $e);
         }
-        // the previous test does not force rollback
+        // The previous test does not force rollback.
         $transaction->allow_commit();
         $this->assertFalse($DB->is_transaction_started());
         $this->assertEquals(1, $DB->count_records($tablename));
     }
 
-    function test_wrong_transactions() {
+    public function test_wrong_transactions() {
         $DB = $this->tdb;
         $dbman = $DB->get_manager();
 
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
-
-        // wrong order of nested commits
+        // Wrong order of nested commits.
         $transaction1 = $DB->start_delegated_transaction();
         $data = (object)array('course'=>3);
         $DB->insert_record($tablename, $data);
@@ -4573,24 +4560,23 @@ class core_dml_testcase extends database_driver_testcase {
         try {
             $transaction1->allow_commit();
             $this->fail('wrong order of commits must throw exception');
-        } catch (Exception $e) {
-            $this->assertEquals(get_class($e), 'dml_transaction_exception');
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('dml_transaction_exception', $e);
         }
         try {
             $transaction2->allow_commit();
             $this->fail('first wrong commit forces rollback');
-        } catch (Exception $e) {
-            $this->assertEquals(get_class($e), 'dml_transaction_exception');
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('dml_transaction_exception', $e);
         }
-        // this is done in default exception handler usually
+        // This is done in default exception handler usually.
         $this->assertTrue($DB->is_transaction_started());
-        $this->assertEquals(2, $DB->count_records($tablename)); // not rolled back yet
+        $this->assertEquals(2, $DB->count_records($tablename)); // Not rolled back yet.
         $DB->force_transaction_rollback();
         $this->assertEquals(0, $DB->count_records($tablename));
         $DB->delete_records($tablename);
 
-
-        // wrong order of nested rollbacks
+        // Wrong order of nested rollbacks.
         $transaction1 = $DB->start_delegated_transaction();
         $data = (object)array('course'=>3);
         $DB->insert_record($tablename, $data);
@@ -4598,7 +4584,7 @@ class core_dml_testcase extends database_driver_testcase {
         $data = (object)array('course'=>4);
         $DB->insert_record($tablename, $data);
         try {
-            // this first rollback should prevent all other rollbacks
+            // This first rollback should prevent all other rollbacks.
             $transaction1->rollback(new Exception('test'));
         } catch (Exception $e) {
             $this->assertEquals(get_class($e), 'Exception');
@@ -4610,17 +4596,15 @@ class core_dml_testcase extends database_driver_testcase {
         }
         try {
             $transaction1->rollback(new Exception('test'));
-        } catch (Exception $e) {
-            // the rollback was used already once, no way to use it again
-            $this->assertEquals(get_class($e), 'dml_transaction_exception');
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('dml_transaction_exception', $e);
         }
-        // this is done in default exception handler usually
+        // This is done in default exception handler usually.
         $this->assertTrue($DB->is_transaction_started());
         $DB->force_transaction_rollback();
         $DB->delete_records($tablename);
 
-
-        // unknown transaction object
+        // Unknown transaction object.
         $transaction1 = $DB->start_delegated_transaction();
         $data = (object)array('course'=>3);
         $DB->insert_record($tablename, $data);
@@ -4628,20 +4612,20 @@ class core_dml_testcase extends database_driver_testcase {
         try {
             $transaction2->allow_commit();
             $this->fail('foreign transaction must fail');
-        } catch (Exception $e) {
-            $this->assertEquals(get_class($e), 'dml_transaction_exception');
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('dml_transaction_exception', $e);
         }
         try {
             $transaction1->allow_commit();
             $this->fail('first wrong commit forces rollback');
-        } catch (Exception $e) {
-            $this->assertEquals(get_class($e), 'dml_transaction_exception');
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('dml_transaction_exception', $e);
         }
         $DB->force_transaction_rollback();
         $DB->delete_records($tablename);
     }
 
-    function test_concurent_transactions() {
+    public function test_concurent_transactions() {
         // Notes about this test:
         // 1- MySQL needs to use one engine with transactions support (InnoDB).
         // 2- MSSQL needs to have enabled versioning for read committed
@@ -4652,8 +4636,8 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
@@ -4663,7 +4647,7 @@ class core_dml_testcase extends database_driver_testcase {
         $DB->insert_record($tablename, $data);
         $this->assertEquals(1, $DB->count_records($tablename));
 
-        //open second connection
+        // Open second connection.
         $cfg = $DB->export_dbconfig();
         if (!isset($cfg->dboptions)) {
             $cfg->dboptions = array();
@@ -4671,35 +4655,35 @@ class core_dml_testcase extends database_driver_testcase {
         $DB2 = moodle_database::get_driver_instance($cfg->dbtype, $cfg->dblibrary);
         $DB2->connect($cfg->dbhost, $cfg->dbuser, $cfg->dbpass, $cfg->dbname, $cfg->prefix, $cfg->dboptions);
 
-        // second instance should not see pending inserts
+        // Second instance should not see pending inserts.
         $this->assertEquals(0, $DB2->count_records($tablename));
         $data = (object)array('course'=>2);
         $DB2->insert_record($tablename, $data);
         $this->assertEquals(1, $DB2->count_records($tablename));
 
-        // first should see the changes done from second
+        // First should see the changes done from second.
         $this->assertEquals(2, $DB->count_records($tablename));
 
-        // now commit and we should see it finally in second connections
+        // Now commit and we should see it finally in second connections.
         $transaction->allow_commit();
         $this->assertEquals(2, $DB2->count_records($tablename));
 
-        // let's try delete all is also working on (this checks MDL-29198)
-        // initially both connections see all the records in the table (2)
+        // Let's try delete all is also working on (this checks MDL-29198).
+        // Initially both connections see all the records in the table (2).
         $this->assertEquals(2, $DB->count_records($tablename));
         $this->assertEquals(2, $DB2->count_records($tablename));
         $transaction = $DB->start_delegated_transaction();
 
-        // delete all from within transaction
+        // Delete all from within transaction.
         $DB->delete_records($tablename);
 
-        // transactional $DB, sees 0 records now
+        // Transactional $DB, sees 0 records now.
         $this->assertEquals(0, $DB->count_records($tablename));
 
-        // others ($DB2) get no changes yet
+        // Others ($DB2) get no changes yet.
         $this->assertEquals(2, $DB2->count_records($tablename));
 
-        // now commit and we should see changes
+        // Now commit and we should see changes.
         $transaction->allow_commit();
         $this->assertEquals(0, $DB2->count_records($tablename));
 
@@ -4710,7 +4694,7 @@ class core_dml_testcase extends database_driver_testcase {
         $DB = $this->tdb;
         $dbman = $DB->get_manager();
 
-        // Open second connection
+        // Open second connection.
         $cfg = $DB->export_dbconfig();
         if (!isset($cfg->dboptions)) {
             $cfg->dboptions = array();
@@ -4718,33 +4702,33 @@ class core_dml_testcase extends database_driver_testcase {
         $DB2 = moodle_database::get_driver_instance($cfg->dbtype, $cfg->dblibrary);
         $DB2->connect($cfg->dbhost, $cfg->dbuser, $cfg->dbpass, $cfg->dbname, $cfg->prefix, $cfg->dboptions);
 
-        // Testing that acquiring a lock effectively locks
-        // Get a session lock on connection1
+        // Testing that acquiring a lock effectively locks.
+        // Get a session lock on connection1.
         $rowid = rand(100, 200);
         $timeout = 1;
         $DB->get_session_lock($rowid, $timeout);
 
-        // Try to get the same session lock on connection2
+        // Try to get the same session lock on connection2.
         try {
             $DB2->get_session_lock($rowid, $timeout);
-            $DB2->release_session_lock($rowid); // Should not be executed, but here for safety
+            $DB2->release_session_lock($rowid); // Should not be executed, but here for safety.
             $this->fail('An Exception is missing, expected due to session lock acquired.');
-        } catch (exception $e) {
-            $this->assertTrue($e instanceof dml_sessionwait_exception);
-            $DB->release_session_lock($rowid); // Release lock on connection1
+        } catch (moodle_exception $e) {
+            $this->assertInstanceOf('dml_sessionwait_exception', $e);
+            $DB->release_session_lock($rowid); // Release lock on connection1.
         }
 
-        // Testing that releasing a lock effectively frees
-        // Get a session lock on connection1
+        // Testing that releasing a lock effectively frees.
+        // Get a session lock on connection1.
         $rowid = rand(100, 200);
         $timeout = 1;
         $DB->get_session_lock($rowid, $timeout);
-        // Release the lock on connection1
+        // Release the lock on connection1.
         $DB->release_session_lock($rowid);
 
-        // Get the just released lock on connection2
+        // Get the just released lock on connection2.
         $DB2->get_session_lock($rowid, $timeout);
-        // Release the lock on connection2
+        // Release the lock on connection2.
         $DB2->release_session_lock($rowid);
 
         $DB2->dispose();
@@ -4757,9 +4741,9 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
         $table->add_field('name', XMLDB_TYPE_CHAR, '255', null, null, null, null);
-        $table->add_field('content', XMLDB_TYPE_TEXT, 'big', XMLDB_UNSIGNED, XMLDB_NOTNULL);
+        $table->add_field('content', XMLDB_TYPE_TEXT, 'big', null, XMLDB_NOTNULL);
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
@@ -4770,8 +4754,7 @@ class core_dml_testcase extends database_driver_testcase {
         $this->assertNotEmpty($DB->insert_record($tablename, array('name' => 'bb', 'content'=>2)));
         $this->assertNotEmpty($DB->insert_record($tablename, array('name' => 'cc', 'content'=>'sometext')));
 
-
-        // Conditions in CHAR columns
+        // Conditions in CHAR columns.
         $this->assertTrue($DB->record_exists($tablename, array('name'=>1)));
         $this->assertTrue($DB->record_exists($tablename, array('name'=>'1')));
         $this->assertFalse($DB->record_exists($tablename, array('name'=>111)));
@@ -4782,35 +4765,35 @@ class core_dml_testcase extends database_driver_testcase {
                     FROM {{$tablename}}
                    WHERE name = ?";
         $this->assertNotEmpty($records = $DB->get_records_sql($sqlqm, array(1)));
-        $this->assertEquals(1, count($records));
+        $this->assertCount(1, $records);
         $this->assertNotEmpty($records = $DB->get_records_sql($sqlqm, array('1')));
-        $this->assertEquals(1, count($records));
+        $this->assertCount(1, $records);
         $records = $DB->get_records_sql($sqlqm, array(222));
-        $this->assertEquals(0, count($records));
+        $this->assertCount(0, $records);
         $sqlnamed = "SELECT *
                        FROM {{$tablename}}
                       WHERE name = :name";
         $this->assertNotEmpty($records = $DB->get_records_sql($sqlnamed, array('name' => 2)));
-        $this->assertEquals(1, count($records));
+        $this->assertCount(1, $records);
         $this->assertNotEmpty($records = $DB->get_records_sql($sqlnamed, array('name' => '2')));
-        $this->assertEquals(1, count($records));
+        $this->assertCount(1, $records);
 
         // Conditions in TEXT columns always must be performed with the sql_compare_text
-        // helper function on both sides of the condition
+        // helper function on both sides of the condition.
         $sqlqm = "SELECT *
                     FROM {{$tablename}}
                    WHERE " . $DB->sql_compare_text('content') . " =  " . $DB->sql_compare_text('?');
         $this->assertNotEmpty($records = $DB->get_records_sql($sqlqm, array('1')));
-        $this->assertEquals(1, count($records));
+        $this->assertCount(1, $records);
         $this->assertNotEmpty($records = $DB->get_records_sql($sqlqm, array(1)));
-        $this->assertEquals(1, count($records));
+        $this->assertCount(1, $records);
         $sqlnamed = "SELECT *
                        FROM {{$tablename}}
                       WHERE " . $DB->sql_compare_text('content') . " =  " . $DB->sql_compare_text(':content');
         $this->assertNotEmpty($records = $DB->get_records_sql($sqlnamed, array('content' => 2)));
-        $this->assertEquals(1, count($records));
+        $this->assertCount(1, $records);
         $this->assertNotEmpty($records = $DB->get_records_sql($sqlnamed, array('content' => '2')));
-        $this->assertEquals(1, count($records));
+        $this->assertCount(1, $records);
     }
 
     public function test_bound_param_reserved() {
@@ -4820,14 +4803,14 @@ class core_dml_testcase extends database_driver_testcase {
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
-        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
         $DB->insert_record($tablename, array('course' => '1'));
 
-        // make sure reserved words do not cause fatal problems in query parameters
+        // Make sure reserved words do not cause fatal problems in query parameters.
 
         $DB->execute("UPDATE {{$tablename}} SET course = 1 WHERE id = :select", array('select'=>1));
         $DB->get_records_sql("SELECT * FROM {{$tablename}} WHERE course = :select", array('select'=>1));
@@ -4837,7 +4820,7 @@ class core_dml_testcase extends database_driver_testcase {
         $DB->set_field_select($tablename, 'course', '1', "id = :select", array('select'=>1));
         $DB->delete_records_select($tablename, "id = :select", array('select'=>1));
 
-        // if we get here test passed ok
+        // If we get here test passed ok.
         $this->assertTrue(true);
     }
 
@@ -4845,14 +4828,12 @@ class core_dml_testcase extends database_driver_testcase {
         $DB = $this->tdb;
         $dbman = $DB->get_manager();
 
-        if (false) $DB = new moodle_database ();
-
         $table = $this->get_test_table();
         $tablename = $table->getName();
 
-        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
+        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
         $table->add_field('name', XMLDB_TYPE_CHAR, '255', null, null, null, null);
-        $table->add_field('content', XMLDB_TYPE_TEXT, 'big', XMLDB_UNSIGNED, XMLDB_NOTNULL);
+        $table->add_field('content', XMLDB_TYPE_TEXT, 'big', null, XMLDB_NOTNULL);
         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
         $dbman->create_table($table);
 
@@ -4866,9 +4847,9 @@ class core_dml_testcase extends database_driver_testcase {
         $sqlqm = "SELECT *
                     FROM {{$tablename}}";
         $this->assertNotEmpty($records = $DB->get_records_sql($sqlqm, null, 4));
-        $this->assertEquals(2, count($records));
-        $this->assertEquals('e', reset($records)->name);
-        $this->assertEquals('f', end($records)->name);
+        $this->assertCount(2, $records);
+        $this->assertSame('e', reset($records)->name);
+        $this->assertSame('f', end($records)->name);
 
         $sqlqm = "SELECT *
                     FROM {{$tablename}}";
@@ -4877,58 +4858,58 @@ class core_dml_testcase extends database_driver_testcase {
         $sqlqm = "SELECT *
                     FROM {{$tablename}}";
         $this->assertNotEmpty($records = $DB->get_records_sql($sqlqm, null, 0, 4));
-        $this->assertEquals(4, count($records));
-        $this->assertEquals('a', reset($records)->name);
-        $this->assertEquals('d', end($records)->name);
+        $this->assertCount(4, $records);
+        $this->assertSame('a', reset($records)->name);
+        $this->assertSame('d', end($records)->name);
 
         $sqlqm = "SELECT *
                     FROM {{$tablename}}";
         $this->assertNotEmpty($records = $DB->get_records_sql($sqlqm, null, 0, 8));
-        $this->assertEquals(6, count($records));
-        $this->assertEquals('a', reset($records)->name);
-        $this->assertEquals('f', end($records)->name);
+        $this->assertCount(6, $records);
+        $this->assertSame('a', reset($records)->name);
+        $this->assertSame('f', end($records)->name);
 
         $sqlqm = "SELECT *
                     FROM {{$tablename}}";
         $this->assertNotEmpty($records = $DB->get_records_sql($sqlqm, null, 1, 4));
-        $this->assertEquals(4, count($records));
-        $this->assertEquals('b', reset($records)->name);
-        $this->assertEquals('e', end($records)->name);
+        $this->assertCount(4, $records);
+        $this->assertSame('b', reset($records)->name);
+        $this->assertSame('e', end($records)->name);
 
         $sqlqm = "SELECT *
                     FROM {{$tablename}}";
         $this->assertNotEmpty($records = $DB->get_records_sql($sqlqm, null, 4, 4));
-        $this->assertEquals(2, count($records));
-        $this->assertEquals('e', reset($records)->name);
-        $this->assertEquals('f', end($records)->name);
+        $this->assertCount(2, $records);
+        $this->assertSame('e', reset($records)->name);
+        $this->assertSame('f', end($records)->name);
 
         $sqlqm = "SELECT t.*, t.name AS test
                     FROM {{$tablename}} t
                     ORDER BY t.id ASC";
         $this->assertNotEmpty($records = $DB->get_records_sql($sqlqm, null, 4, 4));
-        $this->assertEquals(2, count($records));
-        $this->assertEquals('e', reset($records)->name);
-        $this->assertEquals('f', end($records)->name);
+        $this->assertCount(2, $records);
+        $this->assertSame('e', reset($records)->name);
+        $this->assertSame('f', end($records)->name);
 
         $sqlqm = "SELECT DISTINCT t.name, t.name AS test
                     FROM {{$tablename}} t
                     ORDER BY t.name DESC";
         $this->assertNotEmpty($records = $DB->get_records_sql($sqlqm, null, 4, 4));
-        $this->assertEquals(2, count($records));
-        $this->assertEquals('b', reset($records)->name);
-        $this->assertEquals('a', end($records)->name);
+        $this->assertCount(2, $records);
+        $this->assertSame('b', reset($records)->name);
+        $this->assertSame('a', end($records)->name);
 
         $sqlqm = "SELECT 1
                     FROM {{$tablename}} t
                     WHERE t.name = 'a'";
         $this->assertNotEmpty($records = $DB->get_records_sql($sqlqm, null, 0, 1));
-        $this->assertEquals(1, count($records));
+        $this->assertCount(1, $records);
 
         $sqlqm = "SELECT 'constant'
                     FROM {{$tablename}} t
                     WHERE t.name = 'a'";
         $this->assertNotEmpty($records = $DB->get_records_sql($sqlqm, null, 0, 8));
-        $this->assertEquals(1, count($records));
+        $this->assertCount(1, $records);
 
         $this->assertNotEmpty($DB->insert_record($tablename, array('name' => 'a', 'content'=>'one')));
         $this->assertNotEmpty($DB->insert_record($tablename, array('name' => 'b', 'content'=>'two')));
@@ -4943,12 +4924,12 @@ class core_dml_testcase extends database_driver_testcase {
                     GROUP BY t.name
                     ORDER BY t.name ASC";
         $this->assertNotEmpty($records = $DB->get_records_sql($sqlqm));
-        $this->assertEquals(6, count($records));         // a,b,c,d,e,f
-        $this->assertEquals(2, reset($records)->count);  // a has 2 records now
-        $this->assertEquals(1, end($records)->count);    // f has 1 record still
+        $this->assertCount(6, $records);         // a,b,c,d,e,f.
+        $this->assertEquals(2, reset($records)->count);  // a has 2 records now.
+        $this->assertEquals(1, end($records)->count);    // f has 1 record still.
 
         $this->assertNotEmpty($records = $DB->get_records_sql($sqlqm, null, 0, 2));
-        $this->assertEquals(2, count($records));
+        $this->assertCount(2, $records);
         $this->assertEquals(2, reset($records)->count);
         $this->assertEquals(2, end($records)->count);
     }
@@ -4966,38 +4947,38 @@ class moodle_database_for_testing extends moodle_database {
         return $this->fix_table_names($sql);
     }
 
-    public function driver_installed(){}
-    public function get_dbfamily(){}
-    protected function get_dbtype(){}
-    protected function get_dblibrary(){}
-    public function get_name(){}
-    public function get_configuration_help(){}
-    public function connect($dbhost, $dbuser, $dbpass, $dbname, $prefix, array $dboptions=null){}
-    public function get_server_info(){}
-    protected function allowed_param_types(){}
-    public function get_last_error(){}
-    public function get_tables($usecache=true){}
-    public function get_indexes($table){}
-    public function get_columns($table, $usecache=true){}
-    protected function normalise_value($column, $value){}
-    public function set_debug($state){}
-    public function get_debug(){}
-    public function set_logging($state){}
-    public function change_database_structure($sql){}
-    public function execute($sql, array $params=null){}
-    public function get_recordset_sql($sql, array $params=null, $limitfrom=0, $limitnum=0){}
-    public function get_records_sql($sql, array $params=null, $limitfrom=0, $limitnum=0){}
-    public function get_fieldset_sql($sql, array $params=null){}
-    public function insert_record_raw($table, $params, $returnid=true, $bulk=false, $customsequence=false){}
-    public function insert_record($table, $dataobject, $returnid=true, $bulk=false){}
-    public function import_record($table, $dataobject){}
-    public function update_record_raw($table, $params, $bulk=false){}
-    public function update_record($table, $dataobject, $bulk=false){}
-    public function set_field_select($table, $newfield, $newvalue, $select, array $params=null){}
-    public function delete_records_select($table, $select, array $params=null){}
-    public function sql_concat(){}
-    public function sql_concat_join($separator="' '", $elements=array()){}
-    public function sql_substr($expr, $start, $length=false){}
+    public function driver_installed() {}
+    public function get_dbfamily() {}
+    protected function get_dbtype() {}
+    protected function get_dblibrary() {}
+    public function get_name() {}
+    public function get_configuration_help() {}
+    public function connect($dbhost, $dbuser, $dbpass, $dbname, $prefix, array $dboptions=null) {}
+    public function get_server_info() {}
+    protected function allowed_param_types() {}
+    public function get_last_error() {}
+    public function get_tables($usecache=true) {}
+    public function get_indexes($table) {}
+    public function get_columns($table, $usecache=true) {}
+    protected function normalise_value($column, $value) {}
+    public function set_debug($state) {}
+    public function get_debug() {}
+    public function set_logging($state) {}
+    public function change_database_structure($sql) {}
+    public function execute($sql, array $params=null) {}
+    public function get_recordset_sql($sql, array $params=null, $limitfrom=0, $limitnum=0) {}
+    public function get_records_sql($sql, array $params=null, $limitfrom=0, $limitnum=0) {}
+    public function get_fieldset_sql($sql, array $params=null) {}
+    public function insert_record_raw($table, $params, $returnid=true, $bulk=false, $customsequence=false) {}
+    public function insert_record($table, $dataobject, $returnid=true, $bulk=false) {}
+    public function import_record($table, $dataobject) {}
+    public function update_record_raw($table, $params, $bulk=false) {}
+    public function update_record($table, $dataobject, $bulk=false) {}
+    public function set_field_select($table, $newfield, $newvalue, $select, array $params=null) {}
+    public function delete_records_select($table, $select, array $params=null) {}
+    public function sql_concat() {}
+    public function sql_concat_join($separator="' '", $elements=array()) {}
+    public function sql_substr($expr, $start, $length=false) {}
     public function begin_transaction() {}
     public function commit_transaction() {}
     public function rollback_transaction() {}