Drupal
/
drupal
mirror of https://git.drupalcode.org/project/drupal.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Issue #1794012 by Lars Toomre: Remove use of t function from test assertion messages

8.0.x
Jennifer Hodgdon 2012-09-27 09:04:48 -07:00
parent 0790cd975b
commit f988a548f8
31 changed files with 346 additions and 346 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
core/modules/system/lib/Drupal/system/Tests/Database/AlterTest.php
View File

@ -38,7 +38,7 @@ class AlterTest extends DatabaseTestBase {
$num_records++;
}
$this->assertEqual($num_records, 2, t('Returned the correct number of rows.'));
$this->assertEqual($num_records, 2, 'Returned the correct number of rows.');
}
/**
@ -55,14 +55,14 @@ class AlterTest extends DatabaseTestBase {
$records = $result->fetchAll();
$this->assertEqual(count($records), 2, t('Returned the correct number of rows.'));
$this->assertEqual(count($records), 2, 'Returned the correct number of rows.');
$this->assertEqual($records[0]->name, 'George', t('Correct data retrieved.'));
$this->assertEqual($records[0]->$tid_field, 4, t('Correct data retrieved.'));
$this->assertEqual($records[0]->$task_field, 'sing', t('Correct data retrieved.'));
$this->assertEqual($records[1]->name, 'George', t('Correct data retrieved.'));
$this->assertEqual($records[1]->$tid_field, 5, t('Correct data retrieved.'));
$this->assertEqual($records[1]->$task_field, 'sleep', t('Correct data retrieved.'));
$this->assertEqual($records[0]->name, 'George', 'Correct data retrieved.');
$this->assertEqual($records[0]->$tid_field, 4, 'Correct data retrieved.');
$this->assertEqual($records[0]->$task_field, 'sing', 'Correct data retrieved.');
$this->assertEqual($records[1]->name, 'George', 'Correct data retrieved.');
$this->assertEqual($records[1]->$tid_field, 5, 'Correct data retrieved.');
$this->assertEqual($records[1]->$task_field, 'sleep', 'Correct data retrieved.');
}
/**
@ -83,11 +83,11 @@ class AlterTest extends DatabaseTestBase {
$records = $result->fetchAll();
$this->assertEqual(count($records), 1, t('Returned the correct number of rows.'));
$this->assertEqual($records[0]->$name_field, 'John', t('Correct data retrieved.'));
$this->assertEqual($records[0]->$tid_field, 2, t('Correct data retrieved.'));
$this->assertEqual($records[0]->$pid_field, 1, t('Correct data retrieved.'));
$this->assertEqual($records[0]->$task_field, 'sleep', t('Correct data retrieved.'));
$this->assertEqual(count($records), 1, 'Returned the correct number of rows.');
$this->assertEqual($records[0]->$name_field, 'John', 'Correct data retrieved.');
$this->assertEqual($records[0]->$tid_field, 2, 'Correct data retrieved.');
$this->assertEqual($records[0]->$pid_field, 1, 'Correct data retrieved.');
$this->assertEqual($records[0]->$task_field, 'sleep', 'Correct data retrieved.');
}
/**
@ -101,8 +101,8 @@ class AlterTest extends DatabaseTestBase {
$query->addTag('database_test_alter_change_fields');
$record = $query->execute()->fetch();
$this->assertEqual($record->$name_field, 'George', t('Correct data retrieved.'));
$this->assertFalse(isset($record->$age_field), t('Age field not found, as intended.'));
$this->assertEqual($record->$name_field, 'George', 'Correct data retrieved.');
$this->assertFalse(isset($record->$age_field), 'Age field not found, as intended.');
}
/**
@ -119,8 +119,8 @@ class AlterTest extends DatabaseTestBase {
// Ensure that we got the right record.
$record = $result->fetch();
$this->assertEqual($record->$name_field, 'George', t('Fetched name is correct.'));
$this->assertEqual($record->$age_field, 27*3, t('Fetched age expression is correct.'));
$this->assertEqual($record->$name_field, 'George', 'Fetched name is correct.');
$this->assertEqual($record->$age_field, 27*3, 'Fetched age expression is correct.');
}
/**
@ -135,7 +135,7 @@ class AlterTest extends DatabaseTestBase {
$num_records = count($query->execute()->fetchAll());
$this->assertEqual($num_records, 4, t('Returned the correct number of rows.'));
$this->assertEqual($num_records, 4, 'Returned the correct number of rows.');
}
/**
@ -159,7 +159,7 @@ class AlterTest extends DatabaseTestBase {
$name_field = $query->addField('pq', 'name');
$record = $query->execute()->fetch();
$this->assertEqual($record->$name_field, 'George', t('Fetched name is correct.'));
$this->assertEqual($record->$age_field, 27*3, t('Fetched age expression is correct.'));
$this->assertEqual($record->$name_field, 'George', 'Fetched name is correct.');
$this->assertEqual($record->$age_field, 27*3, 'Fetched age expression is correct.');
}
}

12
core/modules/system/lib/Drupal/system/Tests/Database/BasicSyntaxTest.php
View File

@ -34,7 +34,7 @@ class BasicSyntaxTest extends DatabaseTestBase {
':a4' => ' a ',
':a5' => 'test.',
));
$this->assertIdentical($result->fetchField(), 'This is a test.', t('Basic CONCAT works.'));
$this->assertIdentical($result->fetchField(), 'This is a test.', 'Basic CONCAT works.');
}
/**
@ -47,7 +47,7 @@ class BasicSyntaxTest extends DatabaseTestBase {
':a3' => '.',
':age' => 25,
));
$this->assertIdentical($result->fetchField(), 'The age of John is 25.', t('Field CONCAT works.'));
$this->assertIdentical($result->fetchField(), 'The age of John is 25.', 'Field CONCAT works.');
}
/**
@ -66,14 +66,14 @@ class BasicSyntaxTest extends DatabaseTestBase {
->countQuery()
->execute()
->fetchField();
$this->assertIdentical($num_matches, '2', t('Found 2 records.'));
$this->assertIdentical($num_matches, '2', 'Found 2 records.');
// Match only "Ring_" using a LIKE expression with no wildcards.
$num_matches = db_select('test', 't')
->condition('name', db_like('Ring_'), 'LIKE')
->countQuery()
->execute()
->fetchField();
$this->assertIdentical($num_matches, '1', t('Found 1 record.'));
$this->assertIdentical($num_matches, '1', 'Found 1 record.');
}
/**
@ -97,13 +97,13 @@ class BasicSyntaxTest extends DatabaseTestBase {
->countQuery()
->execute()
->fetchField();
$this->assertIdentical($num_matches, '2', t('Found 2 records.'));
$this->assertIdentical($num_matches, '2', 'Found 2 records.');
// Match only the former using a LIKE expression with no wildcards.
$num_matches = db_select('test', 't')
->condition('name', db_like('abc%\_'), 'LIKE')
->countQuery()
->execute()
->fetchField();
$this->assertIdentical($num_matches, '1', t('Found 1 record.'));
$this->assertIdentical($num_matches, '1', 'Found 1 record.');
}
}

4
core/modules/system/lib/Drupal/system/Tests/Database/CaseSensitivityTest.php
View File

@ -34,8 +34,8 @@ class CaseSensitivityTest extends DatabaseTestBase {
->execute();
$num_records_after = db_query('SELECT COUNT(*) FROM {test}')->fetchField();
$this->assertIdentical($num_records_before + 1, (int) $num_records_after, t('Record inserts correctly.'));
$this->assertIdentical($num_records_before + 1, (int) $num_records_after, 'Record inserts correctly.');
$saved_age = db_query('SELECT age FROM {test} WHERE name = :name', array(':name' => 'john'))->fetchField();
$this->assertIdentical($saved_age, '2', t('Can retrieve after inserting.'));
$this->assertIdentical($saved_age, '2', 'Can retrieve after inserting.');
}
}

28
core/modules/system/lib/Drupal/system/Tests/Database/ConnectionTest.php
View File

@ -35,25 +35,25 @@ class ConnectionTest extends DatabaseTestBase {
$db1 = Database::getConnection('default', 'default');
$db2 = Database::getConnection('slave', 'default');
$this->assertNotNull($db1, t('default connection is a real connection object.'));
$this->assertNotNull($db2, t('slave connection is a real connection object.'));
$this->assertNotIdentical($db1, $db2, t('Each target refers to a different connection.'));
$this->assertNotNull($db1, 'default connection is a real connection object.');
$this->assertNotNull($db2, 'slave connection is a real connection object.');
$this->assertNotIdentical($db1, $db2, 'Each target refers to a different connection.');
// Try to open those targets another time, that should return the same objects.
$db1b = Database::getConnection('default', 'default');
$db2b = Database::getConnection('slave', 'default');
$this->assertIdentical($db1, $db1b, t('A second call to getConnection() returns the same object.'));
$this->assertIdentical($db2, $db2b, t('A second call to getConnection() returns the same object.'));
$this->assertIdentical($db1, $db1b, 'A second call to getConnection() returns the same object.');
$this->assertIdentical($db2, $db2b, 'A second call to getConnection() returns the same object.');
// Try to open an unknown target.
$unknown_target = $this->randomName();
$db3 = Database::getConnection($unknown_target, 'default');
$this->assertNotNull($db3, t('Opening an unknown target returns a real connection object.'));
$this->assertIdentical($db1, $db3, t('An unknown target opens the default connection.'));
$this->assertNotNull($db3, 'Opening an unknown target returns a real connection object.');
$this->assertIdentical($db1, $db3, 'An unknown target opens the default connection.');
// Try to open that unknown target another time, that should return the same object.
$db3b = Database::getConnection($unknown_target, 'default');
$this->assertIdentical($db3, $db3b, t('A second call to getConnection() returns the same object.'));
$this->assertIdentical($db3, $db3b, 'A second call to getConnection() returns the same object.');
}
/**
@ -71,7 +71,7 @@ class ConnectionTest extends DatabaseTestBase {
$db1 = Database::getConnection('default', 'default');
$db2 = Database::getConnection('slave', 'default');
$this->assertIdentical($db1, $db2, t('Both targets refer to the same connection.'));
$this->assertIdentical($db1, $db2, 'Both targets refer to the same connection.');
}
/**
@ -86,7 +86,7 @@ class ConnectionTest extends DatabaseTestBase {
$db2 = Database::getConnection('default', 'default');
// Opening a connection after closing it should yield an object different than the original.
$this->assertNotIdentical($db1, $db2, t('Opening the default connection after it is closed returns a new object.'));
$this->assertNotIdentical($db1, $db2, 'Opening the default connection after it is closed returns a new object.');
}
/**
@ -101,8 +101,8 @@ class ConnectionTest extends DatabaseTestBase {
// In the MySQL driver, the port can be different, so check individual
// options.
$this->assertEqual($connection_info['default']['driver'], $connectionOptions['driver'], t('The default connection info driver matches the current connection options driver.'));
$this->assertEqual($connection_info['default']['database'], $connectionOptions['database'], t('The default connection info database matches the current connection options database.'));
$this->assertEqual($connection_info['default']['driver'], $connectionOptions['driver'], 'The default connection info driver matches the current connection options driver.');
$this->assertEqual($connection_info['default']['database'], $connectionOptions['database'], 'The default connection info database matches the current connection options database.');
// Set up identical slave and confirm connection options are identical.
Database::addConnectionInfo('default', 'slave', $connection_info['default']);
@ -111,7 +111,7 @@ class ConnectionTest extends DatabaseTestBase {
// Get a fresh copy of the default connection options.
$connectionOptions = $db->getConnectionOptions();
$this->assertIdentical($connectionOptions, $connectionOptions2, t('The default and slave connection options are identical.'));
$this->assertIdentical($connectionOptions, $connectionOptions2, 'The default and slave connection options are identical.');
// Set up a new connection with different connection info.
$test = $connection_info['default'];
@ -121,6 +121,6 @@ class ConnectionTest extends DatabaseTestBase {
// Get a fresh copy of the default connection options.
$connectionOptions = $db->getConnectionOptions();
$this->assertNotEqual($connection_info['default']['database'], $connectionOptions['database'], t('The test connection info database does not match the current connection options database.'));
$this->assertNotEqual($connection_info['default']['database'], $connectionOptions['database'], 'The test connection info database does not match the current connection options database.');
}
}

2
core/modules/system/lib/Drupal/system/Tests/Database/DatabaseTestBase.php
View File

@ -54,7 +54,7 @@ abstract class DatabaseTestBase extends WebTestBase {
}
foreach ($schema as $name => $data) {
$this->assertTrue(db_table_exists($name), t('Table @name created successfully.', array('@name' => $name)));
$this->assertTrue(db_table_exists($name), format_string('Table @name created successfully.', array('@name' => $name)));
}
}

10
core/modules/system/lib/Drupal/system/Tests/Database/DeleteTruncateTest.php
View File

@ -43,10 +43,10 @@ class DeleteTruncateTest extends DatabaseTestBase {
->condition('pid', $subquery, 'IN');
$num_deleted = $delete->execute();
$this->assertEqual($num_deleted, 1, t("Deleted 1 record."));
$this->assertEqual($num_deleted, 1, 'Deleted 1 record.');
$num_records_after = db_query('SELECT COUNT(*) FROM {test_task}')->fetchField();
$this->assertEqual($num_records_before, $num_records_after + $num_deleted, t('Deletion adds up.'));
$this->assertEqual($num_records_before, $num_records_after + $num_deleted, 'Deletion adds up.');
}
/**
@ -58,10 +58,10 @@ class DeleteTruncateTest extends DatabaseTestBase {
$num_deleted = db_delete('test')
->condition('id', 1)
->execute();
$this->assertIdentical($num_deleted, 1, t('Deleted 1 record.'));
$this->assertIdentical($num_deleted, 1, 'Deleted 1 record.');
$num_records_after = db_query('SELECT COUNT(*) FROM {test}')->fetchField();
$this->assertEqual($num_records_before, $num_records_after + $num_deleted, t('Deletion adds up.'));
$this->assertEqual($num_records_before, $num_records_after + $num_deleted, 'Deletion adds up.');
}
/**
@ -73,6 +73,6 @@ class DeleteTruncateTest extends DatabaseTestBase {
db_truncate('test')->execute();
$num_records_after = db_query("SELECT COUNT(*) FROM {test}")->fetchField();
$this->assertEqual(0, $num_records_after, t('Truncate really deletes everything.'));
$this->assertEqual(0, $num_records_after, 'Truncate really deletes everything.');
}
}

10
core/modules/system/lib/Drupal/system/Tests/Database/EmptyStatementTest.php
View File

@ -29,8 +29,8 @@ class EmptyStatementTest extends WebTestBase {
function testEmpty() {
$result = new StatementEmpty();
$this->assertTrue($result instanceof StatementInterface, t('Class implements expected interface'));
$this->assertNull($result->fetchObject(), t('Null result returned.'));
$this->assertTrue($result instanceof StatementInterface, 'Class implements expected interface');
$this->assertNull($result->fetchObject(), 'Null result returned.');
}
/**
@ -40,11 +40,11 @@ class EmptyStatementTest extends WebTestBase {
$result = new StatementEmpty();
foreach ($result as $record) {
$this->fail(t('Iterating empty result set should not iterate.'));
$this->fail('Iterating empty result set should not iterate.');
return;
}
$this->pass(t('Iterating empty result set skipped iteration.'));
$this->pass('Iterating empty result set skipped iteration.');
}
/**
@ -53,6 +53,6 @@ class EmptyStatementTest extends WebTestBase {
function testEmptyFetchAll() {
$result = new StatementEmpty();
$this->assertEqual($result->fetchAll(), array(), t('Empty array returned from empty result set.'));
$this->assertEqual($result->fetchAll(), array(), 'Empty array returned from empty result set.');
}
}

42
core/modules/system/lib/Drupal/system/Tests/Database/FetchTest.php
View File

@ -31,14 +31,14 @@ class FetchTest extends DatabaseTestBase {
function testQueryFetchDefault() {
$records = array();
$result = db_query('SELECT name FROM {test} WHERE age = :age', array(':age' => 25));
$this->assertTrue($result instanceof StatementInterface, t('Result set is a Drupal statement object.'));
$this->assertTrue($result instanceof StatementInterface, 'Result set is a Drupal statement object.');
foreach ($result as $record) {
$records[] = $record;
$this->assertTrue(is_object($record), t('Record is an object.'));
$this->assertIdentical($record->name, 'John', t('25 year old is John.'));
$this->assertTrue(is_object($record), 'Record is an object.');
$this->assertIdentical($record->name, 'John', '25 year old is John.');
}
$this->assertIdentical(count($records), 1, t('There is only one record.'));
$this->assertIdentical(count($records), 1, 'There is only one record.');
}
/**
@ -49,11 +49,11 @@ class FetchTest extends DatabaseTestBase {
$result = db_query('SELECT name FROM {test} WHERE age = :age', array(':age' => 25), array('fetch' => PDO::FETCH_OBJ));
foreach ($result as $record) {
$records[] = $record;
$this->assertTrue(is_object($record), t('Record is an object.'));
$this->assertIdentical($record->name, 'John', t('25 year old is John.'));
$this->assertTrue(is_object($record), 'Record is an object.');
$this->assertIdentical($record->name, 'John', '25 year old is John.');
}
$this->assertIdentical(count($records), 1, t('There is only one record.'));
$this->assertIdentical(count($records), 1, 'There is only one record.');
}
/**
@ -64,12 +64,12 @@ class FetchTest extends DatabaseTestBase {
$result = db_query('SELECT name FROM {test} WHERE age = :age', array(':age' => 25), array('fetch' => PDO::FETCH_ASSOC));
foreach ($result as $record) {
$records[] = $record;
if ($this->assertTrue(is_array($record), t('Record is an array.'))) {
$this->assertIdentical($record['name'], 'John', t('Record can be accessed associatively.'));
if ($this->assertTrue(is_array($record), 'Record is an array.')) {
$this->assertIdentical($record['name'], 'John', 'Record can be accessed associatively.');
}
}
$this->assertIdentical(count($records), 1, t('There is only one record.'));
$this->assertIdentical(count($records), 1, 'There is only one record.');
}
/**
@ -82,12 +82,12 @@ class FetchTest extends DatabaseTestBase {
$result = db_query('SELECT name FROM {test} WHERE age = :age', array(':age' => 25), array('fetch' => 'Drupal\system\Tests\Database\FakeRecord'));
foreach ($result as $record) {
$records[] = $record;
if ($this->assertTrue($record instanceof FakeRecord, t('Record is an object of class FakeRecord.'))) {
$this->assertIdentical($record->name, 'John', t('25 year old is John.'));
if ($this->assertTrue($record instanceof FakeRecord, 'Record is an object of class FakeRecord.')) {
$this->assertIdentical($record->name, 'John', '25 year old is John.');
}
}
$this->assertIdentical(count($records), 1, t('There is only one record.'));
$this->assertIdentical(count($records), 1, 'There is only one record.');
}
// Confirm that we can fetch a record into an indexed array explicitly.
@ -96,8 +96,8 @@ class FetchTest extends DatabaseTestBase {
$result = db_query('SELECT name FROM {test} WHERE age = :age', array(':age' => 25), array('fetch' => PDO::FETCH_NUM));
foreach ($result as $record) {
$records[] = $record;
if ($this->assertTrue(is_array($record), t('Record is an array.'))) {
$this->assertIdentical($record[0], 'John', t('Record can be accessed numerically.'));
if ($this->assertTrue(is_array($record), 'Record is an array.')) {
$this->assertIdentical($record[0], 'John', 'Record can be accessed numerically.');
}
}
@ -112,13 +112,13 @@ class FetchTest extends DatabaseTestBase {
$result = db_query('SELECT name FROM {test} WHERE age = :age', array(':age' => 25), array('fetch' => PDO::FETCH_BOTH));
foreach ($result as $record) {
$records[] = $record;
if ($this->assertTrue(is_array($record), t('Record is an array.'))) {
$this->assertIdentical($record[0], 'John', t('Record can be accessed numerically.'));
$this->assertIdentical($record['name'], 'John', t('Record can be accessed associatively.'));
if ($this->assertTrue(is_array($record), 'Record is an array.')) {
$this->assertIdentical($record[0], 'John', 'Record can be accessed numerically.');
$this->assertIdentical($record['name'], 'John', 'Record can be accessed associatively.');
}
}
$this->assertIdentical(count($records), 1, t('There is only one record.'));
$this->assertIdentical(count($records), 1, 'There is only one record.');
}
/**
@ -128,12 +128,12 @@ class FetchTest extends DatabaseTestBase {
$records = array();
$result = db_query('SELECT name FROM {test} WHERE age > :age', array(':age' => 25));
$column = $result->fetchCol();
$this->assertIdentical(count($column), 3, t('fetchCol() returns the right number of records.'));
$this->assertIdentical(count($column), 3, 'fetchCol() returns the right number of records.');
$result = db_query('SELECT name FROM {test} WHERE age > :age', array(':age' => 25));
$i = 0;
foreach ($result as $record) {
$this->assertIdentical($record->name, $column[$i++], t('Column matches direct accesss.'));
$this->assertIdentical($record->name, $column[$i++], 'Column matches direct accesss.');
}
}
}

10
core/modules/system/lib/Drupal/system/Tests/Database/InsertDefaultsTest.php
View File

@ -32,7 +32,7 @@ class InsertDefaultsTest extends DatabaseTestBase {
$schema = drupal_get_schema('test');
$job = db_query('SELECT job FROM {test} WHERE id = :id', array(':id' => $id))->fetchField();
$this->assertEqual($job, $schema['fields']['job']['default'], t('Default field value is set.'));
$this->assertEqual($job, $schema['fields']['job']['default'], 'Default field value is set.');
}
/**
@ -44,13 +44,13 @@ class InsertDefaultsTest extends DatabaseTestBase {
try {
$result = db_insert('test')->execute();
// This is only executed if no exception has been thrown.
$this->fail(t('Expected exception NoFieldsException has not been thrown.'));
$this->fail('Expected exception NoFieldsException has not been thrown.');
} catch (NoFieldsException $e) {
$this->pass(t('Expected exception NoFieldsException has been thrown.'));
$this->pass('Expected exception NoFieldsException has been thrown.');
}
$num_records_after = (int) db_query('SELECT COUNT(*) FROM {test}')->fetchField();
$this->assertIdentical($num_records_before, $num_records_after, t('Do nothing as no fields are specified.'));
$this->assertIdentical($num_records_before, $num_records_after, 'Do nothing as no fields are specified.');
}
/**
@ -65,6 +65,6 @@ class InsertDefaultsTest extends DatabaseTestBase {
$schema = drupal_get_schema('test');
$job = db_query('SELECT job FROM {test} WHERE id = :id', array(':id' => $id))->fetchField();
$this->assertEqual($job, $schema['fields']['job']['default'], t('Default field value is set.'));
$this->assertEqual($job, $schema['fields']['job']['default'], 'Default field value is set.');
}
}

6
core/modules/system/lib/Drupal/system/Tests/Database/InsertLobTest.php
View File

@ -25,12 +25,12 @@ class InsertLobTest extends DatabaseTestBase {
*/
function testInsertOneBlob() {
$data = "This is\000a test.";
$this->assertTrue(strlen($data) === 15, t('Test data contains a NULL.'));
$this->assertTrue(strlen($data) === 15, 'Test data contains a NULL.');
$id = db_insert('test_one_blob')
->fields(array('blob1' => $data))
->execute();
$r = db_query('SELECT * FROM {test_one_blob} WHERE id = :id', array(':id' => $id))->fetchAssoc();
$this->assertTrue($r['blob1'] === $data, t('Can insert a blob: id @id, @data.', array('@id' => $id, '@data' => serialize($r))));
$this->assertTrue($r['blob1'] === $data, format_string('Can insert a blob: id @id, @data.', array('@id' => $id, '@data' => serialize($r))));
}
/**
@ -44,6 +44,6 @@ class InsertLobTest extends DatabaseTestBase {
))
->execute();
$r = db_query('SELECT * FROM {test_two_blobs} WHERE id = :id', array(':id' => $id))->fetchAssoc();
$this->assertTrue($r['blob1'] === 'This is' && $r['blob2'] === 'a test', t('Can insert multiple blobs per row.'));
$this->assertTrue($r['blob1'] === 'This is' && $r['blob2'] === 'a test', 'Can insert multiple blobs per row.');
}
}

30
core/modules/system/lib/Drupal/system/Tests/Database/InsertTest.php
View File

@ -34,9 +34,9 @@ class InsertTest extends DatabaseTestBase {
$query->execute();
$num_records_after = db_query('SELECT COUNT(*) FROM {test}')->fetchField();
$this->assertIdentical($num_records_before + 1, (int) $num_records_after, t('Record inserts correctly.'));
$this->assertIdentical($num_records_before + 1, (int) $num_records_after, 'Record inserts correctly.');
$saved_age = db_query('SELECT age FROM {test} WHERE name = :name', array(':name' => 'Yoko'))->fetchField();
$this->assertIdentical($saved_age, '29', t('Can retrieve after inserting.'));
$this->assertIdentical($saved_age, '29', 'Can retrieve after inserting.');
}
/**
@ -63,13 +63,13 @@ class InsertTest extends DatabaseTestBase {
$query->execute();
$num_records_after = (int) db_query('SELECT COUNT(*) FROM {test}')->fetchField();
$this->assertIdentical($num_records_before + 3, $num_records_after, t('Record inserts correctly.'));
$this->assertIdentical($num_records_before + 3, $num_records_after, 'Record inserts correctly.');
$saved_age = db_query('SELECT age FROM {test} WHERE name = :name', array(':name' => 'Larry'))->fetchField();
$this->assertIdentical($saved_age, '30', t('Can retrieve after inserting.'));
$this->assertIdentical($saved_age, '30', 'Can retrieve after inserting.');
$saved_age = db_query('SELECT age FROM {test} WHERE name = :name', array(':name' => 'Curly'))->fetchField();
$this->assertIdentical($saved_age, '31', t('Can retrieve after inserting.'));
$this->assertIdentical($saved_age, '31', 'Can retrieve after inserting.');
$saved_age = db_query('SELECT age FROM {test} WHERE name = :name', array(':name' => 'Moe'))->fetchField();
$this->assertIdentical($saved_age, '32', t('Can retrieve after inserting.'));
$this->assertIdentical($saved_age, '32', 'Can retrieve after inserting.');
}
/**
@ -98,13 +98,13 @@ class InsertTest extends DatabaseTestBase {
$query->execute();
$num_records_after = db_query('SELECT COUNT(*) FROM {test}')->fetchField();
$this->assertIdentical((int) $num_records_before + 3, (int) $num_records_after, t('Record inserts correctly.'));
$this->assertIdentical((int) $num_records_before + 3, (int) $num_records_after, 'Record inserts correctly.');
$saved_age = db_query('SELECT age FROM {test} WHERE name = :name', array(':name' => 'Larry'))->fetchField();
$this->assertIdentical($saved_age, '30', t('Can retrieve after inserting.'));
$this->assertIdentical($saved_age, '30', 'Can retrieve after inserting.');
$saved_age = db_query('SELECT age FROM {test} WHERE name = :name', array(':name' => 'Curly'))->fetchField();
$this->assertIdentical($saved_age, '31', t('Can retrieve after inserting.'));
$this->assertIdentical($saved_age, '31', 'Can retrieve after inserting.');
$saved_age = db_query('SELECT age FROM {test} WHERE name = :name', array(':name' => 'Moe'))->fetchField();
$this->assertIdentical($saved_age, '32', t('Can retrieve after inserting.'));
$this->assertIdentical($saved_age, '32', 'Can retrieve after inserting.');
}
/**
@ -120,11 +120,11 @@ class InsertTest extends DatabaseTestBase {
->values(array('Moe', '32'))
->execute();
$saved_age = db_query('SELECT age FROM {test} WHERE name = :name', array(':name' => 'Larry'))->fetchField();
$this->assertIdentical($saved_age, '30', t('Can retrieve after inserting.'));
$this->assertIdentical($saved_age, '30', 'Can retrieve after inserting.');
$saved_age = db_query('SELECT age FROM {test} WHERE name = :name', array(':name' => 'Curly'))->fetchField();
$this->assertIdentical($saved_age, '31', t('Can retrieve after inserting.'));
$this->assertIdentical($saved_age, '31', 'Can retrieve after inserting.');
$saved_age = db_query('SELECT age FROM {test} WHERE name = :name', array(':name' => 'Moe'))->fetchField();
$this->assertIdentical($saved_age, '32', t('Can retrieve after inserting.'));
$this->assertIdentical($saved_age, '32', 'Can retrieve after inserting.');
}
/**
@ -138,7 +138,7 @@ class InsertTest extends DatabaseTestBase {
))
->execute();
$this->assertIdentical($id, '5', t('Auto-increment ID returned successfully.'));
$this->assertIdentical($id, '5', 'Auto-increment ID returned successfully.');
}
/**
@ -164,6 +164,6 @@ class InsertTest extends DatabaseTestBase {
->execute();
$saved_age = db_query('SELECT age FROM {test} WHERE name = :name', array(':name' => 'Meredith'))->fetchField();
$this->assertIdentical($saved_age, '30', t('Can retrieve after inserting.'));
$this->assertIdentical($saved_age, '30', 'Can retrieve after inserting.');
}
}

10
core/modules/system/lib/Drupal/system/Tests/Database/InvalidDataTest.php
View File

@ -44,7 +44,7 @@ class InvalidDataTest extends DatabaseTestBase {
'job' => 'Singer',
))
->execute();
$this->fail(t('Insert succeedded when it should not have.'));
$this->fail('Insert succeedded when it should not have.');
}
catch (Exception $e) {
// Check if the first record was inserted.
@ -56,14 +56,14 @@ class InvalidDataTest extends DatabaseTestBase {
// Database engines that don't support transactions can leave partial
// inserts in place when an error occurs. This is the case for MySQL
// when running on a MyISAM table.
$this->pass(t("The whole transaction has not been rolled-back when a duplicate key insert occurs, this is expected because the database doesn't support transactions"));
$this->pass("The whole transaction has not been rolled-back when a duplicate key insert occurs, this is expected because the database doesn't support transactions");
}
else {
$this->fail(t('The whole transaction is rolled back when a duplicate key insert occurs.'));
$this->fail('The whole transaction is rolled back when a duplicate key insert occurs.');
}
}
else {
$this->pass(t('The whole transaction is rolled back when a duplicate key insert occurs.'));
$this->pass('The whole transaction is rolled back when a duplicate key insert occurs.');
}
// Ensure the other values were not inserted.
@ -72,7 +72,7 @@ class InvalidDataTest extends DatabaseTestBase {
->condition('age', array(17, 75), 'IN')
->execute()->fetchObject();
$this->assertFalse($record, t('The rest of the insert aborted as expected.'));
$this->assertFalse($record, 'The rest of the insert aborted as expected.');
}
}

24
core/modules/system/lib/Drupal/system/Tests/Database/LoggingTest.php
View File

@ -36,10 +36,10 @@ class LoggingTest extends DatabaseTestBase {
$queries = Database::getLog('testing', 'default');
$this->assertEqual(count($queries), 3, t('Correct number of queries recorded.'));
$this->assertEqual(count($queries), 3, 'Correct number of queries recorded.');
foreach ($queries as $query) {
$this->assertEqual($query['caller']['function'], __FUNCTION__, t('Correct function in query log.'));
$this->assertEqual($query['caller']['function'], __FUNCTION__, 'Correct function in query log.');
}
}
@ -58,8 +58,8 @@ class LoggingTest extends DatabaseTestBase {
$queries1 = Database::getLog('testing1');
$queries2 = Database::getLog('testing2');
$this->assertEqual(count($queries1), 2, t('Correct number of queries recorded for log 1.'));
$this->assertEqual(count($queries2), 1, t('Correct number of queries recorded for log 2.'));
$this->assertEqual(count($queries1), 2, 'Correct number of queries recorded for log 1.');
$this->assertEqual(count($queries2), 1, 'Correct number of queries recorded for log 2.');
}
/**
@ -79,9 +79,9 @@ class LoggingTest extends DatabaseTestBase {
$queries1 = Database::getLog('testing1');
$this->assertEqual(count($queries1), 2, t('Recorded queries from all targets.'));
$this->assertEqual($queries1[0]['target'], 'default', t('First query used default target.'));
$this->assertEqual($queries1[1]['target'], 'slave', t('Second query used slave target.'));
$this->assertEqual(count($queries1), 2, 'Recorded queries from all targets.');
$this->assertEqual($queries1[0]['target'], 'default', 'First query used default target.');
$this->assertEqual($queries1[1]['target'], 'slave', 'Second query used slave target.');
}
/**
@ -105,9 +105,9 @@ class LoggingTest extends DatabaseTestBase {
$queries1 = Database::getLog('testing1');
$this->assertEqual(count($queries1), 2, t('Recorded queries from all targets.'));
$this->assertEqual($queries1[0]['target'], 'default', t('First query used default target.'));
$this->assertEqual($queries1[1]['target'], 'default', t('Second query used default target as fallback.'));
$this->assertEqual(count($queries1), 2, 'Recorded queries from all targets.');
$this->assertEqual($queries1[0]['target'], 'default', 'First query used default target.');
$this->assertEqual($queries1[1]['target'], 'default', 'Second query used default target as fallback.');
}
/**
@ -133,7 +133,7 @@ class LoggingTest extends DatabaseTestBase {
$queries1 = Database::getLog('testing1');
$queries2 = Database::getLog('testing1', 'test2');
$this->assertEqual(count($queries1), 1, t('Correct number of queries recorded for first connection.'));
$this->assertEqual(count($queries2), 1, t('Correct number of queries recorded for second connection.'));
$this->assertEqual(count($queries1), 1, 'Correct number of queries recorded for first connection.');
$this->assertEqual(count($queries2), 1, 'Correct number of queries recorded for second connection.');
}
}

72
core/modules/system/lib/Drupal/system/Tests/Database/MergeTest.php
View File

@ -37,15 +37,15 @@ class MergeTest extends DatabaseTestBase {
))
->execute();
$this->assertEqual($result, Merge::STATUS_INSERT, t('Insert status returned.'));
$this->assertEqual($result, Merge::STATUS_INSERT, 'Insert status returned.');
$num_records_after = db_query('SELECT COUNT(*) FROM {test_people}')->fetchField();
$this->assertEqual($num_records_before + 1, $num_records_after, t('Merge inserted properly.'));
$this->assertEqual($num_records_before + 1, $num_records_after, 'Merge inserted properly.');
$person = db_query('SELECT * FROM {test_people} WHERE job = :job', array(':job' => 'Presenter'))->fetch();
$this->assertEqual($person->name, 'Tiffany', t('Name set correctly.'));
$this->assertEqual($person->age, 31, t('Age set correctly.'));
$this->assertEqual($person->job, 'Presenter', t('Job set correctly.'));
$this->assertEqual($person->name, 'Tiffany', 'Name set correctly.');
$this->assertEqual($person->age, 31, 'Age set correctly.');
$this->assertEqual($person->job, 'Presenter', 'Job set correctly.');
}
/**
@ -62,15 +62,15 @@ class MergeTest extends DatabaseTestBase {
))
->execute();
$this->assertEqual($result, Merge::STATUS_UPDATE, t('Update status returned.'));
$this->assertEqual($result, Merge::STATUS_UPDATE, 'Update status returned.');
$num_records_after = db_query('SELECT COUNT(*) FROM {test_people}')->fetchField();
$this->assertEqual($num_records_before, $num_records_after, t('Merge updated properly.'));
$this->assertEqual($num_records_before, $num_records_after, 'Merge updated properly.');
$person = db_query('SELECT * FROM {test_people} WHERE job = :job', array(':job' => 'Speaker'))->fetch();
$this->assertEqual($person->name, 'Tiffany', t('Name set correctly.'));
$this->assertEqual($person->age, 31, t('Age set correctly.'));
$this->assertEqual($person->job, 'Speaker', t('Job set correctly.'));
$this->assertEqual($person->name, 'Tiffany', 'Name set correctly.');
$this->assertEqual($person->age, 31, 'Age set correctly.');
$this->assertEqual($person->job, 'Speaker', 'Job set correctly.');
}
/**
@ -86,12 +86,12 @@ class MergeTest extends DatabaseTestBase {
->execute();
$num_records_after = db_query('SELECT COUNT(*) FROM {test_people}')->fetchField();
$this->assertEqual($num_records_before, $num_records_after, t('Merge updated properly.'));
$this->assertEqual($num_records_before, $num_records_after, 'Merge updated properly.');
$person = db_query('SELECT * FROM {test_people} WHERE job = :job', array(':job' => 'Speaker'))->fetch();
$this->assertEqual($person->name, 'Tiffany', t('Name set correctly.'));
$this->assertEqual($person->age, 30, t('Age skipped correctly.'));
$this->assertEqual($person->job, 'Speaker', t('Job set correctly.'));
$this->assertEqual($person->name, 'Tiffany', 'Name set correctly.');
$this->assertEqual($person->age, 30, 'Age skipped correctly.');
$this->assertEqual($person->job, 'Speaker', 'Job set correctly.');
}
/**
@ -112,12 +112,12 @@ class MergeTest extends DatabaseTestBase {
->execute();
$num_records_after = db_query('SELECT COUNT(*) FROM {test_people}')->fetchField();
$this->assertEqual($num_records_before, $num_records_after, t('Merge updated properly.'));
$this->assertEqual($num_records_before, $num_records_after, 'Merge updated properly.');
$person = db_query('SELECT * FROM {test_people} WHERE job = :job', array(':job' => 'Speaker'))->fetch();
$this->assertEqual($person->name, 'Joe', t('Name set correctly.'));
$this->assertEqual($person->age, 30, t('Age skipped correctly.'));
$this->assertEqual($person->job, 'Speaker', t('Job set correctly.'));
$this->assertEqual($person->name, 'Joe', 'Name set correctly.');
$this->assertEqual($person->age, 30, 'Age skipped correctly.');
$this->assertEqual($person->job, 'Speaker', 'Job set correctly.');
}
/**
@ -141,12 +141,12 @@ class MergeTest extends DatabaseTestBase {
->execute();
$num_records_after = db_query('SELECT COUNT(*) FROM {test_people}')->fetchField();
$this->assertEqual($num_records_before, $num_records_after, t('Merge updated properly.'));
$this->assertEqual($num_records_before, $num_records_after, 'Merge updated properly.');
$person = db_query('SELECT * FROM {test_people} WHERE job = :job', array(':job' => 'Speaker'))->fetch();
$this->assertEqual($person->name, 'Tiffany', t('Name set correctly.'));
$this->assertEqual($person->age, $age_before + 4, t('Age updated correctly.'));
$this->assertEqual($person->job, 'Speaker', t('Job set correctly.'));
$this->assertEqual($person->name, 'Tiffany', 'Name set correctly.');
$this->assertEqual($person->age, $age_before + 4, 'Age updated correctly.');
$this->assertEqual($person->job, 'Speaker', 'Job set correctly.');
}
/**
@ -160,12 +160,12 @@ class MergeTest extends DatabaseTestBase {
->execute();
$num_records_after = db_query('SELECT COUNT(*) FROM {test_people}')->fetchField();
$this->assertEqual($num_records_before + 1, $num_records_after, t('Merge inserted properly.'));
$this->assertEqual($num_records_before + 1, $num_records_after, 'Merge inserted properly.');
$person = db_query('SELECT * FROM {test_people} WHERE job = :job', array(':job' => 'Presenter'))->fetch();
$this->assertEqual($person->name, '', t('Name set correctly.'));
$this->assertEqual($person->age, 0, t('Age set correctly.'));
$this->assertEqual($person->job, 'Presenter', t('Job set correctly.'));
$this->assertEqual($person->name, '', 'Name set correctly.');
$this->assertEqual($person->age, 0, 'Age set correctly.');
$this->assertEqual($person->job, 'Presenter', 'Job set correctly.');
}
/**
@ -179,12 +179,12 @@ class MergeTest extends DatabaseTestBase {
->execute();
$num_records_after = db_query('SELECT COUNT(*) FROM {test_people}')->fetchField();
$this->assertEqual($num_records_before, $num_records_after, t('Merge skipped properly.'));
$this->assertEqual($num_records_before, $num_records_after, 'Merge skipped properly.');
$person = db_query('SELECT * FROM {test_people} WHERE job = :job', array(':job' => 'Speaker'))->fetch();
$this->assertEqual($person->name, 'Meredith', t('Name skipped correctly.'));
$this->assertEqual($person->age, 30, t('Age skipped correctly.'));
$this->assertEqual($person->job, 'Speaker', t('Job skipped correctly.'));
$this->assertEqual($person->name, 'Meredith', 'Name skipped correctly.');
$this->assertEqual($person->age, 30, 'Age skipped correctly.');
$this->assertEqual($person->job, 'Speaker', 'Job skipped correctly.');
db_merge('test_people')
->key(array('job' => 'Speaker'))
@ -192,12 +192,12 @@ class MergeTest extends DatabaseTestBase {
->execute();
$num_records_after = db_query('SELECT COUNT(*) FROM {test_people}')->fetchField();
$this->assertEqual($num_records_before, $num_records_after, t('Merge skipped properly.'));
$this->assertEqual($num_records_before, $num_records_after, 'Merge skipped properly.');
$person = db_query('SELECT * FROM {test_people} WHERE job = :job', array(':job' => 'Speaker'))->fetch();
$this->assertEqual($person->name, 'Meredith', t('Name skipped correctly.'));
$this->assertEqual($person->age, 30, t('Age skipped correctly.'));
$this->assertEqual($person->job, 'Speaker', t('Job skipped correctly.'));
$this->assertEqual($person->name, 'Meredith', 'Name skipped correctly.');
$this->assertEqual($person->age, 30, 'Age skipped correctly.');
$this->assertEqual($person->job, 'Speaker', 'Job skipped correctly.');
}
/**
@ -214,9 +214,9 @@ class MergeTest extends DatabaseTestBase {
->execute();
}
catch (InvalidMergeQueryException $e) {
$this->pass(t('InvalidMergeQueryException thrown for invalid query.'));
$this->pass('InvalidMergeQueryException thrown for invalid query.');
return;
}
$this->fail(t('No InvalidMergeQueryException thrown'));
$this->fail('No InvalidMergeQueryException thrown');
}
}

4
core/modules/system/lib/Drupal/system/Tests/Database/NextIdTest.php
View File

@ -30,8 +30,8 @@ class NextIdTest extends WebTestBase {
// We can test for exact increase in here because we know there is no
// other process operating on these tables -- normally we could only
// expect $second > $first.
$this->assertEqual($first + 1, $second, t('The second call from a sequence provides a number increased by one.'));
$this->assertEqual($first + 1, $second, 'The second call from a sequence provides a number increased by one.');
$result = db_next_id(1000);
$this->assertEqual($result, 1001, t('Sequence provides a larger number than the existing ID.'));
$this->assertEqual($result, 1001, 'Sequence provides a larger number than the existing ID.');
}
}

2
core/modules/system/lib/Drupal/system/Tests/Database/QueryTest.php
View File

@ -25,6 +25,6 @@ class QueryTest extends DatabaseTestBase {
function testArraySubstitution() {
$names = db_query('SELECT name FROM {test} WHERE age IN (:ages) ORDER BY age', array(':ages' => array(25, 26, 27)))->fetchAll();
$this->assertEqual(count($names), 3, t('Correct number of names returned'));
$this->assertEqual(count($names), 3, 'Correct number of names returned');
}
}

4
core/modules/system/lib/Drupal/system/Tests/Database/RangeQueryTest.php
View File

@ -35,11 +35,11 @@ class RangeQueryTest extends WebTestBase {
function testRangeQuery() {
// Test if return correct number of rows.
$range_rows = db_query_range("SELECT name FROM {system} ORDER BY name", 2, 3)->fetchAll();
$this->assertEqual(count($range_rows), 3, t('Range query work and return correct number of rows.'));
$this->assertEqual(count($range_rows), 3, 'Range query work and return correct number of rows.');
// Test if return target data.
$raw_rows = db_query('SELECT name FROM {system} ORDER BY name')->fetchAll();
$raw_rows = array_slice($raw_rows, 2, 3);
$this->assertEqual($range_rows, $raw_rows, t('Range query work and return target data.'));
$this->assertEqual($range_rows, $raw_rows, 'Range query work and return target data.');
}
}

14
core/modules/system/lib/Drupal/system/Tests/Database/RegressionTest.php
View File

@ -44,30 +44,30 @@ class RegressionTest extends DatabaseTestBase {
))->execute();
$from_database = db_query('SELECT name FROM {test} WHERE name = :name', array(':name' => $name))->fetchField();
$this->assertIdentical($name, $from_database, t("The database handles UTF-8 characters cleanly."));
$this->assertIdentical($name, $from_database, 'The database handles UTF-8 characters cleanly.');
}
/**
* Test the db_table_exists() function.
*/
function testDBTableExists() {
$this->assertIdentical(TRUE, db_table_exists('node'), t('Returns true for existent table.'));
$this->assertIdentical(FALSE, db_table_exists('nosuchtable'), t('Returns false for nonexistent table.'));
$this->assertIdentical(TRUE, db_table_exists('node'), 'Returns true for existent table.');
$this->assertIdentical(FALSE, db_table_exists('nosuchtable'), 'Returns false for nonexistent table.');
}
/**
* Test the db_field_exists() function.
*/
function testDBFieldExists() {
$this->assertIdentical(TRUE, db_field_exists('node', 'nid'), t('Returns true for existent column.'));
$this->assertIdentical(FALSE, db_field_exists('node', 'nosuchcolumn'), t('Returns false for nonexistent column.'));
$this->assertIdentical(TRUE, db_field_exists('node', 'nid'), 'Returns true for existent column.');
$this->assertIdentical(FALSE, db_field_exists('node', 'nosuchcolumn'), 'Returns false for nonexistent column.');
}
/**
* Test the db_index_exists() function.
*/
function testDBIndexExists() {
$this->assertIdentical(TRUE, db_index_exists('node', 'node_created'), t('Returns true for existent index.'));
$this->assertIdentical(FALSE, db_index_exists('node', 'nosuchindex'), t('Returns false for nonexistent index.'));
$this->assertIdentical(TRUE, db_index_exists('node', 'node_created'), 'Returns true for existent index.');
$this->assertIdentical(FALSE, db_index_exists('node', 'nosuchindex'), 'Returns false for nonexistent index.');
}
}

64
core/modules/system/lib/Drupal/system/Tests/Database/SelectComplexTest.php
View File

@ -44,12 +44,12 @@ class SelectComplexTest extends DatabaseTestBase {
$last_priority = 0;
foreach ($result as $record) {
$num_records++;
$this->assertTrue($record->$priority_field >= $last_priority, t('Results returned in correct order.'));
$this->assertNotEqual($record->$name_field, 'Ringo', t('Taskless person not selected.'));
$this->assertTrue($record->$priority_field >= $last_priority, 'Results returned in correct order.');
$this->assertNotEqual($record->$name_field, 'Ringo', 'Taskless person not selected.');
$last_priority = $record->$priority_field;
}
$this->assertEqual($num_records, 7, t('Returned the correct number of rows.'));
$this->assertEqual($num_records, 7, 'Returned the correct number of rows.');
}
/**
@ -70,11 +70,11 @@ class SelectComplexTest extends DatabaseTestBase {
foreach ($result as $record) {
$num_records++;
$this->assertTrue(strcmp($record->$name_field, $last_name) >= 0, t('Results returned in correct order.'));
$this->assertTrue(strcmp($record->$name_field, $last_name) >= 0, 'Results returned in correct order.');
$last_priority = $record->$name_field;
}
$this->assertEqual($num_records, 8, t('Returned the correct number of rows.'));
$this->assertEqual($num_records, 8, 'Returned the correct number of rows.');
}
/**
@ -93,7 +93,7 @@ class SelectComplexTest extends DatabaseTestBase {
$records = array();
foreach ($result as $record) {
$num_records++;
$this->assertTrue($record->$count_field >= $last_count, t('Results returned in correct order.'));
$this->assertTrue($record->$count_field >= $last_count, 'Results returned in correct order.');
$last_count = $record->$count_field;
$records[$record->$task_field] = $record->$count_field;
}
@ -107,10 +107,10 @@ class SelectComplexTest extends DatabaseTestBase {
);
foreach ($correct_results as $task => $count) {
$this->assertEqual($records[$task], $count, t("Correct number of '@task' records found.", array('@task' => $task)));
$this->assertEqual($records[$task], $count, format_string("Correct number of '@task' records found.", array('@task' => $task)));
}
$this->assertEqual($num_records, 6, t('Returned the correct number of total rows.'));
$this->assertEqual($num_records, 6, 'Returned the correct number of total rows.');
}
/**
@ -130,8 +130,8 @@ class SelectComplexTest extends DatabaseTestBase {
$records = array();
foreach ($result as $record) {
$num_records++;
$this->assertTrue($record->$count_field >= 2, t('Record has the minimum count.'));
$this->assertTrue($record->$count_field >= $last_count, t('Results returned in correct order.'));
$this->assertTrue($record->$count_field >= 2, 'Record has the minimum count.');
$this->assertTrue($record->$count_field >= $last_count, 'Results returned in correct order.');
$last_count = $record->$count_field;
$records[$record->$task_field] = $record->$count_field;
}
@ -141,10 +141,10 @@ class SelectComplexTest extends DatabaseTestBase {
);
foreach ($correct_results as $task => $count) {
$this->assertEqual($records[$task], $count, t("Correct number of '@task' records found.", array('@task' => $task)));
$this->assertEqual($records[$task], $count, format_string("Correct number of '@task' records found.", array('@task' => $task)));
}
$this->assertEqual($num_records, 1, t('Returned the correct number of total rows.'));
$this->assertEqual($num_records, 1, 'Returned the correct number of total rows.');
}
/**
@ -162,7 +162,7 @@ class SelectComplexTest extends DatabaseTestBase {
$num_records++;
}
$this->assertEqual($num_records, 2, t('Returned the correct number of rows.'));
$this->assertEqual($num_records, 2, 'Returned the correct number of rows.');
}
/**
@ -179,7 +179,7 @@ class SelectComplexTest extends DatabaseTestBase {
$num_records++;
}
$this->assertEqual($num_records, 6, t('Returned the correct number of rows.'));
$this->assertEqual($num_records, 6, 'Returned the correct number of rows.');
}
/**
@ -193,13 +193,13 @@ class SelectComplexTest extends DatabaseTestBase {
$count = $query->countQuery()->execute()->fetchField();
$this->assertEqual($count, 4, t('Counted the correct number of records.'));
$this->assertEqual($count, 4, 'Counted the correct number of records.');
// Now make sure we didn't break the original query! We should still have
// all of the fields we asked for.
$record = $query->execute()->fetch();
$this->assertEqual($record->$name_field, 'George', t('Correct data retrieved.'));
$this->assertEqual($record->$age_field, 27, t('Correct data retrieved.'));
$this->assertEqual($record->$name_field, 'George', 'Correct data retrieved.');
$this->assertEqual($record->$age_field, 27, 'Correct data retrieved.');
}
function testHavingCountQuery() {
@ -210,7 +210,7 @@ class SelectComplexTest extends DatabaseTestBase {
$query->addField('test', 'age');
$query->addExpression('age + 1');
$count = count($query->execute()->fetchCol());
$this->assertEqual($count, 4, t('Counted the correct number of records.'));
$this->assertEqual($count, 4, 'Counted the correct number of records.');
}
/**
@ -225,20 +225,20 @@ class SelectComplexTest extends DatabaseTestBase {
// Check that the 'all_fields' statement is handled properly.
$tables = $query->getTables();
$this->assertEqual($tables['test']['all_fields'], 1, t('Query correctly sets \'all_fields\' statement.'));
$this->assertEqual($tables['test']['all_fields'], 1, 'Query correctly sets \'all_fields\' statement.');
$tables = $count->getTables();
$this->assertFalse(isset($tables['test']['all_fields']), t('Count query correctly unsets \'all_fields\' statement.'));
$this->assertFalse(isset($tables['test']['all_fields']), 'Count query correctly unsets \'all_fields\' statement.');
// Check that the ordering clause is handled properly.
$orderby = $query->getOrderBy();
$this->assertEqual($orderby['name'], 'ASC', t('Query correctly sets ordering clause.'));
$this->assertEqual($orderby['name'], 'ASC', 'Query correctly sets ordering clause.');
$orderby = $count->getOrderBy();
$this->assertFalse(isset($orderby['name']), t('Count query correctly unsets ordering caluse.'));
$this->assertFalse(isset($orderby['name']), 'Count query correctly unsets ordering caluse.');
// Make sure that the count query works.
$count = $count->execute()->fetchField();
$this->assertEqual($count, 4, t('Counted the correct number of records.'));
$this->assertEqual($count, 4, 'Counted the correct number of records.');
}
@ -253,11 +253,11 @@ class SelectComplexTest extends DatabaseTestBase {
// records in the {test} table).
$query = db_select('test');
$query->fields('test', array('fail'));
$this->assertEqual(4, $query->countQuery()->execute()->fetchField(), t('Count Query removed fields'));
$this->assertEqual(4, $query->countQuery()->execute()->fetchField(), 'Count Query removed fields');
$query = db_select('test');
$query->addExpression('fail');
$this->assertEqual(4, $query->countQuery()->execute()->fetchField(), t('Count Query removed expressions'));
$this->assertEqual(4, $query->countQuery()->execute()->fetchField(), 'Count Query removed expressions');
}
/**
@ -270,7 +270,7 @@ class SelectComplexTest extends DatabaseTestBase {
$count = $query->countQuery()->execute()->fetchField();
$this->assertEqual($count, 6, t('Counted the correct number of records.'));
$this->assertEqual($count, 6, 'Counted the correct number of records.');
}
/**
@ -283,7 +283,7 @@ class SelectComplexTest extends DatabaseTestBase {
$count = $query->countQuery()->execute()->fetchField();
$this->assertEqual($count, 3, t('Counted the correct number of records.'));
$this->assertEqual($count, 3, 'Counted the correct number of records.');
// Use a column alias as, without one, the query can succeed for the wrong
// reason.
@ -295,7 +295,7 @@ class SelectComplexTest extends DatabaseTestBase {
$count = $query->countQuery()->execute()->fetchField();
$this->assertEqual($count, 3, t('Counted the correct number of records.'));
$this->assertEqual($count, 3, 'Counted the correct number of records.');
}
/**
@ -312,7 +312,7 @@ class SelectComplexTest extends DatabaseTestBase {
$query->condition(db_or()->condition('age', 26)->condition('age', 27));
$job = $query->execute()->fetchField();
$this->assertEqual($job, 'Songwriter', t('Correct data retrieved.'));
$this->assertEqual($job, 'Songwriter', 'Correct data retrieved.');
}
/**
@ -325,8 +325,8 @@ class SelectComplexTest extends DatabaseTestBase {
$query->addField($alias, 'job', 'otherjob');
$query->where("$alias.name <> test.name");
$crowded_job = $query->execute()->fetch();
$this->assertEqual($crowded_job->job, $crowded_job->otherjob, t('Correctly joined same table twice.'));
$this->assertNotEqual($crowded_job->name, $crowded_job->othername, t('Correctly joined same table twice.'));
$this->assertEqual($crowded_job->job, $crowded_job->otherjob, 'Correctly joined same table twice.');
$this->assertNotEqual($crowded_job->name, $crowded_job->othername, 'Correctly joined same table twice.');
}
/**
@ -362,6 +362,6 @@ class SelectComplexTest extends DatabaseTestBase {
// Verify that the string only has one copy of condition placeholder 0.
$pos = strpos($str, 'db_condition_placeholder_0', 0);
$pos2 = strpos($str, 'db_condition_placeholder_0', $pos + 1);
$this->assertFalse($pos2, "Condition placeholder is not repeated");
$this->assertFalse($pos2, 'Condition placeholder is not repeated.');
}
}

12
core/modules/system/lib/Drupal/system/Tests/Database/SelectOrderedTest.php
View File

@ -36,11 +36,11 @@ class SelectOrderedTest extends DatabaseTestBase {
$last_age = 0;
foreach ($result as $record) {
$num_records++;
$this->assertTrue($record->age >= $last_age, t('Results returned in correct order.'));
$this->assertTrue($record->age >= $last_age, 'Results returned in correct order.');
$last_age = $record->age;
}
$this->assertEqual($num_records, 4, t('Returned the correct number of rows.'));
$this->assertEqual($num_records, 4, 'Returned the correct number of rows.');
}
/**
@ -67,11 +67,11 @@ class SelectOrderedTest extends DatabaseTestBase {
$num_records++;
foreach ($record as $kk => $col) {
if ($expected[$k][$kk] != $results[$k][$kk]) {
$this->assertTrue(FALSE, t('Results returned in correct order.'));
$this->assertTrue(FALSE, 'Results returned in correct order.');
}
}
}
$this->assertEqual($num_records, 4, t('Returned the correct number of rows.'));
$this->assertEqual($num_records, 4, 'Returned the correct number of rows.');
}
/**
@ -88,10 +88,10 @@ class SelectOrderedTest extends DatabaseTestBase {
$last_age = 100000000;
foreach ($result as $record) {
$num_records++;
$this->assertTrue($record->age <= $last_age, t('Results returned in correct order.'));
$this->assertTrue($record->age <= $last_age, 'Results returned in correct order.');
$last_age = $record->age;
}
$this->assertEqual($num_records, 4, t('Returned the correct number of rows.'));
$this->assertEqual($num_records, 4, 'Returned the correct number of rows.');
}
}

14
core/modules/system/lib/Drupal/system/Tests/Database/SelectPagerDefaultTest.php
View File

@ -50,7 +50,7 @@ class SelectPagerDefaultTest extends DatabaseTestBase {
$correct_number = $count - ($limit * $page);
}
$this->assertEqual(count($data->names), $correct_number, t('Correct number of records returned by pager: @number', array('@number' => $correct_number)));
$this->assertEqual(count($data->names), $correct_number, format_string('Correct number of records returned by pager: @number', array('@number' => $correct_number)));
}
}
@ -84,7 +84,7 @@ class SelectPagerDefaultTest extends DatabaseTestBase {
$correct_number = $count - ($limit * $page);
}
$this->assertEqual(count($data->names), $correct_number, t('Correct number of records returned by pager: @number', array('@number' => $correct_number)));
$this->assertEqual(count($data->names), $correct_number, format_string('Correct number of records returned by pager: @number', array('@number' => $correct_number)));
}
}
@ -107,7 +107,7 @@ class SelectPagerDefaultTest extends DatabaseTestBase {
$ages = $outer_query
->execute()
->fetchCol();
$this->assertEqual($ages, array(25, 26, 27, 28), t('Inner pager query returned the correct ages.'));
$this->assertEqual($ages, array(25, 26, 27, 28), 'Inner pager query returned the correct ages.');
}
/**
@ -128,7 +128,7 @@ class SelectPagerDefaultTest extends DatabaseTestBase {
$ages = $query
->execute()
->fetchCol();
$this->assertEqual($ages, array('George', 'Ringo'), t('Pager query with having expression returned the correct ages.'));
$this->assertEqual($ages, array('George', 'Ringo'), 'Pager query with having expression returned the correct ages.');
}
/**
@ -145,7 +145,7 @@ class SelectPagerDefaultTest extends DatabaseTestBase {
->limit(1)
->execute()
->fetchField();
$this->assertEqual($name, 'Paul', t('Pager query #1 with a specified element ID returned the correct results.'));
$this->assertEqual($name, 'Paul', 'Pager query #1 with a specified element ID returned the correct results.');
// Setting an element smaller than the previous one
// should not overwrite the pager $maxElement with a smaller value.
@ -157,7 +157,7 @@ class SelectPagerDefaultTest extends DatabaseTestBase {
->limit(1)
->execute()
->fetchField();
$this->assertEqual($name, 'George', t('Pager query #2 with a specified element ID returned the correct results.'));
$this->assertEqual($name, 'George', 'Pager query #2 with a specified element ID returned the correct results.');
$name = db_select('test', 't')
->extend('Drupal\Core\Database\Query\PagerSelectExtender')
@ -166,7 +166,7 @@ class SelectPagerDefaultTest extends DatabaseTestBase {
->limit(1)
->execute()
->fetchField();
$this->assertEqual($name, 'John', t('Pager query #3 with a generated element ID returned the correct results.'));
$this->assertEqual($name, 'John', 'Pager query #3 with a generated element ID returned the correct results.');
unset($_GET['page']);
}

12
core/modules/system/lib/Drupal/system/Tests/Database/SelectSubqueryTest.php
View File

@ -50,7 +50,7 @@ class SelectSubqueryTest extends DatabaseTestBase {
// WHERE tt.task = 'code'
$people = $select->execute()->fetchCol();
$this->assertEqual(count($people), 1, t('Returned the correct number of rows.'));
$this->assertEqual(count($people), 1, 'Returned the correct number of rows.');
}
}
@ -77,7 +77,7 @@ class SelectSubqueryTest extends DatabaseTestBase {
// INNER JOIN test t ON t.id=tt.pid
$people = $select->execute()->fetchCol();
$this->assertEqual(count($people), 1, t('Returned the correct number of rows.'));
$this->assertEqual(count($people), 1, 'Returned the correct number of rows.');
}
/**
@ -100,7 +100,7 @@ class SelectSubqueryTest extends DatabaseTestBase {
// FROM test tt2
// WHERE tt2.pid IN (SELECT tt.pid AS pid FROM test_task tt WHERE tt.priority=1)
$people = $select->execute()->fetchCol();
$this->assertEqual(count($people), 5, t('Returned the correct number of rows.'));
$this->assertEqual(count($people), 5, 'Returned the correct number of rows.');
}
/**
@ -124,7 +124,7 @@ class SelectSubqueryTest extends DatabaseTestBase {
// INNER JOIN (SELECT tt.pid AS pid FROM test_task tt WHERE priority=1) tt ON t.id=tt.pid
$people = $select->execute()->fetchCol();
$this->assertEqual(count($people), 2, t('Returned the correct number of rows.'));
$this->assertEqual(count($people), 2, 'Returned the correct number of rows.');
}
/**
@ -154,7 +154,7 @@ class SelectSubqueryTest extends DatabaseTestBase {
// Ensure that we got the right record.
$record = $result->fetch();
$this->assertEqual($record->name, 'George', t('Fetched name is correct using EXISTS query.'));
$this->assertEqual($record->name, 'George', 'Fetched name is correct using EXISTS query.');
}
/**
@ -184,6 +184,6 @@ class SelectSubqueryTest extends DatabaseTestBase {
// Ensure that we got the right number of records.
$people = $query->execute()->fetchCol();
$this->assertEqual(count($people), 3, t('NOT EXISTS query returned the correct results.'));
$this->assertEqual(count($people), 3, 'NOT EXISTS query returned the correct results.');
}
}

8
core/modules/system/lib/Drupal/system/Tests/Database/SelectTableSortDefaultTest.php
View File

@ -43,8 +43,8 @@ class SelectTableSortDefaultTest extends DatabaseTestBase {
$first = array_shift($data->tasks);
$last = array_pop($data->tasks);
$this->assertEqual($first->task, $sort['first'], t('Items appear in the correct order.'));
$this->assertEqual($last->task, $sort['last'], t('Items appear in the correct order.'));
$this->assertEqual($first->task, $sort['first'], 'Items appear in the correct order.');
$this->assertEqual($last->task, $sort['last'], 'Items appear in the correct order.');
}
}
@ -69,8 +69,8 @@ class SelectTableSortDefaultTest extends DatabaseTestBase {
$first = array_shift($data->tasks);
$last = array_pop($data->tasks);
$this->assertEqual($first->task, $sort['first'], t('Items appear in the correct order sorting by @field @sort.', array('@field' => $sort['field'], '@sort' => $sort['sort'])));
$this->assertEqual($last->task, $sort['last'], t('Items appear in the correct order sorting by @field @sort.', array('@field' => $sort['field'], '@sort' => $sort['sort'])));
$this->assertEqual($first->task, $sort['first'], format_string('Items appear in the correct order sorting by @field @sort.', array('@field' => $sort['field'], '@sort' => $sort['sort'])));
$this->assertEqual($last->task, $sort['last'], format_string('Items appear in the correct order sorting by @field @sort.', array('@field' => $sort['field'], '@sort' => $sort['sort'])));
}
}

104
core/modules/system/lib/Drupal/system/Tests/Database/SelectTest.php
View File

@ -34,7 +34,7 @@ class SelectTest extends DatabaseTestBase {
$num_records++;
}
$this->assertEqual($num_records, 4, t('Returned the correct number of rows.'));
$this->assertEqual($num_records, 4, 'Returned the correct number of rows.');
}
/**
@ -54,8 +54,8 @@ class SelectTest extends DatabaseTestBase {
$query = (string)$query;
$expected = "/* Testing query comments */ SELECT test.name AS name, test.age AS age\nFROM \n{test} test";
$this->assertEqual($num_records, 4, t('Returned the correct number of rows.'));
$this->assertEqual($query, $expected, t('The flattened query contains the comment string.'));
$this->assertEqual($num_records, 4, 'Returned the correct number of rows.');
$this->assertEqual($query, $expected, 'The flattened query contains the comment string.');
}
/**
@ -75,8 +75,8 @@ class SelectTest extends DatabaseTestBase {
$query = (string)$query;
$expected = "/* Testing query comments SELECT nid FROM {node}; -- */ SELECT test.name AS name, test.age AS age\nFROM \n{test} test";
$this->assertEqual($num_records, 4, t('Returned the correct number of rows.'));
$this->assertEqual($query, $expected, t('The flattened query contains the sanitised comment string.'));
$this->assertEqual($num_records, 4, 'Returned the correct number of rows.');
$this->assertEqual($query, $expected, 'The flattened query contains the sanitised comment string.');
}
/**
@ -90,13 +90,13 @@ class SelectTest extends DatabaseTestBase {
$result = $query->execute();
// Check that the aliases are being created the way we want.
$this->assertEqual($name_field, 'name', t('Name field alias is correct.'));
$this->assertEqual($age_field, 'age', t('Age field alias is correct.'));
$this->assertEqual($name_field, 'name', 'Name field alias is correct.');
$this->assertEqual($age_field, 'age', 'Age field alias is correct.');
// Ensure that we got the right record.
$record = $result->fetch();
$this->assertEqual($record->$name_field, 'George', t('Fetched name is correct.'));
$this->assertEqual($record->$age_field, 27, t('Fetched age is correct.'));
$this->assertEqual($record->$name_field, 'George', 'Fetched name is correct.');
$this->assertEqual($record->$age_field, 27, 'Fetched age is correct.');
}
/**
@ -110,13 +110,13 @@ class SelectTest extends DatabaseTestBase {
$result = $query->execute();
// Check that the aliases are being created the way we want.
$this->assertEqual($name_field, 'name', t('Name field alias is correct.'));
$this->assertEqual($age_field, 'double_age', t('Age field alias is correct.'));
$this->assertEqual($name_field, 'name', 'Name field alias is correct.');
$this->assertEqual($age_field, 'double_age', 'Age field alias is correct.');
// Ensure that we got the right record.
$record = $result->fetch();
$this->assertEqual($record->$name_field, 'George', t('Fetched name is correct.'));
$this->assertEqual($record->$age_field, 27*2, t('Fetched age expression is correct.'));
$this->assertEqual($record->$name_field, 'George', 'Fetched name is correct.');
$this->assertEqual($record->$age_field, 27*2, 'Fetched age expression is correct.');
}
/**
@ -131,14 +131,14 @@ class SelectTest extends DatabaseTestBase {
$result = $query->execute();
// Check that the aliases are being created the way we want.
$this->assertEqual($age_double_field, 'expression', t('Double age field alias is correct.'));
$this->assertEqual($age_triple_field, 'expression_2', t('Triple age field alias is correct.'));
$this->assertEqual($age_double_field, 'expression', 'Double age field alias is correct.');
$this->assertEqual($age_triple_field, 'expression_2', 'Triple age field alias is correct.');
// Ensure that we got the right record.
$record = $result->fetch();
$this->assertEqual($record->$name_field, 'George', t('Fetched name is correct.'));
$this->assertEqual($record->$age_double_field, 27*2, t('Fetched double age expression is correct.'));
$this->assertEqual($record->$age_triple_field, 27*3, t('Fetched triple age expression is correct.'));
$this->assertEqual($record->$name_field, 'George', 'Fetched name is correct.');
$this->assertEqual($record->$age_double_field, 27*2, 'Fetched double age expression is correct.');
$this->assertEqual($record->$age_triple_field, 27*3, 'Fetched triple age expression is correct.');
}
/**
@ -151,17 +151,17 @@ class SelectTest extends DatabaseTestBase {
->execute()->fetchObject();
// Check that all fields we asked for are present.
$this->assertNotNull($record->id, t('ID field is present.'));
$this->assertNotNull($record->name, t('Name field is present.'));
$this->assertNotNull($record->age, t('Age field is present.'));
$this->assertNotNull($record->job, t('Job field is present.'));
$this->assertNotNull($record->id, 'ID field is present.');
$this->assertNotNull($record->name, 'Name field is present.');
$this->assertNotNull($record->age, 'Age field is present.');
$this->assertNotNull($record->job, 'Job field is present.');
// Ensure that we got the right record.
// Check that all fields we asked for are present.
$this->assertEqual($record->id, 2, t('ID field has the correct value.'));
$this->assertEqual($record->name, 'George', t('Name field has the correct value.'));
$this->assertEqual($record->age, 27, t('Age field has the correct value.'));
$this->assertEqual($record->job, 'Singer', t('Job field has the correct value.'));
$this->assertEqual($record->id, 2, 'ID field has the correct value.');
$this->assertEqual($record->name, 'George', 'Name field has the correct value.');
$this->assertEqual($record->age, 27, 'Age field has the correct value.');
$this->assertEqual($record->job, 'Singer', 'Job field has the correct value.');
}
/**
@ -174,17 +174,17 @@ class SelectTest extends DatabaseTestBase {
->execute()->fetchObject();
// Check that all fields we asked for are present.
$this->assertNotNull($record->id, t('ID field is present.'));
$this->assertNotNull($record->name, t('Name field is present.'));
$this->assertNotNull($record->age, t('Age field is present.'));
$this->assertNotNull($record->job, t('Job field is present.'));
$this->assertNotNull($record->id, 'ID field is present.');
$this->assertNotNull($record->name, 'Name field is present.');
$this->assertNotNull($record->age, 'Age field is present.');
$this->assertNotNull($record->job, 'Job field is present.');
// Ensure that we got the right record.
// Check that all fields we asked for are present.
$this->assertEqual($record->id, 2, t('ID field has the correct value.'));
$this->assertEqual($record->name, 'George', t('Name field has the correct value.'));
$this->assertEqual($record->age, 27, t('Age field has the correct value.'));
$this->assertEqual($record->job, 'Singer', t('Job field has the correct value.'));
$this->assertEqual($record->id, 2, 'ID field has the correct value.');
$this->assertEqual($record->name, 'George', 'Name field has the correct value.');
$this->assertEqual($record->age, 27, 'Age field has the correct value.');
$this->assertEqual($record->job, 'Singer', 'Job field has the correct value.');
}
/**
@ -198,7 +198,7 @@ class SelectTest extends DatabaseTestBase {
->condition('age', NULL)
->execute()->fetchCol();
$this->assertEqual(count($names), 0, t('No records found when comparing to NULL.'));
$this->assertEqual(count($names), 0, 'No records found when comparing to NULL.');
}
/**
@ -212,8 +212,8 @@ class SelectTest extends DatabaseTestBase {
->isNull('age')
->execute()->fetchCol();
$this->assertEqual(count($names), 1, t('Correct number of records found with NULL age.'));
$this->assertEqual($names[0], 'Fozzie', t('Correct record returned for NULL age.'));
$this->assertEqual(count($names), 1, 'Correct number of records found with NULL age.');
$this->assertEqual($names[0], 'Fozzie', 'Correct record returned for NULL age.');
}
/**
@ -228,9 +228,9 @@ class SelectTest extends DatabaseTestBase {
->orderBy('name')
->execute()->fetchCol();
$this->assertEqual(count($names), 2, t('Correct number of records found withNOT NULL age.'));
$this->assertEqual($names[0], 'Gonzo', t('Correct record returned for NOT NULL age.'));
$this->assertEqual($names[1], 'Kermit', t('Correct record returned for NOT NULL age.'));
$this->assertEqual(count($names), 2, 'Correct number of records found withNOT NULL age.');
$this->assertEqual($names[0], 'Gonzo', 'Correct record returned for NOT NULL age.');
$this->assertEqual($names[1], 'Kermit', 'Correct record returned for NOT NULL age.');
}
/**
@ -251,10 +251,10 @@ class SelectTest extends DatabaseTestBase {
$names = $query_1->execute()->fetchCol();
// Ensure we only get 2 records.
$this->assertEqual(count($names), 2, t('UNION correctly discarded duplicates.'));
$this->assertEqual(count($names), 2, 'UNION correctly discarded duplicates.');
$this->assertEqual($names[0], 'George', t('First query returned correct name.'));
$this->assertEqual($names[1], 'Ringo', t('Second query returned correct name.'));
$this->assertEqual($names[0], 'George', 'First query returned correct name.');
$this->assertEqual($names[1], 'Ringo', 'Second query returned correct name.');
}
/**
@ -274,11 +274,11 @@ class SelectTest extends DatabaseTestBase {
$names = $query_1->execute()->fetchCol();
// Ensure we get all 3 records.
$this->assertEqual(count($names), 3, t('UNION ALL correctly preserved duplicates.'));
$this->assertEqual(count($names), 3, 'UNION ALL correctly preserved duplicates.');
$this->assertEqual($names[0], 'George', t('First query returned correct first name.'));
$this->assertEqual($names[1], 'Ringo', t('Second query returned correct second name.'));
$this->assertEqual($names[2], 'Ringo', t('Third query returned correct name.'));
$this->assertEqual($names[0], 'George', 'First query returned correct first name.');
$this->assertEqual($names[1], 'Ringo', 'Second query returned correct second name.');
$this->assertEqual($names[2], 'Ringo', 'Third query returned correct name.');
}
/**
@ -313,7 +313,7 @@ class SelectTest extends DatabaseTestBase {
->orderBy('id')
->execute()
->fetchCol();
$this->assertEqual($ordered_ids, $expected_ids, t('A query without random ordering returns IDs in the correct order.'));
$this->assertEqual($ordered_ids, $expected_ids, 'A query without random ordering returns IDs in the correct order.');
// Now perform the same query, but instead choose a random ordering. We
// expect this to contain a differently ordered version of the original
@ -324,10 +324,10 @@ class SelectTest extends DatabaseTestBase {
->orderRandom()
->execute()
->fetchCol();
$this->assertNotEqual($randomized_ids, $ordered_ids, t('A query with random ordering returns an unordered set of IDs.'));
$this->assertNotEqual($randomized_ids, $ordered_ids, 'A query with random ordering returns an unordered set of IDs.');
$sorted_ids = $randomized_ids;
sort($sorted_ids);
$this->assertEqual($sorted_ids, $ordered_ids, t('After sorting the random list, the result matches the original query.'));
$this->assertEqual($sorted_ids, $ordered_ids, 'After sorting the random list, the result matches the original query.');
// Now perform the exact same query again, and make sure the order is
// different.
@ -337,10 +337,10 @@ class SelectTest extends DatabaseTestBase {
->orderRandom()
->execute()
->fetchCol();
$this->assertNotEqual($randomized_ids_second_set, $randomized_ids, t('Performing the query with random ordering a second time returns IDs in a different order.'));
$this->assertNotEqual($randomized_ids_second_set, $randomized_ids, 'Performing the query with random ordering a second time returns IDs in a different order.');
$sorted_ids_second_set = $randomized_ids_second_set;
sort($sorted_ids_second_set);
$this->assertEqual($sorted_ids_second_set, $sorted_ids, t('After sorting the second random list, the result matches the sorted version of the first random list.'));
$this->assertEqual($sorted_ids_second_set, $sorted_ids, 'After sorting the second random list, the result matches the sorted version of the first random list.');
}
/**

2
core/modules/system/lib/Drupal/system/Tests/Database/SerializeQueryTest.php
View File

@ -30,6 +30,6 @@ class SerializeQueryTest extends DatabaseTestBase {
// assertion.
$query = unserialize(serialize($query));
$results = $query->execute()->fetchCol();
$this->assertEqual($results[0], 28, t('Query properly executed after unserialization.'));
$this->assertEqual($results[0], 28, 'Query properly executed after unserialization.');
}
}

16
core/modules/system/lib/Drupal/system/Tests/Database/TaggingTest.php
View File

@ -33,8 +33,8 @@ class TaggingTest extends DatabaseTestBase {
$query->addTag('test');
$this->assertTrue($query->hasTag('test'), t('hasTag() returned true.'));
$this->assertFalse($query->hasTag('other'), t('hasTag() returned false.'));
$this->assertTrue($query->hasTag('test'), 'hasTag() returned true.');
$this->assertFalse($query->hasTag('other'), 'hasTag() returned false.');
}
/**
@ -48,8 +48,8 @@ class TaggingTest extends DatabaseTestBase {
$query->addTag('test');
$query->addTag('other');
$this->assertTrue($query->hasAllTags('test', 'other'), t('hasAllTags() returned true.'));
$this->assertFalse($query->hasAllTags('test', 'stuff'), t('hasAllTags() returned false.'));
$this->assertTrue($query->hasAllTags('test', 'other'), 'hasAllTags() returned true.');
$this->assertFalse($query->hasAllTags('test', 'stuff'), 'hasAllTags() returned false.');
}
/**
@ -62,8 +62,8 @@ class TaggingTest extends DatabaseTestBase {
$query->addTag('test');
$this->assertTrue($query->hasAnyTag('test', 'other'), t('hasAnyTag() returned true.'));
$this->assertFalse($query->hasAnyTag('other', 'stuff'), t('hasAnyTag() returned false.'));
$this->assertTrue($query->hasAnyTag('test', 'other'), 'hasAnyTag() returned true.');
$this->assertFalse($query->hasAnyTag('other', 'stuff'), 'hasAnyTag() returned false.');
}
/**
@ -84,9 +84,9 @@ class TaggingTest extends DatabaseTestBase {
$query->addMetaData('test', $data);
$return = $query->getMetaData('test');
$this->assertEqual($data, $return, t('Corect metadata returned.'));
$this->assertEqual($data, $return, 'Corect metadata returned.');
$return = $query->getMetaData('nothere');
$this->assertNull($return, t('Non-existent key returned NULL.'));
$this->assertNull($return, 'Non-existent key returned NULL.');
}
}

10
core/modules/system/lib/Drupal/system/Tests/Database/TemporaryQueryTest.php
View File

@ -43,18 +43,18 @@ class TemporaryQueryTest extends WebTestBase {
$this->drupalGet('database_test/db_query_temporary');
$data = json_decode($this->drupalGetContent());
if ($data) {
$this->assertEqual($this->countTableRows("system"), $data->row_count, t('The temporary table contains the correct amount of rows.'));
$this->assertFalse(db_table_exists($data->table_name), t('The temporary table is, indeed, temporary.'));
$this->assertEqual($this->countTableRows("system"), $data->row_count, 'The temporary table contains the correct amount of rows.');
$this->assertFalse(db_table_exists($data->table_name), 'The temporary table is, indeed, temporary.');
}
else {
$this->fail(t("The creation of the temporary table failed."));
$this->fail('The creation of the temporary table failed.');
}
// Now try to run two db_query_temporary() in the same request.
$table_name_system = db_query_temporary('SELECT status FROM {system}', array());
$table_name_users = db_query_temporary('SELECT uid FROM {users}', array());
$this->assertEqual($this->countTableRows($table_name_system), $this->countTableRows("system"), t('A temporary table was created successfully in this request.'));
$this->assertEqual($this->countTableRows($table_name_users), $this->countTableRows("users"), t('A second temporary table was created successfully in this request.'));
$this->assertEqual($this->countTableRows($table_name_system), $this->countTableRows("system"), 'A temporary table was created successfully in this request.');
$this->assertEqual($this->countTableRows($table_name_users), $this->countTableRows("users"), 'A second temporary table was created successfully in this request.');
}
}

60
core/modules/system/lib/Drupal/system/Tests/Database/TransactionTest.php
View File

@ -76,19 +76,19 @@ class TransactionTest extends DatabaseTestBase {
))
->execute();
$this->assertTrue($connection->inTransaction(), t('In transaction before calling nested transaction.'));
$this->assertTrue($connection->inTransaction(), 'In transaction before calling nested transaction.');
// We're already in a transaction, but we call ->transactionInnerLayer
// to nest another transaction inside the current one.
$this->transactionInnerLayer($suffix, $rollback, $ddl_statement);
$this->assertTrue($connection->inTransaction(), t('In transaction after calling nested transaction.'));
$this->assertTrue($connection->inTransaction(), 'In transaction after calling nested transaction.');
if ($rollback) {
// Roll back the transaction, if requested.
// This rollback should propagate to the last savepoint.
$txn->rollback();
$this->assertTrue(($connection->transactionDepth() == $depth), t('Transaction has rolled back to the last savepoint after calling rollback().'));
$this->assertTrue(($connection->transactionDepth() == $depth), 'Transaction has rolled back to the last savepoint after calling rollback().');
}
}
@ -114,7 +114,7 @@ class TransactionTest extends DatabaseTestBase {
$txn = db_transaction();
$depth2 = $connection->transactionDepth();
$this->assertTrue($depth < $depth2, t('Transaction depth is has increased with new transaction.'));
$this->assertTrue($depth < $depth2, 'Transaction depth is has increased with new transaction.');
// Insert a single row into the testing table.
db_insert('test')
@ -124,7 +124,7 @@ class TransactionTest extends DatabaseTestBase {
))
->execute();
$this->assertTrue($connection->inTransaction(), t('In transaction inside nested transaction.'));
$this->assertTrue($connection->inTransaction(), 'In transaction inside nested transaction.');
if ($ddl_statement) {
$table = array(
@ -139,14 +139,14 @@ class TransactionTest extends DatabaseTestBase {
);
db_create_table('database_test_1', $table);
$this->assertTrue($connection->inTransaction(), t('In transaction inside nested transaction.'));
$this->assertTrue($connection->inTransaction(), 'In transaction inside nested transaction.');
}
if ($rollback) {
// Roll back the transaction, if requested.
// This rollback should propagate to the last savepoint.
$txn->rollback();
$this->assertTrue(($connection->transactionDepth() == $depth), t('Transaction has rolled back to the last savepoint after calling rollback().'));
$this->assertTrue(($connection->transactionDepth() == $depth), 'Transaction has rolled back to the last savepoint after calling rollback().');
}
}
@ -167,9 +167,9 @@ class TransactionTest extends DatabaseTestBase {
// Neither of the rows we inserted in the two transaction layers
// should be present in the tables post-rollback.
$saved_age = db_query('SELECT age FROM {test} WHERE name = :name', array(':name' => 'DavidB'))->fetchField();
$this->assertNotIdentical($saved_age, '24', t('Cannot retrieve DavidB row after commit.'));
$this->assertNotIdentical($saved_age, '24', 'Cannot retrieve DavidB row after commit.');
$saved_age = db_query('SELECT age FROM {test} WHERE name = :name', array(':name' => 'DanielB'))->fetchField();
$this->assertNotIdentical($saved_age, '19', t('Cannot retrieve DanielB row after commit.'));
$this->assertNotIdentical($saved_age, '19', 'Cannot retrieve DanielB row after commit.');
}
catch (Exception $e) {
$this->fail($e->getMessage());
@ -193,9 +193,9 @@ class TransactionTest extends DatabaseTestBase {
// Because our current database claims to not support transactions,
// the inserted rows should be present despite the attempt to roll back.
$saved_age = db_query('SELECT age FROM {test} WHERE name = :name', array(':name' => 'DavidB'))->fetchField();
$this->assertIdentical($saved_age, '24', t('DavidB not rolled back, since transactions are not supported.'));
$this->assertIdentical($saved_age, '24', 'DavidB not rolled back, since transactions are not supported.');
$saved_age = db_query('SELECT age FROM {test} WHERE name = :name', array(':name' => 'DanielB'))->fetchField();
$this->assertIdentical($saved_age, '19', t('DanielB not rolled back, since transactions are not supported.'));
$this->assertIdentical($saved_age, '19', 'DanielB not rolled back, since transactions are not supported.');
}
catch (Exception $e) {
$this->fail($e->getMessage());
@ -215,9 +215,9 @@ class TransactionTest extends DatabaseTestBase {
// Because we committed, both of the inserted rows should be present.
$saved_age = db_query('SELECT age FROM {test} WHERE name = :name', array(':name' => 'DavidA'))->fetchField();
$this->assertIdentical($saved_age, '24', t('Can retrieve DavidA row after commit.'));
$this->assertIdentical($saved_age, '24', 'Can retrieve DavidA row after commit.');
$saved_age = db_query('SELECT age FROM {test} WHERE name = :name', array(':name' => 'DanielA'))->fetchField();
$this->assertIdentical($saved_age, '19', t('Can retrieve DanielA row after commit.'));
$this->assertIdentical($saved_age, '19', 'Can retrieve DanielA row after commit.');
}
catch (Exception $e) {
$this->fail($e->getMessage());
@ -309,7 +309,7 @@ class TransactionTest extends DatabaseTestBase {
// $this->fail(t('Rolling back a transaction containing DDL should fail.'));
}
catch (TransactionNoActiveException $e) {
$this->pass(t('Rolling back a transaction containing DDL should fail.'));
$this->pass('Rolling back a transaction containing DDL should fail.');
}
$this->assertRowPresent('row');
}
@ -362,7 +362,7 @@ class TransactionTest extends DatabaseTestBase {
*/
function assertRowPresent($name, $message = NULL) {
if (!isset($message)) {
$message = t('Row %name is present.', array('%name' => $name));
$message = format_string('Row %name is present.', array('%name' => $name));
}
$present = (boolean) db_query('SELECT 1 FROM {test} WHERE name = :name', array(':name' => $name))->fetchField();
return $this->assertTrue($present, $message);
@ -378,7 +378,7 @@ class TransactionTest extends DatabaseTestBase {
*/
function assertRowAbsent($name, $message = NULL) {
if (!isset($message)) {
$message = t('Row %name is absent.', array('%name' => $name));
$message = format_string('Row %name is absent.', array('%name' => $name));
}
$present = (boolean) db_query('SELECT 1 FROM {test} WHERE name = :name', array(':name' => $name))->fetchField();
return $this->assertFalse($present, $message);
@ -402,10 +402,10 @@ class TransactionTest extends DatabaseTestBase {
$this->insertRow('inner');
// Pop the inner transaction.
unset($transaction2);
$this->assertTrue($database->inTransaction(), t('Still in a transaction after popping the inner transaction'));
$this->assertTrue($database->inTransaction(), 'Still in a transaction after popping the inner transaction');
// Pop the outer transaction.
unset($transaction);
$this->assertFalse($database->inTransaction(), t('Transaction closed after popping the outer transaction'));
$this->assertFalse($database->inTransaction(), 'Transaction closed after popping the outer transaction');
$this->assertRowPresent('outer');
$this->assertRowPresent('inner');
@ -418,10 +418,10 @@ class TransactionTest extends DatabaseTestBase {
// Pop the outer transaction, nothing should happen.
unset($transaction);
$this->insertRow('inner-after-outer-commit');
$this->assertTrue($database->inTransaction(), t('Still in a transaction after popping the outer transaction'));
$this->assertTrue($database->inTransaction(), 'Still in a transaction after popping the outer transaction');
// Pop the inner transaction, the whole transaction should commit.
unset($transaction2);
$this->assertFalse($database->inTransaction(), t('Transaction closed after popping the inner transaction'));
$this->assertFalse($database->inTransaction(), 'Transaction closed after popping the inner transaction');
$this->assertRowPresent('outer');
$this->assertRowPresent('inner');
$this->assertRowPresent('inner-after-outer-commit');
@ -435,11 +435,11 @@ class TransactionTest extends DatabaseTestBase {
// Now rollback the inner transaction.
$transaction2->rollback();
unset($transaction2);
$this->assertTrue($database->inTransaction(), t('Still in a transaction after popping the outer transaction'));
$this->assertTrue($database->inTransaction(), 'Still in a transaction after popping the outer transaction');
// Pop the outer transaction, it should commit.
$this->insertRow('outer-after-inner-rollback');
unset($transaction);
$this->assertFalse($database->inTransaction(), t('Transaction closed after popping the inner transaction'));
$this->assertFalse($database->inTransaction(), 'Transaction closed after popping the inner transaction');
$this->assertRowPresent('outer');
$this->assertRowAbsent('inner');
$this->assertRowPresent('outer-after-inner-rollback');
@ -452,11 +452,11 @@ class TransactionTest extends DatabaseTestBase {
$this->insertRow('inner');
// Pop the outer transaction, nothing should happen.
unset($transaction);
$this->assertTrue($database->inTransaction(), t('Still in a transaction after popping the outer transaction'));
$this->assertTrue($database->inTransaction(), 'Still in a transaction after popping the outer transaction');
// Now rollback the inner transaction, it should rollback.
$transaction2->rollback();
unset($transaction2);
$this->assertFalse($database->inTransaction(), t('Transaction closed after popping the inner transaction'));
$this->assertFalse($database->inTransaction(), 'Transaction closed after popping the inner transaction');
$this->assertRowPresent('outer');
$this->assertRowAbsent('inner');
@ -474,23 +474,23 @@ class TransactionTest extends DatabaseTestBase {
try {
$transaction->rollback();
unset($transaction);
$this->fail(t('Rolling back the outer transaction while the inner transaction is active resulted in an exception.'));
$this->fail('Rolling back the outer transaction while the inner transaction is active resulted in an exception.');
}
catch (TransactionOutOfOrderException $e) {
$this->pass(t('Rolling back the outer transaction while the inner transaction is active resulted in an exception.'));
$this->pass('Rolling back the outer transaction while the inner transaction is active resulted in an exception.');
}
$this->assertFalse($database->inTransaction(), t('No more in a transaction after rolling back the outer transaction'));
$this->assertFalse($database->inTransaction(), 'No more in a transaction after rolling back the outer transaction');
// Try to commit one inner transaction.
unset($transaction3);
$this->pass(t('Trying to commit an inner transaction resulted in an exception.'));
$this->pass('Trying to commit an inner transaction resulted in an exception.');
// Try to rollback one inner transaction.
try {
$transaction->rollback();
unset($transaction2);
$this->fail(t('Trying to commit an inner transaction resulted in an exception.'));
$this->fail('Trying to commit an inner transaction resulted in an exception.');
}
catch (TransactionNoActiveException $e) {
$this->pass(t('Trying to commit an inner transaction resulted in an exception.'));
$this->pass('Trying to commit an inner transaction resulted in an exception.');
}
$this->assertRowAbsent('outer');
$this->assertRowAbsent('inner');

34
core/modules/system/lib/Drupal/system/Tests/Database/UpdateComplexTest.php
View File

@ -31,10 +31,10 @@ class UpdateComplexTest extends DatabaseTestBase {
->condition('name', 'Paul')
);
$num_updated = $update->execute();
$this->assertIdentical($num_updated, 2, t('Updated 2 records.'));
$this->assertIdentical($num_updated, 2, 'Updated 2 records.');
$num_matches = db_query('SELECT COUNT(*) FROM {test} WHERE job = :job', array(':job' => 'Musician'))->fetchField();
$this->assertIdentical($num_matches, '2', t('Updated fields successfully.'));
$this->assertIdentical($num_matches, '2', 'Updated fields successfully.');
}
/**
@ -45,10 +45,10 @@ class UpdateComplexTest extends DatabaseTestBase {
->fields(array('job' => 'Musician'))
->condition('name', array('John', 'Paul'), 'IN')
->execute();
$this->assertIdentical($num_updated, 2, t('Updated 2 records.'));
$this->assertIdentical($num_updated, 2, 'Updated 2 records.');
$num_matches = db_query('SELECT COUNT(*) FROM {test} WHERE job = :job', array(':job' => 'Musician'))->fetchField();
$this->assertIdentical($num_matches, '2', t('Updated fields successfully.'));
$this->assertIdentical($num_matches, '2', 'Updated fields successfully.');
}
/**
@ -61,10 +61,10 @@ class UpdateComplexTest extends DatabaseTestBase {
->fields(array('job' => 'Musician'))
->condition('name', array('John', 'Paul', 'George'), 'NoT IN')
->execute();
$this->assertIdentical($num_updated, 1, t('Updated 1 record.'));
$this->assertIdentical($num_updated, 1, 'Updated 1 record.');
$num_matches = db_query('SELECT COUNT(*) FROM {test} WHERE job = :job', array(':job' => 'Musician'))->fetchField();
$this->assertIdentical($num_matches, '1', t('Updated fields successfully.'));
$this->assertIdentical($num_matches, '1', 'Updated fields successfully.');
}
/**
@ -75,10 +75,10 @@ class UpdateComplexTest extends DatabaseTestBase {
->fields(array('job' => 'Musician'))
->condition('age', array(25, 26), 'BETWEEN')
->execute();
$this->assertIdentical($num_updated, 2, t('Updated 2 records.'));
$this->assertIdentical($num_updated, 2, 'Updated 2 records.');
$num_matches = db_query('SELECT COUNT(*) FROM {test} WHERE job = :job', array(':job' => 'Musician'))->fetchField();
$this->assertIdentical($num_matches, '2', t('Updated fields successfully.'));
$this->assertIdentical($num_matches, '2', 'Updated fields successfully.');
}
/**
@ -89,10 +89,10 @@ class UpdateComplexTest extends DatabaseTestBase {
->fields(array('job' => 'Musician'))
->condition('name', '%ge%', 'LIKE')
->execute();
$this->assertIdentical($num_updated, 1, t('Updated 1 record.'));
$this->assertIdentical($num_updated, 1, 'Updated 1 record.');
$num_matches = db_query('SELECT COUNT(*) FROM {test} WHERE job = :job', array(':job' => 'Musician'))->fetchField();
$this->assertIdentical($num_matches, '1', t('Updated fields successfully.'));
$this->assertIdentical($num_matches, '1', 'Updated fields successfully.');
}
/**
@ -106,15 +106,15 @@ class UpdateComplexTest extends DatabaseTestBase {
->fields(array('job' => 'Musician'))
->expression('age', 'age + :age', array(':age' => 4))
->execute();
$this->assertIdentical($num_updated, 1, t('Updated 1 record.'));
$this->assertIdentical($num_updated, 1, 'Updated 1 record.');
$num_matches = db_query('SELECT COUNT(*) FROM {test} WHERE job = :job', array(':job' => 'Musician'))->fetchField();
$this->assertIdentical($num_matches, '1', t('Updated fields successfully.'));
$this->assertIdentical($num_matches, '1', 'Updated fields successfully.');
$person = db_query('SELECT * FROM {test} WHERE name = :name', array(':name' => 'Ringo'))->fetch();
$this->assertEqual($person->name, 'Ringo', t('Name set correctly.'));
$this->assertEqual($person->age, $before_age + 4, t('Age set correctly.'));
$this->assertEqual($person->job, 'Musician', t('Job set correctly.'));
$this->assertEqual($person->name, 'Ringo', 'Name set correctly.');
$this->assertEqual($person->age, $before_age + 4, 'Age set correctly.');
$this->assertEqual($person->job, 'Musician', 'Job set correctly.');
$GLOBALS['larry_test'] = 0;
}
@ -127,9 +127,9 @@ class UpdateComplexTest extends DatabaseTestBase {
->condition('name', 'Ringo')
->expression('age', 'age + :age', array(':age' => 4))
->execute();
$this->assertIdentical($num_updated, 1, t('Updated 1 record.'));
$this->assertIdentical($num_updated, 1, 'Updated 1 record.');
$after_age = db_query('SELECT age FROM {test} WHERE name = :name', array(':name' => 'Ringo'))->fetchField();
$this->assertEqual($before_age + 4, $after_age, t('Age updated correctly'));
$this->assertEqual($before_age + 4, $after_age, 'Age updated correctly');
}
}

6
core/modules/system/lib/Drupal/system/Tests/Database/UpdateLobTest.php
View File

@ -25,7 +25,7 @@ class UpdateLobTest extends DatabaseTestBase {
*/
function testUpdateOneBlob() {
$data = "This is\000a test.";
$this->assertTrue(strlen($data) === 15, t('Test data contains a NULL.'));
$this->assertTrue(strlen($data) === 15, 'Test data contains a NULL.');
$id = db_insert('test_one_blob')
->fields(array('blob1' => $data))
->execute();
@ -37,7 +37,7 @@ class UpdateLobTest extends DatabaseTestBase {
->execute();
$r = db_query('SELECT * FROM {test_one_blob} WHERE id = :id', array(':id' => $id))->fetchAssoc();
$this->assertTrue($r['blob1'] === $data, t('Can update a blob: id @id, @data.', array('@id' => $id, '@data' => serialize($r))));
$this->assertTrue($r['blob1'] === $data, format_string('Can update a blob: id @id, @data.', array('@id' => $id, '@data' => serialize($r))));
}
/**
@ -57,6 +57,6 @@ class UpdateLobTest extends DatabaseTestBase {
->execute();
$r = db_query('SELECT * FROM {test_two_blobs} WHERE id = :id', array(':id' => $id))->fetchAssoc();
$this->assertTrue($r['blob1'] === 'and so' && $r['blob2'] === 'is this', t('Can update multiple blobs per row.'));
$this->assertTrue($r['blob1'] === 'and so' && $r['blob2'] === 'is this', 'Can update multiple blobs per row.');
}
}

26
core/modules/system/lib/Drupal/system/Tests/Database/UpdateTest.php
View File

@ -28,10 +28,10 @@ class UpdateTest extends DatabaseTestBase {
->fields(array('name' => 'Tiffany'))
->condition('id', 1)
->execute();
$this->assertIdentical($num_updated, 1, t('Updated 1 record.'));
$this->assertIdentical($num_updated, 1, 'Updated 1 record.');
$saved_name = db_query('SELECT name FROM {test} WHERE id = :id', array(':id' => 1))->fetchField();
$this->assertIdentical($saved_name, 'Tiffany', t('Updated name successfully.'));
$this->assertIdentical($saved_name, 'Tiffany', 'Updated name successfully.');
}
/**
@ -43,10 +43,10 @@ class UpdateTest extends DatabaseTestBase {
->fields(array('age' => NULL))
->condition('name', 'Kermit')
->execute();
$this->assertIdentical($num_updated, 1, t('Updated 1 record.'));
$this->assertIdentical($num_updated, 1, 'Updated 1 record.');
$saved_age = db_query('SELECT age FROM {test_null} WHERE name = :name', array(':name' => 'Kermit'))->fetchField();
$this->assertNull($saved_age, t('Updated name successfully.'));
$this->assertNull($saved_age, 'Updated name successfully.');
}
/**
@ -57,10 +57,10 @@ class UpdateTest extends DatabaseTestBase {
->fields(array('job' => 'Musician'))
->condition('job', 'Singer')
->execute();
$this->assertIdentical($num_updated, 2, t('Updated 2 records.'));
$this->assertIdentical($num_updated, 2, 'Updated 2 records.');
$num_matches = db_query('SELECT COUNT(*) FROM {test} WHERE job = :job', array(':job' => 'Musician'))->fetchField();
$this->assertIdentical($num_matches, '2', t('Updated fields successfully.'));
$this->assertIdentical($num_matches, '2', 'Updated fields successfully.');
}
/**
@ -71,10 +71,10 @@ class UpdateTest extends DatabaseTestBase {
->fields(array('job' => 'Musician'))
->condition('age', 26, '>')
->execute();
$this->assertIdentical($num_updated, 2, t('Updated 2 records.'));
$this->assertIdentical($num_updated, 2, 'Updated 2 records.');
$num_matches = db_query('SELECT COUNT(*) FROM {test} WHERE job = :job', array(':job' => 'Musician'))->fetchField();
$this->assertIdentical($num_matches, '2', t('Updated fields successfully.'));
$this->assertIdentical($num_matches, '2', 'Updated fields successfully.');
}
/**
@ -85,10 +85,10 @@ class UpdateTest extends DatabaseTestBase {
->fields(array('job' => 'Musician'))
->where('age > :age', array(':age' => 26))
->execute();
$this->assertIdentical($num_updated, 2, t('Updated 2 records.'));
$this->assertIdentical($num_updated, 2, 'Updated 2 records.');
$num_matches = db_query('SELECT COUNT(*) FROM {test} WHERE job = :job', array(':job' => 'Musician'))->fetchField();
$this->assertIdentical($num_matches, '2', t('Updated fields successfully.'));
$this->assertIdentical($num_matches, '2', 'Updated fields successfully.');
}
/**
@ -100,10 +100,10 @@ class UpdateTest extends DatabaseTestBase {
->where('age > :age', array(':age' => 26))
->condition('name', 'Ringo');
$num_updated = $update->execute();
$this->assertIdentical($num_updated, 1, t('Updated 1 record.'));
$this->assertIdentical($num_updated, 1, 'Updated 1 record.');
$num_matches = db_query('SELECT COUNT(*) FROM {test} WHERE job = :job', array(':job' => 'Musician'))->fetchField();
$this->assertIdentical($num_matches, '1', t('Updated fields successfully.'));
$this->assertIdentical($num_matches, '1', 'Updated fields successfully.');
}
/**
@ -123,6 +123,6 @@ class UpdateTest extends DatabaseTestBase {
$num_rows = db_update('test')
->expression('age', 'age * age')
->execute();
$this->assertIdentical($num_rows, 3, t('Number of affected rows are returned.'));
$this->assertIdentical($num_rows, 3, 'Number of affected rows are returned.');
}
}