Club Drupal

<?php

/**

 * Dummy class for fetching into a class.

 *

 * PDO supports using a new instance of an arbitrary class for records

 * rather than just a stdClass or array. This class is for testing that

 * functionality. (See testQueryFetchClass() below)

 */

class FakeRecord { }

/**

 * Base test class for databases.

 *

 * Because all database tests share the same test data, we can centralize that

 * here.

 */

class DatabaseTestCase extends DrupalWebTestCase {

  protected $profile = 'testing';

  function setUp() {

    parent::setUp('database_test');

    $schema['test'] = drupal_get_schema('test');

    $schema['test_people'] = drupal_get_schema('test_people');

    $schema['test_people_copy'] = drupal_get_schema('test_people_copy');

    $schema['test_one_blob'] = drupal_get_schema('test_one_blob');

    $schema['test_two_blobs'] = drupal_get_schema('test_two_blobs');

    $schema['test_task'] = drupal_get_schema('test_task');

    $this->installTables($schema);

    $this->addSampleData();

  }

  /**

   * Set up several tables needed by a certain test.

   *

   * @param $schema

   *   An array of table definitions to install.

   */

  function installTables($schema) {

    // This ends up being a test for table drop and create, too, which is nice.

    foreach ($schema as $name => $data) {

      if (db_table_exists($name)) {

        db_drop_table($name);

      }

      db_create_table($name, $data);

    }

    foreach ($schema as $name => $data) {

      $this->assertTrue(db_table_exists($name), format_string('Table @name created successfully.', array('@name' => $name)));

    }

  }

  /**

   * Set up tables for NULL handling.

   */

  function ensureSampleDataNull() {

    $schema['test_null'] = drupal_get_schema('test_null');

    $this->installTables($schema);

    db_insert('test_null')

    ->fields(array('name', 'age'))

    ->values(array(

      'name' => 'Kermit',

      'age' => 25,

    ))

    ->values(array(

      'name' => 'Fozzie',

      'age' => NULL,

    ))

    ->values(array(

      'name' => 'Gonzo',

      'age' => 27,

    ))

    ->execute();

  }

  /**

   * Setup our sample data.

   *

   * These are added using db_query(), since we're not trying to test the

   * INSERT operations here, just populate.

   */

  function addSampleData() {

    // We need the IDs, so we can't use a multi-insert here.

    $john = db_insert('test')

      ->fields(array(

        'name' => 'John',

        'age' => 25,

        'job' => 'Singer',

      ))

      ->execute();

    $george = db_insert('test')

      ->fields(array(

        'name' => 'George',

        'age' => 27,

        'job' => 'Singer',

      ))

      ->execute();

    $ringo = db_insert('test')

      ->fields(array(

        'name' => 'Ringo',

        'age' => 28,

        'job' => 'Drummer',

      ))

      ->execute();

    $paul = db_insert('test')

      ->fields(array(

        'name' => 'Paul',

        'age' => 26,

        'job' => 'Songwriter',

      ))

      ->execute();

    db_insert('test_people')

      ->fields(array(

        'name' => 'Meredith',

        'age' => 30,

        'job' => 'Speaker',

      ))

      ->execute();

    db_insert('test_task')

      ->fields(array('pid', 'task', 'priority'))

      ->values(array(

        'pid' => $john,

        'task' => 'eat',

        'priority' => 3,

      ))

      ->values(array(

        'pid' => $john,

        'task' => 'sleep',

        'priority' => 4,

      ))

      ->values(array(

        'pid' => $john,

        'task' => 'code',

        'priority' => 1,

      ))

      ->values(array(

        'pid' => $george,

        'task' => 'sing',

        'priority' => 2,

      ))

      ->values(array(

        'pid' => $george,

        'task' => 'sleep',

        'priority' => 2,

      ))

      ->values(array(

        'pid' => $paul,

        'task' => 'found new band',

        'priority' => 1,

      ))

      ->values(array(

        'pid' => $paul,

        'task' => 'perform at superbowl',

        'priority' => 3,

      ))

      ->execute();

    db_insert('virtual')

      ->fields(array(

        'function' => 'Function value 1',

      ))

      ->execute();

  }

}

/**

 * Test connection management.

 */

class DatabaseConnectionTestCase extends DatabaseTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Connection tests',

      'description' => 'Tests of the core database system.',

      'group' => 'Database',

    );

  }

  /**

   * Test that connections return appropriate connection objects.

   */

  function testConnectionRouting() {

    // Clone the master credentials to a slave connection.

    // Note this will result in two independent connection objects that happen

    // to point to the same place.

    $connection_info = Database::getConnectionInfo('default');

    Database::addConnectionInfo('default', 'slave', $connection_info['default']);

    $db1 = Database::getConnection('default', 'default');

    $db2 = Database::getConnection('slave', 'default');

    $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, '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, '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, 'A second call to getConnection() returns the same object.');

  }

  /**

   * Test that connections return appropriate connection objects.

   */

  function testConnectionRoutingOverride() {

    // Clone the master credentials to a slave connection.

    // Note this will result in two independent connection objects that happen

    // to point to the same place.

    $connection_info = Database::getConnectionInfo('default');

    Database::addConnectionInfo('default', 'slave', $connection_info['default']);

    Database::ignoreTarget('default', 'slave');

    $db1 = Database::getConnection('default', 'default');

    $db2 = Database::getConnection('slave', 'default');

    $this->assertIdentical($db1, $db2, 'Both targets refer to the same connection.');

  }

  /**

   * Tests the closing of a database connection.

   */

  function testConnectionClosing() {

    // Open the default target so we have an object to compare.

    $db1 = Database::getConnection('default', 'default');

    // Try to close the default connection, then open a new one.

    Database::closeConnection('default', 'default');

    $db2 = Database::getConnection('default', 'default');

    // Opening a connection after closing it should yield an object different than the original.

    $this->assertNotIdentical($db1, $db2, 'Opening the default connection after it is closed returns a new object.');

  }

  /**

   * Tests the connection options of the active database.

   */

  function testConnectionOptions() {

    $connection_info = Database::getConnectionInfo('default');

    // Be sure we're connected to the default database.

    $db = Database::getConnection('default', 'default');

    $connectionOptions = $db->getConnectionOptions();

    // In the MySQL driver, the port can be different, so check individual

    // options.

    $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']);

    $db2 = Database::getConnection('slave', 'default');

    $connectionOptions2 = $db2->getConnectionOptions();

    // Get a fresh copy of the default connection options.

    $connectionOptions = $db->getConnectionOptions();

    $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'];

    $test['database'] .= 'test';

    Database::addConnectionInfo('test', 'default', $test);

    $connection_info = Database::getConnectionInfo('test');

    // Get a fresh copy of the default connection options.

    $connectionOptions = $db->getConnectionOptions();

    $this->assertNotEqual($connection_info['default']['database'], $connectionOptions['database'], 'The test connection info database does not match the current connection options database.');

  }

}

/**

 * Test cloning Select queries.

 */

class DatabaseSelectCloneTest extends DatabaseTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Select tests, cloning',

      'description' => 'Test cloning Select queries.',

      'group' => 'Database',

    );

  }

  /**

   * Test that subqueries as value within conditions are cloned properly.

   */

  function testSelectConditionSubQueryCloning() {

    $subquery = db_select('test', 't');

    $subquery->addField('t', 'id', 'id');

    $subquery->condition('age', 28, '<');

    $query = db_select('test', 't');

    $query->addField('t', 'name', 'name');

    $query->condition('id', $subquery, 'IN');

    $clone = clone $query;

    // Cloned query should not be altered by the following modification

    // happening on original query.

    $subquery->condition('age', 25, '>');

    $clone_result = $clone->countQuery()->execute()->fetchField();

    $query_result = $query->countQuery()->execute()->fetchField();

    // Make sure the cloned query has not been modified

    $this->assertEqual(3, $clone_result, 'The cloned query returns the expected number of rows');

    $this->assertEqual(2, $query_result, 'The query returns the expected number of rows');

  }

}

/**

 * Test fetch actions, part 1.

 *

 * We get timeout errors if we try to run too many tests at once.

 */

class DatabaseFetchTestCase extends DatabaseTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Fetch tests',

      'description' => 'Test the Database system\'s various fetch capabilities.',

      'group' => 'Database',

    );

  }

  /**

   * Confirm that we can fetch a record properly in default object mode.

   */

  function testQueryFetchDefault() {

    $records = array();

    $result = db_query('SELECT name FROM {test} WHERE age = :age', array(':age' => 25));

    $this->assertTrue($result instanceof DatabaseStatementInterface, 'Result set is a Drupal statement object.');

    foreach ($result as $record) {

      $records[] = $record;

      $this->assertTrue(is_object($record), 'Record is an object.');

      $this->assertIdentical($record->name, 'John', '25 year old is John.');

    }

    $this->assertIdentical(count($records), 1, 'There is only one record.');

  }

  /**

   * Confirm that we can fetch a record to an object explicitly.

   */

  function testQueryFetchObject() {

    $records = array();

    $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), 'Record is an object.');

      $this->assertIdentical($record->name, 'John', '25 year old is John.');

    }

    $this->assertIdentical(count($records), 1, 'There is only one record.');

  }

  /**

   * Confirm that we can fetch a record to an array associative explicitly.

   */

  function testQueryFetchArray() {

    $records = array();

    $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), 'Record is an array.')) {

        $this->assertIdentical($record['name'], 'John', 'Record can be accessed associatively.');

      }

    }

    $this->assertIdentical(count($records), 1, 'There is only one record.');

  }

  /**

   * Confirm that we can fetch a record into a new instance of a custom class.

   *

   * @see FakeRecord

   */

  function testQueryFetchClass() {

    $records = array();

    $result = db_query('SELECT name FROM {test} WHERE age = :age', array(':age' => 25), array('fetch' => 'FakeRecord'));

    foreach ($result as $record) {

      $records[] = $record;

      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, 'There is only one record.');

  }

}

/**

 * Test fetch actions, part 2.

 *

 * We get timeout errors if we try to run too many tests at once.

 */

class DatabaseFetch2TestCase extends DatabaseTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Fetch tests, part 2',

      'description' => 'Test the Database system\'s various fetch capabilities.',

      'group' => 'Database',

    );

  }

  function setUp() {

    parent::setUp();

  }

  // Confirm that we can fetch a record into an indexed array explicitly.

  function testQueryFetchNum() {

    $records = array();

    $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), 'Record is an array.')) {

        $this->assertIdentical($record[0], 'John', 'Record can be accessed numerically.');

      }

    }

    $this->assertIdentical(count($records), 1, 'There is only one record');

  }

  /**

   * Confirm that we can fetch a record into a doubly-keyed array explicitly.

   */

  function testQueryFetchBoth() {

    $records = array();

    $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), '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, 'There is only one record.');

  }

  /**

   * Confirm that we can fetch an entire column of a result set at once.

   */

  function testQueryFetchCol() {

    $records = array();

    $result = db_query('SELECT name FROM {test} WHERE age > :age', array(':age' => 25));

    $column = $result->fetchCol();

    $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++], 'Column matches direct accesss.');

    }

  }

}

/**

 * Test the insert builder.

 */

class DatabaseInsertTestCase extends DatabaseTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Insert tests',

      'description' => 'Test the Insert query builder.',

      'group' => 'Database',

    );

  }

  /**

   * Test the very basic insert functionality.

   */

  function testSimpleInsert() {

    $num_records_before = db_query('SELECT COUNT(*) FROM {test}')->fetchField();

    $query = db_insert('test');

    $query->fields(array(

      'name' => 'Yoko',

      'age' => '29',

    ));

    $query->execute();

    $num_records_after = db_query('SELECT COUNT(*) FROM {test}')->fetchField();

    $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', 'Can retrieve after inserting.');

  }

  /**

   * Test that we can insert multiple records in one query object.

   */

  function testMultiInsert() {

    $num_records_before = (int) db_query('SELECT COUNT(*) FROM {test}')->fetchField();

    $query = db_insert('test');

    $query->fields(array(

      'name' => 'Larry',

      'age' => '30',

    ));

    // We should be able to specify values in any order if named.

    $query->values(array(

      'age' => '31',

      'name' => 'Curly',

    ));

    // We should be able to say "use the field order".

    // This is not the recommended mechanism for most cases, but it should work.

    $query->values(array('Moe', '32'));

    $query->execute();

    $num_records_after = (int) db_query('SELECT COUNT(*) FROM {test}')->fetchField();

    $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', 'Can retrieve after inserting.');

    $saved_age = db_query('SELECT age FROM {test} WHERE name = :name', array(':name' => 'Curly'))->fetchField();

    $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', 'Can retrieve after inserting.');

  }

  /**

   * Test that an insert object can be reused with new data after it executes.

   */

  function testRepeatedInsert() {

    $num_records_before = db_query('SELECT COUNT(*) FROM {test}')->fetchField();

    $query = db_insert('test');

    $query->fields(array(

      'name' => 'Larry',

      'age' => '30',

    ));

    $query->execute();  // This should run the insert, but leave the fields intact.

    // We should be able to specify values in any order if named.

    $query->values(array(

      'age' => '31',

      'name' => 'Curly',

    ));

    $query->execute();

    // We should be able to say "use the field order".

    $query->values(array('Moe', '32'));

    $query->execute();

    $num_records_after = db_query('SELECT COUNT(*) FROM {test}')->fetchField();

    $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', 'Can retrieve after inserting.');

    $saved_age = db_query('SELECT age FROM {test} WHERE name = :name', array(':name' => 'Curly'))->fetchField();

    $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', 'Can retrieve after inserting.');

  }

  /**

   * Test that we can specify fields without values and specify values later.

   */

  function testInsertFieldOnlyDefinintion() {

    // This is useful for importers, when we want to create a query and define

    // its fields once, then loop over a multi-insert execution.

    db_insert('test')

      ->fields(array('name', 'age'))

      ->values(array('Larry', '30'))

      ->values(array('Curly', '31'))

      ->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', 'Can retrieve after inserting.');

    $saved_age = db_query('SELECT age FROM {test} WHERE name = :name', array(':name' => 'Curly'))->fetchField();

    $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', 'Can retrieve after inserting.');

  }

  /**

   * Test that inserts return the proper auto-increment ID.

   */

  function testInsertLastInsertID() {

    $id = db_insert('test')

      ->fields(array(

        'name' => 'Larry',

        'age' => '30',

      ))

      ->execute();

    $this->assertIdentical($id, '5', 'Auto-increment ID returned successfully.');

  }

  /**

   * Test that the INSERT INTO ... SELECT (fields) ... syntax works.

   */

  function testInsertSelectFields() {

    $query = db_select('test_people', 'tp');

    // The query builder will always append expressions after fields.

    // Add the expression first to test that the insert fields are correctly

    // re-ordered.

    $query->addExpression('tp.age', 'age');

    $query

      ->fields('tp', array('name','job'))

      ->condition('tp.name', 'Meredith');

    // The resulting query should be equivalent to:

    // INSERT INTO test (age, name, job)

    // SELECT tp.age AS age, tp.name AS name, tp.job AS job

    // FROM test_people tp

    // WHERE tp.name = 'Meredith'

    db_insert('test')

      ->from($query)

      ->execute();

    $saved_age = db_query('SELECT age FROM {test} WHERE name = :name', array(':name' => 'Meredith'))->fetchField();

    $this->assertIdentical($saved_age, '30', 'Can retrieve after inserting.');

  }

  /**

   * Tests that the INSERT INTO ... SELECT * ... syntax works.

   */

  function testInsertSelectAll() {

    $query = db_select('test_people', 'tp')

      ->fields('tp')

      ->condition('tp.name', 'Meredith');

    // The resulting query should be equivalent to:

    // INSERT INTO test_people_copy

    // SELECT *

    // FROM test_people tp

    // WHERE tp.name = 'Meredith'

    db_insert('test_people_copy')

      ->from($query)

      ->execute();

    $saved_age = db_query('SELECT age FROM {test_people_copy} WHERE name = :name', array(':name' => 'Meredith'))->fetchField();

    $this->assertIdentical($saved_age, '30', 'Can retrieve after inserting.');

  }

}

/**

 * Insert tests using LOB fields, which are weird on some databases.

 */

class DatabaseInsertLOBTestCase extends DatabaseTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Insert tests, LOB fields',

      'description' => 'Test the Insert query builder with LOB fields.',

      'group' => 'Database',

    );

  }

  /**

   * Test that we can insert a single blob field successfully.

   */

  function testInsertOneBlob() {

    $data = "This is\000a test.";

    $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, format_string('Can insert a blob: id @id, @data.', array('@id' => $id, '@data' => serialize($r))));

  }

  /**

   * Test that we can insert multiple blob fields in the same query.

   */

  function testInsertMultipleBlob() {

    $id = db_insert('test_two_blobs')

      ->fields(array(

        'blob1' => 'This is',

        'blob2' => 'a test',

      ))

      ->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', 'Can insert multiple blobs per row.');

  }

}

/**

 * Insert tests for "database default" values.

 */

class DatabaseInsertDefaultsTestCase extends DatabaseTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Insert tests, default fields',

      'description' => 'Test the Insert query builder with default values.',

      'group' => 'Database',

    );

  }

  /**

   * Test that we can run a query that is "default values for everything".

   */

  function testDefaultInsert() {

    $query = db_insert('test')->useDefaults(array('job'));

    $id = $query->execute();

    $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'], 'Default field value is set.');

  }

  /**

   * Test that no action will be preformed if no fields are specified.

   */

  function testDefaultEmptyInsert() {

    $num_records_before = (int) db_query('SELECT COUNT(*) FROM {test}')->fetchField();

    try {

      $result = db_insert('test')->execute();

      // This is only executed if no exception has been thrown.

      $this->fail('Expected exception NoFieldsException has not been thrown.');

    } catch (NoFieldsException $e) {

      $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, 'Do nothing as no fields are specified.');

  }

  /**

   * Test that we can insert fields with values and defaults in the same query.

   */

  function testDefaultInsertWithFields() {

    $query = db_insert('test')

      ->fields(array('name' => 'Bob'))

      ->useDefaults(array('job'));

    $id = $query->execute();

    $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'], 'Default field value is set.');

  }

}

/**

 * Update builder tests.

 */

class DatabaseUpdateTestCase extends DatabaseTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Update tests',

      'description' => 'Test the Update query builder.',

      'group' => 'Database',

    );

  }

  /**

   * Confirm that we can update a single record successfully.

   */

  function testSimpleUpdate() {

    $num_updated = db_update('test')

      ->fields(array('name' => 'Tiffany'))

      ->condition('id', 1)

      ->execute();

    $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', 'Updated name successfully.');

  }

  /**

   * Confirm updating to NULL.

   */

  function testSimpleNullUpdate() {

    $this->ensureSampleDataNull();

    $num_updated = db_update('test_null')

      ->fields(array('age' => NULL))

      ->condition('name', 'Kermit')

      ->execute();

    $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, 'Updated name successfully.');

  }

  /**

   * Confirm that we can update a multiple records successfully.

   */

  function testMultiUpdate() {

    $num_updated = db_update('test')

      ->fields(array('job' => 'Musician'))

      ->condition('job', 'Singer')

      ->execute();

    $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', 'Updated fields successfully.');

  }

  /**

   * Confirm that we can update a multiple records with a non-equality condition.

   */

  function testMultiGTUpdate() {

    $num_updated = db_update('test')

      ->fields(array('job' => 'Musician'))

      ->condition('age', 26, '>')

      ->execute();

    $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', 'Updated fields successfully.');

  }

  /**

   * Confirm that we can update a multiple records with a where call.

   */

  function testWhereUpdate() {

    $num_updated = db_update('test')

      ->fields(array('job' => 'Musician'))

      ->where('age > :age', array(':age' => 26))

      ->execute();

    $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', 'Updated fields successfully.');

  }

  /**

   * Confirm that we can stack condition and where calls.

   */

  function testWhereAndConditionUpdate() {

    $update = db_update('test')

      ->fields(array('job' => 'Musician'))

      ->where('age > :age', array(':age' => 26))

      ->condition('name', 'Ringo');

    $num_updated = $update->execute();

    $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', 'Updated fields successfully.');

  }

  /**

   * Test updating with expressions.

   */

  function testExpressionUpdate() {

    // Set age = 1 for a single row for this test to work.

    db_update('test')

      ->condition('id', 1)

      ->fields(array('age' => 1))

      ->execute();

    // Ensure that expressions are handled properly.  This should set every

    // record's age to a square of itself, which will change only three of the

    // four records in the table since 1*1 = 1. That means only three records

    // are modified, so we should get back 3, not 4, from execute().

    $num_rows = db_update('test')

      ->expression('age', 'age * age')

      ->execute();

    $this->assertIdentical($num_rows, 3, 'Number of affected rows are returned.');

  }

  /**

   * Confirm that we can update the primary key of a record successfully.

   */

  function testPrimaryKeyUpdate() {

    $num_updated = db_update('test')

      ->fields(array('id' => 42, 'name' => 'John'))

      ->condition('id', 1)

      ->execute();

    $this->assertIdentical($num_updated, 1, 'Updated 1 record.');

    $saved_name= db_query('SELECT name FROM {test} WHERE id = :id', array(':id' => 42))->fetchField();

    $this->assertIdentical($saved_name, 'John', 'Updated primary key successfully.');

  }

}

/**

 * Tests for more complex update statements.

 */

class DatabaseUpdateComplexTestCase extends DatabaseTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Update tests, Complex',

      'description' => 'Test the Update query builder, complex queries.',

      'group' => 'Database',

    );

  }

  /**

   * Test updates with OR conditionals.

   */

  function testOrConditionUpdate() {

    $update = db_update('test')

      ->fields(array('job' => 'Musician'))

      ->condition(db_or()

        ->condition('name', 'John')

        ->condition('name', 'Paul')

      );

    $num_updated = $update->execute();

    $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', 'Updated fields successfully.');

  }

  /**

   * Test WHERE IN clauses.

   */

  function testInConditionUpdate() {

    $num_updated = db_update('test')

      ->fields(array('job' => 'Musician'))

      ->condition('name', array('John', 'Paul'), 'IN')

      ->execute();

    $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', 'Updated fields successfully.');

  }

  /**

   * Test WHERE NOT IN clauses.

   */

  function testNotInConditionUpdate() {

    // The o is lowercase in the 'NoT IN' operator, to make sure the operators

    // work in mixed case.

    $num_updated = db_update('test')

      ->fields(array('job' => 'Musician'))

      ->condition('name', array('John', 'Paul', 'George'), 'NoT IN')

      ->execute();

    $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', 'Updated fields successfully.');

  }

  /**

   * Test BETWEEN conditional clauses.

   */

  function testBetweenConditionUpdate() {

    $num_updated = db_update('test')

      ->fields(array('job' => 'Musician'))

      ->condition('age', array(25, 26), 'BETWEEN')

      ->execute();

    $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', 'Updated fields successfully.');

  }

  /**

   * Test LIKE conditionals.

   */

  function testLikeConditionUpdate() {

    $num_updated = db_update('test')

      ->fields(array('job' => 'Musician'))

      ->condition('name', '%ge%', 'LIKE')

      ->execute();

    $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', 'Updated fields successfully.');

  }

  /**

   * Test update with expression values.

   */

  function testUpdateExpression() {

    $before_age = db_query('SELECT age FROM {test} WHERE name = :name', array(':name' => 'Ringo'))->fetchField();

    $GLOBALS['larry_test'] = 1;

    $num_updated = db_update('test')

      ->condition('name', 'Ringo')

      ->fields(array('job' => 'Musician'))

      ->expression('age', 'age + :age', array(':age' => 4))

      ->execute();

    $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', 'Updated fields successfully.');

    $person = db_query('SELECT * FROM {test} WHERE name = :name', array(':name' => 'Ringo'))->fetch();

    $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;

  }

  /**

   * Test update with only expression values.

   */

  function testUpdateOnlyExpression() {

    $before_age = db_query('SELECT age FROM {test} WHERE name = :name', array(':name' => 'Ringo'))->fetchField();

    $num_updated = db_update('test')

      ->condition('name', 'Ringo')

      ->expression('age', 'age + :age', array(':age' => 4))

      ->execute();

    $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, 'Age updated correctly');

  }

}

/**

 * Test update queries involving LOB values.

 */

class DatabaseUpdateLOBTestCase extends DatabaseTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Update tests, LOB',

      'description' => 'Test the Update query builder with LOB fields.',

      'group' => 'Database',

    );

  }

  /**

   * Confirm that we can update a blob column.

   */

  function testUpdateOneBlob() {

    $data = "This is\000a test.";

    $this->assertTrue(strlen($data) === 15, 'Test data contains a NULL.');

    $id = db_insert('test_one_blob')

      ->fields(array('blob1' => $data))

      ->execute();

    $data .= $data;

    db_update('test_one_blob')

      ->condition('id', $id)

      ->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, format_string('Can update a blob: id @id, @data.', array('@id' => $id, '@data' => serialize($r))));

  }

  /**

   * Confirm that we can update two blob columns in the same table.

   */

  function testUpdateMultipleBlob() {

    $id = db_insert('test_two_blobs')

      ->fields(array(

        'blob1' => 'This is',

        'blob2' => 'a test',

      ))

      ->execute();

    db_update('test_two_blobs')

      ->condition('id', $id)

      ->fields(array('blob1' => 'and so', 'blob2' => 'is this'))

      ->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', 'Can update multiple blobs per row.');

  }

}

/**

 * Delete/Truncate tests.

 *

 * The DELETE tests are not as extensive, as all of the interesting code for

 * DELETE queries is in the conditional which is identical to the UPDATE and

 * SELECT conditional handling.

 *

 * The TRUNCATE tests are not extensive either, because the behavior of

 * TRUNCATE queries is not consistent across database engines. We only test

 * that a TRUNCATE query actually deletes all rows from the target table.

 */

class DatabaseDeleteTruncateTestCase extends DatabaseTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Delete/Truncate tests',

      'description' => 'Test the Delete and Truncate query builders.',

      'group' => 'Database',

    );

  }

  /**

   * Confirm that we can use a subselect in a delete successfully.

   */

  function testSubselectDelete() {

    $num_records_before = db_query('SELECT COUNT(*) FROM {test_task}')->fetchField();

    $pid_to_delete = db_query("SELECT * FROM {test_task} WHERE task = 'sleep'")->fetchField();

    $subquery = db_select('test', 't')

      ->fields('t', array('id'))

      ->condition('t.id', array($pid_to_delete), 'IN');

    $delete = db_delete('test_task')

      ->condition('task', 'sleep')

      ->condition('pid', $subquery, 'IN');

    $num_deleted = $delete->execute();

    $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, 'Deletion adds up.');

  }

  /**

   * Confirm that we can delete a single record successfully.

   */

  function testSimpleDelete() {

    $num_records_before = db_query('SELECT COUNT(*) FROM {test}')->fetchField();

    $num_deleted = db_delete('test')

      ->condition('id', 1)

      ->execute();

    $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, 'Deletion adds up.');

  }

  /**

   * Confirm that we can truncate a whole table successfully.

   */

  function testTruncate() {

    $num_records_before = db_query("SELECT COUNT(*) FROM {test}")->fetchField();

    db_truncate('test')->execute();

    $num_records_after = db_query("SELECT COUNT(*) FROM {test}")->fetchField();

    $this->assertEqual(0, $num_records_after, 'Truncate really deletes everything.');

  }

}

/**

 * Test the MERGE query builder.

 */

class DatabaseMergeTestCase extends DatabaseTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Merge tests',

      'description' => 'Test the Merge query builder.',

      'group' => 'Database',

    );

  }

  /**

   * Confirm that we can merge-insert a record successfully.

   */

  function testMergeInsert() {

    $num_records_before = db_query('SELECT COUNT(*) FROM {test_people}')->fetchField();

    $result = db_merge('test_people')

      ->key(array('job' => 'Presenter'))

      ->fields(array(

        'age' => 31,

        'name' => 'Tiffany',

      ))

      ->execute();

    $this->assertEqual($result, MergeQuery::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, 'Merge inserted properly.');

    $person = db_query('SELECT * FROM {test_people} WHERE job = :job', array(':job' => 'Presenter'))->fetch();

    $this->assertEqual($person->name, 'Tiffany', 'Name set correctly.');

    $this->assertEqual($person->age, 31, 'Age set correctly.');

    $this->assertEqual($person->job, 'Presenter', 'Job set correctly.');

  }

  /**

   * Confirm that we can merge-update a record successfully.

   */

  function testMergeUpdate() {

    $num_records_before = db_query('SELECT COUNT(*) FROM {test_people}')->fetchField();

    $result = db_merge('test_people')

      ->key(array('job' => 'Speaker'))

      ->fields(array(

        'age' => 31,

        'name' => 'Tiffany',

      ))

      ->execute();

    $this->assertEqual($result, MergeQuery::STATUS_UPDATE, 'Update status returned.');

    $num_records_after = db_query('SELECT COUNT(*) FROM {test_people}')->fetchField();

    $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', 'Name set correctly.');

    $this->assertEqual($person->age, 31, 'Age set correctly.');

    $this->assertEqual($person->job, 'Speaker', 'Job set correctly.');

  }

  /**

   * Confirm that we can merge-update a record successfully, with different insert and update.

   */

  function testMergeUpdateExcept() {

    $num_records_before = db_query('SELECT COUNT(*) FROM {test_people}')->fetchField();

    db_merge('test_people')

      ->key(array('job' => 'Speaker'))

      ->insertFields(array('age' => 31))

      ->updateFields(array('name' => 'Tiffany'))

      ->execute();

    $num_records_after = db_query('SELECT COUNT(*) FROM {test_people}')->fetchField();

    $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', 'Name set correctly.');

    $this->assertEqual($person->age, 30, 'Age skipped correctly.');

    $this->assertEqual($person->job, 'Speaker', 'Job set correctly.');

  }

  /**

   * Confirm that we can merge-update a record successfully, with alternate replacement.

   */

  function testMergeUpdateExplicit() {

    $num_records_before = db_query('SELECT COUNT(*) FROM {test_people}')->fetchField();

    db_merge('test_people')

      ->key(array('job' => 'Speaker'))

      ->insertFields(array(

        'age' => 31,

        'name' => 'Tiffany',

      ))

      ->updateFields(array(

        'name' => 'Joe',

      ))

      ->execute();

    $num_records_after = db_query('SELECT COUNT(*) FROM {test_people}')->fetchField();

    $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', 'Name set correctly.');

    $this->assertEqual($person->age, 30, 'Age skipped correctly.');

    $this->assertEqual($person->job, 'Speaker', 'Job set correctly.');

  }

  /**

   * Confirm that we can merge-update a record successfully, with expressions.

   */

  function testMergeUpdateExpression() {

    $num_records_before = db_query('SELECT COUNT(*) FROM {test_people}')->fetchField();

    $age_before = db_query('SELECT age FROM {test_people} WHERE job = :job', array(':job' => 'Speaker'))->fetchField();

    // This is a very contrived example, as I have no idea why you'd want to

    // change age this way, but that's beside the point.

    // Note that we are also double-setting age here, once as a literal and

    // once as an expression. This test will only pass if the expression wins,

    // which is what is supposed to happen.

    db_merge('test_people')

      ->key(array('job' => 'Speaker'))

      ->fields(array('name' => 'Tiffany'))

      ->insertFields(array('age' => 31))

      ->expression('age', 'age + :age', array(':age' => 4))

      ->execute();

    $num_records_after = db_query('SELECT COUNT(*) FROM {test_people}')->fetchField();

    $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', 'Name set correctly.');

    $this->assertEqual($person->age, $age_before + 4, 'Age updated correctly.');

    $this->assertEqual($person->job, 'Speaker', 'Job set correctly.');

  }

  /**

   * Test that we can merge-insert without any update fields.

   */

  function testMergeInsertWithoutUpdate() {

    $num_records_before = db_query('SELECT COUNT(*) FROM {test_people}')->fetchField();

    db_merge('test_people')

      ->key(array('job' => 'Presenter'))

      ->execute();

    $num_records_after = db_query('SELECT COUNT(*) FROM {test_people}')->fetchField();

    $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, '', 'Name set correctly.');

    $this->assertEqual($person->age, 0, 'Age set correctly.');

    $this->assertEqual($person->job, 'Presenter', 'Job set correctly.');

  }

  /**

   * Confirm that we can merge-update without any update fields.

   */

  function testMergeUpdateWithoutUpdate() {

    $num_records_before = db_query('SELECT COUNT(*) FROM {test_people}')->fetchField();

    db_merge('test_people')

      ->key(array('job' => 'Speaker'))

      ->execute();

    $num_records_after = db_query('SELECT COUNT(*) FROM {test_people}')->fetchField();

    $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', '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'))

      ->insertFields(array('age' => 31))

      ->execute();

    $num_records_after = db_query('SELECT COUNT(*) FROM {test_people}')->fetchField();

    $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', 'Name skipped correctly.');

    $this->assertEqual($person->age, 30, 'Age skipped correctly.');

    $this->assertEqual($person->job, 'Speaker', 'Job skipped correctly.');

  }

  /**

   * Test that an invalid merge query throws an exception like it is supposed to.

   */

  function testInvalidMerge() {

    try {

      // This query should die because there is no key field specified.

      db_merge('test_people')

        ->fields(array(

          'age' => 31,

          'name' => 'Tiffany',

        ))

        ->execute();

    }

    catch (InvalidMergeQueryException $e) {

      $this->pass('InvalidMergeQueryException thrown for invalid query.');

      return;

    }

    $this->fail('No InvalidMergeQueryException thrown');

  }

}

/**

 * Test the SELECT builder.

 */

class DatabaseSelectTestCase extends DatabaseTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Select tests',

      'description' => 'Test the Select query builder.',

      'group' => 'Database',

    );

  }

  /**

   * Test rudimentary SELECT statements.

   */

  function testSimpleSelect() {

    $query = db_select('test');

    $name_field = $query->addField('test', 'name');

    $age_field = $query->addField('test', 'age', 'age');

    $result = $query->execute();

    $num_records = 0;

    foreach ($result as $record) {

      $num_records++;

    }

    $this->assertEqual($num_records, 4, 'Returned the correct number of rows.');

  }

  /**

   * Test rudimentary SELECT statement with a COMMENT.

   */

  function testSimpleComment() {

    $query = db_select('test')->comment('Testing query comments');

    $name_field = $query->addField('test', 'name');

    $age_field = $query->addField('test', 'age', 'age');

    $result = $query->execute();

    $num_records = 0;

    foreach ($result as $record) {

      $num_records++;

    }

    $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, 'Returned the correct number of rows.');

    $this->assertEqual($query, $expected, 'The flattened query contains the comment string.');

  }

  /**

   * Test query COMMENT system against vulnerabilities.

   */

  function testVulnerableComment() {

    $query = db_select('test')->comment('Testing query comments */ SELECT nid FROM {node}; --');

    $name_field = $query->addField('test', 'name');

    $age_field = $query->addField('test', 'age', 'age');

    $result = $query->execute();

    $num_records = 0;

    foreach ($result as $record) {

      $num_records++;

    }

    $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, 'Returned the correct number of rows.');

    $this->assertEqual($query, $expected, 'The flattened query contains the sanitised comment string.');

    $connection = Database::getConnection();

    foreach ($this->makeCommentsProvider() as $test_set) {

      list($expected, $comments) = $test_set;

      $this->assertEqual($expected, $connection->makeComment($comments));

    }

  }

  /**

   * Provides expected and input values for testVulnerableComment().

   */

  function makeCommentsProvider() {

    return array(

      array(

        '/*  */ ',

        array(''),

      ),

      // Try and close the comment early.

      array(

        '/* Exploit  * / DROP TABLE node; -- */ ',

        array('Exploit */ DROP TABLE node; --'),

      ),

      // Variations on comment closing.

      array(

        '/* Exploit  * / * / DROP TABLE node; -- */ ',

        array('Exploit */*/ DROP TABLE node; --'),

      ),

      array(

        '/* Exploit  *  * // DROP TABLE node; -- */ ',

        array('Exploit **// DROP TABLE node; --'),

      ),

      // Try closing the comment in the second string which is appended.

      array(

        '/* Exploit  * / DROP TABLE node; --; Another try  * / DROP TABLE node; -- */ ',

        array('Exploit */ DROP TABLE node; --', 'Another try */ DROP TABLE node; --'),

      ),

    );

  }

  /**

   * Test basic conditionals on SELECT statements.

   */

  function testSimpleSelectConditional() {

    $query = db_select('test');

    $name_field = $query->addField('test', 'name');

    $age_field = $query->addField('test', 'age', 'age');

    $query->condition('age', 27);

    $result = $query->execute();

    // Check that the aliases are being created the way we want.

    $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', 'Fetched name is correct.');

    $this->assertEqual($record->$age_field, 27, 'Fetched age is correct.');

  }

  /**

   * Test SELECT statements with expressions.

   */

  function testSimpleSelectExpression() {

    $query = db_select('test');

    $name_field = $query->addField('test', 'name');

    $age_field = $query->addExpression("age*2", 'double_age');

    $query->condition('age', 27);

    $result = $query->execute();

    // Check that the aliases are being created the way we want.

    $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', 'Fetched name is correct.');

    $this->assertEqual($record->$age_field, 27*2, 'Fetched age expression is correct.');

  }

  /**

   * Test SELECT statements with multiple expressions.

   */

  function testSimpleSelectExpressionMultiple() {

    $query = db_select('test');

    $name_field = $query->addField('test', 'name');

    $age_double_field = $query->addExpression("age*2");

    $age_triple_field = $query->addExpression("age*3");

    $query->condition('age', 27);

    $result = $query->execute();

    // Check that the aliases are being created the way we want.

    $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', '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.');

  }

  /**

   * Test adding multiple fields to a select statement at the same time.

   */

  function testSimpleSelectMultipleFields() {

    $record = db_select('test')

      ->fields('test', array('id', 'name', 'age', 'job'))

      ->condition('age', 27)

      ->execute()->fetchObject();

    // Check that all fields we asked for are 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, '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.');

  }

  /**

   * Test adding all fields from a given table to a select statement.

   */

  function testSimpleSelectAllFields() {

    $record = db_select('test')

      ->fields('test')

      ->condition('age', 27)

      ->execute()->fetchObject();

    // Check that all fields we asked for are 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, '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.');

  }

  /**

   * Test that we can find a record with a NULL value.