combo_field_storage.test

<?php

/**
 * Execute all the Field storage unit test with Combo-based field storage.
 */
class ComboFieldAttachStorageTestCase extends FieldAttachStorageTestCase {
  public static function getInfo() {
    return array(
      'name' => 'Field attach tests (Combo)',
      'description' => 'Test storage-related Field Attach API functions.',
      'group' => 'Combo',
    );
  }

  function setUp() {
    $this->default_storage = 'combo_field_storage';
    parent::setUp('combo', 'combo_field_storage');
  }
}

/**
 * Tests EntityFieldQuery.
 */
class ComboEntityFieldQueryTestCase extends DrupalWebTestCase {

  public static function getInfo() {
    return array(
      'name' => 'Entity query',
      'description' => 'Test the EntityFieldQuery class.',
      'group' => 'Combo',
    );
  }

  function setUp() {
    parent::setUp(array('combo', 'combo_field_storage', 'field_test'));
    variable_set('field_storage_default', 'combo_field_storage');

    field_attach_create_bundle('bundle1', 'test_entity_bundle_key');
    field_attach_create_bundle('bundle2', 'test_entity_bundle_key');
    field_attach_create_bundle('test_bundle', 'test_entity');
    field_attach_create_bundle('test_entity_bundle', 'test_entity_bundle');

    $instances = array();
    $this->fields = array();
    $this->field_names[0] = $field_name = drupal_strtolower($this->randomName() . '_field_name');
    $field = array('field_name' => $field_name, 'type' => 'test_field');
    $field = field_create_field($field);
    $this->fields[0] = $field;
    $instance = array(
      'field_name' => $field_name,
      'entity_type' => '',
      'bundle' => '',
      'label' => $this->randomName() . '_label',
      'description' => $this->randomName() . '_description',
      'weight' => mt_rand(0, 127),
      'settings' => array(
        'test_instance_setting' => $this->randomName(),
      ),
      'widget' => array(
        'type' => 'test_field_widget',
        'label' => 'Test Field',
        'settings' => array(
          'test_widget_setting' => $this->randomName(),
        )
      )
    );

    $instances[0] = $instance;

    // Add an instance to that bundle.
    $instances[0]['bundle'] = 'bundle1';
    $instances[0]['entity_type'] = 'test_entity_bundle_key';
    field_create_instance($instances[0]);
    $instances[0]['bundle'] = $instances[0]['entity_type'] = 'test_entity_bundle';
    field_create_instance($instances[0]);

    $this->field_names[1] = $field_name = drupal_strtolower($this->randomName() . '_field_name');
    $field = array('field_name' => $field_name, 'type' => 'shape', 'cardinality' => 4);
    $field = field_create_field($field);
    $this->fields[1] = $field;
    $instance = array(
      'field_name' => $field_name,
      'entity_type' => '',
      'bundle' => '',
      'label' => $this->randomName() . '_label',
      'description' => $this->randomName() . '_description',
      'weight' => mt_rand(0, 127),
      'settings' => array(
        'test_instance_setting' => $this->randomName(),
      ),
      'widget' => array(
        'type' => 'test_field_widget',
        'label' => 'Test Field',
        'settings' => array(
          'test_widget_setting' => $this->randomName(),
        )
      )
    );

    $instances[1] = $instance;

    // Add an instance to that bundle.
    $instances[1]['bundle'] = 'bundle2';
    $instances[1]['entity_type'] = 'test_entity_bundle_key';
    field_create_instance($instances[1]);
    $instances[1]['bundle'] = $instances[1]['entity_type'] = 'test_entity_bundle';
    field_create_instance($instances[1]);

    $this->instances = $instances;
    // Write entity base table if there is one.
    $entities = array();
    $key = 1;

    // Create entities which have a 'bundle key' defined.
    for ($i = 1; $i < 7; $i++) {
      $entity = new stdClass();
      $entity->ftid = $i;
      if ($i == 5) {
        $key++;
      }
      $entity->fttype = "bundle$key";

      $entity->{$this->field_names[$key - 1]}[LANGUAGE_NONE][0]['value'] = $i;
      drupal_write_record('test_entity_bundle_key', $entity);
      field_attach_insert('test_entity_bundle_key', $entity);
    }

    $entity = new stdClass();
    $entity->ftid = 5;
    $entity->fttype = 'bundle2';
    $entity->{$this->field_names[1]}[LANGUAGE_NONE][0]['shape'] = 'square';
    $entity->{$this->field_names[1]}[LANGUAGE_NONE][0]['color'] = 'red';
    $entity->{$this->field_names[1]}[LANGUAGE_NONE][1]['shape'] = 'circle';
    $entity->{$this->field_names[1]}[LANGUAGE_NONE][1]['color'] = 'blue';
    drupal_write_record('test_entity_bundle', $entity);
    field_attach_insert('test_entity_bundle', $entity);

    $instances[2] = $instance;
    $instances[2]['bundle'] = 'test_bundle';
    $instances[2]['field_name'] = $this->field_names[0];
    $instances[2]['entity_type'] = 'test_entity';
    field_create_instance($instances[2]);

    // Create entities with support for revisions.
    for ($i = 1; $i < 5; $i++) {
      $entity = new stdClass();
      $entity->ftid = $i;
      $entity->ftvid = $i;
      $entity->fttype = 'test_bundle';
      $entity->{$this->field_names[0]}[LANGUAGE_NONE][0]['value'] = $i;

      drupal_write_record('test_entity', $entity);
      field_attach_insert('test_entity', $entity);
      drupal_write_record('test_entity_revision', $entity);
    }

    // Add two revisions to an entity.
    for ($i = 100; $i < 102; $i++) {
      $entity = new stdClass();
      $entity->ftid = 4;
      $entity->ftvid = $i;
      $entity->fttype = 'test_bundle';
      $entity->{$this->field_names[0]}[LANGUAGE_NONE][0]['value'] = $i;

      drupal_write_record('test_entity', $entity, 'ftid');
      drupal_write_record('test_entity_revision', $entity);

      db_update('test_entity')
       ->fields(array('ftvid' => $entity->ftvid))
       ->condition('ftid', $entity->ftid)
       ->execute();

      field_attach_update('test_entity', $entity);
    }
  }

  /**
   * Tests EntityFieldQuery.
   */
  function testEntityFieldQuery() {
    // Test entity_type condition.
    $query = new EntityFieldQuery();
    $query->entityCondition('entity_type', 'test_entity_bundle_key');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 1),
      array('test_entity_bundle_key', 2),
      array('test_entity_bundle_key', 3),
      array('test_entity_bundle_key', 4),
      array('test_entity_bundle_key', 5),
      array('test_entity_bundle_key', 6),
    ), t('Test entity entity_type condition.'));

    // Test entity_id condition.
    $query = new EntityFieldQuery();
    $query
      ->entityCondition('entity_type', 'test_entity_bundle_key')
      ->entityCondition('entity_id', '3');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 3),
    ), t('Test entity entity_id condition.'));

    $query = new EntityFieldQuery();
    $query
      ->entityCondition('entity_type', 'test_entity_bundle_key')
      ->propertyCondition('ftid', '3');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 3),
    ), t('Test entity entity_id condition and entity_id property condition.'));

    // Test bundle condition.
    $query = new EntityFieldQuery();
    $query
      ->entityCondition('entity_type', 'test_entity_bundle_key')
      ->entityCondition('bundle', 'bundle1');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 1),
      array('test_entity_bundle_key', 2),
      array('test_entity_bundle_key', 3),
      array('test_entity_bundle_key', 4),
    ), t('Test entity bundle condition: bundle1.'));

    $query = new EntityFieldQuery();
    $query
      ->entityCondition('entity_type', 'test_entity_bundle_key')
      ->entityCondition('bundle', 'bundle2');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 5),
      array('test_entity_bundle_key', 6),
    ), t('Test entity bundle condition: bundle2.'));

    $query = new EntityFieldQuery();
    $query
      ->entityCondition('entity_type', 'test_entity_bundle_key')
      ->propertyCondition('fttype', 'bundle2');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 5),
      array('test_entity_bundle_key', 6),
    ), t('Test entity bundle condition and bundle property condition.'));

    // Test revision_id condition.
    $query = new EntityFieldQuery();
    $query
      ->entityCondition('entity_type', 'test_entity')
      ->entityCondition('revision_id', '3');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity', 3),
    ), t('Test entity revision_id condition.'));

    $query = new EntityFieldQuery();
    $query
      ->entityCondition('entity_type', 'test_entity')
      ->propertyCondition('ftvid', '3');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity', 3),
    ), t('Test entity revision_id condition and revision_id property condition.'));

    $query = new EntityFieldQuery();
    $query
      ->entityCondition('entity_type', 'test_entity')
      ->fieldCondition($this->fields[0], 'value', 100, '>=')
      ->age(FIELD_LOAD_REVISION);
    $this->assertEntityFieldQuery($query, array(
        array('test_entity', 100),
        array('test_entity', 101),
    ), t('Test revision age.'));

    // Test entity sort by entity_id.
    $query = new EntityFieldQuery();
    $query
      ->entityCondition('entity_type', 'test_entity_bundle_key')
      ->entityOrderBy('entity_id', 'ASC');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 1),
      array('test_entity_bundle_key', 2),
      array('test_entity_bundle_key', 3),
      array('test_entity_bundle_key', 4),
      array('test_entity_bundle_key', 5),
      array('test_entity_bundle_key', 6),
    ), t('Test sort entity entity_id in ascending order.'), TRUE);

    $query = new EntityFieldQuery();
    $query
      ->entityCondition('entity_type', 'test_entity_bundle_key')
      ->entityOrderBy('entity_id', 'DESC');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 6),
      array('test_entity_bundle_key', 5),
      array('test_entity_bundle_key', 4),
      array('test_entity_bundle_key', 3),
      array('test_entity_bundle_key', 2),
      array('test_entity_bundle_key', 1),
    ), t('Test sort entity entity_id in descending order.'), TRUE);

    // Test property sort by entity id.
    $query = new EntityFieldQuery();
    $query
      ->entityCondition('entity_type', 'test_entity_bundle_key')
      ->propertyOrderBy('ftid', 'ASC');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 1),
      array('test_entity_bundle_key', 2),
      array('test_entity_bundle_key', 3),
      array('test_entity_bundle_key', 4),
      array('test_entity_bundle_key', 5),
      array('test_entity_bundle_key', 6),
    ), t('Test sort entity entity_id property in ascending order.'), TRUE);

    $query = new EntityFieldQuery();
    $query
      ->entityCondition('entity_type', 'test_entity_bundle_key')
      ->propertyOrderBy('ftid', 'DESC');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 6),
      array('test_entity_bundle_key', 5),
      array('test_entity_bundle_key', 4),
      array('test_entity_bundle_key', 3),
      array('test_entity_bundle_key', 2),
      array('test_entity_bundle_key', 1),
    ), t('Test sort entity entity_id property in descending order.'), TRUE);

    // Test entity sort by bundle.
    $query = new EntityFieldQuery();
    $query
      ->entityCondition('entity_type', 'test_entity_bundle_key')
      ->entityOrderBy('bundle', 'ASC')
      ->propertyOrderBy('ftid', 'ASC');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 1),
      array('test_entity_bundle_key', 2),
      array('test_entity_bundle_key', 3),
      array('test_entity_bundle_key', 4),
      array('test_entity_bundle_key', 5),
      array('test_entity_bundle_key', 6),
    ), t('Test sort entity bundle in ascending order.'), TRUE);

    $query = new EntityFieldQuery();
    $foo = $query
      ->entityCondition('entity_type', 'test_entity_bundle_key')
      ->entityOrderBy('bundle', 'DESC')
      ->propertyOrderBy('ftid', 'DESC');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 6),
      array('test_entity_bundle_key', 5),
      array('test_entity_bundle_key', 4),
      array('test_entity_bundle_key', 3),
      array('test_entity_bundle_key', 2),
      array('test_entity_bundle_key', 1),
    ), t('Test sort entity bundle in descending order.'), TRUE);

    // Test entity sort by revision_id.
    $query = new EntityFieldQuery();
    $query
      ->entityCondition('entity_type', 'test_entity')
      ->entityOrderBy('revision_id', 'ASC');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity', 1),
      array('test_entity', 2),
      array('test_entity', 3),
      array('test_entity', 4),
    ), t('Test sort entity revision_id in ascending order.'), TRUE);

    $query = new EntityFieldQuery();
    $query
      ->entityCondition('entity_type', 'test_entity')
      ->entityOrderBy('revision_id', 'DESC');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity', 4),
      array('test_entity', 3),
      array('test_entity', 2),
      array('test_entity', 1),
    ), t('Test sort entity revision_id in descending order.'), TRUE);

    // Test property sort by revision_id.
    $query = new EntityFieldQuery();
    $query
      ->entityCondition('entity_type', 'test_entity')
      ->propertyOrderBy('ftvid', 'ASC');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity', 1),
      array('test_entity', 2),
      array('test_entity', 3),
      array('test_entity', 4),
    ), t('Test sort entity revision_id property in ascending order.'), TRUE);

    $query = new EntityFieldQuery();
    $query
      ->entityCondition('entity_type', 'test_entity')
      ->propertyOrderBy('ftvid', 'DESC');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity', 4),
      array('test_entity', 3),
      array('test_entity', 2),
      array('test_entity', 1),
    ), t('Test sort entity revision_id property in descending order.'), TRUE);

    $query = new EntityFieldQuery();
    $query->entityCondition('entity_type', 'test_entity_bundle_key');
    $query->fieldOrderBy($this->fields[0], 'value', 'ASC');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 1),
      array('test_entity_bundle_key', 2),
      array('test_entity_bundle_key', 3),
      array('test_entity_bundle_key', 4),
    ), t('Test sort field in ascending order without field condition.'), TRUE);

    $query = new EntityFieldQuery();
    $query->entityCondition('entity_type', 'test_entity_bundle_key');
    $query->fieldOrderBy($this->fields[0], 'value', 'DESC');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 4),
      array('test_entity_bundle_key', 3),
      array('test_entity_bundle_key', 2),
      array('test_entity_bundle_key', 1),
    ), t('Test sort field in descending order without field condition.'), TRUE);

    $query = new EntityFieldQuery();
    $query->entityCondition('entity_type', 'test_entity_bundle_key');
    $query->fieldCondition($this->fields[0], 'value', 0, '>');
    $query->fieldOrderBy($this->fields[0], 'value', 'ASC');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 1),
      array('test_entity_bundle_key', 2),
      array('test_entity_bundle_key', 3),
      array('test_entity_bundle_key', 4),
    ), t('Test sort field in ascending order.'), TRUE);

    $query = new EntityFieldQuery();
    $query->entityCondition('entity_type', 'test_entity_bundle_key');
    $query->fieldCondition($this->fields[0], 'value', 0, '>');
    $query->fieldOrderBy($this->fields[0], 'value', 'DESC');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 4),
      array('test_entity_bundle_key', 3),
      array('test_entity_bundle_key', 2),
      array('test_entity_bundle_key', 1),
    ), t('Test sort field in descending order.'), TRUE);

    // Test "in" operation with entity entity_type condition and entity_id
    // property condition.
    $query = new EntityFieldQuery();
    $query
      ->entityCondition('entity_type', 'test_entity_bundle_key')
      ->propertyCondition('ftid', array(1, 3, 4), 'IN');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 1),
      array('test_entity_bundle_key', 3),
      array('test_entity_bundle_key', 4),
    ), t('Test "in" operation with entity entity_type condition and entity_id property condition.'));

    // Test "in" operation with entity entity_type condition and entity_id
    // property condition. Sort in descending order by entity_id.
    $query = new EntityFieldQuery();
    $query
      ->entityCondition('entity_type', 'test_entity_bundle_key')
      ->propertyCondition('ftid', array(1, 3, 4), 'IN')
      ->propertyOrderBy('ftid', 'DESC');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 4),
      array('test_entity_bundle_key', 3),
      array('test_entity_bundle_key', 1),
    ), t('Test "in" operation with entity entity_type condition and entity_id property condition. Sort entity_id in descending order.'), TRUE);

    // Test query count
    $query = new EntityFieldQuery();
    $query_count = $query
      ->entityCondition('entity_type', 'test_entity_bundle_key')
      ->count()
      ->execute();
    $this->assertEqual($query_count, 6, t('Test query count on entity condition.'));

    $query = new EntityFieldQuery();
    $query_count = $query
      ->entityCondition('entity_type', 'test_entity_bundle_key')
      ->propertyCondition('ftid', '1')
      ->count()
      ->execute();
    $this->assertEqual($query_count, 1, t('Test query count on entity and property condition.'));

    $query = new EntityFieldQuery();
    $query_count = $query
      ->entityCondition('entity_type', 'test_entity_bundle_key')
      ->propertyCondition('ftid', '4', '>')
      ->count()
      ->execute();
    $this->assertEqual($query_count, 2, t('Test query count on entity and property condition with operator.'));

    $query = new EntityFieldQuery();
    $query_count = $query
      ->entityCondition('entity_type', 'test_entity_bundle_key')
      ->fieldCondition($this->fields[0], 'value', 3, '=')
      ->count()
      ->execute();
    $this->assertEqual($query_count, 1, t('Test query count on field condition.'));

    // First, test without options.
    $query = new EntityFieldQuery();
    $query
      ->entityCondition('entity_type', 'test_entity_bundle_key')
      ->propertyCondition('fttype', 'undle2', 'CONTAINS');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 5),
      array('test_entity_bundle_key', 6),
    ), t('Test the "contains" operation on a property.'));

    $query = new EntityFieldQuery();
    $query->fieldCondition($this->fields[1], 'shape', 'quar', 'CONTAINS');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle', 5),
    ), t('Test the "contains" operation on a field finds appropriately.'));

    $query = new EntityFieldQuery();
    $query->fieldCondition($this->fields[1], 'shape', 'foobar', 'CONTAINS');
    $this->assertEntityFieldQuery($query, array(
    ), t('Test the "contains" operation on a field does not find more than necessary.'));

    $query = new EntityFieldQuery();
    $query
      ->entityCondition('entity_type', 'test_entity_bundle_key')
      ->propertyCondition('ftid', 1, '=');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 1),
    ), t('Test the "equal to" operation on a property.'));

    $query = new EntityFieldQuery();
    $query->fieldCondition($this->fields[0], 'value', 3, '=');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 3),
      array('test_entity', 3),
    ), t('Test the "equal to" operation on a field.'));

    $query = new EntityFieldQuery();
    $query
      ->entityCondition('entity_type', 'test_entity_bundle_key')
      ->propertyCondition('ftid', 3, '<>');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 1),
      array('test_entity_bundle_key', 2),
      array('test_entity_bundle_key', 4),
      array('test_entity_bundle_key', 5),
      array('test_entity_bundle_key', 6),
    ), t('Test the "not equal to" operation on a property.'));

    $query = new EntityFieldQuery();
    $query->fieldCondition($this->fields[0], 'value', 3, '<>');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 1),
      array('test_entity_bundle_key', 2),
      array('test_entity_bundle_key', 4),
      array('test_entity', 1),
      array('test_entity', 2),
      array('test_entity', 4),
    ), t('Test the "not equal to" operation on a field.'));

    $query = new EntityFieldQuery();
    $query
      ->entityCondition('entity_type', 'test_entity_bundle_key')
      ->propertyCondition('ftid', 2, '<');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 1),
    ), t('Test the "less than" operation on a property.'));

    $query = new EntityFieldQuery();
    $query->fieldCondition($this->fields[0], 'value', 2, '<');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 1),
      array('test_entity', 1),
    ), t('Test the "less than" operation on a field.'));

    $query = new EntityFieldQuery();
    $query
      ->entityCondition('entity_type', 'test_entity_bundle_key')
      ->propertyCondition('ftid', 2, '<=');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 1),
      array('test_entity_bundle_key', 2),
    ), t('Test the "less than or equal to" operation on a property.'));

    $query = new EntityFieldQuery();
    $query->fieldCondition($this->fields[0], 'value', 2, '<=');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 1),
      array('test_entity_bundle_key', 2),
      array('test_entity', 1),
      array('test_entity', 2),
    ), t('Test the "less than or equal to" operation on a field.'));

    $query = new EntityFieldQuery();
    $query
      ->entityCondition('entity_type', 'test_entity_bundle_key')
      ->propertyCondition('ftid', 4, '>');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 5),
      array('test_entity_bundle_key', 6),
    ), t('Test the "greater than" operation on a property.'));

    $query = new EntityFieldQuery();
    $query->fieldCondition($this->fields[0], 'value', 2, '>');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 3),
      array('test_entity_bundle_key', 4),
      array('test_entity', 3),
      array('test_entity', 4),
    ), t('Test the "greater than" operation on a field.'));

    $query = new EntityFieldQuery();
    $query
      ->entityCondition('entity_type', 'test_entity_bundle_key')
      ->propertyCondition('ftid', 4, '>=');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 4),
      array('test_entity_bundle_key', 5),
      array('test_entity_bundle_key', 6),
    ), t('Test the "greater than or equal to" operation on a property.'));

    $query = new EntityFieldQuery();
    $query->fieldCondition($this->fields[0], 'value', 3, '>=');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 3),
      array('test_entity_bundle_key', 4),
      array('test_entity', 3),
      array('test_entity', 4),
    ), t('Test the "greater than or equal to" operation on a field.'));

    $query = new EntityFieldQuery();
    $query
      ->entityCondition('entity_type', 'test_entity_bundle_key')
      ->propertyCondition('ftid', array(3, 4), 'NOT IN');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 1),
      array('test_entity_bundle_key', 2),
      array('test_entity_bundle_key', 5),
      array('test_entity_bundle_key', 6),
    ), t('Test the "not in" operation on a property.'));

    $query = new EntityFieldQuery();
    $query->fieldCondition($this->fields[0], 'value', array(3, 4, 100, 101), 'NOT IN');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 1),
      array('test_entity_bundle_key', 2),
      array('test_entity', 1),
      array('test_entity', 2),
    ), t('Test the "not in" operation on a field.'));

    $query = new EntityFieldQuery();
    $query
      ->entityCondition('entity_type', 'test_entity_bundle_key')
      ->propertyCondition('ftid', array(3, 4), 'IN');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 3),
      array('test_entity_bundle_key', 4),
    ), t('Test the "in" operation on a property.'));

    $query = new EntityFieldQuery();
    $query->fieldCondition($this->fields[0], 'value', array(2, 3), 'IN');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 2),
      array('test_entity_bundle_key', 3),
      array('test_entity', 2),
      array('test_entity', 3),
    ), t('Test the "in" operation on a field.'));

    $query = new EntityFieldQuery();
    $query
      ->entityCondition('entity_type', 'test_entity_bundle_key')
      ->propertyCondition('ftid', array(1, 3), 'BETWEEN');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 1),
      array('test_entity_bundle_key', 2),
      array('test_entity_bundle_key', 3),
    ), t('Test the "between" operation on a property.'));

    $query = new EntityFieldQuery();
    $query->fieldCondition($this->fields[0], 'value', array(1, 3), 'BETWEEN');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 1),
      array('test_entity_bundle_key', 2),
      array('test_entity_bundle_key', 3),
      array('test_entity', 1),
      array('test_entity', 2),
      array('test_entity', 3),
    ), t('Test the "between" operation on a field.'));

    $query = new EntityFieldQuery();
    $query
      ->entityCondition('entity_type', 'test_entity_bundle_key')
      ->propertyCondition('fttype', 'bun', 'STARTS_WITH');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 1),
      array('test_entity_bundle_key', 2),
      array('test_entity_bundle_key', 3),
      array('test_entity_bundle_key', 4),
      array('test_entity_bundle_key', 5),
      array('test_entity_bundle_key', 6),
    ), t('Test the "starts_with" operation on a property.'));

    $query = new EntityFieldQuery();
    $query->fieldCondition($this->fields[1], 'shape', 'squ', 'STARTS_WITH');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle', 5),
    ), t('Test the "starts_with" operation on a field.'));

    $query = new EntityFieldQuery();
    $query->fieldCondition($this->fields[0], 'value', 3);
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 3),
      array('test_entity', 3),
    ), t('Test omission of an operator with a single item.'));

    $query = new EntityFieldQuery();
    $query->fieldCondition($this->fields[0], 'value', array(2, 3));
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 2),
      array('test_entity_bundle_key', 3),
      array('test_entity', 2),
      array('test_entity', 3),
    ), t('Test omission of an operator with multiple items.'));

    $query = new EntityFieldQuery();
    $query
      ->entityCondition('entity_type', 'test_entity_bundle_key')
      ->propertyCondition('ftid', 1, '>')
      ->fieldCondition($this->fields[0], 'value', 4, '<');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 2),
      array('test_entity_bundle_key', 3),
    ), t('Test entity, property and field conditions.'));

    $query = new EntityFieldQuery();
    $query
      ->entityCondition('entity_type', 'test_entity_bundle_key')
      ->entityCondition('bundle', 'bundle', 'STARTS_WITH')
      ->propertyCondition('ftid', 4)
      ->fieldCondition($this->fields[0], 'value', 4);
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 4),
    ), t('Test entity condition with "starts_with" operation, and property and field conditions.'));

    $query = new EntityFieldQuery();
    $query->entityCondition('entity_type', 'test_entity_bundle_key');
    $query->propertyOrderBy('ftid', 'ASC');
    $query->range(0, 2);
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 1),
      array('test_entity_bundle_key', 2),
    ), t('Test limit on a property.'), TRUE);

    $query = new EntityFieldQuery();
    $query->entityCondition('entity_type', 'test_entity_bundle_key');
    $query->fieldCondition($this->fields[0], 'value', 0, '>=');
    $query->fieldOrderBy($this->fields[0], 'value', 'ASC');
    $query->range(0, 2);
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 1),
      array('test_entity_bundle_key', 2),
    ), t('Test limit on a field.'), TRUE);

    $query = new EntityFieldQuery();
    $query->entityCondition('entity_type', 'test_entity_bundle_key');
    $query->propertyOrderBy('ftid', 'ASC');
    $query->range(4, 6);
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 5),
      array('test_entity_bundle_key', 6),
    ), t('Test offset on a property.'), TRUE);

    $query = new EntityFieldQuery();
    $query->entityCondition('entity_type', 'test_entity_bundle_key');
    $query->fieldCondition($this->fields[0], 'value', 0, '>');
    $query->fieldOrderBy($this->fields[0], 'value', 'ASC');
    $query->range(2, 4);
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 3),
      array('test_entity_bundle_key', 4),
    ), t('Test offset on a field.'), TRUE);

    for ($i = 6; $i < 10; $i++) {
      $entity = new stdClass();
      $entity->ftid = $i;
      $entity->{$this->field_names[0]}[LANGUAGE_NONE][0]['value'] = $i - 5;
      drupal_write_record('test_entity_bundle', $entity);
      field_attach_insert('test_entity_bundle', $entity);
    }

    $query = new EntityFieldQuery();
    $query->fieldCondition($this->fields[0], 'value', 2, '>');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 3),
      array('test_entity_bundle_key', 4),
      array('test_entity', 3),
      array('test_entity', 4),
      array('test_entity_bundle', 8),
      array('test_entity_bundle', 9),
    ), t('Select a field across multiple entities.'));

    $query = new EntityFieldQuery();
    $query->fieldCondition($this->fields[1], 'shape', 'square');
    $query->fieldCondition($this->fields[1], 'color', 'blue');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle', 5),
    ), t('Test without a delta group.'));

    $query = new EntityFieldQuery();
    $query->fieldCondition($this->fields[1], 'shape', 'square', '=', 'group');
    $query->fieldCondition($this->fields[1], 'color', 'blue', '=', 'group');
    $this->assertEntityFieldQuery($query, array(), t('Test with a delta group.'));

    // Test query on a deleted field.
    field_attach_delete_bundle('test_entity_bundle_key', 'bundle1');
    field_attach_delete_bundle('test_entity', 'test_bundle');
    $query = new EntityFieldQuery();
    $query->fieldCondition($this->fields[0], 'value', '3');
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle', 8),
    ), t('Test query on a field after deleting field from some entities.'));

    field_attach_delete_bundle('test_entity_bundle', 'test_entity_bundle');
    $query = new EntityFieldQuery();
    $query->fieldCondition($this->fields[0], 'value', '3');
    $this->assertEntityFieldQuery($query, array(), t('Test query on a field after deleting field from all entities.'));

    $query = new EntityFieldQuery();
    $query
      ->fieldCondition($this->fields[0], 'value', '3')
      ->deleted(TRUE);
    $this->assertEntityFieldQuery($query, array(
      array('test_entity_bundle_key', 3),
      array('test_entity_bundle', 8),
      array('test_entity', 3),
    ), t('Test query on a deleted field with deleted option set to TRUE.'));
  }

  /**
   * Fetches the results of an EntityFieldQuery and compares.
   *
   * @param $query
   *   An EntityFieldQuery to run.
   * @param $intended_results
   *   A list of results, every entry is again a list, first being the entity
   *   type, the second being the entity_id.
   * @param $message
   *   The message to be displayed as the result of this test.
   * @param $ordered
   *   If FALSE then the result of EntityFieldQuery will match
   *   $intended_results even if the order is not the same. If TRUE then order
   *   should match too.
   */
  function assertEntityFieldQuery($query, $intended_results, $message, $ordered = FALSE) {
    $results = array();
    try {
      foreach ($query->execute() as $entity_type => $entity_ids) {
        foreach ($entity_ids as $entity_id => $stub_entity) {
          $results[] = array($entity_type, $entity_id);
        }
      }
      if (!isset($ordered) || !$ordered) {
        sort($results);
        sort($intended_results);
      }
      if ($results != $intended_results) {
        debug($results);
        debug($intended_results);
      }
      $this->assertEqual($results, $intended_results, $message);
    }
    catch (EntityFieldQueryException $e) {
      $this->fail('Exception thrown: '. $e->getMessage());
    }
  }
}