updated core to 8.6.1 via composer

core/modules/comment/tests/modules/comment_empty_title_test/comment_empty_title_test.info.yml

@@ -5,4 +5,4 @@ package: Testing
 version: VERSION
 core: 8.x
 dependencies:
-  - comment
+  - drupal:comment

core/modules/comment/tests/modules/comment_test/comment_test.info.yml

@@ -5,4 +5,4 @@ package: Testing
 version: VERSION
 core: 8.x
 dependencies:
-  - comment
+  - drupal:comment

core/modules/comment/tests/modules/comment_test_views/comment_test_views.info.yml

@@ -5,5 +5,5 @@ package: Testing
 version: VERSION
 core: 8.x
 dependencies:
-  - comment
-  - views
+  - drupal:comment
+  - drupal:views

core/modules/comment/tests/src/Functional/CommentAccessTest.php

@@ -78,7 +78,7 @@ class CommentAccessTest extends BrowserTestBase {
     $assert->statusCodeEquals(403);
 
     // Publishing the node grants access.
-    $this->unpublishedNode->setPublished(TRUE)->save();
+    $this->unpublishedNode->setPublished()->save();
     $this->drupalGet($comment_url);
     $assert->statusCodeEquals(200);
   }
@@ -112,7 +112,7 @@ class CommentAccessTest extends BrowserTestBase {
     $assert->statusCodeEquals(403);
 
     // Publishing the node grants access.
-    $this->unpublishedNode->setPublished(TRUE)->save();
+    $this->unpublishedNode->setPublished()->save();
     $this->drupalGet($comment_url);
     $assert->statusCodeEquals(200);
   }

core/modules/comment/tests/src/Functional/CommentAdminTest.php

@@ -57,7 +57,7 @@ class CommentAdminTest extends CommentTestBase {
       'comment_body' => $body,
       'entity_id' => $this->node->id(),
       'entity_type' => 'node',
-      'field_name' => 'comment'
+      'field_name' => 'comment',
     ]);
     $this->drupalLogout();
 
@@ -145,7 +145,7 @@ class CommentAdminTest extends CommentTestBase {
       'comment_body' => $body,
       'entity_id' => $this->node->id(),
       'entity_type' => 'node',
-      'field_name' => 'comment'
+      'field_name' => 'comment',
     ]);
     $this->drupalLogout();
 

core/modules/comment/tests/src/Functional/CommentBlockTest.php

@@ -2,7 +2,7 @@
 
 namespace Drupal\Tests\comment\Functional;
 
-use Drupal\Component\Utility\SafeMarkup;
+use Drupal\Component\Render\FormattableMarkup;
 use Drupal\user\RoleInterface;
 
 /**
@@ -68,13 +68,13 @@ class CommentBlockTest extends CommentTestBase {
     // Test the only the 10 latest comments are shown and in the proper order.
     $this->assertNoText($comments[10]->getSubject(), 'Comment 11 not found in block.');
     for ($i = 0; $i < 10; $i++) {
-      $this->assertText($comments[$i]->getSubject(), SafeMarkup::format('Comment @number found in block.', ['@number' => 10 - $i]));
+      $this->assertText($comments[$i]->getSubject(), new FormattableMarkup('Comment @number found in block.', ['@number' => 10 - $i]));
       if ($i > 1) {
         $previous_position = $position;
-        $position = strpos($this->getRawContent(), $comments[$i]->getSubject());
-        $this->assertTrue($position > $previous_position, SafeMarkup::format('Comment @a appears after comment @b', ['@a' => 10 - $i, '@b' => 11 - $i]));
+        $position = strpos($this->getSession()->getPage()->getContent(), $comments[$i]->getSubject());
+        $this->assertTrue($position > $previous_position, new FormattableMarkup('Comment @a appears after comment @b', ['@a' => 10 - $i, '@b' => 11 - $i]));
       }
-      $position = strpos($this->getRawContent(), $comments[$i]->getSubject());
+      $position = strpos($this->getSession()->getPage()->getContent(), $comments[$i]->getSubject());
     }
 
     // Test that links to comments work when comments are across pages.

core/modules/comment/tests/src/Functional/CommentCSSTest.php

@@ -23,7 +23,7 @@ class CommentCSSTest extends CommentTestBase {
     // Allow anonymous users to see comments.
     user_role_grant_permissions(RoleInterface::ANONYMOUS_ID, [
       'access comments',
-      'access content'
+      'access content',
     ]);
   }
 

core/modules/comment/tests/src/Functional/CommentCacheTagsTest.php

@@ -0,0 +1,156 @@
+<?php
+
+namespace Drupal\Tests\comment\Functional;
+
+use Drupal\comment\CommentInterface;
+use Drupal\comment\CommentManagerInterface;
+use Drupal\comment\Entity\Comment;
+use Drupal\comment\Tests\CommentTestTrait;
+use Drupal\Core\Entity\EntityInterface;
+use Drupal\entity_test\Entity\EntityTest;
+use Drupal\field\Entity\FieldConfig;
+use Drupal\Tests\system\Functional\Entity\EntityWithUriCacheTagsTestBase;
+use Drupal\user\Entity\Role;
+use Drupal\user\RoleInterface;
+
+/**
+ * Tests the Comment entity's cache tags.
+ *
+ * @group comment
+ */
+class CommentCacheTagsTest extends EntityWithUriCacheTagsTestBase {
+
+  use CommentTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['comment'];
+
+  /**
+   * @var \Drupal\entity_test\Entity\EntityTest
+   */
+  protected $entityTestCamelid;
+
+  /**
+   * @var \Drupal\entity_test\Entity\EntityTest
+   */
+  protected $entityTestHippopotamidae;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+
+    // Give anonymous users permission to view comments, so that we can verify
+    // the cache tags of cached versions of comment pages.
+    $user_role = Role::load(RoleInterface::ANONYMOUS_ID);
+    $user_role->grantPermission('access comments');
+    $user_role->save();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function createEntity() {
+    // Create a "bar" bundle for the "entity_test" entity type and create.
+    $bundle = 'bar';
+    entity_test_create_bundle($bundle, NULL, 'entity_test');
+
+    // Create a comment field on this bundle.
+    $this->addDefaultCommentField('entity_test', 'bar', 'comment');
+
+    // Display comments in a flat list; threaded comments are not render cached.
+    $field = FieldConfig::loadByName('entity_test', 'bar', 'comment');
+    $field->setSetting('default_mode', CommentManagerInterface::COMMENT_MODE_FLAT);
+    $field->save();
+
+    // Create a "Camelids" test entity that the comment will be assigned to.
+    $this->entityTestCamelid = EntityTest::create([
+      'name' => 'Camelids',
+      'type' => 'bar',
+    ]);
+    $this->entityTestCamelid->save();
+
+    // Create a "Llama" comment.
+    $comment = Comment::create([
+      'subject' => 'Llama',
+      'comment_body' => [
+        'value' => 'The name "llama" was adopted by European settlers from native Peruvians.',
+        'format' => 'plain_text',
+      ],
+      'entity_id' => $this->entityTestCamelid->id(),
+      'entity_type' => 'entity_test',
+      'field_name' => 'comment',
+      'status' => CommentInterface::PUBLISHED,
+    ]);
+    $comment->save();
+
+    return $comment;
+  }
+
+  /**
+   * Test that comments correctly invalidate the cache tag of their host entity.
+   */
+  public function testCommentEntity() {
+    $this->verifyPageCache($this->entityTestCamelid->urlInfo(), 'MISS');
+    $this->verifyPageCache($this->entityTestCamelid->urlInfo(), 'HIT');
+
+    // Create a "Hippopotamus" comment.
+    $this->entityTestHippopotamidae = EntityTest::create([
+      'name' => 'Hippopotamus',
+      'type' => 'bar',
+    ]);
+    $this->entityTestHippopotamidae->save();
+
+    $this->verifyPageCache($this->entityTestHippopotamidae->urlInfo(), 'MISS');
+    $this->verifyPageCache($this->entityTestHippopotamidae->urlInfo(), 'HIT');
+
+    $hippo_comment = Comment::create([
+      'subject' => 'Hippopotamus',
+      'comment_body' => [
+        'value' => 'The common hippopotamus (Hippopotamus amphibius), or hippo, is a large, mostly herbivorous mammal in sub-Saharan Africa',
+        'format' => 'plain_text',
+      ],
+      'entity_id' => $this->entityTestHippopotamidae->id(),
+      'entity_type' => 'entity_test',
+      'field_name' => 'comment',
+      'status' => CommentInterface::PUBLISHED,
+    ]);
+    $hippo_comment->save();
+
+    // Ensure that a new comment only invalidates the commented entity.
+    $this->verifyPageCache($this->entityTestCamelid->urlInfo(), 'HIT');
+    $this->verifyPageCache($this->entityTestHippopotamidae->urlInfo(), 'MISS');
+    $this->assertText($hippo_comment->getSubject());
+
+    // Ensure that updating an existing comment only invalidates the commented
+    // entity.
+    $this->entity->save();
+    $this->verifyPageCache($this->entityTestCamelid->urlInfo(), 'MISS');
+    $this->verifyPageCache($this->entityTestHippopotamidae->urlInfo(), 'HIT');
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getAdditionalCacheContextsForEntity(EntityInterface $entity) {
+    return [];
+  }
+
+  /**
+   * {@inheritdoc}
+   *
+   * Each comment must have a comment body, which always has a text format.
+   */
+  protected function getAdditionalCacheTagsForEntity(EntityInterface $entity) {
+    /** @var \Drupal\comment\CommentInterface $entity */
+    return [
+      'config:filter.format.plain_text',
+      'user:' . $entity->getOwnerId(),
+      'user_view',
+    ];
+  }
+
+}

core/modules/comment/tests/src/Functional/CommentEntityTest.php

@@ -0,0 +1,80 @@
+<?php
+
+namespace Drupal\Tests\comment\Functional;
+
+use Drupal\comment\Entity\CommentType;
+use Drupal\comment\Plugin\Field\FieldType\CommentItemInterface;
+use Drupal\Core\Language\LanguageInterface;
+use Drupal\comment\CommentInterface;
+use Drupal\Tests\taxonomy\Functional\TaxonomyTestTrait;
+use Drupal\comment\Entity\Comment;
+
+/**
+ * Tests comments with other entities.
+ *
+ * @group comment
+ */
+class CommentEntityTest extends CommentTestBase {
+
+  /**
+   * Modules to install.
+   *
+   * @var array
+   */
+  public static $modules = ['block', 'comment', 'node', 'history', 'field_ui', 'datetime', 'taxonomy'];
+
+  use TaxonomyTestTrait;
+
+  protected $vocab;
+  protected $commentType;
+
+  protected function setUp() {
+    parent::setUp();
+
+    $this->vocab = $this->createVocabulary();
+    $this->commentType = CommentType::create([
+      'id' => 'taxonomy_comment',
+      'label' => 'Taxonomy comment',
+      'description' => '',
+      'target_entity_type_id' => 'taxonomy_term',
+    ]);
+    $this->commentType->save();
+    $this->addDefaultCommentField(
+      'taxonomy_term',
+      $this->vocab->id(),
+      'field_comment',
+      CommentItemInterface::OPEN,
+      $this->commentType->id()
+    );
+  }
+
+  /**
+   * Tests CSS classes on comments.
+   */
+  public function testEntityChanges() {
+    $this->drupalLogin($this->webUser);
+    // Create a new node.
+    $term = $this->createTerm($this->vocab, ['uid' => $this->webUser->id()]);
+
+    // Add a comment.
+    /** @var \Drupal\comment\CommentInterface $comment */
+    $comment = Comment::create([
+      'entity_id' => $term->id(),
+      'entity_type' => 'taxonomy_term',
+      'field_name' => 'field_comment',
+      'uid' => $this->webUser->id(),
+      'status' => CommentInterface::PUBLISHED,
+      'subject' => $this->randomMachineName(),
+      'language' => LanguageInterface::LANGCODE_NOT_SPECIFIED,
+      'comment_body' => [LanguageInterface::LANGCODE_NOT_SPECIFIED => [$this->randomMachineName()]],
+    ]);
+    $comment->save();
+
+    // Request the node with the comment.
+    $this->drupalGet('taxonomy/term/' . $term->id());
+    $settings = $this->getDrupalSettings();
+    $this->assertFalse(isset($settings['ajaxPageState']['libraries']) && in_array('comment/drupal.comment-new-indicator', explode(',', $settings['ajaxPageState']['libraries'])), 'drupal.comment-new-indicator library is present.');
+    $this->assertFalse(isset($settings['history']['lastReadTimestamps']) && in_array($term->id(), array_keys($settings['history']['lastReadTimestamps'])), 'history.lastReadTimestamps is present.');
+  }
+
+}

core/modules/comment/tests/src/Functional/CommentInterfaceTest.php

@@ -5,7 +5,6 @@ namespace Drupal\Tests\comment\Functional;
 use Drupal\comment\CommentManagerInterface;
 use Drupal\comment\Plugin\Field\FieldType\CommentItemInterface;
 use Drupal\comment\Entity\Comment;
-use Drupal\Component\Utility\Unicode;
 use Drupal\Core\Entity\Entity\EntityViewDisplay;
 use Drupal\Core\Entity\Entity\EntityViewMode;
 use Drupal\user\RoleInterface;
@@ -166,7 +165,7 @@ class CommentInterfaceTest extends CommentTestBase {
     $this->setCommentsPerPage(50);
 
     // Attempt to reply to an unpublished comment.
-    $reply_loaded->setPublished(FALSE);
+    $reply_loaded->setUnpublished();
     $reply_loaded->save();
     $this->drupalGet('comment/reply/node/' . $this->node->id() . '/comment/' . $reply_loaded->id());
     $this->assertResponse(403);
@@ -311,7 +310,7 @@ class CommentInterfaceTest extends CommentTestBase {
     $this->assertRaw('<p>' . $comment_text . '</p>');
 
     // Create a new comment entity view mode.
-    $mode = Unicode::strtolower($this->randomMachineName());
+    $mode = mb_strtolower($this->randomMachineName());
     EntityViewMode::create([
       'targetEntityType' => 'comment',
       'id' => "comment.$mode",

core/modules/comment/tests/src/Functional/CommentNewIndicatorTest.php

@@ -0,0 +1,137 @@
+<?php
+
+namespace Drupal\Tests\comment\Functional;
+
+use Drupal\Component\Serialization\Json;
+use Drupal\Core\Language\LanguageInterface;
+use Drupal\comment\CommentInterface;
+use Drupal\Core\Url;
+use Drupal\comment\Entity\Comment;
+
+/**
+ * Tests the 'new' indicator posted on comments.
+ *
+ * @group comment
+ */
+class CommentNewIndicatorTest extends CommentTestBase {
+
+  /**
+   * Use the main node listing to test rendering on teasers.
+   *
+   * @var array
+   *
+   * @todo Remove this dependency.
+   */
+  public static $modules = ['views'];
+
+  /**
+   * Get node "x new comments" metadata from the server for the current user.
+   *
+   * @param array $node_ids
+   *   An array of node IDs.
+   *
+   * @return \Psr\Http\Message\ResponseInterface
+   *   The HTTP response.
+   */
+  protected function renderNewCommentsNodeLinks(array $node_ids) {
+    $client = $this->getHttpClient();
+    $url = Url::fromRoute('comment.new_comments_node_links');
+
+    return $client->request('POST', $this->buildUrl($url), [
+      'cookies' => $this->getSessionCookies(),
+      'http_errors' => FALSE,
+      'form_params' => [
+        'node_ids' => $node_ids,
+        'field_name' => 'comment',
+      ],
+    ]);
+  }
+
+  /**
+   * 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->adminUser);
+    $this->drupalGet('node');
+    $this->assertNoLink(t('@count comments', ['@count' => 0]));
+    $this->assertLink(t('Read more'));
+    // Verify the data-history-node-last-comment-timestamp attribute, which is
+    // used by the drupal.node-new-comments-link library to determine whether
+    // a "x new comments" link might be necessary or not. We do this in
+    // JavaScript to prevent breaking the render cache.
+    $this->assertIdentical(0, count($this->xpath('//*[@data-history-node-last-comment-timestamp]')), 'data-history-node-last-comment-timestamp attribute is not set.');
+
+    // Create a new comment. This helper function may be run with different
+    // comment settings so use $comment->save() to avoid complex setup.
+    /** @var \Drupal\comment\CommentInterface $comment */
+    $comment = Comment::create([
+      'cid' => NULL,
+      'entity_id' => $this->node->id(),
+      'entity_type' => 'node',
+      'field_name' => 'comment',
+      'pid' => 0,
+      'uid' => $this->loggedInUser->id(),
+      'status' => CommentInterface::PUBLISHED,
+      'subject' => $this->randomMachineName(),
+      'hostname' => '127.0.0.1',
+      'langcode' => LanguageInterface::LANGCODE_NOT_SPECIFIED,
+      'comment_body' => [LanguageInterface::LANGCODE_NOT_SPECIFIED => [$this->randomMachineName()]],
+    ]);
+    $comment->save();
+    $this->drupalLogout();
+
+    // Log in with 'web user' and check comment links.
+    $this->drupalLogin($this->webUser);
+    $this->drupalGet('node');
+    // Verify the data-history-node-last-comment-timestamp attribute. Given its
+    // value, the drupal.node-new-comments-link library would determine that the
+    // node received a comment after the user last viewed it, and hence it would
+    // perform an HTTP request to render the "new comments" node link.
+    $this->assertIdentical(1, count($this->xpath('//*[@data-history-node-last-comment-timestamp="' . $comment->getChangedTime() . '"]')), 'data-history-node-last-comment-timestamp attribute is set to the correct value.');
+    $this->assertIdentical(1, count($this->xpath('//*[@data-history-node-field-name="comment"]')), 'data-history-node-field-name attribute is set to the correct value.');
+    // The data will be pre-seeded on this particular page in drupalSettings, to
+    // avoid the need for the client to make a separate request to the server.
+    $settings = $this->getDrupalSettings();
+    $this->assertEqual($settings['history'], ['lastReadTimestamps' => [1 => 0]]);
+    $this->assertEqual($settings['comment'], [
+      'newCommentsLinks' => [
+        'node' => [
+          'comment' => [
+            1 => [
+              'new_comment_count' => 1,
+              'first_new_comment_link' => Url::fromRoute('entity.node.canonical', ['node' => 1])->setOptions([
+                'fragment' => 'new',
+              ])->toString(),
+            ],
+          ],
+        ],
+      ],
+    ]);
+    // Pretend the data was not present in drupalSettings, i.e. test the
+    // separate request to the server.
+    $response = $this->renderNewCommentsNodeLinks([$this->node->id()]);
+    $this->assertSame(200, $response->getStatusCode());
+    $json = Json::decode($response->getBody());
+    $expected = [
+      $this->node->id() => [
+        'new_comment_count' => 1,
+        'first_new_comment_link' => $this->node->url('canonical', ['fragment' => 'new']),
+      ],
+    ];
+    $this->assertIdentical($expected, $json);
+
+    // Failing to specify node IDs for the endpoint should return a 404.
+    $response = $this->renderNewCommentsNodeLinks([]);
+    $this->assertSame(404, $response->getStatusCode());
+
+    // Accessing the endpoint as the anonymous user should return a 403.
+    $this->drupalLogout();
+    $response = $this->renderNewCommentsNodeLinks([$this->node->id()]);
+    $this->assertSame(403, $response->getStatusCode());
+    $response = $this->renderNewCommentsNodeLinks([]);
+    $this->assertSame(403, $response->getStatusCode());
+  }
+
+}

core/modules/comment/tests/src/Functional/CommentNonNodeTest.php

@@ -190,7 +190,7 @@ class CommentNonNodeTest extends BrowserTestBase {
       $regex .= $comment->comment_body->value . '(.*?)';
       $regex .= '/s';
 
-      return (boolean) preg_match($regex, $this->getRawContent());
+      return (boolean) preg_match($regex, $this->getSession()->getPage()->getContent());
     }
     else {
       return FALSE;
@@ -204,7 +204,7 @@ class CommentNonNodeTest extends BrowserTestBase {
    *   Contact info is available.
    */
   public function commentContactInfoAvailable() {
-    return preg_match('/(input).*?(name="name").*?(input).*?(name="mail").*?(input).*?(name="homepage")/s', $this->getRawContent());
+    return preg_match('/(input).*?(name="name").*?(input).*?(name="mail").*?(input).*?(name="homepage")/s', $this->getSession()->getPage()->getContent());
   }
 
   /**
@@ -243,7 +243,7 @@ class CommentNonNodeTest extends BrowserTestBase {
    */
   public function getUnapprovedComment($subject) {
     $this->drupalGet('admin/content/comment/approval');
-    preg_match('/href="(.*?)#comment-([^"]+)"(.*?)>(' . $subject . ')/', $this->getRawContent(), $match);
+    preg_match('/href="(.*?)#comment-([^"]+)"(.*?)>(' . $subject . ')/', $this->getSession()->getPage()->getContent(), $match);
 
     return $match[2];
   }
@@ -253,7 +253,7 @@ class CommentNonNodeTest extends BrowserTestBase {
    */
   public function testCommentFunctionality() {
     $limited_user = $this->drupalCreateUser([
-      'administer entity_test fields'
+      'administer entity_test fields',
     ]);
     $this->drupalLogin($limited_user);
     // Test that default field exists.

core/modules/comment/tests/src/Functional/CommentPagerTest.php

@@ -0,0 +1,433 @@
+<?php
+
+namespace Drupal\Tests\comment\Functional;
+
+use Drupal\comment\CommentManagerInterface;
+use Drupal\Component\Render\FormattableMarkup;
+use Drupal\node\Entity\Node;
+
+/**
+ * Tests paging of comments and their settings.
+ *
+ * @group comment
+ */
+class CommentPagerTest extends CommentTestBase {
+
+  /**
+   * Confirms comment paging works correctly with flat and threaded comments.
+   */
+  public function testCommentPaging() {
+    $this->drupalLogin($this->adminUser);
+
+    // Set comment variables.
+    $this->setCommentForm(TRUE);
+    $this->setCommentSubject(TRUE);
+    $this->setCommentPreview(DRUPAL_DISABLED);
+
+    // Create a node and three comments.
+    $node = $this->drupalCreateNode(['type' => 'article', 'promote' => 1]);
+    $comments = [];
+    $comments[] = $this->postComment($node, $this->randomMachineName(), $this->randomMachineName(), TRUE);
+    $comments[] = $this->postComment($node, $this->randomMachineName(), $this->randomMachineName(), TRUE);
+    $comments[] = $this->postComment($node, $this->randomMachineName(), $this->randomMachineName(), TRUE);
+
+    $this->setCommentSettings('default_mode', CommentManagerInterface::COMMENT_MODE_FLAT, 'Comment paging changed.');
+
+    // Set comments to one per page so that we are able to test paging without
+    // needing to insert large numbers of comments.
+    $this->setCommentsPerPage(1);
+
+    // Check the first page of the node, and confirm the correct comments are
+    // shown.
+    $this->drupalGet('node/' . $node->id());
+    $this->assertRaw(t('next'), 'Paging links found.');
+    $this->assertTrue($this->commentExists($comments[0]), 'Comment 1 appears on page 1.');
+    $this->assertFalse($this->commentExists($comments[1]), 'Comment 2 does not appear on page 1.');
+    $this->assertFalse($this->commentExists($comments[2]), 'Comment 3 does not appear on page 1.');
+
+    // Check the second page.
+    $this->drupalGet('node/' . $node->id(), ['query' => ['page' => 1]]);
+    $this->assertTrue($this->commentExists($comments[1]), 'Comment 2 appears on page 2.');
+    $this->assertFalse($this->commentExists($comments[0]), 'Comment 1 does not appear on page 2.');
+    $this->assertFalse($this->commentExists($comments[2]), 'Comment 3 does not appear on page 2.');
+
+    // Check the third page.
+    $this->drupalGet('node/' . $node->id(), ['query' => ['page' => 2]]);
+    $this->assertTrue($this->commentExists($comments[2]), 'Comment 3 appears on page 3.');
+    $this->assertFalse($this->commentExists($comments[0]), 'Comment 1 does not appear on page 3.');
+    $this->assertFalse($this->commentExists($comments[1]), 'Comment 2 does not appear on page 3.');
+
+    // Post a reply to the oldest comment and test again.
+    $oldest_comment = reset($comments);
+    $this->drupalGet('comment/reply/node/' . $node->id() . '/comment/' . $oldest_comment->id());
+    $reply = $this->postComment(NULL, $this->randomMachineName(), $this->randomMachineName(), TRUE);
+
+    $this->setCommentsPerPage(2);
+    // We are still in flat view - the replies should not be on the first page,
+    // even though they are replies to the oldest comment.
+    $this->drupalGet('node/' . $node->id(), ['query' => ['page' => 0]]);
+    $this->assertFalse($this->commentExists($reply, TRUE), 'In flat mode, reply does not appear on page 1.');
+
+    // If we switch to threaded mode, the replies on the oldest comment
+    // should be bumped to the first page and comment 6 should be bumped
+    // to the second page.
+    $this->setCommentSettings('default_mode', CommentManagerInterface::COMMENT_MODE_THREADED, 'Switched to threaded mode.');
+    $this->drupalGet('node/' . $node->id(), ['query' => ['page' => 0]]);
+    $this->assertTrue($this->commentExists($reply, TRUE), 'In threaded mode, reply appears on page 1.');
+    $this->assertFalse($this->commentExists($comments[1]), 'In threaded mode, comment 2 has been bumped off of page 1.');
+
+    // If (# replies > # comments per page) in threaded expanded view,
+    // the overage should be bumped.
+    $reply2 = $this->postComment(NULL, $this->randomMachineName(), $this->randomMachineName(), TRUE);
+    $this->drupalGet('node/' . $node->id(), ['query' => ['page' => 0]]);
+    $this->assertFalse($this->commentExists($reply2, TRUE), 'In threaded mode where # replies > # comments per page, the newest reply does not appear on page 1.');
+
+    // Test that the page build process does not somehow generate errors when
+    // # comments per page is set to 0.
+    $this->setCommentsPerPage(0);
+    $this->drupalGet('node/' . $node->id(), ['query' => ['page' => 0]]);
+    $this->assertFalse($this->commentExists($reply2, TRUE), 'Threaded mode works correctly when comments per page is 0.');
+
+    $this->drupalLogout();
+  }
+
+  /**
+   * Confirms comment paging works correctly with flat and threaded comments.
+   */
+  public function testCommentPermalink() {
+    $this->drupalLogin($this->adminUser);
+
+    // Set comment variables.
+    $this->setCommentForm(TRUE);
+    $this->setCommentSubject(TRUE);
+    $this->setCommentPreview(DRUPAL_DISABLED);
+
+    // Create a node and three comments.
+    $node = $this->drupalCreateNode(['type' => 'article', 'promote' => 1]);
+    $comments = [];
+    $comments[] = $this->postComment($node, 'comment 1: ' . $this->randomMachineName(), $this->randomMachineName(), TRUE);
+    $comments[] = $this->postComment($node, 'comment 2: ' . $this->randomMachineName(), $this->randomMachineName(), TRUE);
+    $comments[] = $this->postComment($node, 'comment 3: ' . $this->randomMachineName(), $this->randomMachineName(), TRUE);
+
+    $this->setCommentSettings('default_mode', CommentManagerInterface::COMMENT_MODE_FLAT, 'Comment paging changed.');
+
+    // Set comments to one per page so that we are able to test paging without
+    // needing to insert large numbers of comments.
+    $this->setCommentsPerPage(1);
+
+    // Navigate to each comment permalink as anonymous and assert it appears on
+    // the page.
+    foreach ($comments as $index => $comment) {
+      $this->drupalGet($comment->toUrl());
+      $this->assertTrue($this->commentExists($comment), sprintf('Comment %d appears on page %d.', $index + 1, $index + 1));
+    }
+  }
+
+  /**
+   * Tests comment ordering and threading.
+   */
+  public function testCommentOrderingThreading() {
+    $this->drupalLogin($this->adminUser);
+
+    // Set comment variables.
+    $this->setCommentForm(TRUE);
+    $this->setCommentSubject(TRUE);
+    $this->setCommentPreview(DRUPAL_DISABLED);
+
+    // Display all the comments on the same page.
+    $this->setCommentsPerPage(1000);
+
+    // Create a node and three comments.
+    $node = $this->drupalCreateNode(['type' => 'article', 'promote' => 1]);
+    $comments = [];
+    $comments[] = $this->postComment($node, $this->randomMachineName(), $this->randomMachineName(), TRUE);
+    $comments[] = $this->postComment($node, $this->randomMachineName(), $this->randomMachineName(), TRUE);
+    $comments[] = $this->postComment($node, $this->randomMachineName(), $this->randomMachineName(), TRUE);
+
+    // Post a reply to the second comment.
+    $this->drupalGet('comment/reply/node/' . $node->id() . '/comment/' . $comments[1]->id());
+    $comments[] = $this->postComment(NULL, $this->randomMachineName(), $this->randomMachineName(), TRUE);
+
+    // Post a reply to the first comment.
+    $this->drupalGet('comment/reply/node/' . $node->id() . '/comment/' . $comments[0]->id());
+    $comments[] = $this->postComment(NULL, $this->randomMachineName(), $this->randomMachineName(), TRUE);
+
+    // Post a reply to the last comment.
+    $this->drupalGet('comment/reply/node/' . $node->id() . '/comment/' . $comments[2]->id());
+    $comments[] = $this->postComment(NULL, $this->randomMachineName(), $this->randomMachineName(), TRUE);
+
+    // Post a reply to the second comment.
+    $this->drupalGet('comment/reply/node/' . $node->id() . '/comment/' . $comments[3]->id());
+    $comments[] = $this->postComment(NULL, $this->randomMachineName(), $this->randomMachineName(), TRUE);
+
+    // At this point, the comment tree is:
+    // - 0
+    //   - 4
+    // - 1
+    //   - 3
+    //     - 6
+    // - 2
+    //   - 5
+
+    $this->setCommentSettings('default_mode', CommentManagerInterface::COMMENT_MODE_FLAT, 'Comment paging changed.');
+
+    $expected_order = [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+    ];
+    $this->drupalGet('node/' . $node->id());
+    $this->assertCommentOrder($comments, $expected_order);
+
+    $this->setCommentSettings('default_mode', CommentManagerInterface::COMMENT_MODE_THREADED, 'Switched to threaded mode.');
+
+    $expected_order = [
+      0,
+      4,
+      1,
+      3,
+      6,
+      2,
+      5,
+    ];
+    $this->drupalGet('node/' . $node->id());
+    $this->assertCommentOrder($comments, $expected_order);
+  }
+
+  /**
+   * Asserts that the comments are displayed in the correct order.
+   *
+   * @param \Drupal\comment\CommentInterface[] $comments
+   *   An array of comments, must be of the type CommentInterface.
+   * @param array $expected_order
+   *   An array of keys from $comments describing the expected order.
+   */
+  public function assertCommentOrder(array $comments, array $expected_order) {
+    $expected_cids = [];
+
+    // First, rekey the expected order by cid.
+    foreach ($expected_order as $key) {
+      $expected_cids[] = $comments[$key]->id();
+    }
+
+    $comment_anchors = $this->xpath('//a[starts-with(@id,"comment-")]');
+    $result_order = [];
+    foreach ($comment_anchors as $anchor) {
+      $result_order[] = substr($anchor->getAttribute('id'), 8);
+    }
+    return $this->assertEqual($expected_cids, $result_order, format_string('Comment order: expected @expected, returned @returned.', ['@expected' => implode(',', $expected_cids), '@returned' => implode(',', $result_order)]));
+  }
+
+  /**
+   * Tests calculation of first page with new comment.
+   */
+  public function testCommentNewPageIndicator() {
+    $this->drupalLogin($this->adminUser);
+
+    // Set comment variables.
+    $this->setCommentForm(TRUE);
+    $this->setCommentSubject(TRUE);
+    $this->setCommentPreview(DRUPAL_DISABLED);
+
+    // Set comments to one per page so that we are able to test paging without
+    // needing to insert large numbers of comments.
+    $this->setCommentsPerPage(1);
+
+    // Create a node and three comments.
+    $node = $this->drupalCreateNode(['type' => 'article', 'promote' => 1]);
+    $comments = [];
+    $comments[] = $this->postComment($node, $this->randomMachineName(), $this->randomMachineName(), TRUE);
+    $comments[] = $this->postComment($node, $this->randomMachineName(), $this->randomMachineName(), TRUE);
+    $comments[] = $this->postComment($node, $this->randomMachineName(), $this->randomMachineName(), TRUE);
+
+    // Post a reply to the second comment.
+    $this->drupalGet('comment/reply/node/' . $node->id() . '/comment/' . $comments[1]->id());
+    $comments[] = $this->postComment(NULL, $this->randomMachineName(), $this->randomMachineName(), TRUE);
+
+    // Post a reply to the first comment.
+    $this->drupalGet('comment/reply/node/' . $node->id() . '/comment/' . $comments[0]->id());
+    $comments[] = $this->postComment(NULL, $this->randomMachineName(), $this->randomMachineName(), TRUE);
+
+    // Post a reply to the last comment.
+    $this->drupalGet('comment/reply/node/' . $node->id() . '/comment/' . $comments[2]->id());
+    $comments[] = $this->postComment(NULL, $this->randomMachineName(), $this->randomMachineName(), TRUE);
+
+    // At this point, the comment tree is:
+    // - 0
+    //   - 4
+    // - 1
+    //   - 3
+    // - 2
+    //   - 5
+
+    $this->setCommentSettings('default_mode', CommentManagerInterface::COMMENT_MODE_FLAT, 'Comment paging changed.');
+
+    $expected_pages = [
+      // Page of comment 5
+      1 => 5,
+      // Page of comment 4
+      2 => 4,
+      // Page of comment 3
+      3 => 3,
+      // Page of comment 2
+      4 => 2,
+      // Page of comment 1
+      5 => 1,
+      // Page of comment 0
+      6 => 0,
+    ];
+
+    $node = Node::load($node->id());
+    foreach ($expected_pages as $new_replies => $expected_page) {
+      $returned_page = \Drupal::entityManager()->getStorage('comment')
+        ->getNewCommentPageNumber($node->get('comment')->comment_count, $new_replies, $node, 'comment');
+      $this->assertIdentical($expected_page, $returned_page, format_string('Flat mode, @new replies: expected page @expected, returned page @returned.', ['@new' => $new_replies, '@expected' => $expected_page, '@returned' => $returned_page]));
+    }
+
+    $this->setCommentSettings('default_mode', CommentManagerInterface::COMMENT_MODE_THREADED, 'Switched to threaded mode.');
+
+    $expected_pages = [
+      // Page of comment 5
+      1 => 5,
+      // Page of comment 4
+      2 => 1,
+      // Page of comment 4
+      3 => 1,
+      // Page of comment 4
+      4 => 1,
+      // Page of comment 4
+      5 => 1,
+      // Page of comment 0
+      6 => 0,
+    ];
+
+    \Drupal::entityManager()->getStorage('node')->resetCache([$node->id()]);
+    $node = Node::load($node->id());
+    foreach ($expected_pages as $new_replies => $expected_page) {
+      $returned_page = \Drupal::entityManager()->getStorage('comment')
+        ->getNewCommentPageNumber($node->get('comment')->comment_count, $new_replies, $node, 'comment');
+      $this->assertEqual($expected_page, $returned_page, format_string('Threaded mode, @new replies: expected page @expected, returned page @returned.', ['@new' => $new_replies, '@expected' => $expected_page, '@returned' => $returned_page]));
+    }
+  }
+
+  /**
+   * Confirms comment paging works correctly with two pagers.
+   */
+  public function testTwoPagers() {
+    // Add another field to article content-type.
+    $this->addDefaultCommentField('node', 'article', 'comment_2');
+    // Set default to display comment list with unique pager id.
+    entity_get_display('node', 'article', 'default')
+      ->setComponent('comment_2', [
+        'label' => 'hidden',
+        'type' => 'comment_default',
+        'weight' => 30,
+        'settings' => [
+          'pager_id' => 1,
+          'view_mode' => 'default',
+        ],
+      ])
+      ->save();
+
+    // Make sure pager appears in formatter summary and settings form.
+    $account = $this->drupalCreateUser(['administer node display']);
+    $this->drupalLogin($account);
+    $this->drupalGet('admin/structure/types/manage/article/display');
+    $this->assertNoText(t('Pager ID: @id', ['@id' => 0]), 'No summary for standard pager');
+    $this->assertText(t('Pager ID: @id', ['@id' => 1]));
+    $this->drupalPostForm(NULL, [], 'comment_settings_edit');
+    // Change default pager to 2.
+    $this->drupalPostForm(NULL, ['fields[comment][settings_edit_form][settings][pager_id]' => 2], t('Save'));
+    $this->assertText(t('Pager ID: @id', ['@id' => 2]));
+    // Revert the changes.
+    $this->drupalPostForm(NULL, [], 'comment_settings_edit');
+    $this->drupalPostForm(NULL, ['fields[comment][settings_edit_form][settings][pager_id]' => 0], t('Save'));
+    $this->assertNoText(t('Pager ID: @id', ['@id' => 0]), 'No summary for standard pager');
+
+    $this->drupalLogin($this->adminUser);
+
+    // Add a new node with both comment fields open.
+    $node = $this->drupalCreateNode(['type' => 'article', 'promote' => 1, 'uid' => $this->webUser->id()]);
+    // Set comment options.
+    $comments = [];
+    foreach (['comment', 'comment_2'] as $field_name) {
+      $this->setCommentForm(TRUE, $field_name);
+      $this->setCommentPreview(DRUPAL_OPTIONAL, $field_name);
+      $this->setCommentSettings('default_mode', CommentManagerInterface::COMMENT_MODE_FLAT, 'Comment paging changed.', $field_name);
+
+      // Set comments to one per page so that we are able to test paging without
+      // needing to insert large numbers of comments.
+      $this->setCommentsPerPage(1, $field_name);
+      for ($i = 0; $i < 3; $i++) {
+        $comment = t('Comment @count on field @field', [
+          '@count' => $i + 1,
+          '@field' => $field_name,
+        ]);
+        $comments[] = $this->postComment($node, $comment, $comment, TRUE, $field_name);
+      }
+    }
+
+    // Check the first page of the node, and confirm the correct comments are
+    // shown.
+    $this->drupalGet('node/' . $node->id());
+    $this->assertRaw(t('next'), 'Paging links found.');
+    $this->assertRaw('Comment 1 on field comment');
+    $this->assertRaw('Comment 1 on field comment_2');
+    // Navigate to next page of field 1.
+    $this->clickLinkWithXPath('//h3/a[normalize-space(text())=:label]/ancestor::section[1]//a[@rel="next"]', [':label' => 'Comment 1 on field comment']);
+    // Check only one pager updated.
+    $this->assertRaw('Comment 2 on field comment');
+    $this->assertRaw('Comment 1 on field comment_2');
+    // Return to page 1.
+    $this->drupalGet('node/' . $node->id());
+    // Navigate to next page of field 2.
+    $this->clickLinkWithXPath('//h3/a[normalize-space(text())=:label]/ancestor::section[1]//a[@rel="next"]', [':label' => 'Comment 1 on field comment_2']);
+    // Check only one pager updated.
+    $this->assertRaw('Comment 1 on field comment');
+    $this->assertRaw('Comment 2 on field comment_2');
+    // Navigate to next page of field 1.
+    $this->clickLinkWithXPath('//h3/a[normalize-space(text())=:label]/ancestor::section[1]//a[@rel="next"]', [':label' => 'Comment 1 on field comment']);
+    // Check only one pager updated.
+    $this->assertRaw('Comment 2 on field comment');
+    $this->assertRaw('Comment 2 on field comment_2');
+  }
+
+  /**
+   * Follows a link found at a give xpath query.
+   *
+   * Will click the first link found with the given xpath query by default,
+   * or a later one if an index is given.
+   *
+   * If the link is discovered and clicked, the test passes. Fail otherwise.
+   *
+   * @param string $xpath
+   *   Xpath query that targets an anchor tag, or set of anchor tags.
+   * @param array $arguments
+   *   An array of arguments with keys in the form ':name' matching the
+   *   placeholders in the query. The values may be either strings or numeric
+   *   values.
+   * @param int $index
+   *   Link position counting from zero.
+   *
+   * @return string|false
+   *   Page contents on success, or FALSE on failure.
+   *
+   * @see WebTestBase::clickLink()
+   */
+  protected function clickLinkWithXPath($xpath, $arguments = [], $index = 0) {
+    $url_before = $this->getUrl();
+    $urls = $this->xpath($xpath, $arguments);
+    if (isset($urls[$index])) {
+      $url_target = $this->getAbsoluteUrl($urls[$index]->getAttribute('href'));
+      $this->pass(new FormattableMarkup('Clicked link %label (@url_target) from @url_before', ['%label' => $xpath, '@url_target' => $url_target, '@url_before' => $url_before]), 'Browser');
+      return $this->drupalGet($url_target);
+    }
+    $this->fail(new FormattableMarkup('Link %label does not exist on @url_before', ['%label' => $xpath, '@url_before' => $url_before]), 'Browser');
+    return FALSE;
+  }
+
+}

core/modules/comment/tests/src/Functional/CommentTestBase.php

@@ -336,7 +336,7 @@ abstract class CommentTestBase extends BrowserTestBase {
    *   Contact info is available.
    */
   public function commentContactInfoAvailable() {
-    return preg_match('/(input).*?(name="name").*?(input).*?(name="mail").*?(input).*?(name="homepage")/s', $this->getRawContent());
+    return preg_match('/(input).*?(name="name").*?(input).*?(name="mail").*?(input).*?(name="homepage")/s', $this->getSession()->getPage()->getContent());
   }
 
   /**
@@ -375,7 +375,7 @@ abstract class CommentTestBase extends BrowserTestBase {
    */
   public function getUnapprovedComment($subject) {
     $this->drupalGet('admin/content/comment/approval');
-    preg_match('/href="(.*?)#comment-([^"]+)"(.*?)>(' . $subject . ')/', $this->getRawContent(), $match);
+    preg_match('/href="(.*?)#comment-([^"]+)"(.*?)>(' . $subject . ')/', $this->getSession()->getPage()->getContent(), $match);
 
     return $match[2];
   }

core/modules/comment/tests/src/Functional/CommentThreadingTest.php

@@ -10,6 +10,7 @@ use Drupal\comment\CommentManagerInterface;
  * @group comment
  */
 class CommentThreadingTest extends CommentTestBase {
+
   /**
    * Tests the comment threading.
    */

core/modules/comment/tests/src/Functional/CommentTitleTest.php

@@ -9,6 +9,7 @@ namespace Drupal\Tests\comment\Functional;
  * @group comment
  */
 class CommentTitleTest extends CommentTestBase {
+
   /**
    * Tests markup for comments with empty titles.
    */

core/modules/comment/tests/src/Functional/CommentTranslationUITest.php

@@ -99,7 +99,7 @@ class CommentTranslationUITest extends ContentTranslationUITestBase {
     $node = $this->drupalCreateNode([
       'type' => $node_type,
       $field_name => [
-        ['status' => CommentItemInterface::OPEN]
+        ['status' => CommentItemInterface::OPEN],
       ],
     ]);
     $values['entity_id'] = $node->id();

core/modules/comment/tests/src/Functional/CommentUninstallTest.php

@@ -52,7 +52,6 @@ class CommentUninstallTest extends BrowserTestBase {
     }
   }
 
-
   /**
    * Tests if uninstallation succeeds if the field has been deleted beforehand.
    */

core/modules/comment/tests/src/Functional/Hal/CommentHalJsonAnonTest.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Drupal\Tests\comment\Functional\Hal;
+
+use Drupal\Tests\rest\Functional\AnonResourceTestTrait;
+
+/**
+ * @group hal
+ */
+class CommentHalJsonAnonTest extends CommentHalJsonTestBase {
+
+  use AnonResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   *
+   * Anononymous users cannot edit their own comments.
+   *
+   * @see \Drupal\comment\CommentAccessControlHandler::checkAccess
+   *
+   * Therefore we grant them the 'administer comments' permission for the
+   * purpose of this test. Then they are able to edit their own comments, but
+   * some fields are still not editable, even with that permission.
+   *
+   * @see ::setUpAuthorization
+   */
+  protected static $patchProtectedFieldNames = [
+    'changed' => NULL,
+    'thread' => NULL,
+    'entity_type' => NULL,
+    'field_name' => NULL,
+    'entity_id' => NULL,
+  ];
+
+}

core/modules/comment/tests/src/Functional/Hal/CommentHalJsonBasicAuthTest.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Drupal\Tests\comment\Functional\Hal;
+
+use Drupal\Tests\rest\Functional\BasicAuthResourceTestTrait;
+
+/**
+ * @group hal
+ */
+class CommentHalJsonBasicAuthTest extends CommentHalJsonTestBase {
+
+  use BasicAuthResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['basic_auth'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'basic_auth';
+
+}

core/modules/comment/tests/src/Functional/Hal/CommentHalJsonCookieTest.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace Drupal\Tests\comment\Functional\Hal;
+
+use Drupal\Tests\rest\Functional\CookieResourceTestTrait;
+
+/**
+ * @group hal
+ */
+class CommentHalJsonCookieTest extends CommentHalJsonTestBase {
+
+  use CookieResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'cookie';
+
+}

core/modules/comment/tests/src/Functional/Hal/CommentHalJsonTestBase.php

@@ -0,0 +1,130 @@
+<?php
+
+namespace Drupal\Tests\comment\Functional\Hal;
+
+use Drupal\entity_test\Entity\EntityTest;
+use Drupal\Tests\comment\Functional\Rest\CommentResourceTestBase;
+use Drupal\Tests\hal\Functional\EntityResource\HalEntityNormalizationTrait;
+use Drupal\user\Entity\User;
+
+abstract class CommentHalJsonTestBase extends CommentResourceTestBase {
+
+  use HalEntityNormalizationTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * {@inheritdoc}
+   *
+   * The HAL+JSON format causes different PATCH-protected fields. For some
+   * reason, the 'pid' and 'homepage' fields are NOT PATCH-protected, even
+   * though they are for non-HAL+JSON serializations.
+   *
+   * @todo fix in https://www.drupal.org/node/2824271
+   */
+  protected static $patchProtectedFieldNames = [
+    'status' => "The 'administer comments' permission is required.",
+    'created' => "The 'administer comments' permission is required.",
+    'changed' => NULL,
+    'thread' => NULL,
+    'entity_type' => NULL,
+    'field_name' => NULL,
+    'entity_id' => NULL,
+    'uid' => "The 'administer comments' permission is required.",
+  ];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getExpectedNormalizedEntity() {
+    $default_normalization = parent::getExpectedNormalizedEntity();
+
+    $normalization = $this->applyHalFieldNormalization($default_normalization);
+
+    // Because \Drupal\comment\Entity\Comment::getOwner() generates an in-memory
+    // User entity without a UUID, we cannot use it.
+    $author = User::load($this->entity->getOwnerId());
+    $commented_entity = EntityTest::load(1);
+    return $normalization + [
+      '_links' => [
+        'self' => [
+          'href' => $this->baseUrl . '/comment/1?_format=hal_json',
+        ],
+        'type' => [
+          'href' => $this->baseUrl . '/rest/type/comment/comment',
+        ],
+        $this->baseUrl . '/rest/relation/comment/comment/entity_id' => [
+          [
+            'href' => $this->baseUrl . '/entity_test/1?_format=hal_json',
+          ],
+        ],
+        $this->baseUrl . '/rest/relation/comment/comment/uid' => [
+          [
+            'href' => $this->baseUrl . '/user/' . $author->id() . '?_format=hal_json',
+            'lang' => 'en',
+          ],
+        ],
+      ],
+      '_embedded' => [
+        $this->baseUrl . '/rest/relation/comment/comment/entity_id' => [
+          [
+            '_links' => [
+              'self' => [
+                'href' => $this->baseUrl . '/entity_test/1?_format=hal_json',
+              ],
+              'type' => [
+                'href' => $this->baseUrl . '/rest/type/entity_test/bar',
+              ],
+            ],
+            'uuid' => [
+              ['value' => $commented_entity->uuid()],
+            ],
+          ],
+        ],
+        $this->baseUrl . '/rest/relation/comment/comment/uid' => [
+          [
+            '_links' => [
+              'self' => [
+                'href' => $this->baseUrl . '/user/' . $author->id() . '?_format=hal_json',
+              ],
+              'type' => [
+                'href' => $this->baseUrl . '/rest/type/user/user',
+              ],
+            ],
+            'uuid' => [
+              ['value' => $author->uuid()],
+            ],
+            'lang' => 'en',
+          ],
+        ],
+      ],
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getNormalizedPostEntity() {
+    return parent::getNormalizedPostEntity() + [
+      '_links' => [
+        'type' => [
+          'href' => $this->baseUrl . '/rest/type/comment/comment',
+        ],
+      ],
+    ];
+  }
+
+}

core/modules/comment/tests/src/Functional/Hal/CommentTypeHalJsonAnonTest.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Drupal\Tests\comment\Functional\Hal;
+
+use Drupal\Tests\comment\Functional\Rest\CommentTypeResourceTestBase;
+use Drupal\Tests\rest\Functional\AnonResourceTestTrait;
+
+/**
+ * @group hal
+ */
+class CommentTypeHalJsonAnonTest extends CommentTypeResourceTestBase {
+
+  use AnonResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+}

core/modules/comment/tests/src/Functional/Hal/CommentTypeHalJsonBasicAuthTest.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Drupal\Tests\comment\Functional\Hal;
+
+use Drupal\Tests\comment\Functional\Rest\CommentTypeResourceTestBase;
+use Drupal\Tests\rest\Functional\BasicAuthResourceTestTrait;
+
+/**
+ * @group hal
+ */
+class CommentTypeHalJsonBasicAuthTest extends CommentTypeResourceTestBase {
+
+  use BasicAuthResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal', 'basic_auth'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'basic_auth';
+
+}

core/modules/comment/tests/src/Functional/Hal/CommentTypeHalJsonCookieTest.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Drupal\Tests\comment\Functional\Hal;
+
+use Drupal\Tests\comment\Functional\Rest\CommentTypeResourceTestBase;
+use Drupal\Tests\rest\Functional\CookieResourceTestTrait;
+
+/**
+ * @group hal
+ */
+class CommentTypeHalJsonCookieTest extends CommentTypeResourceTestBase {
+
+  use CookieResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['hal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'hal_json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/hal+json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'cookie';
+
+}

core/modules/comment/tests/src/Functional/Rest/CommentJsonAnonTest.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace Drupal\Tests\comment\Functional\Rest;
+
+use Drupal\Tests\rest\Functional\AnonResourceTestTrait;
+
+/**
+ * @group rest
+ */
+class CommentJsonAnonTest extends CommentResourceTestBase {
+
+  use AnonResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/json';
+
+  /**
+   * {@inheritdoc}
+   *
+   * Anononymous users cannot edit their own comments.
+   *
+   * @see \Drupal\comment\CommentAccessControlHandler::checkAccess
+   *
+   * Therefore we grant them the 'administer comments' permission for the
+   * purpose of this test.
+   *
+   * @see ::setUpAuthorization
+   */
+  protected static $patchProtectedFieldNames = [
+    'pid' => NULL,
+    'entity_id' => NULL,
+    'changed' => NULL,
+    'thread' => NULL,
+    'entity_type' => NULL,
+    'field_name' => NULL,
+  ];
+
+}

core/modules/comment/tests/src/Functional/Rest/CommentJsonBasicAuthTest.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace Drupal\Tests\comment\Functional\Rest;
+
+use Drupal\Tests\rest\Functional\BasicAuthResourceTestTrait;
+
+/**
+ * @group rest
+ */
+class CommentJsonBasicAuthTest extends CommentResourceTestBase {
+
+  use BasicAuthResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['basic_auth'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'basic_auth';
+
+}

core/modules/comment/tests/src/Functional/Rest/CommentJsonCookieTest.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace Drupal\Tests\comment\Functional\Rest;
+
+use Drupal\Tests\rest\Functional\CookieResourceTestTrait;
+
+/**
+ * @group rest
+ */
+class CommentJsonCookieTest extends CommentResourceTestBase {
+
+  use CookieResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'cookie';
+
+}

core/modules/comment/tests/src/Functional/Rest/CommentResourceTestBase.php

@@ -0,0 +1,387 @@
+<?php
+
+namespace Drupal\Tests\comment\Functional\Rest;
+
+use Drupal\comment\Entity\Comment;
+use Drupal\comment\Entity\CommentType;
+use Drupal\comment\Tests\CommentTestTrait;
+use Drupal\Core\Cache\Cache;
+use Drupal\entity_test\Entity\EntityTest;
+use Drupal\Tests\rest\Functional\BcTimestampNormalizerUnixTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\EntityResourceTestBase;
+use Drupal\user\Entity\User;
+use GuzzleHttp\RequestOptions;
+
+abstract class CommentResourceTestBase extends EntityResourceTestBase {
+
+  use CommentTestTrait, BcTimestampNormalizerUnixTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['comment', 'entity_test'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $entityTypeId = 'comment';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $patchProtectedFieldNames = [
+    'status' => "The 'administer comments' permission is required.",
+    'pid' => NULL,
+    'entity_id' => NULL,
+    'uid' => "The 'administer comments' permission is required.",
+    'name' => "The 'administer comments' permission is required.",
+    'homepage' => "The 'administer comments' permission is required.",
+    'created' => "The 'administer comments' permission is required.",
+    'changed' => NULL,
+    'thread' => NULL,
+    'entity_type' => NULL,
+    'field_name' => NULL,
+  ];
+
+  /**
+   * @var \Drupal\comment\CommentInterface
+   */
+  protected $entity;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUpAuthorization($method) {
+    switch ($method) {
+      case 'GET':
+        $this->grantPermissionsToTestedRole(['access comments', 'view test entity']);
+        break;
+      case 'POST':
+        $this->grantPermissionsToTestedRole(['post comments']);
+        break;
+      case 'PATCH':
+        // Anononymous users are not ever allowed to edit their own comments. To
+        // be able to test PATCHing comments as the anonymous user, the more
+        // permissive 'administer comments' permission must be granted.
+        // @see \Drupal\comment\CommentAccessControlHandler::checkAccess
+        if (static::$auth) {
+          $this->grantPermissionsToTestedRole(['edit own comments']);
+        }
+        else {
+          $this->grantPermissionsToTestedRole(['administer comments']);
+        }
+        break;
+      case 'DELETE':
+        $this->grantPermissionsToTestedRole(['administer comments']);
+        break;
+    }
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function createEntity() {
+    // Create a "bar" bundle for the "entity_test" entity type and create.
+    $bundle = 'bar';
+    entity_test_create_bundle($bundle, NULL, 'entity_test');
+
+    // Create a comment field on this bundle.
+    $this->addDefaultCommentField('entity_test', 'bar', 'comment');
+
+    // Create a "Camelids" test entity that the comment will be assigned to.
+    $commented_entity = EntityTest::create([
+      'name' => 'Camelids',
+      'type' => 'bar',
+    ]);
+    $commented_entity->save();
+
+    // Create a "Llama" comment.
+    $comment = Comment::create([
+      'comment_body' => [
+        'value' => 'The name "llama" was adopted by European settlers from native Peruvians.',
+        'format' => 'plain_text',
+      ],
+      'entity_id' => $commented_entity->id(),
+      'entity_type' => 'entity_test',
+      'field_name' => 'comment',
+    ]);
+    $comment->setSubject('Llama')
+      ->setOwnerId(static::$auth ? $this->account->id() : 0)
+      ->setPublished()
+      ->setCreatedTime(123456789)
+      ->setChangedTime(123456789);
+    $comment->save();
+
+    return $comment;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getExpectedNormalizedEntity() {
+    $author = User::load($this->entity->getOwnerId());
+    return [
+      'cid' => [
+        ['value' => 1],
+      ],
+      'uuid' => [
+        ['value' => $this->entity->uuid()],
+      ],
+      'langcode' => [
+        [
+          'value' => 'en',
+        ],
+      ],
+      'comment_type' => [
+        [
+          'target_id' => 'comment',
+          'target_type' => 'comment_type',
+          'target_uuid' => CommentType::load('comment')->uuid(),
+        ],
+      ],
+      'subject' => [
+        [
+          'value' => 'Llama',
+        ],
+      ],
+      'status' => [
+        [
+          'value' => TRUE,
+        ],
+      ],
+      'created' => [
+        $this->formatExpectedTimestampItemValues(123456789),
+      ],
+      'changed' => [
+        $this->formatExpectedTimestampItemValues($this->entity->getChangedTime()),
+      ],
+      'default_langcode' => [
+        [
+          'value' => TRUE,
+        ],
+      ],
+      'uid' => [
+        [
+          'target_id' => (int) $author->id(),
+          'target_type' => 'user',
+          'target_uuid' => $author->uuid(),
+          'url' => base_path() . 'user/' . $author->id(),
+        ],
+      ],
+      'pid' => [],
+      'entity_type' => [
+        [
+          'value' => 'entity_test',
+        ],
+      ],
+      'entity_id' => [
+        [
+          'target_id' => 1,
+          'target_type' => 'entity_test',
+          'target_uuid' => EntityTest::load(1)->uuid(),
+          'url' => base_path() . 'entity_test/1',
+        ],
+      ],
+      'field_name' => [
+        [
+          'value' => 'comment',
+        ],
+      ],
+      'name' => [],
+      'homepage' => [],
+      'thread' => [
+        [
+          'value' => '01/',
+        ],
+      ],
+      'comment_body' => [
+        [
+          'value' => 'The name "llama" was adopted by European settlers from native Peruvians.',
+          'format' => 'plain_text',
+          'processed' => '<p>The name &quot;llama&quot; was adopted by European settlers from native Peruvians.</p>' . "\n",
+        ],
+      ],
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getNormalizedPostEntity() {
+    return [
+      'comment_type' => [
+        [
+          'target_id' => 'comment',
+        ],
+      ],
+      'entity_type' => [
+        [
+          'value' => 'entity_test',
+        ],
+      ],
+      'entity_id' => [
+        [
+          'target_id' => (int) EntityTest::load(1)->id(),
+        ],
+      ],
+      'field_name' => [
+        [
+          'value' => 'comment',
+        ],
+      ],
+      'subject' => [
+        [
+          'value' => 'Dramallama',
+        ],
+      ],
+      'comment_body' => [
+        [
+          'value' => 'Llamas are awesome.',
+          'format' => 'plain_text',
+        ],
+      ],
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getNormalizedPatchEntity() {
+    return array_diff_key($this->getNormalizedPostEntity(), ['entity_type' => TRUE, 'entity_id' => TRUE, 'field_name' => TRUE]);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getExpectedCacheTags() {
+    return Cache::mergeTags(parent::getExpectedCacheTags(), ['config:filter.format.plain_text']);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getExpectedCacheContexts() {
+    return Cache::mergeContexts(['languages:language_interface', 'theme'], parent::getExpectedCacheContexts());
+  }
+
+  /**
+   * Tests POSTing a comment without critical base fields.
+   *
+   * Tests with the most minimal normalization possible: the one returned by
+   * ::getNormalizedPostEntity().
+   *
+   * But Comment entities have some very special edge cases:
+   * - base fields that are not marked as required in
+   *   \Drupal\comment\Entity\Comment::baseFieldDefinitions() yet in fact are
+   *   required.
+   * - base fields that are marked as required, but yet can still result in
+   *   validation errors other than "missing required field".
+   */
+  public function testPostDxWithoutCriticalBaseFields() {
+    $this->initAuthentication();
+    $this->provisionEntityResource();
+    $this->setUpAuthorization('POST');
+
+    $url = $this->getEntityResourcePostUrl()->setOption('query', ['_format' => static::$format]);
+    $request_options = [];
+    $request_options[RequestOptions::HEADERS]['Accept'] = static::$mimeType;
+    $request_options[RequestOptions::HEADERS]['Content-Type'] = static::$mimeType;
+    $request_options = array_merge_recursive($request_options, $this->getAuthenticationRequestOptions('POST'));
+
+    // DX: 422 when missing 'entity_type' field.
+    $request_options[RequestOptions::BODY] = $this->serializer->encode(array_diff_key($this->getNormalizedPostEntity(), ['entity_type' => TRUE]), static::$format);
+    $response = $this->request('POST', $url, $request_options);
+    // @todo Uncomment, remove next 3 lines in https://www.drupal.org/node/2820364.
+    $this->assertSame(500, $response->getStatusCode());
+    $this->assertSame(['text/plain; charset=UTF-8'], $response->getHeader('Content-Type'));
+    $this->assertStringStartsWith('The website encountered an unexpected error. Please try again later.</br></br><em class="placeholder">Symfony\Component\HttpKernel\Exception\HttpException</em>: Internal Server Error in <em class="placeholder">Drupal\rest\Plugin\rest\resource\EntityResource-&gt;post()</em>', (string) $response->getBody());
+    // $this->assertResourceErrorResponse(422, "Unprocessable Entity: validation failed.\nentity_type: This value should not be null.\n", $response);
+
+    // DX: 422 when missing 'entity_id' field.
+    $request_options[RequestOptions::BODY] = $this->serializer->encode(array_diff_key($this->getNormalizedPostEntity(), ['entity_id' => TRUE]), static::$format);
+    // @todo Remove the try/catch in favor of the two commented lines in
+    // https://www.drupal.org/node/2820364.
+    try {
+      $response = $this->request('POST', $url, $request_options);
+      // This happens on DrupalCI.
+      // $this->assertSame(500, $response->getStatusCode());
+    }
+    catch (\Exception $e) {
+      // This happens on Wim's local machine.
+      // $this->assertSame("Error: Call to a member function get() on null\nDrupal\\comment\\Plugin\\Validation\\Constraint\\CommentNameConstraintValidator->getAnonymousContactDetailsSetting()() (Line: 96)\n", $e->getMessage());
+    }
+    // $response = $this->request('POST', $url, $request_options);
+    // $this->assertResourceErrorResponse(422, "Unprocessable Entity: validation failed.\nentity_type: This value should not be null.\n", $response);
+
+    // DX: 422 when missing 'entity_type' field.
+    $request_options[RequestOptions::BODY] = $this->serializer->encode(array_diff_key($this->getNormalizedPostEntity(), ['field_name' => TRUE]), static::$format);
+    $response = $this->request('POST', $url, $request_options);
+    // @todo Uncomment, remove next 2 lines in https://www.drupal.org/node/2820364.
+    $this->assertSame(500, $response->getStatusCode());
+    $this->assertSame(['text/plain; charset=UTF-8'], $response->getHeader('Content-Type'));
+    // $this->assertResourceErrorResponse(422, "Unprocessable Entity: validation failed.\nfield_name: This value should not be null.\n", $response);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getExpectedUnauthorizedAccessMessage($method) {
+    if ($this->config('rest.settings')->get('bc_entity_resource_permissions')) {
+      return parent::getExpectedUnauthorizedAccessMessage($method);
+    }
+
+    switch ($method) {
+      case 'GET';
+        return "The 'access comments' permission is required and the comment must be published.";
+      case 'POST';
+        return "The 'post comments' permission is required.";
+      case 'PATCH';
+        return "The 'edit own comments' permission is required, the user must be the comment author, and the comment must be published.";
+      default:
+        return parent::getExpectedUnauthorizedAccessMessage($method);
+    }
+  }
+
+  /**
+   * Tests POSTing a comment with and without 'skip comment approval'
+   */
+  public function testPostSkipCommentApproval() {
+    $this->initAuthentication();
+    $this->provisionEntityResource();
+    $this->setUpAuthorization('POST');
+
+    // Create request.
+    $request_options = [];
+    $request_options[RequestOptions::HEADERS]['Accept'] = static::$mimeType;
+    $request_options[RequestOptions::HEADERS]['Content-Type'] = static::$mimeType;
+    $request_options = array_merge_recursive($request_options, $this->getAuthenticationRequestOptions('POST'));
+    $request_options[RequestOptions::BODY] = $this->serializer->encode($this->getNormalizedPostEntity(), static::$format);
+
+    $url = $this->getEntityResourcePostUrl()->setOption('query', ['_format' => static::$format]);
+
+    // Status should be FALSE when posting as anonymous.
+    $response = $this->request('POST', $url, $request_options);
+    $unserialized = $this->serializer->deserialize((string) $response->getBody(), get_class($this->entity), static::$format);
+    $this->assertResourceResponse(201, FALSE, $response);
+    $this->assertFalse($unserialized->getStatus());
+
+    // Grant anonymous permission to skip comment approval.
+    $this->grantPermissionsToTestedRole(['skip comment approval']);
+
+    // Status should be TRUE when posting as anonymous and skip comment approval.
+    $response = $this->request('POST', $url, $request_options);
+    $unserialized = $this->serializer->deserialize((string) $response->getBody(), get_class($this->entity), static::$format);
+    $this->assertResourceResponse(201, FALSE, $response);
+    $this->assertTrue($unserialized->getStatus());
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getExpectedUnauthorizedAccessCacheability() {
+    // @see \Drupal\comment\CommentAccessControlHandler::checkAccess()
+    return parent::getExpectedUnauthorizedAccessCacheability()
+      ->addCacheTags(['comment:1']);
+  }
+
+}

core/modules/comment/tests/src/Functional/Rest/CommentTypeJsonAnonTest.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Drupal\Tests\comment\Functional\Rest;
+
+use Drupal\Tests\rest\Functional\AnonResourceTestTrait;
+
+/**
+ * @group rest
+ */
+class CommentTypeJsonAnonTest extends CommentTypeResourceTestBase {
+
+  use AnonResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/json';
+
+}

core/modules/comment/tests/src/Functional/Rest/CommentTypeJsonBasicAuthTest.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace Drupal\Tests\comment\Functional\Rest;
+
+use Drupal\Tests\rest\Functional\BasicAuthResourceTestTrait;
+
+/**
+ * @group rest
+ */
+class CommentTypeJsonBasicAuthTest extends CommentTypeResourceTestBase {
+
+  use BasicAuthResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['basic_auth'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'basic_auth';
+
+}

core/modules/comment/tests/src/Functional/Rest/CommentTypeJsonCookieTest.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace Drupal\Tests\comment\Functional\Rest;
+
+use Drupal\Tests\rest\Functional\CookieResourceTestTrait;
+
+/**
+ * @group rest
+ */
+class CommentTypeJsonCookieTest extends CommentTypeResourceTestBase {
+
+  use CookieResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'application/json';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'cookie';
+
+}

core/modules/comment/tests/src/Functional/Rest/CommentTypeResourceTestBase.php

@@ -0,0 +1,77 @@
+<?php
+
+namespace Drupal\Tests\comment\Functional\Rest;
+
+use Drupal\comment\Entity\CommentType;
+use Drupal\Tests\rest\Functional\EntityResource\EntityResourceTestBase;
+
+/**
+ * ResourceTestBase for CommentType entity.
+ */
+abstract class CommentTypeResourceTestBase extends EntityResourceTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['node', 'comment'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $entityTypeId = 'comment_type';
+
+  /**
+   * The CommentType entity.
+   *
+   * @var \Drupal\comment\CommentTypeInterface
+   */
+  protected $entity;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUpAuthorization($method) {
+    $this->grantPermissionsToTestedRole(['administer comment types']);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function createEntity() {
+    // Create a "Camelids" comment type.
+    $camelids = CommentType::create([
+      'id' => 'camelids',
+      'label' => 'Camelids',
+      'description' => 'Camelids are large, strictly herbivorous animals with slender necks and long legs.',
+      'target_entity_type_id' => 'node',
+    ]);
+
+    $camelids->save();
+
+    return $camelids;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getExpectedNormalizedEntity() {
+    return [
+      'dependencies' => [],
+      'description' => 'Camelids are large, strictly herbivorous animals with slender necks and long legs.',
+      'id' => 'camelids',
+      'label' => 'Camelids',
+      'langcode' => 'en',
+      'status' => TRUE,
+      'target_entity_type_id' => 'node',
+      'uuid' => $this->entity->uuid(),
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getNormalizedPostEntity() {
+    // @todo Update in https://www.drupal.org/node/2300677.
+  }
+
+}

core/modules/comment/tests/src/Functional/Rest/CommentTypeXmlAnonTest.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace Drupal\Tests\comment\Functional\Rest;
+
+use Drupal\Tests\rest\Functional\AnonResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\XmlEntityNormalizationQuirksTrait;
+
+/**
+ * @group rest
+ */
+class CommentTypeXmlAnonTest extends CommentTypeResourceTestBase {
+
+  use AnonResourceTestTrait;
+  use XmlEntityNormalizationQuirksTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'xml';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'text/xml; charset=UTF-8';
+
+}

core/modules/comment/tests/src/Functional/Rest/CommentTypeXmlBasicAuthTest.php

@@ -0,0 +1,36 @@
+<?php
+
+namespace Drupal\Tests\comment\Functional\Rest;
+
+use Drupal\Tests\rest\Functional\BasicAuthResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\XmlEntityNormalizationQuirksTrait;
+
+/**
+ * @group rest
+ */
+class CommentTypeXmlBasicAuthTest extends CommentTypeResourceTestBase {
+
+  use BasicAuthResourceTestTrait;
+  use XmlEntityNormalizationQuirksTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['basic_auth'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'xml';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'text/xml; charset=UTF-8';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'basic_auth';
+
+}

core/modules/comment/tests/src/Functional/Rest/CommentTypeXmlCookieTest.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace Drupal\Tests\comment\Functional\Rest;
+
+use Drupal\Tests\rest\Functional\CookieResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\XmlEntityNormalizationQuirksTrait;
+
+/**
+ * @group rest
+ */
+class CommentTypeXmlCookieTest extends CommentTypeResourceTestBase {
+
+  use CookieResourceTestTrait;
+  use XmlEntityNormalizationQuirksTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'xml';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'text/xml; charset=UTF-8';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'cookie';
+
+}

core/modules/comment/tests/src/Functional/Rest/CommentXmlAnonTest.php

@@ -0,0 +1,63 @@
+<?php
+
+namespace Drupal\Tests\comment\Functional\Rest;
+
+use Drupal\Tests\rest\Functional\AnonResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\XmlEntityNormalizationQuirksTrait;
+
+/**
+ * @group rest
+ */
+class CommentXmlAnonTest extends CommentResourceTestBase {
+
+  use AnonResourceTestTrait;
+  use XmlEntityNormalizationQuirksTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'xml';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'text/xml; charset=UTF-8';
+
+  /**
+   * {@inheritdoc}
+   *
+   * Anononymous users cannot edit their own comments.
+   *
+   * @see \Drupal\comment\CommentAccessControlHandler::checkAccess
+   *
+   * Therefore we grant them the 'administer comments' permission for the
+   * purpose of this test.
+   *
+   * @see ::setUpAuthorization
+   */
+  protected static $patchProtectedFieldNames = [
+    'pid',
+    'entity_id',
+    'changed',
+    'thread',
+    'entity_type',
+    'field_name',
+  ];
+
+  /**
+   * {@inheritdoc}
+   */
+  public function testPostDxWithoutCriticalBaseFields() {
+    // Deserialization of the XML format is not supported.
+    $this->markTestSkipped();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function testPostSkipCommentApproval() {
+    // Deserialization of the XML format is not supported.
+    $this->markTestSkipped();
+  }
+
+}

core/modules/comment/tests/src/Functional/Rest/CommentXmlBasicAuthTest.php

@@ -0,0 +1,52 @@
+<?php
+
+namespace Drupal\Tests\comment\Functional\Rest;
+
+use Drupal\Tests\rest\Functional\BasicAuthResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\XmlEntityNormalizationQuirksTrait;
+
+/**
+ * @group rest
+ */
+class CommentXmlBasicAuthTest extends CommentResourceTestBase {
+
+  use BasicAuthResourceTestTrait;
+  use XmlEntityNormalizationQuirksTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = ['basic_auth'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'xml';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'text/xml; charset=UTF-8';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'basic_auth';
+
+  /**
+   * {@inheritdoc}
+   */
+  public function testPostDxWithoutCriticalBaseFields() {
+    // Deserialization of the XML format is not supported.
+    $this->markTestSkipped();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function testPostSkipCommentApproval() {
+    // Deserialization of the XML format is not supported.
+    $this->markTestSkipped();
+  }
+
+}

core/modules/comment/tests/src/Functional/Rest/CommentXmlCookieTest.php

@@ -0,0 +1,47 @@
+<?php
+
+namespace Drupal\Tests\comment\Functional\Rest;
+
+use Drupal\Tests\rest\Functional\CookieResourceTestTrait;
+use Drupal\Tests\rest\Functional\EntityResource\XmlEntityNormalizationQuirksTrait;
+
+/**
+ * @group rest
+ */
+class CommentXmlCookieTest extends CommentResourceTestBase {
+
+  use CookieResourceTestTrait;
+  use XmlEntityNormalizationQuirksTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $format = 'xml';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $mimeType = 'text/xml; charset=UTF-8';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'cookie';
+
+  /**
+   * {@inheritdoc}
+   */
+  public function testPostDxWithoutCriticalBaseFields() {
+    // Deserialization of the XML format is not supported.
+    $this->markTestSkipped();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function testPostSkipCommentApproval() {
+    // Deserialization of the XML format is not supported.
+    $this->markTestSkipped();
+  }
+
+}

core/modules/comment/tests/src/Functional/Update/CommentAdminViewUpdateTest.php

@@ -10,6 +10,7 @@ use Drupal\FunctionalTests\Update\UpdatePathTestBase;
  * @see comment_post_update_enable_comment_admin_view()
  *
  * @group Update
+ * @group legacy
  */
 class CommentAdminViewUpdateTest extends UpdatePathTestBase {
 

core/modules/comment/tests/src/Functional/Update/CommentHostnameUpdateTest.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace Drupal\Tests\comment\Functional\Update;
+
+use Drupal\comment\Entity\Comment;
+use Drupal\FunctionalTests\Update\UpdatePathTestBase;
+
+/**
+ * Tests that comment hostname settings are properly updated.
+ *
+ * @group comment
+ * @group legacy
+ */
+class CommentHostnameUpdateTest extends UpdatePathTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setDatabaseDumpFiles() {
+    $this->databaseDumpFiles = [
+      __DIR__ . '/../../../../../system/tests/fixtures/update/drupal-8-rc1.bare.standard.php.gz',
+    ];
+  }
+
+  /**
+   * Tests comment_update_8600().
+   *
+   * @see comment_update_8600
+   */
+  public function testCommentUpdate8600() {
+    /** @var \Drupal\Core\Entity\EntityDefinitionUpdateManagerInterface $manager */
+    $manager = $this->container->get('entity.definition_update_manager');
+
+    /** @var \Drupal\Core\Field\BaseFieldDefinition $definition */
+    $definition = $manager->getFieldStorageDefinition('hostname', 'comment');
+    // Check that 'hostname' base field doesn't have a default value callback.
+    $this->assertNull($definition->getDefaultValueCallback());
+
+    $this->runUpdates();
+
+    $definition = $manager->getFieldStorageDefinition('hostname', 'comment');
+    // Check that 'hostname' base field default value callback was set.
+    $this->assertEquals(Comment::class . '::getDefaultHostname', $definition->getDefaultValueCallback());
+  }
+
+}

core/modules/comment/tests/src/Functional/Update/CommentUpdateTest.php

@@ -8,6 +8,7 @@ use Drupal\FunctionalTests\Update\UpdatePathTestBase;
  * Tests that comment settings are properly updated during database updates.
  *
  * @group comment
+ * @group legacy
  */
 class CommentUpdateTest extends UpdatePathTestBase {
 

core/modules/comment/tests/src/Functional/Views/CommentRestExportTest.php

@@ -46,14 +46,13 @@ class CommentRestExportTest extends CommentTestBase {
     $this->drupalLogin($user);
   }
 
-
   /**
    * Test comment row.
    */
   public function testCommentRestExport() {
     $this->drupalGet(sprintf('node/%d/comments', $this->nodeUserCommented->id()), ['query' => ['_format' => 'hal_json']]);
     $this->assertResponse(200);
-    $contents = Json::decode($this->getRawContent());
+    $contents = Json::decode($this->getSession()->getPage()->getContent());
     $this->assertEqual($contents[0]['subject'], 'How much wood would a woodchuck chuck');
     $this->assertEqual($contents[1]['subject'], 'A lot, apparently');
     $this->assertEqual(count($contents), 2);

core/modules/comment/tests/src/Functional/Views/DefaultViewRecentCommentsTest.php

@@ -119,7 +119,7 @@ class DefaultViewRecentCommentsTest extends ViewTestBase {
     $map = [
       'subject' => 'subject',
       'cid' => 'cid',
-      'comment_field_data_created' => 'created'
+      'comment_field_data_created' => 'created',
     ];
     $expected_result = [];
     foreach (array_values($this->commentsCreated) as $key => $comment) {

core/modules/comment/tests/src/Functional/Views/WizardTest.php

@@ -23,7 +23,6 @@ class WizardTest extends WizardTestBase {
    */
   public static $modules = ['node', 'comment'];
 
-
   /**
    * {@inheritdoc}
    */

core/modules/comment/tests/src/Kernel/CommentFieldAccessTest.php

@@ -5,7 +5,7 @@ namespace Drupal\Tests\comment\Kernel;
 use Drupal\comment\Entity\Comment;
 use Drupal\comment\Entity\CommentType;
 use Drupal\comment\Tests\CommentTestTrait;
-use Drupal\Component\Utility\SafeMarkup;
+use Drupal\Component\Render\FormattableMarkup;
 use Drupal\Core\Session\AnonymousUserSession;
 use Drupal\entity_test\Entity\EntityTest;
 use Drupal\field\Entity\FieldConfig;
@@ -202,7 +202,7 @@ class CommentFieldAccessTest extends EntityKernelTestBase {
     // Generate permutations.
     $combinations = [
       'comment' => [$comment1, $comment2, $comment3, $comment4],
-      'user' => [$comment_admin_user, $comment_enabled_user, $comment_no_edit_user, $comment_disabled_user, $anonymous_user]
+      'user' => [$comment_admin_user, $comment_enabled_user, $comment_no_edit_user, $comment_disabled_user, $anonymous_user],
     ];
     $permutations = $this->generatePermutations($combinations);
 
@@ -211,12 +211,12 @@ class CommentFieldAccessTest extends EntityKernelTestBase {
       foreach ($permutations as $set) {
         $may_view = $set['comment']->{$field}->access('view', $set['user']);
         $may_update = $set['comment']->{$field}->access('edit', $set['user']);
-        $this->assertTrue($may_view, SafeMarkup::format('User @user can view field @field on comment @comment', [
+        $this->assertTrue($may_view, new FormattableMarkup('User @user can view field @field on comment @comment', [
           '@user' => $set['user']->getUsername(),
           '@comment' => $set['comment']->getSubject(),
           '@field' => $field,
         ]));
-        $this->assertEqual($may_update, $set['user']->hasPermission('administer comments'), SafeMarkup::format('User @user @state update field @field on comment @comment', [
+        $this->assertEqual($may_update, $set['user']->hasPermission('administer comments'), new FormattableMarkup('User @user @state update field @field on comment @comment', [
           '@user' => $set['user']->getUsername(),
           '@state' => $may_update ? 'can' : 'cannot',
           '@comment' => $set['comment']->getSubject(),
@@ -228,7 +228,7 @@ class CommentFieldAccessTest extends EntityKernelTestBase {
     // Check access to normal field.
     foreach ($permutations as $set) {
       $may_update = $set['comment']->access('update', $set['user']) && $set['comment']->subject->access('edit', $set['user']);
-      $this->assertEqual($may_update, $set['user']->hasPermission('administer comments') || ($set['user']->hasPermission('edit own comments') && $set['user']->id() == $set['comment']->getOwnerId()), SafeMarkup::format('User @user @state update field subject on comment @comment', [
+      $this->assertEqual($may_update, $set['user']->hasPermission('administer comments') || ($set['user']->hasPermission('edit own comments') && $set['user']->id() == $set['comment']->getOwnerId()), new FormattableMarkup('User @user @state update field subject on comment @comment', [
         '@user' => $set['user']->getUsername(),
         '@state' => $may_update ? 'can' : 'cannot',
         '@comment' => $set['comment']->getSubject(),
@@ -250,13 +250,13 @@ class CommentFieldAccessTest extends EntityKernelTestBase {
           $view_access = TRUE;
           $state = 'can';
         }
-        $this->assertEqual($may_view, $view_access, SafeMarkup::format('User @user @state view field @field on comment @comment', [
+        $this->assertEqual($may_view, $view_access, new FormattableMarkup('User @user @state view field @field on comment @comment', [
           '@user' => $set['user']->getUsername(),
           '@comment' => $set['comment']->getSubject(),
           '@field' => $field,
           '@state' => $state,
         ]));
-        $this->assertFalse($may_update, SafeMarkup::format('User @user @state update field @field on comment @comment', [
+        $this->assertFalse($may_update, new FormattableMarkup('User @user @state update field @field on comment @comment', [
           '@user' => $set['user']->getUsername(),
           '@state' => $may_update ? 'can' : 'cannot',
           '@comment' => $set['comment']->getSubject(),
@@ -271,12 +271,12 @@ class CommentFieldAccessTest extends EntityKernelTestBase {
       foreach ($permutations as $set) {
         $may_view = $set['comment']->{$field}->access('view', $set['user']);
         $may_update = $set['comment']->{$field}->access('edit', $set['user']);
-        $this->assertEqual($may_view, TRUE, SafeMarkup::format('User @user can view field @field on comment @comment', [
+        $this->assertEqual($may_view, TRUE, new FormattableMarkup('User @user can view field @field on comment @comment', [
           '@user' => $set['user']->getUsername(),
           '@comment' => $set['comment']->getSubject(),
           '@field' => $field,
         ]));
-        $this->assertEqual($may_update, $set['user']->hasPermission('post comments') && $set['comment']->isNew(), SafeMarkup::format('User @user @state update field @field on comment @comment', [
+        $this->assertEqual($may_update, $set['user']->hasPermission('post comments') && $set['comment']->isNew(), new FormattableMarkup('User @user @state update field @field on comment @comment', [
           '@user' => $set['user']->getUsername(),
           '@state' => $may_update ? 'can' : 'cannot',
           '@comment' => $set['comment']->getSubject(),
@@ -298,7 +298,7 @@ class CommentFieldAccessTest extends EntityKernelTestBase {
             $set['comment']->isNew() &&
             $set['user']->hasPermission('post comments') &&
             $set['comment']->getFieldName() == 'comment_other'
-          ), SafeMarkup::format('User @user @state update field @field on comment @comment', [
+          ), new FormattableMarkup('User @user @state update field @field on comment @comment', [
           '@user' => $set['user']->getUsername(),
           '@state' => $may_update ? 'can' : 'cannot',
           '@comment' => $set['comment']->getSubject(),

core/modules/comment/tests/src/Kernel/CommentHostnameTest.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace Drupal\Tests\comment\Kernel;
+
+use Drupal\comment\Entity\Comment;
+use Drupal\comment\Entity\CommentType;
+use Drupal\KernelTests\KernelTestBase;
+use Symfony\Component\HttpFoundation\Request;
+
+/**
+ * Tests the hostname base field.
+ *
+ * @coversDefaultClass \Drupal\comment\Entity\Comment
+ *
+ * @group comment
+ */
+class CommentHostnameTest extends KernelTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $modules = ['comment', 'entity_test', 'user'];
+
+  /**
+   * Tests hostname default value callback.
+   *
+   * @covers ::getDefaultHostname
+   */
+  public function testGetDefaultHostname() {
+    // Create a fake request to be used for testing.
+    $request = Request::create('/', 'GET', [], [], [], ['REMOTE_ADDR' => '203.0.113.1']);
+    /** @var \Symfony\Component\HttpFoundation\RequestStack $stack */
+    $stack = $this->container->get('request_stack');
+    $stack->push($request);
+
+    CommentType::create([
+      'id' => 'foo',
+      'target_entity_type_id' => 'entity_test',
+    ])->save();
+    $comment = Comment::create(['comment_type' => 'foo']);
+
+    // Check that the hostname was set correctly.
+    $this->assertEquals('203.0.113.1', $comment->getHostname());
+  }
+
+}

core/modules/comment/tests/src/Kernel/CommentIntegrationTest.php

@@ -3,7 +3,6 @@
 namespace Drupal\Tests\comment\Kernel;
 
 use Drupal\comment\Entity\CommentType;
-use Drupal\Component\Utility\Unicode;
 use Drupal\Core\Database\Database;
 use Drupal\Core\Entity\Entity\EntityViewDisplay;
 use Drupal\Core\Entity\Entity\EntityViewMode;
@@ -47,7 +46,7 @@ class CommentIntegrationTest extends KernelTestBase {
    * @see CommentDefaultFormatter::calculateDependencies()
    */
   public function testViewMode() {
-    $mode = Unicode::strtolower($this->randomMachineName());
+    $mode = mb_strtolower($this->randomMachineName());
     // Create a new comment view mode and a view display entity.
     EntityViewMode::create([
       'id' => "comment.$mode",
@@ -64,7 +63,7 @@ class CommentIntegrationTest extends KernelTestBase {
     FieldStorageConfig::create([
       'entity_type' => 'entity_test',
       'type' => 'comment',
-      'field_name' => $field_name = Unicode::strtolower($this->randomMachineName()),
+      'field_name' => $field_name = mb_strtolower($this->randomMachineName()),
       'settings' => [
         'comment_type' => 'comment',
       ],

core/modules/comment/tests/src/Kernel/CommentValidationTest.php

@@ -51,7 +51,7 @@ class CommentValidationTest extends EntityKernelTestBase {
       'type' => 'comment',
       'settings' => [
         'comment_type' => 'comment',
-      ]
+      ],
     ])->save();
 
     // Create a page node type.

core/modules/comment/tests/src/Kernel/Migrate/d7/MigrateCommentTest.php

@@ -17,7 +17,18 @@ class MigrateCommentTest extends MigrateDrupal7TestBase {
   /**
    * {@inheritdoc}
    */
-  public static $modules = ['filter', 'node', 'comment', 'text', 'menu_ui'];
+  public static $modules = [
+    'comment',
+    'datetime',
+    'filter',
+    'image',
+    'link',
+    'menu_ui',
+    'node',
+    'taxonomy',
+    'telephone',
+    'text',
+  ];
 
   /**
    * {@inheritdoc}
@@ -40,6 +51,9 @@ class MigrateCommentTest extends MigrateDrupal7TestBase {
       'd7_comment_field_instance',
       'd7_comment_entity_display',
       'd7_comment_entity_form_display',
+      'd7_taxonomy_vocabulary',
+      'd7_field',
+      'd7_field_instance',
       'd7_comment',
     ]);
   }
@@ -59,10 +73,18 @@ class MigrateCommentTest extends MigrateDrupal7TestBase {
     $this->assertSame('This is a comment', $comment->comment_body->value);
     $this->assertSame('filtered_html', $comment->comment_body->format);
     $this->assertSame('2001:db8:ffff:ffff:ffff:ffff:ffff:ffff', $comment->getHostname());
+    $this->assertSame('1000000', $comment->field_integer->value);
 
     $node = $comment->getCommentedEntity();
     $this->assertInstanceOf(NodeInterface::class, $node);
     $this->assertSame('1', $node->id());
+
+    // Tests that comments that used the Drupal 7 Title module and that have
+    // their subject replaced by a real field are correctly migrated.
+    $comment = Comment::load(2);
+    $this->assertInstanceOf(Comment::class, $comment);
+    $this->assertSame('TNG for the win!', $comment->getSubject());
+    $this->assertSame('TNG is better than DS9.', $comment->comment_body->value);
   }
 
 }

core/modules/comment/tests/src/Kernel/Plugin/migrate/source/d7/CommentTest.php

@@ -60,6 +60,16 @@ class CommentTest extends MigrateSqlSourceTestBase {
         'translate' => '0',
       ],
     ];
+    $tests[0]['source_data']['field_config'] = [
+      [
+        'id' => '1',
+        'translatable' => '0',
+      ],
+      [
+        'id' => '2',
+        'translatable' => '1',
+      ],
+    ];
     $tests[0]['source_data']['field_config_instance'] = [
       [
         'id' => '14',
@@ -70,6 +80,15 @@ class CommentTest extends MigrateSqlSourceTestBase {
         'data' => 'a:0:{}',
         'deleted' => '0',
       ],
+      [
+        'id' => '15',
+        'field_id' => '2',
+        'field_name' => 'subject_field',
+        'entity_type' => 'comment',
+        'bundle' => 'comment_node_test_content_type',
+        'data' => 'a:0:{}',
+        'deleted' => '0',
+      ],
     ];
     $tests[0]['source_data']['field_data_comment_body'] = [
       [
@@ -84,6 +103,26 @@ class CommentTest extends MigrateSqlSourceTestBase {
         'comment_body_format' => 'filtered_html',
       ],
     ];
+    $tests[0]['source_data']['field_data_subject_field'] = [
+      [
+        'entity_type' => 'comment',
+        'bundle' => 'comment_node_test_content_type',
+        'deleted' => '0',
+        'entity_id' => '1',
+        'revision_id' => '1',
+        'language' => 'und',
+        'delta' => '0',
+        'subject_field_value' => 'A comment (subject_field)',
+        'subject_field_format' => NULL,
+      ],
+    ];
+    $tests[0]['source_data']['system'] = [
+      [
+        'name' => 'title',
+        'type' => 'module',
+        'status' => 1,
+      ],
+    ];
 
     // The expected results.
     $tests[0]['expected_data'] = [
@@ -92,7 +131,7 @@ class CommentTest extends MigrateSqlSourceTestBase {
         'pid' => '0',
         'nid' => '1',
         'uid' => '1',
-        'subject' => 'A comment',
+        'subject' => 'A comment (subject_field)',
         'hostname' => '::1',
         'created' => '1421727536',
         'changed' => '1421727536',

core/modules/comment/tests/src/Kernel/Views/CommentLinksTest.php

@@ -2,7 +2,6 @@
 
 namespace Drupal\Tests\comment\Kernel\Views;
 
-use Drupal\comment\CommentInterface;
 use Drupal\comment\CommentManagerInterface;
 use Drupal\Core\Session\AnonymousUserSession;
 use Drupal\Core\Url;
@@ -84,7 +83,7 @@ class CommentLinksTest extends CommentViewsKernelTestBase {
     $this->assertEqual(\Drupal::l('Approve', $url), (string) $approve_comment, 'Found a comment approve link for an unapproved comment.');
 
     // Approve the comment.
-    $comment->setPublished(CommentInterface::PUBLISHED);
+    $comment->setPublished();
     $comment->save();
     $view = Views::getView('test_comment');
     $view->preview();
@@ -97,7 +96,7 @@ class CommentLinksTest extends CommentViewsKernelTestBase {
     // anonymous user.
     $account_switcher->switchTo(new AnonymousUserSession());
     // Set the comment as unpublished again.
-    $comment->setPublished(CommentInterface::NOT_PUBLISHED);
+    $comment->setUnpublished();
     $comment->save();
 
     $view = Views::getView('test_comment');
@@ -168,7 +167,7 @@ class CommentLinksTest extends CommentViewsKernelTestBase {
     $this->assertFalse((string) $replyto_comment, "I can't reply to an unapproved comment.");
 
     // Approve the comment.
-    $comment->setPublished(CommentInterface::PUBLISHED);
+    $comment->setPublished();
     $comment->save();
     $view = Views::getView('test_comment');
     $view->preview();

core/modules/comment/tests/src/Kernel/Views/CommentUserNameTest.php

@@ -118,7 +118,7 @@ class CommentUserNameTest extends ViewsKernelTestBase {
                 'field' => 'name',
                 'id' => 'name',
                 'plugin_id' => 'field',
-                'type' => 'comment_username'
+                'type' => 'comment_username',
               ],
               'subject' => [
                 'table' => 'comment_field_data',

core/modules/comment/tests/src/Unit/CommentLinkBuilderTest.php

@@ -60,7 +60,7 @@ class CommentLinkBuilderTest extends UnitTestCase {
   protected $timestamp;
 
   /**
-   * @var \Drupal\comment\CommentLinkBuilderInterface;
+   * @var \Drupal\comment\CommentLinkBuilderInterface
    */
   protected $commentLinkBuilder;
 
@@ -310,7 +310,7 @@ class CommentLinkBuilderTest extends UnitTestCase {
 
     $url = Url::fromRoute('node.view');
     $node->expects($this->any())
-      ->method('urlInfo')
+      ->method('toUrl')
       ->willReturn($url);
     $node->expects($this->any())
       ->method('url')
@@ -324,7 +324,9 @@ class CommentLinkBuilderTest extends UnitTestCase {
 namespace Drupal\comment;
 
 if (!function_exists('history_read')) {
+
   function history_read() {
     return 0;
   }
+
 }

core/modules/comment/tests/src/Unit/Plugin/views/field/CommentBulkFormTest.php

@@ -54,6 +54,8 @@ class CommentBulkFormTest extends UnitTestCase {
 
     $language_manager = $this->getMock('Drupal\Core\Language\LanguageManagerInterface');
 
+    $messenger = $this->getMock('Drupal\Core\Messenger\MessengerInterface');
+
     $views_data = $this->getMockBuilder('Drupal\views\ViewsData')
       ->disableOriginalConstructor()
       ->getMock();
@@ -84,7 +86,7 @@ class CommentBulkFormTest extends UnitTestCase {
     $definition['title'] = '';
     $options = [];
 
-    $comment_bulk_form = new CommentBulkForm([], 'comment_bulk_form', $definition, $entity_manager, $language_manager);
+    $comment_bulk_form = new CommentBulkForm([], 'comment_bulk_form', $definition, $entity_manager, $language_manager, $messenger);
     $comment_bulk_form->init($executable, $display, $options);
 
     $this->assertAttributeEquals(array_slice($actions, 0, -1, TRUE), 'actions', $comment_bulk_form);