class LayoutInterfaceTest

class LayoutInterfaceTest extends BackdropWebTestCase {
  protected $profile = 'minimal';
  protected $admin_user;
  protected $web_user;
  protected $test_node1;
  protected $test_node2;
  protected $orphaned_blocks = FALSE;

  function setUp() {
    parent::setUp('layout_test');

    // Create and login admin user.
    $this->admin_user = $this->backdropCreateUser(array(
      'access user profiles',
      'access administration pages',
      'administer site configuration',
      'administer modules',
      'administer layouts',
      'administer nodes',
    ));
    $this->backdropLogin($this->admin_user);

    // Create a web user.
    $this->web_user = $this->backdropCreateUser(array(
      'access user profiles',
      'access content',
      'administer nodes',
    ));

    // Create content types for testing.
    $this->backdropCreateContentType(array('type' => 'page', 'name' => 'Page'));
    $this->backdropCreateContentType(array('type' => 'post', 'name' => 'Post'));

    $this->test_node1 = $this->backdropCreateNode(array(
      'type' => 'post',
      'title' => $this->randomString(),
      'uid' => $this->admin_user->uid,
    ));

    $this->test_node2 = $this->backdropCreateNode(array(
      'type' => 'page',
      'title' => $this->randomString(),
      'uid' => $this->web_user->uid,
    ));
  }

  /**
   * Test the support for contexts within conditions and blocks.
   */
  function testRelationships() {
    // Make a new layout that creates a custom path with wildcards.
    $layout_title = $this->randomName();
    $layout_name = strtolower($layout_title);
    $layout_path = 'node/%';
    $edit = array(
      'title' => $layout_title,
      'name' => $layout_name,
      'layout_template' => 'moscone_flipped',
      'path' => $layout_path,
    );
    // Check the path first to populate available contexts.
    $this->backdropPost('admin/structure/layouts/add', $edit, t('Check path'));

    // Test Author from Content relationship.
    $edit = array();
    $this->backdropPost('admin/structure/layouts/manage/' . $layout_name . '/configure', $edit, t('Add relationship'));

    $edit = array(
      'relationship' => 'author_from_node:relationship',
    );
    $this->backdropPost(NULL, $edit, t('Load relationship'));
    $this->backdropPost(NULL, array(), t('Add relationship'));

    $this->backdropPost(NULL, array(), t('Create layout'));

    // Add the test block that requires both node and user contexts.
    $this->clickLink(t('Add block'), 3);
    $this->assertText(t('A testing block for layouts with contexts.'));
    $this->clickLink(t('Layout bar block'));
    $select_options = $this->xpath('//*[@id=:select]//option', array(
      ':select' => 'edit-contexts-my-user',
    ));
    $this->assertEqual(count($select_options), 2, 'Two options are found in the select list.');
    $relationship_option = (string) $select_options[0]['value'];
    $this->assertTrue(strpos($relationship_option, 'relationship') === 0, 'First select list option is the user context from the author relationship.');

    $edit = array(
      'contexts[my_user]' => $relationship_option,
    );
    $this->backdropPost(NULL, $edit, t('Add block'));

    // Record the UUID for the newly added block.
    $last_block = $this->xpath('(//*[contains(@class,:region)]//*[@data-block-id])[last()]', array(
      ':region' => 'l-sidebar',
    ));
    $block_uuid = (string) $last_block[0]['data-block-id'];
    $block_edit_url = 'admin/structure/layouts/manage/' . $layout_name . '/configure-block/editor/' . $block_uuid;

    // Save the layout.
    $this->backdropPost(NULL, array(), t('Save layout'));

    // Visit a node created by another user. The user context from that node,
    // rather than the current user, should be available.
    // The current user is User 2.
    $this->backdropGet('node/' . $this->test_node2->nid);
    $this->assertText(format_string('The user email is @mail and the node title is @title', array('@mail' => $this->web_user->mail, '@title' => $this->test_node2->title)));
    $this->backdropGet('admin/structure/layouts/manage/' . $layout_name);

    // Change the user context on the test block to use the current user and
    // test that the node user is no longer displayed.
    $edit = array(
      'contexts[my_user]' => 'current_user',
    );
    $this->backdropPost($block_edit_url, $edit, t('Update block'));
    $this->backdropPost(NULL, array(), t('Save layout'));

    $this->backdropGet('node/' . $this->test_node2->nid);
    $this->assertNoText(format_string('The user email is @mail and the node title is @title', array('@mail' => $this->web_user->mail, '@title' => $this->test_node2->title)));

    // Visit a node created by the current user (User 2) and test that the
    // correct user is displayed.
    $this->backdropGet('node/' . $this->test_node1->nid);
    $this->assertText(format_string('The user email is @mail and the node title is @title', array('@mail' => $this->admin_user->mail, '@title' => $this->test_node1->title)));

    // Remove the author from node relationship.
    $this->backdropPost('admin/structure/layouts/manage/' . $layout_name . '/configure', array(), t('Remove'));
  }

  /**
   * Test that layout templates may be enabled and disabled.
   */
  function testLayoutTemplates() {
    // Attempt to disable the 1 column layout (should fail).
    $this->backdropGet('admin/structure/layouts/settings');
    $edit = array(
      'templates[boxton]' => FALSE,
      'templates[moscone]' => TRUE,
      'templates[moscone_flipped]' => TRUE,
      'templates[simmons]' => TRUE,
    );
    $this->backdropPost(NULL, $edit, t('Save configuration'));
    $this->assertText(t('The "Boxton" layout template is currently in use and may not be disabled.'));

    // Check to see that the Simmons layout is an existing option.
    $this->backdropGet('admin/structure/layouts/manage/default/configure');
    $this->assertText('Simmons');

    // Disable the Bartik layout.
    $edit = array(
      'templates[boxton]' => TRUE,
      'templates[moscone]' => TRUE,
      'templates[moscone_flipped]' => TRUE,
      'templates[simmons]' => FALSE,
    );
    $this->backdropPost('admin/structure/layouts/settings', $edit, t('Save configuration'));
    $this->assertText(t('Your configuration has been saved.'));

    // Check to see that the Simmons layout is no longer an option.
    $this->backdropGet('admin/structure/layouts/manage/default/configure');
    $this->assertNoText('Simmons');

    // Check that hidden templates are not shown by default.
    $this->assertNoText('3/3/4 columns');

    // Enable hidden layouts manually.
    config_set('layout.settings', 'excluded_templates', array());

    // Check that the hidden templates are now available.
    $this->backdropGet('admin/structure/layouts/manage/default/configure');
    $this->assertText('3/3/4 columns');
    $this->backdropGet('admin/structure/layouts/settings');
    $this->assertText('3/3/4 columns');

    // Disable the legacy Bartik layout.
    $edit = array(
      'templates[three_three_four_column]' => FALSE,
    );
    $this->backdropPost('admin/structure/layouts/settings', $edit, t('Save configuration'));
    $this->assertNoText('3/3/4 columns');

    // Post again just make sure the hidden option doesn't return.
    $this->backdropPost('admin/structure/layouts/settings', array(), t('Save configuration'));
    $this->assertNoText('3/3/4 columns');
  }

  /**
   * Test the path view page link.
   */
  function testViewPageLink() {
    $this->backdropGet('admin/structure/layouts');
    $this->clickLink(t('Add layout'));

    // Test the default value for layout template is set.
    $this->assertFieldByXPath('//input[@name="layout_template"][@checked="checked"]', TRUE, 'The Layout template default value is set.');
    $default_layout_template = config_get('layout.layout.default', 'layout_template');
    $field_id = 'edit-layout-template-' . str_replace('_', '-', $default_layout_template);
    $this->assertFieldChecked($field_id, 'The Layout template default value is the same as the default layout.');

    // Create a new layout at a new path.
    $layout_title = $this->randomName();
    $layout_name = strtolower($layout_title);
    $layout_url = 'a-menu-item-path';
    $edit = array(
      'title' => $layout_title,
      'name' => $layout_name,
      'layout_template' => 'moscone_flipped',
      'path' => $layout_url,
    );
    $this->backdropPost(NULL, $edit, t('Create layout'));
    $this->backdropGet('admin/structure/layouts/manage/' . $layout_name);
    layout_reset_caches();

    // Check that the view page link is present.
    $this->assertLinkByHref($layout_url, 0, 'View page link found.');
    $this->assertLink('View page', 0, 'View page link text found.');
    $this->clickLink(t('View page'));
    $this->assertResponse(200, 'View page link goes to path.');

    // Create a new layout overriding node/%.
    $layout_title = $this->randomName();
    $layout_name = strtolower($layout_title);
    $layout_url = 'node/%';
    $edit = array(
      'title' => $layout_title,
      'name' => $layout_name,
      'layout_template' => 'moscone_flipped',
      'path' => $layout_url,
    );
    $this->backdropPost('admin/structure/layouts/add', $edit, t('Create layout'));

    // Check that the view page link is not present.
    $this->assertNoLinkByHref($layout_url, 0, 'View page link found.');
    $this->assertNoLink('View page', 1, 'View page link text found.');
  }

  /**
   * Add and remove blocks from a custom layout path.
   */
  function testBlockBasics() {
    $this->backdropGet('admin/structure/layouts');
    $this->clickLink(t('Add layout'));

    // Create a new layout at a new path.
    $layout_title = $this->randomName();
    $layout_name = strtolower($layout_title);
    $layout_url = 'layout-test-path';
    $edit = array(
      'title' => $layout_title,
      'name' => $layout_name,
      'layout_template' => 'moscone_flipped',
      'path' => $layout_url,
    );
    $this->backdropPost(NULL, $edit, t('Create layout'));

    // We should be taken to the layout content page next.
    $this->assertText(t('Layout created. Blocks may now be added to this layout.'));

    // Check that a block that requires contexts is not shown.
    $this->assertNoLink(t('Main page content'));
    $this->assertNoLink(t('Layout bar block'));

    // Add a block to the sidebar.
    $this->clickLink(t('Add block'), 3);
    $this->assertText(t('A testing block for layouts.'));
    $this->clickLink(t('Layout foo block'));
    $edit = array(
      'block_settings[count]' => 5,
    );
    $this->backdropPost(NULL, $edit, t('Add block'));

    // Record the UUID for the newly added block.
    $last_block = $this->xpath('(//*[contains(@class,:region)]//*[@data-block-id])[last()]', array(
      ':region' => 'l-sidebar',
    ));
    $block_uuid = (string) $last_block[0]['data-block-id'];
    $block_edit_url = 'admin/structure/layouts/manage/' . $layout_name . '/configure-block/editor/' . $block_uuid;

    // Check the admin label and description.
    $elements = $this->xpath('//*[contains(@id,:id)]//*[contains(@class,:class)]//span[normalize-space()=:title]', array(
      ':id' => 'layout-editor-block-' . $block_uuid,
      ':class' => 'layout-editor-block-title',
      ':title' => t('Layout foo block'),
    ));
    $this->assertEqual(count($elements), 1, 'The sample block label was found.');
    $elements = $this->xpath('//*[contains(@id,:id)]//*[contains(@class,:class)]//*[normalize-space()=:description]', array(
      ':id' => 'layout-editor-block-' . $block_uuid,
      ':class' => 'layout-editor-block-content',
      ':description' => t('A testing block for layouts.'),
    ));
    $this->assertEqual(count($elements), 1, 'The sample block description was found.');

    // Change the label and description.
    $block_new_label = $this->randomName();
    $block_new_description = $this->randomName();
    $edit = array(
      'admin_label' => $block_new_label,
      'admin_description' => $block_new_description,
    );
    $this->backdropPost($block_edit_url, $edit, t('Update block'));

    // Check the new admin label and description.
    $elements = $this->xpath('//*[contains(@id,:id)]//*[contains(@class,:class)]//span[normalize-space()=:title]', array(
      ':id' => 'layout-editor-block-' . $block_uuid,
      ':class' => 'layout-editor-block-title',
      ':title' => $block_new_label,
    ));
    $this->assertEqual(count($elements), 1, 'The sample block label was found.');
    $elements = $this->xpath('//*[contains(@id,:id)]//*[contains(@class,:class) and contains(text(), :description)]', array(
      ':id' => 'layout-editor-block-' . $block_uuid,
      ':class' => 'layout-editor-block-content',
      ':description' => $block_new_description,
    ));
    $this->assertEqual(count($elements), 1, 'The sample block description was changed.');

    // Save the layout.
    $this->backdropPost(NULL, array(), t('Save layout'));

    // Check that the layout is in the listing of layouts.
    $this->backdropGet('admin/structure/layouts');
    $this->assertText(check_plain($layout_title));

    // Go to the the layout path and confirm the block exists, has the right
    // setting, and is the right place.
    $this->backdropGet($layout_url);
    $this->assertText('Foo subject');
    $this->assertText(format_string('The setting of count is @setting.', array('@setting' => 5)));
    $elements = $this->xpath('//*[contains(@class,:region)]//*[contains(@class,:block)]', array(
      ':region' => 'l-sidebar',
      ':block' => 'block-layout-test-foo',
    ));
    $this->assertEqual(count($elements), 1, 'The sample block was found in the sidebar.');

    // Try updating the block title to use a custom string.
    $block_new_title = $this->randomName();
    $edit = array(
      'title_display' => LAYOUT_TITLE_CUSTOM,
      'title' => $block_new_title,
    );
    $this->backdropPost($block_edit_url, $edit, t('Update block'));
    $this->backdropPost(NULL, array(), t('Save layout'));
    $this->backdropGet($layout_url);
    $this->assertText(check_plain($block_new_title));

    // Set the block title to nothing.
    $edit = array(
      'title_display' => LAYOUT_TITLE_NONE,
    );
    $this->backdropPost($block_edit_url, $edit, t('Update block'));
    $this->backdropPost(NULL, array(), t('Save layout'));
    $this->backdropGet($layout_url);
    $this->assertNoText('Foo subject');
    $this->assertNoText($block_new_title);

    // Set the block title back to normal and set a special block class.
    $custom_class = $this->randomName();
    $edit = array(
      'title_display' => LAYOUT_TITLE_DEFAULT,
      'style_settings[classes]' => $custom_class,
    );
    $this->backdropPost($block_edit_url, $edit, t('Update block'));
    $this->backdropPost(NULL, array(), t('Save layout'));

    $this->backdropGet($layout_url);
    $this->assertText('Foo subject');
    $this->assertNoText($block_new_title);
    $block_element = $this->xpath('(//*[contains(@class,:region)]//*[contains(@class,:block)])[contains(@class,:custom-class)]', array(
      ':region' => 'l-sidebar',
      ':block' => 'block-layout-test-foo',
      ':custom-class' => $custom_class,
    ));
    $this->assertEqual(count($block_element), 1, 'The sample block was found in the sidebar.');

    // Use the dynamic block style. Save once to update the form (usually done
    // via AJAX) then, edit and save again with the dynamic settings.
    $title_class = $this->randomName();
    $content_class = $this->randomName();
    $edit = array(
      'style' => 'dynamic',
    );
    $this->backdropPost($block_edit_url, $edit, t('Update block'));
    $edit = array(
      'style_settings[wrapper_tag]' => 'aside',
      'style_settings[title_tag]' => 'h3',
      'style_settings[title_classes]' => $title_class,
      'style_settings[content_tag]' => 'p',
      'style_settings[content_classes]' => $content_class,
    );
    $this->backdropPost($block_edit_url, $edit, t('Update block'));
    $this->backdropPost(NULL, array(), t('Save layout'));

    $this->backdropGet($layout_url);
    $block_element = $this->xpath('(//*[contains(@class,:region)]//aside[contains(@class,:block)])[contains(@class,:custom-class)]', array(
      ':region' => 'l-sidebar',
      ':block' => 'block-layout-test-foo',
      ':custom-class' => $custom_class,
    ));
    $this->assertEqual(count($block_element), 1, 'The sample block was found in the sidebar as an aside tag.');
    if ($block_element) {
      $title_element = $block_element[0]->xpath('h3');
      $content_element = $block_element[0]->xpath('p');
      $this->assertEqual(count($title_element), 1, 'The sample block has the correct H3 heading tag.');
      $this->assertEqual(count($content_element), 1, 'The sample block has the correct P content tag.');
      $this->assertEqual($title_element[0]['class'], $title_class, 'The sample block title has the correct class.');
      $this->assertEqual($content_element[0]['class'], $content_class, 'The sample block content has the correct class.');
    }

    // Try injecting XSS into the classes.
    $xss = '"><svg onload="alert(\'XSS hole\')">';
    // The filtered string after running through backdrop_html_class().
    // cspell:disable-next-line
    $filtered_xss = 'svg onloadalertXSS hole';
    $edit = array(
      'style_settings[classes]' => $xss,
      'style_settings[title_classes]' => $xss,
      'style_settings[content_classes]' => $xss,
    );
    $this->backdropPost($block_edit_url, $edit, t('Update block'));
    $this->backdropPost(NULL, array(), t('Save layout'));

    $this->backdropGet($layout_url);
    $this->assertNoRaw($xss);
    $this->assertRaw($filtered_xss);

    // Try moving the block to a different position within the layout.
    $edit = array(
      'content[positions][content]' => $block_uuid,
      'content[positions][sidebar]' => '',
    );
    $this->backdropPost('admin/structure/layouts/manage/' . $layout_name, $edit, t('Save layout'));
    $this->backdropGet($layout_url);
    $block_element = $this->xpath('//*[contains(@class,:region)]//*[contains(@class,:block)]', array(
      ':region' => 'l-content',
      ':block' => 'block-layout-test-foo',
    ));
    $this->assertEqual(count($block_element), 1, 'The sample block was found in the content area after moving it from the sidebar.');

    // Move the block via the block configuration form.
    $edit = array(
      'region' => 'footer',
    );
    $this->backdropPost($block_edit_url, $edit, t('Update block'));
    $this->backdropPost(NULL, array(), t('Save layout'));

    $this->backdropGet($layout_url);
    $block_element = $this->xpath('(//*[contains(@class,:region)]//*[contains(@class,:block)])', array(
      ':region' => 'l-footer',
      ':block' => 'block-layout-test-foo',
    ));
    $this->assertEqual(count($block_element), 1, 'The sample block was found in the footer after moving via block form.');

    // Try moving the block into the sidebar again via the API.
    backdrop_static_reset();
    $layout = layout_load($layout_name);
    $layout->setBlockPosition($block_uuid, 'sidebar');
    $layout->save();

    $this->backdropGet($layout_url);
    $block_element = $this->xpath('(//*[contains(@class,:region)]//*[contains(@class,:block)])', array(
      ':region' => 'l-sidebar',
      ':block' => 'block-layout-test-foo',
    ));
    $this->assertEqual(count($block_element), 1, 'The sample block was found in the sidebar after moving via the API.');

    // With all the manipulations we've performed, make sure that the block is
    // still only shown once, and did not end up in multiple regions on the page
    // by accident.
    $block_element = $this->xpath('//*[contains(@class,:block)]', array(
      ':block' => 'block-layout-test-foo',
    ));
    $this->assertEqual(count($block_element), 1, 'The sample block is only displayed once after moving it.');

    // Disable the block.
    $this->backdropGet('admin/structure/layouts/manage/' . $layout_name);
    $disable_link = $this->xpath('//*[@data-block-id=:uuid]//a[contains(@class,"disable-block")]', array(
      ':uuid' => $block_uuid,
    ));
    $disable_url_parts = backdrop_parse_url($disable_link[0]['href']);
    $this->backdropGet($disable_url_parts['path'], $disable_url_parts);

    $this->assertText(t('Block "@title" disabled.', array('@title' => $block_new_label)));

    // The block is still present in the UI.
    $elements = $this->xpath('//*[contains(@id,:id)]//*[contains(@class,:class)]//span[normalize-space()=:title]', array(
      ':id' => 'layout-editor-block-' . $block_uuid,
      ':class' => 'layout-editor-block-title',
      ':title' => $block_new_label . ' (Disabled)',
    ));
    $this->assertEqual(count($elements), 1, 'The sample block label was found.');
    $elements = $this->xpath('//*[contains(@id,:id)]//*[contains(@class,:class) and contains(text(), :description)]', array(
      ':id' => 'layout-editor-block-' . $block_uuid,
      ':class' => 'layout-editor-block-content',
      ':description' => $block_new_description,
    ));
    $this->assertEqual(count($elements), 1, 'The sample block description was changed.');

    $this->backdropPost(NULL, array(), t('Save layout'));

    // But is gone from the layout page.
    $this->backdropGet($layout_url);
    $this->assertNoText('Foo subject');
    $block_element = $this->xpath('//*[contains(@class,:block)]', array(
      ':block' => 'block-layout-test-foo',
    ));
    $this->assertEqual(count($block_element), 0, 'The sample block is not visible on the page.');

    // Re-enable the block.
    $this->backdropGet('admin/structure/layouts/manage/' . $layout_name);
    $this->backdropGet($disable_url_parts['path'], $disable_url_parts);

    $this->assertText(t('Block "@title" disabled.', array('@title' => $block_new_label)));

    // The block is still present in the UI.
    $elements = $this->xpath('//*[contains(@id,:id)]//*[contains(@class,:class)]//span[normalize-space()=:title]', array(
      ':id' => 'layout-editor-block-' . $block_uuid,
      ':class' => 'layout-editor-block-title',
      ':title' => $block_new_label,
    ));
    $this->assertEqual(count($elements), 1, 'The sample block label was found.');
    $elements = $this->xpath('//*[contains(@id,:id)]//*[contains(@class,:class) and contains(text(), :description)]', array(
      ':id' => 'layout-editor-block-' . $block_uuid,
      ':class' => 'layout-editor-block-content',
      ':description' => $block_new_description,
    ));
    $this->assertEqual(count($elements), 1, 'The sample block description was changed.');

    $this->backdropPost(NULL, array(), t('Save layout'));

    // Block is back on the layout page.
    $this->backdropGet($layout_url);
    $this->assertText('Foo subject');
    $block_element = $this->xpath('//*[contains(@class,:block)]', array(
      ':block' => 'block-layout-test-foo',
    ));
    $this->assertEqual(count($block_element), 1, 'The sample block is again visible on the page.');

    // Finally, try removing the block.
    $this->backdropGet('admin/structure/layouts/manage/' . $layout_name);
    $remove_link = $this->xpath('//*[@data-block-id=:uuid]//a[contains(@class,"remove-block")]', array(
      ':uuid' => $block_uuid,
    ));
    $remove_url_parts = backdrop_parse_url($remove_link[0]['href']);
    $this->backdropGet($remove_url_parts['path'], $remove_url_parts);
    $this->backdropPost(NULL, array(), t('Save layout'));

    $this->backdropGet($layout_url);
    $this->assertNoText('Foo subject');
    $block_element = $this->xpath('//*[contains(@class,:block)]', array(
      ':block' => 'block-layout-test-foo',
    ));
    $this->assertEqual(count($block_element), 0, 'The sample block has been removed.');

    // Delete the layout to prevent it interfering with following tests.
    $this->backdropPost('admin/structure/layouts/manage/' . $layout_name . '/delete', array(), t('Delete layout'));
  }

  /**
   * Test block path and type conditions.
   */
  function testBlockPathTypeConditions() {
    // Create a new layout overriding node/%.
    $layout_title = $this->randomName();
    $layout_name = strtolower($layout_title);
    $layout_url = 'node/%';
    $edit = array(
      'title' => $layout_title,
      'name' => $layout_name,
      'layout_template' => 'moscone_flipped',
      'path' => $layout_url,
    );
    $this->backdropPost('admin/structure/layouts/add', $edit, t('Create layout'));

    // Add a testing block, shown only on page nodes.
    $this->clickLink(t('Add block'), 3);
    $this->clickLink(t('Layout foo block'));
    $block_title = $this->randomString();
    $edit = array(
      'title_display' => LAYOUT_TITLE_CUSTOM,
      'title' => $block_title,
    );
    $this->backdropPost(NULL, $edit, t('Add condition'));
    $edit = array(
      'condition' => 'node_type',
    );
    $this->backdropPost(NULL, $edit, t('Load condition'));
    $edit = array(
      'bundles[page]' => TRUE,
    );
    $this->backdropPost(NULL, $edit, t('Add condition'));
    $this->backdropPost(NULL, array(), t('Update block'));
    $this->backdropPost(NULL, array(), t('Save layout'));

    $this->backdropGet('node/' . $this->test_node1->nid);
    $this->assertNoText(check_plain($block_title), 'Block not shown on post content.');

    $this->backdropGet('node/' . $this->test_node2->nid);
    $this->assertText(check_plain($block_title), 'Block shown on page content.');

    // Get the block UUID.
    layout_reset_caches();
    $layout = layout_load($layout_name);
    $block_uuid = end($layout->positions['sidebar']);

    // Edit condition to show this block only on post nodes.
    $this->backdropGet('admin/structure/layouts/manage/' . $layout_name . '/configure-block/editor/' . $block_uuid);
    $this->backdropPost(NULL, array(), t('Configure'));
    $this->assertRaw('<label for="edit-bundles">Node Type </label>');

    $edit = array(
      'condition' => 'node_type',
    );
    $this->backdropPost(NULL, $edit, t('Load condition'));
    $edit = array(
      'bundles[post]' => TRUE,
      'bundles[page]' => FALSE,
    );
    $this->backdropPost(NULL, $edit, t('Save visibility condition'));
    $this->backdropPost(NULL, array(), t('Update block'));
    $this->backdropPost(NULL, array(), t('Save layout'));

    $this->backdropGet('node/' . $this->test_node1->nid);
    $this->assertText(check_plain($block_title), 'Block shown on post content.');

    $this->backdropGet('node/' . $this->test_node2->nid);
    $this->assertNoText(check_plain($block_title), 'Block not shown on page content.');

    // Add another condition to show this block only on a single node path.
    $this->backdropGet('admin/structure/layouts/manage/' . $layout_name . '/configure-block/editor/' . $block_uuid);
    $this->backdropPost(NULL, array(), t('Add condition'));
    $edit = array(
      'condition' => 'path',
    );
    $this->backdropPost(NULL, $edit, t('Load condition'));
    $edit = array(
      'paths' => 'node/' . $this->test_node1->nid,
    );
    $this->backdropPost(NULL, $edit, t('Add condition'));
    $this->backdropPost(NULL, array(), t('Update block'));
    $this->backdropPost(NULL, array(), t('Save layout'));

    // Create another post node and check the combination of conditions work.
    $second_post = $this->backdropCreateNode(array(
      'type' => 'post',
      'title' => $this->randomString(),
    ));
    $this->backdropGet('node/' . $this->test_node1->nid);
    $this->assertText(check_plain($block_title), 'Block shown on post content and path matches.');

    $this->backdropGet('node/' . $second_post->nid);
    $this->assertNoText(check_plain($block_title), 'Block not shown on post content when path does not match.');
  }

  /**
   * Test block entity ID conditions.
   */
  function testBlockEntityIDConditions() {
    // Create a new layout overriding node/%.
    $layout_title = $this->randomName();
    $layout_name = strtolower($layout_title);
    $layout_url = 'node/%';
    $edit = array(
      'title' => $layout_title,
      'name' => $layout_name,
      'layout_template' => 'moscone_flipped',
      'path' => $layout_url,
    );
    $this->backdropPost('admin/structure/layouts/add', $edit, t('Create layout'));

    // Create another post node.
    $second_post = $this->backdropCreateNode(array(
      'type' => 'post',
      'title' => $this->randomString(),
    ));

    // Add another testing block.
    $this->clickLink(t('Add block'), 3);
    $this->clickLink(t('Layout foo block'));
    $block_title = $this->randomString();
    $edit = array(
      'title_display' => LAYOUT_TITLE_CUSTOM,
      'title' => $block_title,
    );
    $this->backdropPost(NULL, $edit, t('Add condition'));
    $edit = array(
      'condition' => 'node_nid',
    );
    $this->backdropPost(NULL, $edit, t('Load condition'));
    $edit = array(
      'entity_id' => $this->test_node1->nid,
    );
    $this->backdropPost(NULL, $edit, t('Add condition'));
    $this->backdropPost(NULL, array(), t('Update block'));
    $this->backdropPost(NULL, array(), t('Save layout'));

    $this->backdropGet('node/' . $this->test_node1->nid);
    $this->assertText(check_plain($block_title), 'Block shown and node ID matches.');

    $this->backdropGet('node/' . $second_post->nid);
    $this->assertNoText(check_plain($block_title), 'Block not shown when node ID does not match.');

    // Get the block UUID.
    layout_reset_caches();
    $layout = layout_load($layout_name);
    $block_uuid = end($layout->positions['sidebar']);

    // Add another condition to show this block only for a particular user ID.
    $this->backdropGet('admin/structure/layouts/manage/' . $layout_name . '/configure-block/editor/' . $block_uuid);
    $this->backdropPost(NULL, array(), t('Add condition'));
    $edit = array(
      'condition' => 'user_uid',
    );
    $this->backdropPost(NULL, $edit, t('Load condition'));
    $edit = array(
      'entity_id' => $this->web_user->uid,
    );
    $this->backdropPost(NULL, $edit, t('Add condition'));
    $this->backdropPost(NULL, array(), t('Update block'));
    $this->backdropPost(NULL, array(), t('Save layout'));

    $this->backdropGet('node/' . $this->test_node1->nid);
    $this->assertNoText(check_plain($block_title), 'Block not shown when user ID does not match.');

    $this->backdropGet('node/' . $second_post->nid);
    $this->assertNoText(check_plain($block_title), 'Block not shown when user ID does not match.');

    // Login as a the web user and test that the block is now shown.
    $this->backdropLogin($this->web_user);

    $this->backdropGet('node/' . $this->test_node1->nid);
    $this->assertText(check_plain($block_title), 'Block shown when user ID and node ID matches.');

    $this->backdropGet('node/' . $second_post->nid);
    $this->assertNoText(check_plain($block_title), 'Block not shown when user ID and node ID does not match.');
  }

  /**
   * Tests user account comparison condition.
   */
  function testBlockUserCompareConditions() {
    // Create a new layout overriding user/%.
    $layout_title = $this->randomName();
    $layout_name = strtolower($layout_title);
    $layout_url = 'user/%';
    $edit = array(
      'title' => $layout_title,
      'name' => $layout_name,
      'layout_template' => 'moscone_flipped',
      'path' => $layout_url,
    );
    $this->backdropPost('admin/structure/layouts/add', $edit, t('Create layout'));

    // Add another testing block.
    $this->clickLink(t('Add block'), 3);
    $this->clickLink(t('Layout foo block'));
    $block_title = $this->randomString();
    $edit = array(
      'title_display' => LAYOUT_TITLE_CUSTOM,
      'title' => $block_title,
    );
    $this->backdropPost(NULL, $edit, t('Add condition'));
    $edit = array(
      'condition' => 'user_compare',
    );
    $this->backdropPost(NULL, $edit, t('Load condition'));

    // The user account comparison form has some customizations. Verify the
    // fields show as expected.
    $this->assertOption('edit-contexts-user2', '1', 'User account from path in position 2 selected as second comparison user account.');
    $this->assertNoOption('edit-contexts-user2', 'current_user');

    $edit = array(
      'contexts[user2]' => '1',
      'equality' => '1',
    );
    $this->backdropPost(NULL, $edit, t('Add condition'));
    $this->backdropPost(NULL, array(), t('Update block'));
    $this->backdropPost(NULL, array(), t('Save layout'));

    $this->backdropGet('user/' . $this->admin_user->uid);
    $this->assertText(check_plain($block_title), 'Block shown when user views own profile page.');

    $this->backdropGet('user/' . $this->web_user->uid);
    $this->assertNoText(check_plain($block_title), 'Block not shown when user views profile page of another user.');

    // Get the block UUID.
    layout_reset_caches();
    $layout = layout_load($layout_name);
    $block_uuid = end($layout->positions['sidebar']);

    // Update the condition to do the opposite, where a block is only shown to
    // a user viewing their own profile page.
    $this->backdropGet('admin/structure/layouts/manage/' . $layout_name . '/configure-block/editor/' . $block_uuid);
    $this->backdropPost(NULL, array(), t('Configure'));
    $edit = array(
      'equality' => '0',
    );
    $this->backdropPost(NULL, $edit, t('Save visibility condition'));
    $this->backdropPost(NULL, array(), t('Update block'));
    $this->backdropPost(NULL, array(), t('Save layout'));

    $this->backdropGet('user/' . $this->admin_user->uid);
    $this->assertNoText(check_plain($block_title), 'Block not shown when user views own profile page');

    $this->backdropGet('user/' . $this->web_user->uid);
    $this->assertText(check_plain($block_title), 'Block shown when user views profile page of another user.');
  }

  /**
   * Tests 403 and 404 visibility conditions.
   */
  function testBlockHttpResponseCodeConditions() {
    // Create a new layout at a custom path.
    $layout_title = 'Response Codes Test';
    $layout_name = 'response_codes_test';
    $layout_url = 'response-codes-test';
    $edit = array(
      'title' => $layout_title,
      'name' => $layout_name,
      'layout_template' => 'moscone_flipped',
      'path' => $layout_url,
    );
    $this->backdropPost('admin/structure/layouts/add', $edit, t('Create layout'));

    // Add a test block that shows on 404 pages only.
    $this->clickLink(t('Add block'), 3);
    $this->clickLink(t('Layout foo block'));
    $block_title_404 = $this->randomString();
    $edit = array(
      'title_display' => LAYOUT_TITLE_CUSTOM,
      'title' => $block_title_404,
    );
    $this->backdropPost(NULL, $edit, t('Add condition'));
    $edit = array(
      'condition' => 'http_response_code',
    );
    $this->backdropPost(NULL, $edit, t('Load condition'));
    $edit = array(
      'http_response_codes[404]' => TRUE,
    );
    $this->backdropPost(NULL, $edit, t('Add condition'));
    $this->backdropPost(NULL, array(), t('Update block'));

    // Add another test block that shows on 403 pages only.
    $this->clickLink(t('Add block'), 3);
    $this->clickLink(t('Layout foo block'));
    $block_title_403 = $this->randomString();
    $edit = array(
      'title_display' => LAYOUT_TITLE_CUSTOM,
      'title' => $block_title_403,
    );
    $this->backdropPost(NULL, $edit, t('Add condition'));
    $edit = array(
      'condition' => 'http_response_code',
    );
    $this->backdropPost(NULL, $edit, t('Load condition'));
    $edit = array(
      'http_response_codes[403]' => TRUE,
    );
    $this->backdropPost(NULL, $edit, t('Add condition'));
    $this->backdropPost(NULL, array(), t('Update block'));

    // Add another test block that shows non-200 pages only.
    $this->clickLink(t('Add block'), 3);
    $this->clickLink(t('Layout foo block'));
    $block_title_non_200 = $this->randomString();
    $edit = array(
      'title_display' => LAYOUT_TITLE_CUSTOM,
      'title' => $block_title_non_200,
    );
    $this->backdropPost(NULL, $edit, t('Add condition'));
    $edit = array(
      'condition' => 'http_response_code',
    );
    $this->backdropPost(NULL, $edit, t('Load condition'));
    $edit = array(
      'http_response_codes[200]' => TRUE,
      'negate' => TRUE,
    );
    $this->backdropPost(NULL, $edit, t('Add condition'));
    $this->backdropPost(NULL, array(), t('Update block'));

    // Save the entire layout.
    $this->backdropPost(NULL, array(), t('Save layout'));

    // Set this test layout as the 404 page.
    $edit = array(
      'site_404' => 'response-codes-test',
      'site_403' => 'response-codes-test',
    );
    $this->backdropPost('admin/config/system/site-information', $edit, t('Save configuration'));

    // When visiting the layout directly, none of the blocks should show.
    $this->backdropGet('response-codes-test');
    $this->assertNoText(check_plain($block_title_403), 'Block not shown when not on a 403 page.');
    $this->assertNoText(check_plain($block_title_404), 'Block not shown when not on a 404 page.');
    $this->assertNoText(check_plain($block_title_non_200), 'Block not shown when not on a non-200 page.');

    // Now visit a non-existent page, which should show the 404 block.
    $this->backdropGet('non-existent-page-test-url');
    $this->assertText(check_plain($block_title_404), 'Block shown when on a 404 page.');
    $this->assertText(check_plain($block_title_non_200), 'Block shown when on a non-200 page.');

    // Log out and visit an access denied page.
    $this->backdropLogout();
    $this->backdropGet('admin');
    $this->assertText(check_plain($block_title_403), 'Block shown when on a 403 page.');
    $this->assertText(check_plain($block_title_non_200), 'Block shown when on a non-200 page.');
  }

  /**
   * Test the support for contexts within conditions and blocks.
   */
  function testContexts() {
    // Make a new layout that creates a custom path with placeholders.
    $layout_title = $this->randomName();
    $layout_name = strtolower($layout_title);
    $layout_path = 'node/%/foo/%';
    $edit = array(
      'title' => $layout_title,
      'name' => $layout_name,
      'layout_template' => 'moscone_flipped',
      'path' => $layout_path,
    );
    // Check the path first to populate available contexts.
    $this->backdropPost('admin/structure/layouts/add', $edit, t('Check path'));

    // The first context (node) should be auto-detected and not require a value.
    $edit = array(
      'context[required][3][plugin]' => 'user',
    );
    $this->backdropPost('admin/structure/layouts/add', $edit, t('Create layout'));

    // Add the test block that requires both node and user contexts.
    $this->clickLink(t('Add block'), 2);
    $this->assertText(t('A testing block for layouts with contexts.'));
    $this->clickLink(t('Layout bar block'));

    $this->assertNoField('contexts[my_node]', 'Node context selector not shown, only a single option.');
    $this->assertField('contexts[my_user]', 'User context selector is shown.');
    $this->backdropPost(NULL, array(), t('Add block'));

    // Record the UUID for the newly added block.
    $last_block = $this->xpath('(//*[@id="layout-content-form"]//*[contains(@class,:region)]//*[@data-block-id])[last()]', array(
      ':region' => 'l-content',
    ));
    $block_uuid = (string) $last_block[0]['data-block-id'];
    $block_edit_url = 'admin/structure/layouts/manage/' . $layout_name . '/configure-block/editor/' . $block_uuid;

    $this->backdropPost(NULL, array(), t('Save layout'));

    $this->backdropGet('node/' . $this->test_node1->nid . '/foo/' . $this->web_user->uid);
    $this->assertText(format_string('The user email is @mail and the node title is @title', array('@mail' => $this->web_user->mail, '@title' => $this->test_node1->title)));

    // Modify the layout path to remove "node/", removing the auto-selection.
    $edit = array(
      'path' => 'foo/%/bar/%',
    );
    $this->backdropPost('admin/structure/layouts/manage/' . $layout_name . '/configure', $edit, t('Check path'));
    $edit = array(
      'context[required][1][plugin]' => 'node',
    );
    $this->backdropPost(NULL, $edit, t('Save layout'));

    // Check that the block still works, even with the contexts changed.
    $this->backdropGet('foo/' . $this->test_node1->nid . '/bar/' . $this->web_user->uid);
    $this->assertText(format_string('The user email is @mail and the node title is @title', array('@mail' => $this->web_user->mail, '@title' => $this->test_node1->title)));

    // Change the second context to be a node context. The user context should
    // still work, as it will use the current user context.
    $edit = array(
      'context[required][3][plugin]' => 'node',
    );
    $this->backdropPost('admin/structure/layouts/manage/' . $layout_name . '/configure', $edit, t('Save layout'));

    // Now the page should show the current user instead of the one in the URL.
    $this->backdropGet('foo/' . $this->test_node1->nid . '/bar/' . $this->test_node2->nid);
    $this->assertText(format_string('The user email is @mail and the node title is @title', array('@mail' => $this->admin_user->mail, '@title' => $this->test_node1->title)));

    // Change the "my_node" context to use the argument in position 3 instead
    // of position 1.
    $this->backdropGet($block_edit_url);
    $this->assertField('contexts[my_node]', 'Node context selector is shown.');
    $this->assertNoField('contexts[my_user]', 'User context selector is not shown, only the current user available.');

    $edit = array(
      'contexts[my_node]' => '3',
    );
    $this->backdropPost(NULL, $edit, t('Update block'));
    $this->backdropPost(NULL, array(), t('Save layout'));

    // Now the second node should be used as the title in the page.
    $this->backdropGet('foo/' . $this->test_node1->nid . '/bar/' . $this->test_node2->nid);
    $this->assertText(format_string('The user email is @mail and the node title is @title', array('@mail' => $this->admin_user->mail, '@title' => $this->test_node2->title)));

    // Delete the layout to prevent it interfering with following tests.
    $this->backdropPost('admin/structure/layouts/manage/' . $layout_name . '/delete', array(), t('Delete layout'));

    // Make a new layout that creates a custom path with a string pass-through.
    $layout_title = $this->randomName();
    $layout_name = strtolower($layout_title);
    $layout_path = 'passthrough/%';
    $edit = array(
      'title' => $layout_title,
      'name' => $layout_name,
      'layout_template' => 'boxton',
      'path' => $layout_path,
    );
    // Create with the default context (string pass-through).
    $this->backdropPost('admin/structure/layouts/add', $edit, t('Create layout'));

    // Add the test block that requires both node and user contexts.
    $this->clickLink(t('Add block'), 2);
    $this->clickLink(t('String pass-through test'));
    $this->backdropPost(NULL, array(), t('Add block'));
    $this->backdropPost(NULL, array(), t('Save layout'));

    $argument_string = 'argument-value-from-url';
    $this->backdropGet('passthrough/' . $argument_string);
    $this->assertText(format_string('The page argument is @string', array('@string' => $argument_string)));

    // Test custom contexts.
    // Make a new layout with a random path.
    $layout_title = $this->randomName();
    $layout_name = strtolower($layout_title);
    $layout_path = $layout_name;
    $edit = array(
      'title' => $layout_title,
      'name' => $layout_name,
      'layout_template' => 'moscone_flipped',
      'path' => $layout_path,
    );
    // Check the path first to populate available contexts.
    $this->backdropPost('admin/structure/layouts/add', $edit, t('Check path'));

    $this->assertNoText(t('Node ID: 1'));
    $this->assertNoText(t('Node ID: 2'));
    $this->assertNoText(t('User account ID: 3'));

    $this->backdropPost('admin/structure/layouts/add', array(), t('Create layout'));

    // Check that the test block that requires both node and user contexts is
    // not available.
    $this->clickLink(t('Add block'), 2);
    $this->assertNoText(t('A testing block for layouts with contexts.'));

    // Test custom context validation.
    $edit = array();
    $this->backdropPost('admin/structure/layouts/manage/' . $layout_name . '/configure', $edit, t('Add context'));

    // Add a custom node context to the layout.
    $edit = array(
      'context' => 'node',
    );
    $this->backdropPost(NULL, $edit, t('Load context'));
    $edit = array(
      'id' => '2',
    );
    $this->backdropPost(NULL, $edit, t('Add context'));

    $this->assertNoText(t('Node ID: 1'));
    $this->assertText(t('Node ID: 2'));
    $this->assertNoText(t('User account ID: 3'));

    // Test configuring custom contexts.
    // Saving a File context will fail since no files have been created yet.
    $this->backdropPost(NULL, array(), t('Configure'));
    $edit = array(
      'context' => 'file',
    );
    $this->backdropPost(NULL, $edit, t('Load context'));
    $edit = array(
      'id' => '1',
    );
    $this->backdropPost(NULL, $edit, t('Save context'));
    $error_message = t('The selected File does not exist.');
    $this->assertRaw($error_message);
    $edit = array(
      'id' => '',
    );
    $this->backdropPost(NULL, $edit, t('Save context'));
    $error_message = t('An ID is required.');
    $this->assertRaw($error_message);
    $this->backdropPost(NULL, $edit, t('Cancel'));

    $this->backdropPost(NULL, array(), t('Remove'));

    $this->assertNoText(t('Node ID: 1'));
    $this->assertNoText(t('Node ID: 2'));
    $this->assertNoText(t('User account ID: 3'));

    // Add a custom node context to the layout.
    $this->backdropPost(NULL, array(), t('Add context'));
    $edit = array(
      'context' => 'node',
    );
    $this->backdropPost(NULL, $edit, t('Load context'));
    $edit = array(
      'id' => '1',
    );
    $this->backdropPost(NULL, $edit, t('Add context'));

    $this->assertText(t('Node ID: 1'));
    $this->assertNoText(t('Node ID: 2'));
    $this->assertNoText(t('User account ID: 3'));

    $this->backdropPost(NULL, array(), t('Save layout'));

    // Check that the test block that requires both node and user contexts is
    // now available.
    $this->clickLink(t('Add block'), 2);
    $this->assertText(t('A testing block for layouts with contexts.'));
    $this->clickLink(t('Layout bar block'));

    $this->assertNoField('contexts[my_node]', 'Node context selector not shown, only a single option.');
    $this->assertNoField('contexts[my_user]', 'User context selector is not shown.');
    $this->backdropPost(NULL, array(), t('Add block'));

    // Record the UUID for the newly added block.
    $last_block = $this->xpath('(//*[@id="layout-content-form"]//*[contains(@class,:region)]//*[@data-block-id])[last()]', array(
      ':region' => 'l-content',
    ));
    $block_uuid = (string) $last_block[0]['data-block-id'];
    $block_edit_url = 'admin/structure/layouts/manage/' . $layout_name . '/configure-block/editor/' . $block_uuid;

    $this->backdropPost(NULL, array(), t('Save layout'));

    $this->backdropGet($layout_path);
    $this->assertText(format_string('The user email is @mail and the node title is @title', array('@mail' => $this->admin_user->mail, '@title' => $this->test_node1->title)));

    // Add another custom node context to the layout.
    $edit = array();
    $this->backdropPost('admin/structure/layouts/manage/' . $layout_name . '/configure', $edit, t('Add context'));
    $edit = array(
      'context' => 'node',
    );
    $this->backdropPost(NULL, $edit, t('Load context'));
    $edit = array(
      'id' => '2',
    );
    $this->backdropPost(NULL, $edit, t('Add context'));

    $this->assertText(t('Node ID: 1'));
    $this->assertText(t('Node ID: 2'));
    $this->assertNoText(t('User account ID: 3'));

    $this->backdropPost(NULL, array(), t('Save layout'));

    $this->backdropGet($block_edit_url);
    $this->assertField('contexts[my_node]', 'Node context selector is shown.');
    $this->assertNoField('contexts[my_user]', 'User context selector is not shown, only the current user available.');

    $edit = array(
      'contexts[my_node]' => 'node2',
    );
    $this->backdropPost(NULL, $edit, t('Update block'));
    $this->backdropPost(NULL, array(), t('Save layout'));

    // Now the second node should be used as the title in the page.
    $this->backdropGet($layout_path);
    $this->assertText(format_string('The user email is @mail and the node title is @title', array('@mail' => $this->admin_user->mail, '@title' => $this->test_node2->title)));

    // Add a custom user context to the layout.
    $edit = array();
    $this->backdropPost('admin/structure/layouts/manage/' . $layout_name . '/configure', $edit, t('Add context'));
    $edit = array(
      'context' => 'user',
    );
    $this->backdropPost(NULL, $edit, t('Load context'));
    $edit = array(
      'id' => $this->web_user->uid,
    );
    $this->backdropPost(NULL, $edit, t('Add context'));

    $this->assertText(t('Node ID: 1'));
    $this->assertText(t('Node ID: 2'));
    $this->assertText(t('User account ID: 3'));

    $this->backdropPost(NULL, array(), t('Save layout'));

    $this->backdropGet($block_edit_url);
    $this->assertField('contexts[my_node]', 'Node context selector is shown.');
    $this->assertField('contexts[my_user]', 'User context selector is shown.');

    $edit = array(
      'contexts[my_user]' => 'user3',
    );
    $this->backdropPost(NULL, $edit, t('Update block'));
    $this->backdropPost(NULL, array(), t('Save layout'));

    // Now the web user's name should be used as the title in the page.
    $this->backdropGet($layout_path);
    $this->assertText(format_string('The user email is @mail and the node title is @title', array('@mail' => $this->web_user->mail, '@title' => $this->test_node2->title)));

    // Test that custom layouts and path layouts work together.
    $layout_title = $this->randomName();
    $layout_name = strtolower($layout_title);
    $layout_path = 'node/%';
    $edit = array(
      'title' => $layout_title,
      'name' => $layout_name,
      'layout_template' => 'moscone_flipped',
      'path' => $layout_path,
    );
    // Check the path first to populate available contexts.
    $this->backdropPost('admin/structure/layouts/add', $edit, t('Check path'));

    $this->assertNoText(t('Node ID: 1'));
    $this->backdropPost('admin/structure/layouts/add', array(), t('Create layout'));

    // Add a custom node context to the layout.
    $edit = array();
    $this->backdropPost('admin/structure/layouts/manage/' . $layout_name . '/configure', $edit, t('Add context'));
    $edit = array(
      'context' => 'node',
    );
    $this->backdropPost(NULL, $edit, t('Load context'));
    $edit = array(
      'id' => '2',
    );
    $this->backdropPost(NULL, $edit, t('Add context'));

    $this->assertText(t('Position 2: node/%'));
    $this->assertText(t('Node ID: 2'));
    $this->backdropPost(NULL, array(), t('Save layout'));

    // Check that the test block that requires both node and user contexts is
    // now available.
    $this->clickLink(t('Add block'), 2);
    $this->assertText(t('A testing block for layouts with contexts.'));
    $this->clickLink(t('Layout bar block'));

    $this->assertField('contexts[my_node]', 'Node context selector shown.');

    $edit = array(
      'contexts[my_node]' => 'node2',
    );
    $this->backdropPost(NULL, array(), t('Add block'));

    $this->backdropPost(NULL, array(), t('Save layout'));

    // Go to a node path and check that the block shows with the correct
    // content.
    $this->backdropGet('node/' . $this->test_node1->nid);
    $this->assertText(format_string('The user email is @mail and the node title is @title', array('@mail' => $this->admin_user->mail, '@title' => $this->test_node2->title)));

  }

  /**
   * Test the overriding of paths.
   */
  function testOverriddenPaths() {
    // Make a new layout that creates a custom path with placeholders.
    $layout_name = 'node';
    $layout_title = 'Generic Node';
    $layout_path = 'node/%';
    $edit = array(
      'title' => $layout_title,
      'name' => $layout_name,
      'layout_template' => 'moscone_flipped',
      'path' => $layout_path,
    );
    // Save directly without checking contexts.
    $this->backdropPost('admin/structure/layouts/add', $edit, t('Create layout'));

    // Add a block to the sidebar.
    $this->clickLink(t('Add block'), 3);
    $this->clickLink(t('Node title test'));
    $this->backdropPost(NULL, array(), t('Add block'));

    // Record the UUID for the newly added block.
    $last_block = $this->xpath('(//*[contains(@class,:region)]//*[@data-block-id])[last()]', array(
      ':region' => 'l-sidebar',
    ));
    //$block_uuid = (string) $last_block[0]['data-block-id'];

    // Change the title type to custom.
    $edit = array(
      'title_display' => LAYOUT_TITLE_CUSTOM,
      'title' => 'Generic node title',
    );
    $this->backdropPost('admin/structure/layouts/manage/' . $layout_name . '/edit-title/editor/title', $edit, t('Save configuration'));
    $this->backdropPost('admin/structure/layouts/manage/' . $layout_name, array(), t('Save layout'));

    // Visit the sample node page and check that the block is visible.
    $this->backdropGet('node/1');
    $block_element = $this->xpath('//*[contains(@class,:region)]//*[contains(@class,:block)]', array(
      ':region' => 'l-sidebar',
      ':block' => 'block-layout-test-test-node-title',
    ));
    $this->assertEqual(count($block_element), 1, 'The block is shown on the overridden path.');
    $this->assertText($this->test_node1->body[LANGUAGE_NONE][0]['value'], 'Current page content is still shown on the overridden path.');

    // Clone the layout and make a second overriding item at the same path.
    $clone_layout_name = 'node_post';
    $edit = array(
      'name' => $clone_layout_name,
      'title' => 'Post node',
    );
    $this->backdropPost('admin/structure/layouts/manage/' . $layout_name . '/clone', $edit, t('Clone layout'));
    $this->assertText('You may now configure the cloned layout.', 'Layout cloned and landed on settings page.');
    $this->backdropPost(NULL, array(), t('Add condition'));
    $edit = array(
      'condition' => 'node_type',
    );
    $this->backdropPost(NULL, $edit, t('Load condition'));
    $edit = array(
      'bundles[post]' => TRUE,
    );
    $this->backdropPost(NULL, $edit, t('Add condition'));
    $this->backdropPost(NULL, array(), t('Save layout'));

    // Record the UUID for the same block in this layout.
    $last_block = $this->xpath('(//*[contains(@class,:region)]//*[@data-block-id])[last()]', array(
      ':region' => 'l-sidebar',
    ));
    $block_uuid = (string) $last_block[0]['data-block-id'];

    $edit = array(
      'title_display' => LAYOUT_TITLE_BLOCK,
      'title_block' => $block_uuid,
    );
    $this->backdropPost('admin/structure/layouts/manage/' . $clone_layout_name . '/edit-title/editor/title', $edit, t('Save configuration'));
    $this->backdropPost('admin/structure/layouts/manage/' . $clone_layout_name, array(), t('Save layout'));

    $this->backdropGet('node/' . $this->test_node1->nid);
    $this->assertText('Node title', 'The node-type specific layout is used over the generic layout, and the page title is copied from the block title.');

    $this->backdropGet('node/' . $this->test_node2->nid);
    $this->assertText('Generic node title', 'The generic layout is used when there is not a more specific layout.');

    // Check the weights of the layout to ensure they have the correct defaults,
    // then rearrange and check the paths again.
    $this->backdropGet('admin/structure/layouts/reorder', array('query' => array('layouts' => array('node_post', 'node'))));
    $this->assertFieldByXPath('//select[@name="layouts[' . $clone_layout_name . '][weight]"]', '-1');
    $this->assertFieldByXPath('//select[@name="layouts[' . $layout_name . '][weight]"]', '0');

    $edit = array(
      'layouts[node_post][weight]' => 1,
    );
    $this->backdropPost(NULL, $edit, t('Save order'));

    // Now both layouts should use the generic layout.
    $this->backdropGet('node/' . $this->test_node1->nid);
    $this->assertText('Generic node title', 'The generic layout is used on post content.');
    $this->backdropGet('node/' . $this->test_node2->nid);
    $this->assertText('Generic node title', 'The generic layout is used on generic content.');

    // Delete these layouts and ensure it goes back to the default layout.
    $this->backdropPost('admin/structure/layouts/manage/' . $layout_name . '/delete', array(), t('Delete layout'));
    $this->backdropPost('admin/structure/layouts/manage/' . $clone_layout_name . '/delete', array(), t('Delete layout'));

    $this->backdropGet('node/' . $this->test_node1->nid);
    $this->assertNoText('Generic node title', 'The generic node layout has been deleted.');
    $this->assertNoText('Post node title', 'The post node layout has been deleted.');
    $this->assertRaw(check_markup($this->test_node1->body[LANGUAGE_NONE][0]['value'], $this->test_node1->body[LANGUAGE_NONE][0]['format']), 'The default layout is now displaying the node.');
  }

  /**
   * Check special conditions around the main content block.
   */
  function testMainContentBlock() {
    // Make a new layout that overrides an existing path.
    $layout_title = $this->randomName();
    $layout_name = strtolower($layout_title);
    $layout_path = 'layout-test-path'; // Provided by layout_test.module.
    $edit = array(
      'title' => $layout_title,
      'name' => $layout_name,
      'layout_template' => 'moscone_flipped',
      'path' => $layout_path,
    );
    // Save directly without checking contexts.
    $this->backdropPost('admin/structure/layouts/add', $edit, t('Create layout'));

    // Add the main content block to the sidebar.
    $this->clickLink(t('Add block'), 3);
    $this->clickLink(t('Main page content'));
    $this->backdropPost(NULL, array(), t('Add block'));

    // Record the UUID for the newly added block.
    $last_block = $this->xpath('(//*[@id="layout-edit-main"]//*[contains(@class,:region)]//*[@data-block-id])[last()]', array(
      ':region' => 'l-sidebar',
    ));
    $new_content_block_uuid = (string) $last_block[0]['data-block-id'];

    // Save the layout.
    $edit = array(
      'title_display' => LAYOUT_TITLE_CUSTOM,
      'title' => 'Generic node title',
    );
    $this->backdropPost('admin/structure/layouts/manage/' . $layout_name . '/edit-title/editor/title', $edit, t('Save configuration'));
    $this->backdropPost('admin/structure/layouts/manage/' . $layout_name, array(), t('Save layout'));

    // Check that the validation prevented two main content blocks.
    $this->assertText(t('The "@block" block may only be added once to this layout.', array('@block' => t('Main page content'))));

    // Delete the previous content block.
    $old_content_block = $this->xpath('//*[@id="layout-edit-main"]//*[contains(@class,:region)]//*[@data-block-id]', array(
      ':region' => 'l-content',
    ));
    $old_content_block_uuid = (string) $old_content_block[0]['data-block-id'];
    $remove_link = $this->xpath('//*[@id="layout-edit-main"]//*[@data-block-id=:uuid]//a[contains(@class,"remove-block")]', array(
      ':uuid' => $old_content_block_uuid,
    ));
    $remove_url_parts = backdrop_parse_url($remove_link[0]['href']);
    $this->backdropGet($remove_url_parts['path'], $remove_url_parts);

    $this->backdropPost(NULL, array(), t('Save layout'));
    $this->assertText(t('Layout content saved.'), 'Layout saved successfully after removing old content block.');

    // Check the front-end that the content is shown in the sidebar. Note that
    // the main content block does *not* have any wrappers, so we check directly
    // for the content we expect at /node, which is a list of post tags.
    $this->backdropGet($layout_path);
    $front_end_content = $this->xpath('//*[contains(@class,:region)]/div[@id=:page-content]', array(
      ':region' => 'l-sidebar',
      ':page-content' => 'layout-test-page-content',
    ));
    $this->assertEqual(count($front_end_content), 1, 'Main content shown in sidebar after moving main content block.');

    // Now remove the second main content block, which should be allowed even
    // though it is potentially a bad idea.
    $this->backdropGet('admin/structure/layouts/manage/' . $layout_name);
    $remove_link = $this->xpath('//*[@data-block-id=:uuid]//a[contains(@class,"remove-block")]', array(
      ':uuid' => $new_content_block_uuid,
    ));
    $remove_url_parts = backdrop_parse_url($remove_link[0]['href']);
    $this->backdropGet($remove_url_parts['path'], $remove_url_parts);

    $this->backdropPost(NULL, array(), t('Save layout'));
    $this->assertText(t('Layout content saved.'));

    // Check that the main content block is no longer displayed at all.
    $this->backdropGet($layout_path);
    $front_end_content = $this->xpath('//*[@id=:id]', array(
      ':id' => 'layout-test-page-content',
    ));
    $this->assertEqual(count($front_end_content), 0, 'Main content is no longer shown at all.');

    // Edit the default layout and ensure that the main content block cannot be
    // removed.
    $this->backdropGet('admin/structure/layouts/manage/default');
    $default_content_block = $this->xpath('//*[@id="layout-edit-main"]//*[contains(@class,:region)]//*[@data-block-id]', array(
      ':region' => 'l-content',
    ));
    $default_content_block_uuid = (string) $default_content_block[0]['data-block-id'];
    $remove_link = $this->xpath('//*[@data-block-id=:uuid]//a[contains(@class,"remove-block")]', array(
      ':uuid' => $default_content_block_uuid,
    ));
    $remove_url_parts = backdrop_parse_url($remove_link[0]['href']);
    $this->backdropGet($remove_url_parts['path'], $remove_url_parts);

    $this->backdropPost(NULL, array(), t('Save layout'));
    $this->assertText(t('The "@block" block must be added to this layout.', array('@block' => t('Main page content'))));

    // Cancel the changes to the default layout.
    $this->backdropPost(NULL, array(), t('Cancel'));

    // Delete the previous test layout.
    $layout = layout_load($layout_name);
    $layout->delete();

  }

  /**
   * Tests conditions and menu item navigation.
   */
  function testLayoutMenuItems() {
    $layout_name = strtolower($this->randomName());
    $layout_path = $layout_name . '/' . strtolower($this->randomName());
    $edit = array(
      'name' => $layout_name,
      'title' => $layout_name,
      'path' => $layout_path,
      'layout_template' => 'moscone_flipped',
    );
    $this->backdropPost('admin/structure/layouts/add', $edit, t('Create layout'));

    $edit = array(
      'title_display' => LAYOUT_TITLE_CUSTOM,
      'title' => 'Menu item test',
    );
    $this->backdropPost('admin/structure/layouts/manage/' . $layout_name . '/edit-title/editor/title', $edit, t('Save configuration'));
    $this->backdropPost('admin/structure/layouts/manage/' . $layout_name, array(), t('Save layout'));
    $this->backdropGet($layout_path);
    $this->assertResponse(200, 'Layout displayed at the given path.');

    // At this point there should only be a single custom path, so there should
    // only be a single "Menu settings" link on the listing page. If other
    // layouts are added in tests in this class, be sure they are deleted at the
    // end of the test.
    $this->backdropGet('admin/structure/layouts');
    $this->clickLink(t('Menu settings'));
    $this->assertUrl('admin/structure/layouts/menu/' . $layout_name, array(), 'Menu settings link goes to the correct layout menu item settings.');

    // Set as a normal menu item.
    $menu_title = $this->randomName();
    $edit = array(
      'menu[type]' => 'normal',
      'menu[title]' => $menu_title,
      'menu[weight]' => 1,
    );
    $this->backdropPost(NULL, $edit, t('Save menu settings'));

    // Check that the link is available on the homepage (via the main menu).
    $this->backdropGet('<front>');
    $this->assertLink($menu_title, 0, 'Menu link shown on the homepage.');

    $this->backdropPost('admin/structure/layouts/menu/' . $layout_name, array(), t('Add condition'));
    $edit = array(
      'condition' => 'path',
    );
    $this->backdropPost(NULL, $edit, t('Load condition'));

    // This condition will make the menu item available on the home page, and
    // on the layout path itself. Note that the "layout_name" is the first part
    // of the path, so we allow access on it and its children paths.
    $edit = array(
      'paths' => "<front>\n$layout_name*\n",
    );
    $this->backdropPost(NULL, $edit, t('Add condition'));
    $this->backdropPost(NULL, array(), t('Save menu settings'));
    $vc_text = 'Current path is one of "' . str_replace("\n", ', ', $edit['paths']);
    $vc = $this->xpath('//tr[contains(@class,"layout-group")]//ul//li[contains(., :vc_text)]', array(
      ':vc_text' => $vc_text,
    ));
    $this->assertEqual(count($vc), 1, 'The visibility condition shows up properly.');

    $this->backdropGet('<front>');
    $this->assertLink($menu_title, 0, 'Menu link found on the homepage.');
    $this->backdropGet('node/' . $this->test_node1->nid);
    $this->assertNoLink($menu_title, 'Menu link not shown when conditions prevent it.');
    $this->backdropGet($layout_path);
    $this->assertLink($menu_title, 0, 'Menu link shown on the layout page itself.');

    // Change the menu item to a default local tab.
    $menu_tab_title = $this->randomName();
    $edit = array(
      'menu[type]' => 'default tab',
      'menu[title]' => $menu_tab_title,
      'menu[weight]' => 1,
      'menu[parent][type]' => 'normal',
      'menu[parent][title]' => $menu_title,
    );
    $this->backdropPost('admin/structure/layouts/menu/' . $layout_name, $edit, t('Save menu settings'));

    // Ensure that the parent item link still shows up.
    $this->backdropGet('<front>');
    $this->assertLink($menu_title, 0, 'Menu link found on the homepage when registered as a parent menu item link.');
    $this->clickLink($menu_title);
    $this->assertUrl($layout_name, array(), 'Menu link uses the parent path, without the default tab portion of the path.');

    // Create another layout to use as a second tab.
    $tab_layout_name = strtolower($this->randomName());
    $tab_layout_path = $layout_name . '/' . strtolower($this->randomName());
    $edit = array(
      'name' => $tab_layout_name,
      'title' => $tab_layout_name,
      'path' => $tab_layout_path,
      'layout_template' => 'moscone_flipped',
    );
    $this->backdropPost('admin/structure/layouts/add', $edit, t('Create layout'));

    $tab_layout_title = $this->randomName();
    $edit = array(
      'menu[type]' => 'tab',
      'menu[title]' => $tab_layout_title,
      'menu[weight]' => 1,
    );
    $this->backdropPost('admin/structure/layouts/menu/' . $tab_layout_name, $edit, t('Save menu settings'));

    // On the "parent" path, we should now see the default tab and this new tab.
    $this->backdropGet($layout_name);
    $active_tab = $this->xpath('//ul[contains(@class,"tabs")]/li[contains(@class,"active")]/a[@href=:path]', array(
      ':path' => url($layout_name),
    ));
    $this->assertEqual(count($active_tab), 1, 'The menu default tab for a layout shows up properly.');
    $second_tab = $this->xpath('//ul[contains(@class,"tabs")]/li/a[@href=:path]', array(
      ':path' => url($tab_layout_path),
    ));
    $this->assertEqual(count($second_tab), 1, 'The normal menu tab for a layout shows up properly.');

    // Make a 3rd layout at a yet deeper path, creating another tab via its parent.
    $subtab_layout_name = strtolower($this->randomName());
    $subtab_layout_path = $tab_layout_path . '/' . strtolower($this->randomName());
    $subtab_layout_path_last = $subtab_layout_path . '/' . strtolower($this->randomName());
    $edit = array(
      'name' => $subtab_layout_name,
      'title' => $subtab_layout_name,
      'path' => $subtab_layout_path_last,
      'layout_template' => 'moscone_flipped',
    );
    $this->backdropPost('admin/structure/layouts/add', $edit, t('Create layout'));

    $subtab_layout_title = $this->randomName();
    $sub_subtab_layout_title = $this->randomName();
    $edit = array(
      'menu[type]' => 'default tab',
      'menu[title]' => $sub_subtab_layout_title,
      'menu[weight]' => 0,
      'menu[parent][type]' => 'tab',
      'menu[parent][title]' => $subtab_layout_title,
    );
    $this->backdropPost('admin/structure/layouts/menu/' . $subtab_layout_name, $edit, t('Save menu settings'));

    // Reuse the "tab" item to be a child of the subtab.
    $subtab_layout_path_last = $subtab_layout_path . '/' . strtolower($this->randomName());
    $edit = array(
      'path' => $subtab_layout_path_last,
    );
    $this->backdropPost('admin/structure/layouts/manage/' . $tab_layout_name . '/configure', $edit, t('Save layout'));

    // Now we should have an active tab with subtabs, the first one is active.
    $this->backdropGet($subtab_layout_path);
    $active_tab = $this->xpath('//ul[contains(@class,"tabs")][contains(@class,"secondary")]/li[contains(@class,"active")]/a[@href=:path]', array(
      ':path' => url($subtab_layout_path),
    ));
    $this->assertEqual(count($active_tab), 1, 'The sub-tab default menu item for a layout shows up properly.');
    $second_tab = $this->xpath('//ul[contains(@class,"tabs")][contains(@class,"secondary")]/li/a[@href=:path]', array(
      ':path' => url($subtab_layout_path_last),
    ));
    $this->assertEqual(count($second_tab), 1, 'The sub-tab menu item for a layout shows up properly.');

    // Delete all the generated layouts.
    $this->backdropPost('admin/structure/layouts/manage/' . $layout_name . '/delete', array(), t('Delete layout'));
    $this->backdropPost('admin/structure/layouts/manage/' . $tab_layout_name . '/delete', array(), t('Delete layout'));
    $this->backdropPost('admin/structure/layouts/manage/' . $subtab_layout_name . '/delete', array(), t('Delete layout'));

    // Check that both layouts and menu items are deleted.
    layout_reset_caches();
    $this->assertFalse(layout_load($layout_name), 'Base layout deleted.');
    $this->assertFalse(layout_load($tab_layout_name), 'Tab layout deleted.');
    $this->assertFalse(layout_load($subtab_layout_name), 'Sub-tab layout deleted.');
    $this->assertFalse(layout_menu_item_load($layout_name), 'Base menu item deleted.');
    $this->assertFalse(layout_menu_item_load($tab_layout_name), 'Tab menu item deleted.');
    $this->assertFalse(layout_menu_item_load($subtab_layout_name), 'Sub-tab menu item deleted.');
  }

  /**
   * Test region styles.
   */
  function testRegionStyles() {
    $this->backdropGet('admin/structure/layouts/manage/default/configure-region/editor/header');
    $edit = array(
      'element' => 'aside',
      'classes' => 'new-test-class',
    );
    $this->backdropPost(NULL, $edit, t('Save configuration'));
    $this->backdropGet('admin/structure/layouts/manage/default');
    $this->backdropPost(NULL, array(), t('Save layout'));

    $this->backdropGet('node');
    $style_exists = $this->xpath('//header[contains(@class,"l-header")]//aside[contains(@class,"new-test-class")]');
    $this->assertTrue($style_exists, 'Style exists on header div.');
  }

  /**
   * Ensure that reassignment of menu items works when deleting layouts.
   */
  function testMenuItemReassignment() {
    // Create a layout that will generate a menu item automatically.
    $layout_name = strtolower($this->randomName());
    $layout_path = $layout_name;
    $edit = array(
      'name' => $layout_name,
      'title' => $layout_name,
      'path' => $layout_path,
      'layout_template' => 'moscone_flipped',
    );
    $this->backdropPost('admin/structure/layouts/add', $edit, t('Create layout'));

    // Check that the layout and menu item config are generated.
    $result = config_get('layout.layout.' . $layout_name, 'name');
    $this->assertEqual($result, $layout_name, 'Config created for new layout.');
    $result = config_get('layout.menu_item.' . $layout_name, 'name');
    $this->assertEqual($result, $layout_name, 'Config created for new layout menu item.');

    $layout_title = $this->randomName();
    $edit = array(
      'menu[type]' => 'normal',
      'menu[title]' => $layout_title,
      'menu[weight]' => 1,
    );
    $this->backdropPost('admin/structure/layouts/menu/' . $layout_name, $edit, t('Save menu settings'));

    $this->backdropGet('<front>');
    $this->assertLink(check_plain($layout_title), 0, 'Menu link displayed on homepage.');

    // Create another layout at the same path.
    $second_layout_name = strtolower($this->randomName());
    $edit = array(
      'name' => $second_layout_name,
      'title' => $second_layout_name,
      'path' => $layout_path,
      'layout_template' => 'moscone_flipped',
    );
    $this->backdropPost('admin/structure/layouts/add', $edit, t('Create layout'));

    // Check that the layout config is created, but not a menu item, since it
    // will reuse the existing menu item.
    $result = config_get('layout.layout.' . $second_layout_name, 'name');
    $this->assertEqual($result, $second_layout_name, 'Config created for second layout.');
    $result = config_get('layout.menu_item.' . $second_layout_name, 'name');
    $this->assertNull($result, 'No config created for second layout menu item (reuses the existing one).');

    // Delete the first layout and check that the menu item is transferred.
    $this->backdropPost('admin/structure/layouts/manage/' . $layout_name . '/delete', array(), t('Delete layout'));

    layout_reset_caches();
    $this->assertFalse(layout_load($layout_name), 'Base layout deleted.');
    $this->assertFalse(layout_menu_item_load($layout_name), 'Base layout menu item deleted.');

    $menu_item = layout_menu_item_load($second_layout_name);
    $this->assertTrue($menu_item, 'Menu item transferred to second layout.');
    $this->assertEqual($menu_item->name, $second_layout_name, 'Menu name updated.');
    $this->assertEqual($menu_item->path, $layout_path, 'Menu path copied correctly.');

    $this->backdropGet('<front>');
    $this->assertLink(check_plain($layout_title), 0, 'Previous menu item link still displayed after deleting first layout.');

    // Delete the second layout
    $this->backdropPost('admin/structure/layouts/manage/' . $second_layout_name . '/delete', array(), t('Delete layout'));
    $this->backdropGet('<front>');
    $this->assertNoLink(check_plain($layout_title), 'Menu item no longer present after deleting last layout.');

    $result = config_get('layout.menu_item.' . $second_layout_name, 'name');
    $this->assertNull($result, 'Config for second menu item has been deleted.');
  }

  /**
   * Tests switching between different layouts, ensuring block copying.
   */
  function testLayoutChange() {
    // Add blocks to the default layout for checking.
    $default_layout = layout_load('default');
    $default_layout->addBlock('layout_test', 'foo', 'content');
    $default_layout->addBlock('layout_test', 'foo', 'sidebar');
    $default_layout->save();

    // Create a layout should inherit all the blocks. Since the default layout
    // also two columns, all blocks should be copied over.
    $layout_name = strtolower($this->randomName());
    $layout_path = $layout_name;
    $edit = array(
      'name' => $layout_name,
      'title' => $layout_name,
      'path' => $layout_path,
      'layout_template' => 'moscone_flipped',
    );
    $this->backdropPost('admin/structure/layouts/add', $edit, t('Create layout'));

    layout_reset_caches();
    $layout = layout_load($layout_name);
    $this->assertBlocksMatch($layout, $default_layout);

    // Change the layout to the test layout, which has identical regions.
    $edit = array(
      'layout_template' => 'layout_test_layout_template',
    );
    $this->backdropPost('admin/structure/layouts/manage/' . $layout_name . '/configure', $edit, t('Save layout'));

    layout_reset_caches();
    $layout = layout_load($layout_name);
    $this->assertBlocksMatch($layout, $default_layout);

    // Change the layout to the boxton layout, eliminating the sidebar.
    $edit = array(
      'layout_template' => 'boxton',
    );
    $this->backdropPost('admin/structure/layouts/manage/' . $layout_name . '/configure', $edit, t('Save layout'));

    $orphaned_uuids = $default_layout->positions['sidebar'];
    $this->orphaned_blocks = !empty($orphaned_uuids);
    layout_reset_caches();
    $layout = layout_load($layout_name);
    $this->assertBlocksMatch($layout, $default_layout);
    $this->assertFalse(isset($layout->positions['sidebar']), 'Sidebar region blocks moved out when changing layout to single column.');

    $intersection = array_intersect(array_keys($layout->content), $orphaned_uuids);
    $this->assertEqual($intersection, array(), 'The sidebar blocks have been removed from the layout content array.');
    // Check that the sidebar and content region blocks in the old layout are
    // the same number of blocks in the content region of the new layout.
    $default_layout_sidebar_content_regions_count = count($default_layout->positions['sidebar']) + count($default_layout->positions['content']);
    $new_content_region_count = count($layout->positions['content']);
    // Count the system main block separately since it doesn't exist in the
    // new layout.
    if ($default_layout->positions['content'][0] == 'default') {
      $new_content_region_count++;
    }
    $this->assertTrue($default_layout_sidebar_content_regions_count == $new_content_region_count, 'The blocks from the Sidebar and Default regions in the old layout all exist in the Default region of the new layout.');
    // Make sure the moved block is part of the module we expect.
    $moved_block_uuid = $layout->positions['content'][1];
    $moved_block = $layout->content[$moved_block_uuid];
    $this->assertTrue($moved_block->module == 'layout_test', 'The moved block is from the layout_test module.');
  }

  /**
   * Tests current user custom field block
   */
  function testCurrentUser() {
    $field_name = 'field_field1';

    $field_info = array('field_name' => $field_name, 'type' => 'text');
    $field = field_create_field($field_info);
    $instance = array(
      'field_name' => $field_name,
      'entity_type' => 'user',
      'bundle' => 'user',
      'label' => 'Field1',
    );
    field_create_instance($instance);

    $this->backdropGet('admin/structure/layouts');
    $this->clickLink(t('Add layout'));

    // Create a new layout at a new path.
    $layout_title = $this->randomName();
    $layout_name = strtolower($layout_title);
    $layout_url = 'layout-test-path';
    $edit = array(
      'title' => $layout_title,
      'name' => $layout_name,
      'layout_template' => 'moscone_flipped',
      'path' => $layout_url,
    );
    $this->backdropPost(NULL, $edit, t('Create layout'));

    // We should be taken to the layout content page next.
    $this->assertText(t('Layout created. Blocks may now be added to this layout.'));

    // Add a block to the sidebar.
    $this->clickLink(t('Add block'), 3);
    $this->clickLink(t('Field: Field1 (field_field1)'));
    $edit = array();
    $this->backdropPost(NULL, $edit, t('Add block'));

    // Save the layout.
    $this->backdropPost(NULL, array(), t('Save layout'));

    // Set a value for field1 for the current user.
    $field_value = 'the expected value';

    $this->backdropGet('user/' . $this->admin_user->uid . '/edit');
    $this->assertText($instance['label'], 'The field appears on user edit form');
    $edit = array();
    $edit[$field_name . '[' . LANGUAGE_NONE . '][0][value]'] = $field_value;
    $this->backdropPost(NULL, $edit, t('Save'));

    // Go to the new layout and check that the field value is displayed.
    $this->backdropGet($layout_url);
    $this->assertText($field_value, 'The field appears on the new layout page.');
  }

  /**
   * Tests Taxonomy contexts within layouts.
   */
  function testTaxonomyContext() {
    module_enable(array('taxonomy'));

    // Create a default vocabulary named "Tags", enabled for the 'post' content type.
    $vocabulary = new TaxonomyVocabulary(array(
      'name' => 'Tags',
      'description' => 'Use tags to group posts on similar topics into categories.',
      'machine_name' => 'tags',
    ));
    taxonomy_vocabulary_save($vocabulary);

    $field = array(
      'field_name' => 'field_' . $vocabulary->machine_name,
      'type' => 'taxonomy_term_reference',
      // Set cardinality to unlimited for tagging.
      'cardinality' => FIELD_CARDINALITY_UNLIMITED,
      'settings' => array(
        'allowed_values' => array(
          array(
            'vocabulary' => $vocabulary->machine_name,
            'parent' => 0,
          ),
        ),
      ),
    );
    field_create_field($field);

    $instance = array(
      'field_name' => 'field_' . $vocabulary->machine_name,
      'entity_type' => 'node',
      'label' => 'Tags',
      'bundle' => 'post',
      'widget' => array(
        'type' => 'taxonomy_autocomplete',
      ),
    );
    field_create_instance($instance);

    // Make a new layout that creates a custom path with placeholders.
    $layout_title = $this->randomName();
    $layout_name = strtolower($layout_title);
    $layout_path = 'taxonomy/term/%';
    $edit = array(
      'title' => $layout_title,
      'name' => $layout_name,
      'layout_template' => 'moscone_flipped',
      'path' => $layout_path,
    );
    // Check the path first to populate available contexts.
    $this->backdropPost('admin/structure/layouts/add', $edit, t('Check path'));

    // Try to add a condition to the layout itself to only show on the Tag
    // vocabulary.
    $this->backdropPost(NULL, array(), t('Add condition'));

    $this->backdropPost(NULL, array('condition' => 'taxonomy_term_vocabulary'), t('Load condition'));
    $this->backdropPost(NULL, array('bundles[tags]' => TRUE), t('Add condition'));
    $this->backdropPost(NULL, array(), t('Create layout'));

    $this->assertText(t('Layout created. Blocks may now be added to this layout.'));
  }

  /**
   * Check that all the blocks in $layout match those in $copied_from_layout.
   */
  protected function assertBlocksMatch($layout, $copied_from_layout, $orphaned_uuids = array()) {
    $layout_template_info = layout_get_layout_template_info($layout->layout_template);
    $default_region = $layout_template_info['default region'];
    foreach ($layout->positions as $region_name => $blocks) {
      // Don't compare if it's the default region since orphaned blocks might
      // get reassigned here, which throws off the numbers.
      if ($this->orphaned_blocks && $region_name == $default_region) {
        $this->orphaned_blocks = FALSE;
        continue;
      }
      if (isset($copied_from_layout->positions[$region_name])) {
        $blocks_match = TRUE;
        $content_block_offset = 0;
        foreach ($blocks as $position => $block_uuid) {
          $copied_block_uuid = $copied_from_layout->positions[$region_name][$position + $content_block_offset];
          $copied_block = $copied_from_layout->content[$copied_block_uuid];

          // If this is the system main block, it may not exist in the new
          // layout if the new layout creates a new path instead of overriding
          // an existing one. If we encounter the default block, allow it to be
          // skipped.
          if ($copied_block->module === 'system' && $copied_block->delta === 'main' && isset($layout->menu_item)) {
            $content_block_offset = 1;
            $copied_block_uuid = $copied_from_layout->positions[$region_name][$position + $content_block_offset];
            $copied_block = $copied_from_layout->content[$copied_block_uuid];
          }

          $block = $layout->content[$block_uuid];
          if ($block->module !== $copied_block->module || $block->delta !== $copied_block->delta) {
            $blocks_match = FALSE;
          }
        }
        $this->assertTrue($blocks_match, format_string('Blocks copied from @layout1 into @layout2 match in the @region region.', array('@layout1' => $copied_from_layout->layout_template, '@layout2' => $layout->layout_template, '@region' => $region_name)));
      }
      else {
        debug(format_string('The new layout @layout does not have the region @region, so no blocks are being copied.', array('@layout' => $layout->layout_template, '@region' => $region_name)));
      }
    }
  }

  /**
   * Tests layout_modules_uninstalled().
   */
  function testBlockUninstall() {
    $this->backdropGet('admin/structure/layouts');
    $this->clickLink(t('Add layout'));

    // Create a new layout at a new path.
    $layout_title = $this->randomName();
    $layout_name = strtolower($layout_title);
    $layout_url = 'layout-test-path';
    $edit = array(
      'title' => $layout_title,
      'name' => $layout_name,
      'layout_template' => 'moscone_flipped',
      'path' => $layout_url,
    );
    $this->backdropPost(NULL, $edit, t('Create layout'));

    // Add a block to the sidebar.
    $this->clickLink(t('Add block'), 3);
    $this->assertText(t('A testing block for layouts.'));
    $this->clickLink(t('Layout foo block'));
    $edit = array(
      'block_settings[count]' => 5,
    );
    $this->backdropPost(NULL, $edit, t('Add block'));

    // Save the layout.
    $this->backdropPost(NULL, array(), t('Save layout'));

    // Check that the new block is on the edit page.
    $this->backdropGet('admin/structure/layouts/manage/' . $layout_name);
    $this->assertText(t('A testing block for layouts.'));

    // Add the same block to the default layout.
    $this->backdropGet('admin/structure/layouts/manage/default');

    // Add the same block to the sidebar.
    $this->clickLink(t('Add block'), 3);
    $this->assertText(t('A testing block for layouts.'));
    $this->clickLink(t('Layout foo block'));
    $edit = array(
      'block_settings[count]' => 5,
    );
    $this->backdropPost(NULL, $edit, t('Add block'));

    // Save the layout.
    $this->backdropPost(NULL, array(), t('Save layout'));

    // Check that the new block is on the edit page.
    $this->backdropGet('admin/structure/layouts/manage/default');
    $this->assertText(t('A testing block for layouts.'));

    // Uninstall the module providing the block.
    module_disable(array('layout_test'));
    backdrop_uninstall_modules(array('layout_test'));
    $this->assertFalse(module_exists('layout_test'), 'The module has been uninstalled.');

    // Check that the new block is on none of the layout edit pages.
    $this->backdropGet('admin/structure/layouts/manage/default');
    $this->assertNoText(t('A testing block for layouts.'));
    $this->backdropGet('admin/structure/layouts/manage/' . $layout_name);
    $this->assertNoText(t('A testing block for layouts.'));
  }
}