class MenuRouterTestCase

class MenuRouterTestCase extends DrupalWebTestCase {
  public static function getInfo() {
    return array(
      'name' => 'Menu router',
      'description' => 'Tests menu router and hook_menu() functionality.',
      'group' => 'Menu',
    );
  }
  function setUp() {

    // Enable dummy module that implements hook_menu.
    parent::setUp('menu_test');

    // Make the tests below more robust by explicitly setting the default theme
    // and administrative theme that they expect.
    theme_enable(array(
      'bartik',
    ));
    variable_set('theme_default', 'bartik');
    variable_set('admin_theme', 'seven');
  }

  /**
   * Test title callback set to FALSE.
   */
  function testTitleCallbackFalse() {
    $this
      ->drupalGet('node');
    $this
      ->assertText('A title with @placeholder', 'Raw text found on the page');
    $this
      ->assertNoText(t('A title with @placeholder', array(
      '@placeholder' => 'some other text',
    )), 'Text with placeholder substitutions not found.');
  }

  /**
   * Tests page title of MENU_CALLBACKs.
   */
  function testTitleMenuCallback() {

    // Verify that the menu router item title is not visible.
    $this
      ->drupalGet('');
    $this
      ->assertNoText(t('Menu Callback Title'));

    // Verify that the menu router item title is output as page title.
    $this
      ->drupalGet('menu_callback_title');
    $this
      ->assertText(t('Menu Callback Title'));
  }

  /**
   * Test the theme callback when it is set to use an administrative theme.
   */
  function testThemeCallbackAdministrative() {
    $this
      ->drupalGet('menu-test/theme-callback/use-admin-theme');
    $this
      ->assertText('Custom theme: seven. Actual theme: seven.', 'The administrative theme can be correctly set in a theme callback.');
    $this
      ->assertRaw('seven/style.css', "The administrative theme's CSS appears on the page.");
  }

  /**
   * Test that the theme callback is properly inherited.
   */
  function testThemeCallbackInheritance() {
    $this
      ->drupalGet('menu-test/theme-callback/use-admin-theme/inheritance');
    $this
      ->assertText('Custom theme: seven. Actual theme: seven. Theme callback inheritance is being tested.', 'Theme callback inheritance correctly uses the administrative theme.');
    $this
      ->assertRaw('seven/style.css', "The administrative theme's CSS appears on the page.");
  }

  /**
   * Test that 'page callback', 'file' and 'file path' keys are properly
   * inherited from parent menu paths.
   */
  function testFileInheritance() {
    $this
      ->drupalGet('admin/config/development/file-inheritance');
    $this
      ->assertText('File inheritance test description', 'File inheritance works.');
  }

  /**
   * Test path containing "exotic" characters.
   */
  function testExoticPath() {
    $path = "menu-test/ -._~!\$'\"()*@[]?&+%#,;=:" . "%23%25%26%2B%2F%3F" . "éøïвβ中國書۞";

    // Characters from various non-ASCII alphabets.
    $this
      ->drupalGet($path);
    $this
      ->assertRaw('This is menu_test_callback().');
  }

  /**
   * Test the theme callback when the site is in maintenance mode.
   */
  function testThemeCallbackMaintenanceMode() {
    variable_set('maintenance_mode', TRUE);

    // For a regular user, the fact that the site is in maintenance mode means
    // we expect the theme callback system to be bypassed entirely.
    $this
      ->drupalGet('menu-test/theme-callback/use-admin-theme');
    $this
      ->assertRaw('bartik/css/style.css', "The maintenance theme's CSS appears on the page.");

    // An administrator, however, should continue to see the requested theme.
    $admin_user = $this
      ->drupalCreateUser(array(
      'access site in maintenance mode',
    ));
    $this
      ->drupalLogin($admin_user);
    $this
      ->drupalGet('menu-test/theme-callback/use-admin-theme');
    $this
      ->assertText('Custom theme: seven. Actual theme: seven.', 'The theme callback system is correctly triggered for an administrator when the site is in maintenance mode.');
    $this
      ->assertRaw('seven/style.css', "The administrative theme's CSS appears on the page.");
  }

  /**
   * Make sure the maintenance mode can be bypassed using hook_menu_site_status_alter().
   *
   * @see hook_menu_site_status_alter().
   */
  function testMaintenanceModeLoginPaths() {
    variable_set('maintenance_mode', TRUE);
    $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
      ->drupalLogout();
    $this
      ->drupalGet('node');
    $this
      ->assertText($offline_message);
    $this
      ->drupalGet('menu_login_callback');
    $this
      ->assertText('This is menu_login_callback().', t('Maintenance mode can be bypassed through hook_login_paths().'));
  }

  /**
   * Test that an authenticated user hitting 'user/login' gets redirected to
   * 'user' and 'user/register' gets redirected to the user edit page.
   */
  function testAuthUserUserLogin() {
    $loggedInUser = $this
      ->drupalCreateUser(array());
    $this
      ->drupalLogin($loggedInUser);
    $this
      ->drupalGet('user/login');

    // Check that we got to 'user'.
    $this
      ->assertTrue($this->url == url('user', array(
      'absolute' => TRUE,
    )), "Logged-in user redirected to q=user on accessing q=user/login");

    // user/register should redirect to user/UID/edit.
    $this
      ->drupalGet('user/register');
    $this
      ->assertTrue($this->url == url('user/' . $this->loggedInUser->uid . '/edit', array(
      'absolute' => TRUE,
    )), "Logged-in user redirected to q=user/UID/edit on accessing q=user/register");
  }

  /**
   * Test the theme callback when it is set to use an optional theme.
   */
  function testThemeCallbackOptionalTheme() {

    // Request a theme that is not enabled.
    $this
      ->drupalGet('menu-test/theme-callback/use-stark-theme');
    $this
      ->assertText('Custom theme: NONE. Actual theme: bartik.', 'The theme callback system falls back on the default theme when a theme that is not enabled is requested.');
    $this
      ->assertRaw('bartik/css/style.css', "The default theme's CSS appears on the page.");

    // Now enable the theme and request it again.
    theme_enable(array(
      'stark',
    ));
    $this
      ->drupalGet('menu-test/theme-callback/use-stark-theme');
    $this
      ->assertText('Custom theme: stark. Actual theme: stark.', 'The theme callback system uses an optional theme once it has been enabled.');
    $this
      ->assertRaw('stark/layout.css', "The optional theme's CSS appears on the page.");
  }

  /**
   * Test the theme callback when it is set to use a theme that does not exist.
   */
  function testThemeCallbackFakeTheme() {
    $this
      ->drupalGet('menu-test/theme-callback/use-fake-theme');
    $this
      ->assertText('Custom theme: NONE. Actual theme: bartik.', 'The theme callback system falls back on the default theme when a theme that does not exist is requested.');
    $this
      ->assertRaw('bartik/css/style.css', "The default theme's CSS appears on the page.");
  }

  /**
   * Test the theme callback when no theme is requested.
   */
  function testThemeCallbackNoThemeRequested() {
    $this
      ->drupalGet('menu-test/theme-callback/no-theme-requested');
    $this
      ->assertText('Custom theme: NONE. Actual theme: bartik.', 'The theme callback system falls back on the default theme when no theme is requested.');
    $this
      ->assertRaw('bartik/css/style.css', "The default theme's CSS appears on the page.");
  }

  /**
   * Test that hook_custom_theme() can control the theme of a page.
   */
  function testHookCustomTheme() {

    // Trigger hook_custom_theme() to dynamically request the Stark theme for
    // the requested page.
    variable_set('menu_test_hook_custom_theme_name', 'stark');
    theme_enable(array(
      'stark',
    ));

    // Visit a page that does not implement a theme callback. The above request
    // should be honored.
    $this
      ->drupalGet('menu-test/no-theme-callback');
    $this
      ->assertText('Custom theme: stark. Actual theme: stark.', 'The result of hook_custom_theme() is used as the theme for the current page.');
    $this
      ->assertRaw('stark/layout.css', "The Stark theme's CSS appears on the page.");
  }

  /**
   * Test that the theme callback wins out over hook_custom_theme().
   */
  function testThemeCallbackHookCustomTheme() {

    // Trigger hook_custom_theme() to dynamically request the Stark theme for
    // the requested page.
    variable_set('menu_test_hook_custom_theme_name', 'stark');
    theme_enable(array(
      'stark',
    ));

    // The menu "theme callback" should take precedence over a value set in
    // hook_custom_theme().
    $this
      ->drupalGet('menu-test/theme-callback/use-admin-theme');
    $this
      ->assertText('Custom theme: seven. Actual theme: seven.', 'The result of hook_custom_theme() does not override what was set in a theme callback.');
    $this
      ->assertRaw('seven/style.css', "The Seven theme's CSS appears on the page.");
  }

  /**
   * Tests for menu_link_maintain().
   */
  function testMenuLinkMaintain() {
    $admin_user = $this
      ->drupalCreateUser(array(
      'administer site configuration',
    ));
    $this
      ->drupalLogin($admin_user);

    // Create three menu items.
    menu_link_maintain('menu_test', 'insert', 'menu_test_maintain/1', 'Menu link #1');
    menu_link_maintain('menu_test', 'insert', 'menu_test_maintain/1', 'Menu link #1-1');
    menu_link_maintain('menu_test', 'insert', 'menu_test_maintain/2', 'Menu link #2');

    // Move second link to the main-menu, to test caching later on.
    db_update('menu_links')
      ->fields(array(
      'menu_name' => 'main-menu',
    ))
      ->condition('link_title', 'Menu link #1-1')
      ->condition('customized', 0)
      ->condition('module', 'menu_test')
      ->execute();
    menu_cache_clear('main-menu');

    // Load front page.
    $this
      ->drupalGet('node');
    $this
      ->assertLink(t('Menu link #1'), 0, 'Found menu link #1');
    $this
      ->assertLink(t('Menu link #1-1'), 0, 'Found menu link #1-1');
    $this
      ->assertLink(t('Menu link #2'), 0, 'Found menu link #2');

    // Rename all links for the given path.
    menu_link_maintain('menu_test', 'update', 'menu_test_maintain/1', 'Menu link updated');

    // Load a different page to be sure that we have up to date information.
    $this
      ->drupalGet('menu_test_maintain/1');
    $this
      ->assertLink(t('Menu link updated'), 0, 'Found updated menu link');
    $this
      ->assertNoLink(t('Menu link #1'), 0, 'Not found menu link #1');
    $this
      ->assertNoLink(t('Menu link #1'), 0, 'Not found menu link #1-1');
    $this
      ->assertLink(t('Menu link #2'), 0, 'Found menu link #2');

    // Delete all links for the given path.
    menu_link_maintain('menu_test', 'delete', 'menu_test_maintain/1', '');

    // Load a different page to be sure that we have up to date information.
    $this
      ->drupalGet('menu_test_maintain/2');
    $this
      ->assertNoLink(t('Menu link updated'), 0, 'Not found deleted menu link');
    $this
      ->assertNoLink(t('Menu link #1'), 0, 'Not found menu link #1');
    $this
      ->assertNoLink(t('Menu link #1'), 0, 'Not found menu link #1-1');
    $this
      ->assertLink(t('Menu link #2'), 0, 'Found menu link #2');
  }

  /**
   * Test menu_get_names().
   */
  function testMenuGetNames() {

    // Create three menu items.
    for ($i = 0; $i < 3; $i++) {
      $menu_link = array(
        'link_title' => 'Menu link #' . $i,
        'link_path' => 'menu_test/' . $i,
        'module' => 'menu_test',
        'menu_name' => 'menu_test_' . $i,
      );
      menu_link_save($menu_link);
    }
    drupal_static_reset('menu_get_names');

    // Verify that the menu names are correctly reported by menu_get_names().
    $menu_names = menu_get_names();
    $this
      ->pass(implode(' | ', $menu_names));
    for ($i = 0; $i < 3; $i++) {
      $this
        ->assertTrue(in_array('menu_test_' . $i, $menu_names), t('Expected menu name %expected is returned.', array(
        '%expected' => 'menu_test_' . $i,
      )));
    }
  }

  /**
   * Tests for menu_name parameter for hook_menu().
   */
  function testMenuName() {
    $admin_user = $this
      ->drupalCreateUser(array(
      'administer site configuration',
    ));
    $this
      ->drupalLogin($admin_user);
    $sql = "SELECT menu_name FROM {menu_links} WHERE router_path = 'menu_name_test'";
    $name = db_query($sql)
      ->fetchField();
    $this
      ->assertEqual($name, 'original', 'Menu name is "original".');

    // Change the menu_name parameter in menu_test.module, then force a menu
    // rebuild.
    menu_test_menu_name('changed');
    menu_rebuild();
    $sql = "SELECT menu_name FROM {menu_links} WHERE router_path = 'menu_name_test'";
    $name = db_query($sql)
      ->fetchField();
    $this
      ->assertEqual($name, 'changed', 'Menu name was successfully changed after rebuild.');
  }

  /**
   * Tests for menu hierarchy.
   */
  function testMenuHierarchy() {
    $parent_link = db_query('SELECT * FROM {menu_links} WHERE link_path = :link_path', array(
      ':link_path' => 'menu-test/hierarchy/parent',
    ))
      ->fetchAssoc();
    $child_link = db_query('SELECT * FROM {menu_links} WHERE link_path = :link_path', array(
      ':link_path' => 'menu-test/hierarchy/parent/child',
    ))
      ->fetchAssoc();
    $unattached_child_link = db_query('SELECT * FROM {menu_links} WHERE link_path = :link_path', array(
      ':link_path' => 'menu-test/hierarchy/parent/child2/child',
    ))
      ->fetchAssoc();
    $this
      ->assertEqual($child_link['plid'], $parent_link['mlid'], 'The parent of a directly attached child is correct.');
    $this
      ->assertEqual($unattached_child_link['plid'], $parent_link['mlid'], 'The parent of a non-directly attached child is correct.');
  }

  /**
   * Tests menu link depth and parents of local tasks and menu callbacks.
   */
  function testMenuHidden() {

    // Verify links for one dynamic argument.
    $links = db_select('menu_links', 'ml')
      ->fields('ml')
      ->condition('ml.router_path', 'menu-test/hidden/menu%', 'LIKE')
      ->orderBy('ml.router_path')
      ->execute()
      ->fetchAllAssoc('router_path', PDO::FETCH_ASSOC);
    $parent = $links['menu-test/hidden/menu'];
    $depth = $parent['depth'] + 1;
    $plid = $parent['mlid'];
    $link = $links['menu-test/hidden/menu/list'];
    $this
      ->assertEqual($link['depth'], $depth, format_string('%path depth @link_depth is equal to @depth.', array(
      '%path' => $link['router_path'],
      '@link_depth' => $link['depth'],
      '@depth' => $depth,
    )));
    $this
      ->assertEqual($link['plid'], $plid, format_string('%path plid @link_plid is equal to @plid.', array(
      '%path' => $link['router_path'],
      '@link_plid' => $link['plid'],
      '@plid' => $plid,
    )));
    $link = $links['menu-test/hidden/menu/add'];
    $this
      ->assertEqual($link['depth'], $depth, format_string('%path depth @link_depth is equal to @depth.', array(
      '%path' => $link['router_path'],
      '@link_depth' => $link['depth'],
      '@depth' => $depth,
    )));
    $this
      ->assertEqual($link['plid'], $plid, format_string('%path plid @link_plid is equal to @plid.', array(
      '%path' => $link['router_path'],
      '@link_plid' => $link['plid'],
      '@plid' => $plid,
    )));
    $link = $links['menu-test/hidden/menu/settings'];
    $this
      ->assertEqual($link['depth'], $depth, format_string('%path depth @link_depth is equal to @depth.', array(
      '%path' => $link['router_path'],
      '@link_depth' => $link['depth'],
      '@depth' => $depth,
    )));
    $this
      ->assertEqual($link['plid'], $plid, format_string('%path plid @link_plid is equal to @plid.', array(
      '%path' => $link['router_path'],
      '@link_plid' => $link['plid'],
      '@plid' => $plid,
    )));
    $link = $links['menu-test/hidden/menu/manage/%'];
    $this
      ->assertEqual($link['depth'], $depth, format_string('%path depth @link_depth is equal to @depth.', array(
      '%path' => $link['router_path'],
      '@link_depth' => $link['depth'],
      '@depth' => $depth,
    )));
    $this
      ->assertEqual($link['plid'], $plid, format_string('%path plid @link_plid is equal to @plid.', array(
      '%path' => $link['router_path'],
      '@link_plid' => $link['plid'],
      '@plid' => $plid,
    )));
    $parent = $links['menu-test/hidden/menu/manage/%'];
    $depth = $parent['depth'] + 1;
    $plid = $parent['mlid'];
    $link = $links['menu-test/hidden/menu/manage/%/list'];
    $this
      ->assertEqual($link['depth'], $depth, format_string('%path depth @link_depth is equal to @depth.', array(
      '%path' => $link['router_path'],
      '@link_depth' => $link['depth'],
      '@depth' => $depth,
    )));
    $this
      ->assertEqual($link['plid'], $plid, format_string('%path plid @link_plid is equal to @plid.', array(
      '%path' => $link['router_path'],
      '@link_plid' => $link['plid'],
      '@plid' => $plid,
    )));
    $link = $links['menu-test/hidden/menu/manage/%/add'];
    $this
      ->assertEqual($link['depth'], $depth, format_string('%path depth @link_depth is equal to @depth.', array(
      '%path' => $link['router_path'],
      '@link_depth' => $link['depth'],
      '@depth' => $depth,
    )));
    $this
      ->assertEqual($link['plid'], $plid, format_string('%path plid @link_plid is equal to @plid.', array(
      '%path' => $link['router_path'],
      '@link_plid' => $link['plid'],
      '@plid' => $plid,
    )));
    $link = $links['menu-test/hidden/menu/manage/%/edit'];
    $this
      ->assertEqual($link['depth'], $depth, format_string('%path depth @link_depth is equal to @depth.', array(
      '%path' => $link['router_path'],
      '@link_depth' => $link['depth'],
      '@depth' => $depth,
    )));
    $this
      ->assertEqual($link['plid'], $plid, format_string('%path plid @link_plid is equal to @plid.', array(
      '%path' => $link['router_path'],
      '@link_plid' => $link['plid'],
      '@plid' => $plid,
    )));
    $link = $links['menu-test/hidden/menu/manage/%/delete'];
    $this
      ->assertEqual($link['depth'], $depth, format_string('%path depth @link_depth is equal to @depth.', array(
      '%path' => $link['router_path'],
      '@link_depth' => $link['depth'],
      '@depth' => $depth,
    )));
    $this
      ->assertEqual($link['plid'], $plid, format_string('%path plid @link_plid is equal to @plid.', array(
      '%path' => $link['router_path'],
      '@link_plid' => $link['plid'],
      '@plid' => $plid,
    )));

    // Verify links for two dynamic arguments.
    $links = db_select('menu_links', 'ml')
      ->fields('ml')
      ->condition('ml.router_path', 'menu-test/hidden/block%', 'LIKE')
      ->orderBy('ml.router_path')
      ->execute()
      ->fetchAllAssoc('router_path', PDO::FETCH_ASSOC);
    $parent = $links['menu-test/hidden/block'];
    $depth = $parent['depth'] + 1;
    $plid = $parent['mlid'];
    $link = $links['menu-test/hidden/block/list'];
    $this
      ->assertEqual($link['depth'], $depth, format_string('%path depth @link_depth is equal to @depth.', array(
      '%path' => $link['router_path'],
      '@link_depth' => $link['depth'],
      '@depth' => $depth,
    )));
    $this
      ->assertEqual($link['plid'], $plid, format_string('%path plid @link_plid is equal to @plid.', array(
      '%path' => $link['router_path'],
      '@link_plid' => $link['plid'],
      '@plid' => $plid,
    )));
    $link = $links['menu-test/hidden/block/add'];
    $this
      ->assertEqual($link['depth'], $depth, format_string('%path depth @link_depth is equal to @depth.', array(
      '%path' => $link['router_path'],
      '@link_depth' => $link['depth'],
      '@depth' => $depth,
    )));
    $this
      ->assertEqual($link['plid'], $plid, format_string('%path plid @link_plid is equal to @plid.', array(
      '%path' => $link['router_path'],
      '@link_plid' => $link['plid'],
      '@plid' => $plid,
    )));
    $link = $links['menu-test/hidden/block/manage/%/%'];
    $this
      ->assertEqual($link['depth'], $depth, format_string('%path depth @link_depth is equal to @depth.', array(
      '%path' => $link['router_path'],
      '@link_depth' => $link['depth'],
      '@depth' => $depth,
    )));
    $this
      ->assertEqual($link['plid'], $plid, format_string('%path plid @link_plid is equal to @plid.', array(
      '%path' => $link['router_path'],
      '@link_plid' => $link['plid'],
      '@plid' => $plid,
    )));
    $parent = $links['menu-test/hidden/block/manage/%/%'];
    $depth = $parent['depth'] + 1;
    $plid = $parent['mlid'];
    $link = $links['menu-test/hidden/block/manage/%/%/configure'];
    $this
      ->assertEqual($link['depth'], $depth, format_string('%path depth @link_depth is equal to @depth.', array(
      '%path' => $link['router_path'],
      '@link_depth' => $link['depth'],
      '@depth' => $depth,
    )));
    $this
      ->assertEqual($link['plid'], $plid, format_string('%path plid @link_plid is equal to @plid.', array(
      '%path' => $link['router_path'],
      '@link_plid' => $link['plid'],
      '@plid' => $plid,
    )));
    $link = $links['menu-test/hidden/block/manage/%/%/delete'];
    $this
      ->assertEqual($link['depth'], $depth, format_string('%path depth @link_depth is equal to @depth.', array(
      '%path' => $link['router_path'],
      '@link_depth' => $link['depth'],
      '@depth' => $depth,
    )));
    $this
      ->assertEqual($link['plid'], $plid, format_string('%path plid @link_plid is equal to @plid.', array(
      '%path' => $link['router_path'],
      '@link_plid' => $link['plid'],
      '@plid' => $plid,
    )));
  }

  /**
   * Test menu_get_item() with empty ancestors.
   */
  function testMenuGetItemNoAncestors() {
    variable_set('menu_masks', array());
    $this
      ->drupalGet('');
  }

  /**
   * Test menu_set_item().
   */
  function testMenuSetItem() {
    $item = menu_get_item('node');
    $this
      ->assertEqual($item['path'], 'node', "Path from menu_get_item('node') is equal to 'node'", 'menu');

    // Modify the path for the item then save it.
    $item['path'] = 'node_test';
    $item['href'] = 'node_test';
    menu_set_item('node', $item);
    $compare_item = menu_get_item('node');
    $this
      ->assertEqual($compare_item, $item, 'Modified menu item is equal to newly retrieved menu item.', 'menu');
  }

  /**
   * Test menu maintenance hooks.
   */
  function testMenuItemHooks() {

    // Create an item.
    menu_link_maintain('menu_test', 'insert', 'menu_test_maintain/4', 'Menu link #4');
    $this
      ->assertEqual(menu_test_static_variable(), 'insert', 'hook_menu_link_insert() fired correctly');

    // Update the item.
    menu_link_maintain('menu_test', 'update', 'menu_test_maintain/4', 'Menu link updated');
    $this
      ->assertEqual(menu_test_static_variable(), 'update', 'hook_menu_link_update() fired correctly');

    // Delete the item.
    menu_link_maintain('menu_test', 'delete', 'menu_test_maintain/4', '');
    $this
      ->assertEqual(menu_test_static_variable(), 'delete', 'hook_menu_link_delete() fired correctly');
  }

  /**
   * Test menu link 'options' storage and rendering.
   */
  function testMenuLinkOptions() {

    // Create a menu link with options.
    $menu_link = array(
      'link_title' => 'Menu link options test',
      'link_path' => 'node',
      'module' => 'menu_test',
      'options' => array(
        'attributes' => array(
          'title' => 'Test title attribute',
        ),
        'query' => array(
          'testparam' => 'testvalue',
        ),
      ),
    );
    menu_link_save($menu_link);

    // Load front page.
    $this
      ->drupalGet('node');
    $this
      ->assertRaw('title="Test title attribute"', 'Title attribute of a menu link renders.');
    $this
      ->assertRaw('testparam=testvalue', 'Query parameter added to menu link.');
  }

  /**
   * Tests the possible ways to set the title for menu items.
   * Also tests that menu item titles work with string overrides.
   */
  function testMenuItemTitlesCases() {

    // Build array with string overrides.
    $test_data = array(
      1 => array(
        'Example title - Case 1' => 'Alternative example title - Case 1',
      ),
      2 => array(
        'Example @sub1 - Case @op2' => 'Alternative example @sub1 - Case @op2',
      ),
      3 => array(
        'Example title' => 'Alternative example title',
      ),
      4 => array(
        'Example title' => 'Alternative example title',
      ),
    );
    foreach ($test_data as $case_no => $override) {
      $this
        ->menuItemTitlesCasesHelper($case_no);
      variable_set('locale_custom_strings_en', array(
        '' => $override,
      ));
      $this
        ->menuItemTitlesCasesHelper($case_no, TRUE);
      variable_set('locale_custom_strings_en', array());
    }
  }

  /**
   * Get a URL and assert the title given a case number. If override is true,
   * the title is asserted to begin with "Alternative".
   */
  private function menuItemTitlesCasesHelper($case_no, $override = FALSE) {
    $this
      ->drupalGet('menu-title-test/case' . $case_no);
    $this
      ->assertResponse(200);
    $asserted_title = $override ? 'Alternative example title - Case ' . $case_no : 'Example title - Case ' . $case_no;
    $this
      ->assertTitle($asserted_title . ' | Drupal', format_string('Menu title is: %title.', array(
      '%title' => $asserted_title,
    )), 'Menu');
  }

  /**
   * Load the router for a given path.
   */
  protected function menuLoadRouter($router_path) {
    return db_query('SELECT * FROM {menu_router} WHERE path = :path', array(
      ':path' => $router_path,
    ))
      ->fetchAssoc();
  }

  /**
   * Tests inheritance of 'load arguments'.
   */
  function testMenuLoadArgumentsInheritance() {
    $expected = array(
      'menu-test/arguments/%/%' => array(
        2 => array(
          'menu_test_argument_load' => array(
            3,
          ),
        ),
        3 => NULL,
      ),
      // Arguments are inherited to normal children.
      'menu-test/arguments/%/%/default' => array(
        2 => array(
          'menu_test_argument_load' => array(
            3,
          ),
        ),
        3 => NULL,
      ),
      // Arguments are inherited to tab children.
      'menu-test/arguments/%/%/task' => array(
        2 => array(
          'menu_test_argument_load' => array(
            3,
          ),
        ),
        3 => NULL,
      ),
      // Arguments are only inherited to the same loader functions.
      'menu-test/arguments/%/%/common-loader' => array(
        2 => array(
          'menu_test_argument_load' => array(
            3,
          ),
        ),
        3 => 'menu_test_other_argument_load',
      ),
      // Arguments are not inherited to children not using the same loader
      // function.
      'menu-test/arguments/%/%/different-loaders-1' => array(
        2 => NULL,
        3 => 'menu_test_argument_load',
      ),
      'menu-test/arguments/%/%/different-loaders-2' => array(
        2 => 'menu_test_other_argument_load',
        3 => NULL,
      ),
      'menu-test/arguments/%/%/different-loaders-3' => array(
        2 => NULL,
        3 => NULL,
      ),
      // Explicit loader arguments should not be overriden by parent.
      'menu-test/arguments/%/%/explicit-arguments' => array(
        2 => array(
          'menu_test_argument_load' => array(),
        ),
        3 => NULL,
      ),
    );
    foreach ($expected as $router_path => $load_functions) {
      $router_item = $this
        ->menuLoadRouter($router_path);
      $this
        ->assertIdentical(unserialize($router_item['load_functions']), $load_functions, format_string('Expected load functions for router %router_path', array(
        '%router_path' => $router_path,
      )));
    }
  }

}