class CommentInterfaceTest

class CommentInterfaceTest extends CommentHelperCase {
  public static function getInfo() {
    return array(
      'name' => 'Comment interface',
      'description' => 'Test comment user interfaces.',
      'group' => 'Comment',
    );
  }

  /**
   * Test comment interface.
   */
  function testCommentInterface() {
    $langcode = LANGUAGE_NONE;

    // Set comments to have subject and preview disabled.
    $this
      ->drupalLogin($this->admin_user);
    $this
      ->setCommentPreview(DRUPAL_DISABLED);
    $this
      ->setCommentForm(TRUE);
    $this
      ->setCommentSubject(FALSE);
    $this
      ->setCommentSettings('comment_default_mode', COMMENT_MODE_THREADED, 'Comment paging changed.');
    $this
      ->drupalLogout();

    // Post comment #1 without subject or preview.
    $this
      ->drupalLogin($this->web_user);
    $comment_text = $this
      ->randomName();
    $comment = $this
      ->postComment($this->node, $comment_text);
    $comment_loaded = comment_load($comment->id);
    $this
      ->assertTrue($this
      ->commentExists($comment), 'Comment found.');

    // Set comments to have subject and preview to required.
    $this
      ->drupalLogout();
    $this
      ->drupalLogin($this->admin_user);
    $this
      ->setCommentSubject(TRUE);
    $this
      ->setCommentPreview(DRUPAL_REQUIRED);
    $this
      ->drupalLogout();

    // Create comment #2 that allows subject and requires preview.
    $this
      ->drupalLogin($this->web_user);
    $subject_text = $this
      ->randomName();
    $comment_text = $this
      ->randomName();
    $comment = $this
      ->postComment($this->node, $comment_text, $subject_text, TRUE);
    $comment_loaded = comment_load($comment->id);
    $this
      ->assertTrue($this
      ->commentExists($comment), 'Comment found.');

    // Check comment display.
    $this
      ->drupalGet('node/' . $this->node->nid . '/' . $comment->id);
    $this
      ->assertText($subject_text, 'Individual comment subject found.');
    $this
      ->assertText($comment_text, 'Individual comment body found.');

    // Set comments to have subject and preview to optional.
    $this
      ->drupalLogout();
    $this
      ->drupalLogin($this->admin_user);
    $this
      ->setCommentSubject(TRUE);
    $this
      ->setCommentPreview(DRUPAL_OPTIONAL);

    // Test changing the comment author to "Anonymous".
    $this
      ->drupalGet('comment/' . $comment->id . '/edit');
    $comment = $this
      ->postComment(NULL, $comment->comment, $comment->subject, array(
      'name' => '',
    ));
    $comment_loaded = comment_load($comment->id);
    $this
      ->assertTrue(empty($comment_loaded->name) && $comment_loaded->uid == 0, 'Comment author successfully changed to anonymous.');

    // Test changing the comment author to an unverified user.
    $random_name = $this
      ->randomName();
    $this
      ->drupalGet('comment/' . $comment->id . '/edit');
    $comment = $this
      ->postComment(NULL, $comment->comment, $comment->subject, array(
      'name' => $random_name,
    ));
    $this
      ->drupalGet('node/' . $this->node->nid);
    $this
      ->assertText($random_name . ' (' . t('not verified') . ')', 'Comment author successfully changed to an unverified user.');

    // Test changing the comment author to a verified user.
    $this
      ->drupalGet('comment/' . $comment->id . '/edit');
    $comment = $this
      ->postComment(NULL, $comment->comment, $comment->subject, array(
      'name' => $this->web_user->name,
    ));
    $comment_loaded = comment_load($comment->id);
    $this
      ->assertTrue($comment_loaded->name == $this->web_user->name && $comment_loaded->uid == $this->web_user->uid, 'Comment author successfully changed to a registered user.');
    $this
      ->drupalLogout();

    // Reply to comment #2 creating comment #3 with optional preview and no
    // subject though field enabled.
    $this
      ->drupalLogin($this->web_user);
    $this
      ->drupalGet('comment/reply/' . $this->node->nid . '/' . $comment->id);
    $this
      ->assertText($subject_text, 'Individual comment-reply subject found.');
    $this
      ->assertText($comment_text, 'Individual comment-reply body found.');
    $reply = $this
      ->postComment(NULL, $this
      ->randomName(), '', TRUE);
    $reply_loaded = comment_load($reply->id);
    $this
      ->assertTrue($this
      ->commentExists($reply, TRUE), 'Reply found.');
    $this
      ->assertEqual($comment->id, $reply_loaded->pid, 'Pid of a reply to a comment is set correctly.');
    $this
      ->assertEqual(rtrim($comment_loaded->thread, '/') . '.00/', $reply_loaded->thread, 'Thread of reply grows correctly.');

    // Second reply to comment #3 creating comment #4.
    $this
      ->drupalGet('comment/reply/' . $this->node->nid . '/' . $comment->id);
    $this
      ->assertText($subject_text, 'Individual comment-reply subject found.');
    $this
      ->assertText($comment_text, 'Individual comment-reply body found.');
    $reply = $this
      ->postComment(NULL, $this
      ->randomName(), $this
      ->randomName(), TRUE);
    $reply_loaded = comment_load($reply->id);
    $this
      ->assertTrue($this
      ->commentExists($reply, TRUE), 'Second reply found.');
    $this
      ->assertEqual(rtrim($comment_loaded->thread, '/') . '.01/', $reply_loaded->thread, 'Thread of second reply grows correctly.');

    // Edit reply.
    $this
      ->drupalGet('comment/' . $reply->id . '/edit');
    $reply = $this
      ->postComment(NULL, $this
      ->randomName(), $this
      ->randomName(), TRUE);
    $this
      ->assertTrue($this
      ->commentExists($reply, TRUE), 'Modified reply found.');

    // Correct link count
    $this
      ->drupalGet('node');
    $this
      ->assertRaw('4 comments', 'Link to the 4 comments exist.');

    // Confirm a new comment is posted to the correct page.
    $this
      ->setCommentsPerPage(2);
    $comment_new_page = $this
      ->postComment($this->node, $this
      ->randomName(), $this
      ->randomName(), TRUE);
    $this
      ->assertTrue($this
      ->commentExists($comment_new_page), 'Page one exists. %s');
    $this
      ->drupalGet('node/' . $this->node->nid, array(
      'query' => array(
        'page' => 1,
      ),
    ));
    $this
      ->assertTrue($this
      ->commentExists($reply, TRUE), 'Page two exists. %s');
    $this
      ->setCommentsPerPage(50);

    // Attempt to post to node with comments disabled.
    $this->node = $this
      ->drupalCreateNode(array(
      'type' => 'article',
      'promote' => 1,
      'comment' => COMMENT_NODE_HIDDEN,
    ));
    $this
      ->assertTrue($this->node, 'Article node created.');
    $this
      ->drupalGet('comment/reply/' . $this->node->nid);
    $this
      ->assertText('This discussion is closed', 'Posting to node with comments disabled');
    $this
      ->assertNoField('edit-comment', 'Comment body field found.');

    // Attempt to post to node with read-only comments.
    $this->node = $this
      ->drupalCreateNode(array(
      'type' => 'article',
      'promote' => 1,
      'comment' => COMMENT_NODE_CLOSED,
    ));
    $this
      ->assertTrue($this->node, 'Article node created.');
    $this
      ->drupalGet('comment/reply/' . $this->node->nid);
    $this
      ->assertText('This discussion is closed', 'Posting to node with comments read-only');
    $this
      ->assertNoField('edit-comment', 'Comment body field found.');

    // Attempt to post to node with comments enabled (check field names etc).
    $this->node = $this
      ->drupalCreateNode(array(
      'type' => 'article',
      'promote' => 1,
      'comment' => COMMENT_NODE_OPEN,
    ));
    $this
      ->assertTrue($this->node, 'Article node created.');
    $this
      ->drupalGet('comment/reply/' . $this->node->nid);
    $this
      ->assertNoText('This discussion is closed', 'Posting to node with comments enabled');
    $this
      ->assertField('edit-comment-body-' . $langcode . '-0-value', 'Comment body field found.');

    // Delete comment and make sure that reply is also removed.
    $this
      ->drupalLogout();
    $this
      ->drupalLogin($this->admin_user);
    $this
      ->deleteComment($comment);
    $this
      ->deleteComment($comment_new_page);
    $this
      ->drupalGet('node/' . $this->node->nid);
    $this
      ->assertFalse($this
      ->commentExists($comment), 'Comment not found.');
    $this
      ->assertFalse($this
      ->commentExists($reply, TRUE), 'Reply not found.');

    // Enabled comment form on node page.
    $this
      ->drupalLogin($this->admin_user);
    $this
      ->setCommentForm(TRUE);
    $this
      ->drupalLogout();

    // Submit comment through node form.
    $this
      ->drupalLogin($this->web_user);
    $this
      ->drupalGet('node/' . $this->node->nid);
    $form_comment = $this
      ->postComment(NULL, $this
      ->randomName(), $this
      ->randomName(), TRUE);
    $this
      ->assertTrue($this
      ->commentExists($form_comment), 'Form comment found.');

    // Disable comment form on node page.
    $this
      ->drupalLogout();
    $this
      ->drupalLogin($this->admin_user);
    $this
      ->setCommentForm(FALSE);
  }

  /**
   * Tests new comment marker.
   */
  public function testCommentNewCommentsIndicator() {

    // Test if the right links are displayed when no comment is present for the
    // node.
    $this
      ->drupalLogin($this->admin_user);
    $this->node = $this
      ->drupalCreateNode(array(
      'type' => 'article',
      'promote' => 1,
      'comment' => COMMENT_NODE_OPEN,
    ));
    $this
      ->drupalGet('node');
    $this
      ->assertNoLink(t('@count comments', array(
      '@count' => 0,
    )));
    $this
      ->assertNoLink(t('@count new comments', array(
      '@count' => 0,
    )));
    $this
      ->assertLink(t('Read more'));
    $count = $this
      ->xpath('//div[@id=:id]/div[@class=:class]/ul/li', array(
      ':id' => 'node-' . $this->node->nid,
      ':class' => 'link-wrapper',
    ));
    $this
      ->assertTrue(count($count) == 1, 'One child found');

    // Create a new comment. This helper function may be run with different
    // comment settings so use comment_save() to avoid complex setup.
    $comment = (object) array(
      'cid' => NULL,
      'nid' => $this->node->nid,
      'node_type' => $this->node->type,
      'pid' => 0,
      'uid' => $this->loggedInUser->uid,
      'status' => COMMENT_PUBLISHED,
      'subject' => $this
        ->randomName(),
      'hostname' => ip_address(),
      'language' => LANGUAGE_NONE,
      'comment_body' => array(
        LANGUAGE_NONE => array(
          $this
            ->randomName(),
        ),
      ),
    );
    comment_save($comment);
    $this
      ->drupalLogout();

    // Log in with 'web user' and check comment links.
    $this
      ->drupalLogin($this->web_user);
    $this
      ->drupalGet('node');
    $this
      ->assertLink(t('1 new comment'));
    $this
      ->clickLink(t('1 new comment'));
    $this
      ->assertRaw('<a id="new"></a>', 'Found "new" marker.');
    $this
      ->assertTrue($this
      ->xpath('//a[@id=:new]/following-sibling::a[1][@id=:comment_id]', array(
      ':new' => 'new',
      ':comment_id' => 'comment-1',
    )), 'The "new" anchor is positioned at the right comment.');

    // Test if "new comment" link is correctly removed.
    $this
      ->drupalGet('node');
    $this
      ->assertLink(t('1 comment'));
    $this
      ->assertLink(t('Read more'));
    $this
      ->assertNoLink(t('1 new comment'));
    $this
      ->assertNoLink(t('@count new comments', array(
      '@count' => 0,
    )));
    $count = $this
      ->xpath('//div[@id=:id]/div[@class=:class]/ul/li', array(
      ':id' => 'node-' . $this->node->nid,
      ':class' => 'link-wrapper',
    ));
    $this
      ->assertTrue(count($count) == 2, print_r($count, TRUE));
  }

  /**
   * Tests CSS classes on comments.
   */
  function testCommentClasses() {

    // Create all permutations for comments, users, and nodes.
    $parameters = array(
      'node_uid' => array(
        0,
        $this->web_user->uid,
      ),
      'comment_uid' => array(
        0,
        $this->web_user->uid,
        $this->admin_user->uid,
      ),
      'comment_status' => array(
        COMMENT_PUBLISHED,
        COMMENT_NOT_PUBLISHED,
      ),
      'user' => array(
        'anonymous',
        'authenticated',
        'admin',
      ),
    );
    $permutations = $this
      ->generatePermutations($parameters);
    foreach ($permutations as $case) {

      // Create a new node.
      $node = $this
        ->drupalCreateNode(array(
        'type' => 'article',
        'uid' => $case['node_uid'],
      ));

      // Add a comment.
      $comment = (object) array(
        'cid' => NULL,
        'nid' => $node->nid,
        'pid' => 0,
        'uid' => $case['comment_uid'],
        'status' => $case['comment_status'],
        'subject' => $this
          ->randomName(),
        'language' => LANGUAGE_NONE,
        'comment_body' => array(
          LANGUAGE_NONE => array(
            $this
              ->randomName(),
          ),
        ),
      );
      comment_save($comment);

      // Adjust the current/viewing user.
      switch ($case['user']) {
        case 'anonymous':
          $this
            ->drupalLogout();
          $case['user_uid'] = 0;
          break;
        case 'authenticated':
          $this
            ->drupalLogin($this->web_user);
          $case['user_uid'] = $this->web_user->uid;
          break;
        case 'admin':
          $this
            ->drupalLogin($this->admin_user);
          $case['user_uid'] = $this->admin_user->uid;
          break;
      }

      // Request the node with the comment.
      $this
        ->drupalGet('node/' . $node->nid);

      // Verify classes if the comment is visible for the current user.
      if ($case['comment_status'] == COMMENT_PUBLISHED || $case['user'] == 'admin') {

        // Verify the comment-by-anonymous class.
        $comments = $this
          ->xpath('//*[contains(@class, "comment-by-anonymous")]');
        if ($case['comment_uid'] == 0) {
          $this
            ->assertTrue(count($comments) == 1, 'comment-by-anonymous class found.');
        }
        else {
          $this
            ->assertFalse(count($comments), 'comment-by-anonymous class not found.');
        }

        // Verify the comment-by-node-author class.
        $comments = $this
          ->xpath('//*[contains(@class, "comment-by-node-author")]');
        if ($case['comment_uid'] > 0 && $case['comment_uid'] == $case['node_uid']) {
          $this
            ->assertTrue(count($comments) == 1, 'comment-by-node-author class found.');
        }
        else {
          $this
            ->assertFalse(count($comments), 'comment-by-node-author class not found.');
        }

        // Verify the comment-by-viewer class.
        $comments = $this
          ->xpath('//*[contains(@class, "comment-by-viewer")]');
        if ($case['comment_uid'] > 0 && $case['comment_uid'] == $case['user_uid']) {
          $this
            ->assertTrue(count($comments) == 1, 'comment-by-viewer class found.');
        }
        else {
          $this
            ->assertFalse(count($comments), 'comment-by-viewer class not found.');
        }
      }

      // Verify the comment-unpublished class.
      $comments = $this
        ->xpath('//*[contains(@class, "comment-unpublished")]');
      if ($case['comment_status'] == COMMENT_NOT_PUBLISHED && $case['user'] == 'admin') {
        $this
          ->assertTrue(count($comments) == 1, 'comment-unpublished class found.');
      }
      else {
        $this
          ->assertFalse(count($comments), 'comment-unpublished class not found.');
      }

      // Verify the comment-new class.
      if ($case['comment_status'] == COMMENT_PUBLISHED || $case['user'] == 'admin') {
        $comments = $this
          ->xpath('//*[contains(@class, "comment-new")]');
        if ($case['user'] != 'anonymous') {
          $this
            ->assertTrue(count($comments) == 1, 'comment-new class found.');

          // Request the node again. The comment-new class should disappear.
          $this
            ->drupalGet('node/' . $node->nid);
          $comments = $this
            ->xpath('//*[contains(@class, "comment-new")]');
          $this
            ->assertFalse(count($comments), 'comment-new class not found.');
        }
        else {
          $this
            ->assertFalse(count($comments), 'comment-new class not found.');
        }
      }
    }
  }

  /**
   * Tests the node comment statistics.
   */
  function testCommentNodeCommentStatistics() {
    $langcode = LANGUAGE_NONE;

    // Set comments to have subject and preview disabled.
    $this
      ->drupalLogin($this->admin_user);
    $this
      ->setCommentPreview(DRUPAL_DISABLED);
    $this
      ->setCommentForm(TRUE);
    $this
      ->setCommentSubject(FALSE);
    $this
      ->setCommentSettings('comment_default_mode', COMMENT_MODE_THREADED, 'Comment paging changed.');
    $this
      ->drupalLogout();

    // Creates a second user to post comments.
    $this->web_user2 = $this
      ->drupalCreateUser(array(
      'access comments',
      'post comments',
      'create article content',
      'edit own comments',
    ));

    // Checks the initial values of node comment statistics with no comment.
    $node = node_load($this->node->nid);
    $this
      ->assertEqual($node->last_comment_timestamp, $this->node->created, 'The initial value of node last_comment_timestamp is the node created date.');
    $this
      ->assertEqual($node->last_comment_name, NULL, 'The initial value of node last_comment_name is NULL.');
    $this
      ->assertEqual($node->last_comment_uid, $this->web_user->uid, 'The initial value of node last_comment_uid is the node uid.');
    $this
      ->assertEqual($node->comment_count, 0, 'The initial value of node comment_count is zero.');

    // Post comment #1 as web_user2.
    $this
      ->drupalLogin($this->web_user2);
    $comment_text = $this
      ->randomName();
    $comment = $this
      ->postComment($this->node, $comment_text);
    $comment_loaded = comment_load($comment->id);

    // Checks the new values of node comment statistics with comment #1.
    // The node needs to be reloaded with a node_load_multiple cache reset.
    $node = node_load($this->node->nid, NULL, TRUE);
    $this
      ->assertEqual($node->last_comment_name, NULL, 'The value of node last_comment_name is NULL.');
    $this
      ->assertEqual($node->last_comment_uid, $this->web_user2->uid, 'The value of node last_comment_uid is the comment #1 uid.');
    $this
      ->assertEqual($node->comment_count, 1, 'The value of node comment_count is 1.');

    // Prepare for anonymous comment submission (comment approval enabled).
    variable_set('user_register', USER_REGISTER_VISITORS);
    $this
      ->drupalLogin($this->admin_user);
    user_role_change_permissions(DRUPAL_ANONYMOUS_RID, array(
      'access comments' => TRUE,
      'post comments' => TRUE,
      'skip comment approval' => FALSE,
    ));

    // Ensure that the poster can leave some contact info.
    $this
      ->setCommentAnonymous('1');
    $this
      ->drupalLogout();

    // Post comment #2 as anonymous (comment approval enabled).
    $this
      ->drupalGet('comment/reply/' . $this->node->nid);
    $anonymous_comment = $this
      ->postComment($this->node, $this
      ->randomName(), '', TRUE);
    $comment_unpublished_loaded = comment_load($anonymous_comment->id);

    // Checks the new values of node comment statistics with comment #2 and
    // ensure they haven't changed since the comment has not been moderated.
    // The node needs to be reloaded with a node_load_multiple cache reset.
    $node = node_load($this->node->nid, NULL, TRUE);
    $this
      ->assertEqual($node->last_comment_name, NULL, 'The value of node last_comment_name is still NULL.');
    $this
      ->assertEqual($node->last_comment_uid, $this->web_user2->uid, 'The value of node last_comment_uid is still the comment #1 uid.');
    $this
      ->assertEqual($node->comment_count, 1, 'The value of node comment_count is still 1.');

    // Prepare for anonymous comment submission (no approval required).
    $this
      ->drupalLogin($this->admin_user);
    user_role_change_permissions(DRUPAL_ANONYMOUS_RID, array(
      'access comments' => TRUE,
      'post comments' => TRUE,
      'skip comment approval' => TRUE,
    ));
    $this
      ->drupalLogout();

    // Post comment #3 as anonymous.
    $this
      ->drupalGet('comment/reply/' . $this->node->nid);
    $anonymous_comment = $this
      ->postComment($this->node, $this
      ->randomName(), '', array(
      'name' => $this
        ->randomName(),
    ));
    $comment_loaded = comment_load($anonymous_comment->id);

    // Checks the new values of node comment statistics with comment #3.
    // The node needs to be reloaded with a node_load_multiple cache reset.
    $node = node_load($this->node->nid, NULL, TRUE);
    $this
      ->assertEqual($node->last_comment_name, $comment_loaded->name, 'The value of node last_comment_name is the name of the anonymous user.');
    $this
      ->assertEqual($node->last_comment_uid, 0, 'The value of node last_comment_uid is zero.');
    $this
      ->assertEqual($node->comment_count, 2, 'The value of node comment_count is 2.');
  }

  /**
   * Tests comment links.
   *
   * The output of comment links depends on various environment conditions:
   * - Various Comment module configuration settings, user registration
   *   settings, and user access permissions.
   * - Whether the user is authenticated or not, and whether any comments exist.
   *
   * To account for all possible cases, this test creates permutations of all
   * possible conditions and tests the expected appearance of comment links in
   * each environment.
   */
  function testCommentLinks() {

    // Bartik theme alters comment links, so use a different theme.
    theme_enable(array(
      'garland',
    ));
    variable_set('theme_default', 'garland');

    // Remove additional user permissions from $this->web_user added by setUp(),
    // since this test is limited to anonymous and authenticated roles only.
    user_role_delete(key($this->web_user->roles));

    // Matrix of possible environmental conditions and configuration settings.
    // See setEnvironment() for details.
    $conditions = array(
      'authenticated' => array(
        FALSE,
        TRUE,
      ),
      'comment count' => array(
        FALSE,
        TRUE,
      ),
      'access comments' => array(
        0,
        1,
      ),
      'post comments' => array(
        0,
        1,
      ),
      'form' => array(
        COMMENT_FORM_BELOW,
        COMMENT_FORM_SEPARATE_PAGE,
      ),
      // USER_REGISTER_VISITORS_ADMINISTRATIVE_APPROVAL is irrelevant for this
      // test; there is only a difference between open and closed registration.
      'user_register' => array(
        USER_REGISTER_VISITORS,
        USER_REGISTER_ADMINISTRATORS_ONLY,
      ),
    );
    $environments = $this
      ->generatePermutations($conditions);
    foreach ($environments as $info) {
      $this
        ->assertCommentLinks($info);
    }
  }

  /**
   * Re-configures the environment, module settings, and user permissions.
   *
   * @param $info
   *   An associative array describing the environment to setup:
   *   - Environment conditions:
   *     - authenticated: Boolean whether to test with $this->web_user or
   *       anonymous.
   *     - comment count: Boolean whether to test with a new/unread comment on
   *       $this->node or no comments.
   *   - Configuration settings:
   *     - form: COMMENT_FORM_BELOW or COMMENT_FORM_SEPARATE_PAGE.
   *     - user_register: USER_REGISTER_ADMINISTRATORS_ONLY or
   *       USER_REGISTER_VISITORS.
   *     - contact: COMMENT_ANONYMOUS_MAY_CONTACT or
   *       COMMENT_ANONYMOUS_MAYNOT_CONTACT.
   *     - comments: COMMENT_NODE_OPEN, COMMENT_NODE_CLOSED, or
   *       COMMENT_NODE_HIDDEN.
   *   - User permissions:
   *     These are granted or revoked for the user, according to the
   *     'authenticated' flag above. Pass 0 or 1 as parameter values. See
   *     user_role_change_permissions().
   *     - access comments
   *     - post comments
   *     - skip comment approval
   *     - edit own comments
   */
  function setEnvironment(array $info) {
    static $current;

    // Apply defaults to initial environment.
    if (!isset($current)) {
      $current = array(
        'authenticated' => FALSE,
        'comment count' => FALSE,
        'form' => COMMENT_FORM_BELOW,
        'user_register' => USER_REGISTER_VISITORS,
        'contact' => COMMENT_ANONYMOUS_MAY_CONTACT,
        'comments' => COMMENT_NODE_OPEN,
        'access comments' => 0,
        'post comments' => 0,
        // Enabled by default, because it's irrelevant for this test.
        'skip comment approval' => 1,
        'edit own comments' => 0,
      );
    }

    // Complete new environment with current environment.
    $info = array_merge($current, $info);

    // Change environment conditions.
    if ($current['authenticated'] != $info['authenticated']) {
      if ($this->loggedInUser) {
        $this
          ->drupalLogout();
      }
      else {
        $this
          ->drupalLogin($this->web_user);
      }
    }
    if ($current['comment count'] != $info['comment count']) {
      if ($info['comment count']) {

        // Create a comment via CRUD API functionality, since
        // $this->postComment() relies on actual user permissions.
        $comment = (object) array(
          'cid' => NULL,
          'nid' => $this->node->nid,
          'node_type' => $this->node->type,
          'pid' => 0,
          'uid' => 0,
          'status' => COMMENT_PUBLISHED,
          'subject' => $this
            ->randomName(),
          'hostname' => ip_address(),
          'language' => LANGUAGE_NONE,
          'comment_body' => array(
            LANGUAGE_NONE => array(
              $this
                ->randomName(),
            ),
          ),
        );
        comment_save($comment);
        $this->comment = $comment;

        // comment_num_new() relies on node_last_viewed(), so ensure that no one
        // has seen the node of this comment.
        db_delete('history')
          ->condition('nid', $this->node->nid)
          ->execute();
      }
      else {
        $cids = db_query("SELECT cid FROM {comment}")
          ->fetchCol();
        comment_delete_multiple($cids);
        unset($this->comment);
      }
    }

    // Change comment settings.
    variable_set('comment_form_location_' . $this->node->type, $info['form']);
    variable_set('comment_anonymous_' . $this->node->type, $info['contact']);
    if ($this->node->comment != $info['comments']) {
      $this->node->comment = $info['comments'];
      node_save($this->node);
    }

    // Change user settings.
    variable_set('user_register', $info['user_register']);

    // Change user permissions.
    $rid = $this->loggedInUser ? DRUPAL_AUTHENTICATED_RID : DRUPAL_ANONYMOUS_RID;
    $perms = array_intersect_key($info, array(
      'access comments' => 1,
      'post comments' => 1,
      'skip comment approval' => 1,
      'edit own comments' => 1,
    ));
    user_role_change_permissions($rid, $perms);

    // Output verbose debugging information.
    // @see DrupalTestCase::error()
    $t_form = array(
      COMMENT_FORM_BELOW => 'below',
      COMMENT_FORM_SEPARATE_PAGE => 'separate page',
    );
    $t_contact = array(
      COMMENT_ANONYMOUS_MAY_CONTACT => 'optional',
      COMMENT_ANONYMOUS_MAYNOT_CONTACT => 'disabled',
      COMMENT_ANONYMOUS_MUST_CONTACT => 'required',
    );
    $t_comments = array(
      COMMENT_NODE_OPEN => 'open',
      COMMENT_NODE_CLOSED => 'closed',
      COMMENT_NODE_HIDDEN => 'hidden',
    );
    $verbose = $info;
    $verbose['form'] = $t_form[$info['form']];
    $verbose['contact'] = $t_contact[$info['contact']];
    $verbose['comments'] = $t_comments[$info['comments']];
    $message = t('Changed environment:<pre>@verbose</pre>', array(
      '@verbose' => var_export($verbose, TRUE),
    ));
    $this
      ->assert('debug', $message, 'Debug');

    // Update current environment.
    $current = $info;
    return $info;
  }

  /**
   * Asserts that comment links appear according to the passed environment setup.
   *
   * @param $info
   *   An associative array describing the environment to pass to
   *   setEnvironment().
   */
  function assertCommentLinks(array $info) {
    $info = $this
      ->setEnvironment($info);
    $nid = $this->node->nid;
    foreach (array(
      '',
      "node/{$nid}",
    ) as $path) {
      $this
        ->drupalGet($path);

      // User is allowed to view comments.
      if ($info['access comments']) {
        if ($path == '') {

          // In teaser view, a link containing the comment count is always
          // expected.
          if ($info['comment count']) {
            $this
              ->assertLink(t('1 comment'));

            // For logged in users, a link containing the amount of new/unread
            // comments is expected.
            // See important note about comment_num_new() below.
            if ($this->loggedInUser && isset($this->comment) && !isset($this->comment->seen)) {
              $this
                ->assertLink(t('1 new comment'));
              $this->comment->seen = TRUE;
            }
          }
        }
      }
      else {
        $this
          ->assertNoLink(t('1 comment'));
        $this
          ->assertNoLink(t('1 new comment'));
      }

      // comment_num_new() is based on node views, so comments are marked as
      // read when a node is viewed, regardless of whether we have access to
      // comments.
      if ($path == "node/{$nid}" && $this->loggedInUser && isset($this->comment)) {
        $this->comment->seen = TRUE;
      }

      // User is not allowed to post comments.
      if (!$info['post comments']) {
        $this
          ->assertNoLink('Add new comment');

        // Anonymous users should see a note to log in or register in case
        // authenticated users are allowed to post comments.
        // @see theme_comment_post_forbidden()
        if (!$this->loggedInUser) {
          if (user_access('post comments', $this->web_user)) {

            // The note depends on whether users are actually able to register.
            if ($info['user_register']) {
              $this
                ->assertText('Log in or register to post comments');
            }
            else {
              $this
                ->assertText('Log in to post comments');
            }
          }
          else {
            $this
              ->assertNoText('Log in or register to post comments');
            $this
              ->assertNoText('Log in to post comments');
          }
        }
      }
      else {
        $this
          ->assertNoText('Log in or register to post comments');

        // "Add new comment" is always expected, except when there are no
        // comments or if the user cannot see them.
        if ($path == "node/{$nid}" && $info['form'] == COMMENT_FORM_BELOW && (!$info['comment count'] || !$info['access comments'])) {
          $this
            ->assertNoLink('Add new comment');
        }
        else {
          $this
            ->assertLink('Add new comment');
        }

        // Also verify that the comment form appears according to the configured
        // location.
        if ($path == "node/{$nid}") {
          $elements = $this
            ->xpath('//form[@id=:id]', array(
            ':id' => 'comment-form',
          ));
          if ($info['form'] == COMMENT_FORM_BELOW) {
            $this
              ->assertTrue(count($elements), 'Comment form found below.');
          }
          else {
            $this
              ->assertFalse(count($elements), 'Comment form not found below.');
          }
        }
      }
    }
  }

}