1 <?php

     2 

     3 /**

     4  * @file

     5  * Tests for common.inc functionality.

     6  */

     7 

     8 /**

     9  * Tests for URL generation functions.

    10  */

    11 class DrupalAlterTestCase extends DrupalWebTestCase {

    12   public static function getInfo() {

    13     return array(

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

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

    16       'group' => 'System',

    17     );

    18   }

    19 

    20   function setUp() {

    21     parent::setUp('common_test');

    22   }

    23 

    24   function testDrupalAlter() {

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

    26     // active theme.

    27     global $theme, $base_theme_info;

    28     $theme = 'bartik';

    29     $base_theme_info = array();

    30 

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

    32     $entity = new stdClass();

    33     $entity->foo = 'bar';

    34 

    35     // Verify alteration of a single argument.

    36     $array_copy = $array;

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

    38     drupal_alter('drupal_alter', $array_copy);

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

    40 

    41     $entity_copy = clone $entity;

    42     $entity_expected = clone $entity;

    43     $entity_expected->foo = 'Drupal theme';

    44     drupal_alter('drupal_alter', $entity_copy);

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

    46 

    47     // Verify alteration of multiple arguments.

    48     $array_copy = $array;

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

    50     $entity_copy = clone $entity;

    51     $entity_expected = clone $entity;

    52     $entity_expected->foo = 'Drupal theme';

    53     $array2_copy = $array;

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

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

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

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

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

    59 

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

    61     // common_test_module_implements_alter() places 'block' implementation after

    62     // other modules.

    63     $array_copy = $array;

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

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

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

    67   }

    68 }

    69 

    70 /**

    71  * Tests for URL generation functions.

    72  *

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

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

    75  */

    76 class CommonURLUnitTest extends DrupalWebTestCase {

    77   public static function getInfo() {

    78     return array(

    79       'name' => 'URL generation tests',

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

    81       'group' => 'System',

    82     );

    83   }

    84 

    85   /**

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

    87    */

    88   function testLXSS() {

    89     $text = $this->randomName();

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

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

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

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

    94   }

    95 

    96   /*

    97    * Tests for active class in l() function.

    98    */

    99   function testLActiveClass() {

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

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

   102   }

   103 

   104   /**

   105    * Tests for custom class in l() function.

   106    */

   107   function testLCustomClass() {

   108     $class = $this->randomName();

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

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

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

   112   }

   113 

   114   private function hasClass($link, $class) {

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

   116   }

   117 

   118   /**

   119    * Test drupal_get_query_parameters().

   120    */

   121   function testDrupalGetQueryParameters() {

   122     $original = array(

   123       'a' => 1,

   124       'b' => array(

   125         'd' => 4,

   126         'e' => array(

   127           'f' => 5,

   128         ),

   129       ),

   130       'c' => 3,

   131       'q' => 'foo/bar',

   132     );

   133 

   134     // Default arguments.

   135     $result = $_GET;

   136     unset($result['q']);

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

   138 

   139     // Default exclusion.

   140     $result = $original;

   141     unset($result['q']);

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

   143 

   144     // First-level exclusion.

   145     $result = $original;

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

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

   148 

   149     // Second-level exclusion.

   150     $result = $original;

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

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

   153 

   154     // Third-level exclusion.

   155     $result = $original;

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

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

   158 

   159     // Multiple exclusions.

   160     $result = $original;

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

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

   163   }

   164 

   165   /**

   166    * Test drupal_http_build_query().

   167    */

   168   function testDrupalHttpBuildQuery() {

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

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

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

   172     $this->assertEqual(drupal_http_build_query(array('a' => array('b' => '2', 'c' => '3'), 'd' => 'foo')), 'a%5Bb%5D=2&a%5Bc%5D=3&d=foo', 'Nested array was properly encoded.');

   173   }

   174 

   175   /**

   176    * Test drupal_parse_url().

   177    */

   178   function testDrupalParseUrl() {

   179     // Relative URL.

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

   181     $result = array(

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

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

   184       'fragment' => 'foo',

   185     );

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

   187 

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

   189     $url = 'foo/bar:1';

   190     $result = array(

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

   192       'query' => array(),

   193       'fragment' => '',

   194     );

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

   196 

   197     // Absolute URL.

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

   199     $result = array(

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

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

   202       'fragment' => 'foo',

   203     );

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

   205 

   206     // External URL testing.

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

   208 

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

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

   211 

   212     // External URL without an explicit protocol.

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

   214     $this->assertTrue(url_is_external($url), 'Correctly identified an external URL without a protocol part.');

   215 

   216     // Internal URL starting with a slash.

   217     $url = '/drupal.org';

   218     $this->assertFalse(url_is_external($url), 'Correctly identified an internal URL with a leading slash.');

   219 

   220     // Test the parsing of absolute URLs.

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

   222     $result = array(

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

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

   225       'fragment' => 'foo',

   226     );

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

   228 

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

   230     $result = array(

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

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

   233       'fragment' => 'foo',

   234     );

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

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

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

   238 

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

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

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

   242 

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

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

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

   246 

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

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

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

   250   }

   251 

   252   /**

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

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

   255    */

   256   function testUrl() {

   257     global $base_url;

   258 

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

   260       // Get the expected start of the path string.

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

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

   263 

   264       // Disable Clean URLs.

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

   266 

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

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

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

   270 

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

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

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

   274 

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

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

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

   278 

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

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

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

   282 

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

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

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

   286 

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

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

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

   290 

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

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

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

   294 

   295       $url = $base;

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

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

   298 

   299       // Enable Clean URLs.

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

   301 

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

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

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

   305 

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

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

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

   309 

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

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

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

   313 

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

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

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

   317 

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

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

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

   321 

   322       $url = $base;

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

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

   325     }

   326   }

   327 

   328   /**

   329    * Test external URL handling.

   330    */

   331   function testExternalUrls() {

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

   333 

   334     // Verify external URL can contain a fragment.

   335     $url = $test_url . '#drupal';

   336     $result = url($url);

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

   338 

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

   340     $url = $test_url . '#drupal';

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

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

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

   344 

   345     // Verify external URL can contain a query string.

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

   347     $result = url($url);

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

   349 

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

   351     $url = $test_url;

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

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

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

   355 

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

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

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

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

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

   361 

   362     // Verify that an internal URL does not result in an external URL without

   363     // protocol part.

   364     $url = '/drupal.org';

   365     $result = url($url);

   366     $this->assertTrue(strpos($result, '//') === FALSE, 'Internal URL does not turn into an external URL.');

   367 

   368     // Verify that an external URL without protocol part is recognized as such.

   369     $url = '//drupal.org';

   370     $result = url($url);

   371     $this->assertEqual($url, $result, 'External URL without protocol is not altered.');

   372   }

   373 }

   374 

   375 /**

   376  * Tests url_is_external().

   377  */

   378 class UrlIsExternalUnitTest extends DrupalUnitTestCase {

   379 

   380   public static function getInfo() {

   381     return array(

   382       'name' => 'External URL checking',

   383       'description' => 'Performs tests on url_is_external().',

   384       'group' => 'System',

   385     );

   386   }

   387 

   388   /**

   389    * Tests if each URL is external or not.

   390    */

   391   function testUrlIsExternal() {

   392     foreach ($this->examples() as $path => $expected) {

   393       $this->assertIdentical(url_is_external($path), $expected, $path);

   394     }

   395   }

   396 

   397   /**

   398    * Provides data for testUrlIsExternal().

   399    *

   400    * @return array

   401    *   An array of test data, keyed by a path, with the expected value where

   402    *   TRUE is external, and FALSE is not external.

   403    */

   404   protected function examples() {

   405     return array(

   406       // Simple external URLs.

   407       'http://example.com' => TRUE,

   408       'https://example.com' => TRUE,

   409       'http://drupal.org/foo/bar?foo=bar&bar=baz&baz#foo' => TRUE,

   410       '//drupal.org' => TRUE,

   411       // Some browsers ignore or strip leading control characters.

   412       "\x00//www.example.com" => TRUE,

   413       "\x08//www.example.com" => TRUE,

   414       "\x1F//www.example.com" => TRUE,

   415       "\n//www.example.com" => TRUE,

   416       // JSON supports decoding directly from UTF-8 code points.

   417       json_decode('"\u00AD"') . "//www.example.com" => TRUE,

   418       json_decode('"\u200E"') . "//www.example.com" => TRUE,

   419       json_decode('"\uE0020"') . "//www.example.com" => TRUE,

   420       json_decode('"\uE000"')  . "//www.example.com" => TRUE,

   421       // Backslashes should be normalized to forward.

   422       '\\\\example.com' => TRUE,

   423       // Local URLs.

   424       'node' => FALSE,

   425       '/system/ajax' => FALSE,

   426       '?q=foo:bar' => FALSE,

   427       'node/edit:me' => FALSE,

   428       '/drupal.org' => FALSE,

   429       '<front>' => FALSE,

   430     );

   431   }

   432 }

   433 

   434 /**

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

   436  */

   437 class CommonXssUnitTest extends DrupalUnitTestCase {

   438 

   439   public static function getInfo() {

   440     return array(

   441       'name' => 'String filtering tests',

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

   443       'group' => 'System',

   444     );

   445   }

   446 

   447   /**

   448    * Check that invalid multi-byte sequences are rejected.

   449    */

   450   function testInvalidMultiByte() {

   451      // Ignore PHP 5.3+ invalid multibyte sequence warning.

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

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

   454      // Ignore PHP 5.3+ invalid multibyte sequence warning.

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

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

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

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

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

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

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

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

   463   }

   464 

   465   /**

   466    * Check that special characters are escaped.

   467    */

   468   function testEscaping() {

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

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

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

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

   473   }

   474 

   475   /**

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

   477    */

   478   function testFormatStringAndT() {

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

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

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

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

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

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

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

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

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

   488     }

   489   }

   490 

   491   /**

   492    * Check that harmful protocols are stripped.

   493    */

   494   function testBadProtocolStripping() {

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

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

   497     // plain-text string stripped of harmful protocols.

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

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

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

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

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

   503   }

   504 }

   505 

   506 /**

   507  * Tests file size parsing and formatting functions.

   508  */

   509 class CommonSizeTestCase extends DrupalUnitTestCase {

   510   protected $exact_test_cases;

   511   protected $rounded_test_cases;

   512 

   513   public static function getInfo() {

   514     return array(

   515       'name' => 'Size parsing test',

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

   517       'group' => 'System'

   518     );

   519   }

   520 

   521   function setUp() {

   522     $kb = DRUPAL_KILOBYTE;

   523     $this->exact_test_cases = array(

   524       '1 byte' => 1,

   525       '1 KB'   => $kb,

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

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

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

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

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

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

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

   533     );

   534     $this->rounded_test_cases = array(

   535       '2 bytes' => 2,

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

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

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

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

   540     );

   541     parent::setUp();

   542   }

   543 

   544   /**

   545    * Check that format_size() returns the expected string.

   546    */

   547   function testCommonFormatSize() {

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

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

   550         $this->assertEqual(

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

   552           $expected,

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

   554         );

   555       }

   556     }

   557   }

   558 

   559   /**

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

   561    */

   562   function testCommonParseSize() {

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

   564       $this->assertEqual(

   565         $parsed_size = parse_size($string),

   566         $size,

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

   568       );

   569     }

   570 

   571     // Some custom parsing tests

   572     $string = '23476892 bytes';

   573     $this->assertEqual(

   574       ($parsed_size = parse_size($string)),

   575       $size = 23476892,

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

   577     );

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

   579     $this->assertEqual(

   580       $parsed_size = parse_size($string),

   581       $size = 79691776,

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

   583     );

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

   585     $this->assertEqual(

   586       $parsed_size = parse_size($string),

   587       $size = 81862076662,

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

   589     );

   590   }

   591 

   592   /**

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

   594    */

   595   function testCommonParseSizeFormatSize() {

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

   597       $this->assertEqual(

   598         $size,

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

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

   601       );

   602     }

   603   }

   604 }

   605 

   606 /**

   607  * Test drupal_explode_tags() and drupal_implode_tags().

   608  */

   609 class DrupalTagsHandlingTestCase extends DrupalUnitTestCase {

   610   var $validTags = array(

   611     'Drupal' => 'Drupal',

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

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

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

   615   );

   616 

   617   public static function getInfo() {

   618     return array(

   619       'name' => 'Drupal tags handling',

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

   621       'group' => 'System'

   622     );

   623   }

   624 

   625   /**

   626    * Explode a series of tags.

   627    */

   628   function testDrupalExplodeTags() {

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

   630     $tags = drupal_explode_tags($string);

   631     $this->assertTags($tags);

   632   }

   633 

   634   /**

   635    * Implode a series of tags.

   636    */

   637   function testDrupalImplodeTags() {

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

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

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

   641       $string = drupal_implode_tags($tags);

   642       $tags = drupal_explode_tags($string);

   643     }

   644     $this->assertTags($tags);

   645   }

   646 

   647   /**

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

   649    */

   650   function assertTags($tags) {

   651     $original = $this->validTags;

   652     foreach ($tags as $tag) {

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

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

   655       unset($original[$key]);

   656     }

   657     foreach ($original as $leftover) {

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

   659     }

   660   }

   661 }

   662 

   663 /**

   664  * Test the Drupal CSS system.

   665  */

   666 class CascadingStylesheetsTestCase extends DrupalWebTestCase {

   667   public static function getInfo() {

   668     return array(

   669       'name' => 'Cascading stylesheets',

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

   671       'group' => 'System',

   672     );

   673   }

   674 

   675   function setUp() {

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

   677     // Reset drupal_add_css() before each test.

   678     drupal_static_reset('drupal_add_css');

   679   }

   680 

   681   /**

   682    * Check default stylesheets as empty.

   683    */

   684   function testDefault() {

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

   686   }

   687 

   688   /**

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

   690    */

   691   function testModuleInfo() {

   692     $this->drupalGet('');

   693 

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

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

   696       ':media' => 'all',

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

   698     ));

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

   700 

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

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

   703       ':media' => 'print',

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

   705     ));

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

   707   }

   708 

   709   /**

   710    * Tests adding a file stylesheet.

   711    */

   712   function testAddFile() {

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

   714     $css = drupal_add_css($path);

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

   716   }

   717 

   718   /**

   719    * Tests adding an external stylesheet.

   720    */

   721   function testAddExternal() {

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

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

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

   725   }

   726 

   727   /**

   728    * Makes sure that reseting the CSS empties the cache.

   729    */

   730   function testReset() {

   731     drupal_static_reset('drupal_add_css');

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

   733   }

   734 

   735   /**

   736    * Tests rendering the stylesheets.

   737    */

   738   function testRenderFile() {

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

   740     drupal_add_css($css);

   741     $styles = drupal_get_css();

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

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

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

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

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

   747   }

   748 

   749   /**

   750    * Tests rendering an external stylesheet.

   751    */

   752   function testRenderExternal() {

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

   754     drupal_add_css($css, 'external');

   755     $styles = drupal_get_css();

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

   757     // of a STYLE tag.

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

   759   }

   760 

   761   /**

   762    * Tests rendering inline stylesheets with preprocessing on.

   763    */

   764   function testRenderInlinePreprocess() {

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

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

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

   768     $styles = drupal_get_css();

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

   770   }

   771 

   772   /**

   773    * Tests removing charset when rendering stylesheets with preprocessing on.

   774    */

   775   function testRenderRemoveCharsetPreprocess() {

   776     $cases = array(

   777       array(

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

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

   780       ),

   781       // This asset contains extra \n character.

   782       array(

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

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

   785       ),

   786     );

   787 

   788     foreach ($cases as $case) {

   789       $this->assertEqual(

   790         $case['expected'],

   791         drupal_load_stylesheet_content($case['asset']),

   792         'CSS optimizing correctly removes the charset declaration.'

   793       );

   794     }

   795   }

   796 

   797   /**

   798    * Tests rendering inline stylesheets with preprocessing off.

   799    */

   800   function testRenderInlineNoPreprocess() {

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

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

   803     $styles = drupal_get_css();

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

   805   }

   806 

   807   /**

   808    * Tests rendering inline stylesheets through a full page request.

   809    */

   810   function testRenderInlineFullPage() {

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

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

   813     // drupal_add_css() option.

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

   815 

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

   817     $php_format_id = 'php_code';

   818     $settings = array(

   819       'type' => 'page',

   820       'body' => array(

   821         LANGUAGE_NONE => array(

   822           array(

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

   824             'format' => $php_format_id,

   825           ),

   826         ),

   827       ),

   828       'promote' => 1,

   829     );

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

   831 

   832     // Fetch the page.

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

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

   835   }

   836 

   837   /**

   838    * Test CSS ordering.

   839    */

   840   function testRenderOrder() {

   841     // A module CSS file.

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

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

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

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

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

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

   848 

   849     $expected = array(

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

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

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

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

   854     );

   855 

   856 

   857     $styles = drupal_get_css();

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

   859     // of a STYLE tag.

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

   861       $result = $matches[2];

   862     }

   863     else {

   864       $result = array();

   865     }

   866 

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

   868   }

   869 

   870   /**

   871    * Test CSS override.

   872    */

   873   function testRenderOverride() {

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

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

   876 

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

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

   879 

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

   881     $styles = drupal_get_css();

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

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

   884 

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

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

   887 

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

   889     $styles = drupal_get_css();

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

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

   892   }

   893 

   894   /**

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

   896    */

   897   function testAlter() {

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

   899     global $language;

   900     $language->direction = LANGUAGE_RTL;

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

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

   903 

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

   905     $styles = drupal_get_css();

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

   907 

   908     // Change the language back to left to right.

   909     $language->direction = LANGUAGE_LTR;

   910   }

   911 

   912   /**

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

   914    * query string parameters.

   915    */

   916   function testAddCssFileWithQueryString() {

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

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

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

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

   921   }

   922 }

   923 

   924 /**

   925  * Test for cleaning HTML identifiers.

   926  */

   927 class DrupalHTMLIdentifierTestCase extends DrupalUnitTestCase {

   928   public static function getInfo() {

   929     return array(

   930       'name' => 'HTML identifiers',

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

   932       'group' => 'System',

   933     );

   934   }

   935 

   936   /**

   937    * Tests that drupal_clean_css_identifier() cleans the identifier properly.

   938    */

   939   function testDrupalCleanCSSIdentifier() {

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

   941     $identifier = 'abcdefghijklmnopqrstuvwxyz_ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789';

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

   943 

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

   945     $identifier = '¡¢£¤¥';

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

   947 

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

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

   950 

   951     // Verify that double underscores are replaced in the identifier by default.

   952     $identifier = 'css__identifier__with__double__underscores';

   953     $expected = 'css--identifier--with--double--underscores';

   954     $this->assertIdentical(drupal_clean_css_identifier($identifier), $expected, 'Verify double underscores are replaced with double hyphens by default.');

   955 

   956     // Verify that double underscores are preserved in the identifier if the

   957     // variable allow_css_double_underscores is set to TRUE.

   958     $this->setAllowCSSDoubleUnderscores(TRUE);

   959     $this->assertIdentical(drupal_clean_css_identifier($identifier), $identifier, 'Verify double underscores are preserved if the allow_css_double_underscores set to TRUE.');

   960 

   961     // To avoid affecting other test cases, set the variable

   962     // allow_css_double_underscores to FALSE which is the default value.

   963     $this->setAllowCSSDoubleUnderscores(FALSE);

   964   }

   965 

   966   /**

   967    * Set the variable allow_css_double_underscores and reset the cache.

   968    *

   969    * @param $value bool

   970    *   A new value to be set to allow_css_double_underscores.

   971    */

   972   function setAllowCSSDoubleUnderscores($value) {

   973     $GLOBALS['conf']['allow_css_double_underscores'] = $value;

   974     drupal_static_reset('drupal_clean_css_identifier:allow_css_double_underscores');

   975   }

   976 

   977   /**

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

   979    */

   980   function testDrupalHTMLClass() {

   981     // Verify Drupal coding standards are enforced.

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

   983   }

   984 

   985   /**

   986    * Tests that drupal_html_id() cleans the ID properly.

   987    */

   988   function testDrupalHTMLId() {

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

   990     $id = 'abcdefghijklmnopqrstuvwxyz-0123456789';

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

   992 

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

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

   995 

   996     // Verify Drupal coding standards are enforced.

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

   998 

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

  1000     drupal_static_reset('drupal_html_id');

  1001 

  1002     // Clean up IDs with invalid starting characters.

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

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

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

  1006   }

  1007 }

  1008 

  1009 /**

  1010  * CSS Unit Tests.

  1011  */

  1012 class CascadingStylesheetsUnitTest extends DrupalUnitTestCase {

  1013   public static function getInfo() {

  1014     return array(

  1015       'name' => 'CSS Unit Tests',

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

  1017       'group' => 'System',

  1018     );

  1019   }

  1020 

  1021   /**

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

  1023    *

  1024    * Known tests:

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

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

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

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

  1029    * - Files imported from external URLs. (https://drupal.org/node/2014851)

  1030    */

  1031   function testLoadCssBasic() {

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

  1033     // - Original: name.css

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

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

  1036     $testfiles = array(

  1037       'css_input_without_import.css',

  1038       'css_input_with_import.css',

  1039       'css_subfolder/css_input_with_import.css',

  1040       'comment_hacks.css'

  1041     );

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

  1043     foreach ($testfiles as $file) {

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

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

  1046 

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

  1048       $unoptimized_output = drupal_load_stylesheet($file_path, FALSE);

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

  1050 

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

  1052       $optimized_output = drupal_load_stylesheet($file_path, TRUE);

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

  1054 

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

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

  1057       $unoptimized_output_url = drupal_load_stylesheet($file_url, FALSE);

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

  1059 

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

  1061       $optimized_output_url = drupal_load_stylesheet($file_url, TRUE);

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

  1063     }

  1064   }

  1065 }

  1066 

  1067 /**

  1068  * Test drupal_http_request().

  1069  */

  1070 class DrupalHTTPRequestTestCase extends DrupalWebTestCase {

  1071   public static function getInfo() {

  1072     return array(

  1073       'name' => 'Drupal HTTP request',

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

  1075       'group' => 'System'

  1076     );

  1077   }

  1078 

  1079   function setUp() {

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

  1081   }

  1082 

  1083   function testDrupalHTTPRequest() {

  1084     global $is_https;

  1085 

  1086     // Parse URL schema.

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

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

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

  1090 

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

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

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

  1094 

  1095     // Fetch page.

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

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

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

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

  1100 

  1101     // Test that code and status message is returned.

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

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

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

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

  1106 

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

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

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

  1110     if (!$is_https) {

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

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

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

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

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

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

  1117       timer_start(__METHOD__);

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

  1119       $time = timer_read(__METHOD__) / 1000;

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

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

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

  1123     }

  1124   }

  1125 

  1126   function testDrupalHTTPRequestBasicAuth() {

  1127     $username = $this->randomName();

  1128     $password = $this->randomName();

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

  1130 

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

  1132     $result = drupal_http_request($auth);

  1133 

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

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