Club Drupal

<?php

/**

 * @file

 * Tests for common.inc functionality.

 */

/**

 * Tests for URL generation functions.

 */

class DrupalAlterTestCase extends DrupalWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'drupal_alter() tests',

      'description' => 'Confirm that alteration of arguments passed to drupal_alter() works correctly.',

      'group' => 'System',

    );

  }

  function setUp() {

    parent::setUp('common_test');

  }

  function testDrupalAlter() {

    // This test depends on Bartik, so make sure that it is always the current

    // active theme.

    global $theme, $base_theme_info;

    $theme = 'bartik';

    $base_theme_info = array();

    $array = array('foo' => 'bar');

    $entity = new stdClass();

    $entity->foo = 'bar';

    // Verify alteration of a single argument.

    $array_copy = $array;

    $array_expected = array('foo' => 'Drupal theme');

    drupal_alter('drupal_alter', $array_copy);

    $this->assertEqual($array_copy, $array_expected, 'Single array was altered.');

    $entity_copy = clone $entity;

    $entity_expected = clone $entity;

    $entity_expected->foo = 'Drupal theme';

    drupal_alter('drupal_alter', $entity_copy);

    $this->assertEqual($entity_copy, $entity_expected, 'Single object was altered.');

    // Verify alteration of multiple arguments.

    $array_copy = $array;

    $array_expected = array('foo' => 'Drupal theme');

    $entity_copy = clone $entity;

    $entity_expected = clone $entity;

    $entity_expected->foo = 'Drupal theme';

    $array2_copy = $array;

    $array2_expected = array('foo' => 'Drupal theme');

    drupal_alter('drupal_alter', $array_copy, $entity_copy, $array2_copy);

    $this->assertEqual($array_copy, $array_expected, 'First argument to drupal_alter() was altered.');

    $this->assertEqual($entity_copy, $entity_expected, 'Second argument to drupal_alter() was altered.');

    $this->assertEqual($array2_copy, $array2_expected, 'Third argument to drupal_alter() was altered.');

    // Verify alteration order when passing an array of types to drupal_alter().

    // common_test_module_implements_alter() places 'block' implementation after

    // other modules.

    $array_copy = $array;

    $array_expected = array('foo' => 'Drupal block theme');

    drupal_alter(array('drupal_alter', 'drupal_alter_foo'), $array_copy);

    $this->assertEqual($array_copy, $array_expected, 'hook_TYPE_alter() implementations ran in correct order.');

  }

}

/**

 * Tests for URL generation functions.

 *

 * url() calls module_implements(), which may issue a db query, which requires

 * inheriting from a web test case rather than a unit test case.

 */

class CommonURLUnitTest extends DrupalWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'URL generation tests',

      'description' => 'Confirm that url(), drupal_get_query_parameters(), drupal_http_build_query(), and l() work correctly with various input.',

      'group' => 'System',

    );

  }

  /**

   * Confirm that invalid text given as $path is filtered.

   */

  function testLXSS() {

    $text = $this->randomName();

    $path = "<SCRIPT>alert('XSS')</SCRIPT>";

    $link = l($text, $path);

    $sanitized_path = check_url(url($path));

    $this->assertTrue(strpos($link, $sanitized_path) !== FALSE, format_string('XSS attack @path was filtered', array('@path' => $path)));

  }

  /*

   * Tests for active class in l() function.

   */

  function testLActiveClass() {

    $link = l($this->randomName(), $_GET['q']);

    $this->assertTrue($this->hasClass($link, 'active'), format_string('Class @class is present on link to the current page', array('@class' => 'active')));

  }

  /**

   * Tests for custom class in l() function.

   */

  function testLCustomClass() {

    $class = $this->randomName();

    $link = l($this->randomName(), $_GET['q'], array('attributes' => array('class' => array($class))));

    $this->assertTrue($this->hasClass($link, $class), format_string('Custom class @class is present on link when requested', array('@class' => $class)));

    $this->assertTrue($this->hasClass($link, 'active'), format_string('Class @class is present on link to the current page', array('@class' => 'active')));

  }

  private function hasClass($link, $class) {

    return preg_match('|class="([^\"\s]+\s+)*' . $class . '|', $link);

  }

  /**

   * Test drupal_get_query_parameters().

   */

  function testDrupalGetQueryParameters() {

    $original = array(

      'a' => 1,

      'b' => array(

        'd' => 4,

        'e' => array(

          'f' => 5,

        ),

      ),

      'c' => 3,

      'q' => 'foo/bar',

    );

    // Default arguments.

    $result = $_GET;

    unset($result['q']);

    $this->assertEqual(drupal_get_query_parameters(), $result, "\$_GET['q'] was removed.");

    // Default exclusion.

    $result = $original;

    unset($result['q']);

    $this->assertEqual(drupal_get_query_parameters($original), $result, "'q' was removed.");

    // First-level exclusion.

    $result = $original;

    unset($result['b']);

    $this->assertEqual(drupal_get_query_parameters($original, array('b')), $result, "'b' was removed.");

    // Second-level exclusion.

    $result = $original;

    unset($result['b']['d']);

    $this->assertEqual(drupal_get_query_parameters($original, array('b[d]')), $result, "'b[d]' was removed.");

    // Third-level exclusion.

    $result = $original;

    unset($result['b']['e']['f']);

    $this->assertEqual(drupal_get_query_parameters($original, array('b[e][f]')), $result, "'b[e][f]' was removed.");

    // Multiple exclusions.

    $result = $original;

    unset($result['a'], $result['b']['e'], $result['c']);

    $this->assertEqual(drupal_get_query_parameters($original, array('a', 'b[e]', 'c')), $result, "'a', 'b[e]', 'c' were removed.");

  }

  /**

   * Test drupal_http_build_query().

   */

  function testDrupalHttpBuildQuery() {

    $this->assertEqual(drupal_http_build_query(array('a' => ' &#//+%20@۞')), 'a=%20%26%23//%2B%2520%40%DB%9E', 'Value was properly encoded.');

    $this->assertEqual(drupal_http_build_query(array(' &#//+%20@۞' => 'a')), '%20%26%23%2F%2F%2B%2520%40%DB%9E=a', 'Key was properly encoded.');

    $this->assertEqual(drupal_http_build_query(array('a' => '1', 'b' => '2', 'c' => '3')), 'a=1&b=2&c=3', 'Multiple values were properly concatenated.');

    $this->assertEqual(drupal_http_build_query(array('a' => array('b' => '2', 'c' => '3'), 'd' => 'foo')), 'a[b]=2&a[c]=3&d=foo', 'Nested array was properly encoded.');

  }

  /**

   * Test drupal_parse_url().

   */

  function testDrupalParseUrl() {

    // Relative URL.

    $url = 'foo/bar?foo=bar&bar=baz&baz#foo';

    $result = array(

      'path' => 'foo/bar',

      'query' => array('foo' => 'bar', 'bar' => 'baz', 'baz' => ''),

      'fragment' => 'foo',

    );

    $this->assertEqual(drupal_parse_url($url), $result, 'Relative URL parsed correctly.');

    // Relative URL that is known to confuse parse_url().

    $url = 'foo/bar:1';

    $result = array(

      'path' => 'foo/bar:1',

      'query' => array(),

      'fragment' => '',

    );

    $this->assertEqual(drupal_parse_url($url), $result, 'Relative URL parsed correctly.');

    // Absolute URL.

    $url = '/foo/bar?foo=bar&bar=baz&baz#foo';

    $result = array(

      'path' => '/foo/bar',

      'query' => array('foo' => 'bar', 'bar' => 'baz', 'baz' => ''),

      'fragment' => 'foo',

    );

    $this->assertEqual(drupal_parse_url($url), $result, 'Absolute URL parsed correctly.');

    // External URL testing.

    $url = 'http://drupal.org/foo/bar?foo=bar&bar=baz&baz#foo';

    // Test that drupal can recognize an absolute URL. Used to prevent attack vectors.

    $this->assertTrue(url_is_external($url), 'Correctly identified an external URL.');

    // Test the parsing of absolute URLs.

    $result = array(

      'path' => 'http://drupal.org/foo/bar',

      'query' => array('foo' => 'bar', 'bar' => 'baz', 'baz' => ''),

      'fragment' => 'foo',

    );

    $this->assertEqual(drupal_parse_url($url), $result, 'External URL parsed correctly.');

    // Verify proper parsing of URLs when clean URLs are disabled.

    $result = array(

      'path' => 'foo/bar',

      'query' => array('bar' => 'baz'),

      'fragment' => 'foo',

    );

    // Non-clean URLs #1: Absolute URL generated by url().

    $url = $GLOBALS['base_url'] . '/?q=foo/bar&bar=baz#foo';

    $this->assertEqual(drupal_parse_url($url), $result, 'Absolute URL with clean URLs disabled parsed correctly.');

    // Non-clean URLs #2: Relative URL generated by url().

    $url = '?q=foo/bar&bar=baz#foo';

    $this->assertEqual(drupal_parse_url($url), $result, 'Relative URL with clean URLs disabled parsed correctly.');

    // Non-clean URLs #3: URL generated by url() on non-Apache webserver.

    $url = 'index.php?q=foo/bar&bar=baz#foo';

    $this->assertEqual(drupal_parse_url($url), $result, 'Relative URL on non-Apache webserver with clean URLs disabled parsed correctly.');

    // Test that drupal_parse_url() does not allow spoofing a URL to force a malicious redirect.

    $parts = drupal_parse_url('forged:http://cwe.mitre.org/data/definitions/601.html');

    $this->assertFalse(valid_url($parts['path'], TRUE), 'drupal_parse_url() correctly parsed a forged URL.');

  }

  /**

   * Test url() with/without query, with/without fragment, absolute on/off and

   * assert all that works when clean URLs are on and off.

   */

  function testUrl() {

    global $base_url;

    foreach (array(FALSE, TRUE) as $absolute) {

      // Get the expected start of the path string.

      $base = $absolute ? $base_url . '/' : base_path();

      $absolute_string = $absolute ? 'absolute' : NULL;

      // Disable Clean URLs.

      $GLOBALS['conf']['clean_url'] = 0;

      $url = $base . '?q=node/123';

      $result = url('node/123', array('absolute' => $absolute));

      $this->assertEqual($url, $result, "$url == $result");

      $url = $base . '?q=node/123#foo';

      $result = url('node/123', array('fragment' => 'foo', 'absolute' => $absolute));

      $this->assertEqual($url, $result, "$url == $result");

      $url = $base . '?q=node/123&foo';

      $result = url('node/123', array('query' => array('foo' => NULL), 'absolute' => $absolute));

      $this->assertEqual($url, $result, "$url == $result");

      $url = $base . '?q=node/123&foo=bar&bar=baz';

      $result = url('node/123', array('query' => array('foo' => 'bar', 'bar' => 'baz'), 'absolute' => $absolute));

      $this->assertEqual($url, $result, "$url == $result");

      $url = $base . '?q=node/123&foo#bar';

      $result = url('node/123', array('query' => array('foo' => NULL), 'fragment' => 'bar', 'absolute' => $absolute));

      $this->assertEqual($url, $result, "$url == $result");

      $url = $base . '?q=node/123&foo#0';

      $result = url('node/123', array('query' => array('foo' => NULL), 'fragment' => '0', 'absolute' => $absolute));

      $this->assertEqual($url, $result, "$url == $result");

      $url = $base . '?q=node/123&foo';

      $result = url('node/123', array('query' => array('foo' => NULL), 'fragment' => '', 'absolute' => $absolute));

      $this->assertEqual($url, $result, "$url == $result");

      $url = $base;

      $result = url('<front>', array('absolute' => $absolute));

      $this->assertEqual($url, $result, "$url == $result");

      // Enable Clean URLs.

      $GLOBALS['conf']['clean_url'] = 1;

      $url = $base . 'node/123';

      $result = url('node/123', array('absolute' => $absolute));

      $this->assertEqual($url, $result, "$url == $result");

      $url = $base . 'node/123#foo';

      $result = url('node/123', array('fragment' => 'foo', 'absolute' => $absolute));

      $this->assertEqual($url, $result, "$url == $result");

      $url = $base . 'node/123?foo';

      $result = url('node/123', array('query' => array('foo' => NULL), 'absolute' => $absolute));

      $this->assertEqual($url, $result, "$url == $result");

      $url = $base . 'node/123?foo=bar&bar=baz';

      $result = url('node/123', array('query' => array('foo' => 'bar', 'bar' => 'baz'), 'absolute' => $absolute));

      $this->assertEqual($url, $result, "$url == $result");

      $url = $base . 'node/123?foo#bar';

      $result = url('node/123', array('query' => array('foo' => NULL), 'fragment' => 'bar', 'absolute' => $absolute));

      $this->assertEqual($url, $result, "$url == $result");

      $url = $base;

      $result = url('<front>', array('absolute' => $absolute));

      $this->assertEqual($url, $result, "$url == $result");

    }

  }

  /**

   * Test external URL handling.

   */

  function testExternalUrls() {

    $test_url = 'http://drupal.org/';

    // Verify external URL can contain a fragment.

    $url = $test_url . '#drupal';

    $result = url($url);

    $this->assertEqual($url, $result, 'External URL with fragment works without a fragment in $options.');

    // Verify fragment can be overidden in an external URL.

    $url = $test_url . '#drupal';

    $fragment = $this->randomName(10);

    $result = url($url, array('fragment' => $fragment));

    $this->assertEqual($test_url . '#' . $fragment, $result, 'External URL fragment is overidden with a custom fragment in $options.');

    // Verify external URL can contain a query string.

    $url = $test_url . '?drupal=awesome';

    $result = url($url);

    $this->assertEqual($url, $result, 'External URL with query string works without a query string in $options.');

    // Verify external URL can be extended with a query string.

    $url = $test_url;

    $query = array($this->randomName(5) => $this->randomName(5));

    $result = url($url, array('query' => $query));

    $this->assertEqual($url . '?' . http_build_query($query, '', '&'), $result, 'External URL can be extended with a query string in $options.');

    // Verify query string can be extended in an external URL.

    $url = $test_url . '?drupal=awesome';

    $query = array($this->randomName(5) => $this->randomName(5));

    $result = url($url, array('query' => $query));

    $this->assertEqual($url . '&' . http_build_query($query, '', '&'), $result, 'External URL query string can be extended with a custom query string in $options.');

  }

}

/**

 * Tests for check_plain(), filter_xss(), format_string(), and check_url().

 */

class CommonXssUnitTest extends DrupalUnitTestCase {

  public static function getInfo() {

    return array(

      'name' => 'String filtering tests',

      'description' => 'Confirm that check_plain(), filter_xss(), format_string() and check_url() work correctly, including invalid multi-byte sequences.',

      'group' => 'System',

    );

  }

  /**

   * Check that invalid multi-byte sequences are rejected.

   */

  function testInvalidMultiByte() {

     // Ignore PHP 5.3+ invalid multibyte sequence warning.

     $text = @check_plain("Foo\xC0barbaz");

     $this->assertEqual($text, '', 'check_plain() rejects invalid sequence "Foo\xC0barbaz"');

     // Ignore PHP 5.3+ invalid multibyte sequence warning.

     $text = @check_plain("\xc2\"");

     $this->assertEqual($text, '', 'check_plain() rejects invalid sequence "\xc2\""');

     $text = check_plain("Fooÿñ");

     $this->assertEqual($text, "Fooÿñ", 'check_plain() accepts valid sequence "Fooÿñ"');

     $text = filter_xss("Foo\xC0barbaz");

     $this->assertEqual($text, '', 'filter_xss() rejects invalid sequence "Foo\xC0barbaz"');

     $text = filter_xss("Fooÿñ");

     $this->assertEqual($text, "Fooÿñ", 'filter_xss() accepts valid sequence Fooÿñ');

  }

  /**

   * Check that special characters are escaped.

   */

  function testEscaping() {

     $text = check_plain("<script>");

     $this->assertEqual($text, '<script>', 'check_plain() escapes <script>');

     $text = check_plain('<>&"\'');

     $this->assertEqual($text, '<>&"'', 'check_plain() escapes reserved HTML characters.');

  }

  /**

   * Test t() and format_string() replacement functionality.

   */

  function testFormatStringAndT() {

    foreach (array('format_string', 't') as $function) {

      $text = $function('Simple text');

      $this->assertEqual($text, 'Simple text', $function . ' leaves simple text alone.');

      $text = $function('Escaped text: @value', array('@value' => '<script>'));

      $this->assertEqual($text, 'Escaped text: <script>', $function . ' replaces and escapes string.');

      $text = $function('Placeholder text: %value', array('%value' => '<script>'));

      $this->assertEqual($text, 'Placeholder text: <em class="placeholder">&lt;script&gt;</em>', $function . ' replaces, escapes and themes string.');

      $text = $function('Verbatim text: !value', array('!value' => '<script>'));

      $this->assertEqual($text, 'Verbatim text: <script>', $function . ' replaces verbatim string as-is.');

    }

  }

  /**

   * Check that harmful protocols are stripped.

   */

  function testBadProtocolStripping() {

    // Ensure that check_url() strips out harmful protocols, and encodes for

    // HTML. Ensure drupal_strip_dangerous_protocols() can be used to return a

    // plain-text string stripped of harmful protocols.

    $url = 'javascript:http://www.example.com/?x=1&y=2';

    $expected_plain = 'http://www.example.com/?x=1&y=2';

    $expected_html = 'http://www.example.com/?x=1&y=2';

    $this->assertIdentical(check_url($url), $expected_html, 'check_url() filters a URL and encodes it for HTML.');

    $this->assertIdentical(drupal_strip_dangerous_protocols($url), $expected_plain, 'drupal_strip_dangerous_protocols() filters a URL and returns plain text.');

  }

}

/**

 * Tests file size parsing and formatting functions.

 */

class CommonSizeTestCase extends DrupalUnitTestCase {

  protected $exact_test_cases;

  protected $rounded_test_cases;

  public static function getInfo() {

    return array(

      'name' => 'Size parsing test',

      'description' => 'Parse a predefined amount of bytes and compare the output with the expected value.',

      'group' => 'System'

    );

  }

  function setUp() {

    $kb = DRUPAL_KILOBYTE;

    $this->exact_test_cases = array(

      '1 byte' => 1,

      '1 KB'   => $kb,

      '1 MB'   => $kb * $kb,

      '1 GB'   => $kb * $kb * $kb,

      '1 TB'   => $kb * $kb * $kb * $kb,

      '1 PB'   => $kb * $kb * $kb * $kb * $kb,

      '1 EB'   => $kb * $kb * $kb * $kb * $kb * $kb,

      '1 ZB'   => $kb * $kb * $kb * $kb * $kb * $kb * $kb,

      '1 YB'   => $kb * $kb * $kb * $kb * $kb * $kb * $kb * $kb,

    );

    $this->rounded_test_cases = array(

      '2 bytes' => 2,

      '1 MB' => ($kb * $kb) - 1, // rounded to 1 MB (not 1000 or 1024 kilobyte!)

      round(3623651 / ($this->exact_test_cases['1 MB']), 2) . ' MB' => 3623651, // megabytes

      round(67234178751368124 / ($this->exact_test_cases['1 PB']), 2) . ' PB' => 67234178751368124, // petabytes

      round(235346823821125814962843827 / ($this->exact_test_cases['1 YB']), 2) . ' YB' => 235346823821125814962843827, // yottabytes

    );

    parent::setUp();

  }

  /**

   * Check that format_size() returns the expected string.

   */

  function testCommonFormatSize() {

    foreach (array($this->exact_test_cases, $this->rounded_test_cases) as $test_cases) {

      foreach ($test_cases as $expected => $input) {

        $this->assertEqual(

          ($result = format_size($input, NULL)),

          $expected,

          $expected . ' == ' . $result . ' (' . $input . ' bytes)'

        );

      }

    }

  }

  /**

   * Check that parse_size() returns the proper byte sizes.

   */

  function testCommonParseSize() {

    foreach ($this->exact_test_cases as $string => $size) {

      $this->assertEqual(

        $parsed_size = parse_size($string),

        $size,

        $size . ' == ' . $parsed_size . ' (' . $string . ')'

      );

    }

    // Some custom parsing tests

    $string = '23476892 bytes';

    $this->assertEqual(

      ($parsed_size = parse_size($string)),

      $size = 23476892,

      $string . ' == ' . $parsed_size . ' bytes'

    );

    $string = '76MRandomStringThatShouldBeIgnoredByParseSize.'; // 76 MB

    $this->assertEqual(

      $parsed_size = parse_size($string),

      $size = 79691776,

      $string . ' == ' . $parsed_size . ' bytes'

    );

    $string = '76.24 Giggabyte'; // Misspeld text -> 76.24 GB

    $this->assertEqual(

      $parsed_size = parse_size($string),

      $size = 81862076662,

      $string . ' == ' . $parsed_size . ' bytes'

    );

  }

  /**

   * Cross-test parse_size() and format_size().

   */

  function testCommonParseSizeFormatSize() {

    foreach ($this->exact_test_cases as $size) {

      $this->assertEqual(

        $size,

        ($parsed_size = parse_size($string = format_size($size, NULL))),

        $size . ' == ' . $parsed_size . ' (' . $string . ')'

      );

    }

  }

}

/**

 * Test drupal_explode_tags() and drupal_implode_tags().

 */

class DrupalTagsHandlingTestCase extends DrupalUnitTestCase {

  var $validTags = array(

    'Drupal' => 'Drupal',

    'Drupal with some spaces' => 'Drupal with some spaces',

    '"Legendary Drupal mascot of doom: ""Druplicon"""' => 'Legendary Drupal mascot of doom: "Druplicon"',

    '"Drupal, although it rhymes with sloopal, is as awesome as a troopal!"' => 'Drupal, although it rhymes with sloopal, is as awesome as a troopal!',

  );

  public static function getInfo() {

    return array(

      'name' => 'Drupal tags handling',

      'description' => "Performs tests on Drupal's handling of tags, both explosion and implosion tactics used.",

      'group' => 'System'

    );

  }

  /**

   * Explode a series of tags.

   */

  function testDrupalExplodeTags() {

    $string = implode(', ', array_keys($this->validTags));

    $tags = drupal_explode_tags($string);

    $this->assertTags($tags);

  }

  /**

   * Implode a series of tags.

   */

  function testDrupalImplodeTags() {

    $tags = array_values($this->validTags);

    // Let's explode and implode to our heart's content.

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

      $string = drupal_implode_tags($tags);

      $tags = drupal_explode_tags($string);

    }

    $this->assertTags($tags);

  }

  /**

   * Helper function: asserts that the ending array of tags is what we wanted.

   */

  function assertTags($tags) {

    $original = $this->validTags;

    foreach ($tags as $tag) {

      $key = array_search($tag, $original);

      $this->assertTrue($key, format_string('Make sure tag %tag shows up in the final tags array (originally %original)', array('%tag' => $tag, '%original' => $key)));

      unset($original[$key]);

    }

    foreach ($original as $leftover) {

      $this->fail(format_string('Leftover tag %leftover was left over.', array('%leftover' => $leftover)));

    }

  }

}

/**

 * Test the Drupal CSS system.

 */

class CascadingStylesheetsTestCase extends DrupalWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Cascading stylesheets',

      'description' => 'Tests adding various cascading stylesheets to the page.',

      'group' => 'System',

    );

  }

  function setUp() {

    parent::setUp('php', 'locale', 'common_test');

    // Reset drupal_add_css() before each test.

    drupal_static_reset('drupal_add_css');

  }

  /**

   * Check default stylesheets as empty.

   */

  function testDefault() {

    $this->assertEqual(array(), drupal_add_css(), 'Default CSS is empty.');

  }

  /**

   * Test that stylesheets in module .info files are loaded.

   */

  function testModuleInfo() {

    $this->drupalGet('');

    // Verify common_test.css in a STYLE media="all" tag.

    $elements = $this->xpath('//style[@media=:media and contains(text(), :filename)]', array(

      ':media' => 'all',

      ':filename' => 'tests/common_test.css',

    ));

    $this->assertTrue(count($elements), "Stylesheet with media 'all' in module .info file found.");

    // Verify common_test.print.css in a STYLE media="print" tag.

    $elements = $this->xpath('//style[@media=:media and contains(text(), :filename)]', array(

      ':media' => 'print',

      ':filename' => 'tests/common_test.print.css',

    ));

    $this->assertTrue(count($elements), "Stylesheet with media 'print' in module .info file found.");

  }

  /**

   * Tests adding a file stylesheet.

   */

  function testAddFile() {

    $path = drupal_get_path('module', 'simpletest') . '/simpletest.css';

    $css = drupal_add_css($path);

    $this->assertEqual($css[$path]['data'], $path, 'Adding a CSS file caches it properly.');

  }

  /**

   * Tests adding an external stylesheet.

   */

  function testAddExternal() {

    $path = 'http://example.com/style.css';

    $css = drupal_add_css($path, 'external');

    $this->assertEqual($css[$path]['type'], 'external', 'Adding an external CSS file caches it properly.');

  }

  /**

   * Makes sure that reseting the CSS empties the cache.

   */

  function testReset() {

    drupal_static_reset('drupal_add_css');

    $this->assertEqual(array(), drupal_add_css(), 'Resetting the CSS empties the cache.');

  }

  /**

   * Tests rendering the stylesheets.

   */

  function testRenderFile() {

    $css = drupal_get_path('module', 'simpletest') . '/simpletest.css';

    drupal_add_css($css);

    $styles = drupal_get_css();

    $this->assertTrue(strpos($styles, $css) > 0, 'Rendered CSS includes the added stylesheet.');

    // Verify that newlines are properly added inside style tags.

    $query_string = variable_get('css_js_query_string', '0');

    $css_processed = "<style type=\"text/css\" media=\"all\">\n@import url(\"" . check_plain(file_create_url($css)) . "?" . $query_string ."\");\n</style>";

    $this->assertEqual(trim($styles), $css_processed, 'Rendered CSS includes newlines inside style tags for JavaScript use.');

  }

  /**

   * Tests rendering an external stylesheet.

   */

  function testRenderExternal() {

    $css = 'http://example.com/style.css';

    drupal_add_css($css, 'external');

    $styles = drupal_get_css();

    // Stylesheet URL may be the href of a LINK tag or in an @import statement

    // of a STYLE tag.

    $this->assertTrue(strpos($styles, 'href="' . $css) > 0 || strpos($styles, '@import url("' . $css . '")') > 0, 'Rendering an external CSS file.');

  }

  /**

   * Tests rendering inline stylesheets with preprocessing on.

   */

  function testRenderInlinePreprocess() {

    $css = 'body { padding: 0px; }';

    $css_preprocessed = '<style type="text/css" media="all">' . "\n<!--/*--><![CDATA[/*><!--*/\n" . drupal_load_stylesheet_content($css, TRUE) . "\n/*]]>*/-->\n" . '</style>';

    drupal_add_css($css, array('type' => 'inline'));

    $styles = drupal_get_css();

    $this->assertEqual(trim($styles), $css_preprocessed, 'Rendering preprocessed inline CSS adds it to the page.');

  }

  /**

   * Tests removing charset when rendering stylesheets with preprocessing on.

   */

  function testRenderRemoveCharsetPreprocess() {

    $cases = array(

      array(

        'asset' => '@charset "UTF-8";html{font-family:"sans-serif";}',

        'expected' => 'html{font-family:"sans-serif";}',

      ),

      // This asset contains extra \n character.

      array(

        'asset' => "@charset 'UTF-8';\nhtml{font-family:'sans-serif';}",

        'expected' => "\nhtml{font-family:'sans-serif';}",

      ),

    );

    foreach ($cases as $case) {

      $this->assertEqual(

        $case['expected'],

        drupal_load_stylesheet_content($case['asset']),

        'CSS optimizing correctly removes the charset declaration.'

      );

    }

  }

  /**

   * Tests rendering inline stylesheets with preprocessing off.

   */

  function testRenderInlineNoPreprocess() {

    $css = 'body { padding: 0px; }';

    drupal_add_css($css, array('type' => 'inline', 'preprocess' => FALSE));

    $styles = drupal_get_css();

    $this->assertTrue(strpos($styles, $css) > 0, 'Rendering non-preprocessed inline CSS adds it to the page.');

  }

  /**

   * Tests rendering inline stylesheets through a full page request.

   */

  function testRenderInlineFullPage() {

    $css = 'body { font-size: 254px; }';

    // Inline CSS is minified unless 'preprocess' => FALSE is passed as a

    // drupal_add_css() option.

    $expected = 'body{font-size:254px;}';

    // Create a node, using the PHP filter that tests drupal_add_css().

    $php_format_id = 'php_code';

    $settings = array(

      'type' => 'page',

      'body' => array(

        LANGUAGE_NONE => array(

          array(

            'value' => t('This tests the inline CSS!') . "<?php drupal_add_css('$css', 'inline'); ?>",

            'format' => $php_format_id,

          ),

        ),

      ),

      'promote' => 1,

    );

    $node = $this->drupalCreateNode($settings);

    // Fetch the page.

    $this->drupalGet('node/' . $node->nid);

    $this->assertRaw($expected, 'Inline stylesheets appear in the full page rendering.');

  }

  /**

   * Test CSS ordering.

   */

  function testRenderOrder() {

    // A module CSS file.

    drupal_add_css(drupal_get_path('module', 'simpletest') . '/simpletest.css');

    // A few system CSS files, ordered in a strange way.

    $system_path = drupal_get_path('module', 'system');

    drupal_add_css($system_path . '/system.menus.css', array('group' => CSS_SYSTEM));

    drupal_add_css($system_path . '/system.base.css', array('group' => CSS_SYSTEM, 'weight' => -10));

    drupal_add_css($system_path . '/system.theme.css', array('group' => CSS_SYSTEM));

    $expected = array(

      $system_path . '/system.base.css',

      $system_path . '/system.menus.css',

      $system_path . '/system.theme.css',

      drupal_get_path('module', 'simpletest') . '/simpletest.css',

    );

    $styles = drupal_get_css();

    // Stylesheet URL may be the href of a LINK tag or in an @import statement

    // of a STYLE tag.

    if (preg_match_all('/(href="|url\(")' . preg_quote($GLOBALS['base_url'] . '/', '/') . '([^?]+)\?/', $styles, $matches)) {

      $result = $matches[2];

    }

    else {

      $result = array();

    }

    $this->assertIdentical($result, $expected, 'The CSS files are in the expected order.');

  }

  /**

   * Test CSS override.

   */

  function testRenderOverride() {

    $system = drupal_get_path('module', 'system');

    $simpletest = drupal_get_path('module', 'simpletest');

    drupal_add_css($system . '/system.base.css');

    drupal_add_css($simpletest . '/tests/system.base.css');

    // The dummy stylesheet should be the only one included.

    $styles = drupal_get_css();

    $this->assert(strpos($styles, $simpletest . '/tests/system.base.css') !== FALSE, 'The overriding CSS file is output.');

    $this->assert(strpos($styles, $system . '/system.base.css') === FALSE, 'The overridden CSS file is not output.');

    drupal_add_css($simpletest . '/tests/system.base.css');

    drupal_add_css($system . '/system.base.css');

    // The standard stylesheet should be the only one included.

    $styles = drupal_get_css();

    $this->assert(strpos($styles, $system . '/system.base.css') !== FALSE, 'The overriding CSS file is output.');

    $this->assert(strpos($styles, $simpletest . '/tests/system.base.css') === FALSE, 'The overridden CSS file is not output.');

  }

  /**

   * Tests Locale module's CSS Alter to include RTL overrides.

   */

  function testAlter() {

    // Switch the language to a right to left language and add system.base.css.

    global $language;

    $language->direction = LANGUAGE_RTL;

    $path = drupal_get_path('module', 'system');

    drupal_add_css($path . '/system.base.css');

    // Check to see if system.base-rtl.css was also added.

    $styles = drupal_get_css();

    $this->assert(strpos($styles, $path . '/system.base-rtl.css') !== FALSE, 'CSS is alterable as right to left overrides are added.');

    // Change the language back to left to right.

    $language->direction = LANGUAGE_LTR;

  }

  /**

   * Tests that the query string remains intact when adding CSS files that have

   * query string parameters.

   */

  function testAddCssFileWithQueryString() {

    $this->drupalGet('common-test/query-string');

    $query_string = variable_get('css_js_query_string', '0');

    $this->assertRaw(drupal_get_path('module', 'node') . '/node.css?' . $query_string, 'Query string was appended correctly to css.');

    $this->assertRaw(drupal_get_path('module', 'node') . '/node-fake.css?arg1=value1&arg2=value2', 'Query string not escaped on a URI.');

  }

}

/**

 * Test for cleaning HTML identifiers.

 */

class DrupalHTMLIdentifierTestCase extends DrupalUnitTestCase {

  public static function getInfo() {

    return array(

      'name' => 'HTML identifiers',

      'description' => 'Test the functions drupal_html_class(), drupal_html_id() and drupal_clean_css_identifier() for expected behavior',

      'group' => 'System',

    );

  }

  /**

   * Tests that drupal_clean_css_identifier() cleans the identifier properly.

   */

  function testDrupalCleanCSSIdentifier() {

    // Verify that no valid ASCII characters are stripped from the identifier.

    $identifier = 'abcdefghijklmnopqrstuvwxyz_ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789';

    $this->assertIdentical(drupal_clean_css_identifier($identifier, array()), $identifier, 'Verify valid ASCII characters pass through.');

    // Verify that valid UTF-8 characters are not stripped from the identifier.

    $identifier = '¡¢£¤¥';

    $this->assertIdentical(drupal_clean_css_identifier($identifier, array()), $identifier, 'Verify valid UTF-8 characters pass through.');

    // Verify that invalid characters (including non-breaking space) are stripped from the identifier.

    $this->assertIdentical(drupal_clean_css_identifier('invalid !"#$%&\'()*+,./:;<=>?@[\\]^`{|}~ identifier', array()), 'invalididentifier', 'Strip invalid characters.');

  }

  /**

   * Tests that drupal_html_class() cleans the class name properly.

   */

  function testDrupalHTMLClass() {

    // Verify Drupal coding standards are enforced.

    $this->assertIdentical(drupal_html_class('CLASS NAME_[Ü]'), 'class-name--ü', 'Enforce Drupal coding standards.');

  }

  /**

   * Tests that drupal_html_id() cleans the ID properly.

   */

  function testDrupalHTMLId() {

    // Verify that letters, digits, and hyphens are not stripped from the ID.

    $id = 'abcdefghijklmnopqrstuvwxyz-0123456789';

    $this->assertIdentical(drupal_html_id($id), $id, 'Verify valid characters pass through.');

    // Verify that invalid characters are stripped from the ID.

    $this->assertIdentical(drupal_html_id('invalid,./:@\\^`{Üidentifier'), 'invalididentifier', 'Strip invalid characters.');

    // Verify Drupal coding standards are enforced.

    $this->assertIdentical(drupal_html_id('ID NAME_[1]'), 'id-name-1', 'Enforce Drupal coding standards.');

    // Reset the static cache so we can ensure the unique id count is at zero.

    drupal_static_reset('drupal_html_id');

    // Clean up IDs with invalid starting characters.

    $this->assertIdentical(drupal_html_id('test-unique-id'), 'test-unique-id', 'Test the uniqueness of IDs #1.');

    $this->assertIdentical(drupal_html_id('test-unique-id'), 'test-unique-id--2', 'Test the uniqueness of IDs #2.');

    $this->assertIdentical(drupal_html_id('test-unique-id'), 'test-unique-id--3', 'Test the uniqueness of IDs #3.');

  }

}

/**

 * CSS Unit Tests.

 */

class CascadingStylesheetsUnitTest extends DrupalUnitTestCase {

  public static function getInfo() {

    return array(

      'name' => 'CSS Unit Tests',

      'description' => 'Unit tests on CSS functions like aggregation.',

      'group' => 'System',

    );

  }

  /**

   * Tests basic CSS loading with and without optimization via drupal_load_stylesheet().

   *

   * Known tests:

   * - Retain white-space in selectors. (https://drupal.org/node/472820)

   * - Proper URLs in imported files. (https://drupal.org/node/265719)

   * - Retain pseudo-selectors. (https://drupal.org/node/460448)

   * - Don't adjust data URIs. (https://drupal.org/node/2142441)

   */

  function testLoadCssBasic() {

    // Array of files to test living in 'simpletest/files/css_test_files/'.

    // - Original: name.css

    // - Unoptimized expected content: name.css.unoptimized.css

    // - Optimized expected content: name.css.optimized.css

    $testfiles = array(

      'css_input_without_import.css',

      'css_input_with_import.css',

      'css_subfolder/css_input_with_import.css',

      'comment_hacks.css'

    );

    $path = drupal_get_path('module', 'simpletest') . '/files/css_test_files';

    foreach ($testfiles as $file) {

      $file_path = $path . '/' . $file;

      $file_url = $GLOBALS['base_url'] . '/' . $file_path;

      $expected = file_get_contents($file_path . '.unoptimized.css');

      $unoptimized_output = drupal_load_stylesheet($file_path, FALSE);

      $this->assertEqual($unoptimized_output, $expected, format_string('Unoptimized CSS file has expected contents (@file)', array('@file' => $file)));

      $expected = file_get_contents($file_path . '.optimized.css');

      $optimized_output = drupal_load_stylesheet($file_path, TRUE);

      $this->assertEqual($optimized_output, $expected, format_string('Optimized CSS file has expected contents (@file)', array('@file' => $file)));

      // Repeat the tests by accessing the stylesheets by URL.

      $expected = file_get_contents($file_path . '.unoptimized.css');

      $unoptimized_output_url = drupal_load_stylesheet($file_url, FALSE);

      $this->assertEqual($unoptimized_output_url, $expected, format_string('Unoptimized CSS file (loaded from an URL) has expected contents (@file)', array('@file' => $file)));

      $expected = file_get_contents($file_path . '.optimized.css');

      $optimized_output_url = drupal_load_stylesheet($file_url, TRUE);

      $this->assertEqual($optimized_output_url, $expected, format_string('Optimized CSS file (loaded from an URL) has expected contents (@file)', array('@file' => $file)));

    }

  }

}

/**

 * Test drupal_http_request().

 */

class DrupalHTTPRequestTestCase extends DrupalWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Drupal HTTP request',

      'description' => "Performs tests on Drupal's HTTP request mechanism.",

      'group' => 'System'

    );

  }

  function setUp() {

    parent::setUp('system_test', 'locale');

  }

  function testDrupalHTTPRequest() {

    global $is_https;

    // Parse URL schema.

    $missing_scheme = drupal_http_request('example.com/path');

    $this->assertEqual($missing_scheme->code, -1002, 'Returned with "-1002" error code.');

    $this->assertEqual($missing_scheme->error, 'missing schema', 'Returned with "missing schema" error message.');

    $unable_to_parse = drupal_http_request('http:///path');

    $this->assertEqual($unable_to_parse->code, -1001, 'Returned with "-1001" error code.');

    $this->assertEqual($unable_to_parse->error, 'unable to parse URL', 'Returned with "unable to parse URL" error message.');

    // Fetch page.

    $result = drupal_http_request(url('node', array('absolute' => TRUE)));

    $this->assertEqual($result->code, 200, 'Fetched page successfully.');

    $this->drupalSetContent($result->data);

    $this->assertTitle(t('Welcome to @site-name | @site-name', array('@site-name' => variable_get('site_name', 'Drupal'))), 'Site title matches.');

    // Test that code and status message is returned.

    $result = drupal_http_request(url('pagedoesnotexist', array('absolute' => TRUE)));

    $this->assertTrue(!empty($result->protocol),  'Result protocol is returned.');

    $this->assertEqual($result->code, '404', 'Result code is 404');

    $this->assertEqual($result->status_message, 'Not Found', 'Result status message is "Not Found"');

    // Skip the timeout tests when the testing environment is HTTPS because

    // stream_set_timeout() does not work for SSL connections.

    // @link http://bugs.php.net/bug.php?id=47929

    if (!$is_https) {

      // Test that timeout is respected. The test machine is expected to be able

      // to make the connection (i.e. complete the fsockopen()) in 2 seconds and

      // return within a total of 5 seconds. If the test machine is extremely

      // slow, the test will fail. fsockopen() has been seen to time out in

      // slightly less than the specified timeout, so allow a little slack on

      // the minimum expected time (i.e. 1.8 instead of 2).

      timer_start(__METHOD__);

      $result = drupal_http_request(url('system-test/sleep/10', array('absolute' => TRUE)), array('timeout' => 2));

      $time = timer_read(__METHOD__) / 1000;

      $this->assertTrue(1.8 < $time && $time < 5, format_string('Request timed out (%time seconds).', array('%time' => $time)));

      $this->assertTrue($result->error, 'An error message was returned.');

      $this->assertEqual($result->code, HTTP_REQUEST_TIMEOUT, 'Proper error code was returned.');

    }

  }

  function testDrupalHTTPRequestBasicAuth() {

    $username = $this->randomName();

    $password = $this->randomName();

    $url = url('system-test/auth', array('absolute' => TRUE));

    $auth = str_replace('://', '://' . $username . ':' . $password . '@', $url);

    $result = drupal_http_request($auth);

    $this->drupalSetContent($result->data);

    $this->assertRaw($username, 'Username is passed correctly.');

    $this->assertRaw($password, 'Password is passed correctly.');

  }

  function testDrupalHTTPRequestRedirect() {

    $redirect_301 = drupal_http_request(url('system-test/redirect/301', array('absolute' => TRUE)), array('max_redirects' => 1));

    $this->assertEqual($redirect_301->redirect_code, 301, 'drupal_http_request follows the 301 redirect.');

    $redirect_301 = drupal_http_request(url('system-test/redirect/301', array('absolute' => TRUE)), array('max_redirects' => 0));

    $this->assertFalse(isset($redirect_301->redirect_code), 'drupal_http_request does not follow 301 redirect if max_redirects = 0.');

    $redirect_invalid = drupal_http_request(url('system-test/redirect-noscheme', array('absolute' => TRUE)), array('max_redirects' => 1));

    $this->assertEqual($redirect_invalid->code, -1002, format_string('301 redirect to invalid URL returned with error code !error.', array('!error' => $redirect_invalid->error)));

    $this->assertEqual($redirect_invalid->error, 'missing schema', format_string('301 redirect to invalid URL returned with error message "!error".', array('!error' => $redirect_invalid->error)));

    $redirect_invalid = drupal_http_request(url('system-test/redirect-noparse', array('absolute' => TRUE)), array('max_redirects' => 1));

    $this->assertEqual($redirect_invalid->code, -1001, format_string('301 redirect to invalid URL returned with error message code "!error".', array('!error' => $redirect_invalid->error)));

    $this->assertEqual($redirect_invalid->error, 'unable to parse URL', format_string('301 redirect to invalid URL returned with error message "!error".', array('!error' => $redirect_invalid->error)));

    $redirect_invalid = drupal_http_request(url('system-test/redirect-invalid-scheme', array('absolute' => TRUE)), array('max_redirects' => 1));

    $this->assertEqual($redirect_invalid->code, -1003, format_string('301 redirect to invalid URL returned with error code !error.', array('!error' => $redirect_invalid->error)));

    $this->assertEqual($redirect_invalid->error, 'invalid schema ftp', format_string('301 redirect to invalid URL returned with error message "!error".', array('!error' => $redirect_invalid->error)));

    $redirect_302 = drupal_http_request(url('system-test/redirect/302', array('absolute' => TRUE)), array('max_redirects' => 1));

    $this->assertEqual($redirect_302->redirect_code, 302, 'drupal_http_request follows the 302 redirect.');

    $redirect_302 = drupal_http_request(url('system-test/redirect/302', array('absolute' => TRUE)), array('max_redirects' => 0));

    $this->assertFalse(isset($redirect_302->redirect_code), 'drupal_http_request does not follow 302 redirect if $retry = 0.');

    $redirect_307 = drupal_http_request(url('system-test/redirect/307', array('absolute' => TRUE)), array('max_redirects' => 1));

    $this->assertEqual($redirect_307->redirect_code, 307, 'drupal_http_request follows the 307 redirect.');

    $redirect_307 = drupal_http_request(url('system-test/redirect/307', array('absolute' => TRUE)), array('max_redirects' => 0));

    $this->assertFalse(isset($redirect_307->redirect_code), 'drupal_http_request does not follow 307 redirect if max_redirects = 0.');

    $multiple_redirect_final_url = url('system-test/multiple-redirects/0', array('absolute' => TRUE));

    $multiple_redirect_1 = drupal_http_request(url('system-test/multiple-redirects/1', array('absolute' => TRUE)), array('max_redirects' => 1));

    $this->assertEqual($multiple_redirect_1->redirect_url, $multiple_redirect_final_url, 'redirect_url contains the final redirection location after 1 redirect.');

    $multiple_redirect_3 = drupal_http_request(url('system-test/multiple-redirects/3', array('absolute' => TRUE)), array('max_redirects' => 3));

    $this->assertEqual($multiple_redirect_3->redirect_url, $multiple_redirect_final_url, 'redirect_url contains the final redirection location after 3 redirects.');

  }

  /**

   * Tests Content-language headers generated by Drupal.

   */

  function testDrupalHTTPRequestHeaders() {

    // Check the default header.

    $request = drupal_http_request(url('<front>', array('absolute' => TRUE)));

    $this->assertEqual($request->headers['content-language'], 'en', 'Content-Language HTTP header is English.');

    // Add German language and set as default.

    locale_add_language('de', 'German', 'Deutsch', LANGUAGE_LTR, '', '', TRUE, TRUE);

    // Request front page and check for matching Content-Language.

    $request = drupal_http_request(url('<front>', array('absolute' => TRUE)));

    $this->assertEqual($request->headers['content-language'], 'de', 'Content-Language HTTP header is German.');

  }

}

/**

 * Tests parsing of the HTTP response status line.

 */

class DrupalHTTPResponseStatusLineTest extends DrupalUnitTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Drupal HTTP request response status parsing',

      'description' => 'Perform unit tests on _drupal_parse_response_status().',

      'group' => 'System',

    );

  }

  /**

   * Tests parsing HTTP response status line.

   */

  public function testStatusLine() {

    // Grab the big array of test data from statusLineData().

    $data = $this->statusLineData();

    foreach($data as $test_case) {

      $test_data = array_shift($test_case);

      $expected = array_shift($test_case);

      $outcome = _drupal_parse_response_status($test_data);

      foreach(array_keys($expected) as $key) {

        $this->assertIdentical($outcome[$key], $expected[$key]);

      }

    }

  }

  /**

   * Data provider for testStatusLine().

   *

   * @return array

   *   Test data.

   */

  protected function statusLineData() {

    return array(

      array(

        'HTTP/1.1 200 OK',

        array(

          'http_version' => 'HTTP/1.1',

          'response_code' => '200',

          'reason_phrase' => 'OK',

        ),

      ),

      // Data set with no reason phrase.

      array(

        'HTTP/1.1 200',

        array(

          'http_version' => 'HTTP/1.1',

          'response_code' => '200',

          'reason_phrase' => '',

        ),

      ),

      // Arbitrary strings.

      array(

        'version code multi word explanation',

        array(

          'http_version' => 'version',

          'response_code' => 'code',

          'reason_phrase' => 'multi word explanation',

        ),

      ),

    );

  }

}

/**

 * Testing drupal_add_region_content and drupal_get_region_content.

 */

class DrupalSetContentTestCase extends DrupalWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Drupal set/get regions',

      'description' => 'Performs tests on setting and retrieiving content from theme regions.',

      'group' => 'System'

    );

  }

  /**

   * Test setting and retrieving content for theme regions.

   */

  function testRegions() {

    global $theme_key;

    $block_regions = array_keys(system_region_list($theme_key));

    $delimiter = $this->randomName(32);

    $values = array();

    // Set some random content for each region available.

    foreach ($block_regions as $region) {

      $first_chunk = $this->randomName(32);

      drupal_add_region_content($region, $first_chunk);

      $second_chunk = $this->randomName(32);

      drupal_add_region_content($region, $second_chunk);

      // Store the expected result for a drupal_get_region_content call for this region.

      $values[$region] = $first_chunk . $delimiter . $second_chunk;

    }

    // Ensure drupal_get_region_content returns expected results when fetching all regions.

    $content = drupal_get_region_content(NULL, $delimiter);

    foreach ($content as $region => $region_content) {

      $this->assertEqual($region_content, $values[$region], format_string('@region region text verified when fetching all regions', array('@region' => $region)));

    }

    // Ensure drupal_get_region_content returns expected results when fetching a single region.

    foreach ($block_regions as $region) {

      $region_content = drupal_get_region_content($region, $delimiter);

      $this->assertEqual($region_content, $values[$region], format_string('@region region text verified when fetching single region.', array('@region' => $region)));

    }

  }

}

/**

 * Testing drupal_goto and hook_drupal_goto_alter().

 */

class DrupalGotoTest extends DrupalWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Drupal goto',

      'description' => 'Performs tests on the drupal_goto function and hook_drupal_goto_alter',

      'group' => 'System'

    );

  }

  function setUp() {

    parent::setUp('common_test');

  }

  /**

   * Test drupal_goto().

   */

  function testDrupalGoto() {

    $this->drupalGet('common-test/drupal_goto/redirect');

    $headers = $this->drupalGetHeaders(TRUE);

    list(, $status) = explode(' ', $headers[0][':status'], 3);

    $this->assertEqual($status, 302, 'Expected response code was sent.');

    $this->assertText('drupal_goto', 'Drupal goto redirect succeeded.');

    $this->assertEqual($this->getUrl(), url('common-test/drupal_goto', array('absolute' => TRUE)), 'Drupal goto redirected to expected URL.');

    $this->drupalGet('common-test/drupal_goto/redirect_advanced');

    $headers = $this->drupalGetHeaders(TRUE);

    list(, $status) = explode(' ', $headers[0][':status'], 3);

    $this->assertEqual($status, 301, 'Expected response code was sent.');

    $this->assertText('drupal_goto', 'Drupal goto redirect succeeded.');

    $this->assertEqual($this->getUrl(), url('common-test/drupal_goto', array('query' => array('foo' => '123'), 'absolute' => TRUE)), 'Drupal goto redirected to expected URL.');

    // Test that drupal_goto() respects ?destination=xxx. Use an complicated URL

    // to test that the path is encoded and decoded properly.

    $destination = 'common-test/drupal_goto/destination?foo=%2525&bar=123';

    $this->drupalGet('common-test/drupal_goto/redirect', array('query' => array('destination' => $destination)));

    $this->assertText('drupal_goto', 'Drupal goto redirect with destination succeeded.');

    $this->assertEqual($this->getUrl(), url('common-test/drupal_goto/destination', array('query' => array('foo' => '%25', 'bar' => '123'), 'absolute' => TRUE)), 'Drupal goto redirected to given query string destination.');

  }

  /**

   * Test hook_drupal_goto_alter().

   */

  function testDrupalGotoAlter() {

    $this->drupalGet('common-test/drupal_goto/redirect_fail');

    $this->assertNoText(t("Drupal goto failed to stop program"), "Drupal goto stopped program.");

    $this->assertNoText('drupal_goto_fail', "Drupal goto redirect failed.");

  }

  /**

   * Test drupal_get_destination().

   */

  function testDrupalGetDestination() {

    $query = $this->randomName(10);

    // Verify that a 'destination' query string is used as destination.

    $this->drupalGet('common-test/destination', array('query' => array('destination' => $query)));

    $this->assertText('The destination: ' . $query, 'The given query string destination is determined as destination.');

    // Verify that the current path is used as destination.

    $this->drupalGet('common-test/destination', array('query' => array($query => NULL)));

    $url = 'common-test/destination?' . $query;

    $this->assertText('The destination: ' . $url, 'The current path is determined as destination.');

  }

}

/**

 * Tests for the JavaScript system.

 */

class JavaScriptTestCase extends DrupalWebTestCase {

  /**

   * Store configured value for JavaScript preprocessing.

   */

  protected $preprocess_js = NULL;

  public static function getInfo() {

    return array(

      'name' => 'JavaScript',

      'description' => 'Tests the JavaScript system.',

      'group' => 'System'

    );

  }

  function setUp() {

    // Enable Locale and SimpleTest in the test environment.

    parent::setUp('locale', 'simpletest', 'common_test');

    // Disable preprocessing

    $this->preprocess_js = variable_get('preprocess_js', 0);

    variable_set('preprocess_js', 0);

    // Reset drupal_add_js() and drupal_add_library() statics before each test.

    drupal_static_reset('drupal_add_js');

    drupal_static_reset('drupal_add_library');

  }

  function tearDown() {

    // Restore configured value for JavaScript preprocessing.

    variable_set('preprocess_js', $this->preprocess_js);

    parent::tearDown();

  }

  /**

   * Test default JavaScript is empty.

   */

  function testDefault() {

    $this->assertEqual(array(), drupal_add_js(), 'Default JavaScript is empty.');

  }

  /**

   * Test adding a JavaScript file.

   */

  function testAddFile() {

    $javascript = drupal_add_js('misc/collapse.js');

    $this->assertTrue(array_key_exists('misc/jquery.js', $javascript), 'jQuery is added when a file is added.');

    $this->assertTrue(array_key_exists('misc/drupal.js', $javascript), 'Drupal.js is added when file is added.');

    $this->assertTrue(array_key_exists('misc/collapse.js', $javascript), 'JavaScript files are correctly added.');

    $this->assertEqual(base_path(), $javascript['settings']['data'][0]['basePath'], 'Base path JavaScript setting is correctly set.');

    url('', array('prefix' => &$prefix));

    $this->assertEqual(empty($prefix) ? '' : $prefix, $javascript['settings']['data'][1]['pathPrefix'], 'Path prefix JavaScript setting is correctly set.');

  }

  /**

   * Test adding settings.

   */

  function testAddSetting() {

    $javascript = drupal_add_js(array('drupal' => 'rocks', 'dries' => 280342800), 'setting');

    $this->assertEqual(280342800, $javascript['settings']['data'][2]['dries'], 'JavaScript setting is set correctly.');

    $this->assertEqual('rocks', $javascript['settings']['data'][2]['drupal'], 'The other JavaScript setting is set correctly.');

  }

  /**

   * Tests adding an external JavaScript File.

   */

  function testAddExternal() {

    $path = 'http://example.com/script.js';

    $javascript = drupal_add_js($path, 'external');

    $this->assertTrue(array_key_exists('http://example.com/script.js', $javascript), 'Added an external JavaScript file.');

  }

  /**

   * Test drupal_get_js() for JavaScript settings.

   */

  function testHeaderSetting() {

    // Only the second of these two entries should appear in Drupal.settings.

    drupal_add_js(array('commonTest' => 'commonTestShouldNotAppear'), 'setting');

    drupal_add_js(array('commonTest' => 'commonTestShouldAppear'), 'setting');

    // All three of these entries should appear in Drupal.settings.

    drupal_add_js(array('commonTestArray' => array('commonTestValue0')), 'setting');

    drupal_add_js(array('commonTestArray' => array('commonTestValue1')), 'setting');

    drupal_add_js(array('commonTestArray' => array('commonTestValue2')), 'setting');

    // Only the second of these two entries should appear in Drupal.settings.

    drupal_add_js(array('commonTestArray' => array('key' => 'commonTestOldValue')), 'setting');

    drupal_add_js(array('commonTestArray' => array('key' => 'commonTestNewValue')), 'setting');

    $javascript = drupal_get_js('header');

    $this->assertTrue(strpos($javascript, 'basePath') > 0, 'Rendered JavaScript header returns basePath setting.');

    $this->assertTrue(strpos($javascript, 'misc/jquery.js') > 0, 'Rendered JavaScript header includes jQuery.');

    $this->assertTrue(strpos($javascript, 'pathPrefix') > 0, 'Rendered JavaScript header returns pathPrefix setting.');

    // Test whether drupal_add_js can be used to override a previous setting.

    $this->assertTrue(strpos($javascript, 'commonTestShouldAppear') > 0, 'Rendered JavaScript header returns custom setting.');

    $this->assertTrue(strpos($javascript, 'commonTestShouldNotAppear') === FALSE, 'drupal_add_js() correctly overrides a custom setting.');

    // Test whether drupal_add_js can be used to add numerically indexed values

    // to an array.

    $array_values_appear = strpos($javascript, 'commonTestValue0') > 0 && strpos($javascript, 'commonTestValue1') > 0 && strpos($javascript, 'commonTestValue2') > 0;

    $this->assertTrue($array_values_appear, 'drupal_add_js() correctly adds settings to the end of an indexed array.');

    // Test whether drupal_add_js can be used to override the entry for an

    // existing key in an associative array.

    $associative_array_override = strpos($javascript, 'commonTestNewValue') > 0 && strpos($javascript, 'commonTestOldValue') === FALSE;

    $this->assertTrue($associative_array_override, 'drupal_add_js() correctly overrides settings within an associative array.');

  }

  /**

   * Test to see if resetting the JavaScript empties the cache.

   */

  function testReset() {

    drupal_add_js('misc/collapse.js');

    drupal_static_reset('drupal_add_js');

    $this->assertEqual(array(), drupal_add_js(), 'Resetting the JavaScript correctly empties the cache.');

  }

  /**

   * Test adding inline scripts.

   */

  function testAddInline() {

    $inline = 'jQuery(function () { });';

    $javascript = drupal_add_js($inline, array('type' => 'inline', 'scope' => 'footer'));

    $this->assertTrue(array_key_exists('misc/jquery.js', $javascript), 'jQuery is added when inline scripts are added.');

    $data = end($javascript);

    $this->assertEqual($inline, $data['data'], 'Inline JavaScript is correctly added to the footer.');

  }

  /**

   * Test rendering an external JavaScript file.

   */

  function testRenderExternal() {

    $external = 'http://example.com/example.js';

    drupal_add_js($external, 'external');

    $javascript = drupal_get_js();

    // Local files have a base_path() prefix, external files should not.

    $this->assertTrue(strpos($javascript, 'src="' . $external) > 0, 'Rendering an external JavaScript file.');

  }

  /**

   * Test drupal_get_js() with a footer scope.

   */

  function testFooterHTML() {

    $inline = 'jQuery(function () { });';

    drupal_add_js($inline, array('type' => 'inline', 'scope' => 'footer'));

    $javascript = drupal_get_js('footer');

    $this->assertTrue(strpos($javascript, $inline) > 0, 'Rendered JavaScript footer returns the inline code.');

  }

  /**

   * Test drupal_add_js() sets preproccess to false when cache is set to false.

   */

  function testNoCache() {

    $javascript = drupal_add_js('misc/collapse.js', array('cache' => FALSE));

    $this->assertFalse($javascript['misc/collapse.js']['preprocess'], 'Setting cache to FALSE sets proprocess to FALSE when adding JavaScript.');

  }

  /**

   * Test adding a JavaScript file with a different group.

   */

  function testDifferentGroup() {

    $javascript = drupal_add_js('misc/collapse.js', array('group' => JS_THEME));

    $this->assertEqual($javascript['misc/collapse.js']['group'], JS_THEME, 'Adding a JavaScript file with a different group caches the given group.');

  }

  /**

   * Test adding a JavaScript file with a different weight.

   */

  function testDifferentWeight() {

    $javascript = drupal_add_js('misc/collapse.js', array('weight' => 2));

    $this->assertEqual($javascript['misc/collapse.js']['weight'], 2, 'Adding a JavaScript file with a different weight caches the given weight.');

  }

  /**

   * Tests JavaScript aggregation when files are added to a different scope.

   */

  function testAggregationOrder() {

    // Enable JavaScript aggregation.

    variable_set('preprocess_js', 1);

    drupal_static_reset('drupal_add_js');

    // Add two JavaScript files to the current request and build the cache.

    drupal_add_js('misc/ajax.js');

    drupal_add_js('misc/autocomplete.js');

    $js_items = drupal_add_js();

    drupal_build_js_cache(array(

      'misc/ajax.js' => $js_items['misc/ajax.js'],

      'misc/autocomplete.js' => $js_items['misc/autocomplete.js']

    ));

    // Store the expected key for the first item in the cache.

    $cache = array_keys(variable_get('drupal_js_cache_files', array()));

    $expected_key = $cache[0];

    // Reset variables and add a file in a different scope first.

    variable_del('drupal_js_cache_files');

    drupal_static_reset('drupal_add_js');

    drupal_add_js('some/custom/javascript_file.js', array('scope' => 'footer'));

    drupal_add_js('misc/ajax.js');

    drupal_add_js('misc/autocomplete.js');

    // Rebuild the cache.

    $js_items = drupal_add_js();

    drupal_build_js_cache(array(

      'misc/ajax.js' => $js_items['misc/ajax.js'],

      'misc/autocomplete.js' => $js_items['misc/autocomplete.js']

    ));

    // Compare the expected key for the first file to the current one.

    $cache = array_keys(variable_get('drupal_js_cache_files', array()));

    $key = $cache[0];

    $this->assertEqual($key, $expected_key, 'JavaScript aggregation is not affected by ordering in different scopes.');

  }

  /**

   * Test JavaScript ordering.

   */

  function testRenderOrder() {

    // Add a bunch of JavaScript in strange ordering.

    drupal_add_js('(function($){alert("Weight 5 #1");})(jQuery);', array('type' => 'inline', 'scope' => 'footer', 'weight' => 5));

    drupal_add_js('(function($){alert("Weight 0 #1");})(jQuery);', array('type' => 'inline', 'scope' => 'footer'));

    drupal_add_js('(function($){alert("Weight 0 #2");})(jQuery);', array('type' => 'inline', 'scope' => 'footer'));

    drupal_add_js('(function($){alert("Weight -8 #1");})(jQuery);', array('type' => 'inline', 'scope' => 'footer', 'weight' => -8));

    drupal_add_js('(function($){alert("Weight -8 #2");})(jQuery);', array('type' => 'inline', 'scope' => 'footer', 'weight' => -8));

    drupal_add_js('(function($){alert("Weight -8 #3");})(jQuery);', array('type' => 'inline', 'scope' => 'footer', 'weight' => -8));

    drupal_add_js('http://example.com/example.js?Weight -5 #1', array('type' => 'external', 'scope' => 'footer', 'weight' => -5));

    drupal_add_js('(function($){alert("Weight -8 #4");})(jQuery);', array('type' => 'inline', 'scope' => 'footer', 'weight' => -8));

    drupal_add_js('(function($){alert("Weight 5 #2");})(jQuery);', array('type' => 'inline', 'scope' => 'footer', 'weight' => 5));

    drupal_add_js('(function($){alert("Weight 0 #3");})(jQuery);', array('type' => 'inline', 'scope' => 'footer'));

    // Construct the expected result from the regex.

    $expected = array(

      "-8 #1",

      "-8 #2",

      "-8 #3",

      "-8 #4",

      "-5 #1", // The external script.

      "0 #1",

      "0 #2",

      "0 #3",

      "5 #1",

      "5 #2",

    );

    // Retrieve the rendered JavaScript and test against the regex.

    $js = drupal_get_js('footer');

    $matches = array();

    if (preg_match_all('/Weight\s([-0-9]+\s[#0-9]+)/', $js, $matches)) {

      $result = $matches[1];

    }

    else {

      $result = array();

    }

    $this->assertIdentical($result, $expected, 'JavaScript is added in the expected weight order.');

  }

  /**

   * Test rendering the JavaScript with a file's weight above jQuery's.

   */

  function testRenderDifferentWeight() {

    // JavaScript files are sorted first by group, then by the 'every_page'

    // flag, then by weight (see drupal_sort_css_js()), so to test the effect of

    // weight, we need the other two options to be the same.

    drupal_add_js('misc/collapse.js', array('group' => JS_LIBRARY, 'every_page' => TRUE, 'weight' => -21));

    $javascript = drupal_get_js();

    $this->assertTrue(strpos($javascript, 'misc/collapse.js') < strpos($javascript, 'misc/jquery.js'), 'Rendering a JavaScript file above jQuery.');

  }

  /**

   * Test altering a JavaScript's weight via hook_js_alter().

   *

   * @see simpletest_js_alter()

   */

  function testAlter() {

    // Add both tableselect.js and simpletest.js, with a larger weight on SimpleTest.

    drupal_add_js('misc/tableselect.js');

    drupal_add_js(drupal_get_path('module', 'simpletest') . '/simpletest.js', array('weight' => 9999));

    // Render the JavaScript, testing if simpletest.js was altered to be before

    // tableselect.js. See simpletest_js_alter() to see where this alteration

    // takes place.

    $javascript = drupal_get_js();

    $this->assertTrue(strpos($javascript, 'simpletest.js') < strpos($javascript, 'misc/tableselect.js'), 'Altering JavaScript weight through the alter hook.');

  }

  /**

   * Adds a library to the page and tests for both its JavaScript and its CSS.

   */

  function testLibraryRender() {

    $result = drupal_add_library('system', 'farbtastic');

    $this->assertTrue($result !== FALSE, 'Library was added without errors.');

    $scripts = drupal_get_js();

    $styles = drupal_get_css();

    $this->assertTrue(strpos($scripts, 'misc/farbtastic/farbtastic.js'), 'JavaScript of library was added to the page.');

    $this->assertTrue(strpos($styles, 'misc/farbtastic/farbtastic.css'), 'Stylesheet of library was added to the page.');

  }

  /**

   * Adds a JavaScript library to the page and alters it.

   *

   * @see common_test_library_alter()