1 <?php

     2 

     3 

     4 /**

     5  * @file

     6  * Unit test file for the entity API.

     7  */

     8 

     9 /**

    10  * Tests EntityFieldQuery.

    11  */

    12 class EntityFieldQueryTestCase extends DrupalWebTestCase {

    13 

    14   public static function getInfo() {

    15     return array(

    16       'name' => 'Entity query',

    17       'description' => 'Test the EntityFieldQuery class.',

    18       'group' => 'Entity API',

    19     );

    20   }

    21 

    22   function setUp() {

    23     parent::setUp(array('node', 'field_test', 'entity_query_access_test', 'node_access_test'));

    24 

    25     field_test_create_bundle('bundle1');

    26     field_test_create_bundle('bundle2');

    27     field_test_create_bundle('test_bundle');

    28     field_test_create_bundle('test_entity_bundle');

    29 

    30     $instances = array();

    31     $this->fields = array();

    32     $this->field_names[0] = $field_name = drupal_strtolower($this->randomName() . '_field_name');

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

    34     $field = field_create_field($field);

    35     $this->fields[0] = $field;

    36     $instance = array(

    37       'field_name' => $field_name,

    38       'entity_type' => '',

    39       'bundle' => '',

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

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

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

    43       'settings' => array(

    44         'test_instance_setting' => $this->randomName(),

    45       ),

    46       'widget' => array(

    47         'type' => 'test_field_widget',

    48         'label' => 'Test Field',

    49         'settings' => array(

    50           'test_widget_setting' => $this->randomName(),

    51         )

    52       )

    53     );

    54 

    55     $instances[0] = $instance;

    56 

    57     // Add an instance to that bundle.

    58     $instances[0]['bundle'] = 'bundle1';

    59     $instances[0]['entity_type'] = 'test_entity_bundle_key';

    60     field_create_instance($instances[0]);

    61     $instances[0]['bundle'] = 'bundle2';

    62     field_create_instance($instances[0]);

    63     $instances[0]['bundle'] = $instances[0]['entity_type'] = 'test_entity_bundle';

    64     field_create_instance($instances[0]);

    65 

    66     $this->field_names[1] = $field_name = drupal_strtolower($this->randomName() . '_field_name');

    67     $field = array('field_name' => $field_name, 'type' => 'shape', 'cardinality' => 4);

    68     $field = field_create_field($field);

    69     $this->fields[1] = $field;

    70     $instance = array(

    71       'field_name' => $field_name,

    72       'entity_type' => '',

    73       'bundle' => '',

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

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

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

    77       'settings' => array(

    78         'test_instance_setting' => $this->randomName(),

    79       ),

    80       'widget' => array(

    81         'type' => 'test_field_widget',

    82         'label' => 'Test Field',

    83         'settings' => array(

    84           'test_widget_setting' => $this->randomName(),

    85         )

    86       )

    87     );

    88 

    89     $instances[1] = $instance;

    90 

    91     // Add a field instance to the bundles.

    92     $instances[1]['bundle'] = 'bundle1';

    93     $instances[1]['entity_type'] = 'test_entity_bundle_key';

    94     field_create_instance($instances[1]);

    95     $instances[1]['bundle'] = $instances[1]['entity_type'] = 'test_entity_bundle';

    96     field_create_instance($instances[1]);

    97 

    98     $this->instances = $instances;

    99     // Write entity base table if there is one.

   100     $entities = array();

   101 

   102     // Create entities which have a 'bundle key' defined.

   103     for ($i = 1; $i < 7; $i++) {

   104       $entity = new stdClass();

   105       $entity->ftid = $i;

   106       $entity->fttype = ($i < 5) ? 'bundle1' : 'bundle2';

   107 

   108       $entity->{$this->field_names[0]}[LANGUAGE_NONE][0]['value'] = $i;

   109       drupal_write_record('test_entity_bundle_key', $entity);

   110       field_attach_insert('test_entity_bundle_key', $entity);

   111     }

   112 

   113     $entity = new stdClass();

   114     $entity->ftid = 5;

   115     $entity->fttype = 'test_entity_bundle';

   116     $entity->{$this->field_names[1]}[LANGUAGE_NONE][0]['shape'] = 'square';

   117     $entity->{$this->field_names[1]}[LANGUAGE_NONE][0]['color'] = 'red';

   118     $entity->{$this->field_names[1]}[LANGUAGE_NONE][1]['shape'] = 'circle';

   119     $entity->{$this->field_names[1]}[LANGUAGE_NONE][1]['color'] = 'blue';

   120     drupal_write_record('test_entity_bundle', $entity);

   121     field_attach_insert('test_entity_bundle', $entity);

   122 

   123     $instances[2] = $instance;

   124     $instances[2]['bundle'] = 'test_bundle';

   125     $instances[2]['field_name'] = $this->field_names[0];

   126     $instances[2]['entity_type'] = 'test_entity';

   127     field_create_instance($instances[2]);

   128 

   129     // Create entities with support for revisions.

   130     for ($i = 1; $i < 5; $i++) {

   131       $entity = new stdClass();

   132       $entity->ftid = $i;

   133       $entity->ftvid = $i;

   134       $entity->fttype = 'test_bundle';

   135       $entity->{$this->field_names[0]}[LANGUAGE_NONE][0]['value'] = $i;

   136 

   137       drupal_write_record('test_entity', $entity);

   138       field_attach_insert('test_entity', $entity);

   139       drupal_write_record('test_entity_revision', $entity);

   140     }

   141 

   142     // Add two revisions to an entity.

   143     for ($i = 100; $i < 102; $i++) {

   144       $entity = new stdClass();

   145       $entity->ftid = 4;

   146       $entity->ftvid = $i;

   147       $entity->fttype = 'test_bundle';

   148       $entity->{$this->field_names[0]}[LANGUAGE_NONE][0]['value'] = $i;

   149 

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

   151       drupal_write_record('test_entity_revision', $entity);

   152 

   153       db_update('test_entity')

   154        ->fields(array('ftvid' => $entity->ftvid))

   155        ->condition('ftid', $entity->ftid)

   156        ->execute();

   157 

   158       field_attach_update('test_entity', $entity);

   159     }

   160   }

   161 

   162   /**

   163    * Tests EntityFieldQuery.

   164    */

   165   function testEntityFieldQuery() {

   166     $query = new EntityFieldQuery();

   167     $query

   168       ->entityCondition('entity_type', 'test_entity_bundle')

   169       ->entityCondition('entity_id', '5');

   170     $this->assertEntityFieldQuery($query, array(

   171       array('test_entity_bundle', 5),

   172     ), 'Test query on an entity type with a generated bundle.');

   173 

   174     // Test entity_type condition.

   175     $query = new EntityFieldQuery();

   176     $query->entityCondition('entity_type', 'test_entity_bundle_key');

   177     $this->assertEntityFieldQuery($query, array(

   178       array('test_entity_bundle_key', 1),

   179       array('test_entity_bundle_key', 2),

   180       array('test_entity_bundle_key', 3),

   181       array('test_entity_bundle_key', 4),

   182       array('test_entity_bundle_key', 5),

   183       array('test_entity_bundle_key', 6),

   184     ), 'Test entity entity_type condition.');

   185 

   186     // Test entity_id condition.

   187     $query = new EntityFieldQuery();

   188     $query

   189       ->entityCondition('entity_type', 'test_entity_bundle_key')

   190       ->entityCondition('entity_id', '3');

   191     $this->assertEntityFieldQuery($query, array(

   192       array('test_entity_bundle_key', 3),

   193     ), 'Test entity entity_id condition.');

   194 

   195     $query = new EntityFieldQuery();

   196     $query

   197       ->entityCondition('entity_type', 'test_entity_bundle_key')

   198       ->propertyCondition('ftid', '3');

   199     $this->assertEntityFieldQuery($query, array(

   200       array('test_entity_bundle_key', 3),

   201     ), 'Test entity entity_id condition and entity_id property condition.');

   202 

   203     // Test bundle condition.

   204     $query = new EntityFieldQuery();

   205     $query

   206       ->entityCondition('entity_type', 'test_entity_bundle_key')

   207       ->entityCondition('bundle', 'bundle1');

   208     $this->assertEntityFieldQuery($query, array(

   209       array('test_entity_bundle_key', 1),

   210       array('test_entity_bundle_key', 2),

   211       array('test_entity_bundle_key', 3),

   212       array('test_entity_bundle_key', 4),

   213     ), 'Test entity bundle condition: bundle1.');

   214 

   215     $query = new EntityFieldQuery();

   216     $query

   217       ->entityCondition('entity_type', 'test_entity_bundle_key')

   218       ->entityCondition('bundle', 'bundle2');

   219     $this->assertEntityFieldQuery($query, array(

   220       array('test_entity_bundle_key', 5),

   221       array('test_entity_bundle_key', 6),

   222     ), 'Test entity bundle condition: bundle2.');

   223 

   224     $query = new EntityFieldQuery();

   225     $query

   226       ->entityCondition('entity_type', 'test_entity_bundle_key')

   227       ->propertyCondition('fttype', 'bundle2');

   228     $this->assertEntityFieldQuery($query, array(

   229       array('test_entity_bundle_key', 5),

   230       array('test_entity_bundle_key', 6),

   231     ), 'Test entity bundle condition and bundle property condition.');

   232 

   233     // Test revision_id condition.

   234     $query = new EntityFieldQuery();

   235     $query

   236       ->entityCondition('entity_type', 'test_entity')

   237       ->entityCondition('revision_id', '3');

   238     $this->assertEntityFieldQuery($query, array(

   239       array('test_entity', 3),

   240     ), 'Test entity revision_id condition.');

   241 

   242     $query = new EntityFieldQuery();

   243     $query

   244       ->entityCondition('entity_type', 'test_entity')

   245       ->propertyCondition('ftvid', '3');

   246     $this->assertEntityFieldQuery($query, array(

   247       array('test_entity', 3),

   248     ), 'Test entity revision_id condition and revision_id property condition.');

   249 

   250     $query = new EntityFieldQuery();

   251     $query

   252       ->entityCondition('entity_type', 'test_entity')

   253       ->fieldCondition($this->fields[0], 'value', 100, '>=')

   254       ->age(FIELD_LOAD_REVISION);

   255     $this->assertEntityFieldQuery($query, array(

   256         array('test_entity', 100),

   257         array('test_entity', 101),

   258     ), 'Test revision age.');

   259 

   260     // Test that fields attached to the non-revision supporting entity

   261     // 'test_entity_bundle_key' are reachable in FIELD_LOAD_REVISION.

   262     $query = new EntityFieldQuery();

   263     $query

   264       ->fieldCondition($this->fields[0], 'value', 100, '<')

   265       ->age(FIELD_LOAD_REVISION);

   266     $this->assertEntityFieldQuery($query, array(

   267         array('test_entity_bundle_key', 1),

   268         array('test_entity_bundle_key', 2),

   269         array('test_entity_bundle_key', 3),

   270         array('test_entity_bundle_key', 4),

   271         array('test_entity_bundle_key', 5),

   272         array('test_entity_bundle_key', 6),

   273         array('test_entity', 1),

   274         array('test_entity', 2),

   275         array('test_entity', 3),

   276         array('test_entity', 4),

   277     ), 'Test that fields are reachable from FIELD_LOAD_REVISION even for non-revision entities.');

   278 

   279     // Test entity sort by entity_id.

   280     $query = new EntityFieldQuery();

   281     $query

   282       ->entityCondition('entity_type', 'test_entity_bundle_key')

   283       ->entityOrderBy('entity_id', 'ASC');

   284     $this->assertEntityFieldQuery($query, array(

   285       array('test_entity_bundle_key', 1),

   286       array('test_entity_bundle_key', 2),

   287       array('test_entity_bundle_key', 3),

   288       array('test_entity_bundle_key', 4),

   289       array('test_entity_bundle_key', 5),

   290       array('test_entity_bundle_key', 6),

   291     ), 'Test sort entity entity_id in ascending order.', TRUE);

   292 

   293     $query = new EntityFieldQuery();

   294     $query

   295       ->entityCondition('entity_type', 'test_entity_bundle_key')

   296       ->entityOrderBy('entity_id', 'DESC');

   297     $this->assertEntityFieldQuery($query, array(

   298       array('test_entity_bundle_key', 6),

   299       array('test_entity_bundle_key', 5),

   300       array('test_entity_bundle_key', 4),

   301       array('test_entity_bundle_key', 3),

   302       array('test_entity_bundle_key', 2),

   303       array('test_entity_bundle_key', 1),

   304     ), 'Test sort entity entity_id in descending order.', TRUE);

   305 

   306     // Test entity sort by entity_id, with a field condition.

   307     $query = new EntityFieldQuery();

   308     $query

   309       ->entityCondition('entity_type', 'test_entity_bundle_key')

   310       ->fieldCondition($this->fields[0], 'value', 0, '>')

   311       ->entityOrderBy('entity_id', 'ASC');

   312     $this->assertEntityFieldQuery($query, array(

   313       array('test_entity_bundle_key', 1),

   314       array('test_entity_bundle_key', 2),

   315       array('test_entity_bundle_key', 3),

   316       array('test_entity_bundle_key', 4),

   317       array('test_entity_bundle_key', 5),

   318       array('test_entity_bundle_key', 6),

   319     ), 'Test sort entity entity_id in ascending order, with a field condition.', TRUE);

   320 

   321     $query = new EntityFieldQuery();

   322     $query

   323       ->entityCondition('entity_type', 'test_entity_bundle_key')

   324       ->fieldCondition($this->fields[0], 'value', 0, '>')

   325       ->propertyOrderBy('ftid', 'DESC');

   326     $this->assertEntityFieldQuery($query, array(

   327       array('test_entity_bundle_key', 6),

   328       array('test_entity_bundle_key', 5),

   329       array('test_entity_bundle_key', 4),

   330       array('test_entity_bundle_key', 3),

   331       array('test_entity_bundle_key', 2),

   332       array('test_entity_bundle_key', 1),

   333     ), 'Test sort entity entity_id property in descending order, with a field condition.', TRUE);

   334 

   335     // Test property sort by entity id.

   336     $query = new EntityFieldQuery();

   337     $query

   338       ->entityCondition('entity_type', 'test_entity_bundle_key')

   339       ->propertyOrderBy('ftid', 'ASC');

   340     $this->assertEntityFieldQuery($query, array(

   341       array('test_entity_bundle_key', 1),

   342       array('test_entity_bundle_key', 2),

   343       array('test_entity_bundle_key', 3),

   344       array('test_entity_bundle_key', 4),

   345       array('test_entity_bundle_key', 5),

   346       array('test_entity_bundle_key', 6),

   347     ), 'Test sort entity entity_id property in ascending order.', TRUE);

   348 

   349     $query = new EntityFieldQuery();

   350     $query

   351       ->entityCondition('entity_type', 'test_entity_bundle_key')

   352       ->propertyOrderBy('ftid', 'DESC');

   353     $this->assertEntityFieldQuery($query, array(

   354       array('test_entity_bundle_key', 6),

   355       array('test_entity_bundle_key', 5),

   356       array('test_entity_bundle_key', 4),

   357       array('test_entity_bundle_key', 3),

   358       array('test_entity_bundle_key', 2),

   359       array('test_entity_bundle_key', 1),

   360     ), 'Test sort entity entity_id property in descending order.', TRUE);

   361 

   362     // Test property sort by entity id, with a field condition.

   363     $query = new EntityFieldQuery();

   364     $query

   365       ->entityCondition('entity_type', 'test_entity_bundle_key')

   366       ->fieldCondition($this->fields[0], 'value', 0, '>')

   367       ->propertyOrderBy('ftid', 'ASC');

   368     $this->assertEntityFieldQuery($query, array(

   369       array('test_entity_bundle_key', 1),

   370       array('test_entity_bundle_key', 2),

   371       array('test_entity_bundle_key', 3),

   372       array('test_entity_bundle_key', 4),

   373       array('test_entity_bundle_key', 5),

   374       array('test_entity_bundle_key', 6),

   375     ), 'Test sort entity entity_id property in ascending order, with a field condition.', TRUE);

   376 

   377     $query = new EntityFieldQuery();

   378     $query

   379       ->entityCondition('entity_type', 'test_entity_bundle_key')

   380       ->fieldCondition($this->fields[0], 'value', 0, '>')

   381       ->propertyOrderBy('ftid', 'DESC');

   382     $this->assertEntityFieldQuery($query, array(

   383       array('test_entity_bundle_key', 6),

   384       array('test_entity_bundle_key', 5),

   385       array('test_entity_bundle_key', 4),

   386       array('test_entity_bundle_key', 3),

   387       array('test_entity_bundle_key', 2),

   388       array('test_entity_bundle_key', 1),

   389     ), 'Test sort entity entity_id property in descending order, with a field condition.', TRUE);

   390 

   391     // Test entity sort by bundle.

   392     $query = new EntityFieldQuery();

   393     $query

   394       ->entityCondition('entity_type', 'test_entity_bundle_key')

   395       ->entityOrderBy('bundle', 'ASC')

   396       ->propertyOrderBy('ftid', 'DESC');

   397     $this->assertEntityFieldQuery($query, array(

   398       array('test_entity_bundle_key', 4),

   399       array('test_entity_bundle_key', 3),

   400       array('test_entity_bundle_key', 2),

   401       array('test_entity_bundle_key', 1),

   402       array('test_entity_bundle_key', 6),

   403       array('test_entity_bundle_key', 5),

   404     ), 'Test sort entity bundle in ascending order, property in descending order.', TRUE);

   405 

   406     $query = new EntityFieldQuery();

   407     $query

   408       ->entityCondition('entity_type', 'test_entity_bundle_key')

   409       ->entityOrderBy('bundle', 'DESC')

   410       ->propertyOrderBy('ftid', 'ASC');

   411     $this->assertEntityFieldQuery($query, array(

   412       array('test_entity_bundle_key', 5),

   413       array('test_entity_bundle_key', 6),

   414       array('test_entity_bundle_key', 1),

   415       array('test_entity_bundle_key', 2),

   416       array('test_entity_bundle_key', 3),

   417       array('test_entity_bundle_key', 4),

   418     ), 'Test sort entity bundle in descending order, property in ascending order.', TRUE);

   419 

   420     // Test entity sort by bundle, with a field condition.

   421     $query = new EntityFieldQuery();

   422     $query

   423       ->entityCondition('entity_type', 'test_entity_bundle_key')

   424       ->fieldCondition($this->fields[0], 'value', 0, '>')

   425       ->entityOrderBy('bundle', 'ASC')

   426       ->propertyOrderBy('ftid', 'DESC');

   427     $this->assertEntityFieldQuery($query, array(

   428       array('test_entity_bundle_key', 4),

   429       array('test_entity_bundle_key', 3),

   430       array('test_entity_bundle_key', 2),

   431       array('test_entity_bundle_key', 1),

   432       array('test_entity_bundle_key', 6),

   433       array('test_entity_bundle_key', 5),

   434     ), 'Test sort entity bundle in ascending order, property in descending order, with a field condition.', TRUE);

   435 

   436     $query = new EntityFieldQuery();

   437     $query

   438       ->entityCondition('entity_type', 'test_entity_bundle_key')

   439       ->fieldCondition($this->fields[0], 'value', 0, '>')

   440       ->entityOrderBy('bundle', 'DESC')

   441       ->propertyOrderBy('ftid', 'ASC');

   442     $this->assertEntityFieldQuery($query, array(

   443       array('test_entity_bundle_key', 5),

   444       array('test_entity_bundle_key', 6),

   445       array('test_entity_bundle_key', 1),

   446       array('test_entity_bundle_key', 2),

   447       array('test_entity_bundle_key', 3),

   448       array('test_entity_bundle_key', 4),

   449     ), 'Test sort entity bundle in descending order, property in ascending order, with a field condition.', TRUE);

   450 

   451     // Test entity sort by bundle, field.

   452     $query = new EntityFieldQuery();

   453     $query

   454       ->entityCondition('entity_type', 'test_entity_bundle_key')

   455       ->entityOrderBy('bundle', 'ASC')

   456       ->fieldOrderBy($this->fields[0], 'value', 'DESC');

   457     $this->assertEntityFieldQuery($query, array(

   458       array('test_entity_bundle_key', 4),

   459       array('test_entity_bundle_key', 3),

   460       array('test_entity_bundle_key', 2),

   461       array('test_entity_bundle_key', 1),

   462       array('test_entity_bundle_key', 6),

   463       array('test_entity_bundle_key', 5),

   464     ), 'Test sort entity bundle in ascending order, field in descending order.', TRUE);

   465 

   466     $query = new EntityFieldQuery();

   467     $query

   468       ->entityCondition('entity_type', 'test_entity_bundle_key')

   469       ->entityOrderBy('bundle', 'DESC')

   470       ->fieldOrderBy($this->fields[0], 'value', 'ASC');

   471     $this->assertEntityFieldQuery($query, array(

   472       array('test_entity_bundle_key', 5),

   473       array('test_entity_bundle_key', 6),

   474       array('test_entity_bundle_key', 1),

   475       array('test_entity_bundle_key', 2),

   476       array('test_entity_bundle_key', 3),

   477       array('test_entity_bundle_key', 4),

   478     ), 'Test sort entity bundle in descending order, field in ascending order.', TRUE);

   479 

   480     // Test entity sort by revision_id.

   481     $query = new EntityFieldQuery();

   482     $query

   483       ->entityCondition('entity_type', 'test_entity')

   484       ->entityOrderBy('revision_id', 'ASC');

   485     $this->assertEntityFieldQuery($query, array(

   486       array('test_entity', 1),

   487       array('test_entity', 2),

   488       array('test_entity', 3),

   489       array('test_entity', 4),

   490     ), 'Test sort entity revision_id in ascending order.', TRUE);

   491 

   492     $query = new EntityFieldQuery();

   493     $query

   494       ->entityCondition('entity_type', 'test_entity')

   495       ->entityOrderBy('revision_id', 'DESC');

   496     $this->assertEntityFieldQuery($query, array(

   497       array('test_entity', 4),

   498       array('test_entity', 3),

   499       array('test_entity', 2),

   500       array('test_entity', 1),

   501     ), 'Test sort entity revision_id in descending order.', TRUE);

   502 

   503     // Test entity sort by revision_id, with a field condition.

   504     $query = new EntityFieldQuery();

   505     $query

   506       ->entityCondition('entity_type', 'test_entity')

   507       ->fieldCondition($this->fields[0], 'value', 0, '>')

   508       ->entityOrderBy('revision_id', 'ASC');

   509     $this->assertEntityFieldQuery($query, array(

   510       array('test_entity', 1),

   511       array('test_entity', 2),

   512       array('test_entity', 3),

   513       array('test_entity', 4),

   514     ), 'Test sort entity revision_id in ascending order, with a field condition.', TRUE);

   515 

   516     $query = new EntityFieldQuery();

   517     $query

   518       ->entityCondition('entity_type', 'test_entity')

   519       ->fieldCondition($this->fields[0], 'value', 0, '>')

   520       ->entityOrderBy('revision_id', 'DESC');

   521     $this->assertEntityFieldQuery($query, array(

   522       array('test_entity', 4),

   523       array('test_entity', 3),

   524       array('test_entity', 2),

   525       array('test_entity', 1),

   526     ), 'Test sort entity revision_id in descending order, with a field condition.', TRUE);

   527 

   528     // Test property sort by revision_id.

   529     $query = new EntityFieldQuery();

   530     $query

   531       ->entityCondition('entity_type', 'test_entity')

   532       ->propertyOrderBy('ftvid', 'ASC');

   533     $this->assertEntityFieldQuery($query, array(

   534       array('test_entity', 1),

   535       array('test_entity', 2),

   536       array('test_entity', 3),

   537       array('test_entity', 4),

   538     ), 'Test sort entity revision_id property in ascending order.', TRUE);

   539 

   540     $query = new EntityFieldQuery();

   541     $query

   542       ->entityCondition('entity_type', 'test_entity')

   543       ->propertyOrderBy('ftvid', 'DESC');

   544     $this->assertEntityFieldQuery($query, array(

   545       array('test_entity', 4),

   546       array('test_entity', 3),

   547       array('test_entity', 2),

   548       array('test_entity', 1),

   549     ), 'Test sort entity revision_id property in descending order.', TRUE);

   550 

   551     // Test property sort by revision_id, with a field condition.

   552     $query = new EntityFieldQuery();

   553     $query

   554       ->entityCondition('entity_type', 'test_entity')

   555       ->fieldCondition($this->fields[0], 'value', 0, '>')

   556       ->propertyOrderBy('ftvid', 'ASC');

   557     $this->assertEntityFieldQuery($query, array(

   558       array('test_entity', 1),

   559       array('test_entity', 2),

   560       array('test_entity', 3),

   561       array('test_entity', 4),

   562     ), 'Test sort entity revision_id property in ascending order, with a field condition.', TRUE);

   563 

   564     $query = new EntityFieldQuery();

   565     $query

   566       ->entityCondition('entity_type', 'test_entity')

   567       ->fieldCondition($this->fields[0], 'value', 0, '>')

   568       ->propertyOrderBy('ftvid', 'DESC');

   569     $this->assertEntityFieldQuery($query, array(

   570       array('test_entity', 4),

   571       array('test_entity', 3),

   572       array('test_entity', 2),

   573       array('test_entity', 1),

   574     ), 'Test sort entity revision_id property in descending order, with a field condition.', TRUE);

   575 

   576     $query = new EntityFieldQuery();

   577     $query

   578       ->entityCondition('entity_type', 'test_entity_bundle_key')

   579       ->fieldOrderBy($this->fields[0], 'value', 'ASC');

   580     $this->assertEntityFieldQuery($query, array(

   581       array('test_entity_bundle_key', 1),

   582       array('test_entity_bundle_key', 2),

   583       array('test_entity_bundle_key', 3),

   584       array('test_entity_bundle_key', 4),

   585       array('test_entity_bundle_key', 5),

   586       array('test_entity_bundle_key', 6),

   587     ), 'Test sort field in ascending order without field condition.', TRUE);

   588 

   589     $query = new EntityFieldQuery();

   590     $query

   591       ->entityCondition('entity_type', 'test_entity_bundle_key')

   592       ->fieldOrderBy($this->fields[0], 'value', 'DESC');

   593     $this->assertEntityFieldQuery($query, array(

   594       array('test_entity_bundle_key', 6),

   595       array('test_entity_bundle_key', 5),

   596       array('test_entity_bundle_key', 4),

   597       array('test_entity_bundle_key', 3),

   598       array('test_entity_bundle_key', 2),

   599       array('test_entity_bundle_key', 1),

   600     ), 'Test sort field in descending order without field condition.', TRUE);

   601 

   602     $query = new EntityFieldQuery();

   603     $query

   604       ->entityCondition('entity_type', 'test_entity_bundle_key')

   605       ->fieldCondition($this->fields[0], 'value', 0, '>')

   606       ->fieldOrderBy($this->fields[0], 'value', 'ASC');

   607     $this->assertEntityFieldQuery($query, array(

   608       array('test_entity_bundle_key', 1),

   609       array('test_entity_bundle_key', 2),

   610       array('test_entity_bundle_key', 3),

   611       array('test_entity_bundle_key', 4),

   612       array('test_entity_bundle_key', 5),

   613       array('test_entity_bundle_key', 6),

   614     ), 'Test sort field in ascending order.', TRUE);

   615 

   616     $query = new EntityFieldQuery();

   617     $query

   618       ->entityCondition('entity_type', 'test_entity_bundle_key')

   619       ->fieldCondition($this->fields[0], 'value', 0, '>')

   620       ->fieldOrderBy($this->fields[0], 'value', 'DESC');

   621     $this->assertEntityFieldQuery($query, array(

   622       array('test_entity_bundle_key', 6),

   623       array('test_entity_bundle_key', 5),

   624       array('test_entity_bundle_key', 4),

   625       array('test_entity_bundle_key', 3),

   626       array('test_entity_bundle_key', 2),

   627       array('test_entity_bundle_key', 1),

   628     ), 'Test sort field in descending order.', TRUE);

   629 

   630     // Test "in" operation with entity entity_type condition and entity_id

   631     // property condition.

   632     $query = new EntityFieldQuery();

   633     $query

   634       ->entityCondition('entity_type', 'test_entity_bundle_key')

   635       ->propertyCondition('ftid', array(1, 3, 4), 'IN');

   636     $this->assertEntityFieldQuery($query, array(

   637       array('test_entity_bundle_key', 1),

   638       array('test_entity_bundle_key', 3),

   639       array('test_entity_bundle_key', 4),

   640     ), 'Test "in" operation with entity entity_type condition and entity_id property condition.');

   641 

   642     // Test "in" operation with entity entity_type condition and entity_id

   643     // property condition. Sort in descending order by entity_id.

   644     $query = new EntityFieldQuery();

   645     $query

   646       ->entityCondition('entity_type', 'test_entity_bundle_key')

   647       ->propertyCondition('ftid', array(1, 3, 4), 'IN')

   648       ->propertyOrderBy('ftid', 'DESC');

   649     $this->assertEntityFieldQuery($query, array(

   650       array('test_entity_bundle_key', 4),

   651       array('test_entity_bundle_key', 3),

   652       array('test_entity_bundle_key', 1),

   653     ), 'Test "in" operation with entity entity_type condition and entity_id property condition. Sort entity_id in descending order.', TRUE);

   654 

   655     // Test query count

   656     $query = new EntityFieldQuery();

   657     $query_count = $query

   658       ->entityCondition('entity_type', 'test_entity_bundle_key')

   659       ->count()

   660       ->execute();

   661     $this->assertEqual($query_count, 6, 'Test query count on entity condition.');

   662 

   663     $query = new EntityFieldQuery();

   664     $query_count = $query

   665       ->entityCondition('entity_type', 'test_entity_bundle_key')

   666       ->propertyCondition('ftid', '1')

   667       ->count()

   668       ->execute();

   669     $this->assertEqual($query_count, 1, 'Test query count on entity and property condition.');

   670 

   671     $query = new EntityFieldQuery();

   672     $query_count = $query

   673       ->entityCondition('entity_type', 'test_entity_bundle_key')

   674       ->propertyCondition('ftid', '4', '>')

   675       ->count()

   676       ->execute();

   677     $this->assertEqual($query_count, 2, 'Test query count on entity and property condition with operator.');

   678 

   679     $query = new EntityFieldQuery();

   680     $query_count = $query

   681       ->entityCondition('entity_type', 'test_entity_bundle_key')

   682       ->fieldCondition($this->fields[0], 'value', 3, '=')

   683       ->count()

   684       ->execute();

   685     $this->assertEqual($query_count, 1, 'Test query count on field condition.');

   686 

   687     // First, test without options.

   688     $query = new EntityFieldQuery();

   689     $query

   690       ->entityCondition('entity_type', 'test_entity_bundle_key')

   691       ->propertyCondition('fttype', 'und', 'CONTAINS');

   692     $this->assertEntityFieldQuery($query, array(

   693       array('test_entity_bundle_key', 1),

   694       array('test_entity_bundle_key', 2),

   695       array('test_entity_bundle_key', 3),

   696       array('test_entity_bundle_key', 4),

   697       array('test_entity_bundle_key', 5),

   698       array('test_entity_bundle_key', 6),

   699     ), 'Test the "contains" operation on a property.');

   700 

   701     $query = new EntityFieldQuery();

   702     $query->fieldCondition($this->fields[1], 'shape', 'uar', 'CONTAINS');

   703     $this->assertEntityFieldQuery($query, array(

   704       array('test_entity_bundle', 5),

   705     ), 'Test the "contains" operation on a field.');

   706 

   707     $query = new EntityFieldQuery();

   708     $query

   709       ->entityCondition('entity_type', 'test_entity_bundle_key')

   710       ->propertyCondition('ftid', 1, '=');

   711     $this->assertEntityFieldQuery($query, array(

   712       array('test_entity_bundle_key', 1),

   713     ), 'Test the "equal to" operation on a property.');

   714 

   715     $query = new EntityFieldQuery();

   716     $query->fieldCondition($this->fields[0], 'value', 3, '=');

   717     $this->assertEntityFieldQuery($query, array(

   718       array('test_entity_bundle_key', 3),

   719       array('test_entity', 3),

   720     ), 'Test the "equal to" operation on a field.');

   721 

   722     $query = new EntityFieldQuery();

   723     $query

   724       ->entityCondition('entity_type', 'test_entity_bundle_key')

   725       ->propertyCondition('ftid', 3, '<>');

   726     $this->assertEntityFieldQuery($query, array(

   727       array('test_entity_bundle_key', 1),

   728       array('test_entity_bundle_key', 2),

   729       array('test_entity_bundle_key', 4),

   730       array('test_entity_bundle_key', 5),

   731       array('test_entity_bundle_key', 6),

   732     ), 'Test the "not equal to" operation on a property.');

   733 

   734     $query = new EntityFieldQuery();

   735     $query->fieldCondition($this->fields[0], 'value', 3, '<>');

   736     $this->assertEntityFieldQuery($query, array(

   737       array('test_entity_bundle_key', 1),

   738       array('test_entity_bundle_key', 2),

   739       array('test_entity_bundle_key', 4),

   740       array('test_entity_bundle_key', 5),

   741       array('test_entity_bundle_key', 6),

   742       array('test_entity', 1),

   743       array('test_entity', 2),

   744       array('test_entity', 4),

   745     ), 'Test the "not equal to" operation on a field.');

   746 

   747     $query = new EntityFieldQuery();

   748     $query

   749       ->entityCondition('entity_type', 'test_entity_bundle_key')

   750       ->propertyCondition('ftid', 3, '!=');

   751     $this->assertEntityFieldQuery($query, array(

   752       array('test_entity_bundle_key', 1),

   753       array('test_entity_bundle_key', 2),

   754       array('test_entity_bundle_key', 4),

   755       array('test_entity_bundle_key', 5),

   756       array('test_entity_bundle_key', 6),

   757     ), 'Test the "not equal to" operation on a property.');

   758 

   759     $query = new EntityFieldQuery();

   760     $query->fieldCondition($this->fields[0], 'value', 3, '!=');

   761     $this->assertEntityFieldQuery($query, array(

   762       array('test_entity_bundle_key', 1),

   763       array('test_entity_bundle_key', 2),

   764       array('test_entity_bundle_key', 4),

   765       array('test_entity_bundle_key', 5),

   766       array('test_entity_bundle_key', 6),

   767       array('test_entity', 1),

   768       array('test_entity', 2),

   769       array('test_entity', 4),

   770     ), 'Test the "not equal to" operation on a field.');

   771 

   772     $query = new EntityFieldQuery();

   773     $query

   774       ->entityCondition('entity_type', 'test_entity_bundle_key')

   775       ->propertyCondition('ftid', 2, '<');

   776     $this->assertEntityFieldQuery($query, array(

   777       array('test_entity_bundle_key', 1),

   778     ), 'Test the "less than" operation on a property.');

   779 

   780     $query = new EntityFieldQuery();

   781     $query->fieldCondition($this->fields[0], 'value', 2, '<');

   782     $this->assertEntityFieldQuery($query, array(

   783       array('test_entity_bundle_key', 1),

   784       array('test_entity', 1),

   785     ), 'Test the "less than" operation on a field.');

   786 

   787     $query = new EntityFieldQuery();

   788     $query

   789       ->entityCondition('entity_type', 'test_entity_bundle_key')

   790       ->propertyCondition('ftid', 2, '<=');

   791     $this->assertEntityFieldQuery($query, array(

   792       array('test_entity_bundle_key', 1),

   793       array('test_entity_bundle_key', 2),

   794     ), 'Test the "less than or equal to" operation on a property.');

   795 

   796     $query = new EntityFieldQuery();

   797     $query->fieldCondition($this->fields[0], 'value', 2, '<=');

   798     $this->assertEntityFieldQuery($query, array(

   799       array('test_entity_bundle_key', 1),

   800       array('test_entity_bundle_key', 2),

   801       array('test_entity', 1),

   802       array('test_entity', 2),

   803     ), 'Test the "less than or equal to" operation on a field.');

   804 

   805     $query = new EntityFieldQuery();

   806     $query

   807       ->entityCondition('entity_type', 'test_entity_bundle_key')

   808       ->propertyCondition('ftid', 4, '>');

   809     $this->assertEntityFieldQuery($query, array(

   810       array('test_entity_bundle_key', 5),

   811       array('test_entity_bundle_key', 6),

   812     ), 'Test the "greater than" operation on a property.');

   813 

   814     $query = new EntityFieldQuery();

   815     $query->fieldCondition($this->fields[0], 'value', 2, '>');

   816     $this->assertEntityFieldQuery($query, array(

   817       array('test_entity_bundle_key', 3),

   818       array('test_entity_bundle_key', 4),

   819       array('test_entity_bundle_key', 5),

   820       array('test_entity_bundle_key', 6),

   821       array('test_entity', 3),

   822       array('test_entity', 4),

   823     ), 'Test the "greater than" operation on a field.');

   824 

   825     $query = new EntityFieldQuery();

   826     $query

   827       ->entityCondition('entity_type', 'test_entity_bundle_key')

   828       ->propertyCondition('ftid', 4, '>=');

   829     $this->assertEntityFieldQuery($query, array(

   830       array('test_entity_bundle_key', 4),

   831       array('test_entity_bundle_key', 5),

   832       array('test_entity_bundle_key', 6),

   833     ), 'Test the "greater than or equal to" operation on a property.');

   834 

   835     $query = new EntityFieldQuery();

   836     $query->fieldCondition($this->fields[0], 'value', 3, '>=');

   837     $this->assertEntityFieldQuery($query, array(

   838       array('test_entity_bundle_key', 3),

   839       array('test_entity_bundle_key', 4),

   840       array('test_entity_bundle_key', 5),

   841       array('test_entity_bundle_key', 6),

   842       array('test_entity', 3),

   843       array('test_entity', 4),

   844     ), 'Test the "greater than or equal to" operation on a field.');

   845 

   846     $query = new EntityFieldQuery();

   847     $query

   848       ->entityCondition('entity_type', 'test_entity_bundle_key')

   849       ->propertyCondition('ftid', array(3, 4), 'NOT IN');

   850     $this->assertEntityFieldQuery($query, array(

   851       array('test_entity_bundle_key', 1),

   852       array('test_entity_bundle_key', 2),

   853       array('test_entity_bundle_key', 5),

   854       array('test_entity_bundle_key', 6),

   855     ), 'Test the "not in" operation on a property.');

   856 

   857     $query = new EntityFieldQuery();

   858     $query->fieldCondition($this->fields[0], 'value', array(3, 4, 100, 101), 'NOT IN');

   859     $this->assertEntityFieldQuery($query, array(

   860       array('test_entity_bundle_key', 1),

   861       array('test_entity_bundle_key', 2),

   862       array('test_entity_bundle_key', 5),

   863       array('test_entity_bundle_key', 6),

   864       array('test_entity', 1),

   865       array('test_entity', 2),

   866     ), 'Test the "not in" operation on a field.');

   867 

   868     $query = new EntityFieldQuery();

   869     $query

   870       ->entityCondition('entity_type', 'test_entity_bundle_key')

   871       ->propertyCondition('ftid', array(3, 4), 'IN');

   872     $this->assertEntityFieldQuery($query, array(

   873       array('test_entity_bundle_key', 3),

   874       array('test_entity_bundle_key', 4),

   875     ), 'Test the "in" operation on a property.');

   876 

   877     $query = new EntityFieldQuery();

   878     $query->fieldCondition($this->fields[0], 'value', array(2, 3), 'IN');

   879     $this->assertEntityFieldQuery($query, array(

   880       array('test_entity_bundle_key', 2),

   881       array('test_entity_bundle_key', 3),

   882       array('test_entity', 2),

   883       array('test_entity', 3),

   884     ), 'Test the "in" operation on a field.');

   885 

   886     $query = new EntityFieldQuery();

   887     $query

   888       ->entityCondition('entity_type', 'test_entity_bundle_key')

   889       ->propertyCondition('ftid', array(1, 3), 'BETWEEN');

   890     $this->assertEntityFieldQuery($query, array(

   891       array('test_entity_bundle_key', 1),

   892       array('test_entity_bundle_key', 2),

   893       array('test_entity_bundle_key', 3),

   894     ), 'Test the "between" operation on a property.');

   895 

   896     $query = new EntityFieldQuery();

   897     $query->fieldCondition($this->fields[0], 'value', array(1, 3), 'BETWEEN');

   898     $this->assertEntityFieldQuery($query, array(

   899       array('test_entity_bundle_key', 1),

   900       array('test_entity_bundle_key', 2),

   901       array('test_entity_bundle_key', 3),

   902       array('test_entity', 1),

   903       array('test_entity', 2),

   904       array('test_entity', 3),

   905     ), 'Test the "between" operation on a field.');

   906 

   907     $query = new EntityFieldQuery();

   908     $query

   909       ->entityCondition('entity_type', 'test_entity_bundle_key')

   910       ->propertyCondition('fttype', 'bun', 'STARTS_WITH');

   911     $this->assertEntityFieldQuery($query, array(

   912       array('test_entity_bundle_key', 1),

   913       array('test_entity_bundle_key', 2),

   914       array('test_entity_bundle_key', 3),

   915       array('test_entity_bundle_key', 4),

   916       array('test_entity_bundle_key', 5),

   917       array('test_entity_bundle_key', 6),

   918     ), 'Test the "starts_with" operation on a property.');

   919 

   920     $query = new EntityFieldQuery();

   921     $query->fieldCondition($this->fields[1], 'shape', 'squ', 'STARTS_WITH');

   922     $this->assertEntityFieldQuery($query, array(

   923       array('test_entity_bundle', 5),

   924     ), 'Test the "starts_with" operation on a field.');

   925 

   926     $query = new EntityFieldQuery();

   927     $query->fieldCondition($this->fields[0], 'value', 3);

   928     $this->assertEntityFieldQuery($query, array(

   929       array('test_entity_bundle_key', 3),

   930       array('test_entity', 3),

   931     ), 'Test omission of an operator with a single item.');

   932 

   933     $query = new EntityFieldQuery();

   934     $query->fieldCondition($this->fields[0], 'value', array(2, 3));

   935     $this->assertEntityFieldQuery($query, array(

   936       array('test_entity_bundle_key', 2),

   937       array('test_entity_bundle_key', 3),

   938       array('test_entity', 2),

   939       array('test_entity', 3),

   940     ), 'Test omission of an operator with multiple items.');

   941 

   942     $query = new EntityFieldQuery();

   943     $query

   944       ->entityCondition('entity_type', 'test_entity_bundle_key')

   945       ->propertyCondition('ftid', 1, '>')

   946       ->fieldCondition($this->fields[0], 'value', 4, '<');

   947     $this->assertEntityFieldQuery($query, array(

   948       array('test_entity_bundle_key', 2),

   949       array('test_entity_bundle_key', 3),

   950     ), 'Test entity, property and field conditions.');

   951 

   952     $query = new EntityFieldQuery();

   953     $query

   954       ->entityCondition('entity_type', 'test_entity_bundle_key')

   955       ->entityCondition('bundle', 'bundle', 'STARTS_WITH')

   956       ->propertyCondition('ftid', 4)

   957       ->fieldCondition($this->fields[0], 'value', 4);

   958     $this->assertEntityFieldQuery($query, array(

   959       array('test_entity_bundle_key', 4),

   960     ), 'Test entity condition with "starts_with" operation, and property and field conditions.');

   961 

   962     $query = new EntityFieldQuery();

   963     $query

   964       ->entityCondition('entity_type', 'test_entity_bundle_key')

   965       ->propertyOrderBy('ftid', 'ASC')

   966       ->range(0, 2);

   967     $this->assertEntityFieldQuery($query, array(

   968       array('test_entity_bundle_key', 1),

   969       array('test_entity_bundle_key', 2),

   970     ), 'Test limit on a property.', TRUE);

   971 

   972     $query = new EntityFieldQuery();

   973     $query

   974       ->entityCondition('entity_type', 'test_entity_bundle_key')

   975       ->fieldCondition($this->fields[0], 'value', 0, '>=')

   976       ->fieldOrderBy($this->fields[0], 'value', 'ASC')

   977       ->range(0, 2);

   978     $this->assertEntityFieldQuery($query, array(

   979       array('test_entity_bundle_key', 1),

   980       array('test_entity_bundle_key', 2),

   981     ), 'Test limit on a field.', TRUE);

   982 

   983     $query = new EntityFieldQuery();

   984     $query

   985       ->entityCondition('entity_type', 'test_entity_bundle_key')

   986       ->propertyOrderBy('ftid', 'ASC')

   987       ->range(4, 6);

   988     $this->assertEntityFieldQuery($query, array(

   989       array('test_entity_bundle_key', 5),

   990       array('test_entity_bundle_key', 6),

   991     ), 'Test offset on a property.', TRUE);

   992 

   993     $query = new EntityFieldQuery();

   994     $query

   995       ->entityCondition('entity_type', 'test_entity_bundle_key')

   996       ->fieldCondition($this->fields[0], 'value', 0, '>')

   997       ->fieldOrderBy($this->fields[0], 'value', 'ASC')

   998       ->range(2, 4);

   999     $this->assertEntityFieldQuery($query, array(

  1000       array('test_entity_bundle_key', 3),

  1001       array('test_entity_bundle_key', 4),

  1002       array('test_entity_bundle_key', 5),

  1003       array('test_entity_bundle_key', 6),

  1004     ), 'Test offset on a field.', TRUE);

  1005 

  1006     for ($i = 6; $i < 10; $i++) {

  1007       $entity = new stdClass();

  1008       $entity->ftid = $i;

  1009       $entity->fttype = 'test_entity_bundle';

  1010       $entity->{$this->field_names[0]}[LANGUAGE_NONE][0]['value'] = $i - 5;

  1011       drupal_write_record('test_entity_bundle', $entity);

  1012       field_attach_insert('test_entity_bundle', $entity);

  1013     }

  1014 

  1015     $query = new EntityFieldQuery();

  1016     $query->fieldCondition($this->fields[0], 'value', 2, '>');

  1017     $this->assertEntityFieldQuery($query, array(

  1018       array('test_entity_bundle_key', 3),

  1019       array('test_entity_bundle_key', 4),

  1020       array('test_entity_bundle_key', 5),

  1021       array('test_entity_bundle_key', 6),

  1022       array('test_entity', 3),

  1023       array('test_entity', 4),

  1024       array('test_entity_bundle', 8),

  1025       array('test_entity_bundle', 9),

  1026     ), 'Select a field across multiple entities.');

  1027 

  1028     $query = new EntityFieldQuery();

  1029     $query

  1030       ->fieldCondition($this->fields[1], 'shape', 'square')

  1031       ->fieldCondition($this->fields[1], 'color', 'blue');

  1032     $this->assertEntityFieldQuery($query, array(

  1033       array('test_entity_bundle', 5),

  1034     ), 'Test without a delta group.');

  1035 

  1036     $query = new EntityFieldQuery();

  1037     $query

  1038       ->fieldCondition($this->fields[1], 'shape', 'square', '=', 'group')

  1039       ->fieldCondition($this->fields[1], 'color', 'blue', '=', 'group');

  1040     $this->assertEntityFieldQuery($query, array(), 'Test with a delta group.');

  1041 

  1042     // Test query on a deleted field.

  1043     field_attach_delete_bundle('test_entity_bundle_key', 'bundle1');

  1044     field_attach_delete_bundle('test_entity', 'test_bundle');

  1045     $query = new EntityFieldQuery();

  1046     $query->fieldCondition($this->fields[0], 'value', '3');

  1047     $this->assertEntityFieldQuery($query, array(

  1048       array('test_entity_bundle', 8),

  1049     ), 'Test query on a field after deleting field from some entities.');

  1050 

  1051     field_attach_delete_bundle('test_entity_bundle', 'test_entity_bundle');

  1052     $query = new EntityFieldQuery();

  1053     $query->fieldCondition($this->fields[0], 'value', '3');

  1054     $this->assertEntityFieldQuery($query, array(), 'Test query on a field after deleting field from all entities.');

  1055 

  1056     $query = new EntityFieldQuery();

  1057     $query

  1058       ->fieldCondition($this->fields[0], 'value', '3')

  1059       ->deleted(TRUE);

  1060     $this->assertEntityFieldQuery($query, array(

  1061       array('test_entity_bundle_key', 3),

  1062       array('test_entity_bundle', 8),

  1063       array('test_entity', 3),

  1064     ), 'Test query on a deleted field with deleted option set to TRUE.');

  1065 

  1066     $pass = FALSE;

  1067     $query = new EntityFieldQuery();

  1068     try {

  1069       $query->execute();

  1070     }

  1071     catch (EntityFieldQueryException $exception) {

  1072       $pass = ($exception->getMessage() == t('For this query an entity type must be specified.'));

  1073     }

  1074     $this->assertTrue($pass, "Can't query the universe.");

  1075   }

  1076 

  1077   /**

  1078    * Tests querying translatable fields.

  1079    */

  1080   function testEntityFieldQueryTranslatable() {

  1081 

  1082     // Make a test field translatable AND cardinality one.

  1083     $this->fields[0]['translatable'] = TRUE;

  1084     $this->fields[0]['cardinality'] = 1;

  1085     field_update_field($this->fields[0]);

  1086     field_test_entity_info_translatable('test_entity', TRUE);

  1087 

  1088     // Create more items with different languages.

  1089     $entity = new stdClass();

  1090     $entity->ftid = 1;

  1091     $entity->ftvid = 1;

  1092     $entity->fttype = 'test_bundle';

  1093 

  1094     // Set fields in two languages with one field value.

  1095     foreach (array(LANGUAGE_NONE, 'en') as $langcode) {

  1096       $entity->{$this->field_names[0]}[$langcode][0]['value'] = 1234;

  1097     }

  1098 

  1099     field_attach_update('test_entity', $entity);

  1100 

  1101     // Look up number of results when querying a single entity with multilingual

  1102     // field values.

  1103     $query = new EntityFieldQuery();

  1104     $query_count = $query

  1105       ->entityCondition('entity_type', 'test_entity')

  1106       ->entityCondition('bundle', 'test_bundle')

  1107       ->entityCondition('entity_id', '1')

  1108       ->fieldCondition($this->fields[0])

  1109       ->count()

  1110       ->execute();

  1111 

  1112     $this->assertEqual($query_count, 1, "Count on translatable cardinality one field is correct.");

  1113   }

  1114 

  1115   /**

  1116    * Tests field meta conditions.

  1117    */

  1118   function testEntityFieldQueryMetaConditions() {

  1119     // Make a test field translatable.

  1120     $this->fields[0]['translatable'] = TRUE;

  1121     field_update_field($this->fields[0]);

  1122     field_test_entity_info_translatable('test_entity', TRUE);

  1123 

  1124     // Create more items with different languages.

  1125     $entity = new stdClass();

  1126     $entity->ftid = 1;

  1127     $entity->ftvid = 1;

  1128     $entity->fttype = 'test_bundle';

  1129     $j = 0;

  1130 

  1131     foreach (array(LANGUAGE_NONE, 'en') as $langcode) {

  1132       for ($i = 0; $i < 4; $i++) {

  1133         $entity->{$this->field_names[0]}[$langcode][$i]['value'] = $i + $j;

  1134       }

  1135       $j += 4;

  1136     }