1 <?php

     2 

     3 /**

     4  * @file

     5  * Unit tests for the Drupal Form API.

     6  */

     7 

     8 class FormsTestCase extends DrupalWebTestCase {

     9 

    10   public static function getInfo() {

    11     return array(

    12       'name' => 'Form element validation',

    13       'description' => 'Tests various form element validation mechanisms.',

    14       'group' => 'Form API',

    15     );

    16   }

    17 

    18   function setUp() {

    19     parent::setUp('form_test');

    20   }

    21 

    22   /**

    23    * Check several empty values for required forms elements.

    24    *

    25    * Carriage returns, tabs, spaces, and unchecked checkbox elements are not

    26    * valid content for a required field.

    27    *

    28    * If the form field is found in form_get_errors() then the test pass.

    29    */

    30   function testRequiredFields() {

    31     // Originates from http://drupal.org/node/117748

    32     // Sets of empty strings and arrays.

    33     $empty_strings = array('""' => "", '"\n"' => "\n", '" "' => " ", '"\t"' => "\t", '" \n\t "' => " \n\t ", '"\n\n\n\n\n"' => "\n\n\n\n\n");

    34     $empty_arrays = array('array()' => array());

    35     $empty_checkbox = array(NULL);

    36 

    37     $elements['textfield']['element'] = array('#title' => $this->randomName(), '#type' => 'textfield');

    38     $elements['textfield']['empty_values'] = $empty_strings;

    39 

    40     $elements['password']['element'] = array('#title' => $this->randomName(), '#type' => 'password');

    41     $elements['password']['empty_values'] = $empty_strings;

    42 

    43     $elements['password_confirm']['element'] = array('#title' => $this->randomName(), '#type' => 'password_confirm');

    44     // Provide empty values for both password fields.

    45     foreach ($empty_strings as $key => $value) {

    46       $elements['password_confirm']['empty_values'][$key] = array('pass1' => $value, 'pass2' => $value);

    47     }

    48 

    49     $elements['textarea']['element'] = array('#title' => $this->randomName(), '#type' => 'textarea');

    50     $elements['textarea']['empty_values'] = $empty_strings;

    51 

    52     $elements['radios']['element'] = array('#title' => $this->randomName(), '#type' => 'radios', '#options' => array('' => t('None'), $this->randomName(), $this->randomName(), $this->randomName()));

    53     $elements['radios']['empty_values'] = $empty_arrays;

    54 

    55     $elements['checkbox']['element'] = array('#title' => $this->randomName(), '#type' => 'checkbox', '#required' => TRUE);

    56     $elements['checkbox']['empty_values'] = $empty_checkbox;

    57 

    58     $elements['checkboxes']['element'] = array('#title' => $this->randomName(), '#type' => 'checkboxes', '#options' => array($this->randomName(), $this->randomName(), $this->randomName()));

    59     $elements['checkboxes']['empty_values'] = $empty_arrays;

    60 

    61     $elements['select']['element'] = array('#title' => $this->randomName(), '#type' => 'select', '#options' => array('' => t('None'), $this->randomName(), $this->randomName(), $this->randomName()));

    62     $elements['select']['empty_values'] = $empty_strings;

    63 

    64     $elements['file']['element'] = array('#title' => $this->randomName(), '#type' => 'file');

    65     $elements['file']['empty_values'] = $empty_strings;

    66 

    67     // Regular expression to find the expected marker on required elements.

    68     $required_marker_preg = '@<label.*<span class="form-required" title="This field is required\.">\*</span></label>@';

    69 

    70     // Go through all the elements and all the empty values for them.

    71     foreach ($elements as $type => $data) {

    72       foreach ($data['empty_values'] as $key => $empty) {

    73         foreach (array(TRUE, FALSE) as $required) {

    74           $form_id = $this->randomName();

    75           $form = array();

    76           $form_state = form_state_defaults();

    77           form_clear_error();

    78           $form['op'] = array('#type' => 'submit', '#value' => t('Submit'));

    79           $element = $data['element']['#title'];

    80           $form[$element] = $data['element'];

    81           $form[$element]['#required'] = $required;

    82           $form_state['input'][$element] = $empty;

    83           $form_state['input']['form_id'] = $form_id;

    84           $form_state['method'] = 'post';

    85 

    86           // The form token CSRF protection should not interfere with this test,

    87           // so we bypass it by marking this test form as programmed.

    88           $form_state['programmed'] = TRUE;

    89           drupal_prepare_form($form_id, $form, $form_state);

    90           drupal_process_form($form_id, $form, $form_state);

    91           $errors = form_get_errors();

    92           // Form elements of type 'radios' throw all sorts of PHP notices

    93           // when you try to render them like this, so we ignore those for

    94           // testing the required marker.

    95           // @todo Fix this work-around (http://drupal.org/node/588438).

    96           $form_output = ($type == 'radios') ? '' : drupal_render($form);

    97           if ($required) {

    98             // Make sure we have a form error for this element.

    99             $this->assertTrue(isset($errors[$element]), "Check empty($key) '$type' field '$element'");

   100             if (!empty($form_output)) {

   101               // Make sure the form element is marked as required.

   102               $this->assertTrue(preg_match($required_marker_preg, $form_output), "Required '$type' field is marked as required");

   103             }

   104           }

   105           else {

   106             if (!empty($form_output)) {

   107               // Make sure the form element is *not* marked as required.

   108               $this->assertFalse(preg_match($required_marker_preg, $form_output), "Optional '$type' field is not marked as required");

   109             }

   110             if ($type == 'select') {

   111               // Select elements are going to have validation errors with empty

   112               // input, since those are illegal choices. Just make sure the

   113               // error is not "field is required".

   114               $this->assertTrue((empty($errors[$element]) || strpos('field is required', $errors[$element]) === FALSE), "Optional '$type' field '$element' is not treated as a required element");

   115             }

   116             else {

   117               // Make sure there is *no* form error for this element.

   118               $this->assertTrue(empty($errors[$element]), "Optional '$type' field '$element' has no errors with empty input");

   119             }

   120           }

   121         }

   122       }

   123     }

   124     // Clear the expected form error messages so they don't appear as exceptions.

   125     drupal_get_messages();

   126   }

   127 

   128   /**

   129    * Tests validation for required checkbox, select, and radio elements.

   130    *

   131    * Submits a test form containing several types of form elements. The form

   132    * is submitted twice, first without values for required fields and then

   133    * with values. Each submission is checked for relevant error messages.

   134    *

   135    * @see form_test_validate_required_form()

   136    */

   137   function testRequiredCheckboxesRadio() {

   138     $form = $form_state = array();

   139     $form = form_test_validate_required_form($form, $form_state);

   140 

   141     // Attempt to submit the form with no required fields set.

   142     $edit = array();

   143     $this->drupalPost('form-test/validate-required', $edit, 'Submit');

   144 

   145     // The only error messages that should appear are the relevant 'required'

   146     // messages for each field.

   147     $expected = array();

   148     foreach (array('textfield', 'checkboxes', 'select', 'radios') as $key) {

   149       $expected[] = t('!name field is required.', array('!name' => $form[$key]['#title']));

   150     }

   151 

   152     // Check the page for error messages.

   153     $errors = $this->xpath('//div[contains(@class, "error")]//li');

   154     foreach ($errors as $error) {

   155       $expected_key = array_search($error[0], $expected);

   156       // If the error message is not one of the expected messages, fail.

   157       if ($expected_key === FALSE) {

   158         $this->fail(format_string("Unexpected error message: @error", array('@error' => $error[0])));

   159       }

   160       // Remove the expected message from the list once it is found.

   161       else {

   162         unset($expected[$expected_key]);

   163       }

   164     }

   165 

   166     // Fail if any expected messages were not found.

   167     foreach ($expected as $not_found) {

   168       $this->fail(format_string("Found error message: @error", array('@error' => $not_found)));

   169     }

   170 

   171     // Verify that input elements are still empty.

   172     $this->assertFieldByName('textfield', '');

   173     $this->assertNoFieldChecked('edit-checkboxes-foo');

   174     $this->assertNoFieldChecked('edit-checkboxes-bar');

   175     $this->assertOptionSelected('edit-select', '');

   176     $this->assertNoFieldChecked('edit-radios-foo');

   177     $this->assertNoFieldChecked('edit-radios-bar');

   178     $this->assertNoFieldChecked('edit-radios-optional-foo');

   179     $this->assertNoFieldChecked('edit-radios-optional-bar');

   180     $this->assertNoFieldChecked('edit-radios-optional-default-value-false-foo');

   181     $this->assertNoFieldChecked('edit-radios-optional-default-value-false-bar');

   182 

   183     // Submit again with required fields set and verify that there are no

   184     // error messages.

   185     $edit = array(

   186       'textfield' => $this->randomString(),

   187       'checkboxes[foo]' => TRUE,

   188       'select' => 'foo',

   189       'radios' => 'bar',

   190     );

   191     $this->drupalPost(NULL, $edit, 'Submit');

   192     $this->assertNoFieldByXpath('//div[contains(@class, "error")]', FALSE, 'No error message is displayed when all required fields are filled.');

   193     $this->assertRaw("The form_test_validate_required_form form was submitted successfully.", 'Validation form submitted successfully.');

   194   }

   195 

   196   /**

   197    * Tests validation for required textfield element without title.

   198    *

   199    * Submits a test form containing a textfield form elements without title.

   200    * The form is submitted twice, first without value for the required field

   201    * and then with value. Each submission is checked for relevant error

   202    * messages.

   203    *

   204    * @see form_test_validate_required_form_no_title()

   205    */

   206   function testRequiredTextfieldNoTitle() {

   207     $form = $form_state = array();

   208     $form = form_test_validate_required_form_no_title($form, $form_state);

   209 

   210     // Attempt to submit the form with no required field set.

   211     $edit = array();

   212     $this->drupalPost('form-test/validate-required-no-title', $edit, 'Submit');

   213     $this->assertNoRaw("The form_test_validate_required_form_no_title form was submitted successfully.", 'Validation form submitted successfully.');

   214 

   215     // Check the page for the error class on the textfield.

   216     $this->assertFieldByXPath('//input[contains(@class, "error")]', FALSE, 'Error input form element class found.');

   217 

   218     // Submit again with required fields set and verify that there are no

   219     // error messages.

   220     $edit = array(

   221       'textfield' => $this->randomString(),

   222     );

   223     $this->drupalPost(NULL, $edit, 'Submit');

   224     $this->assertNoFieldByXpath('//input[contains(@class, "error")]', FALSE, 'No error input form element class found.');

   225     $this->assertRaw("The form_test_validate_required_form_no_title form was submitted successfully.", 'Validation form submitted successfully.');

   226   }

   227 

   228   /**

   229    * Test default value handling for checkboxes.

   230    *

   231    * @see _form_test_checkbox()

   232    */

   233   function testCheckboxProcessing() {

   234     // First, try to submit without the required checkbox.

   235     $edit = array();

   236     $this->drupalPost('form-test/checkbox', $edit, t('Submit'));

   237     $this->assertRaw(t('!name field is required.', array('!name' => 'required_checkbox')), 'A required checkbox is actually mandatory');

   238 

   239     // Now try to submit the form correctly.

   240     $values = drupal_json_decode($this->drupalPost(NULL, array('required_checkbox' => 1), t('Submit')));

   241     $expected_values = array(

   242       'disabled_checkbox_on' => 'disabled_checkbox_on',

   243       'disabled_checkbox_off' => '',

   244       'checkbox_on' => 'checkbox_on',

   245       'checkbox_off' => '',

   246       'zero_checkbox_on' => '0',

   247       'zero_checkbox_off' => '',

   248     );

   249     foreach ($expected_values as $widget => $expected_value) {

   250       $this->assertEqual($values[$widget], $expected_value, format_string('Checkbox %widget returns expected value (expected: %expected, got: %value)', array(

   251         '%widget' => var_export($widget, TRUE),

   252         '%expected' => var_export($expected_value, TRUE),

   253         '%value' => var_export($values[$widget], TRUE),

   254       )));

   255     }

   256   }

   257 

   258   /**

   259    * Tests validation of #type 'select' elements.

   260    */

   261   function testSelect() {

   262     $form = $form_state = array();

   263     $form = form_test_select($form, $form_state);

   264     $error = '!name field is required.';

   265     $this->drupalGet('form-test/select');

   266 

   267     // Posting without any values should throw validation errors.

   268     $this->drupalPost(NULL, array(), 'Submit');

   269     $this->assertNoText(t($error, array('!name' => $form['select']['#title'])));

   270     $this->assertNoText(t($error, array('!name' => $form['select_required']['#title'])));

   271     $this->assertNoText(t($error, array('!name' => $form['select_optional']['#title'])));

   272     $this->assertNoText(t($error, array('!name' => $form['empty_value']['#title'])));

   273     $this->assertNoText(t($error, array('!name' => $form['empty_value_one']['#title'])));

   274     $this->assertText(t($error, array('!name' => $form['no_default']['#title'])));

   275     $this->assertNoText(t($error, array('!name' => $form['no_default_optional']['#title'])));

   276     $this->assertText(t($error, array('!name' => $form['no_default_empty_option']['#title'])));

   277     $this->assertNoText(t($error, array('!name' => $form['no_default_empty_option_optional']['#title'])));

   278     $this->assertText(t($error, array('!name' => $form['no_default_empty_value']['#title'])));

   279     $this->assertText(t($error, array('!name' => $form['no_default_empty_value_one']['#title'])));

   280     $this->assertNoText(t($error, array('!name' => $form['no_default_empty_value_optional']['#title'])));

   281     $this->assertNoText(t($error, array('!name' => $form['multiple']['#title'])));

   282     $this->assertNoText(t($error, array('!name' => $form['multiple_no_default']['#title'])));

   283     $this->assertText(t($error, array('!name' => $form['multiple_no_default_required']['#title'])));

   284 

   285     // Post values for required fields.

   286     $edit = array(

   287       'no_default' => 'three',

   288       'no_default_empty_option' => 'three',

   289       'no_default_empty_value' => 'three',

   290       'no_default_empty_value_one' => 'three',

   291       'multiple_no_default_required[]' => 'three',

   292     );

   293     $this->drupalPost(NULL, $edit, 'Submit');

   294     $values = drupal_json_decode($this->drupalGetContent());

   295 

   296     // Verify expected values.

   297     $expected = array(

   298       'select' => 'one',

   299       'empty_value' => 'one',

   300       'empty_value_one' => 'one',

   301       'no_default' => 'three',

   302       'no_default_optional' => 'one',

   303       'no_default_optional_empty_value' => '',

   304       'no_default_empty_option' => 'three',

   305       'no_default_empty_option_optional' => '',

   306       'no_default_empty_value' => 'three',

   307       'no_default_empty_value_one' => 'three',

   308       'no_default_empty_value_optional' => 0,

   309       'multiple' => array('two' => 'two'),

   310       'multiple_no_default' => array(),

   311       'multiple_no_default_required' => array('three' => 'three'),

   312     );

   313     foreach ($expected as $key => $value) {

   314       $this->assertIdentical($values[$key], $value, format_string('@name: @actual is equal to @expected.', array(

   315         '@name' => $key,

   316         '@actual' => var_export($values[$key], TRUE),

   317         '@expected' => var_export($value, TRUE),

   318       )));

   319     }

   320   }

   321 

   322   /**

   323    * Test handling of disabled elements.

   324    *

   325    * @see _form_test_disabled_elements()

   326    */

   327   function testDisabledElements() {

   328     // Get the raw form in its original state.

   329     $form_state = array();

   330     $form = _form_test_disabled_elements(array(), $form_state);

   331 

   332     // Build a submission that tries to hijack the form by submitting input for

   333     // elements that are disabled.

   334     $edit = array();

   335     foreach (element_children($form) as $key) {

   336       if (isset($form[$key]['#test_hijack_value'])) {

   337         if (is_array($form[$key]['#test_hijack_value'])) {

   338           foreach ($form[$key]['#test_hijack_value'] as $subkey => $value) {

   339             $edit[$key . '[' . $subkey . ']'] = $value;

   340           }

   341         }

   342         else {

   343           $edit[$key] = $form[$key]['#test_hijack_value'];

   344         }

   345       }

   346     }

   347 

   348     // Submit the form with no input, as the browser does for disabled elements,

   349     // and fetch the $form_state['values'] that is passed to the submit handler.

   350     $this->drupalPost('form-test/disabled-elements', array(), t('Submit'));

   351     $returned_values['normal'] = drupal_json_decode($this->content);

   352 

   353     // Do the same with input, as could happen if JavaScript un-disables an

   354     // element. drupalPost() emulates a browser by not submitting input for

   355     // disabled elements, so we need to un-disable those elements first.

   356     $this->drupalGet('form-test/disabled-elements');

   357     $disabled_elements = array();

   358     foreach ($this->xpath('//*[@disabled]') as $element) {

   359       $disabled_elements[] = (string) $element['name'];

   360       unset($element['disabled']);

   361     }

   362 

   363     // All the elements should be marked as disabled, including the ones below

   364     // the disabled container.

   365     $this->assertEqual(count($disabled_elements), 32, 'The correct elements have the disabled property in the HTML code.');

   366 

   367     $this->drupalPost(NULL, $edit, t('Submit'));

   368     $returned_values['hijacked'] = drupal_json_decode($this->content);

   369 

   370     // Ensure that the returned values match the form's default values in both

   371     // cases.

   372     foreach ($returned_values as $type => $values) {

   373       $this->assertFormValuesDefault($values, $form);

   374     }

   375   }

   376 

   377   /**

   378    * Assert that the values submitted to a form matches the default values of the elements.

   379    */

   380   function assertFormValuesDefault($values, $form) {

   381     foreach (element_children($form) as $key) {

   382       if (isset($form[$key]['#default_value'])) {

   383         if (isset($form[$key]['#expected_value'])) {

   384           $expected_value = $form[$key]['#expected_value'];

   385         }

   386         else {

   387           $expected_value = $form[$key]['#default_value'];

   388         }

   389 

   390         if ($key == 'checkboxes_multiple') {

   391           // Checkboxes values are not filtered out.

   392           $values[$key] = array_filter($values[$key]);

   393         }

   394         $this->assertIdentical($expected_value, $values[$key], format_string('Default value for %type: expected %expected, returned %returned.', array('%type' => $key, '%expected' => var_export($expected_value, TRUE), '%returned' => var_export($values[$key], TRUE))));

   395       }

   396 

   397       // Recurse children.

   398       $this->assertFormValuesDefault($values, $form[$key]);

   399     }

   400   }

   401 

   402   /**

   403    * Verify markup for disabled form elements.

   404    *

   405    * @see _form_test_disabled_elements()

   406    */

   407   function testDisabledMarkup() {

   408     $this->drupalGet('form-test/disabled-elements');

   409     $form_state = array();

   410     $form = _form_test_disabled_elements(array(), $form_state);

   411     $type_map = array(

   412       'textarea' => 'textarea',

   413       'select' => 'select',

   414       'weight' => 'select',

   415       'date' => 'select',

   416     );

   417 

   418     foreach ($form as $name => $item) {

   419       // Skip special #types.

   420       if (!isset($item['#type']) || in_array($item['#type'], array('hidden', 'text_format'))) {

   421         continue;

   422       }

   423       // Setup XPath and CSS class depending on #type.

   424       if (in_array($item['#type'], array('image_button', 'button', 'submit'))) {

   425         $path = "//!type[contains(@class, :div-class) and @value=:value]";

   426         $class = 'form-button-disabled';

   427       }

   428       else {

   429         // starts-with() required for checkboxes.

   430         $path = "//div[contains(@class, :div-class)]/descendant::!type[starts-with(@name, :name)]";

   431         $class = 'form-disabled';

   432       }

   433       // Replace DOM element name in $path according to #type.

   434       $type = 'input';

   435       if (isset($type_map[$item['#type']])) {

   436         $type = $type_map[$item['#type']];

   437       }

   438       $path = strtr($path, array('!type' => $type));

   439       // Verify that the element exists.

   440       $element = $this->xpath($path, array(

   441         ':name' => check_plain($name),

   442         ':div-class' => $class,

   443         ':value' => isset($item['#value']) ? $item['#value'] : '',

   444       ));

   445       $this->assertTrue(isset($element[0]), format_string('Disabled form element class found for #type %type.', array('%type' => $item['#type'])));

   446     }

   447 

   448     // Verify special element #type text-format.

   449     $element = $this->xpath('//div[contains(@class, :div-class)]/descendant::textarea[@name=:name]', array(

   450       ':name' => 'text_format[value]',

   451       ':div-class' => 'form-disabled',

   452     ));

   453     $this->assertTrue(isset($element[0]), format_string('Disabled form element class found for #type %type.', array('%type' => 'text_format[value]')));

   454     $element = $this->xpath('//div[contains(@class, :div-class)]/descendant::select[@name=:name]', array(

   455       ':name' => 'text_format[format]',

   456       ':div-class' => 'form-disabled',

   457     ));

   458     $this->assertTrue(isset($element[0]), format_string('Disabled form element class found for #type %type.', array('%type' => 'text_format[format]')));

   459   }

   460 

   461   /**

   462    * Test Form API protections against input forgery.

   463    *

   464    * @see _form_test_input_forgery()

   465    */

   466   function testInputForgery() {

   467     $this->drupalGet('form-test/input-forgery');

   468     $checkbox = $this->xpath('//input[@name="checkboxes[two]"]');

   469     $checkbox[0]['value'] = 'FORGERY';

   470     $this->drupalPost(NULL, array('checkboxes[one]' => TRUE, 'checkboxes[two]' => TRUE), t('Submit'));

   471     $this->assertText('An illegal choice has been detected.', 'Input forgery was detected.');

   472   }

   473 

   474   /**

   475    * Tests that submitted values are converted to scalar strings for textfields.

   476    */

   477   public function testTextfieldStringValue() {

   478     // Check multivalued submissions.

   479     $multivalue = array('evil' => 'multivalue', 'not so' => 'good');

   480     $this->checkFormValue('textfield', $multivalue, '');

   481     $this->checkFormValue('password', $multivalue, '');

   482     $this->checkFormValue('textarea', $multivalue, '');

   483     $this->checkFormValue('machine_name', $multivalue, '');

   484     $this->checkFormValue('password_confirm', $multivalue, array('pass1' => '', 'pass2' => ''));

   485     // Check integer submissions.

   486     $integer = 5;

   487     $string = '5';

   488     $this->checkFormValue('textfield', $integer, $string);

   489     $this->checkFormValue('password', $integer, $string);

   490     $this->checkFormValue('textarea', $integer, $string);

   491     $this->checkFormValue('machine_name', $integer, $string);

   492     $this->checkFormValue('password_confirm', array('pass1' => $integer, 'pass2' => $integer), array('pass1' => $string, 'pass2' => $string));

   493     // Check that invalid array keys are ignored for password confirm elements.

   494     $this->checkFormValue('password_confirm', array('pass1' => 'test', 'pass2' => 'test', 'extra' => 'invalid'), array('pass1' => 'test', 'pass2' => 'test'));

   495   }

   496 

   497   /**

   498    * Checks that a given form input value is sanitized to the expected result.

   499    *

   500    * @param string $element_type

   501    *   The form element type. Example: textfield.

   502    * @param mixed $input_value

   503    *   The submitted user input value for the form element.

   504    * @param mixed $expected_value

   505    *   The sanitized result value in the form state after calling

   506    *   form_builder().

   507    */

   508   protected function checkFormValue($element_type, $input_value, $expected_value) {

   509     $form_id = $this->randomName();

   510     $form = array();

   511     $form_state = form_state_defaults();

   512     $form['op'] = array('#type' => 'submit', '#value' => t('Submit'));

   513     $form[$element_type] = array(

   514       '#type' => $element_type,

   515       '#title' => 'test',

   516     );

   517 

   518     $form_state['input'][$element_type] = $input_value;

   519     $form_state['input']['form_id'] = $form_id;

   520     $form_state['method'] = 'post';

   521     $form_state['values'] = array();

   522     drupal_prepare_form($form_id, $form, $form_state);

   523 

   524     // This is the main function we want to test: it is responsible for

   525     // populating user supplied $form_state['input'] to sanitized

   526     // $form_state['values'].

   527     form_builder($form_id, $form, $form_state);

   528 

   529     $this->assertIdentical($form_state['values'][$element_type], $expected_value, format_string('Form submission for the "@element_type" element type has been correctly sanitized.', array('@element_type' => $element_type)));

   530   }

   531 }

   532 

   533 /**

   534  * Tests building and processing of core form elements.

   535  */

   536 class FormElementTestCase extends DrupalWebTestCase {

   537   protected $profile = 'testing';

   538 

   539   public static function getInfo() {

   540     return array(

   541       'name' => 'Element processing',

   542       'description' => 'Tests building and processing of core form elements.',

   543       'group' => 'Form API',

   544     );

   545   }

   546 

   547   function setUp() {

   548     parent::setUp(array('form_test'));

   549   }

   550 

   551   /**

   552    * Tests expansion of #options for #type checkboxes and radios.

   553    */

   554   function testOptions() {

   555     $this->drupalGet('form-test/checkboxes-radios');

   556 

   557     // Verify that all options appear in their defined order.

   558     foreach (array('checkbox', 'radio') as $type) {

   559       $elements = $this->xpath('//input[@type=:type]', array(':type' => $type));

   560       $expected_values = array('0', 'foo', '1', 'bar', '>');

   561       foreach ($elements as $element) {

   562         $expected = array_shift($expected_values);

   563         $this->assertIdentical((string) $element['value'], $expected);

   564       }

   565     }

   566 

   567     // Enable customized option sub-elements.

   568     $this->drupalGet('form-test/checkboxes-radios/customize');

   569 

   570     // Verify that all options appear in their defined order, taking a custom

   571     // #weight into account.

   572     foreach (array('checkbox', 'radio') as $type) {

   573       $elements = $this->xpath('//input[@type=:type]', array(':type' => $type));

   574       $expected_values = array('0', 'foo', 'bar', '>', '1');

   575       foreach ($elements as $element) {

   576         $expected = array_shift($expected_values);

   577         $this->assertIdentical((string) $element['value'], $expected);

   578       }

   579     }

   580     // Verify that custom #description properties are output.

   581     foreach (array('checkboxes', 'radios') as $type) {

   582       $elements = $this->xpath('//input[@id=:id]/following-sibling::div[@class=:class]', array(

   583         ':id' => 'edit-' . $type . '-foo',

   584         ':class' => 'description',

   585       ));

   586       $this->assertTrue(count($elements), format_string('Custom %type option description found.', array(

   587         '%type' => $type,

   588       )));

   589     }

   590   }

   591 }

   592 

   593 /**

   594  * Test form alter hooks.

   595  */

   596 class FormAlterTestCase extends DrupalWebTestCase {

   597   public static function getInfo() {

   598     return array(

   599       'name' => 'Form alter hooks',

   600       'description' => 'Tests hook_form_alter() and hook_form_FORM_ID_alter().',

   601       'group' => 'Form API',

   602     );

   603   }

   604 

   605   function setUp() {

   606     parent::setUp('form_test');

   607   }

   608 

   609   /**

   610    * Tests execution order of hook_form_alter() and hook_form_FORM_ID_alter().

   611    */

   612   function testExecutionOrder() {

   613     $this->drupalGet('form-test/alter');

   614     // Ensure that the order is first by module, then for a given module, the

   615     // id-specific one after the generic one.

   616     $expected = array(

   617       'block_form_form_test_alter_form_alter() executed.',

   618       'form_test_form_alter() executed.',

   619       'form_test_form_form_test_alter_form_alter() executed.',

   620       'system_form_form_test_alter_form_alter() executed.',

   621     );

   622     $content = preg_replace('/\s+/', ' ', filter_xss($this->content, array()));

   623     $this->assert(strpos($content, implode(' ', $expected)) !== FALSE, 'Form alter hooks executed in the expected order.');

   624   }

   625 }

   626 

   627 /**

   628  * Test form validation handlers.

   629  */

   630 class FormValidationTestCase extends DrupalWebTestCase {

   631   public static function getInfo() {

   632     return array(

   633       'name' => 'Form validation handlers',

   634       'description' => 'Tests form processing and alteration via form validation handlers.',

   635       'group' => 'Form API',

   636     );

   637   }

   638 

   639   function setUp() {

   640     parent::setUp('form_test');

   641   }

   642 

   643   /**

   644    * Tests form alterations by #element_validate, #validate, and form_set_value().

   645    */

   646   function testValidate() {

   647     $this->drupalGet('form-test/validate');

   648     // Verify that #element_validate handlers can alter the form and submitted

   649     // form values.

   650     $edit = array(

   651       'name' => 'element_validate',

   652     );

   653     $this->drupalPost(NULL, $edit, 'Save');

   654     $this->assertFieldByName('name', '#value changed by #element_validate', 'Form element #value was altered.');

   655     $this->assertText('Name value: value changed by form_set_value() in #element_validate', 'Form element value in $form_state was altered.');

   656 

   657     // Verify that #validate handlers can alter the form and submitted

   658     // form values.

   659     $edit = array(

   660       'name' => 'validate',

   661     );

   662     $this->drupalPost(NULL, $edit, 'Save');

   663     $this->assertFieldByName('name', '#value changed by #validate', 'Form element #value was altered.');

   664     $this->assertText('Name value: value changed by form_set_value() in #validate', 'Form element value in $form_state was altered.');

   665 

   666     // Verify that #element_validate handlers can make form elements

   667     // inaccessible, but values persist.

   668     $edit = array(

   669       'name' => 'element_validate_access',

   670     );

   671     $this->drupalPost(NULL, $edit, 'Save');

   672     $this->assertNoFieldByName('name', 'Form element was hidden.');

   673     $this->assertText('Name value: element_validate_access', 'Value for inaccessible form element exists.');

   674 

   675     // Verify that value for inaccessible form element persists.

   676     $this->drupalPost(NULL, array(), 'Save');

   677     $this->assertNoFieldByName('name', 'Form element was hidden.');

   678     $this->assertText('Name value: element_validate_access', 'Value for inaccessible form element exists.');

   679 

   680     // Verify that #validate handlers don't run if the CSRF token is invalid.

   681     $this->drupalLogin($this->drupalCreateUser());

   682     $this->drupalGet('form-test/validate');

   683     $edit = array(

   684       'name' => 'validate',

   685       'form_token' => 'invalid token'

   686     );

   687     $this->drupalPost(NULL, $edit, 'Save');

   688     $this->assertNoFieldByName('name', '#value changed by #validate', 'Form element #value was not altered.');

   689     $this->assertNoText('Name value: value changed by form_set_value() in #validate', 'Form element value in $form_state was not altered.');

   690     $this->assertText('The form has become outdated. Copy any unsaved work in the form below');

   691   }

   692 

   693   /**

   694    * Tests that a form with a disabled CSRF token can be validated.

   695    */

   696   function testDisabledToken() {

   697     $this->drupalPost('form-test/validate-no-token', array(), 'Save');

   698     $this->assertText('The form_test_validate_no_token form has been submitted successfully.');

   699   }

   700 

   701   /**

   702    * Tests partial form validation through #limit_validation_errors.

   703    */

   704   function testValidateLimitErrors() {

   705     $edit = array(

   706       'test' => 'invalid',

   707       'test_numeric_index[0]' => 'invalid',

   708       'test_substring[foo]' => 'invalid',

   709     );

   710     $path = 'form-test/limit-validation-errors';

   711 

   712     // Submit the form by pressing the 'Partial validate' button (uses

   713     // #limit_validation_errors) and ensure that the title field is not

   714     // validated, but the #element_validate handler for the 'test' field

   715     // is triggered.

   716     $this->drupalPost($path, $edit, t('Partial validate'));

   717     $this->assertNoText(t('!name field is required.', array('!name' => 'Title')));

   718     $this->assertText('Test element is invalid');

   719 

   720     // Edge case of #limit_validation_errors containing numeric indexes: same

   721     // thing with the 'Partial validate (numeric index)' button and the

   722     // 'test_numeric_index' field.

   723     $this->drupalPost($path, $edit, t('Partial validate (numeric index)'));

   724     $this->assertNoText(t('!name field is required.', array('!name' => 'Title')));

   725     $this->assertText('Test (numeric index) element is invalid');

   726 

   727     // Ensure something like 'foobar' isn't considered "inside" 'foo'.

   728     $this->drupalPost($path, $edit, t('Partial validate (substring)'));

   729     $this->assertNoText(t('!name field is required.', array('!name' => 'Title')));

   730     $this->assertText('Test (substring) foo element is invalid');

   731 

   732     // Ensure not validated values are not available to submit handlers.

   733     $this->drupalPost($path, array('title' => '', 'test' => 'valid'), t('Partial validate'));

   734     $this->assertText('Only validated values appear in the form values.');

   735 

   736     // Now test full form validation and ensure that the #element_validate

   737     // handler is still triggered.

   738     $this->drupalPost($path, $edit, t('Full validate'));

   739     $this->assertText(t('!name field is required.', array('!name' => 'Title')));

   740     $this->assertText('Test element is invalid');

   741   }

   742 

   743   /**

   744    *  Tests error border of multiple fields with same name in a page.

   745    */

   746   function testMultiFormSameNameErrorClass() {

   747     $this->drupalGet('form-test/double-form');

   748     $edit = array();

   749     $this->drupalPost(NULL, $edit, t('Save'));

   750     $this->assertFieldByXpath('//input[@id="edit-name" and contains(@class, "error")]', NULL, 'Error input form element class found for first element.');

   751     $this->assertNoFieldByXpath('//input[@id="edit-name--2" and contains(@class, "error")]', NULL, 'No error input form element class found for second element.');

   752   }

   753 }

   754 

   755 /**

   756  * Test form element labels, required markers and associated output.

   757  */

   758 class FormsElementsLabelsTestCase extends DrupalWebTestCase {

   759 

   760   public static function getInfo() {

   761     return array(

   762       'name' => 'Form element and label output test',

   763       'description' => 'Test form element labels, required markers and associated output.',

   764       'group' => 'Form API',

   765     );

   766   }

   767 

   768   function setUp() {

   769     parent::setUp('form_test');

   770   }

   771 

   772   /**

   773    * Test form elements, labels, title attibutes and required marks output

   774    * correctly and have the correct label option class if needed.

   775    */

   776   function testFormLabels() {

   777     $this->drupalGet('form_test/form-labels');

   778 

   779     // Check that the checkbox/radio processing is not interfering with

   780     // basic placement.

   781     $elements = $this->xpath('//input[@id="edit-form-checkboxes-test-third-checkbox"]/following-sibling::label[@for="edit-form-checkboxes-test-third-checkbox" and @class="option"]');

   782     $this->assertTrue(isset($elements[0]), "Label follows field and label option class correct for regular checkboxes.");

   783 

   784     // Make sure the label is rendered for checkboxes.

   785     $elements = $this->xpath('//input[@id="edit-form-checkboxes-test-0"]/following-sibling::label[@for="edit-form-checkboxes-test-0" and @class="option"]');

   786     $this->assertTrue(isset($elements[0]), "Label 0 found checkbox.");

   787 

   788     $elements = $this->xpath('//input[@id="edit-form-radios-test-second-radio"]/following-sibling::label[@for="edit-form-radios-test-second-radio" and @class="option"]');

   789     $this->assertTrue(isset($elements[0]), "Label follows field and label option class correct for regular radios.");

   790 

   791     // Make sure the label is rendered for radios.

   792     $elements = $this->xpath('//input[@id="edit-form-radios-test-0"]/following-sibling::label[@for="edit-form-radios-test-0" and @class="option"]');

   793     $this->assertTrue(isset($elements[0]), "Label 0 found radios.");

   794 

   795     // Exercise various defaults for checkboxes and modifications to ensure

   796     // appropriate override and correct behavior.

   797     $elements = $this->xpath('//input[@id="edit-form-checkbox-test"]/following-sibling::label[@for="edit-form-checkbox-test" and @class="option"]');

   798     $this->assertTrue(isset($elements[0]), "Label follows field and label option class correct for a checkbox by default.");

   799 

   800     // Exercise various defaults for textboxes and modifications to ensure

   801     // appropriate override and correct behavior.

   802     $elements = $this->xpath('//label[@for="edit-form-textfield-test-title-and-required"]/child::span[@class="form-required"]/parent::*/following-sibling::input[@id="edit-form-textfield-test-title-and-required"]');

   803     $this->assertTrue(isset($elements[0]), "Label precedes textfield, with required marker inside label.");

   804 

   805     $elements = $this->xpath('//input[@id="edit-form-textfield-test-no-title-required"]/preceding-sibling::label[@for="edit-form-textfield-test-no-title-required"]/span[@class="form-required"]');

   806     $this->assertTrue(isset($elements[0]), "Label tag with required marker precedes required textfield with no title.");

   807 

   808     $elements = $this->xpath('//input[@id="edit-form-textfield-test-title-invisible"]/preceding-sibling::label[@for="edit-form-textfield-test-title-invisible" and @class="element-invisible"]');

   809     $this->assertTrue(isset($elements[0]), "Label preceding field and label class is element-invisible.");

   810 

   811     $elements = $this->xpath('//input[@id="edit-form-textfield-test-title"]/preceding-sibling::span[@class="form-required"]');

   812     $this->assertFalse(isset($elements[0]), "No required marker on non-required field.");

   813 

   814     $elements = $this->xpath('//input[@id="edit-form-textfield-test-title-after"]/following-sibling::label[@for="edit-form-textfield-test-title-after" and @class="option"]');

   815     $this->assertTrue(isset($elements[0]), "Label after field and label option class correct for text field.");

   816 

   817     $elements = $this->xpath('//label[@for="edit-form-textfield-test-title-no-show"]');

   818     $this->assertFalse(isset($elements[0]), "No label tag when title set not to display.");

   819 

   820     // Check #field_prefix and #field_suffix placement.

   821     $elements = $this->xpath('//span[@class="field-prefix"]/following-sibling::div[@id="edit-form-radios-test"]');

   822     $this->assertTrue(isset($elements[0]), "Properly placed the #field_prefix element after the label and before the field.");

   823 

   824     $elements = $this->xpath('//span[@class="field-suffix"]/preceding-sibling::div[@id="edit-form-radios-test"]');

   825     $this->assertTrue(isset($elements[0]), "Properly places the #field_suffix element immediately after the form field.");

   826 

   827     // Check #prefix and #suffix placement.

   828     $elements = $this->xpath('//div[@id="form-test-textfield-title-prefix"]/following-sibling::div[contains(@class, \'form-item-form-textfield-test-title\')]');

   829     $this->assertTrue(isset($elements[0]), "Properly places the #prefix element before the form item.");

   830 

   831     $elements = $this->xpath('//div[@id="form-test-textfield-title-suffix"]/preceding-sibling::div[contains(@class, \'form-item-form-textfield-test-title\')]');

   832     $this->assertTrue(isset($elements[0]), "Properly places the #suffix element before the form item.");

   833 

   834     // Check title attribute for radios and checkboxes.

   835     $elements = $this->xpath('//div[@id="edit-form-checkboxes-title-attribute"]');

   836     $this->assertEqual($elements[0]['title'], 'Checkboxes test' . ' (' . t('Required') . ')', 'Title attribute found.');

   837     $elements = $this->xpath('//div[@id="edit-form-radios-title-attribute"]');

   838     $this->assertEqual($elements[0]['title'], 'Radios test' . ' (' . t('Required') . ')', 'Title attribute found.');

   839   }

   840 }

   841 

   842 /**

   843  * Test the tableselect form element for expected behavior.

   844  */

   845 class FormsElementsTableSelectFunctionalTest extends DrupalWebTestCase {

   846 

   847   public static function getInfo() {

   848     return array(

   849       'name' => 'Tableselect form element type test',

   850       'description' => 'Test the tableselect element for expected behavior',

   851       'group' => 'Form API',

   852     );

   853   }

   854 

   855   function setUp() {

   856     parent::setUp('form_test');

   857   }

   858 

   859 

   860   /**

   861    * Test the display of checkboxes when #multiple is TRUE.

   862    */

   863   function testMultipleTrue() {

   864 

   865     $this->drupalGet('form_test/tableselect/multiple-true');

   866 

   867     $this->assertNoText(t('Empty text.'), 'Empty text should not be displayed.');

   868 

   869     // Test for the presence of the Select all rows tableheader.

   870     $this->assertFieldByXPath('//th[@class="select-all"]', NULL, 'Presence of the "Select all" checkbox.');

   871 

   872     $rows = array('row1', 'row2', 'row3');

   873     foreach ($rows as $row) {

   874       $this->assertFieldByXPath('//input[@type="checkbox"]', $row, format_string('Checkbox for value @row.', array('@row' => $row)));

   875     }

   876   }

   877 

   878   /**

   879    * Test the display of radios when #multiple is FALSE.

   880    */

   881   function testMultipleFalse() {

   882     $this->drupalGet('form_test/tableselect/multiple-false');

   883 

   884     $this->assertNoText(t('Empty text.'), 'Empty text should not be displayed.');

   885 

   886     // Test for the absence of the Select all rows tableheader.

   887     $this->assertNoFieldByXPath('//th[@class="select-all"]', '', 'Absence of the "Select all" checkbox.');

   888 

   889     $rows = array('row1', 'row2', 'row3');

   890     foreach ($rows as $row) {

   891       $this->assertFieldByXPath('//input[@type="radio"]', $row, format_string('Radio button for value @row.', array('@row' => $row)));

   892     }

   893   }

   894 

   895   /**

   896    * Test the display of the #empty text when #options is an empty array.

   897    */

   898   function testEmptyText() {

   899     $this->drupalGet('form_test/tableselect/empty-text');

   900     $this->assertText(t('Empty text.'), 'Empty text should be displayed.');

   901   }

   902 

   903   /**

   904    * Test the submission of single and multiple values when #multiple is TRUE.

   905    */

   906   function testMultipleTrueSubmit() {

   907 

   908     // Test a submission with one checkbox checked.

   909     $edit = array();

   910     $edit['tableselect[row1]'] = TRUE;

   911     $this->drupalPost('form_test/tableselect/multiple-true', $edit, 'Submit');

   912 

   913     $this->assertText(t('Submitted: row1 = row1'), 'Checked checkbox row1');

   914     $this->assertText(t('Submitted: row2 = 0'), 'Unchecked checkbox row2.');

   915     $this->assertText(t('Submitted: row3 = 0'), 'Unchecked checkbox row3.');

   916 

   917     // Test a submission with multiple checkboxes checked.

   918     $edit['tableselect[row1]'] = TRUE;

   919     $edit['tableselect[row3]'] = TRUE;

   920     $this->drupalPost('form_test/tableselect/multiple-true', $edit, 'Submit');

   921 

   922     $this->assertText(t('Submitted: row1 = row1'), 'Checked checkbox row1.');

   923     $this->assertText(t('Submitted: row2 = 0'), 'Unchecked checkbox row2.');

   924     $this->assertText(t('Submitted: row3 = row3'), 'Checked checkbox row3.');

   925 

   926   }

   927 

   928   /**

   929    * Test submission of values when #multiple is FALSE.

   930    */

   931   function testMultipleFalseSubmit() {

   932     $edit['tableselect'] = 'row1';

   933     $this->drupalPost('form_test/tableselect/multiple-false', $edit, 'Submit');

   934     $this->assertText(t('Submitted: row1'), 'Selected radio button');

   935   }

   936 

   937   /**

   938    * Test the #js_select property.

   939    */

   940   function testAdvancedSelect() {

   941     // When #multiple = TRUE a Select all checkbox should be displayed by default.

   942     $this->drupalGet('form_test/tableselect/advanced-select/multiple-true-default');

   943     $this->assertFieldByXPath('//th[@class="select-all"]', NULL, 'Display a "Select all" checkbox by default when #multiple is TRUE.');

   944 

   945     // When #js_select is set to FALSE, a "Select all" checkbox should not be displayed.

   946     $this->drupalGet('form_test/tableselect/advanced-select/multiple-true-no-advanced-select');

   947     $this->assertNoFieldByXPath('//th[@class="select-all"]', NULL, 'Do not display a "Select all" checkbox when #js_select is FALSE.');

   948 

   949     // A "Select all" checkbox never makes sense when #multiple = FALSE, regardless of the value of #js_select.

   950     $this->drupalGet('form_test/tableselect/advanced-select/multiple-false-default');

   951     $this->assertNoFieldByXPath('//th[@class="select-all"]', NULL, 'Do not display a "Select all" checkbox when #multiple is FALSE.');

   952 

   953     $this->drupalGet('form_test/tableselect/advanced-select/multiple-false-advanced-select');

   954     $this->assertNoFieldByXPath('//th[@class="select-all"]', NULL, 'Do not display a "Select all" checkbox when #multiple is FALSE, even when #js_select is TRUE.');

   955   }

   956 

   957 

   958   /**

   959    * Test the whether the option checker gives an error on invalid tableselect values for checkboxes.

   960    */

   961   function testMultipleTrueOptionchecker() {

   962 

   963     list($header, $options) = _form_test_tableselect_get_data();

   964 

   965     $form['tableselect'] = array(

   966       '#type' => 'tableselect',

   967       '#header' => $header,

   968       '#options' => $options,

   969     );

   970 

   971     // Test with a valid value.

   972     list($processed_form, $form_state, $errors) = $this->formSubmitHelper($form, array('tableselect' => array('row1' => 'row1')));

   973     $this->assertFalse(isset($errors['tableselect']), 'Option checker allows valid values for checkboxes.');

   974 

   975     // Test with an invalid value.

   976     list($processed_form, $form_state, $errors) = $this->formSubmitHelper($form, array('tableselect' => array('non_existing_value' => 'non_existing_value')));

   977     $this->assertTrue(isset($errors['tableselect']), 'Option checker disallows invalid values for checkboxes.');

   978 

   979   }

   980 

   981 

   982   /**

   983    * Test the whether the option checker gives an error on invalid tableselect values for radios.

   984    */

   985   function testMultipleFalseOptionchecker() {

   986 

   987     list($header, $options) = _form_test_tableselect_get_data();

   988 

   989     $form['tableselect'] = array(

   990       '#type' => 'tableselect',

   991       '#header' => $header,

   992       '#options' => $options,

   993       '#multiple' => FALSE,

   994     );

   995 

   996     // Test with a valid value.

   997     list($processed_form, $form_state, $errors) = $this->formSubmitHelper($form, array('tableselect' => 'row1'));

   998     $this->assertFalse(isset($errors['tableselect']), 'Option checker allows valid values for radio buttons.');

   999 

  1000     // Test with an invalid value.

  1001     list($processed_form, $form_state, $errors) = $this->formSubmitHelper($form, array('tableselect' => 'non_existing_value'));

  1002     $this->assertTrue(isset($errors['tableselect']), 'Option checker disallows invalid values for radio buttons.');

  1003   }

  1004 

  1005   /**

  1006    * Test presence of ajax functionality

  1007    */

  1008   function testAjax() {

  1009     $rows = array('row1', 'row2', 'row3');

  1010     // Test checkboxes (#multiple == TRUE).

  1011     foreach ($rows as $row) {

  1012       $element = 'tableselect[' . $row . ']';

  1013       $edit = array($element => TRUE);

  1014       $result = $this->drupalPostAJAX('form_test/tableselect/multiple-true', $edit, $element);

  1015       $this->assertFalse(empty($result), t('Ajax triggers on checkbox for @row.', array('@row' => $row)));

  1016     }

  1017     // Test radios (#multiple == FALSE).

  1018     $element = 'tableselect';

  1019     foreach ($rows as $row) {

  1020       $edit = array($element => $row);

  1021       $result = $this->drupalPostAjax('form_test/tableselect/multiple-false', $edit, $element);

  1022       $this->assertFalse(empty($result), t('Ajax triggers on radio for @row.', array('@row' => $row)));

  1023     }

  1024   }

  1025 

  1026   /**

  1027    * Helper function for the option check test to submit a form while collecting errors.

  1028    *

  1029    * @param $form_element

  1030    *   A form element to test.

  1031    * @param $edit

  1032    *   An array containing post data.

  1033    *

  1034    * @return

  1035    *   An array containing the processed form, the form_state and any errors.

  1036    */

  1037   private function formSubmitHelper($form, $edit) {

  1038     $form_id = $this->randomName();

  1039     $form_state = form_state_defaults();

  1040 

  1041     $form['op'] = array('#type' => 'submit', '#value' => t('Submit'));

  1042 

  1043     $form_state['input'] = $edit;

  1044     $form_state['input']['form_id'] = $form_id;

  1045 

  1046     // The form token CSRF protection should not interfere with this test,

  1047     // so we bypass it by marking this test form as programmed.

  1048     $form_state['programmed'] = TRUE;

  1049 

  1050     drupal_prepare_form($form_id, $form, $form_state);

  1051 

  1052     drupal_process_form($form_id, $form, $form_state);

  1053 

  1054     $errors = form_get_errors();

  1055 

  1056     // Clear errors and messages.

  1057     drupal_get_messages();

  1058     form_clear_error();

  1059 

  1060     // Return the processed form together with form_state and errors

  1061     // to allow the caller lowlevel access to the form.

  1062     return array($form, $form_state, $errors);

  1063   }

  1064 

  1065 }

  1066 

  1067 /**

  1068  * Test the vertical_tabs form element for expected behavior.

  1069  */

  1070 class FormsElementsVerticalTabsFunctionalTest extends DrupalWebTestCase {

  1071 

  1072   public static function getInfo() {

  1073     return array(

  1074       'name' => 'Vertical tabs form element type test',

  1075       'description' => 'Test the vertical_tabs element for expected behavior',

  1076       'group' => 'Form API',

  1077     );

  1078   }

  1079 

  1080   function setUp() {

  1081     parent::setUp('form_test');

  1082   }

  1083 

  1084   /**

  1085    * Ensures that vertical-tabs.js is included before collapse.js.

  1086    *

  1087    * Otherwise, collapse.js adds "SHOW" or "HIDE" labels to the tabs.

  1088    */

  1089   function testJavaScriptOrdering() {

  1090     $this->drupalGet('form_test/vertical-tabs');

  1091     $position1 = strpos($this->content, 'misc/vertical-tabs.js');

  1092     $position2 = strpos($this->content, 'misc/collapse.js');

  1093     $this->assertTrue($position1 !== FALSE && $position2 !== FALSE && $position1 < $position2, 'vertical-tabs.js is included before collapse.js');

  1094   }

  1095 }

  1096 

  1097 /**

  1098  * Test the form storage on a multistep form.

  1099  *

  1100  * The tested form puts data into the storage during the initial form

  1101  * construction. These tests verify that there are no duplicate form

  1102  * constructions, with and without manual form caching activiated. Furthermore

  1103  * when a validation error occurs, it makes sure that changed form element

  1104  * values aren't lost due to a wrong form rebuild.

  1105  */

  1106 class FormsFormStorageTestCase extends DrupalWebTestCase {

  1107 

  1108   public static function getInfo() {

  1109     return array(

  1110       'name'  => 'Multistep form using form storage',

  1111       'description'  => 'Tests a multistep form using form storage and makes sure validation and caching works right.',

  1112       'group' => 'Form API',

  1113     );

  1114   }

  1115 

  1116   function setUp() {

  1117     parent::setUp('form_test');

  1118 

  1119     $this->web_user = $this->drupalCreateUser(array('access content'));

  1120     $this->drupalLogin($this->web_user);

  1121   }

  1122 

  1123   /**

  1124    * Tests using the form in a usual way.

  1125    */

  1126   function testForm() {

  1127     $this->drupalGet('form_test/form-storage');

  1128     $this->assertText('Form constructions: 1');

  1129 

  1130     $edit = array('title' => 'new', 'value' => 'value_is_set');

  1131 

  1132     // Use form rebuilding triggered by a submit button.

  1133     $this->drupalPost(NULL, $edit, 'Continue submit');

  1134     $this->assertText('Form constructions: 2');

  1135     $this->assertText('Form constructions: 3');

  1136