corpus_parole: comparison cms/drupal/modules/system/system.test

equal deleted inserted replaced

-:07239de796bb
+:e756a8c72c3d
+<?php
+/**
+* @file
+* Tests for system.module.
+*/
+/**
+* Helper class for module test cases.
+*/
+class ModuleTestCase extends DrupalWebTestCase {
+protected $admin_user;
+function setUp() {
+parent::setUp('system_test');
+$this->admin_user = $this->drupalCreateUser(array('access administration pages', 'administer modules'));
+$this->drupalLogin($this->admin_user);
+}
+/**
+* Assert there are tables that begin with the specified base table name.
+*
+* @param $base_table
+*   Beginning of table name to look for.
+* @param $count
+*   (optional) Whether or not to assert that there are tables that match the
+*   specified base table. Defaults to TRUE.
+*/
+function assertTableCount($base_table, $count = TRUE) {
+$tables = db_find_tables(Database::getConnection()->prefixTables('{' . $base_table . '}') . '%');
+if ($count) {
+return $this->assertTrue($tables, format_string('Tables matching "@base_table" found.', array('@base_table' => $base_table)));
+}
+return $this->assertFalse($tables, format_string('Tables matching "@base_table" not found.', array('@base_table' => $base_table)));
+}
+/**
+* Assert that all tables defined in a module's hook_schema() exist.
+*
+* @param $module
+*   The name of the module.
+*/
+function assertModuleTablesExist($module) {
+$tables = array_keys(drupal_get_schema_unprocessed($module));
+$tables_exist = TRUE;
+foreach ($tables as $table) {
+if (!db_table_exists($table)) {
+$tables_exist = FALSE;
+}
+}
+return $this->assertTrue($tables_exist, format_string('All database tables defined by the @module module exist.', array('@module' => $module)));
+}
+/**
+* Assert that none of the tables defined in a module's hook_schema() exist.
+*
+* @param $module
+*   The name of the module.
+*/
+function assertModuleTablesDoNotExist($module) {
+$tables = array_keys(drupal_get_schema_unprocessed($module));
+$tables_exist = FALSE;
+foreach ($tables as $table) {
+if (db_table_exists($table)) {
+$tables_exist = TRUE;
+}
+}
+return $this->assertFalse($tables_exist, format_string('None of the database tables defined by the @module module exist.', array('@module' => $module)));
+}
+/**
+* Assert the list of modules are enabled or disabled.
+*
+* @param $modules
+*   Module list to check.
+* @param $enabled
+*   Expected module state.
+*/
+function assertModules(array $modules, $enabled) {
+module_list(TRUE);
+foreach ($modules as $module) {
+if ($enabled) {
+$message = 'Module "@module" is enabled.';
+}
+else {
+$message = 'Module "@module" is not enabled.';
+}
+$this->assertEqual(module_exists($module), $enabled, format_string($message, array('@module' => $module)));
+}
+}
+/**
+* Verify a log entry was entered for a module's status change.
+* Called in the same way of the expected original watchdog() execution.
+*
+* @param $type
+*   The category to which this message belongs.
+* @param $message
+*   The message to store in the log. Keep $message translatable
+*   by not concatenating dynamic values into it! Variables in the
+*   message should be added by using placeholder strings alongside
+*   the variables argument to declare the value of the placeholders.
+*   See t() for documentation on how $message and $variables interact.
+* @param $variables
+*   Array of variables to replace in the message on display or
+*   NULL if message is already translated or not possible to
+*   translate.
+* @param $severity
+*   The severity of the message, as per RFC 3164.
+* @param $link
+*   A link to associate with the message.
+*/
+function assertLogMessage($type, $message, $variables = array(), $severity = WATCHDOG_NOTICE, $link = '') {
+$count = db_select('watchdog', 'w')
+->condition('type', $type)
+->condition('message', $message)
+->condition('variables', serialize($variables))
+->condition('severity', $severity)
+->condition('link', $link)
+->countQuery()
+->execute()
+->fetchField();
+$this->assertTrue($count > 0, format_string('watchdog table contains @count rows for @message', array('@count' => $count, '@message' => $message)));
+}
+}
+/**
+* Test module enabling/disabling functionality.
+*/
+class EnableDisableTestCase extends ModuleTestCase {
+protected $profile = 'testing';
+public static function getInfo() {
+return array(
+'name' => 'Enable/disable modules',
+'description' => 'Enable/disable core module and confirm table creation/deletion.',
+'group' => 'Module',
+);
+}
+/**
+* Test that all core modules can be enabled, disabled and uninstalled.
+*/
+function testEnableDisable() {
+// Try to enable, disable and uninstall all core modules, unless they are
+// hidden or required.
+$modules = system_rebuild_module_data();
+foreach ($modules as $name => $module) {
+if ($module->info['package'] != 'Core' || !empty($module->info['hidden']) || !empty($module->info['required'])) {
+unset($modules[$name]);
+}
+}
+$this->assertTrue(count($modules), format_string('Found @count core modules that we can try to enable in this test.', array('@count' => count($modules))));
+// Enable the dblog module first, since we will be asserting the presence
+// of log messages throughout the test.
+if (isset($modules['dblog'])) {
+$modules = array('dblog' => $modules['dblog']) + $modules;
+}
+// Set a variable so that the hook implementations in system_test.module
+// will display messages via drupal_set_message().
+variable_set('test_verbose_module_hooks', TRUE);
+// Throughout this test, some modules may be automatically enabled (due to
+// dependencies). We'll keep track of them in an array, so we can handle
+// them separately.
+$automatically_enabled = array();
+// Go through each module in the list and try to enable it (unless it was
+// already enabled automatically due to a dependency).
+foreach ($modules as $name => $module) {
+if (empty($automatically_enabled[$name])) {
+// Start a list of modules that we expect to be enabled this time.
+$modules_to_enable = array($name);
+// Find out if the module has any dependencies that aren't enabled yet;
+// if so, add them to the list of modules we expect to be automatically
+// enabled.
+foreach (array_keys($module->requires) as $dependency) {
+if (isset($modules[$dependency]) && empty($automatically_enabled[$dependency])) {
+$modules_to_enable[] = $dependency;
+$automatically_enabled[$dependency] = TRUE;
+}
+}
+// Check that each module is not yet enabled and does not have any
+// database tables yet.
+foreach ($modules_to_enable as $module_to_enable) {
+$this->assertModules(array($module_to_enable), FALSE);
+$this->assertModuleTablesDoNotExist($module_to_enable);
+}
+// Install and enable the module.
+$edit = array();
+$edit['modules[Core][' . $name . '][enable]'] = $name;
+$this->drupalPost('admin/modules', $edit, t('Save configuration'));
+// Handle the case where modules were installed along with this one and
+// where we therefore hit a confirmation screen.
+if (count($modules_to_enable) > 1) {
+$this->drupalPost(NULL, array(), t('Continue'));
+}
+$this->assertText(t('The configuration options have been saved.'), 'Modules status has been updated.');
+// Check that hook_modules_installed() and hook_modules_enabled() were
+// invoked with the expected list of modules, that each module's
+// database tables now exist, and that appropriate messages appear in
+// the logs.
+foreach ($modules_to_enable as $module_to_enable) {
+$this->assertText(t('hook_modules_installed fired for @module', array('@module' => $module_to_enable)));
+$this->assertText(t('hook_modules_enabled fired for @module', array('@module' => $module_to_enable)));
+$this->assertModules(array($module_to_enable), TRUE);
+$this->assertModuleTablesExist($module_to_enable);
+$this->assertLogMessage('system', "%module module installed.", array('%module' => $module_to_enable), WATCHDOG_INFO);
+$this->assertLogMessage('system', "%module module enabled.", array('%module' => $module_to_enable), WATCHDOG_INFO);
+}
+// Disable and uninstall the original module, and check appropriate
+// hooks, tables, and log messages. (Later, we'll go back and do the
+// same thing for modules that were enabled automatically.) Skip this
+// for the dblog module, because that is needed for the test; we'll go
+// back and do that one at the end also.
+if ($name != 'dblog') {
+$this->assertSuccessfulDisableAndUninstall($name);
+}
+}
+}
+// Go through all modules that were automatically enabled, and try to
+// disable and uninstall them one by one.
+while (!empty($automatically_enabled)) {
+$initial_count = count($automatically_enabled);
+foreach (array_keys($automatically_enabled) as $name) {
+// If the module can't be disabled due to dependencies, skip it and try
+// again the next time. Otherwise, try to disable it.
+$this->drupalGet('admin/modules');
+$disabled_checkbox = $this->xpath('//input[@type="checkbox" and @disabled="disabled" and @name="modules[Core][' . $name . '][enable]"]');
+if (empty($disabled_checkbox) && $name != 'dblog') {
+unset($automatically_enabled[$name]);
+$this->assertSuccessfulDisableAndUninstall($name);
+}
+}
+$final_count = count($automatically_enabled);
+// If all checkboxes were disabled, something is really wrong with the
+// test. Throw a failure and avoid an infinite loop.
+if ($initial_count == $final_count) {
+$this->fail(t('Remaining modules could not be disabled.'));
+break;
+}
+}
+// Disable and uninstall the dblog module last, since we needed it for
+// assertions in all the above tests.
+if (isset($modules['dblog'])) {
+$this->assertSuccessfulDisableAndUninstall('dblog');
+}
+// Now that all modules have been tested, go back and try to enable them
+// all again at once. This tests two things:
+// - That each module can be successfully enabled again after being
+//   uninstalled.
+// - That enabling more than one module at the same time does not lead to
+//   any errors.
+$edit = array();
+foreach (array_keys($modules) as $name) {
+$edit['modules[Core][' . $name . '][enable]'] = $name;
+}
+$this->drupalPost('admin/modules', $edit, t('Save configuration'));
+$this->assertText(t('The configuration options have been saved.'), 'Modules status has been updated.');
+}
+/**
+* Ensures entity info cache is updated after changes.
+*/
+function testEntityInfoChanges() {
+module_enable(array('entity_cache_test'));
+$entity_info = entity_get_info();
+$this->assertTrue(isset($entity_info['entity_cache_test']), 'Test entity type found.');
+// Change the label of the test entity type and make sure changes appear
+// after flushing caches.
+variable_set('entity_cache_test_label', 'New label.');
+drupal_flush_all_caches();
+$info = entity_get_info('entity_cache_test');
+$this->assertEqual($info['label'], 'New label.', 'New label appears in entity info.');
+// Disable the providing module and make sure the entity type is gone.
+module_disable(array('entity_cache_test', 'entity_cache_test_dependency'));
+$entity_info = entity_get_info();
+$this->assertFalse(isset($entity_info['entity_cache_test']), 'Entity type of the providing module is gone.');
+}
+/**
+* Tests entity info cache after enabling a module with a dependency on an entity providing module.
+*
+* @see entity_cache_test_watchdog()
+*/
+function testEntityInfoCacheWatchdog() {
+module_enable(array('entity_cache_test'));
+$info = variable_get('entity_cache_test');
+$this->assertEqual($info['label'], 'Entity Cache Test', 'Entity info label is correct.');
+$this->assertEqual($info['controller class'], 'DrupalDefaultEntityController', 'Entity controller class info is correct.');
+}
+/**
+* Disables and uninstalls a module and asserts that it was done correctly.
+*
+* @param $module
+*   The name of the module to disable and uninstall.
+*/
+function assertSuccessfulDisableAndUninstall($module) {
+// Disable the module.
+$edit = array();
+$edit['modules[Core][' . $module . '][enable]'] = FALSE;
+$this->drupalPost('admin/modules', $edit, t('Save configuration'));
+$this->assertText(t('The configuration options have been saved.'), 'Modules status has been updated.');
+$this->assertModules(array($module), FALSE);
+// Check that the appropriate hook was fired and the appropriate log
+// message appears.
+$this->assertText(t('hook_modules_disabled fired for @module', array('@module' => $module)));
+$this->assertLogMessage('system', "%module module disabled.", array('%module' => $module), WATCHDOG_INFO);
+//  Check that the module's database tables still exist.
+$this->assertModuleTablesExist($module);
+// Uninstall the module.
+$edit = array();
+$edit['uninstall[' . $module . ']'] = $module;
+$this->drupalPost('admin/modules/uninstall', $edit, t('Uninstall'));
+$this->drupalPost(NULL, NULL, t('Uninstall'));
+$this->assertText(t('The selected modules have been uninstalled.'), 'Modules status has been updated.');
+$this->assertModules(array($module), FALSE);
+// Check that the appropriate hook was fired and the appropriate log
+// message appears. (But don't check for the log message if the dblog
+// module was just uninstalled, since the {watchdog} table won't be there
+// anymore.)
+$this->assertText(t('hook_modules_uninstalled fired for @module', array('@module' => $module)));
+if ($module != 'dblog') {
+$this->assertLogMessage('system', "%module module uninstalled.", array('%module' => $module), WATCHDOG_INFO);
+}
+// Check that the module's database tables no longer exist.
+$this->assertModuleTablesDoNotExist($module);
+}
+}
+/**
+* Tests failure of hook_requirements('install').
+*/
+class HookRequirementsTestCase extends ModuleTestCase {
+public static function getInfo() {
+return array(
+'name' => 'Requirements hook failure',
+'description' => "Attempts enabling a module that fails hook_requirements('install').",
+'group' => 'Module',
+);
+}
+/**
+* Assert that a module cannot be installed if it fails hook_requirements().
+*/
+function testHookRequirementsFailure() {
+$this->assertModules(array('requirements1_test'), FALSE);
+// Attempt to install the requirements1_test module.
+$edit = array();
+$edit['modules[Testing][requirements1_test][enable]'] = 'requirements1_test';
+$this->drupalPost('admin/modules', $edit, t('Save configuration'));
+// Makes sure the module was NOT installed.
+$this->assertText(t('Requirements 1 Test failed requirements'), 'Modules status has been updated.');
+$this->assertModules(array('requirements1_test'), FALSE);
+}
+}
+/**
+* Test module dependency functionality.
+*/
+class ModuleDependencyTestCase extends ModuleTestCase {
+public static function getInfo() {
+return array(
+'name' => 'Module dependencies',
+'description' => 'Enable module without dependency enabled.',
+'group' => 'Module',
+);
+}
+/**
+* Checks functionality of project namespaces for dependencies.
+*/
+function testProjectNamespaceForDependencies() {
+// Enable module with project namespace to ensure nothing breaks.
+$edit = array(
+'modules[Testing][system_project_namespace_test][enable]' => TRUE,
+);
+$this->drupalPost('admin/modules', $edit, t('Save configuration'));
+$this->assertModules(array('system_project_namespace_test'), TRUE);
+}
+/**
+* Attempt to enable translation module without locale enabled.
+*/
+function testEnableWithoutDependency() {
+// Attempt to enable content translation without locale enabled.
+$edit = array();
+$edit['modules[Core][translation][enable]'] = 'translation';
+$this->drupalPost('admin/modules', $edit, t('Save configuration'));
+$this->assertText(t('Some required modules must be enabled'), 'Dependency required.');
+$this->assertModules(array('translation', 'locale'), FALSE);
+// Assert that the locale tables weren't enabled.
+$this->assertTableCount('languages', FALSE);
+$this->assertTableCount('locale', FALSE);
+$this->drupalPost(NULL, NULL, t('Continue'));
+$this->assertText(t('The configuration options have been saved.'), 'Modules status has been updated.');
+$this->assertModules(array('translation', 'locale'), TRUE);
+// Assert that the locale tables were enabled.
+$this->assertTableCount('languages', TRUE);
+$this->assertTableCount('locale', TRUE);
+}
+/**
+* Attempt to enable a module with a missing dependency.
+*/
+function testMissingModules() {
+// Test that the system_dependencies_test module is marked
+// as missing a dependency.
+$this->drupalGet('admin/modules');
+$this->assertRaw(t('@module (<span class="admin-missing">missing</span>)', array('@module' => drupal_ucfirst('_missing_dependency'))), 'A module with missing dependencies is marked as such.');
+$checkbox = $this->xpath('//input[@type="checkbox" and @disabled="disabled" and @name="modules[Testing][system_dependencies_test][enable]"]');
+$this->assert(count($checkbox) == 1, 'Checkbox for the module is disabled.');
+// Force enable the system_dependencies_test module.
+module_enable(array('system_dependencies_test'), FALSE);
+// Verify that the module is forced to be disabled when submitting
+// the module page.
+$this->drupalPost('admin/modules', array(), t('Save configuration'));
+$this->assertText(t('The @module module is missing, so the following module will be disabled: @depends.', array('@module' => '_missing_dependency', '@depends' => 'system_dependencies_test')), 'The module missing dependencies will be disabled.');
+// Confirm.
+$this->drupalPost(NULL, NULL, t('Continue'));
+// Verify that the module has been disabled.
+$this->assertModules(array('system_dependencies_test'), FALSE);
+}
+/**
+* Tests enabling a module that depends on an incompatible version of a module.
+*/
+function testIncompatibleModuleVersionDependency() {
+// Test that the system_incompatible_module_version_dependencies_test is
+// marked as having an incompatible dependency.
+$this->drupalGet('admin/modules');
+$this->assertRaw(t('@module (<span class="admin-missing">incompatible with</span> version @version)', array(
+'@module' => 'System incompatible module version test (>2.0)',
+'@version' => '1.0',
+)), 'A module that depends on an incompatible version of a module is marked as such.');
+$checkbox = $this->xpath('//input[@type="checkbox" and @disabled="disabled" and @name="modules[Testing][system_incompatible_module_version_dependencies_test][enable]"]');
+$this->assert(count($checkbox) == 1, 'Checkbox for the module is disabled.');
+}
+/**
+* Tests enabling a module that depends on a module with an incompatible core version.
+*/
+function testIncompatibleCoreVersionDependency() {
+// Test that the system_incompatible_core_version_dependencies_test is
+// marked as having an incompatible dependency.
+$this->drupalGet('admin/modules');
+$this->assertRaw(t('@module (<span class="admin-missing">incompatible with</span> this version of Drupal core)', array(
+'@module' => 'System incompatible core version test',
+)), 'A module that depends on a module with an incompatible core version is marked as such.');
+$checkbox = $this->xpath('//input[@type="checkbox" and @disabled="disabled" and @name="modules[Testing][system_incompatible_core_version_dependencies_test][enable]"]');
+$this->assert(count($checkbox) == 1, 'Checkbox for the module is disabled.');
+}
+/**
+* Tests enabling a module that depends on a module which fails hook_requirements().
+*/
+function testEnableRequirementsFailureDependency() {
+$this->assertModules(array('requirements1_test'), FALSE);
+$this->assertModules(array('requirements2_test'), FALSE);
+// Attempt to install both modules at the same time.
+$edit = array();
+$edit['modules[Testing][requirements1_test][enable]'] = 'requirements1_test';
+$edit['modules[Testing][requirements2_test][enable]'] = 'requirements2_test';
+$this->drupalPost('admin/modules', $edit, t('Save configuration'));
+// Makes sure the modules were NOT installed.
+$this->assertText(t('Requirements 1 Test failed requirements'), 'Modules status has been updated.');
+$this->assertModules(array('requirements1_test'), FALSE);
+$this->assertModules(array('requirements2_test'), FALSE);
+// Makes sure that already enabled modules the failing modules depend on
+// were not disabled.
+$this->assertModules(array('comment'), TRUE);
+}
+/**
+* Tests that module dependencies are enabled in the correct order via the
+* UI. Dependencies should be enabled before their dependents.
+*/
+function testModuleEnableOrder() {
+module_enable(array('module_test'), FALSE);
+$this->resetAll();
+$this->assertModules(array('module_test'), TRUE);
+variable_set('dependency_test', 'dependency');
+// module_test creates a dependency chain: forum depends on poll, which
+// depends on php. The correct enable order is, php, poll, forum.
+$expected_order = array('php', 'poll', 'forum');
+// Enable the modules through the UI, verifying that the dependency chain
+// is correct.
+$edit = array();
+$edit['modules[Core][forum][enable]'] = 'forum';
+$this->drupalPost('admin/modules', $edit, t('Save configuration'));
+$this->assertModules(array('forum'), FALSE);
+$this->assertText(t('You must enable the Poll, PHP filter modules to install Forum.'), t('Dependency chain created.'));
+$edit['modules[Core][poll][enable]'] = 'poll';
+$edit['modules[Core][php][enable]'] = 'php';
+$this->drupalPost('admin/modules', $edit, t('Save configuration'));
+$this->assertModules(array('forum', 'poll', 'php'), TRUE);
+// Check the actual order which is saved by module_test_modules_enabled().
+$this->assertIdentical(variable_get('test_module_enable_order', FALSE), $expected_order, t('Modules enabled in the correct order.'));
+}
+/**
+* Tests attempting to uninstall a module that has installed dependents.
+*/
+function testUninstallDependents() {
+// Enable the forum module.
+$edit = array('modules[Core][forum][enable]' => 'forum');
+$this->drupalPost('admin/modules', $edit, t('Save configuration'));
+$this->assertModules(array('forum'), TRUE);
+// Disable forum and comment. Both should now be installed but disabled.
+$edit = array('modules[Core][forum][enable]' => FALSE);
+$this->drupalPost('admin/modules', $edit, t('Save configuration'));
+$this->assertModules(array('forum'), FALSE);
+$edit = array('modules[Core][comment][enable]' => FALSE);
+$this->drupalPost('admin/modules', $edit, t('Save configuration'));
+$this->assertModules(array('comment'), FALSE);
+// Check that the taxonomy module cannot be uninstalled.
+$this->drupalGet('admin/modules/uninstall');
+$checkbox = $this->xpath('//input[@type="checkbox" and @disabled="disabled" and @name="uninstall[comment]"]');
+$this->assert(count($checkbox) == 1, 'Checkbox for uninstalling the comment module is disabled.');
+// Uninstall the forum module, and check that taxonomy now can also be
+// uninstalled.
+$edit = array('uninstall[forum]' => 'forum');
+$this->drupalPost('admin/modules/uninstall', $edit, t('Uninstall'));
+$this->drupalPost(NULL, NULL, t('Uninstall'));
+$this->assertText(t('The selected modules have been uninstalled.'), 'Modules status has been updated.');
+$edit = array('uninstall[comment]' => 'comment');
+$this->drupalPost('admin/modules/uninstall', $edit, t('Uninstall'));
+$this->drupalPost(NULL, NULL, t('Uninstall'));
+$this->assertText(t('The selected modules have been uninstalled.'), 'Modules status has been updated.');
+}
+/**
+* Tests whether the correct module metadata is returned.
+*/
+function testModuleMetaData() {
+// Generate the list of available modules.
+$modules = system_rebuild_module_data();
+// Check that the mtime field exists for the system module.
+$this->assertTrue(!empty($modules['system']->info['mtime']), 'The system.info file modification time field is present.');
+// Use 0 if mtime isn't present, to avoid an array index notice.
+$test_mtime = !empty($modules['system']->info['mtime']) ? $modules['system']->info['mtime'] : 0;
+// Ensure the mtime field contains a number that is greater than zero.
+$this->assertTrue(is_numeric($test_mtime) && ($test_mtime > 0), 'The system.info file modification time field contains a timestamp.');
+}
+/**
+* Tests whether the correct theme metadata is returned.
+*/
+function testThemeMetaData() {
+// Generate the list of available themes.
+$themes = system_rebuild_theme_data();
+// Check that the mtime field exists for the bartik theme.
+$this->assertTrue(!empty($themes['bartik']->info['mtime']), 'The bartik.info file modification time field is present.');
+// Use 0 if mtime isn't present, to avoid an array index notice.
+$test_mtime = !empty($themes['bartik']->info['mtime']) ? $themes['bartik']->info['mtime'] : 0;
+// Ensure the mtime field contains a number that is greater than zero.
+$this->assertTrue(is_numeric($test_mtime) && ($test_mtime > 0), 'The bartik.info file modification time field contains a timestamp.');
+}
+}
+/**
+* Test module dependency on specific versions.
+*/
+class ModuleVersionTestCase extends ModuleTestCase {
+public static function getInfo() {
+return array(
+'name' => 'Module versions',
+'description' => 'Check module version dependencies.',
+'group' => 'Module',
+);
+}
+function setUp() {
+parent::setUp('module_test');
+}
+/**
+* Test version dependencies.
+*/
+function testModuleVersions() {
+$dependencies = array(
+// Alternating between being compatible and incompatible with 7.x-2.4-beta3.
+// The first is always a compatible.
+'common_test',
+// Branch incompatibility.
+'common_test (1.x)',
+// Branch compatibility.
+'common_test (2.x)',
+// Another branch incompatibility.
+'common_test (>2.x)',
+// Another branch compatibility.
+'common_test (<=2.x)',
+// Another branch incompatibility.
+'common_test (<2.x)',
+// Another branch compatibility.
+'common_test (>=2.x)',
+// Nonsense, misses a dash. Incompatible with everything.
+'common_test (=7.x2.x, >=2.4)',
+// Core version is optional. Compatible.
+'common_test (=7.x-2.x, >=2.4-alpha2)',
+// Test !=, explicitly incompatible.
+'common_test (=2.x, !=2.4-beta3)',
+// Three operations. Compatible.
+'common_test (=2.x, !=2.3, <2.5)',
+// Testing extra version. Incompatible.
+'common_test (<=2.4-beta2)',
+// Testing extra version. Compatible.
+'common_test (>2.4-beta2)',
+// Testing extra version. Incompatible.
+'common_test (>2.4-rc0)',
+);
+variable_set('dependencies', $dependencies);
+$n = count($dependencies);
+for ($i = 0; $i < $n; $i++) {
+$this->drupalGet('admin/modules');
+$checkbox = $this->xpath('//input[@id="edit-modules-testing-module-test-enable"]');
+$this->assertEqual(!empty($checkbox[0]['disabled']), $i % 2, $dependencies[$i]);
+}
+}
+}
+/**
+* Test required modules functionality.
+*/
+class ModuleRequiredTestCase extends ModuleTestCase {
+public static function getInfo() {
+return array(
+'name' => 'Required modules',
+'description' => 'Attempt disabling of required modules.',
+'group' => 'Module',
+);
+}
+/**
+* Assert that core required modules cannot be disabled.
+*/
+function testDisableRequired() {
+$module_info = system_get_info('module');
+$this->drupalGet('admin/modules');
+foreach ($module_info as $module => $info) {
+// Check to make sure the checkbox for each required module is disabled
+// and checked (or absent from the page if the module is also hidden).
+if (!empty($info['required'])) {
+$field_name = "modules[{$info['package']}][$module][enable]";
+if (empty($info['hidden'])) {
+$this->assertFieldByXPath("//input[@name='$field_name' and @disabled='disabled' and @checked='checked']", '', format_string('Field @name was disabled and checked.', array('@name' => $field_name)));
+}
+else {
+$this->assertNoFieldByName($field_name);
+}
+}
+}
+}
+}
+class IPAddressBlockingTestCase extends DrupalWebTestCase {
+protected $blocking_user;
+/**
+* Implement getInfo().
+*/
+public static function getInfo() {
+return array(
+'name' => 'IP address blocking',
+'description' => 'Test IP address blocking.',
+'group' => 'System'
+);
+}
+/**
+* Implement setUp().
+*/
+function setUp() {
+parent::setUp();
+// Create user.
+$this->blocking_user = $this->drupalCreateUser(array('block IP addresses'));
+$this->drupalLogin($this->blocking_user);
+}
+/**
+* Test a variety of user input to confirm correct validation and saving of data.
+*/
+function testIPAddressValidation() {
+$this->drupalGet('admin/config/people/ip-blocking');
+// Block a valid IP address.
+$edit = array();
+$edit['ip'] = '1.2.3.3';
+$this->drupalPost('admin/config/people/ip-blocking', $edit, t('Add'));
+$ip = db_query("SELECT iid from {blocked_ips} WHERE ip = :ip", array(':ip' => $edit['ip']))->fetchField();
+$this->assertTrue($ip, t('IP address found in database.'));
+$this->assertRaw(t('The IP address %ip has been blocked.', array('%ip' => $edit['ip'])), t('IP address was blocked.'));
+// Try to block an IP address that's already blocked.
+$edit = array();
+$edit['ip'] = '1.2.3.3';
+$this->drupalPost('admin/config/people/ip-blocking', $edit, t('Add'));
+$this->assertText(t('This IP address is already blocked.'));
+// Try to block a reserved IP address.
+$edit = array();
+$edit['ip'] = '255.255.255.255';
+$this->drupalPost('admin/config/people/ip-blocking', $edit, t('Add'));
+$this->assertText(t('Enter a valid IP address.'));
+// Try to block a reserved IP address.
+$edit = array();
+$edit['ip'] = 'test.example.com';
+$this->drupalPost('admin/config/people/ip-blocking', $edit, t('Add'));
+$this->assertText(t('Enter a valid IP address.'));
+// Submit an empty form.
+$edit = array();
+$edit['ip'] = '';
+$this->drupalPost('admin/config/people/ip-blocking', $edit, t('Add'));
+$this->assertText(t('Enter a valid IP address.'));
+// Pass an IP address as a URL parameter and submit it.
+$submit_ip = '1.2.3.4';
+$this->drupalPost('admin/config/people/ip-blocking/' . $submit_ip, NULL, t('Add'));
+$ip = db_query("SELECT iid from {blocked_ips} WHERE ip = :ip", array(':ip' => $submit_ip))->fetchField();
+$this->assertTrue($ip, t('IP address found in database'));
+$this->assertRaw(t('The IP address %ip has been blocked.', array('%ip' => $submit_ip)), t('IP address was blocked.'));
+// Submit your own IP address. This fails, although it works when testing manually.
+// TODO: on some systems this test fails due to a bug or inconsistency in cURL.
+// $edit = array();
+// $edit['ip'] = ip_address();
+// $this->drupalPost('admin/config/people/ip-blocking', $edit, t('Save'));
+// $this->assertText(t('You may not block your own IP address.'));
+}
+/**
+* Test duplicate IP addresses are not present in the 'blocked_ips' table.
+*/
+function testDuplicateIpAddress() {
+drupal_static_reset('ip_address');
+$submit_ip = $_SERVER['REMOTE_ADDR'] = '192.168.1.1';
+system_block_ip_action();
+system_block_ip_action();
+$ip_count = db_query("SELECT iid from {blocked_ips} WHERE ip = :ip", array(':ip' => $submit_ip))->rowCount();
+$this->assertEqual('1', $ip_count);
+drupal_static_reset('ip_address');
+$submit_ip = $_SERVER['REMOTE_ADDR'] = ' ';
+system_block_ip_action();
+system_block_ip_action();
+system_block_ip_action();
+$ip_count = db_query("SELECT iid from {blocked_ips} WHERE ip = :ip", array(':ip' => $submit_ip))->rowCount();
+$this->assertEqual('1', $ip_count);
+}
+}
+class CronRunTestCase extends DrupalWebTestCase {
+/**
+* Implement getInfo().
+*/
+public static function getInfo() {
+return array(
+'name' => 'Cron run',
+'description' => 'Test cron run.',
+'group' => 'System'
+);
+}
+function setUp() {
+parent::setUp(array('common_test', 'common_test_cron_helper'));
+}
+/**
+* Test cron runs.
+*/
+function testCronRun() {
+global $base_url;
+// Run cron anonymously without any cron key.
+$this->drupalGet($base_url . '/cron.php', array('external' => TRUE));
+$this->assertResponse(403);
+// Run cron anonymously with a random cron key.
+$key = $this->randomName(16);
+$this->drupalGet($base_url . '/cron.php', array('external' => TRUE, 'query' => array('cron_key' => $key)));
+$this->assertResponse(403);
+// Run cron anonymously with the valid cron key.
+$key = variable_get('cron_key', 'drupal');
+$this->drupalGet($base_url . '/cron.php', array('external' => TRUE, 'query' => array('cron_key' => $key)));
+$this->assertResponse(200);
+}
+/**
+* Ensure that the automatic cron run feature is working.
+*
+* In these tests we do not use REQUEST_TIME to track start time, because we
+* need the exact time when cron is triggered.
+*/
+function testAutomaticCron() {
+// Ensure cron does not run when the cron threshold is enabled and was
+// not passed.
+$cron_last = time();
+$cron_safe_threshold = 100;
+variable_set('cron_last', $cron_last);
+variable_set('cron_safe_threshold', $cron_safe_threshold);
+$this->drupalGet('');
+$this->assertTrue($cron_last == variable_get('cron_last', NULL), 'Cron does not run when the cron threshold is not passed.');
+// Test if cron runs when the cron threshold was passed.
+$cron_last = time() - 200;
+variable_set('cron_last', $cron_last);
+$this->drupalGet('');
+sleep(1);
+$this->assertTrue($cron_last < variable_get('cron_last', NULL), 'Cron runs when the cron threshold is passed.');
+// Disable the cron threshold through the interface.
+$admin_user = $this->drupalCreateUser(array('administer site configuration'));
+$this->drupalLogin($admin_user);
+$this->drupalPost('admin/config/system/cron', array('cron_safe_threshold' => 0), t('Save configuration'));
+$this->assertText(t('The configuration options have been saved.'));
+$this->drupalLogout();
+// Test if cron does not run when the cron threshold is disabled.
+$cron_last = time() - 200;
+variable_set('cron_last', $cron_last);
+$this->drupalGet('');
+$this->assertTrue($cron_last == variable_get('cron_last', NULL), 'Cron does not run when the cron threshold is disabled.');
+}
+/**
+* Ensure that temporary files are removed.
+*
+* Create files for all the possible combinations of age and status. We are
+* using UPDATE statements rather than file_save() because it would set the
+* timestamp.
+*/
+function testTempFileCleanup() {
+// Temporary file that is older than DRUPAL_MAXIMUM_TEMP_FILE_AGE.
+$temp_old = file_save_data('');
+db_update('file_managed')
+->fields(array(
+'status' => 0,
+'timestamp' => 1,
+))
+->condition('fid', $temp_old->fid)
+->execute();
+$this->assertTrue(file_exists($temp_old->uri), 'Old temp file was created correctly.');
+// Temporary file that is less than DRUPAL_MAXIMUM_TEMP_FILE_AGE.
+$temp_new = file_save_data('');
+db_update('file_managed')
+->fields(array('status' => 0))
+->condition('fid', $temp_new->fid)
+->execute();
+$this->assertTrue(file_exists($temp_new->uri), 'New temp file was created correctly.');
+// Permanent file that is older than DRUPAL_MAXIMUM_TEMP_FILE_AGE.
+$perm_old = file_save_data('');
+db_update('file_managed')
+->fields(array('timestamp' => 1))
+->condition('fid', $temp_old->fid)
+->execute();
+$this->assertTrue(file_exists($perm_old->uri), 'Old permanent file was created correctly.');
+// Permanent file that is newer than DRUPAL_MAXIMUM_TEMP_FILE_AGE.
+$perm_new = file_save_data('');
+$this->assertTrue(file_exists($perm_new->uri), 'New permanent file was created correctly.');
+// Run cron and then ensure that only the old, temp file was deleted.
+$this->cronRun();
+$this->assertFalse(file_exists($temp_old->uri), 'Old temp file was correctly removed.');
+$this->assertTrue(file_exists($temp_new->uri), 'New temp file was correctly ignored.');
+$this->assertTrue(file_exists($perm_old->uri), 'Old permanent file was correctly ignored.');
+$this->assertTrue(file_exists($perm_new->uri), 'New permanent file was correctly ignored.');
+}
+/**
+* Make sure exceptions thrown on hook_cron() don't affect other modules.
+*/
+function testCronExceptions() {
+variable_del('common_test_cron');
+// The common_test module throws an exception. If it isn't caught, the tests
+// won't finish successfully.
+// The common_test_cron_helper module sets the 'common_test_cron' variable.
+$this->cronRun();
+$result = variable_get('common_test_cron');
+$this->assertEqual($result, 'success', 'Cron correctly handles exceptions thrown during hook_cron() invocations.');
+}
+/**
+* Tests that hook_flush_caches() is not invoked on every single cron run.
+*
+* @see system_cron()
+*/
+public function testCronCacheExpiration() {
+module_enable(array('system_cron_test'));
+variable_del('system_cron_test_flush_caches');
+// Invoke cron the first time: hook_flush_caches() should be called and then
+// get cached.
+drupal_cron_run();
+$this->assertEqual(variable_get('system_cron_test_flush_caches'), 1, 'hook_flush_caches() was invoked the first time.');
+$cache = cache_get('system_cache_tables');
+$this->assertEqual(empty($cache), FALSE, 'Cache is filled with cache table data.');
+// Run cron again and ensure that hook_flush_caches() is not called.
+variable_del('system_cron_test_flush_caches');
+drupal_cron_run();
+$this->assertNull(variable_get('system_cron_test_flush_caches'), 'hook_flush_caches() was not invoked the second time.');
+}
+}
+/**
+* Test execution of the cron queue.
+*/
+class CronQueueTestCase extends DrupalWebTestCase {
+/**
+* Implement getInfo().
+*/
+public static function getInfo() {
+return array(
+'name' => 'Cron queue functionality',
+'description' => 'Tests the cron queue runner.',
+'group' => 'System'
+);
+}
+function setUp() {
+parent::setUp(array('common_test', 'common_test_cron_helper', 'cron_queue_test'));
+}
+/**
+* Tests that exceptions thrown by workers are handled properly.
+*/
+function testExceptions() {
+$queue = DrupalQueue::get('cron_queue_test_exception');
+// Enqueue an item for processing.
+$queue->createItem(array($this->randomName() => $this->randomName()));
+// Run cron; the worker for this queue should throw an exception and handle
+// it.
+$this->cronRun();
+// The item should be left in the queue.
+$this->assertEqual($queue->numberOfItems(), 1, 'Failing item still in the queue after throwing an exception.');
+}
+/**
+* Tests worker defined as a class method callable.
+*/
+function testCallable() {
+$queue = DrupalQueue::get('cron_queue_test_callback');
+// Enqueue an item for processing.
+$queue->createItem(array($this->randomName() => $this->randomName()));
+// Run cron; the worker should perform the task and delete the item from the
+// queue.
+$this->cronRun();
+// The queue should be empty.
+$this->assertEqual($queue->numberOfItems(), 0);
+}
+}
+class AdminMetaTagTestCase extends DrupalWebTestCase {
+/**
+* Implement getInfo().
+*/
+public static function getInfo() {
+return array(
+'name' => 'Fingerprinting meta tag',
+'description' => 'Confirm that the fingerprinting meta tag appears as expected.',
+'group' => 'System'
+);
+}
+/**
+* Verify that the meta tag HTML is generated correctly.
+*/
+public function testMetaTag() {
+list($version, ) = explode('.', VERSION);
+$string = '<meta name="Generator" content="Drupal ' . $version . ' (http://drupal.org)" />';
+$this->drupalGet('node');
+$this->assertRaw($string, 'Fingerprinting meta tag generated correctly.', 'System');
+}
+}
+/**
+* Tests custom access denied functionality.
+*/
+class AccessDeniedTestCase extends DrupalWebTestCase {
+protected $admin_user;
+public static function getInfo() {
+return array(
+'name' => '403 functionality',
+'description' => 'Tests page access denied functionality, including custom 403 pages.',
+'group' => 'System'
+);
+}
+function setUp() {
+parent::setUp();
+// Create an administrative user.
+$this->admin_user = $this->drupalCreateUser(array('access administration pages', 'administer site configuration', 'administer blocks'));
+}
+function testAccessDenied() {
+$this->drupalGet('admin');
+$this->assertText(t('Access denied'), 'Found the default 403 page');
+$this->assertResponse(403);
+$this->drupalLogin($this->admin_user);
+$edit = array(
+'title' => $this->randomName(10),
+'body' => array(LANGUAGE_NONE => array(array('value' => $this->randomName(100)))),
+);
+$node = $this->drupalCreateNode($edit);
+// Use a custom 403 page.
+$this->drupalPost('admin/config/system/site-information', array('site_403' => 'node/' . $node->nid), t('Save configuration'));
+$this->drupalLogout();
+$this->drupalGet('admin');
+$this->assertText($node->title, 'Found the custom 403 page');
+// Logout and check that the user login block is shown on custom 403 pages.
+$this->drupalLogout();
+$this->drupalGet('admin');
+$this->assertText($node->title, 'Found the custom 403 page');
+$this->assertText(t('User login'), 'Blocks are shown on the custom 403 page');
+// Log back in and remove the custom 403 page.
+$this->drupalLogin($this->admin_user);
+$this->drupalPost('admin/config/system/site-information', array('site_403' => ''), t('Save configuration'));
+// Logout and check that the user login block is shown on default 403 pages.
+$this->drupalLogout();
+$this->drupalGet('admin');
+$this->assertText(t('Access denied'), 'Found the default 403 page');
+$this->assertResponse(403);
+$this->assertText(t('User login'), 'Blocks are shown on the default 403 page');
+// Log back in, set the custom 403 page to /user and remove the block
+$this->drupalLogin($this->admin_user);
+variable_set('site_403', 'user');
+$this->drupalPost('admin/structure/block', array('blocks[user_login][region]' => '-1'), t('Save blocks'));
+// Check that we can log in from the 403 page.
+$this->drupalLogout();
+$edit = array(
+'name' => $this->admin_user->name,
+'pass' => $this->admin_user->pass_raw,
+);
+$this->drupalPost('admin/config/system/site-information', $edit, t('Log in'));
+// Check that we're still on the same page.
+$this->assertText(t('Site information'));
+}
+}
+class PageNotFoundTestCase extends DrupalWebTestCase {
+protected $admin_user;
+/**
+* Implement getInfo().
+*/
+public static function getInfo() {
+return array(
+'name' => '404 functionality',
+'description' => "Tests page not found functionality, including custom 404 pages.",
+'group' => 'System'
+);
+}
+/**
+* Implement setUp().
+*/
+function setUp() {
+parent::setUp();
+// Create an administrative user.
+$this->admin_user = $this->drupalCreateUser(array('administer site configuration'));
+$this->drupalLogin($this->admin_user);
+}
+function testPageNotFound() {
+$this->drupalGet($this->randomName(10));
+$this->assertText(t('Page not found'), 'Found the default 404 page');
+$edit = array(
+'title' => $this->randomName(10),
+'body' => array(LANGUAGE_NONE => array(array('value' => $this->randomName(100)))),
+);
+$node = $this->drupalCreateNode($edit);
+// As node IDs must be integers, make sure requests for non-integer IDs
+// return a page not found error.
+$this->drupalGet('node/invalid');
+$this->assertResponse(404);
+// Use a custom 404 page.
+$this->drupalPost('admin/config/system/site-information', array('site_404' => 'node/' . $node->nid), t('Save configuration'));
+$this->drupalGet($this->randomName(10));
+$this->assertText($node->title, 'Found the custom 404 page');
+}
+}
+/**
+* Tests site maintenance functionality.
+*/
+class SiteMaintenanceTestCase extends DrupalWebTestCase {
+protected $admin_user;
+public static function getInfo() {
+return array(
+'name' => 'Site maintenance mode functionality',
+'description' => 'Test access to site while in maintenance mode.',
+'group' => 'System',
+);
+}
+function setUp() {
+parent::setUp();
+// Create a user allowed to access site in maintenance mode.
+$this->user = $this->drupalCreateUser(array('access site in maintenance mode'));
+// Create an administrative user.
+$this->admin_user = $this->drupalCreateUser(array('administer site configuration', 'access site in maintenance mode'));
+$this->drupalLogin($this->admin_user);
+}
+/**
+* Verify site maintenance mode functionality.
+*/
+function testSiteMaintenance() {
+// Turn on maintenance mode.
+$edit = array(
+'maintenance_mode' => 1,
+);
+$this->drupalPost('admin/config/development/maintenance', $edit, t('Save configuration'));
+$admin_message = t('Operating in maintenance mode. <a href="@url">Go online.</a>', array('@url' => url('admin/config/development/maintenance')));
+$user_message = t('Operating in maintenance mode.');
+$offline_message = t('@site is currently under maintenance. We should be back shortly. Thank you for your patience.', array('@site' => variable_get('site_name', 'Drupal')));
+$this->drupalGet('');
+$this->assertRaw($admin_message, 'Found the site maintenance mode message.');
+// Logout and verify that offline message is displayed.
+$this->drupalLogout();
+$this->drupalGet('');
+$this->assertText($offline_message);
+$this->drupalGet('node');
+$this->assertText($offline_message);
+$this->drupalGet('user/register');
+$this->assertText($offline_message);
+// Verify that user is able to log in.
+$this->drupalGet('user');
+$this->assertNoText($offline_message);
+$this->drupalGet('user/login');
+$this->assertNoText($offline_message);
+// Log in user and verify that maintenance mode message is displayed
+// directly after login.
+$edit = array(
+'name' => $this->user->name,
+'pass' => $this->user->pass_raw,
+);
+$this->drupalPost(NULL, $edit, t('Log in'));
+$this->assertText($user_message);
+// Log in administrative user and configure a custom site offline message.
+$this->drupalLogout();
+$this->drupalLogin($this->admin_user);
+$this->drupalGet('admin/config/development/maintenance');
+$this->assertNoRaw($admin_message, 'Site maintenance mode message not displayed.');
+$offline_message = 'Sorry, not online.';
+$edit = array(
+'maintenance_mode_message' => $offline_message,
+);
+$this->drupalPost(NULL, $edit, t('Save configuration'));
+// Logout and verify that custom site offline message is displayed.
+$this->drupalLogout();
+$this->drupalGet('');
+$this->assertRaw($offline_message, 'Found the site offline message.');
+// Verify that custom site offline message is not displayed on user/password.
+$this->drupalGet('user/password');
+$this->assertText(t('Username or e-mail address'), 'Anonymous users can access user/password');
+// Submit password reset form.
+$edit = array(
+'name' => $this->user->name,
+);
+$this->drupalPost('user/password', $edit, t('E-mail new password'));
+$mails = $this->drupalGetMails();
+$start = strpos($mails[0]['body'], 'user/reset/'. $this->user->uid);
+$path = substr($mails[0]['body'], $start, 66 + strlen($this->user->uid));
+// Log in with temporary login link.
+$this->drupalPost($path, array(), t('Log in'));
+$this->assertText($user_message);
+}
+}
+/**
+* Tests generic date and time handling capabilities of Drupal.
+*/
+class DateTimeFunctionalTest extends DrupalWebTestCase {
+public static function getInfo() {
+return array(
+'name' => 'Date and time',
+'description' => 'Configure date and time settings. Test date formatting and time zone handling, including daylight saving time.',
+'group' => 'System',
+);
+}
+function setUp() {
+parent::setUp(array('locale'));
+// Create admin user and log in admin user.
+$this->admin_user = $this->drupalCreateUser(array('administer site configuration'));
+$this->drupalLogin($this->admin_user);
+}
+/**
+* Test time zones and DST handling.
+*/
+function testTimeZoneHandling() {
+// Setup date/time settings for Honolulu time.
+variable_set('date_default_timezone', 'Pacific/Honolulu');
+variable_set('configurable_timezones', 0);
+variable_set('date_format_medium', 'Y-m-d H:i:s O');
+// Create some nodes with different authored-on dates.
+$date1 = '2007-01-31 21:00:00 -1000';
+$date2 = '2007-07-31 21:00:00 -1000';
+$node1 = $this->drupalCreateNode(array('created' => strtotime($date1), 'type' => 'article'));
+$node2 = $this->drupalCreateNode(array('created' => strtotime($date2), 'type' => 'article'));
+// Confirm date format and time zone.
+$this->drupalGet("node/$node1->nid");
+$this->assertText('2007-01-31 21:00:00 -1000', 'Date should be identical, with GMT offset of -10 hours.');
+$this->drupalGet("node/$node2->nid");
+$this->assertText('2007-07-31 21:00:00 -1000', 'Date should be identical, with GMT offset of -10 hours.');
+// Set time zone to Los Angeles time.
+variable_set('date_default_timezone', 'America/Los_Angeles');
+// Confirm date format and time zone.
+$this->drupalGet("node/$node1->nid");
+$this->assertText('2007-01-31 23:00:00 -0800', 'Date should be two hours ahead, with GMT offset of -8 hours.');
+$this->drupalGet("node/$node2->nid");
+$this->assertText('2007-08-01 00:00:00 -0700', 'Date should be three hours ahead, with GMT offset of -7 hours.');
+}
+/**
+* Test date type configuration.
+*/
+function testDateTypeConfiguration() {
+// Confirm system date types appear.
+$this->drupalGet('admin/config/regional/date-time');
+$this->assertText(t('Medium'), 'System date types appear in date type list.');
+$this->assertNoRaw('href="/admin/config/regional/date-time/types/medium/delete"', 'No delete link appear for system date types.');
+// Add custom date type.
+$this->clickLink(t('Add date type'));
+$date_type = strtolower($this->randomName(8));
+$machine_name = 'machine_' . $date_type;
+$date_format = 'd.m.Y - H:i';
+$edit = array(
+'date_type' => $date_type,
+'machine_name' => $machine_name,
+'date_format' => $date_format,
+);
+$this->drupalPost('admin/config/regional/date-time/types/add', $edit, t('Add date type'));
+$this->assertEqual($this->getUrl(), url('admin/config/regional/date-time', array('absolute' => TRUE)), 'Correct page redirection.');
+$this->assertText(t('New date type added successfully.'), 'Date type added confirmation message appears.');
+$this->assertText($date_type, 'Custom date type appears in the date type list.');
+$this->assertText(t('delete'), 'Delete link for custom date type appears.');
+// Delete custom date type.
+$this->clickLink(t('delete'));
+$this->drupalPost('admin/config/regional/date-time/types/' . $machine_name . '/delete', array(), t('Remove'));
+$this->assertEqual($this->getUrl(), url('admin/config/regional/date-time', array('absolute' => TRUE)), 'Correct page redirection.');
+$this->assertText(t('Removed date type ' . $date_type), 'Custom date type removed.');
+}
+/**
+* Test date format configuration.
+*/
+function testDateFormatConfiguration() {
+// Confirm 'no custom date formats available' message appears.
+$this->drupalGet('admin/config/regional/date-time/formats');
+$this->assertText(t('No custom date formats available.'), 'No custom date formats message appears.');
+// Add custom date format.
+$this->clickLink(t('Add format'));
+$edit = array(
+'date_format' => 'Y',
+);
+$this->drupalPost('admin/config/regional/date-time/formats/add', $edit, t('Add format'));
+$this->assertEqual($this->getUrl(), url('admin/config/regional/date-time/formats', array('absolute' => TRUE)), 'Correct page redirection.');
+$this->assertNoText(t('No custom date formats available.'), 'No custom date formats message does not appear.');
+$this->assertText(t('Custom date format added.'), 'Custom date format added.');
+// Ensure custom date format appears in date type configuration options.
+$this->drupalGet('admin/config/regional/date-time');
+$this->assertRaw('<option value="Y">', 'Custom date format appears in options.');
+// Edit custom date format.
+$this->drupalGet('admin/config/regional/date-time/formats');
+$this->clickLink(t('edit'));
+$edit = array(
+'date_format' => 'Y m',
+);
+$this->drupalPost($this->getUrl(), $edit, t('Save format'));
+$this->assertEqual($this->getUrl(), url('admin/config/regional/date-time/formats', array('absolute' => TRUE)), 'Correct page redirection.');
+$this->assertText(t('Custom date format updated.'), 'Custom date format successfully updated.');
+// Check that ajax callback is protected by CSRF token.
+$this->drupalGet('admin/config/regional/date-time/formats/lookup', array('query' => array('format' => 'Y m d')));
+$this->assertResponse(403, 'Access denied with no token');
+$this->drupalGet('admin/config/regional/date-time/formats/lookup', array('query' => array('token' => 'invalid', 'format' => 'Y m d')));
+$this->assertResponse(403, 'Access denied with invalid token');
+$this->drupalGet('admin/config/regional/date-time/formats');
+$this->clickLink(t('edit'));
+$settings = $this->drupalGetSettings();
+$lookup_url = $settings['dateTime']['date-format']['lookup'];
+preg_match('/token=([^&]+)/', $lookup_url, $matches);
+$this->assertFalse(empty($matches[1]), 'Found token value');
+$this->drupalGet('admin/config/regional/date-time/formats/lookup', array('query' => array('token' => $matches[1], 'format' => 'Y m d')));
+$this->assertResponse(200, 'Access allowed with valid token');
+$this->assertText(format_date(time(), 'custom', 'Y m d'));
+// Delete custom date format.
+$this->drupalGet('admin/config/regional/date-time/formats');
+$this->clickLink(t('delete'));
+$this->drupalPost($this->getUrl(), array(), t('Remove'));
+$this->assertEqual($this->getUrl(), url('admin/config/regional/date-time/formats', array('absolute' => TRUE)), 'Correct page redirection.');
+$this->assertText(t('Removed date format'), 'Custom date format removed successfully.');
+}
+/**
+* Test if the date formats are stored properly.
+*/
+function testDateFormatStorage() {
+$date_format = array(
+'type' => 'short',
+'format' => 'dmYHis',
+'locked' => 0,
+'is_new' => 1,
+);
+system_date_format_save($date_format);
+$format = db_select('date_formats', 'df')
+->fields('df', array('format'))
+->condition('type', 'short')
+->condition('format', 'dmYHis')
+->execute()
+->fetchField();
+$this->verbose($format);
+$this->assertEqual('dmYHis', $format, 'Unlocalized date format resides in general table.');
+$format = db_select('date_format_locale', 'dfl')
+->fields('dfl', array('format'))
+->condition('type', 'short')
+->condition('format', 'dmYHis')
+->execute()
+->fetchField();
+$this->assertFalse($format, 'Unlocalized date format resides not in localized table.');
+// Enable German language
+locale_add_language('de', NULL, NULL, LANGUAGE_LTR, '', '', TRUE, 'en');
+$date_format = array(
+'type' => 'short',
+'format' => 'YMDHis',
+'locales' => array('de', 'tr'),
+'locked' => 0,
+'is_new' => 1,
+);
+system_date_format_save($date_format);
+$format = db_select('date_format_locale', 'dfl')
+->fields('dfl', array('format'))
+->condition('type', 'short')
+->condition('format', 'YMDHis')
+->condition('language', 'de')
+->execute()
+->fetchField();
+$this->assertEqual('YMDHis', $format, 'Localized date format resides in localized table.');
+$format = db_select('date_formats', 'df')
+->fields('df', array('format'))
+->condition('type', 'short')
+->condition('format', 'YMDHis')
+->execute()
+->fetchField();
+$this->assertEqual('YMDHis', $format, 'Localized date format resides in general table too.');
+$format = db_select('date_format_locale', 'dfl')
+->fields('dfl', array('format'))
+->condition('type', 'short')
+->condition('format', 'YMDHis')
+->condition('language', 'tr')
+->execute()
+->fetchColumn();
+$this->assertFalse($format, 'Localized date format for disabled language is ignored.');
+}
+}
+/**
+* Tests date format configuration.
+*/
+class DateFormatTestCase extends DrupalWebTestCase {
+public static function getInfo() {
+return array(
+'name' => 'Date format',
+'description' => 'Test date format configuration and defaults.',
+'group' => 'System',
+);
+}
+function setUp() {
+parent::setUp();
+// Create admin user and log in admin user.
+$this->admin_user = $this->drupalCreateUser(array('administer site configuration'));
+$this->drupalLogin($this->admin_user);
+}
+/**
+* Test the default date type formats are consistent.
+*/
+function testDefaultDateFormats() {
+// These are the default format values from format_date().
+$default_formats = array(
+'short' => 'm/d/Y - H:i',
+'medium' => 'D, m/d/Y - H:i',
+'long' => 'l, F j, Y - H:i',
+);
+// Clear the date format variables.
+variable_del('date_format_short');
+variable_del('date_format_medium');
+variable_del('date_format_long');
+$this->drupalGet('admin/config/regional/date-time');
+foreach ($default_formats as $format_name => $format_value) {
+$id = 'edit-date-format-' . $format_name;
+// Check that the configuration fields match the default format.
+$this->assertOptionSelected(
+$id,
+$format_value,
+format_string('The @type format type matches the expected format @format.',
+array(
+'@type' => $format_name,
+'@format' => $format_value,
+)
+));
+}
+}
+}
+class PageTitleFiltering extends DrupalWebTestCase {
+protected $content_user;
+protected $saved_title;
+/**
+* Implement getInfo().
+*/
+public static function getInfo() {
+return array(
+'name' => 'HTML in page titles',
+'description' => 'Tests correct handling or conversion by drupal_set_title() and drupal_get_title() and checks the correct escaping of site name and slogan.',
+'group' => 'System'
+);
+}
+/**
+* Implement setUp().
+*/
+function setUp() {
+parent::setUp();
+$this->content_user = $this->drupalCreateUser(array('create page content', 'access content', 'administer themes', 'administer site configuration'));
+$this->drupalLogin($this->content_user);
+$this->saved_title = drupal_get_title();
+}
+/**
+* Reset page title.
+*/
+function tearDown() {
+// Restore the page title.
+drupal_set_title($this->saved_title, PASS_THROUGH);
+parent::tearDown();
+}
+/**
+* Tests the handling of HTML by drupal_set_title() and drupal_get_title()
+*/
+function testTitleTags() {
+$title = "string with <em>HTML</em>";
+// drupal_set_title's $filter is CHECK_PLAIN by default, so the title should be
+// returned with check_plain().
+drupal_set_title($title, CHECK_PLAIN);
+$this->assertTrue(strpos(drupal_get_title(), '<em>') === FALSE, 'Tags in title converted to entities when $output is CHECK_PLAIN.');
+// drupal_set_title's $filter is passed as PASS_THROUGH, so the title should be
+// returned with HTML.
+drupal_set_title($title, PASS_THROUGH);
+$this->assertTrue(strpos(drupal_get_title(), '<em>') !== FALSE, 'Tags in title are not converted to entities when $output is PASS_THROUGH.');
+// Generate node content.
+$langcode = LANGUAGE_NONE;
+$edit = array(
+"title" => '!SimpleTest! ' . $title . $this->randomName(20),
+"body[$langcode][0][value]" => '!SimpleTest! test body' . $this->randomName(200),
+);
+// Create the node with HTML in the title.
+$this->drupalPost('node/add/page', $edit, t('Save'));
+$node = $this->drupalGetNodeByTitle($edit["title"]);
+$this->assertNotNull($node, 'Node created and found in database');
+$this->drupalGet("node/" . $node->nid);
+$this->assertText(check_plain($edit["title"]), 'Check to make sure tags in the node title are converted.');
+}
+/**
+* Test if the title of the site is XSS proof.
+*/
+function testTitleXSS() {
+// Set some title with JavaScript and HTML chars to escape.
+$title = '</title><script type="text/javascript">alert("Title XSS!");</script> & < > " \' ';
+$title_filtered = check_plain($title);
+$slogan = '<script type="text/javascript">alert("Slogan XSS!");</script>';
+$slogan_filtered = filter_xss_admin($slogan);
+// Activate needed appearance settings.
+$edit = array(
+'toggle_name'           => TRUE,
+'toggle_slogan'         => TRUE,
+'toggle_main_menu'      => TRUE,
+'toggle_secondary_menu' => TRUE,
+);
+$this->drupalPost('admin/appearance/settings', $edit, t('Save configuration'));
+// Set title and slogan.
+$edit = array(
+'site_name'    => $title,
+'site_slogan'  => $slogan,
+);
+$this->drupalPost('admin/config/system/site-information', $edit, t('Save configuration'));
+// Load frontpage.
+$this->drupalGet('');
+// Test the title.
+$this->assertNoRaw($title, 'Check for the unfiltered version of the title.');
+// Adding </title> so we do not test the escaped version from drupal_set_title().
+$this->assertRaw($title_filtered . '</title>', 'Check for the filtered version of the title.');
+// Test the slogan.
+$this->assertNoRaw($slogan, 'Check for the unfiltered version of the slogan.');
+$this->assertRaw($slogan_filtered, 'Check for the filtered version of the slogan.');
+}
+}
+/**
+* Test front page functionality and administration.
+*/
+class FrontPageTestCase extends DrupalWebTestCase {
+public static function getInfo() {
+return array(
+'name' => 'Front page',
+'description' => 'Tests front page functionality and administration.',
+'group' => 'System',
+);
+}
+function setUp() {
+parent::setUp('system_test');
+// Create admin user, log in admin user, and create one node.
+$this->admin_user = $this->drupalCreateUser(array('access content', 'administer site configuration'));
+$this->drupalLogin($this->admin_user);
+$this->node_path = "node/" . $this->drupalCreateNode(array('promote' => 1))->nid;
+// Enable front page logging in system_test.module.
+variable_set('front_page_output', 1);
+}
+/**
+* Test front page functionality.
+*/
+function testDrupalIsFrontPage() {
+$this->drupalGet('');
+$this->assertText(t('On front page.'), 'Path is the front page.');
+$this->drupalGet('node');
+$this->assertText(t('On front page.'), 'Path is the front page.');
+$this->drupalGet($this->node_path);
+$this->assertNoText(t('On front page.'), 'Path is not the front page.');
+// Change the front page to an invalid path.
+$edit = array('site_frontpage' => 'kittens');
+$this->drupalPost('admin/config/system/site-information', $edit, t('Save configuration'));
+$this->assertText(t("The path '@path' is either invalid or you do not have access to it.", array('@path' => $edit['site_frontpage'])));
+// Change the front page to a valid path.
+$edit['site_frontpage'] = $this->node_path;
+$this->drupalPost('admin/config/system/site-information', $edit, t('Save configuration'));
+$this->assertText(t('The configuration options have been saved.'), 'The front page path has been saved.');
+$this->drupalGet('');
+$this->assertText(t('On front page.'), 'Path is the front page.');
+$this->drupalGet('node');
+$this->assertNoText(t('On front page.'), 'Path is not the front page.');
+$this->drupalGet($this->node_path);
+$this->assertText(t('On front page.'), 'Path is the front page.');
+}
+}
+class SystemBlockTestCase extends DrupalWebTestCase {
+protected $profile = 'testing';
+public static function getInfo() {
+return array(
+'name' => 'Block functionality',
+'description' => 'Configure and move powered-by block.',
+'group' => 'System',
+);
+}
+function setUp() {
+parent::setUp('block');
+// Create and login user
+$admin_user = $this->drupalCreateUser(array('administer blocks', 'access administration pages'));
+$this->drupalLogin($admin_user);
+}
+/**
+* Test displaying and hiding the powered-by and help blocks.
+*/
+function testSystemBlocks() {
+// Set block title and some settings to confirm that the interface is available.
+$this->drupalPost('admin/structure/block/manage/system/powered-by/configure', array('title' => $this->randomName(8)), t('Save block'));
+$this->assertText(t('The block configuration has been saved.'), t('Block configuration set.'));
+// Set the powered-by block to the footer region.
+$edit = array();
+$edit['blocks[system_powered-by][region]'] = 'footer';
+$edit['blocks[system_main][region]'] = 'content';
+$this->drupalPost('admin/structure/block', $edit, t('Save blocks'));
+$this->assertText(t('The block settings have been updated.'), t('Block successfully moved to footer region.'));
+// Confirm that the block is being displayed.
+$this->drupalGet('node');
+$this->assertRaw('id="block-system-powered-by"', t('Block successfully being displayed on the page.'));
+// Set the block to the disabled region.
+$edit = array();
+$edit['blocks[system_powered-by][region]'] = '-1';
+$this->drupalPost('admin/structure/block', $edit, t('Save blocks'));
+// Confirm that the block is hidden.
+$this->assertNoRaw('id="block-system-powered-by"', t('Block no longer appears on page.'));
+// For convenience of developers, set the block to its default settings.
+$edit = array();
+$edit['blocks[system_powered-by][region]'] = 'footer';
+$this->drupalPost('admin/structure/block', $edit, t('Save blocks'));
+$this->drupalPost('admin/structure/block/manage/system/powered-by/configure', array('title' => ''), t('Save block'));
+// Set the help block to the help region.
+$edit = array();
+$edit['blocks[system_help][region]'] = 'help';
+$this->drupalPost('admin/structure/block', $edit, t('Save blocks'));
+// Test displaying the help block with block caching enabled.
+variable_set('block_cache', TRUE);
+$this->drupalGet('admin/structure/block/add');
+$this->assertRaw(t('Use this page to create a new custom block.'));
+$this->drupalGet('admin/index');
+$this->assertRaw(t('This page shows you all available administration tasks for each module.'));
+}
+}
+/**
+* Test main content rendering fallback provided by system module.
+*/
+class SystemMainContentFallback extends DrupalWebTestCase {
+protected $admin_user;
+protected $web_user;
+public static function getInfo() {
+return array(
+'name' => 'Main content rendering fallback',
+'description' => ' Test system module main content rendering fallback.',
+'group' => 'System',
+);
+}
+function setUp() {
+parent::setUp('system_test');
+// Create and login admin user.
+$this->admin_user = $this->drupalCreateUser(array(
+'access administration pages',
+'administer site configuration',
+'administer modules',
+'administer blocks',
+'administer nodes',
+));
+$this->drupalLogin($this->admin_user);
+// Create a web user.
+$this->web_user = $this->drupalCreateUser(array('access user profiles', 'access content'));
+}
+/**
+* Test availability of main content.
+*/
+function testMainContentFallback() {
+$edit = array();
+// Disable the dashboard module, which depends on the block module.
+$edit['modules[Core][dashboard][enable]'] = FALSE;
+$this->drupalPost('admin/modules', $edit, t('Save configuration'));
+$this->assertText(t('The configuration options have been saved.'), 'Modules status has been updated.');
+// Disable the block module.
+$edit['modules[Core][block][enable]'] = FALSE;
+$this->drupalPost('admin/modules', $edit, t('Save configuration'));
+$this->assertText(t('The configuration options have been saved.'), 'Modules status has been updated.');
+module_list(TRUE);
+$this->assertFalse(module_exists('block'), 'Block module disabled.');
+// At this point, no region is filled and fallback should be triggered.
+$this->drupalGet('admin/config/system/site-information');
+$this->assertField('site_name', 'Admin interface still available.');
+// Fallback should not trigger when another module is handling content.
+$this->drupalGet('system-test/main-content-handling');
+$this->assertRaw('id="system-test-content"', 'Content handled by another module');
+$this->assertText(t('Content to test main content fallback'), 'Main content still displayed.');
+// Fallback should trigger when another module
+// indicates that it is not handling the content.
+$this->drupalGet('system-test/main-content-fallback');
+$this->assertText(t('Content to test main content fallback'), 'Main content fallback properly triggers.');
+// Fallback should not trigger when another module is handling content.
+// Note that this test ensures that no duplicate
+// content gets created by the fallback.
+$this->drupalGet('system-test/main-content-duplication');
+$this->assertNoText(t('Content to test main content fallback'), 'Main content not duplicated.');
+// Request a user* page and see if it is displayed.
+$this->drupalLogin($this->web_user);
+$this->drupalGet('user/' . $this->web_user->uid . '/edit');
+$this->assertField('mail', 'User interface still available.');
+// Enable the block module again.
+$this->drupalLogin($this->admin_user);
+$edit = array();
+$edit['modules[Core][block][enable]'] = 'block';
+$this->drupalPost('admin/modules', $edit, t('Save configuration'));
+$this->assertText(t('The configuration options have been saved.'), 'Modules status has been updated.');
+module_list(TRUE);
+$this->assertTrue(module_exists('block'), 'Block module re-enabled.');
+}
+}
+/**
+* Tests for the theme interface functionality.
+*/
+class SystemThemeFunctionalTest extends DrupalWebTestCase {
+public static function getInfo() {
+return array(
+'name' => 'Theme interface functionality',
+'description' => 'Tests the theme interface functionality by enabling and switching themes, and using an administration theme.',
+'group' => 'System',
+);
+}
+function setUp() {
+parent::setUp();
+$this->admin_user = $this->drupalCreateUser(array('access administration pages', 'view the administration theme', 'administer themes', 'bypass node access', 'administer blocks'));
+$this->drupalLogin($this->admin_user);
+$this->node = $this->drupalCreateNode();
+}
+/**
+* Test the theme settings form.
+*/
+function testThemeSettings() {
+// Specify a filesystem path to be used for the logo.
+$file = current($this->drupalGetTestFiles('image'));
+$file_relative = strtr($file->uri, array('public:/' => variable_get('file_public_path', conf_path() . '/files')));
+$default_theme_path = 'themes/stark';
+$supported_paths = array(
+// Raw stream wrapper URI.
+$file->uri => array(
+'form' => file_uri_target($file->uri),
+'src' => file_create_url($file->uri),
+),
+// Relative path within the public filesystem.
+file_uri_target($file->uri) => array(
+'form' => file_uri_target($file->uri),
+'src' => file_create_url($file->uri),
+),
+// Relative path to a public file.
+$file_relative => array(
+'form' => $file_relative,
+'src' => file_create_url($file->uri),
+),
+// Relative path to an arbitrary file.
+'misc/druplicon.png' => array(
+'form' => 'misc/druplicon.png',
+'src' => $GLOBALS['base_url'] . '/' . 'misc/druplicon.png',
+),
+// Relative path to a file in a theme.
+$default_theme_path . '/logo.png' => array(
+'form' => $default_theme_path . '/logo.png',
+'src' => $GLOBALS['base_url'] . '/' . $default_theme_path . '/logo.png',
+),
+);
+foreach ($supported_paths as $input => $expected) {
+$edit = array(
+'default_logo' => FALSE,
+'logo_path' => $input,
+);
+$this->drupalPost('admin/appearance/settings', $edit, t('Save configuration'));
+$this->assertNoText('The custom logo path is invalid.');
+$this->assertFieldByName('logo_path', $expected['form']);
+// Verify the actual 'src' attribute of the logo being output.
+$this->drupalGet('');
+$elements = $this->xpath('//*[@id=:id]/img', array(':id' => 'logo'));
+$this->assertEqual((string) $elements[0]['src'], $expected['src']);
+}
+$unsupported_paths = array(
+// Stream wrapper URI to non-existing file.
+'public://whatever.png',
+'private://whatever.png',
+'temporary://whatever.png',
+// Bogus stream wrapper URIs.
+'public:/whatever.png',
+'://whatever.png',
+':whatever.png',
+'public://',
+// Relative path within the public filesystem to non-existing file.
+'whatever.png',
+// Relative path to non-existing file in public filesystem.
+variable_get('file_public_path', conf_path() . '/files') . '/whatever.png',
+// Semi-absolute path to non-existing file in public filesystem.
+'/' . variable_get('file_public_path', conf_path() . '/files') . '/whatever.png',
+// Relative path to arbitrary non-existing file.
+'misc/whatever.png',
+// Semi-absolute path to arbitrary non-existing file.
+'/misc/whatever.png',
+// Absolute paths to any local file (even if it exists).
+drupal_realpath($file->uri),
+);
+$this->drupalGet('admin/appearance/settings');
+foreach ($unsupported_paths as $path) {
+$edit = array(
+'default_logo' => FALSE,
+'logo_path' => $path,
+);
+$this->drupalPost(NULL, $edit, t('Save configuration'));
+$this->assertText('The custom logo path is invalid.');
+}
+// Upload a file to use for the logo.
+$edit = array(
+'default_logo' => FALSE,
+'logo_path' => '',
+'files[logo_upload]' => drupal_realpath($file->uri),
+);
+$this->drupalPost('admin/appearance/settings', $edit, t('Save configuration'));
+$fields = $this->xpath($this->constructFieldXpath('name', 'logo_path'));
+$uploaded_filename = 'public://' . $fields[0]['value'];
+$this->drupalGet('');
+$elements = $this->xpath('//*[@id=:id]/img', array(':id' => 'logo'));
+$this->assertEqual($elements[0]['src'], file_create_url($uploaded_filename));
+}
+/**
+* Test the administration theme functionality.
+*/
+function testAdministrationTheme() {
+theme_enable(array('stark'));
+variable_set('theme_default', 'stark');
+// Enable an administration theme and show it on the node admin pages.
+$edit = array(
+'admin_theme' => 'seven',
+'node_admin_theme' => TRUE,
+);
+$this->drupalPost('admin/appearance', $edit, t('Save configuration'));
+$this->drupalGet('admin/config');
+$this->assertRaw('themes/seven', 'Administration theme used on an administration page.');
+$this->drupalGet('node/' . $this->node->nid);
+$this->assertRaw('themes/stark', 'Site default theme used on node page.');
+$this->drupalGet('node/add');
+$this->assertRaw('themes/seven', 'Administration theme used on the add content page.');
+$this->drupalGet('node/' . $this->node->nid . '/edit');
+$this->assertRaw('themes/seven', 'Administration theme used on the edit content page.');
+// Disable the admin theme on the node admin pages.
+$edit = array(
+'node_admin_theme' => FALSE,
+);
+$this->drupalPost('admin/appearance', $edit, t('Save configuration'));
+$this->drupalGet('admin/config');
+$this->assertRaw('themes/seven', 'Administration theme used on an administration page.');
+$this->drupalGet('node/add');
+$this->assertRaw('themes/stark', 'Site default theme used on the add content page.');
+// Reset to the default theme settings.
+variable_set('theme_default', 'bartik');
+$edit = array(
+'admin_theme' => '0',
+'node_admin_theme' => FALSE,
+);
+$this->drupalPost('admin/appearance', $edit, t('Save configuration'));
+$this->drupalGet('admin');
+$this->assertRaw('themes/bartik', 'Site default theme used on administration page.');
+$this->drupalGet('node/add');
+$this->assertRaw('themes/bartik', 'Site default theme used on the add content page.');
+}
+/**
+* Test switching the default theme.
+*/
+function testSwitchDefaultTheme() {
+// Enable "stark" and set it as the default theme.
+theme_enable(array('stark'));
+$this->drupalGet('admin/appearance');
+$this->clickLink(t('Set default'), 1);
+$this->assertTrue(variable_get('theme_default', '') == 'stark', 'Site default theme switched successfully.');
+// Test the default theme on the secondary links (blocks admin page).
+$this->drupalGet('admin/structure/block');
+$this->assertText('Stark(' . t('active tab') . ')', 'Default local task on blocks admin page is the default theme.');
+// Switch back to Bartik and test again to test that the menu cache is cleared.
+$this->drupalGet('admin/appearance');
+$this->clickLink(t('Set default'), 0);
+$this->drupalGet('admin/structure/block');
+$this->assertText('Bartik(' . t('active tab') . ')', 'Default local task on blocks admin page has changed.');
+}
+}
+/**
+* Test the basic queue functionality.
+*/
+class QueueTestCase extends DrupalWebTestCase {
+public static function getInfo() {
+return array(
+'name' => 'Queue functionality',
+'description' => 'Queues and dequeues a set of items to check the basic queue functionality.',
+'group' => 'System',
+);
+}
+/**
+* Queues and dequeues a set of items to check the basic queue functionality.
+*/
+function testQueue() {
+// Create two queues.
+$queue1 = DrupalQueue::get($this->randomName());
+$queue1->createQueue();
+$queue2 = DrupalQueue::get($this->randomName());
+$queue2->createQueue();
+// Create four items.
+$data = array();
+for ($i = 0; $i < 4; $i++) {
+$data[] = array($this->randomName() => $this->randomName());
+}
+// Queue items 1 and 2 in the queue1.
+$queue1->createItem($data[0]);
+$queue1->createItem($data[1]);
+// Retrieve two items from queue1.
+$items = array();
+$new_items = array();
+$items[] = $item = $queue1->claimItem();
+$new_items[] = $item->data;
+$items[] = $item = $queue1->claimItem();
+$new_items[] = $item->data;
+// First two dequeued items should match the first two items we queued.
+$this->assertEqual($this->queueScore($data, $new_items), 2, 'Two items matched');
+// Add two more items.
+$queue1->createItem($data[2]);
+$queue1->createItem($data[3]);
+$this->assertTrue($queue1->numberOfItems(), 'Queue 1 is not empty after adding items.');
+$this->assertFalse($queue2->numberOfItems(), 'Queue 2 is empty while Queue 1 has items');
+$items[] = $item = $queue1->claimItem();
+$new_items[] = $item->data;
+$items[] = $item = $queue1->claimItem();
+$new_items[] = $item->data;
+// All dequeued items should match the items we queued exactly once,
+// therefore the score must be exactly 4.
+$this->assertEqual($this->queueScore($data, $new_items), 4, 'Four items matched');
+// There should be no duplicate items.
+$this->assertEqual($this->queueScore($new_items, $new_items), 4, 'Four items matched');
+// Delete all items from queue1.
+foreach ($items as $item) {
+$queue1->deleteItem($item);
+}
+// Check that both queues are empty.
+$this->assertFalse($queue1->numberOfItems(), 'Queue 1 is empty');
+$this->assertFalse($queue2->numberOfItems(), 'Queue 2 is empty');
+}
+/**
+* This function returns the number of equal items in two arrays.
+*/
+function queueScore($items, $new_items) {
+$score = 0;
+foreach ($items as $item) {
+foreach ($new_items as $new_item) {
+if ($item === $new_item) {
+$score++;
+}
+}
+}
+return $score;
+}
+}
+/**
+* Test token replacement in strings.
+*/
+class TokenReplaceTestCase extends DrupalWebTestCase {
+public static function getInfo() {
+return array(
+'name' => 'Token replacement',
+'description' => 'Generates text using placeholders for dummy content to check token replacement.',
+'group' => 'System',
+);
+}
+/**
+* Creates a user and a node, then tests the tokens generated from them.
+*/
+function testTokenReplacement() {
+// Create the initial objects.
+$account = $this->drupalCreateUser();
+$node = $this->drupalCreateNode(array('uid' => $account->uid));
+$node->title = '<blink>Blinking Text</blink>';
+global $user, $language;
+$source  = '[node:title]';         // Title of the node we passed in
+$source .= '[node:author:name]';   // Node author's name
+$source .= '[node:created:since]'; // Time since the node was created
+$source .= '[current-user:name]';  // Current user's name
+$source .= '[date:short]';         // Short date format of REQUEST_TIME
+$source .= '[user:name]';          // No user passed in, should be untouched
+$source .= '[bogus:token]';        // Non-existent token
+$target  = check_plain($node->title);
+$target .= check_plain($account->name);
+$target .= format_interval(REQUEST_TIME - $node->created, 2, $language->language);
+$target .= check_plain($user->name);
+$target .= format_date(REQUEST_TIME, 'short', '', NULL, $language->language);
+// Test that the clear parameter cleans out non-existent tokens.
+$result = token_replace($source, array('node' => $node), array('language' => $language, 'clear' => TRUE));
+$result = $this->assertEqual($target, $result, 'Valid tokens replaced while invalid tokens cleared out.');
+// Test without using the clear parameter (non-existent token untouched).
+$target .= '[user:name]';
+$target .= '[bogus:token]';
+$result = token_replace($source, array('node' => $node), array('language' => $language));
+$this->assertEqual($target, $result, 'Valid tokens replaced while invalid tokens ignored.');
+// Check that the results of token_generate are sanitized properly. This does NOT
+// test the cleanliness of every token -- just that the $sanitize flag is being
+// passed properly through the call stack and being handled correctly by a 'known'
+// token, [node:title].
+$raw_tokens = array('title' => '[node:title]');
+$generated = token_generate('node', $raw_tokens, array('node' => $node));
+$this->assertEqual($generated['[node:title]'], check_plain($node->title), 'Token sanitized.');
+$generated = token_generate('node', $raw_tokens, array('node' => $node), array('sanitize' => FALSE));
+$this->assertEqual($generated['[node:title]'], $node->title, 'Unsanitized token generated properly.');
+// Test token replacement when the string contains no tokens.
+$this->assertEqual(token_replace('No tokens here.'), 'No tokens here.');
+}
+/**
+* Test whether token-replacement works in various contexts.
+*/
+function testSystemTokenRecognition() {
+global $language;
+// Generate prefixes and suffixes for the token context.
+$tests = array(
+array('prefix' => 'this is the ', 'suffix' => ' site'),
+array('prefix' => 'this is the', 'suffix' => 'site'),
+array('prefix' => '[', 'suffix' => ']'),
+array('prefix' => '', 'suffix' => ']]]'),
+array('prefix' => '[[[', 'suffix' => ''),
+array('prefix' => ':[:', 'suffix' => '--]'),
+array('prefix' => '-[-', 'suffix' => ':]:'),
+array('prefix' => '[:', 'suffix' => ']'),
+array('prefix' => '[site:', 'suffix' => ':name]'),
+array('prefix' => '[site:', 'suffix' => ']'),
+);
+// Check if the token is recognized in each of the contexts.
+foreach ($tests as $test) {
+$input = $test['prefix'] . '[site:name]' . $test['suffix'];
+$expected = $test['prefix'] . 'Drupal' . $test['suffix'];
+$output = token_replace($input, array(), array('language' => $language));
+$this->assertTrue($output == $expected, format_string('Token recognized in string %string', array('%string' => $input)));
+}
+}
+/**
+* Tests the generation of all system site information tokens.
+*/
+function testSystemSiteTokenReplacement() {
+global $language;
+$url_options = array(
+'absolute' => TRUE,
+'language' => $language,
+);
+// Set a few site variables.
+variable_set('site_name', '<strong>Drupal<strong>');
+variable_set('site_slogan', '<blink>Slogan</blink>');
+// Generate and test sanitized tokens.
+$tests = array();
+$tests['[site:name]'] = check_plain(variable_get('site_name', 'Drupal'));
+$tests['[site:slogan]'] = check_plain(variable_get('site_slogan', ''));
+$tests['[site:mail]'] = 'simpletest@example.com';
+$tests['[site:url]'] = url('<front>', $url_options);
+$tests['[site:url-brief]'] = preg_replace(array('!^https?://!', '!/$!'), '', url('<front>', $url_options));
+$tests['[site:login-url]'] = url('user', $url_options);
+// Test to make sure that we generated something for each token.
+$this->assertFalse(in_array(0, array_map('strlen', $tests)), 'No empty tokens generated.');
+foreach ($tests as $input => $expected) {
+$output = token_replace($input, array(), array('language' => $language));
+$this->assertEqual($output, $expected, format_string('Sanitized system site information token %token replaced.', array('%token' => $input)));
+}
+// Generate and test unsanitized tokens.
+$tests['[site:name]'] = variable_get('site_name', 'Drupal');
+$tests['[site:slogan]'] = variable_get('site_slogan', '');
+foreach ($tests as $input => $expected) {
+$output = token_replace($input, array(), array('language' => $language, 'sanitize' => FALSE));
+$this->assertEqual($output, $expected, format_string('Unsanitized system site information token %token replaced.', array('%token' => $input)));
+}
+}
+/**
+* Tests the generation of all system date tokens.
+*/
+function testSystemDateTokenReplacement() {
+global $language;
+// Set time to one hour before request.
+$date = REQUEST_TIME - 3600;
+// Generate and test tokens.
+$tests = array();
+$tests['[date:short]'] = format_date($date, 'short', '', NULL, $language->language);
+$tests['[date:medium]'] = format_date($date, 'medium', '', NULL, $language->language);
+$tests['[date:long]'] = format_date($date, 'long', '', NULL, $language->language);
+$tests['[date:custom:m/j/Y]'] = format_date($date, 'custom', 'm/j/Y', NULL, $language->language);
+$tests['[date:since]'] = format_interval((REQUEST_TIME - $date), 2, $language->language);
+$tests['[date:raw]'] = filter_xss($date);
+// Test to make sure that we generated something for each token.
+$this->assertFalse(in_array(0, array_map('strlen', $tests)), 'No empty tokens generated.');
+foreach ($tests as $input => $expected) {
+$output = token_replace($input, array('date' => $date), array('language' => $language));
+$this->assertEqual($output, $expected, format_string('Date token %token replaced.', array('%token' => $input)));
+}
+}
+}
+class InfoFileParserTestCase extends DrupalUnitTestCase {
+public static function getInfo() {
+return array(
+'name' => 'Info file format parser',
+'description' => 'Tests proper parsing of a .info file formatted string.',
+'group' => 'System',
+);
+}
+/**
+* Test drupal_parse_info_format().
+*/
+function testDrupalParseInfoFormat() {
+$config = '
+simple = Value
+quoted = " Value"
+multiline = "Value
+Value"
+array[] = Value1
+array[] = Value2
+array_assoc[a] = Value1
+array_assoc[b] = Value2
+array_deep[][][] = Value
+array_deep_assoc[a][b][c] = Value
+array_space[a b] = Value';
+$expected = array(
+'simple' => 'Value',
+'quoted' => ' Value',
+'multiline' => "Value\n  Value",
+'array' => array(
+0 => 'Value1',
+1 => 'Value2',
+),
+'array_assoc' => array(
+'a' => 'Value1',
+'b' => 'Value2',
+),
+'array_deep' => array(
+0 => array(
+0 => array(
+0 => 'Value',
+),
+),
+),
+'array_deep_assoc' => array(
+'a' => array(
+'b' => array(
+'c' => 'Value',
+),
+),
+),
+'array_space' => array(
+'a b' => 'Value',
+),
+);
+$parsed = drupal_parse_info_format($config);
+$this->assertEqual($parsed['simple'], $expected['simple'], 'Set a simple value.');
+$this->assertEqual($parsed['quoted'], $expected['quoted'], 'Set a simple value in quotes.');
+$this->assertEqual($parsed['multiline'], $expected['multiline'], 'Set a multiline value.');
+$this->assertEqual($parsed['array'], $expected['array'], 'Set a simple array.');
+$this->assertEqual($parsed['array_assoc'], $expected['array_assoc'], 'Set an associative array.');
+$this->assertEqual($parsed['array_deep'], $expected['array_deep'], 'Set a nested array.');
+$this->assertEqual($parsed['array_deep_assoc'], $expected['array_deep_assoc'], 'Set a nested associative array.');
+$this->assertEqual($parsed['array_space'], $expected['array_space'], 'Set an array with a whitespace in the key.');
+$this->assertEqual($parsed, $expected, 'Entire parsed .info string and expected array are identical.');
+}
+}
+/**
+* Tests the effectiveness of hook_system_info_alter().
+*/
+class SystemInfoAlterTestCase extends DrupalWebTestCase {
+public static function getInfo() {
+return array(
+'name' => 'System info alter',
+'description' => 'Tests the effectiveness of hook_system_info_alter().',
+'group' => 'System',
+);
+}
+/**
+* Tests that {system}.info is rebuilt after a module that implements
+* hook_system_info_alter() is enabled. Also tests if core *_list() functions
+* return freshly altered info.
+*/
+function testSystemInfoAlter() {
+// Enable our test module. Flush all caches, which we assert is the only
+// thing necessary to use the rebuilt {system}.info.
+module_enable(array('module_test'), FALSE);
+drupal_flush_all_caches();
+$this->assertTrue(module_exists('module_test'), 'Test module is enabled.');
+$info = $this->getSystemInfo('seven', 'theme');
+$this->assertTrue(isset($info['regions']['test_region']), 'Altered theme info was added to {system}.info.');
+$seven_regions = system_region_list('seven');
+$this->assertTrue(isset($seven_regions['test_region']), 'Altered theme info was returned by system_region_list().');
+$system_list_themes = system_list('theme');
+$info = $system_list_themes['seven']->info;
+$this->assertTrue(isset($info['regions']['test_region']), 'Altered theme info was returned by system_list().');
+$list_themes = list_themes();
+$this->assertTrue(isset($list_themes['seven']->info['regions']['test_region']), 'Altered theme info was returned by list_themes().');
+// Disable the module and verify that {system}.info is rebuilt without it.
+module_disable(array('module_test'), FALSE);
+drupal_flush_all_caches();
+$this->assertFalse(module_exists('module_test'), 'Test module is disabled.');
+$info = $this->getSystemInfo('seven', 'theme');
+$this->assertFalse(isset($info['regions']['test_region']), 'Altered theme info was removed from {system}.info.');
+$seven_regions = system_region_list('seven');
+$this->assertFalse(isset($seven_regions['test_region']), 'Altered theme info was not returned by system_region_list().');
+$system_list_themes = system_list('theme');
+$info = $system_list_themes['seven']->info;
+$this->assertFalse(isset($info['regions']['test_region']), 'Altered theme info was not returned by system_list().');
+$list_themes = list_themes();
+$this->assertFalse(isset($list_themes['seven']->info['regions']['test_region']), 'Altered theme info was not returned by list_themes().');
+}
+/**
+* Returns the info array as it is stored in {system}.
+*
+* @param $name
+*   The name of the record in {system}.
+* @param $type
+*   The type of record in {system}.
+*
+* @return
+*   Array of info, or FALSE if the record is not found.
+*/
+function getSystemInfo($name, $type) {
+$raw_info = db_query("SELECT info FROM {system} WHERE name = :name AND type = :type", array(':name' => $name, ':type' => $type))->fetchField();
+return $raw_info ? unserialize($raw_info) : FALSE;
+}
+}
+/**
+* Tests for the update system functionality.
+*/
+class UpdateScriptFunctionalTest extends DrupalWebTestCase {
+private $update_url;
+private $update_user;
+public static function getInfo() {
+return array(
+'name' => 'Update functionality',
+'description' => 'Tests the update script access and functionality.',
+'group' => 'System',
+);
+}
+function setUp() {
+parent::setUp('update_script_test');
+$this->update_url = $GLOBALS['base_url'] . '/update.php';
+$this->update_user = $this->drupalCreateUser(array('administer software updates'));
+}
+/**
+* Tests that there are no pending updates for the first test method.
+*/
+function testNoPendingUpdates() {
+// Ensure that for the first test method in a class, there are no pending
+// updates. This tests a drupal_get_schema_versions() bug that previously
+// led to the wrong schema version being recorded for the initial install
+// of a child site during automated testing.
+$this->drupalLogin($this->update_user);
+$this->drupalGet($this->update_url, array('external' => TRUE));
+$this->drupalPost(NULL, array(), t('Continue'));
+$this->assertText(t('No pending updates.'), 'End of update process was reached.');
+}
+/**
+* Tests access to the update script.
+*/
+function testUpdateAccess() {
+// Try accessing update.php without the proper permission.
+$regular_user = $this->drupalCreateUser();
+$this->drupalLogin($regular_user);
+$this->drupalGet($this->update_url, array('external' => TRUE));
+$this->assertResponse(403);
+// Try accessing update.php as an anonymous user.
+$this->drupalLogout();
+$this->drupalGet($this->update_url, array('external' => TRUE));
+$this->assertResponse(403);
+// Access the update page with the proper permission.
+$this->drupalLogin($this->update_user);
+$this->drupalGet($this->update_url, array('external' => TRUE));
+$this->assertResponse(200);
+// Access the update page as user 1.
+$user1 = user_load(1);
+$user1->pass_raw = user_password();
+require_once DRUPAL_ROOT . '/' . variable_get('password_inc', 'includes/password.inc');
+$user1->pass = user_hash_password(trim($user1->pass_raw));
+db_query("UPDATE {users} SET pass = :pass WHERE uid = :uid", array(':pass' => $user1->pass, ':uid' => $user1->uid));
+$this->drupalLogin($user1);
+$this->drupalGet($this->update_url, array('external' => TRUE));
+$this->assertResponse(200);
+}
+/**
+* Tests that requirements warnings and errors are correctly displayed.
+*/
+function testRequirements() {
+$this->drupalLogin($this->update_user);
+// If there are no requirements warnings or errors, we expect to be able to
+// go through the update process uninterrupted.
+$this->drupalGet($this->update_url, array('external' => TRUE));
+$this->drupalPost(NULL, array(), t('Continue'));
+$this->assertText(t('No pending updates.'), 'End of update process was reached.');
+// Confirm that all caches were cleared.
+$this->assertText(t('hook_flush_caches() invoked for update_script_test.module.'), 'Caches were cleared when there were no requirements warnings or errors.');
+// If there is a requirements warning, we expect it to be initially
+// displayed, but clicking the link to proceed should allow us to go
+// through the rest of the update process uninterrupted.
+// First, run this test with pending updates to make sure they can be run
+// successfully.
+variable_set('update_script_test_requirement_type', REQUIREMENT_WARNING);
+drupal_set_installed_schema_version('update_script_test', drupal_get_installed_schema_version('update_script_test') - 1);
+$this->drupalGet($this->update_url, array('external' => TRUE));
+$this->assertText('This is a requirements warning provided by the update_script_test module.');
+$this->clickLink('try again');
+$this->assertNoText('This is a requirements warning provided by the update_script_test module.');
+$this->drupalPost(NULL, array(), t('Continue'));
+$this->drupalPost(NULL, array(), t('Apply pending updates'));
+$this->assertText(t('The update_script_test_update_7000() update was executed successfully.'), 'End of update process was reached.');
+// Confirm that all caches were cleared.
+$this->assertText(t('hook_flush_caches() invoked for update_script_test.module.'), 'Caches were cleared after resolving a requirements warning and applying updates.');
+// Now try again without pending updates to make sure that works too.
+$this->drupalGet($this->update_url, array('external' => TRUE));
+$this->assertText('This is a requirements warning provided by the update_script_test module.');
+$this->clickLink('try again');
+$this->assertNoText('This is a requirements warning provided by the update_script_test module.');
+$this->drupalPost(NULL, array(), t('Continue'));
+$this->assertText(t('No pending updates.'), 'End of update process was reached.');
+// Confirm that all caches were cleared.
+$this->assertText(t('hook_flush_caches() invoked for update_script_test.module.'), 'Caches were cleared after applying updates and re-running the script.');
+// If there is a requirements error, it should be displayed even after
+// clicking the link to proceed (since the problem that triggered the error
+// has not been fixed).
+variable_set('update_script_test_requirement_type', REQUIREMENT_ERROR);
+$this->drupalGet($this->update_url, array('external' => TRUE));
+$this->assertText('This is a requirements error provided by the update_script_test module.');
+$this->clickLink('try again');
+$this->assertText('This is a requirements error provided by the update_script_test module.');
+// Check if the optional 'value' key displays without a notice.
+variable_set('update_script_test_requirement_type', REQUIREMENT_INFO);
+$this->drupalGet($this->update_url, array('external' => TRUE));
+$this->assertText('This is a requirements info provided by the update_script_test module.');
+$this->assertNoText('Notice: Undefined index: value in theme_status_report()');
+}
+/**
+* Tests the effect of using the update script on the theme system.
+*/
+function testThemeSystem() {
+// Since visiting update.php triggers a rebuild of the theme system from an
+// unusual maintenance mode environment, we check that this rebuild did not
+// put any incorrect information about the themes into the database.
+$original_theme_data = db_query("SELECT * FROM {system} WHERE type = 'theme' ORDER BY name")->fetchAll();
+$this->drupalLogin($this->update_user);
+$this->drupalGet($this->update_url, array('external' => TRUE));
+$final_theme_data = db_query("SELECT * FROM {system} WHERE type = 'theme' ORDER BY name")->fetchAll();
+$this->assertEqual($original_theme_data, $final_theme_data, 'Visiting update.php does not alter the information about themes stored in the database.');
+}
+/**
+* Tests update.php when there are no updates to apply.
+*/
+function testNoUpdateFunctionality() {
+// Click through update.php with 'administer software updates' permission.
+$this->drupalLogin($this->update_user);
+$this->drupalPost($this->update_url, array(), t('Continue'), array('external' => TRUE));
+$this->assertText(t('No pending updates.'));
+$this->assertNoLink('Administration pages');
+$this->clickLink('Front page');
+$this->assertResponse(200);
+// Click through update.php with 'access administration pages' permission.
+$admin_user = $this->drupalCreateUser(array('administer software updates', 'access administration pages'));
+$this->drupalLogin($admin_user);
+$this->drupalPost($this->update_url, array(), t('Continue'), array('external' => TRUE));
+$this->assertText(t('No pending updates.'));
+$this->clickLink('Administration pages');
+$this->assertResponse(200);
+}
+/**
+* Tests update.php after performing a successful update.
+*/
+function testSuccessfulUpdateFunctionality() {
+drupal_set_installed_schema_version('update_script_test', drupal_get_installed_schema_version('update_script_test') - 1);
+// Click through update.php with 'administer software updates' permission.
+$this->drupalLogin($this->update_user);
+$this->drupalPost($this->update_url, array(), t('Continue'), array('external' => TRUE));
+$this->drupalPost(NULL, array(), t('Apply pending updates'));
+$this->assertText('Updates were attempted.');
+$this->assertLink('site');
+$this->assertNoLink('Administration pages');
+$this->assertNoLink('logged');
+$this->clickLink('Front page');
+$this->assertResponse(200);
+drupal_set_installed_schema_version('update_script_test', drupal_get_installed_schema_version('update_script_test') - 1);
+// Click through update.php with 'access administration pages' and
+// 'access site reports' permissions.
+$admin_user = $this->drupalCreateUser(array('administer software updates', 'access administration pages', 'access site reports'));
+$this->drupalLogin($admin_user);
+$this->drupalPost($this->update_url, array(), t('Continue'), array('external' => TRUE));
+$this->drupalPost(NULL, array(), t('Apply pending updates'));
+$this->assertText('Updates were attempted.');
+$this->assertLink('logged');
+$this->clickLink('Administration pages');
+$this->assertResponse(200);
+}
+}
+/**
+* Functional tests for the flood control mechanism.
+*/
+class FloodFunctionalTest extends DrupalWebTestCase {
+public static function getInfo() {
+return array(
+'name' => 'Flood control mechanism',
+'description' => 'Functional tests for the flood control mechanism.',
+'group' => 'System',
+);
+}
+/**
+* Test flood control mechanism clean-up.
+*/
+function testCleanUp() {
+$threshold = 1;
+$window_expired = -1;
+$name = 'flood_test_cleanup';
+// Register expired event.
+flood_register_event($name, $window_expired);
+// Verify event is not allowed.
+$this->assertFalse(flood_is_allowed($name, $threshold));
+// Run cron and verify event is now allowed.
+$this->cronRun();
+$this->assertTrue(flood_is_allowed($name, $threshold));
+// Register unexpired event.
+flood_register_event($name);
+// Verify event is not allowed.
+$this->assertFalse(flood_is_allowed($name, $threshold));
+// Run cron and verify event is still not allowed.
+$this->cronRun();
+$this->assertFalse(flood_is_allowed($name, $threshold));
+}
+}
+/**
+* Test HTTP file downloading capability.
+*/
+class RetrieveFileTestCase extends DrupalWebTestCase {
+public static function getInfo() {
+return array(
+'name' => 'HTTP file retrieval',
+'description' => 'Checks HTTP file fetching and error handling.',
+'group' => 'System',
+);
+}
+/**
+* Invokes system_retrieve_file() in several scenarios.
+*/
+function testFileRetrieving() {
+// Test 404 handling by trying to fetch a randomly named file.
+drupal_mkdir($sourcedir = 'public://' . $this->randomName());
+$filename = 'Файл для тестирования ' . $this->randomName();
+$url = file_create_url($sourcedir . '/' . $filename);
+$retrieved_file = system_retrieve_file($url);
+$this->assertFalse($retrieved_file, 'Non-existent file not fetched.');
+// Actually create that file, download it via HTTP and test the returned path.
+file_put_contents($sourcedir . '/' . $filename, 'testing');
+$retrieved_file = system_retrieve_file($url);
+// URLs could not contains characters outside the ASCII set so $filename
+// has to be encoded.
+$encoded_filename = rawurlencode($filename);
+$this->assertEqual($retrieved_file, 'public://' . $encoded_filename, 'Sane path for downloaded file returned (public:// scheme).');
+$this->assertTrue(is_file($retrieved_file), 'Downloaded file does exist (public:// scheme).');
+$this->assertEqual(filesize($retrieved_file), 7, 'File size of downloaded file is correct (public:// scheme).');
+file_unmanaged_delete($retrieved_file);
+// Test downloading file to a different location.
+drupal_mkdir($targetdir = 'temporary://' . $this->randomName());
+$retrieved_file = system_retrieve_file($url, $targetdir);
+$this->assertEqual($retrieved_file, "$targetdir/$encoded_filename", 'Sane path for downloaded file returned (temporary:// scheme).');
+$this->assertTrue(is_file($retrieved_file), 'Downloaded file does exist (temporary:// scheme).');
+$this->assertEqual(filesize($retrieved_file), 7, 'File size of downloaded file is correct (temporary:// scheme).');
+file_unmanaged_delete($retrieved_file);
+file_unmanaged_delete_recursive($sourcedir);
+file_unmanaged_delete_recursive($targetdir);
+}
+}
+/**
+* Functional tests shutdown functions.
+*/
+class ShutdownFunctionsTest extends DrupalWebTestCase {
+public static function getInfo() {
+return array(
+'name' => 'Shutdown functions',
+'description' => 'Functional tests for shutdown functions',
+'group' => 'System',
+);
+}
+function setUp() {
+parent::setUp('system_test');
+}
+/**
+* Test shutdown functions.
+*/
+function testShutdownFunctions() {
+$arg1 = $this->randomName();
+$arg2 = $this->randomName();
+$this->drupalGet('system-test/shutdown-functions/' . $arg1 . '/' . $arg2);
+$this->assertText(t('First shutdown function, arg1 : @arg1, arg2: @arg2', array('@arg1' => $arg1, '@arg2' => $arg2)));
+$this->assertText(t('Second shutdown function, arg1 : @arg1, arg2: @arg2', array('@arg1' => $arg1, '@arg2' => $arg2)));
+// Make sure exceptions displayed through _drupal_render_exception_safe()
+// are correctly escaped.
+$this->assertRaw('Drupal is &amp;lt;blink&amp;gt;awesome&amp;lt;/blink&amp;gt;.');
+}
+}
+/**
+* Tests administrative overview pages.
+*/
+class SystemAdminTestCase extends DrupalWebTestCase {
+public static function getInfo() {
+return array(
+'name' => 'Administrative pages',
+'description' => 'Tests output on administrative pages and compact mode functionality.',
+'group' => 'System',
+);
+}
+function setUp() {
+// testAdminPages() requires Locale module.
+parent::setUp(array('locale'));
+// Create an administrator with all permissions, as well as a regular user
+// who can only access administration pages and perform some Locale module
+// administrative tasks, but not all of them.
+$this->admin_user = $this->drupalCreateUser(array_keys(module_invoke_all('permission')));
+$this->web_user = $this->drupalCreateUser(array(
+'access administration pages',
+'translate interface',
+));
+$this->drupalLogin($this->admin_user);
+}
+/**
+* Tests output on administrative listing pages.
+*/
+function testAdminPages() {
+// Go to Administration.
+$this->drupalGet('admin');
+// Verify that all visible, top-level administration links are listed on
+// the main administration page.
+foreach (menu_get_router() as $path => $item) {
+if (strpos($path, 'admin/') === 0 && ($item['type'] & MENU_VISIBLE_IN_TREE) && $item['_number_parts'] == 2) {
+$this->assertLink($item['title']);
+$this->assertLinkByHref($path);
+$this->assertText($item['description']);
+}
+}
+// For each administrative listing page on which the Locale module appears,
+// verify that there are links to the module's primary configuration pages,
+// but no links to its individual sub-configuration pages. Also verify that
+// a user with access to only some Locale module administration pages only
+// sees links to the pages they have access to.
+$admin_list_pages = array(
+'admin/index',
+'admin/config',
+'admin/config/regional',
+);
+foreach ($admin_list_pages as $page) {
+// For the administrator, verify that there are links to Locale's primary
+// configuration pages, but no links to individual sub-configuration
+// pages.
+$this->drupalLogin($this->admin_user);
+$this->drupalGet($page);
+$this->assertLinkByHref('admin/config');
+$this->assertLinkByHref('admin/config/regional/settings');
+$this->assertLinkByHref('admin/config/regional/date-time');
+$this->assertLinkByHref('admin/config/regional/language');
+$this->assertNoLinkByHref('admin/config/regional/language/configure/session');
+$this->assertNoLinkByHref('admin/config/regional/language/configure/url');
+$this->assertLinkByHref('admin/config/regional/translate');
+// On admin/index only, the administrator should also see a "Configure
+// permissions" link for the Locale module.
+if ($page == 'admin/index') {
+$this->assertLinkByHref("admin/people/permissions#module-locale");
+}
+// For a less privileged user, verify that there are no links to Locale's
+// primary configuration pages, but a link to the translate page exists.
+$this->drupalLogin($this->web_user);
+$this->drupalGet($page);
+$this->assertLinkByHref('admin/config');
+$this->assertNoLinkByHref('admin/config/regional/settings');
+$this->assertNoLinkByHref('admin/config/regional/date-time');
+$this->assertNoLinkByHref('admin/config/regional/language');
+$this->assertNoLinkByHref('admin/config/regional/language/configure/session');
+$this->assertNoLinkByHref('admin/config/regional/language/configure/url');
+$this->assertLinkByHref('admin/config/regional/translate');
+// This user cannot configure permissions, so even on admin/index should
+// not see a "Configure permissions" link for the Locale module.
+if ($page == 'admin/index') {
+$this->assertNoLinkByHref("admin/people/permissions#module-locale");
+}
+}
+}
+/**
+* Test compact mode.
+*/
+function testCompactMode() {
+$this->drupalGet('admin/compact/on');
+$this->assertTrue($this->cookies['Drupal.visitor.admin_compact_mode']['value'], 'Compact mode turns on.');
+$this->drupalGet('admin/compact/on');
+$this->assertTrue($this->cookies['Drupal.visitor.admin_compact_mode']['value'], 'Compact mode remains on after a repeat call.');
+$this->drupalGet('');
+$this->assertTrue($this->cookies['Drupal.visitor.admin_compact_mode']['value'], 'Compact mode persists on new requests.');
+$this->drupalGet('admin/compact/off');
+$this->assertEqual($this->cookies['Drupal.visitor.admin_compact_mode']['value'], 'deleted', 'Compact mode turns off.');
+$this->drupalGet('admin/compact/off');
+$this->assertEqual($this->cookies['Drupal.visitor.admin_compact_mode']['value'], 'deleted', 'Compact mode remains off after a repeat call.');
+$this->drupalGet('');
+$this->assertTrue($this->cookies['Drupal.visitor.admin_compact_mode']['value'], 'Compact mode persists on new requests.');
+}
+}
+/**
+* Tests authorize.php and related hooks.
+*/
+class SystemAuthorizeCase extends DrupalWebTestCase {
+public static function getInfo() {
+return array(
+'name' => 'Authorize API',
+'description' => 'Tests the authorize.php script and related API.',
+'group' => 'System',
+);
+}
+function setUp() {
+parent::setUp(array('system_test'));
+variable_set('allow_authorize_operations', TRUE);
+// Create an administrator user.
+$this->admin_user = $this->drupalCreateUser(array('administer software updates'));
+$this->drupalLogin($this->admin_user);
+}
+/**
+* Helper function to initialize authorize.php and load it via drupalGet().
+*
+* Initializing authorize.php needs to happen in the child Drupal
+* installation, not the parent. So, we visit a menu callback provided by
+* system_test.module which calls system_authorized_init() to initialize the
+* $_SESSION inside the test site, not the framework site. This callback
+* redirects to authorize.php when it's done initializing.
+*
+* @see system_authorized_init().
+*/
+function drupalGetAuthorizePHP($page_title = 'system-test-auth') {
+$this->drupalGet('system-test/authorize-init/' . $page_title);
+}
+/**
+* Tests the FileTransfer hooks
+*/
+function testFileTransferHooks() {
+$page_title = $this->randomName(16);
+$this->drupalGetAuthorizePHP($page_title);
+$this->assertTitle(strtr('@title | Drupal', array('@title' => $page_title)), 'authorize.php page title is correct.');
+$this->assertNoText('It appears you have reached this page in error.');
+$this->assertText('To continue, provide your server connection details');
+// Make sure we see the new connection method added by system_test.
+$this->assertRaw('System Test FileTransfer');
+// Make sure the settings form callback works.
+$this->assertText('System Test Username');
+}
+}
+/**
+* Test the handling of requests containing 'index.php'.
+*/
+class SystemIndexPhpTest extends DrupalWebTestCase {
+public static function getInfo() {
+return array(
+'name' => 'Index.php handling',
+'description' => "Test the handling of requests containing 'index.php'.",
+'group' => 'System',
+);
+}
+function setUp() {
+parent::setUp();
+}
+/**
+* Test index.php handling.
+*/
+function testIndexPhpHandling() {
+$index_php = $GLOBALS['base_url'] . '/index.php';
+$this->drupalGet($index_php, array('external' => TRUE));
+$this->assertResponse(200, 'Make sure index.php returns a valid page.');
+$this->drupalGet($index_php, array('external' => TRUE, 'query' => array('q' => 'user')));
+$this->assertResponse(200, 'Make sure index.php?q=user returns a valid page.');
+$this->drupalGet($index_php .'/user', array('external' => TRUE));
+$this->assertResponse(404, "Make sure index.php/user returns a 'page not found'.");
+}
+}
+/**
+* Test token replacement in strings.
+*/
+class TokenScanTest extends DrupalWebTestCase {
+public static function getInfo() {
+return array(
+'name' => 'Token scanning',
+'description' => 'Scan token-like patterns in a dummy text to check token scanning.',
+'group' => 'System',
+);
+}
+/**
+* Scans dummy text, then tests the output.
+*/
+function testTokenScan() {
+// Define text with valid and not valid, fake and existing token-like
+// strings.
+$text = 'First a [valid:simple], but dummy token, and a dummy [valid:token with: spaces].';
+$text .= 'Then a [not valid:token].';
+$text .= 'Last an existing token: [node:author:name].';
+$token_wannabes = token_scan($text);
+$this->assertTrue(isset($token_wannabes['valid']['simple']), 'A simple valid token has been matched.');
+$this->assertTrue(isset($token_wannabes['valid']['token with: spaces']), 'A valid token with space characters in the token name has been matched.');
+$this->assertFalse(isset($token_wannabes['not valid']), 'An invalid token with spaces in the token type has not been matched.');
+$this->assertTrue(isset($token_wannabes['node']), 'An existing valid token has been matched.');
+}
+}
+/**
+* Test case for drupal_valid_token().
+*/
+class SystemValidTokenTest extends DrupalUnitTestCase {
+/**
+* Flag to indicate whether PHP error reportings should be asserted.
+*
+* @var bool
+*/
+protected $assertErrors = TRUE;
+public static function getInfo() {
+return array(
+'name' => 'Token validation',
+'description' => 'Test the security token validation.',
+'group' => 'System',
+);
+}
+/**
+* Tests invalid invocations of drupal_valid_token() that must return FALSE.
+*/
+public function testTokenValidation() {
+// The following checks will throw PHP notices, so we disable error
+// assertions.
+$this->assertErrors = FALSE;
+$this->assertFalse(drupal_valid_token(NULL, new stdClass()), 'Token NULL, value object returns FALSE.');
+$this->assertFalse(drupal_valid_token(0, array()), 'Token 0, value array returns FALSE.');
+$this->assertFalse(drupal_valid_token('', array()), "Token '', value array returns FALSE.");
+$this->assertFalse('' === drupal_get_token(array()), 'Token generation does not return an empty string on invalid parameters.');
+$this->assertErrors = TRUE;
+$this->assertFalse(drupal_valid_token(TRUE, 'foo'), 'Token TRUE, value foo returns FALSE.');
+$this->assertFalse(drupal_valid_token(0, 'foo'), 'Token 0, value foo returns FALSE.');
+}
+/**
+* Overrides DrupalTestCase::errorHandler().
+*/
+public function errorHandler($severity, $message, $file = NULL, $line = NULL) {
+if ($this->assertErrors) {
+return parent::errorHandler($severity, $message, $file, $line);
+}
+return TRUE;
+}
+}
+/**
+* Tests drupal_set_message() and related functions.
+*/
+class DrupalSetMessageTest extends DrupalWebTestCase {
+public static function getInfo() {
+return array(
+'name' => 'Messages',
+'description' => 'Tests that messages can be displayed using drupal_set_message().',
+'group' => 'System',
+);
+}
+function setUp() {
+parent::setUp('system_test');
+}
+/**
+* Tests setting messages and removing one before it is displayed.
+*/
+function testSetRemoveMessages() {
+// The page at system-test/drupal-set-message sets two messages and then
+// removes the first before it is displayed.
+$this->drupalGet('system-test/drupal-set-message');
+$this->assertNoText('First message (removed).');
+$this->assertText('Second message (not removed).');
+}
+}
+/**
+* Tests confirm form destinations.
+*/
+class ConfirmFormTest extends DrupalWebTestCase {
+protected $admin_user;
+public static function getInfo() {
+return array(
+'name' => 'Confirm form',
+'description' => 'Tests that the confirm form does not use external destinations.',
+'group' => 'System',
+);
+}
+function setUp() {
+parent::setUp();
+$this->admin_user = $this->drupalCreateUser(array('administer users'));
+$this->drupalLogin($this->admin_user);
+}
+/**
+* Tests that the confirm form does not use external destinations.
+*/
+function testConfirmForm() {
+$this->drupalGet('user/1/cancel');
+$this->assertCancelLinkUrl(url('user/1'));
+$this->drupalGet('user/1/cancel', array('query' => array('destination' => 'node')));
+$this->assertCancelLinkUrl(url('node'));
+$this->drupalGet('user/1/cancel', array('query' => array('destination' => 'http://example.com')));
+$this->assertCancelLinkUrl(url('user/1'));
+}
+/**
+* Asserts that a cancel link is present pointing to the provided URL.
+*/
+function assertCancelLinkUrl($url, $message = '', $group = 'Other') {
+$links = $this->xpath('//a[normalize-space(text())=:label and @href=:url]', array(':label' => t('Cancel'), ':url' => $url));
+$message = ($message ? $message : format_string('Cancel link with url %url found.', array('%url' => $url)));
+return $this->assertTrue(isset($links[0]), $message, $group);
+}
+}