Club Drupal

<?php

/**

 * @file

 * Tests for field.module.

 */

/**

 * Parent class for Field API tests.

 */

class FieldTestCase extends DrupalWebTestCase {

  var $default_storage = 'field_sql_storage';

  /**

   * Set the default field storage backend for fields created during tests.

   */

  function setUp() {

    // Since this is a base class for many test cases, support the same

    // flexibility that DrupalWebTestCase::setUp() has for the modules to be

    // passed in as either an array or a variable number of string arguments.

    $modules = func_get_args();

    if (isset($modules[0]) && is_array($modules[0])) {

      $modules = $modules[0];

    }

    parent::setUp($modules);

    // Set default storage backend.

    variable_set('field_storage_default', $this->default_storage);

  }

  /**

   * Generate random values for a field_test field.

   *

   * @param $cardinality

   *   Number of values to generate.

   * @return

   *  An array of random values, in the format expected for field values.

   */

  function _generateTestFieldValues($cardinality) {

    $values = array();

    for ($i = 0; $i < $cardinality; $i++) {

      // field_test fields treat 0 as 'empty value'.

      $values[$i]['value'] = mt_rand(1, 127);

    }

    return $values;

  }

  /**

   * Assert that a field has the expected values in an entity.

   *

   * This function only checks a single column in the field values.

   *

   * @param $entity

   *   The entity to test.

   * @param $field_name

   *   The name of the field to test

   * @param $langcode

   *   The language code for the values.

   * @param $expected_values

   *   The array of expected values.

   * @param $column

   *   (Optional) the name of the column to check.

   */

  function assertFieldValues($entity, $field_name, $langcode, $expected_values, $column = 'value') {

    $e = clone $entity;

    field_attach_load('test_entity', array($e->ftid => $e));

    $values = isset($e->{$field_name}[$langcode]) ? $e->{$field_name}[$langcode] : array();

    $this->assertEqual(count($values), count($expected_values), 'Expected number of values were saved.');

    foreach ($expected_values as $key => $value) {

      $this->assertEqual($values[$key][$column], $value, format_string('Value @value was saved correctly.', array('@value' => $value)));

    }

  }

}

class FieldAttachTestCase extends FieldTestCase {

  function setUp() {

    // Since this is a base class for many test cases, support the same

    // flexibility that DrupalWebTestCase::setUp() has for the modules to be

    // passed in as either an array or a variable number of string arguments.

    $modules = func_get_args();

    if (isset($modules[0]) && is_array($modules[0])) {

      $modules = $modules[0];

    }

    if (!in_array('field_test', $modules)) {

      $modules[] = 'field_test';

    }

    parent::setUp($modules);

    $this->createFieldWithInstance();

  }

  /**

   * Create a field and an instance of it.

   *

   * @param string $suffix

   *   (optional) A string that should only contain characters that are valid in

   *   PHP variable names as well.

   */

  function createFieldWithInstance($suffix = '') {

    $field_name = 'field_name' . $suffix;

    $field = 'field' . $suffix;

    $field_id = 'field_id' . $suffix;

    $instance = 'instance' . $suffix;

    $this->$field_name = drupal_strtolower($this->randomName() . '_field_name' . $suffix);

    $this->$field = array('field_name' => $this->$field_name, 'type' => 'test_field', 'cardinality' => 4);

    $this->$field = field_create_field($this->$field);

    $this->$field_id = $this->{$field}['id'];

    $this->$instance = array(

      'field_name' => $this->$field_name,

      'entity_type' => 'test_entity',

      'bundle' => 'test_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(),

        )

      )

    );

    field_create_instance($this->$instance);

  }

}

/**

 * Unit test class for storage-related field_attach_* functions.

 *

 * All field_attach_* test work with all field_storage plugins and

 * all hook_field_attach_pre_{load,insert,update}() hooks.

 */

class FieldAttachStorageTestCase extends FieldAttachTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Field attach tests (storage-related)',

      'description' => 'Test storage-related Field Attach API functions.',

      'group' => 'Field API',

    );

  }

  /**

   * Check field values insert, update and load.

   *

   * Works independently of the underlying field storage backend. Inserts or

   * updates random field data and then loads and verifies the data.

   */

  function testFieldAttachSaveLoad() {

    // Configure the instance so that we test hook_field_load() (see

    // field_test_field_load() in field_test.module).

    $this->instance['settings']['test_hook_field_load'] = TRUE;

    field_update_instance($this->instance);

    $langcode = LANGUAGE_NONE;

    $entity_type = 'test_entity';

    $values = array();

    // TODO : test empty values filtering and "compression" (store consecutive deltas).

    // Preparation: create three revisions and store them in $revision array.

    for ($revision_id = 0; $revision_id < 3; $revision_id++) {

      $revision[$revision_id] = field_test_create_stub_entity(0, $revision_id, $this->instance['bundle']);

      // Note: we try to insert one extra value.

      $values[$revision_id] = $this->_generateTestFieldValues($this->field['cardinality'] + 1);

      $current_revision = $revision_id;

      // If this is the first revision do an insert.

      if (!$revision_id) {

        $revision[$revision_id]->{$this->field_name}[$langcode] = $values[$revision_id];

        field_attach_insert($entity_type, $revision[$revision_id]);

      }

      else {

        // Otherwise do an update.

        $revision[$revision_id]->{$this->field_name}[$langcode] = $values[$revision_id];

        field_attach_update($entity_type, $revision[$revision_id]);

      }

    }

    // Confirm current revision loads the correct data.

    $entity = field_test_create_stub_entity(0, 0, $this->instance['bundle']);

    field_attach_load($entity_type, array(0 => $entity));

    // Number of values per field loaded equals the field cardinality.

    $this->assertEqual(count($entity->{$this->field_name}[$langcode]), $this->field['cardinality'], 'Current revision: expected number of values');

    for ($delta = 0; $delta < $this->field['cardinality']; $delta++) {

      // The field value loaded matches the one inserted or updated.

      $this->assertEqual($entity->{$this->field_name}[$langcode][$delta]['value'] , $values[$current_revision][$delta]['value'], format_string('Current revision: expected value %delta was found.', array('%delta' => $delta)));

      // The value added in hook_field_load() is found.

      $this->assertEqual($entity->{$this->field_name}[$langcode][$delta]['additional_key'], 'additional_value', format_string('Current revision: extra information for value %delta was found', array('%delta' => $delta)));

    }

    // Confirm each revision loads the correct data.

    foreach (array_keys($revision) as $revision_id) {

      $entity = field_test_create_stub_entity(0, $revision_id, $this->instance['bundle']);

      field_attach_load_revision($entity_type, array(0 => $entity));

      // Number of values per field loaded equals the field cardinality.

      $this->assertEqual(count($entity->{$this->field_name}[$langcode]), $this->field['cardinality'], format_string('Revision %revision_id: expected number of values.', array('%revision_id' => $revision_id)));

      for ($delta = 0; $delta < $this->field['cardinality']; $delta++) {

        // The field value loaded matches the one inserted or updated.

        $this->assertEqual($entity->{$this->field_name}[$langcode][$delta]['value'], $values[$revision_id][$delta]['value'], format_string('Revision %revision_id: expected value %delta was found.', array('%revision_id' => $revision_id, '%delta' => $delta)));

        // The value added in hook_field_load() is found.

        $this->assertEqual($entity->{$this->field_name}[$langcode][$delta]['additional_key'], 'additional_value', format_string('Revision %revision_id: extra information for value %delta was found', array('%revision_id' => $revision_id, '%delta' => $delta)));

      }

    }

  }

  /**

   * Test the 'multiple' load feature.

   */

  function testFieldAttachLoadMultiple() {

    $entity_type = 'test_entity';

    $langcode = LANGUAGE_NONE;

    // Define 2 bundles.

    $bundles = array(

      1 => 'test_bundle_1',

      2 => 'test_bundle_2',

    );

    field_test_create_bundle($bundles[1]);

    field_test_create_bundle($bundles[2]);

    // Define 3 fields:

    // - field_1 is in bundle_1 and bundle_2,

    // - field_2 is in bundle_1,

    // - field_3 is in bundle_2.

    $field_bundles_map = array(

      1 => array(1, 2),

      2 => array(1),

      3 => array(2),

    );

    for ($i = 1; $i <= 3; $i++) {

      $field_names[$i] = 'field_' . $i;

      $field = array('field_name' => $field_names[$i], 'type' => 'test_field');

      $field = field_create_field($field);

      $field_ids[$i] = $field['id'];

      foreach ($field_bundles_map[$i] as $bundle) {

        $instance = array(

          'field_name' => $field_names[$i],

          'entity_type' => 'test_entity',

          'bundle' => $bundles[$bundle],

          'settings' => array(

            // Configure the instance so that we test hook_field_load()

            // (see field_test_field_load() in field_test.module).

            'test_hook_field_load' => TRUE,

          ),

        );

        field_create_instance($instance);

      }

    }

    // Create one test entity per bundle, with random values.

    foreach ($bundles as $index => $bundle) {

      $entities[$index] = field_test_create_stub_entity($index, $index, $bundle);

      $entity = clone($entities[$index]);

      $instances = field_info_instances('test_entity', $bundle);

      foreach ($instances as $field_name => $instance) {

        $values[$index][$field_name] = mt_rand(1, 127);

        $entity->$field_name = array($langcode => array(array('value' => $values[$index][$field_name])));

      }

      field_attach_insert($entity_type, $entity);

    }

    // Check that a single load correctly loads field values for both entities.

    field_attach_load($entity_type, $entities);

    foreach ($entities as $index => $entity) {

      $instances = field_info_instances($entity_type, $bundles[$index]);

      foreach ($instances as $field_name => $instance) {

        // The field value loaded matches the one inserted.

        $this->assertEqual($entity->{$field_name}[$langcode][0]['value'], $values[$index][$field_name], format_string('Entity %index: expected value was found.', array('%index' => $index)));

        // The value added in hook_field_load() is found.

        $this->assertEqual($entity->{$field_name}[$langcode][0]['additional_key'], 'additional_value', format_string('Entity %index: extra information was found', array('%index' => $index)));

      }

    }

    // Check that the single-field load option works.

    $entity = field_test_create_stub_entity(1, 1, $bundles[1]);

    field_attach_load($entity_type, array(1 => $entity), FIELD_LOAD_CURRENT, array('field_id' => $field_ids[1]));

    $this->assertEqual($entity->{$field_names[1]}[$langcode][0]['value'], $values[1][$field_names[1]], format_string('Entity %index: expected value was found.', array('%index' => 1)));

    $this->assertEqual($entity->{$field_names[1]}[$langcode][0]['additional_key'], 'additional_value', format_string('Entity %index: extra information was found', array('%index' => 1)));

    $this->assert(!isset($entity->{$field_names[2]}), format_string('Entity %index: field %field_name is not loaded.', array('%index' => 2, '%field_name' => $field_names[2])));

    $this->assert(!isset($entity->{$field_names[3]}), format_string('Entity %index: field %field_name is not loaded.', array('%index' => 3, '%field_name' => $field_names[3])));

  }

  /**

   * Test saving and loading fields using different storage backends.

   */

  function testFieldAttachSaveLoadDifferentStorage() {

    $entity_type = 'test_entity';

    $langcode = LANGUAGE_NONE;

    // Create two fields using different storage backends, and their instances.

    $fields = array(

      array(

        'field_name' => 'field_1',

        'type' => 'test_field',

        'cardinality' => 4,

        'storage' => array('type' => 'field_sql_storage')

      ),

      array(

        'field_name' => 'field_2',

        'type' => 'test_field',

        'cardinality' => 4,

        'storage' => array('type' => 'field_test_storage')

      ),

    );

    foreach ($fields as $field) {

      field_create_field($field);

      $instance = array(

        'field_name' => $field['field_name'],

        'entity_type' => 'test_entity',

        'bundle' => 'test_bundle',

      );

      field_create_instance($instance);

    }

    $entity_init = field_test_create_stub_entity();

    // Create entity and insert random values.

    $entity = clone($entity_init);

    $values = array();

    foreach ($fields as $field) {

      $values[$field['field_name']] = $this->_generateTestFieldValues($this->field['cardinality']);

      $entity->{$field['field_name']}[$langcode] = $values[$field['field_name']];

    }

    field_attach_insert($entity_type, $entity);

    // Check that values are loaded as expected.

    $entity = clone($entity_init);

    field_attach_load($entity_type, array($entity->ftid => $entity));

    foreach ($fields as $field) {

      $this->assertEqual($values[$field['field_name']], $entity->{$field['field_name']}[$langcode], format_string('%storage storage: expected values were found.', array('%storage' => $field['storage']['type'])));

    }

  }

  /**

   * Test storage details alteration.

   *

   * @see field_test_storage_details_alter()

   */

  function testFieldStorageDetailsAlter() {

    $field_name = 'field_test_change_my_details';

    $field = array(

      'field_name' => $field_name,

      'type' => 'test_field',

      'cardinality' => 4,

      'storage' => array('type' => 'field_test_storage'),

    );

    $field = field_create_field($field);

    $instance = array(

      'field_name' => $field_name,

      'entity_type' => 'test_entity',

      'bundle' => 'test_bundle',

    );

    field_create_instance($instance);

    $field = field_info_field($instance['field_name']);

    $instance = field_info_instance($instance['entity_type'], $instance['field_name'], $instance['bundle']);

    // The storage details are indexed by a storage engine type.

    $this->assertTrue(array_key_exists('drupal_variables', $field['storage']['details']), 'The storage type is Drupal variables.');

    $details = $field['storage']['details']['drupal_variables'];

    // The field_test storage details are indexed by variable name. The details

    // are altered, so moon and mars are correct for this test.

    $this->assertTrue(array_key_exists('moon', $details[FIELD_LOAD_CURRENT]), 'Moon is available in the instance array.');

    $this->assertTrue(array_key_exists('mars', $details[FIELD_LOAD_REVISION]), 'Mars is available in the instance array.');

    // Test current and revision storage details together because the columns

    // are the same.

    foreach ((array) $field['columns'] as $column_name => $attributes) {

      $this->assertEqual($details[FIELD_LOAD_CURRENT]['moon'][$column_name], $column_name, format_string('Column name %value matches the definition in %bin.', array('%value' => $column_name, '%bin' => 'moon[FIELD_LOAD_CURRENT]')));

      $this->assertEqual($details[FIELD_LOAD_REVISION]['mars'][$column_name], $column_name, format_string('Column name %value matches the definition in %bin.', array('%value' => $column_name, '%bin' => 'mars[FIELD_LOAD_REVISION]')));

    }

  }

  /**

   * Tests insert and update with missing or NULL fields.

   */

  function testFieldAttachSaveMissingData() {

    $entity_type = 'test_entity';

    $entity_init = field_test_create_stub_entity();

    $langcode = LANGUAGE_NONE;

    // Insert: Field is missing.

    $entity = clone($entity_init);

    field_attach_insert($entity_type, $entity);

    $entity = clone($entity_init);

    field_attach_load($entity_type, array($entity->ftid => $entity));

    $this->assertTrue(empty($entity->{$this->field_name}), 'Insert: missing field results in no value saved');

    // Insert: Field is NULL.

    field_cache_clear();

    $entity = clone($entity_init);

    $entity->{$this->field_name} = NULL;

    field_attach_insert($entity_type, $entity);

    $entity = clone($entity_init);

    field_attach_load($entity_type, array($entity->ftid => $entity));

    $this->assertTrue(empty($entity->{$this->field_name}), 'Insert: NULL field results in no value saved');

    // Add some real data.

    field_cache_clear();

    $entity = clone($entity_init);

    $values = $this->_generateTestFieldValues(1);

    $entity->{$this->field_name}[$langcode] = $values;

    field_attach_insert($entity_type, $entity);

    $entity = clone($entity_init);

    field_attach_load($entity_type, array($entity->ftid => $entity));

    $this->assertEqual($entity->{$this->field_name}[$langcode], $values, 'Field data saved');

    // Update: Field is missing. Data should survive.

    field_cache_clear();

    $entity = clone($entity_init);

    field_attach_update($entity_type, $entity);

    $entity = clone($entity_init);

    field_attach_load($entity_type, array($entity->ftid => $entity));

    $this->assertEqual($entity->{$this->field_name}[$langcode], $values, 'Update: missing field leaves existing values in place');

    // Update: Field is NULL. Data should be wiped.

    field_cache_clear();

    $entity = clone($entity_init);

    $entity->{$this->field_name} = NULL;

    field_attach_update($entity_type, $entity);

    $entity = clone($entity_init);

    field_attach_load($entity_type, array($entity->ftid => $entity));

    $this->assertTrue(empty($entity->{$this->field_name}), 'Update: NULL field removes existing values');

    // Re-add some data.

    field_cache_clear();

    $entity = clone($entity_init);

    $values = $this->_generateTestFieldValues(1);

    $entity->{$this->field_name}[$langcode] = $values;

    field_attach_update($entity_type, $entity);

    $entity = clone($entity_init);

    field_attach_load($entity_type, array($entity->ftid => $entity));

    $this->assertEqual($entity->{$this->field_name}[$langcode], $values, 'Field data saved');

    // Update: Field is empty array. Data should be wiped.

    field_cache_clear();

    $entity = clone($entity_init);

    $entity->{$this->field_name} = array();

    field_attach_update($entity_type, $entity);

    $entity = clone($entity_init);

    field_attach_load($entity_type, array($entity->ftid => $entity));

    $this->assertTrue(empty($entity->{$this->field_name}), 'Update: empty array removes existing values');

  }

  /**

   * Test insert with missing or NULL fields, with default value.

   */

  function testFieldAttachSaveMissingDataDefaultValue() {

    // Add a default value function.

    $this->instance['default_value_function'] = 'field_test_default_value';

    field_update_instance($this->instance);

    $entity_type = 'test_entity';

    $entity_init = field_test_create_stub_entity();

    $langcode = LANGUAGE_NONE;

    // Insert: Field is NULL.

    $entity = clone($entity_init);

    $entity->{$this->field_name}[$langcode] = NULL;

    field_attach_insert($entity_type, $entity);

    $entity = clone($entity_init);

    field_attach_load($entity_type, array($entity->ftid => $entity));

    $this->assertTrue(empty($entity->{$this->field_name}[$langcode]), 'Insert: NULL field results in no value saved');

    // Insert: Field is missing.

    field_cache_clear();

    $entity = clone($entity_init);

    field_attach_insert($entity_type, $entity);

    $entity = clone($entity_init);

    field_attach_load($entity_type, array($entity->ftid => $entity));

    $values = field_test_default_value($entity_type, $entity, $this->field, $this->instance);

    $this->assertEqual($entity->{$this->field_name}[$langcode], $values, 'Insert: missing field results in default value saved');

  }

  /**

   * Test field_has_data().

   */

  function testFieldHasData() {

    $entity_type = 'test_entity';

    $langcode = LANGUAGE_NONE;

    $field_name = 'field_1';

    $field = array('field_name' => $field_name, 'type' => 'test_field');

    $field = field_create_field($field);

    $this->assertFalse(field_has_data($field), "No data should be detected.");

    $instance = array(

      'field_name' => $field_name,

      'entity_type' => 'test_entity',

      'bundle' => 'test_bundle'

    );

    $instance = field_create_instance($instance);

    $table = _field_sql_storage_tablename($field);

    $revision_table = _field_sql_storage_revision_tablename($field);

    $columns = array('entity_type', 'entity_id', 'revision_id', 'delta', 'language', $field_name . '_value');

    $eid = 0;

    // Insert values into the field revision table.

    $query = db_insert($revision_table)->fields($columns);

    $query->values(array($entity_type, $eid, 0, 0, $langcode, 1));

    $query->execute();

    $this->assertTrue(field_has_data($field), "Revision data only should be detected.");

    $field_name = 'field_2';

    $field = array('field_name' => $field_name, 'type' => 'test_field');

    $field = field_create_field($field);

    $this->assertFalse(field_has_data($field), "No data should be detected.");

    $instance = array(

      'field_name' => $field_name,

      'entity_type' => 'test_entity',

      'bundle' => 'test_bundle'

    );

    $instance = field_create_instance($instance);

    $table = _field_sql_storage_tablename($field);

    $revision_table = _field_sql_storage_revision_tablename($field);

    $columns = array('entity_type', 'entity_id', 'revision_id', 'delta', 'language', $field_name . '_value');

    $eid = 1;

    // Insert values into the field table.

    $query = db_insert($table)->fields($columns);

    $query->values(array($entity_type, $eid, 0, 0, $langcode, 1));

    $query->execute();

    $this->assertTrue(field_has_data($field), "Values only in field table should be detected.");

  }

  /**

   * Test field_attach_delete().

   */

  function testFieldAttachDelete() {

    $entity_type = 'test_entity';

    $langcode = LANGUAGE_NONE;

    $rev[0] = field_test_create_stub_entity(0, 0, $this->instance['bundle']);

    // Create revision 0

    $values = $this->_generateTestFieldValues($this->field['cardinality']);

    $rev[0]->{$this->field_name}[$langcode] = $values;

    field_attach_insert($entity_type, $rev[0]);

    // Create revision 1

    $rev[1] = field_test_create_stub_entity(0, 1, $this->instance['bundle']);

    $rev[1]->{$this->field_name}[$langcode] = $values;

    field_attach_update($entity_type, $rev[1]);

    // Create revision 2

    $rev[2] = field_test_create_stub_entity(0, 2, $this->instance['bundle']);

    $rev[2]->{$this->field_name}[$langcode] = $values;

    field_attach_update($entity_type, $rev[2]);

    // Confirm each revision loads

    foreach (array_keys($rev) as $vid) {

      $read = field_test_create_stub_entity(0, $vid, $this->instance['bundle']);

      field_attach_load_revision($entity_type, array(0 => $read));

      $this->assertEqual(count($read->{$this->field_name}[$langcode]), $this->field['cardinality'], "The test entity revision $vid has {$this->field['cardinality']} values.");

    }

    // Delete revision 1, confirm the other two still load.

    field_attach_delete_revision($entity_type, $rev[1]);

    foreach (array(0, 2) as $vid) {

      $read = field_test_create_stub_entity(0, $vid, $this->instance['bundle']);

      field_attach_load_revision($entity_type, array(0 => $read));

      $this->assertEqual(count($read->{$this->field_name}[$langcode]), $this->field['cardinality'], "The test entity revision $vid has {$this->field['cardinality']} values.");

    }

    // Confirm the current revision still loads

    $read = field_test_create_stub_entity(0, 2, $this->instance['bundle']);

    field_attach_load($entity_type, array(0 => $read));

    $this->assertEqual(count($read->{$this->field_name}[$langcode]), $this->field['cardinality'], "The test entity current revision has {$this->field['cardinality']} values.");

    // Delete all field data, confirm nothing loads

    field_attach_delete($entity_type, $rev[2]);

    foreach (array(0, 1, 2) as $vid) {

      $read = field_test_create_stub_entity(0, $vid, $this->instance['bundle']);

      field_attach_load_revision($entity_type, array(0 => $read));

      $this->assertIdentical($read->{$this->field_name}, array(), "The test entity revision $vid is deleted.");

    }

    $read = field_test_create_stub_entity(0, 2, $this->instance['bundle']);

    field_attach_load($entity_type, array(0 => $read));

    $this->assertIdentical($read->{$this->field_name}, array(), 'The test entity current revision is deleted.');

  }

  /**

   * Test field_attach_create_bundle() and field_attach_rename_bundle().

   */

  function testFieldAttachCreateRenameBundle() {

    // Create a new bundle. This has to be initiated by the module so that its

    // hook_entity_info() is consistent.

    $new_bundle = 'test_bundle_' . drupal_strtolower($this->randomName());

    field_test_create_bundle($new_bundle);

    // Add an instance to that bundle.

    $this->instance['bundle'] = $new_bundle;

    field_create_instance($this->instance);

    // Save an entity with data in the field.

    $entity = field_test_create_stub_entity(0, 0, $this->instance['bundle']);

    $langcode = LANGUAGE_NONE;

    $values = $this->_generateTestFieldValues($this->field['cardinality']);

    $entity->{$this->field_name}[$langcode] = $values;

    $entity_type = 'test_entity';

    field_attach_insert($entity_type, $entity);

    // Verify the field data is present on load.

    $entity = field_test_create_stub_entity(0, 0, $this->instance['bundle']);

    field_attach_load($entity_type, array(0 => $entity));

    $this->assertEqual(count($entity->{$this->field_name}[$langcode]), $this->field['cardinality'], "Data is retrieved for the new bundle");

    // Rename the bundle. This has to be initiated by the module so that its

    // hook_entity_info() is consistent.

    $new_bundle = 'test_bundle_' . drupal_strtolower($this->randomName());

    field_test_rename_bundle($this->instance['bundle'], $new_bundle);

    // Check that the instance definition has been updated.

    $this->instance = field_info_instance($entity_type, $this->field_name, $new_bundle);

    $this->assertIdentical($this->instance['bundle'], $new_bundle, "Bundle name has been updated in the instance.");

    // Verify the field data is present on load.

    $entity = field_test_create_stub_entity(0, 0, $new_bundle);

    field_attach_load($entity_type, array(0 => $entity));

    $this->assertEqual(count($entity->{$this->field_name}[$langcode]), $this->field['cardinality'], "Bundle name has been updated in the field storage");

  }

  /**

   * Test field_attach_delete_bundle().

   */

  function testFieldAttachDeleteBundle() {

    // Create a new bundle. This has to be initiated by the module so that its

    // hook_entity_info() is consistent.

    $new_bundle = 'test_bundle_' . drupal_strtolower($this->randomName());

    field_test_create_bundle($new_bundle);

    // Add an instance to that bundle.

    $this->instance['bundle'] = $new_bundle;

    field_create_instance($this->instance);

    // Create a second field for the test bundle

    $field_name = drupal_strtolower($this->randomName() . '_field_name');

    $field = array('field_name' => $field_name, 'type' => 'test_field', 'cardinality' => 1);

    field_create_field($field);

    $instance = array(

      'field_name' => $field_name,

      'entity_type' => 'test_entity',

      'bundle' => $this->instance['bundle'],

      'label' => $this->randomName() . '_label',

      'description' => $this->randomName() . '_description',

      'weight' => mt_rand(0, 127),

      // test_field has no instance settings

      'widget' => array(

        'type' => 'test_field_widget',

        'settings' => array(

          'size' => mt_rand(0, 255))));

    field_create_instance($instance);

    // Save an entity with data for both fields

    $entity = field_test_create_stub_entity(0, 0, $this->instance['bundle']);

    $langcode = LANGUAGE_NONE;

    $values = $this->_generateTestFieldValues($this->field['cardinality']);

    $entity->{$this->field_name}[$langcode] = $values;

    $entity->{$field_name}[$langcode] = $this->_generateTestFieldValues(1);

    field_attach_insert('test_entity', $entity);

    // Verify the fields are present on load

    $entity = field_test_create_stub_entity(0, 0, $this->instance['bundle']);

    field_attach_load('test_entity', array(0 => $entity));

    $this->assertEqual(count($entity->{$this->field_name}[$langcode]), 4, 'First field got loaded');

    $this->assertEqual(count($entity->{$field_name}[$langcode]), 1, 'Second field got loaded');

    // Delete the bundle. This has to be initiated by the module so that its

    // hook_entity_info() is consistent.

    field_test_delete_bundle($this->instance['bundle']);

    // Verify no data gets loaded

    $entity = field_test_create_stub_entity(0, 0, $this->instance['bundle']);

    field_attach_load('test_entity', array(0 => $entity));

    $this->assertFalse(isset($entity->{$this->field_name}[$langcode]), 'No data for first field');

    $this->assertFalse(isset($entity->{$field_name}[$langcode]), 'No data for second field');

    // Verify that the instances are gone

    $this->assertFalse(field_read_instance('test_entity', $this->field_name, $this->instance['bundle']), "First field is deleted");

    $this->assertFalse(field_read_instance('test_entity', $field_name, $instance['bundle']), "Second field is deleted");

  }

}

/**

 * Unit test class for non-storage related field_attach_* functions.

 */

class FieldAttachOtherTestCase extends FieldAttachTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Field attach tests (other)',

      'description' => 'Test other Field Attach API functions.',

      'group' => 'Field API',

    );

  }

  /**

   * Test field_attach_view() and field_attach_prepare_view().

   */

  function testFieldAttachView() {

    $this->createFieldWithInstance('_2');

    $entity_type = 'test_entity';

    $entity_init = field_test_create_stub_entity();

    $langcode = LANGUAGE_NONE;

    $options = array('field_name' => $this->field_name_2);

    // Populate values to be displayed.

    $values = $this->_generateTestFieldValues($this->field['cardinality']);

    $entity_init->{$this->field_name}[$langcode] = $values;

    $values_2 = $this->_generateTestFieldValues($this->field_2['cardinality']);

    $entity_init->{$this->field_name_2}[$langcode] = $values_2;

    // Simple formatter, label displayed.

    $entity = clone($entity_init);

    $formatter_setting = $this->randomName();

    $this->instance['display'] = array(

      'full' => array(

        'label' => 'above',

        'type' => 'field_test_default',

        'settings' => array(

          'test_formatter_setting' => $formatter_setting,

        )

      ),

    );

    field_update_instance($this->instance);

    $formatter_setting_2 = $this->randomName();

    $this->instance_2['display'] = array(

      'full' => array(

        'label' => 'above',

        'type' => 'field_test_default',

        'settings' => array(

          'test_formatter_setting' => $formatter_setting_2,

        )

      ),

    );

    field_update_instance($this->instance_2);

    // View all fields.

    field_attach_prepare_view($entity_type, array($entity->ftid => $entity), 'full');

    $entity->content = field_attach_view($entity_type, $entity, 'full');

    $output = drupal_render($entity->content);

    $this->content = $output;

    $this->assertRaw($this->instance['label'], "First field's label is displayed.");

    foreach ($values as $delta => $value) {

      $this->content = $output;

      $this->assertRaw("$formatter_setting|{$value['value']}", "Value $delta is displayed, formatter settings are applied.");

    }

    $this->assertRaw($this->instance_2['label'], "Second field's label is displayed.");

    foreach ($values_2 as $delta => $value) {

      $this->content = $output;

      $this->assertRaw("$formatter_setting_2|{$value['value']}", "Value $delta is displayed, formatter settings are applied.");

    }

    // View single field (the second field).

    field_attach_prepare_view($entity_type, array($entity->ftid => $entity), 'full', $langcode, $options);

    $entity->content = field_attach_view($entity_type, $entity, 'full', $langcode, $options);

    $output = drupal_render($entity->content);

    $this->content = $output;

    $this->assertNoRaw($this->instance['label'], "First field's label is not displayed.");

    foreach ($values as $delta => $value) {

      $this->content = $output;

      $this->assertNoRaw("$formatter_setting|{$value['value']}", "Value $delta is displayed, formatter settings are applied.");

    }

    $this->assertRaw($this->instance_2['label'], "Second field's label is displayed.");

    foreach ($values_2 as $delta => $value) {

      $this->content = $output;

      $this->assertRaw("$formatter_setting_2|{$value['value']}", "Value $delta is displayed, formatter settings are applied.");

    }

    // Label hidden.

    $entity = clone($entity_init);

    $this->instance['display']['full']['label'] = 'hidden';

    field_update_instance($this->instance);

    field_attach_prepare_view($entity_type, array($entity->ftid => $entity), 'full');

    $entity->content = field_attach_view($entity_type, $entity, 'full');

    $output = drupal_render($entity->content);

    $this->content = $output;

    $this->assertNoRaw($this->instance['label'], "Hidden label: label is not displayed.");

    // Field hidden.

    $entity = clone($entity_init);

    $this->instance['display'] = array(

      'full' => array(

        'label' => 'above',

        'type' => 'hidden',

      ),

    );

    field_update_instance($this->instance);

    field_attach_prepare_view($entity_type, array($entity->ftid => $entity), 'full');

    $entity->content = field_attach_view($entity_type, $entity, 'full');

    $output = drupal_render($entity->content);

    $this->content = $output;

    $this->assertNoRaw($this->instance['label'], "Hidden field: label is not displayed.");

    foreach ($values as $delta => $value) {

      $this->assertNoRaw("$formatter_setting|{$value['value']}", "Hidden field: value $delta is not displayed.");

    }

    // Multiple formatter.

    $entity = clone($entity_init);

    $formatter_setting = $this->randomName();

    $this->instance['display'] = array(

      'full' => array(

        'label' => 'above',

        'type' => 'field_test_multiple',

        'settings' => array(

          'test_formatter_setting_multiple' => $formatter_setting,

        )

      ),

    );

    field_update_instance($this->instance);

    field_attach_prepare_view($entity_type, array($entity->ftid => $entity), 'full');

    $entity->content = field_attach_view($entity_type, $entity, 'full');

    $output = drupal_render($entity->content);

    $display = $formatter_setting;

    foreach ($values as $delta => $value) {

      $display .= "|$delta:{$value['value']}";

    }

    $this->content = $output;

    $this->assertRaw($display, "Multiple formatter: all values are displayed, formatter settings are applied.");

    // Test a formatter that uses hook_field_formatter_prepare_view().

    $entity = clone($entity_init);

    $formatter_setting = $this->randomName();

    $this->instance['display'] = array(

      'full' => array(

        'label' => 'above',

        'type' => 'field_test_with_prepare_view',

        'settings' => array(

          'test_formatter_setting_additional' => $formatter_setting,

        )

      ),

    );

    field_update_instance($this->instance);

    field_attach_prepare_view($entity_type, array($entity->ftid => $entity), 'full');

    $entity->content = field_attach_view($entity_type, $entity, 'full');

    $output = drupal_render($entity->content);

    $this->content = $output;

    foreach ($values as $delta => $value) {

      $this->content = $output;

      $expected = $formatter_setting . '|' . $value['value'] . '|' . ($value['value'] + 1);

      $this->assertRaw($expected, "Value $delta is displayed, formatter settings are applied.");

    }

    // TODO:

    // - check display order with several fields

    // Preprocess template.

    $variables = array();

    field_attach_preprocess($entity_type, $entity, $entity->content, $variables);

    $result = TRUE;

    foreach ($values as $delta => $item) {

      if ($variables[$this->field_name][$delta]['value'] !== $item['value']) {

        $result = FALSE;

        break;

      }

    }

    $this->assertTrue($result, format_string('Variable $@field_name correctly populated.', array('@field_name' => $this->field_name)));

  }

  /**

   * Tests the 'multiple entity' behavior of field_attach_prepare_view().

   */

  function testFieldAttachPrepareViewMultiple() {

    $entity_type = 'test_entity';

    $langcode = LANGUAGE_NONE;

    // Set the instance to be hidden.

    $this->instance['display']['full']['type'] = 'hidden';

    field_update_instance($this->instance);

    // Set up a second instance on another bundle, with a formatter that uses

    // hook_field_formatter_prepare_view().

    field_test_create_bundle('test_bundle_2');

    $formatter_setting = $this->randomName();

    $this->instance2 = $this->instance;

    $this->instance2['bundle'] = 'test_bundle_2';

    $this->instance2['display']['full'] = array(

      'type' => 'field_test_with_prepare_view',

      'settings' => array(

        'test_formatter_setting_additional' => $formatter_setting,

      )

    );

    field_create_instance($this->instance2);

    // Create one entity in each bundle.

    $entity1_init = field_test_create_stub_entity(1, 1, 'test_bundle');

    $values1 = $this->_generateTestFieldValues($this->field['cardinality']);

    $entity1_init->{$this->field_name}[$langcode] = $values1;

    $entity2_init = field_test_create_stub_entity(2, 2, 'test_bundle_2');

    $values2 = $this->_generateTestFieldValues($this->field['cardinality']);

    $entity2_init->{$this->field_name}[$langcode] = $values2;

    // Run prepare_view, and check that the entities come out as expected.

    $entity1 = clone($entity1_init);

    $entity2 = clone($entity2_init);

    field_attach_prepare_view($entity_type, array($entity1->ftid => $entity1, $entity2->ftid => $entity2), 'full');

    $this->assertFalse(isset($entity1->{$this->field_name}[$langcode][0]['additional_formatter_value']), 'Entity 1 did not run through the prepare_view hook.');

    $this->assertTrue(isset($entity2->{$this->field_name}[$langcode][0]['additional_formatter_value']), 'Entity 2 ran through the prepare_view hook.');

    // Same thing, reversed order.

    $entity1 = clone($entity1_init);

    $entity2 = clone($entity2_init);

    field_attach_prepare_view($entity_type, array($entity2->ftid => $entity2, $entity1->ftid => $entity1), 'full');

    $this->assertFalse(isset($entity1->{$this->field_name}[$langcode][0]['additional_formatter_value']), 'Entity 1 did not run through the prepare_view hook.');

    $this->assertTrue(isset($entity2->{$this->field_name}[$langcode][0]['additional_formatter_value']), 'Entity 2 ran through the prepare_view hook.');

  }

  /**

   * Test field cache.

   */

  function testFieldAttachCache() {

    // Initialize random values and a test entity.

    $entity_init = field_test_create_stub_entity(1, 1, $this->instance['bundle']);

    $langcode = LANGUAGE_NONE;

    $values = $this->_generateTestFieldValues($this->field['cardinality']);

    // Non-cacheable entity type.

    $entity_type = 'test_entity';

    $cid = "field:$entity_type:{$entity_init->ftid}";

    // Check that no initial cache entry is present.

    $this->assertFalse(cache_get($cid, 'cache_field'), 'Non-cached: no initial cache entry');

    // Save, and check that no cache entry is present.

    $entity = clone($entity_init);

    $entity->{$this->field_name}[$langcode] = $values;

    field_attach_insert($entity_type, $entity);

    $this->assertFalse(cache_get($cid, 'cache_field'), 'Non-cached: no cache entry on insert');

    // Load, and check that no cache entry is present.

    $entity = clone($entity_init);

    field_attach_load($entity_type, array($entity->ftid => $entity));

    $this->assertFalse(cache_get($cid, 'cache_field'), 'Non-cached: no cache entry on load');

    // Cacheable entity type.

    $entity_type = 'test_cacheable_entity';

    $cid = "field:$entity_type:{$entity_init->ftid}";

    $instance = $this->instance;

    $instance['entity_type'] = $entity_type;

    field_create_instance($instance);

    // Check that no initial cache entry is present.

    $this->assertFalse(cache_get($cid, 'cache_field'), 'Cached: no initial cache entry');

    // Save, and check that no cache entry is present.

    $entity = clone($entity_init);

    $entity->{$this->field_name}[$langcode] = $values;

    field_attach_insert($entity_type, $entity);

    $this->assertFalse(cache_get($cid, 'cache_field'), 'Cached: no cache entry on insert');

    // Load a single field, and check that no cache entry is present.

    $entity = clone($entity_init);

    field_attach_load($entity_type, array($entity->ftid => $entity), FIELD_LOAD_CURRENT, array('field_id' => $this->field_id));

    $cache = cache_get($cid, 'cache_field');

    $this->assertFalse(cache_get($cid, 'cache_field'), 'Cached: no cache entry on loading a single field');

    // Load, and check that a cache entry is present with the expected values.

    $entity = clone($entity_init);

    field_attach_load($entity_type, array($entity->ftid => $entity));

    $cache = cache_get($cid, 'cache_field');

    $this->assertEqual($cache->data[$this->field_name][$langcode], $values, 'Cached: correct cache entry on load');

    // Update with different values, and check that the cache entry is wiped.

    $values = $this->_generateTestFieldValues($this->field['cardinality']);

    $entity = clone($entity_init);

    $entity->{$this->field_name}[$langcode] = $values;

    field_attach_update($entity_type, $entity);

    $this->assertFalse(cache_get($cid, 'cache_field'), 'Cached: no cache entry on update');

    // Load, and check that a cache entry is present with the expected values.

    $entity = clone($entity_init);

    field_attach_load($entity_type, array($entity->ftid => $entity));

    $cache = cache_get($cid, 'cache_field');

    $this->assertEqual($cache->data[$this->field_name][$langcode], $values, 'Cached: correct cache entry on load');

    // Create a new revision, and check that the cache entry is wiped.

    $entity_init = field_test_create_stub_entity(1, 2, $this->instance['bundle']);

    $values = $this->_generateTestFieldValues($this->field['cardinality']);

    $entity = clone($entity_init);

    $entity->{$this->field_name}[$langcode] = $values;

    field_attach_update($entity_type, $entity);

    $cache = cache_get($cid, 'cache_field');

    $this->assertFalse(cache_get($cid, 'cache_field'), 'Cached: no cache entry on new revision creation');

    // Load, and check that a cache entry is present with the expected values.

    $entity = clone($entity_init);

    field_attach_load($entity_type, array($entity->ftid => $entity));

    $cache = cache_get($cid, 'cache_field');

    $this->assertEqual($cache->data[$this->field_name][$langcode], $values, 'Cached: correct cache entry on load');

    // Delete, and check that the cache entry is wiped.

    field_attach_delete($entity_type, $entity);

    $this->assertFalse(cache_get($cid, 'cache_field'), 'Cached: no cache entry after delete');

  }

  /**

   * Test field_attach_validate().

   *

   * Verify that field_attach_validate() invokes the correct

   * hook_field_validate.

   */

  function testFieldAttachValidate() {

    $this->createFieldWithInstance('_2');

    $entity_type = 'test_entity';

    $entity = field_test_create_stub_entity(0, 0, $this->instance['bundle']);

    $langcode = LANGUAGE_NONE;

    // Set up all but one values of the first field to generate errors.

    $values = array();

    for ($delta = 0; $delta < $this->field['cardinality']; $delta++) {

      $values[$delta]['value'] = -1;

    }

    // Arrange for item 1 not to generate an error

    $values[1]['value'] = 1;

    $entity->{$this->field_name}[$langcode] = $values;

    // Set up all values of the second field to generate errors.

    $values_2 = array();

    for ($delta = 0; $delta < $this->field_2['cardinality']; $delta++) {

      $values_2[$delta]['value'] = -1;

    }

    $entity->{$this->field_name_2}[$langcode] = $values_2;

    // Validate all fields.

    try {

      field_attach_validate($entity_type, $entity);

    }

    catch (FieldValidationException $e) {

      $errors = $e->errors;

    }

    foreach ($values as $delta => $value) {

      if ($value['value'] != 1) {

        $this->assertIdentical($errors[$this->field_name][$langcode][$delta][0]['error'], 'field_test_invalid', "Error set on first field's value $delta");

        $this->assertEqual(count($errors[$this->field_name][$langcode][$delta]), 1, "Only one error set on first field's value $delta");

        unset($errors[$this->field_name][$langcode][$delta]);

      }

      else {

        $this->assertFalse(isset($errors[$this->field_name][$langcode][$delta]), "No error set on first field's value $delta");

      }

    }

    foreach ($values_2 as $delta => $value) {

      $this->assertIdentical($errors[$this->field_name_2][$langcode][$delta][0]['error'], 'field_test_invalid', "Error set on second field's value $delta");

      $this->assertEqual(count($errors[$this->field_name_2][$langcode][$delta]), 1, "Only one error set on second field's value $delta");

      unset($errors[$this->field_name_2][$langcode][$delta]);

    }

    $this->assertEqual(count($errors[$this->field_name][$langcode]), 0, 'No extraneous errors set for first field');

    $this->assertEqual(count($errors[$this->field_name_2][$langcode]), 0, 'No extraneous errors set for second field');

    // Validate a single field.

    $options = array('field_name' => $this->field_name_2);

    try {

      field_attach_validate($entity_type, $entity, $options);

    }

    catch (FieldValidationException $e) {

      $errors = $e->errors;

    }

    foreach ($values_2 as $delta => $value) {

      $this->assertIdentical($errors[$this->field_name_2][$langcode][$delta][0]['error'], 'field_test_invalid', "Error set on second field's value $delta");

      $this->assertEqual(count($errors[$this->field_name_2][$langcode][$delta]), 1, "Only one error set on second field's value $delta");

      unset($errors[$this->field_name_2][$langcode][$delta]);

    }

    $this->assertFalse(isset($errors[$this->field_name]), 'No validation errors are set for the first field, despite it having errors');

    $this->assertEqual(count($errors[$this->field_name_2][$langcode]), 0, 'No extraneous errors set for second field');

    // Check that cardinality is validated.

    $entity->{$this->field_name_2}[$langcode] = $this->_generateTestFieldValues($this->field_2['cardinality'] + 1);

    // When validating all fields.

    try {

      field_attach_validate($entity_type, $entity);

    }

    catch (FieldValidationException $e) {

      $errors = $e->errors;

    }

    $this->assertEqual($errors[$this->field_name_2][$langcode][0][0]['error'], 'field_cardinality', 'Cardinality validation failed.');

    // When validating a single field (the second field).

    try {

      field_attach_validate($entity_type, $entity, $options);

    }

    catch (FieldValidationException $e) {

      $errors = $e->errors;

    }

    $this->assertEqual($errors[$this->field_name_2][$langcode][0][0]['error'], 'field_cardinality', 'Cardinality validation failed.');

  }

  /**

   * Test field_attach_form().

   *

   * This could be much more thorough, but it does verify that the correct

   * widgets show up.

   */

  function testFieldAttachForm() {

    $this->createFieldWithInstance('_2');

    $entity_type = 'test_entity';

    $entity = field_test_create_stub_entity(0, 0, $this->instance['bundle']);

    $langcode = LANGUAGE_NONE;

    // When generating form for all fields.

    $form = array();

    $form_state = form_state_defaults();

    field_attach_form($entity_type, $entity, $form, $form_state);

    $this->assertEqual($form[$this->field_name][$langcode]['#title'], $this->instance['label'], "First field's form title is {$this->instance['label']}");

    $this->assertEqual($form[$this->field_name_2][$langcode]['#title'], $this->instance_2['label'], "Second field's form title is {$this->instance_2['label']}");

    for ($delta = 0; $delta < $this->field['cardinality']; $delta++) {

      // field_test_widget uses 'textfield'

        $this->assertEqual($form[$this->field_name][$langcode][$delta]['value']['#type'], 'textfield', "First field's form delta $delta widget is textfield");

      }

      for ($delta = 0; $delta < $this->field_2['cardinality']; $delta++) {

        // field_test_widget uses 'textfield'

        $this->assertEqual($form[$this->field_name_2][$langcode][$delta]['value']['#type'], 'textfield', "Second field's form delta $delta widget is textfield");

      }

      // When generating form for a single field (the second field).

      $options = array('field_name' => $this->field_name_2);

      $form = array();

      $form_state = form_state_defaults();

      field_attach_form($entity_type, $entity, $form, $form_state, NULL, $options);

      $this->assertFalse(isset($form[$this->field_name]), 'The first field does not exist in the form');

      $this->assertEqual($form[$this->field_name_2][$langcode]['#title'], $this->instance_2['label'], "Second field's form title is {$this->instance_2['label']}");

      for ($delta = 0; $delta < $this->field_2['cardinality']; $delta++) {

        // field_test_widget uses 'textfield'

        $this->assertEqual($form[$this->field_name_2][$langcode][$delta]['value']['#type'], 'textfield', "Second field's form delta $delta widget is textfield");

      }

  }

  /**

   * Test field_attach_submit().

   */

  function testFieldAttachSubmit() {

    $this->createFieldWithInstance('_2');

    $entity_type = 'test_entity';

    $entity_init = field_test_create_stub_entity(0, 0, $this->instance['bundle']);

    $langcode = LANGUAGE_NONE;

    // Build the form for all fields.

    $form = array();

    $form_state = form_state_defaults();

    field_attach_form($entity_type, $entity_init, $form, $form_state);

    // Simulate incoming values.

    // First field.

    $values = array();

    $weights = array();

    for ($delta = 0; $delta < $this->field['cardinality']; $delta++) {

      $values[$delta]['value'] = mt_rand(1, 127);

      // Assign random weight.

      do {

        $weight = mt_rand(0, $this->field['cardinality']);

      } while (in_array($weight, $weights));

      $weights[$delta] = $weight;

      $values[$delta]['_weight'] = $weight;

    }

    // Leave an empty value. 'field_test' fields are empty if empty().

    $values[1]['value'] = 0;

    // Second field.

    $values_2 = array();

    $weights_2 = array();

    for ($delta = 0; $delta < $this->field_2['cardinality']; $delta++) {

      $values_2[$delta]['value'] = mt_rand(1, 127);

      // Assign random weight.

      do {

        $weight = mt_rand(0, $this->field_2['cardinality']);

      } while (in_array($weight, $weights_2));

      $weights_2[$delta] = $weight;

      $values_2[$delta]['_weight'] = $weight;

    }

    // Leave an empty value. 'field_test' fields are empty if empty().

    $values_2[1]['value'] = 0;

    // Pretend the form has been built.

    drupal_prepare_form('field_test_entity_form', $form, $form_state);

    drupal_process_form('field_test_entity_form', $form, $form_state);

    $form_state['values'][$this->field_name][$langcode] = $values;

    $form_state['values'][$this->field_name_2][$langcode] = $values_2;

    // Call field_attach_submit() for all fields.

    $entity = clone($entity_init);

    field_attach_submit($entity_type, $entity, $form, $form_state);

    asort($weights);

    asort($weights_2);

    $expected_values = array();

    $expected_values_2 = array();

    foreach ($weights as $key => $value) {

      if ($key != 1) {

        $expected_values[] = array('value' => $values[$key]['value']);

      }

    }

    $this->assertIdentical($entity->{$this->field_name}[$langcode], $expected_values, 'Submit filters empty values');

    foreach ($weights_2 as $key => $value) {

      if ($key != 1) {

        $expected_values_2[] = array('value' => $values_2[$key]['value']);

      }

    }

    $this->assertIdentical($entity->{$this->field_name_2}[$langcode], $expected_values_2, 'Submit filters empty values');

    // Call field_attach_submit() for a single field (the second field).

    $options = array('field_name' => $this->field_name_2);

    $entity = clone($entity_init);

    field_attach_submit($entity_type, $entity, $form, $form_state, $options);

    $expected_values_2 = array();

    foreach ($weights_2 as $key => $value) {

      if ($key != 1) {

        $expected_values_2[] = array('value' => $values_2[$key]['value']);

      }

    }

    $this->assertFalse(isset($entity->{$this->field_name}), 'The first field does not exist in the entity object');

    $this->assertIdentical($entity->{$this->field_name_2}[$langcode], $expected_values_2, 'Submit filters empty values');

  }

}

class FieldInfoTestCase extends FieldTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Field info tests',

      'description' => 'Get information about existing fields, instances and bundles.',

      'group' => 'Field API',

    );

  }

  function setUp() {

    parent::setUp('field_test');

  }

  /**

   * Test that field types and field definitions are correcly cached.

   */

  function testFieldInfo() {

    // Test that field_test module's fields, widgets, and formatters show up.

    $field_test_info = field_test_field_info();

    // We need to account for the existence of user_field_info_alter().

    foreach (array_keys($field_test_info) as $name) {

      $field_test_info[$name]['instance_settings']['user_register_form'] = FALSE;

    }

    $info = field_info_field_types();

    foreach ($field_test_info as $t_key => $field_type) {

      foreach ($field_type as $key => $val) {

        $this->assertEqual($info[$t_key][$key], $val, format_string('Field type %t_key key %key is %value', array('%t_key' => $t_key, '%key' => $key, '%value' => print_r($val, TRUE))));

      }

      $this->assertEqual($info[$t_key]['module'], 'field_test',  "Field type field_test module appears");

    }

    $formatter_info = field_test_field_formatter_info();

    $info = field_info_formatter_types();

    foreach ($formatter_info as $f_key => $formatter) {

      foreach ($formatter as $key => $val) {

        $this->assertEqual($info[$f_key][$key], $val, format_string('Formatter type %f_key key %key is %value', array('%f_key' => $f_key, '%key' => $key, '%value' => print_r($val, TRUE))));

      }

      $this->assertEqual($info[$f_key]['module'], 'field_test',  "Formatter type field_test module appears");

    }

    $widget_info = field_test_field_widget_info();

    $info = field_info_widget_types();

    foreach ($widget_info as $w_key => $widget) {

      foreach ($widget as $key => $val) {

        $this->assertEqual($info[$w_key][$key], $val, format_string('Widget type %w_key key %key is %value', array('%w_key' => $w_key, '%key' => $key, '%value' => print_r($val, TRUE))));

      }

      $this->assertEqual($info[$w_key]['module'], 'field_test',  "Widget type field_test module appears");

    }

    $storage_info = field_test_field_storage_info();

    $info = field_info_storage_types();

    foreach ($storage_info as $s_key => $storage) {

      foreach ($storage as $key => $val) {

        $this->assertEqual($info[$s_key][$key], $val, format_string('Storage type %s_key key %key is %value', array('%s_key' => $s_key, '%key' => $key, '%value' => print_r($val, TRUE))));

      }

      $this->assertEqual($info[$s_key]['module'], 'field_test',  "Storage type field_test module appears");

    }

    // Verify that no unexpected instances exist.

    $instances = field_info_instances('test_entity');

    $expected = array('test_bundle' => array());

    $this->assertIdentical($instances, $expected, format_string("field_info_instances('test_entity') returns %expected.", array('%expected' => var_export($expected, TRUE))));

    $instances = field_info_instances('test_entity', 'test_bundle');

    $this->assertIdentical($instances, array(), "field_info_instances('test_entity', 'test_bundle') returns an empty array.");

    // Create a field, verify it shows up.

    $core_fields = field_info_fields();

    $field = array(

      'field_name' => drupal_strtolower($this->randomName()),

      'type' => 'test_field',

    );

    field_create_field($field);

    $fields = field_info_fields();

    $this->assertEqual(count($fields), count($core_fields) + 1, 'One new field exists');

    $this->assertEqual($fields[$field['field_name']]['field_name'], $field['field_name'], 'info fields contains field name');

    $this->assertEqual($fields[$field['field_name']]['type'], $field['type'], 'info fields contains field type');

    $this->assertEqual($fields[$field['field_name']]['module'], 'field_test', 'info fields contains field module');

    $settings = array('test_field_setting' => 'dummy test string');

    foreach ($settings as $key => $val) {

      $this->assertEqual($fields[$field['field_name']]['settings'][$key], $val, format_string('Field setting %key has correct default value %value', array('%key' => $key, '%value' => $val)));

    }

    $this->assertEqual($fields[$field['field_name']]['cardinality'], 1, 'info fields contains cardinality 1');

    $this->assertEqual($fields[$field['field_name']]['active'], 1, 'info fields contains active 1');

    // Create an instance, verify that it shows up

    $instance = array(

      'field_name' => $field['field_name'],

      'entity_type' => 'test_entity',

      'bundle' => 'test_bundle',

      'label' => $this->randomName(),

      'description' => $this->randomName(),

      'weight' => mt_rand(0, 127),

      // test_field has no instance settings

      'widget' => array(

        'type' => 'test_field_widget',

        'settings' => array(

          'test_setting' => 999)));

    field_create_instance($instance);

    $info = entity_get_info('test_entity');

    $instances = field_info_instances('test_entity', $instance['bundle']);

    $this->assertEqual(count($instances), 1, format_string('One instance shows up in info when attached to a bundle on a @label.', array(

      '@label' => $info['label']

    )));

    $this->assertTrue($instance < $instances[$instance['field_name']], 'Instance appears in info correctly');

    // Test a valid entity type but an invalid bundle.

    $instances = field_info_instances('test_entity', 'invalid_bundle');

    $this->assertIdentical($instances, array(), "field_info_instances('test_entity', 'invalid_bundle') returns an empty array.");

    // Test invalid entity type and bundle.

    $instances = field_info_instances('invalid_entity', $instance['bundle']);

    $this->assertIdentical($instances, array(), "field_info_instances('invalid_entity', 'test_bundle') returns an empty array.");

    // Test invalid entity type, no bundle provided.

    $instances = field_info_instances('invalid_entity');

    $this->assertIdentical($instances, array(), "field_info_instances('invalid_entity') returns an empty array.");

    // Test with an entity type that has no bundles.

    $instances = field_info_instances('user');

    $expected = array('user' => array());

    $this->assertIdentical($instances, $expected, format_string("field_info_instances('user') returns %expected.", array('%expected' => var_export($expected, TRUE))));

    $instances = field_info_instances('user', 'user');

    $this->assertIdentical($instances, array(), "field_info_instances('user', 'user') returns an empty array.");

    // Test that querying for invalid entity types does not add entries in the

    // list returned by field_info_instances().

    field_info_cache_clear();

    field_info_instances('invalid_entity', 'invalid_bundle');

    // Simulate new request by clearing static caches.

    drupal_static_reset();

    field_info_instances('invalid_entity', 'invalid_bundle');

    $instances = field_info_instances();

    $this->assertFalse(isset($instances['invalid_entity']), 'field_info_instances() does not contain entries for the invalid entity type that was queried before');

  }

  /**

   * Test that cached field definitions are ready for current runtime context.

   */

  function testFieldPrepare() {

    $field_definition = array(

      'field_name' => 'field',

      'type' => 'test_field',

    );

    field_create_field($field_definition);

    // Simulate a stored field definition missing a field setting (e.g. a

    // third-party module adding a new field setting has been enabled, and

    // existing fields do not know the setting yet).

    $data = db_query('SELECT data FROM {field_config} WHERE field_name = :field_name', array(':field_name' => $field_definition['field_name']))->fetchField();

    $data = unserialize($data);

    $data['settings'] = array();

    db_update('field_config')

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

      ->condition('field_name', $field_definition['field_name'])

      ->execute();

    field_cache_clear();

    // Read the field back.

    $field = field_info_field($field_definition['field_name']);

    // Check that all expected settings are in place.

    $field_type = field_info_field_types($field_definition['type']);

    $this->assertIdentical($field['settings'], $field_type['settings'], 'All expected default field settings are present.');

  }

  /**

   * Test that cached instance definitions are ready for current runtime context.

   */

  function testInstancePrepare() {

    $field_definition = array(

      'field_name' => 'field',

      'type' => 'test_field',

    );

    field_create_field($field_definition);

    $instance_definition = array(

      'field_name' => $field_definition['field_name'],

      'entity_type' => 'test_entity',

      'bundle' => 'test_bundle',

    );

    field_create_instance($instance_definition);

    // Simulate a stored instance definition missing various settings (e.g. a

    // third-party module adding instance, widget or display settings has been

    // enabled, but existing instances do not know the new settings).

    $data = db_query('SELECT data FROM {field_config_instance} WHERE field_name = :field_name AND bundle = :bundle', array(':field_name' => $instance_definition['field_name'], ':bundle' => $instance_definition['bundle']))->fetchField();

    $data = unserialize($data);

    $data['settings'] = array();

    $data['widget']['settings'] = 'unavailable_widget';

    $data['widget']['settings'] = array();

    $data['display']['default']['type'] = 'unavailable_formatter';

    $data['display']['default']['settings'] = array();

    db_update('field_config_instance')

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

      ->condition('field_name', $instance_definition['field_name'])

      ->condition('bundle', $instance_definition['bundle'])

      ->execute();

    field_cache_clear();

    // Read the instance back.

    $instance = field_info_instance($instance_definition['entity_type'], $instance_definition['field_name'], $instance_definition['bundle']);

    // Check that all expected instance settings are in place.

    $field_type = field_info_field_types($field_definition['type']);

    $this->assertIdentical($instance['settings'], $field_type['instance_settings'] , 'All expected instance settings are present.');

    // Check that the default widget is used and expected settings are in place.

    $this->assertIdentical($instance['widget']['type'], $field_type['default_widget'], 'Unavailable widget replaced with default widget.');

    $widget_type = field_info_widget_types($instance['widget']['type']);

    $this->assertIdentical($instance['widget']['settings'], $widget_type['settings'] , 'All expected widget settings are present.');

    // Check that display settings are set for the 'default' mode.

    $display = $instance['display']['default'];

    $this->assertIdentical($display['type'], $field_type['default_formatter'], "Formatter is set for the 'default' view mode");

    $formatter_type = field_info_formatter_types($display['type']);

    $this->assertIdentical($display['settings'], $formatter_type['settings'] , "Formatter settings are set for the 'default' view mode");

  }

  /**

   * Test that instances on disabled entity types are filtered out.

   */

  function testInstanceDisabledEntityType() {

    // For this test the field type and the entity type must be exposed by

    // different modules.

    $field_definition = array(

      'field_name' => 'field',

      'type' => 'test_field',

    );

    field_create_field($field_definition);

    $instance_definition = array(

      'field_name' => 'field',

      'entity_type' => 'comment',

      'bundle' => 'comment_node_article',

    );

    field_create_instance($instance_definition);

    // Disable coment module. This clears field_info cache.

    module_disable(array('comment'));

    $this->assertNull(field_info_instance('comment', 'field', 'comment_node_article'), 'No instances are returned on disabled entity types.');

  }

  /**

   * Test field_info_field_map().

   */

  function testFieldMap() {

    // We will overlook fields created by the 'standard' install profile.

    $exclude = field_info_field_map();

    // Create a new bundle for 'test_entity' entity type.

    field_test_create_bundle('test_bundle_2');

    // Create a couple fields.

    $fields  = array(

      array(

        'field_name' => 'field_1',

        'type' => 'test_field',

      ),

      array(

        'field_name' => 'field_2',

        'type' => 'hidden_test_field',

      ),

    );

    foreach ($fields as $field) {

      field_create_field($field);

    }

    // Create a couple instances.

    $instances = array(

      array(

        'field_name' => 'field_1',

        'entity_type' => 'test_entity',

        'bundle' => 'test_bundle',

      ),

      array(

        'field_name' => 'field_1',

        'entity_type' => 'test_entity',

        'bundle' => 'test_bundle_2',

      ),

      array(

        'field_name' => 'field_2',

        'entity_type' => 'test_entity',

        'bundle' => 'test_bundle',

      ),

      array(

        'field_name' => 'field_2',

        'entity_type' => 'test_cacheable_entity',

        'bundle' => 'test_bundle',

      ),

    );

    foreach ($instances as $instance) {

      field_create_instance($instance);

    }

    $expected = array(

      'field_1' => array(

        'type' => 'test_field',

        'bundles' => array(

          'test_entity' => array('test_bundle', 'test_bundle_2'),

        ),

      ),

      'field_2' => array(

        'type' => 'hidden_test_field',

        'bundles' => array(

          'test_entity' => array('test_bundle'),

          'test_cacheable_entity' => array('test_bundle'),

        ),

      ),

    );

    // Check that the field map is correct.

    $map = field_info_field_map();

    $map = array_diff_key($map, $exclude);

    $this->assertEqual($map, $expected);

  }

  /**

   * Test that the field_info settings convenience functions work.

   */

  function testSettingsInfo() {

    $info = field_test_field_info();

    // We need to account for the existence of user_field_info_alter().

    foreach (array_keys($info) as $name) {

      $info[$name]['instance_settings']['user_register_form'] = FALSE;

    }

    foreach ($info as $type => $data) {

      $this->assertIdentical(field_info_field_settings($type), $data['settings'], format_string("field_info_field_settings returns %type's field settings", array('%type' => $type)));

      $this->assertIdentical(field_info_instance_settings($type), $data['instance_settings'], format_string("field_info_field_settings returns %type's field instance settings", array('%type' => $type)));

    }

    $info = field_test_field_widget_info();

    foreach ($info as $type => $data) {

      $this->assertIdentical(field_info_widget_settings($type), $data['settings'], format_string("field_info_widget_settings returns %type's widget settings", array('%type' => $type)));

    }

    $info = field_test_field_formatter_info();